EXEC(2) — Silicon Graphics
NAME
execl, execv, execle, execve, execlp, execvp − execute a file
SYNOPSIS
int execl (path, arg0, arg1, ..., argn, 0)
char ∗path, ∗arg0, ∗arg1, ..., ∗argn;
int execv (path, argv)
char ∗path, ∗argv[ ];
int execle (path, arg0, arg1, ..., argn, 0, envp)
char ∗path, ∗arg0, ∗arg1, ..., ∗argn, ∗envp[ ];
int execve (path, argv, envp)
char ∗path, ∗argv[ ], ∗envp[ ];
int execlp (file, arg0, arg1, ..., argn, 0)
char ∗file, ∗arg0, ∗arg1, ..., ∗argn;
int execvp (file, argv)
char ∗file, ∗argv[ ];
DESCRIPTION
Exec in all its forms transforms the calling process into a new process. The new process is constructed from an ordinary, executable file called the new process file. This file consists of a header (see a.out(4)), a text segment, and a data segment. The data segment contains an initialized portion and an uninitialized portion (bss). There can be no return from a successful exec because the calling process is overlaid by the new process.
An interpreter file begins with a line of the form "#! interpreter". When an interpreter file is execve’d, the system execve’s the specified interpreter, giving it the name of the originally exec’d file as an argument, shifting over the rest of the original arguments.
Path points to a path name that identifies the new process file.
File points to the new process file. The path prefix for this file is obtained by a search of the directories passed as the environment line "PATH =" (see environ(5)). The environment is supplied by the shell (see sh(1)). The shell is invoked if a command file is found by execlp or execvp.
Arg0, arg1, ..., argn are pointers to null-terminated character strings. These strings constitute the argument list available to the new process. By convention, at least arg0 must be present and point to a string that is the same as path (or its last component).
Argv is an array of character pointers to null-terminated strings. These strings constitute the argument list available to the new process. By convention, argv must have at least one member, and it must point to a string that is the same as path (or its last component). Argv is terminated by a null pointer and is directly usable in another execv because argv[argc] is 0.
Envp is an array of character pointers to null-terminated strings. These strings constitute the environment for the new process. Envp is terminated by a null pointer. For execl and execv, the C run-time start-off routine places a pointer to the calling process’s environment in the global cell:
extern char ∗∗environ;
and it is used to pass the calling process’s environment to the new process.
File descriptors open in the calling process remain open in the new process, except for those whose close-on-exec flag is set; see fcntl(2). For those file descriptors that remain open, the file pointer is unchanged.
Signals set to terminate the calling process will be set to terminate the new process. Signals set to be ignored by the calling process will be set to be ignored by the new process. Signals set to be caught by the calling process will be set to terminate new process; see signal(2).
If the set-user-ID mode bit of the new process file is set (see chmod(2)), exec sets the effective user ID of the new process to the owner ID of the new process file. Similarly, if the set-group-ID mode bit of the new process file is set, the effective group ID of the new process is set to the group ID of the new process file. The real user ID and real group ID of the new process remain the same as those of the calling process.
The shared memory segments attached to the calling process will not be attached to the new process (see shmop(2)).
Profiling is disabled for the new process; see profil(2).
The new process also inherits the following attributes from the calling process:
nice value (see nice(2))
process ID
parent process ID
process group ID
semadj values (see semop(2))
tty group ID (see exit(2) and signal(2))
trace flag (see ptrace(2) request 0)
time left until an alarm clock signal (see alarm(2))
current working directory
root directory
file mode creation mask (see umask(2))
file size limit (see ulimit(2))
utime, stime, cutime, and cstime (see times(2))
From C, two interfaces are available. execl is useful when a known file with known arguments is being called; the arguments to execl are the character strings constituting the file and the arguments; the first argument is conventionally the same as the file name (or its last component). A 0 argument must end the argument list.
When a C program is executed, it is called as follows:
main(argc, argv, envp)
int argc;
char **argv, **envp;
where argc is the argument count and argv is an array of character pointers to the arguments themselves. As indicated, argc is conventionally at least one and the first member of the array points to a string containing the name of the file.
Envp is a pointer to an array of strings that constitute the environment of the process. Each string consists of a name, an “=”, and a null-terminated value. The array of pointers is terminated by a null pointer. The shell sh(1) passes an environment entry for each global shell variable defined when the program is called. See environ(5) for some conventionally used names. The C run-time start-off routine places a copy of envp in the global cell environ, which is used by execv and execl to pass the environment to any subprograms executed by the current program. The exec routines use lower-level routines as follows to pass an environment explicitly:
execve(file, argv, environ);
execle(file, arg0, arg1, . . . , argn, 0, environ);
Execlp and execvp are called with the same arguments as execl and execv, but duplicate the shell’s actions in searching for an executable file in a list of directories. The directory list is obtained from the environment.
Exec will fail and return to the calling process if one or more of the following are true:
One or more components of the new process file’s path name do not exist. [ENOENT]
A component of the new process file’s path prefix is not a directory. [ENOTDIR]
Search permission is denied for a directory listed in the new process file’s path prefix. [EACCES]
The new process file is not an ordinary file. [EACCES]
The new process file mode denies execution permission. [EACCES]
The exec is not an execlp or execvp, and the new process file has the appropriate access permission but an invalid magic number in its header. [ENOEXEC]
The new process file is a pure procedure (shared text) file that is currently open for writing by some process. [ETXTBSY]
The new process requires more memory than is allowed by the system-imposed maximum MAXMEM. [ENOMEM]
The number of bytes in the new process’s argument list and environment is greater than the system-imposed limit of 5120 bytes. [E2BIG]
The new process file is not as long as indicated by the size values in its header. [EFAULT]
Path, argv, or envp point to an illegal address. [EFAULT]
RETURN VALUE
If exec returns to the calling process an error has occurred; the return value will be −1 and errno will be set to indicate the error.
SEE ALSO
Version 2.5r1 — October 29, 1986