EXEC(2)                              SysV                              EXEC(2)



NAME
     exec: execl, execv, execle, execve, execlp, execvp - execute a file

SYNOPSIS
     int execl (path, arg0, arg1, ..., argn, (char *)0)
     char *path, *arg0, *arg1, ..., *argn;

     int execv (path, argv)
     char *path, *argv[ ];

     int execle (path, arg0, arg1, ..., argn, (char *)0, envp)
     char *path, *arg0, *arg1, ..., *argn, *envp[ ];

     int execve (path, argv, envp)
     char *path, *argv[ ], *envp[ ];

     int execlp (file, arg0, arg1, ..., argn, (char *)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.

     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, argv is an array of character pointers
     to the arguments themselves, and envp is an array of character pointers
     to the environment strings.  As indicated, argc is conventionally at
     least 1 and the first member of the array points to a string containing
     the name of the file.

     path points to a pathname 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)).

     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.

     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 environment of the calling
     process in the global cell:

          extern char **environ;

     and it is used to pass the environment of the calling process 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)).

     For signals set by sigset(2), exec will ensure that the new process has
     the same system signal action for each signal type whose action is
     SIG_DFL, SIG_IGN, or SIG_HOLD as the calling process.  However, if the
     action is to catch the signal, then the action will be reset to SIG_DFL,
     and any pending signal for this type will be held.

     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))
     ⊕  File-locks (see fcntl(2) and lockf(3C))

DIAGNOSTICS
     A successful call never returns.  A failed call returns -1 and sets errno
     as indicated below.

ERRORS
     exec will fail and return to the calling process if one or more of the
     following are true:

     [ENOENT]      One or more components of the new process pathname of the
                   file do not exist.

     [ENOTDIR]     A component of the new process path of the file prefix is
                   not a directory.

     [EACCES]      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.

     [ENOEXEC]     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.

     [ETXTBSY]     The new process file is a pure procedure (shared text) file
                   that is currently open for writing by some process.

     [ENOMEM]      The new process requires more memory than is allowed by the
                   system-imposed maximum MAXMEM.

     [E2BIG]       The number of bytes in the new process' argument list is
                   greater than the system-imposed limit of 10240 bytes.

     [EFAULT]      Required hardware is not present.

     [EFAULT]      path, argv, or envp point to an illegal address.

     [EAGAIN]      Not enough memory.

     [EINTR]       A signal was caught during the exec system call.

SEE ALSO
     alarm(2), exit(2), fcntl(2), fork(2), nice(2), ptrace(2), semop(2),
     signal(2), sigset(2), times(2), ulimit(2), umask(2), lockf(3C), a.out(4),
     environ(5).
     sh(1) in the SysV Command Reference.

NOTES
     Under other implementations, exec fails if any of the following are true:

     [EFAULT]      An a.out that was compiled with the MAU or 32B flag is
                   running on a machine without a MAU or 32B.

     [ENOLINK]     path points to a remote machine and the link to that
                   machine is no longer active.

     [EMULTIHOP]   Components of path require hopping to multiple remote
                   machines.

     [ELIBACC]     Required shared library does not have execute permission.

     [ELIBEXEC]    Trying to exec(2) a shared library directly.