How to Kill Current Command When Bash Script is Killed

Question

I current have a script that looks like this.

# code

mplayer "$vid"

# more code

The problem is that if this script is killed the mplayer process lives. I wondering how I could make it so that killing the script would kill mplayer as well.

I can't use exec because I need to run commands after mplayer.

exec mplayer "$vid"

The only possible solution I can think of is to spawn it in the background and wait until it finishes manually. That way I can get it's PID and kill it when the script gets killed, not exactly elegant. I was wondering what the "proper" or best way of doing this is.

Answer 1

I was able to test the prctl idea I posted about in a comment and it seems to work. You will need to compile this:

#include "sys/prctl.h"
#include "stdlib.h"
#include "string.h"
#include "unistd.h"

int main(int argc, char ** argv){

  prctl(PR_SET_PDEATHSIG, atoi(argv[1]),0,0,0);

  char * argv0 = strdup(argv[2]);

  char * slashptr = strrchr(argv0, '/');
  if(slashptr){
    argv0 = slashptr + 1;
  }

   return execvp(argv0, &(argv[2]));



}

Let's say you have compiled the above to an executable named "prun" and it is in your path. Let's say your script is called "foo.sh" and it is also in your path. Make a wrapper script that calls

prun 15 foo.sh

foo.sh should get SIGTERM when the wrapper script is terminated for any reason, even SIGKILL.

Note: this is a linux only solution and the c source code presented is without detailed checking of arguments

Answer 2

Thanks to Mux for the lead. It appears that there is no way to do this in bash except for manually catching signals. Here is a final working (overly commented) version.

trap : SIGTERM SIGINT # Trap these two (killing) signals.  These will cause wait
                      # to return a value greater than 128 immediately after received.

mplayer "$vid" & # Start in background (PID gets put in `$!`)
pid=$!

wait $pid # Wait for mplayer to finish.
[ $? -gt 128 ] && { kill $pid ; exit 128; } ; # If a signal was recieved
                                              # kill mplayer and exit.

Refrences: - traps: http://tldp.org/LDP/Bash-Beginners-Guide/html/sect_12_02.html

Answer 3

(Updated) I think I understand what you are looking for now:

You can accomplish this by spawning a new terminal to run your script:

gnome-terminal -x /path_to_dir_of_your_script/your_script_name

(or use xterm -e or konsole -e instead of gnome-terminal -x, depending on what system you are on)

So now whenever your script ends / exits (I assume you have exit 0 or exit 1 in certain parts of the script), the newly spawned terminal will also exit since the script is finished - this will in turn also kill any applications spawned under that new terminal.

For example, I just tested the above command with this script:

#!/bin/bash

gedit &
pid=$!
echo "$pid"

sleep 5
exit 0

As you can see, there are no explicit calls to kill the new gedit process, but the application (gedit) closes as soon as the script exits anyway.

(Previous answer: alternatively, if you were simply asking about how to kill a process) Here's a short example of how you can accomplish that with kill.

#!/bin/bash

gedit &
pid=$!
echo "$pid"

sleep 5
kill -s SIGKILL $pid

Unless I misunderstood your question, you can get the PID of the spawned process right away instead of waiting until it finishes.

Answer 4

Well, you can simply kill the process group instead, this way the whole process tree will be killed, first find out the group id

ps x -o  "%p %r  %c" | grep <name>

And then use kill like so:

kill -TERM -<gid>

Note the dash before the process group id. Or a one-liner:

kill -TERM -$(pgrep <name>)

Answer 5

Perhaps use command substitution to run mplayer "$vid" in a subshell:

$(mplayer "$vid")

---

I tested it this way:

tesh.sh:

#!/bin/sh
$vid = "..."
$(mplayer "$vid")

---

% test.sh

In a separate terminal:

% pkill test.sh

In the orginal terminal, mplayer stops, printing to stderr

Terminated
MPlayer interrupted by signal 13 in module: av_sync