🖕 🎽 👂🏻 एक अखंड यूनिक्स जैसा ओएस विकसित करना

पिछले लेख में, हमने एक गतिशील मेमोरी मैनेजर को लागू किया था।
आज हम इंटेल i386 प्रोसेसर के संरक्षित मोड में काम करने की मूल बातें कवर करेंगे।
अर्थात्: ग्लोबल डिस्क्रिप्टर टेबल और इंटरप्ट वेक्टर टेबल।

सामग्री की तालिका

बिल्ड सिस्टम (मेक, जीसीसी, गैस)। प्रारंभिक बूट (मल्टीबूट)। लॉन्च (qemu)। सी लाइब्रेरी (strcpy, memcpy, strext)।
सी लाइब्रेरी (स्प्रिंटफ, स्ट्रैची, स्ट्रैम्प, स्ट्रेटोक, वा_लिस्ट ...)। लाइब्रेरी को कर्नेल मोड और उपयोगकर्ता एप्लिकेशन मोड में बनाना।
कर्नेल सिस्टम लॉग। वीडियो मेमोरी टर्मिनल का आउटपुट (kprintf, kpanic, kassert)।
डायनेमिक मेमोरी, हीप (kmalloc, kfree)।
मेमोरी और इंटरप्ट हैंडलिंग (GDT, IDT, PIC, syscall) का संगठन। अपवाद।
वर्चुअल मेमोरी (पेज डायरेक्टरी और पेज टेबल)।
प्रक्रिया। समयबद्धक। मल्टीटास्किंग। सिस्टम कॉल (मार, निकास, पीएस)।
कर्नेल की फ़ाइल प्रणाली (initrd), योगिनी, और इसके आंतरिक। सिस्टम कॉल (निष्पादन)।
चरित्र डिवाइस ड्राइवर। सिस्टम कॉल (ioctl, fopen, fread, fwrite)। सी लाइब्रेरी (fopen, fclose, fprintf, fscanf)।
कर्नेल के लिए एक पूर्ण कार्यक्रम के रूप में शेल।
उपयोगकर्ता सुरक्षा मोड (रिंग 3)। टास्क स्टेटस सेगमेंट (tss)।

रैखिक संबोधन

इंटेल प्रोसेसर में 2 मुख्य ऑपरेटिंग मोड हैं: संरक्षित मोड x32 और IA-32e x64।
सामान्य तौर पर, जुबकोव बहुत अच्छी तरह से और इस बारे में समझ में आता है, मैं इसे पढ़ने की सलाह देता हूं, हालांकि सिद्धांत रूप में इंटेल मैनुअल भी संभव है, यह जटिल नहीं है, लेकिन निरर्थक और बड़े।
सिस्टम प्रोग्रामिंग के लिए उनके पास एक अलग वॉल्यूम है, मैं इसे पढ़ने और पढ़ने की सलाह देता हूं।
पहले पर बहुत अधिक रूसी भाषा की जानकारी है, इसलिए, हम मुख्य बिंदुओं पर संक्षेप में विचार करेंगे।
दो प्रकार के पते हैं: रैखिक और पृष्ठ। रैखिक का मतलब है कि पूरे भौतिक स्थान को लगातार वर्णित किया जाता है और भौतिक एक के साथ मेल खाता है, क्योंकि एक नियम के रूप में खंड वर्णनकर्ताओं के आधार शून्य हैं, क्योंकि यह आसान है।
इस मामले में, कर्नेल मोड के लिए, आपको मेमोरी का वर्णन करने वाले तीन विवरण बनाने की आवश्यकता है: कोड, स्टैक और डेटा के लिए। वे कुछ हार्डवेयर सुरक्षा द्वारा प्रतिष्ठित हैं।
ऐसे प्रत्येक खंड में शून्य का आधार होता है और एक मशीन शब्द के अधिकतम आकार द्वारा संबोधित सीमा होती है। स्टैक विपरीत दिशा में बढ़ता है, और इसके लिए विवरणक में एक झंडा भी होता है।
इसलिए, इस प्रारूप के तीन रिकॉर्ड के साथ हमें वह सब कुछ पता है जिसकी हमें आवश्यकता है:

/* * Global descriptor table entry */ struct GDT_entry_t { u16 limit_low: 16; u16 base_low: 16; u8 base_middle: 8; u8 type: 4; /* whether code (0b1010), data (0b0010), stack (0b0110) or tss (0b1001) */ u8 s: 1; /* whether system descriptor */ u8 dpl: 2; /* privilege level */ u8 p: 1; /* whether segment prensent */ u8 limit_high: 4; u8 a: 1; /* reserved for operation system */ u8 zero: 1; /* zero */ u8 db: 1; /* whether 16 or 32 segment */ u8 g: 1; /* granularity */ u8 base_high: 8; } attribute(packed);

GDT में प्रत्येक सेगमेंट रजिस्टर (cs, ds, ss) का अपना डिस्क्रिप्टर होता है, इसलिए जब हम कोड सेक्शन में कुछ लिखते हैं, तो हमें एक त्रुटि मिलती है, क्योंकि डिस्क्रिप्टर में लिखित सुरक्षा होती है।
इस कार्य के लिए, हमें GDTR रजिस्टर में निम्न प्रारूप की एक संरचना लोड करने की आवश्यकता है:

 /* * Global descriptor table pointer */ struct GDT_pointer_t { u16 limit; u32 base; } attribute(packed);

सीमा जीडीटी तालिका शून्य से 1 के अंत है, स्मृति में आधार इसकी शुरुआत है।
जीडीटी को इस तरह रजिस्टर में लोड किया जाता है:

/*
* Load global descriptor table
* void asm_gdt_load(void *gdt_ptr)
*/
asm_gdt_load:
mov 4(%esp),%eax # eax = gdt_ptr
lgdt (%eax)
mov $0x10,%eax
mov %ax,%ds
mov %ax,%es
mov %ax,%fs
mov %ax,%gs
mov %ax,%ss
jmp $0x08,$asm_gdt_load_exit
asm_gdt_load_exit:
ret

और इसके तुरंत बाद हम कर्नेल डेटा चयनकर्ताओं को डेटा डिस्क्रिप्टर (शून्य सुरक्षा रिंग) को इंगित करने वाले सभी सेगमेंट रजिस्टर में लोड करते हैं।
उसके बाद, पेजिंग को शामिल करने के लिए सब कुछ तैयार है, लेकिन बाद में उस पर और अधिक।
वैसे, मल्टीबूट बूटलोडर्स तुरंत अपने जीडीटी को स्थापित करने की सलाह देते हैं, हालांकि वे इसे स्वयं करते हैं, वे इतना अधिक मज़बूती से कहते हैं।
वीडियो ट्यूटोरियल में यह सब तकनीकी रूप से सही तरीके से करने का तरीका देखें।

बाधा से निपटने

GDT के अनुरूप होने से, इंटरप्ट टेबल का अपना IDTR रजिस्टर होता है, जिसमें आपको एक समान पॉइंटर लोड करने की जरूरत होती है, लेकिन पहले से ही IDT पर।
इंटरप्ट टेबल को निम्नलिखित प्रविष्टियों द्वारा वर्णित किया गया है:

 /* * Interrupt table entry */ struct IDT_entry_t { u16 offset_lowerbits; u16 selector; u8 zero; u8 type_attr; u16 offset_higherbits; };

रुकावट प्रवेश द्वार आमतौर पर एक प्रकार के रूप में कार्य करता है, क्योंकि हम रुकावटों को विशेष रूप से संभालना चाहते हैं। हम अभी तक जाल और कॉल गेटवे पर विचार नहीं करते हैं, क्योंकि यह टीएसएस और सुरक्षा के छल्ले के करीब है।
आइए अपने साथ इन तालिकाओं के साथ काम करने के लिए एक इंटरफ़ेस बनाएं। उन्हें बस एक बार स्थापित करने और भूलने की आवश्यकता है।

 /* * Api */ extern void gdt_init(); extern void idt_init();

और अब हम IDT रिकॉर्ड में सूचीबद्ध व्यवधानकर्ताओं को स्वयं घोषित करेंगे।
सबसे पहले, हार्डवेयर एरर हैंडलर्स लिखें:

 /* * Api - IDT */ extern void ih_double_fault(); extern void ih_general_protect(); extern void ih_page_fault(); extern void ih_alignment_check(); extern void asm_ih_double_fault(); extern void asm_ih_general_protect(); extern void asm_ih_page_fault(); extern void asm_ih_alignment_check();

फिर कीबोर्ड इंटरप्ट हैंडलर:

 /* * Api - IRQ */ extern void ih_keyboard(); extern void asm_ih_keyboard();

यह आईडीटी तालिका को आरंभ करने का समय है।
यह कुछ इस तरह दिखता है:

 extern void idt_init() { size_t idt_address; size_t idt_ptr[2]; pic_init(); /* fill idt */ idt_fill_entry(INT_DOUBLE_FAULT, (size_t)asm_ih_double_fault); idt_fill_entry(INT_GENERAL_PROTECT, (size_t)asm_ih_general_protect); idt_fill_entry(INT_ALIGNMENT_CHECK, (size_t)asm_ih_alignment_check); idt_fill_entry(INT_KEYBOARD, (size_t)asm_ih_keyboard); /* load idt */ idt_address = (size_t)IDT; idt_ptr[0] = (LOW_WORD(idt_address) << 16) + (sizeof(struct IDT_entry_t) * IDT_SIZE); idt_ptr[1] = idt_address >> 16; asm_idt_load(idt_ptr); }

यहां हमने तीन हार्डवेयर त्रुटि हैंडलर और एक रुकावट दर्ज की।
इसके लिए काम करना शुरू करने के लिए, हमें IDTR रजिस्टर में एक विशेष पॉइंटर को आधार और सीमा के साथ लोड करना होगा:

/*
* Load interrupt table
* void asm_idt_load(unsigned long *addr)
*/
asm_idt_load:
push %edx
mov 8(%esp), %edx
lidt (%edx)
pop %edx
ret

तालिका में कितने रिकॉर्ड हैं, यह समझने के लिए सीमाओं की आवश्यकता होती है।
यह एक कीबोर्ड इंटरप्ट हैंडलर लिखने का समय है:

/*
* Handle IRQ1
* void asm_ih_keyboard(unsigned int)
*/
asm_ih_keyboard:
pushal
call ih_keyboard
popal
iretl

नोट: इसके बाद और हर जगह कोड में "निचले हिस्सों" लिनक्स में "ऊपरी हिस्सों" के बराबर हैं। और "ऊपरी", क्रमशः, विपरीत। मैं माफी माँगता हूँ, इसके विपरीत मेरे सिर में डाल दिया गया था: डी

दरअसल यह एक उच्च-स्तरीय हैंडलर को कोड पास करेगा।
बदले में, इसी ड्राइवर के निचले हिस्सों के हैंडलर को कॉल करेगा जिसने इस रुकावट को संसाधित करने के लिए अनुरोध पंजीकृत किया था।
हमारे मामले में, यह एक चरित्र डिवाइस ड्राइवर होगा।
दूसरों को धीमा करने के बिना जल्दी से बाधित करने की प्रक्रिया में निचले हिस्सों की आवश्यकता होती है, और फिर, जब समय होता है, तो ऊपरी हिस्सों के प्रोसेसर धीरे-धीरे अतिरिक्त काम करेंगे, क्योंकि इस तरह के प्रोसेसर पहले से ही भीड़ (बाधित) हो सकते हैं।

 /* * Api - Keyboard interrupt handler */ extern void ih_keyboard() { printf("[IH]: irq %u\n", 1); u_char status = asm_read_port(KEYBOARD_STATUS_PORT); if (status & 0x01) { char keycode = asm_read_port(KEYBOARD_DATA_PORT); if (keycode < 1) { goto end; } /* call low half (bottom) interrupt handler */ } end: asm_write_port(PIC1_CMD_PORT, 0x20); /* end of interrupt */ }

अब, जब हम कीबोर्ड की दबाते हैं, तो हर बार हम कर्नेल सिस्टम लॉग में संबंधित प्रविष्टि देखेंगे।

संदर्भ

अब, इस लेख के लिए वीडियो ट्यूटोरियल खोलें।
और समानांतर में गिट रिपॉजिटरी देखें (आपको एक सबक 5 शाखा की आवश्यकता है)

संदर्भ

1. जेम्स मोलॉय। अपना खुद का खिलौना यूनिक्स-क्लोन ओएस रोल करें।
2. दाँत। डॉस, विंडोज, यूनिक्स के लिए असेंबलर
3. कलाश्निकोव। असेंबलर आसान है!
4. ताननबाम। ऑपरेटिंग सिस्टम। कार्यान्वयन और विकास।
5. रॉबर्ट लव। लिनक्स कर्नेल विकास प्रक्रिया का विवरण।

एक अखंड यूनिक्स जैसा ओएस विकसित करना - जीडीटी और आईडीटी (5)

सामग्री की तालिका

रैखिक संबोधन

बाधा से निपटने

संदर्भ

संदर्भ

More articles: