चढ़ाई एलब्रस - लड़ाई में टोही। तकनीकी भाग 2. व्यवधान, अपवाद, सिस्टम टाइमर

हम इसे Embox को पोर्ट करके Elbrus का पता लगाना जारी रखते हैं।

यह लेख एल्ब्रस वास्तुकला पर एक तकनीकी लेख का भाग दो है। पहले भाग ने स्टैक, रजिस्टर, और इसी तरह से निपटा। इस भाग को पढ़ने से पहले, हम अनुशंसा करते हैं कि आप पहले अध्ययन करें, क्योंकि यह एल्ब्रस वास्तुकला में बुनियादी चीजों के बारे में बात करता है। यह खंड टाइमर, इंटरप्ट और अपवादों पर केंद्रित होगा। यह, फिर से, आधिकारिक दस्तावेज नहीं है। इसके लिए, आपको आईसीएसटी में एलब्रस के डेवलपर्स से संपर्क करना चाहिए।
एल्ब्रस का अध्ययन करना शुरू करना, हम जल्दी से टाइमर शुरू करना चाहते थे, क्योंकि, जैसा कि आप जानते हैं, प्रीमेप्टिव मल्टीटास्किंग इसके बिना काम नहीं करता है। ऐसा करने के लिए, यह बाधा नियंत्रक और टाइमर को लागू करने के लिए पर्याप्त लग रहा था, लेकिन हम अप्रत्याशित अपेक्षित कठिनाइयों में भाग गए, हम उनके बिना कहां जाएंगे। उन्होंने डिबगिंग क्षमताओं की तलाश शुरू की और पता चला कि डेवलपर्स ने कई आज्ञाओं को पेश करके इस बात का ध्यान रखा है जो आपको विभिन्न असाधारण स्थितियों को बढ़ाने की अनुमति देते हैं। उदाहरण के लिए, आप रजिस्टर PSR (प्रोसेसर स्टेटस रजिस्टर) और UPSR (उपयोगकर्ता प्रोसेसर रजिस्टर) के माध्यम से एक विशेष प्रकार का अपवाद उत्पन्न कर सकते हैं। PSR के लिए, exc_last_wish बिट प्रक्रिया से लौटते समय exc_last_wish अपवाद ध्वज है, और UPSR के लिए, exc_d_interrupt VFDI ऑपरेशन द्वारा उत्पन्न विलंबित अवरोध ध्वज है (विलंब अवरोधन ध्वज की जाँच करें)।

कोड इस प्रकार है:

#define UPSR_DI (1 << 3) /*   .h  */ rrs %upsr, %r1 ors %r1, UPSR_DI, %r1 /* upsr |= UPSR_DI; */ rws %r1, %upsr vfdi /*      */ 

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

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

  cpuid = __e2k_atomic32_add(1, &last_cpuid); if (cpuid > 1) { /* XXX currently we support only single core */ while(1); } /* copy of trap table */ memcpy((void*)0, &_t_entry, 0x1800); kernel_start(); 

ऐसा किया

  /* Since we enable exceptions only when all CPUs except the main one * reached the idle state (cpu_idle), we can rely that order and can * guarantee exceptions happen strictly after all CPUS entries. */ if (entries_count >= CPU_COUNT) { /* Entering here because of expection or interrupt */ e2k_trap_handler(regs); ... } /* It wasn't exception, so we decide this usual program execution, * that is, Embox started on CPU0 or CPU1 */ e2k_wait_all(); entries_count = __e2k_atomic32_add(1, &entries_count); if (entries_count > 1) { /* XXX currently we support only single core */ cpu_idle(); } e2k_kernel_start(); } 

और अंत में हमने रुकावट में प्रवेश करने की प्रतिक्रिया देखी (बस प्रिंटफ की मदद से हमने एक पंक्ति छापी)।

यहाँ यह समझाने लायक है कि शुरू में पहले संस्करण में हमें अपवाद तालिका की प्रतिलिपि बनाने की उम्मीद थी, लेकिन सबसे पहले, यह पता चला कि यह हमारे पते पर था, और दूसरी बात, हम सही प्रतिलिपि बनाने में सक्षम नहीं थे। मुझे लिंकर स्क्रिप्ट, सिस्टम में प्रवेश बिंदु, और इंटरप्ट हैंडलर को फिर से लिखना पड़ा, अर्थात, मुझे इसके बारे में थोड़ी देर बाद कोडांतरक भाग की आवश्यकता थी।

इस तरह से स्क्रिप्ट लिंकर का संशोधित हिस्सा अब दिखता है:

 .text : { _start = .; _t_entry = .; /* Interrupt handler */ *(.ttable_entry0) . = _t_entry + 0x800; /* Syscall handler */ *(.ttable_entry1) . = _t_entry + 0x1000; /* longjmp handler */ *(.ttable_entry2) . = _t_entry + 0x1800; _t_entry_end = .; *(.e2k_entry) *(.cpu_idle) /* text */ } 

अर्थात्, हमने अपवाद तालिका के लिए प्रवेश अनुभाग को हटा दिया। Cpu_idle अनुभाग उन CPU के लिए भी वहां स्थित है, जिनका उपयोग नहीं किया गया है।

यह वह क्रिया है जो हमारे सक्रिय कर्नेल की तरह दिखती है, जिस पर Embox चलेगा:

 static void e2k_kernel_start(void) { extern void kernel_start(void); int psr; /*    CPU “” */ while (idled_cpus_count < CPU_COUNT - 1) ; ... /*     ,     */ e2k_upsr_write(e2k_upsr_read() & ~UPSR_FE); kernel_start(); /*   Embox */ } 

खैर, VFDI निर्देश के अनुसार, एक अपवाद फेंक दिया गया था। अब आपको यह सुनिश्चित करने के लिए उसका नंबर प्राप्त करने की आवश्यकता है कि यह सही अपवाद है। इसके लिए, एल्ब्रस में TIR इंटरप्ट इंफॉर्मेशन रजिस्टर (ट्रैप इन्फो रजिस्टर) है। उनमें अंतिम कुछ कमांड्स के बारे में जानकारी होती है, यानी ट्रेस का अंतिम भाग। ट्रेस कार्यक्रम के निष्पादन के दौरान इकट्ठा होता है और एक बाधा में प्रवेश करते समय "जमा देता है"। टीआईआर में निम्न (64 बिट्स) और उच्च (64 बिट्स) हिस्से शामिल हैं। कम शब्द में अपवाद झंडे होते हैं, और उच्च शब्द में निर्देश के लिए एक सूचक होता है जो अपवाद और वर्तमान टीआईआर संख्या का नेतृत्व करता था। तदनुसार, हमारे मामले में, exc_d_interrupt 4 बिट है।

नोट हमें अभी भी TIRs की गहराई (संख्या) के बारे में कुछ गलतफहमी है। प्रलेखन प्रदान करता है:

“टीआईआर मेमोरी डेप्थ, यानी ट्रैप इंफो रजिस्टर की संख्या निर्धारित की जाती है
TIR_NUM मैक्रो के लिए आवश्यक प्रोसेसर पाइपलाइन चरणों की संख्या के बराबर है
सभी संभव विशेष स्थितियों को जारी करना। TIR_NUM = 19; "

व्यवहार में, हम गहराई = 1 देखते हैं, और इसलिए हम केवल TIR0 रजिस्टर का उपयोग करते हैं।

MCST के विशेषज्ञों ने हमें समझाया कि सब कुछ सही है, और केवल "सटीक" व्यवधान के लिए TIR0 होगा, लेकिन अन्य स्थितियों के लिए कुछ और हो सकता है। लेकिन जब से हम केवल टाइमर इंटरप्ट के बारे में बात कर रहे हैं, यह हमें परेशान नहीं करता है।

ठीक है, अब आइए देखें कि अपवाद हैंडलर को सही ढंग से दर्ज / बाहर करने के लिए क्या आवश्यक है। वास्तव में, इनपुट पर सहेजना और आउटपुट पर निम्नलिखित 5 रजिस्टरों को पुनर्स्थापित करना आवश्यक है। तीन नियंत्रण हस्तांतरण तैयारी रजिस्टर ctpr [1,2,3] हैं, और दो चक्र नियंत्रण रजिस्टर ILCR (चक्र काउंटर के प्रारंभिक मूल्यों का रजिस्टर) और LSR (चक्र स्थिति का रजिस्टर) हैं।

 .type ttable_entry0,@function ttable_entry0: setwd wsz = 0x10, nfx = 1; rrd %ctpr1, %dr1 rrd %ctpr2, %dr2 rrd %ctpr3, %dr3 rrd %ilcr, %dr4 rrd %lsr, %dr5 /* sizeof pt_regs */ getsp -(5 * 8), %dr0 std %dr1, [%dr0 + PT_CTRP1] /* regs->ctpr1 = ctpr1 */ std %dr2, [%dr0 + PT_CTRP2] /* regs->ctpr2 = ctpr2 */ std %dr3, [%dr0 + PT_CTRP3] /* regs->ctpr3 = ctpr3 */ std %dr4, [%dr0 + PT_ILCR] /* regs->ilcr = ilcr */ std %dr5, [%dr0 + PT_LSR] /* regs->lsr = lsr */ disp %ctpr1, e2k_entry ct %ctpr1 

वास्तव में, यह सभी अपवाद हैंडलर से बाहर निकलने के बाद, आपको इन 5 रजिस्टरों को पुनर्स्थापित करने की आवश्यकता है।

हम इसे एक मैक्रो के साथ करते हैं:

 #define RESTORE_COMMON_REGS(regs) \ ({ \ uint64_t ctpr1 = regs->ctpr1, ctpr2 = regs->ctpr2, \ ctpr3 = regs->ctpr3, lsr = regs->lsr, \ ilcr = regs->ilcr; \ /* ctpr2 is restored first because of tight time constraints \ * on restoring ctpr2 and aaldv. */ \ E2K_SET_DSREG(ctpr1, ctpr1); \ E2K_SET_DSREG(ctpr2, ctpr2); \ E2K_SET_DSREG(ctpr3, ctpr3); \ E2K_SET_DSREG(lsr, lsr); \ E2K_SET_DSREG(ilcr, ilcr); \ }) 

यह भी महत्वपूर्ण है कि DONE ऑपरेशन (हार्डवेयर इंटरप्ट हैंडलर से रिटर्न) के लिए रजिस्टरों की बहाली के बाद भूल न जाएं। यह ऑपरेशन आवश्यक है, विशेष रूप से, बाधित नियंत्रण हस्तांतरण कार्यों को सही ढंग से संसाधित करने के लिए। हम इसे एक मैक्रो के साथ करते हैं:

 #define E2K_DONE \ do { \ asm volatile ("{nop 3} {done}" ::: "ctpr3"); \ } while (0) 

वास्तव में, हम इन दो मैक्रोज़ का उपयोग करके सी कोड में सीधे रुकावट से वापसी करते हैं।

  /* Entering here because of expection or interrupt */ e2k_trap_handler(regs); RESTORE_COMMON_REGS(regs); E2K_DONE; 

बाहरी व्यवधान

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

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

हम निम्नलिखित समाधान का उपयोग करते हैं। पीएसआर रजिस्टर आपको यूपीएसआर के माध्यम से प्रबंधन को सक्षम करने की अनुमति देता है, जो पहले से ही वैश्विक है (जिसकी हमें आवश्यकता है)। इसलिए, हम Embox कोर लॉगिन फ़ंक्शन से पहले सीधे UPSR (महत्वपूर्ण!) के माध्यम से नियंत्रण सक्षम करते हैं:

  /* PSR is local register and makes sense only within a function, * so we set it here before kernel start. */ asm volatile ("rrs %%psr, %0" : "=r"(psr) :); psr |= (PSR_IE | PSR_NMIE | PSR_UIE); asm volatile ("rws %0, %%psr" : : "ri"(psr)); kernel_start(); 

किसी तरह संयोग से मैंने फिर से काम किया और इन पंक्तियों को एक अलग फ़ंक्शन में डाल दिया ... और रजिस्टर फ़ंक्शन के लिए स्थानीय है। यह स्पष्ट है कि सब कुछ टूट गया है :)

तो, प्रोसेसर में सब कुछ चालू होने लगता है, इंटरप्ट कंट्रोलर पर जाएं।

जैसा कि हमने ऊपर देखा है, अपवाद संख्या के बारे में जानकारी TIR रजिस्टर में है। इसके अलावा, इस रजिस्टर में 32 वें बिट की रिपोर्ट है कि एक बाहरी व्यवधान उत्पन्न हुआ है।

टाइमर को चालू करने के बाद, कुछ दिनों की पीड़ा के बाद, कोई रुकावट नहीं आई। कारण काफी मनोरंजक था। एल्ब्रस में 64-बिट पॉइंटर्स हैं, और APIC में रजिस्टर का पता uint32_t में मिला, इसीलिए हमने उनका इस्तेमाल किया। लेकिन यह पता चला है कि यदि आपको आवश्यकता है, उदाहरण के लिए, 0xF0000000 को एक सूचक पर कास्ट करें, तो आपको 0xF0000000 नहीं, बल्कि 0xFFFFFFFFF0000000 मिलेगा। यही है, संकलक आपके अहस्ताक्षरित इंट साइन का विस्तार करेगा।

यहां, ज़ाहिर है, uintptr_t का उपयोग करना आवश्यक था, क्योंकि, जैसा कि यह निकला, C99 मानक में, इस प्रकार के रूपांतरण को परिभाषित परिभाषित रूप में परिभाषित किया गया था।

हमने आखिरकार टीआईआर में उठाए गए 32 वें बिट को देखा, हमने यह देखना शुरू किया कि इंटरप्ट नंबर कैसे प्राप्त किया जाए। यह काफी सरल निकला, हालांकि x86 पर बिल्कुल भी नहीं, यह LAPIC कार्यान्वयन के बीच के अंतरों में से एक है। एल्ब्रस के लिए, इंटरप्ट नंबर प्राप्त करने के लिए, आपको विशेष LAPIC रजिस्टर में जाना होगा:

  #define APIC_VECT (0xFEE00000 + 0xFF0) 

जहां 0xFEE00000 LAPIC रजिस्टरों का आधार पता है।

यह सब है, यह सिस्टम टाइमर और LAPIC टाइमर दोनों को लेने के लिए निकला।

निष्कर्ष

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



एल्ब्रस वास्तुकला के बारे में यह अंतिम तकनीकी हिस्सा नहीं है। अब हम Elbrus में मेमोरी मैनेजमेंट (MMU) में महारत हासिल कर रहे हैं, हम जल्द ही इसके बारे में बात करने की उम्मीद करते हैं। हमें न केवल आभासी पते के रिक्त स्थान के कार्यान्वयन के लिए, बल्कि बाह्य उपकरणों के साथ सामान्य कार्य के लिए भी इसकी आवश्यकता है, क्योंकि इस तंत्र के माध्यम से आप पता स्थान के एक विशिष्ट क्षेत्र के कैशिंग को अक्षम या सक्षम कर सकते हैं।

लेख में जो कुछ लिखा गया है वह सब कुछ Embox रिपॉजिटरी में पाया जा सकता है। आप निर्माण और चला सकते हैं, यदि निश्चित रूप से एक हार्डवेयर प्लेटफॉर्म है। सच है, इसके लिए एक कंपाइलर की आवश्यकता होती है, और यह केवल MCST पर प्राप्त किया जा सकता है। आधिकारिक प्रलेखन वहाँ अनुरोध किया जा सकता है।