Killing all child processes?

Kevin

unread,

Apr 23, 2002, 10:23:36 PM4/23/02

to

Hi all,

I can't seem to get my python program to kill all the child prcoesses
that it may fork. Is this possible?

I've researched usenet+the web and read subproc.py from
ftp.python.org, but still no go.

My latest attempt was a python script that forks itself, uses setpgid,
then the child does an execl(). The execl'd program creates some
children. Meanwhile, the parent decides time is up on the child and
tries to kill everything, but my os.kill(pid,9) only succeeds in
killing the child aka the execvp'd process.

There's another bug that I haven't yet addressed about the parent
waiting around when the child doesn't write to either of the pipes.
But that'd not my focus now, so don't worry about that; I just want
all the children to die.

My full code it at the bottom. Hints, anyone? This is on Linux and
FreeBSD.

Thanks,
Kevin

---Full code follows---
---- pcontrol.py below
#!/usr/bin/python
#
# pcontrol.py
#

import os
import sys
import signal

_alarm = "request timed out"

time = 5

cmd="sh1.sh"

###########################################################

def alarm_handler(a , b):
global _alarm
signal.alarm(0)
raise _alarm

###########################################################

# Okay, let's do this the hard way: create two unnamed
# pipes for stdout/err. Then, fork this process, and the
# child becomes the new command and shoves their output
# onto the pipes, while the parent waits for the child to die.

# Create two named pipes
child_out_r, child_out_w = os.pipe()
child_err_r, child_err_w = os.pipe()

# Let's fork a child that gets replaced with the test process - krf
child_pid = os.fork()

if (child_pid != 0):
# We're the parent

os.close(child_out_w) # the parent won't read the pipes
os.close(child_err_w)

os.setpgid(child_pid, 0)

# Now do the timing...
signal.signal(signal.SIGALRM, alarm_handler)
signal.alarm(time)

try:
child_pid, child_status = os.waitpid(child_pid, 0); # wait for
child
except OSError:
print("OSError... did the executable time out?")
child_status = -1 # this is the same as a timeout for now
except _alarm:
print("Timed out")
# kill it!
os.kill(child_pid, 9)
child_status = -1 # timeout

signal.alarm(0) # clean up alarm

else:
# We're the child
os.setpgid(0, 0) # now the child is it's group leader (?)

# Redirect error to our pipes
os.close(child_out_r) # the child won't read the pipes
os.close(child_err_r)
os.dup2(child_out_w, sys.stdout.fileno())
os.dup2(child_err_w, sys.stderr.fileno())

# replace the process
os.execl(cmd, cmd) #strange, but execl->execv needs a second
arg...
# the child is no more... (assuming success)

print "Status = ", child_status
print "Child stdout [",os.read(child_out_r,999),"]"
print "Child stderr [",os.read(child_err_r,999),"]"

------- sh1.sh below
#!/bin/sh

echo "This is processs (1) $$."
sh2.sh &
sh3.sh &
sleep 600
echo "Process (1) $$ exiting."

------- sh2.sh below
#!/bin/sh

echo "This is processs (2) $$."
sleep 600
echo "Process (2) $$ exiting."

------- sh3.sh below
#!/bin/sh

echo "This is processs (3) $$."
sleep 600
echo "Process (3) $$ exiting."

Noah

unread,

Apr 24, 2002, 3:59:58 AM4/24/02

to

You want to kill the process group.
Practically the only change you need to make is to
call os.kill with the negative of the child pid.

So in the line that reads:
os.kill(child_pid, 9)
You need to change it to read:
os.kill(-child_pid, 9)
That kills the given pid and every process that has a
process group id with the same number as the child_pid.

You ensured that all the children had the same group as
the first child (session leader) when you wrote this line:
os.setpgid(0, 0)
But note that Python has a special call just for that:
os.setpgrp() # Sets process session leader.

FYI, execlp() takes two arguments because the
first one is the path to the command to exec and the second
one is supposed to become the argv[0] of the command.
But it doesn't seem to do that. I'm not sure why.

Yours,
Noah

Martin Barnard

unread,

Apr 24, 2002, 3:51:48 AM4/24/02

to

Shouldn't you be looking into each child process having a handler to
pass on any SIG events it receives from STDIN (or parent)?
e.g. for each child process, take a PID and store it.
If parent receives a SIG event, then pass it down to child processes.
Each child process should have the same handler code in also (possibly
with a signal to parent if it quits, so that the list of child processes
is current for each parent).
Sorry if it sounds a little strange, I've just woken up, and am rambling
a little :)

Let's see if I can visualise:

The only potential problem would be if a child branch died before hand,
and the PID was taken by another process that Parent_1 could kill (same
user).

Hope this helps, if not, just ignore my waffling.

Martin.

> --
> http://mail.python.org/mailman/listinfo/python-list
>
--
Experience is that marvelous thing that enables you recognize a mistake
when you make it again.
-- F. P. Jones