docs: add obsidian hwr docs

Betriebssysteme/Zusammenfassung_Einführung_Hardware.md

@@ -0,0 +1,254 @@
+# Zusammenfassung Einführung + Hardware
+
+### 1. Definition und Aufgaben
+• **Hauptaufgabe:** Verwaltung physischer und logischer Ressourcen (CPU, RAM, Geräte, Prozesse)
+• **Schlüsselkonzept Transparenz:** Das BS verbirgt die komplexe interne Struktur und Hardware-Details vor dem Benutzer
+• **Zielfunktionen:**
+    ◦ **Auftragsverwaltung:** Steuerung und Abrechnung von Jobs
+    ◦ **Betriebsmittelverwaltung:** Zuweisung von Hardware und Vermeidung von Konflikten (Deadlocks)
+    ◦ **Speicherverwaltung:** Verwaltung von physischem und virtuellem Speicher
+    ◦ **Schutz:** Zugriffskontrolle und Fehlerbehandlung
+### 2. Klassifizierung von Betriebssystemen
+Betriebssysteme werden nach verschiedenen Kriterien unterschieden:
+• **Anzahl der Aufgaben:**
+    ◦ **Single-Tasking:** Nur ein Programm läuft (historisch)
+    ◦ **Multi-Tasking:** Mehrere Programme laufen scheinbar gleichzeitig
+• **Verarbeitungsmodus:**
+    ◦ **Stapelverarbeitung (Batch):** Jobs werden ohne Benutzerinteraktion nacheinander abgearbeitet (Großrechner)
+    ◦ **Dialogbetrieb (Interactive):** Der Benutzer interagiert direkt mit dem System
+    ◦ **Echtzeitverarbeitung (Real-time):** Garantierte Reaktionszeiten für Steuerungsaufgaben
+• **Architektur:** Zentralisiert vs. Verteilt (Zentrale Systemsteuerung existiert/existiert nicht)
+### 3. Eigenschaften moderner Betriebssysteme
+• **Präemptives Multitasking:** Das BS kann einem Prozess die CPU entziehen (im Gegensatz zum kooperativen Multitasking, wo das Programm die CPU freiwillig abgeben musste)
+• **Multithreading:** Eine Anwendung kann mehrere Aufgaben (Threads) parallel ausführen
+• **Symmetrisches Multiprocessing (SMP):** Mehrere gleichwertige Prozessoren teilen sich die Aufgaben ("jeder macht alles")
+• **Stabilität:** Durch Speichertrennung führt der Absturz einer App nicht zum Absturz des Gesamtsystems
+• **Sicherheit (C2-Standard):** Authentifizierung, Zugriffskontrolllisten (ACLs) für Ressourcen und Protokollierung
+• **Skalierbarkeit:** Fähigkeit, Leistung bei wachsenden Anforderungen durch neue Hardware (_Scale Up_) oder neue Rechner (_Scale Out_) zu halten
+### 4. Architektur und Design (Kernel)
+**Bestandteile eines BS:** Kernel (resident im RAM), externe Module (Treiber), Befehlsinterpreter. _Nicht_ dazu gehören Compiler oder Office-Programme
+**Architektur-Modelle:**
+• **Monolithischer Kernel:**
+    ◦ Alles (Dateisystem, Treiber, Speicherverwaltung) läuft im Kernel-Modus in einer Datei.
+    ◦ _Vorteil:_ Sehr schnell.
+    ◦ _Nachteil:_ Ein Fehler im Treiber bringt das ganze System zum Absturz
+• **Mikrokernel:**
+    ◦ Nur minimale Funktionen (IPC, Scheduling) im Kernel-Modus. Treiber und Dateisysteme laufen im Benutzer-Modus.
+    ◦ _Vorteil:_ Sehr stabil.
+    ◦ _Nachteil:_ Langsamer durch Kommunikations-Overhead
+• **Hybrid:** Mischung aus beiden (z.B. Windows, macOS), um Geschwindigkeit und Stabilität zu vereinen
+**Schichtenmodell:** Jede Schicht darf nur Dienste der direkt darunterliegenden Schicht nutzen
+### 5. Dualer Modus
+Zum Schutz vor fehlerhaften Programmen arbeitet der Prozessor in zwei Modi (gesteuert durch das CPL-Bit im Register):
+1. **Kernelmodus (Ring 0 / CPL=0):** Das BS hat vollen Zugriff auf alle Befehle und Hardware
+2. **Benutzermodus (Ring 3 / CPL=3):** Anwendungen laufen hier. Kritische Befehle (Hardwarezugriff, I/O) sind verboten
+### 6. Systemaufrufe
+**Der Systemaufruf (System Call):** Wenn eine Anwendung eine kritische Operation benötigt (z.B. "Speichere Datei"), kann sie das nicht selbst tun.
+• Sie ruft eine Bibliotheksfunktion auf (z.B. `open()`, `read()`)
+• Dies löst einen **Systemaufruf** aus.
+• Die CPU schaltet in den **Kernelmodus**, führt die Aufgabe sicher aus und schaltet zurück
+#### 1. Das Grundproblem
+Eine Anwendung (z.B. Word) darf nicht direkt auf die Hardware (z.B. Festplatte) zugreifen. Würde sie das tun, könnte ein Fehler in Word die Festplatte beschädigen oder Daten anderer Programme überschreiben. Daher laufen Anwendungen im **Benutzermodus (User Mode, Ring 3)** und das Betriebssystem (BS) im **Kernelmodus (Kernel Mode, Ring 0)**.
+Ein **Systemaufruf** ist der definierte Weg, wie eine Anwendung den Kernel bittet: _"Bitte erledige diese privilegierte Aufgabe für mich"_
+#### 2. Der Ablauf eines Systemaufrufs
+Der Prozess ist streng geregelt, um Sicherheit zu garantieren:
+1. **Aufruf:** Die Anwendung ruft eine Bibliotheksfunktion auf (z.B. `read()` in C),.
+2. **Auslöser:** Diese Funktion löst einen Software-Interrupt (Trap) aus. Dies signalisiert der CPU, dass ein Moduswechsel nötig ist.
+3. **Moduswechsel:** Die CPU schaltet vom Benutzermodus (CPL=3) in den Kernelmodus (CPL=0),.
+4. **Identifikation:** Das BS schaut in einer internen Tabelle (System Call Table) nach, welche Funktion ausgeführt werden soll (basierend auf einer ID/Nummer),.
+5. **Prüfung:** Das BS prüft die übergebenen Parameter auf Gültigkeit (z.B.: Darf dieser Nutzer diese Datei lesen?),.
+6. **Ausführung:** Der Kernel führt die Operation (z.B. Festplattenzugriff) aus.
+7. **Rückkehr:** Das BS schaltet zurück in den Benutzermodus und gibt das Ergebnis (oder einen Fehlercode) an die Anwendung zurück
+#### 3. Methoden der Parameterübergabe
+Da der Kernel und die Anwendung in unterschiedlichen Adressräumen arbeiten können, ist die Übergabe von Daten (z.B. "Welche Datei soll geöffnet werden?") nicht trivial. Es gibt drei Methoden:
+1. **Über Register:**
+    ◦ _Funktionsweise:_ Parameter werden direkt in die CPU-Register geschrieben.
+    ◦ _Vorteil:_ Sehr schnell und einfach.
+    ◦ _Nachteil:_ Die Anzahl und Größe der Register ist stark begrenzt (reicht nicht für viele Daten).
+2. **Über einen Speicherblock (Tabelle):**
+    ◦ _Funktionsweise:_ Die Parameter werden in einen Speicherblock im RAM geschrieben. Nur die **Startadresse** dieses Blocks wird in einem Register an den Kernel übergeben.
+    ◦ _Vorteil:_ Anzahl und Größe der Parameter spielen keine Rolle.
+    ◦ _Nachteil:_ Langsamer als Register
+3. **Über den Stack (Stapel):**
+    ◦ _Funktionsweise:_ Parameter werden auf den Stack gelegt (push). Das BS liest sie vom Stack (pop).
+    ◦ _Vorteil:_ Flexible Anzahl an Parametern möglich.
+#### 4. Kategorien und Beispiele
+Systemaufrufe decken alle Bereiche ab, in denen das BS Ressourcen verwaltet. In den Folien werden folgende Kategorien unterschieden:
+
+|   |   |   |
+|---|---|---|
+|Kategorie|Beispiele (Funktionen)|Erklärung|
+|**Prozessmanagement**|`fork()`, `exit()`, `CreateProcess()`|Prozesse erzeugen, beenden oder steuern.|
+|**Dateiverwaltung**|`open()`, `read()`, `CreateFile()`|Dateien öffnen, lesen, schreiben.|
+|**Speicherverwaltung**|`malloc()`, `GlobalAlloc()`|Arbeitsspeicher anfordern.|
+|**Geräteverwaltung**|`ioctl()`, `ReadConsole()`|Hardware konfigurieren oder ansprechen.|
+|**Zeitmanagement**|`sleep()`, `SetTimer()`|Warten oder Zeit messen.|
+|**Schutz/Sicherheit**|`chmod()`, `icacls()`|Zugriffsrechte ändern.|
+
+#### 5. Inkompatibilität zwischen Betriebssystemen
+Warum läuft ein Windows-Programm (.exe) nicht auf Linux? Einer der Hauptgründe sind die Systemaufrufe.
+• Die **Formate** der Systemaufrufe sind unterschiedlich.
+• Die **Art**, wie Parameter übergeben werden, unterscheidet sich. Selbst auf der gleichen Hardware (z.B. Intel CPU) sind Anwendungen daher nicht kompatibel, da sie eine "andere Sprache" sprechen, um mit dem Kernel zu reden
+### 7. Programmausführung & Speicher
+Wie wird aus Code ein Prozess?
+1. **Compiler:** Quellcode -> Objektdatei
+2. **Linker:** Verbindet Objektdatei mit Bibliotheken -> Ausführbare Datei (.exe)
+3. **Loader:** Lädt Datei in den RAM -> **Prozess**
+**Speicheraufbau eines C-Programms im RAM:**
+• **Text:** Der Programmcode
+• **Data:** Initialisierte globale Variablen
+• **BSS:** Nicht-initialisierte globale Variablen
+• **Heap:** Dynamischer Speicher (malloc)
+• **Stack:** Lokale Variablen und Funktionsaufrufe
+## Hardware:
+### 1. Grundbegriffe & Einheiten
+• **EVA-Prinzip:** Eingabe → Verarbeitung → Ausgabe. Peripheriegeräte (Tastatur, Monitor) machen E/A, die Systemeinheit (CPU) macht die Verarbeitung
+• **Maßeinheiten:** Die Folien unterscheiden strikt zwischen dezimalen und binären Präfixen:
+    ◦ **KB, MB, GB:** Basieren auf Faktor 1000 (103).
+    ◦ **KiB, MiB, GiB:** Basieren auf Faktor 1024 (210). _Wichtig: Das Betriebssystem rechnet meist binär (GiB), Festplattenhersteller oft dezimal (GB)._
+### 2. Rechnerarchitekturen
+#### Von-Neumann-Architektur (Standard PC)
+Die meisten modernen PCs basieren auf dem **John-von-Neumann-Prinzip** (1945):
+1. **SISD:** Single Instruction, Single Data (ein Befehl bearbeitet einen Datensatz).
+2. **Gemeinsamer Speicher:** Befehle (Programmcode) und Daten liegen im selben RAM.
+3. **Lineare Adressierung:** Speicherzellen werden über Adressen angesprochen.
+#### Andere Architekturen
+• **Harvard:** Getrennter Speicher für Befehle und Daten (schneller, teurer).
+• **SIMD (Single Instruction Multiple Data):** Ein Befehl bearbeitet viele Daten gleichzeitig (Vektorrechner, Supercomputer).
+• **MIMD (Multiple Instruction Multiple Data):** Viele Prozessoren bearbeiten unterschiedliche Daten mit unterschiedlichen Befehlen.
+#### Das Minimalsystem
+Ein funktionierender Computer benötigt mindestens:
+1. **CPU:** Verarbeitet Daten.
+2. **RAM:** Speichert Daten flüchtig.
+3. **Datenträger:** Speichert Daten dauerhaft.
+4. **Bussystem:** Verbindet alles. Besteht aus:
+	    ◦ _Datenbus_ (Prozessor -> Arbeitsspeicher).
+	    ◦ _Adressbus_ (wählt Speicherzellen/Geräte aus).
+	    ◦ _Steuerbus_ (Taktgeber, Lese-/Schreibsignale).
+#### Mainboard:
+Die Hauptplatine belegt die zentrale Stelle im Systemgehäuse. Sie steuert die Zusammenarbeit aller Bauteile
+**Wichtige Komponenten auf dem Mainboard:**
+• **Prozessorsockel:** Hier wird die CPU eingesetzt. Server-Mainboards können oft mehrere Sockel für mehrere Prozessoren haben, um die Leistung massiv zu steigern
+• **Chipsatz:** Der "Verkehrspolizist" des Mainboards. Er steuert den Datenfluss zwischen Prozessor, Speicher und Peripherie
+• **BIOS & CMOS:**
+    1. **Das BIOS (Basic Input/Output System)** ist die **Firmware** (Software). Es enthält die unveränderlichen Funktionen und Anweisungen, um den Startvorgang (Boot) überhaupt durchzuführen,
+2. **Das CMOS** ist der **Datenspeicher**. Es ist ein kleiner Speicherchip, der die **variablen Einstellungen** (Uhrzeit, Boot-Reihenfolge, Passwörter) speichert. Da dieser Speicher flüchtig ist, wird er von einer kleinen **Batterie** auf dem Mainboard gepuffert, damit die Daten nicht verloren gehen, wenn Sie den Stecker ziehen
+	**Kurz gemerkt:** Das BIOS ist der „Motor“ (das Programm), das CMOS ist der „Tank“ für Ihre persönlichen Einstellungen.
+• **Schnittstellen & Steckplätze:**
+    ◦ _Intern:_ Speicherbänke für RAM, Anschlüsse für Festplatten/SSDs (SATA/M.2)
+    ◦ _Erweiterung:_ Slots (z.B. PCIe) für Grafik-, Sound- oder Netzwerkkarten
+    ◦ _Extern:_ USB, Monitor, Netzwerk
+### 3. Der Prozessor (CPU)
+Die CPU führt arithmetische und logische Operationen aus. Die Leistung hängt von der Taktfrequenz und der Architektur (32-Bit vs. 64-Bit) ab
+#### CISC vs. RISC
+• **CISC (Complex Instruction Set Computing):** (z.B. Intel/AMD)
+    ◦ Mächtige, komplexe Befehle.
+    ◦ Befehle werden intern oft durch **Mikrocode** (Software im Chip) realisiert.
+    ◦ _Nachteil:_ Dekodierung dauert länger.
+• **RISC (Reduced Instruction Set Computing):** (z.B. ARM, SPARC)
+    ◦ Wenige, einfache Befehle.
+    ◦ Fest verdrahtet (kein Mikrocode), sehr schnelle Ausführung.
+#### Wichtige Register
+Register sind extrem schnelle, aber kleine Speicherbereiche direkt im Prozessor. Sie sind entscheidend für die Arbeitsweise der CPU und das Verständnis von Kontextwechseln (Multitasking).
+##### 1. Register-Gruppen und Namenskonventionen
+Die Bezeichnung der Register hängt von der Architektur ab. Die Folien nutzen die Intel-Nomenklatur:
+• **16-Bit:** `AX`, `BX`, `CX` ...
+• **32-Bit:** `EAX`, `EBX`, `ECX` ... (E = Extended)
+• **64-Bit:** `RAX`, `RBX`, `RCX` ... (R = Register/Re-extended)
+##### 2. Datenregister (General Purpose Registers)
+Diese werden für Rechenoperationen genutzt:
+• **AX / EAX / RAX (Accumulator):** Der primäre Akkumulator für arithmetische Operationen. Er wird auch für den Datenaustausch mit dem Arbeitsspeicher genutzt (ein Operand hier, einer im RAM).
+• **BX / EBX / RBX (Base):** Das Basisregister. Es wird oft für die adressierte Indizierung (Zeiger auf Daten) verwendet.
+• **CX / ECX / RCX (Counter):** Das Zählregister. Es ist speziell für Schleifen (`loops`) optimiert, da es automatisch herunterzählen (dekrementieren) kann.
+• **DX / EDX / RDX (Data):** Das Datenregister. Es wird für I/O-Operationen und für Berechnungen mit großen Zahlen (z.B. Multiplikation/Division zusammen mit AX) genutzt.
+##### 3. Segmentregister
+Da der Speicher in Segmente unterteilt ist, zeigen diese Register auf den Beginn eines Segments:
+• **CS (Code Segment):** Startadresse des Programmcodes (Befehle).
+• **DS (Data Segment):** Startadresse der Daten (Variablen, Konstanten).
+• **SS (Stack Segment):** Startadresse des Stacks (für Funktionsaufrufe/lokale Variablen).
+• **ES (Extra Segment):** Zusätzlicher Speicherbereich für Daten.
+##### 4. Zeiger- und Indexregister (Klausurrelevant!)
+Diese Register sind für den Programmablauf und die Stack-Verwaltung essenziell:
+• **IP / EIP / RIP (Instruction Pointer / Befehlszeiger):**
+    ◦ Speichert die Adresse des **nächsten** auszuführenden Befehls.
+    ◦ Zusammen mit dem `CS`-Register (`CS:IP`) ergibt sich die exakte physikalische Adresse des Befehls.
+• **SP / ESP / RSP (Stack Pointer / Stapelzeiger):**
+    ◦ Zeigt immer auf das aktuelle **Ende** (Top) des Stacks.
+    ◦ Wird zusammen mit dem `SS`-Register (`SS:SP`) verwendet.
+• **BP / EBP / RBP (Base Pointer):**
+    ◦ Dient als Referenzrahmen für Funktionsparameter und lokale Variablen auf dem Stack.
+    
+Wenn ein **Interrupt** auftritt oder ein **Prozesswechsel** (Kontextwechsel) stattfindet, muss das Betriebssystem den Inhalt _aller_ dieser Register sichern (in den PCB oder auf den Stack). Wenn der Prozess später weiterrechnet, werden die alten Werte in die Register zurückgeladen, damit der Prozess exakt dort weitermachen kann, wo er unterbrochen wurde
+#### Multicore
+Um Leistung zu steigern, ohne die Taktfrequenz (Wärme!) zu erhöhen, nutzt man mehrere Kerne.
+• **Hyperthreading:** Ein Kern simuliert zwei logische Kerne.
+• **Multi-Core:** Echte physische Kerne auf einem Chip. Jeder Kern hat eigene Rechenwerke (ALU/FPU) und L1-Cache, teilt sich aber oft L2/L3-Cache.
+### 4. Speicherhierarchie & Datenträger
+• **Cache (L1, L2, L3):** Puffer zwischen der sehr schnellen CPU und dem langsamen RAM. Ziel: Daten bereitstellen, bevor die CPU sie anfordert
+• **RAM (Arbeitsspeicher):**
+    ◦ _DRAM:_ Günstig, braucht Refresh-Zyklen (Kondensatoren entladen sich).
+    ◦ _SRAM:_ Schnell, teuer, kein Refresh nötig (Flip-Flops)
+• **Massenspeicher:**
+    ◦ _HDD:_ Mechanisch, Fragmentierung ist ein Problem.
+    ◦ _SSD:_ Flash-Speicher, keine beweglichen Teile, sehr schnell, verhält sich logisch wie eine Festplatte
+### 5. Treiber
+#### Das Grundproblem: Sprachbarrieren
+Das Betriebssystem muss mit vielen unterschiedlichen internen und externen Geräten (Festplatte, Grafikkarte, Drucker, Netzwerkkarte) kommunizieren.
+• **Komplexität:** Jedes Gerät ist technisch anders aufgebaut und besitzt eine eigene, oft sehr komplizierte „Sprache“ (Protokolle, Befehlssätze),.
+• **Unmöglichkeit:** Das Betriebssystem selbst (der Kernel) kann unmöglich alle Sprachen aller existierenden (und zukünftigen) Geräte beherrschen,.
+#### Die Hardware-Seite: Der Controller
+Jedes Gerät besitzt einen **Geräte-Controller** (einen Hardware-Chip).
+• Dieser Controller versteht die spezifische interne Sprache des Geräts und steuert die physischen Vorgänge (z.B. Schreibkopf bewegen, Pixel setzen).
+• Der Controller ist der direkte Ansprechpartner für die Software,.
+#### Die Software-Seite: Der Treiber
+Der **Treiber** ist ein spezielles Programm (Teil des Betriebssystems), das als Übersetzer fungiert.
+1. **Funktion:** Der Treiber kennt die Sprache des spezifischen Geräte-Controllers. Er übersetzt die allgemeinen Befehle des Betriebssystems (z.B. „Drucke Datei“) in die spezifischen Befehle für den Controller,.
+2. **Kommunikation:** Er sorgt für den Datentransfer hin und her zwischen dem Hauptspeicher und dem Gerät,.
+3. **Abstraktion:** Für manche standardisierten Schnittstellen (z.B. USB-Massenspeicher) gibt es generische Treiber, die für viele Geräte funktionieren. Meistens ist ein Treiber aber spezifisch für genau **ein** Gerät und genau **ein** Betriebssystem,.
+#### Geschwindigkeit
+Alle **E/A-Operationen** (Ein-/Ausgabe), die über Treiber laufen, sind im Vergleich zu reinen CPU-Register- oder RAM-Zugriffen extrem **langsam**. Daher versucht das BS oft, diese Wartezeiten durch Multitasking (Prozesswechsel) zu überbrücken.
+### 6. Datenübertragung: DMA (Direct Memory Access)
+**Problem:** Wenn die CPU jedes Byte einzeln von der Festplatte in den RAM kopieren müsste, wäre sie zu 100% ausgelastet ("zu schlau für dumme Arbeit")
+**Lösung (DMA-Ablauf):**
+1. Die **CPU** beauftragt den **DMA-Controller**: "Kopiere X Bytes von Adresse A nach B".
+2. Die CPU widmet sich sofort anderen Prozessen (rechnet weiter).
+3. Der **DMA-Controller** übernimmt den Bus und kopiert die Daten selbstständig.
+4. Nach Abschluss sendet der DMA-Controller einen **Interrupt** an die CPU ("Fertig!").
+5. Die CPU unterbricht ihre Arbeit kurz und bearbeitet das Ende des Transfers.
+### 7. Kommunikation: Polling vs. Interrupts
+#### 1. Polling (Aktives Warten)
+Dies ist die ältere und einfachere, aber ineffiziente Methode.
+**Das Prinzip:** Der Prozessor übernimmt die aktive Rolle. Er befindet sich in einer Schleife und fragt nacheinander jedes angeschlossene Gerät ab: _"Hast du Daten für mich? Hast du einen Auftrag?"_
+**Der Ablauf:**
+1. Die CPU stoppt ihre aktuelle Berechnung.
+2. Sie fragt Gerät A: "Status?".
+3. Sie fragt Gerät B: "Status?".
+4. Wenn kein Gerät etwas will, nimmt die CPU die Berechnung wieder auf oder fängt die Runde von vorne an
+**Die Nachteile (Warum wir es kaum noch nutzen):**
+• **Verschwendung:** Die CPU verbringt einen Großteil ihrer Zeit mit Fragen, auf die die Antwort meistens "Nein" lautet. Diese Zeit fehlt für echte Berechnungen
+• **Datenverlust:** Wenn die CPU gerade Gerät A bedient (Daten kopiert) und Gerät B in diesem Moment wichtige Daten empfängt (z.B. Netzwerkpakete), kann die CPU nicht reagieren. Da Gerät B oft keinen großen eigenen Speicher hat, gehen diese Daten verloren
+#### 2. Interrupts (Unterbrechungen)
+Dies ist der Standard in modernen Systemen. Hier melden sich die Geräte aktiv bei der CPU ("Event-Driven").
+
+**Das Prinzip:** Die CPU kümmert sich nicht um die Geräte, sondern rechnet an ihrem Prozess. Wenn ein Gerät Aufmerksamkeit braucht, sendet es ein elektronisches Signal (Interrupt). Die CPU unterbricht ihre Arbeit _sofort_, erledigt den Job des Geräts und macht dann weiter, als wäre nichts gewesen
+**Notwendige Hardware-Komponenten:** Damit das funktioniert, benötigt die CPU Hilfe:
+• **Interrupt-Register (IR):** Ein spezielles Register in der CPU, in dem Bits gesetzt werden, wenn eine Unterbrechung anliegt.
+• **Interrupt-Controller:** Ein Chip, der die Signale der vielen Geräte sammelt und geordnet an die CPU weiterleitet.
+• **Stack:** Ein Speicherbereich im RAM, um den Zustand der CPU (Kontext) kurzzeitig zu sichern.
+• **Interrupt-Vektoren:** Eine Tabelle im Speicher, die der CPU sagt: "Bei Fehler Nr. 5 springe zu Adresse X".
+• **ISR (Interrupt Service Routine):** Das kleine Programm (Treiber), das das Gerät tatsächlich bedient.
+
+Der detaillierte Ablauf eines Interrupts am Beispiel einer Netzwerkkarte, die Daten empfängt:
+1. **Ereignis:** Daten kommen an der Netzwerkkarte an. Da ihr Speicher klein ist, müssen sie sofort abgeholt werden.
+2. **Signal:** Die Karte sendet ein Signal an den **Interrupt-Controller** (z.B. IRQ 5).
+3. **Weiterleitung:** Der Interrupt-Controller setzt das entsprechende Bit (Nr. 5) im **Interrupt-Register (IR)** der CPU.
+4. **Zyklus-Check:** Die CPU beendet ihren _aktuellen_ Befehl. Bevor sie den nächsten Befehl lädt, prüft sie automatisch das IR.
+5. **Erkennung:** Die CPU sieht: "Bit 5 ist gesetzt!".
+6. **Sicherung (Kontextwechsel):** Die CPU unterbricht das laufende Programm. Sie speichert alle wichtigen Registerinhalte und den Befehlszeiger auf den **Stack**.
+7. **Lookup:** Die CPU schaut in der Vektortabelle nach Eintrag Nr. 5, um die Startadresse der passenden **ISR** zu finden.
+8. **Ausführung:** Die CPU springt zur ISR. Die ISR kopiert die Daten von der Netzwerkkarte in den RAM.
+9. **Restore:** Die ISR ist fertig. Die CPU lädt die alten Registerwerte vom Stack zurück.
+10. **Weiter:** Das ursprüngliche Programm läuft an exakt der gleichen Stelle weiter.
+#### Vergleich:
+• Beim **Polling** geht die Initiative von der CPU aus (teuer, langsam).
+• Beim **Interrupt** geht die Initiative vom Gerät aus (effizient, schnell).