Was passiert mit dem Speicher des Prozesses, wenn wir…

Beim Aufruf von fork() erstellt der Kernel des Betriebssystems einen neuen Prozess, einen Kindprozess, der fast eine exakte Kopie des Elternprozesses ist.

Aus Sicht des Speichers passiert Folgendes:

Virtueller Adressraum: Der Kindprozess erhält seinen eigenen virtuellen Adressraum, der zum Zeitpunkt des fork()-Aufrufs identisch mit dem des Elternprozesses ist. Das bedeutet, dass der Kindprozess die gleichen Adressbereiche sieht und die gleiche Segmentstruktur (Code, Daten, Stack, Heap) wie der Elternprozess hat.
Physischer Speicher und Copy-on-Write (CoW): Anfangs teilen sich Eltern- und Kindprozess die gleichen Seiten des physischen Speichers. Dies ist eine Optimierung namens "Copy-on-Write" (CoW). Der physische Speicher wird nur kopiert, wenn einer der Prozesse versucht, den Inhalt einer Seite zu ändern.
- Wenn der Eltern- oder Kindprozess Daten in eine zuvor geteilte Seite schreibt, erstellt der Kernel eine neue Kopie dieser physischen Speicherseite für den schreibenden Prozess. Der andere Prozess verwendet weiterhin die alte Version der Seite.
- Wenn die Prozesse nur lesen, verwenden sie weiterhin die gemeinsame physische Speicherseite.
Dateideskriptoren: Offene Dateideskriptoren werden vom Kindprozess geerbt. Beide Prozesse teilen sich Zeiger auf die Dateioffset.
Andere Ressourcen: Andere Ressourcen wie Signal-Handler, aktuelles Arbeitsverzeichnis usw. werden ebenfalls kopiert oder vererbt.

Hier eine vereinfachte Illustration:

Vor fork():

+-------------------+
| Elternprozess     |
| +--------------+  |
| | Virtueller Speicher | |
| | (Stack, Heap, ...) | |
| +--------------+  |
|      |            |
|      V            |
| +--------------+  |
| | Physischer Speicher | |
| +--------------+  |
+-------------------+

Direkt nach fork() (CoW):

+-----------------------+   +-----------------------+
| Elternprozess         |   | Kindprozess           |
| +-------------------+ |   | +-------------------+ |
| | Virtueller Speicher | |   | | Virtueller Speicher | |
| | (Gleiche Struktur) | |   | | (Gleiche Struktur) | |
| +-------------------+ |   | +-------------------+ |
|        |              |   |        |              |
|        V              |   |        V              |
| +-------------------+ |   | +-------------------+ |
| | Physischer Speicher | |   | | Physischer Speicher | |
| | (Einige Seiten gemeinsam)| | | (Einige Seiten gemeinsam)| |
| +-------------------+ |   | +-------------------+ |
+-----------------------+   +-----------------------+
          |                            |
          +----------------------------+
                Anfangs gemeinsam genutzte physische Seiten

Nach Schreiben in eine Seite (CoW aktiviert):

+-----------------------+   +-----------------------+
| Elternprozess         |   | Kindprozess           |
| +-------------------+ |   | +-------------------+ |
| | Virtueller Speicher | |   | | Virtueller Speicher | |
| |                   | |   | |                   | |
| +-------------------+ |   | +-------------------+ |
|        |              |   |        |              |
|        V              |   |        V              |
| +-------------------+ |   | +-------------------+ |
| | Physischer Speicher | |   | | Physischer Speicher | |
| | (Getrennte Seiten) | |   | | (Getrennte Seiten) | |
| +-------------------+ |   | +-------------------+ |
+-----------------------+   +-----------------------+

Es ist wichtig zu verstehen, dass, obwohl der virtuelle Adressraum unmittelbar nach fork() identisch ist, Änderungen im Speicher eines Prozesses (Schreiben in Variablen, Allokieren/Freigeben von Speicher im Heap) den Speicher des anderen Prozesses dank des CoW-Mechanismus nicht beeinflussen. Es sind vollständig unabhängige Prozesse.

Was passiert mit dem Speicher des Prozesses, wenn wir eine Kopie davon mit dem Systemaufruf fork im Linux-Betriebssystem erstellen?