Cfrtjryk

I would like to get a list of all the processes that descend (e.g. children, grand-children, etc) from $pid. This is the simplest way I've come up with:

pstree -p $pid | tr "n" " " |sed "s/[^0-9]/ /g" |sed "s/ss*/ /g"

Is there any command, or any simpler way to get the full list of all descendant processes?

The following is somewhat simpler, and has the added advantage of ignoring numbers in the command names:

pstree -p $pid | grep -o '([0-9]+)' | grep -o '[0-9]+'

Or with Perl:

pstree -p $pid | perl -ne 'print "$1n" while /((d+))/g'

We're looking for numbers within parentheses so that we don't, for example, give 2 as a child process when we run across gif2png(3012). But if the command name contains a parenthesized number, all bets are off. There's only so far text processing can take you.

So I also think that process groups are the way to go. If you'd like to have a process run in its own process group, you can use the 'pgrphack' tool from the Debian package 'daemontools':

pgrphack my_command args

Or you could again turn to Perl:

perl -e 'setpgid or die; exec { $ARGV[0] } @ARGV;' my_command args

The only caveat here is that process groups do not nest, so if some process is creating its own process groups, its subprocesses will no longer be in the group that you created.

descendent_pids() {

    pids=$(pgrep -P $1)

    echo $pids

    for pid in $pids; do

        descendent_pids $pid

    done

}

The shortest version I have found that also deals correctly with commands like pop3d:

pstree -p $pid | perl -ne 's/((d+))/print " $1"/ge'

It deals wrongly if you have commands that have weird names like: my(23)prog.

There is also the issue of correctness. Naively parsing the output of pstree is problematic for several reasons:

• pstree displays PIDs and the ids of threads (names are shown in curly braces)


• a command name might contain curly braces, numbers in parentheses that make reliable parsing impossible

If you have Python and the psutil package installed you can use this snippet to list all descendant processes:

pid=2235; python3 -c "import psutil

for c in psutil.Process($pid).children(True):

  print(c.pid)"

(The psutil package is e.g. installed as a dependency of the tracer command which is available on Fedora/CentOS.)

Alternatively, you can do an breadth-first traversal of the process tree in a bourne shell:

ps=2235; while [ "$ps" ]; do echo $ps; ps=$(echo $ps | xargs -n1 pgrep -P); 

  done | tail -n +2 | tr " " "n"

For computing the transitive-closure of a pid, the tail part can be omitted.

Note that the above doesn't use recursion and also runs in ksh-88.

On Linux, one can eliminate the pgrep call and instead read the information from /proc:

ps=2235; while [ "$ps" ]; do echo $ps ; 

  ps=$(for p in $ps; do cat /proc/$p/task/$p/children; done); done 

  | tr " " "n"' | tail -n +2

This is more efficient because we save one fork/exec for each PID and pgrep does some additional work in each call.

This Linux version needs /proc and ps only. It's adapted from the last piece of @maxschlepzig's excellent answer. This version reads /proc directly from the shell instead of spawning a sub-process in a loop. It's a bit faster and arguably slightly more elegant, as this thread title requests.

#!/bin/dash



# Print all descendant pids of process pid $1

# adapted from https://unix.stackexchange.com/a/339071



ps=${1:-1}

while [ "$ps" ]; do

  echo $ps

  unset ps1 ps2

  for p in $ps; do

    read ps2 < /proc/$p/task/$p/children 2>/dev/null

    ps1="$ps1 $ps2"

  done

  ps=$ps1

done | tr " " "n" | tail -n +2

In each of your two (seemingly very artificial) use cases, why do you want to kill some unfortunate process's sub-processes? How do you know better than a process when its children should live or die? This seems like poor design to me; a process should clean up after itself.

If you really do know better, then you should be forking these sub-processes, and the 'daemonized process' is apparently too dumb to be trusted to fork(2).

You should avoid keeping lists of child processes or grovelling through the process tree, eg by putting the child processes in a separate process group as suggested by @Gilles.

In any case, I suspect that your daemonized process would be better off creating a worker thread pool (which necessarily dies along with its containing process) than a deep tree of sub-sub-sub-processes, which something somewhere then has to clean up.