NASM और QEMU पर सबसे सरल कमांड लाइन

तो, इस बिंदु पर सही है। हम लिनक्स के तहत, NASM पर और QEMU का उपयोग करके लिखेंगे। यह स्थापित करना आसान है, इसलिए इस चरण को छोड़ दें।

यह समझा जाता है कि पाठक कम से कम बुनियादी स्तर पर एनएएसएम के वाक्य विन्यास से परिचित है (हालांकि, यहां कुछ भी विशेष रूप से जटिल नहीं होगा) और समझता है कि रजिस्टर क्या हैं।

मूल सिद्धांत

कंप्यूटर चालू होने पर प्रोसेसर शुरू होने वाली पहली चीज BIOS कोड (या UEFI है, लेकिन यहां मैं केवल BIOS के बारे में बात करूंगा), जो कि मदरबोर्ड की मेमोरी में "वायर्ड" है (विशेष रूप से, 0xFFFFFF0 पर)।

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

अगला कदम बूट डिस्क की पहचान करना है जिससे आप ओएस बूट कर सकते हैं। एक बूट डिस्क एक डिस्क (या किसी अन्य ड्राइव) है जिसमें पहले सेक्टर के अंतिम 2 बाइट्स होते हैं (पहला सेक्टर ड्राइव के पहले 512 बाइट्स का मतलब है, क्योंकि 1 सेक्टर = 512 बाइट्स) 55 और एए (हेक्साडेसिमल प्रारूप में) है। जैसे ही एक बूट डिस्क मिलती है, BIOS 0x7c00 के पते पर रैम में अपने पहले 512 बाइट्स को लोड करेगा और इस पते पर प्रोसेसर को कंट्रोल ट्रांसफर करेगा।

बेशक, इन 512 बाइट्स में यह एक पूर्ण ऑपरेटिंग सिस्टम को फिट करने के लिए काम नहीं करेगा। इसलिए, आमतौर पर इस क्षेत्र में प्राथमिक लोडर डालते हैं, जो मुख्य ओएस कोड को रैम में लोड करता है और इसे नियंत्रित करता है।

शुरुआत से ही, प्रोसेसर रियल मोड (= 16-बिट मोड) में चल रहा है। इसका मतलब है कि यह केवल 16-बिट डेटा के साथ काम कर सकता है और खंडित मेमोरी एड्रेसिंग का उपयोग करता है, और केवल 1 एमबी मेमोरी को भी संबोधित कर सकता है। लेकिन हम यहां दूसरे का उपयोग नहीं करेंगे। हमारे कोड पर नियंत्रण स्थानांतरित करते समय नीचे दी गई तस्वीर रैम की स्थिति को दिखाती है (चित्र यहां से लिया गया है )।

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

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

इसके अलावा, प्रत्येक रुकावट का अपना उपसर्ग होता है जो उसके व्यवहार की ख़ासियत को निर्धारित करता है। पाठ प्रारूप (!) में कुछ प्रदर्शित करने के लिए, आपको AH रजिस्टर में मान 0x0e दर्ज करना होगा। इसके अलावा, इंटरप्ट्स के अपने पैरामीटर हैं। 0x10 आह से मान लेता है (एक विशिष्ट सबफंक्शन को परिभाषित करता है) और अल (मुद्रित होने वाला वर्ण)। इस तरह से

mov ah, 0x0e mov al, 'x' int 0x10 

चरित्र 'x' प्रदर्शित करता है। 0x16 आह (विशिष्ट सबफ़ंक्शन) से मान लेता है और दर्ज कुंजी का मान रजिस्टर अल में लोड करता है। हम 0x0 फ़ंक्शन का उपयोग करेंगे।

व्यावहारिक भाग

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

str_compare.asm:

 compare_strs_si_bx: push si ;         push bx push ax comp: mov ah, [bx] ;     , cmp [si], ah ;      ah jne not_equal ;    ,     cmp byte [si], 0 ;    ,    je first_zero ;    inc si ;     bx  si inc bx jmp comp ;   first_zero: cmp byte [bx], 0 ;    bx != 0,  ,   jne not_equal ;  ,    not_equal mov cx, 1 ;     ,  cx = 1 pop si ;     pop bx pop ax ret ;     not_equal: mov cx, 0 ;  ,  cx = 0 pop si ;    pop bx pop ax ret ;     

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

यह भी ध्यान देने योग्य है कि रजिस्टरों AX, BX, CX और DX को दो एकल-बाइट भागों में विभाजित किया गया है: AH, BH, CH और DH उच्च बाइट के लिए, और AL, BL, CL और DL कम बाइट के लिए।

प्रारंभ में, यह माना जाता है कि bx और si में पॉइंटर्स (!) है (जो मेमोरी में एड्रेस को स्टोर करता है) मेमोरी में कुछ एड्रेस पर जिसमें लाइन की शुरुआत स्थित है। ऑपरेशन [बीएक्स] बीएक्स से एक पॉइंटर लेगा, यह इस पते पर जाएगा और वहां से कुछ मूल्य लेगा। inc bx का मतलब है कि अब सूचक मूल पते के तुरंत बाद पते को संदर्भित करेगा।

print_string.asm:

 print_string_si: push ax ;  ax   mov ah, 0x0e ;  ah  0x0e,    call print_next_char ;  pop ax ;  ax ret ;   print_next_char: mov al, [si] ;    cmp al, 0 ;  si  jz if_zero ;     int 0x10 ;     al inc si ;    jmp print_next_char ;   ... if_zero: ret 

एक पैरामीटर के रूप में, फ़ंक्शन एसआई रजिस्टर लेता है और बाइट द्वारा बाइट एक स्ट्रिंग प्रिंट करता है।

अब मुख्य कोड पर चलते हैं। सबसे पहले, सभी चर को परिभाषित करते हैं (यह कोड फ़ाइल के बहुत अंत में होगा):

 ; 0x0d -   , 0xa -    wrong_command: db "Wrong command!", 0x0d, 0xa, 0 greetings: db "The OS is on. Type 'help' for commands", 0x0d, 0xa, 0xa, 0 help_desc: db "Here's nothing to show yet. But soon...", 0x0d, 0xa, 0 goodbye: db 0x0d, 0xa, "Goodbye!", 0x0d, 0xa, 0 prompt: db ">", 0 new_line: db 0x0d, 0xa, 0 help_command: db "help", 0 input: times 64 db 0 ;   - 64  times 510 - ($-$$) db 0 dw 0xaa55 

कैरिज रिटर्न कैरेक्टर कैरिज को स्क्रीन के बाएं किनारे पर ले जाता है, यानी लाइन की शुरुआत में।

 input: times 64 db 0 

इसका मतलब है कि हम इनपुट के लिए बफर के नीचे 64 बाइट आवंटित करते हैं और उन्हें शून्य से भरते हैं।

बाकी चर कुछ जानकारी प्रदर्शित करने के लिए आवश्यक हैं, आगे कोड नीचे आप समझेंगे कि उन्हें सभी की आवश्यकता क्यों है।

 times 510 - ($-$$) db 0 dw 0xaa55 

इसका मतलब है कि हमने स्पष्ट रूप से आउटपुट फ़ाइल का आकार (एक्सटेंशन .bin के साथ) 512 बाइट्स पर सेट किया है, पहले 510 बाइट्स को ज़ीरोस के साथ भरें (बेशक, वे पूरे कोड निष्पादित होने से पहले भरे हुए हैं), और आखिरी दो बाइट्स एक ही "मैजिक" बाइट्स 55 और एए के साथ। । $ का मतलब वर्तमान अनुदेश का पता है, और $ $ हमारे कोड के पहले निर्देश का पता है।

चलिए वास्तविक कोड पर चलते हैं:

 org 0x7c00 ; (1) bits 16 ; (2) jmp start ;    start %include "print_string.asm" ;     %include "str_compare.asm" ; ==================================================== start: mov ah, 0x00 ;   (3) mov al, 0x03 int 0x10 mov sp, 0x7c00 ;   (4) mov si, greetings ;    call print_string_si ;      mainloop 

(1)। यह कमांड NASM को स्पष्ट करता है कि हम कोड को 0x7c00 से शुरू कर रहे हैं। यह इसे स्वचालित रूप से उस पते के सापेक्ष सभी पतों को पूर्वाग्रहित करने की अनुमति देता है ताकि हम स्पष्ट रूप से ऐसा न करें।
(2)। यह कमांड NASM को निर्देश देता है कि हम 16-बिट मोड में काम कर रहे हैं।
(3)। लॉन्च करते समय, QEMU बहुत सारी जानकारी प्रिंट करता है जिसकी हमें आवश्यकता नहीं है। ऐसा करने के लिए, आह 0x00 पर, 0x03 पर सेट करें और 0x10 को कॉल करें ताकि सब कुछ स्क्रीन साफ़ हो सके।
(4)। स्टैक पर रजिस्टरों को बचाने के लिए, आपको यह निर्दिष्ट करना होगा कि एसपी स्टैक पॉइंटर का उपयोग करके इसका शीर्ष किस पते पर स्थित होगा। एसपी स्मृति में उस क्षेत्र को इंगित करेगा जिसमें अगला मूल्य लिखा जाएगा। स्टैक में मान जोड़ें - एसपी 2 बाइट्स से मेमोरी को नीचे चला जाता है (क्योंकि हम रियल मोड में हैं, जहां सभी रजिस्टर ऑपरेंड 16-बिट, यानी डबल-बाइट, मान) हैं। हमने 0x7c00 निर्दिष्ट किया है, इसलिए स्टैक पर मानों को मेमोरी में हमारे कोड के ठीक बगल में संग्रहीत किया जाएगा। एक बार फिर - ढेर नीचे (!) बढ़ता है। इसका मतलब यह है कि स्टैक पर जितने अधिक मूल्य हैं, एसपी स्टैक का सूचक उतनी ही कम मेमोरी इंगित करेगा।

 mainloop: mov si, prompt ;   call print_string_si call get_input ;     jmp mainloop ;  mainloop... 

मुख्य लूप। यहां, प्रत्येक पुनरावृत्ति के साथ, हम ">" वर्ण मुद्रित करते हैं, जिसके बाद हम get_input फ़ंक्शन को कॉल करते हैं, जो कि कीबोर्ड रुकावट के साथ काम करता है।

 get_input: mov bx, 0 ;  bx      input_processing: mov ah, 0x0 ;    0x16 int 0x16 ;  ASCII  cmp al, 0x0d ;   enter je check_the_input ;   ,   ,  ;    cmp al, 0x8 ;   backspace je backspace_pressed cmp al, 0x3 ;   ctrl+c je stop_cpu mov ah, 0x0e ;     -   ;     int 0x10 mov [input+bx], al ;       inc bx ;   cmp bx, 64 ;  input  je check_the_input ;    ,    enter jmp input_processing ;    

(1) [इनपुट + बीएक्स] का मतलब है कि हम इनपुट बफर इनपुट की शुरुआत का पता लेते हैं और इसमें बीएक्स जोड़ते हैं, अर्थात हम बफर के 1 तत्व को bx + प्राप्त करते हैं।

 stop_cpu: mov si, goodbye ;   call print_string_si jmp $ ;    ; $     

यहाँ सब कुछ सरल है - अगर आपने Ctrl + C दबाया है, तो कंप्यूटर केवल jmp $ फंक्शन करता है।

 backspace_pressed: cmp bx, 0 ;  backspace ,  input ,  je input_processing ;    mov ah, 0x0e ;  backspace.  ,   int 0x10 ;   ,      mov al, ' ' ;      ,  int 0x10 ;   mov al, 0x8 ;       int 0x10 ;     backspace dec bx mov byte [input+bx], 0 ;    input   jmp input_processing ;    

बैकस्पेस दबाते समय '>' वर्ण को न मिटाने के लिए, हम जाँचते हैं कि इनपुट खाली है या नहीं। यदि नहीं, तो कुछ भी न करें।

 check_the_input: inc bx mov byte [input+bx], 0 ;     ,   ;  (  '\0'  ) mov si, new_line ;     call print_string_si mov si, help_command ;  si     help mov bx, input ;   bx -   call compare_strs_si_bx ;  si  bx (  help) cmp cx, 1 ; compare_strs_si_bx   cx 1,  ;     je equal_help ;  =>    ;  help jmp equal_to_nothing ;   ,   "Wrong command!" 

यहां, मुझे लगता है कि टिप्पणियों से सब कुछ स्पष्ट है।

 equal_help: mov si, help_desc call print_string_si jmp done equal_to_nothing: mov si, wrong_command call print_string_si jmp done 

जो दर्ज किया गया था, उसके आधार पर, हम या तो help_desc चर का पाठ प्रदर्शित करते हैं या गलत_ पाठ चर का पाठ प्रदर्शित करते हैं।

 ; done    input done: cmp bx, 0 ;     input   je exit ;   ,    mainloop dec bx ;  ,      mov byte [input+bx], 0 jmp done ;       exit: ret 

दरअसल, पूरा कोड है:

prompt.asm:

 org 0x7c00 bits 16 jmp start ;    start %include "print_string.asm" %include "str_compare.asm" ; ==================================================== start: cli ;  ,    ;     mov ah, 0x00 ;   mov al, 0x03 int 0x10 mov sp, 0x7c00 ;   mov si, greetings ;    call print_string_si ;      mainloop mainloop: mov si, prompt ;   call print_string_si call get_input ;     jmp mainloop ;  mainloop... get_input: mov bx, 0 ;  bx      input_processing: mov ah, 0x0 ;    0x16 int 0x16 ;  ASCII  cmp al, 0x0d ;   enter je check_the_input ;   ,   ,  ;    cmp al, 0x8 ;   backspace je backspace_pressed cmp al, 0x3 ;   ctrl+c je stop_cpu mov ah, 0x0e ;     -   ;     int 0x10 mov [input+bx], al ;       inc bx ;   cmp bx, 64 ;  input  je check_the_input ;    ,    enter jmp input_processing ;    stop_cpu: mov si, goodbye ;   call print_string_si jmp $ ;    ; $     backspace_pressed: cmp bx, 0 ;  backspace ,  input ,  je input_processing ;    mov ah, 0x0e ;  backspace.  ,   int 0x10 ;   ,      mov al, ' ' ;      ,  int 0x10 ;   mov al, 0x8 ;       int 0x10 ;     backspace dec bx mov byte [input+bx], 0 ;    input   jmp input_processing ;    check_the_input: inc bx mov byte [input+bx], 0 ;     ,   ;  (  '\0'  ) mov si, new_line ;     call print_string_si mov si, help_command ;  si     help mov bx, input ;   bx -   call compare_strs_si_bx ;  si  bx (  help) cmp cx, 1 ; compare_strs_si_bx   cx 1,  ;     je equal_help ;  =>    ;  help jmp equal_to_nothing ;   ,   "Wrong command!" equal_help: mov si, help_desc call print_string_si jmp done equal_to_nothing: mov si, wrong_command call print_string_si jmp done ; done    input done: cmp bx, 0 ;     input   je exit ;   ,    mainloop dec bx ;  ,      mov byte [input+bx], 0 jmp done ;       exit: ret ; 0x0d -   , 0xa -    wrong_command: db "Wrong command!", 0x0d, 0xa, 0 greetings: db "The OS is on. Type 'help' for commands", 0x0d, 0xa, 0xa, 0 help_desc: db "Here's nothing to show yet. But soon...", 0x0d, 0xa, 0 goodbye: db 0x0d, 0xa, "Goodbye!", 0x0d, 0xa, 0 prompt: db ">", 0 new_line: db 0x0d, 0xa, 0 help_command: db "help", 0 input: times 64 db 0 ;   - 64  times 510 - ($-$$) db 0 dw 0xaa55 

यह सब संकलित करने के लिए, कमांड दर्ज करें:

 nasm -f bin prompt.asm -o bootloader.bin 

और हम आउटपुट पर हमारे कोड के साथ बाइनरी प्राप्त करते हैं। अब इस फ़ाइल के साथ QEMU एमुलेटर चलाएं (-monitor stdio आपको प्रिंट $ reg कमांड का उपयोग करके किसी भी समय रजिस्टर मूल्य प्रदर्शित करने की अनुमति देता है):

 qemu-system-i386 bootloader.bin -monitor stdio 

और हमें आउटपुट मिलता है: