🌳 📛 👨🏿‍🌾 मल्टीटास्किंग माइक्रो कर्नेल ओएस डेवलपमेंट

जब आप हैबे पर उपलब्ध लेखों की श्रृंखला से हैलो वर्ल्ड गुठली लिखने के लिए बुनियादी चरणों को पढ़ते हैं, तो यह सबसे बुनियादी उपकरणों के गंभीर विकास को शुरू करने का समय है: हीप आवंटन और अनुसूचक।

महत्वपूर्ण :
1. शुरुआती लोगों के लिए सबक की यह श्रृंखला। लक्ष्य दुनिया का एक समग्र चित्र बनाना है। बहुत लंबे समय तक मेरे सिर में तेनबाम सिद्धांत था और मैं इसे अभ्यास से नहीं जोड़ सका। जिन लोगों के पास समान चीज है - मैं इस लेख को समर्पित करता हूं।
2. कोड सबसे सरल और विनम्र है, लेकिन जितना संभव हो उतना स्पष्ट है। मेरा लक्ष्य आपको एक समझ देना है, ताकि आप अपने कर्नेल को लिख सकें, इससे बहुत अच्छा।
3. जैसे ही मैं इसे विस्तृत श्रृंखला के लिए तैयार मानता हूं, मैं रेपो प्रकाशित कर दूंगा। मैं एक छोटा सा हिस्सा, डिबग लिखता हूं, और एक वीडियो ट्यूटोरियल शूट करता हूं। मेरे पास तैयार उत्पाद नहीं है।

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

मैंने दसवीं कक्षा में अपना ओएस लिखने का सपना देखा था। तेनबाम की किताब में एक अद्भुत संपत्ति है। जो भी इसे जल्द ही छू लेता है या बाद में अपने स्वयं के ऑपरेटिंग सिस्टम को लिखने का सपना देखने लगता है। लेकिन मैंने तब कुछ भी नहीं लिखा, जब मुझे एहसास हुआ कि एक मास्टर के दिन कोड के साथ एक स्वच्छ बाइनरी को संकलित करना और लिंक करना असंभव है। मुझे लिनक्स का अध्ययन करना था, विश्वविद्यालय जाना था, काम पर जाना था। सब कुछ नहीं होगा। हां, केवल दस साल बाद केवल एक सपना सच हुआ। अब, रिएक्ट पर उबाऊ साँचे बनाना, मैं पीछे मुड़कर देखता हूं, उस जुनून को याद करता हूं जिसके साथ मैंने डिसबेंबलर और डीबगर के लिए घंटों बिताए, पैकर्स को हटा दिया, दरार बक्से तोड़ दिए, मैंने रात में स्कूल के उपन्यासों के बहुत सारे लेख पढ़े ... और मैं समझता हूं कि मेरा जीवन अलग तरीके से बदल सकता था। काफी अलग। यदि केवल मेरे पास एक व्यक्ति था जो शुरुआत में मेरी मदद कर सकता था। लेकिन समय निकल गया। कार्यक्रमों को तोड़ना मुश्किल हो गया है। लिनक्स कर्नेल अविश्वसनीय आकार तक बढ़ गया है। हाइपरवाइजर दिखाई दिए। इंटेल असेंबलर इतना बड़ा हो गया है कि मैनुअल में आदेशों की एक सूची को देखकर, इसके बारे में सीखने के लिए कोई भी उत्साह गायब हो जाता है। हमें वेब पर रोटी कमानी थी। हां। सिस्टम प्रोग्रामिंग की दुनिया अपने सुनहरे वर्षों से बच गई है।

इसलिए, उन सभी छात्रों के लिए जिनके उत्साह में थकावट नहीं हुई है, मैं अपने स्वयं के खोल के साथ सबसे सरल मल्टीटास्किंग माइक्रोकर्नेल कोर को खरोंच से लेने और लिखने के तरीके पर एक विस्तृत ट्यूटोरियल समर्पित करता हूं। और मैं हर किसी को चेतावनी देना चाहता हूं, जो अभी तक प्रकट नहीं हुआ है कि यह एक कृतघ्न और अनपेक्षित मामला है, यद्यपि बहुत दिलचस्प है। और युवा, जैसा कि आप जानते हैं, इसकी अपनी चिंताएँ हैं।

चलो चलते हैं!

इस लेख में मेरे होम स्टूडियो में शूट किया गया वीडियो ट्यूटोरियल है । यह सीधे कोड को समर्पित है।

आइए, ढेर प्रबंधक के विकास के साथ शुरुआत करें।

extern void *kmalloc(size_t size); extern void kfree(void *addr);

ढेर आवंटन लिखने के लिए, आपको स्वतंत्र और व्यस्त पते के क्षेत्रों को संग्रहीत करने की आवश्यकता है। यह एक दिशात्मक सूची के रूप में लागू करना सबसे आसान है। एक निर्देशित सूची का कार्यान्वयन स्वयं एक स्थैतिक सरणी के माध्यम से करना होगा।

 struct slist_head_t { struct slist_head_t *prev; struct slist_head_t *next; bool is_valid; void *data; } attribute(packed); struct slist_definition_t { size_t base; u_int slots; size_t slot_size; struct slist_head_t *head; struct slist_head_t *tail; };

ऐसी सीमित सूची के तत्व मेमोरी क्षेत्रों के रिकॉर्ड होंगे। इसके अलावा, आसन्न क्षेत्रों के बीच कोई छेद नहीं हो सकता है। यदि मुफ्त मेमोरी मौजूद है, तो यह एक अलग सूची आइटम द्वारा वर्णित है।

 struct kheap_entry_t { struct slist_head_t list_head; /* static (array placed) list */ size_t addr; /* physical address */ size_t size; /* memory block size */ bool is_buzy; /* whether block used */ } attribute(packed); struct kheap_entry_t kheap_blocks[KHEAP_MAX_ENTRIES]; struct slist_definition_t kheap_list = { .head = null, .tail = null, .slot_size = sizeof(struct kheap_entry_t), .slots = KHEAP_MAX_ENTRIES, .base = (size_t)kheap_blocks };

Kheap_entry_t संरचना की शुरुआत में slist_head_t है, जो आपको दर्द रहित रूप से रिकॉर्ड प्रकार को एक सूची आइटम में डालने की अनुमति देता है।

अब सबसे सरल ढेर आवंटन एल्गोरिथ्म (kmalloc) पर विचार करें:

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

मेमोरी मुक्त एल्गोरिथ्म समान होगा (kfree):

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

अगला लेख ढेर एल्गोरिथ्म के कार्यान्वयन पर ध्यान केंद्रित करेगा।

आइए सरलतम शेड्यूलर लिखें। कार्य इस तरह दिखेगा:

 struct task_t { struct clist_head_t list_head; /* cyclic list */ u_short tid; /* task id */ struct gp_registers_t gp_registers; /* general purpose registers */ struct op_registers_t op_registers; /* other purpose registers */ struct flags_t flags; /* processor flags */ u_int time; /* time of task execution */ bool reschedule; /* whether task need to be rescheduled */ u_short status; /* task status */ int msg_count_in; /* count of incomming messages */ struct message_t msg_buff[TASK_MSG_BUFF_SIZE]; /* task message buffer */ void *kstack; /* kernel stack top */ void *ustack; /* user stack top */ } attribute(packed); struct clist_definition_t task_list = { .head = null, .slot_size = sizeof(struct task_t) };

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

हमने कार्यों की छंटनी की, अब स्वयं योजना। IDT में एक टाइमर हैंडलर जोड़ें और PIC में वांछित IRQ लाइन के व्यवधान को सक्षम करें। टाइमर को बाधित करने से (और कर्नेल इनिशियलाइज़ेशन कोड के अंत में), हम शेड्यूलर को कंट्रोल ट्रांसफर करते हैं, रिटर्न एड्रेस और टाइमर की रुकावट से पहले से बचाए गए रजिस्टरों के पते को पास करते हैं:

 /* * Handle IRQ0 * void asm_ih_timer(unsigned long *addr) */ asm_ih_timer: cli pushal mov %esp,%ebp mov %ebp,%ebx pushl %ebx # &reg add $32,%ebx pushl %ebx # &ret addr call ih_timer mov %ebp,%esp popal sti iretl

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

  /* save task state */ current_task->op_registers.eip = *ret_addr; current_task->op_registers.cs = *(u16 *)((size_t)ret_addr + 4); *(u32 *)(&current_task->flags) = *(u32 *)((size_t)ret_addr + 6) | 0x200; current_task->op_registers.u_esp = (size_t)ret_addr + 12; current_task->gp_registers.esp = current_task->op_registers.u_esp; memcpy(&current_task->gp_registers, (void *)reg_addr, sizeof(struct gp_registers_t));

हम नए कार्य का स्टैक पता लेते हैं और वहां iret कमांड के लिए रिटर्न फ्रेम बनाते हैं। फिर हम असेंबली फ़ंक्शन को संदर्भ स्विच करने के लिए कहते हैं।

  /* prepare context for the next task */ next_task->op_registers.u_esp -= 4; *(u32 *)(next_task->op_registers.u_esp) = (*(u16 *)(&next_task->flags)) | 0x200; next_task->op_registers.u_esp -= 4; *(u32 *)(next_task->op_registers.u_esp) = next_task->op_registers.cs; next_task->op_registers.u_esp -= 4; *(u32 *)(next_task->op_registers.u_esp) = next_task->op_registers.eip; next_task->gp_registers.esp = next_task->op_registers.u_esp; next_task->op_registers.u_esp -= sizeof(struct gp_registers_t); memcpy((void *)next_task->op_registers.u_esp, (void *)&next_task->gp_registers, sizeof(struct gp_registers_t)); /* update current task pointer */ current_task = next_task; /* run next task */ asm_switch_context(next_task->op_registers.u_esp);

संदर्भ स्विच स्वयं इस तरह दिखता है:

 # # Switch context # void asm_switch_context(u32 esp) # asm_switch_context: mov 4(%esp),%ebp # ebp = esp mov %ebp,%esp popal sti iretl

शेड्यूलर तैयार है।

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

मल्टीटास्किंग माइक्रो कर्नेल ओएस डेवलपमेंट - शेड्यूलर

More articles: