How does copy-on-write in fork() handle multiple fork?

Question

According to Wikipedia (which could be wrong)

When a fork() system call is issued, a copy of all the pages corresponding to the parent process is created, loaded into a separate memory location by the OS for the child process. But this is not needed in certain cases. Consider the case when a child executes an "exec" system call (which is used to execute any executable file from within a C program) or exits very soon after the fork(). When the child is needed just to execute a command for the parent process, there is no need for copying the parent process' pages, since exec replaces the address space of the process which invoked it with the command to be executed.

In such cases, a technique called copy-on-write (COW) is used. With this technique, when a fork occurs, the parent process's pages are not copied for the child process. Instead, the pages are shared between the child and the parent process. Whenever a process (parent or child) modifies a page, a separate copy of that particular page alone is made for that process (parent or child) which performed the modification. This process will then use the newly copied page rather than the shared one in all future references. The other process (the one which did not modify the shared page) continues to use the original copy of the page (which is now no longer shared). This technique is called copy-on-write since the page is copied when some process writes to it.

It seems that when either of the processes tries to write to the page a new copy of the page gets allocated and assigned to the process that generated the page fault. The original page gets marked writable afterwards.

My question is: what happens if the fork() gets called multiple times before any of the processes made an attempt to write to a shared page?

Answer 1

Nothing particular happens. All processes are sharing the same set of pages and each one gets its own private copy when it wants to modify a page.

Answer 2

The behavior of fork() depends on whether the *nix system has a MMU or not. On a non-MMU system (like early PDP-11s) the fork() system call copied all of the parent's memory for each child. On a MMU-based *nix system the kernel marks all the non-stack pages as R/O and shares them between parent and child. Then when either process writes to any page, the MMU traps the attempt, the kernel then allocates a writeable page and updates the MMU page-tables to point to the now writeable page. This Copy-on-Write behavior provides a speed-up since initially only a private stack needs to be allocated and cloned for each child process.

If you execute some parent code between each fork() call then the resulting child processes will differ by the pages that have been altered by the parent. On the other hand, if the parent simply issues multiple fork() calls, e.g. in a loop, then the child processes will be almost identical. If a local loop variable is used then that will be different within each child's stack.

Answer 3

When the system preforms a fork, usually (this may depend on implementation) it also marks the pages as read-only, and marks the parent process as the master of these pages.
When trying to write to these pages, a page fault occurs and the OS takes over, copying the entire list of pages or just the changed ones (again, dependent on implementation), so the writing process will have a writable copy.
When there are multiple processes forked from the same one, when the "master" process writes to it's memory, the other processes get their equivalent pages copied.