You might want different behavior if the parent is just done, or if you've gone and SIGINTed (control-c) the parent. For This is wrote a little set that had some useful code in it:

• All childs forking record their PID as a key into a hash called scythe. The values are pointers to functions that should be performed for cleanup.
• It has a reaper function attached to the SIGCHLD to handle the death of a child. This collects its exit value, and passes it as an argument to the function that was stored for cleanup.
• There's a bait function that does not cleanup but is a valid function reference for a child to have a value in the scythe.
• There's an event on SIGINT that kills child processes which remain before exiting. Otherwise you could waitpid on all the keys in scythe.
• A function named phork will setup a child that doesn't need special post processing and execute the args as a unix command. (this is not so useful for your dummy function, but it can be used as an example of setting up a nice child process)

The code follows:

use POSIX qw(:sys_wait_h);
use IO::Handle;

my %scythe;                     # a scythe for the REAPER (see FAQ);

$SIG{CHLD} = \&REAPER;          # set handling of zombie child process
+es.

STDOUT->autoflush;              # make sure output is flushed before f
+orking

# setup an interupt handler
#  kills every pid used as a key in %scythe
####################
$SIG{INT} = sub {
    print "\nCleaning: ";
    print join(", ", keys(%scythe));
    print "\n";
    kill('INT', keys %scythe);
    print "done with: ";
    print join(", ", keys(%scythe));
    die "\n";
};

#### MAIN ####

#### END MAIN, begin defs ####

sub phork {
  # we will call fork and return a pid.  The child will exec with all 
+args
  # and suppress the child's output;
  my $pid;

  if ($pid = fork) {                    # fork the process;
    #parent
    return $pid;
  }else
  {
    #child
    die "CANNOT FORK!!\n" unless defined $pid;
    close(STDOUT);                      # suppressing output
    close(STDERR);                      # suppressing output
    {exec(@_);};                        # calls exec with current @_
    exit(1);                            # exec may maybe fail... maybe
+.
  }
}
 
 
sub baitKiller {
#  This functions is a dummy to be used to be added to %scythe for a $
+pid
#  This way when the interupt is called, the process with the $pid wil
+l
#  be cleaned up (killed) so it doesn't keep running after its parent'
+s
#  death.  If you'd rather it did, just don't assign anything in %scyt
+he
#  for the key of it's $pid.
        return "Come get some!";
}
 
sub REAPER {
# we reap child processes, and post process it.
# note: this sub relies on a global %scythe
#   sort of...  if a $scythe{$pid} is defined, it will assume that its
+ a
#     reference to a function that takes $pid and $exit_value as args
#     and presumably does something useful with that.  Then it deletes
+ the
#     $scythe{$pid} hash entry.   is it not nifty?

  # local vars
  my $pid;
  my $exit_value;

  $pid = waitpid(-1, &WNOHANG);

  if($pid == -1) {
    # no child waiting
  }
  elsif (WIFEXITED($?))
  {
    # the process exited, get exit value.
    my $slot;
    my $state;

    $exit_value = $? >> 8;
    if (exists($scythe{$pid})) {
      $scythe{$pid}->( $pid, $exit_value );
      delete($scythe{$pid});
    } else {
      # we're reaping something we didn't sow or didn't care about;
      return;
    }
  }  
  else
  {
    # false alarm on $pid
  }
  $SIG{CHLD} = \&REAPER;                #reset signal handling.
} #end sub REAPER
[download]