ओएस लेखन: मल्टीटास्किंग

अच्छा दिन, प्रिय पाठक, सबसे अधिक संभावना है, आपने मेरा पिछला लेख देखा था कि आप स्वयं काफी समय में एक व्यावहारिक OS लिख सकते हैं। खैर, आज हम अपने ओएस में मल्टीटास्किंग के कार्यान्वयन के बारे में बात करेंगे।

ठीक है, आप शायद 2018 में सिंगल-टास्किंग ओएस की कल्पना नहीं कर सकते हैं, इसलिए मैंने अपने ओएस में मल्टीटास्किंग के कार्यान्वयन के बारे में बात करने का फैसला किया। और इसलिए, पहली बात - आपको मल्टीटास्किंग के प्रकार पर निर्णय लेने की आवश्यकता है, मैंने प्रीमेप्टिव चुना।
वह क्या है? प्रीमेप्टिव मल्टीटास्किंग प्रोसेसर कंप्यूटिंग पावर को प्रक्रियाओं के बीच वितरित करने के लिए एक प्रणाली है: प्रत्येक की अपनी मात्रा निर्धारित होती है, प्रत्येक की अपनी प्राथमिकता होती है। और पहली समस्या यह है कि किस क्वांटम को लंबाई में चुनना है, क्वांटम की समाप्ति के बाद प्रक्रिया को चलने से कैसे रोकें? वास्तव में, सब कुछ पहले से कहीं ज्यादा आसान है! हम शुरू में प्रति सेकंड रुकावट के साथ 10026 की आवृत्ति सेट के साथ पीआईटी का उपयोग करेंगे, वहीं हम एक और समस्या का समाधान करते हैं: हम पहले से ही पिछली प्रक्रिया को रोक रहे हैं। और इसलिए, चलो पीआईटी के साथ शुरू करते हैं।

गड्ढे

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

unsigned short hz = 119; outportb(0x43, 0x34); outportb(0x40, (unsigned char)hz & 0xFF); //Low outportb(0x40, (unsigned char)(hz >> 8) & 0xFF); //Hight, about 10026 times per second 

अब यह PIT से व्यवधान की प्रोग्रामिंग शुरू करने के लायक है, इसमें 0 का IRQ है, और PIC के रीमैप के बाद यह 0x20m होगा। पहले PIC के IRQ के लिए, मैंने यह मैक्रो लिखा है:

 //PIC#0; port 0x20 #define IRQ_HANDLER(func) char func = 0x90;\ __asm__(#func ": \npusha \n call __"#func " \n movb $0x20,\ %al \n outb %al, $0x20 \n popa \n iret \n");\ void _## func() 

संरचना और प्रक्रियाएं

और इसलिए, जैसा कि आप समझते हैं, हमें प्रत्येक प्रक्रिया के लिए एक संरचना विकसित करने की आवश्यकता है, साथ ही एक ऐसी संरचना जो मुझे अपने सभी स्मृति आवंटन को याद रखने की अनुमति देती है।
यहाँ मेरे पास है:

 typedef struct _pralloc { void * addr; struct _pralloc * next; } processAlloc; typedef struct { void * entry; processAlloc *allocs; } ELF_Process; typedef struct __attribute__((packed)) _E { unsigned int eax;//4 unsigned int ebx;//8 unsigned int ecx;//12 unsigned int edx;//16 unsigned int ebp;//20 unsigned int esp;//24 unsigned int esi;//28 unsigned int edi;//32 unsigned int eflags;//36 unsigned int state;//40 void * startAddr;//44 void * currentAddr;//48 void * stack;//52 unsigned int sse[4 * 8];// unsigned int mmx[2 * 8];//244 unsigned int priority;//248 unsigned int priorityL;//252 void * elf_process;//256 char ** argv;//260 unsigned int argc;//264 unsigned int runnedFrom;//268 char * workingDir;//272 unsigned int cs;//276 - pop is 4 byte in IRET unsigned int ds;//280 } Process; 

शुरू करने के लिए, हमें निम्नलिखित को समझने की आवश्यकता है: हम वैश्विक पते पर कहीं जा सकते हैं, उदाहरण के लिए, 0xDEAD में वर्तमान में चल रही प्रक्रिया की संख्या डालते हैं, फिर किसी भी कोड को निष्पादित करते समय, हम यह सुनिश्चित कर सकते हैं: हमारे पास वर्तमान में चल रही प्रक्रिया की संख्या है, इसका मतलब है कि मॉलॉक तक पहुँचने के दौरान, हम जानते हैं कि हम किसको मेमोरी आवंटित कर रहे हैं, और हम आवंटित मेमोरी के पते को तुरंत ऑलोक की सूची में जोड़ सकते हैं।

 void addProcessAlloc(ELF_Process * p, void * addr) { void * z = p->allocs; p->allocs = malloc_wo_adding_to_process(sizeof(processAlloc)); p->allocs->addr = addr; p->allocs->next = z; } 

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

अब यह हमारे लिए प्रक्रिया के मूल्यों को रजिस्टर में रखने के लिए बना हुआ है जिसमें हमने IRET को स्विच किया और निष्पादित किया। लाभ!

प्रक्रिया शुरू

प्रक्रिया शुरू करते समय, हमारे लिए यह प्रक्रिया के लिए स्टैक आवंटित करने के लिए पर्याप्त है, और फिर इसमें argc और argv डाल दिया जाता है, फ़ंक्शन का पता जिसे प्रक्रिया पूरी होने के बाद नियंत्रण दिया जाएगा। आपको प्रोसेसर के झंडे को आपके द्वारा आवश्यक मूल्य पर सेट करने की आवश्यकता है, उदाहरण के लिए, मेरे ओएस के लिए यह 0x216 है, आप विकिपीडिया पर ध्वज रजिस्टर के बारे में पढ़ सकते हैं।

अंत में मैं आपको सफलता की कामना करना चाहता हूं, जल्द ही मैं स्मृति और रुचि के अन्य लेखों के साथ काम करने के बारे में लिखूंगा।
गुड लक, और एथिकल हैकिंग!