What is the difference between the functions of the exec family of system calls like exec and execve?
Solution 1
Use man exec
and read:
The execv(), execvp(), and execvpe() functions provide an array of pointers to
null-terminated strings that represent the argument list available to the new program.
The first argument, by convention, should point to the filename associated with the file
being executed. The array of pointers must be terminated by a NULL pointer.
execv
int execv(const char *path, char *const argv[]);
So you pass an array as parameters
int execle(const char *path, const char *arg,
..., char * const envp[]);
Almost the same, but not as an array, but rather as a list of values (strings), followed by an array the designates the environment.
Here:
int execvp(const char *file, char *const argv[]);
You are calling a file, without path, so it expects you to be already in the right path
before calling.
Last but not least:
int execve(const char *filename, char *const argv[],
char *const envp[]);
Similar to previous one, but now you have two arrays, for arguments and environment variables.
Solution 2
There is no exec
system call -- this is usually used to refer to all the execXX
calls as a group. They all do essentially the same thing: loading a new program into the current process, and provide it with arguments and environment variables. The differences are in how the program is found, how the arguments are specified, and where the environment comes from.
The calls with
v
in the name take an array parameter to specify theargv[]
array of the new program. The end of the arguments is indicated by an array element containingNULL
.The calls with
l
in the name take the arguments of the new program as a variable-length argument list to the function itself. The end of the arguments is indicated by a(char *)NULL
argument. You should always include the type cast, becauseNULL
is allowed to be an integer constant, and default argument conversions when calling a variadic function won't convert that to a pointer.The calls with
e
in the name take an extra argument (or arguments in thel
case) to provide the environment of the new program; otherwise, the program inherits the current process's environment. This is provided in the same way as theargv
array: an array forexecve()
, separate arguments forexecle()
.The calls with
p
in the name search thePATH
environment variable to find the program if it doesn't have a directory in it (i.e. it doesn't contain a/
character). Otherwise, the program name is always treated as a path to the executable.FreeBSD 5.2 added another variant:
execvP
(with uppercaseP
). This is likeexecvp()
, but instead of getting the search path from thePATH
environment variable, it's an explicit parameter to the function:
int execvP(const char *file, const char *search_path, char *const argv[]);
Solution 3
Since all of these function belongs to exec() family, let me differentiate
according to extra characters
with the meanings,
1.execve():
p : not present => name of the program to run will be taken from pathname
v : present => argument will be passed as array
e : present => environment will be taken from envp argument
2.execle():
p : not present => name of the program to run will be taken from pathname
l : present => argument will be passed as list
e : present => environment will be taken from envp argument
3.execlp():
p : present => name of the program to run will be taken from filename
specified or system will search for program file
in PATH
variable.
l : present => argument will be passed as list
e : not present => environment will be taken from caller's environ
4.execvp():
p : present => name of the program to run will be taken from filename
specified or system will search for program file
in PATH
variable.
v : present => argument will be passed as array
e : not present => environment will be taken from caller's environ
5.execv():
p : not present => name of the program to run will be taken from pathname
v : present => argument will be passed as array
e : not present => environment will be taken from caller's environ
6.execl():
p : not present => name of the program to run will be taken from pathname
l : present => argument will be passed as list
e : not present => environment will be taken from caller's environ
Solution 4
Main Idea
exec() family of functions replaces existing process image with a new process image. This is a marked difference from fork() system call where the parent and child processes co-exist in the memory.
exec() family of functions
int execv (const char *filename, char *const argv[])
The filename is the file of the new process image.
argv represents an array of null-terminated strings.The last element of this array must be a null pointer.
int execl (const char *filename, const char *arg0, …)
Same as execv but the arguments are provided as an individual string (separated by commas) instead of an array/vector.
int execve (const char *filename, char *const argv[], char *const env[])
Same as execv but it permits to specify environment variables for new process image.
int execle (const char *filename, const char *arg0, …, char *const env[])
Same as execl but it permits to specify environment variables for new process image.
int execvp (const char *filename, char *const argv[])
Same as execv function but it searches standard environment variable PATH to find the filename if the filename does not contain a slash.
Here is a list of standard environment variable:
https://www.gnu.org/software/libc/manual/html_node/Standard-Environment.html#Standard-Environment
int execlp (const char *filename, const char *arg0, …)
Same as execl function except the fact that if performs the filename search as the execvp function.
Note
In a Linux system, if you type env
or printenv
on the shell or terminal you will get a list standard environment variables.
Solution 5
To answer the first part of your question, in the context of Linux specifically, there is only one system call and it's execve (not exec). The remainder of the so called "exec family" (execl, execle, execv, execve, execvp, etc.) are all GLIBC wrappers for for the kernel's system call, that is execve.
buddhi weerasinghe
Updated on November 23, 2020Comments
-
buddhi weerasinghe over 3 years
I have been following a system programming course recently and I came through the system calls exec() and execve(). So far I cannot find any difference between these two, Even the Wikipedia does not give a clear explanation, so is there a difference between exec() and execve().
And someone please could give brief descriptions about exec family system calls such as execl(), execv(), execle(), execvp().
-
buddhi weerasinghe over 10 yearsThe only difference between the above system calls is with the parameters. Is that the case? If so, is the ultimate outcome of all the exec family system calls to execute a program (with different parameters)?
-
buddhi weerasinghe over 10 yearsThe only difference between the above system calls is with the parameters. Is that the case? If so, is the ultimate outcome of all the exec family system calls to execute a program (with different parameters)?
-
Noam Rathaus over 10 yearsJust different parameters, nothing else is different
-
Basile Starynkevitch over 10 years
-
Barmar over 10 yearsI know that, but the distinction is not really important unless you're a kernel developer.
-
Tim over 5 yearsThanks. Is there difference between the popularity of these exec* functions? I haven't seen much examples, but it seems to me execlp() (and maybe execvp()) is used most often?