Wat gebeurt er met het geheugen van het proces…

Bij het aanroepen van fork(), creëert de besturingssysteemkernel een nieuwe proces, een kindproces, dat bijna een exacte kopie is van het ouder proces.

Vanuit geheugenperspectief gebeurt het volgende:

Virtueel adresruimte: Het kindproces krijgt zijn eigen virtuele adresruimte, die identiek is aan die van de ouder op het moment van de fork()-aanroep. Dit betekent dat het kindproces dezelfde adresbereiken "ziet" en dezelfde segmentstructuur (code, gegevens, stack, heap) heeft als de ouder.
Fysiek geheugen en Copy-on-Write (CoW): Aanvankelijk delen ouder- en kindproces dezelfde fysieke geheugenpagina's. Dit is een optimalisatie genaamd "Copy-on-Write" (CoW). Het fysieke geheugen wordt pas gekopieerd wanneer een van de processen probeert de inhoud van een pagina te wijzigen.
- Als het ouder- of kindproces gegevens schrijft op een gedeelde pagina, maakt de kernel een nieuwe kopie van die fysieke pagina voor het schrijvende proces. Het andere proces blijft de oude versie van de pagina gebruiken.
- Als de processen alleen lezen, blijven ze dezelfde gedeelde fysieke pagina gebruiken.
Bestanddescriptoren: Openstaande bestanddescriptoren worden geërfd door het kindproces. Beide processen delen de pointers naar de offset in het bestand.
Andere bronnen: Andere bronnen, zoals signaalhandlers, huidige werkdirectory, etc., worden ook gekopieerd of geërfd.

Hier een vereenvoudigde illustratie:

Voor fork():

+-------------------+
| Ouderproces        |
| +--------------+  |
| | Virtuele Geheugen | |
| | (Stack, Heap, ...) | |
| +--------------+  |
|      |            |
|      V            |
| +--------------+  |
| | Fysiek Geheugen | |
| +--------------+  |
+-------------------+

Direct na fork() (CoW):

+-----------------------+   +-----------------------+
| Ouderproces           |   | Kindproces            |
| +-------------------+ |   | +-------------------+ |
| | Virtuele Geheugen  | |   | | Virtuele Geheugen  | |
| | (Dezelfde structuur)| |   | | (Dezelfde structuur)| |
| +-------------------+ |   | +-------------------+ |
|        |             |   |        |             |
|        V             |   |        V             |
| +-------------------+ |   | +-------------------+ |
| | Fysiek Geheugen    | |   | | Fysiek Geheugen    | |
| | (Sommige pagina's gedeeld)| | | (Sommige pagina's gedeeld)| |
| +-------------------+ |   | +-------------------+ |
+-----------------------+   +-----------------------+
          |                            |
          +----------------------------+
                Aanvankelijke gedeelde fysieke pagina's

Na het schrijven op een van de pagina's (CoW geactiveerd):

+-----------------------+   +-----------------------+
| Ouderproces           |   | Kindproces            |
| +-------------------+ |   | +-------------------+ |
| | Virtuele Geheugen  | |   | | Virtuele Geheugen  | |
| |                   | |   | |                   | |
| +-------------------+ |   | +-------------------+ |
|        |             |   |        |             |
|        V             |   |        V             |
| +-------------------+ |   | +-------------------+ |
| | Fysiek Geheugen    | |   | | Fysiek Geheugen    | |
| | (Aparte pagina's)  | |   | | (Aparte pagina's)  | |
| +-------------------+ |   | +-------------------+ |
+-----------------------+   +-----------------------+

Het is belangrijk te begrijpen dat, hoewel de virtuele adresruimte onmiddellijk na fork() identiek is, elke wijziging in het geheugen van een proces (schrijven naar variabelen, toewijzen/vrijmaken van geheugen op de heap) het geheugen van het andere proces niet beïnvloedt dankzij het CoW-mechanisme. Dit zijn volledig onafhankelijke processen.

Wat gebeurt er met het geheugen van het proces wanneer we een kopie ervan maken met behulp van de systeemaanroep fork in het Linux-besturingssysteem?