sair (chamada de sistema) - exit (system call)
Em muitos sistemas operacionais de computador , um processo de computador encerra sua execução fazendo uma chamada de saída do sistema . De modo mais geral, uma saída em um ambiente multithreading significa que um thread de execução parou de funcionar. Para gerenciamento de recursos , o sistema operacional recupera recursos ( memória , arquivos , etc.) que foram usados pelo processo. O processo é considerado um processo morto depois de encerrado.
Como funciona
Sob Unix e Unix-like sistemas operacionais , um processo é iniciado quando o seu processo pai executa um garfo chamada de sistema . O processo pai pode então esperar que o processo filho termine ou pode continuar a execução (possivelmente bifurcando outros processos filho). Quando o processo filho termina ("morre"), normalmente chamando exit , ou anormalmente devido a uma exceção fatal ou sinal (por exemplo, SIGTERM , SIGINT , SIGKILL ), um status de saída é retornado ao sistema operacional e um sinal SIGCHLD é enviado para o processo pai. O status de saída pode então ser recuperado pelo processo pai por meio da chamada de sistema de espera .
A maioria dos sistemas operacionais permite que o processo de encerramento forneça um status de saída específico para o sistema, que é disponibilizado para o processo pai. Normalmente, é um valor inteiro, embora alguns sistemas operacionais (por exemplo, Plan 9 da Bell Labs ) permitam que uma sequência de caracteres seja retornada. Os sistemas que retornam um valor inteiro normalmente usam um valor zero para indicar uma execução bem-sucedida e valores diferentes de zero para indicar condições de erro. Outros sistemas (por exemplo, OpenVMS ) usam valores pares para sucesso e valores ímpares para erros. Ainda outros sistemas (por exemplo, IBM z / OS e seus predecessores) usam intervalos de valores inteiros para indicar resultados de sucesso, aviso e conclusão de erro.
Limpar
A operação de saída normalmente executa operações de limpeza dentro do espaço do processo antes de devolver o controle ao sistema operacional. Alguns sistemas e linguagens de programação permitem que as sub - rotinas do usuário sejam registradas de forma que sejam chamadas no encerramento do programa antes que o processo seja encerrado definitivamente. Como a etapa final do encerramento, uma chamada de saída do sistema primitiva é chamada, informando ao sistema operacional que o processo foi encerrado e permite que ele recupere os recursos usados pelo processo.
Às vezes, é possível ignorar a limpeza normal; C99 oferece a _exit()
função que termina o processo atual sem qualquer limpeza extra do programa. Isso pode ser usado, por exemplo, em uma rotina fork-exec quando a exec
chamada falha em substituir o processo filho; as atexit
rotinas de chamada liberariam erroneamente recursos pertencentes ao pai.
Órfãos e zumbis
Alguns sistemas operacionais tratam de um processo filho cujo processo pai foi encerrado de maneira especial. Esse processo órfão torna-se filho de um processo raiz especial , que então aguarda o término do processo filho. Da mesma forma, uma estratégia semelhante é usada para lidar com um processo zumbi , que é um processo filho que foi encerrado, mas cujo status de saída é ignorado por seu processo pai. Esse processo se torna filho de um processo pai especial, que recupera o status de saída do filho e permite que o sistema operacional conclua o encerramento do processo morto. Lidar com esses casos especiais mantém a tabela de processos do sistema em um estado consistente.
Exemplos
Os programas a seguir são encerrados e retornam um status de saída bem- sucedida ao sistema.
C :
|
C ++ :
#include <cstdlib>
int main()
{
std::exit(EXIT_SUCCESS); // or return EXIT_SUCCESS
}
|
COBOL :
IDENTIFICATION DIVISION.
PROGRAM-ID. SUCCESS-PROGRAM.
PROCEDURE DIVISION.
MAIN.
MOVE ZERO TO RETURN-CODE.
END PROGRAM.
Fortran :
program wiki
call exit(0)
end program wiki
Java :
public class Success
{
public static void main(String[] args)
{
System.exit(0);
}
}
Pascal :
program wiki;
begin
ExitCode := 0;
exit
end.
exit 0
Perl :
#!/usr/bin/env perl
exit;
PHP :
<?php
exit(0);
Python :
#!/usr/bin/env python3
import sys
sys.exit(0)
exit 0
; For MASM/TASM .MODEL SMALL .STACK .CODE main PROC NEAR MOV AH, 4Ch ; Service 4Ch - Terminate with Error Code MOV AL, 0 ; Error code INT 21h ; Interrupt 21h - DOS General Interrupts main ENDP END main ; Starts at main
Alguns programadores podem preparar tudo para INT 21h de uma vez:
MOV AX, 4C00h ; replace the 00 with your error code in HEX
Montagem x86 do Linux de 32 bits :
; For NASM MOV AL, 1 ; Function 1: exit() MOV EBX, 0 ; Return code INT 80h ; # Passes control to interrupt vector # invokes system call—in this case system call # number 1 with argument 0
# For GAS .text .global _start _start: movl $1, %eax # System call number 1: exit() movl $0, %ebx # Exits with exit status 0 int $0x80 # Passes control to interrupt vector # invokes system call—in this case system call # number 1 with argument 0
Linux 64-bit x86 64 Assembly: para FASM
format ELF64 executable 3
entry start
segment readable executable
start:
; STUFF
; exiting
mov eax, 60 ; sys_exit syscall number: 60
xor edi, edi ; set exit status to 0 (`xor edi, edi` is equal to `mov edi, 0` )
syscall ; call it
Conjunto OS X 64 bits x86 64 : para NASM
global _main
section .text
_main:
mov rax, 0x02000001 ; sys_exit syscall number: 1 (add 0x02000000 for OS X)
xor rdi, rdi ; set exit status to 0 (`xor rdi, rdi` is equal to `mov rdi, 0` )
syscall ; call exit()
janelas
No Windows, um programa pode se encerrar chamando a função ExitProcess ou RtlExitUserProcess.
Veja também
|
|
Referências
links externos
- The Single UNIX Specification , Issue 7 from The Open Group : encerrar um processo - Referência de interfaces do sistema,
- Referência C ++ para
std::exit