🌧️ 🧓🏾 🚃 बिना ऑपरेटिंग सिस्टम के PCI डिवाइस को कैसे खोजें 💹 ⏹️ 🛃

काम के दौरान, हमें समय-समय पर हार्डवेयर के साथ एक निम्न-स्तर की बातचीत से निपटना पड़ता है। इस लेख में, हम यह दिखाना चाहते हैं कि पीसीआई उपकरणों की पूछताछ और उनकी पहचान के लिए संबंधित डिवाइस ड्राइवरों की लोडिंग कैसे होती है।

पीसीआई उपकरणों के साथ काम करने के लिए एक न्यूनतम आधार के रूप में, हम एक कर्नेल का उपयोग करेंगे जो मल्टीबूट विनिर्देश का समर्थन करता है। यह आपके स्वयं के बूट क्षेत्र और लोडर को लिखने की आवश्यकता से बचा जाता है। इसके अलावा, यह मुद्दा पहले से ही इंटरनेट पर अच्छी तरह से कवर किया गया है। बूट लोडर GRUB होगा। हम फ्लैश ड्राइव से बूट करेंगे, क्योंकि यह एक आभासी और वास्तविक मशीन दोनों से बूट करना सुविधाजनक है। हम QEMU का उपयोग वर्चुअल मशीन के रूप में करेंगे। एक वास्तविक मशीन एक नियमित BIOS (यूईएफआई नहीं) के साथ एक मशीन होनी चाहिए जो यूएसबी-एचडीडी से बूटिंग का समर्थन करती है (आमतौर पर लीगेसी यूएसबी समर्थन विकल्प है)। काम करने के लिए, आपको निम्नलिखित कार्यक्रमों के साथ उबंटू लिनक्स की आवश्यकता होगी: उम्मीद करें, क्यूमू, ग्रब (वे सूदो एप-गेट इंस्टॉल कमांड का उपयोग करके आसानी से स्थापित किए जा सकते हैं)। उपयोग किए गए gcc को 32 बिट कोड संकलित करना चाहिए।

पहले चरण पर विचार करें - एक कर्नेल बनाना जो मल्टीबूट विनिर्देश का समर्थन करता है। लोडर के रूप में GRUB का उपयोग करने के मामले में, कर्नेल को 3 फ़ाइलों से बनाया जाएगा:
कर्नेल। सी - हमारे कार्यक्रम के कोड और मुख्य () प्रक्रिया के साथ मुख्य फ़ाइल;
लोडर.एस - में GRUB के लिए मल्टीबूट हैडर है;
Linker.ld एक ld लिंकर स्क्रिप्ट है जो विशेष रूप से इंगित करती है कि कर्नेल किस पते पर स्थित होगा।

Linker.ld सामग्री:

ENTRY (loader) SECTIONS { . = 0x00100000; .text ALIGN (0x1000) : { *(.text) } .rodata ALIGN (0x1000) : { *(.rodata*) } .data ALIGN (0x1000) : { *(.data) } .bss : { sbss = .; *(COMMON) *(.bss) ebss = .; } }

लिंकर स्क्रिप्ट इंगित करता है कि पहले से संकलित ऑब्जेक्ट फ़ाइलों को कैसे लिंक किया जाए। पहली पंक्ति इंगित करती है कि हमारे कोर में प्रवेश बिंदु "लोडर" लेबल वाला पता होगा। आगे की स्क्रिप्ट में यह इंगित किया गया है कि पता 0x00100000 (1Mb) से शुरू होकर टेक्स्ट सेक्शन स्थित होगा। रॉडटा, डेटा और बीएसएस अनुभाग 0x1000 (4Kb) से जुड़े होते हैं और पाठ अनुभाग के बाद स्थित होते हैं।

Loader.s की सामग्री:

 .global loader .set FLAGS, 0x0 .set MAGIC, 0x1BADB002 .set CHECKSUM, -(MAGIC + FLAGS) .align 4 .long MAGIC .long FLAGS .long CHECKSUM # reserve initial kernel stack space .set STACKSIZE, 0x4000 .lcomm stack, STACKSIZE .comm mbd, 4 .comm magic, 4 loader: movl $(stack + STACKSIZE), %esp movl %eax, magic movl %ebx, mbd call kmain cli hang: hlt jmp hang

GRUB डिस्क से कर्नेल छवि को लोड करने के बाद डाउनलोड की गई छवि के पहले 8Kb में हस्ताक्षर 0x1BADB002 के लिए दिखता है। हस्ताक्षर पहला मल्टीबूट हैडर फ़ील्ड है। शीर्षक स्वयं इस प्रकार है:

ओफ़्सेट	टाइप	क्षेत्र का नाम	टिप्पणी
0	u32	जादू	अपेक्षित
4	u32	झंडे	अपेक्षित
8	u32	चेकसम	अपेक्षित
12	u32	header_addr	अगर झंडे [16] सेट है
16	u32	load_addr	अगर झंडे [16] सेट है
20	u32	load_end_addr	अगर झंडे [16] सेट है
24	u32	bss_end_addr	अगर झंडे [16] सेट है
28	u32	entry_addr	अगर झंडे [16] सेट है
32	u32	mode_type	अगर झंडे [2] सेट है
36	u32	चौड़ाई	अगर झंडे [2] सेट है
40	u32	ऊंचाई	अगर झंडे [2] सेट है
44	u32	गहराई	अगर झंडे [2] सेट है

शीर्षक में कम से कम 3 फ़ील्ड शामिल होने चाहिए - जादू, झंडा, चेकसम। मैजिक फ़ील्ड एक हस्ताक्षर है और जैसा कि ऊपर बताया गया है, हमेशा 0x1BADB002 है। ओएस नियंत्रण के हस्तांतरण के समय ध्वज क्षेत्र में मशीन की स्थिति के लिए अतिरिक्त आवश्यकताएं होती हैं। इस फ़ील्ड के मूल्य के आधार पर, मल्टीबूट सूचना संरचना में फ़ील्ड्स का सेट बदल सकता है। मल्टीबूट सूचना संरचना के लिए एक पॉइंटर में लोड कर्नेल पर नियंत्रण के हस्तांतरण के समय ईबीएक्स रजिस्टर होता है। हमारे मामले में, ध्वज फ़ील्ड का मान 0 है, और मल्टीबूट शीर्षलेख में केवल 3 फ़ील्ड हैं।

कर्नेल पर नियंत्रण स्थानांतरित करने के समय, प्रोसेसर पेजिंग डिसेबल के साथ संरक्षित मोड में संचालित होता है। डिवाइस इंटरप्ट हैंडलिंग अक्षम है। GRUB बूट करने योग्य कर्नेल के लिए एक स्टैक नहीं बनाता है, और यह पहली चीज है जिसे ऑपरेटिंग सिस्टम को करना चाहिए। हमारे मामले में, 16 केबी को स्टैक के तहत आवंटित किया गया है। अंतिम असेंबलर स्टेटमेंट को कॉल किया गया कॉल kmain स्टेटमेंट है, जो C कोड को कंट्रोल करता है, अर्थात् शून्य kmain (शून्य) फ़ंक्शन।

कर्नेल की सामग्री।

 #include "printf.h" #include "screen.h" void kmain(void) { clear_screen(); printf(" -- Kernel started! -- \n"); }

यहां अभी तक कुछ भी दिलचस्प नहीं है। लोडिंग के दृष्टिकोण से, इसमें कुछ भी विशिष्ट मौजूद नहीं होना चाहिए, केवल C कोड के लिए एक प्रवेश बिंदु है। इंटरनेट पर पाए जाने वाले प्रिंटफ फ़ंक्शन के कार्यान्वयन को प्रदर्शित करने के लिए, और वीडियो मेमोरी के साथ काम करने के लिए कई फ़ंक्शन, जैसे कि putchar, clear_screen जोड़ा गया था।

कर्नेल के निर्माण के लिए निम्नलिखित सरल मेकफाइल का उपयोग किया जाएगा:

 CC = gcc CFLAGS = -Wall -nostdlib -fno-builtin -nostartfiles -nodefaultlibs LD = ld OBJFILES = \ loader.o \ printf.o \ screen.o \ pci.o \ kernel.o start: all cp ./kernel.bin ./flash/boot/grub/ expect ./grub_install.exp qemu /dev/sdb all: kernel.bin .so: as -o $@ $< .co: $(CC) $(CFLAGS) -o $@ -c $< kernel.bin: $(OBJFILES) $(LD) -T linker.ld -o $@ $^ clean: rm $(OBJFILES) kernel.bin

अब हमारे पास एक कर्नेल है जिसे डाउनलोड किया जा सकता है। यह जांचने का समय है कि यह वास्तव में लोड होता है। USB फ्लैश ड्राइव पर GRUB स्थापित करें और इसे स्टार्टअप पर हमारे कर्नेल को लोड करने के लिए कहें। ऐसा करने के लिए, इन चरणों का पालन करें:

1. एक USB फ्लैश ड्राइव पर एक विभाजन बनाएं, इसे GRUB द्वारा समर्थित फ़ाइल सिस्टम में प्रारूपित करें (हमारे मामले में, यह एक FAT32 फ़ाइल सिस्टम है)। हमने उबंटू बंडल से डिस्क उपयोगिता उपयोगिता का उपयोग किया, जिसने हमें एक विभाजन बनाने की अनुमति दी:

2. USB फ्लैश ड्राइव को माउंट करें और डायरेक्टरी / बूट / ग्रब / बनाएं। फ़ाइलों को चरण 1, स्टेज 2, fat_stage1_5 में / usr / lib में कॉपी करें। निर्देशिका / बूट / ग्रब / में एक टेक्स्ट फ़ाइल मेनू बनाएँ। और इसे लिखें

 timeout 5 default 0 title start_kernel root (hd0,0) kernel /boot/grub/kernel.bin

USB फ्लैश ड्राइव पर GRUB स्थापित करने के लिए, grub_install.exp फ़ाइल में अपेक्षित स्क्रिप्ट का उपयोग करें। इसकी सामग्री:

 log_user 0 spawn grub expect "grub> " send "root (hd1,0)\r" expect "grub> " send "setup (hd1)\r" expect "grub> " send "quit\r" exit 0

एक विशिष्ट मामले में, अन्य ड्राइव नंबर और डिवाइस नाम संभव हैं। अंततः, वर्चुअल मशीन को कंपाइल करना और शुरू करना मेक स्टार्ट कमांड के साथ होना चाहिए। Makefile की यह कमांड grub_install.exp स्क्रिप्ट का उपयोग करके फ्लैश ड्राइव पर GRUB स्थापित करेगी, और फिर हमारे प्रोग्राम के साथ QEMU वर्चुअल मशीन को शुरू करेगी। चूंकि सब कुछ एक वास्तविक फ्लैश ड्राइव से लोड किया गया है, इसलिए इसे न केवल एक क्यूमू वर्चुअल मशीन से बूट करना संभव है, बल्कि एक वास्तविक कंप्यूटर भी है।

हमारे प्रोग्राम के साथ लॉन्च की गई QEMU वर्चुअल मशीन इस प्रकार है:

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

प्रत्येक PCI-डिवाइस 256 बाइट्स (PCI कॉन्फ़िगरेशन स्पेस) की संरचना के साथ जुड़ा हुआ है, जिसमें इसकी सेटिंग्स स्थित हैं। डिवाइस का कॉन्फ़िगरेशन अंततः इस संरचना से डेटा लिखने और पढ़ने के लिए नीचे आता है। सभी PCI डिवाइसों के लिए, डेटा पढ़ना और लिखना 2 इनपुट / आउटपुट पोर्ट के माध्यम से होता है:
0xcf8 - कॉन्फ़िगरेशन पोर्ट जिसमें पीसीआई पता लिखा गया है;
0xcfc - डेटा पोर्ट जिसके माध्यम से डेटा को पढ़ा जाता है और कॉन्फ़िगरेशन पोर्ट में निर्दिष्ट PCI पते पर लिखा जाता है।

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

पीसीआई पता निम्नलिखित 32-बिट संरचना है:

बिट ३१	बिट्स 30 - 24	बिट्स 23 - 16	बिट्स 15 - 11	बिट्स 10 - 8	बिट्स 7 - 2	बिट्स 1 - 0
हमेशा 1	आरक्षित	टायर नंबर	डिवाइस नंबर	कार्य संख्या	रजिस्टर संख्या	हमेशा 0

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

पीसीआई कॉन्फ़िगरेशन स्पेस को सशर्त रूप से 4 बाइट्स के रजिस्टरों में विभाजित किया गया है। जिस रजिस्टर नंबर को एक्सेस किया जा रहा है वह 2-से 7 बिट तक 32-बिट पीसीआई पते में संग्रहीत है। PCI कॉन्फ़िगरेशन स्पेस संरचना में PCI डिवाइस का वर्णन करने वाले क्षेत्र इसके प्रकार पर निर्भर करते हैं। लेकिन सभी प्रकार के उपकरणों के लिए, संरचना के पहले 4 रजिस्टरों में निम्नलिखित फ़ील्ड शामिल हैं:

रजिस्टर संख्या	बिट्स 31 - 24	बिट्स 23 - 16	बिट्स 15 - 8	बिट्स 7 - 0
0	डिवाइस आईडी		विक्रेता आईडी
1	स्थिति		आदेश
2	कक्षा कोड	उपवर्ग	प्रोग आई। एफ	संशोधन आईडी
3	बिष्ट	हैडर प्रकार	विलंबता टाइमर	कैश लाइन का आकार

क्लास कोड - डिवाइस के कार्य (नेटवर्क एडेप्टर, वीडियो कार्ड, आदि) के संदर्भ में डिवाइस के प्रकार (वर्ग) का वर्णन करता है;
वेंडर आईडी - डिवाइस निर्माता पहचानकर्ता (दुनिया में प्रत्येक डिवाइस निर्माता के पास इन विशिष्ट पहचानकर्ताओं में से एक या अधिक है)। ये नंबर PCI SIG द्वारा जारी किए गए हैं;
डिवाइस आईडी - डिवाइस के लिए एक विशिष्ट पहचानकर्ता (निर्दिष्ट विक्रेता आईडी के लिए अद्वितीय)। उनकी संख्या निर्माता द्वारा निर्धारित की जाती है।

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

एक कोड पर विचार करें जो कंप्यूटर पर पीसीआई उपकरणों की सूची प्राप्त करने का सबसे आसान तरीका लागू करता है:

 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 kmain(void) { int bus; int dev; clear_screen(); printf(" -- Kernel started! -- \n"); 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); } } } }

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

0x8086 इंटेल का वेंडरआईडी हार्डवेयर है। 0x7000 का एक DeviceID एक PIIX3 PCI-to-ISA ब्रिज डिवाइस से मेल खाता है। VmWare वर्कस्टेशन 9.0 में परिणामी फ्लैश ड्राइव से बूट। पीसीआई उपकरणों की सूची अधिक लंबी हो गई और निम्नानुसार दिखाई देती है:

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

बिना ऑपरेटिंग सिस्टम के PCI डिवाइस को कैसे खोजें

More articles: