🧖🏻 🍗 🔕 अपना बूटलोडर लिखना 👑 🦐 🙏🏽

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

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

बूट लोडर क्या है?

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

गहरा गोता लगाने के लिए तैयार हो जाओ

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

तो आपको किस भाषा को बूट लोडर लिखने के लिए जानना आवश्यक है

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

यह लेख मुख्य रूप से C ++ भाषा का उपयोग करेगा। लेकिन अगर आप सी जानते हैं, तो आपके लिए आवश्यक सी ++ तत्वों को सीखना आसान होगा। सामान्य तौर पर, सी भाषा का ज्ञान भी पर्याप्त होगा, लेकिन फिर आपको उदाहरणों के स्रोत कोड को बदलना होगा।

यदि आप जावा या सी # जानते हैं, तो दुर्भाग्य से यह हमारे कार्य के लिए मदद नहीं करेगा। तथ्य यह है कि संकलन के बाद उत्पन्न होने वाला जावा और सी # कोड मध्यवर्ती है। एक विशेष वर्चुअल मशीन का उपयोग आगे की प्रक्रिया के लिए किया जाता है (प्रोसेसर के लिए निर्देशों में मध्यवर्ती कोड को परिवर्तित करने के लिए जावा मशीन और सी # के लिए .NET)। रूपांतरण के बाद, यह प्रदर्शन किया जा सकता है। ऐसी वास्तुकला मिश्रित कोड तकनीक का उपयोग करना असंभव बना देती है - लेकिन हम इसका उपयोग अपने जीवन को आसान बनाने के लिए करेंगे, इसलिए जावा और सी # यहां मदद नहीं करेगा।

और इसलिए, एक साधारण लोडर विकसित करने के लिए, आपको सी या सी ++ पता होना चाहिए, और यह भी अच्छा होगा यदि आप थोड़ा असेंबलर जानते हैं।

आपको किस कंपाइलर की जरूरत है

मिश्रित कोड तकनीक का उपयोग करने के लिए, आपको कम से कम दो संकलक चाहिए: कोडांतरक के लिए और C / C ++ के लिए, साथ ही एक लिंकर जो ऑब्जेक्ट फ़ाइलों (.obj) को एक निष्पादन योग्य फ़ाइल में जोड़ता है।

अब, कुछ विशेष बिंदुओं के बारे में बात करते हैं। प्रोसेसर ऑपरेशन के दो तरीके हैं: वास्तविक और संरक्षित मोड। रियल मोड 16-बिट है और इसकी कुछ सीमाएं हैं। संरक्षित मोड 32-बिट है और पूरी तरह से ऑपरेटिंग सिस्टम द्वारा उपयोग किया जाता है। जब कंप्यूटर बस शुरू होता है, तो प्रोसेसर 16-बिट मोड में चलता है। इस प्रकार, एक प्रोग्राम लिखने और एक निष्पादन योग्य फ़ाइल प्राप्त करने के लिए, आपको 16-बिट मोड के लिए कोडांतरक के लिए एक कंपाइलर और लिंकर की आवश्यकता होती है। C / C ++ के लिए, आपको केवल एक कंपाइलर की आवश्यकता होती है जो 16-बिट मोड के लिए ऑब्जेक्ट फाइल्स बना सके।

32-बिट अनुप्रयोगों के लिए आधुनिक कंपाइलर बनाए गए हैं, इसलिए हम उनका उपयोग नहीं कर पाएंगे।

मैंने 16-बिट मोड के लिए कई मुफ्त और व्यावसायिक संकलक आज़माए और Microsoft से एक उत्पाद चुना। असेंबलर, सी और सी ++ के लिए कोडांतरक के साथ कंपाइलर को Microsoft Visual Studio 1.52 में शामिल किया गया है, इसे कंपनी की आधिकारिक वेबसाइट से डाउनलोड किया जा सकता है। संकलक के बारे में कुछ विवरण हमें दिए गए हैं।

ML 6.15 16-बिट मोड के लिए Microsoft का असेंबलर कंपाइलर है।
लिंक 5.16 एक लिंकर है जो 16-बिट मोड के लिए COM फाइलें बना सकता है।
सीएल - सी, सी + + 16-बिट मोड के लिए संकलक।

आप कई वैकल्पिक विकल्पों का भी उपयोग कर सकते हैं।

DMC 16 और 32-बिट डिजिटल मार्स मोड के लिए कोडांतरक, C, C ++ को संकलित करने के लिए एक मुफ्त संकलक है।
लिंक DMC कंपाइलर के लिए एक मुफ्त लिंकर है।

बोरलैंड से कुछ उत्पाद भी हैं।

BCC 3.5 - C, C ++ कंपाइलर जो 16-बिट मोड के लिए फाइल बना सकते हैं।
TASM 16-बिट मोड के लिए एक असेंबलर कंपाइलर है।
TLINK एक लिंकर है जो 16-बिट मोड के लिए COM फाइलें बना सकता है।

इस आलेख के सभी कोड उदाहरण Microsoft के टूल के साथ विकसित किए गए थे।

सिस्टम कैसे बूट करता है

हमारी समस्या को हल करने के लिए, हमें याद रखना चाहिए कि सिस्टम कैसे लोड होता है।
आइए हम संक्षेप में विचार करें कि सिस्टम के घटक कैसे बातचीत करते हैं जब सिस्टम बूट होता है।

नियंत्रण को 0000: 7C00 के पते पर स्थानांतरित करने के बाद, मास्टर बूट रिकॉर्ड (एमबीआर) अपना काम शुरू करता है और ऑपरेटिंग सिस्टम को लोड करना शुरू करता है।

कोडिंग पर चलते हैं

निम्नलिखित अनुभागों में, हम सीधे निम्न-स्तरीय प्रोग्रामिंग में शामिल होंगे - हम अपने स्वयं के बूटलोडर लिखेंगे।

कार्यक्रम की वास्तुकला

हम अपने लिए एक बूटलोडर विकसित करते हैं। इसके कार्य केवल निम्नलिखित हैं:

पता 0000: 7 C00 में मेमोरी में सही लोडिंग।
उस फ़ंक्शन के बूटमैन को कॉल करें जिसे हमने उच्च-स्तरीय भाषा में लिखा था।
निम्न-स्तर से - "हैलो, दुनिया ..." वाक्यांश प्रदर्शित करें।

कार्यक्रम की वास्तुकला।

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

अगली वस्तु, बूटमैन, मुख्य का एक एनालॉग है, जो बदले में, मुख्य कार्य है जिसमें सभी कार्यक्रम फ़ंक्शन केंद्रित हैं।

CDisplay और CString क्लासेस प्रोग्राम के कार्यात्मक भाग का ध्यान रखते हैं और स्क्रीन पर एक संदेश प्रदर्शित करते हैं। जैसा कि आप पिछली तस्वीर में देख सकते हैं, CDisplay वर्ग अपने काम में CString वर्ग का उपयोग करता है।

विकास का वातावरण

यहां मैं मानक विकास वातावरण Microsoft Visual Studio 2005 या 2008 का उपयोग करता हूं। आप किसी अन्य टूल का उपयोग कर सकते हैं, लेकिन मुझे यकीन है कि ये दोनों कुछ सेटिंग्स के साथ, आसानी से और आसानी से काम करते हैं।

पहले हमें मेकफाइल प्रोजेक्ट बनाने की जरूरत है, जहां मुख्य काम किया जाएगा।

फ़ाइल-> नया \ प्रोजेक्ट-> सामान्य \ Makefile प्रोजेक्ट

BIOS इंटरप्ट और स्क्रीन की सफाई

स्क्रीन पर एक संदेश प्रदर्शित करने के लिए, हमें पहले इसे साफ़ करना होगा। हम इस उद्देश्य के लिए विशेष BIOS इंटरप्ट का उपयोग करेंगे।

BIOS हार्डवेयर के साथ काम करने के लिए कई व्यवधान प्रदान करता है, जैसे कि वीडियो कार्ड, कीबोर्ड, सिस्टम डिस्क। प्रत्येक व्यवधान में निम्न संरचना होती है:

int [number_of_interrupt];

जहाँ "number_of_interrupt" रुकावट संख्या है।

प्रत्येक व्यवधान में कई पैरामीटर होते हैं जिन्हें कॉल करने से पहले सेट किया जाना चाहिए। प्रोसेसर रजिस्टर आह, हमेशा वर्तमान अवरोध के लिए कार्यों की संख्या के लिए जिम्मेदार है, और अन्य रजिस्टरों को आमतौर पर वर्तमान ऑपरेशन के अन्य मापदंडों के लिए उपयोग किया जाता है। आइए देखें कि असेंबलर में इंटरप्ट नंबर 10h कैसे काम करता है। हम 00 फ़ंक्शन का उपयोग करेंगे, यह वीडियो मोड को बदलता है और स्क्रीन को साफ करता है:

 mov al, 02h;    80x25 () mov ah, 00h;      int 10h;

हम केवल उन व्यवधानों और कार्यों पर विचार करेंगे जो हमारे आवेदन में उपयोग किए जाएंगे। हमें आवश्यकता होगी:

 int 10h, function 00h –       ; int 10h, function 01h –   ; int 10h, function 13h –    ;

"मिश्रित कोड"

C ++ कंपाइलर बिल्ट-इन असेम्बलर को सपोर्ट करता है, यानी उच्च-स्तरीय भाषा में कोड लिखते समय, आप निम्न-स्तरीय भाषा का भी उपयोग कर सकते हैं। असेंबलर निर्देश जो उच्च स्तर पर उपयोग किए जाते हैं, उन्हें एसम आवेषण भी कहा जाता है। उनमें कीवर्ड "__asm" और कोडांतरक निर्देशों का एक ब्लॉक शामिल है:

 __asm ;  ,    ASM  { ;   … ;     } ;

मिश्रित कोड का एक उदाहरण प्रदर्शित करने के लिए, हम पहले उल्लेख किए गए कोडांतरक कोड का उपयोग करेंगे, जो स्क्रीन सफाई करता है और इसे C ++ में लिखे कोड के साथ जोड़ता है।

 void ClearScreen() { __asm { mov al, 02h;    80x25 () mov ah, 00h;      int 10h;   } }

Cstring कार्यान्वयन

CString वर्ग को स्ट्रिंग्स के साथ काम करने के लिए डिज़ाइन किया गया है। इसमें Strlen () विधि शामिल है, जो एक पैरामीटर के रूप में स्ट्रिंग के लिए एक संकेतक लेती है और उस स्ट्रिंग में वर्णों की संख्या लौटाती है।

CDisplay वर्ग स्क्रीन के साथ काम करने के लिए डिज़ाइन किया गया है। इसमें कई विधियाँ शामिल हैं:

TextOut () - स्क्रीन पर एक लाइन प्रदर्शित करता है।
ShowCursor () - स्क्रीन पर व्यू कर्सर को नियंत्रित करता है: शो, छिपाना।
क्लियरस्क्रीन () - वीडियो मोड को बदलता है और इस प्रकार स्क्रीन को साफ करता है।

 // CString.h #ifndef __CSTRING__ #define __CSTRING__ #include "Types.h" class CString { public: static byte Strlen(const char far* inStrSource); }; #endif // __CSTRING__ // CString.cpp #include "CString.h" byte CString::Strlen(const char far* inStrSource) { byte lenghtOfString = 0; while(*inStrSource++ != '\0') { ++lenghtOfString; } return lenghtOfString; }

CDisplay - कार्यान्वयन

  // CDisplay.h #ifndef __CDISPLAY__ #define __CDISPLAY__ // // colors for TextOut func // #define BLACK 0x0 #define BLUE 0x1 #define GREEN 0x2 #define CYAN 0x3 #define RED 0x4 #define MAGENTA 0x5 #define BROWN 0x6 #define GREY 0x7 #define DARK_GREY 0x8 #define LIGHT_BLUE 0x9 #define LIGHT_GREEN 0xA #define LIGHT_CYAN 0xB #define LIGHT_RED 0xC #define LIGHT_MAGENTA 0xD #define LIGHT_BROWN 0xE #define WHITE 0xF #include "Types.h" #include "CString.h" class CDisplay { public: static void ClearScreen(); static void TextOut( const char far* inStrSource, byte inX = 0, byte inY = 0, byte inBackgroundColor = BLACK, byte inTextColor = WHITE, bool inUpdateCursor = false ); static void ShowCursor( bool inMode ); }; #endif // __CDISPLAY__ // CDisplay.cpp #include "CDisplay.h" void CDisplay::TextOut( const char far* inStrSource, byte inX, byte inY, byte inBackgroundColor, byte inTextColor, bool inUpdateCursor ) { byte textAttribute = ((inTextColor) | (inBackgroundColor << 4)); byte lengthOfString = CString::Strlen(inStrSource); __asm { push bp mov al, inUpdateCursor xor bh, bh mov bl, textAttribute xor cx, cx mov cl, lengthOfString mov dh, inY mov dl, inX mov es, word ptr[inStrSource + 2] mov bp, word ptr[inStrSource] mov ah, 13h int 10h pop bp } } void CDisplay::ClearScreen() { __asm { mov al, 02h mov ah, 00h int 10h } } void CDisplay::ShowCursor( bool inMode ) { byte flag = inMode ? 0 : 0x32; __asm { mov ch, flag mov cl, 0Ah mov ah, 01h int 10h } }

Types.h - कार्यान्वयन

Type.h एक हेडर फ़ाइल है जिसमें डेटा प्रकार और मैक्रो परिभाषाएँ शामिल हैं।

 // Types.h #ifndef __TYPES__ #define __TYPES__ typedef unsigned char byte; typedef unsigned short word; typedef unsigned long dword; typedef char bool; #define true 0x1 #define false 0x0 #endif // __TYPES__

BootMain.cpp - कार्यान्वयन

बूटमैन () कार्यक्रम का मुख्य कार्य है, जो कि पहला प्रवेश बिंदु (मुख्य से मुख्य) () है। यहां मुख्य काम किया जाता है।

 // BootMain.cpp #include "CDisplay.h" #define HELLO_STR "\"Hello, world…\", from low-level..." extern "C" void BootMain() { CDisplay::ClearScreen(); CDisplay::ShowCursor(false); CDisplay::TextOut( HELLO_STR, 0, 0, BLACK, WHITE, false ); return; }

StartPoint.asm - कार्यान्वयन

 ;------------------------------------------------------------ .286 ; CPU type ;------------------------------------------------------------ .model TINY ; memory of model ;---------------------- EXTERNS ----------------------------- extrn _BootMain:near ; prototype of C func ;------------------------------------------------------------ ;------------------------------------------------------------ .code org 07c00h ; for BootSector main: jmp short start ; go to main nop ;----------------------- CODE SEGMENT ----------------------- start: cli mov ax,cs ; Setup segment registers mov ds,ax ; Make DS correct mov es,ax ; Make ES correct mov ss,ax ; Make SS correct mov bp,7c00h mov sp,7c00h ; Setup a stack sti ; start the program call _BootMain ret END main ; End of program

चलो इसे सब एक साथ रखो

एक COM फ़ाइल बनाना

अब जब कोड विकसित हो गया है, तो हमें इसे 16-बिट OS के लिए फ़ाइल में बदलना होगा। ऐसी फाइलें .COM फाइलें होती हैं। हम कमांड लाइन से कंपाइलर शुरू कर सकते हैं, आवश्यक पैरामीटर पास कर सकते हैं, परिणामस्वरूप हमें कई ऑब्जेक्ट फाइलें मिलती हैं। इसके बाद, हम सभी .COM फ़ाइलों को एक्सटेंशन के साथ एक निष्पादन योग्य फ़ाइल में बदलने के लिए लिंकर को चलाते हैं। कॉम। यह काम एक सक्षम विकल्प है लेकिन बहुत आसान नहीं है।

आइए इस प्रक्रिया को बेहतर ढंग से स्वचालित करें। ऐसा करने के लिए, हमें एक .bat फ़ाइल बनाने और उसमें आवश्यक मापदंडों के साथ आवश्यक कमांड लिखने की आवश्यकता है।

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

 .\VC152\CL.EXE /AT /G2 /Gs /Gx /c /Zl *.cpp .\VC152\ML.EXE /AT /c *.asm .\VC152\LINK.EXE /T /NOD StartPoint.obj bootmain.obj cdisplay.obj cstring.obj del *.obj

कोडांतरण - स्वचालन

इस खंड में अंतिम चरण के रूप में, हम वर्णन करते हैं कि Microsoft विज़ुअल स्टूडियो 2005, 2008 को किसी भी संकलक का समर्थन करने वाले विकास परिवेश में कैसे बदलना है। ऐसा करने के लिए, प्रोजेक्ट गुण पर जाएँ: प्रोजेक्ट-> गुण- > कॉन्फ़िगरेशन गुण \ सामान्य-> कॉन्फ़िगरेशन प्रकार ।

कॉन्फ़िगरेशन गुण टैब में तीन आइटम शामिल हैं: सामान्य , डीबगिंग और NMake । NMake सेलेक्ट करें और Build Command Line और Rebuild Command Lin में "build.bat" का पथ निर्दिष्ट करें।

यदि सब कुछ सही ढंग से किया जाता है, तो आप F7 या Ctrl + F7 दबाकर संकलन कर सकते हैं। इस स्थिति में, सभी संबंधित जानकारी आउटपुट विंडो में प्रदर्शित की जाएगी। यहां मुख्य लाभ न केवल विधानसभा का स्वचालन है, बल्कि कोड में त्रुटियों की निगरानी भी है, यदि कोई हो।

परीक्षण और प्रदर्शन

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

बूटलोडर की जांच कैसे करें

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

सबसे पहले, हमें अपने बूटलोडर को आभासी या भौतिक डिस्क पर लिखने के लिए एक उपकरण की आवश्यकता होती है। जहां तक मुझे पता है, कई मुफ्त और वाणिज्यिक कंसोल और जीयूआई अनुप्रयोग हैं। मैंने MS-DOS पर काम करने के लिए Windows और Norton Disk Editor 2002 पर काम करने के लिए NTFS 3.66 के लिए डिस्क एक्सप्लोरर (FAT के लिए डिस्क एक्सप्लोरर के लिए एक संस्करण) का उपयोग किया।

मैं केवल NTFS 3.66 के लिए डिस्क एक्सप्लोरर का वर्णन करूंगा क्योंकि यह सबसे आसान तरीका है और हमारे उद्देश्यों के लिए सबसे उपयुक्त है।

VmWare वर्चुअल मशीन के साथ परीक्षण

वर्चुअल मशीन बनाना

हमें VmWare सॉफ्टवेयर संस्करण 5.0, 6.0 या उच्चतर की आवश्यकता होगी। बूटलोडर का परीक्षण करने के लिए, हम न्यूनतम डिस्क आकार के साथ एक नई आभासी मशीन बनाएंगे, उदाहरण के लिए, 1 जीबी। इसे NTFS फाइल सिस्टम में फॉर्मेट करें। अब हमें VmWare को वर्चुअल ड्राइव के रूप में स्वरूपित हार्ड ड्राइव को मैप करना होगा। ऐसा करने के लिए, चुनें:

फ़ाइल-> मानचित्र या वर्चुअल डिस्कनेक्ट करें ...

उसके बाद एक विंडो दिखाई देगी। वहां आपको मैप बटन पर क्लिक करना होगा। दिखाई देने वाली अगली विंडो में, आपको डिस्क पर पथ निर्दिष्ट करना होगा। अब आप एक ड्राइव लेटर भी चुन सकते हैं।

बॉक्स "केवल-पढ़ने के लिए मोड (अनुशंसित) में फ़ाइल खोलें" को अनचेक करना न भूलें। उपरोक्त सभी संकेत पूरे करने के बाद, डेटा भ्रष्टाचार से बचने के लिए ड्राइव केवल रीड-ओनली मोड में उपलब्ध होना चाहिए।

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

NTFS के लिए डिस्क एक्सप्लोरर के साथ काम करना

कार्यक्रम शुरू करने के बाद, हम अपने ड्राइव (फाइल-> ड्राइव) पर जाते हैं। दिखाई देने वाली विंडो में, तार्किक ड्राइव अनुभाग पर जाएं और हमारी बनाई गई ड्राइव का चयन करें (मेरे मामले में यह जेड है)।

अब हम हेक्स कमांड के रूप में मेनू आइटम व्यू का चयन करते हैं। दिखाई देने वाली इस विंडो में, हम 16-बिट प्रतिनिधित्व में डिस्क जानकारी को सेक्टरों में विभाजित करके देख सकते हैं। अब हमारे पास केवल 0 है, क्योंकि डिस्क अभी के लिए खाली है।

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

आपको सेक्टर की शुरुआत से ही स्थिति 1 एफई पर हस्ताक्षर 55 एएएच लिखना होगा। यदि आप ऐसा नहीं करते हैं, तो BIOS अंतिम दो बाइट्स की जांच करेगा, और निर्दिष्ट हस्ताक्षर नहीं ढूंढने पर, यह विचार करेगा कि यह क्षेत्र बूट करने योग्य नहीं है और इसे मेमोरी में लोड नहीं करेगा।

संपादन मोड में जाने के लिए, F2 कुंजी दबाएं और आवश्यक संख्याएं लिखें - 55AAh हस्ताक्षर। संपादन मोड से बाहर निकलने के लिए ESC दबाएँ।

अब हमें रिकॉर्ड किए गए डेटा की पुष्टि करने की आवश्यकता है।

दर्ज किए गए आवेदन को लागू करने के लिए हम टूल-> विकल्प पर जाते हैं , अब हम मोड आइटम पर जाते हैं और रिकॉर्डिंग विधि का चयन करते हैं - वर्चुअल लिखें और राइट बटन पर क्लिक करें।

अंत में, अधिकांश नियमित क्रियाएं पूरी हो चुकी हैं, और अब आप देख सकते हैं कि हमने इस लेख की शुरुआत से क्या विकसित किया है। चलो वर्चुअल डिस्क डिस्कनेक्ट करने के लिए VwWare पर वापस जाएं (फ़ाइल-> मैप या वर्चुअल डिस्क डिस्कनेक्ट करें ... और डिस्कनेक्ट करें पर क्लिक करें)।

वर्चुअल मशीन शुरू करते हैं। अब हम देखते हैं कि मशीन कोड्स के दायरे की गहराई से कितनी परिचित लाइनें दिखाई देती हैं - "हैलो वर्ल्ड ...", निम्न-स्तर से ... "।

असली हार्डवेयर पर परीक्षण

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

NTFS 3.66 के लिए डिस्क एक्सप्लोरर में फ्लैश ड्राइव पर बूटलोडर लिखने की प्रक्रिया एक वर्चुअल मशीन के लिए समान है। आपको बस अपने तार्किक विभाजन के बजाय हार्ड ड्राइव को चुनना होगा।

निष्कर्ष

इस आलेख में, हमने जांच की कि बूट लोडर क्या है, BIOS कैसे काम करता है, और सिस्टम के घटक सिस्टम के बूट होने पर कैसे बातचीत करते हैं। व्यावहारिक भाग ने हमें इस बात की समझ दी कि आप अपने स्वयं के, सरल बूटलोडर को कैसे विकसित कर सकते हैं। हमने Microsoft विज़ुअल स्टूडियो 2005, 2008 का उपयोग करके मिश्रित कोड तकनीक और निर्माण स्वचालन प्रक्रिया का प्रदर्शन किया।

बेशक, यह निम्न-स्तरीय प्रोग्रामिंग के विशाल विषय की तुलना में केवल एक छोटा हिस्सा है, लेकिन अगर आप इस लेख में रुचि रखते हैं, तो यह अच्छा है।

UPD: स्रोत लिंक

अपना बूटलोडर लिखना