Write Countersign Copy with airSlate SignNow

Write countersign copy

let's talk now about something else that you could do with paging hardware we're talking about a copy on write for so let's look first at a normal fork so we have process a and it has three pages allocated if we do a fork then what are we going to get as we'd expect we get a duplicate of process a so we duplicate all of its pages and that's great and then process b and process a can now go about their business and they have individual copies of everything they're operating independently but if we look probably 99 times out of 100 or maybe 99.9 times out of 100 a fork is followed immediately by an exec right that is the child process is going to do an exec what happens on the exec so process a is the parent process it's doing its thing process b creates all these pages and then all of a sudden does an exact what doesn't exec do exec basically replaces the address space with new pages from a an alpha file right from the executable so what would happen we would now go ahead and read the elf file we would get rid of all these pages and instead create new pages perhaps more perhaps fewer depending on the actual executable so this is great this all works the problem is we did this wasteful duplicating all these pages just then to go ahead and free them up and create other pages so a copy on right fork is an optimization the parent process and the child process can't tell the difference of using this optimization but it speeds things up so let's show how that's going to work so how the fork will work because we'll still create a new process however this process is actually going to instead of duplicating these pages share the pages so conceptually it's going to look like this so those shared pages work fine for read-only pages but for writable pages we're actually okay until one or the other at least needs to write so imagine we get these four processes and now they can both be running along they have different values of registers right because those registers get swapped out in a context switch but these page contents are identical if one of them wants to write to a page then we've got a problem so here's what's going to happen in the page table entry for one of these pages so let's look at the page table entry for this one so it's going to refer to this page and then the bits here of course we have a present bit and to begin with we had a write bit because let's say this was a writable page when we do the copy on right fork what we're going to do is remove this writable bit so we're going to basically say it is no longer writable that is we'll get a page fault on a right and then what will happen is we'll have to keep some sort of a data structure that keeps track of the fact that this page is in use by multiple okay really what we can do is keep some sort of info about a page and we can keep inside this a reference count so imagine we have this for for every page because this will be useful so for this page we're going to keep track i'm going to just kind of show this as a page info sitting around that's referring to this personally some data structure referring to all the pages but we're going to keep track of the fact that now the reference count of this page is 2. and the reference count of this page and this page will both be two okay and we've also got our page table entries ensuring that these guys are not writable for right possible reasons are they didn't start out writable in which case they will continue to not be writable and then they can just nicely be shared and that's fine or they started out as writable and we're going to still mark them as not writable and then what happens let's say process b tries to change this page well since the pte doesn't have the right bid set we're going to get a page fault the kernel is going to look at this page look at the reference account for the page and say hmm this reference account is two also look at where this page is and say basically should this page be writeable or not that is was this supposed to be writable and yet we just marked it as non-writable because of copy on write so the copy on write says when a write occurs we go ahead and do the copy we wait to copy until we know we need to the original fork said copy everything the copy on right says wait to copy until you're forced to and you're forced to because you need two different pages with different values and that is the last minute you can wait till then is still a right happens so let's look at what happens we would the kernel would say okay this is supposed to be writable but it's not it has a ref reference count of two so therefore this page is shared with other processes i better make a copy now so it makes copy updates pointer here updates the reference count updates the pte sets this guy's pte to be present and writable and finally sets a ref count of 1 for this so what have we got now we've got process a which has it still it's original version of this page because it hasn't tried to write to it yet it's got a ref count of one it's writable so it can read and write as normal we're not getting any page faults process b now has its own copy of this page after the page fault returns it can go re-execute the right instruction and directly write to this page so it now has its own copy these two are still shared if process b now does an exact then we will again replace all these but notice we had to only allocate one extra page instead of all the extra pages from procedure a now we're going to have to do some sort of copying even if we do a fork and an exec well actually we're guaranteed we're going to have to because if we call exact we're going to have to be passing some parameters on the stack right so one of these pages is going to be the stack or at least the current top of stack and so when we do an exec the child process will be writing to the stack so we know that's going to cause a copy on write at least to the stack perhaps nothing else though and so that stack will change the rest of these will be unchanged will save the expense of having to copy all those so again we're taking advantage of paging hardware and the fact that we can get notified that is we can get a page fault assuming we set up our page table entries appropriately when someone tries to either write to a page or even read from a page if we turn off the p bit that's some of the magic of paging hardware