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

"એમ્યુલેટિંગ લિનસ ટોરવાલ્ડ્સ" શીર્ષકવાળી પોસ્ટ્સની આ શ્રેણીમાં પાછા આવો આપનું સ્વાગત છે. આજે આપણે જી.ડી.ટી. પહેલા આપણે એ જોવું પડશે કે જીડીટી શું છે. વિકિપિડિયા અનુસાર:

આ વૈશ્વિક વર્ણનકર્તા કોષ્ટક or જીડીટી એક ડેટા સ્ટ્રક્ચર છે જેનો ઉપયોગ થાય છે ઇન્ટેલ x86-ફેમિલી પ્રોસેસર 80286 પ્રોગ્રામ એક્ઝેક્યુશન દરમિયાન ઉપયોગમાં લેવાતા વિવિધ મેમરી ક્ષેત્રોની લાક્ષણિકતાઓને નિર્ધારિત કરવા માટે, જેમાં સરનામું, કદ અને એક્ઝિક્યુટિએબિલીટી અને લેખનક્ષમતા જેવા સગવડ

જેનું ભાષાંતર થયું તે ગ્લોબલ ડિસ્ક્રીપ્ટર ટેબલ હશે, જે ડેટા એક્સ્ટ્રક્ચર છે જેનો ઉપયોગ ઇન્ટેલ x86 પ્રોસેસરમાં 80286 થી પ્રોગ્રામ એક્ઝેક્યુશન દરમિયાન ઉપયોગમાં લેવાતા વિવિધ મેમરી ક્ષેત્રોની લાક્ષણિકતાઓને વ્યાખ્યાયિત કરવા માટે થાય છે.

સારાંશમાં, જો આપણે ઇન્ટેલ x86 પ્રોસેસરનો ઉપયોગ કરી રહ્યા છીએ, તો આપણે મેમરીના યોગ્ય ઉપયોગ માટે જીડીટી વ્યાખ્યાયિત કરવી આવશ્યક છે. અમે વધુ ગૂંચવણ કરીશું નહીં અને અમે કોષ્ટકમાં 3 પ્રવેશો વ્યાખ્યાયિત કરીશું:

• બધા કોષ્ટકો માટે જરૂરી નલ પ્રવેશ.
• વિભાગ માટે ટિકિટ માહિતી, અમે મહત્તમ ઉપયોગ કરીશું, જે 32 બિટ્સમાં 4 જીબી છે.
• વિભાગ માટે ટિકિટ કોડ, અમે મહત્તમ ઉપયોગ કરીશું, જે 32 બિટ્સમાં 4 જીબી છે.

જેમ તમે જોઈ શકો છો, ડેટા અને કોડ સમાન જગ્યાનો ઉપયોગ કરશે. ઠીક છે, હવે અમે તેનો અમલ કરવા જઈ રહ્યા છીએ. આ માટે અમે બે સ્ટ્રક્ચર્સનો ઉપયોગ કરીશું, પ્રથમ આપણા જીડીટીના વાસ્તવિક ડેટા માટે પોઇંટર રાખવાનો હવાલો હશે. અને બીજો જીડીટી પ્રવેશો સાથેનો એરે હશે. ચાલો પ્રથમ તેમને વ્યાખ્યાયિત કરીએ

struct Entry{
uint16_t limit_low;
uint16_t base_low;
uint8_t base_middle;
uint8_t access;
uint8_t granularity;
uint8_t base_high;
} __attribute__((packed));
struct Ptr{
uint16_t limit;
uint32_t base;
} __attribute__((packed));


તમે સ્ટ્રક્ચર્સના અંતમાં એક વિચિત્ર __attribute __ ((પેક્ડ)) જોયું હશે. આ જીસીસીને સ્ટ્રક્ચર્સને .પ્ટિમાઇઝ ન કરવા કહે છે કારણ કે આપણે જે જોઈએ છે તે પ્રોસેસરની જેમ ડેટા પાસ કરવાનું છે. હવે અમે જીડીટી સ્થાપિત કરવા માટે એક કાર્ય કરવા જઈ રહ્યા છીએ. આપણે સ્ટ્રક્ચર્સને ઘોષિત કરી દીધાં હોત, હવે આપણે તે પ્રારંભ કરીશું.

struct ND::GDT::Entry gdt[3];
struct ND::GDT::Ptr gp;
void ND::GDT::Install()
{
gp.limit=(sizeof(struct ND::GDT::Entry)*3)-1;
gp.base=(uint32_t)&gdt;
}


તેથી અમે અમારા 3-ઇનપુટ ટેબલ પર જાય છે તે નિર્દેશક બનાવવાનું છે.

void ND::GDT::SetGate(int num, uint32_t base, uint32_t limit, uint8_t access,uint8_t gran)
{
gdt[num].base_low=(base & 0xFFFF);
gdt[num].base_middle=(base >> 16) & 0xFF;
gdt[num].base_high=(base >> 24) & 0xFF;
gdt[num].limit_low=(limit & 0xFFFF);
gdt[num].granularity=(limit >> 16) & 0x0F;
gdt[num].granularity |= (gran & 0xF0);
gdt[num].access=access;
}


અને આપણે તેને ઇન્સ્ટોલ ફંક્શનથી 3 વાર કહીએ છીએ

ND::GDT::SetGate(0,0,0,0,0); /* NULL segmente entry */
ND::GDT::SetGate(1,0,0xFFFFFFFF,0x9A,0xCF); /* 4 GiB for Code Segment */
ND::GDT::SetGate(2,0,0xFFFFFFFF,0x92,0xCF); /* 4 GiB for Data segment */


અંતે, આપણે પ્રોસેસરને કહેવું જ જોઇએ કે અમારી પાસે જીડીટી છે, જેથી તે તેને લોડ કરી શકે, અને અમારા કિસ્સામાં જ્યારે GRUB સાથે કર્નલ લોડ કરવામાં આવે ત્યારે, GRUB GDT ફરીથી લખી શકાય. જી.ડી.ટી.ટી. ને લોડ કરવા માટે એ.જી.જી.ડી.ટી. (અથવા વાક્યરચનાના આધારે એલ.જી.ડી.ડી.ટી.) નામની એક સૂચના છે, અમે તેનો ઉપયોગ કરીશું.

asm volatile("lgdtl (gp)");
asm volatile(
"movw $0x10, %ax \n"
"movw %ax, %ds \n"
"movw %ax, %es \n"
"movw %ax, %fs \n"
"movw %ax, %gs \n"
"movw %ax, %ss \n"
"ljmp $0x08, $next \n"
"next: \n"
);


સારું, એકવાર આપણે આ સમાપ્ત કરી લીધા પછી અમારી સિસ્ટમ પાસે પહેલાથી જ જી.ડી.ટી. હવે પછીનાં અધ્યાયમાં આપણે આઈડીટી જોશું, એક ટેબલ જીડીટી જેવું જ છે પરંતુ વિક્ષેપો સાથે. મેં જીડીટી સાથે કેટલાક સ્ટેટસ અને પુષ્ટિ સંદેશા મૂક્યાં છે તેથી નેક્સ્ટડિવલ હવે આના જેવો દેખાય છે: