👨🏽‍🔬 🖕🏻 👩‍👩‍👦 MIPS प्रणाली कॉल 😰 👸 🖕🏾

इस गर्मी में, एपप्लामैक ने एमआइपीएस असेम्बलर सीखने के बारे में एक लेख प्रकाशित किया । इसमें, विशेष रूप से, सिस्टम कॉल उत्पन्न करने वाले syscall कमांड पर विचार किया गया था। लेखक ने एमआइपीएस असेंबलर को समझाने पर ध्यान केंद्रित किया, और, मेरी राय में, विस्तार से नहीं बताया कि यह सिस्टम कॉल क्या है। उस समय, मैं MIPS आर्किटेक्चर के लिए प्रोजेक्ट को स्थानांतरित करने में लगा हुआ था, मैं व्यवधानों, अपवादों और सिस्टम कॉल से निपटता था।

अब चूंकि कोड पहले ही लिखा और डिबग किया जा चुका है, इसलिए मैंने एक लेख लिखने का फैसला किया है, जो यह बताता है कि MIPS में सिस्टम कॉल तंत्र कैसे काम करता है। आप इसे कोडांतरक पर उस लेख के अतिरिक्त के रूप में मान सकते हैं।

परिचय

सबसे पहले, आपको यह समझने की आवश्यकता है कि सिस्टम कॉल क्या हैं, और उनकी आवश्यकता क्यों है।
विकिपीडिया निम्नलिखित परिभाषा देता है:

प्रोग्रामिंग और कंप्यूटर इंजीनियरिंग में एक सिस्टम कॉल एक ऑपरेशन करने के लिए एक ऑपरेटिंग सिस्टम के कर्नेल के लिए एक एप्लिकेशन प्रोग्राम की अपील है।
प्रोग्रामर के दृष्टिकोण से, एक सिस्टम कॉल आमतौर पर सिस्टम लाइब्रेरी से सबरूटीन या फ़ंक्शन कॉल की तरह दिखता है। हालांकि, इस तरह के फ़ंक्शन या सबरूटीन को कॉल करने के एक विशेष मामले के रूप में एक सिस्टम कॉल को सिस्टम लाइब्रेरी में अधिक सामान्य कॉल से अलग किया जाना चाहिए, क्योंकि बाद वाले को विशेषाधिकार प्राप्त संचालन की आवश्यकता नहीं हो सकती है।

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

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

MIPS वास्तुकला

आइए MIPS वास्तुकला में इन उपप्रणालियों के एक विशिष्ट कार्यान्वयन के लिए आगे बढ़ते हैं।

MIPS संस्करण 2 आर्किटेक्चर में व्यवधान के लिए ऑपरेशन के कई तरीके हैं। वे स्वयं के तालिकाओं के आधार पते और संरचनाओं में भिन्न होते हैं।
आधार पते के लिए दो तरीके हैं:

पहले मामले में, प्रोसेसर, किसी भी प्रकार के अपवाद का सामना करता है, पता तय पते (0x80000180) पर नियंत्रण स्थानांतरित करता है, प्रोसेसर का आकार 128 बाइट्स है।
दूसरे में, प्रोसेसर CP0_EBASE रजिस्टर में निर्दिष्ट पते पर नियंत्रण स्थानांतरित करता है, प्रोसेसर का आकार 256 बाइट्स है।

रुकावट तालिका की संरचना के लिए दो ऑपरेटिंग मोड हैं: सामान्य, जब एक हैंडलर को सभी अपवादों और वेक्टर के जवाब में कहा जाता है, जिसमें प्रत्येक रुकावट संख्या में हैंडलर के लिए अपना स्थान होता है।

ये मोड MIPS प्रोसेसर के विशेष रजिस्टरों में सेट किए गए हैं। विशेष रजिस्टरों, सामान्य प्रयोजन के रजिस्टरों के विपरीत, प्रोग्राम द्वारा स्वयं प्रोसेसर को नियंत्रित करने के लिए उपयोग किया जाता है।

MIPS में, इस तरह के रजिस्टर को कोप्रोसेसर 0. में लिया जाता है और उन्हें रजिस्टर में पढ़ने के लिए mfc0 - और विशेष असेंबलर कमांड द्वारा एक्सेस किया जाता है - और रजिस्टर करने के लिए mtc0 -।
रजिस्टर इंडेक्स और कोप्रोसेसर चयनकर्ता द्वारा संबोधित किया जाता है। सिस्टम कॉल से निपटने के लिए यहां कुछ महत्वपूर्ण रजिस्टर दिए गए हैं:

नाम	सूची	चयनकर्ता	विवरण
CP0_STATUS	12	0	प्रोसेसर के लिए नियंत्रण झंडे
CP0_CAUSE	13	0	रुकावट के कारण के बारे में जानकारी
CP0_EPC	14	0	उस आदेश का पता जो व्यवधान के समय निष्पादित हो रहा था
CP0_EBASE	15	1	अपवाद हैंडलिंग प्रक्रिया का आधार पता

अपवाद हैंडलिंग मोड के विनिर्देश पर लौटते हुए, उन्हें दो रजिस्टरों में सेट किया जाता है: CP0_STATUS और CP0_CAUSE, जिनमें निम्न प्रारूप हैं।

SP0_STATUS

31-28	27	26	25	24	23	22	21	20	19	18-16	15-8	7	6	5	4-3	2	1	0
CU3..CU0	आरपी	एफआर	आरई	एमएक्स	PX	BEV	टीएस	एसआर	एनएमआई	impl	IM7..IM0	KX	SX	UX	KSU	ERL	EXL	आईई

CP0_CAUSE

31	30	29-28	27	26	25-24	23	22	21-16	15-10	9-8	7	6-2	1-0
BD	टीआई	सीई	डीसी	पीसीआई	0	चतुर्थ	WP	0	आईपी	आईपी	0	exCode	0

सीपीयू आरंभीकरण

मैं ऑपरेशन के पहले मोड को सबसे सरल और सभी एमआइपी प्रोसेसर के साथ संगत मानूंगा। अन्य सभी तरीके समान तरीके से किए जाते हैं।

प्रोसेसर को इस मोड में रखने के लिए, आपको स्थिति रजिस्टर में BEV बिट और कारण रजिस्टर में बिट IV को रीसेट करना होगा।

सी कोड प्रोजेक्ट से

/* Setup a proper exception table and enable exceptions. */ static int mips_exception_init(void) { unsigned int reg; /* clear BEV bit */ reg = mips_read_c0_status(); reg &= ~(ST0_BEV); mips_write_c0_status(reg); /* clear CauseIV bit */ reg = mips_read_c0_cause(); reg &= ~(CAUSE_IV); mips_write_c0_cause(reg); /* copy the first exception handler */ memcpy((void *)(EBASE + 0x180), &mips_first_exception_handler, 0x80); mips_setup_exc_table(); /* clear EXL bit */ reg = mips_read_c0_status(); reg &= ~(ST0_ERL); mips_write_c0_status(reg); return 0; }

एक बाधा, अपवाद या सिस्टम कॉल होने पर इन बिट्स को साफ़ करने के बाद, प्रोसेसर निर्देश के अनुक्रमिक निष्पादन को बाधित करता है और नियंत्रण को 0x80000180 पते पर स्थानांतरित करता है, जहां इस पते पर हमारे द्वारा कॉपी किया गया प्राथमिक प्रसंस्करण कोड स्थित है। इसी समय, प्रोसेसर विशेषाधिकार प्राप्त मोड में चला जाता है, CP0_EPC रजिस्टर में रिटर्न एड्रेस बचाता है, और CP0_CAUSE रजिस्टर (अपवाद कोड फ़ील्ड में) में अपवाद का कारण (प्रकार) लिखता है।

अपवाद कोड फ़ील्ड के बारे में थोड़ा और विस्तार के लायक है। जैसा कि ऊपर उल्लेख किया गया है, एमआइपीएस में, साथ ही साथ अन्य आर्किटेक्चर में, एक उपतंत्र में, सिस्टम कॉल और हार्डवेयर अपवाद आमतौर पर एक समान तरीके से लागू होते हैं। यही है, हैंडलर कोड पहली बात यह है कि क्या हुआ के बारे में जानकारी को बचाने के लिए करना चाहिए। यह वह जानकारी है जो अपवाद कोड फ़ील्ड में दर्ज की गई है। MIPS में, यह क्षेत्र निम्नलिखित मान ले सकता है:

कोड	पद	विवरण
0	INT	बाहरी व्यवधान
1-3		वर्चुअल मेमोरी के साथ काम करना
4	ADDRL	Unaligned पते से पढ़ना
5	addrs	असंतुलित पता रिकॉर्डिंग
6	ibus	निर्देश पढ़ने में त्रुटि
7	DBUS	डेटा बस में त्रुटि
8	syscall	सिस्टम कॉल
9	BKPT	ब्रेकपाइंट
10	आरआई	आरक्षित निर्देश
11		कोप्रोसेसर त्रुटि
12	OVF	अंकगणित अतिप्रवाह
13 और ऊपर		फ्लोटिंग पॉइंट ऑपरेशन

हैंडलिंग सिस्टम कॉल

पहले स्तर का हैंडलर

प्राथमिक हैंडलर को असेंबलर में लिखा जाता है।

 NESTED(mips_first_exception_handler, 0, $sp) .set push /* save the current status of flags */ mfc0 $k1, $CP0_CAUSE andi $k1, $k1, 0x7c /* read exception number */ j mips_second_exception_handler /* jump to real exception handler */ nop .set pop /* restore the previous status of flags */ END(mips_first_exception_handler)

यह सिर्फ रजिस्टर $ k1 में अपवाद के प्रकार को संग्रहीत करता है और दूसरे स्तर के हैंडलर को कॉल करता है, जो अब आकार में सीमित नहीं है। कॉल कमांड "j" द्वारा किया जाता है, न कि "जार", क्योंकि हैंडलर कोड प्रोग्राम ऑपरेशन के दौरान रखा जाता है (हमने इसे इनिशियलाइज़ेशन फंक्शन्स में कॉपी किया है), और हमें कॉल की गई प्रक्रिया के सापेक्ष पते के बजाय एक संपूर्ण होना चाहिए।

यहाँ उल्लेख के लायक एक अन्य विशेषता k1 रजिस्टर है।
MIPS वास्तुकला में 32 सामान्य-उद्देश्य रजिस्टर r0 - r31 हैं। और सम्मेलन द्वारा, कुछ रजिस्टरों को एक विशेष तरीके से उपयोग किया जाता है, उदाहरण के लिए, आर 31 रजिस्टर का उपयोग स्टैक के लिए एक पॉइंटर के रूप में किया जाता है, और इसे विशेष नाम सपा द्वारा एक्सेस किया जा सकता है। वही रजिस्टर k0 (r26) और k1 (r27) के साथ है, संकलक उनका उपयोग नहीं करता है, वे ओएस के कर्नेल में उपयोग के लिए आरक्षित हैं, और व्यवधान से निपटने केवल इस तरह के विशेष उपयोग का मामला है।

दूसरे स्तर का हैंडलर

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

  LEAF(mips_second_exception_handler) SAVE_ALL /* save all needed registers */ PTR_L $k0, exception_handlers($k1) /* exception number is an offset in array */ PTR_LA $ra, restore_from_exception /* return address for exit from exception */ move $a0, $sp /* Arg 0: saved regs. */ jr $k0 /* Call C code. */ nop restore_from_exception: /* label for exception return address */ RESTORE_ALL /* restore all registers and return from exception */ END(mips_second_exception_handler)

SAVE_ALL एक कोडांतरक मैक्रो है। यह इस प्रकार दिखता है।

  .macro SAVE_ALL LONG_ADDI $sp, -PT_SIZE SAVE_SOME SAVE_AT SAVE_TEMP SAVE_STATIC .endm

मैं सभी नेस्टेड मैक्रोज़ के सोर्स कोड का हवाला नहीं दूंगा। मैं केवल यह कह सकता हूं कि पहली पंक्ति में रुकावट के लिए एक स्टैक फ्रेम होता है, जहां सभी आवश्यक रजिस्टर क्रमिक रूप से सहेजे जाते हैं।
SAVE_AT - (r1) पर रजिस्टर कोडांतरक द्वारा उपयोग के लिए आरक्षित है और इसके साथ काम को निर्देश ".सेट नॉट" और ".सेट एट" द्वारा अलग किया जाना चाहिए (ताकि कोई कंपाइलर चेतावनी न हो)
SAVE_TEMP - अस्थायी रजिस्टर (r8-r15) और (r24-r25) बचाता है
SAVE_STATIC - s0-s7 पंजीकृत करता है
SAVE_SOME - आवश्यक सेवा रजिस्टर, उदाहरण के लिए, स्टैक के लिए एक सूचक और विशेष कोप्रोसेसर रजिस्टरों (उदाहरण के लिए, एक स्थिति रजिस्टर), इसलिए यह मैक्रो पहले होना चाहिए।

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

यहाँ इस संरचना का वर्णन है

 typedef struct pt_regs { unsigned int reg[25]; unsigned int gp; /* global pointer r28 */ unsigned int sp; /* stack pointer r29 */ unsigned int fp; /* frame pointer r30 */ unsigned int ra; /* return address 31*/ unsigned int lo; unsigned int hi; unsigned int cp0_status; unsigned int pc; }pt_regs_t;

तृतीय-स्तरीय हैंडलर (C कोड)

प्रोसेसर के लिए कोड निम्नानुसार है

 void mips_c_syscall_handler(pt_regs_t *regs) { uint32_t result; /* v0 contains syscall number */ uint32_t (*sys_func)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t) = SYSCALL_TABLE[regs->reg[1]]; /* a0, a1, a2, a3, s0 contain arguments */ result = sys_func(regs->reg[3], regs->reg[4], regs->reg[5], regs->reg[6], regs->reg[15]); /* v0 set equal to result */ regs->reg[1] = result; regs->pc += 4; /* skip comand generated syscall */ }

आशा है कि सब कुछ कोड से स्पष्ट है:

सबसे पहले, हम वांछित संख्या के साथ सिस्टम कॉल हैंडलर की संख्या प्राप्त करते हैं।
फिर हम इस हैंडलर को कॉल करते हैं, जो कि एक सिस्टम कॉल के दौरान हो सकता है।
रजिस्टर v0 में हमने कॉल का परिणाम डाल दिया।
और अंत में, हम सिस्टम कॉल को उत्पन्न करने वाले कमांड को छोड़ देते हैं, अन्यथा हम उसी पते पर लौटेंगे जहां यह हुआ था, और कॉल फिर से होगा।

एक सिस्टम कॉल प्राप्त करना

अब हमें सिस्टम कॉल करने के तरीके के बारे में बात करने की आवश्यकता है।
एक सिस्टम कॉल एक विशेष असेम्बलर कमांड द्वारा जेनरेट किया जाता है: उदाहरण के लिए, x86 में यह int है , SPARC में यह टा है , और MIPS में यह syscall है ।

जैसा कि यह संभवतः पिछले भाग से स्पष्ट हो गया है, सिस्टम कॉल के समय, कॉल नंबर को रजिस्टर v0 में संग्रहीत किया जाना चाहिए, और रजिस्टरों a0, a1, a2, a3 में स्थानांतरित किया जाना चाहिए। यहां, उदाहरण के लिए, एक फ़ंक्शन के लिए कोड है जो रजिस्टर ए में एक तर्क रखता है और सिस्टम को 0x11 कॉल करता है। मुझे लगता है कि पाठक जीसीसी इनलाइन कोडांतरक से परिचित है

 static inline int syscall_demo(int arg1) { long __res; __asm__ volatile ( "move $a0, %2\n\t" "li $v0, %1\n\t" "syscall\n\t" "move %0, $v0" : "=r" (__res) : "I" (0x11), "r" ((long)(arg1))); return __res; }

बेशक, प्रत्येक प्रकार के कार्यों को लिखना सुविधाजनक नहीं है, यही कारण है कि मैक्रोज़ का उपयोग किया जाता है। निम्नलिखित एक मैक्रो कोड है जो एक पैरामीटर के साथ सिस्टम कॉल फ़ंक्शन की घोषणा करता है।

 #define __SYSCALL1(NR,type,name,type1,arg1) \ static inline type name(type1 arg1) \ { \ long __res; \ __asm__ volatile ( \ "move $a0, %2\n\t" \ "li $v0, %1\n\t" \ "syscall\n\t" \ "move %0, $v0" \ \ : "=r" (__res) \ : "I" (NR), \ "r" ((long)(arg1))); \ return __res; \ }

एक अलग संख्या के मापदंडों के साथ सिस्टम कॉल के लिए कोड दिए गए के समान है।

यह सब एक साथ रखना। हमारी परियोजना कई परीक्षणों का उपयोग करती है, जिनमें से एक नीचे स्थित है।

 SYSCALL1(1,int,syscall_1,int,arg1); TEST_CASE("calling syscall with one argument") { test_assert_equal(syscall_1(1), 1); }

SYSCALL मैक्रो को इनलाइन असेम्बलर के साथ उपरोक्त कोड में विस्तारित किया जाता है, इसे नंबर 1 (मैक्रो का पहला तर्क) द्वारा कॉल नाम syscall_1 (तीसरे पैरामीटर) के रूप में प्रतिस्थापित किया जाता है, वापसी प्रकार इंट (दूसरा मैक्रो पैरामीटर) है, और चर का प्रकार भी int (चौथा मैक्रो पैरामीटर है) )।
परीक्षण स्वयं जांचता है कि syscall_1 (1) पर कॉल का परिणाम एक के बराबर होगा।

निष्कर्ष

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

अंत तक पढ़ने वाले सभी को धन्यवाद! मुझे टिप्पणियों, सिफारिशों और सुझावों को सुनकर खुशी होगी।

MIPS प्रणाली कॉल