Update: trap requires removing SIG prefix on condition, although some shells support including it. See comment below.

The ampersand "&" runs a command in the background in a new process. When its parent process (the command that runs the bash script in your case) ends, this background process will reset its parent process to init (process with PID 1), but will not die. When you press ctrl+c, you are sending an interrupt signal to the foreground process, and it will not affect the background process.

In order to kill the background process, you should use the kill command with the PID of the most recent background process, which could be obtained by $!.

If you want the to use ctrl+c to kill both the script and background process, you can do this:

trap 'kill $BGPID; exit' INT
sleep 1024 &    # background command
BGPID=$!
sleep 1024      # foreground command of the script

trap modifies the trap handler of the SIGINT (trap requires removing the SIG prefix but some shell may support including it) so the script will kills the process with $BGPID before it exits.

For anyone wondering, this is how you launch childs in the background and kill them on ctrl+c:

#!/usr/bin/env bash
command1 &
pid[0]=$!
command2 &
pid[1]=$!
trap "kill {pid[1]}; exit 1" INT
wait

Just negate the pgid when you specify the pid to kill. You should be able to use $$ as the process group, but sometimes it's convenient to pull the process group id from ps. Try:

#!/bin/bash

echo "This runs 8 similar versions of giza"

pgid=$(ps -o pgid= $$ | tr -d ' ')
trap 'kill -- -$pgid' 0

for d in giza_google giza giza_{1..6}; do
        (cd $d; sh runAgent) &
done
wait

Note that I've changed the name of the script to runAgent without the .sh suffix. See https://www.talisman.org/~erlkonig/documents/commandname-extensions-considered-harmful/

Your kill command is backwards.

Like many UNIX commands, options that start with a minus must come first, before other arguments.

If you write

kill -INT 0

it sees the -INT as an option, and sends SIGINT to 0 (0 is a special number meaning all processes in the current process group).

But if you write

kill 0 -INT

it sees the 0, decides there's no more options, so uses SIGTERM by default. And sends that to the current process group, the same as if you did

kill -TERM 0 -INT    

(it would also try sending SIGTERM to -INT, which would cause a syntax error, but it sends SIGTERM to 0 first, and never gets that far.)

So your main script is getting a SIGTERM before it gets to run the wait and echo DONE.

Add

trap 'echo got SIGTERM' TERM

at the top, just after

trap 'killall' INT

and run it again to prove this.

As Stephane Chazelas points out, your backgrounded children (process1, etc.) will ignore SIGINT by default.

In any case, I think sending SIGTERM would make more sense.

Finally, I'm not sure whether kill -process group is guaranteed to go to the children first. Ignoring signals while shutting down might be a good idea.

So try this:

#!/bin/bash
trap 'killall' INT

killall() {
    trap '' INT TERM     # ignore INT and TERM while shutting down
    echo "**** Shutting down... ****"     # added double quotes
    kill -TERM 0         # fixed order, send TERM not INT
    wait
    echo DONE
}

./process1 &
./process2 &
./process3 &

cat # wait forever

&(Ampersand) sends the process to the background. It means if you run "run_webserver &" then this process will run in the backgrond.

You can bring this process to foreground by looking at the job id for the process in the terminal.

Steps to bring the process to foreground and kill

1. jobs :--> this command will list all the process running on the terminal.

2. fg :--> this command will bring the process to the foreground.

Then you can use your ctrl-c to kill the process, or any other sequence which kills the process.

Please find the attached screen shots:-

You can try trapping SIGINT to kill 0 in envar:

$ cat envar
trap "kill 0" SIGINT
spinner()
{ 
  spin='-\|/'
  i=0
  while kill -0 $1 2>/dev/null
  do
    i=$(( (i+1) %4 ))
    printf "\e[1;33m"
    printf "\r${spin:$i:1}"
    printf "\e[m"
    sleep .1
  done
}

This will make the subshell also die. I tested with:

$ cat foo.sh
#!/bin/bash

## source your function file
. envar

sleep 600 &
pid=$!
spinner $pid
echo "$jobs done"

Running this and killing with Ctrl+C results in:

$ foo.sh
/^CTerminated
$ pgrep -c sleep
0

First, you should know that kill 0 send the signal to all process in current process group. (see kill(1) - Linux man page) My guess is that it is killing more than it should. This is why wait is not waiting, it is being terminated for some reason. My best bet to solve this problem is to iterate over running jobs from jobs -pr killing one by one: this way I assure the signal is sent only to child processes in that moment and nothing more.

To get this to work I did several tests, but I was stuck on sending SIGINT to child processes. They simple don't react to it! Searching the web I've found this answer on Stack Overflow:

https://stackoverflow.com/questions/2524937/how-to-send-a-signal-sigint-from-script-to-script-bash

So the real problem is that you cannot send SIGINT from one script to other, because in non-interactive shells the signal is ignored. I was not able to workaround this issue (using bash -i to call the child script does not to work).

I know you probably want to send SIGINT and wait for the child processes to shutdown gracefully, but if you do not mind to use SIGTERM (or any other signal but SIGINT) this is the best script I wrote:

#!/bin/bash
trap 'killall' INT

killall() {
    echo '**** Shutting down... ****'
    jobs -pr
    for i in $(jobs -pr); do
        kill -TERM $i
    done
    wait
    echo DONE
}

./long.sh &
./long.sh &
./long.sh &

cat # wait forever

To test, I've created this long.sh script:

#!/bin/bash
trap 'killall' TERM

echo "Started... $$" >> file.txt

killall() {
    # shutting down gracefully
    echo "Finished... $$" >> file.txt
    exit # don't forget this!
}

# infinite loop
while true; do echo loop >/dev/null ; done

In this last script I did not use sleep function because it creates a new process that was staying on memory even after the script finishes. In your script, you can call new processes but you should assure to broadcast the SIGTERM (or any other signal you've used) to all of them.

When you write the command

`./my_script.sh 1` &

you are doing a command substitution (see below).
Practically you are executing a subshell (the one for the backticks ``) in background (&) in which it runs your script (./my_script.sh 1).

The present shell is waiting the end of the execution of its subshell to run its output as commands.
The subshell is waiting the end of your script.
When you press Ctrl+C you interrupt this waiting, passing the signal SIGINT to the child.

In this moment the current shell tries to run as command the output obtained till now... and it generates the error 130 that means "Script terminated by Control-C" ^[2].

With the backticks ``, as well as with $(), in bash you are doing a command substitution ^[1]:

Bash performs the expansion by executing COMMAND and replacing the command substitution with the standard output of the command, with any trailing newlines deleted.

for example

echo `date`   
Thu Feb 6 10:06:20 CET 2003 

Note that if you run in background more of this kind of commands

`./myscript 1` &
`./myscript 2` &
`./myscript 3` &

it is always the current shell that is waiting for all the childs output. A single Ctrl+C will end this waiting for all together.

If instead you will wait the end of the script, the current shell will try to execute their output as they will finish.

There are many ways to go about this.

Method #1 - ps

You can use the ps command to find the process ID for this process and then use the PID to kill the process.

Example

$ ps -eaf | grep [w]get 
saml      1713  1709  0 Dec10 pts/0    00:00:00 wget ...

$ kill 1713

Method #2 - pgrep

You can also find the process ID using pgrep.

Example

$ pgrep wget
1234

$ kill 1234

Method #3 - pkill

If you're sure it's the only wget you've run you can use the command pkill to kill the job by name.

Example

$ pkill wget

Method #4 - jobs

If you're in the same shell from where you ran the job that's now backgrounded. You can check if it's running still using the jobs command, and also kill it by its job number.

Example

My fake job, sleep.

$ sleep 100 &
[1] 4542

Find it's job number. NOTE: the number 4542 is the process ID.

$ jobs
[1]+  Running                 sleep 100 &

$ kill %1
[1]+  Terminated              sleep 100

Method #5 - fg

You can bring a backgrounded job back to the foreground using the fg command.

Example

Fake job, sleep.

$ sleep 100 &
[1] 4650

Get the job's number.

$ jobs
[1]+  Running                 sleep 100 &

Bring job #1 back to the foreground, and then use Ctrl+C.

$ fg 1
sleep 100
^C
$

Set-up a trap handling SIGINT (Ctrl+C). In your case that would be something like:

trap "kill -2 $pid1 $pid2" SIGINT

Just place it before the wait command.

You can get the PID of mplayer and upon trapping send the kill signal to mplayer's PID.

function clean_up {

    # Perform program exit housekeeping
    KILL $MPLAYER_PID
    exit
}

trap clean_up SIGHUP SIGINT SIGTERM
mplayer sound.mp3 &
MPLAYER_PID=$!
wait $MPLAYER_PID