Linus Torvalds emuleren: maak uw eigen besturingssysteem helemaal opnieuw (III)

We gaan door met deze reeks berichten over het maken van ons besturingssysteem. Vandaag gaan we ons niet op één onderwerp concentreren, maar we gaan vanaf nu enkele nuttige functies definiëren. Eerst gaan we 3 functies definiëren die de functie vervullen van memcpy, memeset y memcmp:

void* ND::Memory::Set(void* buf, int c, size_t len)
{
unsigned char* tmp=(unsigned char*)buf;
while(len--)
{
*tmp++=c;
}
return buf;
}
void* ND::Memory::Copy(void* dest,const void* src, size_t len)
{
const unsigned char* sp=(const unsigned char*)src;
unsigned char* dp=(unsigned char*)dest;
for(;len!=0;len--) *dp++=*sp++;
return dest;
}
int ND::Memory::Compare(const void* p1, const void* p2, size_t len)
{
const char* a=(const char*)p1;
const char* b=(const char*)p2;
size_t i=0;
for(;i<len;i++)
{
if(a[i] < b[i]) return -1; else if(a[i] > b[i])
return 1;
}
return 0;
}

Ze implementeren allemaal zichzelf. Deze functies heb ik overgenomen van een kleine C-bibliotheek, de implementatie is meestal vergelijkbaar in alle besturingssystemen. Nu gaan we 3 gesimuleerde functies doen, maar om strings te manipuleren. Ze zouden de functie vervullen van streng, streng y strcmp.

size_t ND::String::Length(const char* src)
{
size_t i=0;
while(*src--)
i++;
return i;
}
int ND::String::Copy(char* dest, const char* src)
{
int n = 0;
while (*src)
{
*dest++ = *src++;
n++;
}
*dest = '';
return n;
}
int ND::String::Compare(const char *p1, const char *p2)
{
int i = 0;
int failed = 0;
while(p1[i] != '' && p2[i] != '')
{
if(p1[i] != p2[i])
{
failed = 1;
break;
}
i++;
}
if( (p1[i] == '' && p2[i] != '') || (p1[i] != '' && p2[i] == '') )
failed = 1;
return failed;
}
char *ND::String::Concatenate(char *dest, const char *src)
{
int di = ND::String::Length(dest);
int si = 0;
while (src[si])
dest[di++] = src[si++];
dest[di] = '';
return dest;
}

We gaan nu met een aantal behoorlijk interessante functies. Met deze functies kunnen we lezen en schrijven naar de hardwarepoorten. Dit wordt normaal gesproken gedaan met ASM en komt overeen (op x86) met de instructies in y uit. Gebruik de instructie om ASM gemakkelijk vanaf C te bellen aSM, met het gevaar dat het met zich meebrengt dat het niet draagbaar is. Aan deze zin voegen we de vluchtig zodat GCC die tekst niet probeert te optimaliseren. Aan de andere kant heeft de asm-instructie een merkwaardige manier om parameters te accepteren, maar ik denk dat dat beter wordt begrepen door de voorbeelden te zien.

void ND::Ports::OutputB(uint16_t port, uint8_t value)
{
asm volatile("outb %1, %0" : : "dN"(port), "a"(value));
}
uint8_t ND::Ports::InputB(uint16_t _port)
{
unsigned char rv;
asm volatile("inb %1, %0" : "=a"(rv) : "dN"(_port));
return rv;
}

En tot nu toe in post 3, hebben we vandaag niets opzichtigs gedaan, maar we hebben een functie gedefinieerd die van pas zal komen voor de toekomst. Bericht aan 64-bits gebruikers dat ik bezig ben met het oplossen van een kever wat het correct compileren in 64 bits verhindert. In de volgende post zullen we een belangrijk onderdeel van de x86-architectuur zien, de GDT.