Differences between fork and exec

by

The use of fork and exec exemplifies the spirit of UNIX in that it provides a very simple way to start new processes.

The fork call basically makes a duplicate of the current process, identical in almost every way. Not everything is copied over (for example, resource limits in some implementations) but the idea is to create as close a copy as possible.

The new process (child) gets a different process ID (PID) and has the PID of the old process (parent) as its parent PID (PPID). Because the two processes are now running exactly the same code, they can tell which is which by the return code of fork – the child gets 0, the parent gets the PID of the child. This is all, of course, assuming the fork call works – if not, no child is created and the parent gets an error code.

The exec call is a way to basically replace the entire current process with a new program. It loads the program into the current process space and runs it from the entry point.

So, fork and exec are often used in sequence to get a new program running as a child of a current process. Shells typically do this whenever you try to run a program like find – the shell forks, then the child loads the find program into memory, setting up all command line arguments, standard I/O and so forth.

But they’re not required to be used together. It’s perfectly acceptable for a program to fork itself without execing if, for example, the program contains both parent and child code (you need to be careful what you do, each implementation may have restrictions). This was used quite a lot (and still is) for daemons which simply listen on a TCP port and fork a copy of themselves to process a specific request while the parent goes back to listening.

Similarly, programs that know they’re finished and just want to run another program don’t need to fork, exec and then wait for the child. They can just load the child directly into their process space.

Some UNIX implementations have an optimized fork which uses what they call copy-on-write. This is a trick to delay the copying of the process space in fork until the program attempts to change something in that space. This is useful for those programs using only fork and not exec in that they don’t have to copy an entire process space.

If the exec is called following fork (and this is what happens mostly), that causes a write to the process space and it is then copied for the child process.

Note that there is a whole family of exec calls (execl, execle, execve and so on) but exec in context here means any of them.

The following diagram illustrates the typical fork/exec operation where the bash shell is used to list a directory with the ls command:

+--------+
| pid=7  |
| ppid=4 |
| bash   |
+--------+
    |
    | calls fork
    V
+--------+             +--------+
| pid=7  |    forks    | pid=22 |
| ppid=4 | ----------> | ppid=7 |
| bash   |             | bash   |
+--------+             +--------+
    |                      |
    | waits for pid 22     | calls exec to run ls
    |                      V
    |                  +--------+
    |                  | pid=22 |
    |                  | ppid=7 |
    |                  | ls     |
    V                  +--------+
+--------+                 |
| pid=7  |                 | exits
| ppid=4 | <---------------+
| bash   |
+--------+
    |
    | continues
    V

More Related Contents:

  1. printf anomaly after “fork()”
  2. How to make child process die after parent exits?
  3. Why does this program print “forked!” 4 times?
  4. In C how do you redirect stdin/stdout/stderr to files when making an execvp() or similar call?
  5. Redirecting exec output to a buffer or file
  6. Using poll function with buffered streams
  7. Grabbing output from exec
  8. After forking, are global variables shared?
  9. Are file descriptors shared when fork()ing?
  10. Waiting for all child processes before parent resumes execution UNIX
  11. Having trouble with fork(), pipe(), dup2() and exec() in C
  12. fork and existing threads?
  13. Why the address of variable of child process and parent process is same
  14. Difference between “system” and “exec” in Linux?
  15. Seeking a simple description regarding ‘file descriptor’ after fork()
  16. C – Retrieving a child’s exit status that is larger than 8 bits
  17. fork() and wait() with two child processes
  18. how to set close-on-exec by default
  19. Color text in terminal applications in UNIX [duplicate]
  20. What does the brk() system call do?
  21. Getting absolute path of a file
  22. How to use POSIX semaphores on forked processes in C?
  23. How can I convert a file pointer ( FILE* fp ) to a file descriptor (int fd)?
  24. I do not understand how execlp() works in Linux
  25. Understanding concurrent file writes from multiple processes
  26. Why does forking my process cause the file to be read infinitely
  27. How do I debug the child process after fork() in gdb?
  28. What is the difference between fork and thread?
  29. What can cause a “Resource temporarily unavailable” on sock send() command
  30. Unix O_CREAT flag without mode specified

Leave a Comment