ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 6. FAT फाइल सिस्टम के साथ डिस्क के साथ काम करने के लिए समर्थन

लेखों की हमारी श्रृंखला के पांचवें भाग में, हमने दिखाया कि आप संरक्षित मोड में स्विच करने के बाद BIOS इंटरप्ट का उपयोग कैसे कर सकते हैं, और एक उदाहरण के रूप में हमने रैम के आकार को निर्धारित किया। आज हम इस सफलता को विकसित करेंगे और FAT16 और FAT32 फाइल सिस्टम के साथ काम करने के लिए पूर्ण समर्थन को लागू करेंगे। डिस्क पर फ़ाइलों के साथ काम 2 भागों में विभाजित किया जा सकता है: फ़ाइल सिस्टम के साथ काम करें और रीड / राइट सेक्टर पर डिस्क के साथ काम करें। हम कह सकते हैं कि इसके लिए हमें फाइल सिस्टम के "ड्राइवर" और डिस्क के "ड्राइवर" को लिखना होगा।

पढ़ने / लिखने के क्षेत्रों के स्तर पर डिस्क के साथ काम करें

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

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

यह स्पष्ट है कि 8GB बहुत छोटा है, और संबोधित करने का यह तरीका पुराना है, और सभी आधुनिक (और ऐसा नहीं है) हार्ड डिस्क कंट्रोलर LBA एड्रेसिंग का समर्थन करते हैं। एलबीए डिस्क ज्यामिति से सार को संबोधित करता है और प्रत्येक क्षेत्र को एक अलग संख्या प्रदान करता है। सेक्टर नंबरिंग खरोंच से शुरू होती है। LBA ब्लॉक संख्या निर्दिष्ट करने के लिए 48 बिट्स का उपयोग करता है, जो 512 बाइट्स के सेक्टर आकार को ध्यान में रखते हुए 128 PiB को संबोधित करने की अनुमति देता है। व्यवधान int0x13 एलबीए का उपयोग करके डिस्क को पढ़ने और लिखने के लिए दो सेवाएं प्रदान करता है। हम उनका उपयोग करेंगे। किसी सेक्टर को पढ़ने के लिए, in0x13 इंटरप्ट निम्न मापदंडों की अपेक्षा करता है:



डीएपी संरचना:



व्यवधान निम्नलिखित मान लौटाता है:



मापदंडों में से एक डिस्क नंबर है। हमें किसी तरह डिस्क संख्या का पता लगाने की आवश्यकता है जिसके साथ हम काम करने जा रहे हैं। नंबरिंग इस प्रकार है: फ्लॉपी डिस्क (fdd), और सब कुछ जो फ्लॉपी के रूप में अनुकरण किया जाता है, खरोंच और हार्ड डिस्क (hdd) से क्रमांकित किया जाता है, और सब कुछ जो उनके जैसा अनुकरण किया जाता है (usb फ्लैश ड्राइव, उदाहरण के लिए) 0x80 से गिने जाते हैं। इस नंबर का BIOS सेटिंग्स में बूट अनुक्रम से कोई लेना-देना नहीं है। हमारे मामले में, जिस डिस्क के साथ हम काम करने जा रहे हैं वह डिस्क है जिसमें से हमने बूट किया था।

जब BIOS एमबीआर नियंत्रण को स्थानांतरित करता है, तो वह इसे 0000h: 7C00h पते पर लोड करता है, और डीएल रजिस्टर में यह बूट डिवाइस नंबर को स्थानांतरित करता है जिसकी हमें आवश्यकता होती है। यह BIOS और MBR के बीच इंटरफेस का हिस्सा है। इस प्रकार, यह संख्या GRUB में आती है, जहां तब इसका उपयोग डिस्क के साथ काम करने के लिए किया जाता है। GRUB, बदले में, इस OS नंबर को मल्टीबूट सूचना संरचना के हिस्से के रूप में पास करता है।

GRUB से OS पर नियंत्रण स्थानांतरित करने के ठीक बाद, इस संरचना का एक सूचक EBX रजिस्टर में स्थित है। संरचना का पहला क्षेत्र झंडे है, और यदि इसमें 2 बिट सेट है, तो boot_device फ़ील्ड सही है। यह फ़ील्ड मल्टीबूट सूचना संरचना से भी संबंधित है और इसकी उच्च बाइट में (फ़ील्ड का आकार 4 बाइट्स है) हमें जिस डिस्क नंबर की आवश्यकता होती है उसे संग्रहीत किया जाता है, जो inter0x13 इंटरप्ट को समझता है। इस प्रकार, GRUB का उपयोग करते हुए, हमें डिस्क को पढ़ने / लिखने के क्षेत्रों के लिए लापता पैरामीटर मिला।

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



विभाजन तालिका में विभाजन जानकारी संग्रहीत है। एक डिस्क पर केवल 4 प्राथमिक विभाजन हो सकते हैं जिससे आप बूट कर सकते हैं। प्रति सेक्शन प्रविष्टि में 8 बाइट्स हैं। पहला बाइट ध्वज है, यदि इसका मान 0x80 है, तो विभाजन बूट करने योग्य है। अपने काम के दौरान एमबीआर कोड बूट विभाजन की तलाश में इन 4 खंडों के माध्यम से चलता है। अपनी खोज के बाद, एमबीआर इस खंड के पहले सेक्टर की सामग्री को 0000h: 7C00h और ट्रांसपोर्ट कंट्रोल को संबोधित करता है। हम बूट विभाजन के पहले क्षेत्र के LBA पते में रुचि रखते हैं, क्योंकि यह इस पर है कि हमारा कर्नेल स्थित है, और एक फाइल सिस्टम है जिसे हम पढ़ने जा रहे हैं। इस पते को प्राप्त करने के लिए, आपको डिस्क के पहले सेक्टर को पढ़ने की जरूरत है, उस पर विभाजन तालिका ढूंढें, विभाजन तालिका में बूट विभाजन को ढूंढें, और इसके रिकॉर्ड से वांछित क्षेत्र को पढ़ें।

तो, हमारे पास डिस्क से एक सेक्टर को पढ़ने और विभाजन के स्थान के बारे में जानने के लिए एक तंत्र है जो हमें डिस्क पर चाहिए। यह जानने के लिए रहता है कि इस खंड में फ़ाइल सिस्टम के साथ कैसे काम किया जाए।

फ़ाइल सिस्टम के साथ काम करें

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

int media_read(uint32 sector, uint8 *buffer, uint32 sector_count); int media_write(uint32 sector, uint8 *buffer, uint32 sector_count); Return: int, 1 = success, 0 = failure. 

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

इसलिए, हमारे पास विभाजन के लिए एक सेक्टर को पढ़ने / लिखने के लिए कार्य हैं और FAT16 / 32 के साथ काम करने के लिए एक पुस्तकालय है जो इन कार्यों का उपयोग करता है। यह सब कुछ एक साथ रखने और परिणाम प्रदर्शित करने के लिए बनी हुई है। लेकिन कोड पर जाने से पहले, मैं यह बताना चाहूंगा कि हम जिस दृष्टिकोण का उपयोग करने जा रहे हैं वह वास्तविक जीवन में काफी लागू है। नीचे VBR विंडोज 7 का एक छोटा सा हिस्सा है, जिसमें डिस्क सेक्टर को int0x13 इंटरप्ट के माध्यम से पढ़ा जाता है। इस कोड को बार-बार सिस्टम बूट प्रक्रिया के दौरान कहा जाता है, बूट एनीमेशन को प्रस्तुत करने के क्षण तक।



इस कोड को कॉल करने के लिए, विंडोज 7, हम इसे कैसे करते हैं के समान है, संरक्षित मोड से वास्तविक मोड में जाता है, और इसके विपरीत। यह QEMU में विंडोज 7 चलाकर सत्यापित करना आसान है। QEMU को कनेक्ट करने के लिए डीबगर का इंतजार करना चाहिए। डिबगर (जीडीबी) को जोड़ने के बाद हमने ब्रेकप्वाइंट को एड्रेस (0x7c00 + 0x11d) पर सेट किया। ट्रिगर ब्रेकपाइंट का अर्थ होगा इस फ़ंक्शन को कॉल करना। वैसे, विंडोज एक्सपी में यह तंत्र अनुपस्थित है, BIOS व्यवधान पैदा करने के लिए, वे वहां VM86 मोड पर स्विच करते हैं।

! महत्वपूर्ण! हमारे लेखों की श्रृंखला के पांचवें भाग से सभी चरणों को सफलतापूर्वक पारित करने के बाद ही सभी आगे की कार्रवाई को सफलतापूर्वक पूरा किया जा सकता है

चरण 1. कर्नेल में मुख्य तर्क बदलें

1. कर्नेल में निम्न घोषणाएँ जोड़ें। फ़ाइल:

 #include "multiboot.h" #include "fat_io_lib/fat_filelib.h" //    loader.s extern u32 mbd; extern u32 magic; 

कोड रैम के आकार को प्रिंट करता है

 u64 ram_size = GetRamsize(); printf("ram_size = %llu(%lluMb)\n", ram_size, ram_size / 0x100000); 

निम्नलिखित कोड से बदलें:

 // ,    grub- if (magic != MULTIBOOT_BOOTLOADER_MAGIC) { printf("Invalid magic number: 0x%x\n", magic); return; } multiboot_info_t *p_multiboot_info = (multiboot_info_t*)mbd; // Is boot_device valid? if ((p_multiboot_info->flags & 2) == 0) { printf("Error: boot_device(2) flag is clear\n"); return; } //      if (InitBootMedia(p_multiboot_info->boot_device >> 24) == 0) { printf("Error: InitBootMedia failed.\n"); return; } //   fat_io_lib fl_init(); if (fl_attach_media(ReadBootMedia, WriteBootMedia) != FAT_INIT_OK) { printf("Error: Media attach failed.\n"); return; } //      /boot/grub fl_listdirectory("/boot/grub"); //   /boot/grub/menu.lst   char str[64]; void *file = fl_fopen("/boot/grub/menu.lst", "r"); if (file == 0) { printf("Error: can not open file.\n"); return; } printf("\nConntent of the file /boot/grub/menu.lst:\n"); while (fl_fgets(str, sizeof(str), file)) { printf("%s", str); } 

Mbd और मैजिक वैरिएबल के लिए मेमोरी लोडर.एस फाइल में आरक्षित है, इसलिए उन्हें C कोड से वैश्विक वैरिएबल के समान उपयोग किया जा सकता है। मैजिक वैरिएबल में एक सिग्नेचर होता है जिसमें यह पुष्टि की जाती है कि लोड करने के लिए मल्टीबूट मानक का उपयोग किया गया था, जिसका संदर्भ कार्यान्वयन GRUB है। Mbd वैरिएबल मल्टीबूट_info_t संरचना की ओर इशारा करता है, जिसे मल्टीबूट में घोषित किया गया है। बूट डिस्क संख्या निम्न अभिव्यक्ति द्वारा निर्धारित की जाती है - p_multiboot_info-> boot_device >> 24. InitBootMedia फ़ंक्शन डिस्क संख्या को याद रखता है और फ़ाइल सिस्टम के पहले सेक्टर को खोजता है, ताकि सभी ऑफसेट को इससे पढ़ा जा सके।

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

2. शामिल फ़ोल्डर में multiboot.h फ़ाइल जोड़ें। हम पिछले संस्करण के विनिर्देश साइट से फ़ाइल की सामग्री लेते हैं।

चरण 2. डिस्क के साथ काम करने के लिए फ़ंक्शन जोड़ें

1. फ़ाइल में \ callrealmode.h शामिल है, हम निम्नलिखित कार्यों के प्रोटोटाइप जोड़ते हैं:

 u32 InitBootMedia(u8 bootDevice); int ReadBootMedia(unsigned long sector, unsigned char *buffer, unsigned long sectorCount); int WriteBootMedia(unsigned long sector, unsigned char *buffer, unsigned long sectorCount); 

2. शामिल \ callrealmode_asm.h फ़ाइल में, enum callrealmode_Func के लिए एक नया मान जोड़ें ताकि निम्न घटित हो:

 enum callrealmode_Func { CALLREALMODE_FUNC_GETSYSMEMMAP = 0, CALLREALMODE_FUNC_READ_DISK = 1 };  ,       : <source lang="c"> struct callrealmode_read_disk { u64 start_sector_lba; u32 buff_addr; u32 sectors_count; u16 disk_number; u8 ret_code; } __attribute__ ((packed)); 

Callrealmode_Data संरचना के अंदर यूनियन में जोड़ें बस घोषित callrealmode_read_disk संरचना। आपको निम्नलिखित मिलना चाहिए:

 struct callrealmode_Data { enum callrealmode_Func func : 16; union { struct callrealmode_GetSysMemMap getsysmemmap; struct callrealmode_read_disk readdisk; }; } __attribute__ ((packed)); 

3. fat_io_lib लाइब्रेरी में उपयोग किए गए strncmp और strncpy फ़ंक्शन को \ string.h फ़ाइल में शामिल करें।

 static inline int strncmp ( const char * str1, const char * str2, unsigned int num ) { for ( ; num > 0; str1++, str2++, --num) { if (*str1 != *str2) return ((*(unsigned char *)str1 < *(unsigned char *)str2) ? -1 : +1); else if (*str1 == '\0') return 0; } return 0; } static inline char* strncpy ( char * dst, const char * src, unsigned int num ) { if (num != 0) { char *d = dst; const char *s = src; do { if ((*d++ = *s++) == 0) { while (--num) *d++ = 0; break; } } while (--num); } return dst; } 

4. callrealmode.c फ़ाइल में निम्न घोषणाएँ जोड़ें:

 #include "fat_io_lib/fat_opts.h" #include "mbr.h" u64 g_BootPartitionStart = 0; //        u32 g_BootDeviceInt13Num = 0; //    

और कुछ कार्य:

 //     int ReadBootMedia(unsigned long sector, unsigned char *buffer, unsigned long sectorCount) { struct callrealmode_Data param; // ,     //    RM,    param.func = CALLREALMODE_FUNC_READ_DISK; //         int13. //          //    1Mb,   "buffer"     . //         "low_mem_buff", //     RM ,    CALLREALMODE_OFFSET < 1Mb int i; void *low_mem_buff = CALLREALMODE_OFFSET + (&callrealmode_end - &callrealmode_start); for (i = 0; i < sectorCount; i++) { param.readdisk.start_sector_lba = sector + g_BootPartitionStart + i; param.readdisk.buff_addr = (u32)low_mem_buff; param.readdisk.disk_number = g_BootDeviceInt13Num; param.readdisk.sectors_count = 1; callrealmode_Call(¶m); // int 0x13    "param" if (param.readdisk.ret_code) { return 0; // error } memcpy(buffer + i * FAT_SECTOR_SIZE, low_mem_buff, FAT_SECTOR_SIZE); } return 1; // success } //    .  int WriteBootMedia(unsigned long sector, unsigned char *buffer, unsigned long sectorCount) { return 0; // error } //   u32 InitBootMedia(u8 bootDevice) { g_BootDeviceInt13Num = bootDevice; //     MBRSector_t mbr; if (ReadBootMedia(0, (u8*)&mbr, 1) == 0) { return 0; } //   if (mbr.mbr_sign[0] != 0x55 || mbr.mbr_sign[1] != 0xaa) { return 0; } //    int i; for (i = 0; i < 4; i++) { if (mbr.part[i].boot_indicator == 0x80) break; } if (i == 4) { return 0; } //       g_BootPartitionStart = mbr.part[i].start_lva; printf("start sector = %lld boot dev int13 num = 0x%x\n", g_BootPartitionStart, g_BootDeviceInt13Num); return 1; } 

ReadBootMedia और WriteBootMedia फ़ंक्शन का उपयोग सेक्टरों को पढ़ने / लिखने के लिए fat_io_lib लाइब्रेरी द्वारा किया जाता है। WriteBootMedia फ़ंक्शन वैकल्पिक है और एक स्टब है क्योंकि इस उदाहरण में डिस्क पर कोई लेखन नहीं है। इसका कार्यान्वयन ReadBootMedia फ़ंक्शन के समान होगा। ReadBootMedia फ़ंक्शन पिछले लेख से प्रकार param.func तक GetRamsize फ़ंक्शन के समान है, और param.readysmemmap के बजाय param.readdisk का उपयोग किया जाता है। InitBootMedia फ़ंक्शन को अन्य दो से पहले कॉल किया जाना चाहिए, क्योंकि यह g_BootPartitionStart और g_BootDeviceInt13Num के मूल्यों को आरंभ करता है।

5. callrealmode_asm.s बदलें। अन्य प्रकार के CALLREALMODE_FUNC_READ_DISK कार्यों को जोड़ें, आपको निम्नलिखित प्राप्त करने चाहिए:

 #    enum callrealmode_Func CALLREALMODE_FUNC_GETSYSMEMMAP = 0x0 CALLREALMODE_FUNC_READ_DISK = 0x1 

अगला, हम फ़ंक्शन के प्रकार और डिस्क से कोड पढ़ने पर सीधे एक और चेक जोड़ते हैं। आपको निम्नलिखित मिलना चाहिए:

 callrealmode_switch: OFF_FUNC = 44 #     %bp #   func  callrealmode_Data # Which function? movw OFF_FUNC(%bp),%ax cmp $CALLREALMODE_FUNC_GETSYSMEMMAP,%ax je getsysmemmap cmp $CALLREALMODE_FUNC_READ_DISK,%ax je readdisk ret readdisk: OFF_START_SECTOR = 50 #    start_sector_lba  callrealmode_Data OFF_BUFFER_ADDR = 58 #    buff_addr  callrealmode_Data OFF_SECTORS_COUNT = 62 #    sectors_count  callrealmode_Data OFF_DISK_NUMBER = 66 #    disk_number  callrealmode_Data OFF_RETURN_CODE = 68 #    ret_code  callrealmode_Data push %bp mov %sp,%bp #     DAP pushl OFF_START_SECTOR+4(%bp) pushl OFF_START_SECTOR+0(%bp) pushl OFF_BUFFER_ADDR(%bp) pushw OFF_SECTORS_COUNT(%bp) pushw $0x10 mov %sp,%si # ds:si    , ..  DAP mov OFF_DISK_NUMBER(%bp),%dl #    dl mov $0x42,%ah # EXTENDED READ int $0x13 # CALL DISK BIOS mov %ah,OFF_RETURN_CODE(%bp) #   add $0x10,%sp #    DAP pop %bp ret 

रीडडिस्क लेबल उस कोड को इंगित करता है जो callrealmode_Data संरचना से DAP संरचना बनाता है और int0x13 कहता है। कोड में, लेबल callrealmode_switch के बाद, 2 निर्देशों को यह जांचने के लिए जोड़ा गया था कि क्या रीडडिस्क को बुलाया जाना चाहिए।

6. MBR के साथ काम करने के लिए परिभाषा वाले एक \ mbr.h फ़ाइल जोड़ें। इसकी सामग्री:

 #ifndef _MBR_H_ #define _MBR_H_ #include "types.h" struct MBRPartitionEntry { unsigned char boot_indicator; unsigned char start_head; unsigned short start_sector : 6; unsigned short start_cylinder : 10; unsigned char sys_id; unsigned char end_head; unsigned short end_sector : 6; unsigned short end_cylinder : 10; unsigned int start_lva; unsigned int size_in_sectors; } __attribute__ ((packed)); typedef struct MBRPartitionEntry MBRPartitionEntry_t; struct MBRSector { u8 code[446]; MBRPartitionEntry_t part[4]; u8 mbr_sign[2]; } __attribute__ ((packed)); typedef struct MBRSector MBRSector_t; 

MBRSector संरचना का उपयोग InitBootMedia फ़ंक्शन में किया जाता है।

चरण 3. fat_io_lib लाइब्रेरी जोड़ें और चलाएं

1. fat_io_lib.zip संग्रह डाउनलोड करें और प्रोजेक्ट रूट में fat_io_lib फ़ोल्डर में इसे अनज़िप करें।
2. फोल्डर में खाली फाइल assert.h और stdlib.h को शामिल करें। उन्हें संकलन के लिए पुस्तकालय की आवश्यकता होती है।
3. Makefile को ठीक करें। संकलन के लिए लक्ष्यों की सूची में लाइब्रेरी से फाइलें जोड़ें। आपको निम्नलिखित मिलना चाहिए:

 FAT_LIB_OBJFILES = \ ./fat_io_lib/fat_access.o \ ./fat_io_lib/fat_cache.o \ ./fat_io_lib/fat_filelib.o \ ./fat_io_lib/fat_format.o \ ./fat_io_lib/fat_misc.o \ ./fat_io_lib/fat_string.o \ ./fat_io_lib/fat_table.o \ ./fat_io_lib/fat_write.o OBJFILES = \ loader.o \ common/printf.o \ common/screen.o \ common/string.o \ kernel.o \ callrealmode.o \ callrealmode_asm.o \ descriptor.o \ $(FAT_LIB_OBJFILES) 

लाइन बदलें

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

पर

 @dd if=/dev/zero of=./hdd.img bs=1M count=10 1>/dev/null 2>&1 

अब छवि का आकार 10Mb है। यह सुनिश्चित करने के लिए है कि mkdosfs कमांड FAT12 के बजाय FAT16 में विभाजन को प्रारूपित करता है। FAT12 को fat_io_lib लाइब्रेरी द्वारा समर्थित नहीं किया गया है।

लाइन बदलें

 $(CC) -Iinclude $(CFLAGS) -o $@ -c $< 

पर

 $(CC) -Iinclude -DFAT_PRINTF_NOINC_STDIO $(CFLAGS) -o $@ -c $< 

इस परिभाषित के साथ, पुस्तकालय में stdio.h शामिल नहीं होगा, लेकिन यह प्रिंटफ फ़ंक्शन के तैयार किए गए प्रोटोटाइप का उपयोग करेगा, जो कि हमारे जैसा ही है, और जो पहले से ही लागू है।

4. परियोजना का पुनर्निर्माण

 make rebuild 

सुडोल छवि बनाते हैं

5. भागो

 sudo qemu-system-i386 -hda hdd.img 

आपको निम्नलिखित मिलना चाहिए:



पिछले भागों की तरह, आप USB फ्लैश ड्राइव पर hdd.img छवि का dd बना सकते हैं और उसमें से बूट करके वास्तविक हार्डवेयर पर कोड की जांच कर सकते हैं।

परिणामस्वरूप, हमने FAT16 और FAT32 फाइल सिस्टम के साथ काम को लागू किया। हमने रेडी-मेड लाइब्रेरी का उपयोग करके थोड़ा धोखा दिया, लेकिन समझने के लिए FAT डिवाइस कम दिलचस्प होगा, और यह संभावना नहीं होगी कि हम 1 लेख में फिट होंगे। आशा है कि आपको यह पढ़ना दिलचस्प लगा होगा। यदि आपको चरणों से गुजरने में समस्या है, तो टिप्पणियों में लिखें!

पिछले भागों के लिंक का चयन:

• बिना ऑपरेटिंग सिस्टम के प्रोग्राम कैसे चलाएं
• ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 2
• ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 3: ग्राफिक्स
• ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 4. समानांतर कंप्यूटिंग
• ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 5. ओएस से BIOS तक पहुंचना