Mein, mein liebe Leute willkommen zum nächsten Video zur Vorlesung Betriebssysteme. Weiter geht es im

Kapitel Soft-IRQs. Wir haben uns im letzten Video angeguckt, wie die Aufteilung gemacht wird und

warum die Aufteilung gemacht wird bei der Interrupt-Behandlung. Gucken wir uns das jetzt in der

Implementierung an, gucken uns einfach ein Beispiel an, wie man das jetzt in der Praxis wirklich

implementiert. Also sieht folgendermaßen aus, stellt euch vor, ihr sollt, na, ihr kennt das Beispiel aus dem

letzten Video, einen Keyboard-Interrupt-Händler schreiben. Ja, Keyboard-Interrupt-Request, was soll der

machen? Zwei Dinge. Er soll einmal im ersten Schritt, haben wir uns angeguckt, das Zeichen von

der Tastatur wirklich abholen. Dann haben wir gesagt, können wir die Interrupts wieder anschalten.

In der Interrupt-Welt heißt das dann Z, Set Interrupt Enable und wenn die Interrupts enabled sind,

dann können wir den eher softwarelastigen Teil der Interrupt-Bearbeitung machen. Gut,

was macht jetzt? Gehen wir es der Reihe nach durch. Hardware-Interrupt-Abarbeitung, was ist das?

Ja, also wir holen uns den Code vom Keyboard-Controller, das ist der wirklich

hardwareabhängige Teil. Wenn in unserem Buffer Platz ist, packen wir das Zeichen in den Buffer.

Mehr nicht. Also wichtiger Punkt, das hier ist ein vergleichsweise kleiner Teilsoftware.

Der sollte auch nicht lange schleifendurch laufen. Das ist nur einfach ein paar Bytes vom Keyboard-

Controller abholen. Das Bytes, ein bisschen Rechnerei außen rum reicht, um dann den Buffer zu befüllen.

Der zweite Schritt. Was machen wir, um das Zeichen dann letztendlich weiter zu verarbeiten? Ja,

wir holen uns ein Zeichen aus dem Buffer raus, solange noch eins drin ist. Wichtig, wenn wir das hier

rausholen, dann darf in dem Moment natürlich jetzt kein Interrupt da wieder diesen Teil

auslösen. Das heißt, da darf nichts in den Buffer in der Zwischenzeit eingefügt werden.

Haben wir uns in einem der letzten Videos angeguckt, wie man das verhindert. Also vorher

Interrupts ausschalten, ein Byte, ein Code auslesen, Interrupts wieder anschalten. Dann haben wir

ein Byte aus dem Buffer rausgeholt. Das Byte können wir jetzt weiter verarbeiten. Also wir können es

umwandeln in irgendwie in ASCII-Zeichen, wir können es auf den Bildschirm malen und so weiter.

Dann schalten wir die Interrupts wieder aus, gucken, ob noch ein weiteres Byte im Buffer drin ist.

Wenn ja, holen wir uns sonst raus, Interrupts wieder anschalten, verarbeiten, Interrupts aus,

Byte holen, Interrupts an, verarbeiten und so weiter, bis irgendwann unser Buffer leer ist.

Und dann schalten wir die Interrupts wieder an und sind fertig. Warum, Preisfrage, ist das hier

oben jetzt ein Zeichen, was ich abholen und wenn ich überhaupt in den Buffer tue, vielleicht auch

nicht, weil Buffer vielleicht schon voll. Hier unten habe ich jetzt noch eine Weilschleife.

Könnte das hier nicht ein IF sein? Nee, kann es nicht. Warum? Es könnte sein, dass während wir

hier unser Zeichen verarbeiten, natürlich schon wieder ein Tastaturinterrupt kommt. Heißt, wir

würden dann schon wieder den Teil hier ausführen, wir würden schon wieder sozusagen ein Byte

nachfüllen in den Buffer. Dementsprechend könnte es sein, während wir hier den Code verarbeiten,

dass sich der Buffer schon wieder füllt. Dementsprechend machen wir das hier in einer Weilschleife.

Kommen wir nachher noch darauf, dass das vielleicht aus anderen Gründen nicht geht,

aber das wäre erstmal die Idee. Das wäre so die Abarbeitung in zwei Teilen. Ein mehr

Hardware abhängiger Teil, der dann nur noch was in den Buffer füllt und ein Teil, der was aus dem

Buffer holt und jetzt pure Software ist irgendwie Zeichen verarbeiten. Gut, das war mal so das Prinzip.

Jetzt gehen wir uns das noch mal genauer angucken. Das war so der Aufteilungsteil. Wie verarbeiten wir

Keyboardinterrupt aufgeteilt in zwei Teile? Geht eventuell nicht. Da kann man jetzt lange

leider darüber nachdenken. Wer jetzt gar nichts zu tun hat, kann das Video ja mal anhalten und

mal darüber nachdenken. Da muss man wahrscheinlich auch schon länger darüber nachdenken, bis man auf

die Idee kommt. Folgendes Problem kann auftreten. Stellt euch vor, ihr schaltet hier die Interrupts

wieder an und verarbeitet das Zeichen. Da habe ich gerade gesagt, wenn die Interrupts an sind, dann

kann ja schon wieder, wenn eine weitere Taste gedrückt wurde, kann ja schon wieder die

Hardwareinterrupt Abarbeitung laufen. Dann wird dieser Keyboardinterrupt Händler ja durch

sich selber sozusagen unterbrochen. Okay, dann wird das nächste Zeichen angenommen in den Tastaturbuffer

getan und die Abarbeitung wieder gestartet. Während die Abarbeitung gestartet wird, sind aber die

Interrupts wieder an. Das heißt, es kann schon wieder ein Tastencode kommen und ihr müsst ja