बूटलोडर से कर्नेल तक

यदि आप पिछले लेख पढ़ते हैं , तो आप निम्न-स्तरीय प्रोग्रामिंग के लिए मेरे नए शौक के बारे में जानते हैं। मैंने x86_64 लिनक्स के लिए कोडांतरक प्रोग्रामिंग पर कई लेख लिखे और उसी समय लिनक्स कर्नेल के स्रोत कोड में गोता लगाना शुरू किया।

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

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

सभी लेख GitHub रिपॉजिटरी में प्रकाशित होते हैं, और अगर मेरी अंग्रेजी या लेख की सामग्री में कुछ गलत है, तो एक पुल अनुरोध भेजने में संकोच न करें।

कृपया ध्यान दें कि यह आधिकारिक दस्तावेज नहीं है, लेकिन केवल प्रशिक्षण और ज्ञान साझा करना है।

आवश्यक ज्ञान

• सी कोड को समझना
• असेंबलर कोड (एटी एंड टी सिंटैक्स) को समझना

किसी भी मामले में, यदि आप ऐसे उपकरण सीखना शुरू कर रहे हैं, तो मैं इस और बाद के लेखों में कुछ समझाने की कोशिश करूंगा। ठीक है, परिचय समाप्त होने के साथ, यह लिनक्स कर्नेल और निम्न-स्तरीय चीजों में गोता लगाने का समय है।

मैंने लिनक्स 3.18 कर्नेल के दिनों में इस पुस्तक को लिखना शुरू किया था और तब से बहुत कुछ बदल गया है। यदि परिवर्तन हैं, तो मैं तदनुसार लेखों को अपडेट करूंगा।

मैजिक पावर बटन, आगे क्या है?

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

प्रोसेसर 80386 और बाद के संस्करणों में रिबूट के बाद सीपीयू रजिस्टर में निम्नलिखित मान होने चाहिए:

  आईपी ​​0xfff0
 सीएस चयनकर्ता 0xf000
 सीएस बेस 0xffff0000 

प्रोसेसर वास्तविक मोड में काम करना शुरू कर देता है । आइए थोड़ा पीछे जाएं और इस मोड में मेमोरी सेगमेंटेशन को समझने की कोशिश करें। वास्तविक मोड सभी x86- संगत प्रोसेसर पर समर्थित है: 8086 से आधुनिक 64-बिट इंटेल प्रोसेसर तक। 8086 प्रोसेसर 20-बिट एड्रेस बस का उपयोग करता है, अर्थात यह 0-0xFFFFF या 1 एड्रेस स्पेस के साथ काम कर सकता है। लेकिन इसका केवल 16-बिट रजिस्टर है जिसमें 2^16-1 या 0xffff (64 किलोबाइट) का अधिकतम पता है।

संपूर्ण उपलब्ध पता स्थान का उपयोग करने के लिए मेमोरी सेगमेंटेशन की आवश्यकता होती है। सभी मेमोरी को 65536 बाइट्स (64 KB) के एक निश्चित आकार के छोटे सेगमेंट में विभाजित किया गया है। चूंकि 16-बिट रजिस्टरों के साथ हम 64 केबी से ऊपर मेमोरी तक नहीं पहुंच सकते हैं, इसलिए एक वैकल्पिक तरीका विकसित किया गया था।

पते में दो भाग होते हैं: 1) एक आधार पता के साथ एक खंड चयनकर्ता; 2) आधार पते से ऑफसेट। वास्तविक मोड में, खंड * 16 आधार पता * 16 । इस प्रकार, स्मृति में भौतिक पता प्राप्त करने के लिए, आपको खंड चयनकर्ता के हिस्से को 16 से गुणा करना होगा और उसमें ऑफसेट जोड़ना होगा:

   =   * 16 +  

उदाहरण के लिए, यदि CS:IP रजिस्टर का मान 0x2000:0x0010 , तो संबंधित भौतिक पता इस प्रकार होगा:

 >>> hex((0x2000 << 4) + 0x0010) '0x20010' 

लेकिन अगर आप सबसे बड़े सेगमेंट के चयनकर्ता और ऑफसेट 0xffff:0xffff , तो आपको पता मिलता है:

 >>> hex((0xffff << 4) + 0xffff) '0x10ffef' 

यह, पहली मेगाबाइट के बाद 65520 बाइट्स है। चूँकि वास्तविक मोड में केवल एक मेगाबाइट उपलब्ध है, 0x10ffef A20 लाइन अक्षम के साथ 0x10ffef बन जाता है।

ठीक है, अब हम इस मोड में वास्तविक मोड और मेमोरी एड्रेसिंग के बारे में थोड़ा जानते हैं। रीसेट के बाद रजिस्टर मानों की चर्चा पर लौटते हैं।

CS रजिस्टर में दो भाग होते हैं: एक दृश्य खंड चयनकर्ता और एक छिपा हुआ आधार पता। हालांकि आधार पता आमतौर पर खंड चयनकर्ता के मूल्य को 16 से गुणा करके बनाया जाता है, लेकिन एक हार्डवेयर रीसेट के दौरान, सीएस रजिस्टर में खंड चयनकर्ता 0xf000 , और आधार पता 0xffff0000 । CS के बदलने तक प्रोसेसर इस विशेष आधार पते का उपयोग करता है।

प्रारंभिक पता ईआईपी रजिस्टर में मूल्य के आधार पते को जोड़कर बनाया गया है:

 >>> 0xffff0000 + 0xfff0 '0xfffffff0' 

हमें 0xfffffff0 मिलता है, जो 4 जीबी से नीचे 16 बाइट्स है। इस बिंदु को रीसेट वेक्टर कहा जाता है । यह स्मृति में वह स्थान है जहां CPU रीसेट के बाद निष्पादित करने के लिए पहले निर्देश की प्रतीक्षा करता है: एक जंप ऑपरेशन ( jmp ), जो आमतौर पर BIOS प्रविष्टि बिंदु को इंगित करता है। उदाहरण के लिए, यदि आप कोरबूट ( src/cpu/x86/16bit/reset16.inc ) के स्रोत कोड को देखते हैं, तो हम देखेंगे:

  .section ".reset", "ax", %progbits .code16 .globl _start _start: .byte 0xe9 .int _start16bit - ( . + 2 ) ... 

यहाँ हम ऑपरेशन कोड ( opcode ) jmp , जिसका नाम 0xe9 , और गंतव्य पता _start16bit - ( . + 2) ।

हम यह भी देखते हैं कि reset खंड 16 बाइट्स है, और यह 0xfffff0 ( src/cpu/x86/16bit/reset16.ld ) पते से चलने के लिए संकलित करता है:

 SECTIONS { /* Trigger an error if I have an unuseable start address */ _bogus = ASSERT(_start16bit >= 0xffff0000, "_start16bit too low. Please report."); _ROMTOP = 0xfffffff0; . = _ROMTOP; .reset . : { *(.reset); . = 15; BYTE(0x00); } } 

BIOS अब शुरू होता है; BIOS हार्डवेयर को आरंभ करने और जांचने के बाद, आपको बूट डिवाइस को खोजने की आवश्यकता है। बूट ऑर्डर BIOS कॉन्फ़िगरेशन में सहेजा गया है। हार्ड ड्राइव से बूट करने की कोशिश करते समय, BIOS बूट सेक्टर को खोजने की कोशिश करता है। एमबीआर विभाजन डिस्क पर, बूट सेक्टर पहले सेक्टर के 446 बाइट्स में संग्रहीत किया जाता है, जहां प्रत्येक सेक्टर 512 बाइट्स होता है। पहले सेक्टर के अंतिम दो बाइट्स 0x55 और 0xaa । वे BIOS को दिखाते हैं कि यह एक बूट डिवाइस है।

उदाहरण के लिए:

 ; ; :       Intel x86 ; [BITS 16] boot: mov al, '!' mov ah, 0x0e mov bh, 0x00 mov bl, 0x07 int 0x10 jmp $ times 510-($-$$) db 0 db 0x55 db 0xaa 

हम इकट्ठा करते हैं और चलाते हैं:

nasm -f bin boot.nasm && qemu-system-x86_64 boot

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

आप देखेंगे:



इस उदाहरण में, हम देखते हैं कि कोड 16-बिट वास्तविक मोड में चलता है और स्मृति में 0x7c00 पते पर शुरू होता है। शुरू करने के बाद, यह 0x10 अवरोध का कारण बनता है, जो बस एक चरित्र को प्रिंट करता है ! ; शेष 510 बाइट्स को शून्य से भरता है और दो मैजिक बाइट्स 0xaa और 0x55 साथ समाप्त होता है।

आप बाइनरी डंप को objdump उपयोगिता के साथ देख सकते हैं:

nasm -f bin boot.nasm
objdump -D -b binary -mi386 -Maddr16,data16,intel boot

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

नोट : जैसा कि ऊपर बताया गया है, सीपीयू वास्तविक मोड में है; स्मृति में भौतिक पते की गणना इस प्रकार है:

   =   * 16 +  

हमारे पास केवल 16-बिट सामान्य-उद्देश्य रजिस्टर हैं, और 16-बिट रजिस्टर का अधिकतम मूल्य 0xffff , इसलिए सबसे बड़े मूल्यों पर परिणाम होगा:

 >>> hex((0xffff * 16) + 0xffff) '0x10ffef' 

जहाँ 0x10ffef 1 + 64 - 16 । 8086 प्रोसेसर (वास्तविक मोड वाला पहला प्रोसेसर) में 20-बिट एड्रेस लाइन होती है। 2^20 = 1048576 बाद से, वास्तविक उपलब्ध मेमोरी 1 एमबी है।

सामान्य तौर पर, वास्तविक-मोड मेमोरी एड्रेसिंग इस प्रकार है:

  0x00000000 - 0x000003FF - वास्तविक मोड के बाधित वैक्टर की तालिका
 0x00000400 - 0x000004FF - BIOS डेटा क्षेत्र
 0x00000500 - 0x00007BFF - उपयोग नहीं किया गया
 0x00007C00 - 0x00007DFF - हमारा बूटलोडर
 0x00007E00 - 0x0009FFFF - उपयोग नहीं किया गया
 0x000A0000 - 0x000BFFFF - वीडियो रैम (VRAM) 
 0x000B0000 - 0x000B7777 - मोनोक्रोम वीडियो मेमोरी
 0x000B8000 - 0x000BFFFF - रंग मोड वीडियो मेमोरी
 0x000C0000 - 0x000C7FFF - वीडियो ROM BIOS
 0x000C8000 - 0x000EFFFF - छाया क्षेत्र (BIOS छाया)
 0x000F0000 - 0x000FFFFF - सिस्टम BIOS 

लेख की शुरुआत में लिखा गया है कि प्रोसेसर के लिए पहला निर्देश 0xFFFFFFF0 पर स्थित 0xFFFFFFF0 , जो 0xFFFFF (1 MB) से बहुत अधिक है। वास्तविक मोड में सीपीयू इस पते तक कैसे पहुंच सकता है? कोरबूट प्रलेखन में उत्तर:

0xFFFE_0000 - 0xFFFF_FFFF: 128 ROM

निष्पादन की शुरुआत में, BIOS रैम में नहीं है, लेकिन रोम में है।

लोडर

लिनक्स कर्नेल को अलग बूट लोडर के साथ लोड किया जा सकता है, जैसे GRUB 2 और syslinux । कर्नेल में एक बूट प्रोटोकॉल है जो लिनक्स समर्थन को लागू करने के लिए बूटलोडर आवश्यकताओं को परिभाषित करता है। इस उदाहरण में, हम GRUB 2 के साथ काम कर रहे हैं।

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

grub_main फ़ंक्शन कंसोल को प्रारंभ करता है, मॉड्यूल के लिए आधार पता देता है, रूट डिवाइस सेट करता है, ग्रब कॉन्फ़िगरेशन फ़ाइल को लोड / पार्स करता है, मॉड्यूल लोड करता है, आदि। निष्पादन के अंत में, यह ग्रब को सामान्य मोड में डालता है। grub_normal_execute फ़ंक्शन ( grub-core/normal/main.c स्रोत फ़ाइल से) अंतिम तैयारी पूरी करता है और ऑपरेटिंग सिस्टम चुनने के लिए एक मेनू प्रदर्शित करता है। जब हम किसी ग्रब मेनू आइटम का चयन करते हैं, तो grub_menu_execute_entry फ़ंक्शन grub_menu_execute_entry , जो ग्रब boot कमांड निष्पादित करता है और चयनित ओएस को लोड करता है।

जैसा कि कर्नेल बूट प्रोटोकॉल में संकेत दिया गया है, बूट लोडर को कर्नेल इंस्टॉलेशन हेडर के कुछ फ़ील्ड्स को पढ़ना और भरना होगा, जो कि कर्नेल इंस्टॉलेशन कोड से ऑफसेट 0x01f1 पर शुरू होता है। यह ऑफसेट लिंकर स्क्रिप्ट में इंगित किया गया है। कर्नेल हेडर आर्क / x86 / बूट / हेडर। इसके साथ शुरू होता है:

  .globl hdr hdr: setup_sects: .byte 0 root_flags: .word ROOT_RDONLY syssize: .long 0 ram_size: .word 0 vid_mode: .word SVGA_MODE root_dev: .word 0 boot_flag: .word 0xAA55 

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

जैसा कि आप कर्नेल बूट प्रोटोकॉल में देख सकते हैं, मेमोरी निम्नानुसार प्रदर्शित की जाएगी:

  |  संरक्षित कर्नेल मोड |
 100000 + ------------------------ +
          |  I / O मैपिंग |
 0A0000 + ------------------------ +
          |  आरक्षित।  BIOS के लिए |  जितना संभव हो मुक्त छोड़ दें
          ~ ~
          |  कमांड लाइन |  (X + 10000 से नीचे भी हो सकता है)
 X + 10000 + ------------------------ +
          |  ढेर / ढेर |  वास्तविक कर्नेल मोड कोड का उपयोग करने के लिए
 X + 08000 + ------------------------ +
          |  कर्नेल इंस्टॉलेशन |  कर्नेल वास्तविक मोड कोड
          |  कर्नेल बूट सेक्टर |  विरासत कर्नेल बूट क्षेत्र
        एक्स + ------------------------ +
          |  लोडर |  <- प्रवेश बिंदु 0x7C00 बूट सेक्टर
 001000 + ------------------------ +
          |  आरक्षित।  MBR / BIOS के लिए |
 000800 + ------------------------ +
          |  आमतौर पर उपयोग करते हैं  एमबीआर |
 000600 + ------------------------ +
          |  का प्रयोग करें।  केवल BIOS |
 000000 + ------------------------ +

इसलिए, जब लोडर कर्नेल पर नियंत्रण स्थानांतरित करता है, तो यह पते से शुरू होता है:

 X + sizeof (KernelBootSector) + 1 

जहां X कर्नेल बूट सेक्टर का पता है। हमारे मामले में, X 0x10000 , जैसा कि मेमोरी डंप में देखा गया है:



बूटलोडर ने लिनक्स कर्नेल को मेमोरी में स्थानांतरित किया, हेडर फ़ील्ड्स को पॉप्युलेट किया, और फिर संबंधित मेमोरी एड्रेस पर ले जाया गया। अब हम सीधे कर्नेल इंस्टॉलेशन कोड पर जा सकते हैं।

कर्नेल इंस्टॉलेशन चरण की शुरुआत

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

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

qemu-system-x86_64 vmlinuz-3.18-generic

आप देखेंगे:



दरअसल, header.S फ़ाइल मैजिक नंबर MZ (ऊपर डंप का स्क्रीनशॉट देखें) से शुरू होती है, त्रुटि संदेश और पीई हेडर का पाठ:

 #ifdef CONFIG_EFI_STUB # "MZ", MS-DOS header .byte 0x4d .byte 0x5a #endif ... ... ... pe_header: .ascii "PE" .word 0 

UEFI समर्थन के साथ एक ऑपरेटिंग सिस्टम को लोड करना आवश्यक है। हम निम्नलिखित अध्याय में इसकी युक्ति पर विचार करेंगे।

कर्नेल स्थापित करने के लिए वास्तविक प्रवेश बिंदु:

 // header.S line 292 .globl _start _start: 

बूटलोडर (grub2 और अन्य) इस बिंदु के बारे में जानता है ( MZ से ऑफसेट 0x200 ) और सीधे उसके पास जाता है, हालांकि header.S .bstext अनुभाग से शुरू होता है, जहां त्रुटि संदेश का पाठ स्थित है।

 // // arch/x86/boot/setup.ld // . = 0; // current position .bstext : { *(.bstext) } // put .bstext section to position 0 .bsdata : { *(.bsdata) } 

कर्नेल स्थापना प्रविष्टि बिंदु:

  .globl _start _start: .byte 0xeb .byte start_of_setup-1f 1: // // rest of the header // 

यहां हम ऑपरेशन कोड jmp ( 0xeb ) देखते हैं, जो बिंदु start_of_setup-1f । Nf संकेतन में, उदाहरण के लिए, 2f स्थानीय लेबल 2: को संदर्भित करता है 2: हमारे मामले में, यह लेबल 1 , जो संक्रमण के तुरंत बाद मौजूद है, और इसमें बाकी सेटअप हेडर शामिल हैं। स्थापना शीर्ष लेख के तुरंत बाद, हम .entrytext अनुभाग देखते हैं, जो start_of_setup लेबल से शुरू होता है।

यह वास्तव में निष्पादित पहला कोड है (पिछले कूद निर्देशों के अलावा, निश्चित रूप से)। कर्नेल इंस्टॉलेशन के भाग के बाद लोडर से नियंत्रण प्राप्त करता है, पहला jmp निर्देश वास्तविक कर्नेल मोड की शुरुआत से 0x200 पर ऑफसेट 0x200 है, अर्थात पहले 512 बाइट्स के बाद। यह लिनक्स कर्नेल बूट प्रोटोकॉल और grub2 स्रोत कोड दोनों में देखा जा सकता है:

 segment = grub_linux_real_target >> 4; state.gs = state.fs = state.es = state.ds = state.ss = segment; state.cs = segment + 0x20; 

हमारे मामले में, पता 0x10000 पर कर्नेल बूट करता है। इसका मतलब है कि कर्नेल इंस्टॉलेशन शुरू करने के बाद, सेगमेंट रजिस्टर में निम्नलिखित मान होंगे:

gs = fs = es = ds = ss = 0x10000
cs = 0x10200

start_of_setup जाने के बाद start_of_setup कर्नेल को निम्न कार्य करना चाहिए:

• सुनिश्चित करें कि सभी खंड रजिस्टर मूल्य समान हैं
• यदि आवश्यक हो, तो सही स्टैक कॉन्फ़िगर करें
• Bss कॉन्फ़िगर करें
• आर्क / x86 / बूट / main.c में C कोड पर जाएं

आइए देखें कि यह कैसे लागू किया जाता है।

खंड केस संरेखण

सबसे पहले, कर्नेल जाँचता है कि ds और es खंड रजिस्टर एक ही पते पर इंगित करते हैं। यह तब cld का उपयोग करके दिशा ध्वज को साफ़ करता है:

  movw %ds, %ax movw %ax, %es cld 

जैसा कि मैंने पहले लिखा था, डिफ़ॉल्ट रूप से ग्रब 2 कर्नेल इंस्टॉलेशन कोड को 0x10000 पर लोड करता है, और 0x10200 पर 0x10200 , क्योंकि निष्पादन फ़ाइल की शुरुआत से शुरू नहीं होता है, लेकिन यहां संक्रमण से:

 _start: .byte 0xeb .byte start_of_setup-1f 

यह 4d 5a से 512 बाइट ऑफसेट है। अन्य सभी सेगमेंट रजिस्टरों की तरह 0x10200 से 0x10000 तक cs को संरेखित करना भी आवश्यक है। उसके बाद स्टैक स्थापित करें:

  pushw %ds pushw $6f lretw 

यह निर्देश स्टैक पर ds मान को धकेलता है, इसके बाद लेबल 6 का पता और lretw निर्देश है, जो लेबल 6 के पते को कमांड काउंटर के रजिस्टर में लोड करता है और मान ds साथ cs लोड करता है। उसके बाद, ds और cs में समान मान होंगे।

स्टैक सेटअप

इस कोड के लगभग सभी सी वातावरण को वास्तविक मोड में तैयार करने की प्रक्रिया का हिस्सा है। अगला चरण ss रजिस्टर मान की जाँच करना और ss मान गलत होने पर सही स्टैक बनाना है:

  movw %ss, %dx cmpw %ax, %dx movw %sp, %dx je 2f 

यह तीन अलग-अलग परिदृश्यों को ट्रिगर कर सकता है:

• ss मान 0x1000 ( cs को छोड़कर अन्य सभी रजिस्टरों के साथ)
• ss अमान्य मान है और CAN_USE_HEAP ध्वज सेट है (नीचे देखें)
• ss अमान्य मान है और CAN_USE_HEAP ध्वज सेट नहीं है (नीचे देखें)

क्रम में सभी परिदृश्यों पर विचार करें:

• ss वैध मान ( 0x1000 ) है। इस मामले में, हम लेबल 2 पर जाते हैं:

 2: andw $~3, %dx jnz 3f movw $0xfffc, %dx 3: movw %ax, %ss movzwl %dx, %esp sti 

यहां हमने dx रजिस्टर (जिसमें बूटलोडर द्वारा दर्शाया गया sp मान होता है) के संरेखण को 4 बाइट्स पर सेट किया है और शून्य की जांच की है। यदि यह शून्य है, तो हम मूल्य 0xfffc dx ( 4 बाइट-संरेखित पता 64 केबी के अधिकतम खंड आकार से पहले) में 0xfffc । यदि यह शून्य के बराबर नहीं है, तो हम बूटलोडर (हमारे मामले में 0xf7f4 ) द्वारा निर्दिष्ट sp मान का उपयोग करना जारी रखते हैं। फिर हमने ss में ax मूल्य डाला, जो सही खंड पते 0x1000 बचाता है और सही sp सेट करता है। अब हमारे पास सही स्टैक है:

• दूसरे परिदृश्य में, ss != ds । सबसे पहले हम dend (इंस्टालेशन कोड के अंत का पता) dx में loadflags और हेडर फील्ड loadflags जांच करते हैं, अगर testb का उपयोग किया जा सकता है यह testb लिए testb अनुदेश का उपयोग करते हुए। लोडफ्लैग एक बिटमास्क हेडर है जिसे निम्नानुसार परिभाषित किया गया है:

 #define LOADED_HIGH (1<<0) #define QUIET_FLAG (1<<5) #define KEEP_SEGMENTS (1<<6) #define CAN_USE_HEAP (1<<7) 

और जैसा कि बूट प्रोटोकॉल में संकेत दिया गया है:

: loadflags

.

7 (): CAN_USE_HEAP
1, ,
heap_end_ptr . ,
.

यदि CAN_USE_HEAP बिट CAN_USE_HEAP , तो dx हम मान heap_end_ptr (जो कि _end को _end ) सेट करते हैं और उसमें STACK_SIZE जोड़ते हैं (न्यूनतम स्टैक आकार 1024 बाइट्स है)। उसके बाद, लेबल 2 (पिछले मामले में) और सही स्टैक बनाएं।

• यदि CAN_USE_HEAP सेट नहीं है, तो बस _end से _end + STACK_SIZE तक न्यूनतम स्टैक का उपयोग करें:

बीएसएस सेटअप

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

  cmpl $0x5a5aaa55, setup_sig jne setup_bad 

निर्देश बस मैजिक नंबर 0x5a5aaa55 के साथ setup_sig की तुलना करता है। यदि वे समान नहीं हैं, तो एक घातक त्रुटि की सूचना दी जाती है।

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

BSS अनुभाग का उपयोग सांख्यिकीय रूप से आवंटित किए गए असमान डेटा को संग्रहीत करने के लिए किया जाता है। लिनक्स ध्यान से जाँचता है कि यह मेमोरी क्षेत्र रीसेट है:

  movw $__bss_start, %di movw $_end+3, %cx xorl %eax, %eax subw %di, %cx shrw $2, %cx rep; stosl 

सबसे पहले, __bss_start का प्रारंभ पता di ले जाया जाता है। फिर पता _end + 3 (4 बाइट्स द्वारा संरेखण के लिए +3) को cx स्थानांतरित कर दिया जाता है। eax रजिस्टर को मंजूरी दे दी गई है (एक्सआर निर्देश का उपयोग करके), बीएसएस अनुभाग ( cx-di डीआई) के आकार की गणना की जाती है, और इसे cx में रखा जाता है। फिर cx को चार ("शब्द" के आकार) में विभाजित किया गया है और stosl इंस्ट्रक्शन को stosl उपयोग किया stosl , यह मान में (शून्य) को संग्रहीत करता है, जो कि di ओर इशारा करता है, स्वचालित रूप से चार से di बढ़ता है और इसे दोहराता है जब तक कि यह शून्य तक नहीं पहुंच जाता है)। इस कोड का शुद्ध प्रभाव यह है कि शून्य को स्मृति में सभी शब्दों को _end से __bss_start तक _end :

मुख्य पर जाएं

यही है: हमारे पास एक स्टैक और बीएसएस है, इसलिए आप main() सी फ़ंक्शन पर जा सकते हैं:

  calll main 

main() फ़ंक्शन आर्क / x86 / बूट / main.c में स्थित है। हम उसके बारे में अगले भाग में बात करेंगे।

निष्कर्ष

यह लिनक्स कर्नेल डिवाइस के बारे में पहले भाग का अंत है। , , . C, Linux, , memset , memcpy , earlyprintk , .

संदर्भ

• Intel 80386, , 1986 .
• Intel
• 8086
• 80386
• Linux
• Coreboot,
• « »