1 /* tail -- output the last part of file(s)
2 Copyright (C) 1989, 90, 91, 1995-2001 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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>
39 #include "safe-read.h"
42 /* The official name of this program (e.g., no `g' prefix). */
43 #define PROGRAM_NAME "tail"
46 "Paul Rubin, David MacKenzie, Ian Lance Taylor, and Jim Meyering"
49 /* Some systems don't have ENOSYS -- this should be a big enough
50 value that no valid errno value will match it. */
54 /* Number of items to tail. */
55 #define DEFAULT_N_LINES 10
57 /* Size of atomic reads. */
59 # define BUFSIZ (512 * 8)
62 /* A special value for dump_remainder's N_BYTES parameter. */
63 #define COPY_TO_EOF OFF_T_MAX
65 /* FIXME: make Follow_name the default? */
66 #define DEFAULT_FOLLOW_MODE Follow_descriptor
70 /* Follow the name of each file: if the file is renamed, try to reopen
71 that name and track the end of the new file if/when it's recreated.
72 This is useful for tracking logs that are occasionally rotated. */
75 /* Follow each descriptor obtained upon opening a file.
76 That means we'll continue to follow the end of a file even after
77 it has been renamed or unlinked. */
81 /* The types of files for which tail works. */
82 #define IS_TAILABLE_FILE_TYPE(Mode) \
83 (S_ISREG (Mode) || S_ISFIFO (Mode) || S_ISCHR (Mode))
85 static char const *const follow_mode_string[] =
87 "descriptor", "name", 0
90 static enum Follow_mode const follow_mode_map[] =
92 Follow_descriptor, Follow_name,
97 /* The actual file name, or "-" for stdin. */
100 /* File descriptor on which the file is open; -1 if it's not open. */
103 /* The size of the file the last time we checked. */
106 /* The device and inode of the file the last time we checked. */
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 unsigned int n_unchanged_stats;
118 /* See description of DEFAULT_MAX_N_... below. */
119 unsigned int n_consecutive_size_changes;
121 /* A file is tailable if it exists, is readable, and is of type
122 IS_TAILABLE_FILE_TYPE. */
125 /* The value of errno seen last time we checked this file. */
130 /* Keep trying to open a file even if it is inaccessible when tail starts
131 or if it becomes inaccessible later -- useful only with -f. */
132 static int reopen_inaccessible_files;
134 /* If nonzero, interpret the numeric argument as the number of lines.
135 Otherwise, interpret it as the number of bytes. */
136 static int count_lines;
138 /* Whether we follow the name of each file or the file descriptor
139 that is initially associated with each name. */
140 static enum Follow_mode follow_mode = Follow_descriptor;
142 /* If nonzero, read from the ends of all specified files until killed. */
145 /* If nonzero, count from start of file instead of end. */
146 static int from_start;
148 /* If nonzero, print filename headers. */
149 static int print_headers;
151 /* When to print the filename banners. */
154 multiple_files, always, never
157 /* When tailing a file by name, if there have been this many consecutive
158 iterations for which the size has remained the same, then open/fstat
159 the file to determine if that file name is still associated with the
160 same device/inode-number pair as before. This option is meaningful only
161 when following by name. --max-unchanged-stats=N */
162 #define DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS 5
163 static unsigned long max_n_unchanged_stats_between_opens =
164 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS;
166 /* This variable is used to ensure that a file that is unlinked or moved
167 aside, yet always growing will be recognized as having been renamed.
168 After detecting this many consecutive size changes for a file, open/fstat
169 the file to determine if that file name is still associated with the
170 same device/inode-number pair as before. This option is meaningful only
171 when following by name. --max-consecutive-size-changes=N */
172 #define DEFAULT_MAX_N_CONSECUTIVE_SIZE_CHANGES 200
173 static unsigned long max_n_consecutive_size_changes_between_opens =
174 DEFAULT_MAX_N_CONSECUTIVE_SIZE_CHANGES;
176 /* The name this program was run with. */
179 /* The number of seconds to sleep between iterations.
180 During one iteration, every file name or descriptor is checked to
181 see if it has changed. */
182 /* FIXME: allow fractional seconds */
183 static unsigned int sleep_interval = 1;
185 /* The process ID of the process (presumably on the current host)
186 that is writing to all followed files. */
189 /* Nonzero if we have ever read standard input. */
190 static int have_read_stdin;
192 /* For long options that have no equivalent short option, use a
193 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
196 RETRY_OPTION = CHAR_MAX + 1,
197 MAX_UNCHANGED_STATS_OPTION,
199 /* FIXME: remove this in 2001, unless someone can show a good
200 reason to keep it. */
201 MAX_CONSECUTIVE_SIZE_CHANGES_OPTION,
207 static struct option const long_options[] =
209 /* --allow-missing is deprecated; use --retry instead
210 FIXME: remove it some day */
211 {"allow-missing", no_argument, NULL, RETRY_OPTION},
212 {"bytes", required_argument, NULL, 'c'},
213 {"follow", optional_argument, NULL, LONG_FOLLOW_OPTION},
214 {"lines", required_argument, NULL, 'n'},
215 {"max-unchanged-stats", required_argument, NULL, MAX_UNCHANGED_STATS_OPTION},
216 {"max-consecutive-size-changes", required_argument, NULL,
217 MAX_CONSECUTIVE_SIZE_CHANGES_OPTION},
218 {"pid", required_argument, NULL, PID_OPTION},
219 {"quiet", no_argument, NULL, 'q'},
220 {"retry", no_argument, NULL, RETRY_OPTION},
221 {"silent", no_argument, NULL, 'q'},
222 {"sleep-interval", required_argument, NULL, 's'},
223 {"verbose", no_argument, NULL, 'v'},
224 {GETOPT_HELP_OPTION_DECL},
225 {GETOPT_VERSION_OPTION_DECL},
233 fprintf (stderr, _("Try `%s --help' for more information.\n"),
238 Usage: %s [OPTION]... [FILE]...\n\
242 Print the last %d lines of each FILE to standard output.\n\
243 With more than one FILE, precede each with a header giving the file name.\n\
244 With no FILE, or when FILE is -, read standard input.\n\
246 Mandatory arguments to long options are mandatory for short options too.\n\
247 --retry keep trying to open a file even if it is\n\
248 inaccessible when tail starts or if it becomes\n\
249 inaccessible later -- useful only with -f\n\
250 "), DEFAULT_N_LINES);
252 -c, --bytes=N output the last N bytes\n\
253 -f, --follow[={name|descriptor}]\n\
254 output appended data as the file grows;\n\
255 -f, --follow, and --follow=descriptor are\n\
257 -F same as --follow=name --retry\n\
260 -n, --lines=N output the last N lines, instead of the last %d\n\
261 --max-unchanged-stats=N\n\
262 with --follow=name, reopen a FILE which has not\n\
263 changed size after N (default %d) iterations\n\
264 to see if it has been unlinked or renamed\n\
265 (this is the usual case of rotated log files)\n\
268 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS
271 --pid=PID with -f, terminate after process ID, PID dies\n\
272 -q, --quiet, --silent never output headers giving file names\n\
273 -s, --sleep-interval=S with -f, each iteration lasts approximately S\n\
274 (default 1) seconds\n\
277 -v, --verbose always output headers giving file names\n\
278 --help display this help and exit\n\
279 --version output version information and exit\n\
283 If the first character of N (the number of bytes or lines) is a `+',\n\
284 print beginning with the Nth item from the start of each file, otherwise,\n\
285 print the last N items in the file. N may have a multiplier suffix:\n\
286 b for 512, k for 1024, m for 1048576 (1 Meg). A first OPTION of -VALUE\n\
287 or +VALUE is treated like -n VALUE or -n +VALUE unless VALUE has one of\n\
288 the [bkm] suffix multipliers, in which case it is treated like -c VALUE\n\
291 or -c +VALUE. Warning: a first option of +VALUE is obsolescent, and support\n\
292 for it will be withdrawn.\n\
294 With --follow (-f), tail defaults to following the file descriptor, which\n\
295 means that even if a tail'ed file is renamed, tail will continue to track\n\
296 its end. This default behavior is not desirable when you really want to\n\
299 track the actual name of the file, not the file descriptor (e.g., log\n\
300 rotation). Use --follow=name in that case. That causes tail to track the\n\
301 named file by reopening it periodically to see if it has been removed and\n\
302 recreated by some other program.\n\
305 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
307 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
311 valid_file_spec (struct File_spec const *f)
313 /* Exactly one of the following subexpressions must be true. */
314 return ((f->fd == -1) ^ (f->errnum == 0));
318 pretty_name (struct File_spec const *f)
320 return (STREQ (f->name, "-") ? "standard input" : f->name);
324 xwrite (int fd, char *const buffer, size_t n_bytes)
326 assert (fd == STDOUT_FILENO);
327 if (n_bytes > 0 && fwrite (buffer, 1, n_bytes, stdout) == 0)
328 error (EXIT_FAILURE, errno, _("write error"));
332 close_fd (int fd, const char *filename)
334 if (fd != -1 && fd != STDIN_FILENO && close (fd))
336 error (0, errno, _("closing %s (fd=%d)"), filename, fd);
341 write_header (const char *pretty_filename)
343 static int first_file = 1;
345 printf ("%s==> %s <==\n", (first_file ? "" : "\n"), pretty_filename);
349 /* Read and output N_BYTES of file PRETTY_FILENAME starting at the current
350 position in FD. If N_BYTES is COPY_TO_EOF, then copy until end of file.
351 Return the number of bytes read from the file. */
354 dump_remainder (const char *pretty_filename, int fd, off_t n_bytes)
359 off_t n_remaining = n_bytes;
364 long n = MIN (n_remaining, (off_t) BUFSIZ);
365 bytes_read = safe_read (fd, buffer, n);
368 xwrite (STDOUT_FILENO, buffer, bytes_read);
369 n_remaining -= bytes_read;
370 n_written += bytes_read;
372 if (bytes_read == -1)
373 error (EXIT_FAILURE, errno, "%s", pretty_filename);
378 /* Call lseek with the specified arguments, where file descriptor FD
379 corresponds to the file, FILENAME.
380 Give a diagnostic and exit nonzero if lseek fails. */
383 xlseek (int fd, off_t offset, int whence, char const *filename)
385 off_t new_offset = lseek (fd, offset, whence);
386 char buf[LONGEST_HUMAN_READABLE + 1];
393 sign = offset < 0 ? "-" : "";
397 s = human_readable ((uintmax_t) offset, buf, 1, 1);
401 error (1, errno, _("%s: cannot seek to offset %s%s"),
405 error (1, errno, _("%s: cannot seek to relative offset %s%s"),
409 error (1, errno, _("%s: cannot seek to end-relative offset %s%s"),
417 /* Print the last N_LINES lines from the end of file FD.
418 Go backward through the file, reading `BUFSIZ' bytes at a time (except
419 probably the first), until we hit the start of the file or have
420 read NUMBER newlines.
421 START_POS is the starting position of the read pointer for the file
422 associated with FD (may be nonzero).
423 FILE_LENGTH is the length of the file (one more than the offset of the
424 last byte of the file).
425 Return 0 if successful, 1 if an error occurred. */
428 file_lines (const char *pretty_filename, int fd, long int n_lines,
429 off_t start_pos, off_t file_length)
433 off_t pos = file_length;
438 /* Set `bytes_read' to the size of the last, probably partial, buffer;
439 0 < `bytes_read' <= `BUFSIZ'. */
440 bytes_read = (pos - start_pos) % BUFSIZ;
443 /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
444 reads will be on block boundaries, which might increase efficiency. */
446 xlseek (fd, pos, SEEK_SET, pretty_filename);
447 bytes_read = safe_read (fd, buffer, bytes_read);
448 if (bytes_read == -1)
450 error (0, errno, "%s", pretty_filename);
454 /* Count the incomplete line on files that don't end with a newline. */
455 if (bytes_read && buffer[bytes_read - 1] != '\n')
460 int i; /* Index into `buffer' for scanning. */
461 /* Scan backward, counting the newlines in this bufferfull. */
462 for (i = bytes_read - 1; i >= 0; i--)
464 /* Have we counted the requested number of newlines yet? */
465 if (buffer[i] == '\n' && n_lines-- == 0)
467 /* If this newline wasn't the last character in the buffer,
468 print the text after it. */
469 if (i != bytes_read - 1)
470 xwrite (STDOUT_FILENO, &buffer[i + 1], bytes_read - (i + 1));
471 dump_remainder (pretty_filename, fd,
472 file_length - (pos + bytes_read));
476 /* Not enough newlines in that bufferfull. */
477 if (pos == start_pos)
479 /* Not enough lines in the file; print the entire file. */
480 xlseek (fd, start_pos, SEEK_SET, pretty_filename);
481 dump_remainder (pretty_filename, fd, file_length);
485 xlseek (fd, pos, SEEK_SET, pretty_filename);
487 while ((bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0);
489 if (bytes_read == -1)
491 error (0, errno, "%s", pretty_filename);
498 /* Print the last N_LINES lines from the end of the standard input,
499 open for reading as pipe FD.
500 Buffer the text as a linked list of LBUFFERs, adding them as needed.
501 Return 0 if successful, 1 if an error occured. */
504 pipe_lines (const char *pretty_filename, int fd, long int n_lines)
510 struct linebuffer *next;
512 typedef struct linebuffer LBUFFER;
513 LBUFFER *first, *last, *tmp;
514 int i; /* Index into buffers. */
515 int total_lines = 0; /* Total number of newlines in all buffers. */
517 int nbytes; /* Size of most recent read */
519 first = last = (LBUFFER *) xmalloc (sizeof (LBUFFER));
520 first->nbytes = first->nlines = 0;
522 tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
524 /* Input is always read into a fresh buffer. */
525 while ((nbytes = tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0)
530 /* Count the number of newlines just read. */
531 for (i = 0; i < tmp->nbytes; i++)
532 if (tmp->buffer[i] == '\n')
534 total_lines += tmp->nlines;
536 /* If there is enough room in the last buffer read, just append the new
537 one to it. This is because when reading from a pipe, `nbytes' can
538 often be very small. */
539 if (tmp->nbytes + last->nbytes < BUFSIZ)
541 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
542 last->nbytes += tmp->nbytes;
543 last->nlines += tmp->nlines;
547 /* If there's not enough room, link the new buffer onto the end of
548 the list, then either free up the oldest buffer for the next
549 read if that would leave enough lines, or else malloc a new one.
550 Some compaction mechanism is possible but probably not
552 last = last->next = tmp;
553 if (total_lines - first->nlines > n_lines)
556 total_lines -= first->nlines;
560 tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
568 error (0, errno, "%s", pretty_filename);
573 /* If the file is empty, then bail out. */
574 if (last->nbytes == 0)
577 /* This prevents a core dump when the pipe contains no newlines. */
581 /* Count the incomplete line on files that don't end with a newline. */
582 if (last->buffer[last->nbytes - 1] != '\n')
588 /* Run through the list, printing lines. First, skip over unneeded
590 for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
591 total_lines -= tmp->nlines;
593 /* Find the correct beginning, then print the rest of the file. */
594 if (total_lines > n_lines)
598 /* Skip `total_lines' - `n_lines' newlines. We made sure that
599 `total_lines' - `n_lines' <= `tmp->nlines'. */
601 for (i = total_lines - n_lines; i; --i)
602 while (*cp++ != '\n')
604 i = cp - tmp->buffer;
608 xwrite (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
610 for (tmp = tmp->next; tmp; tmp = tmp->next)
611 xwrite (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
617 free ((char *) first);
623 /* Print the last N_BYTES characters from the end of pipe FD.
624 This is a stripped down version of pipe_lines.
625 Return 0 if successful, 1 if an error occurred. */
628 pipe_bytes (const char *pretty_filename, int fd, off_t n_bytes)
634 struct charbuffer *next;
636 typedef struct charbuffer CBUFFER;
637 CBUFFER *first, *last, *tmp;
638 int i; /* Index into buffers. */
639 int total_bytes = 0; /* Total characters in all buffers. */
642 first = last = (CBUFFER *) xmalloc (sizeof (CBUFFER));
645 tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
647 /* Input is always read into a fresh buffer. */
648 while ((tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0)
652 total_bytes += tmp->nbytes;
653 /* If there is enough room in the last buffer read, just append the new
654 one to it. This is because when reading from a pipe, `nbytes' can
655 often be very small. */
656 if (tmp->nbytes + last->nbytes < BUFSIZ)
658 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
659 last->nbytes += tmp->nbytes;
663 /* If there's not enough room, link the new buffer onto the end of
664 the list, then either free up the oldest buffer for the next
665 read if that would leave enough characters, or else malloc a new
666 one. Some compaction mechanism is possible but probably not
668 last = last->next = tmp;
669 if (total_bytes - first->nbytes > n_bytes)
672 total_bytes -= first->nbytes;
677 tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
681 if (tmp->nbytes == -1)
683 error (0, errno, "%s", pretty_filename);
691 /* Run through the list, printing characters. First, skip over unneeded
693 for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next)
694 total_bytes -= tmp->nbytes;
696 /* Find the correct beginning, then print the rest of the file.
697 We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'. */
698 if (total_bytes > n_bytes)
699 i = total_bytes - n_bytes;
702 xwrite (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
704 for (tmp = tmp->next; tmp; tmp = tmp->next)
705 xwrite (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
711 free ((char *) first);
717 /* Skip N_BYTES characters from the start of pipe FD, and print
718 any extra characters that were read beyond that.
719 Return 1 on error, 0 if ok. */
722 start_bytes (const char *pretty_filename, int fd, off_t n_bytes)
727 while (n_bytes > 0 && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0)
728 n_bytes -= bytes_read;
729 if (bytes_read == -1)
731 error (0, errno, "%s", pretty_filename);
734 else if (n_bytes < 0)
735 xwrite (STDOUT_FILENO, &buffer[bytes_read + n_bytes], -n_bytes);
739 /* Skip N_LINES lines at the start of file or pipe FD, and print
740 any extra characters that were read beyond that.
741 Return 1 on error, 0 if ok. */
744 start_lines (const char *pretty_filename, int fd, long int n_lines)
748 int bytes_to_skip = 0;
750 while (n_lines && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0)
753 while (bytes_to_skip < bytes_read)
754 if (buffer[bytes_to_skip++] == '\n' && --n_lines == 0)
757 if (bytes_read == -1)
759 error (0, errno, "%s", pretty_filename);
762 else if (bytes_to_skip < bytes_read)
764 xwrite (STDOUT_FILENO, &buffer[bytes_to_skip],
765 bytes_read - bytes_to_skip);
770 /* FIXME: describe */
773 recheck (struct File_spec *f)
775 /* open/fstat the file and announce if dev/ino have changed */
776 struct stat new_stats;
779 int is_stdin = (STREQ (f->name, "-"));
780 int was_tailable = f->tailable;
781 int prev_errnum = f->errnum;
784 assert (valid_file_spec (f));
786 fd = (is_stdin ? STDIN_FILENO : open (f->name, O_RDONLY));
788 /* If the open fails because the file doesn't exist,
789 then mark the file as not tailable. */
790 f->tailable = !(reopen_inaccessible_files && fd == -1);
792 if (fd == -1 || fstat (fd, &new_stats) < 0)
800 /* FIXME-maybe: detect the case in which the file first becomes
801 unreadable (perms), and later becomes readable again and can
802 be seen to be the same file (dev/ino). Otherwise, tail prints
803 the entire contents of the file when it becomes readable. */
804 error (0, f->errnum, _("`%s' has become inaccessible"),
809 /* say nothing... it's still not tailable */
812 else if (prev_errnum != errno)
814 error (0, errno, "%s", pretty_name (f));
817 else if (!IS_TAILABLE_FILE_TYPE (new_stats.st_mode))
821 error (0, 0, _("`%s' has been replaced with an untailable file;\
822 giving up on this name"),
834 close_fd (fd, pretty_name (f));
835 close_fd (f->fd, pretty_name (f));
838 else if (prev_errnum && prev_errnum != ENOENT)
841 assert (f->fd == -1);
842 error (0, 0, _("`%s' has become accessible"), pretty_name (f));
844 else if (f->ino != new_stats.st_ino || f->dev != new_stats.st_dev)
850 _("`%s' has appeared; following end of new file"),
855 /* Close the old one. */
856 close_fd (f->fd, pretty_name (f));
858 /* File has been replaced (e.g., via log rotation) --
861 _("`%s' has been replaced; following end of new file"),
869 /* This happens when one iteration finds the file missing,
870 then the preceding <dev,inode> pair is reused as the
871 file is recreated. */
876 close_fd (fd, pretty_name (f));
882 /* Record new file info in f. */
884 f->size = 0; /* Start at the beginning of the file... */
885 f->dev = new_stats.st_dev;
886 f->ino = new_stats.st_ino;
887 f->n_unchanged_stats = 0;
888 f->n_consecutive_size_changes = 0;
890 xlseek (f->fd, f->size, SEEK_SET, pretty_name (f));
894 /* FIXME: describe */
897 n_live_files (const struct File_spec *f, int n_files)
900 unsigned int n_live = 0;
902 for (i = 0; i < n_files; i++)
910 /* Tail NFILES files forever, or until killed.
911 The pertinent information for each file is stored in an entry of F.
912 Loop over each of them, doing an fstat to see if they have changed size,
913 and an occasional open/fstat to see if any dev/ino pair has changed.
914 If none of them have changed size in one iteration, sleep for a
915 while and try again. Continue until the user interrupts us. */
918 tail_forever (struct File_spec *f, int nfiles)
921 int writer_is_dead = 0;
931 for (i = 0; i < nfiles; i++)
944 if (fstat (f[i].fd, &stats) < 0)
948 error (0, errno, "%s", pretty_name (&f[i]));
952 if (stats.st_size == f[i].size)
954 f[i].n_consecutive_size_changes = 0;
955 if (++f[i].n_unchanged_stats > max_n_unchanged_stats_between_opens
956 && follow_mode == Follow_name)
959 f[i].n_unchanged_stats = 0;
965 ++f[i].n_consecutive_size_changes;
967 /* Ensure that a file that's unlinked or moved aside, yet always
968 growing will be recognized as having been renamed. */
969 if (follow_mode == Follow_name
970 && (f[i].n_consecutive_size_changes
971 > max_n_consecutive_size_changes_between_opens))
973 f[i].n_consecutive_size_changes = 0;
978 /* This file has changed size. Print out what we can, and
979 then keep looping. */
984 f[i].n_unchanged_stats = 0;
986 if (stats.st_size < f[i].size)
988 error (0, 0, _("%s: file truncated"), pretty_name (&f[i]));
990 xlseek (f[i].fd, (off_t) stats.st_size, SEEK_SET,
991 pretty_name (&f[i]));
992 f[i].size = stats.st_size;
999 write_header (pretty_name (&f[i]));
1002 f[i].size += dump_remainder (pretty_name (&f[i]), f[i].fd,
1006 if (n_live_files (f, nfiles) == 0 && ! reopen_inaccessible_files)
1008 error (0, 0, _("no files remaining"));
1012 /* If none of the files changed size, sleep. */
1017 sleep (sleep_interval);
1019 /* Once the writer is dead, read the files once more to
1020 avoid a race condition. */
1021 writer_is_dead = (pid != 0
1022 && kill (pid, 0) != 0
1023 /* Handle the case in which you cannot send a
1024 signal to the writer, so kill fails and sets
1031 /* Output the last N_BYTES bytes of file FILENAME open for reading in FD.
1032 Return 0 if successful, 1 if an error occurred. */
1035 tail_bytes (const char *pretty_filename, int fd, off_t n_bytes)
1039 /* We need binary input, since `tail' relies on `lseek' and byte counts,
1040 while binary output will preserve the style (Unix/DOS) of text file. */
1041 SET_BINARY2 (fd, STDOUT_FILENO);
1043 if (fstat (fd, &stats))
1045 error (0, errno, "%s", pretty_filename);
1051 if (S_ISREG (stats.st_mode))
1053 xlseek (fd, n_bytes, SEEK_CUR, pretty_filename);
1055 else if (start_bytes (pretty_filename, fd, n_bytes))
1059 dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1063 if (S_ISREG (stats.st_mode))
1065 off_t current_pos, end_pos;
1066 size_t bytes_remaining;
1068 if ((current_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1
1069 && (end_pos = lseek (fd, (off_t) 0, SEEK_END)) != -1)
1072 /* Be careful here. The current position may actually be
1073 beyond the end of the file. */
1074 bytes_remaining = (diff = end_pos - current_pos) < 0 ? 0 : diff;
1078 error (0, errno, "%s", pretty_filename);
1082 if (bytes_remaining <= n_bytes)
1084 /* From the current position to end of file, there are no
1085 more bytes than have been requested. So reposition the
1086 file pointer to the incoming current position and print
1087 everything after that. */
1088 xlseek (fd, current_pos, SEEK_SET, pretty_filename);
1092 /* There are more bytes remaining than were requested.
1094 xlseek (fd, -n_bytes, SEEK_END, pretty_filename);
1096 dump_remainder (pretty_filename, fd, n_bytes);
1099 return pipe_bytes (pretty_filename, fd, n_bytes);
1104 /* Output the last N_LINES lines of file FILENAME open for reading in FD.
1105 Return 0 if successful, 1 if an error occurred. */
1108 tail_lines (const char *pretty_filename, int fd, long int n_lines)
1112 /* We need binary input, since `tail' relies on `lseek' and byte counts,
1113 while binary output will preserve the style (Unix/DOS) of text file. */
1114 SET_BINARY2 (fd, STDOUT_FILENO);
1116 if (fstat (fd, &stats))
1118 error (0, errno, "%s", pretty_filename);
1124 if (start_lines (pretty_filename, fd, n_lines))
1126 dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1133 /* Use file_lines only if FD refers to a regular file for
1134 which lseek (... SEEK_END) works. */
1135 if (S_ISREG (stats.st_mode)
1136 && (start_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1
1137 && start_pos < (length = lseek (fd, (off_t) 0, SEEK_END)))
1139 if (length != 0 && file_lines (pretty_filename, fd, n_lines,
1144 return pipe_lines (pretty_filename, fd, n_lines);
1149 /* Display the last N_UNITS units of file FILENAME, open for reading
1151 Return 0 if successful, 1 if an error occurred. */
1154 tail (const char *pretty_filename, int fd, off_t n_units)
1157 return tail_lines (pretty_filename, fd, (long) n_units);
1159 return tail_bytes (pretty_filename, fd, n_units);
1162 /* Display the last N_UNITS units of the file described by F.
1163 Return 0 if successful, 1 if an error occurred. */
1166 tail_file (struct File_spec *f, off_t n_units)
1170 int is_stdin = (STREQ (f->name, "-"));
1174 have_read_stdin = 1;
1179 fd = open (f->name, O_RDONLY);
1182 f->tailable = !(reopen_inaccessible_files && fd == -1);
1194 error (0, errno, "%s", pretty_name (f));
1200 write_header (pretty_name (f));
1201 errors = tail (pretty_name (f), fd, n_units);
1207 if (fstat (fd, &stats) < 0)
1211 error (0, errno, "%s", pretty_name (f));
1213 else if (!IS_TAILABLE_FILE_TYPE (stats.st_mode))
1215 error (0, 0, _("%s: cannot follow end of this type of file;\
1216 giving up on this name"),
1225 close_fd (fd, pretty_name (f));
1231 f->size = stats.st_size;
1232 f->dev = stats.st_dev;
1233 f->ino = stats.st_ino;
1234 f->n_unchanged_stats = 0;
1235 f->n_consecutive_size_changes = 0;
1241 if (!is_stdin && close (fd))
1243 error (0, errno, "%s", pretty_name (f));
1252 /* If the command line arguments are of the obsolescent form and the
1253 option string is well-formed, set *FAIL to zero, set *N_UNITS, the
1254 globals COUNT_LINES, FOREVER, and FROM_START, and return non-zero.
1255 Otherwise, if the command line arguments appear to be of the
1256 obsolescent form but the option string is malformed, set *FAIL to
1257 non-zero, don't modify any other parameter or global variable, and
1258 return non-zero. Otherwise, return zero and don't modify any parameter
1259 or global variable. */
1262 parse_obsolescent_option (int argc, const char *const *argv,
1263 off_t *n_units, int *fail)
1265 const char *p = argv[1];
1266 const char *n_string = NULL;
1267 const char *n_string_end;
1273 /* With the obsolescent form, there is one option string and
1274 (technically) at most one file argument. But we allow two or more
1279 /* If P starts with `+', `-N' (where N is a digit), or `-l',
1280 then it is obsolescent. Return zero otherwise. */
1281 if ( ! (p[0] == '+' || (p[0] == '-' && (p[1] == 'l' || ISDIGIT (p[1])))) )
1299 while (ISDIGIT (*p));
1304 if (*p == 'c' || *p == 'b')
1323 /* If (argv[1] begins with a `+' or if it begins with `-' followed
1324 by a digit), but has an invalid suffix character, give a diagnostic
1325 and indicate to caller that this *is* of the obsolescent form,
1326 but that it's an invalid option. */
1327 if (t_from_start || n_string)
1330 _("%c: invalid suffix character in obsolescent option" ), *p);
1335 /* Otherwise, it might be a valid non-obsolescent option like -n. */
1340 if (n_string == NULL)
1341 *n_units = DEFAULT_N_LINES;
1345 unsigned long int tmp_ulong;
1348 s_err = xstrtoul (n_string, &end, 10, &tmp_ulong,
1349 *n_string_end == 'b' ? "b" : NULL);
1350 if (s_err == LONGINT_OK && tmp_ulong <= OFF_T_MAX)
1351 *n_units = (off_t) tmp_ulong;
1354 /* Extract a NUL-terminated string for the error message. */
1355 size_t len = n_string_end - n_string;
1356 char *n_string_tmp = xmalloc (len + 1);
1358 strncpy (n_string_tmp, n_string, len);
1359 n_string_tmp[len] = '\0';
1362 _("%s: %s is so large that it is not representable"),
1363 n_string_tmp, (t_count_lines
1364 ? _("number of lines")
1365 : _("number of bytes")));
1366 free (n_string_tmp);
1375 int posix_pedantic = (getenv ("POSIXLY_CORRECT") != NULL);
1377 /* When POSIXLY_CORRECT is set, enforce the `at most one
1378 file argument' requirement. */
1382 too many arguments; When using tail's obsolescent option syntax (%s)\n\
1383 there may be no more than one file argument. Use the equivalent -n or -c\n\
1384 option instead."), argv[1]);
1389 #if DISABLED /* FIXME: enable or remove this warning. */
1391 Warning: it is not portable to use two or more file arguments with\n\
1392 tail's obsolescent option syntax (%s). Use the equivalent -n or -c\n\
1393 option instead."), argv[1]);
1398 from_start = t_from_start;
1399 count_lines = t_count_lines;
1400 forever = t_forever;
1407 parse_options (int argc, char **argv,
1408 off_t *n_units, enum header_mode *header_mode)
1413 forever = from_start = print_headers = 0;
1415 while ((c = getopt_long (argc, argv, "c:n:fFqs:v", long_options, NULL))
1425 follow_mode = Follow_name;
1426 reopen_inaccessible_files = 1;
1431 count_lines = (c == 'n');
1434 else if (*optarg == '-')
1440 s_err = xstrtoumax (optarg, NULL, 10, &n, "bkm");
1441 if (s_err == LONGINT_INVALID)
1443 error (EXIT_FAILURE, 0, "%s: %s", optarg,
1445 ? _("invalid number of lines")
1446 : _("invalid number of bytes")));
1449 if (s_err != LONGINT_OK)
1450 error (EXIT_FAILURE, 0,
1451 _("%s: is so large that it is not representable"), optarg);
1454 error (EXIT_FAILURE, 0,
1455 _("%s is larger than the maximum file size on this system"),
1457 *n_units = (off_t) n;
1462 case LONG_FOLLOW_OPTION:
1465 follow_mode = DEFAULT_FOLLOW_MODE;
1467 follow_mode = XARGMATCH ("--follow", optarg,
1468 follow_mode_string, follow_mode_map);
1472 reopen_inaccessible_files = 1;
1475 case MAX_UNCHANGED_STATS_OPTION:
1476 /* --max-unchanged-stats=N */
1477 if (xstrtoul (optarg, NULL, 10,
1478 &max_n_unchanged_stats_between_opens, "") != LONGINT_OK)
1480 error (EXIT_FAILURE, 0,
1481 _("%s: invalid maximum number of unchanged stats between opens"),
1486 case MAX_CONSECUTIVE_SIZE_CHANGES_OPTION:
1487 /* --max-consecutive-size-changes=N */
1488 if (xstrtoul (optarg, NULL, 10,
1489 &max_n_consecutive_size_changes_between_opens, "")
1492 error (EXIT_FAILURE, 0,
1493 _("%s: invalid maximum number of consecutive size changes"),
1501 unsigned long int tmp_ulong;
1502 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1503 if (s_err != LONGINT_OK || tmp_ulong > PID_T_MAX)
1505 error (EXIT_FAILURE, 0, _("%s: invalid PID"), optarg);
1512 *header_mode = never;
1518 unsigned long int tmp_ulong;
1519 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1520 if (s_err != LONGINT_OK || tmp_ulong > UINT_MAX)
1522 error (EXIT_FAILURE, 0,
1523 _("%s: invalid number of seconds"), optarg);
1525 sleep_interval = tmp_ulong;
1530 *header_mode = always;
1533 case_GETOPT_HELP_CHAR;
1535 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1542 if (reopen_inaccessible_files && follow_mode != Follow_name)
1543 error (0, 0, _("warning: --retry is useful only when following by name"));
1545 if (pid && !forever)
1547 _("warning: PID ignored; --pid=PID is useful only when following"));
1548 else if (pid && kill (pid, 0) != 0 && errno == ENOSYS)
1550 error (0, 0, _("warning: --pid=PID is not supported on this system"));
1556 main (int argc, char **argv)
1558 enum header_mode header_mode = multiple_files;
1559 int exit_status = 0;
1560 /* If from_start, the number of items to skip before printing; otherwise,
1561 the number of items at the end of the file to print. Although the type
1562 is signed, the value is never negative. */
1563 off_t n_units = DEFAULT_N_LINES;
1566 struct File_spec *F;
1569 program_name = argv[0];
1570 setlocale (LC_ALL, "");
1571 bindtextdomain (PACKAGE, LOCALEDIR);
1572 textdomain (PACKAGE);
1574 atexit (close_stdout);
1576 have_read_stdin = 0;
1579 int found_obsolescent;
1581 found_obsolescent = parse_obsolescent_option (argc,
1582 (const char *const *) argv,
1584 if (found_obsolescent)
1587 exit (EXIT_FAILURE);
1592 parse_options (argc, argv, &n_units, &header_mode);
1596 /* To start printing with item N_UNITS from the start of the file, skip
1597 N_UNITS - 1 items. `tail +0' is actually meaningless, but for Unix
1598 compatibility it's treated the same as `tail +1'. */
1605 n_files = argc - optind;
1606 file = argv + optind;
1610 static char *dummy_stdin = "-";
1612 file = &dummy_stdin;
1615 F = (struct File_spec *) xmalloc (n_files * sizeof (F[0]));
1616 for (i = 0; i < n_files; i++)
1617 F[i].name = file[i];
1619 if (header_mode == always
1620 || (header_mode == multiple_files && n_files > 1))
1623 for (i = 0; i < n_files; i++)
1624 exit_status |= tail_file (&F[i], n_units);
1628 /* This fflush appears to be required only on Solaris2.7. */
1629 if (fflush (stdout) < 0)
1630 error (EXIT_FAILURE, errno, _("write error"));
1632 SETVBUF (stdout, NULL, _IONBF, 0);
1633 tail_forever (F, n_files);
1636 if (have_read_stdin && close (0) < 0)
1637 error (EXIT_FAILURE, errno, "-");
1638 exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);