Preforked children not killed when parent is killed

[macli]

Hi Monks, I run a prefork server sample script from perl cookbook:

#./prefork.pl &
# ps -ef | grep prefork.pl
root     22626   947  0 15:34 pts/3    ./prefork.pl
root     22627 22626  0 15:34 pts/3    ./prefork.pl
root     22628 22626  0 15:34 pts/3    ./prefork.pl
#kill 22626
#ps -ef | grep prefork
root     22627     1  0 15:34 pts/3  ./prefork.pl
root     22628     1  0 15:34 pts/3  ./prefork.pl

From what I understand, when I killed the parent, the children should get killed too, but why the children become orphaned and adopted by init.What changes can be made to the scipt to kill the children when parent is killed?

I comment the sig handling code, it does the same thing,

=for nobody
sub REAPER {                    # takes care of dead children
    my $pid = wait;
    $children--;
    delete $children{$pid};
    $SIG{CHLD} = \&REAPER;      # reset as necessary, should be at end
}

sub HUNTSMAN {                  # signal handler for SIGINT
    local ( $SIG{CHLD} ) = 'IGNORE';    # we're going to kill our chil
+dren
    kill 'INT' => keys %children;
    exit 0;                             # clean up with dignity
}

=cut


# Install signal handlers.
#$SIG{CHLD} = \&REAPER;
#$SIG{INT}  = \&HUNTSMAN;

The sample script is below:

#!/usr/bin/perl
# preforker - server who forks first
use strict;
use warnings;

use IO::Socket;
use Symbol;
use POSIX;

# establish SERVER socket, bind and listen.
my $server = IO::Socket::INET->new(
    LocalPort => 6969,
    Type      => SOCK_STREAM,
    Proto     => 'tcp',
    Reuse     => 1,
    Listen    => 10
  )
  or die "making socket: $@\n";

# global variables
my $PREFORK               = 2;     # number of children to maintain
my $MAX_CLIENTS_PER_CHILD = 5;     # number of clients each child shou
+ld process
my %children              = ();    # keys are current child process ID
+s
my $children              = 0;     # current number of children
my $client;

sub REAPER {         # takes care of dead children
    my $pid = wait;
    $children--;
    delete $children{$pid};
    $SIG{CHLD} = \&REAPER;# reset as necessary, should be at end
}

sub HUNTSMAN {       # signal handler for SIGINT
  local ( $SIG{CHLD} ) = 'IGNORE'; # we're going to kill our children
    kill 'INT' => keys %children;
    exit 0;                   # clean up with dignity
}


# Fork off our children.
for ( 1 .. $PREFORK ) {
    make_new_child();
}

# Install signal handlers.
$SIG{CHLD} = \&REAPER;
$SIG{INT}  = \&HUNTSMAN;

# And maintain the population.
while (1) {
    sleep;    # wait for a signal (i.e., child's death)
    my $i;
    for (  $i = $children ; $i < $PREFORK ; $i++ ) {
        make_new_child();    # top up the child pool
    }
}

sub make_new_child {
    my $pid;
    my $sigset;
    my $i;

    # block signal for fork
    $sigset = POSIX::SigSet->new(SIGINT);
    sigprocmask( SIG_BLOCK, $sigset )
      or die "Can't block SIGINT for fork: $!\n";

    die "fork: $!" unless defined( $pid = fork );

    if ($pid) {

        # Parent records the child's birth and returns.
        sigprocmask( SIG_UNBLOCK, $sigset )
          or die "Can't unblock SIGINT for fork: $!\n";
        $children{$pid} = 1;
        $children++;
        return;
    }
    else {

        # Child can *not* return from this subroutine.
        $SIG{INT} = 'DEFAULT';    # make SIGINT kill us as it did befo
+re

        # unblock signals
        sigprocmask( SIG_UNBLOCK, $sigset )
          or die "Can't unblock SIGINT for fork: $!\n";

        # handle connections until we've reached $MAX_CLIENTS_PER_CHIL
+D
        for ( $i = 0 ; $i < $MAX_CLIENTS_PER_CHILD ; $i++ ) {
            $client = $server->accept() or last;

            # do something with the connection
        }

        # tidy up gracefully and finish

        # this exit is VERY important, otherwise the child will become
        # a producer of more and more children, forking yourself into
        # process death.
        exit;
    }
}