Ontwerp en bouw een besturingssysteem/Blue Screen of Death/Hulpfuncties

I/O poorten

Om gegevens via de I/O poorten te kunnen versturen, hebben we de outb assembler instructie nodig. En om gegevens te lezen van een I/O poort, gebruiken we de inb instructie. Tussen je C code kan je assembler instructies gebruiken. Dit heet inline assembly. We definieren System_InPortByte() en System_OutPortByte() in een nieuw bestand system.c.

/kernel/src/system.c

#include <system.h>

// Leest een byte van een I/O poort.
// <port> is de poort.
// Geeft de gelezen waarde terug.
byte System_InPortByte(uint16 port)
{
    byte rv;
    asm volatile ("inb %1, %0" : "=a" (rv) : "dN" (port));
    return rv;
}

// Schrijft een byte naar een I/O poort.
// <port> is de poort.
// <data> is de byte die geschreven moet worden.
void System_OutPortByte(uint16 port, byte data)
{
    asm volatile ("outb %1, %0" : : "dN" (port), "a" (data));
}

Om er gebruik van te kunnen maken, moet je declaraties van deze functies in een system.h headerbestand zetten.

/kernel/include/system.h

#ifndef __SYSTEM_H
#define __SYSTEM_H

extern byte System_InPortByte(uint16 port);
extern void System_OutPortByte(uint16 port, byte data);

#endif  // __SYSTEM_H

Tip! Als je in meerdere codebestanden dezelfde headerbestanden gebruikt, dan is de kans groot dat ze dubbel of zelfs nog vaker in de code worden gezet. Om dit te voorkomen definieer je (met #define een constante specifiek voor elk headerbestand. Is die constante al gedefinieerd (te testen met #ifndef), dan sla je de inhoud van het headerbestand over. Zie de code voor system.h voor een voorbeeld.

Geheugen

Vaak worden er hele stukken van het werkgeheugen gekopieerd, verplaatst of op een bepaalde waarde gezet. Voor deze bewerkingen schrijf je nu zelf geheugenfuncties in een nieuw bestand genaamd memory.c, en maak een bijbehorend memory.h headerbestand in de /kernel/include directory. De te schrijven functies:

/kernel/src/memory.c

#include <memory.h>

// Kopieert <count> bytes van <src> naar <dest>.
// Als de delen overlappen is het gedrag onbepaald.
// Geeft <dest> terug.
void* Memory_Copy(void* dest, const void* src, nint count)
{
    ...
}

// Verplaatst <count> bytes van <src> naar <dest>.
// Als de delen overlappen blijven de brongegevens niet intact.
// Geeft <dest> terug.
void* Memory_Move(void* dest, const void* src, nint count)
{
    ...
}

// Stelt <count> bytes vanaf <dest> in op de byte waarde <value>.
// Geeft <dest> terug.
void* Memory_Set(void* dest, byte value, nint count)
{
    ...
}

// Stelt <count> 16-bit woorden vanaf <dest> in
// op de 16-bit waarde <value>. Geeft <dest> terug.
uint16* Memory_SetW(uint16* dest, uint16 value, nint count);
{
    ...
}

// Vergelijkt twee reeksen (<what> en <with>) van <count> bytes.
// Geeft 0 terug als ze gelijk zijn of niet 0 als ze verschillend zijn.
nint Memory_Compare(const void* what, const void* with, nint count)
{
    ...
}

Als je er niet uit komt met de geheugenfuncties, kijk dan eens hier: LINK1 LINK2 Linux 1.0 Broncode Let wel op eventuele licentievoorwaarden.