timeout: send a signal to a process after some time
September 20th, 2009 edited by VichoArticle submitted by Carsten Aulbert. Guess what? We still need you to submit good articles about software you like!
timeout (part of the SATAN package) is a nice little tool to terminate/send a signal to a process after a given time.
It usually takes two arguments, the first one is the time limit in seconds and the second the program to start. All trailing options are then passed to the started program.
It accepts a single numerical option which specifies what signal to send — be careful as its default is SIGKILL.
Quite useful on many occasions, e.g.: strace stats of a process PID for the next 300 seconds
timeout -2 300 strace -tt -c -p PID
Ensure that your ***** don’t play *****splay all day long (of course you need to make sure that they won’t be able to restart it ;))
timeout 3600 *****splay
Similar programs could be timelimit.
Package is available in Debian for ages (at least since etch) and Ubuntu since at least dapper.
September 21st, 2009 at 11:36 am
the Bash ulimit command does the same thing:
( ulimit -t 3600; *****splay )
creates a sub-shell with modified *****U time limit of 3600s that launches *****splay. Setting up a bash function or script as:
( ulimit -t $1 ; $2 ${@:3} )
can also be used as a replacement. (it would also need to check if all the arguments are set, etc., etc. $1 is the first argument, $2 the second, of course, and ${@:3}$ is all the arguments, starting from the third (so basically, the rest of the command line))
btw, I’ve been a long time debaday reader, keep up the good work!
September 21st, 2009 at 11:54 am
Steven:
Not it’s not the same. ulimit -t measures time in *****U. So if a process doesn’t consume *****U, it doesn’t timeout. For example,
(ulimit -t 3; sleep 10)
takes 10 seconds to execute, but
timeout 3 sleep 10
takes only the expected 3 seconds.
Thanks for the cheer up!
September 22nd, 2009 at 12:09 am
You’re quite right! I forgot about programs that are 99.999% idle… I suppose a lot of games are like that.
I used ulimit -St x -t y recently to limit a compute-intensive program and it works pretty well.
How does that program works? It forks then keep walltime and eventually kill the ***** process?
September 22nd, 2009 at 6:42 am
That’s right, it forks and execs the command. The parent installs a signal handler for a bunch of signals (including SIGALRM) and then, it sleeps in an alarm(time). When the alarm fires (or any of the other “terminate” signals are caught), the parent sends the signal (SIGKILL by default) to the command and returns the exit status of the command.
November 13th, 2009 at 8:32 am
If you want to limit the overall *****ren session duration, you should probably use timeoutd instead (with a final D). Unfortunately you’ll have to apply a patch to make it run correctly in Lenny but it is easy to do:
https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=522233