diff --git a/usr.bin/tail/forward.c b/usr.bin/tail/forward.c index e8e2cb89ab01..a8f52ed376c4 100644 --- a/usr.bin/tail/forward.c +++ b/usr.bin/tail/forward.c @@ -1,435 +1,432 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1991, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Edward Sze-Tyan Wang. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "extern.h" static void rlines(FILE *, const char *fn, off_t, struct stat *); static int show(file_info_t *); static void set_events(file_info_t *files); /* defines for inner loop actions */ #define USE_SLEEP 0 #define USE_KQUEUE 1 #define ADD_EVENTS 2 static struct kevent *ev; static int action = USE_SLEEP; static int kq; static const file_info_t *last; /* * forward -- display the file, from an offset, forward. * * There are eight separate cases for this -- regular and non-regular * files, by bytes or lines and from the beginning or end of the file. * * FBYTES byte offset from the beginning of the file * REG seek * NOREG read, counting bytes * * FLINES line offset from the beginning of the file * REG read, counting lines * NOREG read, counting lines * * RBYTES byte offset from the end of the file * REG seek * NOREG cyclically read characters into a wrap-around buffer * * RLINES * REG mmap the file and step back until reach the correct offset. * NOREG cyclically read lines into a wrap-around array of buffers */ void forward(FILE *fp, const char *fn, enum STYLE style, off_t off, struct stat *sbp) { int ch; switch(style) { case FBYTES: if (off == 0) break; if (S_ISREG(sbp->st_mode)) { if (sbp->st_size < off) off = sbp->st_size; if (fseeko(fp, off, SEEK_SET) == -1) { ierr(fn); return; } } else while (off--) if ((ch = getc(fp)) == EOF) { if (ferror(fp)) { ierr(fn); return; } break; } break; case FLINES: if (off == 0) break; for (;;) { if ((ch = getc(fp)) == EOF) { if (ferror(fp)) { ierr(fn); return; } break; } if (ch == '\n' && !--off) break; } break; case RBYTES: if (S_ISREG(sbp->st_mode)) { if (sbp->st_size >= off && fseeko(fp, -off, SEEK_END) == -1) { ierr(fn); return; } } else if (off == 0) { while (getc(fp) != EOF); if (ferror(fp)) { ierr(fn); return; } } else if (bytes(fp, fn, off)) return; break; case RLINES: if (S_ISREG(sbp->st_mode)) if (!off) { if (fseeko(fp, (off_t)0, SEEK_END) == -1) { ierr(fn); return; } } else rlines(fp, fn, off, sbp); else if (off == 0) { while (getc(fp) != EOF); if (ferror(fp)) { ierr(fn); return; } } else if (lines(fp, fn, off)) return; break; default: break; } while ((ch = getc(fp)) != EOF) if (putchar(ch) == EOF) oerr(); if (ferror(fp)) { ierr(fn); return; } (void)fflush(stdout); } /* * rlines -- display the last offset lines of the file. */ static void rlines(FILE *fp, const char *fn, off_t off, struct stat *sbp) { struct mapinfo map; off_t curoff, size; int i; if (!(size = sbp->st_size)) return; map.start = NULL; map.fd = fileno(fp); map.mapoff = map.maxoff = size; /* * Last char is special, ignore whether newline or not. Note that * size == 0 is dealt with above, and size == 1 sets curoff to -1. */ curoff = size - 2; while (curoff >= 0) { if (curoff < map.mapoff && maparound(&map, curoff) != 0) { ierr(fn); return; } for (i = curoff - map.mapoff; i >= 0; i--) if (map.start[i] == '\n' && --off == 0) break; /* `i' is either the map offset of a '\n', or -1. */ curoff = map.mapoff + i; if (i >= 0) break; } curoff++; if (mapprint(&map, curoff, size - curoff) != 0) { ierr(fn); exit(1); } /* Set the file pointer to reflect the length displayed. */ if (fseeko(fp, sbp->st_size, SEEK_SET) == -1) { ierr(fn); return; } if (map.start != NULL && munmap(map.start, map.maplen)) { ierr(fn); return; } } static int show(file_info_t *file) { int ch; while ((ch = getc(file->fp)) != EOF) { if (last != file) { if (vflag || (qflag == 0 && no_files > 1)) printfn(file->file_name, 1); last = file; } if (putchar(ch) == EOF) oerr(); } (void)fflush(stdout); if (ferror(file->fp)) { fclose(file->fp); file->fp = NULL; ierr(file->file_name); return 0; } clearerr(file->fp); return 1; } static void set_events(file_info_t *files) { int i, n = 0; file_info_t *file; struct timespec ts; struct statfs sf; ts.tv_sec = 0; ts.tv_nsec = 0; action = USE_KQUEUE; for (i = 0, file = files; i < no_files; i++, file++) { - if (! file->fp) + if (!file->fp) continue; if (fstatfs(fileno(file->fp), &sf) == 0 && (sf.f_flags & MNT_LOCAL) == 0) { action = USE_SLEEP; return; } if (Fflag && fileno(file->fp) != STDIN_FILENO) { EV_SET(&ev[n], fileno(file->fp), EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_CLEAR, NOTE_DELETE | NOTE_RENAME, 0, 0); n++; } EV_SET(&ev[n], fileno(file->fp), EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, 0); n++; } if (kevent(kq, ev, n, NULL, 0, &ts) < 0) { action = USE_SLEEP; } } /* * follow -- display the file, from an offset, forward. * */ void follow(file_info_t *files, enum STYLE style, off_t off) { - int active, ev_change, i, n = -1; + int active, ev_change, i, n; struct stat sb2; file_info_t *file; FILE *ftmp; struct timespec ts; /* Position each of the files */ - - file = files; active = 0; - n = 0; - for (i = 0; i < no_files; i++, file++) { - if (file->fp) { - active = 1; - n++; - if (vflag || (qflag == 0 && no_files > 1)) - printfn(file->file_name, 1); - forward(file->fp, file->file_name, style, off, &file->st); - if (Fflag && fileno(file->fp) != STDIN_FILENO) - n++; - } + for (i = 0, file = files; i < no_files; i++, file++) { + if (!file->fp) + continue; + active = 1; + if (vflag || (qflag == 0 && no_files > 1)) + printfn(file->file_name, 1); + forward(file->fp, file->file_name, style, off, &file->st); } if (!Fflag && !active) return; last = --file; kq = kqueue(); if (kq < 0) err(1, "kqueue"); - ev = malloc(n * sizeof(struct kevent)); - if (! ev) - err(1, "Couldn't allocate memory for kevents."); + /* + * The number of kqueue events we track may vary over time and may + * even grow past its initial value in the -F case, but it will + * never exceed two per file, so just preallocate that. + */ + ev = malloc(no_files * 2 * sizeof(struct kevent)); + if (ev == NULL) + err(1, "Couldn't allocate memory for kevents."); set_events(files); for (;;) { ev_change = 0; if (Fflag) { for (i = 0, file = files; i < no_files; i++, file++) { if (!file->fp) { file->fp = fileargs_fopen(fa, file->file_name, "r"); if (file->fp != NULL && fstat(fileno(file->fp), &file->st) == -1) { fclose(file->fp); file->fp = NULL; } if (file->fp != NULL) ev_change++; continue; } if (fileno(file->fp) == STDIN_FILENO) continue; ftmp = fileargs_fopen(fa, file->file_name, "r"); if (ftmp == NULL || fstat(fileno(ftmp), &sb2) == -1) { if (errno != ENOENT) ierr(file->file_name); show(file); if (file->fp != NULL) { fclose(file->fp); file->fp = NULL; } if (ftmp != NULL) { fclose(ftmp); } ev_change++; continue; } if (sb2.st_ino != file->st.st_ino || sb2.st_dev != file->st.st_dev || sb2.st_nlink == 0) { show(file); fclose(file->fp); file->fp = ftmp; memcpy(&file->st, &sb2, sizeof(struct stat)); ev_change++; } else { fclose(ftmp); } } } for (i = 0, file = files; i < no_files; i++, file++) if (file->fp && !show(file)) ev_change++; if (ev_change) set_events(files); switch (action) { case USE_KQUEUE: ts.tv_sec = 1; ts.tv_nsec = 0; /* * In the -F case we set a timeout to ensure that * we re-stat the file at least once every second. * If we've recieved EINTR, ignore it. Both reasons * for its generation are transient. */ do { n = kevent(kq, NULL, 0, ev, 1, Fflag ? &ts : NULL); - if (n < 0 && errno == EINTR) - continue; - if (n < 0) + if (n < 0 && errno != EINTR) err(1, "kevent"); } while (n < 0); if (n == 0) { /* timeout */ break; } else if (ev->filter == EVFILT_READ && ev->data < 0) { /* file shrank, reposition to end */ if (lseek(ev->ident, (off_t)0, SEEK_END) == -1) { ierr(file->file_name); continue; } } break; case USE_SLEEP: (void) usleep(250000); break; } } } diff --git a/usr.bin/tail/tests/tail_test.sh b/usr.bin/tail/tests/tail_test.sh index 8123a310fe67..9c941f8a2c2f 100755 --- a/usr.bin/tail/tests/tail_test.sh +++ b/usr.bin/tail/tests/tail_test.sh @@ -1,432 +1,451 @@ # SPDX-License-Identifier: BSD-2-Clause # # Copyright (c) 2016 Alan Somers # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF # SUCH DAMAGE. # atf_test_case empty_r empty_r_head() { atf_set "descr" "Reverse an empty file" } empty_r_body() { touch infile expectfile tail -r infile > outfile tail -r < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case file_r file_r_head() { atf_set "descr" "Reverse a file" } file_r_body() { cat > infile < expectfile << HERE This is the third line This is the second line This is the first line HERE tail -r infile > outfile tail -r < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case file_rn2 file_rn2_head() { atf_set "descr" "Reverse the last two lines of a file" } file_rn2_body() { cat > infile < expectfile << HERE This is the third line This is the second line HERE tail -rn2 infile > outfile tail -rn2 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } # Regression test for PR 222671 # https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=222671 atf_test_case pipe_leading_newline_r pipe_leading_newline_r_head() { atf_set "descr" "Reverse a pipe whose first character is a newline" } pipe_leading_newline_r_body() { cat > expectfile << HERE 3 2 1 HERE printf '\n1\n2\n3\n' | tail -r > outfile printf '\n1\n2\n3\n' | tail -r > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case file_rc28 file_rc28_head() { atf_set "descr" "Reverse a file and display the last 28 characters" } file_rc28_body() { cat > infile < expectfile << HERE This is the third line line HERE tail -rc28 infile > outfile tail -rc28 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case file_rc28 file_rc28_head() { atf_set "descr" "Reverse a file and display the last 28 characters" } file_rc28_body() { cat > infile < expectfile << HERE This is the third line line HERE tail -rc28 infile > outfile tail -rc28 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_r longfile_r_head() { atf_set "descr" "Reverse a long file" } longfile_r_body() { jot -w "%0511d" 1030 0 > infile jot -w "%0511d" 1030 1029 0 -1 > expectfile tail -r infile > outfile tail -r < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_r_enomem longfile_r_enomem_head() { atf_set "descr" "Reverse a file that's too long to store in RAM" } longfile_r_enomem_body() { # When we reverse a file that's too long for RAM, tail should drop the # first part and just print what it can. We'll check that the last # part is ok { ulimit -v 32768 || atf_skip "Can't adjust ulimit" jot -w "%01023d" 32768 0 | tail -r > outfile ; } if [ "$?" -ne 1 ]; then atf_skip "Didn't get ENOMEM. Adjust test parameters" fi # We don't know how much of the input we dropped. So just check that # the first ten lines of tail's output are the same as the last ten of # the input jot -w "%01023d" 10 32767 0 -1 > expectfile head -n 10 outfile > outtrunc diff expectfile outtrunc atf_check cmp expectfile outtrunc } atf_test_case longfile_r_longlines longfile_r_longlines_head() { atf_set "descr" "Reverse a long file with extremely long lines" } longfile_r_longlines_body() { jot -s " " -w "%07d" 18000 0 > infile jot -s " " -w "%07d" 18000 18000 >> infile jot -s " " -w "%07d" 18000 36000 >> infile jot -s " " -w "%07d" 18000 36000 > expectfile jot -s " " -w "%07d" 18000 18000 >> expectfile jot -s " " -w "%07d" 18000 0 >> expectfile tail -r infile > outfile tail -r < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_rc135782 longfile_rc135782_head() { atf_set "descr" "Reverse a long file and print the last 135,782 bytes" } longfile_rc135782_body() { jot -w "%063d" 9000 0 > infile jot -w "%063d" 2121 8999 0 -1 > expectfile echo "0000000000000000000000000000000006878" >> expectfile tail -rc135782 infile > outfile tail -rc135782 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_rc145782_longlines longfile_rc145782_longlines_head() { atf_set "descr" "Reverse a long file with extremely long lines and print the last 145,782 bytes" } longfile_rc145782_longlines_body() { jot -s " " -w "%07d" 18000 0 > infile jot -s " " -w "%07d" 18000 18000 >> infile jot -s " " -w "%07d" 18000 36000 >> infile jot -s " " -w "%07d" 18000 36000 > expectfile echo -n "35777 " >> expectfile jot -s " " -w "%07d" 222 35778 >> expectfile tail -rc145782 infile > outfile tail -rc145782 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_rn2500 longfile_rn2500_head() { atf_set "descr" "Reverse a long file and print the last 2,500 lines" } longfile_rn2500_body() { jot -w "%063d" 9000 0 > infile jot -w "%063d" 2500 8999 0 -1 > expectfile tail -rn2500 infile > outfile tail -rn2500 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case broken_pipe broken_pipe_head() { atf_set "descr" "Do not print bogus errno based output on short writes" } broken_pipe_body() { atf_check -o save:ints seq -f '%128g' 1 1000 atf_check -s ignore \ -e "inline:tail: stdout\nexit code: 1\n" \ -x '(tail -n 856 ints; echo exit code: $? >&2) | sleep 2' } atf_test_case stdin stdin_head() { atf_set "descr" "Check basic operations on standard input" } stdin_body() { seq 1 5 > infile seq 1 5 > expectfile seq 5 1 > expectfile_r tail < infile > outfile tail -r < infile > outfile_r atf_check cmp expectfile outfile atf_check cmp expectfile_r outfile_r } atf_test_case follow follow_head() { atf_set "descr" "Basic regression test for -f" } follow_body() { local pid seq 1 5 > expectfile seq 1 3 > infile tail -f infile > outfile & pid=$! sleep 0.1 seq 4 5 >> infile sleep 0.1 atf_check cmp expectfile outfile atf_check kill $pid } atf_test_case follow_stdin follow_stdin_head() { atf_set "descr" "Verify that -f works with files piped to standard input" } follow_stdin_body() { local pid seq 1 5 > expectfile seq 1 3 > infile tail -f < infile > outfile & pid=$! sleep 0.1 seq 4 5 >> infile sleep 0.1 atf_check cmp expectfile outfile atf_check kill $pid } +atf_test_case follow_create +follow_create_head() +{ + atf_set "descr" "Verify that -F works when a file is created" +} +follow_create_body() +{ + local pid + + rm -f infile + tail -F infile > outfile & + pid=$! + seq 1 5 >infile + sleep 2 + atf_check cmp infile outfile + atf_check kill $pid +} + atf_test_case follow_rename follow_rename_head() { - atf_set "descr" "Verify that -F works" + atf_set "descr" "Verify that -F works when a file is replaced" } follow_rename_body() { local pid seq 1 5 > expectfile seq 1 3 > infile tail -F infile > outfile & pid=$! seq 4 5 > infile_new atf_check mv infile infile_old atf_check mv infile_new infile # tail -F polls for a new file every 1s. sleep 2 atf_check cmp expectfile outfile atf_check kill $pid } atf_test_case silent_header silent_header_head() { atf_set "descr" "Test tail(1)'s silent header feature" } silent_header_body() { jot 11 1 11 > file1 jot 11 2 12 > file2 jot 10 2 11 > expectfile jot 10 3 12 >> expectfile tail -q file1 file2 > outfile atf_check cmp outfile expectfile } atf_test_case verbose_header verbose_header_head() { atf_set "descr" "Test tail(1)'s verbose header feature" } verbose_header_body() { jot 11 1 11 > file1 echo '==> file1 <==' > expectfile jot 10 2 11 >> expectfile tail -v file1 > outfile atf_check cmp outfile expectfile } atf_test_case si_number si_number_head() { atf_set "descr" "Test tail(1)'s SI number feature" } si_number_body() { jot -b aaaaaaa 129 > file1 jot -b aaaaaaa 128 > expectfile tail -c 1k file1 > outfile atf_check cmp outfile expectfile jot 1025 1 1025 > file1 jot 1024 2 1025 > expectfile tail -n 1k file1 > outfile atf_check cmp outfile expectfile } atf_test_case no_lf_at_eof no_lf_at_eof_head() { atf_set "descr" "File does not end in newline" } no_lf_at_eof_body() { printf "a\nb\nc" >infile atf_check -o inline:"c" tail -1 infile atf_check -o inline:"b\nc" tail -2 infile atf_check -o inline:"a\nb\nc" tail -3 infile atf_check -o inline:"a\nb\nc" tail -4 infile } atf_init_test_cases() { atf_add_test_case empty_r atf_add_test_case file_r atf_add_test_case file_rc28 atf_add_test_case file_rn2 atf_add_test_case pipe_leading_newline_r # The longfile tests are designed to exercise behavior in r_buf(), # which operates on 128KB blocks atf_add_test_case longfile_r atf_add_test_case longfile_r_enomem atf_add_test_case longfile_r_longlines atf_add_test_case longfile_rc135782 atf_add_test_case longfile_rc145782_longlines atf_add_test_case longfile_rn2500 atf_add_test_case broken_pipe atf_add_test_case stdin atf_add_test_case follow atf_add_test_case follow_stdin + atf_add_test_case follow_create atf_add_test_case follow_rename atf_add_test_case silent_header atf_add_test_case verbose_header atf_add_test_case si_number atf_add_test_case no_lf_at_eof }