{"id":2340,"date":"2021-02-08T16:35:44","date_gmt":"2021-02-08T11:05:44","guid":{"rendered":"https:\/\/binaryterms.com\/?p=2340"},"modified":"2021-02-08T16:41:05","modified_gmt":"2021-02-08T11:11:05","slug":"difference-between-fork-and-exec-system-call","status":"publish","type":"post","link":"https:\/\/binaryterms.com\/difference-between-fork-and-exec-system-call.html","title":{"rendered":"Difference Between fork() and exec() System Call"},"content":{"rendered":"

The fork() and exec() are the system calls that are used for controlling processes. Both are used to create a new process where the process is the program in execution. The fork() system call when invoked by any process creates a new duplicate child process of the invoking process.<\/p>\n

However, the exec() system call when invoked by any process replaces the invoking process along with all its threads by the process specified to it in its parameter.<\/p>\n

In the section ahead we will discuss a few more differences between fork() and exec(). Along with that, we will also discuss both the terms separately in order to get a brief idea of both the system calls.<\/p>\n

Content: fork() Vs exec() System Call<\/h2>\n
    \n
  1. Difference Chart<\/a><\/li>\n
  2. What is the fork() System Call?<\/a><\/li>\n
  3. What is exec() System Call?<\/a><\/li>\n
  4. Key Takeaways<\/a><\/li>\n
  5. Conclusion<\/a><\/li>\n<\/ol>\n

    <\/a><\/p>\n

    Difference Chart<\/h3>\n

    \n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t
    Factors for Differentiation<\/th>fork()<\/th>exec()<\/th>\n<\/tr>\n<\/thead>\n
    Invoking<\/td>fork() creates a new duplicate child process of the process that invoked fork()<\/td>exec() replaces a process that invokes it with a new process provided in its parameter.<\/td>\n<\/tr>\n
    Process id<\/td>The child process and parent process have unique process id.\u00a0<\/td>The new process and the replaced process have the same process id.<\/td>\n<\/tr>\n
    Execution<\/td>The parent and child process start simultaneous execution from the instruction just after fork().<\/td>The currently running process is terminated and the exec() start execution of the new process from its entry point.<\/td>\n<\/tr>\n
    Arguments<\/td>No arguments are passed to fork() system call.<\/td>Basically, three or more arguments are passed to the exec() system call.<\/td>\n<\/tr>\n
    Format<\/td>Pid=fork();<\/td>exec(cont char *filename, char* const argv[], char* const envp[])<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    \n<\/a><\/p>\n

    What is the fork() System Call?<\/h3>\n

    The fork() system call is a process controlling system call. The fork() system call when invoked by any process creates a separate new process which is a duplicate of the process invoking the fork() system call. However, the process invoking the fork() system call is termed as the parent process<\/strong> and the new duplicate process created by the fork() is termed to as a child process<\/strong>.<\/p>\n

    After fork() creates a duplicate child process both the parent and child process resumes their execution from the next instruction after fork() simultaneously. Both the parent process and child process have their unique process id. we can illustrate this with the help of an example below:<\/p>\n

    \"fork()<\/p>\n

    As soon as the fork() is executed one child process is created that is duplicate of the parent process. Now, both parent and child process will execute the printf() statement simultaneously. Where once the parent process id will get printed and once the child process id will get printed.<\/p>\n

    If the fork has successfully created a child then the value its return would be 0 and if the fork() execution failed then it returns a negative value. For the parent process, fork() returns the process identifier of its child process.<\/p>\n

    To understand the working of fork() system call observe the code below:<\/p>\n

    main(){\r\n\r\nfork();\r\n\r\nprintf(\u201c\\n hello world\u201d);\r\n\r\n}<\/pre>\n
     <\/p>\n
    \"fork()<\/p>\n
    In the figure above you can see that as soon as the process P1<\/sub> invokes the fork() instruction a child process CP1<\/sub> is created and both child and parent process resume their execution from the next instruction after fork(). So we can see that the \u2018printf()\u2019 statement after fork() instruction is being executed two times once by the parent process and once by the child process.<\/p>\n
    Now what if we have fork() instruction is two times in the code above i.e.<\/p>\n
    main(){\r\n\r\nfork();\r\n\r\nfork();\r\n\r\nprintf(\u201c\\n hello world\u201d);\r\n\r\n}<\/pre>\n
    In this case, execution would take place in this manner.<\/p>\n
    \"fork<\/p>\n
    So, seeing the number of fork() system calls in the code you can calculate the number of child processes that would be created by calculating 2n<\/sup>-1<\/strong>, where n is the number of fork() system call in the code.
    \n    <\/a><\/p>\n
    What is exec() System Call?<\/h3>\n
    Typically exec() system call is used to replace the currently executing process along with all its threads with the program provided to it in its parameter. The exec() system call is generally invoked after the fork() system call, either by parent or by the child process.<\/p>\n
    There are most of the cases where the child needs to execute the different program like that of the parent. So, by invoking the exec() system call a new program starts its execution in the context of the existing program.<\/p>\n
    Now, consider we have two program files prog1 and prog2. We will start executing prog1 and we will see how we can use exec() system call to replace the prog1 with prog2. Below you have the code for prog1.c.<\/p>\n
    \"exec1()\"<\/p>\n
    The figure below shows the code for prog2.c.<\/p>\n
    \"exec2()\"<\/p>\n
    On executing prog1.c we get the result as you can see below:<\/p>\n
    \"exec()\"<\/p>\n
    You can notice that the control of the program has not gone back to prog1.c after the execution of exec(). The only condition where the program control goes back to the invoking program is an error in the execution of exec().<\/p>\n
    The process invoking exec() must provide the environment for the new program. Like the name of the file or program to be executed, a pointer to the argument array, and finally a pointer to the environment array.<\/p>\n
    There are few versions of exec() system call including execl, execv, execle, and execve, that allow the parameters to be omitted or specified in various other ways.
    \n    <\/a><\/p>\n
    \n
    Key Takeaways<\/h3>\n