👏 👩🏾‍🔧 🎣 ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 5. ओएस से BIOS तक पहुंचना 🥛 💐 👩🏼‍🍳

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

थोड़ा सा व्यवधान

एक रुकावट एक संकेत है जो एक घटना की घटना के प्रोसेसर को सूचित करता है। व्यवधानों को 2 समूहों में विभाजित किया जा सकता है:
• बाहरी व्यवधान - उपकरणों और अन्य प्रोसेसर द्वारा उत्पन्न;
• आंतरिक व्यवधान - किसी भी असाधारण स्थितियों (उदाहरण के लिए, 0 से विभाजन या अमान्य पते तक पहुंच) या निर्देश के अनुसार प्रोसेसर द्वारा उत्पन्न होते हैं।

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

बिजली चालू करने के बाद, प्रोसेसर रियल मोड के समान एक मोड में अपना ऑपरेशन शुरू करता है। एक प्रोसेसर को इनिशियलाइज़ करने का एक कदम BIOS कंट्रोल ट्रांसफर करना है। BIOS कुछ CPU रजिस्टरों को सेट करता है, रैम को इनिशियलाइज़ करता है, POST डिवाइसेस की जाँच करता है, बेसिक इक्विपमेंट इनिशियलाइज़ करता है, बूटलोडर को मेमोरी में कॉपी करता है और उस पर कंट्रोल ट्रांसफर करता है। BIOS चरणों में से एक बाधा हैंडलर तालिका को कॉन्फ़िगर करना है, जिसका पता IDTR में संग्रहीत है। यह आमतौर पर 0x0 है । वास्तविक प्रोसेसर मोड (रियल मोड) में, इंटरफेज टेबल में एक प्रविष्टि में एक sel: ऑफ़सेट जोड़ी होती है, जिसमें इंटरप्टलर का पता होता है। BIOS ऑपरेटिंग सिस्टम को हार्डवेयर के साथ निम्न-स्तरीय कार्य से बचाने के लिए अपने स्वयं के इंटरप्ट हैंडलर स्थापित करता है, जो मशीन से मशीन में भिन्न हो सकते हैं।

उपकरण के साथ काम करने के लिए BIOS एक इंटरफेस के रूप में कार्य करता है। उदाहरण के लिए, डिस्क्स से सेक्टर पढ़ने के लिए 0x13 इंटरप्ट का उपयोग किया जाता है, वीडियो मोड को कॉन्फ़िगर करने के लिए 0x10 इंटरप्ट का उपयोग किया जाता है। BIOS इंटरप्ट को कॉल करने के लिए, रियल मोड में चलने वाला प्रोग्राम असेंबलर इंट अनुदेश का उपयोग कर सकता है। उदाहरण के लिए, डिस्क से एक सेक्टर को पढ़ने के लिए, आपको सामान्य रजिस्टरों में मापदंडों के साथ int 0x13 निर्देश का उपयोग करने की आवश्यकता है।

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

संरक्षित मोड में, बाधा तालिका अलग दिखती है। आईडीटीआर रजिस्टर अभी भी इसे इंगित करता है, लेकिन इस तालिका में प्रविष्टि 3 संभावित प्रकारों में से एक का गेट डिस्क्रिप्टर है (इंटेल मैनुअल का पैराग्राफ 6.11 पढ़ें)। ऑपरेटिंग सिस्टम द्वारा इंटरप्ट टेबल को कॉन्फ़िगर किया जाना चाहिए, न कि BIOS को, इसलिए, संरक्षित मोड में BIOS इंटरप्ट का उपयोग करने का कोई तरीका नहीं है। उपकरणों के साथ सभी काम (एचडीडी, सीडी-रोम, वीडियो कार्ड ...) ऑपरेटिंग सिस्टम के कंधों पर पड़ता है जो इसके लिए ड्राइवर का उपयोग करता है। लॉन्ग मोड में, गेट डिस्क्रिप्टर के आकार के बराबर स्थिति बिल्कुल वैसी ही है।

संरक्षित मोड से BIOS को आमंत्रित करने के तरीके

ठीक है, अगर ओएस कर्नेल, जो संरक्षित मोड में काम करता है, तब भी डिस्क से कुछ पढ़ने की जरूरत है (उदाहरण के लिए, हार्ड डिस्क ड्राइवर) और ड्राइवर अभी तक लोड नहीं किया गया है? ऐसा करने के दो तरीके हैं।
1. VirtualMode86 कॉन्फ़िगर करें और संरक्षित मोड में BIOS कॉल करें।
2. RealMode पर जाएं, BIOS पर जाएं, संरक्षित मोड पर लौटें।

वर्चुअल मोड 86 ( वीएम 86) एक और प्रोसेसर ऑपरेटिंग मोड है जिसमें सेगमेंटिंग एड्रेसिंग वास्तविक मोड के समान है, लेकिन संरक्षित मोड का पेजिंग उसी समय काम करता है। हम दूसरी विधि का उपयोग करेंगे, चूंकि, इसी तरह की तकनीक का उपयोग करके, आप 64-बिट कोड से BIOS का उपयोग कर सकते हैं (जो कि लोंगमोड में चलता है, जो VM86 में संक्रमण का समर्थन नहीं करता है)। हम बाद के लिए डिस्क के साथ काम छोड़ देंगे, और अब हम BIOS का उपयोग करके रैम का आकार निर्धारित करते हैं।

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

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

हम दूसरी विधि से निपटते हैं

तो, हमारा लक्ष्य: e820 तालिकाओं के अनुसार रैम के आकार को निर्धारित करने के लिए, जो हमें BIOS इंटर इंट 0x15 का उपयोग करके मिलेगा। E820 टेबल एक भौतिक मेमोरी कार्ड है जो बताता है कि ऑपरेटिंग सिस्टम द्वारा उपयोग के लिए भौतिक मेमोरी की कौन सी रेंज उपलब्ध हैं। भौतिक मेमोरी के दुर्गम क्षेत्रों में, वीडियो कार्ड के मुख्य BIOS और BIOS, ACPI तालिकाओं को संग्रहीत किया जाता है, भौतिक मेमोरी की कुछ श्रेणियों को उपकरणों और उनके रजिस्टरों की स्मृति में मैप किया जाता है। यदि आप विंडोज 7 में संसाधन मॉनिटर शुरू करते हैं और "मेमोरी" टैब खोलते हैं, तो "आरक्षित उपकरण" में आरक्षित श्रेणियों द्वारा कवर की गई भौतिक मेमोरी की मात्रा शामिल है।

तालिका E820 से एक प्रविष्टि प्राप्त करने के लिए, निम्नलिखित मानों को रजिस्टरों को लिखा जाना चाहिए: EBX में, मान 0 है, EAX में मान 0xE820 है, ECX में बफर आकार (कम से कम 20 बाइट्स), EDX में मान 0x534d4150 है, ES: DI में आपको एक सूचक लिखने की आवश्यकता है। बफ़र। Int0x15 इंटरप्ट कहा जाता है के बाद, e820 टेबल से एक रिकॉर्ड बफर को लिखा जाएगा, और EBX में मूल्य 1 से बढ़ जाएगा। ईबीएक्स फिर से 0 हो जाने तक रुकावट को दोहराया जाना चाहिए, जिसका अर्थ है तालिका का अंत। उसके बाद, बफर में तालिका से सभी मान शामिल होंगे। सफल समापन पर, एफ़्लैग्स रजिस्टर में कैरी फ़्लैग को रीसेट किया जाएगा, और 'SMAP' मूल्य EAX को लिखा जाएगा। तालिका प्रविष्टि में निम्न प्रारूप है:

प्रकार "1" है यदि मेमोरी प्रबंधक द्वारा भौतिक मेमोरी का उपयोग किया जा सकता है, तो "मेमोरी" डिवाइस या BIOS, "3" या "4" के लिए आरक्षित है यदि मेमोरी का उपयोग एसीपीआई द्वारा किया जाता है। अन्य मान आरक्षित हैं; श्रेणियां ओवरलैप नहीं हैं। उदाहरण मेमोरी कार्ड:

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

कंप्यूटर को शुरू करने के बाद, सीपीयू रियलमोड मोड में चलता है, जिसमें BIOS ट्रांसफर को नियंत्रित करता है। उदाहरण के लिए, जैसा कि कोरबूट करता है, BIOS काम करने के लिए स्वतंत्र है, और संरक्षित मोड में जा सकता है। अपने काम को पूरा करने के बाद, BIOS मेमोरी में लोड होता है और बूट ऑर्डर के अनुसार उच्चतम प्राथमिकता वाले डिवाइस के पहले सेक्टर पर नियंत्रण स्थानांतरित करता है (कम से कम अगर यह एचडीडी है या डिवाइस को एचडीडी के रूप में अनुकरण किया जाता है)। आरएम में रहते हुए BIOS नियंत्रण स्थानांतरित करता है। हमारे मामले में, लोडिंग hdd के साथ होती है और पहला सेक्टर MBR है, जो GRUB पर नियंत्रण स्थानांतरित करता है। GRUB मुख्य रूप से PM में काम करता है, लेकिन यदि आवश्यक हो, तो उपकरण तक पहुंचें (उदाहरण के लिए, डिस्क से एक सेक्टर पढ़ें) आरएम पर जाता है और BIOS बाधित का उपयोग करता है। GRUB पीएम में हमारे कर्नेल पर नियंत्रण स्थानांतरित करता है। नीचे दिया गया आंकड़ा बूट के दौरान ऑपरेटिंग मोड के बीच सीपीयू संक्रमण के वर्णित अनुक्रम को दर्शाता है।

वार्तालाप जारी रखने और सीधे कोड पर जाने के लिए, आपको संरक्षित मोड के लिए थोड़ा सैद्धांतिक इंडेंटेशन बनाने की आवश्यकता है। विषय व्यापक और अच्छी तरह से कवर किया गया है, इसलिए केवल बाद में हम कोड में जो देखेंगे, उसका वर्णन यहां किया जाएगा। आरएम और पीएम के बीच मुख्य अंतर खंडित मेमोरी एड्रेसिंग के लिए तंत्र है। और खंड स्मृति को सामान्य रूप से संबोधित क्या है? आरएम मेमोरी को एक्सेस करने के लिए 20-बिट एड्रेस का उपयोग करता है, लेकिन उपलब्ध रजिस्टरों की लंबाई 16 बिट्स तक सीमित है (इस वजह से, कोड को 16-बिट कहा जाता है)। इसलिए, रजिस्टरों के जोड़े को संबोधित करने के लिए उपयोग किया जाता है, जिनमें से एक खंड का आधार होता है, और दूसरा ऑफसेट। ऑफसेट को जोड़कर रैखिक पता प्राप्त किया जाता है और 4. द्वारा बाईं ओर शिफ्ट किए गए सेगमेंट का आधार आरएम में सेगमेंट को नीचे दिए गए चित्र में दिखाया गया है।

ऑफसेट को किसी भी सामान्य प्रयोजन रजिस्टर में संग्रहीत किया जा सकता है। सेगमेंट बेस को निम्नलिखित रजिस्टरों में से एक में संग्रहीत किया जाता है: सीएस, डीएस, एसएस, ईएस, एफएस, जीएस। इन रजिस्टरों को चयनकर्ता कहा जाता है। सभी आदेशों के लिए, डिफ़ॉल्ट चयनकर्ताओं को परिभाषित किया गया है। PUSH, POP के लिए, यह SS (स्टैक सेगमेंट) है, JUMP के लिए, LOOP CS (कोड सेगमेंट) है, MOV के लिए DS (डेटा सेगमेंट) है।

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

• RPL (अनुरोधित विशेषाधिकार स्तर) - खंड सुरक्षा तंत्र में विशेषाधिकार स्तर को अलग करने के लिए उपयोग किया जाता है।
• TI - डिस्क्रिप्टर तालिका के प्रकार को इंगित करता है जिसमें वांछित डिस्क्रिप्टर स्थित है। 1 - एलडीटी (स्थानीय डिस्क्रिप्टिव टेबल), 0 - जीडीटी (ग्लोबल डिस्क्रिप्टर टेबल)।
• इंडेक्स - डिस्क्रिप्टर तालिका में डिस्क्रिप्टर का सूचकांक।

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

सेगमेंट डिस्क्रिप्टर सेगमेंट के प्रकार, आकार, विशेषाधिकार के स्तर को निर्धारित करने, पढ़ने, लिखने और निष्पादन के अधिकार और सेगमेंट के आधार को निर्धारित करता है। चलो वर्णनकर्ता संरचना का विश्लेषण करते हैं।
• बेस एड्रेस सेगमेंट के पहले बाइट का 32-बिट एड्रेस है, यह फील्ड 3 भागों में विभाजित है base_0_15, base_16_23, base_24_31।
• सेगमेंट लिमिट - बाइट्स में सेगमेंट साइज अगर झंडा G = 0 है, या 4Kb के ब्लॉक में अगर झंडा G = 1 है।
• जी (ग्रैन्युलैरिटी) - यदि झंडा सेट है, तो सेगमेंट लिमिट को 4Kb के ब्लॉक में मापा जाता है, अन्यथा बाइट्स में।
• एस (डिस्क्रिप्टर टाइप) - यदि झंडा सेट है, तो उपयोगकर्ता डिस्क्रिप्टर, अन्यथा सिस्टम। हमारे कोड में, सभी विवरणकर्ताओं के पास यह ध्वज सेट है।
• प्रकार - इस क्षेत्र की व्याख्या एस ध्वज पर निर्भर करती है। उपयोगकर्ता खंड के लिए, 2 मुख्य विकल्प संभव हैं: एक कोड खंड और एक डेटा खंड, यह क्षेत्र के उच्च बिट द्वारा निर्धारित किया जाता है। नीचे दी गई तालिका सभी संभावित संयोजनों को दिखाती है।

डेटा खंड के लिए निम्नलिखित बिट्स को परिभाषित किया गया है: ई (विस्तार-दिशा), (डब्ल्यू) राइट-इनेबल, (ए) एक्सेस। बिट (डब्ल्यू) आपको एक सेगमेंट में लिखने की अनुमति देता है, (ई) का उपयोग स्टैक सेगमेंट को गतिशील रूप से विस्तारित करने के लिए किया जाता है, (ए) डेटा और कोड सेगमेंट के लिए सामान्य बिट है, एक सेगमेंट तक पहुंचते समय 1 पर सेट किया जाता है, चाहे वह पढ़ रहा हो, लिख रहा हो या निष्पादित कर रहा हो। कोड सेगमेंट के मामले में, बिट (E) की व्याख्या © और (W) के रूप में की जाती है। इस सेगमेंट के कोड को दूसरे सेगमेंट में कॉल करने के दौरान बिट © कन्फर्मिंग, सिक्योरिटी चेक का हिस्सा रद्द कर देता है। ® पढ़ने में सक्षम बिट एक कोड खंड से पढ़ने में सक्षम बनाता है। आप संरक्षित मोड में कोड सेगमेंट को नहीं लिख सकते।

• L (64-बिट कोड सेगमेंट) - यदि सेगमेंट में 64-बिट कोड है तो सेट करें। ध्वज को कोड सेगमेंट के लिए केवल 1 पर सेट किया जा सकता है।
• एवीएल (उपलब्ध और आरक्षित बिट्स) - प्रोसेसर द्वारा उपयोग नहीं किया जाता है, ओएस का उपयोग किया जा सकता है।
• डी / बी (डिफ़ॉल्ट ऑपरेशन आकार) - उपयोगकर्ता कोड और डेटा खंडों की थोड़ी गहराई निर्धारित करता है। 16 बिट्स, यदि ध्वज 0 और 32 पर सेट है, यदि 1 (हाँ, हाँ, संरक्षित मोड में 16-बिट कोड भी होता है)।
• डीपीएल (वर्णनात्मक विशेषाधिकार स्तर) - खंड विशेषाधिकार स्तर को परिभाषित करता है। यह 0 से 3 तक मान ले सकता है, जहां 0 सबसे विशेषाधिकार प्राप्त है। एक सेगमेंट तक पहुंच को प्रतिबंधित करने के लिए उपयोग किया जाता है।

इंटेल सिस्टम प्रोग्रामिंग गाइड भाग 1 , अनुभाग 3.4.5 में वर्णनकर्ता संरचना के बारे में अधिक पढ़ें। वहां आप यह भी वर्णन कर सकते हैं कि खंडों तक पहुंच को उनके विशेषाधिकार स्तर के अनुसार कैसे व्यवस्थित किया जाता है। Habré पर इस विषय पर एक अच्छा अनुवाद है ।
याद करें कि हम सभी ने यह क्यों शुरू किया है - हमें सी कोड से BIOS इंटरप्ट का कारण बनने की आवश्यकता है। आपको ASM पर कोड से C से RM में कोड पर और फिर वापस जाना होगा। सी कोड 32-बिट पीएम में चलता है। संक्रमण योजना इस तरह दिखाई देगी:

अन्य बातों के अलावा, आपको सी कोड से आरएम तक कोड और आरएम में कोड से सी कोड में परिणाम पारित करने की आवश्यकता है।

! महत्वपूर्ण! लेख के पहले भाग से सभी 6 चरणों को सफलतापूर्वक पूरा करने के बाद ही सभी कार्यों को सफलतापूर्वक पूरा किया जा सकता है "ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं"!

तो हमारी योजना:
1. GRUB द्वारा कॉन्फ़िगर किए गए एक के बजाय अपनी GDT तालिका सेट करें।
2. C में BIOS तक पहुँचने के लिए एक आवरण लिखें।
3. कुछ सामान्य सुविधाएँ जोड़ें।
4. सभी को एक साथ मिलाकर चलाएं।

चलो शुरू हो जाओ!

चरण 1. प्रारंभिक जीडीटी

1. बिटविज़र प्रोजेक्ट में शामिल बिटविज़र -1.2 \ core \ desc.h फ़ाइल को फ़ोल्डर में शामिल करें। यहां कोड डाउनलोड किया जा सकता है । फ़ाइल में उपयोगकर्ता विवरणक की संरचना की घोषणा शामिल है।
2. निम्नलिखित सामग्रियों के साथ एक डिस्क्रिप्टर सी फ़ाइल जोड़ें:

#include "types.h" #include "desc.h" #include "string.h" static void SetSegDesc(struct segdesc *d, u32 limit, u32 base, enum segdesc_type type, enum segdesc_s s, unsigned int dpl, unsigned int p, unsigned int avl, enum segdesc_l l, enum segdesc_d_b d_b) { d->base_15_0 = base; d->base_23_16 = base >> 16; d->type = type; d->s = s; d->dpl = dpl; d->p = p; d->avl = avl; d->l = l; d->d_b = d_b; d->base_31_24 = base >> 24; if (limit <= 0xFFFFF) { d->g = 0; d->limit_15_0 = limit >> 0; d->limit_19_16 = limit >> 16; } else { d->g = 1; d->limit_15_0 = limit >> 12; d->limit_19_16 = limit >> 28; } } void SetupDescTables(struct segdesc *GDT_base) { // SEG_SEL_NULL memset(&GDT_base[0], 0, sizeof(GDT_base[0])); //  .  0 // SEG_SEL_CODE32 SetSegDesc(&GDT_base[1], 0xFFFFFFFF, 0x00000000, // 32    SEGDESC_TYPE_EXECREAD_CODE, //   0 SEGDESC_S_CODE_OR_DATA_SEGMENT, 0, 1, //  0  4G 0, SEGDESC_L_16_OR_32, SEGDESC_D_B_32); // SEG_SEL_DATA32 SetSegDesc(&GDT_base[2], 0xFFFFFFFF, 0x00000000, // 32    SEGDESC_TYPE_RDWR_DATA, //   0 SEGDESC_S_CODE_OR_DATA_SEGMENT, 0, 1, //  0  4G 0, SEGDESC_L_16_OR_32, SEGDESC_D_B_32); // SEG_SEL_CODE16 SetSegDesc(&GDT_base[3], 0x0000FFFF, 0x00000000, // 16    SEGDESC_TYPE_EXECREAD_CODE, //   0 SEGDESC_S_CODE_OR_DATA_SEGMENT, 0, 1, //  0  4G 0, SEGDESC_L_16_OR_32, SEGDESC_D_B_16); // SEG_SEL_DATA16 SetSegDesc(&GDT_base[4], 0x0000FFFF, 0x00000000, // 16    SEGDESC_TYPE_RDWR_DATA, //   0 SEGDESC_S_CODE_OR_DATA_SEGMENT, 0, 1, //  0  4G 0, SEGDESC_L_16_OR_32, SEGDESC_D_B_16); struct descreg gdtr; gdtr.base = (ulong)GDT_base; //     gdtr.limit = 5 * sizeof(*GDT_base) - 1; //     - 1 __asm__ volatile ("lgdt %0" // GCC-Inline-Assembly : : "m" (gdtr)); }

सी कोड ऑपरेशन के लिए, 2 उपयोगकर्ता खंड पर्याप्त हैं: 32-बिट कोड खंड और 32-बिट डेटा खंड। 16-बिट कोड में जाने के लिए, हमें दो अतिरिक्त सेगमेंट चाहिए: 16-बिट कोड और डेटा सेगमेंट। * GDT_base पते पर GDT तालिका पाँच डिस्क्रिप्टर के साथ SetupDescTables फ़ंक्शन बनाती है, जिनमें से पहला शून्य है, और शेष 4 ऊपर वर्णित सेगमेंट के अनुरूप हैं। सभी सेगमेंट में 0 का आधार और 4 जी की सीमा होती है। GDT में पहला डिस्क्रिप्टर हमेशा शून्य होना चाहिए। GDTR रजिस्टर, जो GDT की ओर इशारा करता है, को lgdt निर्देश के साथ आरंभ किया जाता है। निर्देश को आमंत्रित करने के लिए, विशिष्ट GCC सिंटैक्स के साथ कोडांतरक सम्मिलित किया जाता है। असेंबलर आवेषण में निम्न रूप की संरचना होती है:

 asm ( assembler template : output operands /* optional */ : input operands /* optional */ : list of clobbered registers /* optional */ );

उपयोग किया गया asm सम्मिलित निम्नलिखित कोड में बदल जाता है:

कड़ाई से बोलते हुए, जीडीटी तालिका का उपयोग करने के लिए, आपको सीएस, एसएस, डीएस रजिस्टरों में संबंधित चयनकर्ताओं के मूल्यों को लोड करने की आवश्यकता है। लेकिन इस स्तर पर यह इतना महत्वपूर्ण नहीं है।

3. एक कॉल को Setup.DescTables और कुछ घोषणाओं को kern.c में जोड़ें । परिणाम निम्नलिखित है:

 #include "printf.h" #include "screen.h" #include "types.h" #include "desc.h" #include "callrealmode.h" struct segdesc g_GDT[5]; void SetupDescTables(struct segdesc *GDT_base); void kmain(void) { clear_screen(); printf(" -- Kernel started! -- \n"); SetupDescTables(g_GDT); u64 ram_size = GetAvalibleRAMSize (); printf("ram_size = %llu(%lluMb)\n", ram_size, ram_size / 0x100000); }

GetAvalibleRAMSize () कॉल बाइट्स में RAM का आकार देता है।

चरण 2. कुछ सामान्य सुविधाएँ जोड़ें।

1. Bitvisor-1.2 \ core \ string.s फ़ाइल को आम फ़ोल्डर में जोड़ें, bitvisor-1.2 \ core \ longmode.h और bitvisor-1.2 \ BitVisor प्रोजेक्ट से शामिल फ़ोल्डर में \ core \ string.h फ़ाइलों को शामिल करें । इन फ़ाइलों में कई सामान्य-प्रयोजन के कार्यों का कार्यान्वयन होता है, जैसे कि मेम्स्की और मेमसेट। शामिल की गई सामग्री को निम्न प्रकार से प्रतिस्थापित किया जाना चाहिए:

 #ifndef _TYPES_H #define _TYPES_H #define NULL 0 typedef unsigned long size_t; typedef unsigned long ulong; typedef unsigned char u8; typedef unsigned short u16; typedef unsigned int u32; typedef unsigned long long u64; #endif

चरण 3. BIOS तक पहुंचना

1. SetupDescTables फ़ंक्शन में परिभाषित डिस्क्रिप्टर के लिए चयनकर्ता मानों को शामिल करने के लिए एक सेगमेंट फ़ाइल शामिल करें ।

 #ifndef _SEGMENT_H #define _SEGMENT_H #define SEG_SEL_NULL 0 #define SEG_SEL_CODE32 (1 * 8) // Index = 1, TI = 0, RPL = 0 #define SEG_SEL_DATA32 (2 * 8) // Index = 2, TI = 0, RPL = 0 #define SEG_SEL_CODE16 (3 * 8) // Index = 3, TI = 0, RPL = 0 #define SEG_SEL_DATA16 (4 * 8) // Index = 4, TI = 0, RPL = 0 #endif

और GetRamsize फ़ंक्शन के प्रोटोटाइप के साथ फ़ाइल callrealmode.h ।

 #ifndef _CALLREALMODE_H #define _CALLREALMODE_H #include "types.h" u64 GetAvalibleRAMSize(); #endif

2. निम्नलिखित सामग्री के साथ हमारे प्रोजेक्ट के मूल में callrealmode.c फ़ाइल जोड़ें:

 #include "printf.h" #include "types.h" #include "string.h" #include "segment.h" #include "callrealmode_asm.h" // interrupts and paging must be disabled static void callrealmode_Call(struct callrealmode_Data *p_param) { u16 sp16; u32 sp32; // copy 16 bit code and stack //   memcpy  16    //  callrealmode_start  callrealmode_end //   CALLREALMODE_OFFSET < 1Mb.   //    ,   RM     //   1Mb. memcpy ((u8*)CALLREALMODE_OFFSET, &callrealmode_start, &callrealmode_end - &callrealmode_start); //    ,     ,    . //     RM   ,     SP //     sp16 = CALLREALMODE_OFFSET - sizeof(*p_param); //   memcpy     memcpy ((void*)(u32)sp16, p_param, sizeof(*p_param)); __asm__ volatile ( "mov %%esp,%0\n" //   ESP   sp32 "mov %1,%%ds \n" //  16     "mov %1,%%es \n" //  DS, ES, FS, GS, SS "mov %1,%%fs \n" // "mov %1,%%gs \n" // "mov %1,%%ss \n" // "mov %2,%%esp\n" //   16     sp16 "pusha \n" //     "lcall %3,%4 \n" //  16     CS //     CALLREALMODE_OFFSET. //     CS  EIP, //     // lretl    32   "popa \n" //      "mov %5,%%ds \n" //  32     "mov %5,%%es \n" //  DS, ES, FS, GS, SS "mov %5,%%fs \n" // "mov %5,%%gs \n" // "mov %5,%%ss \n" // "mov %0,%%esp\n" //   32  ,  //     sp32 : "=&a" (sp32) // %0 – Input : "b" ((u32)SEG_SEL_DATA16) // %1 - Output , "c" ((u32)sp16) // %2 - Output , "i" ((u32)SEG_SEL_CODE16) // %3 - Output , "i" (CALLREALMODE_OFFSET) // %4 - Output , "d" ((u32)SEG_SEL_DATA32) // %5 - Output ); //      16    p_param memcpy (p_param, (void*)(u32)sp16, sizeof(*p_param)); } u64 GetAvalibleRAMSize() { struct callrealmode_Data param; // ,     //    RM,    u64 avalible_ram_sz = 0; param.func = CALLREALMODE_FUNC_GETSYSMEMMAP; param.getsysmemmap.next_num = 0; do { param.getsysmemmap.num = param.getsysmemmap.next_num; callrealmode_Call(¶m); // int 0x15,  EBX = param.getsysmemmap.num // EAX = 0xE820, EDX = 0x534d4150, ECX = 20 // ES:DI = ¶m.getsysmemmap.base //   EBX  // param.getsysmemmap.next_num = EBX //        SYSMEMMAP_TYPE_AVAILABLE if (SYSMEMMAP_TYPE_AVAILABLE == param.getsysmemmap.type) { avalible_ram_sz += param.getsysmemmap.len; } printf("n 0x%08X nn 0x%08X b 0x%08llX l 0x%08llX(%lldMb) t 0x%08X\n", param.getsysmemmap.num, param.getsysmemmap.next_num, param.getsysmemmap.base, param.getsysmemmap.len, param.getsysmemmap.len / 0x100000, param.getsysmemmap.type); } while (param.getsysmemmap.next_num); return avalible_ram_sz; }

हम सबसे दिलचस्प तक पहुँच गए! इस कोड में 2 कार्य हैं: GetRamsize और callrealmode_Call । GetRamsize फ़ंक्शन callrealmode_Call को कॉल करने के लिए एक callrealmode_Data परम संरचना बनाता है । Callrealmode_Call फ़ंक्शन सीधे 16-बिट असेंबलर कोड में जाता है। इसके आधार पर, आप अन्य कार्यों को लिख सकते हैं जो BIOS तक पहुंचते हैं, उदाहरण के लिए, डिस्क से एक सेक्टर को पढ़ने का कार्य। एकमात्र शर्त callrealmode_Data संरचना का उपयोग है।

GetRamsize फ़ंक्शन अपने तर्क में एक अंतर्वर्ती int0x15 के माध्यम से भौतिक मेमोरी कार्ड प्राप्त करने के लिए तंत्र को लागू करता है, बार-बार callrealmode_Call फ़ंक्शन (एनालॉग int0x15) को param.getsysmemmap.next_num (उर्फ EBX) तक शून्य हो जाता है। Callrealmode_Call फ़ंक्शन दो फ़्रेमयुक्त असेंबली कोड लेबल्स callrealmode_start और callrealmode_end का उपयोग करता है, जो सभी 16-बिट कोड को निम्न मेगाबाइट पर CALLREALMODE_OFFPET = 0x5000 पते पर कॉपी करता है । पते का चयन इसलिए किया जाता है ताकि नकल करते समय यह BIOS संरचनाओं को न भटके। फंक्शन में सबसे बड़ी दिलचस्पी असेम्बलर इंसर्ट की है, यह अच्छी तरह से टिप्पणी की गई है, इसलिए केवल यह दिखाएं कि यह संकलित रूप में क्या बदल गया:

3. इसमें शामिल फ़ोल्डर में callrealmode_asm.h फ़ाइल जोड़ें, फ़ाइल यहाँ ली जा सकती है , और callrealmode_asm.s फ़ाइल को स्रोत रूट में, जो यहाँ लिया जा सकता है । पहली फ़ाइल में callrealmode.c में प्रयुक्त संरचनाओं की परिभाषाएँ हैं। दूसरी फ़ाइल में 16-बिट असेंबलर कोड होता है, जिसमें आरएम को संक्रमण, BIOS कॉल, पीएम को वापसी और फिर सी कोड में प्रदर्शन किया जाता है। कोड पर विस्तार से टिप्पणी की जाती है और इसे समझा जा सकता है। यह ध्यान दिया जाना चाहिए कि पीएम और आरएम के बीच संक्रमण के लिए उपयोग की जाने वाली सुरक्षा_ऑफ और प्रोटेक्शन_ऑन प्रक्रियाएं बहुत सरल हैं। वे रजिस्टर के हिस्से के बारे में भूल जाते हैं, जैसे कि सीआर 3, कुछ एमएसआर, जिन मूल्यों को सहेजने और पुनर्स्थापित करने की आवश्यकता है, जैसा कि जीडीटीआर और आईडीटीआर के साथ होता है। इन फ़ंक्शंस का अधिक पूर्ण कार्यान्वयन बिटविज़र प्रोजेक्ट में पाया जा सकता है, अर्थात् फ़ाइल बिटविज़र-1.2 \ core \ callrealmode_asm.s में ।

चरण 4. हाल ही में सुधार और लॉन्च

1. मेकफाइल में बदलाव करें। की जगह

 OBJFILES = \ loader.o \ common/printf.o \ common/screen.o \ kernel.o

पर

 OBJFILES = \ loader.o \ common/printf.o \ common/screen.o \ common/string.o \ kernel.o \ callrealmode.o \ callrealmode_asm.o \ descriptor.o

और एक लाइन

 as -o $@ $<

पर

 as -I include -o $@ $<

2. परियोजना का पुनर्निर्माण:

 make rebuild sudo make image

3. "एम-एम" विकल्प के साथ चलाएँ, जो आपको रैम के आकार को स्पष्ट रूप से निर्दिष्ट करने की अनुमति देता है। आपको निम्न जैसा कुछ मिलना चाहिए:

 sudo qemu-system-i386 -hda hdd.img –m 123

कार्यक्रम सभी उपलब्ध मेमोरी रेंज को प्रिंट करता है। पिछले भागों की तरह, आप USB फ्लैश ड्राइव पर hdd.img छवि का dd बना सकते हैं और उसमें से बूट करके वास्तविक हार्डवेयर पर कोड की जांच कर सकते हैं।

आगे की योजना

नतीजतन, हमें एक तंत्र मिला जो सी में कोड से BIOS तक पहुंचने की अनुमति देता है। इसके अलावा, संरक्षित मोड के संचालन से संबंधित सैद्धांतिक भाग को छुआ गया था। भविष्य में, इस लेख का उपयोग FAT32 फाइल सिस्टम के साथ काम करने के लिए एक प्रारंभिक बिंदु के रूप में किया जा सकता है, लेकिन अगली बार उस पर अधिक!

श्रृंखला में निम्नलिखित लेख के लिए लिंक:
" ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 6. FAT फाइल सिस्टम के साथ डिस्क के साथ काम करने के लिए समर्थन "

ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 5. ओएस से BIOS तक पहुंचना