As said in the comments, Ctrl-C does not kill the tail process, which is done by sending either a SIGTERM or SIGKILL signal (the infamous -9...); it merely sends a SIGINT which tells tail to end the forward mode and exit.
FYI, these's a better tool:
less +F filename
In less, you can press Ctrl-C to end forward mode and scroll through the file, then press F to go back to forward mode again.
Note that less +F is advocated by many as a better alternative to tail -f. For difference and caveats between the two tools, read this answer: Is `tail -f` more efficient than `less +F`?
tail is not killed by CTRL-C and is not interactive) I believe my answer is more than appropriate.
– dr_
Aug 22 '17 at 11:37
kill <pid> does. For most programs, there's no real difference between Ctrl-C (=SIGINT), SIGTERM and, to some extent, SIGKILL. The default action for all three is to simply terminate the process, as if exit() had been called, with the exception that for SIGKILL, none of the user-mode code associated with exit() is called (so no atexit() cleanups etc). Ctrl-C and SIGTERM, in particular, are completely identical unless the program explicitly catches either and acts on it. GNU tail doesn't.
– marcelm
Aug 22 '17 at 12:02
tail of which I was previously not aware?
– Toby Speight
Aug 22 '17 at 15:51
kill. Ctrl-C doesn't use it, but some sort of kernel internal equivalent.
– Kaz
Aug 22 '17 at 18:45
exit() being called. exit() will run the atexit() handlers, and clean up open stdio files (most importantly flushing output buffers). A SIGINT handler could do this, but most programs don't bother; I don't know whether tail does.
– Barmar
Aug 23 '17 at 17:46
less is not always a better tool than tail, they're different and have different advantages. E.G. with tail -f I can press enter a few times to "mark" where I was, or I can use tail -f | grep (or awk, cut, etc)
– Josh
Aug 23 '17 at 19:49
SIGTERM / SIGINT termination indeed doesn't do that. However, this brings SIGTERM / SIGINT and SIGKILL even closer than I argued before ;)
– marcelm
Aug 25 '17 at 10:05
What I want is a normal way to quit, like q in top.
That's ControlC :)
I am just curious about the question, because I feel that killing the process is not a good way to quit something.
^C (ControlC) sends a SIGINT to the process, which is defined as:
The SIGINT signal is sent to a process by its controlling terminal when a user wishes to interrupt the process
That's exactly what you want to do here, is interrupt tail. There's no other way to accomplish what you're trying to do ("nicely" quit tail) and while other answers provide a means to stop tail in other ways, they're no better.
Pressing ^C will attempt to interrupt a task in Linux -- this is perfectly normal, and it's only "not good" if that process is in the middle of something and you're not letting it finish, and then the only "not good" side effect is leftover things from that process. As an example, ^C in the middle of a make command leaves partially-compiled software, but that's fine: a further run of make will clean that up / resume where it left off.
make example is a reminder why we always write .DELETE_ON_ERROR: in our Makefiles - we want Make to remove partially-written intermediate files when it learns that one of its commands received a signal.
– Toby Speight
Aug 23 '17 at 07:26
SIGINT and do cleanup before exit as indicated in Toby's .DELETE_ON_ERROR: example.
– Dennis Williamson
Aug 23 '17 at 15:45
^C :)
– Josh
Aug 23 '17 at 19:44
tail -ffilename, how to quit the mode without use Ctrl c to kill the process
You can't do that. Perhaps you wanted to run tail -f somefile | less
The Ctrl c is interpreted by the tty subsystem (and by your shell) and sends a SIGINT signal (see signal(7) and pty(7)...). See tty demystified.
This would work and answers your question, but is not a particularly satisfactory solution.
timeout 15s tail -f /var/log/messages
This will run the command for 15 seconds and then kill it for you, without having to press ^C
tail is being run on. Still, you're not wrong I guess.
– Aaron
Aug 22 '17 at 13:00
tail with SIGTERM better than terminating it with SIGINT?
– Dmitry Grigoryev
Aug 22 '17 at 14:53
Assuming you have a function
function prll(){
.....
pkill -9 -x tail
}
Assuming you run tail along your function
tail -n 1 -f file |
pv -l > /dev/null |
prll file
echo !!done!!
Conclusion, the answer is:
pkill -9 -x tail
Answers differ based on context. To quit tail -f elegantly, you will need a trigger. Assume you are trying to monitor output of a task that will finish at some point in time - that can become your trigger.
task >& filename.log &
task_pid=$!
tail -f filename.log &
tail_pid=$!
while [ 1 ]
do
# -0 is a special "poke" signal - "are you around?"
kill -0 $task_pid
if [ $? -eq 0 ]
then
# Original task is still alive.
sleep 2
continue
fi
kill -TERM $tail_pid
break
done
I have used similar ideas in the past.
Enjoy.
I think another good approach is using the old ps + kill in another session.
ps -fea | grep tail
The above command would identify any tail running by any user, and after finding the right PID, just run kill. For example:
kill 999999
Hope this can help someone as an alternative approach.
Issuing
echo tail -n 1 -f <filename>
works for me though I'm not 100% sure it terminates the tail process.
tail, -n, 1, -f and the filename with spaces between them.
– Kusalananda
Jun 02 '22 at 16:28
tailis not interactive; it does not take commands. – muru Aug 22 '17 at 07:13tail -fdoesn't have normal quit way, the only way is usingCtrl+c? – Key Shang Aug 22 '17 at 07:22kill <pid>orpkill tail, but all three do the same thing: send a signal totailthat kills it. – muru Aug 22 '17 at 07:23taildoesn't do much, so it's perfectly alright to kill it. – muru Aug 22 '17 at 07:49man signalfor more – mrc02_kr Aug 22 '17 at 07:56tailor even kill it without worry. But if you want an alternative, considermost, which has an admittedly under-documented "follow" mode, initiated with Shift+F, and can be cleanly exited with Q. – Toby Speight Aug 22 '17 at 15:49tail -fisn't that :) – Josh Aug 22 '17 at 21:34tail() { trap "stty intr '^c'" 2 0; stty intr q; command tail "$@"; }– Mark Plotnick Aug 22 '17 at 23:39