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

हमारे लेख के पहले भाग में , हमने इस बारे में बात की कि आप एक सरल प्रोग्राम "हैलो वर्ल्ड" कैसे प्राप्त कर सकते हैं, जो बिना ऑपरेटिंग सिस्टम के चलता है और स्क्रीन पर एक संदेश प्रिंट करता है।

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

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

एक कार्यक्रम डिबग करने के लिए सीखना

मुख्य लेख : GDB डीबगर का अधिकतम उपयोग करना

कर्नेल.बिन कोड को डीबग कैसे करें? ऐसा करने के लिए, डिबगिंग प्रतीकों को कर्नेल.बिन में जोड़ें और डीबगर चलाएँ:

1. मेकफाइल में कंपाइलर विकल्प जोड़ें ताकि यह डिबगिंग सिंबल जेनरेट करे:

CFLAGS = -Wall -fno-builtin -nostdinc -nostdlib -ggdb3 

2. असेंबली स्टेज पर कुछ पंक्तियों को जोड़ें ताकि कर्नेल.बिना वर्णों को डिस्क पर लिखे (ऐसी फाइल को स्ट्रिप यूटिलिटी का उपयोग करके बनाया जा सके)। ऐसा करने के लिए, मेकाइल में कर्नेल.बिन लक्ष्य को ठीक करें:

 kernel.bin: $(OBJFILES) $(LD) -T linker.ld -o $@ $^ cp $@ $@.dbg strip $@ 

तो:
kernel.bin - में वर्ण नहीं हैं - इसे लॉन्च किया जा सकता है;
kernel.bin.dbg - में वर्ण और कोड दोनों शामिल हैं - इसे डीबगर को खिलाया जा सकता है।

3. डिबगर स्थापित करें:

 sudo apt-get install cgdb 

4. कार्यक्रम को फिर से संगठित करें:

 make clean make all sudo make image 

5. डिबगर प्रतीक्षा विकल्प के साथ qemu चलाएँ:

 sudo qemu-system-i386 -s -S -hda hdd.img & 

6. डिबगर को वर्णों के साथ फ़ाइल का संकेत देते हुए चलाएँ:

 cgdb kernel.bin.dbg 

7. डिबगर में, qemu से कनेक्ट करें और ब्रेकपॉइंट को सीधे मुख्य फ़ंक्शन पर सेट करें:

 (gdb) target remote localhost:1234 (gdb) break main 

8. हम इसे मुख्य और डीबग करते हैं:

 (gdb) c (gdb) n (gdb) n 

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

विजुअल स्टूडियो से संकलन

मुख्य लेख : लिनक्स पर gcc का उपयोग करके परियोजनाओं को संकलित करने के लिए Visual Studio 2010 शेल का उपयोग करना

विजुअल स्टूडियो से प्राप्त कोड के साथ कैसे काम करें? लेख में दिए गए निर्देशों के बाद, हम लिनक्स पर प्रोजेक्ट बनाए बिना विजुअल स्टूडियो प्रोजेक्ट को इकट्ठा करते हैं - यह पहले से मौजूद है।

1. ssh प्रणाली में स्थापित करें:

 sudo apt-get install ssh 

2. हम वर्चुअल मशीन के लिए साझा निर्देशिका पर kern.bin से प्रोजेक्ट स्रोत रखते हैं।

3. उपकरण फ़ोल्डर में पलक उपयोगिता स्थापित करें और इसके संचालन की जांच करें।

4. हम निर्देशों का पालन करते हुए विज़ुअल स्टूडियो प्रोजेक्ट बनाते हैं और निम्नलिखित पेड़ प्राप्त करते हैं:

\ proj \ कर्नेल
\ proj \ loader.s
\ proj \ आम \ printf.c
\ proj \ आम \ screen.c
\ proj \ \ printf.h शामिल हैं
\ proj \ \ stdarg.h शामिल हैं
\ proj \ शामिल \ स्क्रीन
\ proj \ शामिल \ type.h
\ proj \ makefile
\ proj \ linker.ld
\ proj \ tools \ plink.exe
\ proj \ कर्नेल \ कर्नेल। sln
\ proj \ कर्नेल \ कर्नेल।सू
\ proj \ कर्नेल \ कर्नेल .sdf
\ proj \ कर्नेल \ vs \ k गिरी ।vcxproj
\ proj \ कर्नेल \ vs \ k गिरी ।vcxproj.filters
\ proj \ कर्नेल \ vs \ make_vs.props

5. हम निर्देश के अनुसार फ़ाइल "\ proj \ k गिरी" बनाम \ make_vs.props बनाते हैं:

 <?xml version="1.0" encoding="utf-8"?> <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <PropertyGroup Label="RemoteBuildLocals"> <RblFolder>proj</RblFolder> <RblIncludePath>$(SolutionDir)\include\</RblIncludePath> <RblExecute>sudo make image; sudo qemu-system-i386 -hda hdd.img</RblExecute> </PropertyGroup> <PropertyGroup Label="RemoteBuildSettings"> <RbHost>192.168.1.8</RbHost> <RbUser>user</RbUser> <RbPassword>123456</RbPassword> <RbRoot> ~/Desktop/_habr</RbRoot> </PropertyGroup> <PropertyGroup Label="RemoteBuild"> <RbToolArgs> -pw $(RbPassword) $(RbUser)%40$(RbHost) cd $(RbRoot); cd $(RblFolder);</RbToolArgs> <RbToolExe>$(SolutionDir)tools\plink -batch $(RbToolArgs)</RbToolExe> <RbBuildCmd>$(RbToolExe) make all</RbBuildCmd> <RbRebuildAllCmd>$(RbToolExe) make rebuild</RbRebuildAllCmd> <RbCleanCmd>$(RbToolExe) make cleanall</RbCleanCmd> <RbExecuteCmd>$(RbToolArgs) $(RblExecute)</RbExecuteCmd> <RbIncludePath>$(RblIncludePath)</RbIncludePath> </PropertyGroup> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> <NMakeBuildCommandLine>$(RbBuildCmd)</NMakeBuildCommandLine> <NMakeReBuildCommandLine>$(RbRebuildAllCmd)</NMakeReBuildCommandLine> <NMakeCleanCommandLine>$(RbCleanCmd)</NMakeCleanCommandLine> <IncludePath>$(RbIncludePath)</IncludePath> <LocalDebuggerCommand>$(SolutionDir) tools\plink</LocalDebuggerCommand> <LocalDebuggerCommandArguments>$(RbExecuteCmd)</LocalDebuggerCommandArguments> </PropertyGroup> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> <NMakeBuildCommandLine>$(RbBuildCmd)</NMakeBuildCommandLine> <NMakeReBuildCommandLine>$(RbRebuildAllCmd)</NMakeReBuildCommandLine> <NMakeCleanCommandLine>$(RbCleanCmd)</NMakeCleanCommandLine> <IncludePath>$(RbIncludePath)</IncludePath> <LocalDebuggerCommand>$(SolutionDir)tools\plink</LocalDebuggerCommand> <LocalDebuggerCommandArguments>$(RbExecuteCmd)</LocalDebuggerCommandArguments> </PropertyGroup> </Project> 

6. निर्देश के अनुसार फ़ाइल "\ proj \ k गिरी" बनाम \ कर्नेल .vcxproj बदलें:

 <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> <Import Project="$(SolutionDir)\vs\make_vs.props" /> <ImportGroup Label="ExtensionSettings"> 

7. परिणाम कुछ इस तरह होना चाहिए:



8. जांचें कि सब कुछ काम करता है:



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

पीसीआईघड़ी उपकरणों को स्कैन करें

मुख्य लेख : एक ऑपरेटिंग सिस्टम के बिना पीसीआई उपकरणों को कैसे खोजें

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

1. निम्न प्रकार परिभाषा को शामिल करें \ type.h फ़ाइल में जोड़ें:

 typedef unsigned long u32; typedef unsigned short u16; typedef unsigned char u8; 

2. फ़ाइल को शामिल करें \ io.h , जो कि बिना बदलाव के निर्देशिका से बिटविसर परियोजना से लिया जा सकता है (जिसमें \ io.h शामिल हैं)।

3. शामिल \ pci.h फ़ाइल, जिसमें पीसीआई फ़ंक्शंस के लिए मूल परिभाषाएँ शामिल हैं। इसकी निम्नलिखित सामग्रियां हैं:

 #ifndef _PCI_H #define _PCI_H #include "types.h" #define PCI_CONFIG_PORT 0x0CF8 #define PCI_DATA_PORT 0x0CFC #define PCI_MAX_BUSES 255 #define PCI_MAX_DEVICES 32 #define PCI_MAX_FUNCTIONS 8 #define PCI_HEADERTYPE_NORMAL 0 #define PCI_HEADERTYPE_BRIDGE 1 #define PCI_HEADERTYPE_CARDBUS 2 #define PCI_HEADERTYPE_MULTIFUNC 0x80 typedef union { struct { u16 vendorID; u16 deviceID; u16 commandReg; u16 statusReg; u8 revisionID; u8 progIF; u8 subClassCode; u8 classCode; u8 cachelineSize; u8 latency; u8 headerType; u8 BIST; } __attribute__((packed)) option; u32 header[4]; } __attribute__((packed)) PCIDevHeader; void ReadConfig32(u32 bus, u32 dev, u32 func, u32 reg, u32 *data); char *GetPCIDevClassName(u32 class_code); void PCIScan(); #endif 

4. परियोजना के मूल में pci.c फ़ाइल जोड़ें, निम्न सामग्री के साथ (हमने मुख्य लेख की तुलना में इस कोड को थोड़ा सुधार दिया है:

 #include "types.h" #include "printf.h" #include "io.h" #include "pci.h" typedef struct { u32 class_code; char name[32]; } PCIClassName; static PCIClassName g_PCIClassNames[] = { { 0x00, "before PCI 2.0"}, { 0x01, "disk controller"}, { 0x02, "network interface"}, { 0x03, "graphics adapter"}, { 0x04, "multimedia controller"}, { 0x05, "memory controller"}, { 0x06, "bridge device"}, { 0x07, "communication controller"}, { 0x08, "system device"}, { 0x09, "input device"}, { 0x0a, "docking station"}, { 0x0b, "CPU"}, { 0x0c, "serial bus"}, { 0x0d, "wireless controller"}, { 0x0e, "intelligent I/O controller"}, { 0x0f, "satellite controller"}, { 0x10, "encryption controller"}, { 0x11, "signal processing controller"}, { 0xFF, "proprietary device"} }; typedef union { struct { u32 zero : 2; u32 reg_num : 6; u32 func_num : 3; u32 dev_num : 5; u32 bus_num : 8; u32 reserved : 7; u32 enable_bit : 1; }; u32 val; } PCIConfigAddres; void ReadConfig32(u32 bus, u32 dev, u32 func, u32 reg, u32 *data) { PCIConfigAddres addr; addr.val = 0; addr.enable_bit = 1; addr.reg_num = reg; addr.func_num = func; addr.dev_num = dev; addr.bus_num = bus; out32(PCI_CONFIG_PORT, addr.val); in32(PCI_DATA_PORT, data); return; } char *GetPCIDevClassName(u32 class_code) { int i; for (i = 0; i < sizeof(g_PCIClassNames)/sizeof(g_PCIClassNames[0]); i++) { if (g_PCIClassNames[i].class_code == class_code) return g_PCIClassNames[i].name; } return NULL; } int ReadPCIDevHeader(u32 bus, u32 dev, u32 func, PCIDevHeader *p_pciDevice) { int i; if (p_pciDevice == 0) return 1; for (i = 0; i < sizeof(p_pciDevice->header)/sizeof(p_pciDevice->header[0]); i++) ReadConfig32(bus, dev, func, i, &p_pciDevice->header[i]); if (p_pciDevice->option.vendorID == 0x0000 || p_pciDevice->option.vendorID == 0xffff || p_pciDevice->option.deviceID == 0xffff) return 1; return 0; } void PrintPCIDevHeader(u32 bus, u32 dev, u32 func, PCIDevHeader *p_pciDevice) { char *class_name; printf("bus=0x%x dev=0x%x func=0x%x venID=0x%x devID=0x%x", bus, dev, func, p_pciDevice->option.vendorID, p_pciDevice->option.deviceID); class_name = GetPCIDevClassName(p_pciDevice->option.classCode); if (class_name) printf(" class_name=%s", class_name); printf("\n"); } void PCIScan(void) { int bus; int dev; for (bus = 0; bus < PCI_MAX_BUSES; bus++) for (dev = 0; dev < PCI_MAX_DEVICES; dev++) { u32 func = 0; PCIDevHeader pci_device; if (ReadPCIDevHeader(bus, dev, func, &pci_device)) continue; PrintPCIDevHeader(bus, dev, func, &pci_device); if (pci_device.option.headerType & PCI_HEADERTYPE_MULTIFUNC) { for (func = 1; func < PCI_MAX_FUNCTIONS; func++) { if (ReadPCIDevHeader(bus, dev, func, &pci_device)) continue; PrintPCIDevHeader(bus, dev, func, &pci_device); } } } } 

5. कर्नेल में PCI उपकरणों को स्कैन करने की शुरुआत जोड़ें:

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

6. मेकफाइल में आवश्यक परिवर्तन करें:

 OBJFILES = \ loader.o \ common/printf.o \ common/screen.o \ pci.o \ kernel.o 

7. अब आप परियोजना का पुनर्निर्माण कर सकते हैं:

 make rebuild sudo make image 

8. यह सुनिश्चित करने के लिए प्रोजेक्ट चलाएं कि सब कुछ काम करता है:

 sudo qemu-system-i386 -hda hdd.img 

इसलिए हमें कंप्यूटर पर पीसीआई उपकरणों की एक सूची मिली। यह एक नियमित कंप्यूटर पर भी काम करेगा, एक यूएसबी फ्लैश ड्राइव से बूट होगा।

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

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