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>
38 #include "safe-read.h"
41 /* The official name of this program (e.g., no `g' prefix). */
42 #define PROGRAM_NAME "tail"
45 "Paul Rubin, David MacKenzie, Ian Lance Taylor, and Jim Meyering"
48 /* Some systems don't have ENOSYS -- this should be a big enough
49 value that no valid errno value will match it. */
53 /* Number of items to tail. */
54 #define DEFAULT_N_LINES 10
56 /* Size of atomic reads. */
58 # define BUFSIZ (512 * 8)
61 /* A special value for dump_remainder's N_BYTES parameter. */
62 #define COPY_TO_EOF OFF_T_MAX
64 /* FIXME: make Follow_name the default? */
65 #define DEFAULT_FOLLOW_MODE Follow_descriptor
69 /* Follow the name of each file: if the file is renamed, try to reopen
70 that name and track the end of the new file if/when it's recreated.
71 This is useful for tracking logs that are occasionally rotated. */
74 /* Follow each descriptor obtained upon opening a file.
75 That means we'll continue to follow the end of a file even after
76 it has been renamed or unlinked. */
80 /* The types of files for which tail works. */
81 #define IS_TAILABLE_FILE_TYPE(Mode) \
82 (S_ISREG (Mode) || S_ISFIFO (Mode) || S_ISCHR (Mode))
84 static char const *const follow_mode_string[] =
86 "descriptor", "name", 0
89 static enum Follow_mode const follow_mode_map[] =
91 Follow_descriptor, Follow_name,
96 /* The actual file name, or "-" for stdin. */
99 /* File descriptor on which the file is open; -1 if it's not open. */
102 /* The size of the file the last time we checked. */
105 /* The device and inode of the file the last time we checked. */
109 /* The specified name initially referred to a directory or some other
110 type for which tail isn't meaningful. Unlike for a permission problem
111 (tailable, below) once this is set, the name is not checked ever again. */
114 /* See description of DEFAULT_MAX_N_... below. */
115 unsigned int n_unchanged_stats;
117 /* See description of DEFAULT_MAX_N_... below. */
118 unsigned int n_consecutive_size_changes;
120 /* A file is tailable if it exists, is readable, and is of type
121 IS_TAILABLE_FILE_TYPE. */
124 /* The value of errno seen last time we checked this file. */
129 /* Keep trying to open a file even if it is inaccessible when tail starts
130 or if it becomes inaccessible later -- useful only with -f. */
131 static int reopen_inaccessible_files;
133 /* If nonzero, interpret the numeric argument as the number of lines.
134 Otherwise, interpret it as the number of bytes. */
135 static int count_lines;
137 /* Whether we follow the name of each file or the file descriptor
138 that is initially associated with each name. */
139 static enum Follow_mode follow_mode = Follow_descriptor;
141 /* If nonzero, read from the ends of all specified files until killed. */
144 /* If nonzero, count from start of file instead of end. */
145 static int from_start;
147 /* If nonzero, print filename headers. */
148 static int print_headers;
150 /* When to print the filename banners. */
153 multiple_files, always, never
156 /* When tailing a file by name, if there have been this many consecutive
157 iterations for which the size has remained the same, then open/fstat
158 the file to determine if that file name is still associated with the
159 same device/inode-number pair as before. This option is meaningful only
160 when following by name. --max-unchanged-stats=N */
161 #define DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS 5
162 static unsigned long max_n_unchanged_stats_between_opens =
163 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS;
165 /* This variable is used to ensure that a file that is unlinked or moved
166 aside, yet always growing will be recognized as having been renamed.
167 After detecting this many consecutive size changes for a file, open/fstat
168 the file to determine if that file name is still associated with the
169 same device/inode-number pair as before. This option is meaningful only
170 when following by name. --max-consecutive-size-changes=N */
171 #define DEFAULT_MAX_N_CONSECUTIVE_SIZE_CHANGES 200
172 static unsigned long max_n_consecutive_size_changes_between_opens =
173 DEFAULT_MAX_N_CONSECUTIVE_SIZE_CHANGES;
175 /* The name this program was run with. */
178 /* The number of seconds to sleep between iterations.
179 During one iteration, every file name or descriptor is checked to
180 see if it has changed. */
181 /* FIXME: allow fractional seconds */
182 static unsigned int sleep_interval = 1;
184 /* The process ID of the process (presumably on the current host)
185 that is writing to all followed files. */
188 /* Nonzero if we have ever read standard input. */
189 static int have_read_stdin;
191 /* For long options that have no equivalent short option, use a
192 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
195 RETRY_OPTION = CHAR_MAX + 1,
196 MAX_UNCHANGED_STATS_OPTION,
198 /* FIXME: remove this in 2001, unless someone can show a good
199 reason to keep it. */
200 MAX_CONSECUTIVE_SIZE_CHANGES_OPTION,
206 static struct option const long_options[] =
208 /* --allow-missing is deprecated; use --retry instead
209 FIXME: remove it some day */
210 {"allow-missing", no_argument, NULL, RETRY_OPTION},
211 {"bytes", required_argument, NULL, 'c'},
212 {"follow", optional_argument, NULL, LONG_FOLLOW_OPTION},
213 {"lines", required_argument, NULL, 'n'},
214 {"max-unchanged-stats", required_argument, NULL, MAX_UNCHANGED_STATS_OPTION},
215 {"max-consecutive-size-changes", required_argument, NULL,
216 MAX_CONSECUTIVE_SIZE_CHANGES_OPTION},
217 {"pid", required_argument, NULL, PID_OPTION},
218 {"quiet", no_argument, NULL, 'q'},
219 {"retry", no_argument, NULL, RETRY_OPTION},
220 {"silent", no_argument, NULL, 'q'},
221 {"sleep-interval", required_argument, NULL, 's'},
222 {"verbose", no_argument, NULL, 'v'},
223 {GETOPT_HELP_OPTION_DECL},
224 {GETOPT_VERSION_OPTION_DECL},
232 fprintf (stderr, _("Try `%s --help' for more information.\n"),
237 Usage: %s [OPTION]... [FILE]...\n\
241 Print the last %d lines of each FILE to standard output.\n\
242 With more than one FILE, precede each with a header giving the file name.\n\
243 With no FILE, or when FILE is -, read standard input.\n\
245 Mandatory arguments to long options are mandatory for short options too.\n\
246 --retry keep trying to open a file even if it is\n\
247 inaccessible when tail starts or if it becomes\n\
248 inaccessible later -- useful only with -f\n\
249 -c, --bytes=N output the last N bytes\n\
250 -f, --follow[={name|descriptor}]\n\
251 output appended data as the file grows;\n\
252 -f, --follow, and --follow=descriptor are\n\
254 -F same as --follow=name --retry\n\
255 -n, --lines=N output the last N lines, instead of the last %d\n\
256 --max-unchanged-stats=N\n\
257 with --follow=name, reopen a FILE which has not\n\
258 changed size after N (default %d) iterations\n\
259 to see if it has been unlinked or renamed\n\
260 (this is the usual case of rotated log files)\n\
261 --pid=PID with -f, terminate after process ID, PID dies\n\
262 -q, --quiet, --silent never output headers giving file names\n\
263 -s, --sleep-interval=S with -f, each iteration lasts approximately S\n\
264 (default 1) seconds\n\
265 -v, --verbose always output headers giving file names\n\
266 --help display this help and exit\n\
267 --version output version information and exit\n\
270 DEFAULT_N_LINES, DEFAULT_N_LINES,
271 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS
274 If the first character of N (the number of bytes or lines) is a `+',\n\
275 print beginning with the Nth item from the start of each file, otherwise,\n\
276 print the last N items in the file. N may have a multiplier suffix:\n\
277 b for 512, k for 1024, m for 1048576 (1 Meg). A first OPTION of -VALUE\n\
278 or +VALUE is treated like -n VALUE or -n +VALUE unless VALUE has one of\n\
279 the [bkm] suffix multipliers, in which case it is treated like -c VALUE\n\
280 or -c +VALUE. Warning: a first option of +VALUE is obsolescent, and support\n\
281 for it will be withdrawn.\n\
283 With --follow (-f), tail defaults to following the file descriptor, which\n\
284 means that even if a tail'ed file is renamed, tail will continue to track\n\
285 its end. This default behavior is not desirable when you really want to\n\
286 track the actual name of the file, not the file descriptor (e.g., log\n\
287 rotation). Use --follow=name in that case. That causes tail to track the\n\
288 named file by reopening it periodically to see if it has been removed and\n\
289 recreated by some other program.\n\
292 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
294 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
298 valid_file_spec (struct File_spec const *f)
300 /* Exactly one of the following subexpressions must be true. */
301 return ((f->fd == -1) ^ (f->errnum == 0));
305 pretty_name (struct File_spec const *f)
307 return (STREQ (f->name, "-") ? "standard input" : f->name);
311 xwrite (int fd, char *const buffer, size_t n_bytes)
313 assert (fd == STDOUT_FILENO);
314 assert (n_bytes >= 0);
315 if (n_bytes > 0 && fwrite (buffer, 1, n_bytes, stdout) == 0)
316 error (EXIT_FAILURE, errno, _("write error"));
320 close_fd (int fd, const char *filename)
322 if (fd != -1 && fd != STDIN_FILENO && close (fd))
324 error (0, errno, _("closing %s (fd=%d)"), filename, fd);
329 write_header (const char *pretty_filename)
331 static int first_file = 1;
333 printf ("%s==> %s <==\n", (first_file ? "" : "\n"), pretty_filename);
337 /* Read and output N_BYTES of file PRETTY_FILENAME starting at the current
338 position in FD. If N_BYTES is COPY_TO_EOF, then copy until end of file.
339 Return the number of bytes read from the file. */
342 dump_remainder (const char *pretty_filename, int fd, off_t n_bytes)
347 off_t n_remaining = n_bytes;
352 long n = MIN (n_remaining, (off_t) BUFSIZ);
353 bytes_read = safe_read (fd, buffer, n);
356 xwrite (STDOUT_FILENO, buffer, bytes_read);
357 n_remaining -= bytes_read;
358 n_written += bytes_read;
360 if (bytes_read == -1)
361 error (EXIT_FAILURE, errno, "%s", pretty_filename);
366 /* Print the last N_LINES lines from the end of file FD.
367 Go backward through the file, reading `BUFSIZ' bytes at a time (except
368 probably the first), until we hit the start of the file or have
369 read NUMBER newlines.
370 FILE_LENGTH is the length of the file (one more than the offset of the
371 last byte of the file).
372 Return 0 if successful, 1 if an error occurred. */
375 file_lines (const char *pretty_filename, int fd, long int n_lines,
380 int i; /* Index into `buffer' for scanning. */
381 off_t pos = file_length;
386 /* Set `bytes_read' to the size of the last, probably partial, buffer;
387 0 < `bytes_read' <= `BUFSIZ'. */
388 bytes_read = pos % BUFSIZ;
391 /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
392 reads will be on block boundaries, which might increase efficiency. */
394 /* FIXME: check lseek return value */
395 lseek (fd, pos, SEEK_SET);
396 bytes_read = safe_read (fd, buffer, bytes_read);
397 if (bytes_read == -1)
399 error (0, errno, "%s", pretty_filename);
403 /* Count the incomplete line on files that don't end with a newline. */
404 if (bytes_read && buffer[bytes_read - 1] != '\n')
409 /* Scan backward, counting the newlines in this bufferfull. */
410 for (i = bytes_read - 1; i >= 0; i--)
412 /* Have we counted the requested number of newlines yet? */
413 if (buffer[i] == '\n' && n_lines-- == 0)
415 /* If this newline wasn't the last character in the buffer,
416 print the text after it. */
417 if (i != bytes_read - 1)
418 xwrite (STDOUT_FILENO, &buffer[i + 1], bytes_read - (i + 1));
419 dump_remainder (pretty_filename, fd,
420 file_length - (pos + bytes_read));
424 /* Not enough newlines in that bufferfull. */
427 /* Not enough lines in the file; print the entire file. */
428 /* FIXME: check lseek return value */
429 lseek (fd, (off_t) 0, SEEK_SET);
430 dump_remainder (pretty_filename, fd, file_length);
434 /* FIXME: check lseek return value */
435 lseek (fd, pos, SEEK_SET);
437 while ((bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0);
439 if (bytes_read == -1)
441 error (0, errno, "%s", pretty_filename);
448 /* Print the last N_LINES lines from the end of the standard input,
449 open for reading as pipe FD.
450 Buffer the text as a linked list of LBUFFERs, adding them as needed.
451 Return 0 if successful, 1 if an error occured. */
454 pipe_lines (const char *pretty_filename, int fd, long int n_lines)
460 struct linebuffer *next;
462 typedef struct linebuffer LBUFFER;
463 LBUFFER *first, *last, *tmp;
464 int i; /* Index into buffers. */
465 int total_lines = 0; /* Total number of newlines in all buffers. */
467 int nbytes; /* Size of most recent read */
469 first = last = (LBUFFER *) xmalloc (sizeof (LBUFFER));
470 first->nbytes = first->nlines = 0;
472 tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
474 /* Input is always read into a fresh buffer. */
475 while ((nbytes = tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0)
480 /* Count the number of newlines just read. */
481 for (i = 0; i < tmp->nbytes; i++)
482 if (tmp->buffer[i] == '\n')
484 total_lines += tmp->nlines;
486 /* If there is enough room in the last buffer read, just append the new
487 one to it. This is because when reading from a pipe, `nbytes' can
488 often be very small. */
489 if (tmp->nbytes + last->nbytes < BUFSIZ)
491 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
492 last->nbytes += tmp->nbytes;
493 last->nlines += tmp->nlines;
497 /* If there's not enough room, link the new buffer onto the end of
498 the list, then either free up the oldest buffer for the next
499 read if that would leave enough lines, or else malloc a new one.
500 Some compaction mechanism is possible but probably not
502 last = last->next = tmp;
503 if (total_lines - first->nlines > n_lines)
506 total_lines -= first->nlines;
510 tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
518 error (0, errno, "%s", pretty_filename);
523 /* If the file is empty, then bail out. */
524 if (last->nbytes == 0)
527 /* This prevents a core dump when the pipe contains no newlines. */
531 /* Count the incomplete line on files that don't end with a newline. */
532 if (last->buffer[last->nbytes - 1] != '\n')
538 /* Run through the list, printing lines. First, skip over unneeded
540 for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
541 total_lines -= tmp->nlines;
543 /* Find the correct beginning, then print the rest of the file. */
544 if (total_lines > n_lines)
548 /* Skip `total_lines' - `n_lines' newlines. We made sure that
549 `total_lines' - `n_lines' <= `tmp->nlines'. */
551 for (i = total_lines - n_lines; i; --i)
552 while (*cp++ != '\n')
554 i = cp - tmp->buffer;
558 xwrite (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
560 for (tmp = tmp->next; tmp; tmp = tmp->next)
561 xwrite (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
567 free ((char *) first);
573 /* Print the last N_BYTES characters from the end of pipe FD.
574 This is a stripped down version of pipe_lines.
575 Return 0 if successful, 1 if an error occurred. */
578 pipe_bytes (const char *pretty_filename, int fd, off_t n_bytes)
584 struct charbuffer *next;
586 typedef struct charbuffer CBUFFER;
587 CBUFFER *first, *last, *tmp;
588 int i; /* Index into buffers. */
589 int total_bytes = 0; /* Total characters in all buffers. */
592 first = last = (CBUFFER *) xmalloc (sizeof (CBUFFER));
595 tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
597 /* Input is always read into a fresh buffer. */
598 while ((tmp->nbytes = safe_read (fd, tmp->buffer, BUFSIZ)) > 0)
602 total_bytes += tmp->nbytes;
603 /* If there is enough room in the last buffer read, just append the new
604 one to it. This is because when reading from a pipe, `nbytes' can
605 often be very small. */
606 if (tmp->nbytes + last->nbytes < BUFSIZ)
608 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
609 last->nbytes += tmp->nbytes;
613 /* If there's not enough room, link the new buffer onto the end of
614 the list, then either free up the oldest buffer for the next
615 read if that would leave enough characters, or else malloc a new
616 one. Some compaction mechanism is possible but probably not
618 last = last->next = tmp;
619 if (total_bytes - first->nbytes > n_bytes)
622 total_bytes -= first->nbytes;
627 tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
631 if (tmp->nbytes == -1)
633 error (0, errno, "%s", pretty_filename);
641 /* Run through the list, printing characters. First, skip over unneeded
643 for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next)
644 total_bytes -= tmp->nbytes;
646 /* Find the correct beginning, then print the rest of the file.
647 We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'. */
648 if (total_bytes > n_bytes)
649 i = total_bytes - n_bytes;
652 xwrite (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
654 for (tmp = tmp->next; tmp; tmp = tmp->next)
655 xwrite (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
661 free ((char *) first);
667 /* Skip N_BYTES characters from the start of pipe FD, and print
668 any extra characters that were read beyond that.
669 Return 1 on error, 0 if ok. */
672 start_bytes (const char *pretty_filename, int fd, off_t n_bytes)
677 while (n_bytes > 0 && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0)
678 n_bytes -= bytes_read;
679 if (bytes_read == -1)
681 error (0, errno, "%s", pretty_filename);
684 else if (n_bytes < 0)
685 xwrite (STDOUT_FILENO, &buffer[bytes_read + n_bytes], -n_bytes);
689 /* Skip N_LINES lines at the start of file or pipe FD, and print
690 any extra characters that were read beyond that.
691 Return 1 on error, 0 if ok. */
694 start_lines (const char *pretty_filename, int fd, long int n_lines)
698 int bytes_to_skip = 0;
700 while (n_lines && (bytes_read = safe_read (fd, buffer, BUFSIZ)) > 0)
703 while (bytes_to_skip < bytes_read)
704 if (buffer[bytes_to_skip++] == '\n' && --n_lines == 0)
707 if (bytes_read == -1)
709 error (0, errno, "%s", pretty_filename);
712 else if (bytes_to_skip < bytes_read)
714 xwrite (STDOUT_FILENO, &buffer[bytes_to_skip],
715 bytes_read - bytes_to_skip);
720 /* FIXME: describe */
723 recheck (struct File_spec *f)
725 /* open/fstat the file and announce if dev/ino have changed */
726 struct stat new_stats;
729 int is_stdin = (STREQ (f->name, "-"));
730 int was_tailable = f->tailable;
731 int prev_errnum = f->errnum;
734 assert (valid_file_spec (f));
736 fd = (is_stdin ? STDIN_FILENO : open (f->name, O_RDONLY));
738 /* If the open fails because the file doesn't exist,
739 then mark the file as not tailable. */
740 f->tailable = !(reopen_inaccessible_files && fd == -1);
742 if (fd == -1 || fstat (fd, &new_stats) < 0)
750 /* FIXME-maybe: detect the case in which the file first becomes
751 unreadable (perms), and later becomes readable again and can
752 be seen to be the same file (dev/ino). Otherwise, tail prints
753 the entire contents of the file when it becomes readable. */
754 error (0, f->errnum, _("`%s' has become inaccessible"),
759 /* say nothing... it's still not tailable */
762 else if (prev_errnum != errno)
764 error (0, errno, "%s", pretty_name (f));
767 else if (!IS_TAILABLE_FILE_TYPE (new_stats.st_mode))
771 error (0, 0, _("`%s' has been replaced with an untailable file;\
772 giving up on this name"),
784 close_fd (fd, pretty_name (f));
785 close_fd (f->fd, pretty_name (f));
788 else if (prev_errnum && prev_errnum != ENOENT)
791 assert (f->fd == -1);
792 error (0, 0, _("`%s' has become accessible"), pretty_name (f));
794 else if (f->ino != new_stats.st_ino || f->dev != new_stats.st_dev)
800 _("`%s' has appeared; following end of new file"),
805 /* Close the old one. */
806 close_fd (f->fd, pretty_name (f));
808 /* File has been replaced (e.g., via log rotation) --
811 _("`%s' has been replaced; following end of new file"),
819 /* This happens when one iteration finds the file missing,
820 then the preceding <dev,inode> pair is reused as the
821 file is recreated. */
826 close_fd (fd, pretty_name (f));
832 /* Record new file info in f. */
834 f->size = 0; /* Start at the beginning of the file... */
835 f->dev = new_stats.st_dev;
836 f->ino = new_stats.st_ino;
837 f->n_unchanged_stats = 0;
838 f->n_consecutive_size_changes = 0;
840 /* FIXME: check lseek return value */
841 lseek (f->fd, f->size, SEEK_SET);
845 /* FIXME: describe */
848 n_live_files (const struct File_spec *f, int n_files)
851 unsigned int n_live = 0;
853 for (i = 0; i < n_files; i++)
861 /* Tail NFILES files forever, or until killed.
862 The pertinent information for each file is stored in an entry of F.
863 Loop over each of them, doing an fstat to see if they have changed size,
864 and an occasional open/fstat to see if any dev/ino pair has changed.
865 If none of them have changed size in one iteration, sleep for a
866 while and try again. Continue until the user interrupts us. */
869 tail_forever (struct File_spec *f, int nfiles)
872 int writer_is_dead = 0;
882 for (i = 0; i < nfiles; i++)
895 if (fstat (f[i].fd, &stats) < 0)
899 error (0, errno, "%s", pretty_name (&f[i]));
903 if (stats.st_size == f[i].size)
905 f[i].n_consecutive_size_changes = 0;
906 if (++f[i].n_unchanged_stats > max_n_unchanged_stats_between_opens
907 && follow_mode == Follow_name)
910 f[i].n_unchanged_stats = 0;
916 ++f[i].n_consecutive_size_changes;
918 /* Ensure that a file that's unlinked or moved aside, yet always
919 growing will be recognized as having been renamed. */
920 if (follow_mode == Follow_name
921 && (f[i].n_consecutive_size_changes
922 > max_n_consecutive_size_changes_between_opens))
924 f[i].n_consecutive_size_changes = 0;
929 /* This file has changed size. Print out what we can, and
930 then keep looping. */
935 f[i].n_unchanged_stats = 0;
937 if (stats.st_size < f[i].size)
939 error (0, 0, _("%s: file truncated"), pretty_name (&f[i]));
941 /* FIXME: check lseek return value */
942 lseek (f[i].fd, stats.st_size, SEEK_SET);
943 f[i].size = stats.st_size;
950 write_header (pretty_name (&f[i]));
953 f[i].size += dump_remainder (pretty_name (&f[i]), f[i].fd,
957 if (n_live_files (f, nfiles) == 0 && ! reopen_inaccessible_files)
959 error (0, 0, _("no files remaining"));
963 /* If none of the files changed size, sleep. */
968 sleep (sleep_interval);
970 /* Once the writer is dead, read the files once more to
971 avoid a race condition. */
972 writer_is_dead = (pid != 0
973 && kill (pid, 0) != 0
974 /* Handle the case in which you cannot send a
975 signal to the writer, so kill fails and sets
982 /* Output the last N_BYTES bytes of file FILENAME open for reading in FD.
983 Return 0 if successful, 1 if an error occurred. */
986 tail_bytes (const char *pretty_filename, int fd, off_t n_bytes)
990 /* We need binary input, since `tail' relies on `lseek' and byte counts,
991 while binary output will preserve the style (Unix/DOS) of text file. */
992 SET_BINARY2 (fd, STDOUT_FILENO);
994 if (fstat (fd, &stats))
996 error (0, errno, "%s", pretty_filename);
1002 if (S_ISREG (stats.st_mode))
1004 /* FIXME: check lseek return value */
1005 lseek (fd, n_bytes, SEEK_CUR);
1007 else if (start_bytes (pretty_filename, fd, n_bytes))
1011 dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1015 if (S_ISREG (stats.st_mode))
1017 off_t current_pos, end_pos;
1018 size_t bytes_remaining;
1020 if ((current_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1
1021 && (end_pos = lseek (fd, (off_t) 0, SEEK_END)) != -1)
1024 /* Be careful here. The current position may actually be
1025 beyond the end of the file. */
1026 bytes_remaining = (diff = end_pos - current_pos) < 0 ? 0 : diff;
1030 error (0, errno, "%s", pretty_filename);
1034 if (bytes_remaining <= n_bytes)
1036 /* From the current position to end of file, there are no
1037 more bytes than have been requested. So reposition the
1038 file pointer to the incoming current position and print
1039 everything after that. */
1040 /* FIXME: check lseek return value */
1041 lseek (fd, current_pos, SEEK_SET);
1045 /* There are more bytes remaining than were requested.
1047 /* FIXME: check lseek return value */
1048 lseek (fd, -n_bytes, SEEK_END);
1050 dump_remainder (pretty_filename, fd, n_bytes);
1053 return pipe_bytes (pretty_filename, fd, n_bytes);
1058 /* Output the last N_LINES lines of file FILENAME open for reading in FD.
1059 Return 0 if successful, 1 if an error occurred. */
1062 tail_lines (const char *pretty_filename, int fd, long int n_lines)
1067 /* We need binary input, since `tail' relies on `lseek' and byte counts,
1068 while binary output will preserve the style (Unix/DOS) of text file. */
1069 SET_BINARY2 (fd, STDOUT_FILENO);
1071 if (fstat (fd, &stats))
1073 error (0, errno, "%s", pretty_filename);
1079 if (start_lines (pretty_filename, fd, n_lines))
1081 dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1085 /* Use file_lines only if FD refers to a regular file with
1086 its file pointer positioned at beginning of file. */
1087 /* FIXME: adding the lseek conjunct is a kludge.
1088 Once there's a reasonable test suite, fix the true culprit:
1089 file_lines. file_lines shouldn't presume that the input
1090 file pointer is initially positioned to beginning of file. */
1091 if (S_ISREG (stats.st_mode)
1092 && lseek (fd, (off_t) 0, SEEK_CUR) == (off_t) 0)
1094 length = lseek (fd, (off_t) 0, SEEK_END);
1095 if (length != 0 && file_lines (pretty_filename, fd, n_lines, length))
1099 return pipe_lines (pretty_filename, fd, n_lines);
1104 /* Display the last N_UNITS units of file FILENAME, open for reading
1106 Return 0 if successful, 1 if an error occurred. */
1109 tail (const char *pretty_filename, int fd, off_t n_units)
1112 return tail_lines (pretty_filename, fd, (long) n_units);
1114 return tail_bytes (pretty_filename, fd, n_units);
1117 /* Display the last N_UNITS units of the file described by F.
1118 Return 0 if successful, 1 if an error occurred. */
1121 tail_file (struct File_spec *f, off_t n_units)
1126 int is_stdin = (STREQ (f->name, "-"));
1130 have_read_stdin = 1;
1135 fd = open (f->name, O_RDONLY);
1138 f->tailable = !(reopen_inaccessible_files && fd == -1);
1150 error (0, errno, "%s", pretty_name (f));
1156 write_header (pretty_name (f));
1157 errors = tail (pretty_name (f), fd, n_units);
1161 /* FIXME: duplicate code */
1162 if (fstat (fd, &stats) < 0)
1166 error (0, errno, "%s", pretty_name (f));
1168 else if (!IS_TAILABLE_FILE_TYPE (stats.st_mode))
1170 error (0, 0, _("%s: cannot follow end of this type of file;\
1171 giving up on this name"),
1180 close_fd (fd, pretty_name (f));
1186 f->size = stats.st_size;
1187 f->dev = stats.st_dev;
1188 f->ino = stats.st_ino;
1189 f->n_unchanged_stats = 0;
1190 f->n_consecutive_size_changes = 0;
1196 if (!is_stdin && close (fd))
1198 error (0, errno, "%s", pretty_name (f));
1207 /* If the command line arguments are of the obsolescent form and the
1208 option string is well-formed, set *FAIL to zero, set *N_UNITS, the
1209 globals COUNT_LINES, FOREVER, and FROM_START, and return non-zero.
1210 Otherwise, if the command line arguments appear to be of the
1211 obsolescent form but the option string is malformed, set *FAIL to
1212 non-zero, don't modify any other parameter or global variable, and
1213 return non-zero. Otherwise, return zero and don't modify any parameter
1214 or global variable. */
1217 parse_obsolescent_option (int argc, const char *const *argv,
1218 off_t *n_units, int *fail)
1220 const char *p = argv[1];
1221 const char *n_string = NULL;
1222 const char *n_string_end;
1228 /* With the obsolescent form, there is one option string and
1229 (technically) at most one file argument. But we allow two or more
1234 /* If P starts with `+', `-N' (where N is a digit), or `-l',
1235 then it is obsolescent. Return zero otherwise. */
1236 if ( ! (p[0] == '+' || (p[0] == '-' && (p[1] == 'l' || ISDIGIT (p[1])))) )
1254 while (ISDIGIT (*p));
1259 if (*p == 'c' || *p == 'b')
1278 /* If (argv[1] begins with a `+' or if it begins with `-' followed
1279 by a digit), but has an invalid suffix character, give a diagnostic
1280 and indicate to caller that this *is* of the obsolescent form,
1281 but that it's an invalid option. */
1282 if (t_from_start || n_string)
1285 _("%c: invalid suffix character in obsolescent option" ), *p);
1290 /* Otherwise, it might be a valid non-obsolescent option like -n. */
1295 if (n_string == NULL)
1296 *n_units = DEFAULT_N_LINES;
1300 unsigned long int tmp_ulong;
1303 s_err = xstrtoul (n_string, &end, 10, &tmp_ulong,
1304 *n_string_end == 'b' ? "b" : NULL);
1305 if (s_err == LONGINT_OK && tmp_ulong <= OFF_T_MAX)
1306 *n_units = (off_t) tmp_ulong;
1309 /* Extract a NUL-terminated string for the error message. */
1310 size_t len = n_string_end - n_string;
1311 char *n_string_tmp = xmalloc (len + 1);
1313 strncpy (n_string_tmp, n_string, len);
1314 n_string_tmp[len] = '\0';
1317 _("%s: %s is so large that it is not representable"),
1318 n_string_tmp, (t_count_lines
1319 ? _("number of lines")
1320 : _("number of bytes")));
1321 free (n_string_tmp);
1330 int posix_pedantic = (getenv ("POSIXLY_CORRECT") != NULL);
1332 /* When POSIXLY_CORRECT is set, enforce the `at most one
1333 file argument' requirement. */
1337 too many arguments; When using tail's obsolescent option syntax (%s)\n\
1338 there may be no more than one file argument. Use the equivalent -n or -c\n\
1339 option instead."), argv[1]);
1344 #if DISABLED /* FIXME: enable or remove this warning. */
1346 Warning: it is not portable to use two or more file arguments with\n\
1347 tail's obsolescent option syntax (%s). Use the equivalent -n or -c\n\
1348 option instead."), argv[1]);
1353 from_start = t_from_start;
1354 count_lines = t_count_lines;
1355 forever = t_forever;
1362 parse_options (int argc, char **argv,
1363 off_t *n_units, enum header_mode *header_mode)
1368 forever = from_start = print_headers = 0;
1370 while ((c = getopt_long (argc, argv, "c:n:fFqs:v", long_options, NULL))
1380 follow_mode = Follow_name;
1381 reopen_inaccessible_files = 1;
1386 count_lines = (c == 'n');
1389 else if (*optarg == '-')
1395 s_err = xstrtoumax (optarg, NULL, 10, &n, "bkm");
1396 if (s_err == LONGINT_INVALID)
1398 error (EXIT_FAILURE, 0, "%s: %s", optarg,
1400 ? _("invalid number of lines")
1401 : _("invalid number of bytes")));
1404 if (s_err != LONGINT_OK)
1405 error (EXIT_FAILURE, 0,
1406 _("%s: is so large that it is not representable"), optarg);
1409 error (EXIT_FAILURE, 0,
1410 _("%s is larger than the maximum file size on this system"),
1412 *n_units = (off_t) n;
1417 case LONG_FOLLOW_OPTION:
1420 follow_mode = DEFAULT_FOLLOW_MODE;
1422 follow_mode = XARGMATCH ("--follow", optarg,
1423 follow_mode_string, follow_mode_map);
1427 reopen_inaccessible_files = 1;
1430 case MAX_UNCHANGED_STATS_OPTION:
1431 /* --max-unchanged-stats=N */
1432 if (xstrtoul (optarg, NULL, 10,
1433 &max_n_unchanged_stats_between_opens, "") != LONGINT_OK)
1435 error (EXIT_FAILURE, 0,
1436 _("%s: invalid maximum number of unchanged stats between opens"),
1441 case MAX_CONSECUTIVE_SIZE_CHANGES_OPTION:
1442 /* --max-consecutive-size-changes=N */
1443 if (xstrtoul (optarg, NULL, 10,
1444 &max_n_consecutive_size_changes_between_opens, "")
1447 error (EXIT_FAILURE, 0,
1448 _("%s: invalid maximum number of consecutive size changes"),
1456 unsigned long int tmp_ulong;
1457 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1458 if (s_err != LONGINT_OK || tmp_ulong > PID_T_MAX)
1460 error (EXIT_FAILURE, 0, _("%s: invalid PID"), optarg);
1467 *header_mode = never;
1473 unsigned long int tmp_ulong;
1474 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1475 if (s_err != LONGINT_OK || tmp_ulong > UINT_MAX)
1477 error (EXIT_FAILURE, 0,
1478 _("%s: invalid number of seconds"), optarg);
1480 sleep_interval = tmp_ulong;
1485 *header_mode = always;
1488 case_GETOPT_HELP_CHAR;
1490 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1497 if (reopen_inaccessible_files && follow_mode != Follow_name)
1498 error (0, 0, _("warning: --retry is useful only when following by name"));
1500 if (pid && !forever)
1502 _("warning: PID ignored; --pid=PID is useful only when following"));
1503 else if (pid && kill (pid, 0) != 0 && errno == ENOSYS)
1505 error (0, 0, _("warning: --pid=PID is not supported on this system"));
1511 main (int argc, char **argv)
1513 enum header_mode header_mode = multiple_files;
1514 int exit_status = 0;
1515 /* If from_start, the number of items to skip before printing; otherwise,
1516 the number of items at the end of the file to print. Although the type
1517 is signed, the value is never negative. */
1518 off_t n_units = DEFAULT_N_LINES;
1521 struct File_spec *F;
1524 program_name = argv[0];
1525 setlocale (LC_ALL, "");
1526 bindtextdomain (PACKAGE, LOCALEDIR);
1527 textdomain (PACKAGE);
1529 atexit (close_stdout);
1531 have_read_stdin = 0;
1534 int found_obsolescent;
1536 found_obsolescent = parse_obsolescent_option (argc,
1537 (const char *const *) argv,
1539 if (found_obsolescent)
1542 exit (EXIT_FAILURE);
1547 parse_options (argc, argv, &n_units, &header_mode);
1551 /* To start printing with item N_UNITS from the start of the file, skip
1552 N_UNITS - 1 items. `tail +0' is actually meaningless, but for Unix
1553 compatibility it's treated the same as `tail +1'. */
1560 n_files = argc - optind;
1561 file = argv + optind;
1565 static char *dummy_stdin = "-";
1567 file = &dummy_stdin;
1570 F = (struct File_spec *) xmalloc (n_files * sizeof (F[0]));
1571 for (i = 0; i < n_files; i++)
1572 F[i].name = file[i];
1574 if (header_mode == always
1575 || (header_mode == multiple_files && n_files > 1))
1578 for (i = 0; i < n_files; i++)
1579 exit_status |= tail_file (&F[i], n_units);
1583 /* This fflush appears to be required only on Solaris2.7. */
1584 if (fflush (stdout) < 0)
1585 error (EXIT_FAILURE, errno, _("write error"));
1587 SETVBUF (stdout, NULL, _IONBF, 0);
1588 tail_forever (F, n_files);
1591 if (have_read_stdin && close (0) < 0)
1592 error (EXIT_FAILURE, errno, "-");
1593 exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);