यूनिक्स जैसा ओएस विकास - शेल। निष्कर्ष (9)

यह हमारे कर्नेल के लिए पहला अलग प्रोग्राम लिखने का समय है - शेल। यह एक अलग .elf फ़ाइल में संग्रहीत किया जाएगा और कर्नेल प्रारंभ होने पर init प्रक्रिया द्वारा लॉन्च किया जाएगा।

यह हमारे ऑपरेटिंग सिस्टम के विकास चक्र का अंतिम लेख है।

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

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

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

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

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

प्रक्रिया। समयबद्धक। मल्टीटास्किंग। सिस्टम कॉल (मार, निकास, पीएस)।

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

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

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

पूर्ण कर्नेल प्रोग्राम के रूप में शेल

पिछले लेख में, हमने चरित्र डिवाइस ड्राइवरों को देखा और टर्मिनल ड्राइवर लिखा।

अब हमारे पास पहला कंसोल एप्लिकेशन बनाने के लिए आवश्यक सब कुछ है।

हम कंसोल एप्लिकेशन को स्वयं लिखेंगे, जिसे हम एक अलग योगिनी में संकलित करेंगे।

/* * Elf entry point */ void start() { u_int errno; stdio_init(); errno = main(); stdio_deinit(); exit(errno); } 

हमें मानक पुस्तकालय को आरंभ करने और परिचित मुख्य समारोह में नियंत्रण स्थानांतरित करने की आवश्यकता होगी।

 int main() { char cmd[255]; while (1) { printf(prompt); flush(); scanf(cmd); if (!execute_command(cmd)) { break; } } return 0; } 

लूप में आगे, हम बस लाइन पढ़ते हैं और कमांड निष्पादित करते हैं।

यदि तर्क हैं तो पारसीम strtok_r के माध्यम से आदेश देता है।

 static bool execute_command(char* cmd) { if (!strcmp(cmd, cmd_ps)) { /* show tasks list */ struct clist_definition_t *task_list; task_list = ps(); printf(" -- process list\n"); clist_for_each(task_list, print_task_info); } else if (!strcmp(cmd, cmd_clear)) { /* clear screen */ clear(); flush(); } else if (!strncmp(cmd, cmd_kill, strlen(cmd_kill))) { /* kill task */ char* save_ptr = null; strtok_r(cmd, " ", &save_ptr); char* str_tid = strtok_r(null, " ", &save_ptr); u_short tid = atou(str_tid); if (!kill(tid)) { printf(" There is no process with pid %u\n", tid); }; } else if (!strncmp(cmd, cmd_exit, strlen(cmd_exit))) { /* exit */ clear(); printf(prompt); flush(); return false; } else if (!strncmp(cmd, cmd_exec, strlen(cmd_exec))) { /* exec file on intrd */ char* save_ptr = null; strtok_r(cmd, " ", &save_ptr); char* str_file = strtok_r(null, " ", &save_ptr); exec(str_file); } else if (!strncmp(cmd, cmd_dev, strlen(cmd_dev))) { /* show device list */ struct clist_definition_t *dev_list; dev_list = devs(); printf(" -- device list\n"); clist_for_each(dev_list, print_dev_info); } else { printf(" There is no such command.\n Available command list:\n"); printf(" %s %s %s <pid> %s <file.elf> %s %s\n", cmd_ps, cmd_exit, cmd_kill, cmd_exec, cmd_clear, cmd_dev); } return true; } 

वास्तव में, हम सिर्फ सिस्टम कॉल खींच रहे हैं।
मुझे आपको मानक पुस्तकालय के आरंभ के बारे में याद दिलाना चाहिए।

पिछले पाठ में, हमने लाइब्रेरी में निम्नलिखित फंक्शन लिखे:

 extern void stdio_init() { stdin = fopen(tty_dev_name, MOD_R); stdout = fopen(tty_dev_name, MOD_W); asm_syscall(SYSCALL_IOCTL, stdout, IOCTL_INIT); asm_syscall(SYSCALL_IOCTL, stdin, IOCTL_READ_MODE_LINE); asm_syscall(SYSCALL_IOCTL, stdin, IOCTL_READ_MODE_ECHO); } 

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

हम अपने योगिनी को एक शेल के साथ इकट्ठा करने के बाद, इसे मूल कर्नेल फ़ाइल सिस्टम (initrd) पर रखा जाना चाहिए।

आरंभिक रैम डिस्क कर्नेल लोडर द्वारा एक मल्टीबूट मॉड्यूल के रूप में लोड किया जाता है, इसलिए हम अपनी initrd की स्मृति में पता जानते हैं।

यह initrd के लिए फ़ाइल सिस्टम को व्यवस्थित करने के लिए बना हुआ है, जो कि जेम्स मोलॉय के एक लेख के अनुसार करना आसान है।

इसलिए, प्रारूप इस प्रकार होगा:

 extern struct initrd_node_t { unsigned char magic; /* magic number */ char name[8]; /* file name */ unsigned int offset; /* file base */ unsigned int length; /* file length */ }; extern struct initrd_fs_t { int count; /* files count */ struct initrd_node_t node[INITRD_MAX_FILES]; /* files headers */ }; 

अगला, 32 बिट योगिनी का प्रारूप याद रखें।

 struct elf_header_t { struct elf_header_ident_t e_ident; u16 e_type; u16 e_machine; u32 e_version; u32 e_entry; /* virtual address of entry point */ u32 e_phoff; /* program headers table offset */ u32 e_shoff; /* program headers sections table offset */ u32 e_flags; u16 e_ehsize; /* file header size */ u16 e_phentsize; /* single header size */ u16 e_phnum; /* headers count */ u16 e_shentsize; /* section header size */ u16 e_shnum; /* sections headers count */ u16 e_shstrndx; }; 

यहां हम प्रवेश बिंदु और कार्यक्रम हेडर की तालिका के पते में रुचि रखते हैं।

कोड और डेटा सेक्शन पहले हेडिंग होगा, और स्टैक सेक्शन दूसरा होगा (ओब्जेक्ट के माध्यम से योगिनी के अध्ययन के परिणामों के अनुसार)।

 struct elf_program_header_t { u32 p_type; /* segment type */ u32 p_offset; /* segment offset from file begin */ u32 p_vaddr; /* target virtual address */ u32 p_paddr; /* target physical address */ u32 p_filesz; /* segment size in file */ u32 p_memsz; /* segment size in memory */ u32 p_flags; /* permissions and etc */ u32 p_align; /* alignment */ } attribute(packed); 

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

 /* * Api - execute elf as a task */ extern void elf_exec(struct elf_header_t* header) { assert(header->e_ident.ei_magic == EI_MAGIC); printf(MSG_KERNEL_ELF_LOADING, header->e_phnum); // elf_dump(header); size_t elf_base = (size_t)header; size_t entry_point = header->e_entry; struct task_mem_t task_mem; memset(&task_mem, 0, sizeof(struct task_mem_t)); // load sections in memory for (int i = 0; i < header->e_phnum; ++i) { struct elf_program_header_t* p_header = (void*)(header->e_phoff + elf_base + i * header->e_phentsize); task_mem.pages_count = (p_header->p_memsz / MM_PAGE_SIZE) + 1; if (p_header->p_memsz == 0) { continue; } // allocate pages assert(task_mem.pages_count > 0); assert(task_mem.pages == null); task_mem.pages = mm_phys_alloc_pages(task_mem.pages_count); void* section = (void*)(elf_base + p_header->p_offset); memcpy(task_mem.pages, section, p_header->p_memsz); // setup virtual memory task_mem.page_table = mmu_create_user_page_table(); task_mem.page_dir = mmu_create_user_page_directory(task_mem.page_table); for (int i = 0; i < task_mem.pages_count; ++i) { mmu_occupy_user_page(task_mem.page_table, (void*)((size_t)task_mem.pages + i * MM_PAGE_SIZE)); } } // create task u_short tid = next_tid++; assert(task_create(tid, (void*)entry_point, &task_mem)); // run task struct task_t* task; task = task_get_by_id(tid); task->status = TASK_RUNNING; strncpy(task->name, "elf", sizeof(task->name)); printf(MSG_KERNEL_ELF_LOADED); } 

यहां सबसे दिलचस्प बात एक पेज डायरेक्टरी और पेज टेबल का निर्माण है।
ध्यान दें, पहले हम भौतिक पृष्ठों (mm_phys_alloc_pages) का चयन करते हैं, और फिर उन्हें तार्किक पृष्ठों (mmu_occupy_user_page) पर मैप करते हैं।
यहाँ यह माना जाता है कि भौतिक स्मृति में पृष्ठों को लगातार आवंटित किया जाता है।
वह सब है। अब आप अपने कर्नेल के लिए अपने स्वयं के शेल को लागू कर सकते हैं! वीडियो ट्यूटोरियल देखें और विवरण में तल्लीन करें।

निष्कर्ष

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

इसलिए, बेल्ट को कस लें, और लड़ाई में! अपना खुद का ऑपरेटिंग सिस्टम लिख कर!
मुझे एक महीने के बारे में लगा (अगर हम दिन में 6-8 घंटे के लिए पूरा समय मानते हैं) तो वह सब कुछ लागू करने के लिए जो आपने और मैंने खरोंच से सीखा था।

इसलिए, 2-3 महीनों में आप एक वास्तविक फ़ाइल सिस्टम के साथ एक पूर्ण ओएस लिख पाएंगे, जिसे आपने और मैंने कार्यान्वित करने का प्रबंधन नहीं किया था।

बस यह जान लें कि qemu को पता नहीं है कि मनमाने प्रारूप के initrd के साथ कैसे काम करना है, और इसे 4kb में काट दिया जाए, इसलिए आपको या तो इसे लिनक्स की तरह बनाने की आवश्यकता होगी, या qemu के बजाय borsch का उपयोग करना होगा।
यदि आप जानते हैं कि इस समस्या को कैसे हल किया जाए, तो एक व्यक्तिगत पत्र में लिखें, मैं आपका बहुत आभारी रहूंगा।

वह सब है! जब तक नया नहीं मिलता है!

संदर्भ

अधिक जानकारी के लिए वीडियो ट्यूटोरियल देखें।

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

संदर्भ

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