અનુકરણ લિનસ ટોરવાલ્ડ્સ: શરૂઆતથી તમારી પોતાની operatingપરેટિંગ સિસ્ટમ બનાવો (III)

આપણી ourપરેટિંગ સિસ્ટમ કેવી રીતે બનાવવી તેના પર અમે પોસ્ટ્સની આ શ્રેણી ચાલુ રાખીએ છીએ. આજે આપણે એક વિષય પર ધ્યાન કેન્દ્રિત કરવાના નથી પરંતુ આપણે હવેથી કેટલાક ઉપયોગી કાર્યોની વ્યાખ્યા આપી રહ્યા છીએ. પ્રથમ આપણે 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;
}

તે બધા સ્વ-અમલીકરણ છે. આ વિધેયો મેં નાના સી લાઇબ્રેરીમાંથી લીધા છે, અમલીકરણ સામાન્ય રીતે બધી operatingપરેટિંગ સિસ્ટમ્સમાં સમાન હોય છે. હવે આપણે 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 ને સરળતાથી ક callલ કરવા માટે, સૂચનાનો ઉપયોગ કરો એએસએમ, તે જોખમમાં છે કે તે દબાણ કરે છે કે તે પોર્ટેબલ નથી. આ વાક્યમાં આપણે ઉમેરીએ છીએ વોલેટાઇલ જેથી જીસીસી તે લખાણને izeપ્ટિમાઇઝ કરવાનો પ્રયાસ ન કરે. બીજી બાજુ, એએસએમ સૂચનામાં પરિમાણોને સ્વીકારવાની એક વિચિત્ર રીત છે, પરંતુ મને લાગે છે કે ઉદાહરણો જોતાં તે વધુ સારી રીતે સમજાય છે.

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 આર્કિટેક્ચરનો એક મહત્વપૂર્ણ ઘટક જોશું, જી.ડી.ટી.