The fork() System Call (2024)

System call fork() is used to create processes. It takes no argumentsand returns a process ID. The purpose of fork() is to create a new process, which becomes the child process of thecaller. After a new child process is created, both processes will execute the next instruction following the fork() system call. Therefore, we have to distinguish the parent from the child. This can be done by testing the returned value of fork():

• If fork() returns a negative value, the creation of a child process was unsuccessful.
• fork() returns a zero to the newly created child process.
• fork() returns a positive value, the process ID of the child process, to the parent. The returned process ID is of type pid_t defined in sys/types.h. Normally, the process ID is an integer. Moreover, a process can use function getpid() to retrieve the process ID assigned to this process.

Let us take an example to make the above points clear. This example doesnot distinguish parent and the child processes.Click here to download this filefork-01.c.

#include <stdio.h>#include <string.h>#include <sys/types.h>#define MAX_COUNT 200#define BUF_SIZE 100void main(void){ pid_t pid; int i; char buf[BUF_SIZE]; fork(); pid = getpid(); for (i = 1; i <= MAX_COUNT; i++) { sprintf(buf, "This line is from pid %d, value = %d\n", pid, i); write(1, buf, strlen(buf)); } }

If the call to fork() is executed successfully, Unix will

• make two identical copies of address spaces, one for the parent and the other for the child.
• Both processes will start their execution at the next statement following the fork() call. In this case, both processes will start their execution at the assignment statement as shown below:

Both processes start their execution right after the system call fork(). Since both processes have identical but separate address spaces, those variables initialized beforethe fork() call have the same values in both address spaces.Since every process has its own address space, any modifications will be independent of the others. In other words, if the parent changes the value of its variable, the modification will only affect the variable in the parentprocess's address space. Other address spaces created by fork()calls will not be affected even though they have identical variable names.

What is the reason of using write rather than printf?It is because printf() is "buffered," meaning printf()will group the output of a process together. While buffering the outputfor the parent process, the child may also use printf to printout some information, which will also be buffered. As a result, since theoutput will not be send to screen immediately, you may not get the rightorder of the expected result. Worse, the output from the two processesmay be mixed in strange ways. To overcome this problem, you mayconsider to use the "unbuffered" write.

If you run this program, you might see the following on the screen:

 ................This line is from pid 3456, value 13This line is from pid 3456, value 14 ................This line is from pid 3456, value 20This line is from pid 4617, value 100This line is from pid 4617, value 101 ................This line is from pid 3456, value 21This line is from pid 3456, value 22 ................

Consider one more simple example, which distinguishes the parent from the child. Click here to download this filefork-02.c.

#include <stdio.h>#include <sys/types.h>#define MAX_COUNT 200void ChildProcess(void); /* child process prototype */void ParentProcess(void); /* parent process prototype */void main(void){ pid_t pid; pid = fork(); if (pid == 0) ChildProcess(); else ParentProcess();}void ChildProcess(void){ int i; for (i = 1; i <= MAX_COUNT; i++) printf(" This line is from child, value = %d\n", i); printf(" *** Child process is done ***\n");}void ParentProcess(void){ int i; for (i = 1; i <= MAX_COUNT; i++) printf("This line is from parent, value = %d\n", i); printf("*** Parent is done ***\n");}

When the main program executes fork(), an identical copy of itsaddress space, including the program and all data, is created. System callfork() returns the child process ID to the parent andreturns 0 to the child process. The following figure shows that in bothaddress spaces there is a variable pid. The one in the parent receivesthe child's process ID 3456 and the one in the child receives 0.

Now both programs (i.e., the parent and child) will executeindependent of each other starting at the next statement:

In the parent, since pid is non-zero, it calls functionParentProcess(). On the other hand, the child has a zero pidand calls ChildProcess() as shown below:

Due to the fact that the CPU scheduler will assign a time quantum to each process, the parent or the child process will run for some time before thecontrol is switched to the other and the running process will print some lines before you can see any line printed by the other process. Therefore, the value of MAX_COUNT should be large enough so that both processes will run for at least two or more time quanta. If the value of MAX_COUNT is so small that a process can finish in one time quantum, you will see two groups of lines, each of which contains all lines printed bythe same process.