beenden (Systemaufruf) - exit (system call)

Auf vielen Computerbetriebssysteme , ein Computerprozeß beendet seine Ausführung durch einen machen Austrittssystemaufruf . Mehr ein Ausgang in einer im allgemeinen, Multithreading - Umgebung bedeutet , dass ein Thread der Ausführung mehr lief. Für die Ressourcenverwaltung fordert das Betriebssystem Ressourcen ( Speicher , Dateien usw.) zurück, die vom Prozess verwendet wurden. Der Prozess wird als toter Prozess bezeichnet, nachdem er beendet wurde.

Wie es funktioniert

Unter Unix und Unix-ähnlichen Betriebssystemen wird ein Prozess gestartet, wenn sein Elternprozess einen Fork- Systemaufruf ausführt . Der Elternprozess kann dann auf die Beendigung des Kindprozesses warten oder die Ausführung fortsetzen (möglicherweise andere Kindprozesse abspalten). Wenn der Kindprozess beendet ("stirbt"), entweder normalerweise durch Aufrufen von exit oder abnormal aufgrund einer schwerwiegenden Ausnahme oder eines Signals (zB SIGTERM , SIGINT , SIGKILL ), wird ein Exit-Status an das Betriebssystem zurückgegeben und ein SIGCHLD- Signal ist an den übergeordneten Prozess gesendet. Der Exit-Status kann dann vom Elternprozess über den Wait- Systemaufruf abgerufen werden .

Die meisten Betriebssysteme erlauben dem beendenden Prozess, dem System einen bestimmten Exit-Status zu geben, der dem Elternprozess zur Verfügung gestellt wird. Normalerweise ist dies ein ganzzahliger Wert, obwohl einige Betriebssysteme (z. B. Plan 9 von Bell Labs ) die Rückgabe einer Zeichenkette zulassen . Systeme, die einen ganzzahligen Wert zurückgeben, verwenden im Allgemeinen einen Nullwert, um eine erfolgreiche Ausführung anzuzeigen, und Werte ungleich Null, um Fehlerbedingungen anzuzeigen. Andere Systeme (zB OpenVMS ) verwenden geradzahlige Werte für den Erfolg und ungerade Werte für Fehler. Wieder andere Systeme (z. B. IBM z/OS und seine Vorgänger) verwenden Bereiche von ganzzahligen Werten, um Erfolgs-, Warnungs- und Fehlerabschlussergebnisse anzuzeigen.

Aufräumen

Die Exit-Operation führt typischerweise Bereinigungsoperationen innerhalb des Prozessraums durch, bevor die Steuerung wieder an das Betriebssystem zurückgegeben wird. Einige Systeme und Programmiersprachen ermöglichen Benutzer - Subroutinen registriert werden , so dass sie bei Beendigung des Programms aufgerufen werden , bevor der Prozess beendet eigentlich für gut. Als letzter Schritt der Beendigung wird ein primitiver Systemexit-Aufruf aufgerufen, der das Betriebssystem darüber informiert, dass der Prozess beendet wurde, und es ihm ermöglicht, die vom Prozess verwendeten Ressourcen zurückzufordern.

Manchmal ist es möglich, die übliche Bereinigung zu umgehen; C99 bietet die _exit()Funktion, den aktuellen Prozess ohne zusätzliche Programmbereinigung zu beenden. Dies kann beispielsweise in einer fork-exec- Routine verwendet werden, wenn der execAufruf den Kindprozess nicht ersetzt; Aufruf atexitRoutinen würden Ressourcen fälschlicherweise freigeben an die Mutter gehören.

Waisen und Zombies

Einige Betriebssysteme handhaben einen Kindprozess, dessen Elternprozess auf besondere Weise beendet wurde. Ein solcher verwaister Prozess wird ein Kind eines speziellen Root-Prozesses , der dann auf die Beendigung des Kindprozesses wartet. Ebenso wird eine ähnliche Strategie verwendet, um mit einem Zombie-Prozess umzugehen , bei dem es sich um einen Kindprozess handelt, der beendet wurde, dessen Beendigungsstatus jedoch von seinem Elternprozess ignoriert wird. Ein solcher Prozess wird zum Kind eines speziellen Elternprozesses, der den Exit-Status des Kinds abruft und es dem Betriebssystem ermöglicht, die Beendigung des toten Prozesses abzuschließen. Der Umgang mit diesen speziellen Fällen hält das System Prozesstabelle in einem konsistenten Zustand.

Beispiele

Die folgenden Programme werden beendet und geben einen erfolgreichen Exit-Status an das System zurück.

C : 
#include <stdlib.h>

int main(void)
{
    exit(EXIT_SUCCESS); /* or return EXIT_SUCCESS */
}
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.

PC-DOS- Stapeldatei : 

exit 0

Perl : 

#!/usr/bin/env perl
exit;

PHP : 

<?php
exit(0);

Python : 

#!/usr/bin/env python3
import sys
sys.exit(0)

Unix-Shell : 

exit 0

PC-DOS- Assembly : 

; 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

Manche Programmierer bereiten vielleicht alles auf einmal für INT 21h vor: 

    MOV AX, 4C00h ; replace the 00 with your error code in HEX

Linux 32-Bit- x86- Assembly: 

; 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: für 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

OS X 64-Bit- x86-64- Assembly: für 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()

Fenster

Unter Windows kann sich ein Programm durch Aufrufen der Funktion ExitProcess oder RtlExitUserProcess selbst beenden.

Siehe auch

Verweise

Externe Links