CODEWITHSUNDEEP
cunixoperating-systemsystems-programming
Utkarsh Srivastav
Utkarsh Srivastav

Reputation: 3227

Fork implementation

How is fork system call code written . I want to know some details how a function can return two different values and that to two different processes . In short want to know how fork system call is implemented?

Upvotes: 14

Views: 18237

Answers (4)

Hadi Moshayedi
Hadi Moshayedi

Reputation: 886

Carl's answer was great. I'd like to add that in many operating systems return values are passed in one of the registers. In x86 architecture this register might be eax, In ARM architecture this register might be R0, etc.

Each process also have a Process Control Block (PCB), which store values of registers at the time some interrupt, syscall, or exception happened and control was passed to the OS. The next time the process scheduled, the values of the registers are restored from PCB.

Now, when fork() happens, OS can do:

 child_process->PCB[return_value_register] = 0;
 parrent_process->PCB[return_value_register] = child_pid;

So, when the processes are rescheduled, each of them see a different return value.

As an example, you can see xv6's implementation of fork. In there, the parent process is still in running state, so it returns parent's return value using simple return statement. But it sets value of EAX register for child process to 0, so when child process is scheduled it sees 0 as return value:

// Clear %eax so that fork returns 0 in the child.
np->tf->eax = 0;

Note that return 0 will also compile to something like "mov eax, 0".

Update: I just implemented fork() for a hobby OS I am doing. You can see the source code here.

Upvotes: 17

plaes
plaes

Reputation: 32716

There is a comment in the Unix V6 source code booklet for universities which was annotated by Ken Thompson and Dennis Ritchie themselves describing how the double return actually works. The comment ends with following sentence:

You are not expected to understand this.

Upvotes: 4

Svisstack
Svisstack

Reputation: 16616

In easy way for example process is cloned in fork() function with Moving IP/EIP/RIP register to skip some instruction in functions that can look like:

return pid;
return 0;

First process will execute first instruction and pop function from stack, second process will start but from second instruction returning 0.

Upvotes: -3

Carl Norum
Carl Norum

Reputation: 224924

You've pretty much explained it by saying that it's a system call. It's the operating system's job to do all that work, and the operating system can pretty much do whatever it wants outside of the context of your program or the rules of whatever language you're implementing it in. Here's a simple example of how it might happen:

  1. Program calls fork() system call
  2. Kernel fork system call duplicates the process running the program
  3. The kernel sets the return value for the system call for the original program and for the duplicate (PID of the duplicate and 0, respectively)
  4. The kernel puts both processes in the scheduler queue
  5. As each process is scheduled, the kernel 'returns' to each of the two programs.

Upvotes: 13

Related Questions