Como obtenho o caminho de um processo no Unix / Linux

138

No ambiente Windows, há uma API para obter o caminho que está executando um processo. Existe algo semelhante no Unix / Linux?

Ou existe alguma outra maneira de fazer isso nesses ambientes?

lsalamon
fonte

Respostas:

183

No Linux, o link simbólico /proc/<pid>/exetem o caminho do executável. Use o comando readlink -f /proc/<pid>/exepara obter o valor.

No AIX, esse arquivo não existe. Você pode comparar cksum <actual path to binary>e cksum /proc/<pid>/object/a.out.

jpalecek
fonte
2
sudose a saída estiver vazia, alguns processos serão criados por outros usuários do sistema.
Lun4i 02/09
63

Você pode encontrar o exe facilmente por essas maneiras, tente você mesmo.

  • ll /proc/<PID>/exe
  • pwdx <PID>
  • lsof -p <PID> | grep cwd
hahakubile
fonte
1
Isso é incrível. Eu sabia que o rodava de um local que tinha o link simbólico para o executável original (uma das muitas versões). pwdx <PID>me deu a localização do link simbólico para que eu pudesse encontrar os logs e interromper o processo da maneira correta.
NurShomik
1
llgeralmente é um apelido: alias ll='ls -alF'.
Pablo A
1
Os dois últimos (pwdx e lsof) podem não fornecer o resultado correto. A questão era sobre o caminho completo para o executável. pwdx e lsof fornecerão o cwd do processo, e não o caminho para o processo. Eu acho que a resposta do jpalecek é mais precisa, pois o solicitante original solicitou o caminho para o executável, em vez de o link que descreve o executável.
Shimon
28

Um pouco tarde, mas todas as respostas foram específicas para o Linux.

Se você também precisar do unix, precisará do seguinte:

char * getExecPath (char * path,size_t dest_len, char * argv0)
{
    char * baseName = NULL;
    char * systemPath = NULL;
    char * candidateDir = NULL;

    /* the easiest case: we are in linux */
    size_t buff_len;
    if (buff_len = readlink ("/proc/self/exe", path, dest_len - 1) != -1)
    {
        path [buff_len] = '\0';
        dirname (path);
        strcat  (path, "/");
        return path;
    }

    /* Ups... not in linux, no  guarantee */

    /* check if we have something like execve("foobar", NULL, NULL) */
    if (argv0 == NULL)
    {
        /* we surrender and give current path instead */
        if (getcwd (path, dest_len) == NULL) return NULL;
        strcat  (path, "/");
        return path;
    }


    /* argv[0] */
    /* if dest_len < PATH_MAX may cause buffer overflow */
    if ((realpath (argv0, path)) && (!access (path, F_OK)))
    {
        dirname (path);
        strcat  (path, "/");
        return path;
    }

    /* Current path */
    baseName = basename (argv0);
    if (getcwd (path, dest_len - strlen (baseName) - 1) == NULL)
        return NULL;

    strcat (path, "/");
    strcat (path, baseName);
    if (access (path, F_OK) == 0)
    {
        dirname (path);
        strcat  (path, "/");
        return path;
    }

    /* Try the PATH. */
    systemPath = getenv ("PATH");
    if (systemPath != NULL)
    {
        dest_len--;
        systemPath = strdup (systemPath);
        for (candidateDir = strtok (systemPath, ":"); candidateDir != NULL; candidateDir = strtok (NULL, ":"))
        {
            strncpy (path, candidateDir, dest_len);
            strncat (path, "/", dest_len);
            strncat (path, baseName, dest_len);

            if (access(path, F_OK) == 0)
            {
                free (systemPath);
                dirname (path);
                strcat  (path, "/");
                return path;
            }
        }
        free(systemPath);
        dest_len++;
    }

    /* again someone has use execve: we dont knowe the executable name; we surrender and give instead current path */
    if (getcwd (path, dest_len - 1) == NULL) return NULL;
    strcat  (path, "/");
    return path;
}

EDITADO: Corrigido o bug relatado por Mark Lakata.

Hiperion
fonte
Obrigado por compartilhar o Hiperion, mas eu precisava especificar um PID e obter seu caminho exe, isso é possível com este código?
Noitidart 22/10
1
@Noitidart - substitua "/proc/self/exe"porsprintf(foo,"/proc/%d/exe",pid)
Mark Lakata
2
Observe que o readlink não encerra o resultado nulo, portanto esse código tem um comportamento indefinido.
precisa saber é o seguinte
Obrigado @MarkLakata! :)
Noitidart
Obrigado por perceber @MarkLakata
Hiperion
14

Eu uso:

ps -ef | grep 786

Substitua 786 pelo seu PID ou nome do processo.

Do utilizador
fonte
11

pwdx <process id>

Este comando buscará o caminho do processo de onde está sendo executado.

gobi
fonte
A questão é sobre a API para obter informações, mas obrigado de qualquer maneira.
Lsalamon
4

No Linux, todo processo possui sua própria pasta /proc. Portanto, você pode usar getpid()para obter o pid do processo em execução e, em seguida, associá-lo ao caminho /procpara obter a pasta de que você precisa.

Aqui está um pequeno exemplo em Python:

import os
print os.path.join('/proc', str(os.getpid()))

Aqui está o exemplo no ANSI C também:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>


int
main(int argc, char **argv)
{
    pid_t pid = getpid();

    fprintf(stdout, "Path to current process: '/proc/%d/'\n", (int)pid);

    return EXIT_SUCCESS;
}

Compile com:

gcc -Wall -Werror -g -ansi -pedantic process_path.c -oprocess_path 
hiperboreia
fonte
Saída do Python em uma versão recente do Ubuntu: >>> import os >>> print os.path.join ('/ proc', str (os.getpid ())) / proc / 24346
Luke Stanley
3

Não existe um método "garantido para trabalhar em qualquer lugar".

O passo 1 é verificar o argv [0], se o programa foi iniciado por seu caminho completo, este (normalmente) teria o caminho completo. Se foi iniciado por um caminho relativo, o mesmo se aplica (embora isso exija a obtenção do diretório de trabalho atual, usando getcwd ().

O passo 2, se nenhuma das opções acima se aplica, é obter o nome do programa, obter o nome do programa em argv [0], obter o PATH do usuário no ambiente e passar por isso para verificar se existe um binário executável com o mesmo nome.

Observe que argv [0] é definido pelo processo que executa o programa, portanto, não é 100% confiável.

Vatine
fonte
2

agradecimentos: Kiwy
with AIX:

getPathByPid()
{
    if [[ -e /proc/$1/object/a.out ]]; then
        inode=`ls -i /proc/$1/object/a.out 2>/dev/null | awk '{print $1}'`
        if [[ $? -eq 0 ]]; then
            strnode=${inode}"$"
            strNum=`ls -li /proc/$1/object/ 2>/dev/null | grep $strnode | awk '{print $NF}' | grep "[0-9]\{1,\}\.[0-9]\{1,\}\."`
            if [[ $? -eq 0 ]]; then
                # jfs2.10.6.5869
                n1=`echo $strNum|awk -F"." '{print $2}'`
                n2=`echo $strNum|awk -F"." '{print $3}'`
                # brw-rw----    1 root     system       10,  6 Aug 23 2013  hd9var
                strexp="^b.*"$n1,"[[:space:]]\{1,\}"$n2"[[:space:]]\{1,\}.*$"   # "^b.*10, \{1,\}5 \{1,\}.*$"
                strdf=`ls -l /dev/ | grep $strexp | awk '{print $NF}'`
                if [[ $? -eq 0 ]]; then
                    strMpath=`df | grep $strdf | awk '{print $NF}'`
                    if [[ $? -eq 0 ]]; then
                        find $strMpath -inum $inode 2>/dev/null
                        if [[ $? -eq 0 ]]; then
                            return 0
                        fi
                    fi
                fi
            fi
        fi
    fi
    return 1
}
zirong
fonte
Bom que alguém fez um script dele
kiwy
1

Você também pode encontrar o caminho no GNU / Linux com (não completamente testado):

char file[32];
char buf[64];
pid_t pid = getpid();
sprintf(file, "/proc/%i/cmdline", pid);
FILE *f = fopen(file, "r");
fgets(buf, 64, f);
fclose(f);

Se você deseja que o diretório do executável talvez altere o diretório ativo para o diretório do processo (para mídia / dados / etc), será necessário descartar tudo após o último /:

*strrchr(buf, '/') = '\0';
/*chdir(buf);*/
Jimmio92
fonte
1

O comando abaixo procura o nome do processo na lista de processos em execução e redireciona o comando pid para pwdx para encontrar o local do processo.

ps -ef | grep "abc" |grep -v grep| awk '{print $2}' | xargs pwdx

Substitua "abc" pelo seu padrão específico.

Como alternativa, se você puder configurá-lo como uma função no .bashrc, poderá achar útil usá-lo se precisar que ele seja usado com frequência.

ps1() { ps -ef | grep "$1" |grep -v grep| awk '{print $2}' | xargs pwdx; }

Por exemplo:

[admin@myserver:/home2/Avro/AvroGen]$ ps1 nifi

18404: /home2/Avro/NIFI

Espero que isso ajude alguém em algum momento .....

Uma corrida
fonte
-1

Encontre o caminho para um nome de processo

#!/bin/bash
# @author Lukas Gottschall
PID=`ps aux | grep precessname | grep -v grep | awk '{ print $2 }'`
PATH=`ls -ald --color=never /proc/$PID/exe | awk '{ print $10 }'`
echo $PATH
DwD
fonte
4
Por favor, explique seu código. Se você copiar e colar de outro lugar, faça o link para a fonte.
Tim
O que esse código não tão eficiente está fazendo é obter o nome do processo (essencialmente, a linha "PID" é um substituto para pgrep); na próxima linha, obtém o caminho do binário sendo executado ( /proc/$PID/exeé um link simbólico para o arquivo executável); e finalmente ecoa esse link simbólico.
Enrico