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 "), DEFAULT_N_LINES);
248 Mandatory arguments to long options are mandatory for short options too.\n\
251 --retry keep trying to open a file even if it is\n\
252 inaccessible when tail starts or if it becomes\n\
253 inaccessible later -- useful only with -f\n\
254 -c, --bytes=N output the last N bytes\n\
257 -f, --follow[={name|descriptor}]\n\
258 output appended data as the file grows;\n\
259 -f, --follow, and --follow=descriptor are\n\
261 -F same as --follow=name --retry\n\
264 -n, --lines=N output the last N lines, instead of the last %d\n\
265 --max-unchanged-stats=N\n\
266 with --follow=name, reopen a FILE which has not\n\
267 changed size after N (default %d) iterations\n\
268 to see if it has been unlinked or renamed\n\
269 (this is the usual case of rotated log files)\n\
272 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS
275 --pid=PID with -f, terminate after process ID, PID dies\n\
276 -q, --quiet, --silent never output headers giving file names\n\
277 -s, --sleep-interval=S with -f, each iteration lasts approximately S\n\
278 (default 1) seconds\n\
279 -v, --verbose always output headers giving file names\n\
282 --help display this help and exit\n\
283 --version output version information and exit\n\
287 If the first character of N (the number of bytes or lines) is a `+',\n\
288 print beginning with the Nth item from the start of each file, otherwise,\n\
289 print the last N items in the file. N may have a multiplier suffix:\n\
290 b for 512, k for 1024, m for 1048576 (1 Meg). A first OPTION of -VALUE\n\
291 or +VALUE is treated like -n VALUE or -n +VALUE unless VALUE has one of\n\
292 the [bkm] suffix multipliers, in which case it is treated like -c VALUE\n\
295 or -c +VALUE. Warning: a first option of +VALUE is obsolescent, and support\n\
296 for it will be withdrawn.\n\
298 With --follow (-f), tail defaults to following the file descriptor, which\n\
299 means that even if a tail'ed file is renamed, tail will continue to track\n\
300 its end. This default behavior is not desirable when you really want to\n\
303 track the actual name of the file, not the file descriptor (e.g., log\n\
304 rotation). Use --follow=name in that case. That causes tail to track the\n\
305 named file by reopening it periodically to see if it has been removed and\n\
306 recreated by some other program.\n\
309 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
311 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
315 valid_file_spec (struct File_spec const *f)
317 /* Exactly one of the following subexpressions must be true. */
318 return ((f->fd == -1) ^ (f->errnum == 0));
322 pretty_name (struct File_spec const *f)
324 return (STREQ (f->name, "-") ? "standard input" : f->name);
328 xwrite (int fd, char *const buffer, size_t n_bytes)
330 assert (fd == STDOUT_FILENO);
331 if (n_bytes > 0 && fwrite (buffer, 1, n_bytes, stdout) == 0)
332 error (EXIT_FAILURE, errno, _("write error"));
336 close_fd (int fd, const char *filename)
338 if (fd != -1 && fd != STDIN_FILENO && close (fd))
340 error (0, errno, _("closing %s (fd=%d)"), filename, fd);
345 write_header (const char *pretty_filename)
347 static int first_file = 1;
349 printf ("%s==> %s <==\n", (first_file ? "" : "\n"), pretty_filename);
353 /* Read and output N_BYTES of file PRETTY_FILENAME starting at the current
354 position in FD. If N_BYTES is COPY_TO_EOF, then copy until end of file.
355 Return the number of bytes read from the file. */
358 dump_remainder (const char *pretty_filename, int fd, off_t n_bytes)
363 off_t n_remaining = n_bytes;
368 long n = MIN (n_remaining, (off_t) BUFSIZ);
369 bytes_read = safe_read (fd, buffer, n);
372 xwrite (STDOUT_FILENO, buffer, bytes_read);
373 n_remaining -= bytes_read;
374 n_written += bytes_read;
376 if (bytes_read == -1)
377 error (EXIT_FAILURE, errno, "%s", pretty_filename);
382 /* Call lseek with the specified arguments, where file descriptor FD
383 corresponds to the file, FILENAME.
384 Give a diagnostic and exit nonzero if lseek fails. */
387 xlseek (int fd, off_t offset, int whence, char const *filename)
389 off_t new_offset = lseek (fd, offset, whence);
390 char buf[LONGEST_HUMAN_READABLE + 1];
397 sign = offset < 0 ? "-" : "";
401 s = human_readable ((uintmax_t) offset, buf, 1, 1);
405 error (1, errno, _("%s: cannot seek to offset %s%s"),
409 error (1, errno, _("%s: cannot seek to relative offset %s%s"),
413 error (1, errno, _("%s: cannot seek to end-relative offset %s%s"),
421 /* Print the last N_LINES lines from the end of file FD.
422 Go backward through the file, reading `BUFSIZ' bytes at a time (except
423 probably the first), until we hit the start of the file or have
424 read NUMBER newlines.
425 START_POS is the starting position of the read pointer for the file
426 associated with FD (may be nonzero).
427 FILE_LENGTH is the length of the file (one more than the offset of the
428 last byte of the file).
429 Return 0 if successful, 1 if an error occurred. */
432 file_lines (const char *pretty_filename, int fd, long int n_lines,
433 off_t start_pos, off_t file_length)
437 off_t pos = file_length;
442 /* Set `bytes_read' to the size of the last, probably partial, buffer;
443 0 < `bytes_read' <= `BUFSIZ'. */
444 bytes_read = (pos - start_pos) % BUFSIZ;
447 /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
448 reads will be on block boundaries, which might increase efficiency. */
450 xlseek (fd, pos, SEEK_SET, pretty_filename);
451 bytes_read = safe_read (fd, buffer, bytes_read);
452 if (bytes_read == -1)
454 error (0, errno, "%s", pretty_filename);
458 /* Count the incomplete line on files that don't end with a newline. */
459 if (bytes_read && buffer[bytes_read - 1] != '\n')
464 int i; /* Index into `buffer' for scanning. */
465 /* Scan backward, counting the newlines in this bufferfull. */
466 for (i = bytes_read - 1; i >= 0; i--)
468 /* Have we counted the requested number of newlines yet? */
469 if (buffer[i] == '\n' && n_lines-- == 0)
471 /* If this newline wasn't the last character in the buffer,
472 print the text after it. */
473 if (i != bytes_read - 1)
474 xwrite (STDOUT_FILENO, &buffer[i + 1], bytes_read - (i + 1));
475 dump_remainder (pretty_filename, fd,
476 file_length - (pos + bytes_read));
480 /* Not enough newlines in that bufferfull. */
481 if (pos == start_pos)
483 /* Not enough lines in the file; print the entire file. */
484 xlseek (fd, start_pos, SEEK_SET, pretty_filename);
485 dump_remainder (pretty_filename, fd, file_length);
489 xlseek (fd, pos, SEEK_SET, pretty_filename);
491 while ((bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0);
493 if (bytes_read == -1)
495 error (0, errno, "%s", pretty_filename);
502 /* Print the last N_LINES lines from the end of the standard input,
503 open for reading as pipe FD.
504 Buffer the text as a linked list of LBUFFERs, adding them as needed.
505 Return 0 if successful, 1 if an error occured. */
508 pipe_lines (const char *pretty_filename, int fd, long int n_lines)
514 struct linebuffer *next;
516 typedef struct linebuffer LBUFFER;
517 LBUFFER *first, *last, *tmp;
518 int i; /* Index into buffers. */
519 int total_lines = 0; /* Total number of newlines in all buffers. */
521 int nbytes; /* Size of most recent read */
523 first = last = (LBUFFER *) xmalloc (sizeof (LBUFFER));
524 first->nbytes = first->nlines = 0;
526 tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
528 /* Input is always read into a fresh buffer. */
529 while ((nbytes = tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0)
534 /* Count the number of newlines just read. */
535 for (i = 0; i < tmp->nbytes; i++)
536 if (tmp->buffer[i] == '\n')
538 total_lines += tmp->nlines;
540 /* If there is enough room in the last buffer read, just append the new
541 one to it. This is because when reading from a pipe, `nbytes' can
542 often be very small. */
543 if (tmp->nbytes + last->nbytes < BUFSIZ)
545 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
546 last->nbytes += tmp->nbytes;
547 last->nlines += tmp->nlines;
551 /* If there's not enough room, link the new buffer onto the end of
552 the list, then either free up the oldest buffer for the next
553 read if that would leave enough lines, or else malloc a new one.
554 Some compaction mechanism is possible but probably not
556 last = last->next = tmp;
557 if (total_lines - first->nlines > n_lines)
560 total_lines -= first->nlines;
564 tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
572 error (0, errno, "%s", pretty_filename);
577 /* If the file is empty, then bail out. */
578 if (last->nbytes == 0)
581 /* This prevents a core dump when the pipe contains no newlines. */
585 /* Count the incomplete line on files that don't end with a newline. */
586 if (last->buffer[last->nbytes - 1] != '\n')
592 /* Run through the list, printing lines. First, skip over unneeded
594 for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
595 total_lines -= tmp->nlines;
597 /* Find the correct beginning, then print the rest of the file. */
598 if (total_lines > n_lines)
602 /* Skip `total_lines' - `n_lines' newlines. We made sure that
603 `total_lines' - `n_lines' <= `tmp->nlines'. */
605 for (i = total_lines - n_lines; i; --i)
606 while (*cp++ != '\n')
608 i = cp - tmp->buffer;
612 xwrite (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
614 for (tmp = tmp->next; tmp; tmp = tmp->next)
615 xwrite (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
621 free ((char *) first);
627 /* Print the last N_BYTES characters from the end of pipe FD.
628 This is a stripped down version of pipe_lines.
629 Return 0 if successful, 1 if an error occurred. */
632 pipe_bytes (const char *pretty_filename, int fd, off_t n_bytes)
638 struct charbuffer *next;
640 typedef struct charbuffer CBUFFER;
641 CBUFFER *first, *last, *tmp;
642 int i; /* Index into buffers. */
643 int total_bytes = 0; /* Total characters in all buffers. */
646 first = last = (CBUFFER *) xmalloc (sizeof (CBUFFER));
649 tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
651 /* Input is always read into a fresh buffer. */
652 while ((tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0)
656 total_bytes += tmp->nbytes;
657 /* If there is enough room in the last buffer read, just append the new
658 one to it. This is because when reading from a pipe, `nbytes' can
659 often be very small. */
660 if (tmp->nbytes + last->nbytes < BUFSIZ)
662 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
663 last->nbytes += tmp->nbytes;
667 /* If there's not enough room, link the new buffer onto the end of
668 the list, then either free up the oldest buffer for the next
669 read if that would leave enough characters, or else malloc a new
670 one. Some compaction mechanism is possible but probably not
672 last = last->next = tmp;
673 if (total_bytes - first->nbytes > n_bytes)
676 total_bytes -= first->nbytes;
681 tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
685 if (tmp->nbytes == -1)
687 error (0, errno, "%s", pretty_filename);
695 /* Run through the list, printing characters. First, skip over unneeded
697 for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next)
698 total_bytes -= tmp->nbytes;
700 /* Find the correct beginning, then print the rest of the file.
701 We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'. */
702 if (total_bytes > n_bytes)
703 i = total_bytes - n_bytes;
706 xwrite (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
708 for (tmp = tmp->next; tmp; tmp = tmp->next)
709 xwrite (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
715 free ((char *) first);
721 /* Skip N_BYTES characters from the start of pipe FD, and print
722 any extra characters that were read beyond that.
723 Return 1 on error, 0 if ok. */
726 start_bytes (const char *pretty_filename, int fd, off_t n_bytes)
731 while (n_bytes > 0 && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0)
732 n_bytes -= bytes_read;
733 if (bytes_read == -1)
735 error (0, errno, "%s", pretty_filename);
738 else if (n_bytes < 0)
739 xwrite (STDOUT_FILENO, &buffer[bytes_read + n_bytes], -n_bytes);
743 /* Skip N_LINES lines at the start of file or pipe FD, and print
744 any extra characters that were read beyond that.
745 Return 1 on error, 0 if ok. */
748 start_lines (const char *pretty_filename, int fd, long int n_lines)
752 int bytes_to_skip = 0;
754 while (n_lines && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0)
757 while (bytes_to_skip < bytes_read)
758 if (buffer[bytes_to_skip++] == '\n' && --n_lines == 0)
761 if (bytes_read == -1)
763 error (0, errno, "%s", pretty_filename);
766 else if (bytes_to_skip < bytes_read)
768 xwrite (STDOUT_FILENO, &buffer[bytes_to_skip],
769 bytes_read - bytes_to_skip);
774 /* FIXME: describe */
777 recheck (struct File_spec *f)
779 /* open/fstat the file and announce if dev/ino have changed */
780 struct stat new_stats;
783 int is_stdin = (STREQ (f->name, "-"));
784 int was_tailable = f->tailable;
785 int prev_errnum = f->errnum;
788 assert (valid_file_spec (f));
790 fd = (is_stdin ? STDIN_FILENO : open (f->name, O_RDONLY));
792 /* If the open fails because the file doesn't exist,
793 then mark the file as not tailable. */
794 f->tailable = !(reopen_inaccessible_files && fd == -1);
796 if (fd == -1 || fstat (fd, &new_stats) < 0)
804 /* FIXME-maybe: detect the case in which the file first becomes
805 unreadable (perms), and later becomes readable again and can
806 be seen to be the same file (dev/ino). Otherwise, tail prints
807 the entire contents of the file when it becomes readable. */
808 error (0, f->errnum, _("`%s' has become inaccessible"),
813 /* say nothing... it's still not tailable */
816 else if (prev_errnum != errno)
818 error (0, errno, "%s", pretty_name (f));
821 else if (!IS_TAILABLE_FILE_TYPE (new_stats.st_mode))
825 error (0, 0, _("`%s' has been replaced with an untailable file;\
826 giving up on this name"),
838 close_fd (fd, pretty_name (f));
839 close_fd (f->fd, pretty_name (f));
842 else if (prev_errnum && prev_errnum != ENOENT)
845 assert (f->fd == -1);
846 error (0, 0, _("`%s' has become accessible"), pretty_name (f));
848 else if (f->ino != new_stats.st_ino || f->dev != new_stats.st_dev)
854 _("`%s' has appeared; following end of new file"),
859 /* Close the old one. */
860 close_fd (f->fd, pretty_name (f));
862 /* File has been replaced (e.g., via log rotation) --
865 _("`%s' has been replaced; following end of new file"),
873 /* This happens when one iteration finds the file missing,
874 then the preceding <dev,inode> pair is reused as the
875 file is recreated. */
880 close_fd (fd, pretty_name (f));
886 /* Record new file info in f. */
888 f->size = 0; /* Start at the beginning of the file... */
889 f->dev = new_stats.st_dev;
890 f->ino = new_stats.st_ino;
891 f->n_unchanged_stats = 0;
892 f->n_consecutive_size_changes = 0;
894 xlseek (f->fd, f->size, SEEK_SET, pretty_name (f));
898 /* FIXME: describe */
901 n_live_files (const struct File_spec *f, int n_files)
904 unsigned int n_live = 0;
906 for (i = 0; i < n_files; i++)
914 /* Tail NFILES files forever, or until killed.
915 The pertinent information for each file is stored in an entry of F.
916 Loop over each of them, doing an fstat to see if they have changed size,
917 and an occasional open/fstat to see if any dev/ino pair has changed.
918 If none of them have changed size in one iteration, sleep for a
919 while and try again. Continue until the user interrupts us. */
922 tail_forever (struct File_spec *f, int nfiles)
925 int writer_is_dead = 0;
935 for (i = 0; i < nfiles; i++)
948 if (fstat (f[i].fd, &stats) < 0)
952 error (0, errno, "%s", pretty_name (&f[i]));
956 if (stats.st_size == f[i].size)
958 f[i].n_consecutive_size_changes = 0;
959 if (++f[i].n_unchanged_stats > max_n_unchanged_stats_between_opens
960 && follow_mode == Follow_name)
963 f[i].n_unchanged_stats = 0;
969 ++f[i].n_consecutive_size_changes;
971 /* Ensure that a file that's unlinked or moved aside, yet always
972 growing will be recognized as having been renamed. */
973 if (follow_mode == Follow_name
974 && (f[i].n_consecutive_size_changes
975 > max_n_consecutive_size_changes_between_opens))
977 f[i].n_consecutive_size_changes = 0;
982 /* This file has changed size. Print out what we can, and
983 then keep looping. */
988 f[i].n_unchanged_stats = 0;
990 if (stats.st_size < f[i].size)
992 error (0, 0, _("%s: file truncated"), pretty_name (&f[i]));
994 xlseek (f[i].fd, (off_t) stats.st_size, SEEK_SET,
995 pretty_name (&f[i]));
996 f[i].size = stats.st_size;
1003 write_header (pretty_name (&f[i]));
1006 f[i].size += dump_remainder (pretty_name (&f[i]), f[i].fd,
1010 if (n_live_files (f, nfiles) == 0 && ! reopen_inaccessible_files)
1012 error (0, 0, _("no files remaining"));
1016 /* If none of the files changed size, sleep. */
1021 sleep (sleep_interval);
1023 /* Once the writer is dead, read the files once more to
1024 avoid a race condition. */
1025 writer_is_dead = (pid != 0
1026 && kill (pid, 0) != 0
1027 /* Handle the case in which you cannot send a
1028 signal to the writer, so kill fails and sets
1035 /* Output the last N_BYTES bytes of file FILENAME open for reading in FD.
1036 Return 0 if successful, 1 if an error occurred. */
1039 tail_bytes (const char *pretty_filename, int fd, off_t n_bytes)
1043 /* We need binary input, since `tail' relies on `lseek' and byte counts,
1044 while binary output will preserve the style (Unix/DOS) of text file. */
1045 SET_BINARY2 (fd, STDOUT_FILENO);
1047 if (fstat (fd, &stats))
1049 error (0, errno, "%s", pretty_filename);
1055 if (S_ISREG (stats.st_mode))
1057 xlseek (fd, n_bytes, SEEK_CUR, pretty_filename);
1059 else if (start_bytes (pretty_filename, fd, n_bytes))
1063 dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1067 if (S_ISREG (stats.st_mode))
1069 off_t current_pos, end_pos;
1070 size_t bytes_remaining;
1072 if ((current_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1
1073 && (end_pos = lseek (fd, (off_t) 0, SEEK_END)) != -1)
1076 /* Be careful here. The current position may actually be
1077 beyond the end of the file. */
1078 bytes_remaining = (diff = end_pos - current_pos) < 0 ? 0 : diff;
1082 error (0, errno, "%s", pretty_filename);
1086 if (bytes_remaining <= n_bytes)
1088 /* From the current position to end of file, there are no
1089 more bytes than have been requested. So reposition the
1090 file pointer to the incoming current position and print
1091 everything after that. */
1092 xlseek (fd, current_pos, SEEK_SET, pretty_filename);
1096 /* There are more bytes remaining than were requested.
1098 xlseek (fd, -n_bytes, SEEK_END, pretty_filename);
1100 dump_remainder (pretty_filename, fd, n_bytes);
1103 return pipe_bytes (pretty_filename, fd, n_bytes);
1108 /* Output the last N_LINES lines of file FILENAME open for reading in FD.
1109 Return 0 if successful, 1 if an error occurred. */
1112 tail_lines (const char *pretty_filename, int fd, long int n_lines)
1116 /* We need binary input, since `tail' relies on `lseek' and byte counts,
1117 while binary output will preserve the style (Unix/DOS) of text file. */
1118 SET_BINARY2 (fd, STDOUT_FILENO);
1120 if (fstat (fd, &stats))
1122 error (0, errno, "%s", pretty_filename);
1128 if (start_lines (pretty_filename, fd, n_lines))
1130 dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1137 /* Use file_lines only if FD refers to a regular file for
1138 which lseek (... SEEK_END) works. */
1139 if (S_ISREG (stats.st_mode)
1140 && (start_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1
1141 && start_pos < (length = lseek (fd, (off_t) 0, SEEK_END)))
1143 if (length != 0 && file_lines (pretty_filename, fd, n_lines,
1148 return pipe_lines (pretty_filename, fd, n_lines);
1153 /* Display the last N_UNITS units of file FILENAME, open for reading
1155 Return 0 if successful, 1 if an error occurred. */
1158 tail (const char *pretty_filename, int fd, off_t n_units)
1161 return tail_lines (pretty_filename, fd, (long) n_units);
1163 return tail_bytes (pretty_filename, fd, n_units);
1166 /* Display the last N_UNITS units of the file described by F.
1167 Return 0 if successful, 1 if an error occurred. */
1170 tail_file (struct File_spec *f, off_t n_units)
1174 int is_stdin = (STREQ (f->name, "-"));
1178 have_read_stdin = 1;
1183 fd = open (f->name, O_RDONLY);
1186 f->tailable = !(reopen_inaccessible_files && fd == -1);
1198 error (0, errno, "%s", pretty_name (f));
1204 write_header (pretty_name (f));
1205 errors = tail (pretty_name (f), fd, n_units);
1211 if (fstat (fd, &stats) < 0)
1215 error (0, errno, "%s", pretty_name (f));
1217 else if (!IS_TAILABLE_FILE_TYPE (stats.st_mode))
1219 error (0, 0, _("%s: cannot follow end of this type of file;\
1220 giving up on this name"),
1229 close_fd (fd, pretty_name (f));
1235 f->size = stats.st_size;
1236 f->dev = stats.st_dev;
1237 f->ino = stats.st_ino;
1238 f->n_unchanged_stats = 0;
1239 f->n_consecutive_size_changes = 0;
1245 if (!is_stdin && close (fd))
1247 error (0, errno, "%s", pretty_name (f));
1256 /* If the command line arguments are of the obsolescent form and the
1257 option string is well-formed, set *FAIL to zero, set *N_UNITS, the
1258 globals COUNT_LINES, FOREVER, and FROM_START, and return non-zero.
1259 Otherwise, if the command line arguments appear to be of the
1260 obsolescent form but the option string is malformed, set *FAIL to
1261 non-zero, don't modify any other parameter or global variable, and
1262 return non-zero. Otherwise, return zero and don't modify any parameter
1263 or global variable. */
1266 parse_obsolescent_option (int argc, const char *const *argv,
1267 off_t *n_units, int *fail)
1269 const char *p = argv[1];
1270 const char *n_string = NULL;
1271 const char *n_string_end;
1277 /* With the obsolescent form, there is one option string and
1278 (technically) at most one file argument. But we allow two or more
1283 /* If P starts with `+', `-N' (where N is a digit), or `-l',
1284 then it is obsolescent. Return zero otherwise. */
1285 if ( ! (p[0] == '+' || (p[0] == '-' && (p[1] == 'l' || ISDIGIT (p[1])))) )
1303 while (ISDIGIT (*p));
1308 if (*p == 'c' || *p == 'b')
1327 /* If (argv[1] begins with a `+' or if it begins with `-' followed
1328 by a digit), but has an invalid suffix character, give a diagnostic
1329 and indicate to caller that this *is* of the obsolescent form,
1330 but that it's an invalid option. */
1331 if (t_from_start || n_string)
1334 _("%c: invalid suffix character in obsolescent option" ), *p);
1339 /* Otherwise, it might be a valid non-obsolescent option like -n. */
1344 if (n_string == NULL)
1345 *n_units = DEFAULT_N_LINES;
1349 unsigned long int tmp_ulong;
1352 s_err = xstrtoul (n_string, &end, 10, &tmp_ulong,
1353 *n_string_end == 'b' ? "b" : NULL);
1354 if (s_err == LONGINT_OK && tmp_ulong <= OFF_T_MAX)
1355 *n_units = (off_t) tmp_ulong;
1358 /* Extract a NUL-terminated string for the error message. */
1359 size_t len = n_string_end - n_string;
1360 char *n_string_tmp = xmalloc (len + 1);
1362 strncpy (n_string_tmp, n_string, len);
1363 n_string_tmp[len] = '\0';
1366 _("%s: %s is so large that it is not representable"),
1367 n_string_tmp, (t_count_lines
1368 ? _("number of lines")
1369 : _("number of bytes")));
1370 free (n_string_tmp);
1379 int posix_pedantic = (getenv ("POSIXLY_CORRECT") != NULL);
1381 /* When POSIXLY_CORRECT is set, enforce the `at most one
1382 file argument' requirement. */
1386 too many arguments; When using tail's obsolescent option syntax (%s)\n\
1387 there may be no more than one file argument. Use the equivalent -n or -c\n\
1388 option instead."), argv[1]);
1393 #if DISABLED /* FIXME: enable or remove this warning. */
1395 Warning: it is not portable to use two or more file arguments with\n\
1396 tail's obsolescent option syntax (%s). Use the equivalent -n or -c\n\
1397 option instead."), argv[1]);
1402 from_start = t_from_start;
1403 count_lines = t_count_lines;
1404 forever = t_forever;
1411 parse_options (int argc, char **argv,
1412 off_t *n_units, enum header_mode *header_mode)
1417 forever = from_start = print_headers = 0;
1419 while ((c = getopt_long (argc, argv, "c:n:fFqs:v", long_options, NULL))
1429 follow_mode = Follow_name;
1430 reopen_inaccessible_files = 1;
1435 count_lines = (c == 'n');
1438 else if (*optarg == '-')
1444 s_err = xstrtoumax (optarg, NULL, 10, &n, "bkm");
1445 if (s_err == LONGINT_INVALID)
1447 error (EXIT_FAILURE, 0, "%s: %s", optarg,
1449 ? _("invalid number of lines")
1450 : _("invalid number of bytes")));
1453 if (s_err != LONGINT_OK)
1454 error (EXIT_FAILURE, 0,
1455 _("%s: is so large that it is not representable"), optarg);
1458 error (EXIT_FAILURE, 0,
1459 _("%s is larger than the maximum file size on this system"),
1461 *n_units = (off_t) n;
1466 case LONG_FOLLOW_OPTION:
1469 follow_mode = DEFAULT_FOLLOW_MODE;
1471 follow_mode = XARGMATCH ("--follow", optarg,
1472 follow_mode_string, follow_mode_map);
1476 reopen_inaccessible_files = 1;
1479 case MAX_UNCHANGED_STATS_OPTION:
1480 /* --max-unchanged-stats=N */
1481 if (xstrtoul (optarg, NULL, 10,
1482 &max_n_unchanged_stats_between_opens, "") != LONGINT_OK)
1484 error (EXIT_FAILURE, 0,
1485 _("%s: invalid maximum number of unchanged stats between opens"),
1490 case MAX_CONSECUTIVE_SIZE_CHANGES_OPTION:
1491 /* --max-consecutive-size-changes=N */
1492 if (xstrtoul (optarg, NULL, 10,
1493 &max_n_consecutive_size_changes_between_opens, "")
1496 error (EXIT_FAILURE, 0,
1497 _("%s: invalid maximum number of consecutive size changes"),
1505 unsigned long int tmp_ulong;
1506 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1507 if (s_err != LONGINT_OK || tmp_ulong > PID_T_MAX)
1509 error (EXIT_FAILURE, 0, _("%s: invalid PID"), optarg);
1516 *header_mode = never;
1522 unsigned long int tmp_ulong;
1523 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1524 if (s_err != LONGINT_OK || tmp_ulong > UINT_MAX)
1526 error (EXIT_FAILURE, 0,
1527 _("%s: invalid number of seconds"), optarg);
1529 sleep_interval = tmp_ulong;
1534 *header_mode = always;
1537 case_GETOPT_HELP_CHAR;
1539 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1546 if (reopen_inaccessible_files && follow_mode != Follow_name)
1547 error (0, 0, _("warning: --retry is useful only when following by name"));
1549 if (pid && !forever)
1551 _("warning: PID ignored; --pid=PID is useful only when following"));
1552 else if (pid && kill (pid, 0) != 0 && errno == ENOSYS)
1554 error (0, 0, _("warning: --pid=PID is not supported on this system"));
1560 main (int argc, char **argv)
1562 enum header_mode header_mode = multiple_files;
1563 int exit_status = 0;
1564 /* If from_start, the number of items to skip before printing; otherwise,
1565 the number of items at the end of the file to print. Although the type
1566 is signed, the value is never negative. */
1567 off_t n_units = DEFAULT_N_LINES;
1570 struct File_spec *F;
1573 program_name = argv[0];
1574 setlocale (LC_ALL, "");
1575 bindtextdomain (PACKAGE, LOCALEDIR);
1576 textdomain (PACKAGE);
1578 atexit (close_stdout);
1580 have_read_stdin = 0;
1583 int found_obsolescent;
1585 found_obsolescent = parse_obsolescent_option (argc,
1586 (const char *const *) argv,
1588 if (found_obsolescent)
1591 exit (EXIT_FAILURE);
1596 parse_options (argc, argv, &n_units, &header_mode);
1600 /* To start printing with item N_UNITS from the start of the file, skip
1601 N_UNITS - 1 items. `tail +0' is actually meaningless, but for Unix
1602 compatibility it's treated the same as `tail +1'. */
1609 n_files = argc - optind;
1610 file = argv + optind;
1614 static char *dummy_stdin = "-";
1616 file = &dummy_stdin;
1619 F = (struct File_spec *) xmalloc (n_files * sizeof (F[0]));
1620 for (i = 0; i < n_files; i++)
1621 F[i].name = file[i];
1623 if (header_mode == always
1624 || (header_mode == multiple_files && n_files > 1))
1627 for (i = 0; i < n_files; i++)
1628 exit_status |= tail_file (&F[i], n_units);
1632 /* This fflush appears to be required only on Solaris2.7. */
1633 if (fflush (stdout) < 0)
1634 error (EXIT_FAILURE, errno, _("write error"));
1636 SETVBUF (stdout, NULL, _IONBF, 0);
1637 tail_forever (F, n_files);
1640 if (have_read_stdin && close (0) < 0)
1641 error (EXIT_FAILURE, errno, "-");
1642 exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);