1 /* tail -- output the last part of file(s)
2 Copyright (C) 1989, 90, 91, 1995-2006 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 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>
42 #include "safe-read.h"
43 #include "stat-time.h"
44 #include "xnanosleep.h"
48 /* The official name of this program (e.g., no `g' prefix). */
49 #define PROGRAM_NAME "tail"
52 "Paul Rubin", "David MacKenzie, Ian Lance Taylor", "Jim Meyering"
54 /* Number of items to tail. */
55 #define DEFAULT_N_LINES 10
57 /* Special values for dump_remainder's N_BYTES parameter. */
58 #define COPY_TO_EOF UINTMAX_MAX
59 #define COPY_A_BUFFER (UINTMAX_MAX - 1)
61 /* FIXME: make Follow_name the default? */
62 #define DEFAULT_FOLLOW_MODE Follow_descriptor
66 /* Follow the name of each file: if the file is renamed, try to reopen
67 that name and track the end of the new file if/when it's recreated.
68 This is useful for tracking logs that are occasionally rotated. */
71 /* Follow each descriptor obtained upon opening a file.
72 That means we'll continue to follow the end of a file even after
73 it has been renamed or unlinked. */
77 /* The types of files for which tail works. */
78 #define IS_TAILABLE_FILE_TYPE(Mode) \
79 (S_ISREG (Mode) || S_ISFIFO (Mode) || S_ISSOCK (Mode) || S_ISCHR (Mode))
81 static char const *const follow_mode_string
[] =
83 "descriptor", "name", NULL
86 static enum Follow_mode
const follow_mode_map
[] =
88 Follow_descriptor
, Follow_name
,
93 /* The actual file name, or "-" for stdin. */
96 /* File descriptor on which the file is open; -1 if it's not open. */
99 /* Attributes of the file the last time we checked. */
101 struct timespec mtime
;
106 /* 1 if O_NONBLOCK is clear, 0 if set, -1 if not known. */
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 uintmax_t n_unchanged_stats
;
117 /* A file is tailable if it exists, is readable, and is of type
118 IS_TAILABLE_FILE_TYPE. */
121 /* The value of errno seen last time we checked this file. */
126 /* Keep trying to open a file even if it is inaccessible when tail starts
127 or if it becomes inaccessible later -- useful only with -f. */
128 static bool reopen_inaccessible_files
;
130 /* If true, interpret the numeric argument as the number of lines.
131 Otherwise, interpret it as the number of bytes. */
132 static bool count_lines
;
134 /* Whether we follow the name of each file or the file descriptor
135 that is initially associated with each name. */
136 static enum Follow_mode follow_mode
= Follow_descriptor
;
138 /* If true, read from the ends of all specified files until killed. */
141 /* If true, count from start of file instead of end. */
142 static bool from_start
;
144 /* If true, print filename headers. */
145 static bool print_headers
;
147 /* When to print the filename banners. */
150 multiple_files
, always
, never
153 /* When tailing a file by name, if there have been this many consecutive
154 iterations for which the file has not changed, then open/fstat
155 the file to determine if that file name is still associated with the
156 same device/inode-number pair as before. This option is meaningful only
157 when following by name. --max-unchanged-stats=N */
158 #define DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS 5
159 static uintmax_t max_n_unchanged_stats_between_opens
=
160 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS
;
162 /* The name this program was run with. */
165 /* The process ID of the process (presumably on the current host)
166 that is writing to all followed files. */
169 /* True if we have ever read standard input. */
170 static bool have_read_stdin
;
172 /* If nonzero, skip the is-regular-file test used to determine whether
173 to use the lseek optimization. Instead, use the more general (and
174 more expensive) code unconditionally. Intended solely for testing. */
175 static bool presume_input_pipe
;
177 /* For long options that have no equivalent short option, use a
178 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
181 RETRY_OPTION
= CHAR_MAX
+ 1,
182 MAX_UNCHANGED_STATS_OPTION
,
184 PRESUME_INPUT_PIPE_OPTION
,
188 static struct option
const long_options
[] =
190 {"bytes", required_argument
, NULL
, 'c'},
191 {"follow", optional_argument
, NULL
, LONG_FOLLOW_OPTION
},
192 {"lines", required_argument
, NULL
, 'n'},
193 {"max-unchanged-stats", required_argument
, NULL
, MAX_UNCHANGED_STATS_OPTION
},
194 {"pid", required_argument
, NULL
, PID_OPTION
},
195 {"-presume-input-pipe", no_argument
, NULL
,
196 PRESUME_INPUT_PIPE_OPTION
}, /* do not document */
197 {"quiet", no_argument
, NULL
, 'q'},
198 {"retry", no_argument
, NULL
, RETRY_OPTION
},
199 {"silent", no_argument
, NULL
, 'q'},
200 {"sleep-interval", required_argument
, NULL
, 's'},
201 {"verbose", no_argument
, NULL
, 'v'},
202 {GETOPT_HELP_OPTION_DECL
},
203 {GETOPT_VERSION_OPTION_DECL
},
210 if (status
!= EXIT_SUCCESS
)
211 fprintf (stderr
, _("Try `%s --help' for more information.\n"),
216 Usage: %s [OPTION]... [FILE]...\n\
220 Print the last %d lines of each FILE to standard output.\n\
221 With more than one FILE, precede each with a header giving the file name.\n\
222 With no FILE, or when FILE is -, read standard input.\n\
224 "), DEFAULT_N_LINES
);
226 Mandatory arguments to long options are mandatory for short options too.\n\
229 --retry keep trying to open a file even if it is\n\
230 inaccessible when tail starts or if it becomes\n\
231 inaccessible later; useful when following by name,\n\
232 i.e., with --follow=name\n\
233 -c, --bytes=N output the last N bytes; alternatively, use +N to\n\
234 output bytes starting with the Nth of each file\n\
237 -f, --follow[={name|descriptor}]\n\
238 output appended data as the file grows;\n\
239 -f, --follow, and --follow=descriptor are\n\
241 -F same as --follow=name --retry\n\
244 -n, --lines=N output the last N lines, instead of the last %d;\n\
245 or use +N to output lines starting with the Nth\n\
246 --max-unchanged-stats=N\n\
247 with --follow=name, reopen a FILE which has not\n\
248 changed size after N (default %d) iterations\n\
249 to see if it has been unlinked or renamed\n\
250 (this is the usual case of rotated log files)\n\
253 DEFAULT_MAX_N_UNCHANGED_STATS_BETWEEN_OPENS
256 --pid=PID with -f, terminate after process ID, PID dies\n\
257 -q, --quiet, --silent never output headers giving file names\n\
258 -s, --sleep-interval=S with -f, sleep for approximately S seconds\n\
259 (default 1.0) between iterations.\n\
260 -v, --verbose always output headers giving file names\n\
262 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
263 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
266 If the first character of N (the number of bytes or lines) is a `+',\n\
267 print beginning with the Nth item from the start of each file, otherwise,\n\
268 print the last N items in the file. N may have a multiplier suffix:\n\
269 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
270 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
274 With --follow (-f), tail defaults to following the file descriptor, which\n\
275 means that even if a tail'ed file is renamed, tail will continue to track\n\
279 This default behavior is not desirable when you really want to\n\
280 track the actual name of the file, not the file descriptor (e.g., log\n\
281 rotation). Use --follow=name in that case. That causes tail to track the\n\
282 named file by reopening it periodically to see if it has been removed and\n\
283 recreated by some other program.\n\
285 emit_bug_reporting_address ();
291 valid_file_spec (struct File_spec
const *f
)
293 /* Exactly one of the following subexpressions must be true. */
294 return ((f
->fd
== -1) ^ (f
->errnum
== 0));
298 pretty_name (struct File_spec
const *f
)
300 return (STREQ (f
->name
, "-") ? "standard input" : f
->name
);
304 xwrite_stdout (char const *buffer
, size_t n_bytes
)
306 if (n_bytes
> 0 && fwrite (buffer
, 1, n_bytes
, stdout
) == 0)
307 error (EXIT_FAILURE
, errno
, _("write error"));
310 /* Record a file F with descriptor FD, size SIZE, status ST, and
311 blocking status BLOCKING. */
314 record_open_fd (struct File_spec
*f
, int fd
,
315 off_t size
, struct stat
const *st
,
320 f
->mtime
= get_stat_mtime (st
);
323 f
->mode
= st
->st_mode
;
324 f
->blocking
= blocking
;
325 f
->n_unchanged_stats
= 0;
329 /* Close the file with descriptor FD and name FILENAME. */
332 close_fd (int fd
, const char *filename
)
334 if (fd
!= -1 && fd
!= STDIN_FILENO
&& close (fd
))
336 error (0, errno
, _("closing %s (fd=%d)"), filename
, fd
);
341 write_header (const char *pretty_filename
)
343 static bool first_file
= true;
345 printf ("%s==> %s <==\n", (first_file
? "" : "\n"), pretty_filename
);
349 /* Read and output N_BYTES of file PRETTY_FILENAME starting at the current
350 position in FD. If N_BYTES is COPY_TO_EOF, then copy until end of file.
351 If N_BYTES is COPY_A_BUFFER, then copy at most one buffer's worth.
352 Return the number of bytes read from the file. */
355 dump_remainder (const char *pretty_filename
, int fd
, uintmax_t n_bytes
)
358 uintmax_t n_remaining
= n_bytes
;
364 size_t n
= MIN (n_remaining
, BUFSIZ
);
365 size_t bytes_read
= safe_read (fd
, buffer
, n
);
366 if (bytes_read
== SAFE_READ_ERROR
)
369 error (EXIT_FAILURE
, errno
, _("error reading %s"),
370 quote (pretty_filename
));
375 xwrite_stdout (buffer
, bytes_read
);
376 n_written
+= bytes_read
;
377 if (n_bytes
!= COPY_TO_EOF
)
379 n_remaining
-= bytes_read
;
380 if (n_remaining
== 0 || n_bytes
== COPY_A_BUFFER
)
388 /* Call lseek with the specified arguments, where file descriptor FD
389 corresponds to the file, FILENAME.
390 Give a diagnostic and exit nonzero if lseek fails.
391 Otherwise, return the resulting offset. */
394 xlseek (int fd
, off_t offset
, int whence
, char const *filename
)
396 off_t new_offset
= lseek (fd
, offset
, whence
);
397 char buf
[INT_BUFSIZE_BOUND (off_t
)];
403 s
= offtostr (offset
, buf
);
407 error (0, errno
, _("%s: cannot seek to offset %s"),
411 error (0, errno
, _("%s: cannot seek to relative offset %s"),
415 error (0, errno
, _("%s: cannot seek to end-relative offset %s"),
425 /* Print the last N_LINES lines from the end of file FD.
426 Go backward through the file, reading `BUFSIZ' bytes at a time (except
427 probably the first), until we hit the start of the file or have
428 read NUMBER newlines.
429 START_POS is the starting position of the read pointer for the file
430 associated with FD (may be nonzero).
431 END_POS is the file offset of EOF (one larger than offset of last byte).
432 Return true if successful. */
435 file_lines (const char *pretty_filename
, int fd
, uintmax_t n_lines
,
436 off_t start_pos
, off_t end_pos
, uintmax_t *read_pos
)
445 /* Set `bytes_read' to the size of the last, probably partial, buffer;
446 0 < `bytes_read' <= `BUFSIZ'. */
447 bytes_read
= (pos
- start_pos
) % BUFSIZ
;
450 /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
451 reads will be on block boundaries, which might increase efficiency. */
453 xlseek (fd
, pos
, SEEK_SET
, pretty_filename
);
454 bytes_read
= safe_read (fd
, buffer
, bytes_read
);
455 if (bytes_read
== SAFE_READ_ERROR
)
457 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
460 *read_pos
= pos
+ bytes_read
;
462 /* Count the incomplete line on files that don't end with a newline. */
463 if (bytes_read
&& buffer
[bytes_read
- 1] != '\n')
468 /* Scan backward, counting the newlines in this bufferfull. */
470 size_t n
= bytes_read
;
474 nl
= memrchr (buffer
, '\n', n
);
480 /* If this newline isn't the last character in the buffer,
481 output the part that is after it. */
482 if (n
!= bytes_read
- 1)
483 xwrite_stdout (nl
+ 1, bytes_read
- (n
+ 1));
484 *read_pos
+= dump_remainder (pretty_filename
, fd
,
485 end_pos
- (pos
+ bytes_read
));
490 /* Not enough newlines in that bufferfull. */
491 if (pos
== start_pos
)
493 /* Not enough lines in the file; print everything from
494 start_pos to the end. */
495 xlseek (fd
, start_pos
, SEEK_SET
, pretty_filename
);
496 *read_pos
= start_pos
+ dump_remainder (pretty_filename
, fd
,
501 xlseek (fd
, pos
, SEEK_SET
, pretty_filename
);
503 bytes_read
= safe_read (fd
, buffer
, BUFSIZ
);
504 if (bytes_read
== SAFE_READ_ERROR
)
506 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
510 *read_pos
= pos
+ bytes_read
;
512 while (bytes_read
> 0);
517 /* Print the last N_LINES lines from the end of the standard input,
518 open for reading as pipe FD.
519 Buffer the text as a linked list of LBUFFERs, adding them as needed.
520 Return true if successful. */
523 pipe_lines (const char *pretty_filename
, int fd
, uintmax_t n_lines
,
531 struct linebuffer
*next
;
533 typedef struct linebuffer LBUFFER
;
534 LBUFFER
*first
, *last
, *tmp
;
535 size_t total_lines
= 0; /* Total number of newlines in all buffers. */
537 size_t n_read
; /* Size in bytes of most recent read */
539 first
= last
= xmalloc (sizeof (LBUFFER
));
540 first
->nbytes
= first
->nlines
= 0;
542 tmp
= xmalloc (sizeof (LBUFFER
));
544 /* Input is always read into a fresh buffer. */
547 n_read
= safe_read (fd
, tmp
->buffer
, BUFSIZ
);
548 if (n_read
== 0 || n_read
== SAFE_READ_ERROR
)
550 tmp
->nbytes
= n_read
;
555 /* Count the number of newlines just read. */
557 char const *buffer_end
= tmp
->buffer
+ n_read
;
558 char const *p
= tmp
->buffer
;
559 while ((p
= memchr (p
, '\n', buffer_end
- p
)))
565 total_lines
+= tmp
->nlines
;
567 /* If there is enough room in the last buffer read, just append the new
568 one to it. This is because when reading from a pipe, `n_read' can
569 often be very small. */
570 if (tmp
->nbytes
+ last
->nbytes
< BUFSIZ
)
572 memcpy (&last
->buffer
[last
->nbytes
], tmp
->buffer
, tmp
->nbytes
);
573 last
->nbytes
+= tmp
->nbytes
;
574 last
->nlines
+= tmp
->nlines
;
578 /* If there's not enough room, link the new buffer onto the end of
579 the list, then either free up the oldest buffer for the next
580 read if that would leave enough lines, or else malloc a new one.
581 Some compaction mechanism is possible but probably not
583 last
= last
->next
= tmp
;
584 if (total_lines
- first
->nlines
> n_lines
)
587 total_lines
-= first
->nlines
;
591 tmp
= xmalloc (sizeof (LBUFFER
));
597 if (n_read
== SAFE_READ_ERROR
)
599 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
604 /* If the file is empty, then bail out. */
605 if (last
->nbytes
== 0)
608 /* This prevents a core dump when the pipe contains no newlines. */
612 /* Count the incomplete line on files that don't end with a newline. */
613 if (last
->buffer
[last
->nbytes
- 1] != '\n')
619 /* Run through the list, printing lines. First, skip over unneeded
621 for (tmp
= first
; total_lines
- tmp
->nlines
> n_lines
; tmp
= tmp
->next
)
622 total_lines
-= tmp
->nlines
;
624 /* Find the correct beginning, then print the rest of the file. */
626 char const *beg
= tmp
->buffer
;
627 char const *buffer_end
= tmp
->buffer
+ tmp
->nbytes
;
628 if (total_lines
> n_lines
)
630 /* Skip `total_lines' - `n_lines' newlines. We made sure that
631 `total_lines' - `n_lines' <= `tmp->nlines'. */
633 for (j
= total_lines
- n_lines
; j
; --j
)
635 beg
= memchr (beg
, '\n', buffer_end
- beg
);
641 xwrite_stdout (beg
, buffer_end
- beg
);
644 for (tmp
= tmp
->next
; tmp
; tmp
= tmp
->next
)
645 xwrite_stdout (tmp
->buffer
, tmp
->nbytes
);
657 /* Print the last N_BYTES characters from the end of pipe FD.
658 This is a stripped down version of pipe_lines.
659 Return true if successful. */
662 pipe_bytes (const char *pretty_filename
, int fd
, uintmax_t n_bytes
,
669 struct charbuffer
*next
;
671 typedef struct charbuffer CBUFFER
;
672 CBUFFER
*first
, *last
, *tmp
;
673 size_t i
; /* Index into buffers. */
674 size_t total_bytes
= 0; /* Total characters in all buffers. */
678 first
= last
= xmalloc (sizeof (CBUFFER
));
681 tmp
= xmalloc (sizeof (CBUFFER
));
683 /* Input is always read into a fresh buffer. */
686 n_read
= safe_read (fd
, tmp
->buffer
, BUFSIZ
);
687 if (n_read
== 0 || n_read
== SAFE_READ_ERROR
)
690 tmp
->nbytes
= n_read
;
693 total_bytes
+= tmp
->nbytes
;
694 /* If there is enough room in the last buffer read, just append the new
695 one to it. This is because when reading from a pipe, `nbytes' can
696 often be very small. */
697 if (tmp
->nbytes
+ last
->nbytes
< BUFSIZ
)
699 memcpy (&last
->buffer
[last
->nbytes
], tmp
->buffer
, tmp
->nbytes
);
700 last
->nbytes
+= tmp
->nbytes
;
704 /* If there's not enough room, link the new buffer onto the end of
705 the list, then either free up the oldest buffer for the next
706 read if that would leave enough characters, or else malloc a new
707 one. Some compaction mechanism is possible but probably not
709 last
= last
->next
= tmp
;
710 if (total_bytes
- first
->nbytes
> n_bytes
)
713 total_bytes
-= first
->nbytes
;
718 tmp
= xmalloc (sizeof (CBUFFER
));
725 if (n_read
== SAFE_READ_ERROR
)
727 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
732 /* Run through the list, printing characters. First, skip over unneeded
734 for (tmp
= first
; total_bytes
- tmp
->nbytes
> n_bytes
; tmp
= tmp
->next
)
735 total_bytes
-= tmp
->nbytes
;
737 /* Find the correct beginning, then print the rest of the file.
738 We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'. */
739 if (total_bytes
> n_bytes
)
740 i
= total_bytes
- n_bytes
;
743 xwrite_stdout (&tmp
->buffer
[i
], tmp
->nbytes
- i
);
745 for (tmp
= tmp
->next
; tmp
; tmp
= tmp
->next
)
746 xwrite_stdout (tmp
->buffer
, tmp
->nbytes
);
758 /* Skip N_BYTES characters from the start of pipe FD, and print
759 any extra characters that were read beyond that.
760 Return 1 on error, 0 if ok, -1 if EOF. */
763 start_bytes (const char *pretty_filename
, int fd
, uintmax_t n_bytes
,
770 size_t bytes_read
= safe_read (fd
, buffer
, BUFSIZ
);
773 if (bytes_read
== SAFE_READ_ERROR
)
775 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
778 read_pos
+= bytes_read
;
779 if (bytes_read
<= n_bytes
)
780 n_bytes
-= bytes_read
;
783 size_t n_remaining
= bytes_read
- n_bytes
;
785 xwrite_stdout (&buffer
[n_bytes
], n_remaining
);
793 /* Skip N_LINES lines at the start of file or pipe FD, and print
794 any extra characters that were read beyond that.
795 Return 1 on error, 0 if ok, -1 if EOF. */
798 start_lines (const char *pretty_filename
, int fd
, uintmax_t n_lines
,
808 size_t bytes_read
= safe_read (fd
, buffer
, BUFSIZ
);
809 char *buffer_end
= buffer
+ bytes_read
;
810 if (bytes_read
== 0) /* EOF */
812 if (bytes_read
== SAFE_READ_ERROR
) /* error */
814 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
818 *read_pos
+= bytes_read
;
820 while ((p
= memchr (p
, '\n', buffer_end
- p
)))
826 xwrite_stdout (p
, buffer_end
- p
);
833 /* FIXME: describe */
836 recheck (struct File_spec
*f
, bool blocking
)
838 /* open/fstat the file and announce if dev/ino have changed */
839 struct stat new_stats
;
841 bool is_stdin
= (STREQ (f
->name
, "-"));
842 bool was_tailable
= f
->tailable
;
843 int prev_errnum
= f
->errnum
;
847 : open (f
->name
, O_RDONLY
| (blocking
? 0 : O_NONBLOCK
)));
849 assert (valid_file_spec (f
));
851 /* If the open fails because the file doesn't exist,
852 then mark the file as not tailable. */
853 f
->tailable
= !(reopen_inaccessible_files
&& fd
== -1);
855 if (fd
== -1 || fstat (fd
, &new_stats
) < 0)
863 /* FIXME-maybe: detect the case in which the file first becomes
864 unreadable (perms), and later becomes readable again and can
865 be seen to be the same file (dev/ino). Otherwise, tail prints
866 the entire contents of the file when it becomes readable. */
867 error (0, f
->errnum
, _("%s has become inaccessible"),
868 quote (pretty_name (f
)));
872 /* say nothing... it's still not tailable */
875 else if (prev_errnum
!= errno
)
877 error (0, errno
, "%s", pretty_name (f
));
880 else if (!IS_TAILABLE_FILE_TYPE (new_stats
.st_mode
))
884 error (0, 0, _("%s has been replaced with an untailable file;\
885 giving up on this name"),
886 quote (pretty_name (f
)));
897 close_fd (fd
, pretty_name (f
));
898 close_fd (f
->fd
, pretty_name (f
));
901 else if (prev_errnum
&& prev_errnum
!= ENOENT
)
904 assert (f
->fd
== -1);
905 error (0, 0, _("%s has become accessible"), quote (pretty_name (f
)));
907 else if (f
->ino
!= new_stats
.st_ino
|| f
->dev
!= new_stats
.st_dev
)
913 _("%s has appeared; following end of new file"),
914 quote (pretty_name (f
)));
918 /* Close the old one. */
919 close_fd (f
->fd
, pretty_name (f
));
921 /* File has been replaced (e.g., via log rotation) --
924 _("%s has been replaced; following end of new file"),
925 quote (pretty_name (f
)));
932 /* This happens when one iteration finds the file missing,
933 then the preceding <dev,inode> pair is reused as the
934 file is recreated. */
939 close_fd (fd
, pretty_name (f
));
945 /* Start at the beginning of the file. */
946 record_open_fd (f
, fd
, 0, &new_stats
, (is_stdin
? -1 : blocking
));
947 xlseek (fd
, 0, SEEK_SET
, pretty_name (f
));
951 /* Return true if any of the N_FILES files in F are live, i.e., have
952 open file descriptors. */
955 any_live_files (const struct File_spec
*f
, int n_files
)
959 for (i
= 0; i
< n_files
; i
++)
965 /* Tail NFILES files forever, or until killed.
966 The pertinent information for each file is stored in an entry of F.
967 Loop over each of them, doing an fstat to see if they have changed size,
968 and an occasional open/fstat to see if any dev/ino pair has changed.
969 If none of them have changed size in one iteration, sleep for a
970 while and try again. Continue until the user interrupts us. */
973 tail_forever (struct File_spec
*f
, int nfiles
, double sleep_interval
)
975 /* Use blocking I/O as an optimization, when it's easy. */
976 bool blocking
= (pid
== 0 && follow_mode
== Follow_descriptor
977 && nfiles
== 1 && ! S_ISREG (f
[0].mode
));
979 bool writer_is_dead
= false;
986 bool any_input
= false;
988 for (i
= 0; i
< nfiles
; i
++)
994 uintmax_t bytes_read
;
1001 recheck (&f
[i
], blocking
);
1006 name
= pretty_name (&f
[i
]);
1009 if (f
[i
].blocking
!= blocking
)
1011 int old_flags
= fcntl (fd
, F_GETFL
);
1012 int new_flags
= old_flags
| (blocking
? 0 : O_NONBLOCK
);
1014 || (new_flags
!= old_flags
1015 && fcntl (fd
, F_SETFL
, new_flags
) == -1))
1017 /* Don't update f[i].blocking if fcntl fails. */
1018 if (S_ISREG (f
[i
].mode
) && errno
== EPERM
)
1020 /* This happens when using tail -f on a file with
1021 the append-only attribute. */
1024 error (EXIT_FAILURE
, errno
,
1025 _("%s: cannot change nonblocking mode"), name
);
1028 f
[i
].blocking
= blocking
;
1033 if (fstat (fd
, &stats
) != 0)
1036 f
[i
].errnum
= errno
;
1037 error (0, errno
, "%s", name
);
1041 if (f
[i
].mode
== stats
.st_mode
1042 && (! S_ISREG (stats
.st_mode
) || f
[i
].size
== stats
.st_size
)
1043 && timespec_cmp (f
[i
].mtime
, get_stat_mtime (&stats
)) == 0)
1045 if ((max_n_unchanged_stats_between_opens
1046 <= f
[i
].n_unchanged_stats
++)
1047 && follow_mode
== Follow_name
)
1049 recheck (&f
[i
], f
[i
].blocking
);
1050 f
[i
].n_unchanged_stats
= 0;
1055 /* This file has changed. Print out what we can, and
1056 then keep looping. */
1058 f
[i
].mtime
= get_stat_mtime (&stats
);
1059 f
[i
].mode
= stats
.st_mode
;
1062 f
[i
].n_unchanged_stats
= 0;
1064 if (S_ISREG (mode
) && stats
.st_size
< f
[i
].size
)
1066 error (0, 0, _("%s: file truncated"), name
);
1068 xlseek (fd
, stats
.st_size
, SEEK_SET
, name
);
1069 f
[i
].size
= stats
.st_size
;
1076 write_header (name
);
1081 bytes_read
= dump_remainder (name
, fd
,
1083 ? COPY_A_BUFFER
: COPY_TO_EOF
));
1084 any_input
|= (bytes_read
!= 0);
1085 f
[i
].size
+= bytes_read
;
1088 if (! any_live_files (f
, nfiles
) && ! reopen_inaccessible_files
)
1090 error (0, 0, _("no files remaining"));
1094 if ((!any_input
| blocking
) && fflush (stdout
) != 0)
1095 error (EXIT_FAILURE
, errno
, _("write error"));
1097 /* If nothing was read, sleep and/or check for dead writers. */
1103 if (xnanosleep (sleep_interval
))
1104 error (EXIT_FAILURE
, errno
, _("cannot read realtime clock"));
1106 /* Once the writer is dead, read the files once more to
1107 avoid a race condition. */
1108 writer_is_dead
= (pid
!= 0
1109 && kill (pid
, 0) != 0
1110 /* Handle the case in which you cannot send a
1111 signal to the writer, so kill fails and sets
1118 /* Output the last N_BYTES bytes of file FILENAME open for reading in FD.
1119 Return true if successful. */
1122 tail_bytes (const char *pretty_filename
, int fd
, uintmax_t n_bytes
,
1123 uintmax_t *read_pos
)
1127 if (fstat (fd
, &stats
))
1129 error (0, errno
, _("cannot fstat %s"), quote (pretty_filename
));
1135 if ( ! presume_input_pipe
1136 && S_ISREG (stats
.st_mode
) && n_bytes
<= OFF_T_MAX
)
1138 xlseek (fd
, n_bytes
, SEEK_CUR
, pretty_filename
);
1139 *read_pos
+= n_bytes
;
1143 int t
= start_bytes (pretty_filename
, fd
, n_bytes
, read_pos
);
1147 *read_pos
+= dump_remainder (pretty_filename
, fd
, COPY_TO_EOF
);
1151 if ( ! presume_input_pipe
1152 && S_ISREG (stats
.st_mode
) && n_bytes
<= OFF_T_MAX
)
1154 off_t current_pos
= xlseek (fd
, 0, SEEK_CUR
, pretty_filename
);
1155 off_t end_pos
= xlseek (fd
, 0, SEEK_END
, pretty_filename
);
1156 off_t diff
= end_pos
- current_pos
;
1157 /* Be careful here. The current position may actually be
1158 beyond the end of the file. */
1159 off_t bytes_remaining
= (diff
= end_pos
- current_pos
) < 0 ? 0 : diff
;
1162 if (bytes_remaining
<= nb
)
1164 /* From the current position to end of file, there are no
1165 more bytes than have been requested. So reposition the
1166 file pointer to the incoming current position and print
1167 everything after that. */
1168 *read_pos
= xlseek (fd
, current_pos
, SEEK_SET
, pretty_filename
);
1172 /* There are more bytes remaining than were requested.
1174 *read_pos
= xlseek (fd
, -nb
, SEEK_END
, pretty_filename
);
1176 *read_pos
+= dump_remainder (pretty_filename
, fd
, n_bytes
);
1179 return pipe_bytes (pretty_filename
, fd
, n_bytes
, read_pos
);
1184 /* Output the last N_LINES lines of file FILENAME open for reading in FD.
1185 Return true if successful. */
1188 tail_lines (const char *pretty_filename
, int fd
, uintmax_t n_lines
,
1189 uintmax_t *read_pos
)
1193 if (fstat (fd
, &stats
))
1195 error (0, errno
, _("cannot fstat %s"), quote (pretty_filename
));
1201 int t
= start_lines (pretty_filename
, fd
, n_lines
, read_pos
);
1204 *read_pos
+= dump_remainder (pretty_filename
, fd
, COPY_TO_EOF
);
1208 off_t start_pos
= -1;
1211 /* Use file_lines only if FD refers to a regular file for
1212 which lseek (... SEEK_END) works. */
1213 if ( ! presume_input_pipe
1214 && S_ISREG (stats
.st_mode
)
1215 && (start_pos
= lseek (fd
, 0, SEEK_CUR
)) != -1
1216 && start_pos
< (end_pos
= lseek (fd
, 0, SEEK_END
)))
1218 *read_pos
= end_pos
;
1220 && ! file_lines (pretty_filename
, fd
, n_lines
,
1221 start_pos
, end_pos
, read_pos
))
1226 /* Under very unlikely circumstances, it is possible to reach
1227 this point after positioning the file pointer to end of file
1228 via the `lseek (...SEEK_END)' above. In that case, reposition
1229 the file pointer back to start_pos before calling pipe_lines. */
1230 if (start_pos
!= -1)
1231 xlseek (fd
, start_pos
, SEEK_SET
, pretty_filename
);
1233 return pipe_lines (pretty_filename
, fd
, n_lines
, read_pos
);
1239 /* Display the last N_UNITS units of file FILENAME, open for reading
1240 via FD. Set *READ_POS to the position of the input stream pointer.
1241 *READ_POS is usually the number of bytes read and corresponds to an
1242 offset from the beginning of a file. However, it may be larger than
1243 OFF_T_MAX (as for an input pipe), and may also be larger than the
1244 number of bytes read (when an input pointer is initially not at
1245 beginning of file), and may be far greater than the number of bytes
1246 actually read for an input file that is seekable.
1247 Return true if successful. */
1250 tail (const char *filename
, int fd
, uintmax_t n_units
,
1251 uintmax_t *read_pos
)
1255 return tail_lines (filename
, fd
, n_units
, read_pos
);
1257 return tail_bytes (filename
, fd
, n_units
, read_pos
);
1260 /* Display the last N_UNITS units of the file described by F.
1261 Return true if successful. */
1264 tail_file (struct File_spec
*f
, uintmax_t n_units
)
1269 bool is_stdin
= (STREQ (f
->name
, "-"));
1273 have_read_stdin
= true;
1275 if (O_BINARY
&& ! isatty (STDIN_FILENO
))
1276 freopen (NULL
, "rb", stdin
);
1279 fd
= open (f
->name
, O_RDONLY
| O_BINARY
);
1281 f
->tailable
= !(reopen_inaccessible_files
&& fd
== -1);
1293 error (0, errno
, _("cannot open %s for reading"),
1294 quote (pretty_name (f
)));
1302 write_header (pretty_name (f
));
1303 ok
= tail (pretty_name (f
), fd
, n_units
, &read_pos
);
1308 #if TEST_RACE_BETWEEN_FINAL_READ_AND_INITIAL_FSTAT
1309 /* Before the tail function provided `read_pos', there was
1310 a race condition described in the URL below. This sleep
1311 call made the window big enough to exercise the problem. */
1315 if (fstat (fd
, &stats
) < 0)
1319 error (0, errno
, _("error reading %s"), quote (pretty_name (f
)));
1321 else if (!IS_TAILABLE_FILE_TYPE (stats
.st_mode
))
1323 error (0, 0, _("%s: cannot follow end of this type of file;\
1324 giving up on this name"),
1333 close_fd (fd
, pretty_name (f
));
1338 /* Note: we must use read_pos here, not stats.st_size,
1339 to avoid a race condition described by Ken Raeburn:
1340 http://mail.gnu.org/archive/html/bug-textutils/2003-05/msg00007.html */
1341 record_open_fd (f
, fd
, read_pos
, &stats
, (is_stdin
? -1 : 1));
1346 if (!is_stdin
&& close (fd
))
1348 error (0, errno
, _("error reading %s"), quote (pretty_name (f
)));
1357 /* If obsolete usage is allowed, and the command line arguments are of
1358 the obsolete form and the option string is well-formed, set
1359 *N_UNITS, the globals COUNT_LINES, FOREVER, and FROM_START, and
1360 return true. If the command line arguments are obviously incorrect
1361 (e.g., because obsolete usage is not allowed and the arguments are
1362 incorrect for non-obsolete usage), report an error and exit.
1363 Otherwise, return false and don't modify any parameter or global
1367 parse_obsolete_option (int argc
, char * const *argv
, uintmax_t *n_units
)
1370 const char *n_string
;
1371 const char *n_string_end
;
1372 bool obsolete_usage
;
1373 int default_count
= DEFAULT_N_LINES
;
1375 bool t_count_lines
= true;
1376 bool t_forever
= false;
1378 /* With the obsolete form, there is one option string and at most
1379 one file argument. Watch out for "-" and "--", though. */
1381 || (argc
== 3 && ! (argv
[2][0] == '-' && argv
[2][1]))
1382 || (3 <= argc
&& argc
<= 4 && STREQ (argv
[2], "--"))))
1385 obsolete_usage
= (posix2_version () < 200112);
1394 /* Leading "+" is a file name in the non-obsolete form. */
1395 if (!obsolete_usage
)
1398 t_from_start
= true;
1402 /* In the non-obsolete form, "-" is standard input and "-c"
1403 requires an option-argument. The obsolete multidigit options
1404 are supported as a GNU extension even when conforming to
1405 POSIX 1003.1-2001, so don't complain about them. */
1406 if (!obsolete_usage
&& !p
[p
[0] == 'c'])
1409 t_from_start
= false;
1414 while (ISDIGIT (*p
))
1420 case 'b': default_count
*= 512; /* Fall through. */
1421 case 'c': t_count_lines
= false; /* Fall through. */
1422 case 'l': p
++; break;
1434 if (n_string
== n_string_end
)
1435 *n_units
= default_count
;
1436 else if ((xstrtoumax (n_string
, NULL
, 10, n_units
, "b")
1437 & ~LONGINT_INVALID_SUFFIX_CHAR
)
1439 error (EXIT_FAILURE
, 0, _("number in %s is too large"), quote (argv
[1]));
1442 from_start
= t_from_start
;
1443 count_lines
= t_count_lines
;
1444 forever
= t_forever
;
1450 parse_options (int argc
, char **argv
,
1451 uintmax_t *n_units
, enum header_mode
*header_mode
,
1452 double *sleep_interval
)
1456 while ((c
= getopt_long (argc
, argv
, "c:n:fFqs:v0123456789",
1457 long_options
, NULL
))
1464 follow_mode
= Follow_name
;
1465 reopen_inaccessible_files
= true;
1470 count_lines
= (c
== 'n');
1473 else if (*optarg
== '-')
1478 s_err
= xstrtoumax (optarg
, NULL
, 10, n_units
, "bkKmMGTPEZY0");
1479 if (s_err
!= LONGINT_OK
)
1481 error (EXIT_FAILURE
, 0, "%s: %s", optarg
,
1483 ? _("invalid number of lines")
1484 : _("invalid number of bytes")));
1490 case LONG_FOLLOW_OPTION
:
1493 follow_mode
= DEFAULT_FOLLOW_MODE
;
1495 follow_mode
= XARGMATCH ("--follow", optarg
,
1496 follow_mode_string
, follow_mode_map
);
1500 reopen_inaccessible_files
= true;
1503 case MAX_UNCHANGED_STATS_OPTION
:
1504 /* --max-unchanged-stats=N */
1505 if (xstrtoumax (optarg
, NULL
, 10,
1506 &max_n_unchanged_stats_between_opens
,
1510 error (EXIT_FAILURE
, 0,
1511 _("%s: invalid maximum number of unchanged stats between opens"),
1519 unsigned long int tmp_ulong
;
1520 s_err
= xstrtoul (optarg
, NULL
, 10, &tmp_ulong
, "");
1521 if (s_err
!= LONGINT_OK
|| tmp_ulong
> PID_T_MAX
)
1523 error (EXIT_FAILURE
, 0, _("%s: invalid PID"), optarg
);
1529 case PRESUME_INPUT_PIPE_OPTION
:
1530 presume_input_pipe
= true;
1534 *header_mode
= never
;
1540 if (! (xstrtod (optarg
, NULL
, &s
, c_strtod
) && 0 <= s
))
1541 error (EXIT_FAILURE
, 0,
1542 _("%s: invalid number of seconds"), optarg
);
1543 *sleep_interval
= s
;
1548 *header_mode
= always
;
1551 case_GETOPT_HELP_CHAR
;
1553 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
1555 case '0': case '1': case '2': case '3': case '4':
1556 case '5': case '6': case '7': case '8': case '9':
1557 error (EXIT_FAILURE
, 0,
1558 _("option used in invalid context -- %c"), c
);
1561 usage (EXIT_FAILURE
);
1565 if (reopen_inaccessible_files
&& follow_mode
!= Follow_name
)
1566 error (0, 0, _("warning: --retry is useful mainly when following by name"));
1568 if (pid
&& !forever
)
1570 _("warning: PID ignored; --pid=PID is useful only when following"));
1571 else if (pid
&& kill (pid
, 0) != 0 && errno
== ENOSYS
)
1573 error (0, 0, _("warning: --pid=PID is not supported on this system"));
1579 main (int argc
, char **argv
)
1581 enum header_mode header_mode
= multiple_files
;
1583 /* If from_start, the number of items to skip before printing; otherwise,
1584 the number of items at the end of the file to print. Although the type
1585 is signed, the value is never negative. */
1586 uintmax_t n_units
= DEFAULT_N_LINES
;
1589 struct File_spec
*F
;
1591 bool obsolete_option
;
1593 /* The number of seconds to sleep between iterations.
1594 During one iteration, every file name or descriptor is checked to
1595 see if it has changed. */
1596 double sleep_interval
= 1.0;
1598 initialize_main (&argc
, &argv
);
1599 program_name
= argv
[0];
1600 setlocale (LC_ALL
, "");
1601 bindtextdomain (PACKAGE
, LOCALEDIR
);
1602 textdomain (PACKAGE
);
1604 atexit (close_stdout
);
1606 have_read_stdin
= false;
1609 forever
= from_start
= print_headers
= false;
1610 obsolete_option
= parse_obsolete_option (argc
, argv
, &n_units
);
1611 argc
-= obsolete_option
;
1612 argv
+= obsolete_option
;
1613 parse_options (argc
, argv
, &n_units
, &header_mode
, &sleep_interval
);
1615 /* To start printing with item N_UNITS from the start of the file, skip
1616 N_UNITS - 1 items. `tail -n +0' is actually meaningless, but for Unix
1617 compatibility it's treated the same as `tail -n +1'. */
1626 n_files
= argc
- optind
;
1627 file
= argv
+ optind
;
1631 static char *dummy_stdin
= "-";
1633 file
= &dummy_stdin
;
1635 /* POSIX says that -f is ignored if no file operand is specified
1636 and standard input is a pipe. However, the GNU coding
1637 standards say that program behavior should not depend on
1638 device type, because device independence is an important
1639 principle of the system's design.
1641 Follow the POSIX requirement only if POSIXLY_CORRECT is set. */
1643 if (forever
&& getenv ("POSIXLY_CORRECT"))
1646 int is_a_fifo_or_pipe
=
1647 (fstat (STDIN_FILENO
, &st
) != 0 ? -1
1648 : S_ISFIFO (st
.st_mode
) ? 1
1649 : HAVE_FIFO_PIPES
== 1 ? 0
1650 : isapipe (STDIN_FILENO
));
1651 if (is_a_fifo_or_pipe
< 0)
1652 error (EXIT_FAILURE
, errno
, _("standard input"));
1653 if (is_a_fifo_or_pipe
)
1659 bool found_hyphen
= false;
1661 for (i
= 0; i
< n_files
; i
++)
1662 if (STREQ (file
[i
], "-"))
1663 found_hyphen
= true;
1665 /* When following by name, there must be a name. */
1666 if (found_hyphen
&& follow_mode
== Follow_name
)
1667 error (EXIT_FAILURE
, 0, _("cannot follow %s by name"), quote ("-"));
1669 /* When following forever, warn if any file is `-'.
1670 This is only a warning, since tail's output (before a failing seek,
1671 and that from any non-stdin files) might still be useful. */
1672 if (forever
&& found_hyphen
&& isatty (STDIN_FILENO
))
1673 error (0, 0, _("warning: following standard input"
1674 " indefinitely is ineffective"));
1677 F
= xnmalloc (n_files
, sizeof *F
);
1678 for (i
= 0; i
< n_files
; i
++)
1679 F
[i
].name
= file
[i
];
1681 if (header_mode
== always
1682 || (header_mode
== multiple_files
&& n_files
> 1))
1683 print_headers
= true;
1685 if (O_BINARY
&& ! isatty (STDOUT_FILENO
))
1686 freopen (NULL
, "wb", stdout
);
1688 for (i
= 0; i
< n_files
; i
++)
1689 ok
&= tail_file (&F
[i
], n_units
);
1692 tail_forever (F
, n_files
, sleep_interval
);
1694 if (have_read_stdin
&& close (STDIN_FILENO
) < 0)
1695 error (EXIT_FAILURE
, errno
, "-");
1696 exit (ok
? EXIT_SUCCESS
: EXIT_FAILURE
);