exec (computing)

This article is about the computer operating system function. For other uses, see Exec (disambiguation).

In computing, exec is a functionality of an operating system that runs an executable file in the context of an already existing process, replacing the previous executable. This act is also referred to as anoverlay. It is especially important in Unix-like systems, although exists elsewhere. As a new process is not created, the process identifier (PID) does not change, but the machine code, data, heap, and stackof the process are replaced by those of the new program.

The exec is available for many programming languages including compilable languages and somescripting languages. In OS command interpreters, exec built-in command replaces the shell process with the specified program.[1] Though, in some languages the call named exec means passing the command line to a command interpreter, a different function.


Interfaces to exec and its implementations vary. Depending on programming language it may be accessible via one or more functions, and depending on operating system it may be represented with one or more actual system calls. For this reason exec is sometimes described as a collection of functions.

Standard names of such functions in C are execl, execle, execlp, execv, execve, and execvp(see below), but not “exec” itself. Linux kernel has one corresponding system call named “execve”, whereas all aforementioned functions are user-space wrappers around it.

Higher-level languages usually provide one call named exec.

Unix, POSIX, and other multitasking systems[edit]

C language prototypes[edit]

The POSIX standard declares exec functions in the unistd.h header file, in C language. The same functions are declared in process.h for DOS (see below), OS/2, and Microsoft Windows.

int execl(char const *path, char const *arg0, ...);
int execle(char const *path, char const *arg0, ..., char const *envp[]);
int execlp(char const *file, char const *arg0, ...);
int execv(char const *path, char const *argv[]);
int execve(char const *path, char const *argv[], char const *envp[]);
int execvp(char const *file, char const *argv[]);

Some implementations provide these functions named with a leading underscore (e.g. _execl).

The base of each is exec (execute), followed by one or more letters:

e – An array of pointers to environment variables is explicitly passed to the new process image.
lCommand-line arguments are passed individually (a list) to the function.
p – Uses the PATH environment variable to find the file named in the path argument to be executed.
v – Command-line arguments are passed to the function as an array (vector) of pointers.

The argument specifies the path name of the file to execute as the new process image. Arguments beginning at arg0 are pointers to arguments to be passed to the new process image. The argv value is an array of pointers to arguments.


The first argument arg0 should be the name of the executable file. Usually it is the same value as thepath argument. Some programs may incorrectly rely on this argument providing the location of the executable, but there is no guarantee of this nor is it standardized across platforms.


Argument envp is an array of pointers to environment settings. The exec calls named ending with an ealter the environment for the new process image by passing a list of environment settings through theenvp argument. This argument is an array of character pointers; each element (except for the final element) points to a null-terminated string defining an environment variable.

Each null-terminated string has the form:


where name is the environment variable name, and value is the value of that that variable. The final element of the envp array must be null.

In the execl, execlp, execv, and execvp calls, the new process image inherits the current environment variables.


A file descriptor open when an exec call is made remain open in the new process image, unless wasfcntled with FD_CLOEXEC. This aspect is used to specify the standard streams (stdin, stdout and stderr) of the new program.

A successful overlay destroys the previous memory address space of the process, and all its memory areas, that were not shared, are reclaimed by the operating system. Consequently, all its data that were not passed to the new program, or otherwise saved, become lost.

Return value[edit]

A successful exec replaces the current process image, so it cannot return anything to the program that made the call. Processes do have an exit status, but that value is collected by the parent process.

If an exec function does return to the calling program, an error occurs, the return value is −1, and errnois set to one of the following values:

Name Notes
E2BIG The argument list exceeds the system limit.
EACCES The specified file has a locking or sharing violation.
ENOENT The file or path name not found.
ENOMEM Not enough memory is available to execute the new process image.

DOS operating systems[edit]

DOS is not a multitasking operating system, but replacing the previous executable image has a great merit there due to harsh primary memory limitations and lack of virtual memory. The same API is used for overlaying programs in DOS and it has effects similar to ones on POSIX systems.

MS-DOS exec functions always load the new program into memory as if the “maximum allocation” in the program’s executable file header is set to default value 0xFFFF. The EXEHDR utility can be used to change the maximum allocation field of a program. However, if this is done and the program is invoked with one of the exec functions, the program might behave differently from a program invoked directly from the operating-system command line or with one of the spawn functions (see below).

Command interpreters[edit]

Many Unix shells also offer a builtin exec command that replaces the shell process with the specified program.[1] Wrapper scripts often use this command to run a program (either directly or through aninterpreter or virtual machine) after setting environment variables or other configuration. By using exec, the resources used by the shell program do not need to stay in use after the program is started.[2]

The exec command can also perform a redirection. In some shells it is even possible to use the execcommand for redirection only, without making an actual overlay.


The traditional Unix system does not have the functionality to create a new process running a new executable program in one step, that explains the importance of exec for Unix programming. Other systems may use spawn as the main tool for running executables. Its result is equivalent to the fork-execsequence of Unix-like systems. POSIX supports the posix_spawn routines as an optional extension that usually is implemented using vfork.

Other Systems[edit]

OS/360 and successors include a system call XCTL (transfer control) that performs a similar function to exec.

See also[edit]

SOURCE: http://en.wikipedia.org/wiki/Exec_(computing)

This entry was posted in COMPUTING. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s