Dann offiziell Moin Moin. Wir haben gestern aufgehört mit dem Problemchen MMU. Ihr erinnert euch,

wir müssen die MMU dem Gast irgendwie vorgaukeln. Wir kriegen mit, wenn er mit CR3 irgendwas versucht

anzustellen. Dann haben wir gesagt, wenn er CR3 setzt auf seine neue Tabelle, dann durchwühlen

wir die Tabelle, passen die Tabelle an und dann lassen wir ihn machen und machen die Tabelle in

der Zwischenzeit Read-Ondi. Oder nicht nur Read-Ondi, sondern ganz weg, damit er auch die getürkten

Werte nicht sieht. Und wenn er was dran ändern will oder wenn er es wieder lesen will, dann knipsen

wir die Tabelle wieder aus oder zumindest einen Teil von der Tabelle und switchen da immer hin und her.

Es gäbe eine ganz andere Variante, weil jemand noch eine ganz andere Idee, wie man das machen könnte.

Ein Problem der ganzen Geschichte ist, wir müssen die Tabelle immer hin drehen und wir müssen wieder

zurück drehen. Wir müssen sie wieder hin drehen, wir müssen wieder zurück drehen. Je nachdem,

ob er sie jetzt nutzen will oder ob er sie lesen, schreiben will. Da könnte man sagen,

naja warum jetzt immer hin und wieder hinten. Dann nehmen wir doch einfach eine zweite Tabelle.

Wohin führt uns die Idee? Man könnte das als Shadowtable bezeichnen. Das hat im Prinzip die

gleiche Struktur. Wenn die echte Tabelle 10 Einträge hat, dann hat die Schattentabelle

auch 10 Einträge, dann sehen sie halt ein bisschen anders aus. Was würde das heißen?

Er hat uns eine Tabelle gegeben, die baut er sicher in seinem Speicher auf,

mit den entsprechenden Pointeren drin und er sagt, da möchte ich meinen CH3 draufsetzen.

Was machen wir dann?

Vielleicht meinst du das richtig, ich verstehe es nur falsch. Also das ist das, was er uns gibt.

Wir haben ihm ihr Speicher gegeben und in dem Speicher beschreibt er eine Tabelle und er sagt,

da möchte ich CH3 draufsetzen. Also das ist jetzt hier Gast.

Vielleicht meinst du das Richtige.

Genau, das jetzt eben in einer Schattentabelle, also nicht die modifizieren, sondern wir nehmen

sozusagen den Speicher, den der Host hoffentlich noch übrig hat und bauen im Prinzip die gleiche

Tabelle nochmal auf. Von der Form her sieht sie identisch aus. Wenn hier zwei Einträge

drin sind, die hier drauf verweisen, dann sind es hier auch genau die zwei Einträge an den

entsprechenden Stellen. Hier steht natürlich jetzt ein Pointer auf die Tabelle, hier steht

ein Pointer auf die Tabelle. Nun setzen wir das CH3 nicht da hin, sondern CH3 zeigt jetzt

auf die Tabelle. Ein Vorteil hast du schon genannt, wenn der Gast jetzt da drin liest,

zum Beispiel wenn jemand einen Mellok macht und er sucht jetzt die nächste freie Page,

dann kann er hier drüben rühlen und suchen und machen und tun, kann er gerne tun, kein

Problem. Wie schaut das mit den anderen Operationen aus, die wir ja sonst auch noch so haben?

Wenn er verändert, dann müssen wir uns markieren, für unser CH3 müssen wir kurzfristig

den Ch3 verändern lassen und wenn er das in der nächsten Phase Zugriff wieder machen

möchte, dann müssen wir ihn komplett durchwühlen. Er will ändern, er will hier einen Eintrag

reinschreiben. Dann, wie kriegen wir das mit? Page fault write protected. Jetzt könnten

wir den Eintrag gleich übernehmen, wir simulieren die eine Instruktion. Da haben wir schon gesehen,

man kann das natürlich auch drauf addieren, man kann es reinschreiben, man kann es wegodern,

das war gestern die Lösung. Welche Tabelle einen Eintrag invalidieren wir? Wenn er jetzt

verändert hat, dann müssen wir den Page directory und Phasensregister einbreiten.

Wenn wir merken, den ändert er, was können wir da reinschreiben? Richtig reinschreiben

wird mühsam, dann müssen wir sämtliche Befehle nachmachen. Man kann ja auch noch

die Tabelle einbreiten, wenn man das nicht befreit. Wir schreiben einfach eine große

Null rein, die Seite gibt es nicht. Jetzt haben wir ja normalerweise etwas falsches

eingetragen, er hat ja eine sinnige Page eingetragen. Wann merken wir, dass wir etwas

falsches eingetragen haben? Wenn er jetzt die Tabelle nutzt und jetzt auf die, die Adresse

zeigt, benutzt, dann kriegt er einen Page fault. Dann gucken wir mal nach, war das jetzt

eigentlich ein berechtigter Page fault? Ja oder nein? Dann werden wir merken, bei uns

steht eine Null, bei ihm steht inzwischen aber was anderes. Dann hätten wir ihm wohl was

geben sollen, dann können wir gucken, was hat er dann reingeschrieben? Umrechnen, da