Respostas:
Existem várias opções:
ps -fp <pid>
cat /proc/<pid>/cmdline | sed -e "s/\x00/ /g"; echo
Há mais informações no /proc/<pid>Linux, basta dar uma olhada.
Em outros Unixes, as coisas podem ser diferentes. O pscomando funcionará em qualquer lugar, o /procmaterial é específico do sistema operacional. Por exemplo, em AIX não existe cmdlineno /proc.
ps -ww -fp <pid>) para especificar uma saída ampla, pois se houver vários comandos, eles poderão ser cortados.
-wwopção permite acesso a argumentos completos da linha de comando (o máximo que é armazenado pelo kernel). Veja também: como o solaris e o bsd obtêm os parâmetros da linha de comando não truncados para as opções de
cat /proc/<pid>/cmdlinetambém funciona no Cygwin, onde os argumentos da linha cmd não são mostrados pscom nenhuma opção.
args, o comando é ps -o args -p <pid>e ele imprimirá apenas o comando args-ocmd se você precisar apenas ver o cmd. Tentar ler /proc/<pid>/cmdlinenem sempre funcionará para usuários sem privilégios. O psutilitário irá funcionar.
/proc/<pid>/cmdlineé limitado (codificado no valor do parâmetro PAGE_SIZE do kernel), portanto, linhas de comando mais longas ainda são mostradas truncadas! Consulte stackoverflow.com/questions/199130/… para obter mais informações. Você pode consultar a configuração do seu kernel getconf PAGE_SIZE, geralmente é 4096.
Isto irá fazer o truque:
xargs -0 < /proc/<pid>/cmdline
Sem os xargs, não haverá espaços entre os argumentos, porque eles foram convertidos em NULs.
xargs -0 < /proc/<pid>/cmdline.
Para Linux e Unix System, você pode usar ps -ef | grep process_namepara obter a linha de comando completa.
Nos sistemas SunOS, se você deseja obter uma linha de comando completa, pode usar
/usr/ucb/ps -auxww | grep -i process_name
Para obter a linha de comando completa, você precisa se tornar superusuário.
pargs -a PROCESS_ID
fornecerá uma lista detalhada de argumentos passados para um processo. Ele produzirá a matriz de argumentos da seguinte maneira:
argv[o]: first argument
argv[1]: second..
argv[*]: and so on..
Não encontrei nenhum comando semelhante para Linux, mas usaria o seguinte comando para obter resultados semelhantes:
tr '\0' '\n' < /proc/<pid>/environ
No Linux
cat /proc/<pid>/cmdline
get é a linha de comando do processo (incluindo args), mas com todos os espaços em branco alterados para caracteres NUL.
Você pode usar pgrepcom -f(linha de comando completa) e -l(descrição longa):
pgrep -l -f PatternOfProcess
Este método tem uma diferença crucial com qualquer uma das outras respostas: funciona no CygWin , para que você possa usá-lo para obter a linha de comando completa de qualquer processo em execução no Windows (execute como elevado se desejar dados sobre qualquer processo elevado / administrativo) . Qualquer outro método para fazer isso no Windows é mais complicado ( por exemplo ).
Além disso: nos meus testes, a maneira pgrep foi o único sistema que trabalhou para obter o caminho completo para scripts em execução no python do CygWin .
$ exec -a fakename bash & [1] 14102 [1]+ Stopped exec -a fakename bash $ xargs -0 < /proc/14102/cmdline; fakename $ pgrep -l -f fakename; 14102 bash
pgrep from procps-ng 3.3.15e 3.3.12. Apenas imprime o nome pid e prorgam sem argumentos.
Outra variante de impressão /proc/PID/cmdlinecom espaços no Linux é:
cat -v /proc/PID/cmdline | sed 's/\^@/\ /g' && echo
Dessa forma, catimprime caracteres NULL como ^@e, em seguida, você os substitui por um espaço usando sed; echoimprime uma nova linha.
Além de todas as maneiras acima para converter o texto, se você simplesmente usar 'strings', ele produzirá a saída em linhas separadas por padrão. Com o benefício adicional, ele também pode impedir a exibição de caracteres que possam embaralhar seu terminal.
Ambos emitem em um comando:
strings / proc // cmdline / proc // environ
A verdadeira questão é ... existe uma maneira de ver a linha de comando real de um processo no Linux que foi alterada para que o cmdline contenha o texto alterado em vez do comando real que foi executado.
No Linux, com bash, para produzir como args entre aspas, para que você possa editar o comando e executá-lo novamente
</proc/"${pid}"/cmdline xargs --no-run-if-empty -0 -n1 \
bash -c 'printf "%q " "${1}"' /dev/null; echo
No Solaris, com bash (testado com a versão 3.2.51 (1)) e sem a terra do usuário do 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
Exemplo de Linux bash (cole no 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" $'\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
}
Resultado:
MATCH
Exemplo do 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
}
Resultado:
MATCH
tr \\0 ' ' < /proc/<pid>/cmdline