salir (llamada al sistema) - exit (system call)
En muchos sistemas operativos de computadora , un proceso de computadora termina su ejecución haciendo una llamada de salida al sistema . De manera más general, una salida en un entorno de subprocesos múltiples significa que un subproceso de ejecución ha dejado de ejecutarse. Para la gestión de recursos , el sistema operativo recupera recursos ( memoria , archivos , etc.) que fueron utilizados por el proceso. Se dice que el proceso es un proceso muerto después de que termina.
Cómo funciona
Bajo Unix y Unix-como sistemas operativos , se inicia un proceso cuando su proceso padre se ejecuta un tenedor llamada al sistema . El proceso padre puede entonces esperar para el proceso hijo a terminar o puede continuar la ejecución (posiblemente se bifurcan fuera otros procesos secundarios). Cuando el proceso hijo termina ("muere"), ya sea normalmente llamando a exit o de forma anormal debido a una excepción o señal fatal (por ejemplo, SIGTERM , SIGINT , SIGKILL ), se devuelve un estado de salida al sistema operativo y se envía una señal SIGCHLD. enviado al proceso padre. El proceso principal puede recuperar el estado de salida a través de la llamada al sistema de espera .
La mayoría de los sistemas operativos permiten que el proceso de terminación proporcione un estado de salida específico al sistema, que se pone a disposición del proceso principal. Normalmente, se trata de un valor entero, aunque algunos sistemas operativos (por ejemplo, Plan 9 de Bell Labs ) permiten que se devuelva una cadena de caracteres . Los sistemas que devuelven un valor entero suelen utilizar un valor cero para indicar una ejecución satisfactoria y valores distintos de cero para indicar condiciones de error. Otros sistemas (por ejemplo, OpenVMS ) utilizan valores pares para el éxito y valores impares para los errores. Otros sistemas (por ejemplo, IBM z / OS y sus predecesores) utilizan rangos de valores enteros para indicar resultados de éxito, advertencia y finalización de error.
Limpiar
La operación de salida normalmente realiza operaciones de limpieza dentro del espacio del proceso antes de devolver el control al sistema operativo. Algunos sistemas y lenguajes de programación permiten que se registren subrutinas de usuario para que se invoquen al finalizar el programa antes de que el proceso termine definitivamente. Como paso final de la terminación, se invoca una llamada de salida del sistema primitivo, que informa al sistema operativo que el proceso ha terminado y le permite recuperar los recursos utilizados por el proceso.
A veces es posible omitir la limpieza habitual; C99 ofrece la _exit()
función que finaliza el proceso actual sin ninguna limpieza adicional del programa. Esto se puede usar, por ejemplo, en una rutina fork-exec cuando la exec
llamada no reemplaza el proceso hijo; las atexit
rutinas de llamada liberarían erróneamente los recursos que pertenecen al padre.
Huérfanos y zombis
Algunos sistemas operativos manejan un proceso hijo cuyo proceso padre ha terminado de una manera especial. Dicho proceso huérfano se convierte en hijo de un proceso raíz especial , que luego espera a que termine el proceso hijo. Asimismo, se utiliza una estrategia similar para tratar con un proceso zombi , que es un proceso hijo que ha terminado pero cuyo estado de salida es ignorado por su proceso padre. Dicho proceso se convierte en hijo de un proceso padre especial, que recupera el estado de salida del hijo y permite que el sistema operativo complete la terminación del proceso muerto. Tratar con estos casos especiales mantiene la tabla de procesos del sistema en un estado consistente.
Ejemplos de
Los siguientes programas terminan y devuelven un estado de salida satisfactoria al 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
Algunos programadores pueden preparar todo para INT 21h a la vez:
MOV AX, 4C00h ; replace the 00 with your error code in HEX
Ensamblado Linux de 32 bits x86 :
; 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
Ensamblaje Linux 64-bit x86 64 : 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
Ensamblaje OS X 64-bit 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()
Ventanas
En Windows, un programa se puede terminar llamando a la función ExitProcess o RtlSalirUserProcess.
Ver también
|
|
Referencias
enlaces externos
- Especificación única de UNIX , Edición 7 de The Open Group : terminar un proceso - Referencia de interfaces del sistema,
- Referencia de C ++ para
std::exit