Copy on write
we illustrated how a process can start quickly by merely demandpaging in the page containing the first instruction. However, process creation using the fork () system call may initially bypass the need for demand paging by using a technique similar to page sharing (covered in Section 8.4.4). This technique provides for rapid process creation and minimizes the number of new pages that must be allocated to the newly created process.
Recall that the fork() system call creates a child process as a duplicate of its parent. Traditionally, forkO worked by creating a copy of the parent's address space for the child, duplicating the pages belonging to the parent. However, considering that many child processes invoke the exec() system call immediately after creation, the copying of the parent's address space may be unnecessary. Alternatively, we can use a technique known as copy-on-write, which works by allowing the parent and child processes initially to share the same pages. These shared pages are marked as copy-on-write pages, meaning that if either process writes to a shared page, a copy of the shared page is created.
Copy-on-write is illustrated in Figures 9.7 and Figure 9.8, which show the contents of the physical memory before and after process 1 modifies page C. For example, assume that the child process attempts to modify a page containing portions of the stack, with the pages set to be copy-on-write. The operating system will then create a copy of this page, mapping it to the address space of the child process. The child process will then modify its copied page and not the page belonging to the parent process. Obviously, when the copy-onwrite technique is used, only the pages that are modified by either process are copied; all unmodified pages can be shared by the parent and child processes.
|These Topics Are Also In Your Syllabus|
|1||Implementing Real-Time Operating Systems||link|
|2||What is VxWorks 5.x?||link|
|You May Find Something Very Interesting Here.||link|
|5||Types of System Calls||link|
Note, too, that only pages that can be modified need be marked as copy-onwrite. Pages that cannot be modified (pages containing executable code) can be shared by the parent and child. Copy-on-write is a common technique used by several operating systems, including Windows XP, Linux, and Solaris. When it is determined that a page is going to be duplicated using copyon-write, it is important to note the location from which the free page will be allocated. Many operating systems provide a pool of free pages for such requests. These free pages are typically allocated when the stack or heap for a process must expand or when there are copy-on-write pages to be managed.
Operating systems typically allocate these pages using a technique known as zero-fill-on-demand. Zero-fill-on-demand pages have been zeroed-out before being allocated, thus erasing the previous contents. Several versions of UNIX (including Solaris and Linux) also provide a variation of the forkC) system call—vforkO (for virtual memory fork). vf ork() operates differently from fork() with copy-on-write.
With vf ork(), the parent process is suspended, and the child process uses the address space of the parent. Because vf ork () does not use copy-on-write, if the child process changes any pages of the parent's address space, the altered pages will be visible to the parent once it resumes. Therefore, vf ork() must be used with caution to ensure that the child process does not modify the address space of the parent, vf ork() is intended to be used when the child process calls execO immediately after creation. Because no copying of pages takes place, vf ork() is an extremely efficient method of process creation and is sometimes used to implement UNIX command-line shell interfaces.