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

"इमुलेटिंग लिनस टोरवाल्ड्स" या पोस्टच्या या मालिकेत पुन्हा आपले स्वागत आहे. आज आपण जीडीटी पाहू. प्रथम जीडीटी म्हणजे काय ते पहा. विकिपीडियाच्या मते:

अगोदर निर्देश केलेल्या बाबीसंबंधी बोलताना ग्लोबल डिस्क्रिप्टर टेबल or जीडीटी द्वारे वापरलेली एक डेटा स्ट्रक्चर आहे इंटेल x86-फॅमली प्रोसेसर सह प्रारंभ 80286 प्रोग्राम अंमलबजावणीदरम्यान वापरल्या जाणार्‍या विविध मेमरी क्षेत्राची वैशिष्ट्ये परिभाषित करण्यासाठी, ज्यामध्ये बेस पत्ता, आकार आणि एक्सेस एक्झिक्युटिबिटी सारख्या एक्झिक्यूटेबिलिटी आणि लिटीलिटी

काय भाषांतरित केले जाईल ते ग्लोबल डिस्क्रिप्टर टेबल असेल, प्रोग्राम एक्झिक्यूशनदरम्यान वापरल्या जाणार्‍या विविध मेमरी क्षेत्रांची वैशिष्ट्ये परिभाषित करण्यासाठी 86०२80286 पासून इंटेल xXNUMX प्रोसेसरमध्ये वापरली जाणारी एक डेटा स्ट्रक्चर.

सारांश, जर आपण इंटेल 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 जीडीटी अधिलिखित करा. जीडीटी लोड करण्यासाठी एलजीडीटी (किंवा सिंटॅक्सवर अवलंबून एलजीडीटीएल) नावाच्या एएसएम मध्ये एक सूचना आहे, आम्ही त्याचा वापर करणार आहोत.

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"
);


एकदा आम्ही हे पूर्ण केल्यावर आमच्या सिस्टमकडे आधीपासूनच जीडीटी असेल. पुढील अध्यायात आम्ही आयडीटी पाहू, जीडीटीसारखेच एक सारणी परंतु व्यत्ययांसह. मी जीडीटी सह काही स्थिती आणि पुष्टीकरण संदेश ठेवले आहेत म्हणून नेक्स्टडिव्हल आता यासारखे दिसते: