पहला भाग

पहले लेख के पास अभी तक ठंडा होने का समय नहीं था, लेकिन मैंने फैसला किया कि आप इसे पेचीदा न रखें और अगली कड़ी लिखें।

इसलिए, पिछले लेख में हमने कर्नेल फ़ाइल को लिंक करने, लोड करने और प्राथमिक आरंभ के बारे में बात की थी। मैंने कुछ उपयोगी लिंक दिए, बताया कि कैसे लोड किया गया कर्नेल मेमोरी में स्थित है, बूट समय पर आभासी और भौतिक पते की तुलना कैसे की जाती है, और पृष्ठ तंत्र के लिए समर्थन कैसे सक्षम किया जाए। अंत में, नियंत्रण मेरी कर्नेल के kmain फ़ंक्शन को पारित कर दिया, जिसे रस्ट में लिखा गया है। यह आगे बढ़ने और यह पता लगाने का समय है कि खरगोश छेद कितना गहरा है!

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

जंग सेटअप

सामान्य तौर पर, इस प्रक्रिया में कुछ भी जटिल नहीं है, विवरण के लिए आप फिलिप ब्लॉग से संपर्क कर सकते हैं। हालांकि, मैं कुछ बिंदुओं पर रुकूंगा।

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

rustup override add nightly-YYYY-MM-DD 

तंत्र के विवरण के लिए, कृपया यहां संपर्क करें ।

अगला, उस लक्ष्य प्लेटफ़ॉर्म को कॉन्फ़िगर करें जिसके लिए हम जा रहे हैं। मैं फिलिप ओपरमैन के ब्लॉग पर आधारित था, इसलिए इस खंड की कई चीजें उनसे ली गईं, हड्डियों से विमुख और मेरी जरूरतों के अनुकूल। फिलिप अपने ब्लॉग में x64 के लिए विकसित कर रहा है, मैंने मूल रूप से x32 चुना है, इसलिए मेरा लक्ष्य.जॉन थोड़ा अलग होगा। मैं इसे पूरी तरह से लाता हूं

 { "llvm-target": "i686-unknown-none", "data-layout": "em:ep:32:32-f64:32:64-f80:32-n8:16:32-S128", "arch": "x86", "target-endian": "little", "target-pointer-width": "32", "target-c-int-width": "32", "os": "none", "executables": true, "linker-flavor": "ld.lld", "linker": "rust-lld", "panic-strategy": "abort", "disable-redzone": true, "features": "-mmx,-sse,+soft-float" } 

यहां सबसे कठिन हिस्सा " डेटा-लेआउट " पैरामीटर है। LLVM प्रलेखन हमें बताता है कि ये "-" द्वारा अलग किए गए डेटा लेआउट विकल्प हैं। बहुत पहले "ई" चरित्र भारतीयता के लिए जिम्मेदार है - हमारे मामले में यह थोड़ा-सा है, जैसा कि मंच की आवश्यकता है। दूसरा चरित्र है, "विकृति"। लेआउट के दौरान चरित्र के नाम के लिए जिम्मेदार। चूंकि हमारा आउटपुट स्वरूप ELF होगा (निर्माण स्क्रिप्ट देखें), हम "m: e" का चयन करते हैं। तीसरा चरित्र बिट्स और एबीआई (एप्लिकेशन बाइनरी इंटरफ़ेस) में सूचक का आकार है। यहां सब कुछ सरल है, हमारे पास 32 बिट्स हैं, इसलिए हम साहसपूर्वक "पी: 32: 32" डालते हैं। इसके बाद फ्लोटिंग पॉइंट नंबर हैं। हम रिपोर्ट कर रहे हैं कि हम एलाइन 32 के अनुसार 64-बिट संख्या को संरेखण 64 के साथ समर्थन करते हैं - "f64: 32: 64", साथ ही साथ डिफ़ॉल्ट रूप से संरेखण के साथ 80-बिट संख्या - "f80: 32"। अगला तत्व पूर्णांक है। हम 8 बिट्स के साथ शुरू करते हैं और प्लेटफ़ॉर्म की अधिकतम 32 बिट्स पर जाते हैं - "n8: 16: 32"। अंतिम स्टैक संरेखण है। मुझे 128 बिट पूर्णांक की भी आवश्यकता है, इसलिए इसे S128 होने दें। किसी भी मामले में, एलएलवीएम इस पैरामीटर को सुरक्षित रूप से अनदेखा कर सकता है, यह हमारी प्राथमिकता है।

शेष मापदंडों के बारे में, आप फिलिप को देख सकते हैं, वह सब कुछ अच्छी तरह से समझाता है।

हमें कार्गो-एक्सबिल्ट की भी आवश्यकता है - एक उपकरण जो आपको अपरिचित लक्ष्य मंच के तहत निर्माण करते समय जंग-कोर को पार करने की अनुमति देता है।
निर्धारित करें।

 cargo install cargo-xbuild 

हम इसे इस तरह एकत्रित करेंगे।

 cargo xbuild -Z unstable-options --manifest-path=kernel/Cargo.toml --target kernel/targets/$(ARCH).json --out-dir=build/lib 

मुझे मेक के सही संचालन के लिए एक मैनिफ़ेस्ट की आवश्यकता थी, क्योंकि यह रूट डायरेक्टरी से शुरू होता है, और कर्नेल कर्नेल डायरेक्टरी में निहित होता है।

मैनिफ़ेस्ट की सुविधाओं में, मैं केवल टोकरा-प्रकार = ["स्टेटलिब"] को उजागर कर सकता हूं, जो आउटपुट के लिए एक लिंक करने योग्य फ़ाइल देता है। हम उसे एलएलडी में खिलाएंगे।

kmain और प्रारंभिक सेटअप

रस्ट सम्मेलनों के अनुसार, यदि हम एक स्थिर पुस्तकालय (या "फ्लैट" बाइनरी फ़ाइल) बनाते हैं, तो टोकरे की जड़ में फ़ाइल lib.rs होनी चाहिए, जो कि प्रवेश बिंदु है। इसमें, विशेषताओं की मदद से, भाषा की विशेषताओं को कॉन्फ़िगर किया गया है, और साथ ही क़ीमती kmain स्थित है।

तो, पहले चरण में हमें एसटीडी लाइब्रेरी को निष्क्रिय करना होगा। यह एक मैक्रो के साथ किया जाता है।

 #![no_std] 

इस तरह के एक सरल कदम के साथ, हम तुरंत मानक पुस्तकालय के मल्टीथ्रेडिंग, गतिशील मेमोरी और अन्य प्रसन्नता के बारे में भूल जाते हैं। इसके अलावा, हम खुद को प्रिंटलाइन से भी वंचित करते हैं!, मैक्रो, इसलिए हमें इसे स्वयं लागू करना होगा। मैं आपको बताता हूँ कि अगली बार कैसे करना है।

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

 #![no_std] #[macro_use] pub mod debug; #[cfg(target_arch = "x86")] #[path = "arch/i686/mod.rs"] pub mod arch; #[no_mangle] extern "C" fn kmain(pd: usize, mb_pointer: usize, mb_magic: usize) { arch::arch_init(pd); ...... } #[panic_handler] fn panic(_info: &PanicInfo) -> ! { println!("{}", _info); loop {} } 

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

मैंने पूरी तरह से प्राइमरी पैनिक हैंडलर घोषित किया, जिसे रस्ट की आवश्यकता है। फिर इसे संशोधित करना संभव होगा।

kmain तीन तर्कों को स्वीकार करता है और इसे C नोटेशन में नाम विरूपण के बिना भी निर्यात किया जाता है ताकि लिंकर फ़ंक्शन को सही ढंग से _loader से कॉल के साथ जोड़ सके, जिसे मैंने पिछले लेख में वर्णित किया था। पहला तर्क PD पृष्ठ तालिका का पता है, दूसरा GRUB संरचना का भौतिक पता है, जहां से हमें मेमोरी कार्ड मिलेगा, तीसरा मैजिक नंबर है। भविष्य में, मैं मल्टीबूट 2 समर्थन और अपने स्वयं के बूटलोडर दोनों को लागू करना चाहूंगा, इसलिए मैं बूट विधि की पहचान करने के लिए एक मैजिक नंबर का उपयोग करता हूं।

पहला kmain कॉल प्लेटफॉर्म-विशिष्ट इनिशियलाइज़ेशन है। हम अंदर जाते हैं। Arch_init फ़ंक्शन फ़ाइल आर्क / i686 / mod.rs में स्थित है, सार्वजनिक है, 32-बिट x86- विशिष्ट है, और इस तरह दिखता है:

 pub fn arch_init(pd: usize) { unsafe { vga::VGA_WRITER.lock().init(); gdt::setup_gdt(); idt::init_idt(); paging::setup_pd(pd); } } 

जैसा कि आप देख सकते हैं, x86 के लिए, आउटपुट, सेगमेंटेशन, इंटरप्ट, और पेजिंग को क्रम में प्रारंभ किया गया है। शुरुआत करते हैं वीजीए से।

वीजीए आरंभीकरण

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

 use lazy_static::lazy_static; use spin::Mutex; lazy_static! { pub static ref VGA_WRITER : Mutex<Writer> = Mutex::new(Writer { cursor_position: 0, vga_color: ColorCode::new(Color::LightGray, Color::Black), buffer: unsafe { &mut *(0xC00B8000 as *mut VgaBuffer) } }); } 

जैसा कि आप जानते हैं, स्क्रीन बफर भौतिक पते 0xB8000 पर स्थित है और इसका आकार 80x25x2 बाइट्स (स्क्रीन की चौड़ाई और ऊंचाई, प्रति चरित्र बाइट और विशेषताएँ: रंग, झिलमिलाहट) है। चूंकि हमने पहले से ही वर्चुअल मेमोरी को सक्षम कर लिया है, इसलिए इस पते तक पहुंच क्रैश हो जाएगी, इसलिए हम 3 जीबी जोड़ते हैं। हम एक कच्चे सूचक को भी रोकते हैं, जो असुरक्षित है - लेकिन हम जानते हैं कि हम क्या कर रहे हैं।
इस फ़ाइल में दिलचस्प चीजों में से, शायद, केवल राइटर संरचना का कार्यान्वयन है, जो न केवल एक पंक्ति में पात्रों को प्रदर्शित करने की अनुमति देता है, बल्कि स्क्रॉल करने, स्क्रीन पर किसी भी स्थान पर जाने और अन्य सुखद ट्रिफ़ल के लिए भी अनुमति देता है।

 pub struct Writer { cursor_position: usize, vga_color: ColorCode, buffer: &'static mut VgaBuffer, } impl Writer { pub fn init(&mut self) { let vga_color = self.vga_color; for y in 0..(VGA_HEIGHT - 1) { for x in 0..VGA_WIDTH { self.buffer.chars[y * VGA_WIDTH + x] = ScreenChar { ascii_character: b' ', color_code: vga_color, } } } self.set_cursor_abs(0); } fn set_cursor_abs(&mut self, position: usize) { unsafe { outb(0x3D4, 0x0F); outb(0x3D5, (position & 0xFF) as u8); outb(0x3D4, 0x0E); outb(0x3D4, ((position >> 8) & 0xFF) as u8); } self.cursor_position = position; } pub fn set_cursor(&mut self, x: usize, y: usize) { self.set_cursor_abs(y * VGA_WIDTH + x); } pub fn move_cursor(&mut self, offset: usize) { self.cursor_position = self.cursor_position + offset; self.set_cursor_abs(self.cursor_position); } pub fn get_x(&mut self) -> u8 { (self.cursor_position % VGA_WIDTH) as u8 } pub fn get_y(&mut self) -> u8 { (self.cursor_position / VGA_WIDTH) as u8 } pub fn scroll(&mut self) { for y in 0..(VGA_HEIGHT - 1) { for x in 0..VGA_WIDTH { self.buffer.chars[y * VGA_WIDTH + x] = self.buffer.chars[(y + 1) * VGA_WIDTH + x] } } for x in 0..VGA_WIDTH { let color_code = self.vga_color; self.buffer.chars[(VGA_HEIGHT - 1) * VGA_WIDTH + x] = ScreenChar { ascii_character: b' ', color_code } } } pub fn ln(&mut self) { let next_line = self.get_y() as usize + 1; if next_line >= VGA_HEIGHT { self.scroll(); self.set_cursor(0, VGA_HEIGHT - 1); } else { self.set_cursor(0, next_line) } } pub fn write_byte_at_xy(&mut self, byte: u8, color: ColorCode, x: usize, y: usize) { self.buffer.chars[y * VGA_WIDTH + x] = ScreenChar { ascii_character: byte, color_code: color } } pub fn write_byte_at_pos(&mut self, byte: u8, color: ColorCode, position: usize) { self.buffer.chars[position] = ScreenChar { ascii_character: byte, color_code: color } } pub fn write_byte(&mut self, byte: u8) { if self.cursor_position >= VGA_WIDTH * VGA_HEIGHT { self.scroll(); self.set_cursor(0, VGA_HEIGHT - 1); } self.write_byte_at_pos(byte, self.vga_color, self.cursor_position); self.move_cursor(1); } pub fn write_string(&mut self, s: &str) { for byte in s.bytes() { match byte { 0x20...0xFF => self.write_byte(byte), b'\n' => self.ln(), _ => self.write_byte(0xfe), } } } } 

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

• पूर्ण कर्सर ऑफसेट, समन्वय नहीं, प्रदर्शित होता है।
• आप एक बार में एक बाइट कंट्रोलर को आउटपुट कर सकते हैं
• एक बाइट का आउटपुट दो कमांड में होता है - पहले हम कंट्रोलर को कमांड लिखते हैं, फिर डेटा को।
• कमांड के लिए पोर्ट 0x3D4 है, डेटा पोर्ट 0x3D5 है
• सबसे पहले, 0x0F कमांड के साथ स्थिति के निचले बाइट को प्रिंट करें, फिर कमांड 0x0E के साथ शीर्ष

 global writeb global writew global writed section .text writeb: push ebp mov ebp, esp mov edx, [ebp + 8] ;port in stack: 8 = 4 (push ebp) + 4 (parameter port length is 2 bytes but stack aligned 4 bytes) mov eax, [ebp + 8 + 4] ;value in stack - 8 = see ^, 4 = 1 byte value aligned 4 bytes out dx, al ;write byte by port number an dx - value in al mov esp, ebp pop ebp ret writew: push ebp mov ebp, esp mov edx, [ebp + 8] ;port in stack: 8 = 4 (push ebp) + 4 (parameter port length is 2 bytes but stack aligned 4 bytes) mov eax, [ebp + 8 + 4] ;value in stack - 8 = see ^, 4 = 1 word value aligned 4 bytes out dx, ax ;write word by port number an dx - value in ax mov esp, ebp pop ebp ret writed: push ebp mov ebp, esp mov edx, [ebp + 8] ;port in stack: 8 = 4 (push ebp) + 4 (parameter port length is 2 bytes but stack aligned 4 bytes) mov eax, [ebp + 8 + 4] ;value in stack - 8 = see ^, 4 = 1 double word value aligned 4 bytes out dx, eax ;write double word by port number an dx - value in eax mov esp, ebp pop ebp ret 

सेगमेंट सेटअप

हम सबसे अधिक हैरान थे, लेकिन एक ही समय में सबसे सरल विषय। जैसा कि मैंने पिछले लेख में कहा था, स्मृति में पृष्ठ और खंड संगठन को मेरे सिर में मिलाया गया था, मैंने पृष्ठ तालिका का पता GDTR में लोड किया और मेरा सिर पकड़ लिया। सामग्री को पर्याप्त रूप से पढ़ने, उसे पचाने और उसे महसूस करने में सक्षम होने में मुझे कई महीने लग गए। मैं पीटर एबेल की पाठ्यपुस्तक असेंबलर का शिकार हो सकता हूं। आईबीएम पीसी के लिए भाषा और प्रोग्रामिंग "(एक महान पुस्तक!), जो इंटेल 8086 के लिए विभाजन का वर्णन करता है। उन सुखद समय में, हमने बीस-बिट पते के ऊपरी 16 बिट्स को सेगमेंट रजिस्टर में लोड किया, और यह मेमोरी में पता था। यह एक क्रूर निराशा थी जो संरक्षित मोड में i286 से शुरू हुई, सब कुछ पूरी तरह से गलत है।

तो, नंगे सिद्धांत यह है कि x86 एक खंडित स्मृति मॉडल का समर्थन करता है, क्योंकि पुराने प्रोग्राम केवल 640 KB से आगे निकल सकते हैं, और फिर 1 एमबी मेमोरी।

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

पता अनुवाद के बारे में फिर से करते हैं (उम्मीद है कि आखिरी में)
लाइन का पता [0x08: 0xFFFFFFFF] -> सेगमेंट की अनुमतियों को सत्यापित करें 0x08 -> वर्चुअल एड्रेस [0xFFFFFFFFFF] -> पेज टेबल + टीएलबी -> भौतिक पता [0xAAAAFFFF]

एक खंड का उपयोग केवल प्रोसेसर के अंदर किया जाता है, इसे एक विशेष खंड रजिस्टर (सीएस, एसएस, डीएस, ईएस, एफएस, जीएस) में संग्रहीत किया जाता है और विशेष रूप से कोड को निष्पादित करने और नियंत्रण स्थानांतरित करने के अधिकारों के लिए उपयोग किया जाता है। यही कारण है कि आप कर्नेल फ़ंक्शन को उपयोगकर्ता स्थान से सिर्फ ले और कॉल नहीं कर सकते। 0x18 के डिस्क्रिप्टर के साथ एक सेगमेंट (मेरे पास एक है, आपके पास एक अलग है) के स्तर 3 के अधिकार हैं, और 0x08 के डिस्क्रिप्टर के साथ एक सेगमेंट के स्तर 0. के अधिकार हैं। x86 सम्मेलन के अनुसार, अनधिकृत पहुंच की सुरक्षा के लिए, कम विशेषाधिकार वाले एक सेगमेंट को सीधे बड़े खंड के साथ एक सेगमेंट नहीं कहा जा सकता है। jmp 0x08 के माध्यम से अधिकार: [EAX], लेकिन अन्य तंत्रों, जैसे जाल, फाटक, व्यवधान का उपयोग करने के लिए बाध्य है।

सेगमेंट और उनके प्रकार (कोड, डेटा, लैडर, गेट्स) को GDT ग्लोबल डिस्क्रिप्टर टेबल, वर्चुअल एड्रेस और जिसका आकार GDTR रजिस्टर में लोड किया गया है, में वर्णित किया जाना चाहिए। सेगमेंट के बीच स्विच करते समय (सादगी के लिए, मेरा मानना ​​है कि एक सीधा संक्रमण संभव है), आपको jmp को 0x08: [EAX] निर्देश को कॉल करना होगा, जहां 0x08 तालिका की शुरुआत से बाइट्स में पहले मान्य डिस्क्रिप्टर की ऑफसेट है , और EAX ट्रांस्फ़ॉर्म एड्रेस वाला रजिस्टर है। ऑफ़सेट (चयनकर्ता) को CS रजिस्टर में लोड किया जाएगा, और संबंधित डिस्क्रिप्टर को प्रोसेसर के छाया रजिस्टर में लोड किया जाएगा। प्रत्येक विवरणक एक 8-बाइट संरचना है। यह अच्छी तरह से प्रलेखित है और इसका विवरण OSDev और Intel दस्तावेज़ीकरण दोनों में पाया जा सकता है (पहला लेख देखें)।

मैं संक्षेप में बताता हूं। जब हम GDT को इनिशियलाइज़ करते हैं और jmp 0x08 को निष्पादित करते हैं: [EAX] संक्रमण, प्रोसेसर की स्थिति इस प्रकार होगी:

• GDTR में वर्चुअल GDT एड्रेस होता है
• CS में मान 0x08 है
• पते पर एक हैंडल [GDTR + 0x08] को मेमोरी से छाया रजिस्टर सीएस पर कॉपी किया गया था
• EIP रजिस्टर में EAX रजिस्टर से पता होता है

शून्य डिस्क्रिप्टर को हमेशा एकतरफा होना चाहिए और उस तक पहुंच निषिद्ध है। जब हम मल्टीथ्रेडिंग पर चर्चा करते हैं तो मैं टीएसएस डिस्क्रिप्टर और इसके अर्थ पर अधिक विस्तार से ध्यान दूंगा। मेरी GDT तालिका अब इस तरह दिखती है:

 extern { fn load_gdt(base: *const GdtEntry, limit: u16); } pub unsafe fn setup_gdt() { GDT[5].set_offset((&super::tss::TSS) as *const _ as u32); GDT[5].set_limit(core::mem::size_of::<super::tss::Tss>() as u32); let gdt_ptr: *const GdtEntry = GDT.as_ptr(); let limit = (GDT.len() * core::mem::size_of::<GdtEntry>() - 1) as u16; load_gdt(gdt_ptr, limit); } static mut GDT: [GdtEntry; 7] = [ //null descriptor - cannot access GdtEntry::new(0, 0, 0, 0), //kernel code GdtEntry::new(0, 0xFFFFFFFF, GDT_A_PRESENT | GDT_A_RING_0 | GDT_A_SYSTEM | GDT_A_EXECUTABLE | GDT_A_PRIVILEGE, GDT_F_PAGE_SIZE | GDT_F_PROTECTED_MODE), //kernel data GdtEntry::new(0, 0xFFFFFFFF, GDT_A_PRESENT | GDT_A_RING_0 | GDT_A_SYSTEM | GDT_A_PRIVILEGE, GDT_F_PAGE_SIZE | GDT_F_PROTECTED_MODE), //user code GdtEntry::new(0, 0xFFFFFFFF, GDT_A_PRESENT | GDT_A_RING_3 | GDT_A_SYSTEM | GDT_A_EXECUTABLE | GDT_A_PRIVILEGE, GDT_F_PAGE_SIZE | GDT_F_PROTECTED_MODE), //user data GdtEntry::new(0, 0xFFFFFFFF, GDT_A_PRESENT | GDT_A_RING_3 | GDT_A_SYSTEM | GDT_A_PRIVILEGE, GDT_F_PAGE_SIZE | GDT_F_PROTECTED_MODE), //TSS - for interrupt handling in multithreading GdtEntry::new(0, 0, GDT_A_PRESENT | GDT_A_RING_3 | GDT_A_TSS_AVAIL, 0), GdtEntry::new(0, 0, 0, 0), ]; 

और यहाँ इनिशियलाइज़ेशन है, जिसके बारे में मैंने बहुत ऊपर बात की है। जीडीटी पता और आकार लोडिंग एक अलग संरचना के माध्यम से किया जाता है, जिसमें केवल दो फ़ील्ड होते हैं। इस संरचना का पता lgdt कमांड को दिया गया है। डेटा खंड रजिस्टर में, 0x10 की ऑफसेट के साथ निम्नलिखित विवरणक लोड करें।

 global load_gdt section .text gdtr dw 0 ; For limit storage dd 0 ; For base storage load_gdt: mov eax, [esp + 4] mov [gdtr + 2], eax mov ax, [esp + 8] mov [gdtr], ax lgdt [gdtr] jmp 0x08:.reload_CS .reload_CS: mov ax, 0x10 ; 0x10 points at the new data selector mov ds, ax mov es, ax mov fs, ax mov gs, ax mov ss, ax mov ax, 0x28 ltr ax ret 

फिर सब कुछ थोड़ा आसान होगा, लेकिन कोई कम दिलचस्प नहीं।

बीच में आता है

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

कोड शैली के बारे में गीतात्मक विषयांतर।

समुदाय और विशेष रूप से फिलिप ओपरमैन के प्रयासों के लिए धन्यवाद, एक्स 86-बाधित कॉलिंग सम्मेलन को रुस्ट में जोड़ा गया है, जो आपको iret को निष्पादित करने वाले रुकावट संचालकों को लिखने की अनुमति देता है। हालाँकि, मैंने सचेत रूप से इस मार्ग पर नहीं जाने का फैसला किया, क्योंकि मैंने असेंबलर और रस्ट को अलग-अलग फाइलों में अलग करने का फैसला किया था, और इसलिए यह कार्य करता है। हां, मैं अनुचित रूप से स्टैक मेमोरी का उपयोग कर रहा हूं, मुझे इसकी जानकारी नहीं है, लेकिन यह अभी भी स्वादिष्ट है। मेरे इंटरप्ट हैंडलर को असेम्बलर में लिखा जाता है और ठीक एक काम करते हैं: वे रुस्ट में लिखे लगभग एक ही बीच के हैंडलर को कहते हैं। कृपया इस तथ्य को स्वीकार करें और भोगवादी बनें।

सामान्य तौर पर, इंटरप्ट को इनिशियलाइज़ करने की प्रक्रिया GDT को इनिशियलाइज़ करने के समान है, लेकिन समझने में आसान है। दूसरी ओर, आपको एक समान कोड की आवश्यकता है। Redox OS के डेवलपर्स भाषा के सभी आयामों का उपयोग करते हुए, एक सुंदर निर्णय लेते हैं, लेकिन मैं "माथे पर" गया और कोड दोहराव की अनुमति देने का फैसला किया।

X86 सम्मेलन के अनुसार, हमारे पास रुकावटें हैं, लेकिन असाधारण स्थितियां हैं। इस संदर्भ में, हमारे लिए सेटिंग्स व्यावहारिक रूप से समान हैं। अंतर केवल इतना है कि जब कोई अपवाद फेंका जाता है, तो स्टैक में अतिरिक्त जानकारी हो सकती है। उदाहरण के लिए, मैं एक गुच्छा के साथ काम करते समय एक पृष्ठ की कमी को संभालने के लिए इसका उपयोग करता हूं (लेकिन हर चीज का अपना समय होता है)। इंटरप्ट और अपवाद दोनों को एक ही तालिका से संसाधित किया जाता है, जिसे आपको और मुझे भरने की आवश्यकता है। यह भी PIC (प्रोग्रामेबल इंटरप्ट कंट्रोलर) प्रोग्राम करने के लिए आवश्यक है। एपीआईसी भी है, लेकिन मैंने अभी तक इसका पता नहीं लगाया है।

PIC के साथ काम करने पर मैं बहुत सारी टिप्पणियां नहीं दूंगा, क्योंकि इसके साथ काम करने के नेटवर्क पर कई उदाहरण हैं। मैं कोडांतरक में हैंडलर के साथ शुरू करूँगा। वे सभी पूरी तरह से समान हैं, इसलिए मैं स्पॉइलर के लिए कोड निकाल दूंगा।

 global irq0 global irq1 ...... global irq14 global irq15 extern kirq0 extern kirq1 ...... extern kirq14 extern kirq15 section .text irq0: pusha call kirq0 popa iret irq1: pusha call kirq1 popa iret ...... irq14: pusha call kirq14 popa iret irq15: pusha call kirq15 popa iret 

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

 global e0_zero_divide global e1_debug ...... global eE_page_fault ...... global e14_virtualization global e1E_security extern k0_zero_divide extern k1_debug ...... extern kE_page_fault ...... extern k14_virtualization extern k1E_security section .text e0_zero_divide: pushad call k0_zero_divide popad iret e1_debug: pushad call k1_debug popad iret ...... eE_page_fault: pushad mov eax, [esp + 32] push eax mov eax, cr2 push eax call kE_page_fault pop eax pop eax popad add esp, 4 iret ...... e14_virtualization: pushad call k14_virtualization popad iret e1E_security: pushad call k1E_security popad iret 

हम कोडांतरक संचालकों की घोषणा करते हैं:

 extern { fn load_idt(base: *const IdtEntry, limit: u16); fn e0_zero_divide(); fn e1_debug(); ...... fn e14_virtualization(); fn e1E_security(); fn irq0(); fn irq1(); ...... fn irq14(); fn irq15(); } 

हम जंग हैंडलर्स को परिभाषित करते हैं जिसे हम ऊपर कहते हैं। कृपया ध्यान दें कि कीबोर्ड को बाधित करने के लिए, मैं बस प्राप्त कोड प्रदर्शित करता हूं, जो मुझे पोर्ट 0x60 से मिलता है - यह है कि कीबोर्ड सबसे सरल मोड में काम करता है। भविष्य में, यह एक पूर्ण चालक में बदल जाता है, मुझे आशा है। प्रत्येक बाधा के बाद, आपको 0x20 प्रसंस्करण के अंत के सिग्नल को आउटपुट करने की आवश्यकता है, यह महत्वपूर्ण है! अन्यथा, आपको अधिक अंतराल नहीं मिलेगा।

 #[no_mangle] pub unsafe extern fn kirq0() { // println!("IRQ 0"); outb(0x20, 0x20); } #[no_mangle] pub unsafe extern fn kirq1() { let ch: char = inb(0x60) as char; crate::arch::vga::VGA_WRITER.force_unlock(); println!("IRQ 1 {}", ch); outb(0x20, 0x20); } #[no_mangle] pub unsafe extern fn kirq2() { println!("IRQ 2"); outb(0x20, 0x20); } ... 

आईडीटी और पीआईसी की शुरुआत। PIC और इसके रीमैपिंग के बारे में, मुझे विस्तार की अलग-अलग डिग्री के ट्यूटोरियल की एक बड़ी संख्या मिली, जो OSDev से शुरू हुई और शौकिया साइटों के साथ समाप्त हुई। चूंकि प्रोग्रामिंग प्रक्रिया संचालन और निरंतर कमांड के निरंतर अनुक्रम के साथ चलती है, इसलिए मैं इस कोड को और स्पष्टीकरण के बिना दे दूंगा। , 0x20-0x2F , 0x20 0x28, 16 IDT.

 unsafe fn setup_pic(pic1: u8, pic2: u8) { // Start initialization outb(PIC1, 0x11); outb(PIC2, 0x11); // Set offsets outb(PIC1 + 1, pic1); /* remap */ outb(PIC2 + 1, pic2); /* pics */ // Set up cascade outb(PIC1 + 1, 4); /* IRQ2 -> connection to slave */ outb(PIC2 + 1, 2); // Set up interrupt mode (1 is 8086/88 mode, 2 is auto EOI) outb(PIC1 + 1, 1); outb(PIC2 + 1, 1); // Unmask interrupts outb(PIC1 + 1, 0); outb(PIC2 + 1, 0); // Ack waiting outb(PIC1, 0x20); outb(PIC2, 0x20); } pub unsafe fn init_idt() { IDT[0x0].set_func(e0_zero_divide); IDT[0x1].set_func(e1_debug); ...... IDT[0x14].set_func(e14_virtualization); IDT[0x1E].set_func(e1E_security); IDT[0x20].set_func(irq0); IDT[0x21].set_func(irq1); ...... IDT[0x2E].set_func(irq14); IDT[0x2F].set_func(irq15); setup_pic(0x20, 0x28); let idt_ptr: *const IdtEntry = IDT.as_ptr(); let limit = (IDT.len() * core::mem::size_of::<IdtEntry>() - 1) as u16; load_idt(idt_ptr, limit); } 

IDTR GDTR — . STI — — , , ASCII- -.

 global load_idt section .text idtr dw 0 ; For limit storage dd 0 ; For base storage load_idt: mov eax, [esp + 4] mov [idtr + 2], eax mov ax, [esp + 8] mov [idtr], ax lidt [idtr] sti ret 

अंतभाषण

, , . setup_pd, . , , , .

- GitLab .

आपका ध्यान के लिए धन्यवाद!

UPD: 3