बूटलोडर/कर्नेल विकसित करते समय, अंतर्निहित आर्किटेक्चर को समझना सॉफ्टवेयर और हार्डवेयर के बीच प्रदर्शन और अनुकूलता को अनुकूलित करने के लिए महत्वपूर्ण है।
इंजीनियरों के लिए सिस्टम जानकारी क्वेरी और पुनर्प्राप्त करने के लिए उपलब्ध एक महत्वपूर्ण लेकिन कभी-कभी अनदेखा टूल CPUID निर्देश है।
CPUID निर्देश क्या है?
CPUID निर्देश एक निम्न-स्तरीय निर्देश है, जो हर आधुनिक x86 और x86-64 प्रोसेसर के दिल में होता है जो सॉफ्टवेयर को प्रोसेसर और उसकी समर्थित सुविधाओं के बारे में जानकारी के लिए CPU को क्वेरी करने की अनुमति देता है।
इस निर्देश को आह्वान करके, आप प्रोसेसर के मॉडल, फैमिली, आंतरिक कैश आकार, और SIMD या हार्डवेयर वर्चुअलाइजेशन जैसी समर्थित सुविधाओं जैसी जानकारी एकत्र कर सकते हैं। यह आपको प्रदर्शन को अनुकूलित करने और समर्थित सुविधाओं को गतिशील रूप से सक्षम या अक्षम करने में मदद कर सकता है।
बूटलोडर या कर्नेल डेवलपर्स के लिए, यह समझना कि प्रोसेसर किन सुविधाओं का समर्थन करता है - जैसे हार्डवेयर वर्चुअलाइजेशन, कैश आकार, या SIMD निर्देश - यह सुनिश्चित कर सकता है कि सिस्टम कुशलतापूर्वक चलता है और आपके द्वारा लिखा गया कोड विभिन्न CPUs के साथ संगत है। CPUID निर्देश का उपयोग करके, आप विशिष्ट प्रोसेसर के आधार पर अपने कर्नेल के व्यवहार को गतिशील रूप से समायोजित कर सकते हैं जिस पर यह चल रहा है।
इस लेख में आप सीखेंगे कि अपने सिस्टम के लिए CPUID निर्देश उपलब्ध है या नहीं यह कैसे जांचें, यह कैसे काम करता है और इसका उपयोग करके आप क्या जानकारी प्राप्त कर सकते हैं।
पूर्वापेक्षाएँ
- असेंबली भाषा का कुछ ज्ञान (इस उदाहरण के लिए मैं FASM का उपयोग करता हूं)
- ऑपरेटिंग सिस्टम/कर्नेल का कुछ ज्ञान
- निम्न-स्तरीय डिबगिंग टूल्स तक पहुंच (उदाहरण के लिए, GDB) या QEMU जैसे हार्डवेयर एमुलेटर्स अपने बूटलोडर/कर्नेल को विभिन्न प्लेटफॉर्म पर टेस्ट करने के लिए।
चरण 1: CPUID उपलब्धता की जांच करें
CPUID निर्देश निष्पादित करने से पहले, यह निर्धारित करना महत्वपूर्ण है कि प्रोसेसर इसका समर्थन करता है या नहीं, क्योंकि सभी CPUs में यह कार्यक्षमता होने की गारंटी नहीं है। निम्नलिखित कोड EFLAGS रजिस्टर में ID बिट (बिट 21) को संशोधित और परीक्षण करके CPUID निर्देश की उपलब्धता की जांच करता है।
यहां wiki.osdev.org से एक तस्वीर है जो EFLAGS रजिस्टर के प्रत्येक बिट को दिखाती है:
यदि प्रोसेसर इस बिट को टॉगल करने की अनुमति देता है, तो CPUID समर्थित है; अन्यथा, यह नहीं है। यहां पता लगाने की प्रक्रिया कैसे काम करती है:
(अधिकांश लोग सोचते हैं कि रियल मोड में 32 रजिस्टर एक्सेसिबल नहीं हैं। यह सच नहीं है। सभी 32-बिट रजिस्टर उपयोग योग्य हैं)
cpuid_check: pusha ; स्थिति सहेजें pushfd ; EFLAGS सहेजें pushfd ; EFLAGS स्टोर करें xor dword [esp],0x00200000 ; स्टोर्ड EFLAGS में ID बिट इनवर्ट करें popfd ; स्टोर्ड EFLAGS लोड करें (ID बिट इनवर्टेड के साथ) pushfd ; EFLAGS फिर से स्टोर करें (ID बिट इनवर्टेड हो भी सकता है और नहीं भी) pop eax ; eax = संशोधित EFLAGS (ID बिट इनवर्टेड हो भी सकता है और नहीं भी) xor eax,[esp] ; eax = जो भी बिट्स बदले गए popfd ; मूल EFLAGS पुनर्स्थापित करें and eax,0x00200000 ; eax = शून्य यदि ID बिट नहीं बदला जा सकता, अन्यथा नॉन-जीरो cmp eax,0x00 je .cpuid_instruction_not_is_available .cpuid_instruction_is_available: ;CPUID मौजूद है हैंडल करें .cpuid_instruction_not_is_available: ;CPUID समर्थित नहीं है हैंडल करें .cpuid_check_end: popa ; स्थिति पुनर्स्थापित करें ret
pusha: मूल स्थिति को अंत में पुनर्स्थापित करने के लिए सुनिश्चित करने के लिए सभी जनरल पर्पज रजिस्टर्स को सहेजता है।
pushfd: वर्तमान EFLAGS रजिस्टर को सहेजता है।
pushfd: EFLAGS की एक प्रति स्टोर करता है।
xor dword [esp], 0x00200000: कोड XOR ऑपरेटर का उपयोग करके EFLAGS के ID बिट (21) को फ्लिप करता है।
popfd: ID बिट इनवर्टेड के साथ संशोधित EFLAGS को पुनर्स्थापित करता है।
pushfd: संशोधित EFLAGS को वापस स्टैक पर पुश करता है।
pop eax: संशोधित EFLAGS (ID बिट इनवर्टेड हो भी सकता है और नहीं भी) को EAX रजिस्टर में डालता है।
xor eax, [esp]: XOR ऑपरेशन के बाद, EAX में वे बिट्स होंगे जो बदले गए थे।
popfd: मूल EFLAGS पुनर्स्थापित करता है।
and eax, 0x00200000: and ऑपरेशन अन्य सभी बिट्स को मास्क करके 21वें बिट (ID बिट) को अलग करता है। इस ऑपरेशन के बाद EAX रजिस्टर में या तो 0x00200000 होगा (यदि 21 बिट बदला गया था जिसका मतलब है CPUID समर्थित है) या 0x00 (21 बिट नहीं बदला, CPUID समर्थित नहीं)।
cmp eax, 0x00: CMP निर्देश पिछले ऑपरेशन के परिणाम की जांच करता है। यदि EAX 0x00 के बराबर है, तो इसका मतलब है कि ID बिट को संशोधित नहीं किया जा सकता और प्रोसेसर CPUID निर्देश का समर्थन नहीं करता। यदि यह शून्य नहीं है, तो इसका मतलब है कि ID बिट फ्लिप हो गया था और आपका प्रोसेसर CPUID निर्देश का समर्थन करता है।
CPU फीचर्स प्राप्त करें
CPUID निर्देश EAX रजिस्टर में अलग-अलग मानों के साथ अलग-अलग जानकारी लौटाएगा।
mov eax, 0x1 cpuid
EAX को 1 पर सेट करने पर, CPUID EDX में एक बिटफील्ड लौटाएगा, जिसमें निम्न मान होंगे। अलग-अलग ब्रांड इनके लिए अलग अर्थ दे सकते हैं (स्रोत https://wiki.osdev.org/CPUID)
enum { CPUID_FEAT_ECX_SSE3 = 1 << 0, CPUID_FEAT_ECX_PCLMUL = 1 << 1, CPUID_FEAT_ECX_DTES64 = 1 << 2, CPUID_FEAT_ECX_MONITOR = 1 << 3, CPUID_FEAT_ECX_DS_CPL = 1 << 4, CPUID_FEAT_ECX_VMX = 1 << 5, CPUID_FEAT_ECX_SMX = 1 << 6, CPUID_FEAT_ECX_EST = 1 << 7, CPUID_FEAT_ECX_TM2 = 1 << 8, CPUID_FEAT_ECX_SSSE3 = 1 << 9, CPUID_FEAT_ECX_CID = 1 << 10, CPUID_FEAT_ECX_SDBG = 1 << 11, CPUID_FEAT_ECX_FMA = 1 << 12, CPUID_FEAT_ECX_CX16 = 1 << 13, CPUID_FEAT_ECX_XTPR = 1 << 14, CPUID_FEAT_ECX_PDCM = 1 << 15, CPUID_FEAT_ECX_PCID = 1 << 17, CPUID_FEAT_ECX_DCA = 1 << 18, CPUID_FEAT_ECX_SSE4_1 = 1 << 19, CPUID_FEAT_ECX_SSE4_2 = 1 << 20, CPUID_FEAT_ECX_X2APIC = 1 << 21, CPUID_FEAT_ECX_MOVBE = 1 << 22, CPUID_FEAT_ECX_POPCNT = 1 << 23, CPUID_FEAT_ECX_TSC = 1 << 24, CPUID_FEAT_ECX_AES = 1 << 25, CPUID_FEAT_ECX_XSAVE = 1 << 26, CPUID_FEAT_ECX_OSXSAVE = 1 << 27, CPUID_FEAT_ECX_AVX = 1 << 28, CPUID_FEAT_ECX_F16C = 1 << 29, CPUID_FEAT_ECX_RDRAND = 1 << 30, CPUID_FEAT_ECX_HYPERVISOR = 1 << 31, CPUID_FEAT_EDX_FPU = 1 << 0, CPUID_FEAT_EDX_VME = 1 << 1, CPUID_FEAT_EDX_DE = 1 << 2, CPUID_FEAT_EDX_PSE = 1 << 3, CPUID_FEAT_EDX_TSC = 1 << 4, CPUID_FEAT_EDX_MSR = 1 << 5, CPUID_FEAT_EDX_PAE = 1 << 6, CPUID_FEAT_EDX_MCE = 1 << 7, CPUID_FEAT_EDX_CX8 = 1 << 8, CPUID_FEAT_EDX_APIC = 1 << 9, CPUID_FEAT_EDX_SEP = 1 << 11, CPUID_FEAT_EDX_MTRR = 1 << 12, CPUID_FEAT_EDX_PGE = 1 << 13, CPUID_FEAT_EDX_MCA = 1 << 14, CPUID_FEAT_EDX_CMOV = 1 << 15, CPUID_FEAT_EDX_PAT = 1 << 16, CPUID_FEAT_EDX_PSE36 = 1 << 17, CPUID_FEAT_EDX_PSN = 1 << 18, CPUID_FEAT_EDX_CLFLUSH = 1 << 19, CPUID_FEAT_EDX_DS = 1 << 21, CPUID_FEAT_EDX_ACPI = 1 << 22, CPUID_FEAT_EDX_MMX = 1 << 23, CPUID_FEAT_EDX_FXSR = 1 << 24, CPUID_FEAT_EDX_SSE = 1 << 25, CPUID_FEAT_EDX_SSE2 = 1 << 26, CPUID_FEAT_EDX_SS = 1 << 27, CPUID_FEAT_EDX_HTT = 1 << 28, CPUID_FEAT_EDX_TM = 1 << 29, CPUID_FEAT_EDX_IA64 = 1 << 30, CPUID_FEAT_EDX_PBE = 1 << 31 };
उपरोक्त CPU फीचर्स का संक्षिप्त विवरण:
PCLMUL, AES: तेज एन्क्रिप्शन और डिक्रिप्शन के लिए क्रिप्टोग्राफिक इंस्ट्रक्शन सेट्स।VMX, SMX: वर्चुअल मशीन चलाने के लिए वर्चुअलाइजेशन सपोर्ट।SSE3, SSSE3, SSE4.1, SSE4.2, AVX: तेज मल्टीमीडिया, गणित, और वेक्टर प्रोसेसिंग के लिए SIMD इंस्ट्रक्शन सेट्स।FMA: फ्यूज्ड मल्टीप्लाई-एड, फ्लोटिंग-पॉइंट गणनाओं में प्रदर्शन में सुधार करता है।RDRAND: रैंडम नंबर जेनरेटर।X2APIC: मल्टीप्रोसेसर सिस्टम में उन्नत इंटरप्ट हैंडलिंग।PCID: कॉन्टेक्स्ट स्विच के दौरान मेमोरी मैनेजमेंट को अनुकूलित करता है।FPU: तेज गणित संचालन के लिए हार्डवेयर फ्लोटिंग-पॉइंट यूनिट।PAE: फिजिकल एड्रेस एक्सटेंशन, 4 GB से अधिक मेमोरी एड्रेस करने की अनुमति देता है।HTT: एक सिंगल CPU कोर को कई थ्रेड्स संभालने की अनुमति देता है।PAT, PGE: कैशिंग और पेज मैपिंग को नियंत्रित करने के लिए मेमोरी मैनेजमेंट फीचर्स।MMX, SSE, SSE2: मल्टीमीडिया प्रोसेसिंग के लिए पुराने SIMD इंस्ट्रक्शन सेट्स।
CPU विक्रेता स्ट्रिंग प्राप्त करें
यदि आप CPU विक्रेता स्ट्रिंग प्राप्त करना चाहते हैं, तो CPUID निर्देश आह्वान करने से पहले EAX को 0x0 पर सेट करना चाहिए।
mov eax, 0x0 cpuid
विक्रेता स्ट्रिंग एक अद्वितीय पहचानकर्ता है जिसका उपयोग AMD और Intel जैसे CPU विक्रेता करते हैं। उदाहरण हैं: GenuineIntel (इंटेल प्रोसेसर के लिए) या AuthenticAMD (AMD प्रोसेसर के लिए)। यह मूल रूप से CPU के निर्माता को निर्दिष्ट करता है।
विक्रेता स्ट्रिंग कर्नेल को CPU निर्माता की पहचान करने की अनुमति देती है जो बहुत उपयोगी है क्योंकि विभिन्न निर्माता कुछ सुविधाओं को अलग तरीके से लागू करते हैं। साथ ही, सॉफ्टवेयर या ड्राइवर CPU निर्माता के आधार पर अलग तरह से इंटरैक्ट कर सकते हैं ताकि अनुकूलता सुनिश्चित हो सके।
जब इस तरह उपयोग किया जाता है, तो विक्रेता आईडी स्ट्रिंग EBX, EDX, ECX रजिस्टर्स में लौटाई जाएगी। आप उन्हें एक बफर में लिख सकते हैं और पूरा 12 कैरेक्टर स्ट्रिंग प्राप्त कर सकते हैं।
उदाहरण कोड:
चरण 1: बफर
12 बाइट्स रखने वाला एक बफर बनाएं:
buffer: db 12 dup(0), 0xA, 0xD, 0
चरण 2: बफर प्रिंट करें
हम एक स्ट्रिंग प्रिंटिंग फंक्शन बनाकर शुरू करते हैं।
यह असेंबली कोड एक स्ट्रिंग को कैरेक्टर दर कैरेक्टर पढ़ता है और BIOS इंटरप्ट 0x10 का उपयोग करके इसे स्क्रीन पर प्रिंट करता है। print फंक्शन स्ट्रिंग के माध्यम से लूप करता है और प्रत्येक कैरेक्टर को al रजिस्टर में लोड करने के लिए lodsb निर्देश का उपयोग करता है।
फिर print_char फंक्शन इंटरप्ट 0x10 का उपयोग करके इसे स्क्रीन पर प्रिंट करता है। जब कोड स्ट्रिंग के अंत (नल टर्मिनेटर) पर पहुंचता है, तो लूप समाप्त होता है।
print_string: call print ret print: .loop: lodsb ;कैरेक्टर को al में पढ़ें और फिर इंक्रीमेंट करें cmp al ,0 ;जांचें कि क्या हम अंत पर पहुंच गए je .done ;हम नल टर्मिनेटर पर पहुंच गए, खत्म करें call print_char ;कैरेक्टर प्रिंट करें jmp .loop ;लूप में वापस जाएं .done: ret print_char: mov ah, 0eh int 0x10 ret
चरण 3: बफर भरें और प्रिंट करें
यहां, pusha निर्देश का उपयोग करके वर्तमान स्थिति को सहेजने और cpuid को EAX रजिस्टर में 0x0 पास करके कॉल करने के बाद, हम ebx, edx, ecx की सामग्री को बफर में स्टोर कर सकते हैं। फिर हम इसे प्रिंट करने के लिए print_string कॉल करते हैं।
get_cpu_vendor: pusha mov eax, 0x0 cpuid mov [buffer], ebx mov [buffer + 4], edx mov [buffer + 8], ecx mov si, buffer call print_string popa ret
मेरे YouTube चैनल से एक वीडियो जहां मैं उपरोक्त कोड को विस्तार से लागू और समझाता हूं
EAX रजिस्टर में पास किए गए मान के अनुसार CPUID निर्देश आपको क्या जानकारी दे सकता है, इसके बारे में अधिक जानकारी यहां मिल सकती है: https://gitlab.com/x86-cpuid.org/x86-cpuid-db
उपसंहार
CPUID निर्देश को समझने और उपयोग करने से, आप अपने बूटलोडर/कर्नेल को प्रोसेसर की एक विस्तृत श्रृंखला के लिए अधिक अनुकूलनीय बना सकते हैं। निर्देश की उपलब्धता का पता लगाने और महत्वपूर्ण सिस्टम जानकारी पुनर्प्राप्त करने का तरीका जानना - जैसे CPU फीचर्स, कैश आकार, और समर्थित तकनीकें - प्रदर्शन और अनुकूलता को काफी बढ़ा सकता है।
इस लेख को पढ़ने के बाद, आपके पास CPUID निर्देश का पता लगाने और इसे अपने प्रोजेक्ट में कैसे उपयोग कर सकते हैं, इसके लिए उपकरण और ज्ञान होना चाहिए!
हैप्पी कोडिंग!
