Difference between fork() and exec()
Last Updated :
08 Nov, 2022
Every application(program) comes into execution through means of process, process is a running instance of a program. Processes are created through different system calls, most popular are fork() and exec()
fork()
pid_t pid = fork();
fork() creates a new process by duplicating the calling process, The new process, referred to as child, is an exact duplicate of the calling process, referred to as parent, except for the following :
- The child has its own unique process ID, and this PID does not match the ID of any existing process group.
- The child's parent process ID is the same as the parent's process ID.
- The child does not inherit its parent's memory locks and semaphore adjustments.
- The child does not inherit outstanding asynchronous I/O operations from its parent nor does it inherit any asynchronous I/O contexts from its parent.
Return value of fork() On success, the PID of the child process is returned in the parent, and 0 is returned in the child. On failure, -1 is returned in the parent, no child process is created, and errno is set appropriately.
exec()
The exec() family of functions replaces the current process image with a new process image. It loads the program into the current process space and runs it from the entry point. The exec() family consists of following functions, I have implemented execv() in following C program, you can try rest as an exercise
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,
char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],
char *const envp[]);
fork vs exec
- fork starts a new process which is a copy of the one that calls it, while exec replaces the current process image with another (different) one.
- Both parent and child processes are executed simultaneously in case of fork() while Control never returns to the original program unless there is an exec() error.
C
// C program to illustrate use of fork() &
// exec() system call for process creation
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/wait.h>
int main(){
pid_t pid;
int ret = 1;
int status;
pid = fork();
if (pid == -1){
// pid == -1 means error occurred
printf("can't fork, error occurred\n");
exit(EXIT_FAILURE);
}
else if (pid == 0){
// pid == 0 means child process created
// getpid() returns process id of calling process
// Here It will return process id of child process
printf("child process, pid = %u\n",getpid());
// Here It will return Parent of child Process means Parent process it self
printf("parent of child process, pid = %u\n",getppid());
// the argv list first argument should point to
// filename associated with file being executed
// the array pointer must be terminated by NULL
// pointer
char * argv_list[] = {"ls","-lart","/home",NULL};
// the execv() only return if error occurred.
// The return value is -1
execv("ls",argv_list);
exit(0);
}
else{
// a positive number is returned for the pid of
// parent process
// getppid() returns process id of parent of
// calling process
// Here It will return parent of parent process's ID
printf("Parent Of parent process, pid = %u\n",getppid());
printf("parent process, pid = %u\n",getpid());
// the parent process calls waitpid() on the child
// waitpid() system call suspends execution of
// calling process until a child specified by pid
// argument has changed state
// see wait() man page for all the flags or options
// used here
if (waitpid(pid, &status, 0) > 0) {
if (WIFEXITED(status) && !WEXITSTATUS(status))
printf("program execution successful\n");
else if (WIFEXITED(status) && WEXITSTATUS(status)) {
if (WEXITSTATUS(status) == 127) {
// execv failed
printf("execv failed\n");
}
else
printf("program terminated normally,"
" but returned a non-zero status\n");
}
else
printf("program didn't terminate normally\n");
}
else {
// waitpid() failed
printf("waitpid() failed\n");
}
exit(0);
}
return 0;
}
Output:
parent process, pid = 11523
child process, pid = 14188
Program execution successful
Let us see the differences in a tabular form -:
| fork() | exec() |
1. | It is a system call in the C programming language | It is a system call of operating system |
2. | It is used to create a new process | exec() runs an executable file |
3. | Its return value is an integer type | It does not creates new process |
4. | It does not takes any parameters. | Here the Process identifier does not changes |
5. | It can return three types of integer values | In exec() the machine code, data, heap, and stack of the process are replaced by the new program. |
Similar Reads
Difference between fork() and vfork()
1. fork() : Fork() is system call which is used to create new process. New process created by fork() system call is called child process and process that invoked fork() system call is called parent process. Code of child process is same as code of its parent process. Once child process is created, b
2 min read
Difference between Program and Executable File
1. Program : Program, as name suggest, are simply set of instructions developed by programmer that tell computer what to perform and consist of compiled code that run directly from operating system of computer. 2. Executable File : Executable File, as name suggests, are computer files that contain e
2 min read
Difference between system() and execl() call
A system() call is a way for the programs to interact with the operating system. It is used to execute a command within a process. The system call provides the services of the operating system to the user programs via Application Program Interface (API). It provides an interface between a process an
4 min read
Difference between Shell and Kernel
In computing, the operating system (OS) serves as the fundamental layer that bridges the gap between computer hardware and the user. Two critical components of an operating system are the kernel and the shell. Understanding the relationship between these two components is fundamental to grasping how
4 min read
Difference between Program and Process
In Computer Science, there are two fundamental terms in operating system: Program and Process. Program is a set of instructions written to perform a task, stored in memory. A process is the active execution of a program, using system resources like CPU and memory. In other words, a program is static
4 min read
Difference between Spinlock and Semaphore
Semaphore is just a shared, non-negative variable that is used by multiple threads. A semaphore is a signalling device, and another thread may signal a thread that is awaiting a semaphore. It uses two atomic actions for process synchronisation: 1) wait, and 2) signal. In accordance with how it is co
5 min read
Difference between Process and Thread
Process and threads are the basic components in OS. Process is a program under execution whereas a thread is part of process. Threads allows a program to perform multiple tasks simultaneously, like downloading a file while you browse a website or running animations while processing user input. A pro
7 min read
Difference Between fork and clone in GitHub
Understanding the difference between fork and clone in GitHub is important for anyone looking to collaborate on open-source projects or manage their code efficiently. While both actions involve creating a copy of a repository, their purposes and implementations differ significantly. This article wil
3 min read
Difference between Program and Command
1. Program : Program, as name suggest, are simply set of instructions developed by programmers in programming languages that consist of compiled code and run directly from computers operating system. 2. Command : Command, as name suggests, are instruction given by user to computer to perform specifi
2 min read
Difference Between Thread ID and Thread Handle
Prerequisite: Thread in Operating System Thread Id is a long positive integer that is created when the thread was created. During the entire lifecycle of a thread, the thread ID is unique and remains unchanged. It can be reused when the thread is terminated. The Thread get_id() method can be studied
3 min read