👨🏼‍💻 🤾🏾 🕚 मैं एक खिलौना ओएस लिख रहा हूँ (रुकावट के बारे में) 🙍🏽 👩🏾‍🤝‍👨🏽 👩‍✈️

यह लेख एक ब्लॉग पोस्ट के रूप में लिखा गया है। यदि यह आपके लिए दिलचस्प हो जाता है, तो एक अगली कड़ी होगी।

पिछले चार महीनों से, मैं x86_64 के लिए खिलौना OS लिखने के लिए खाली समय दे रहा हूं। स्रोत कोड यहाँ है

सामान्य विचार (जो अभी भी कार्यान्वयन से बहुत दूर है) इस प्रकार है: एकल 64-बिट पता स्थान जिसमें अनन्त धागे होते हैं (जैसे कि फैंटम ओएस); एक वर्चुअल मशीन जो कोड निष्पादन के लिए सुरक्षा प्रदान करती है। वर्तमान में लागू:

1. एक मल्टीबूट बूटलोडर (GRUB) का उपयोग करके कर्नेल लोड करना;
2. पाठ वीजीए मोड (16-रंग, kprintf);
पृष्ठों को प्रदर्शित करने के लिए 3. सरल इंटरफ़ेस;
4. सी में व्यवधान को संभालने की क्षमता;
5. प्रोसेसर टोपोलॉजी (सॉकेट्स, कोर, थ्रेड्स) और उनके लॉन्च की पहचान;
6. प्राथमिकता समर्थन के साथ प्रीमेप्टिव एसएमपी अनुसूचक का एक कामकाजी प्रोटोटाइप;

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

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

लंबे मोड में रुकावट के समय, प्रोसेसर हैंडलर स्टैक में एक फ्रेम बनाता है (यह या तो एक उपयोगकर्ता या अलग से आवंटित स्टैक हो सकता है) जिसमें सहेजे गए रजिस्टर होते हैं:

दरअसल, यह तस्वीर संरक्षित मोड से मेल खाती है (मुझे लंबे मोड के लिए उच्च-गुणवत्ता वाली तस्वीर नहीं मिली), लेकिन, छोटे विवरणों के अलावा, सिद्धांत बिल्कुल समान है। उपयोगकर्ता स्ट्रीम के शेष रजिस्टर बरकरार हैं, इसलिए हैंडलर को उन्हें स्टैक पर सहेजना होगा। चूँकि हमारे हैंडलर को C में लिखा गया है, इसलिए हमें रजिस्टर का एक पूरा सेट सहेजना होगा, जिसमें FPU / MMX / SSE के 512 बाइट्स शामिल हैं। बेशक, आप कंपाइलर को पूरे कर्नेल के लिए सिमड कोड उत्पन्न करने से रोक सकते हैं, या केवल उन कार्यों के लिए जो अंदर काम करते हैं। पहले मामले में, हम कई अनुकूलन खो देते हैं, दूसरे में - हम आम तौर पर सी में हैंडलर लिखने के लाभ को बेअसर करते हैं, क्योंकि हम किसी भी मानक कार्यों का उपयोग करने में सक्षम नहीं होंगे। तो, हम एफएक्सयू / एमएमएक्स / एसएसई रजिस्टरों को जल्दी से बचाने / बहाल करने के लिए fxsave और fxrstor निर्देशों का उपयोग करते हैं।

यहाँ हमारे स्टैक फ्रेम की संरचना है:

struct int_stack_frame { uint64_t r15, r14, r13, r12, r11, r10, r9, r8; uint64_t rdi, rsi, rbp, rdx, rcx, rbx, rax; uint8_t fxdata[512]; uint32_t error_code; uint64_t rip; uint16_t cs; uint64_t rflags, rsp; uint16_t ss; };

एरर_कोड से पहले फ़ील्ड्स का पहला भाग मैन्युअल रूप से रजिस्टरों को सहेजा जाता है, दूसरा वह रजिस्टर्स है जो प्रोसेसर द्वारा स्वतः सेव किया जाता है। रिवर्स ऑर्डर इस तथ्य के कारण है कि स्टैक ऊपर से नीचे तक बढ़ता है। अब हम मैक्रो को आसानी से लिखने वाले हैंडलर के लिए परिभाषित करते हैं।

 #define DEFINE_INT_HANDLER(name) \ static NOINLINE \ void handle_##name##_int(UNUSED struct int_stack_frame *stack_frame, \ UNUSED uint64_t data) #define DEFINE_ISR_WRAPPER(name, handler_name, data) \ static NOINLINE void *get_##name##_isr(void) { \ ASMV("jmp 2f\n.align 16\n1: andq $(~0xF), %rsp"); \ ASMV("subq $512, %rsp\nfxsave (%rsp)"); \ ASMV("push %rax\npush %rbx\npush %rcx\npush %rdx\npush %rbp\n"); \ ASMV("push %rsi\npush %rdi\npush %r8\npush %r9\npush %r10"); \ ASMV("push %r11\npush %r12\npush %r13\npush %r14\npush %r15"); \ ASMV("movq %%rsp, %%rdi\nmovabsq $%P0, %%rsi" : : "i"(data)); \ ASMV("callq %P0" : : "i"(handle_##handler_name##_int)); \ ASMV("pop %r15\npop %r14\npop %r13\npop %r12\npop %r11"); \ ASMV("pop %r10\npop %r9\npop %r8\npop %rdi\npop %rsi"); \ ASMV("pop %rbp\npop %rdx\npop %rcx\npop %rbx\npop %rax"); \ ASMV("fxrstor (%rsp)\naddq $(512 + 8), %rsp"); \ void *isr; \ ASMV("iretq\n2: movq $1b, %0" : "=m"(isr)); \ return isr; \ } #define DEFINE_ISR(name, data) \ DEFINE_INT_HANDLER(name); \ DEFINE_ISR_WRAPPER(name, name, data) \ DEFINE_INT_HANDLER(name)

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

एक आवरण एक फ़ंक्शन है जो अपने स्वयं के शरीर में स्थित प्रसंस्करण कोड की शुरुआत के लिए एक संकेतक लौटाता है। इस ट्रिक के बारे में यहाँ और पढ़ें।

परिणामस्वरूप, एक हैंडलर लिखना और उसे एक बाधा से बांधना एक तुच्छ कार्य बन जाता है:

 DEFINE_ISR(foo) { //  C-   //  struct int_stack_frame *stack_frame  uint64_t data } set_isr(INT_FOO_VECTOR, get_foo_isr());

यह सब मैं ~~वियतनाम~~ को बाधित करने से निपटने के बारे में बताना चाहता था।

मैं एक खिलौना ओएस लिख रहा हूँ (रुकावट के बारे में)

More articles: