christoph/lecture-operating-system-development
1
Fork 0
Code Activity

add vorgabe04

Browse Source
This commit is contained in:
churl
2022-05-14 16:54:22 +02:00
parent d1f68b234d
commit d804fff473
15 changed files with 378 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
c_os/kernel/interrupts/ISR.h Executable file
View File

@ -0,0 +1,27 @@
/*****************************************************************************
* *
* I S R *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Interrupt Service Routine. Jeweils ein Objekt pro ISR. *
* Erlaubt es einen Kontext mit Variablen fuer die Unter- *
* brechungsroutine bereitzustellen. *
* *
* Autor: Michael Schoettner, 06.04.20 *
*****************************************************************************/
#ifndef __ISR_include__
#define __ISR_include__
class ISR {
private:
ISR (const ISR &copy); // Verhindere Kopieren
public:
ISR () {}
// Unterbrechungsbehandlungsroutine
virtual void trigger () = 0;
};
#endif

75
c_os/kernel/interrupts/IntDispatcher.cc
View File

@ -8,11 +8,78 @@
* Interrupts an. Wenn eine Interrupt Service Routine *
* registriert ist, wird diese aufgerufen. *
* *
* Autor: Michael Schoettner, 30.7.16 *
* Autor: Michael Schoettner, 31.8.2016 *
*****************************************************************************/
#include "kernel/CPU.h"
#include "kernel/Globals.h"
#include "kernel/interrupts/IntDispatcher.h"
extern "C" void int_disp(unsigned int slot);
// Low-Level Interrupt-Behandlung. (Die Funktion wird spaeter noch erweitert)
void int_disp(unsigned int slot) {
extern "C" void int_disp (unsigned int slot);
/*****************************************************************************
* Prozedur: int_disp *
*---------------------------------------------------------------------------*
* Beschreibung: Low-Level Interrupt-Behandlung. *
* Diese Funktion ist in der IDT fuer alle Eintraege einge- *
* tragen. Dies geschieht bereits im Bootloader. *
* Sie wird also fuer alle Interrupts aufgerufen. Von hier *
* aus sollen die passenden ISR-Routinen der Treiber-Objekte*
* mithilfe von 'IntDispatcher::report' aufgerufen werden. *
* Parameter: *
* vector: Vektor-Nummer der Unterbrechung *
*****************************************************************************/
void int_disp (unsigned int vector) {
/* hier muss Code eingefuegt werden */
kout << "Ein Interrupt ist aufgetreten" << slot << endl;
}
/*****************************************************************************
* Konstruktor: IntDispatcher::IntDispatcher *
*---------------------------------------------------------------------------*
* Beschreibung: Initialisierung der ISR map mit einer Default-ISR. *
*****************************************************************************/
IntDispatcher::IntDispatcher () {
for (unsigned int slot=0; slot<size; slot++)
map[slot] = 0;
}
/*****************************************************************************
* Methode: IntDispatcher::assign *
*---------------------------------------------------------------------------*
* Beschreibung: Registrierung einer ISR. *
* *
* Parameter: *
* vector: Vektor-Nummer der Unterbrechung *
* isr: ISR die registriert werden soll *
* *
* Rueckgabewert: 0 = Erfolg, -1 = Fehler *
*****************************************************************************/
int IntDispatcher::assign (unsigned int vector, ISR& isr) {
/* hier muss Code eingefuegt werden */
}
/*****************************************************************************
* Methode: IntDispatcher::report *
*---------------------------------------------------------------------------*
* Beschreibung: Eingetragene ISR ausfuehren. *
* *
* Parameter: *
* vector: Gesuchtes ISR-Objekt fuer diese Vektor-Nummer. *
* *
* Rueckgabewert: 0 = ISR wurde aufgerufen, -1 = unbekannte Vektor-Nummer *
*****************************************************************************/
int IntDispatcher::report (unsigned int vector) {
/* hier muss Code eingefuegt werden */
}

45
c_os/kernel/interrupts/IntDispatcher.h Executable file
View File

@ -0,0 +1,45 @@
/*****************************************************************************
* *
* I N T D I S P A T C H E R *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Zentrale Unterbrechungsbehandlungsroutine des Systems. *
* Der Parameter gibt die Nummer des aufgetretenen *
* Interrupts an. Wenn eine Interrupt Service Routine (ISR) *
* in der Map registriert ist, so wird diese aufgerufen. *
* *
* Autor: Michael Schoettner, 30.7.16 *
*****************************************************************************/
#ifndef __IntDispatcher_include__
#define __IntDispatcher_include__
#include "kernel/ISR.h"
class IntDispatcher {
private:
IntDispatcher(const IntDispatcher &copy); // Verhindere Kopieren
enum { size = 256 };
ISR* map[size];
public:
// Vektor-Nummern
enum {
timer = 32,
keyboard = 33
};
// Initialisierung der ISR map mit einer Default-ISR.
IntDispatcher ();
// Registrierung einer ISR. (Rueckgabewert: 0 = Erfolg, -1 = Fehler)
int assign (unsigned int vector, ISR& gate);
// ISR fuer 'vector' ausfuehren
int report (unsigned int vector);
};
#endif

73
c_os/kernel/interrupts/PIC.cc Executable file
View File

@ -0,0 +1,73 @@
/*****************************************************************************
* *
* P I C *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Mit Hilfe des PICs koennen Hardware-Interrupts (IRQs) *
* einzeln zugelassen oder unterdrueckt werden. Auf diese *
* Weise wird also bestimmt, ob die Unterbrechung eines *
* Geraetes ueberhaupt an den Prozessor weitergegeben wird. *
* Selbst dann erfolgt eine Aktivierung der Unterbrechungs- *
* routine nur, wenn der Prozessor bereit ist, auf Unter- *
* brechungen zu reagieren. Dies kann mit Hilfe der Klasse *
* CPU festgelegt werden. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
*****************************************************************************/
#include "kernel/PIC.h"
#include "kernel/IOport.h"
static IOport IMR1 (0x21); // interrupt mask register von PIC 1
static IOport IMR2 (0xa1); // interrupt mask register von PIC 2
/*****************************************************************************
* Methode: PIC::allow *
*---------------------------------------------------------------------------*
* Beschreibung: Sorgt dafuer, dass der uebergebene IRQ ab sofort durch *
* den PIC an den Prozessor weitergereicht wird. Um eine *
* Unterbrechungsbehandlung zu ermoeglichen, muss *
* zusaetzlich CPU::enable_int() aufgerufen werden. *
* *
* Parameter: *
* irq: IRQ der erlaubt werden soll *
*****************************************************************************/
void PIC::allow (int irq) {
/* hier muss Code eingefuegt werden */
}
/*****************************************************************************
* Methode: PIC::forbid *
*---------------------------------------------------------------------------*
* Beschreibung: Unterdrueckt mit Hilfe des PICs einen bestimmten IRQ. *
* *
* Parameter: *
* interrupt: IRQ der maskiert werden soll *
*****************************************************************************/
void PIC::forbid (int irq) {
/* hier muss Code eingefuegt werden */
}
/*****************************************************************************
* Methode: PIC::status *
*---------------------------------------------------------------------------*
* Beschreibung: Liefert den aktuellen Zustand des Maskierbits eines *
* bestimmten IRQs. *
* *
* Parameter: *
* irq: IRQ dessen Status erfragt werden soll *
*****************************************************************************/
bool PIC::status (int irq) {
/* hier muss Code eingefuegt werden */
}

44
c_os/kernel/interrupts/PIC.h Executable file
View File

@ -0,0 +1,44 @@
/*****************************************************************************
* *
* P I C *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Mit Hilfe des PICs koennen Hardware-Interrupts (IRQs) *
* einzeln zugelassen oder unterdrueckt werden. Auf diese *
* Weise wird also bestimmt, ob die Unterbrechung eines *
* Geraetes ueberhaupt an den Prozessor weitergegeben wird. *
* Selbst dann erfolgt eine Aktivierung der Unterbrechungs- *
* routine nur, wenn der Prozessor bereit ist, auf Unter- *
* brechungen zu reagieren. Dies kann mit Hilfe der Klasse *
* CPU festgelegt werden. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
*****************************************************************************/
#ifndef __PIC_include__
#define __PIC_include__
class PIC {
private:
PIC(const PIC &copy); // Verhindere Kopieren
public:
PIC() {}
public:
// IRQ-Nummern von Geraeten
enum {
timer = 0, // Programmable Interrupt Timer (PIT)
keyboard = 1 // Tastatur
};
// Freischalten der Weiterleitung eines IRQs durch den PIC an die CPU
void allow (int irq);
// Unterdruecken der Weiterleitung eines IRQs durch den PIC an die CPU
void forbid (int irq);
// Abfragen, ob die Weiterleitung fuer einen bestimmten IRQ unterdrueckt ist
bool status (int interrupt_device);
};
#endif