Comment obtenir la ligne de commande arguments passés à un processus en cours d'exécution sur les systèmes unix/linux?

Sur SunOS il est pargs de commande qui imprime les arguments de ligne de commande passés au processus en cours d'exécution.

Est il existe une commande similaire sur d'autres environnements Unix?

  • tr \\0 ' ' < /proc/<pid>/cmdline
InformationsquelleAutor Hemant | 2009-05-04
  1. 278

    Il y a plusieurs options:

    ps -fp <pid>
cat /proc/<pid>/cmdline | sed -e "s/\x00//g"; echo

    Il n'y a plus d'infos dans /proc/<pid> sur Linux, il suffit de jeter un coup d'oeil.

    Sur d'autres systèmes Unix, les choses peuvent être différentes. Le ps commande fonctionnera partout, la /proc truc est spécifique au système d'exploitation. Par exemple sur AIX il n'y a pas de cmdline dans /proc.

    • sur linux, vous aurez probablement besoin d'-ww (c'est à dire ps -ww -fp <pid>) pour spécifier l'échelle de sortie, car si il y a plusieurs commandes, ils pourraient être coupée.
    • Pour plus de précisions, le fichier n'est pas /<pid>/, mais plutôt de /proc/<pid>
    • le -ww option permet l'accès à tous les arguments de ligne de commande (comme beaucoup comme est stockée par le noyau). Voir Aussi: comment solaris et bsd obtenir le untruncated ligne de commande paramètres d'un processus d' et ps options
    • cat /proc/<pid>/cmdline travaille également sur Cygwin, où la ligne de cmd arguments ne sont pas affichés dans ps avec toutes les options.
    • Sur Linux, si vous avez seulement besoin d'obtenir le args, la commande est ps -o args -p <pid> et il ne imprimer la args ou utilisez -o cmd si vous avez seulement besoin de voir le cmd. Essayer de lire /proc/<pid>/cmdline ne sera pas toujours le cas pour les unprivilege utilisateurs. Le ps l'utilitaire de travail.
    • Conseil: la longueur de /proc/<pid>/cmdline est limitée (codé en dur à la valeur de PAGE_SIZE paramètre de noyau), de sorte que plus les lignes de commande sont toujours tronqués! Voir stackoverflow.com/questions/199130/... pour plus d'info. Vous pouvez interroger votre paramètre du noyau avec getconf PAGE_SIZE, il est généralement 4096.
    • wow c'est génial, le ps -fp commande a fonctionné pour moi sur Debian et Ubuntu.
    • Notez que la commande peut être exécutée avec un nom différent (premier arg); dans ce cas, vous pouvez regarder /proc/<pid>/comm

    InformationsquelleAutor markus_b
  2. 60

    Cela fera l'affaire:

    xargs -0 < /proc/<pid>/cmdline

    Sans xargs, il n'y aura pas d'espaces entre les arguments, parce qu'ils ont été convertis NULs.

    • Cela peut être raccourcie à xargs -0 < /proc/<pid>/cmdline.
    • Vous avez raison, j'ai mis à jour la réponse.
    • Il est stil tronquer ma sortie. Tout conseiller?
    • Jamais remarqué aucune troncature - pouvez-vous donner un exemple?
    InformationsquelleAutor Michael Böckling
  3. 16

    Plein de ligne de commande

    Pour Linux & Système Unix, vous pouvez utiliser ps -ef | grep process_name pour obtenir la ligne de commande complet.

    Sur SunOS systèmes, si vous voulez obtenir plein de ligne de commande, vous pouvez utiliser 

    /usr/ucb/ps -auxww | grep -i process_name

    Pour obtenir le plein de ligne de commande vous avez besoin pour devenir super-utilisateur.

    Liste des arguments

    pargs -a PROCESS_ID

    donnera une liste détaillée des arguments passés à un processus. Il sera de sortie le tableau des arguments de ce genre:

    argv[o]: first argument
argv[1]: second..
argv[*]: and so on..

    Je n'ai pas trouvé de similaire de commande pour Linux, mais je voudrais utiliser la commande suivante pour obtenir le même résultat:

    tr '
    tr '\0' '\n' < /proc/<pid>/environ

    ' '\n' < /proc/<pid>/environ
    • la meilleure réponse de l'omi +1
    InformationsquelleAutor LOGAN
  4. 14

    Sur Linux

    cat /proc/<pid>/cmdline

    vous la ligne de commande du processus (y compris args) mais avec tous les espaces changé à NUL caractères.

    • Les espaces n'est pas supprimé, il est remplacé par NULs.
    • Ah, je n'ai pas vérifier. Bonne prise!
    • xargs -0 echo < /proc/<pid>/cmdline . Vous pouvez également le faire avec /proc/<pid>/environ aussi, bien que vous voudrez peut-être ajouter -n 1 pour l'.
    • Sur mon système, il n'y a pas de système de fichiers /proc 🙁 toute autre solution ?
    • Le mien est un processus java avec des de longue de longue de longue paramètres. Il est stil tronquer ma sortie. Tout conseiller?
    • Je viens de réaliser que j'ai voté en bas de cette réponse par accident. J'ai l'intention de voter, jusqu'à. Désolé.
    • Que doit être l'endroit où tous ceux mystère bas-votes viennent! 🙂

    InformationsquelleAutor lothar
  5. 12

    Vous pouvez utiliser pgrep avec -f (ligne de commande complet) et -l (description longue):

    pgrep -l -f PatternOfProcess

    Cette méthode a une différence essentielle avec les autres réponses: il fonctionne sur CygWin, de sorte que vous pouvez l'utiliser pour obtenir la ligne de commande complet de tous les processus s'exécutant sous Windows (exécuter en tant que élevée si vous souhaitez que les données relatives à toute élévation/admin processus). Toute autre méthode pour ce faire sur Windows est plus maladroit, par exemple.

    En outre: au cours de mes tests, le pgrep a été le seul système qui fonctionne pour obtenir le chemin d'accès complet pour scripts en cours d'exécution à l'intérieur de CygWin du python.

    • Ce qu'en réalité on imprime l'exécutable d'origine nom de trop: $ exec -a fakename bash & [1] 14102 [1]+ Stopped exec -a fakename bash $ xargs -0 < /proc/14102/cmdline; fakename $ pgrep -l -f fakename; 14102 bash
    InformationsquelleAutor Sopalajo de Arrierez
  6. 3

    Une autre variante de l'impression /proc/PID/cmdline avec des espaces Linux est:

    cat -v /proc/PID/cmdline | sed 's/\^@/\ /g' && echo

    De cette façon cat imprime Les caractères NULL comme ^@ puis de les remplacer par un espace à l'aide de sed; echo imprime un caractère de saut de ligne.

    • Pour info, vous pouvez également utiliser chat -v /proc/PID/cmdline | sed 's/\^@/\n/g'. Il remplacera le caractère null avec un caractère de saut de ligne. En agissant de la sorte, chaque argument sera imprimé sur sa propre ligne. De cette façon, il est plus facile de dire à un argument d'un autre.
    InformationsquelleAutor Diego
  7. 2

    Plutôt que l'utilisation de plusieurs commandes pour modifier le flux, il suffit d'utiliser un tr se traduit par un personnage à l'autre:

    tr '
    tr '\0' ' ' </proc/<pid>/cmdline

    ' ' ' </proc/<pid>/cmdline
    InformationsquelleAutor Tom Evans
  8. 1

    En plus de tous les moyens ci-dessus pour convertir le texte, si vous utilisez simplement les 'chaînes', il va faire la sortie sur des lignes séparées par défaut. Avec l'avantage supplémentaire qu'il peut également empêcher les caractères qui peut brouiller votre terminal d'apparaître.

    À la fois de sortie en une seule commande:

    cordes /proc/cmdline /proc//environ

    La vraie question est... est-il un moyen de voir la vraie ligne de commande d'un processus dans Linux qui a été modifié de sorte que le cmdline contient le texte modifié au lieu de la commande réelle qui a été exécuté.

    InformationsquelleAutor Timothy J. Biggs
  9. 1

    Sur Solaris

         ps -eo pid,comm

    similaire peut être utilisé sur les systèmes unix.

    InformationsquelleAutor HuntM
  10. 1

    Sur Linux, avec bash, à la sortie, tel que cité args de sorte que vous pouvez modifier la commande et exécutez à nouveau il

    </proc/"${pid}"/cmdline xargs --no-run-if-empty -0 -n1 \
    bash -c 'printf "%q " ""' /dev/null; echo

    Sur Solaris, avec bash (testé avec 3.2.51(1)-release) et sans gnu userland:

    IFS=$'
    IFS=$'\002' tmpargs=( $( pargs "${pid}" \
| /usr/bin/sed -n 's/^argv\[[0-9]\{1,\}\]: //gp' \
| tr '\n' '\002' ) )
for tmparg in "${tmpargs[@]}"; do
printf "%q " "$( echo -e "${tmparg}" )"
done; echo

    2' tmpargs=( $( pargs "${pid}" \
    | /usr/bin/sed -n 's/^argv\[[0-9]\{1,\}\]: //gp' \
    | tr '\n' '
    IFS=$'\002' tmpargs=( $( pargs "${pid}" \
| /usr/bin/sed -n 's/^argv\[[0-9]\{1,\}\]: //gp' \
| tr '\n' '\002' ) )
for tmparg in "${tmpargs[@]}"; do
printf "%q " "$( echo -e "${tmparg}" )"
done; echo

    2' ) )
for tmparg in "${tmpargs[@]}"; do
    printf "%q " "$( echo -e "${tmparg}" )"
done; echo

    Linux bash Exemple (coller dans le terminal):

    {
## setup intial args
argv=( /bin/bash -c '{ /usr/bin/sleep 10; echo; }' /dev/null 'BEGIN {system("sleep 2")}' "this is" \
    "some" "args "$'\n'" that" $'
    {
## setup intial args
argv=( /bin/bash -c '{ /usr/bin/sleep 10; echo; }' /dev/null 'BEGIN {system("sleep 2")}' "this is" \
"some" "args "$'\n'" that" $'\000' $'\002' "need" "quot"$'\t'"ing" )
## run in background
"${argv[@]}" &
## recover into eval string that assigns it to argv_recovered
eval_me=$(
printf "argv_recovered=( "
</proc/"${!}"/cmdline xargs --no-run-if-empty -0 -n1 \
bash -c 'printf "%q " "${1}"' /dev/null
printf " )\n"
)
## do eval
eval "${eval_me}"
## verify match
if [ "$( declare -p argv )" == "$( declare -p argv_recovered | sed 's/argv_recovered/argv/' )" ];
then
echo MATCH
else
echo NO MATCH
fi
}

    0' $'
    {
## setup intial args
argv=( /bin/bash -c '{ /usr/bin/sleep 10; echo; }' /dev/null 'BEGIN {system("sleep 2")}' "this is" \
"some" "args "$'\n'" that" $'\000' $'\002' "need" "quot"$'\t'"ing" )
## run in background
"${argv[@]}" &
## recover into eval string that assigns it to argv_recovered
eval_me=$(
printf "argv_recovered=( "
</proc/"${!}"/cmdline xargs --no-run-if-empty -0 -n1 \
bash -c 'printf "%q " "${1}"' /dev/null
printf " )\n"
)
## do eval
eval "${eval_me}"
## verify match
if [ "$( declare -p argv )" == "$( declare -p argv_recovered | sed 's/argv_recovered/argv/' )" ];
then
echo MATCH
else
echo NO MATCH
fi
}

    2' "need" "quot"$'\t'"ing" )

## run in background
"${argv[@]}" &

## recover into eval string that assigns it to argv_recovered
eval_me=$(
    printf "argv_recovered=( "
    </proc/"${!}"/cmdline xargs --no-run-if-empty -0 -n1 \
        bash -c 'printf "%q " ""' /dev/null
    printf " )\n"
)

## do eval
eval "${eval_me}"

## verify match
if [ "$( declare -p argv )" == "$( declare -p argv_recovered | sed 's/argv_recovered/argv/' )" ];
then
    echo MATCH
else
    echo NO MATCH
fi
}

    De sortie:

    MATCH

    Solaris Bash Exemple:

    {
## setup intial args
argv=( /bin/bash -c '{ /usr/bin/sleep 10; echo; }' /dev/null 'BEGIN {system("sleep 2")}' "this is" \
    "some" "args "$'\n'" that" $'
    {
## setup intial args
argv=( /bin/bash -c '{ /usr/bin/sleep 10; echo; }' /dev/null 'BEGIN {system("sleep 2")}' "this is" \
"some" "args "$'\n'" that" $'\000' $'\002' "need" "quot"$'\t'"ing" )
## run in background
"${argv[@]}" &
pargs "${!}"
ps -fp "${!}"
declare -p tmpargs
eval_me=$(
printf "argv_recovered=( "
IFS=$'\002' tmpargs=( $( pargs "${!}" \
| /usr/bin/sed -n 's/^argv\[[0-9]\{1,\}\]: //gp' \
| tr '\n' '\002' ) )
for tmparg in "${tmpargs[@]}"; do
printf "%q " "$( echo -e "${tmparg}" )"
done; echo
printf " )\n"
)
## do eval
eval "${eval_me}"
## verify match
if [ "$( declare -p argv )" == "$( declare -p argv_recovered | sed 's/argv_recovered/argv/' )" ];
then
echo MATCH
else
echo NO MATCH
fi
}

    0' $'
    {
## setup intial args
argv=( /bin/bash -c '{ /usr/bin/sleep 10; echo; }' /dev/null 'BEGIN {system("sleep 2")}' "this is" \
"some" "args "$'\n'" that" $'\000' $'\002' "need" "quot"$'\t'"ing" )
## run in background
"${argv[@]}" &
pargs "${!}"
ps -fp "${!}"
declare -p tmpargs
eval_me=$(
printf "argv_recovered=( "
IFS=$'\002' tmpargs=( $( pargs "${!}" \
| /usr/bin/sed -n 's/^argv\[[0-9]\{1,\}\]: //gp' \
| tr '\n' '\002' ) )
for tmparg in "${tmpargs[@]}"; do
printf "%q " "$( echo -e "${tmparg}" )"
done; echo
printf " )\n"
)
## do eval
eval "${eval_me}"
## verify match
if [ "$( declare -p argv )" == "$( declare -p argv_recovered | sed 's/argv_recovered/argv/' )" ];
then
echo MATCH
else
echo NO MATCH
fi
}

    2' "need" "quot"$'\t'"ing" )

## run in background
"${argv[@]}" &
pargs "${!}"
ps -fp "${!}"

declare -p tmpargs
eval_me=$(
    printf "argv_recovered=( "
    IFS=$'
    {
## setup intial args
argv=( /bin/bash -c '{ /usr/bin/sleep 10; echo; }' /dev/null 'BEGIN {system("sleep 2")}' "this is" \
"some" "args "$'\n'" that" $'\000' $'\002' "need" "quot"$'\t'"ing" )
## run in background
"${argv[@]}" &
pargs "${!}"
ps -fp "${!}"
declare -p tmpargs
eval_me=$(
printf "argv_recovered=( "
IFS=$'\002' tmpargs=( $( pargs "${!}" \
| /usr/bin/sed -n 's/^argv\[[0-9]\{1,\}\]: //gp' \
| tr '\n' '\002' ) )
for tmparg in "${tmpargs[@]}"; do
printf "%q " "$( echo -e "${tmparg}" )"
done; echo
printf " )\n"
)
## do eval
eval "${eval_me}"
## verify match
if [ "$( declare -p argv )" == "$( declare -p argv_recovered | sed 's/argv_recovered/argv/' )" ];
then
echo MATCH
else
echo NO MATCH
fi
}

    2' tmpargs=( $( pargs "${!}" \
        | /usr/bin/sed -n 's/^argv\[[0-9]\{1,\}\]: //gp' \
        | tr '\n' '
    {
## setup intial args
argv=( /bin/bash -c '{ /usr/bin/sleep 10; echo; }' /dev/null 'BEGIN {system("sleep 2")}' "this is" \
"some" "args "$'\n'" that" $'\000' $'\002' "need" "quot"$'\t'"ing" )
## run in background
"${argv[@]}" &
pargs "${!}"
ps -fp "${!}"
declare -p tmpargs
eval_me=$(
printf "argv_recovered=( "
IFS=$'\002' tmpargs=( $( pargs "${!}" \
| /usr/bin/sed -n 's/^argv\[[0-9]\{1,\}\]: //gp' \
| tr '\n' '\002' ) )
for tmparg in "${tmpargs[@]}"; do
printf "%q " "$( echo -e "${tmparg}" )"
done; echo
printf " )\n"
)
## do eval
eval "${eval_me}"
## verify match
if [ "$( declare -p argv )" == "$( declare -p argv_recovered | sed 's/argv_recovered/argv/' )" ];
then
echo MATCH
else
echo NO MATCH
fi
}

    2' ) )
    for tmparg in "${tmpargs[@]}"; do
        printf "%q " "$( echo -e "${tmparg}" )"
    done; echo
    printf " )\n"
)

## do eval
eval "${eval_me}"


## verify match
if [ "$( declare -p argv )" == "$( declare -p argv_recovered | sed 's/argv_recovered/argv/' )" ];
then
    echo MATCH
else
    echo NO MATCH
fi
}

    De sortie:

    MATCH
    InformationsquelleAutor Iwan Aucamp
  11. 1

    Vous pouvez simplement utiliser:

    ps -o args= -f -p ProcessPid
    InformationsquelleAutor Mitar
  12. 0

    essayer "ps -n" dans un terminal linux. cela fera apparaître:

    1.Tous les processus en cours d'EXÉCUTION, leur ligne de commande et leur Pid

    1. Le programme intiate le processus.

    Par la suite, vous saurez quel processus pour tuer

    InformationsquelleAutor repzero
  13. 0

    Si vous souhaitez obtenir une longue possible (pas sûr de ce qu'il y a des limites), similaire à la version de Solaris pargs, vous pouvez l'utiliser sur Linux & mac OSX:

    ps -ww -o pid,command [-p <pid> ... ]
    InformationsquelleAutor pourhaus