ps: ¿Cómo puedo obtener recursivamente todos los procesos secundarios para un pid dado?

¿Cómo puedo hacer que todo el árbol de procesos sea generado por un proceso dado que se muestra como un árbol y solo ese árbol, es decir, no hay otros procesos?

La salida podría, por ejemplo, verse como

 4378 ?        Ss     0:10 SCREEN
 4897 pts/16   Ss     0:00  \_ -/bin/bash
25667 pts/16   S+     0:00  |   \_ git diff
25669 pts/16   S+     0:00  |       \_ less -FRSX
11118 pts/32   Ss+    0:00  \_ -/bin/bash
11123 pts/32   S+     0:00      \_ vi

No pude obtener el resultado deseado simplemente con parámetros para ps.

Lo siguiente da el resultado deseado pero parece un poco complicado:

#!/bin/bash

pidtree() {
  echo -n $1 " "
  for _child in $(ps -o pid --no-headers --ppid $1); do
    echo -n $_child `pidtree $_child` " "
  done
}

ps f `pidtree 4378`

¿Alguien tiene una solución más fácil?

El pstreees una muy buena solución, pero es un poco reticente bits. Yo uso ps --foresten su lugar. Pero no para a PID( -p) porque imprime solo el proceso específico, sino para la sesión ( -g). Puede imprimir cualquier información que pspueda imprimir en un elegante árbol de arte ASCII que define la -oopción.

Entonces mi sugerencia para este problema:

ps --forest -o pid,tty,stat,time,cmd -g 2795

Si el proceso no es un líder de sesión, entonces se debe aplicar un poco más de truco:

ps --forest -o pid,tty,stat,time,cmd -g $(ps -o sid= -p 2795)

Esto obtiene el ID de sesión (SID) del proceso actual primero y luego llama a ps nuevamente con ese sid.

Si los encabezados de columna no son necesarios, agregue un '=' después de cada definición de columna en las opciones '-o', como:

ps --forest -o pid=,tty=,stat=,time=,cmd= -g $(ps -o sid= -p 2795)

Un ejemplo de ejecución y el resultado:

$ ps --forest -o pid=,tty=,stat=,time=,cmd= -g $(ps -o sid= -p 30085)
27950 pts/36   Ss   00:00:00 -bash
30085 pts/36   S+   00:00:00  \_ /bin/bash ./loop.sh
31888 pts/36   S+   00:00:00      \_ sleep 5

Desafortunadamente, esto no funciona, screenya que establece el sid para cada pantalla secundaria y para todos los nietos.

Para obtener todos los procesos generados por un proceso, es necesario construir todo el árbol. Solía awk para eso. Al principio construye una matriz hash para contener todo PID => ,child,child.... Al final, llama a una función recursiva para extraer todos los procesos secundarios de un proceso dado. El resultado se pasa a otro pspara formatear el resultado. El PID real debe escribirse como un argumento para awk en lugar de <PID>:

ps --forest $(ps -e --no-header -o pid,ppid|awk -vp=<PID> 'function r(s){print s;s=a[s];while(s){sub(",","",s);t=s;sub(",.*","",t);sub("[0-9]+","",s);r(t)}}{a[$2]=a[$2]","$1}END{r(p)}')

Para un proceso SCREEN (pid = 8041), el resultado de ejemplo se ve así:

  PID TTY      STAT   TIME COMMAND
 8041 ?        Ss     0:00 SCREEN
 8042 pts/8    Ss     0:00  \_ /bin/bash
 8092 pts/8    T      0:00      \_ vim test_arg test_server
12473 pts/8    T      0:00      \_ vim
12972 pts/8    T      0:00      \_ vim

pstree ${pid}

donde ${pid}está el pid del proceso padre.

En Gentoo Linux, pstreeestá en el paquete "psmisc", aparentemente ubicado enhttp://psmisc.sourceforge.net/

Aquí está mi versión que se ejecuta instantáneamente (porque se psejecuta solo una vez). Funciona en bash y zsh.

pidtree() (
    [ -n "$ZSH_VERSION"  ] && setopt shwordsplit
    declare -A CHILDS
    while read P PP;do
        CHILDS[$PP]+=" $P"
    done < <(ps -e -o pid= -o ppid=)

    walk() {
        echo $1
        for i in ${CHILDS[$1]};do
            walk $i
        done
    }

    for i in "$@";do
        walk $i
    done
)

He creado un pequeño script bash para crear una lista de pid de los procesos secundarios de un padre. Recurrentemente hasta que encuentre el último proceso hijo que no tiene ningún hijo. No te da una vista de árbol. Simplemente enumera todos los pid.

function list_offspring {
  tp=`pgrep -P $1`          #get childs pids of parent pid
  for i in $tp; do          #loop through childs
    if [ -z $i ]; then      #check if empty list
      exit                  #if empty: exit
    else                    #else
      echo -n "$i "         #print childs pid
      list_offspring $i     #call list_offspring again with child pid as the parent
    fi;
  done
}
list_offspring $1

primer argumento de list_offspring es el padre pid

ps -H -g "$pid" -o comm

no agrega un árbol per se, es solo la lista de procesos.

da por ejemplo

COMMAND
bash
  nvim
    python

He estado trabajando para encontrar una solución al mismo problema. Básicamente, ps manpage no documenta ninguna opción que permita hacer lo que queramos con un solo comando. Conclusión: se necesita un guión.

Se me ocurrió un guión muy similar al tuyo. Lo pegué en mi ~ / .bashrc para poder usarlo desde cualquier shell.

pidtree() {
  local parent=$1
  local list=
  while [ "$parent" ] ; do     
    if [ -n "$list" ] ; then
      list="$list,$parent"
    else
      list="$parent"
    fi
    parent=$(ps --ppid $parent -o pid h)
  done
  ps -f -p $list f
}

En camino en la línea de comandos:

ps -o time,pid,ppid,cmd --forest -g -p $(pgrep -x bash)

produce:

    TIME   PID  PPID CMD
00:00:00  5484  5480 bash
00:00:01  5531  5484  \_ emacs -nw .bashrc
00:00:01  2986  2984 /bin/bash
00:00:00  4731  2986  \_ redshift
00:00:00  5543  2986  \_ ps -o time,pid,ppid,cmd --forest -g -p 2986 5484

La forma más elegante de esa manera es definir una función en .bashrc:

function subps()                                                                                    
{                                                                                                   
    process=$(pgrep -x $1)                                                                                                                                                                     
    ps -o time,pid,ppid,cmd --forest -g -p $process                                                 
}    

luego en la línea de comando ejecutar:

subps bash

Esto proporciona solo los pid hijos pid + cada uno en una línea, lo cual es útil para su posterior procesamiento.

pidtree() {
    for _pid in "$@"; do
        echo $_pid
        pidtree `ps --ppid $_pid -o pid h`
    done
}

Hice un guión similar basado en lo anterior de Philippe

pidlist() {
local thispid=$1
local fulllist=
local childlist=
childlist=$(ps --ppid $thispid -o pid h)
for pid in $childlist
do
  fulllist="$(pidlist $pid) $fulllist"
done
echo "$thispid $fulllist"
}

Esto genera todos los pids secundarios, nietos, etc. en formato delimitado por espacios. Esto, a su vez, puede ser alimentado a ps, como en

ps -p $ (pidlist pid )

para todo el proceso - pstree -a show by user - pstree user