exec, execl, execle, execlp, execv, execve, execvp, exect, ou fexecve Subroutine

Propósito

Executa um arquivo.

Biblioteca

Biblioteca C Padrão (libc.a)

Sintaxe

#include <unistd.h>

extern 
char **environ;

int execl (
 Path, 
 Argument0 [, Argument1, ...], 0)
const char *Path, *Argument0, *Argument
1, ...;

int execle (
 Path, 
 Argument0 [, Argument1, ...], 0,
        
 EnvironmentPointer)
const 
char *Path, *Argument0, *Argum
ent
1, ...;
char *const EnvironmentPointer[ ];

int execlp (
 File, 
 Argument0 [, Argument1
, ...], 0)
const char *File, *Argument0, *Argument
1, ...;

int execv (
 Path, 
 ArgumentV)
const char *Path;
char *const ArgumentV[ ];

int execve (
 Path, 
 ArgumentV,
        
 EnvironmentPointer)
const char *Path;
char 
*const ArgumentV[ ], *EnvironmentPointer
[ ];

int execvp (
 File, 
 ArgumentV)
const char *File;
char *const ArgumentV[ ];

int exect (
 Path,
 ArgumentV,
 EnvironmentPointer)
char *Path, *ArgumentV, *EnvironmentPointer [ ];

int fexecve (FileDescriptor, ArgumentV, EnvironmentPointer)
int FileDescriptor;
char *const ArgumentV[ ], *EnvironmentPointer[ ];

Descrição

A subroutine exec , em todas as suas formas, executa um novo programa no processo de chamada. O subroutine exec não cria um novo processo, mas sobrepõe o programa atual com um novo, que é chamado de imagem de novo processo. O arquivo de imagem do novo processo pode ser um dos três tipos de arquivo:

• Um arquivo binário executável no formato de arquivo XCOFF.
• Um arquivo de texto executável que contém um procedimento de shell (apenas as subroutines execlp e execvp permitem esse tipo de arquivo de imagem de novo processo).
• Um arquivo que nomeia um arquivo binário executável ou procedimento de shell a ser executado.

A subroutine fexecve é equivalente ao subroutine execve , exceto que a subroutine fexecve leva o descritor de arquivo de um arquivo aberto para ser executado como um primeiro parâmetro, em vez de um nome de nome. No entanto, aplica-se o seguinte:

A imagem nova-processo herda os seguintes atributos da imagem do processo de chamada: filiação de sessão, IDs de grupos complementares, máscara de sinal de processo e sinais pendentes.

O último dos tipos mencionados é reconhecido por um cabeçalho com a seguinte sintaxe:

#! Path [String]

O #! é o arquivo número mágico, que identifica o tipo de arquivo. O nome do caminho do arquivo a ser executado é especificado pelo parâmetro Caminho . O parâmetro Sequência é uma string de caracteres opcional que contém nenhum guia ou caracteres de espaço. Se especificado, esta string é passada para o novo processo como um argumento na frente do nome do arquivo de imagem do novo processo. O cabeçalho deve ser finalizado com um caractere de nova linha. Quando chamado, o novo processo passa o parâmetro Path como ArgumentV[0]. Se um parâmetro String for especificado no novo arquivo de imagem de processo, a sub-rotina exec define ArgumentV[0] como os valores dos parâmetros String e Path concatenados. O restante dos argumentos passados são os mesmos que foram transmitidos para a subroutine exec .

O subroutine exec tenta cancelar o pendente solicitações de E/S assíncronas por este processo. Se as solicitações de E/S assíncronas não puderem ser canceladas, o aplicativo será bloqueado até que os pedidos tenham sido concluídos.

A subroutine exec é semelhante à subroutine carga , exceto que a subroutine exec não tem um parâmetro de caminho de biblioteca explícito. Em vez disso, a subroutine exec usa a variável de ambiente LIBPATH ou LD_LIBRARY_PATH . A variável LIBPATH , quando configurado, é usada a favor de LD_LIBRARY_PATH; caso contrário, LD_LIBRARY_PATH é usado. Essas variáveis de caminho da biblioteca são ignoradas quando o programa que o subroutine exec é executado tem mais privilégio do que o programa de chamada (por exemplo, um programa suid ).

A subroutine exect está incluso para compatibilidade com programas mais antigos sendo rastreados com o comando ptrace . O programa que está sendo executado é forçado no modo single-step de hardware.

Parâmetros

Quando um programa C é executado, ele recebe os seguintes parâmetros:

main (ArgumentCount, ArgumentV, EnvironmentPointer)
int ArgumentCount;
char *ArgumentV[ ], *EnvironmentPointer[ 
];

Neste exemplo, o parâmetro ArgumentCount é a contagem de argumentos e o parâmetro ArgumentV é uma matriz de ponteiros de caractere para os argumentos em si mesmos Por convenção, o valor do parâmetro ArgumentCount é pelo menos 1, e o parâmetro ArgumentV[0] aponta para uma cadeia de caracteres que contém o nome do arquivo de imagem do novo processo.

A rotina principal de um programa de idiomas C começa automaticamente com uma rotina de start-off de tempo de execução. Essa rotina configura a variável global environ para que ela aponte para a matriz de ambiente transmitida para o programa em EnvironmentPointer. Você pode acessar esta variável global incluindo a declaração a seguir em seu programa:

extern char **environ;

As subroutines execl, execv, execlpe execvp usam a variável global environ para passar o ambiente de corrente de processo de chamada para o novo processo.

Os descritores de arquivos abertos no processo de chamada permanecem abertos, exceto aqueles cuja sinalização close-on-exec está definida. Para aqueles descritores de arquivo que permanecem abertos, o ponteiro do arquivo fica inalterado. (Para obter informações sobre controle de arquivos, consulte o arquivo fcntl.h .)

Os descritores de estado-de-conversão e descritores de catálogo de mensagens na nova imagem do processo estão indefinidos. Para o novo processo, um equivalente ao subroutine setlocale , especificando o valor LC_ALL para sua categoria e o valor "C" para o seu locale, é executado na inicialização.

Se o novo programa requer bibliotecas compartilhadas, o exec subroutine encontra, abre e carrega cada um deles para o espaço de endereço de novo processo. As contagens referenciadas para bibliotecas compartilhadas em uso pelo emissor do exec são decrementadas. As bibliotecas compartilhadas são procuradas nos diretórios listados na variável de ambiente LIBPATH . Se qualquer um desses arquivos for remoto, os dados são copiados na memória virtual local.

As subroutines exec reajustam todos os sinais capturados para a ação padrão. Sinais que fazem com que a ação padrão continue a fazer isso após as subroutines exec . Os sinais ignorados permanecem ignorados, a máscara de sinal permanece a mesma e o estado da pilha de sinal é reajustado. (Para obter informações sobre sinais, consulte a sub-rotina sigação .)

Se o bit do modo SetUserID do arquivo de imagem de novo processo estiver definido, a sub-rotina exec define o ID de usuário efetivo do novo processo como o ID do proprietário do arquivo de imagem de novo processo. Da mesma forma, se o bit de modo SetGroupID do arquivo de imagem de novo processo for definido, a ID de grupo efetiva do novo processo será definida como a ID de grupo do arquivo de imagem de novo processo. O ID real do usuário e o real ID do grupo ID do novo processo permanecem os mesmos dos do processo de chamada. (Para obter informações sobre os modos SetID , consulte a sub-rotina chmod .)

No final da operação exec o ID de usuário salvo e o ID do grupo salvo do processo estão sempre configurados para o ID do usuário efetivo e ID do grupo efetivo, respectivamente, do processo.

Quando um ou ambos os bits do modo ID configurados é configurado e o arquivo a ser executado é um arquivo remoto, o usuário de arquivos e IDs de grupo passam por tradução de saída no servidor. Em seguida, eles são transmitidos para o nó do cliente onde são traduzidos de acordo com a tabela de conversão de entrada. Esses IDs traduzidos tornam-se os IDs de usuário e grupo do novo processo.

A profiling está desativada para o novo processo.

O novo processo herda os seguintes atributos a partir do processo de chamada:

• Valor agradável (veja a subroutine getprioridade , setprioridade subroutine, legal subroutine)
• ID do Processo
• ID do processo pai
• ID do grupo de processos
• semadj valores (veja a subroutine semop )
• tty group ID (veja o saída, atsairou _saída subroutine, sigação subroutine)
• trace bandeira (consulte a solicitação 0 da sub-rotina ptrace )
• Tempo restante até um sinal de despertador (consulte a sub-rotina incinterval , a sub-rotina setitimer e a sub-rotina alarm )
• Diretório atual
• Diretório raiz
• Máscara de criação de modo de arquivo (veja a sub-rotina umask )
• Limite de tamanho do arquivo (veja a subroutine ulimit )
• Limites de recursos (veja a subroutine getrlimit , setrlimit subroutine e vlimit subroutine)
• tms_utime,tms_stime,tms_cutimeetms_ctimecampos da estrutura tms (veja a subroutine vezes )
• ID do usuário de login

Após a conclusão bem-sucedida, a marca de subroutines exec para atualização dost_atimecampo do arquivo.

Exemplos

1. Para executar um comando e passá-lo um parâmetro, digite:

   execlp("ls", "ls", "-al", 0);

   O subroutine execlp procura cada um dos diretórios listados na variável de ambiente PATH para o comando ls e, em seguida, ele sobrepõe a imagem do processo atual com este comando. A subroutine execlp não é devolvida, a menos que o comando ls não possa ser executado.
   Nota: Este exemplo não executa o processador de comandos shell, portanto, operações interpretadas pelo shell, como usar caracteres curingas em nomes de arquivos, não são válidas.
2. Para executar o shell para interpretar um comando, digite:

   execl("/usr/bin/sh", "sh", "-c", "ls -l *.c", 
   0);

   Isso executa o comando sh com a sinalização -c , o que indica que o parâmetro a seguir é o comando a ser interpretado. Este exemplo usa o subroutine execl em vez da subroutine execlp porque o nome completo do caminho /usr/bin/sh é especificado, tornando uma busca de caminho desnecessária.

   Executar um comando shell em um processo filho é geralmente mais útil do que simplesmente usar a subroutine exec , como mostrado neste exemplo. A maneira mais simples de fazer isso é usar a subroutine sistema .

3. A seguir está um exemplo de um novo arquivo de processo que nomeia um programa a ser executado:

   #! /usr/bin/awk -f
   { for (i = NF; i > 0; --i) print $i }

   Se este arquivo for denominadoreverse, inserindo o seguinte comando na linha de comando:

   reverse chapter1 chapter2

   Este comando executa o seguinte comando:

   /usr/bin/awk -f reverse chapter1 chapter2

   Nota: As sub-rotinas exec usam apenas a primeira linha do arquivo de imagem de novo processo e ignoram o restante dele. Além disso, o comando awk interpreta o texto que segue um # (sinal de libra) como um comentário.

Valores De Retorno

Após a conclusão bem-sucedida, as subroutines exec não retornam porque a imagem do processo de chamada é sobreposta pela imagem do novo processo. Se as sub-rotinas exec retornarem ao processo de chamada, o valor -1 será retornado e a variável global errno será definida para identificar o erro.

Códigos De Erro

Se a subroutine exec não for bem sucedida, ele retornará um ou mais dos seguintes códigos de erro:

Se a subroutine exec não for bem-sucedida por causa de uma condição que requer resolução de nome do caminho, ele retorna um ou mais dos seguintes códigos de erro:

Além disso, alguns erros podem ocorrer ao usar o arquivo de novo processo após a imagem do processo antigo ter sido sobrescrito. Esses erros incluem problemas na configuração de novos dados e cadastros de pilha, problemas no mapeamento de uma biblioteca compartilhada ou problemas na leitura do arquivo de novo processo. Como o retorno ao processo de chamada não é possível, o sistema envia o sinal SIGKILL para o processo quando um desses erros ocorre.

Se ocorreu um erro ao mapear uma biblioteca compartilhada, uma mensagem de erro descrevendo a razão do erro é escrita para erro padrão antes que o sinal SIGKILL seja enviado para o processo. Se uma biblioteca compartilhada não puder ser mapeada, a subroutine retornará um dos seguintes códigos de erro:

Se a subroutine fexecve não for bem-sucedida, pode também retornar um dos códigos de erro a seguir:

Se NFS estiver instalado no sistema, a subroutine exec também pode falhar se o seguinte for true: