इमुलेटिंग लिनस टोरवाल्ड्स: स्क्रॅचपासून आपली स्वतःची ऑपरेटिंग सिस्टम तयार करा (III)

आमची ऑपरेटिंग सिस्टम कशी तयार करावी यासाठी आम्ही पोस्टची ही मालिका सुरू ठेवतो. आज आपण एका विषयावर लक्ष केंद्रित करणार नाही परंतु आम्ही आतापासून काही उपयुक्त कार्ये परिभाषित करणार आहोत. प्रथम आपण कार्ये पूर्ण करणार्या 3 फंक्शन्सची व्याख्या करणार आहोत मेमकपी, मेमसेट 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;
}

ते सर्व स्वत: ची अंमलबजावणी करीत आहेत. ही कार्ये मी एका छोट्या सी लायब्ररीतून घेतली आहेत, अंमलबजावणी सहसा सर्व ऑपरेटिंग सिस्टममध्ये समान असते. आता आपण 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;
}

आम्ही आता काही अत्यंत मनोरंजक कार्ये करीत आहोत. या फंक्शन्सद्वारे आम्ही हार्डवेअर पोर्ट वाचू आणि लिहू शकतो. हे सहसा एएसएम सह केले जाते आणि सूचनांशी संबंधित (x86 वर) केले जाते in y बाहेर. सी कडून एएसएम सहजपणे कॉल करण्यासाठी, सूचना वापरा 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;
}

आणि आतापर्यंत post नंतर, आज आम्ही काही चांगले काम केले नाही परंतु आम्ही कार्ये निश्चित केली आहेत जी भविष्यासाठी उपयुक्त आहेत. मी निश्चित करण्याचे काम करीत असलेल्या-3-बिट वापरकर्त्यांना सूचना द्या किडा जे b 64 बिट मध्ये अचूकपणे संकलित करण्यास प्रतिबंधित करते. पुढील पोस्टमध्ये आपण जीडीटी, एक्स 86 आर्किटेक्चरचा एक महत्त्वाचा घटक पाहू.