यूनिक्स जैसा ओएस डिजाइन - वर्चुअल एड्रेस स्पेस (6)

पिछले लेख में, हमने IA-32 संरक्षित मोड में काम करने की मूल बातों की जांच की। आज यह जानने का समय है कि वर्चुअल एड्रेस स्पेस के साथ कैसे काम किया जाए।

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

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

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

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

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

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

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

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

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

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

आभासी स्मृति

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

हम 4 किलोबाइट पृष्ठों के साथ काम करने पर विचार करेंगे। इस स्थिति में, हम अधिकतम 4 मेगाबाइट रैम को संबोधित कर सकते हैं। हमारे लिए इतना ही काफी है। पता मानचित्र इस तरह दिखेगा:

0-1 एमबी : स्पर्श न करें।
1-2 mb : कोड और कर्नेल डेटा।
2-3 एमबी : गुठली का एक गुच्छा।
3-4 एमबी : एल्फ फ़ाइलों के कस्टम पेज अपलोड किए गए।

पेज पेजिंग सक्षम होने पर रैखिक पता (फ्लैट मॉडल से प्राप्त) भौतिक एक के बराबर नहीं है। इसके बजाय, पता ऑफसेट (कम-ऑर्डर बिट्स), पेज टेबल में प्रविष्टि के सूचकांक और पेज डायरेक्टरी (हाई-ऑर्डर बिट्स) के सूचकांक से विभाजित है। प्रत्येक प्रक्रिया में पृष्ठों की अपनी निर्देशिका होगी और, तदनुसार, टेबल टेबल। यह वह है जो आपको वर्चुअल एड्रेस स्पेस व्यवस्थित करने की अनुमति देता है।

पृष्ठ निर्देशिका प्रविष्टि इस तरह दिखती है:

struct page_directory_entry_t { u8 present : 1; u8 read_write : 1; u8 user_supervisor : 1; u8 write_through : 1; u8 cache_disabled : 1; u8 accessed : 1; u8 zero : 1; u8 page_size : 1; u8 ignored : 1; u8 available : 3; u32 page_table_addr : 20; } attribute(packed); 

पृष्ठ तालिका तत्व इस तरह दिखता है:

 struct page_table_entry_t { u8 present : 1; u8 read_write : 1; u8 user_supervisor : 1; u8 write_through : 1; u8 cache_disabled : 1; u8 accessed : 1; u8 dirty : 1; u8 zero : 1; u8 global : 1; u8 available : 3; u32 page_phys_addr : 20; } attribute(packed); 

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

 static struct page_directory_entry_t kpage_directory attribute(aligned(4096)); static struct page_table_entry_t kpage_table[MMU_PAGE_TABLE_ENTRIES_COUNT] attribute(aligned(4096)); 

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

कर्नेल पृष्ठों की एक निर्देशिका और एक संबंधित पृष्ठ तालिका बनाएं। जब कर्नेल को प्रारंभ किया जाता है, तो यह सक्रिय होगा।

 /* * Api - init kernel page directory * Here assumed each entry addresses 4Kb */ extern void mmu_init() { memset(&kpage_directory, 0, sizeof(struct page_directory_entry_t)); /* set kernel page directory */ kpage_directory.zero = 1; kpage_directory.accessed = 0; kpage_directory.available = 0; kpage_directory.cache_disabled = 0; kpage_directory.ignored = 0; kpage_directory.page_size = 0; /* 4KB */ kpage_directory.present = 1; /* kernel pages always in memory */ kpage_directory.read_write = 1; /* read & write */ kpage_directory.user_supervisor = 1; /* kernel mode pages */ kpage_directory.write_through = 1; kpage_directory.page_table_addr = (size_t)kpage_table >> 12; /* set kernel table */ for (int i = 0; i < MMU_PAGE_TABLE_ENTRIES_COUNT; ++i) { kpage_table[i].zero = 0; kpage_table[i].accessed = 0; kpage_table[i].available = 0; kpage_table[i].cache_disabled = 0; kpage_table[i].dirty = 0; kpage_table[i].global = 1; kpage_table[i].present = 1; /* kernel pages always in memory */ kpage_table[i].read_write = 1; /* read & write */ kpage_table[i].user_supervisor = 1; /* kernel mode pages */ kpage_table[i].write_through = 1; kpage_table[i].page_phys_addr = (i * 4096) >> 12; /* assume 4Kb pages */ } } 

जब हम योगिनी फ़ाइलों को अपलोड करते हैं, तो हमें उपयोगकर्ता प्रक्रिया के लिए एक पृष्ठ निर्देशिका बनाने की आवश्यकता होगी। आप इसे निम्न कार्य के साथ कर सकते हैं:

 /* * Api - Create user page directory */ extern struct page_directory_entry_t* mmu_create_user_page_directory(struct page_table_entry_t* page_table) { struct page_directory_entry_t* upage_dir; upage_dir = malloc_a(sizeof(struct page_directory_entry_t), 4096); upage_dir->zero = 1; upage_dir->accessed = 0; upage_dir->available = 0; upage_dir->cache_disabled = 0; upage_dir->ignored = 0; upage_dir->page_size = 0; /* 4KB */ upage_dir->present = 1; upage_dir->read_write = 1; /* read & write */ upage_dir->user_supervisor = 0; /* user mode pages */ upage_dir->write_through = 1; upage_dir->page_table_addr = (size_t)page_table >> 12; /* assume 4Kb pages */ return upage_dir; } 

डिफ़ॉल्ट रूप से, प्रक्रिया पृष्ठ तालिका में कर्नेल पृष्ठ और भविष्य की प्रक्रिया पृष्ठों के लिए रिक्त प्रविष्टियाँ होंगी, अर्थात्। वर्तमान ध्वज के साथ रिकॉर्ड साफ़ किया गया और 0 पर भौतिक पृष्ठ का पता।

 /* * Api - Create user page table */ extern struct page_table_entry_t* mmu_create_user_page_table() { struct page_table_entry_t* upage_table; upage_table = malloc_a(sizeof(struct page_table_entry_t) * MMU_PAGE_TABLE_ENTRIES_COUNT, 4096); /* share kernel pages */ memcpy(upage_table, kpage_table, sizeof(struct page_table_entry_t) * MMU_KERNEL_PAGES_COUNT); /* fill user pages */ for (int i = MMU_KERNEL_PAGES_COUNT; i < MMU_PAGE_TABLE_ENTRIES_COUNT; ++i) { struct page_table_entry_t* current; current = upage_table + i; current->zero = 0; current->accessed = 0; current->available = 0; current->cache_disabled = 0; current->dirty = 0; current->global = 1; current->present = 0; /* not present as so as there is no user pages yet */ current->read_write = 1; /* read & write */ current->user_supervisor = 0; /* user mode page */ current->write_through = 1; current->page_phys_addr = 0; /* page is not present */ } return upage_table; } 

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

 /* * Api - Occupy user page */ extern bool mmu_occupy_user_page(struct page_table_entry_t* upage_table, void* phys_addr) { for (int i = MMU_KERNEL_PAGES_COUNT; i < MMU_PAGE_TABLE_ENTRIES_COUNT; ++i) { struct page_table_entry_t* current; current = upage_table + i; if (current->present) { /* page is buzy */ continue; } current->zero = 0; current->accessed = 0; current->available = 0; current->cache_disabled = 0; current->dirty = 0; current->global = 1; current->present = 1; current->read_write = 1; /* read & write */ current->user_supervisor = 0; /* user mode page */ current->write_through = 1; current->page_phys_addr = (size_t)phys_addr >> 12; /* assume 4Kb pages */ return true; } return false; } 

पेजिंग मोड को प्रोसेसर फ्लैग रजिस्टर में थोड़ा सा ऑन और ऑफ किया जाता है।

 /* * Enable paging * void asm_enable_paging(void *page_directory) */ asm_enable_paging: mov 4(%esp),%eax # page_directory mov %eax,%cr3 mov %cr0,%eax or $0x80000001,%eax # set PE & PG bits mov %eax,%cr0 ret /* * Disable paging * void asm_disable_paging() */ asm_disable_paging: mov %eax,%cr3 mov %cr0,%eax xor $0x80000000,%eax # unset PG bit mov %eax,%cr0 ret 

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

 static u32 bitmap[MM_BITMAP_SIZE]; 

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

 /* * Api - allocate pages */ extern void* mm_phys_alloc_pages(u_int count) { /* find free pages */ for (int i = 0; i < MM_DYNAMIC_PAGES_COUNT; ++i) { bool is_found = true; for (int j = 0; j < count; ++j) { is_found = is_found && !mm_get_bit(i + j); } if (is_found) { /* occupy */ for (int j = 0; j < count; ++j) { assert(!mm_get_bit(i + j)); mm_set_bit(i + j); } return (void *)mm_get_addr(i); } } return null; } /* * Api - free page */ extern bool mm_phys_free_pages(void* ptr, u_int count) { size_t address = (size_t)ptr; assert(address >= MM_AREA_START); assert(address % MM_PAGE_SIZE == 0); /* find page */ for (int i = 0; i < MM_DYNAMIC_PAGES_COUNT; ++i) { size_t addr = mm_get_addr(i); if (addr == address) { /* free pages */ for (int j = 0; j < count; ++j) { assert(mm_get_bit(i + j)); mm_clear_bit(i + j); } return true; } } return false; } 

यह आपके कर्नेल में वर्चुअल मेमोरी के लिए पूर्ण समर्थन को पेश करने के लिए पर्याप्त है।

संदर्भ

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

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

संदर्भ

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