पहले चरण से दूसरे चरण बूट लोडर को कैसे लोड करें?

Question

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

यहाँ पहले चरण के लिए एक कार्यक्रम है

[BITS 16] ;Tells the assembler that its a 16 bit code 
[ORG 0x7C00] ;Origin, tell the assembler that where the code will 
       ;be in memory after it is been loaded 

MOV SI, HelloString ;Store string pointer to SI 
CALL PrintString ;Call print string procedure 
JMP $  ;Infinite loop, hang it here. 


PrintCharacter: ;Procedure to print character on screen 
    ;Assume that ASCII value is in register AL 
MOV AH, 0x0E ;Tell BIOS that we need to print one charater on screen. 
MOV BH, 0x00 ;Page no. 
MOV BL, 0x07 ;Text attribute 0x07 is lightgrey font on black background 

INT 0x10 ;Call video interrupt 
RET  ;Return to calling procedure 



PrintString: ;Procedure to print string on screen 
    ;Assume that string starting pointer is in register SI 

next_character: ;Lable to fetch next character from string 
MOV AL, [SI] ;Get a byte from string and store in AL register 
INC SI  ;Increment SI pointer 
OR AL, AL ;Check if value in AL is zero (end of string) 
JZ exit_function ;If end then return 
CALL PrintCharacter ;Else print the character which is in AL register 
JMP next_character ;Fetch next character from string 
exit_function: ;End label 
RET  ;Return from procedure 


;Data 
HelloString db 'Hello World', 0 ;HelloWorld string ending with 0 

TIMES 510 - ($ - $$) db 0 ;Fill the rest of sector with 0 
DW 0xAA55   ;Add boot signature at the end of bootloader 

Answer 1

86 आप निम्नलिखित (सरलीकृत) करना होगा पर:

• बूटलोडर डिस्क/फ्लॉपी के एन-वें क्षेत्र लोड (लो जहां भी आप बूट कर रहे हैं) स्मृति में और इसे निष्पादित करें (यानी लोड सेगमेंट/ऑफ़सेट और retf करें)। एक बेहतर विकल्प फ़ाइल सिस्टम को एक निश्चित फ़ाइल नाम (उदाहरण के लिए KERNEL.BIN) के लिए खोजना है - लेकिन आपको फ़ाइल सिस्टम प्रकार (जैसे FAT12 अगर आप फ्लॉपी छवि से परीक्षण कर रहे हैं) को जानना होगा।
• कर्नेल वास्तविक मोड में शुरू होगा। यह कोड डिस्क्रिप्टर, जीडीटी, और इसी तरह सेट करता है, 32-बिट एड्रेसिंग को सक्रिय करता है (आपको "ए 20" के बारे में सुना होगा) और अंत में संरक्षित मोड में प्रवेश करता है। फिर आपको 32-बिट कोड सेगमेंट तक बहुत दूर की आवश्यकता है (कर्नेल फ़ाइल को इस तरह से एक साथ जोड़ा जाना चाहिए कि 32-बिट कोड पूर्ण स्थिति पर है, उदाहरण के लिए ऑफसेट 512, 16-बिट वास्तविक मोड सामग्री के ठीक बाद) ।
• 32-बिट कर्नेल असेंबली, फिर, EXTERN _mykernel (उदाहरण के लिए) को परिभाषित करता है और उस प्रतीक को कॉल करता है।
• फिर आप अपने कर्नेल को सी फ़ंक्शन mykernel के रूप में लिखना शुरू कर सकते हैं।

ठीक है कि मैंने कुछ साल पहले जो कुछ किया था उसका संक्षिप्त अवलोकन था (इंटरनेट से पेस्ट & पेस्ट की बहुत सारी प्रतियां;)।

• http://www.brokenthorn.com/Resources/OSDevIndex.html
• http://wiki.osdev.org/Main_Page
• http://lowlevel.brainsware.org/wiki/index.php/Hauptseite (जर्मन केवल कई शौकिया ओएस डेवलपर्स के साथ विकी, ...)

: अगर वह उपयोगी नहीं है, यहाँ ओएस विकास पर कुछ अच्छा वेब संसाधन हैं

आशा जो GRUB कार्यान्वयन यहाँ पर ^^

Answer 2

देखो में मदद करता है (चरण 1):

http://src.illumos.org/source/xref/illumos-gate/usr/src/grub/grub-0.97/stage1/stage1.S

पहले इस क्षेत्र के लिए 0x7c00 पर शुरुआती बिंदु और 0xaa55 के अंतिम हस्ताक्षर पर ध्यान दिया। disassembly के भीतर से, यू यह देख सकते हैं:

349 copy_buffer: 
350 movw ABS(stage2_segment), %es 
351 
352 /* 
353 * We need to save %cx and %si because the startup code in 
354 * stage2 uses them without initializing them. 
355 */ 
356 pusha 
357 pushw %ds 
358 
359 movw $0x100, %cx 
360 movw %bx, %ds 
361 xorw %si, %si 
362 xorw %di, %di 
363 
364 cld 
365 
366 rep 
367 movsw 
368 
369 popw %ds 
370 popa 
371 
372 /* boot stage2 */ 
373 jmp *(stage2_address) 
374 
375 /* END OF MAIN LOOP */ 
376 

अनिवार्य रूप से तर्क स्मृति के किसी अन्य भाग में चरण 2 कोड को कॉपी करने के लिए है, और कहा कि कूद के बाद सीधे वहाँ, और कहा कि "बूट stage2 है "। दूसरे शब्दों में, "बूट स्टेज 1" प्रभावी रूप से बीआईओएस से ट्रिगर किया गया है क्योंकि इसने क्षेत्र को स्मृति में लोड किया है, जबकि चरण 2 वह जगह है जहां आप वहां कूदते हैं - यह कहीं भी हो सकता है।

Answer 3

मिनिमल runnable एनएएसएम BIOS उदाहरण है कि चरण 2 लोड करता है और इसे करने के लिए कूदता है

use16 
org 0x7C00 

    ; You should do further initializations here 
    ; like setup the stack and segment registers. 

    ; Load stage 2 to memory. 
    mov ah, 0x02 
    ; Number of sectors to read. 
    mov al, 1 
    ; This may not be necessary as many BIOS set it up as an initial state. 
    mov dl, 0x80 
    ; Cylinder number. 
    mov ch, 0 
    ; Head number. 
    mov dh, 0 
    ; Starting sector number. 2 because 1 was already loaded. 
    mov cl, 2 
    ; Where to load to. 
    mov bx, stage2 
    int 0x13 

    jmp stage2 

    ; Magic bytes.  
    times ((0x200 - 2) - ($ - $$)) db 0x00 
    dw 0xAA55 

stage2: 

    ; Print 'a'. 
    mov ax, 0x0E61 
    int 0x10 

    cli 
    hlt 

    ; Pad image to multiple of 512 bytes. 
    times ((0x400) - ($ - $$)) db 0x00 

संकलित करें और चलाएँ:

nasm -f bin -o main.img main.asm 
qemu-system-i386 main.img 

अपेक्षित परिणाम: a स्क्रीन पर मुद्रित हो जाता है, और उसके बाद कार्यक्रम रोकता है।

उबंटू 14.04 पर परीक्षण किया गया।

एक लिंकर स्क्रिप्ट का उपयोग करके सनर जीएएस उदाहरण और अधिक सही प्रारंभिकरण (सेगमेंट रजिस्ट्रार, स्टैक) on my GitHub।