View source for Exit (system call)

{{Short description|Call by which a computer process terminates its execution}}
{{use list-defined references|date=December 2021}}
{{lowercase}}
On many computer operating systems, a computer process terminates its execution by making an '''exit''' [[System call|system call]]. More generally, an exit in a multithreading environment means that a thread of execution has stopped running. For [[Resource management (computing)|resource management]], the [[Operating system|operating system]] reclaims resources (memory, [[Computer file|files]], etc.) that were used by the process. The process is said to be a ''dead process'' after it terminates.

==How it works==
Under [[Software:Unix|Unix]] and [[Unix-like]] operating systems, a process is started when its [[Parent process|parent process]] executes a ''fork'' [[System call|system call]]. The parent process may then wait for the [[Child process|child process]] to terminate, or may continue execution (possibly forking off other child processes). When the child process terminates ("dies"), either normally by calling ''exit'', or [[Abnormal end|abnormally]] due to a fatal exception or [[Signal (IPC)|signal]] (e.g., SIGTERM, SIGINT, SIGKILL), an [[Exit status|exit status]] is returned to the operating system and a SIGCHLD signal is sent to the parent process. The exit status can then be retrieved by the parent process via the ''wait'' system call.

Most operating systems allow the terminating process to provide a specific [[Exit status|exit status]] to the system, which is made available to the parent process. Typically this is an integer value, although some operating systems (e.g., [[Software:Plan 9 from Bell Labs|Plan 9 from Bell Labs]]) allow a character string to be returned. Systems returning an integer value commonly use a zero value to indicate successful execution and non-zero values to indicate error conditions. Other systems (e.g., [[Software:OpenVMS|OpenVMS]]) use even-numbered values for success and odd values for errors. Still other systems (e.g., IBM z/OS and its predecessors) use ranges of integer values to indicate success, warning, and error completion results.

===Clean up===
The exit operation typically performs clean-up operations within the process space before returning control back to the operating system. Some systems and programming languages allow user subroutines to be registered so that they are invoked at program termination before the process actually terminates for good. As the final step of termination, a primitive system exit call is invoked, informing the operating system that the process has terminated and allows it to reclaim the resources used by the process.

It is sometimes possible to bypass the usual cleanup; [[C99]] offers the <code>_exit()</code> function which terminates the current process without any extra program clean-up.  This may be used, for example, in a fork-exec routine when the <code>exec</code> call fails to replace the child process; calling <code>atexit</code> routines would erroneously release resources belonging to the parent.

===Orphans and zombies===
Some operating systems handle a child process whose parent process has terminated in a special manner.  Such an ''[[Orphan process|orphan process]]'' becomes a child of a special ''[[Software:Init|root process]]'', which then waits for the child process to terminate. Likewise, a similar strategy is used to deal with a ''[[Zombie process|zombie process]]'', which is a child process that has terminated but whose exit status is ignored by its parent process.  Such a process becomes the child of a special parent process, which retrieves the child's exit status and allows the operating system to complete the termination of the dead process. Dealing with these special cases keeps the system process table in a consistent state.

==Examples==

The following programs terminate and return a success [[Exit status|exit status]] to the system.
{|
|[[C (programming language)|C]]:
{|
|<source lang="c">
#include <stdlib.h>

int main(void)
{
    exit(EXIT_SUCCESS); /* or return EXIT_SUCCESS */
}
</source>
|}
|[[C++]]:

<source lang="cpp">
#include <cstdlib>

int main()
{
    std::exit(EXIT_SUCCESS); // or return EXIT_SUCCESS
}
</source>
|}
[[COBOL]]:

<source lang="cobolfree">
 IDENTIFICATION DIVISION.
 PROGRAM-ID. SUCCESS-PROGRAM.
 
 PROCEDURE DIVISION.
 MAIN.
     MOVE ZERO TO RETURN-CODE.
 END PROGRAM.
</source>

[[Fortran]]:
<source lang="fortran">
 program wiki
      call exit(0)
 end program wiki
</source>

[[Java (programming language)|Java]]:
<source lang="java">
public class Success
{
    public static void main(String[] args)
    {
        System.exit(0);
    }
}
</source>

[[Pascal (programming language)|Pascal]]:
<source lang="pascal">
program wiki;
begin
        ExitCode := 0;
        exit
end.
</source>

[[Software:DR-DOS|DR-DOS]] [[Batch file|batch file]]:<!-- Return codes for EXIT are not supported by MS-DOS/PC DOS COMMAND.COM, but they are by COMMAND.COM of DR-DOS, and by 4DOS. --><ref name="Paul_1997_NWDOSTIP"/>
<source lang="dosbatch">
exit 0
</source>

[[Perl]]:
<source lang="perl">
#!/usr/bin/env perl
exit;
</source>

[[Organization:PHP|PHP]]:
<source lang="php">
<?php
exit(0);
</source>

[[Python (programming language)|Python]]:
<source lang="python">
#!/usr/bin/env python3
import sys
sys.exit(0)
</source>

[[Unix shell]]:
<source lang="bash">
exit 0
</source>

[[Engineering:DOS|DOS]] [[Assembly language|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''

Some programmers may prepare everything for INT 21h at once:

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

[[Software:Linux|Linux]] 32-bit [[X86|x86]] Assembly:

 ; For [[Software:Netwide Assembler|NASM]]
 MOV AL, 1 ; Function 1: exit()
 MOV EBX, 0 ; Return code
 INT 80h ; ''# Passes control to interrupt vector''
               ''# [http://www.linfo.org/int_0x80.html invokes system call]—in this case system call''
               ''# number 1 with argument 0''

 ''# For [[Software:GNU Assembler|GAS]]''
 .text
 
 .global _start
 
 _start:
     movl $1, %eax  ''# System call number 1: exit()''
     movl $0, %ebx  ''# Exits with [[Exit status|exit status]] 0''
     int $0x80      ''# Passes control to interrupt vector''
                    ''# [http://www.linfo.org/int_0x80.html invokes system call]—in this case system call''
                    ''# number 1 with argument 0''

[[Software:Linux|Linux]] 64-bit x86 64 Assembly: for [[Software:FASM|FASM]]

<source lang="nasm">
 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
</source>

[[Software:OS X|OS X]] 64-bit x86 64 Assembly: for [[Software:Netwide Assembler|NASM]]

<source lang="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()
</source>

==Windows==
On Windows, a program can terminate itself by calling ExitProcess or RtlExitUserProcess function.

==See also==
{{div col|colwidth=22em}}
* [[Software:Exit (command)|exit (command)]]
* [[Child process]]
* Execution
* [[Exit status]]
* Fork
* Kill command
* [[Orphan process]]
* [[Process (computing)|Process]]
* [[Parent process]]
* SIGCHLD
* Task
* Thread
* Wait
{{div col end}}

==References==
{{Reflist|refs=
<ref name="Paul_1997_NWDOSTIP">{{cite book |title=NWDOS-TIPs &mdash; Tips & Tricks rund um Novell DOS 7, mit Blick auf undokumentierte Details, Bugs und Workarounds |chapter=II.4. Undokumentierte Eigenschaften externer Kommandos |work=MPDOSTIP |author-first=Matthias R. |author-last=Paul |date=1997-07-30 |orig-date=1994-05-01 |edition=3 |version=Release 157 |language=de |url=http://www.antonis.de/dos/dos-tuts/mpdostip/html/nwdostip.htm |access-date=2012-01-11 |url-status=live |archive-url=https://web.archive.org/web/20161105172944/http://www.antonis.de/dos/dos-tuts/mpdostip/html/nwdostip.htm |archive-date=2016-11-05}} (NB. <code>NWDOSTIP.TXT</code> is a comprehensive work on Novell DOS 7 and OpenDOS 7.01, including the description of many undocumented features and internals. It is part of the author's yet larger <code>MPDOSTIP.ZIP</code><!-- still named TIPS_MP.ZIP between 1991 and 1996-11 --> collection maintained up to 2001 and distributed on many sites at the time. The provided link points to a HTML-converted older version of the file.) [https://web.archive.org/web/20190601152204/https://www.sac.sk/download/text/mpdostip.zip<!-- A yet older version 155 from 1997-05-13 of the 1997-07-15 distribution archive. -->]</ref>
}}

==External links==
* {{man|sh|exit|SUS|terminate a process}}
* [http://en.cppreference.com/w/cpp/utility/program/exit C++ reference for <code>std::exit</code>]

[[Category:C standard library]]
[[Category:Process (computing)]]
[[Category:POSIX]]

{{Sourceattribution|Exit (system call)}}