Error codes common exit codes

From Wikipedia, the free encyclopedia

«Exit code» redirects here. For the prefix used to place an international telephone call, see International call prefix.

«Result code» redirects here. For the result code of software in general, see Return code.

The exit status of a process in computer programming is a small number passed from a child process (or callee) to a parent process (or caller) when it has finished executing a specific procedure or delegated task. In DOS, this may be referred to as an errorlevel.

When computer programs are executed, the operating system creates an abstract entity called a process in which the book-keeping for that program is maintained. In multitasking operating systems such as Unix or Linux, new processes can be created by active processes. The process that spawns another is called a parent process, while those created are child processes. Child processes run concurrently with the parent process. The technique of spawning child processes is used to delegate some work to a child process when there is no reason to stop the execution of the parent. When the child finishes executing, it exits by calling the exit system call. This system call facilitates passing the exit status code back to the parent, which can retrieve this value using the wait system call.

Semantics[edit]

The parent and the child can have an understanding about the meaning of the exit statuses. For example, it is common programming practice for a child process to return (exit with) zero to the parent signifying success. Apart from this return value from the child, other information like how the process exited, either normally or by a signal may also be available to the parent process.

The specific set of codes returned is unique to the program that sets it. Typically it indicates success or failure. The value of the code returned by the function or program may indicate a specific cause of failure. On many systems, the higher the value, the more severe the cause of the error.^[1] Alternatively, each bit may indicate a different condition, with these being evaluated by the or operator together to give the final value; for example, fsck does this.

Sometimes, if the codes are designed with this purpose in mind, they can be used directly as a branch index upon return to the initiating program to avoid additional tests.

AmigaOS[edit]

In AmigaOS, MorphOS and AROS, four levels are defined:

• OK 0
• WARN 5
• ERROR 10
• FAILURE 20

Shell and scripts[edit]

Shell scripts typically execute commands and capture their exit statuses.

For the shell’s purposes, a command which exits with a zero exit status has succeeded. A nonzero exit status indicates failure. This seemingly counter-intuitive scheme is used so there is one well-defined way to indicate success and a variety of ways to indicate various failure modes. When a command is terminated by a signal whose number is N, a shell sets the variable $? to a value greater than 128. Most shells use 128+N, while ksh93 uses 256+N.

If a command is not found, the shell should return a status of 127. If a command is found but is not executable, the return status should be 126.^[2] Note that this is not the case for all shells.

If a command fails because of an error during expansion or redirection, the exit status is greater than zero.

C language[edit]

The C programming language allows programs exiting or returning from the main function to signal success or failure by returning an integer, or returning the macros EXIT_SUCCESS and EXIT_FAILURE. On Unix-like systems these are equal to 0 and 1 respectively.^[3] A C program may also use the exit() function specifying the integer status or exit macro as the first parameter.

The return value from main is passed to the exit function, which for values zero, EXIT_SUCCESS or EXIT_FAILURE may translate it to “an implementation defined form” of successful termination or unsuccessful termination.

Apart from zero and the macros EXIT_SUCCESS and EXIT_FAILURE, the C standard does not define the meaning of return codes. Rules for the use of return codes vary on different platforms (see the platform-specific sections).

DOS[edit]

In DOS terminology, an errorlevel is an integer exit code returned by an executable program or subroutine. Errorlevels typically range from 0 to 255.^[4][5][6][7] In DOS there are only 256 error codes available, but DR DOS 6.0 and higher support 16-bit error codes at least in CONFIG.SYS.^[6] With 4DOS and DR-DOS COMMAND.COM, exit codes (in batchjobs) can be set by EXIT n^[6] and (in CONFIG.SYS) through ERROR=n.^[6]

Exit statuses are often captured by batch programs through IF ERRORLEVEL commands.^[4][6] Multiuser DOS supports a reserved environment variable %ERRORLVL% which gets automatically updated on return from applications. COMMAND.COM under DR-DOS 7.02 and higher supports a similar pseudo-environment variable %ERRORLVL% as well as %ERRORLEVEL%. In CONFIG.SYS, DR DOS 6.0 and higher supports ONERROR to test the load status and return code of device drivers and the exit code of programs.^[6]

Java[edit]

In Java, any method can call System.exit(int status), unless a security manager does not permit it. This will terminate the currently running Java Virtual Machine. «The argument serves as a status code; by convention, a nonzero status code indicates abnormal termination.»^[8]

OpenVMS[edit]

In OpenVMS, success is indicated by odd values and failure by even values.
The value is a 32 bit integer with sub-fields: control bits, facility number, message number and severity. Severity values are divided between success (Success, Informational) and failure (Warning, Error, Fatal).^[9]

POSIX[edit]

In Unix and other POSIX-compatible systems, the parent process can retrieve the exit status of a child process using the wait() family of system calls defined in wait.h.^[10] Of these, the waitid() ^[11] call retrieves the full 32-bit exit status, but the older wait() and waitpid() ^[12] calls retrieve only the least significant 8 bits of the exit status.

The wait() and waitpid() interfaces set a status value of type int packed as a bitfield with various types of child termination information. If the child terminated by exiting (as determined by the WIFEXITED() macro; the usual alternative being that it died from an uncaught signal), SUS specifies that the low-order 8 bits of the exit status can be retrieved from the status value using the WEXITSTATUS() macro.

In the waitid() system call (added with SUSv1), the child exit status and other information are no longer in a bitfield but in the structure of type siginfo_t.^[13]

POSIX-compatible systems typically use a convention of zero for success and nonzero for error.^[14] Some conventions have developed as to the relative meanings of various error codes; for example GNU recommend that codes with the high bit set be reserved for serious errors.^[3]

BSD-derived OS’s have defined an extensive set of preferred interpretations: Meanings for 15 status codes 64 through 78 are defined in sysexits.h.^[15] These historically derive from sendmail and other message transfer agents, but they have since found use in many other programs.^[16]

For portability reasons, glibc defines the macros EXIT_SUCCESS and EXIT_FAILURE. The Advanced Bash-Scripting Guide and /usr/include/sysexits.h have some information on the meaning of non-0 exit status codes.^[17]

Windows[edit]

Windows uses 32-bit unsigned integers as exit codes,^[18][19] although the command interpreter treats them as signed.^[20]

Exit codes are directly referenced, for example, by the command line interpreter CMD.exe in the errorlevel terminology inherited from DOS. .NET Framework processes and the Windows PowerShell refer to it as the ExitCode property of the Process object.

See also[edit]

• Error code
• Return statement
• true and false (commands)

References[edit]

By Matthew Adams 🕤 Updated on January 27, 2023 at 9:30 am

Automation Workshop monitors files and folders on local & network or remote servers like Amazon S3 and SFTP, and executes Actions when files or folders are created, modified, or deleted according to defined conditions · Getting started · See more Automation videos

Let’s debug… the codes

Automation Workshop is a versatile tool that can handle complex automation scenarios including launching external apps therefore advanced error handling and debug capability is an essential part of process automation. Some Run Actions may complete with errorlevels or exit codes…

• Run CMD Command · Advanced · Variables · Events 68000, 68002, 68202, and 68402
• Start App · Advanced · Variables · Events 67000, 67002, 67202, and 67402
• Terminate App · Options · Variables · Events 420000, 420001, and 420400
• Remote FTP Command · Options · Variables · Events 338000 and 338402
• Remote SSH Command · Options · Variables · Events 337000 and 337402

…that indicate the termination status of executed Command or Application.

Exit codes

Program exit codes allow determining the specific reason for command’s or application’s termination. Although Automation Workshop shows codes in decimal format, they are also referred to as hexadecimal or negative decimal values.

Help more?

For some error codes, Windows may provide a more friendly error message. NET HELPMSG displays information about Windows network messages (such as errors, warnings, and alerts). When you type NET HELPMSG and the error code (for example, net helpmsg 2182), Windows tells you more about the error code and may suggest actions to solve the issue.

This will only work for Windows API Win32 error codes that originate from Microsoft Windows. If net help does not return a valid result, it can mean that the problem originates in external processes such as executed application or command syntax.

More ways to Run…

• API · Run Task using API
• Remote Manager · Remote Operations · Remote deployment · Run Remote Tasks
• Interactive · Desktop Shortcut · Tray Icon · Command line
• Advanced fallback · On Task Error · On Action Error
• Post-execution events

Discover

Automation Workshop includes many more awesome Triggers and numerous Actions to aid you to automate any repetitive computer or business task by providing state-of-the-art GUI tools.

Just ask…

If you have any questions, please do not hesitate to contact our support team.

To a first approximation, 0 is success, non-zero is failure, with 1 being general failure, and anything larger than one being a specific failure. Aside from the trivial exceptions of false and test, which are both designed to give 1 for success, there’s a few other exceptions I found.

More realistically, 0 means success or maybe failure, 1 means general failure or maybe success, 2 means general failure if 1 and 0 are both used for success, but maybe success as well.

The diff command gives 0 if files compared are identical, 1 if they differ, and 2 if binaries are different. 2 also means failure. The less command gives 1 for failure unless you fail to supply an argument, in which case, it exits 0 despite failing.

The more command and the spell command give 1 for failure, unless the failure is a result of permission denied, nonexistent file, or attempt to read a directory. In any of these cases, they exit 0 despite failing.

Then the expr command gives 1 for success unless the output is the empty string or zero, in which case, 0 is success. 2 and 3 are failure.

Then there’s cases where success or failure is ambiguous. When grep fails to find a pattern, it exits 1, but it exits 2 for a genuine failure (like permission denied). klist also exits 1 when it fails to find a ticket, although this isn’t really any more of a failure than when grep doesn’t find a pattern, or when you ls an empty directory.

So, unfortunately, the Unix powers that be don’t seem to enforce any logical set of rules, even on very commonly used executables.

In consumer productsEdit

In computingEdit

In networking softwareEdit

In automobilesEdit

Error codes and exception handlingEdit

See alsoEdit

ReferencesEdit

External linksEdit