Jak przekazać argumenty wiersza poleceń do działającego procesu w systemach unix / linux?

W pargssystemie SunOS istnieje polecenie, które wypisuje argumenty wiersza poleceń przekazane do uruchomionego procesu.

Czy istnieje inne podobne polecenie w innych środowiskach uniksowych?

Istnieje kilka opcji:

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

Jest więcej informacji na /proc/<pid>temat Linuksa, wystarczy spojrzeć.

Na innych Uniksach może być inaczej. psKomenda będzie działać wszędzie, /procrzeczy jest OS specyficzny. Na przykład w systemie AIX nie ma cmdlinew /proc.

To załatwi sprawę:

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

Bez xargs między argumentami nie będzie spacji, ponieważ zostały one przekonwertowane na wartości NUL.

Pełna linia poleceń

W przypadku systemu Linux i Unix można użyć, ps -ef | grep process_nameaby uzyskać pełny wiersz poleceń.

W systemach SunOS, jeśli chcesz uzyskać pełny wiersz poleceń, możesz użyć

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

Aby uzyskać pełną linię poleceń, musisz zostać superużytkownikiem.

Lista argumentów

pargs -a PROCESS_ID

poda szczegółową listę argumentów przekazanych do procesu. Wyświetli tablicę argumentów w następujący sposób:

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

Nie znalazłem żadnego podobnego polecenia dla systemu Linux, ale użyłbym następującego polecenia, aby uzyskać podobne dane wyjściowe:

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

W systemie Linux

cat /proc/<pid>/cmdline

dostajesz komendę procesu (łącznie z argumentami), ale wszystkie białe znaki zostały zmienione na znaki NUL.

Możesz używać pgrepz -f(pełnym wierszem poleceń) i -l(długim opisem):

pgrep -l -f PatternOfProcess

Ta metoda ma zasadniczą różnicę w stosunku do innych odpowiedzi: działa na CygWin , dzięki czemu można jej użyć do uzyskania pełnego wiersza polecenia dowolnego procesu działającego w systemie Windows (wykonaj jako podniesiony, jeśli chcesz danych o dowolnym podniesionym / administracyjnym procesie) . Każda inna metoda wykonywania tego w systemie Windows jest bardziej niewygodna ( na przykład ).
Ponadto: w moich testach sposób pgrep był jedynym systemem, który działał w celu uzyskania pełnej ścieżki dla skryptów działających w pythonie CygWin .

Innym wariantem drukowania /proc/PID/cmdlineze spacjami w systemie Linux jest:

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

W ten sposób catdrukuje znaki NULL jako, ^@a następnie zamieniasz je spacją za pomocą sed; echowypisuje nowy wiersz.

Możesz po prostu użyć:

ps -o args= -f -p ProcessPid

Zamiast używać wielu poleceń do edycji strumienia, po prostu użyj jednego - tr tłumaczy jeden znak na inny:

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

Oprócz wszystkich powyższych sposobów konwersji tekstu, jeśli po prostu użyjesz „łańcuchów”, domyślnie utworzy on wyjście w osobnych wierszach. Z tą dodatkową zaletą, że może również zapobiegać pojawianiu się znaków, które mogą mieszać twój terminal.

Oba dane wyjściowe w jednym poleceniu:

strings / proc // cmdline / proc // environment

Prawdziwe pytanie brzmi ... czy istnieje sposób, aby zobaczyć prawdziwą linię komend procesu w Linuksie, która została zmieniona, tak aby cmdline zawierał zmieniony tekst zamiast faktycznie uruchomionej komendy.

W systemie Solaris

     ps -eo pid,comm

podobne mogą być stosowane w systemach uniksopodobnych.

W Linuksie, z bash, wyprowadza jako cytowane argumenty, aby można było edytować polecenie i uruchomić je ponownie

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

W Solarisie, z bash (testowany z wydaniem 3.2.51 (1)) i bez przestrzeni użytkownika GNU:

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

Linux bash Przykład (wklej w terminalu):

{
## 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
}

Wynik:

MATCH

Przykład Solaris Bash:

{
## 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
}

Wynik:

MATCH

Jeśli chcesz uzyskać jak najdłużej (nie jestem pewien, jakie są ograniczenia), podobnie jak w systemach Solaris , możesz użyć tego w systemach Linux i OSX:

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

spróbuj ps -nw terminalu Linux. To pokaże:

1. Wszystkie procesy RUNNING , ich linia poleceń i ich PID

2. Program inicjuje procesy.

Następnie dowiesz się, który proces zabić