Liste der Nachkommenprozesse elegant abrufen

Ich möchte eine Liste aller Prozesse erhalten, von denen ich abstamme (z. B. Kinder, Enkelkinder usw.) $pid. Dies ist der einfachste Weg, den ich mir ausgedacht habe:

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

Gibt es einen Befehl oder eine einfachere Möglichkeit, die vollständige Liste aller untergeordneten Prozesse abzurufen?

Das Folgende ist etwas einfacher und hat den zusätzlichen Vorteil, dass Zahlen in den Befehlsnamen ignoriert werden:

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

Oder mit Perl:

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

Wir suchen nach Zahlen in Klammern, damit wir beispielsweise keine 2 als untergeordneten Prozess angeben, wenn wir darauf stoßen gif2png(3012). Wenn der Befehlsname jedoch eine Zahl in Klammern enthält, sind alle Wetten deaktiviert. Es gibt nur so weit Textverarbeitung können Sie.

Daher denke ich auch, dass Prozessgruppen der richtige Weg sind. Wenn Sie möchten, dass ein Prozess in einer eigenen Prozessgruppe ausgeführt wird, können Sie das Tool 'pgrphack' aus dem Debian-Paket 'daemontools' verwenden:

pgrphack my_command args

Oder Sie könnten sich wieder an Perl wenden:

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

Die einzige Einschränkung besteht darin, dass Prozessgruppen nicht verschachtelt werden. Wenn also ein Prozess seine eigenen Prozessgruppen erstellt, befinden sich seine Unterprozesse nicht mehr in der von Ihnen erstellten Gruppe.

descendent_pids() {
    pids=$(pgrep -P $1)
    echo $pids
    for pid in $pids; do
        descendent_pids $pid
    done
}

Die kürzeste Version, die ich gefunden habe, befasst sich auch korrekt mit Befehlen wie pop3d:

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

Es befasst sich falsch , wenn Sie Befehle haben , die seltsame Namen haben wie: my(23)prog.

Es gibt auch die Frage der Richtigkeit. Das einfache Parsen der Ausgabe von pstreeist aus mehreren Gründen problematisch:

• pstree zeigt PIDs und die IDs von Threads an (Namen werden in geschweiften Klammern angezeigt)
• Ein Befehlsname kann geschweifte Klammern und Zahlen in Klammern enthalten, die ein zuverlässiges Parsen unmöglich machen

Wenn Sie Python und das psutilPaket installiert haben, können Sie dieses Snippet verwenden, um alle nachfolgenden Prozesse aufzulisten:

pid=2235; python3 -c "import psutil
for c in psutil.Process($pid).children(True):
  print(c.pid)"

(Das psutil-Paket wird zB als eine Abhängigkeit des tracerBefehls installiert, der auf Fedora / CentOS verfügbar ist.)

Alternativ können Sie den Prozessbaum in einer Bourneshell im ersten Schritt durchlaufen:

ps=2235; while [ "$ps" ]; do echo $ps; ps=$(echo $ps | xargs -n1 pgrep -P); \
  done | tail -n +2 | tr " " "\n"

Zur Berechnung des Transitiv-Verschlusses einer PID kann der Endteil weggelassen werden.

Beachten Sie, dass der obige Befehl keine Rekursion verwendet und auch in ksh-88 ausgeführt wird.

Unter Linux kann man den pgrepAufruf unterdrücken und stattdessen die Informationen lesen von /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

Dies ist effizienter, da für jede PID ein Fork / Exec gespeichert wird und pgrepbei jedem Aufruf zusätzliche Arbeit geleistet wird.

Diese Linux-Version benötigt nur / proc und ps. Es ist aus dem letzten Stück von @ maxschlepzigs exzellenter Antwort angepasst . Diese Version liest / proc direkt aus der Shell, anstatt einen Unterprozess in einer Schleife zu erzeugen. Es ist ein bisschen schneller und wohl etwas eleganter, als der Titel dieses Threads verlangt.

#!/bin/dash

# Print all descendant pids of process pid $1
# adapted from /unix//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

Warum möchten Sie in jedem Ihrer beiden (scheinbar sehr künstlichen) Anwendungsfälle die Unterprozesse eines unglücklichen Prozesses beenden? Woher weißt du besser als ein Prozess, wann seine Kinder leben oder sterben sollten? Dies scheint mir ein schlechtes Design zu sein. Ein Prozess sollte nach sich selbst bereinigen.

Wenn Sie es wirklich besser wissen, sollten Sie diese Unterprozesse forken, und der "daemonisierte Prozess" ist anscheinend zu dumm, um ihm zu vertrauen fork(2).

Sie sollten vermeiden, Listen von untergeordneten Prozessen zu führen oder den Prozessbaum zu durchsuchen, z. B. indem Sie die untergeordneten Prozesse in eine separate Prozessgruppe einteilen, wie von @Gilles vorgeschlagen.

Ich vermute auf jeden Fall, dass Ihr daemonisierter Prozess besser dazu geeignet ist, einen Worker-Thread-Pool zu erstellen (der notwendigerweise zusammen mit dem enthaltenen Prozess abstirbt) als einen tiefen Baum von Sub-Sub-Sub-Prozessen, die irgendwo aufgeräumt werden müssen .

Hier ist ein pgrep-Wrapper-Skript, mit dem Sie pgrep verwenden und alle Nachkommen gleichzeitig abrufen können.

~/bin/pgrep_wrapper:

#!/bin/bash

# the delimiter argument must be the first arg, otherwise it is ignored
delim=$'\n'
if [ "$1" == "-d" ]; then
    delim=$2
    shift 2
fi

pids=
newpids=$(pgrep "$@")
status=$?
if [ $status -ne 0 ]; then
    exit $status
fi

while [ "$pids" != "$newpids" ]; do
    pids=$newpids
    newpids=$( { echo "$pids"; pgrep -P "$(echo -n "$pids" | tr -cs '[:digit:]' ',')"; } | sort -u )
done
if [ "$delim" != $'\n' ]; then
    first=1
    for pid in $pids; do
        if [ $first -ne 1 ]; then
            echo -n "$delim"
        else
            first=0
        fi  
        echo -n "$pid"
    done
else
    echo "$pids"
fi

Rufen Sie auf die gleiche Weise auf, wie Sie normale pgrep aufrufen würden pgrep_recursive -U $USER java, um beispielsweise alle Java-Prozesse und -Unterprozesse des aktuellen Benutzers zu finden.