Kopiante Linus Torvalds: Kreu vian propran operaciumon de nulo (III)

Ni daŭrigas ĉi tiun serion da afiŝoj pri kiel krei nian operaciumon. Hodiaŭ ni ne celos unu temon, sed ni difinos iujn utilajn funkciojn de nun. Unue ni difinos 3 funkciojn, kiuj plenumas la funkcion de 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;
}

Ĉiuj estas memefektivigaj. Ĉi tiujn funkciojn mi prenis de malgranda C-biblioteko, la efektivigo kutime similas en ĉiuj operaciumoj. Nun ni faros 3 simulitajn funkciojn sed manipuli kordojn. Ili plenumus la funkcion de strcpy, strcat 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;
}

Ni iras nun kun sufiĉe interesaj funkcioj. Per ĉi tiuj funkcioj ni povas legi kaj skribi al la aparatoj. Ĉi tio kutime fariĝas per ASM kaj respondas (ĉe x86) al la instrukcioj in y eksteren. Por facile voki ASM de C, uzu la instrukcion asm, kun la danĝero, ke ĝi implicas, ke ĝi ne estas portebla. Al ĉi tiu frazo ni aldonas la flamiĝemaj por ke GCC ne provu optimumigi tiun tekston. Aliflanke, la asm-instrukcio havas kuriozan manieron akcepti parametrojn, sed mi pensas, ke oni pli bone komprenas ĝin rigardante la ekzemplojn.

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;
}

Kaj ĝis nun post 3, hodiaŭ ni faris nenion okulfrapan, sed ni difinis funkciojn, kiuj utilos por la estonteco. Rimarku al 64-bitaj uzantoj, ke mi laboras pri riparado de cimo kio malebligas kompili ĝuste en 64 bitoj. En la sekva afiŝo ni vidos gravan eron de la x86-arkitekturo, la GDT.