1 /* tail -- output the last part of file(s)
2 Copyright (C) 1989, 90, 91, 1995-2006, 2008 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 3 of the License, or
7 (at your option) any later version.
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, see <http://www.gnu.org/licenses/>. */
17 /* Can display any amount of data, unlike the Unix version, which uses
18 a fixed size buffer and therefore can only deliver a limited number
21 Original version by Paul Rubin <phr@ocf.berkeley.edu>.
22 Extensions by David MacKenzie <djm@gnu.ai.mit.edu>.
23 tail -f for multiple files by Ian Lance Taylor <ian@airs.com>. */
30 #include <sys/types.h>
41 #include "safe-read.h"
42 #include "stat-time.h"
43 #include "xnanosleep.h"
47 /* The official name of this program (e.g., no `g' prefix). */
48 #define PROGRAM_NAME "tail"
51 proper_name ("Paul Rubin"), \
52 proper_name ("David MacKenzie"), \
53 proper_name ("Ian Lance Taylor"), \
54 proper_name ("Jim Meyering")
56 /* Number of items to tail. */
57 #define DEFAULT_N_LINES 10
59 /* Special values for dump_remainder's N_BYTES parameter. */
60 #define COPY_TO_EOF UINTMAX_MAX
61 #define COPY_A_BUFFER (UINTMAX_MAX - 1)
63 /* FIXME: make Follow_name the default? */
64 #define DEFAULT_FOLLOW_MODE Follow_descriptor
68 /* Follow the name of each file: if the file is renamed, try to reopen
69 that name and track the end of the new file if/when it's recreated.
70 This is useful for tracking logs that are occasionally rotated. */
73 /* Follow each descriptor obtained upon opening a file.
74 That means we'll continue to follow the end of a file even after
75 it has been renamed or unlinked. */
79 /* The types of files for which tail works. */
80 #define IS_TAILABLE_FILE_TYPE(Mode) \
81 (S_ISREG (Mode) || S_ISFIFO (Mode) || S_ISSOCK (Mode) || S_ISCHR (Mode))
83 static char const *const follow_mode_string[] =
85 "descriptor", "name", NULL
88 static enum Follow_mode const follow_mode_map[] =
90 Follow_descriptor, Follow_name,
95 /* The actual file name, or "-" for stdin. */
98 /* File descriptor on which the file is open; -1 if it's not open. */
101 /* Attributes of the file the last time we checked. */
103 struct timespec mtime;
108 /* 1 if O_NONBLOCK is clear, 0 if set, -1 if not known. */
111 /* The specified name initially referred to a directory or some other
112 type for which tail isn't meaningful. Unlike for a permission problem
113 (tailable, below) once this is set, the name is not checked ever again. */
116 /* See description of DEFAULT_MAX_N_... below. */
117 uintmax_t n_unchanged_stats;
119 /* A file is tailable if it exists, is readable, and is of type
120 IS_TAILABLE_FILE_TYPE. */
123 /* The value of errno seen last time we checked this file. */
128 /* Keep trying to open a file even if it is inaccessible when tail starts
129 or if it becomes inaccessible later -- useful only with -f. */
130 static bool reopen_inaccessible_files;
132 /* If true, interpret the numeric argument as the number of lines.
133 Otherwise, interpret it as the number of bytes. */
134 static bool count_lines;
136 /* Whether we follow the name of each file or the file descriptor
137 that is initially associated with each name. */
138 static enum Follow_mode follow_mode = Follow_descriptor;
140 /* If true, read from the ends of all specified files until killed. */
143 /* If true, count from start of file instead of end. */
144 static bool from_start;
146 /* If true, print filename headers. */
147 static bool print_headers;
149 /* When to print the filename banners. */
152 multiple_files, always, never
155 /* When tailing a file by name, if there have been this many consecutive
156 iterations for which the file has not changed, then open/fstat
157 the file to determine if that file name is still associated with the
158 same device/inode-number pair as before. This option is meaningful only
159 when following by name. --max-unchanged-stats=N */
160 #define DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS 5
161 static uintmax_t max_n_unchanged_stats_between_opens =
162 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS;
164 /* The process ID of the process (presumably on the current host)
165 that is writing to all followed files. */
168 /* True if we have ever read standard input. */
169 static bool have_read_stdin;
171 /* If nonzero, skip the is-regular-file test used to determine whether
172 to use the lseek optimization. Instead, use the more general (and
173 more expensive) code unconditionally. Intended solely for testing. */
174 static bool presume_input_pipe;
176 /* For long options that have no equivalent short option, use a
177 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
180 RETRY_OPTION = CHAR_MAX + 1,
181 MAX_UNCHANGED_STATS_OPTION,
183 PRESUME_INPUT_PIPE_OPTION,
187 static struct option const long_options[] =
189 {"bytes", required_argument, NULL, 'c'},
190 {"follow", optional_argument, NULL, LONG_FOLLOW_OPTION},
191 {"lines", required_argument, NULL, 'n'},
192 {"max-unchanged-stats", required_argument, NULL, MAX_UNCHANGED_STATS_OPTION},
193 {"pid", required_argument, NULL, PID_OPTION},
194 {"-presume-input-pipe", no_argument, NULL,
195 PRESUME_INPUT_PIPE_OPTION}, /* do not document */
196 {"quiet", no_argument, NULL, 'q'},
197 {"retry", no_argument, NULL, RETRY_OPTION},
198 {"silent", no_argument, NULL, 'q'},
199 {"sleep-interval", required_argument, NULL, 's'},
200 {"verbose", no_argument, NULL, 'v'},
201 {GETOPT_HELP_OPTION_DECL},
202 {GETOPT_VERSION_OPTION_DECL},
209 if (status != EXIT_SUCCESS)
210 fprintf (stderr, _("Try `%s --help' for more information.\n"),
215 Usage: %s [OPTION]... [FILE]...\n\
219 Print the last %d lines of each FILE to standard output.\n\
220 With more than one FILE, precede each with a header giving the file name.\n\
221 With no FILE, or when FILE is -, read standard input.\n\
223 "), DEFAULT_N_LINES);
225 Mandatory arguments to long options are mandatory for short options too.\n\
228 --retry keep trying to open a file even if it is\n\
229 inaccessible when tail starts or if it becomes\n\
230 inaccessible later; useful when following by name,\n\
231 i.e., with --follow=name\n\
232 -c, --bytes=N output the last N bytes; alternatively, use +N to\n\
233 output bytes starting with the Nth of each file\n\
236 -f, --follow[={name|descriptor}]\n\
237 output appended data as the file grows;\n\
238 -f, --follow, and --follow=descriptor are\n\
240 -F same as --follow=name --retry\n\
243 -n, --lines=N output the last N lines, instead of the last %d;\n\
244 or use +N to output lines starting with the Nth\n\
245 --max-unchanged-stats=N\n\
246 with --follow=name, reopen a FILE which has not\n\
247 changed size after N (default %d) iterations\n\
248 to see if it has been unlinked or renamed\n\
249 (this is the usual case of rotated log files)\n\
252 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS
255 --pid=PID with -f, terminate after process ID, PID dies\n\
256 -q, --quiet, --silent never output headers giving file names\n\
257 -s, --sleep-interval=S with -f, sleep for approximately S seconds\n\
258 (default 1.0) between iterations.\n\
259 -v, --verbose always output headers giving file names\n\
261 fputs (HELP_OPTION_DESCRIPTION, stdout);
262 fputs (VERSION_OPTION_DESCRIPTION, stdout);
265 If the first character of N (the number of bytes or lines) is a `+',\n\
266 print beginning with the Nth item from the start of each file, otherwise,\n\
267 print the last N items in the file. N may have a multiplier suffix:\n\
268 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
269 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
273 With --follow (-f), tail defaults to following the file descriptor, which\n\
274 means that even if a tail'ed file is renamed, tail will continue to track\n\
278 This default behavior is not desirable when you really want to\n\
279 track the actual name of the file, not the file descriptor (e.g., log\n\
280 rotation). Use --follow=name in that case. That causes tail to track the\n\
281 named file by reopening it periodically to see if it has been removed and\n\
282 recreated by some other program.\n\
284 emit_bug_reporting_address ();
290 valid_file_spec (struct File_spec const *f)
292 /* Exactly one of the following subexpressions must be true. */
293 return ((f->fd == -1) ^ (f->errnum == 0));
297 pretty_name (struct File_spec const *f)
299 return (STREQ (f->name, "-") ? "standard input" : f->name);
303 xwrite_stdout (char const *buffer, size_t n_bytes)
305 if (n_bytes > 0 && fwrite (buffer, 1, n_bytes, stdout) == 0)
306 error (EXIT_FAILURE, errno, _("write error"));
309 /* Record a file F with descriptor FD, size SIZE, status ST, and
310 blocking status BLOCKING. */
313 record_open_fd (struct File_spec *f, int fd,
314 off_t size, struct stat const *st,
319 f->mtime = get_stat_mtime (st);
322 f->mode = st->st_mode;
323 f->blocking = blocking;
324 f->n_unchanged_stats = 0;
328 /* Close the file with descriptor FD and name FILENAME. */
331 close_fd (int fd, const char *filename)
333 if (fd != -1 && fd != STDIN_FILENO && close (fd))
335 error (0, errno, _("closing %s (fd=%d)"), filename, fd);
340 write_header (const char *pretty_filename)
342 static bool first_file = true;
344 printf ("%s==> %s <==\n", (first_file ? "" : "\n"), pretty_filename);
348 /* Read and output N_BYTES of file PRETTY_FILENAME starting at the current
349 position in FD. If N_BYTES is COPY_TO_EOF, then copy until end of file.
350 If N_BYTES is COPY_A_BUFFER, then copy at most one buffer's worth.
351 Return the number of bytes read from the file. */
354 dump_remainder (const char *pretty_filename, int fd, uintmax_t n_bytes)
357 uintmax_t n_remaining = n_bytes;
363 size_t n = MIN (n_remaining, BUFSIZ);
364 size_t bytes_read = safe_read (fd, buffer, n);
365 if (bytes_read == SAFE_READ_ERROR)
368 error (EXIT_FAILURE, errno, _("error reading %s"),
369 quote (pretty_filename));
374 xwrite_stdout (buffer, bytes_read);
375 n_written += bytes_read;
376 if (n_bytes != COPY_TO_EOF)
378 n_remaining -= bytes_read;
379 if (n_remaining == 0 || n_bytes == COPY_A_BUFFER)
387 /* Call lseek with the specified arguments, where file descriptor FD
388 corresponds to the file, FILENAME.
389 Give a diagnostic and exit nonzero if lseek fails.
390 Otherwise, return the resulting offset. */
393 xlseek (int fd, off_t offset, int whence, char const *filename)
395 off_t new_offset = lseek (fd, offset, whence);
396 char buf[INT_BUFSIZE_BOUND (off_t)];
402 s = offtostr (offset, buf);
406 error (0, errno, _("%s: cannot seek to offset %s"),
410 error (0, errno, _("%s: cannot seek to relative offset %s"),
414 error (0, errno, _("%s: cannot seek to end-relative offset %s"),
424 /* Print the last N_LINES lines from the end of file FD.
425 Go backward through the file, reading `BUFSIZ' bytes at a time (except
426 probably the first), until we hit the start of the file or have
427 read NUMBER newlines.
428 START_POS is the starting position of the read pointer for the file
429 associated with FD (may be nonzero).
430 END_POS is the file offset of EOF (one larger than offset of last byte).
431 Return true if successful. */
434 file_lines (const char *pretty_filename, int fd, uintmax_t n_lines,
435 off_t start_pos, off_t end_pos, uintmax_t *read_pos)
444 /* Set `bytes_read' to the size of the last, probably partial, buffer;
445 0 < `bytes_read' <= `BUFSIZ'. */
446 bytes_read = (pos - start_pos) % BUFSIZ;
449 /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
450 reads will be on block boundaries, which might increase efficiency. */
452 xlseek (fd, pos, SEEK_SET, pretty_filename);
453 bytes_read = safe_read (fd, buffer, bytes_read);
454 if (bytes_read == SAFE_READ_ERROR)
456 error (0, errno, _("error reading %s"), quote (pretty_filename));
459 *read_pos = pos + bytes_read;
461 /* Count the incomplete line on files that don't end with a newline. */
462 if (bytes_read && buffer[bytes_read - 1] != '\n')
467 /* Scan backward, counting the newlines in this bufferfull. */
469 size_t n = bytes_read;
473 nl = memrchr (buffer, '\n', n);
479 /* If this newline isn't the last character in the buffer,
480 output the part that is after it. */
481 if (n != bytes_read - 1)
482 xwrite_stdout (nl + 1, bytes_read - (n + 1));
483 *read_pos += dump_remainder (pretty_filename, fd,
484 end_pos - (pos + bytes_read));
489 /* Not enough newlines in that bufferfull. */
490 if (pos == start_pos)
492 /* Not enough lines in the file; print everything from
493 start_pos to the end. */
494 xlseek (fd, start_pos, SEEK_SET, pretty_filename);
495 *read_pos = start_pos + dump_remainder (pretty_filename, fd,
500 xlseek (fd, pos, SEEK_SET, pretty_filename);
502 bytes_read = safe_read (fd, buffer, BUFSIZ);
503 if (bytes_read == SAFE_READ_ERROR)
505 error (0, errno, _("error reading %s"), quote (pretty_filename));
509 *read_pos = pos + bytes_read;
511 while (bytes_read > 0);
516 /* Print the last N_LINES lines from the end of the standard input,
517 open for reading as pipe FD.
518 Buffer the text as a linked list of LBUFFERs, adding them as needed.
519 Return true if successful. */
522 pipe_lines (const char *pretty_filename, int fd, uintmax_t n_lines,
530 struct linebuffer *next;
532 typedef struct linebuffer LBUFFER;
533 LBUFFER *first, *last, *tmp;
534 size_t total_lines = 0; /* Total number of newlines in all buffers. */
536 size_t n_read; /* Size in bytes of most recent read */
538 first = last = xmalloc (sizeof (LBUFFER));
539 first->nbytes = first->nlines = 0;
541 tmp = xmalloc (sizeof (LBUFFER));
543 /* Input is always read into a fresh buffer. */
546 n_read = safe_read (fd, tmp->buffer, BUFSIZ);
547 if (n_read == 0 || n_read == SAFE_READ_ERROR)
549 tmp->nbytes = n_read;
554 /* Count the number of newlines just read. */
556 char const *buffer_end = tmp->buffer + n_read;
557 char const *p = tmp->buffer;
558 while ((p = memchr (p, '\n', buffer_end - p)))
564 total_lines += tmp->nlines;
566 /* If there is enough room in the last buffer read, just append the new
567 one to it. This is because when reading from a pipe, `n_read' can
568 often be very small. */
569 if (tmp->nbytes + last->nbytes < BUFSIZ)
571 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
572 last->nbytes += tmp->nbytes;
573 last->nlines += tmp->nlines;
577 /* If there's not enough room, link the new buffer onto the end of
578 the list, then either free up the oldest buffer for the next
579 read if that would leave enough lines, or else malloc a new one.
580 Some compaction mechanism is possible but probably not
582 last = last->next = tmp;
583 if (total_lines - first->nlines > n_lines)
586 total_lines -= first->nlines;
590 tmp = xmalloc (sizeof (LBUFFER));
596 if (n_read == SAFE_READ_ERROR)
598 error (0, errno, _("error reading %s"), quote (pretty_filename));
603 /* If the file is empty, then bail out. */
604 if (last->nbytes == 0)
607 /* This prevents a core dump when the pipe contains no newlines. */
611 /* Count the incomplete line on files that don't end with a newline. */
612 if (last->buffer[last->nbytes - 1] != '\n')
618 /* Run through the list, printing lines. First, skip over unneeded
620 for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
621 total_lines -= tmp->nlines;
623 /* Find the correct beginning, then print the rest of the file. */
625 char const *beg = tmp->buffer;
626 char const *buffer_end = tmp->buffer + tmp->nbytes;
627 if (total_lines > n_lines)
629 /* Skip `total_lines' - `n_lines' newlines. We made sure that
630 `total_lines' - `n_lines' <= `tmp->nlines'. */
632 for (j = total_lines - n_lines; j; --j)
634 beg = memchr (beg, '\n', buffer_end - beg);
640 xwrite_stdout (beg, buffer_end - beg);
643 for (tmp = tmp->next; tmp; tmp = tmp->next)
644 xwrite_stdout (tmp->buffer, tmp->nbytes);
656 /* Print the last N_BYTES characters from the end of pipe FD.
657 This is a stripped down version of pipe_lines.
658 Return true if successful. */
661 pipe_bytes (const char *pretty_filename, int fd, uintmax_t n_bytes,
668 struct charbuffer *next;
670 typedef struct charbuffer CBUFFER;
671 CBUFFER *first, *last, *tmp;
672 size_t i; /* Index into buffers. */
673 size_t total_bytes = 0; /* Total characters in all buffers. */
677 first = last = xmalloc (sizeof (CBUFFER));
680 tmp = xmalloc (sizeof (CBUFFER));
682 /* Input is always read into a fresh buffer. */
685 n_read = safe_read (fd, tmp->buffer, BUFSIZ);
686 if (n_read == 0 || n_read == SAFE_READ_ERROR)
689 tmp->nbytes = n_read;
692 total_bytes += tmp->nbytes;
693 /* If there is enough room in the last buffer read, just append the new
694 one to it. This is because when reading from a pipe, `nbytes' can
695 often be very small. */
696 if (tmp->nbytes + last->nbytes < BUFSIZ)
698 memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
699 last->nbytes += tmp->nbytes;
703 /* If there's not enough room, link the new buffer onto the end of
704 the list, then either free up the oldest buffer for the next
705 read if that would leave enough characters, or else malloc a new
706 one. Some compaction mechanism is possible but probably not
708 last = last->next = tmp;
709 if (total_bytes - first->nbytes > n_bytes)
712 total_bytes -= first->nbytes;
717 tmp = xmalloc (sizeof (CBUFFER));
724 if (n_read == SAFE_READ_ERROR)
726 error (0, errno, _("error reading %s"), quote (pretty_filename));
731 /* Run through the list, printing characters. First, skip over unneeded
733 for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next)
734 total_bytes -= tmp->nbytes;
736 /* Find the correct beginning, then print the rest of the file.
737 We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'. */
738 if (total_bytes > n_bytes)
739 i = total_bytes - n_bytes;
742 xwrite_stdout (&tmp->buffer[i], tmp->nbytes - i);
744 for (tmp = tmp->next; tmp; tmp = tmp->next)
745 xwrite_stdout (tmp->buffer, tmp->nbytes);
757 /* Skip N_BYTES characters from the start of pipe FD, and print
758 any extra characters that were read beyond that.
759 Return 1 on error, 0 if ok, -1 if EOF. */
762 start_bytes (const char *pretty_filename, int fd, uintmax_t n_bytes,
769 size_t bytes_read = safe_read (fd, buffer, BUFSIZ);
772 if (bytes_read == SAFE_READ_ERROR)
774 error (0, errno, _("error reading %s"), quote (pretty_filename));
777 read_pos += bytes_read;
778 if (bytes_read <= n_bytes)
779 n_bytes -= bytes_read;
782 size_t n_remaining = bytes_read - n_bytes;
784 xwrite_stdout (&buffer[n_bytes], n_remaining);
792 /* Skip N_LINES lines at the start of file or pipe FD, and print
793 any extra characters that were read beyond that.
794 Return 1 on error, 0 if ok, -1 if EOF. */
797 start_lines (const char *pretty_filename, int fd, uintmax_t n_lines,
807 size_t bytes_read = safe_read (fd, buffer, BUFSIZ);
808 char *buffer_end = buffer + bytes_read;
809 if (bytes_read == 0) /* EOF */
811 if (bytes_read == SAFE_READ_ERROR) /* error */
813 error (0, errno, _("error reading %s"), quote (pretty_filename));
817 *read_pos += bytes_read;
819 while ((p = memchr (p, '\n', buffer_end - p)))
825 xwrite_stdout (p, buffer_end - p);
832 /* FIXME: describe */
835 recheck (struct File_spec *f, bool blocking)
837 /* open/fstat the file and announce if dev/ino have changed */
838 struct stat new_stats;
840 bool is_stdin = (STREQ (f->name, "-"));
841 bool was_tailable = f->tailable;
842 int prev_errnum = f->errnum;
846 : open (f->name, O_RDONLY | (blocking ? 0 : O_NONBLOCK)));
848 assert (valid_file_spec (f));
850 /* If the open fails because the file doesn't exist,
851 then mark the file as not tailable. */
852 f->tailable = !(reopen_inaccessible_files && fd == -1);
854 if (fd == -1 || fstat (fd, &new_stats) < 0)
862 /* FIXME-maybe: detect the case in which the file first becomes
863 unreadable (perms), and later becomes readable again and can
864 be seen to be the same file (dev/ino). Otherwise, tail prints
865 the entire contents of the file when it becomes readable. */
866 error (0, f->errnum, _("%s has become inaccessible"),
867 quote (pretty_name (f)));
871 /* say nothing... it's still not tailable */
874 else if (prev_errnum != errno)
876 error (0, errno, "%s", pretty_name (f));
879 else if (!IS_TAILABLE_FILE_TYPE (new_stats.st_mode))
883 error (0, 0, _("%s has been replaced with an untailable file;\
884 giving up on this name"),
885 quote (pretty_name (f)));
896 close_fd (fd, pretty_name (f));
897 close_fd (f->fd, pretty_name (f));
900 else if (prev_errnum && prev_errnum != ENOENT)
903 assert (f->fd == -1);
904 error (0, 0, _("%s has become accessible"), quote (pretty_name (f)));
906 else if (f->ino != new_stats.st_ino || f->dev != new_stats.st_dev)
912 _("%s has appeared; following end of new file"),
913 quote (pretty_name (f)));
917 /* Close the old one. */
918 close_fd (f->fd, pretty_name (f));
920 /* File has been replaced (e.g., via log rotation) --
923 _("%s has been replaced; following end of new file"),
924 quote (pretty_name (f)));
931 /* This happens when one iteration finds the file missing,
932 then the preceding <dev,inode> pair is reused as the
933 file is recreated. */
938 close_fd (fd, pretty_name (f));
944 /* Start at the beginning of the file. */
945 record_open_fd (f, fd, 0, &new_stats, (is_stdin ? -1 : blocking));
946 xlseek (fd, 0, SEEK_SET, pretty_name (f));
950 /* Return true if any of the N_FILES files in F are live, i.e., have
951 open file descriptors. */
954 any_live_files (const struct File_spec *f, int n_files)
958 for (i = 0; i < n_files; i++)
964 /* Tail NFILES files forever, or until killed.
965 The pertinent information for each file is stored in an entry of F.
966 Loop over each of them, doing an fstat to see if they have changed size,
967 and an occasional open/fstat to see if any dev/ino pair has changed.
968 If none of them have changed size in one iteration, sleep for a
969 while and try again. Continue until the user interrupts us. */
972 tail_forever (struct File_spec *f, int nfiles, double sleep_interval)
974 /* Use blocking I/O as an optimization, when it's easy. */
975 bool blocking = (pid == 0 && follow_mode == Follow_descriptor
976 && nfiles == 1 && ! S_ISREG (f[0].mode));
978 bool writer_is_dead = false;
985 bool any_input = false;
987 for (i = 0; i < nfiles; i++)
993 uintmax_t bytes_read;
1000 recheck (&f[i], blocking);
1005 name = pretty_name (&f[i]);
1008 if (f[i].blocking != blocking)
1010 int old_flags = fcntl (fd, F_GETFL);
1011 int new_flags = old_flags | (blocking ? 0 : O_NONBLOCK);
1013 || (new_flags != old_flags
1014 && fcntl (fd, F_SETFL, new_flags) == -1))
1016 /* Don't update f[i].blocking if fcntl fails. */
1017 if (S_ISREG (f[i].mode) && errno == EPERM)
1019 /* This happens when using tail -f on a file with
1020 the append-only attribute. */
1023 error (EXIT_FAILURE, errno,
1024 _("%s: cannot change nonblocking mode"), name);
1027 f[i].blocking = blocking;
1032 if (fstat (fd, &stats) != 0)
1035 f[i].errnum = errno;
1036 error (0, errno, "%s", name);
1040 if (f[i].mode == stats.st_mode
1041 && (! S_ISREG (stats.st_mode) || f[i].size == stats.st_size)
1042 && timespec_cmp (f[i].mtime, get_stat_mtime (&stats)) == 0)
1044 if ((max_n_unchanged_stats_between_opens
1045 <= f[i].n_unchanged_stats++)
1046 && follow_mode == Follow_name)
1048 recheck (&f[i], f[i].blocking);
1049 f[i].n_unchanged_stats = 0;
1054 /* This file has changed. Print out what we can, and
1055 then keep looping. */
1057 f[i].mtime = get_stat_mtime (&stats);
1058 f[i].mode = stats.st_mode;
1061 f[i].n_unchanged_stats = 0;
1063 if (S_ISREG (mode) && stats.st_size < f[i].size)
1065 error (0, 0, _("%s: file truncated"), name);
1067 xlseek (fd, stats.st_size, SEEK_SET, name);
1068 f[i].size = stats.st_size;
1075 write_header (name);
1080 bytes_read = dump_remainder (name, fd,
1082 ? COPY_A_BUFFER : COPY_TO_EOF));
1083 any_input |= (bytes_read != 0);
1084 f[i].size += bytes_read;
1087 if (! any_live_files (f, nfiles) && ! reopen_inaccessible_files)
1089 error (0, 0, _("no files remaining"));
1093 if ((!any_input | blocking) && fflush (stdout) != 0)
1094 error (EXIT_FAILURE, errno, _("write error"));
1096 /* If nothing was read, sleep and/or check for dead writers. */
1102 if (xnanosleep (sleep_interval))
1103 error (EXIT_FAILURE, errno, _("cannot read realtime clock"));
1105 /* Once the writer is dead, read the files once more to
1106 avoid a race condition. */
1107 writer_is_dead = (pid != 0
1108 && kill (pid, 0) != 0
1109 /* Handle the case in which you cannot send a
1110 signal to the writer, so kill fails and sets
1117 /* Output the last N_BYTES bytes of file FILENAME open for reading in FD.
1118 Return true if successful. */
1121 tail_bytes (const char *pretty_filename, int fd, uintmax_t n_bytes,
1122 uintmax_t *read_pos)
1126 if (fstat (fd, &stats))
1128 error (0, errno, _("cannot fstat %s"), quote (pretty_filename));
1134 if ( ! presume_input_pipe
1135 && S_ISREG (stats.st_mode) && n_bytes <= OFF_T_MAX)
1137 xlseek (fd, n_bytes, SEEK_CUR, pretty_filename);
1138 *read_pos += n_bytes;
1142 int t = start_bytes (pretty_filename, fd, n_bytes, read_pos);
1146 *read_pos += dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1150 if ( ! presume_input_pipe
1151 && S_ISREG (stats.st_mode) && n_bytes <= OFF_T_MAX)
1153 off_t current_pos = xlseek (fd, 0, SEEK_CUR, pretty_filename);
1154 off_t end_pos = xlseek (fd, 0, SEEK_END, pretty_filename);
1155 off_t diff = end_pos - current_pos;
1156 /* Be careful here. The current position may actually be
1157 beyond the end of the file. */
1158 off_t bytes_remaining = (diff = end_pos - current_pos) < 0 ? 0 : diff;
1161 if (bytes_remaining <= nb)
1163 /* From the current position to end of file, there are no
1164 more bytes than have been requested. So reposition the
1165 file pointer to the incoming current position and print
1166 everything after that. */
1167 *read_pos = xlseek (fd, current_pos, SEEK_SET, pretty_filename);
1171 /* There are more bytes remaining than were requested.
1173 *read_pos = xlseek (fd, -nb, SEEK_END, pretty_filename);
1175 *read_pos += dump_remainder (pretty_filename, fd, n_bytes);
1178 return pipe_bytes (pretty_filename, fd, n_bytes, read_pos);
1183 /* Output the last N_LINES lines of file FILENAME open for reading in FD.
1184 Return true if successful. */
1187 tail_lines (const char *pretty_filename, int fd, uintmax_t n_lines,
1188 uintmax_t *read_pos)
1192 if (fstat (fd, &stats))
1194 error (0, errno, _("cannot fstat %s"), quote (pretty_filename));
1200 int t = start_lines (pretty_filename, fd, n_lines, read_pos);
1203 *read_pos += dump_remainder (pretty_filename, fd, COPY_TO_EOF);
1207 off_t start_pos = -1;
1210 /* Use file_lines only if FD refers to a regular file for
1211 which lseek (... SEEK_END) works. */
1212 if ( ! presume_input_pipe
1213 && S_ISREG (stats.st_mode)
1214 && (start_pos = lseek (fd, 0, SEEK_CUR)) != -1
1215 && start_pos < (end_pos = lseek (fd, 0, SEEK_END)))
1217 *read_pos = end_pos;
1219 && ! file_lines (pretty_filename, fd, n_lines,
1220 start_pos, end_pos, read_pos))
1225 /* Under very unlikely circumstances, it is possible to reach
1226 this point after positioning the file pointer to end of file
1227 via the `lseek (...SEEK_END)' above. In that case, reposition
1228 the file pointer back to start_pos before calling pipe_lines. */
1229 if (start_pos != -1)
1230 xlseek (fd, start_pos, SEEK_SET, pretty_filename);
1232 return pipe_lines (pretty_filename, fd, n_lines, read_pos);
1238 /* Display the last N_UNITS units of file FILENAME, open for reading
1239 via FD. Set *READ_POS to the position of the input stream pointer.
1240 *READ_POS is usually the number of bytes read and corresponds to an
1241 offset from the beginning of a file. However, it may be larger than
1242 OFF_T_MAX (as for an input pipe), and may also be larger than the
1243 number of bytes read (when an input pointer is initially not at
1244 beginning of file), and may be far greater than the number of bytes
1245 actually read for an input file that is seekable.
1246 Return true if successful. */
1249 tail (const char *filename, int fd, uintmax_t n_units,
1250 uintmax_t *read_pos)
1254 return tail_lines (filename, fd, n_units, read_pos);
1256 return tail_bytes (filename, fd, n_units, read_pos);
1259 /* Display the last N_UNITS units of the file described by F.
1260 Return true if successful. */
1263 tail_file (struct File_spec *f, uintmax_t n_units)
1268 bool is_stdin = (STREQ (f->name, "-"));
1272 have_read_stdin = true;
1274 if (O_BINARY && ! isatty (STDIN_FILENO))
1275 freopen (NULL, "rb", stdin);
1278 fd = open (f->name, O_RDONLY | O_BINARY);
1280 f->tailable = !(reopen_inaccessible_files && fd == -1);
1292 error (0, errno, _("cannot open %s for reading"),
1293 quote (pretty_name (f)));
1301 write_header (pretty_name (f));
1302 ok = tail (pretty_name (f), fd, n_units, &read_pos);
1307 #if TEST_RACE_BETWEEN_FINAL_READ_AND_INITIAL_FSTAT
1308 /* Before the tail function provided `read_pos', there was
1309 a race condition described in the URL below. This sleep
1310 call made the window big enough to exercise the problem. */
1314 if (fstat (fd, &stats) < 0)
1318 error (0, errno, _("error reading %s"), quote (pretty_name (f)));
1320 else if (!IS_TAILABLE_FILE_TYPE (stats.st_mode))
1322 error (0, 0, _("%s: cannot follow end of this type of file;\
1323 giving up on this name"),
1332 close_fd (fd, pretty_name (f));
1337 /* Note: we must use read_pos here, not stats.st_size,
1338 to avoid a race condition described by Ken Raeburn:
1339 http://mail.gnu.org/archive/html/bug-textutils/2003-05/msg00007.html */
1340 record_open_fd (f, fd, read_pos, &stats, (is_stdin ? -1 : 1));
1345 if (!is_stdin && close (fd))
1347 error (0, errno, _("error reading %s"), quote (pretty_name (f)));
1356 /* If obsolete usage is allowed, and the command line arguments are of
1357 the obsolete form and the option string is well-formed, set
1358 *N_UNITS, the globals COUNT_LINES, FOREVER, and FROM_START, and
1359 return true. If the command line arguments are obviously incorrect
1360 (e.g., because obsolete usage is not allowed and the arguments are
1361 incorrect for non-obsolete usage), report an error and exit.
1362 Otherwise, return false and don't modify any parameter or global
1366 parse_obsolete_option (int argc, char * const *argv, uintmax_t *n_units)
1369 const char *n_string;
1370 const char *n_string_end;
1371 bool obsolete_usage;
1372 int default_count = DEFAULT_N_LINES;
1374 bool t_count_lines = true;
1375 bool t_forever = false;
1377 /* With the obsolete form, there is one option string and at most
1378 one file argument. Watch out for "-" and "--", though. */
1380 || (argc == 3 && ! (argv[2][0] == '-' && argv[2][1]))
1381 || (3 <= argc && argc <= 4 && STREQ (argv[2], "--"))))
1384 obsolete_usage = (posix2_version () < 200112);
1393 /* Leading "+" is a file name in the non-obsolete form. */
1394 if (!obsolete_usage)
1397 t_from_start = true;
1401 /* In the non-obsolete form, "-" is standard input and "-c"
1402 requires an option-argument. The obsolete multidigit options
1403 are supported as a GNU extension even when conforming to
1404 POSIX 1003.1-2001, so don't complain about them. */
1405 if (!obsolete_usage && !p[p[0] == 'c'])
1408 t_from_start = false;
1413 while (ISDIGIT (*p))
1419 case 'b': default_count *= 512; /* Fall through. */
1420 case 'c': t_count_lines = false; /* Fall through. */
1421 case 'l': p++; break;
1433 if (n_string == n_string_end)
1434 *n_units = default_count;
1435 else if ((xstrtoumax (n_string, NULL, 10, n_units, "b")
1436 & ~LONGINT_INVALID_SUFFIX_CHAR)
1438 error (EXIT_FAILURE, 0, _("number in %s is too large"), quote (argv[1]));
1441 from_start = t_from_start;
1442 count_lines = t_count_lines;
1443 forever = t_forever;
1449 parse_options (int argc, char **argv,
1450 uintmax_t *n_units, enum header_mode *header_mode,
1451 double *sleep_interval)
1455 while ((c = getopt_long (argc, argv, "c:n:fFqs:v0123456789",
1456 long_options, NULL))
1463 follow_mode = Follow_name;
1464 reopen_inaccessible_files = true;
1469 count_lines = (c == 'n');
1472 else if (*optarg == '-')
1477 s_err = xstrtoumax (optarg, NULL, 10, n_units, "bkKmMGTPEZY0");
1478 if (s_err != LONGINT_OK)
1480 error (EXIT_FAILURE, 0, "%s: %s", optarg,
1482 ? _("invalid number of lines")
1483 : _("invalid number of bytes")));
1489 case LONG_FOLLOW_OPTION:
1492 follow_mode = DEFAULT_FOLLOW_MODE;
1494 follow_mode = XARGMATCH ("--follow", optarg,
1495 follow_mode_string, follow_mode_map);
1499 reopen_inaccessible_files = true;
1502 case MAX_UNCHANGED_STATS_OPTION:
1503 /* --max-unchanged-stats=N */
1504 if (xstrtoumax (optarg, NULL, 10,
1505 &max_n_unchanged_stats_between_opens,
1509 error (EXIT_FAILURE, 0,
1510 _("%s: invalid maximum number of unchanged stats between opens"),
1518 unsigned long int tmp_ulong;
1519 s_err = xstrtoul (optarg, NULL, 10, &tmp_ulong, "");
1520 if (s_err != LONGINT_OK || tmp_ulong > PID_T_MAX)
1522 error (EXIT_FAILURE, 0, _("%s: invalid PID"), optarg);
1528 case PRESUME_INPUT_PIPE_OPTION:
1529 presume_input_pipe = true;
1533 *header_mode = never;
1539 if (! (xstrtod (optarg, NULL, &s, c_strtod) && 0 <= s))
1540 error (EXIT_FAILURE, 0,
1541 _("%s: invalid number of seconds"), optarg);
1542 *sleep_interval = s;
1547 *header_mode = always;
1550 case_GETOPT_HELP_CHAR;
1552 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1554 case '0': case '1': case '2': case '3': case '4':
1555 case '5': case '6': case '7': case '8': case '9':
1556 error (EXIT_FAILURE, 0,
1557 _("option used in invalid context -- %c"), c);
1560 usage (EXIT_FAILURE);
1564 if (reopen_inaccessible_files && follow_mode != Follow_name)
1565 error (0, 0, _("warning: --retry is useful mainly when following by name"));
1567 if (pid && !forever)
1569 _("warning: PID ignored; --pid=PID is useful only when following"));
1570 else if (pid && kill (pid, 0) != 0 && errno == ENOSYS)
1572 error (0, 0, _("warning: --pid=PID is not supported on this system"));
1578 main (int argc, char **argv)
1580 enum header_mode header_mode = multiple_files;
1582 /* If from_start, the number of items to skip before printing; otherwise,
1583 the number of items at the end of the file to print. Although the type
1584 is signed, the value is never negative. */
1585 uintmax_t n_units = DEFAULT_N_LINES;
1588 struct File_spec *F;
1590 bool obsolete_option;
1592 /* The number of seconds to sleep between iterations.
1593 During one iteration, every file name or descriptor is checked to
1594 see if it has changed. */
1595 double sleep_interval = 1.0;
1597 initialize_main (&argc, &argv);
1598 set_program_name (argv[0]);
1599 setlocale (LC_ALL, "");
1600 bindtextdomain (PACKAGE, LOCALEDIR);
1601 textdomain (PACKAGE);
1603 atexit (close_stdout);
1605 have_read_stdin = false;
1608 forever = from_start = print_headers = false;
1609 obsolete_option = parse_obsolete_option (argc, argv, &n_units);
1610 argc -= obsolete_option;
1611 argv += obsolete_option;
1612 parse_options (argc, argv, &n_units, &header_mode, &sleep_interval);
1614 /* To start printing with item N_UNITS from the start of the file, skip
1615 N_UNITS - 1 items. `tail -n +0' is actually meaningless, but for Unix
1616 compatibility it's treated the same as `tail -n +1'. */
1625 n_files = argc - optind;
1626 file = argv + optind;
1630 static char *dummy_stdin = "-";
1632 file = &dummy_stdin;
1634 /* POSIX says that -f is ignored if no file operand is specified
1635 and standard input is a pipe. However, the GNU coding
1636 standards say that program behavior should not depend on
1637 device type, because device independence is an important
1638 principle of the system's design.
1640 Follow the POSIX requirement only if POSIXLY_CORRECT is set. */
1642 if (forever && getenv ("POSIXLY_CORRECT"))
1645 int is_a_fifo_or_pipe =
1646 (fstat (STDIN_FILENO, &st) != 0 ? -1
1647 : S_ISFIFO (st.st_mode) ? 1
1648 : HAVE_FIFO_PIPES == 1 ? 0
1649 : isapipe (STDIN_FILENO));
1650 if (is_a_fifo_or_pipe < 0)
1651 error (EXIT_FAILURE, errno, _("standard input"));
1652 if (is_a_fifo_or_pipe)
1658 bool found_hyphen = false;
1660 for (i = 0; i < n_files; i++)
1661 if (STREQ (file[i], "-"))
1662 found_hyphen = true;
1664 /* When following by name, there must be a name. */
1665 if (found_hyphen && follow_mode == Follow_name)
1666 error (EXIT_FAILURE, 0, _("cannot follow %s by name"), quote ("-"));
1668 /* When following forever, warn if any file is `-'.
1669 This is only a warning, since tail's output (before a failing seek,
1670 and that from any non-stdin files) might still be useful. */
1671 if (forever && found_hyphen && isatty (STDIN_FILENO))
1672 error (0, 0, _("warning: following standard input"
1673 " indefinitely is ineffective"));
1676 F = xnmalloc (n_files, sizeof *F);
1677 for (i = 0; i < n_files; i++)
1678 F[i].name = file[i];
1680 if (header_mode == always
1681 || (header_mode == multiple_files && n_files > 1))
1682 print_headers = true;
1684 if (O_BINARY && ! isatty (STDOUT_FILENO))
1685 freopen (NULL, "wb", stdout);
1687 for (i = 0; i < n_files; i++)
1688 ok &= tail_file (&F[i], n_units);
1691 tail_forever (F, n_files, sleep_interval);
1693 if (have_read_stdin && close (STDIN_FILENO) < 0)
1694 error (EXIT_FAILURE, errno, "-");
1695 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);