1 /* tail -- output the last part of file(s)
2 Copyright (C) 1989, 90, 91, 1995-2006 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
18 /* Can display any amount of data, unlike the Unix version, which uses
19 a fixed size buffer and therefore can only deliver a limited number
22 Original version by Paul Rubin <phr@ocf.berkeley.edu>.
23 Extensions by David MacKenzie <djm@gnu.ai.mit.edu>.
24 tail -f for multiple files by Ian Lance Taylor <ian@airs.com>. */
31 #include <sys/types.h>
43 #include "safe-read.h"
44 #include "stat-time.h"
45 #include "xnanosleep.h"
49 /* The official name of this program (e.g., no `g' prefix). */
50 #define PROGRAM_NAME "tail"
53 "Paul Rubin", "David MacKenzie, Ian Lance Taylor", "Jim Meyering"
55 /* Number of items to tail. */
56 #define DEFAULT_N_LINES 10
58 /* Special values for dump_remainder's N_BYTES parameter. */
59 #define COPY_TO_EOF UINTMAX_MAX
60 #define COPY_A_BUFFER (UINTMAX_MAX - 1)
62 /* FIXME: make Follow_name the default? */
63 #define DEFAULT_FOLLOW_MODE Follow_descriptor
67 /* Follow the name of each file: if the file is renamed, try to reopen
68 that name and track the end of the new file if/when it's recreated.
69 This is useful for tracking logs that are occasionally rotated. */
72 /* Follow each descriptor obtained upon opening a file.
73 That means we'll continue to follow the end of a file even after
74 it has been renamed or unlinked. */
78 /* The types of files for which tail works. */
79 #define IS_TAILABLE_FILE_TYPE(Mode) \
80 (S_ISREG (Mode) || S_ISFIFO (Mode) || S_ISSOCK (Mode) || S_ISCHR (Mode))
82 static char const *const follow_mode_string[] =
84 "descriptor", "name", NULL
87 static enum Follow_mode const follow_mode_map[] =
89 Follow_descriptor, Follow_name,
94 /* The actual file name, or "-" for stdin. */
97 /* File descriptor on which the file is open; -1 if it's not open. */
100 /* Attributes of the file the last time we checked. */
102 struct timespec mtime;
107 /* 1 if O_NONBLOCK is clear, 0 if set, -1 if not known. */
110 /* The specified name initially referred to a directory or some other
111 type for which tail isn't meaningful. Unlike for a permission problem
112 (tailable, below) once this is set, the name is not checked ever again. */
115 /* See description of DEFAULT_MAX_N_... below. */
116 uintmax_t n_unchanged_stats;
118 /* A file is tailable if it exists, is readable, and is of type
119 IS_TAILABLE_FILE_TYPE. */
122 /* The value of errno seen last time we checked this file. */
127 /* Keep trying to open a file even if it is inaccessible when tail starts
128 or if it becomes inaccessible later -- useful only with -f. */
129 static bool reopen_inaccessible_files;
131 /* If true, interpret the numeric argument as the number of lines.
132 Otherwise, interpret it as the number of bytes. */
133 static bool count_lines;
135 /* Whether we follow the name of each file or the file descriptor
136 that is initially associated with each name. */
137 static enum Follow_mode follow_mode = Follow_descriptor;
139 /* If true, read from the ends of all specified files until killed. */
142 /* If true, count from start of file instead of end. */
143 static bool from_start;
145 /* If true, print filename headers. */
146 static bool print_headers;
148 /* When to print the filename banners. */
151 multiple_files, always, never
154 /* When tailing a file by name, if there have been this many consecutive
155 iterations for which the file has not changed, then open/fstat
156 the file to determine if that file name is still associated with the
157 same device/inode-number pair as before. This option is meaningful only
158 when following by name. --max-unchanged-stats=N */
159 #define DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS 5
160 static uintmax_t max_n_unchanged_stats_between_opens =
161 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS;
163 /* The name this program was run with. */
166 /* The process ID of the process (presumably on the current host)
167 that is writing to all followed files. */
170 /* True if we have ever read standard input. */
171 static bool have_read_stdin;
173 /* If nonzero, skip the is-regular-file test used to determine whether
174 to use the lseek optimization. Instead, use the more general (and
175 more expensive) code unconditionally. Intended solely for testing. */
176 static bool presume_input_pipe;
178 /* For long options that have no equivalent short option, use a
179 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
182 RETRY_OPTION = CHAR_MAX + 1,
183 MAX_UNCHANGED_STATS_OPTION,
185 PRESUME_INPUT_PIPE_OPTION,
189 static struct option const long_options[] =
191 {"bytes", required_argument, NULL, 'c'},
192 {"follow", optional_argument, NULL, LONG_FOLLOW_OPTION},
193 {"lines", required_argument, NULL, 'n'},
194 {"max-unchanged-stats", required_argument, NULL, MAX_UNCHANGED_STATS_OPTION},
195 {"pid", required_argument, NULL, PID_OPTION},
196 {"-presume-input-pipe", no_argument, NULL,
197 PRESUME_INPUT_PIPE_OPTION}, /* do not document */
198 {"quiet", no_argument, NULL, 'q'},
199 {"retry", no_argument, NULL, RETRY_OPTION},
200 {"silent", no_argument, NULL, 'q'},
201 {"sleep-interval", required_argument, NULL, 's'},
202 {"verbose", no_argument, NULL, 'v'},
203 {GETOPT_HELP_OPTION_DECL},
204 {GETOPT_VERSION_OPTION_DECL},
211 if (status != EXIT_SUCCESS)
212 fprintf (stderr, _("Try `%s --help' for more information.\n"),
217 Usage: %s [OPTION]... [FILE]...\n\
221 Print the last %d lines of each FILE to standard output.\n\
222 With more than one FILE, precede each with a header giving the file name.\n\
223 With no FILE, or when FILE is -, read standard input.\n\
225 "), DEFAULT_N_LINES);
227 Mandatory arguments to long options are mandatory for short options too.\n\
230 --retry keep trying to open a file even if it is\n\
231 inaccessible when tail starts or if it becomes\n\
232 inaccessible later; useful when following by name,\n\
233 i.e., with --follow=name\n\
234 -c, --bytes=N output the last N bytes\n\
237 -f, --follow[={name|descriptor}]\n\
238 output appended data as the file grows;\n\
239 -f, --follow, and --follow=descriptor are\n\
241 -F same as --follow=name --retry\n\
244 -n, --lines=N output the last N lines, instead of the last %d\n\
245 --max-unchanged-stats=N\n\
246 with --follow=name, reopen a FILE which has not\n\
247 changed size after N (default %d) iterations\n\
248 to see if it has been unlinked or renamed\n\
249 (this is the usual case of rotated log files)\n\
252 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS
255 --pid=PID with -f, terminate after process ID, PID dies\n\
256 -q, --quiet, --silent never output headers giving file names\n\
257 -s, --sleep-interval=S with -f, sleep for approximately S seconds\n\
258 (default 1.0) between iterations.\n\
259 -v, --verbose always output headers giving file names\n\
261 fputs (HELP_OPTION_DESCRIPTION, stdout);
262 fputs (VERSION_OPTION_DESCRIPTION, stdout);
265 If the first character of N (the number of bytes or lines) is a `+',\n\
266 print beginning with the Nth item from the start of each file, otherwise,\n\
267 print the last N items in the file. N may have a multiplier suffix:\n\
268 b 512, k 1024, m 1024*1024.\n\
272 With --follow (-f), tail defaults to following the file descriptor, which\n\
273 means that even if a tail'ed file is renamed, tail will continue to track\n\
277 This default behavior is not desirable when you really want to\n\
278 track the actual name of the file, not the file descriptor (e.g., log\n\
279 rotation). Use --follow=name in that case. That causes tail to track the\n\
280 named file by reopening it periodically to see if it has been removed and\n\
281 recreated by some other program.\n\
283 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
289 valid_file_spec (struct File_spec const *f)
291 /* Exactly one of the following subexpressions must be true. */
292 return ((f->fd == -1) ^ (f->errnum == 0));
296 pretty_name (struct File_spec const *f)
298 return (STREQ (f->name, "-") ? "standard input" : f->name);
302 xwrite_stdout (char const *buffer, size_t n_bytes)
304 if (n_bytes > 0 && fwrite (buffer, 1, n_bytes, stdout) == 0)
305 error (EXIT_FAILURE, errno, _("write error"));
308 /* Record a file F with descriptor FD, size SIZE, status ST, and
309 blocking status BLOCKING. */
312 record_open_fd (struct File_spec *f, int fd,
313 off_t size, struct stat const *st,
318 f->mtime = get_stat_mtime (st);
321 f->mode = st->st_mode;
322 f->blocking = blocking;
323 f->n_unchanged_stats = 0;
327 /* Close the file with descriptor FD and name FILENAME. */
330 close_fd (int fd, const char *filename)
332 if (fd != -1 && fd != STDIN_FILENO && close (fd))
334 error (0, errno, _("closing %s (fd=%d)"), filename, fd);
339 write_header (const char *pretty_filename)
341 static bool first_file = true;
343 printf ("%s==> %s <==\n", (first_file ? "" : "\n"), pretty_filename);
347 /* Read and output N_BYTES of file PRETTY_FILENAME starting at the current
348 position in FD. If N_BYTES is COPY_TO_EOF, then copy until end of file.
349 If N_BYTES is COPY_A_BUFFER, then copy at most one buffer's worth.
350 Return the number of bytes read from the file. */
353 dump_remainder (const char *pretty_filename, int fd, uintmax_t n_bytes)
356 uintmax_t n_remaining = n_bytes;
362 size_t n = MIN (n_remaining, BUFSIZ);
363 size_t bytes_read = safe_read (fd, buffer, n);
364 if (bytes_read == SAFE_READ_ERROR)
367 error (EXIT_FAILURE, errno, _("error reading %s"),
368 quote (pretty_filename));
373 xwrite_stdout (buffer, bytes_read);
374 n_written += bytes_read;
375 if (n_bytes != COPY_TO_EOF)
377 n_remaining -= bytes_read;
378 if (n_remaining == 0 || n_bytes == COPY_A_BUFFER)
386 /* Call lseek with the specified arguments, where file descriptor FD
387 corresponds to the file, FILENAME.
388 Give a diagnostic and exit nonzero if lseek fails.
389 Otherwise, return the resulting offset. */
392 xlseek (int fd, off_t offset, int whence, char const *filename)
394 off_t new_offset = lseek (fd, offset, whence);
395 char buf[INT_BUFSIZE_BOUND (off_t)];
401 s = offtostr (offset, buf);
405 error (0, errno, _("%s: cannot seek to offset %s"),
409 error (0, errno, _("%s: cannot seek to relative offset %s"),
413 error (0, errno, _("%s: cannot seek to end-relative offset %s"),
423 /* Print the last N_LINES lines from the end of file FD.
424 Go backward through the file, reading `BUFSIZ' bytes at a time (except
425 probably the first), until we hit the start of the file or have
426 read NUMBER newlines.
427 START_POS is the starting position of the read pointer for the file
428 associated with FD (may be nonzero).
429 END_POS is the file offset of EOF (one larger than offset of last byte).
430 Return true if successful. */
433 file_lines (const char *pretty_filename, int fd, uintmax_t n_lines,
434 off_t start_pos, off_t end_pos, uintmax_t *read_pos)
443 /* Set `bytes_read' to the size of the last, probably partial, buffer;
444 0 < `bytes_read' <= `BUFSIZ'. */
445 bytes_read = (pos - start_pos) % BUFSIZ;
448 /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
449 reads will be on block boundaries, which might increase efficiency. */
451 xlseek (fd, pos, SEEK_SET, pretty_filename);
452 bytes_read = safe_read (fd, buffer, bytes_read);
453 if (bytes_read == SAFE_READ_ERROR)
455 error (0, errno, _("error reading %s"), quote (pretty_filename));
458 *read_pos = pos + bytes_read;
460 /* Count the incomplete line on files that don't end with a newline. */
461 if (bytes_read && buffer[bytes_read - 1] != '\n')
466 /* Scan backward, counting the newlines in this bufferfull. */
468 size_t n = bytes_read;
472 nl = memrchr (buffer, '\n', n);
478 /* If this newline isn't the last character in the buffer,
479 output the part that is after it. */
480 if (n != bytes_read - 1)
481 xwrite_stdout (nl + 1, bytes_read - (n + 1));
482 *read_pos += dump_remainder (pretty_filename, fd,
483 end_pos - (pos + bytes_read));
488 /* Not enough newlines in that bufferfull. */
489 if (pos == start_pos)
491 /* Not enough lines in the file; print everything from
492 start_pos to the end. */
493 xlseek (fd, start_pos, SEEK_SET, pretty_filename);
494 *read_pos = start_pos + dump_remainder (pretty_filename, fd,
499 xlseek (fd, pos, SEEK_SET, pretty_filename);
501 bytes_read = safe_read (fd, buffer, BUFSIZ);
502 if (bytes_read == SAFE_READ_ERROR)
504 error (0, errno, _("error reading %s"), quote (pretty_filename));
508 *read_pos = pos + bytes_read;
510 while (bytes_read > 0);
515 /* Print the last N_LINES lines from the end of the standard input,
516 open for reading as pipe FD.
517 Buffer the text as a linked list of LBUFFERs, adding them as needed.
518 Return true if successful. */
521 pipe_lines (const char *pretty_filename, int fd, uintmax_t n_lines,
529 struct linebuffer *next;
531 typedef struct linebuffer LBUFFER;
532 LBUFFER *first, *last, *tmp;
533 size_t total_lines = 0; /* Total number of newlines in all buffers. */
535 size_t n_read; /* Size in bytes of most recent read */
537 first = last = xmalloc (sizeof (LBUFFER));
538 first->nbytes = first->nlines = 0;
540 tmp = xmalloc (sizeof (LBUFFER));
542 /* Input is always read into a fresh buffer. */
545 n_read = safe_read (fd, tmp->buffer, BUFSIZ);
546 if (n_read == 0 || n_read == SAFE_READ_ERROR)
548 tmp->nbytes = n_read;
553 /* Count the number of newlines just read. */
555 char const *buffer_end = tmp->buffer + n_read;
556 char const *p = tmp->buffer;
557 while ((p = memchr (p, '\n', buffer_end - p)))
563 total_lines += tmp->nlines;
565 /* If there is enough room in the last buffer read, just append the new
566 one to it. This is because when reading from a pipe, `n_read' can
567 often be very small. */
568 if (tmp->nbytes + last->nbytes < BUFSIZ)
570 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
571 last->nbytes += tmp->nbytes;
572 last->nlines += tmp->nlines;
576 /* If there's not enough room, link the new buffer onto the end of
577 the list, then either free up the oldest buffer for the next
578 read if that would leave enough lines, or else malloc a new one.
579 Some compaction mechanism is possible but probably not
581 last = last->next = tmp;
582 if (total_lines - first->nlines > n_lines)
585 total_lines -= first->nlines;
589 tmp = xmalloc (sizeof (LBUFFER));
595 if (n_read == SAFE_READ_ERROR)
597 error (0, errno, _("error reading %s"), quote (pretty_filename));
602 /* If the file is empty, then bail out. */
603 if (last->nbytes == 0)
606 /* This prevents a core dump when the pipe contains no newlines. */
610 /* Count the incomplete line on files that don't end with a newline. */
611 if (last->buffer[last->nbytes - 1] != '\n')
617 /* Run through the list, printing lines. First, skip over unneeded
619 for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
620 total_lines -= tmp->nlines;
622 /* Find the correct beginning, then print the rest of the file. */
624 char const *beg = tmp->buffer;
625 char const *buffer_end = tmp->buffer + tmp->nbytes;
626 if (total_lines > n_lines)
628 /* Skip `total_lines' - `n_lines' newlines. We made sure that
629 `total_lines' - `n_lines' <= `tmp->nlines'. */
631 for (j = total_lines - n_lines; j; --j)
633 beg = memchr (beg, '\n', buffer_end - beg);
639 xwrite_stdout (beg, buffer_end - beg);
642 for (tmp = tmp->next; tmp; tmp = tmp->next)
643 xwrite_stdout (tmp->buffer, tmp->nbytes);
655 /* Print the last N_BYTES characters from the end of pipe FD.
656 This is a stripped down version of pipe_lines.
657 Return true if successful. */
660 pipe_bytes (const char *pretty_filename, int fd, uintmax_t n_bytes,
667 struct charbuffer *next;
669 typedef struct charbuffer CBUFFER;
670 CBUFFER *first, *last, *tmp;
671 size_t i; /* Index into buffers. */
672 size_t total_bytes = 0; /* Total characters in all buffers. */
676 first = last = xmalloc (sizeof (CBUFFER));
679 tmp = xmalloc (sizeof (CBUFFER));
681 /* Input is always read into a fresh buffer. */
684 n_read = safe_read (fd, tmp->buffer, BUFSIZ);
685 if (n_read == 0 || n_read == SAFE_READ_ERROR)
688 tmp->nbytes = n_read;
691 total_bytes += tmp->nbytes;
692 /* If there is enough room in the last buffer read, just append the new
693 one to it. This is because when reading from a pipe, `nbytes' can
694 often be very small. */
695 if (tmp->nbytes + last->nbytes < BUFSIZ)
697 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
698 last->nbytes += tmp->nbytes;
702 /* If there's not enough room, link the new buffer onto the end of
703 the list, then either free up the oldest buffer for the next
704 read if that would leave enough characters, or else malloc a new
705 one. Some compaction mechanism is possible but probably not
707 last = last->next = tmp;
708 if (total_bytes - first->nbytes > n_bytes)
711 total_bytes -= first->nbytes;
716 tmp = xmalloc (sizeof (CBUFFER));
723 if (n_read == SAFE_READ_ERROR)
725 error (0, errno, _("error reading %s"), quote (pretty_filename));
730 /* Run through the list, printing characters. First, skip over unneeded
732 for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next)
733 total_bytes -= tmp->nbytes;
735 /* Find the correct beginning, then print the rest of the file.
736 We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'. */
737 if (total_bytes > n_bytes)
738 i = total_bytes - n_bytes;
741 xwrite_stdout (&tmp->buffer[i], tmp->nbytes - i);
743 for (tmp = tmp->next; tmp; tmp = tmp->next)
744 xwrite_stdout (tmp->buffer, tmp->nbytes);
756 /* Skip N_BYTES characters from the start of pipe FD, and print
757 any extra characters that were read beyond that.
758 Return 1 on error, 0 if ok, -1 if EOF. */
761 start_bytes (const char *pretty_filename, int fd, uintmax_t n_bytes,
768 size_t bytes_read = safe_read (fd, buffer, BUFSIZ);
771 if (bytes_read == SAFE_READ_ERROR)
773 error (0, errno, _("error reading %s"), quote (pretty_filename));
776 read_pos += bytes_read;
777 if (bytes_read <= n_bytes)
778 n_bytes -= bytes_read;
781 size_t n_remaining = bytes_read - n_bytes;
783 xwrite_stdout (&buffer[n_bytes], n_remaining);
791 /* Skip N_LINES lines at the start of file or pipe FD, and print
792 any extra characters that were read beyond that.
793 Return 1 on error, 0 if ok, -1 if EOF. */
796 start_lines (const char *pretty_filename, int fd, uintmax_t n_lines,
806 size_t bytes_read = safe_read (fd, buffer, BUFSIZ);
807 char *buffer_end = buffer + bytes_read;
808 if (bytes_read == 0) /* EOF */
810 if (bytes_read == SAFE_READ_ERROR) /* error */
812 error (0, errno, _("error reading %s"), quote (pretty_filename));
816 *read_pos += bytes_read;
818 while ((p = memchr (p, '\n', buffer_end - p)))
824 xwrite_stdout (p, buffer_end - p);
831 /* FIXME: describe */
834 recheck (struct File_spec *f, bool blocking)
836 /* open/fstat the file and announce if dev/ino have changed */
837 struct stat new_stats;
839 bool is_stdin = (STREQ (f->name, "-"));
840 bool was_tailable = f->tailable;
841 int prev_errnum = f->errnum;
845 : open (f->name, O_RDONLY | (blocking ? 0 : O_NONBLOCK)));
847 assert (valid_file_spec (f));
849 /* If the open fails because the file doesn't exist,
850 then mark the file as not tailable. */
851 f->tailable = !(reopen_inaccessible_files && fd == -1);
853 if (fd == -1 || fstat (fd, &new_stats) < 0)
861 /* FIXME-maybe: detect the case in which the file first becomes
862 unreadable (perms), and later becomes readable again and can
863 be seen to be the same file (dev/ino). Otherwise, tail prints
864 the entire contents of the file when it becomes readable. */
865 error (0, f->errnum, _("%s has become inaccessible"),
866 quote (pretty_name (f)));
870 /* say nothing... it's still not tailable */
873 else if (prev_errnum != errno)
875 error (0, errno, "%s", pretty_name (f));
878 else if (!IS_TAILABLE_FILE_TYPE (new_stats.st_mode))
882 error (0, 0, _("%s has been replaced with an untailable file;\
883 giving up on this name"),
884 quote (pretty_name (f)));
895 close_fd (fd, pretty_name (f));
896 close_fd (f->fd, pretty_name (f));
899 else if (prev_errnum && prev_errnum != ENOENT)
902 assert (f->fd == -1);
903 error (0, 0, _("%s has become accessible"), quote (pretty_name (f)));
905 else if (f->ino != new_stats.st_ino || f->dev != new_stats.st_dev)
911 _("%s has appeared; following end of new file"),
912 quote (pretty_name (f)));
916 /* Close the old one. */
917 close_fd (f->fd, pretty_name (f));
919 /* File has been replaced (e.g., via log rotation) --
922 _("%s has been replaced; following end of new file"),
923 quote (pretty_name (f)));
930 /* This happens when one iteration finds the file missing,
931 then the preceding <dev,inode> pair is reused as the
932 file is recreated. */
937 close_fd (fd, pretty_name (f));
943 /* Start at the beginning of the file. */
944 record_open_fd (f, fd, 0, &new_stats, (is_stdin ? -1 : blocking));
945 xlseek (fd, 0, SEEK_SET, pretty_name (f));
949 /* Return true if any of the N_FILES files in F are live, i.e., have
950 open file descriptors. */
953 any_live_files (const struct File_spec *f, int n_files)
957 for (i = 0; i < n_files; i++)
963 /* Tail NFILES files forever, or until killed.
964 The pertinent information for each file is stored in an entry of F.
965 Loop over each of them, doing an fstat to see if they have changed size,
966 and an occasional open/fstat to see if any dev/ino pair has changed.
967 If none of them have changed size in one iteration, sleep for a
968 while and try again. Continue until the user interrupts us. */
971 tail_forever (struct File_spec *f, int nfiles, double sleep_interval)
973 /* Use blocking I/O as an optimization, when it's easy. */
974 bool blocking = (pid == 0 && follow_mode == Follow_descriptor
975 && nfiles == 1 && ! S_ISREG (f[0].mode));
977 bool writer_is_dead = false;
984 bool any_input = false;
986 for (i = 0; i < nfiles; i++)
992 uintmax_t bytes_read;
999 recheck (&f[i], blocking);
1004 name = pretty_name (&f[i]);
1007 if (f[i].blocking != blocking)
1009 int old_flags = fcntl (fd, F_GETFL);
1010 int new_flags = old_flags | (blocking ? 0 : O_NONBLOCK);
1012 || (new_flags != old_flags
1013 && fcntl (fd, F_SETFL, new_flags) == -1))
1015 /* Don't update f[i].blocking if fcntl fails. */
1016 if (S_ISREG (f[i].mode) && errno == EPERM)
1018 /* This happens when using tail -f on a file with
1019 the append-only attribute. */
1022 error (EXIT_FAILURE, errno,
1023 _("%s: cannot change nonblocking mode"), name);
1026 f[i].blocking = blocking;
1031 if (fstat (fd, &stats) != 0)
1034 f[i].errnum = errno;
1035 error (0, errno, "%s", name);
1039 if (f[i].mode == stats.st_mode
1040 && (! S_ISREG (stats.st_mode) || f[i].size == stats.st_size)
1041 && timespec_cmp (f[i].mtime, get_stat_mtime (&stats)) == 0)
1043 if ((max_n_unchanged_stats_between_opens
1044 <= f[i].n_unchanged_stats++)
1045 && follow_mode == Follow_name)
1047 recheck (&f[i], f[i].blocking);
1048 f[i].n_unchanged_stats = 0;
1053 /* This file has changed. Print out what we can, and
1054 then keep looping. */
1056 f[i].mtime = get_stat_mtime (&stats);
1057 f[i].mode = stats.st_mode;
1060 f[i].n_unchanged_stats = 0;
1062 if (S_ISREG (mode) && stats.st_size < f[i].size)
1064 error (0, 0, _("%s: file truncated"), name);
1066 xlseek (fd, stats.st_size, SEEK_SET, name);
1067 f[i].size = stats.st_size;
1074 write_header (name);
1079 bytes_read = dump_remainder (name, fd,
1081 ? COPY_A_BUFFER : COPY_TO_EOF));
1082 any_input |= (bytes_read != 0);
1083 f[i].size += bytes_read;
1086 if (! any_live_files (f, nfiles) && ! reopen_inaccessible_files)
1088 error (0, 0, _("no files remaining"));
1092 if ((!any_input | blocking) && fflush (stdout) != 0)
1093 error (EXIT_FAILURE, errno, _("write error"));
1095 /* If nothing was read, sleep and/or check for dead writers. */
1101 if (xnanosleep (sleep_interval))
1102 error (EXIT_FAILURE, errno, _("cannot read realtime clock"));
1104 /* Once the writer is dead, read the files once more to
1105 avoid a race condition. */
1106 writer_is_dead = (pid != 0
1107 && kill (pid, 0) != 0
1108 /* Handle the case in which you cannot send a
1109 signal to the writer, so kill fails and sets
1116 /* Output the last N_BYTES bytes of file FILENAME open for reading in FD.
1117 Return true if successful. */
1120 tail_bytes (const char *pretty_filename, int fd, uintmax_t n_bytes,
1121 uintmax_t *read_pos)
1125 if (fstat (fd, &stats))
1127 error (0, errno, _("cannot fstat %s"), quote (pretty_filename));
1133 if ( ! presume_input_pipe
1134 && S_ISREG (stats.st_mode) && n_bytes <= OFF_T_MAX)
1136 xlseek (fd, n_bytes, SEEK_CUR, pretty_filename);
1137 *read_pos += n_bytes;
1141 int t = start_bytes (pretty_filename, fd, n_bytes, read_pos);
1145 *read_pos += dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1149 if ( ! presume_input_pipe
1150 && S_ISREG (stats.st_mode) && n_bytes <= OFF_T_MAX)
1152 off_t current_pos = xlseek (fd, 0, SEEK_CUR, pretty_filename);
1153 off_t end_pos = xlseek (fd, 0, SEEK_END, pretty_filename);
1154 off_t diff = end_pos - current_pos;
1155 /* Be careful here. The current position may actually be
1156 beyond the end of the file. */
1157 off_t bytes_remaining = (diff = end_pos - current_pos) < 0 ? 0 : diff;
1160 if (bytes_remaining <= nb)
1162 /* From the current position to end of file, there are no
1163 more bytes than have been requested. So reposition the
1164 file pointer to the incoming current position and print
1165 everything after that. */
1166 *read_pos = xlseek (fd, current_pos, SEEK_SET, pretty_filename);
1170 /* There are more bytes remaining than were requested.
1172 *read_pos = xlseek (fd, -nb, SEEK_END, pretty_filename);
1174 *read_pos += dump_remainder (pretty_filename, fd, n_bytes);
1177 return pipe_bytes (pretty_filename, fd, n_bytes, read_pos);
1182 /* Output the last N_LINES lines of file FILENAME open for reading in FD.
1183 Return true if successful. */
1186 tail_lines (const char *pretty_filename, int fd, uintmax_t n_lines,
1187 uintmax_t *read_pos)
1191 if (fstat (fd, &stats))
1193 error (0, errno, _("cannot fstat %s"), quote (pretty_filename));
1199 int t = start_lines (pretty_filename, fd, n_lines, read_pos);
1202 *read_pos += dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1206 off_t start_pos = -1;
1209 /* Use file_lines only if FD refers to a regular file for
1210 which lseek (... SEEK_END) works. */
1211 if ( ! presume_input_pipe
1212 && S_ISREG (stats.st_mode)
1213 && (start_pos = lseek (fd, 0, SEEK_CUR)) != -1
1214 && start_pos < (end_pos = lseek (fd, 0, SEEK_END)))
1216 *read_pos = end_pos;
1218 && ! file_lines (pretty_filename, fd, n_lines,
1219 start_pos, end_pos, read_pos))
1224 /* Under very unlikely circumstances, it is possible to reach
1225 this point after positioning the file pointer to end of file
1226 via the `lseek (...SEEK_END)' above. In that case, reposition
1227 the file pointer back to start_pos before calling pipe_lines. */
1228 if (start_pos != -1)
1229 xlseek (fd, start_pos, SEEK_SET, pretty_filename);
1231 return pipe_lines (pretty_filename, fd, n_lines, read_pos);
1237 /* Display the last N_UNITS units of file FILENAME, open for reading
1238 via FD. Set *READ_POS to the position of the input stream pointer.
1239 *READ_POS is usually the number of bytes read and corresponds to an
1240 offset from the beginning of a file. However, it may be larger than
1241 OFF_T_MAX (as for an input pipe), and may also be larger than the
1242 number of bytes read (when an input pointer is initially not at
1243 beginning of file), and may be far greater than the number of bytes
1244 actually read for an input file that is seekable.
1245 Return true if successful. */
1248 tail (const char *filename, int fd, uintmax_t n_units,
1249 uintmax_t *read_pos)
1253 return tail_lines (filename, fd, n_units, read_pos);
1255 return tail_bytes (filename, fd, n_units, read_pos);
1258 /* Display the last N_UNITS units of the file described by F.
1259 Return true if successful. */
1262 tail_file (struct File_spec *f, uintmax_t n_units)
1267 bool is_stdin = (STREQ (f->name, "-"));
1271 have_read_stdin = true;
1273 if (O_BINARY && ! isatty (STDIN_FILENO))
1274 freopen (NULL, "rb", stdin);
1277 fd = open (f->name, O_RDONLY | O_BINARY);
1279 f->tailable = !(reopen_inaccessible_files && fd == -1);
1291 error (0, errno, _("cannot open %s for reading"),
1292 quote (pretty_name (f)));
1300 write_header (pretty_name (f));
1301 ok = tail (pretty_name (f), fd, n_units, &read_pos);
1306 #if TEST_RACE_BETWEEN_FINAL_READ_AND_INITIAL_FSTAT
1307 /* Before the tail function provided `read_pos', there was
1308 a race condition described in the URL below. This sleep
1309 call made the window big enough to exercise the problem. */
1313 if (fstat (fd, &stats) < 0)
1317 error (0, errno, _("error reading %s"), quote (pretty_name (f)));
1319 else if (!IS_TAILABLE_FILE_TYPE (stats.st_mode))
1321 error (0, 0, _("%s: cannot follow end of this type of file;\
1322 giving up on this name"),
1331 close_fd (fd, pretty_name (f));
1336 /* Note: we must use read_pos here, not stats.st_size,
1337 to avoid a race condition described by Ken Raeburn:
1338 http://mail.gnu.org/archive/html/bug-textutils/2003-05/msg00007.html */
1339 record_open_fd (f, fd, read_pos, &stats, (is_stdin ? -1 : 1));
1344 if (!is_stdin && close (fd))
1346 error (0, errno, _("error reading %s"), quote (pretty_name (f)));
1355 /* If obsolete usage is allowed, and the command line arguments are of
1356 the obsolete form and the option string is well-formed, set
1357 *N_UNITS, the globals COUNT_LINES, FOREVER, and FROM_START, and
1358 return true. If the command line arguments are obviously incorrect
1359 (e.g., because obsolete usage is not allowed and the arguments are
1360 incorrect for non-obsolete usage), report an error and exit.
1361 Otherwise, return false and don't modify any parameter or global
1365 parse_obsolete_option (int argc, char * const *argv, uintmax_t *n_units)
1368 const char *n_string;
1369 const char *n_string_end;
1370 bool obsolete_usage;
1371 int default_count = DEFAULT_N_LINES;
1373 bool t_count_lines = true;
1374 bool t_forever = false;
1376 /* With the obsolete form, there is one option string and at most
1377 one file argument. Watch out for "-" and "--", though. */
1379 || (argc == 3 && ! (argv[2][0] == '-' && argv[2][1]))
1380 || (3 <= argc && argc <= 4 && STREQ (argv[2], "--"))))
1383 obsolete_usage = (posix2_version () < 200112);
1392 /* Leading "+" is a file name in the non-obsolete form. */
1393 if (!obsolete_usage)
1396 t_from_start = true;
1400 /* In the non-obsolete form, "-" is standard input and "-c"
1401 requires an option-argument. The obsolete multidigit options
1402 are supported as a GNU extension even when conforming to
1403 POSIX 1003.1-2001, so don't complain about them. */
1404 if (!obsolete_usage && !p[p[0] == 'c'])
1407 t_from_start = false;
1412 while (ISDIGIT (*p))
1418 case 'b': default_count *= 512; /* Fall through. */
1419 case 'c': t_count_lines = false; /* Fall through. */
1420 case 'l': p++; break;
1432 if (n_string == n_string_end)
1433 *n_units = default_count;
1434 else if ((xstrtoumax (n_string, NULL, 10, n_units, "b")
1435 & ~LONGINT_INVALID_SUFFIX_CHAR)
1437 error (EXIT_FAILURE, 0, _("number in %s is too large"), quote (argv[1]));
1440 from_start = t_from_start;
1441 count_lines = t_count_lines;
1442 forever = t_forever;
1448 parse_options (int argc, char **argv,
1449 uintmax_t *n_units, enum header_mode *header_mode,
1450 double *sleep_interval)
1454 while ((c = getopt_long (argc, argv, "c:n:fFqs:v0123456789",
1455 long_options, NULL))
1462 follow_mode = Follow_name;
1463 reopen_inaccessible_files = true;
1468 count_lines = (c == 'n');
1471 else if (*optarg == '-')
1476 s_err = xstrtoumax (optarg, NULL, 10, n_units, "bkm");
1477 if (s_err != LONGINT_OK)
1479 error (EXIT_FAILURE, 0, "%s: %s", optarg,
1481 ? _("invalid number of lines")
1482 : _("invalid number of bytes")));
1488 case LONG_FOLLOW_OPTION:
1491 follow_mode = DEFAULT_FOLLOW_MODE;
1493 follow_mode = XARGMATCH ("--follow", optarg,
1494 follow_mode_string, follow_mode_map);
1498 reopen_inaccessible_files = true;
1501 case MAX_UNCHANGED_STATS_OPTION:
1502 /* --max-unchanged-stats=N */
1503 if (xstrtoumax (optarg, NULL, 10,
1504 &max_n_unchanged_stats_between_opens,
1508 error (EXIT_FAILURE, 0,
1509 _("%s: invalid maximum number of unchanged stats between opens"),
1517 unsigned long int tmp_ulong;
1518 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1519 if (s_err != LONGINT_OK || tmp_ulong > PID_T_MAX)
1521 error (EXIT_FAILURE, 0, _("%s: invalid PID"), optarg);
1527 case PRESUME_INPUT_PIPE_OPTION:
1528 presume_input_pipe = true;
1532 *header_mode = never;
1538 if (! (xstrtod (optarg, NULL, &s, c_strtod) && 0 <= s))
1539 error (EXIT_FAILURE, 0,
1540 _("%s: invalid number of seconds"), optarg);
1541 *sleep_interval = s;
1546 *header_mode = always;
1549 case_GETOPT_HELP_CHAR;
1551 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1553 case '0': case '1': case '2': case '3': case '4':
1554 case '5': case '6': case '7': case '8': case '9':
1555 error (EXIT_FAILURE, 0,
1556 _("option used in invalid context -- %c"), c);
1559 usage (EXIT_FAILURE);
1563 if (reopen_inaccessible_files && follow_mode != Follow_name)
1564 error (0, 0, _("warning: --retry is useful mainly when following by name"));
1566 if (pid && !forever)
1568 _("warning: PID ignored; --pid=PID is useful only when following"));
1569 else if (pid && kill (pid, 0) != 0 && errno == ENOSYS)
1571 error (0, 0, _("warning: --pid=PID is not supported on this system"));
1577 main (int argc, char **argv)
1579 enum header_mode header_mode = multiple_files;
1581 /* If from_start, the number of items to skip before printing; otherwise,
1582 the number of items at the end of the file to print. Although the type
1583 is signed, the value is never negative. */
1584 uintmax_t n_units = DEFAULT_N_LINES;
1587 struct File_spec *F;
1589 bool obsolete_option;
1591 /* The number of seconds to sleep between iterations.
1592 During one iteration, every file name or descriptor is checked to
1593 see if it has changed. */
1594 double sleep_interval = 1.0;
1596 initialize_main (&argc, &argv);
1597 program_name = argv[0];
1598 setlocale (LC_ALL, "");
1599 bindtextdomain (PACKAGE, LOCALEDIR);
1600 textdomain (PACKAGE);
1602 atexit (close_stdout);
1604 have_read_stdin = false;
1607 forever = from_start = print_headers = false;
1608 obsolete_option = parse_obsolete_option (argc, argv, &n_units);
1609 argc -= obsolete_option;
1610 argv += obsolete_option;
1611 parse_options (argc, argv, &n_units, &header_mode, &sleep_interval);
1613 /* To start printing with item N_UNITS from the start of the file, skip
1614 N_UNITS - 1 items. `tail -n +0' is actually meaningless, but for Unix
1615 compatibility it's treated the same as `tail -n +1'. */
1624 n_files = argc - optind;
1625 file = argv + optind;
1629 static char *dummy_stdin = "-";
1631 file = &dummy_stdin;
1633 /* POSIX says that -f is ignored if no file operand is specified
1634 and standard input is a pipe. However, the GNU coding
1635 standards say that program behavior should not depend on
1636 device type, because device independence is an important
1637 principle of the system's design.
1639 Follow the POSIX requirement only if POSIXLY_CORRECT is set. */
1641 if (forever && getenv ("POSIXLY_CORRECT"))
1644 int is_a_fifo_or_pipe =
1645 (fstat (STDIN_FILENO, &st) != 0 ? -1
1646 : S_ISFIFO (st.st_mode) ? 1
1647 : HAVE_FIFO_PIPES == 1 ? 0
1648 : isapipe (STDIN_FILENO));
1649 if (is_a_fifo_or_pipe < 0)
1650 error (EXIT_FAILURE, errno, _("standard input"));
1651 if (is_a_fifo_or_pipe)
1657 bool found_hyphen = false;
1659 for (i = 0; i < n_files; i++)
1660 if (STREQ (file[i], "-"))
1661 found_hyphen = true;
1663 /* When following by name, there must be a name. */
1664 if (found_hyphen && follow_mode == Follow_name)
1665 error (EXIT_FAILURE, 0, _("cannot follow %s by name"), quote ("-"));
1667 /* When following forever, warn if any file is `-'.
1668 This is only a warning, since tail's output (before a failing seek,
1669 and that from any non-stdin files) might still be useful. */
1670 if (forever && found_hyphen && isatty (STDIN_FILENO))
1671 error (0, 0, _("warning: following standard input"
1672 " indefinitely is ineffective"));
1675 F = xnmalloc (n_files, sizeof *F);
1676 for (i = 0; i < n_files; i++)
1677 F[i].name = file[i];
1679 if (header_mode == always
1680 || (header_mode == multiple_files && n_files > 1))
1681 print_headers = true;
1683 if (O_BINARY && ! isatty (STDOUT_FILENO))
1684 freopen (NULL, "wb", stdout);
1686 for (i = 0; i < n_files; i++)
1687 ok &= tail_file (&F[i], n_units);
1690 tail_forever (F, n_files, sleep_interval);
1692 if (have_read_stdin && close (STDIN_FILENO) < 0)
1693 error (EXIT_FAILURE, errno, "-");
1694 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);