Quais são os valores mínimo e máximo dos códigos de saída no Linux?

Quais são os valores mínimo e máximo dos seguintes códigos de saída no Linux:

1. O código de saída retornado de um executável binário (por exemplo: um programa em C).
2. O código de saída retornado de um script bash (ao chamar exit).
3. O código de saída retornado de uma função (ao chamar return). Eu acho que isso é entre 0e 255.

O número passado para a chamada _exit()/ exit_group()system (às vezes chamado de código de saída para evitar a ambiguidade com o status de saída), que também se refere a uma codificação do código de saída ou número do sinal e informações adicionais, dependendo se o processo foi encerrado ou encerrado normalmente ) é do tipo int, portanto, em sistemas do tipo Unix, como o Linux, geralmente um número inteiro de 32 bits com valores de -2147483648 (-2 ³¹ ) a 2147483647 (2 ³¹ -1).

No entanto, em todos os sistemas, quando o processo pai (ou a subreaper criança ou initse o pai morreu) usa os wait(), waitpid(), wait3(), wait4()chamadas de sistema para recuperá-lo, apenas os 8 bits inferiores de que são disponíveis (valores de 0 a 255 (2 ⁸ - 1)).

Ao usar a waitid()API (ou um manipulador de sinal no SIGCHLD), na maioria dos sistemas (e como o POSIX agora exige mais claramente na edição de 2016 do padrão (consulte a _exit()especificação )), o número completo está disponível (no si_statuscampo da estrutura retornada ) Esse ainda não é o caso do Linux, embora também trunque o número de 8 bits com a waitid()API, mas isso provavelmente mudará no futuro.

Geralmente, você deseja usar apenas os valores 0 (geralmente significando sucesso) a 125 apenas, pois muitos shells usam valores acima de 128 na $?representação do status de saída para codificar o número do sinal de um processo que está sendo morto e 126 e 127 para funções especiais. condições.

Você pode usar 126 a 255 exit()para significar a mesma coisa que eles fazem para os shell $?(como quando um script faz ret=$?; ...; exit "$ret"). Usar valores fora de 0 -> 255 geralmente não é útil. Geralmente, você faria isso apenas se souber que o pai usará a waitid()API em sistemas que não são truncados e se você precisar do intervalo de valores de 32 bits. Observe que, se você fizer um, exit(2048)por exemplo, isso será visto como sucesso pelos pais usando as wait*()APIs tradicionais .

Mais informações em:

• Código de saída padrão quando o processo é finalizado?

Esperamos que as perguntas e respostas respondam à maioria das outras perguntas e esclareçam o significado de status de saída . Vou adicionar mais algumas coisas:

Um processo não pode terminar, a menos que seja morto ou faça as chamadas _exit()/ exit_group()system. Quando você retorna de main()in C, a libc chama essa chamada de sistema com o valor de retorno.

A maioria dos idiomas possui uma exit()função que agrupa a chamada do sistema e o valor que eles assumem, se algum for geralmente passado como é para a chamada do sistema. (observe que geralmente fazem mais coisas como a limpeza feita pela exit()função de C que libera os buffers stdio, executa os atexit()ganchos ...)

Esse é o caso de pelo menos:

$ strace -e exit_group awk 'BEGIN{exit(1234)}'
exit_group(1234)                        = ?
$ strace -e exit_group mawk 'BEGIN{exit(1234)}'
exit_group(1234)                        = ?
$ strace -e exit_group busybox awk 'BEGIN{exit(1234)}'
exit_group(1234)                        = ?
$ echo | strace -e exit_group sed 'Q1234'
exit_group(1234)                        = ?
$ strace -e exit_group perl -e 'exit(1234)'
exit_group(1234)                        = ?
$ strace -e exit_group python -c 'exit(1234)'
exit_group(1234)                        = ?
$ strace -e exit_group expect -c 'exit 1234'
exit_group(1234)                        = ?
$ strace -e exit_group php -r 'exit(1234);'
exit_group(1234)                        = ?
$ strace -e exit_group zsh -c 'exit 1234'
exit_group(1234)

Ocasionalmente, você vê algumas reclamações quando usa um valor fora de 0 a 255:

$ echo 'm4exit(1234)' | strace -e exit_group m4
m4:stdin:1: exit status out of range: `1234'
exit_group(1)                           = ?

Algumas conchas reclamam quando você usa um valor negativo:

$ strace -e exit_group dash -c 'exit -1234'
dash: 1: exit: Illegal number: -1234
exit_group(2)                           = ?
$ strace -e exit_group yash -c 'exit -- -1234'
exit: `-1234' is not a valid integer
exit_group(2)                           = ?

O POSIX deixa o comportamento indefinido se o valor passado para o exitbuilt-in especial estiver fora de 0-> 255.

Algumas conchas mostram comportamentos inesperados se você:

• bash(e mkshnão pdkshno qual se baseia) se encarrega de truncar o valor para 8 bits:

  $ strace -e exit_group bash -c 'exit 1234'
  exit_group(210)                         = ?
  

  Portanto, nessas shells, se você quiser sair com um valor fora de 0-255, precisará fazer algo como:

  exec zsh -c 'exit -- -12345'
  exec perl -e 'exit(-12345)'
  

  Ou seja, execute outro comando no mesmo processo que pode chamar a chamada do sistema com o valor desejado.

• como mencionado nas outras perguntas e respostas, ksh93tem o comportamento mais estranho para valores de saída de 257 a 256 + max_signal_number onde, em vez de chamar exit_group(), ele se mata com o sinal correspondente¹.

  $ ksh -c 'exit "$((256 + $(kill -l STOP)))"'
  zsh: suspended (signal)  ksh -c 'exit "$((256 + $(kill -l STOP)))"'
  

  e trunca o número como bash/ mksh.

^{É provável que isso mude na próxima versão. Agora que o desenvolvimento ksh93foi retomado como um esforço da comunidade fora da AT&T, esse comportamento, embora encorajado de alguma forma pelo POSIX, está sendo revertido}

O mínimo é 0, e isso é considerado o valor do sucesso. Todos os outros são fracassos. O máximo 255também é conhecido como -1.

Essas regras se aplicam a scripts e outros executáveis, além de funções de shell.

Valores maiores resultam no módulo 256.

Isso parece tão simples, mas, oh, os problemas.

A linguagem C (e a seguir à maioria das outras linguagens, direta ou indiretamente) exige que retornar de mainseja equivalente a chamar exitcom o mesmo argumento que o valor de retorno. Este é um número inteiro (o tipo de retorno é muito claramente int), de modo que, em princípio, a gama seria INT_MINde INT_MAX.

No entanto, o POSIX afirma que apenas os 8 bits mais baixos passados exitdevem ser disponibilizados para um processo pai em espera, literalmente como se fosse "status & 0xFF" .
Portanto, na prática, o código de saída é um número inteiro (ainda assinado) do qual apenas os 8 bits mais baixos são definidos.

O mínimo será assim -128 e o máximo 127 . Espere, isso não é verdade. Será de 0 a 255.

Mas, infelizmente, é claro que não pode ser assim tão simples . Na prática, o Linux (ou melhor, o bash) faz diferente . O intervalo válido de códigos de retorno é de 0 a 255 (isto é, não assinado).

Para estar do lado seguro em termos de evitar confusão, provavelmente é uma boa idéia apenas supor que os códigos de retorno não tenham sinal e transmitir tudo do que você voltar waitpara não assinado. Dessa forma, é consistente com o que você vê em uma concha. Como os bits mais altos (incluindo o mais significativo) são limpos, isso nem é "errado" porque, embora tecnicamente assinado, os valores reais sempre são sem sinal (pois o bit de sinal nunca é definido).
Também ajuda a evitar o erro comum de comparar um código de saída -1, o qual, por algum motivo estranho, parece nunca aparecer mesmo quando um programa sai com -1(bem, adivinhe por que!).

Sobre o seu último ponto, retornando de uma função, se essa função acontecer main, veja acima. Caso contrário, depende do tipo de retorno da função, poderia, em princípio, ser qualquer coisa (inclusive void).

1. O código de saída retornado de um executável binário (por exemplo: um programa em C).
2. O código de saída retornado de um script bash (ao chamar exit).

Os códigos de saída de qualquer processo - seja um executável binário, um script de shell ou qualquer outra coisa - variam de 0 a 255. É possível passar um valor maior para exit(), mas apenas os 8 bits inferiores do status são disponibilizados para outros processos através wait().

3. O código de saída retornado de uma função (ao chamar return). Eu acho que isso é entre 0 e 255.

A função CA pode ser declarada como retornando quase qualquer tipo. Os limites de seu valor de retorno são determinados inteiramente por esse tipo: por exemplo, -128 a 127 para uma função retornando signed char, ou 0 a 4,2 bilhões para uma função retornando unsigned int, ou qualquer número de ponto flutuante até e inclusive infpara uma função retornando double. E isso não está contando os tipos não numéricos, como void *ou um struct...