חיקוי לינוס טורבלדס: צור מערכת הפעלה משלך מאפס (III)

אנו ממשיכים בסדרת הפוסטים הזו כיצד ליצור את מערכת ההפעלה שלנו. היום אנחנו לא מתכוונים להתמקד בנושא אחד אבל אנחנו הולכים להגדיר כמה פונקציות שימושיות מעתה ואילך. ראשית אנו הולכים להגדיר 3 פונקציות הממלאות את הפונקציה של memcpy, ממט 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;
}

כולם מיישמים את עצמם. את הפונקציות האלה לקחתי מספריית C קטנה, היישום בדרך כלל דומה בכל מערכות ההפעלה. עכשיו אנחנו הולכים לעשות 3 פונקציות מדומות אבל לתפעל מחרוזות. הם היו ממלאים את הפונקציה של 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;
}

אנחנו הולכים עכשיו עם כמה פונקציות מעניינות למדי. בעזרת פונקציות אלה אנו יכולים לקרוא ולכתוב ליציאות החומרה. זה נעשה בדרך כלל עם ASM ותואם (ב- x86) להוראות in y הַחוּצָה. כדי להתקשר בקלות ל- ASM מ- C, השתמש בהוראות ASM, עם הסכנה שזה כרוך בכך שהוא לא נייד. למשפט זה אנו מוסיפים את נדיף כדי ש- GCC לא ינסה לייעל את הטקסט הזה. מצד שני, להוראות asm יש דרך מוזרה לקבל פרמטרים, אבל אני חושב שניתן להבין זאת טוב יותר על ידי התבוננות בדוגמאות.

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

ועד כה פוסט 3, היום לא עשינו שום דבר ראוותני אבל הגדרנו פונקציות שיהיו שימושיות לעתיד. שים לב למשתמשי 64 סיביות שאני עובד על תיקון a באג מה שמונע קומפילציה נכונה ב 64 ביט. בפוסט הבא נראה מרכיב חשוב בארכיטקטורת x86, ה- GDT.