execve() executes the program pointed to by filename.
filename must be either a binary executable, or a script
starting with a line of the form "#! interpreter [arg]".
In the latter case, the interpreter must be a valid pathname for an
executable which is not itself a script, which will be invoked as
interpreter [arg] filename.
argv is an array of argument strings passed to the new program.
envp is an array of strings, conventionally of the form
key=value, which are passed as environment to the new
program. Both argv and envp must be terminated by a null
pointer. The argument vector and environment can be accessed by the
called program’s main function, when it is defined as int main(int
argc, char *argv[], char *envp[]).
execve() does not return on success, and the text, data, bss, and
stack of the calling process are overwritten by that of the program
loaded.
If the current program is being ptraced, a SIGTRAP is sent to it
after a successful execve().
If the set-user-ID bit is set on the program file pointed to by
filename, and the calling process is not being ptraced,
then the effective user ID of the calling process is changed
to that of the owner of the program file.
Similarly, when the set-group-ID
bit of the program file is set the effective group ID of the calling
process is set to the group of the program file.
The effective user ID of the process is copied to the saved set-user-ID;
similarly, the effective group ID is copied to the saved set-group-ID.
This copying takes place after any effective ID changes that occur
because of the set-user-ID and set-group-ID permission bits.
If the executable is an a.out dynamically-linked
binary executable containing
shared-library stubs, the Linux dynamic linker
ld.so(8)
is called at the start of execution to bring
needed shared libraries into memory
and link the executable with them.
If the executable is a dynamically-linked ELF executable, the
interpreter named in the PT_INTERP segment is used to load the needed
shared libraries. This interpreter is typically
/lib/ld-linux.so.1 for binaries linked with the Linux libc
version 5, or /lib/ld-linux.so.2 for binaries linked with the
GNU libc version 2.
All process attributes are preserved during an
execve(), except the following:
*
File descriptors that are marked close-on-exec are closed
(see the description of
FD_CLOEXEC in
fcntl(2)).
*
The set of pending signals is cleared
(sigpending(2)).
*
The dispositions of any signals that are being caught are
reset to being ignored.
*
Any alternate signal stack is not preserved
(sigaltstack(2)).
*
Memory mappings are not preserved
(mmap(2)).
*
Attached System V shared memory segments are detached
(shmat(2)).
*
POSIX shared memory regions are unmapped
(shm_open(3)).
*
Open POSIX message queue descriptors are closed
(mq_overview(7)).
*
Any open POSIX named semaphores are closed
(sem_overview(7)).
*
POSIX timers are not preserved
(timer_create(3)).
*
Any open directory streams are closed
(opendir(3)).
*
Memory locks are not preserved
(mlock(2),
mlockall(2)).
*
Exit handlers are not preserved
(atexit(3),
on_exit(3)).
The process attributes in the preceding list are all specified
in POSIX.1-2001.
The following Linux-specific process attributes are also
not preserved during an
execve():
*
The
prctl(2)
PR_SET_DUMPABLE flag is set,
unless a set-user-ID or set-group ID program is being executed,
in which case it is cleared.
*
The
prctl(2)
PR_SET_KEEPCAPS flag is cleared.
*
The process name, as set by
prctl(2)
PR_SET_NAME (and displayed by
ps -o comm), is reset to the name of the new executable file.
*
The termination signal is reset to SIGCHLD
(see
clone(2)).
Note the following further points:
*
All threads other than calling thread are destroyed during an
execve(). Mutexes, condition variables, and other pthreads objects are not preserved.
*
The equivalent of setlocale(LC_ALL, "C")
is executed at program start-up.
*
POSIX.1-2001 specifies that the dispositions of any signals that
are ignored or set to the default are left unchanged.
POSIX.1-2001 specifies one exception: if SIGCHLD is being ignored,
then an implementation may leave the disposition unchanged or
reset it to the default; Linux does the former.
*
Any outstanding asynchronous I/O operations are cancelled
(aio_read(3),
aio_write(3)).
*
For the handling of capabilities during
execve(2),
see
capabilities(7).
Set-user-ID and set-group-ID processes can not be ptrace()d.
Linux ignores the set-user-ID and set-group-ID bits on scripts.
The result of mounting a filesystem
nosuid vary between Linux kernel versions:
some will refuse execution of set-user-ID and set-group-ID
executables when this would
give the user powers she did not have already (and return EPERM),
some will just ignore the set-user-ID and set-group-ID bits and
exec() successfully.
A maximum line length of 127 characters is allowed for the first line in
a #! executable shell script.
With Unix V6 the argument list of an
exec() call was ended by 0,
while the argument list of
main was ended by -1. Thus, this
argument list was not directly usable in a further
exec() call.
Since Unix V7 both are NULL.
