De PIC herprogrammeren

Standaard zijn IRQ 0-7 van de PIC gemapt naar interrupt 8-15. Interrupt 0-31 zijn door Intel gereserveerd voor exceptions, dus dat gaat fout. Er is geen mogelijkheid om in je interrupt routine te detecteren of het om een exception ging of om een hardware interrupt gestuurd dor de PIC. De enige mogelijkheid is dus om de PIC zo te herprogrammeren dat IRQ 0-7 een ander interrupt oproepen.

Op http://www.osdev.org/wiki/PIC staat een uitgebreide Engelse uitleg hierover. Onderaan die pagina staat voorbeeldcode waarmee dit zou moeten lukken. Als het niet lukt stel dan gerust je vraag.

Interrupts, wat zijn het en hoe ze te gebruiken?

Wat is een interrupt?

Een interrupt is een gebeurtenis die de uitvoering van instructies onderbreekt. Een interrupt kan op verschillende manieren plaatsvinden, door software maar ook door hardware. Een hardware-interrupt komt bijvoorbeeld voor als je een toets indrukt op je toetsenbord. Een software-interrupt is een speciale instructie die door een programma wordt uitgevoerd om de kernel aan te roepen, bijvoorbeeld als de applicatie meer heap-geheugen nodig heeft. Ook wordt er door de processor een interrupt gecreeerd als er een fout optreed, bevoorbeeld bij een deling door 0.

Hoe kun je interrupts gebruiken?

Als er een fout (exception) optreed in de processor wordt er een interrupt aangeroepen. De interrupt die intel voor fouten heeft gereserveerd lopen van 0 t/m 31. De zelf te gebruiken interrupts lopen van 32 t/m 255. Voordat je hier iets mee kunt moet je eerst aan de processor vertellen welke functie aangeroepen moet worden als een interrupt optreedt. Dit kan door middel van een idt. Uitleg over de idt volgt binnenkort.

Een malloc-functie

Ik ben nu bezig om mijn eigen malloc-functie (malloc is een afkorting voor memory allocator) te schrijven voor mijn kernel. Deze functie noem ik kalloc. Een goed voorbeeld is Doug Lea's malloc. Zie ook de broncode van dlmalloc. Mijn eigen allocator wordt veel simpeler. Ik hou een linked list bij van blokken geheugen die of vrij of in gebruik zijn. Bij deze blokken sla ik de lengte, het type (vrij of in gebruik) en een pointer naar het volgende blok op. Als kalloc wordt aangeroepen wordt de linked list doorlopen vanaf het eerste vrij blok (daarnaartoe hou ik een globale variabele bij) tot het blok dat genoeg ruimte heeft. Als dit blok veel te groot is wordt het in twee blokken gesplitst. Zodra een blok vrijgemaakt wordt via de functie free, wordt gekeken of het blok erachter ook vrij is, zoja, dan worden deze twee blokken samengevoegd. Eventueel laat ik kalloc ook nog controlen of er twee blokken achter elkaar vrij zijn, zodat ook aanvragen voor grotere stukken afgehandeld kunnen worden door twee vrij aanliggende stukken aan elkaar te plakken.

Ik zet voor elk stuk geheugen dat ik vrijgeef de volgende header:struct blockInfoStruct{
unsigned long length;
struct blockInfoStruct *next;
unsigned short type;
unsigned short reserved;
} __attribute__((packed));