बिना ऑपरेटिंग सिस्टम के प्रोग्राम कैसे चलाएं

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

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

तो, लक्ष्य: जितना संभव हो उतना कम प्रयास में खर्च करने के बाद, अपने स्वयं के बूट करने योग्य यूएसबी फ्लैश ड्राइव बनाएं, जो कंप्यूटर स्क्रीन पर केवल क्लासिक "हैलो वर्ल्ड" प्रिंट करता है।

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

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

यदि आप लिनक्स उबंटू का उपयोग कर रहे हैं, तो आपको पहले कई उपयोगिताओं को स्थापित करना होगा:
1. ग्रब। ऐसा करने के लिए, कमांड का उपयोग करें:

sudo apt-get install grub 

2. क्यूमू। यह जल्दी से परीक्षण करने और सब कुछ डिबग करने की आवश्यकता है, इसके लिए कमांड समान है:

 sudo apt-get install qemu 

अब हमारी योजना इस प्रकार है:
1. एक C प्रोग्राम बनाएं जो स्क्रीन पर एक लाइन प्रिंट करता है।
2. इसे मिनीबूट प्रारूप में एक छवि (कर्नेल.बिन) से संकलित करें ताकि यह GRUB का उपयोग करके डाउनलोड के लिए उपलब्ध हो।
3. बूट डिस्क छवि फ़ाइल बनाएं और उसे प्रारूपित करें।
4. इस छवि पर ग्रब स्थापित करें।
5. डिस्क पर बनाए गए प्रोग्राम (kernel.bin) को कॉपी करें।
6. छवि को भौतिक मीडिया में लिखें या इसे qemu में चलाएं।

और सिस्टम बूट प्रक्रिया:


इसे काम करने के लिए, आपको कई फाइलें और निर्देशिकाएँ बनाने की आवश्यकता होगी:

kernel.c	सी में लिखा गया प्रोग्राम कोड। प्रोग्राम स्क्रीन पर एक संदेश प्रिंट करता है।
makefile	मेकफाइल, एक स्क्रिप्ट जो प्रोग्राम की पूरी असेंबली चलाती है और एक बूट इमेज बनाती है।
linker.ld	कर्नेल के लिए लिंक स्क्रिप्ट।
loader.s	असेंबलर कोड जिसे ग्रब द्वारा बुलाया जाता है और सी प्रोग्राम से मुख्य फ़ंक्शन को नियंत्रित करता है।
शामिल करें /	हेडर फ़ाइलों के साथ फ़ोल्डर।
ग्रब /	ग्रब फ़ाइल फ़ोल्डर।
सामान्य /	सामान्य प्रयोजन कार्यों के साथ फ़ोल्डर। जिसमें प्रिंटफ का कार्यान्वयन भी शामिल है।

चरण 1. लक्ष्य कार्यक्रम का कोड बनाना (कर्नेल):

एक कर्नेल बनाएँ। फ़ाइल में निम्न कोड होगा जो स्क्रीन पर एक संदेश प्रिंट करता है:

 #include "printf.h" #include "screen.h" #include "types.h" void main(void) { clear_screen(); printf("\n>>> Hello World!\n"); } 

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

0x1BADB002 = मैजिक	मल्टीबूट हस्ताक्षर
0x0 = फ्लैग	फ़्लेग जिसमें लोडर द्वारा पारित कर्नेल (हमारे प्रोग्राम) को लोड करने के लिए अतिरिक्त आवश्यकताएं होती हैं। इस स्थिति में, सभी झंडे रीसेट हो जाते हैं।
0xE4524FFE = - (मैजिक + फ्लैग)	Checksum।

यदि ये सभी शर्तें पूरी हो जाती हैं, तो ग्रब% eax से होकर गुजरता है और% ebx मल्टीबूट सूचना संरचना और क्रमशः 0x1BADB002 के मान के लिए एक संकेतक दर्ज करता है। मल्टीबूट सूचना संरचना में विभिन्न जानकारी शामिल हैं, जिसमें लोड किए गए मॉड्यूल की सूची और उनका स्थान शामिल है, जो सिस्टम के आगे लोड करने के लिए आवश्यक हो सकता है।
प्रोग्राम फ़ाइल के लिए आवश्यक हस्ताक्षर करने के लिए, निम्नलिखित सामग्री के साथ एक लोडर। S फ़ाइल बनाएँ:

 .text .global loader # making entry point visible to linker # setting up the Multiboot header - see GRUB docs for details .set FLAGS, 0x0 # this is the Multiboot 'flag' field .set MAGIC, 0x1BADB002 # 'magic number' lets bootloader find the header .set CHECKSUM, -(MAGIC + FLAGS) # checksum required .align 4 .long MAGIC .long FLAGS .long CHECKSUM # reserve initial kernel stack space .set STACKSIZE, 0x4000 # that is, 16k. .lcomm stack, STACKSIZE # reserve 16k stack .comm mbd, 4 # we will use this in kmain .comm magic, 4 # we will use this in kmain loader: movl $(stack + STACKSIZE), %esp # set up the stack movl %eax, magic # Multiboot magic number movl %ebx, mbd # Multiboot data structure call main # call C code cli hang: hlt # halt machine should kernel return jmp hang 

अधिक विस्तार से कोड पर विचार करें। यह कोड wiki.osdev.org/Bare_Bones से लगभग अपरिवर्तित है। चूंकि gcc का उपयोग संकलन के लिए किया जाता है, GAS सिंटैक्स का उपयोग किया जाता है। आइए इस कोड के बारे में जानकारी लेते हैं।

 .text 

बाद के सभी कोड निष्पादन योग्य अनुभाग में आ जाएंगे।

 .global loader 

हम लिंकर को दिखाई देने वाले लोडर प्रतीक की घोषणा करते हैं। यह आवश्यक है क्योंकि लिंकर लोडर का उपयोग एक प्रवेश बिंदु के रूप में करेगा।

  .set FLAGS, 0x0 #  FLAGS = 0x0 .set MAGIC, 0x1BADB002 #  MAGIC = 0x1BADB002 .set CHECKSUM, -(MAGIC + FLAGS) #  CHECKSUM = -(MAGIC + FLAGS) .align 4 #     4  .long MAGIC #      MAGIC .long FLAGS #      FLAGS .long CHECKSUM #      CHECKSUM 

यह कोड मल्टीबूट प्रारूप का एक हस्ताक्षर बनाता है। .सेट निर्देश, वर्ण के मान को अल्पविराम के दाईं ओर सेट करता है। .Align 4 निर्देश 4 बाइट्स के बाद की सामग्री को संरेखित करता है। लंबा निर्देश अगले चार बाइट्स में मूल्य संग्रहीत करता है।

  .set STACKSIZE, 0x4000 #  STACKSIZE = 0x4000 .lcomm stack, STACKSIZE #  STACKSIZE . stack    .comm mbd, 4 #  4    mdb   COMMON .comm magic, 4 #  4    magic   COMMON 

बूट प्रक्रिया के दौरान, ग्रब स्टैक को कॉन्फ़िगर नहीं करता है, और सबसे पहले कर्नेल को स्टैक को कॉन्फ़िगर करना चाहिए, इसके लिए हम 0x4000 (16Kb) बाइट्स आरक्षित करते हैं। .Bcomm निर्देश में .lcomm निर्देश को दशमलव बिंदु के बाद निर्दिष्ट बाइट्स की संख्या अनुभाग में रखा गया है। नाम स्टैक केवल संकलित फ़ाइल में दिखाई देगा। .Comm निर्देश .lcomm के समान है, लेकिन प्रतीक नाम विश्व स्तर पर घोषित किया जाएगा। इसका मतलब यह है कि सी कोड में निम्नलिखित पंक्ति लिखकर हम इसका उपयोग कर सकते हैं।
बाहरी जादू

और अब अंतिम भाग:

 loader: movl $(stack + STACKSIZE), %esp #   movl %eax, magic #  %eax   magic movl %ebx, mbd #  %ebx   mbd call main #   main cli #     hang: hlt #       jmp hang #    hang 

पहला निर्देश% esp रजिस्टर में स्टैक के शीर्ष के मूल्य को बचाता है। जैसे ही स्टैक बढ़ता है, स्टैक के लिए आवंटित सीमा के अंत का पता% esp में लिखा जाता है। 4 बाद की आरक्षित श्रेणियों में दो बाद के निर्देशों की दुकान उन मूल्यों को मानती है जो ग्रब% ex,% ईबेक्स रजिस्टरों में गुजरती हैं। फिर मुख्य फ़ंक्शन, जो पहले से ही सी में लिखा गया है, कहा जाता है। यदि आप इस प्रक्रिया से लौटते हैं, तो प्रोसेसर लूप करेगा।

चरण 2. कार्यक्रम (सिस्टम लाइब्रेरी) के लिए अतिरिक्त कोड तैयार करना:

चूंकि पूरे कार्यक्रम को स्क्रैच से लिखा जाता है, इसलिए प्रिंटफ़ फ़ंक्शन को स्क्रैच से लिखा जाना चाहिए। ऐसा करने के लिए, कई फाइलें तैयार करें।
एक सामान्य बनाएं और फ़ोल्डर शामिल करें:

 mkdir common mkdir include 

एक फ़ाइल सामान्य \ printf.c बनाएँ जिसमें परिचित प्रिंटफ़ फ़ंक्शन का कार्यान्वयन होगा। यह पूरी फाइल www.bitvisor.org प्रोजेक्ट से ली जा सकती है। बिटविज़र के स्रोतों में फ़ाइल का पथ: core / printf.c। बिटवाइज़र से कॉपी की गई प्रिंटफ़। सी। फ़ाइल में, लक्ष्य कार्यक्रम में उपयोग के लिए, आपको लाइनों को बदलने की आवश्यकता है:

 #include "initfunc.h" #include "printf.h" #include "putchar.h" #include "spinlock.h" 

प्रति पंक्ति:

 #include "types.h" #include "stdarg.h" #include "screen.h" 

फिर, इस फ़ाइल में printf_init_global फ़ंक्शन और उसके सभी संदर्भों को हटा दें:

 static void printf_init_global (void) { spinlock_init (&printf_lock); } INITFUNC ("global0", printf_init_global); 

फिर इस फ़ाइल में प्रिंटफ़्लॉक चर और इसके सभी संदर्भ हटा दें:

 static spinlock_t printf_lock; … spinlock_lock (&printf_lock); … spinlock_unlock (&printf_lock); 

प्रिंटफ फ़ंक्शन पुचर फ़ंक्शन का उपयोग करता है, जिसे लिखना भी आवश्यक है। ऐसा करने के लिए, निम्न सामग्री के साथ फ़ाइल को सामान्य \ screen.c बनाएँ:

 #include "types.h" #define GREEN 0x2 #define MAX_COL 80 // Maximum number of columns #define MAX_ROW 25 // Maximum number of rows #define VRAM_SIZE (MAX_COL*MAX_ROW) // Size of screen, in short's #define DEF_VRAM_BASE 0xb8000 // Default base for video memory static unsigned char curr_col = 0; static unsigned char curr_row = 0; // Write character at current screen location #define PUT(c) ( ((unsigned short *) (DEF_VRAM_BASE)) \ [(curr_row * MAX_COL) + curr_col] = (GREEN << 8) | (c)) // Place a character on next screen position static void cons_putc(int c) { switch (c) { case '\t': do { cons_putc(' '); } while ((curr_col % 8) != 0); break; case '\r': curr_col = 0; break; case '\n': curr_row += 1; if (curr_row >= MAX_ROW) { curr_row = 0; } break; case '\b': if (curr_col > 0) { curr_col -= 1; PUT(' '); } break; default: PUT(c); curr_col += 1; if (curr_col >= MAX_COL) { curr_col = 0; curr_row += 1; if (curr_row >= MAX_ROW) { curr_row = 0; } } }; } void putchar( int c ) { if (c == '\n') cons_putc('\r'); cons_putc(c); } void clear_screen( void ) { curr_col = 0; curr_row = 0; int i; for (i = 0; i < VRAM_SIZE; i++) cons_putc(' '); curr_col = 0; curr_row = 0; } 

निर्दिष्ट कोड में पाठ मोड में स्क्रीन पर वर्ण मुद्रित करने के लिए सरल तर्क हैं। इस मोड में, एक चरित्र लिखने के लिए दो बाइट्स का उपयोग किया जाता है (एक चरित्र कोड के साथ, दूसरा इसकी विशेषताओं के साथ), सीधे स्क्रीन पर प्रदर्शित वीडियो मेमोरी के लिए सीधे लिखा जाता है और पता 0xB8000 से शुरू होता है। स्क्रीन रिज़ॉल्यूशन 80x25 अक्षर है। चरित्र सीधे PUT मैक्रो का उपयोग करके मुद्रित किया जाता है।
अब केवल कुछ हेडर फाइलें गायब हैं:
1. फ़ाइल में \ screen.h शामिल है। एक पुचकार फ़ंक्शन की घोषणा करता है, जिसका उपयोग प्रिंटफ़ फ़ंक्शन में किया जाता है। फ़ाइल सामग्री:

 #ifndef _SCREEN_H #define _SCREEN_H void clear_screen( void ); void putchar( int c ); #endif 

2. फ़ाइल में \ printf.h शामिल है। प्रिंटफ फ़ंक्शन की घोषणा करता है, जिसका उपयोग मुख्य रूप से किया जाता है। फ़ाइल सामग्री:

 #ifndef _PRINTF_H #define _PRINTF_H int printf (const char *format, ...); #endif 

3. फ़ाइल में \ stdarg.h शामिल है। उन तर्कों पर कार्य करने की घोषणा करता है जिनकी संख्या पहले से ज्ञात नहीं है। पूरी फाइल www.bitvisor.org प्रोजेक्ट से ली गई है। बिटविज़र प्रोजेक्ट कोड में फ़ाइल का पथ: \ core \ stdarg.h शामिल करें।
4. फ़ाइल में \ type.h शामिल है। NULL और size_t की घोषणा करता है। फ़ाइल सामग्री:

 #ifndef _TYPES_H #define _TYPES_H #define NULL 0 typedef unsigned int size_t; #endif 

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

चरण 3. लिंकर के लिए एक स्क्रिप्ट बनाना:

हम linker.ld फ़ाइल बनाते हैं, जिसका उपयोग लिंकर द्वारा टार्गेट प्रोग्राम फ़ाइल (k गिने.बिन) बनाने के लिए किया जाएगा। फ़ाइल में निम्नलिखित शामिल होना चाहिए:

 ENTRY (loader) LMA = 0x00100000; SECTIONS { . = LMA; .multiboot ALIGN (0x1000) : { loader.o( .text ) } .text ALIGN (0x1000) : { *(.text) } .rodata ALIGN (0x1000) : { *(.rodata*) } .data ALIGN (0x1000) : { *(.data) } .bss : { *(COMMON) *(.bss) } /DISCARD/ : { *(.comment) } } 

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


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

 SECTIONS 

कहते हैं कि वर्गों का आगे वर्णन किया गया है।

 . = LMA; 

यह अभिव्यक्ति लिंकर को इंगित करता है कि सभी बाद के अनुभाग एलएमए पते के बाद हैं।

  ALIGN (0x1000) 

ऊपर दिए गए निर्देश का अर्थ है कि अनुभाग 0x1000 बाइट्स से संरेखित है।

 .multiboot ALIGN (0x1000) : { loader.o( .text ) } 

एक अलग मल्टीबूट अनुभाग, जिसमें लोडर .o फ़ाइल से .text खंड शामिल है, यह सुनिश्चित करने के लिए डिज़ाइन किया गया है कि मल्टीबूट प्रारूप का हस्ताक्षर कर्नेल छवि के पहले 8kb में मिलता है।

 .bss : { *(COMMON) *(.bss) } 

* (COMMON) वह क्षेत्र है जिसमें मेमोरी को निर्देश .comm और .lcomm द्वारा आरक्षित किया जाता है। हम इसे .bs अनुभाग में रखते हैं।

 /DISCARD/ : { *(.comment) } 

DISCARD चिह्नित सभी खंड छवि से हटा दिए गए हैं। इस स्थिति में, हम .comment सेक्शन को हटा देते हैं, जिसमें लिंकर के संस्करण के बारे में जानकारी होती है।

अब कोड को एक बाइनरी फ़ाइल में निम्न कमांड के साथ संकलित करें:

 as -o loader.o loader.s gcc -Iinclude -Wall -fno-builtin -nostdinc -nostdlib -o kernel.o -c kernel.c gcc -Iinclude -Wall -fno-builtin -nostdinc -nostdlib -o printf.o -c common/printf.c gcc -Iinclude -Wall -fno-builtin -nostdinc -nostdlib -o screen.o -c common/screen.c ld -T linker.ld -o kernel.bin kernel.o screen.o printf.o loader.o 

Objdump का उपयोग करते हुए, हम यह देखेंगे कि लिंक करने के बाद कर्नेल की छवि कैसी दिखती है:

 objdump -ph ./kernel.bin 

जैसा कि आप देख सकते हैं, छवि में अनुभाग उन लोगों के साथ मेल खाते हैं जिन्हें हमने लिंकर स्क्रिप्ट में वर्णित किया था। लिंकर ने वर्णित वर्गों से 3 खंडों का गठन किया। पहले खंड में .multiboot, .text, .rodata और एक आभासी और भौतिक पता 0x00100000 शामिल हैं। दूसरे खंड में .data और .bs वर्ग शामिल हैं और 0x00104000 पर स्थित है। तो सब कुछ ग्रब का उपयोग करके इस फ़ाइल को डाउनलोड करने के लिए तैयार है।

चरण 4. ग्रब बूटलोडर तैयार करना:
ग्रब फ़ोल्डर बनाएँ:

 mkdir grub 

इस फ़ोल्डर में कई ग्रब फ़ाइलों की प्रतिलिपि बनाएँ जो छवि पर इसे स्थापित करने के लिए आवश्यक हैं (निम्न फ़ाइलें मौजूद हैं यदि ग्रब सिस्टम पर स्थापित है)। ऐसा करने के लिए, निम्न आदेश चलाएँ:

 cp /usr/lib/grub/i386-pc/stage1 ./grub/ cp /usr/lib/grub/i386-pc/stage2 ./grub/ cp /usr/lib/grub/i386-pc/fat_stage1_5 ./grub/ 

निम्नलिखित सामग्री के साथ एक ग्रब / मेनू.लस्ट फ़ाइल बनाएँ:

 timeout 3 default 0 title mini_os root (hd0,0) kernel /kernel.bin 

चरण 5. स्वचालित करें और बूट छवि बनाएं:

बिल्ड प्रक्रिया को स्वचालित करने के लिए, हम मेक यूटिलिटी का उपयोग करेंगे। ऐसा करने के लिए, एक मेकफाइल बनाएं जो स्रोत कोड को संकलित करने के लिए संकलन करेगा, कर्नेल को संकलित करें और एक बूट छवि बनाएं। मेकफाइल में निम्नलिखित सामग्री होनी चाहिए:

 CC = gcc CFLAGS = -Wall -fno-builtin -nostdinc -nostdlib LD = ld OBJFILES = \ loader.o \ common/printf.o \ common/screen.o \ kernel.o image: @echo "Creating hdd.img..." @dd if=/dev/zero of=./hdd.img bs=512 count=16065 1>/dev/null 2>&1 @echo "Creating bootable first FAT32 partition..." @losetup /dev/loop1 ./hdd.img @(echo c; echo u; echo n; echo p; echo 1; echo ; echo ; echo a; echo 1; echo t; echo c; echo w;) | fdisk /dev/loop1 1>/dev/null 2>&1 || true @echo "Mounting partition to /dev/loop2..." @losetup /dev/loop2 ./hdd.img \ --offset `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk '{print $$3}'\`*512 | bc` \ --sizelimit `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk '{print $$4}'\`*512 | bc` @losetup -d /dev/loop1 @echo "Format partition..." @mkdosfs /dev/loop2 @echo "Copy kernel and grub files on partition..." @mkdir -p tempdir @mount /dev/loop2 tempdir @mkdir tempdir/boot @cp -r grub tempdir/boot/ @cp kernel.bin tempdir/ @sleep 1 @umount /dev/loop2 @rm -r tempdir @losetup -d /dev/loop2 @echo "Installing GRUB..." @echo "device (hd0) hdd.img \n \ root (hd0,0) \n \ setup (hd0) \n \ quit\n" | grub --batch 1>/dev/null @echo "Done!" all: kernel.bin rebuild: clean all .so: as -o $@ $< .co: $(CC) -Iinclude $(CFLAGS) -o $@ -c $< kernel.bin: $(OBJFILES) $(LD) -T linker.ld -o $@ $^ clean: rm -f $(OBJFILES) hdd.img kernel.bin 

फ़ाइल में दो मुख्य लक्ष्य घोषित किए गए हैं: सभी - कर्नेल, और छवि को संकलित करता है - जो बूट डिस्क बनाता है। सामान्य मेकफाइल की तरह सभी टारगेट में .so और .co के सबगोल्स होते हैं, जो * .s और * .c फाइलों को ऑब्जेक्ट फाइल्स (* .o) में संकलित करते हैं, साथ ही कर्नेल.बिना उत्पन्न करने के लिए एक टारगेट बनाते हैं, जो लिंकर को पहले बनाई गई स्क्रिप्ट के साथ कॉल करता है। ये लक्ष्य चरण 3 में सूचीबद्ध समान कमांड्स का प्रदर्शन करते हैं।
यहां सबसे बड़ी रुचि बूट छवि HDd.img (लक्ष्य छवि) का निर्माण है। आइए हम चरणों में विचार करें कि यह कैसे होता है।

 dd if=/dev/zero of=./hdd.img bs=512 count=16065 1>/dev/null 2>&1 

यह कमांड एक छवि बनाता है जिसके साथ आगे काम होगा। सेक्टरों की संख्या संयोग से नहीं चुना गया था: 16065 = 255 * 63. डिफ़ॉल्ट रूप से, डिस्क के साथ fdsik काम करता है जैसे कि इसमें CHS ज्यामिति थी, जिसमें हेडर (H) = 255, सेक्टर (S) = 63, और Cindenders (C) निर्भर करता है। डिस्क का आकार। इस प्रकार, डिफ़ॉल्ट डिस्क ज्यामिति को बदलने के बिना fdsik के साथ काम करने वाला न्यूनतम डिस्क आकार 512 * 255 * 63 * 1 = 8225280 बाइट्स है, जहां 512 क्षेत्र का आकार है और 1 सिलेंडर की संख्या है।
अगला, एक विभाजन तालिका बनाई गई है:

 losetup /dev/loop1 ./hdd.img (echo c; echo u; echo n; echo p; echo 1; echo ; echo ; echo a; echo 1; echo t; echo c; echo w;) | fdisk /dev/loop1 1>/dev/null 2>&1 || true 

पहला कमांड ब्लॉक डिवाइस / देव / लूप 1 के लिए hdd.img फाइल को माउंट करता है, जिससे आप फाइल को डिवाइस के रूप में काम कर सकते हैं। दूसरा कमांड डिवाइस / देव / लूप 1 पर एक विभाजन तालिका बनाता है, जिसमें FAT32 फाइल सिस्टम लेबल के साथ डिस्क का 1 प्राथमिक बूट विभाजन होता है, जो संपूर्ण डिस्क पर कब्जा कर लेता है।
फिर हम निर्मित अनुभाग को प्रारूपित करते हैं। ऐसा करने के लिए, इसे ब्लॉक डिवाइस के रूप में माउंट करें और फ़ॉर्मेटिंग निष्पादित करें।

 losetup /dev/loop2 ./hdd.img \ --offset `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk '{print $$3}'\`*512 | bc` \ --sizelimit `echo \`fdisk -lu /dev/loop1 | sed -n 10p | awk '{print $$4}'\`*512 | bc` losetup -d /dev/loop1 

पहला कमांड डिवाइस / देव / लूप 2 में पहले से बने विभाजन को मापता है। –ऑफ़सेट विकल्प अनुभाग की शुरुआत का पता निर्दिष्ट करता है, और अनुभाग के अंत का पता -sizelimit। दोनों मापदंडों को fdisk कमांड का उपयोग करके प्राप्त किया जाता है।

 mkdosfs /dev/loop2 

Mkdosfs उपयोगिता FAT32 फ़ाइल सिस्टम में एक विभाजन को प्रारूपित करती है।
कर्नेल की प्रत्यक्ष असेंबली के लिए, पहले से चर्चा की गई कमांड का उपयोग क्लासिक मेकफाइल सिंटैक्स में किया जाता है।
अब विचार करें कि विभाजन पर GRUB कैसे स्थापित करें:

 mkdir -p tempdir #    mount /dev/loop2 tempdir #     mkdir tempdir/boot #   /boot   cp -r grub tempdir/boot/ #   grub  /boot cp kernel.bin tempdir/ #      sleep 1 #  Ubuntu umount /dev/loop2 #    rm -r tempdir #    losetup -d /dev/loop2 #   

उपरोक्त आदेशों को निष्पादित करने के बाद, छवि GRUB स्थापित करने के लिए तैयार होगी। निम्न कमांड GRd को hdd.img डिस्क छवि के MBR में स्थापित करता है।

 echo "device (hd0) hdd.img \n \ root (hd0,0) \n \ setup (hd0) \n \ quit\n" | grub --batch 1>/dev/null 

सब कुछ परीक्षण के लिए तैयार है!

चरण 6. लॉन्च करें:

संकलन करने के लिए, कमांड का उपयोग करें:

 make all 

जिसके बाद कर्नेल.बिन फ़ाइल दिखनी चाहिए।
बूट डिस्क छवि बनाने के लिए, कमांड का उपयोग करें:

 sudo make image 

परिणामस्वरूप, hdd.img फ़ाइल दिखाई देनी चाहिए।
अब आप hdd.img डिस्क इमेज से बूट कर सकते हैं। आप इसे निम्न कमांड से सत्यापित कर सकते हैं:

 qemu -hda hdd.img -m 32 

या:

 qemu-system-i386 -hda hdd.img 

एक असली मशीन पर जांच करने के लिए, आपको इस छवि की dd को एक फ्लैश ड्राइव पर बनाना होगा और उससे बूट करना होगा। उदाहरण के लिए, इस आदेश के साथ:

 sudo dd if=./hdd.img of=/dev/sdb 

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

श्रृंखला में निम्नलिखित लेखों के लिंक:
" ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाया जाए: भाग 2 "
" ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 3: ग्राफिक्स "
" कैसे एक ऑपरेटिंग सिस्टम के बिना एक कार्यक्रम चलाने के लिए: भाग 4. समानांतर कंप्यूटिंग "
" ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाना है: भाग 5. ओएस से BIOS तक पहुंचना "
" ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 6. FAT फाइल सिस्टम के साथ डिस्क के साथ काम करने के लिए समर्थन "