यूनिक्स जैसा ओएस विकास - मल्टीटास्किंग और सिस्टम कॉल (7)

पिछले लेख में, हमने सीखा कि वर्चुअल एड्रेस स्पेस के साथ कैसे काम किया जाए। आज हम मल्टीटास्किंग समर्थन जोड़ेंगे।

सामग्री की तालिका

बिल्ड सिस्टम (मेक, जीसीसी, गैस)। प्रारंभिक बूट (मल्टीबूट)। लॉन्च (qemu)। सी लाइब्रेरी (strcpy, memcpy, strext)।

सी लाइब्रेरी (स्प्रिंटफ, स्ट्रैची, स्ट्रैम्प, स्ट्रेटोक, वा_लिस्ट ...)। लाइब्रेरी को कर्नेल मोड और उपयोगकर्ता एप्लिकेशन मोड में बनाना।

कर्नेल सिस्टम लॉग। वीडियो मेमोरी टर्मिनल का आउटपुट (kprintf, kpanic, kassert)।
डायनेमिक मेमोरी, हीप (kmalloc, kfree)।

मेमोरी और इंटरप्ट हैंडलिंग (GDT, IDT, PIC, syscall) का संगठन। अपवाद।
वर्चुअल मेमोरी (पेज डायरेक्टरी और पेज टेबल)।

प्रक्रिया। समयबद्धक। मल्टीटास्किंग। सिस्टम कॉल (मार, निकास, पीएस)।
कर्नेल की फ़ाइल प्रणाली (initrd), योगिनी, और इसके आंतरिक। सिस्टम कॉल (निष्पादन)।

चरित्र डिवाइस ड्राइवर। सिस्टम कॉल (ioctl, fopen, fread, fwrite)। सी लाइब्रेरी (fopen, fclose, fprintf, fscanf)।

कर्नेल के लिए एक पूर्ण कार्यक्रम के रूप में शेल।

उपयोगकर्ता सुरक्षा मोड (रिंग 3)। टास्क स्टेटस सेगमेंट (tss)।

मल्टीटास्किंग

जैसा कि आपको याद है, प्रत्येक प्रक्रिया का अपना पता स्थान होना चाहिए।

ऐसा करने के लिए, आपको प्रक्रिया द्वारा उपयोग किए जाने वाले पृष्ठों की गणना करने की आवश्यकता है।

इसलिए, हमें प्रक्रिया की स्मृति का वर्णन करना चाहिए:

/* * Process memory description */ struct task_mem_t { void* pages; /* task physical pages */ u_int pages_count; /* task physical pages count */ void* page_dir; /* page directory */ void* page_table; /* page table */ }; 

प्रक्रियाओं को किसी तरह एक दूसरे के साथ सूचना का आदान-प्रदान करना पड़ता है। ऐसा करने के लिए, हम एक संदेश की अवधारणा प्रस्तुत करते हैं:

 struct message_t { u_short type; /* message type */ u_int len; /* data length */ u8 data[IPC_MSG_DATA_BUFF_SIZE]; /* message data */ }; 

उसके बाद, आपको प्रक्रिया को एक परिपत्र सूची के एक तत्व के रूप में वर्णित करना होगा।

यहाँ चक्रीय सूची सुविधाजनक है क्योंकि अनुसूचक में आपको प्रत्येक कार्य से अगले का चयन करना होगा जब तक कि सूची खाली न हो।

इसके द्वारा हम पतित मामले को हटाते हैं, जिसका अर्थ है कि हम तर्क को सरल बनाते हैं।

 /* * Process descriptor */ struct task_t { struct clist_head_t list_head; /* should be at first */ u_short tid; /* task id */ char name[8]; /* task name */ 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 */ struct task_mem_t task_mem; /* task memory */ } attribute(packed); 

हम प्रत्येक प्रक्रिया के लिए एक कोटा आवंटित करेंगे, टाइमर की संख्या में व्यवधान जिसके बाद प्रक्रिया को फिर से शेड्यूल किया जाएगा।

 #define TASK_QUOTA 3 

इसके बाद, आपको एक नई प्रक्रिया बनाने के लिए एक फ़ंक्शन लिखना होगा।

जबकि हमारे पास विशेषाधिकार स्तर नहीं हैं, हम कर्नेल चयनकर्ताओं का उपयोग करेंगे।

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

हम प्रारंभिक स्थिति को TASK_UNINTERRUPTABLE के रूप में सेट करेंगे ताकि कार्य को पूर्ण आरंभ से पहले पूरा करने का समय न हो।

 /* * Api - Create new task */ extern bool task_create(u_short tid, void* address, struct task_mem_t *task_mem) { struct task_t* task; struct clist_head_t* entry; /* allocate memory */ entry = clist_insert_entry_after(&task_list, task_list.head); task = (struct task_t*)entry->data; task->kstack = malloc(TASK_KSTACK_SIZE); task->ustack = malloc(TASK_USTACK_SIZE); /* fill data */ task->tid = tid; task->name[0] = '\0'; task->status = TASK_UNINTERRUPTABLE; task->msg_count_in = 0; task->time = 0; memcpy(&task->task_mem, task_mem, sizeof(struct task_mem_t)); /* set flags */ *(u32*)(&task->flags) = asm_get_eflags() | 0x200; /* set general purpose registers */ memset(&task->gp_registers, 0, sizeof(struct gp_registers_t)); /* set other purpose registers */ task->op_registers.cs = GDT_KCODE_SELECTOR; task->op_registers.ds = GDT_KDATA_SELECTOR; task->op_registers.ss = GDT_KSTACK_SELECTOR; task->op_registers.eip = (size_t)address; task->op_registers.cr3 = (size_t)task_mem->page_dir; task->op_registers.k_esp = (u32)task->kstack + TASK_KSTACK_SIZE; task->op_registers.u_esp = (u32)task->ustack + TASK_USTACK_SIZE; printf(MSG_SCHED_TID_CREATE, tid, (u_int)address, task->kstack, task->ustack); return true; } 

प्रक्रिया की स्थिति TASK_KILLING होने पर शेड्यूलर द्वारा प्रक्रिया को हटा दिया जाएगा।
हटाते समय, हमें केवल स्टैक्स, डेटा और कोड अनुभागों के लिए आवंटित पृष्ठों को मुक्त करना होगा और प्रक्रिया पृष्ठों की निर्देशिका को भी नष्ट करना होगा।

सामान्य तौर पर, एक अच्छे उपयोगकर्ता स्टैक के लिए, आप मेमोरी मैनेजर के माध्यम से आवंटित कर सकते हैं, लेकिन सुविधा के लिए, डिबगिंग करते समय हम इसे कर्नेल के ढेर में लागू करते हैं, जो हमेशा पृष्ठ निर्देशिकाओं में होता है।

 /* * Api - Delete task by id */ extern void task_delete(struct task_t* task) { printf(MSG_SCHED_TID_DELETE, (u_int)task->tid); assert(task != null); /* free stack memory */ free(task->kstack); free(task->ustack); task->kstack = null; task->ustack = null; /* free user pages memory */ if (task->task_mem.pages_count > 0) { mm_phys_free_pages(task->task_mem.pages, task->task_mem.pages_count); task->task_mem.pages = null; task->task_mem.pages_count = 0; } /* clear resources */ if (task->task_mem.page_dir != null) { mmu_destroy_user_page_directory(task->task_mem.page_dir, task->task_mem.page_table); } clist_delete_entry(&task_list, (struct clist_head_t*)task); } 

अब आपको खुद शेड्यूलर लिखने की जरूरत है।

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

 /* * Api - Schedule task to run */ extern void sched_schedule(size_t* ret_addr, size_t* reg_addr) { struct task_t* next_task = null; /* finish current task */ if (current_task != null) { /* update running time */ current_task->time += 1; /* check quota exceed */ if (current_task->time < TASK_QUOTA && !current_task->reschedule) { return; /* continue task execution */ } /* reset quota */ current_task->time = 0; current_task->reschedule = false; /* 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)); } /* pick next task */ if (current_task) { next_task = task_get_next_by_status(TASK_RUNNING, current_task); } else { next_task = task_get_by_status(TASK_RUNNING); tss_set_kernel_stack(next_task->kstack); } assert(next_task != null); /* whether should kill current task */ if (current_task && current_task->status == TASK_KILLING) { /* kill current task */ task_delete(current_task); } else { /* try to kill killing tasks */ struct task_t* task; task = task_find_by_status(TASK_KILLING); if (task) { task_delete(task); } } /* 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 */ printf(MSG_SCHED_NEXT, next_task->tid, next_task->op_registers.u_esp, *ret_addr, next_task->op_registers.eip); asm_switch_ucontext(next_task->op_registers.u_esp, next_task->op_registers.cr3); } 

यह एक कार्य संदर्भ स्विचिंग फ़ंक्शन लिखने के लिए रहता है।

ऐसा करने के लिए, आपको एक नई पृष्ठ निर्देशिका डाउनलोड करने और सभी सामान्य रजिस्टरों को पुनर्स्थापित करने की आवश्यकता है, जिसमें झंडे भी शामिल हैं।

आपको अगले कार्य के ढेर पर स्विच करने की भी आवश्यकता है।

इसके बाद, आपको बाधा से वापसी करने की आवश्यकता है, क्योंकि हमने इसके लिए एक विशेष स्टैक फ्रेम का गठन किया है।

इस तथ्य के लिए कि बाद में हमें विशेषाधिकार स्तरों को बदलने के लिए इसकी आवश्यकता होगी।

 /* * Switch context (to kernel ring) * void asm_switch_kcontext(u32 esp, u32 cr3) */ asm_switch_kcontext: mov 4(%esp),%ebp # ebp = esp mov 8(%esp),%eax # eax = cr3 mov %cr0,%ebx # ebx = cr0 and $0x7FFFFFFF,%ebx # unset PG bit mov %ebx,%cr0 mov %eax,%cr3 or $0x80000001,%ebx # set PE & PG bits mov %ebx,%cr0 mov %ebp,%esp popal sti iretl 

हम प्रक्रियाओं के बीच सबसे सरल संदेश तंत्र को लागू करते हैं।

जब हम किसी प्रक्रिया को संदेश भेजते हैं, तो उसे जमे हुए होने पर उसे पिघलाने की आवश्यकता होती है क्योंकि यह संदेशों के लिए प्रतीक्षा कर रहा है।

लेकिन जब हमें कोई संदेश प्राप्त होता है, तो हमें प्रक्रिया को खाली करना होगा यदि संदेश कतार खाली है।

उसके बाद, आपको शेड्यूलर पर नियंत्रण स्थानांतरित करने की आवश्यकता है।

 /* * Api - Send message to task */ extern void ksend(u_short tid, struct message_t* msg) { struct task_t* task; /* get target task */ task = task_get_by_id(tid); /* put message to task buffer */ task_pack_message(task, msg); /* whether task has frozen */ if (task->status == TASK_INTERRUPTABLE) { /* defrost task */ task->status = TASK_RUNNING; } } /* * Api - Receive message to task * This function has blocking behaviour */ extern void kreceive(u_short tid, struct message_t* msg) { struct task_t* task_before; /* before yield */ struct task_t* task_after; /* after yield */ /* get current task */ task_before = sched_get_current_task(); assert(tid == task_before->tid); assert(task_before->status == TASK_RUNNING); /* whether task has not incomming messages */ if (task_before->msg_count_in == 0) { /* freeze task */ task_before->status = TASK_INTERRUPTABLE; } /* wait fot message */ sched_yield(); /* get current task */ task_after = sched_get_current_task(); assert(task_after == task_before); assert(tid == task_after->tid); assert(task_after->status == TASK_RUNNING); /* fetch message from buffer */ task_extract_message(task_after, msg); assert(msg != null); } 

अब आपको उपयोगकर्ता एप्लिकेशन से प्रक्रियाओं के साथ काम करने के लिए सिस्टम कॉल लिखने की आवश्यकता है।

वहां हम संदेश भेजने और प्राप्त करने के लिए सिस्टम कॉल फेंकेंगे।

 /* * Api - Syscall handler */ extern size_t ih_syscall(u_int* function) { size_t params_addr = ((size_t)function + sizeof(u_int)); size_t result = 0; struct task_t *current = sched_get_current_task(); printf(MSG_SYSCALL, *function, current->tid); asm_lock(); /* handle syscall */ switch (*function) { case SYSCALL_KSEND: { /* send message */ u_short tid = *(u_int*)params_addr; ksend(tid, *(struct message_t**)(params_addr + 4)); break; } case SYSCALL_KRECEIVE: { /* receive message */ u_short tid = *(u_int*)params_addr; kreceive(tid, *(struct message_t**)(params_addr + 4)); break; } case SYSCALL_KILL: { /* kill task */ u_short tid = *(u_int*)params_addr; struct task_t* task = task_find_by_id(tid); if (task != null) { assert(task->tid == tid); task->status = TASK_KILLING; task->reschedule = true; result = true; } else { result = false; } break; } case SYSCALL_EXIT: { /* exit task */ int errno = *(int*)params_addr; u_int tid = current->tid; printf(MSG_TASK_FINISHED, tid, errno); current->status = TASK_KILLING; sched_yield(); break; } case SYSCALL_TASK_LIST: { /* get tasks list */ result = (size_t)task_get_task_list(); break; } default: unreachable(); } printf(MSG_SYSCALL_RET, *function); asm_unlock(); return result; } 

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

 /* * Call kernel * void asm_syscall(unsigned int function, ...) */ asm_syscall: push %ebx push %ebp mov %esp,%ebp mov %ebp,%ebx add $8,%ebx # skip registers add $4,%ebx # skip return address push %ebx # &function int $0x80 mov %ebp,%esp pop %ebp pop %ebx ret 

यह सुरक्षा के छल्ले के समर्थन के बिना सबसे सरल मल्टीटास्किंग को लागू करने के लिए पर्याप्त है। अब वीडियो ट्यूटोरियल खोलें और क्रम में सब कुछ देखें!

संदर्भ

वीडियो ट्यूटोरियल में विवरण और स्पष्टीकरण।

गिट रिपॉजिटरी में स्रोत कोड (आपको सबक 7 शाखा की आवश्यकता है)।

संदर्भ

1. जेम्स मोलॉय। अपना खुद का खिलौना यूनिक्स-क्लोन ओएस रोल करें।
2. दाँत। डॉस, विंडोज, यूनिक्स के लिए असेंबलर
3. कलाश्निकोव। असेंबलर आसान है!
4. ताननबाम। ऑपरेटिंग सिस्टम। कार्यान्वयन और विकास।
5. रॉबर्ट लव। लिनक्स कर्नेल विकास प्रक्रिया का विवरण।