ईएफआई बाइट कोड से x86 प्रक्रिया कॉल का आयोजन

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

समस्या का बयान

एक ईबीसी आवेदन से निर्दिष्ट MSR (मॉडल विशिष्ट रजिस्टर) पढ़ने के उदाहरण पर विचार करें। जैसा कि आप जानते हैं, x86 इंस्ट्रक्शन सिस्टम RDMSR (Read MSR) निर्देश प्रदान करता है जो ECX रजिस्टर में एक 32-बिट MSR पता इनपुट पैरामीटर के रूप में प्राप्त करता है और EDX (उच्च 32 बिट्स) और EAX (कम 32 बिट्स) रजिस्टरों में 64-बिट MSR सामग्री देता है। )। ईबीसी वर्चुअल मशीन कमांड सिस्टम समान कार्यक्षमता प्रदान नहीं करता है, यही वजह है कि देशी कोड में एक सबरूटीन कॉल की आवश्यकता होती है।

ध्यान दें कि UEFImark x64 संस्करण की जानकारी और नैदानिक ​​उपयोगिता में, RDMSR निर्देश का सीधे उपयोग किया जाता है, और UEFImark EBC संस्करण में, इसके लिए EBC प्रोग्राम से देशी दिनचर्या को कॉल करने की आवश्यकता होती है।

प्रयोग की स्थिति

यह माना जाता है कि प्रश्न में प्रक्रिया पर नियंत्रण स्थानांतरित करने से पहले, ईबीसी कार्यक्रम ने x86 प्लेटफॉर्म का पता लगाया और पाया कि IA32 या x64 आर्किटेक्चर में से एक का समर्थन किया गया है। पता लगाने की विधि इस लेख के दायरे से परे है, इसे बाद के प्रकाशनों में विचार करने की योजना है।

उदाहरणों को प्रसारित करने के लिए, FASM 1.69.50 का उपयोग किया जाता है। ईबीसी निर्देश मैक्रोज़ का उपयोग करके कार्यान्वित किए जाते हैं, x86 कोड 64-बिट मोड के लिए प्रसारित किया जाता है, 32-बिट मोड के साथ इसकी संगतता सुनिश्चित करने की सुविधाओं के बारे में नीचे चर्चा की गई है।

कॉलिंग प्रक्रिया EBC_Read_MSR

;--- Subroutine: EBC/x86 gate for Read MSR ----------------------------------; ; Caller must verify x86 support (IA32 or x64) before call this subroutine, ; ; but this subroutine differentiate IA32/x64 internally. ; ; ; ; INPUT: R1 = Global variables pool base address ; ; R6 = MSR index (same as ECX before RDMSR instruction) ; ; OUTPUT: R3 = MSR data after Read (same as EDX:EAX after RDMSR instruction) ; ; R4-R7 can be changed ; ;----------------------------------------------------------------------------; EBC_Read_MSR: XOR64 R7,R7 ; R7=0 PUSH64 R7 ; Storage for output MOVQ R7,R0 ; Address of storage = stack pointer PUSHN R7 ; Parameter#2 = Output address PUSHN R6 ; Parameter#1 = MSR address MOVINW R7,1,0 CMPI32WEQ R7,4 ; R7=4 for 32-bit, R7=8 for 64-bit MOVIQW R7,_IA32_Read_MSR ; This pointer for IA32 (native width=4) JMP8CS Native_Gate MOVIQW R7,_x64_Read_MSR ; This pointer for x64 (native width=8) Native_Gate: ADD64 R7,R1 ; Add base address = R1 CALL32EXA R7 POPN R6 ; Remove Parameter#1 POPN R7 ; Remove Parameter#2 POP64 R3 ; Read R3 = Output RET 

अंजीर। १ । X86 MSR रीडिंग प्रक्रिया को EBC प्रक्रिया कहते हैं

कॉलिंग ईबीसी प्रक्रिया द्वारा किए गए संचालन के अनुक्रम पर विचार करें।

1. 64-बिट चर के ढेर में एक आरक्षण जिसमें निर्दिष्ट प्रक्रिया निर्दिष्ट MSR रजिस्टर की सामग्री को लिखेगी।
2. स्टैक को लिखित प्रक्रिया के लिए दूसरा इनपुट पैरामीटर - एमएसआर की सामग्री को बचाने के लिए पता। यह चरण 1 में निर्मित चर का पता है।
3. स्टैक को लिखित प्रक्रिया के लिए पहला इनपुट पैरामीटर लिखना - एमएसआर रजिस्टर का पता, रजिस्टर आर 6 में सबरूटीन द्वारा अपनाया गया।
4. EBC निर्देश MOVINW का उपयोग करके प्राकृतिक क्षमता का निर्धारण। यदि यह पहले स्थापित किया गया था कि प्लेटफ़ॉर्म x86- संगत है, तो प्राकृतिक बिट 4 का मान IA32 (4 बाइट्स = 32 बिट्स), 8 का मतलब x64 (8 बाइट्स = 64 बिट्स) है।
5. एंट्री पॉइंट के लिए एड्रेस को चुने गए सबरूटीन (चरण 4 के परिणामों के अनुसार और R7 रजिस्टर में रखकर।
6. चरण 5 में प्राप्त पते पर सबरूटीन को कॉल करें।
7. स्टैक से पहले से लिखे गए मापदंडों को पढ़ना और हटाना, चरण 1 में बनाए गए चर के मूल्य को R3 रजिस्टर में पढ़ा जाता है, जिसमें कहा जाता है कि सबरूटीन ने परिणाम लिखा था - 64-बिट MSR सामग्री।

PUSHN (पुश नेचुरल) निर्देशों द्वारा स्टैक पर लिखे गए मापदंडों की बिट गहराई और POPN (पॉप नेचुरल) निर्देशों के स्टैक से पढ़ें IA32 UEFI के लिए 32 बिट्स और x64 UEFI के लिए 64 बिट्स हैं।

कॉल की गई प्रक्रिया: IA32_Read_MSR, x64_Read_MSR

 ;--- Read Model-Specific Register, selected by input index --------------; ; INPUT: Parm#1 = MSR address (ECX before RDMSR), natural width 32/64 ; ; Parm#2 = Address for write output data, natural width 32/64 ; ; OUTPUT: R7 = Reserved for UEFI status ; ; QWORD at Address [Parm#2] = MSR data (EDX:EAX after RDMSR) ; ;------------------------------------------------------------------------; IA32_Read_MSR: ; Entry point for IA32 push rbx rcx rdx mov ecx,[rsp+16] ; ECX = Parm#1 = MSR address, assembled same as [esp+16], can use for IA32 mov ebx,[rsp+20] ; EBX = Parm#2 = Output address, assembled same as [esp+20], can use for IA32 jmp Entry_R_MSR x64_Read_MSR: ; Entry point for x64 push rbx rcx rdx mov rbx,rdx ; RBX=Output address (p#2), RCX=MSR address (p#1) Entry_R_MSR: rdmsr ; RCX=Input, EDX:EAX=Output mov [rbx+00],eax mov [rbx+04],edx pop rdx rcx rbx ret 

अंजीर। २ । X86 को MSR रीड प्रक्रिया कहा जाता है

X86 प्रक्रिया द्वारा किए गए संचालन के अनुक्रम पर विचार करें।

1. IA32 के लिए प्रवेश बिंदु (लेबल IA32_Read_MSR)। EBX, ECX, EDX के ढेर में बचत। इनपुट प्रक्रिया द्वारा बनाए गए स्टैक फ्रेम से इनपुट मापदंडों को पढ़ा जाता है: एमएसआर की सामग्री को बचाने के लिए एमएसआर पता और चर पता। चरण 3 पर जाएं।
2. X64 के लिए प्रवेश बिंदु (लेबल x64_Read_MSR)। रजिस्टर स्टैक आरबीएक्स, आरसीएक्स, आरडीएक्स में बचत। रजिस्टरों में RCX और RDX क्रमशः पहले और दूसरे इनपुट पैरामीटर हैं।
3. लक्ष्य संचालन करना - RDMSR निर्देश का उपयोग करके MSR पढ़ें।
4. दूसरे इनपुट पैरामीटर द्वारा निर्दिष्ट पते पर रीड एमएसआर सामग्री को सहेजना।
5. रजिस्टर EDX, ECX, EBX (IA32 के लिए) या RDX, RCX, RBX (x64 के लिए) को पुनर्स्थापित करें और कॉलिंग प्रक्रिया पर लौटें।

प्रक्रिया को देखते हुए, आप एक विरोधाभास पा सकते हैं: 64-बिट मोड में कई निर्देश निष्पादन की 32-बिट शाखा के लिए उपयोग किए जाते हैं, उदाहरण के लिए, 64-बिट रजिस्टरों के साथ संचालित PUSH और POP निर्देश। यह कैसे काम करता है? तथ्य यह है कि इन निर्देशों के 32-बिट और 64-बिट रूपों को एक ही तरीके से एन्कोड किया गया है, और उनकी व्याख्या प्रोसेसर ऑपरेटिंग मोड पर निर्भर करती है। तो, 32-बिट मोड में कोड 53h PUSH EBX निर्देश से मेल खाता है, और 64-बिट मोड में यह PUSH RBX निर्देश से मेल खाता है।

उपप्रोग्राम के इनपुट और आउटपुट मापदंडों के संचरण तंत्र पर विचार करें।

IA32 EFI के लिए, कॉल किए गए रूटीन के इनपुट मापदंडों को स्टैक के माध्यम से पारित किया जाता है। इस प्रक्रिया में, पहला पैरामीटर [ESP + 16] पर स्थित है। ऑफसेट 16 दो शब्दों से बना है: 4 स्टैक बाइट्स का उपयोग EIP इंस्ट्रक्शन काउंटर को स्टोर करने के लिए किया जाता है, जो कि सबरूटीन से लौटते समय आवश्यक होता है, EBX, ECX, EDX के लिए 12 बाइट्स जो PUSH निर्देश द्वारा स्टैक को लिखे जाते हैं। 4 + 12 = 16।

X64 UEFI के लिए, बुलाया सबरूटीन के पहले चार इनपुट मापदंडों को रजिस्टरों RCX, RDX, R8, R9, स्टैक के माध्यम से अगले पास किया जाता है। हमारे उदाहरण में, केवल दो मापदंडों का उपयोग किया जाता है, जो RCX और RDX को पास किए जाते हैं।

IA32 UEFI के लिए, x86 सबरूटीन से लौटने के बाद 32-बिट x86 EAX रजिस्टर की सामग्री 64-बिट EBC रजिस्टर R7 के 32 लो-ऑर्डर बिट्स में हैं। R7 के उच्च 32 बिट्स की सामग्री अपरिभाषित है। X64 UEFI के लिए, x86 सबरूटीन से लौटने के बाद 64-बिट x86 RAX रजिस्टर की सामग्री EBC रजिस्टर R7 में हैं। यह कार्यक्षमता स्टेटस कोड्स को ट्रांसमिट करने के लिए सुविधाजनक है; इसे उपयोग में नहीं माना जाता है।

वर्णित तकनीक का उपयोग न केवल आवेदन में शामिल प्रक्रियाओं को कॉल करने के लिए किया जाता है, बल्कि यूईएफआई एपीआई तक पहुंचने के दौरान, जिसके प्रसंस्करण को फर्मवेयर में लागू किया जाता है। उदाहरण के लिए, CPU आर्किटेक्चरल प्रोटोकॉल और फाइल I / O प्रोटोकॉल फ़ंक्शन का उपयोग करते समय।

सारांश

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

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