पहला भाग
दूसरा भाग

आज की बातचीत का विषय स्मृति के साथ काम करना है। मैं पेज डायरेक्टरी को इनिशियलाइज़ करने, फिजिकल मेमोरी मैप करने, वर्चुअल मैनेज करने और एलोकेटर के लिए अपने ऑर्गनाइजेशन हीप के बारे में बात करूंगा।

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

पिछली बार जब मैं वास्तुकला पर निर्भर setup_pd विधि पर बस गया था और इसके साथ जारी रखना चाहता था, हालांकि, एक और विवरण था जिसे मैंने पिछले लेख में कवर नहीं किया था - वीजीए आउटपुट का उपयोग जंग और मानक प्रिंटल मैक्रो। चूंकि इसका कार्यान्वयन तुच्छ है, इसलिए मैं इसे बिगाड़ने के तहत हटा दूंगा। कोड डीबग पैकेज में है।

#[macro_export] macro_rules! print { ($($arg:tt)*) => ($crate::debug::_print(format_args!($($arg)*))); } #[macro_export] macro_rules! println { () => ($crate::print!("\n")); ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*))); } #[cfg(target_arch = "x86")] pub fn _print(args: core::fmt::Arguments) { use core::fmt::Write; use super::arch::vga; vga::VGA_WRITER.lock().write_fmt(args).unwrap(); } #[cfg(target_arch = "x86_64")] pub fn _print(args: core::fmt::Arguments) { use core::fmt::Write; use super::arch::vga; // vga::VGA_WRITER.lock().write_fmt(args).unwrap(); } 

अब, एक स्पष्ट विवेक के साथ, मैं स्मृति में लौटता हूं।

पेज डायरेक्टरी इनिशियलाइज़ेशन

हमारी kmain पद्धति ने इनपुट के रूप में तीन तर्क दिए, जिनमें से एक पृष्ठ तालिका का आभासी पता है। आवंटन और मेमोरी प्रबंधन के लिए बाद में इसका उपयोग करने के लिए, आपको रिकॉर्ड और निर्देशिकाओं की संरचना को निर्दिष्ट करने की आवश्यकता है। X86 के लिए, पेज डायरेक्टरी और पेज टेबल काफी अच्छी तरह से वर्णित हैं, इसलिए मैं खुद को एक छोटे से परिचय तक सीमित करूंगा। पृष्ठ निर्देशिका प्रविष्टि एक सूचक आकार संरचना है, हमारे लिए यह 4 बाइट्स है। मान में पृष्ठ का 4KB भौतिक पता होता है। रिकॉर्ड का सबसे महत्वपूर्ण बाइट झंडे के लिए आरक्षित है। एक आभासी पते को भौतिक में बदलने का तंत्र इस तरह दिखता है (मेरी 4 एमबी ग्रैन्युलैरिटी के मामले में, शिफ्ट 22 बिट्स से होती है। अन्य ग्रैन्युलैरिटी के लिए, शिफ्ट अलग होगी और पदानुक्रमित तालिकाओं का उपयोग किया जाएगा!)।

आभासी पता 0xC010A110 -> 22 बिट पते को दाईं ओर ले जाकर निर्देशिका में सूचकांक प्राप्त करें -> सूचकांक 0x300 -> सूचकांक 0x300 द्वारा पृष्ठ का भौतिक पता प्राप्त करें, झंडे और स्थिति की जांच करें -> 0x1000000 -> नीचे दिए गए 22 22 बिट्स वर्चुअल पते को ऑफसेट के रूप में जोड़ें, जोड़ें पृष्ठ का भौतिक पता -> 0x1000000 + 0x10A110 = स्मृति में भौतिक पता 0x110A110

एक्सेस को तेज करने के लिए, प्रोसेसर TLB - ट्रांसलेशन लुकसाइड बफर का उपयोग करता है, जो पेज एड्रेस को कैश करता है।

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

 #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct PDirectoryEntry(u32); impl PDirectoryEntry { pub fn by_phys_address(address: usize, flags: PDEntryFlags) -> Self { PDirectoryEntry((address as u32) & ADDRESS_MASK | flags.bits()) } pub fn flags(&self) -> PDEntryFlags { PDEntryFlags::from_bits_truncate(self.0) } pub fn phys_address(&self) -> u32 { self.0 & ADDRESS_MASK } pub fn dbg(&self) -> u32 { self.0 } } pub struct PDirectory { entries: [PDirectoryEntry; 1024] } impl PDirectory { pub fn at(&self, idx: usize) -> PDirectoryEntry { self.entries[idx] } pub fn set_by_addr(&mut self, logical_addr: usize, entry: PDirectoryEntry) { self.set(PDirectory::to_idx(logical_addr), entry); } pub fn set(&mut self, idx: usize, entry: PDirectoryEntry) { self.entries[idx] = entry; unsafe { invalidate_page(idx); } } pub fn to_logical_addr(idx: usize) -> usize { (idx << 22) } pub fn to_idx(logical_addr: usize) -> usize { (logical_addr >> 22) } } use lazy_static::lazy_static; use spin::Mutex; lazy_static! { static ref PAGE_DIRECTORY: Mutex<&'static mut PDirectory> = Mutex::new( unsafe { &mut *(0xC0000000 as *mut PDirectory) } ); } pub unsafe fn setup_pd(pd: usize) { let mut data = PAGE_DIRECTORY.lock(); *data = &mut *(pd as *mut PDirectory); } 

मैंने बहुत ही अजीब तरीके से शुरुआती स्थैतिक आरंभीकरण को एक अलहदा संबोधन बनाया है, इसलिए मैं आभारी रहूंगा यदि आप मुझे लिखेंगे कि लिंक पुन: असाइनमेंट के साथ इस तरह के इनिशियलाइज़ेशन करने के लिए रस्ट समुदाय में यह कैसे प्रथागत है।

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

  match mb_magic { 0x2BADB002 => { println!("multibooted v1, yeah, reading mb info"); boot::init_with_mb1(mb_pointer); }, . . . . . . } memory::init(); 

GRUB मेमोरी कार्ड और OS1 भौतिक मेमोरी कार्ड

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

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

 pub mod multiboot2; pub mod multiboot; use super::arch; unsafe fn process_pointer(mb_pointer: usize) -> usize { //if in first 4 MB - map to kernel address space if mb_pointer < 0x400000 { arch::KERNEL_BASE | mb_pointer } else { arch::paging::allocate_page(mb_pointer, arch::MB_INFO_BASE, arch::paging::PDEntryFlags::PRESENT | arch::paging::PDEntryFlags::WRITABLE | arch::paging::PDEntryFlags::HUGE_PAGE ); arch::MB_INFO_BASE | mb_pointer } } pub fn init_with_mb1(mb_pointer: usize) { let ln_pointer = unsafe { process_pointer(mb_pointer) }; println!("mb pointer 0x{:X}", ln_pointer); let mb_info = multiboot::from_ptr(ln_pointer); println!("mb flags: {:?}", mb_info.flags().unwrap()); if mb_info.flags().unwrap().contains(multiboot::MBInfoFlags::MEM_MAP) { multiboot::parse_mmap(mb_info); println!("Multiboot memory map parsed, physical memory map has been built"); } else { panic!("MB mmap is not presented"); } } 

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

 impl MultibootInfo { . . . . . . pub unsafe fn get_mmap(&self, index: usize) -> Option<*const MemMapEntry> { use crate::arch::get_mb_pointer_base; let base: usize = get_mb_pointer_base(self.mmap_addr as usize); let mut iter: *const MemMapEntry = (base as u32 + self.mmap_addr) as *const MemMapEntry; for _i in 0..index { iter = ((iter as usize) + ((*iter).size as usize) + 4) as *const MemMapEntry; if ((iter as usize) - base) >= (self.mmap_addr + self.mmap_lenght) as usize { return None } else {} } Some(iter) } } 

मेमोरी कार्ड पार्स करते समय, हम GRUB संरचना के माध्यम से पुनरावृत्ति करते हैं और इसे बिटमैप में परिवर्तित करते हैं, जो OS1 भौतिक मेमोरी को प्रबंधित करने के लिए काम करेगा। मैंने नियंत्रण के लिए उपलब्ध मूल्यों के एक छोटे समूह में खुद को सीमित करने का फैसला किया - मुक्त, व्यस्त, आरक्षित, अनुपलब्ध, हालांकि GRUB और BIOS अधिक विकल्प हैं। इसलिए, हम मानचित्र प्रविष्टियों पर पुनरावृत्ति करते हैं और उनके राज्य को GRUB / BIOS मानों से OS1 के मानों में परिवर्तित करते हैं:

 pub fn parse_mmap(mbi: &MultibootInfo) { unsafe { let mut mmap_opt = mbi.get_mmap(0); let mut i: usize = 1; loop { let mmap = mmap_opt.unwrap(); crate::memory::physical::map((*mmap).addr as usize, (*mmap).len as usize, translate_multiboot_mem_to_os1(&(*mmap).mtype)); mmap_opt = mbi.get_mmap(i); match mmap_opt { None => break, _ => i += 1, } } } } pub fn translate_multiboot_mem_to_os1(mtype: &u32) -> usize { use crate::memory::physical::{RESERVED, UNUSABLE, USABLE}; match mtype { &MULTIBOOT_MEMORY_AVAILABLE => USABLE, &MULTIBOOT_MEMORY_RESERVED => UNUSABLE, &MULTIBOOT_MEMORY_ACPI_RECLAIMABLE => RESERVED, &MULTIBOOT_MEMORY_NVS => UNUSABLE, &MULTIBOOT_MEMORY_BADRAM => UNUSABLE, _ => UNUSABLE } } 

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

मैं बिगाड़ने के तहत बिटमैप कार्यान्वयन को हटा दूंगा ताकि लेख को अव्यवस्थित न किया जाए। संरचना कक्षाओं और मुफ्त मेमोरी की संख्या, सूचकांक और पते से पृष्ठों को चिह्नित करने और मुफ्त पृष्ठों की खोज करने में सक्षम है (यह भविष्य में ढेर को लागू करने की आवश्यकता होगी)। कार्ड अपने आप में 64 u32 तत्वों की एक सरणी है, आवश्यक दो बिट्स (ब्लॉक) को अलग करने के लिए, तथाकथित चंक (सरणी में सूचकांक, 16 ब्लॉक की पैकिंग) और ब्लॉक (चंक में बिट स्थिति) में रूपांतरण का उपयोग किया जाता है।

 pub const USABLE: usize = 0; pub const USED: usize = 1; pub const RESERVED: usize = 2; pub const UNUSABLE: usize = 3; pub const DEAD: usize = 0xDEAD; struct PhysMemoryInfo { pub total: usize, used: usize, reserved: usize, chunks: [u32; 64], } impl PhysMemoryInfo { // returns (chunk, page) pub fn find_free(&self) -> (usize, usize) { for chunk in 0..64 { for page in 0.. 16 { if ((self.chunks[chunk] >> page * 2) & 3) ^ 3 == 3 { return (chunk, page) } else {} } } (DEAD, 0) } // marks page to given flag and returns its address pub fn mark(&mut self, chunk: usize, block: usize, flag: usize) -> usize { self.chunks[chunk] = self.chunks[chunk] ^ (3 << (block * 2)); let mask = (0xFFFFFFFC ^ flag).rotate_left(block as u32 * 2); self.chunks[chunk] = self.chunks[chunk] & (mask as u32); if flag == USED { self.used += 1; } else if flag == UNUSABLE || flag == RESERVED { self.reserved += 1; } else { if self.used > 0 { self.used -= 1; } } (chunk * 16 + block) << 22 } pub fn mark_by_addr(&mut self, addr: usize, flag: usize) { let block_num = addr >> 22; let chunk: usize = (block_num / 16) as usize; let block: usize = block_num - chunk * 16; self.mark(chunk, block, flag); } pub fn count_total(& mut self) { let mut count: usize = 0; for i in 0..64 { let mut chunk = self.chunks[i]; for _j in 0..16 { if chunk & 0b11 != 0b11 { count += 1; } chunk = chunk >> 2; } } self.total = count; } pub fn get_total(&self) -> usize { self.total } pub fn get_used(&self) -> usize { self.used } pub fn get_reserved(&self) -> usize { self.reserved } pub fn get_free(&self) -> usize { self.total - self.used - self.reserved } } 

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

 use lazy_static::lazy_static; use spin::Mutex; lazy_static! { static ref RAM_INFO: Mutex<PhysMemoryInfo> = Mutex::new(PhysMemoryInfo { total: 0, used: 0, reserved: 0, chunks: [0xFFFFFFFF; 64] }); } pub fn map(addr: usize, len: usize, flag: usize) { // if len <= 4MiB then mark whole page with flag if len <= 4 * 1024 * 1024 { RAM_INFO.lock().mark_by_addr(addr, flag); } else { let pages: usize = len >> 22; for map_page in 0..(pages - 1) { map(addr + map_page << 22, 4 * 1024 * 1024, flag); } map(addr + (pages << 22), len - (pages << 22), flag); } } 

ढेर और उसका प्रबंधन

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

मैंने सबसे अधिक कर्नेल मेमोरी स्पेस (0xE0000000) के 512 एमबी को ढेर में दिया, मैं ढेर उपयोग मानचित्र (0xDFC00000) को 4 एमबी कम स्टोर करता हूं। मैं राज्य का वर्णन करने के लिए बिटमैप का उपयोग करता हूं, भौतिक स्मृति की तरह, लेकिन इसमें केवल 2 राज्य हैं - व्यस्त / मुफ्त। मेमोरी ब्लॉक का आकार 64 बाइट्स है - यह u32, u8 जैसे छोटे चर के लिए बहुत कुछ है, लेकिन, शायद, यह डेटा संरचनाओं को संग्रहीत करने के लिए इष्टतम है। फिर भी, यह संभावना नहीं है कि हमें ढेर पर एकल चर स्टोर करने की आवश्यकता है, अब इसका मुख्य उद्देश्य मल्टीटास्किंग के लिए संदर्भ संरचनाओं को संग्रहीत करना है।

64 बाइट्स के ब्लॉक को संरचनाओं में समूहीकृत किया जाता है जो पूरे 4 एमबी पेज की स्थिति का वर्णन करता है, इसलिए हम कई पन्नों में दोनों छोटी और बड़ी मात्रा में मेमोरी आवंटित कर सकते हैं। मैं निम्नलिखित शब्दों का उपयोग करता हूं: chunk - 64 बाइट्स, पैक - 2 KB (एक u32 - 64 बाइट्स * 32 बिट्स प्रति पैकेज), पेज - 4 एमबी।

 #[repr(packed)] #[derive(Copy, Clone)] struct HeapPageInfo { //every bit represents 64 bytes chunk of memory. 0 is free, 1 is busy //u32 size is 4 bytes, so page information total size is 8KiB pub _4mb_by_64b: [u32; 2048], } #[repr(packed)] #[derive(Copy, Clone)] struct HeapInfo { //Here we can know state of any 64 bit chunk in any of 128 4-MiB pages //Page information total size is 8KiB, so information about 128 pages requires 1MiB reserved data pub _512mb_by_4mb: [HeapPageInfo; 128], } 

आवंटनकर्ता से स्मृति का अनुरोध करते समय, मैं तीन मामलों पर विचार करता हूं, जो कि ग्रैन्युलैरिटी पर निर्भर करता है:

• 2 केबी से कम मेमोरी का अनुरोध आवंटनकर्ता से आया था। आपको एक पैक खोजने की आवश्यकता है जिसमें यह मुफ़्त होगा [आकार / 64, कोई भी गैर-शून्य शेष एक जोड़ता है] एक पंक्ति में विखंडू, इन विखंडू को व्यस्त के रूप में चिह्नित करें, पहले चंक का पता वापस करें।
• आबंटक से 4 एमबी से कम मेमोरी के लिए अनुरोध आया, लेकिन 2 केबी से अधिक। आपको एक ऐसा पृष्ठ खोजने की आवश्यकता है जिसमें मुफ़्त [आकार / 2048 हो, कोई भी नॉनज़रो शेष एक पंक्ति में एक] पैक जोड़ता है। मार्क [आकार / 2048] व्यस्त के रूप में पैक करता है, यदि कोई शेष है, तो निशान [शेष] को अंतिम पैक में व्यस्त के रूप में चिह्नित करें।
• आवंटनकर्ता से 4 एमबी से अधिक की मेमोरी के लिए अनुरोध आया। [आकार / 4 Mi, किसी भी नॉनजरो बैलेंस को एक पंक्ति में एक] पृष्ठ जोड़ते हैं, व्यस्त के रूप में [आकार / 4 Mi] पृष्ठों को जोड़ते हैं, अगर कोई संतुलन है - चिह्न [संतुलन] व्यस्त के रूप में पैक करता है। अंतिम पैक में, शेष भाग को व्यस्त मानकर चिह्नित करें।

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

 //512 MiB should be enough for kernel heap. If not - ooops... pub const KHEAP_START: usize = 0xE0000000; //I will keep 1MiB info about my heap in separate 4MiB page before heap at this point pub const KHEAP_INFO_ADDR: usize = 0xDFC00000; pub const KHEAP_CHUNK_SIZE: usize = 64; pub fn init() { KHEAP_INFO.lock().init(); } #[repr(packed)] #[derive(Copy, Clone)] struct HeapPageInfo { //every bit represents 64 bytes chunk of memory. 0 is free, 1 is busy //u32 size is 4 bytes, so page information total size is 8KiB pub _4mb_by_64b: [u32; 2048], } impl HeapPageInfo { pub fn init(&mut self) { for i in 0..2048 { self._4mb_by_64b[i] = 0; } } pub fn mark_chunks_used(&mut self, _32pack: usize, chunk: usize, n: usize) { let mask: u32 = 0xFFFFFFFF >> (32 - n) << chunk; self._4mb_by_64b[_32pack] = self._4mb_by_64b[_32pack] | mask; } pub fn mark_chunks_free(&mut self, _32pack: usize, chunk: usize, n: usize) { let mask: u32 = 0xFFFFFFFF >> (32 - n) << chunk; self._4mb_by_64b[_32pack] = self._4mb_by_64b[_32pack] ^ mask; } pub fn empty(&self) -> bool { for i in 0..2048 { if self._4mb_by_64b[i] != 0 { return false } } true } } #[repr(packed)] #[derive(Copy, Clone)] struct HeapInfo { //Here we can know state of any 64 bit chunk in any of 128 4-MiB pages //Page information total size is 8KiB, so information about 128 pages requires 1MiB reserved data pub _512mb_by_4mb: [HeapPageInfo; 128], } impl HeapInfo { pub fn init(&mut self) { for i in 0..128 { self._512mb_by_4mb[i].init(); } } // returns page number pub fn find_free_pages_of_size(&self, n: usize) -> usize { if n >= 128 { 0xFFFFFFFF } else { let mut start_page: usize = 0xFFFFFFFF; let mut current_page: usize = 0xFFFFFFFF; for page in 0..128 { if self._512mb_by_4mb[page].empty() { if current_page - start_page == n { return start_page } if start_page == 0xFFFFFFFF { start_page = page; } current_page = page; } else { start_page = 0xFFFFFFFF; current_page = 0xFFFFFFFF; } } 0xFFFFFFFF } } // returns (page number, 32pack number) pub fn find_free_packs_of_size(&self, n: usize) -> (usize, usize) { if n < 2048 { for page in 0..128 { let mut start_pack: usize = 0xFFFFFFFF; let mut current_pack: usize = 0xFFFFFFFF; for _32pack in 0..2048 { let _32pack_info = self._512mb_by_4mb[page]._4mb_by_64b[_32pack]; if _32pack_info == 0 { if current_pack - start_pack == n { return (page, start_pack) } if start_pack == 0xFFFFFFFF { start_pack = _32pack; } current_pack = _32pack; } else { start_pack = 0xFFFFFFFF; current_pack = 0xFFFFFFFF; } } } (0xFFFFFFFF, 0xFFFFFFFF) } else { (0xFFFFFFFF, 0xFFFFFFFF) } } // returns (page number, 32pack number, chunk number) pub fn find_free_chunks_of_size(&self, n: usize) -> (usize, usize, usize) { if n < 32 { for page in 0..128 { for _32pack in 0..2048 { let _32pack_info = self._512mb_by_4mb[page]._4mb_by_64b[_32pack]; let mask: u32 = 0xFFFFFFFF >> (32 - n); for chunk in 0..(32-n) { if ((_32pack_info >> chunk) & mask) ^ mask == mask { return (page, _32pack, chunk) } } } } (0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF) } else { (0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF) } } fn mark_chunks_used(&mut self, page: usize, _32pack: usize, chunk: usize, n: usize) { self._512mb_by_4mb[page].mark_chunks_used(_32pack, chunk, n); } fn mark_chunks_free(&mut self, page: usize, _32pack: usize, chunk: usize, n: usize) { self._512mb_by_4mb[page].mark_chunks_free(_32pack, chunk, n); } fn mark_packs_used(&mut self, page: usize, _32pack:usize, n: usize) { for i in _32pack..(_32pack + n) { self._512mb_by_4mb[page]._4mb_by_64b[i] = 0xFFFFFFFF; } } fn mark_packs_free(&mut self, page: usize, _32pack:usize, n: usize) { for i in _32pack..(_32pack + n) { self._512mb_by_4mb[page]._4mb_by_64b[i] = 0; } } } use lazy_static::lazy_static; use spin::Mutex; lazy_static! { static ref KHEAP_INFO: Mutex<&'static mut HeapInfo> = Mutex::new(unsafe { &mut *(KHEAP_INFO_ADDR as *mut HeapInfo) }); } fn allocate_n_chunks_less_than_pack(n: usize, align: usize) -> *mut u8 { let mut heap_info = KHEAP_INFO.lock(); let (page, _32pack, chunk) = heap_info.find_free_chunks_of_size(n); if page == 0xFFFFFFFF { core::ptr::null_mut() } else { let tptr: usize = KHEAP_START + 0x400000 * page + _32pack * 32 * 64 + chunk * 64; let res = tptr % align; let uptr = if res == 0 { tptr } else { tptr + align - res }; //check bounds: more than start and less than 4GiB - 64B //but according to chunks error should never happen if uptr >= KHEAP_START && uptr <= 0xFFFFFFFF - 64 * n { heap_info.mark_chunks_used(page, _32pack, chunk, n); uptr as *mut u8 } else { core::ptr::null_mut() } } } fn allocate_n_chunks_less_than_page(n: usize, align: usize) -> *mut u8 { let mut heap_info = KHEAP_INFO.lock(); let packs_n: usize = n / 32; let lost_chunks = n - packs_n * 32; let mut packs_to_alloc = packs_n; if lost_chunks != 0 { packs_to_alloc += 1; } let (page, pack) = heap_info.find_free_packs_of_size(packs_to_alloc); if page == 0xFFFFFFFF { core::ptr::null_mut() } else { let tptr: usize = KHEAP_START + 0x400000 * page + pack * 32 * 64; let res = tptr % align; let uptr = if res == 0 { tptr } else { tptr + align - res }; //check bounds: more than start and less than 4GiB - 64B //but according to chunks error should never happen if uptr >= KHEAP_START && uptr <= 0xFFFFFFFF - 64 * n { heap_info.mark_packs_used(page, pack, packs_n); if lost_chunks != 0 { heap_info.mark_chunks_used(page, pack + packs_to_alloc, 0, lost_chunks); } uptr as *mut u8 } else { core::ptr::null_mut() } } } //unsupported yet fn allocate_n_chunks_more_than_page(n: usize, align: usize) -> *mut u8 { let mut heap_info = KHEAP_INFO.lock(); let packs_n: usize = n / 32; let lost_chunks = n - packs_n * 32; let mut packs_to_alloc = packs_n; if lost_chunks != 0 { packs_to_alloc += 1; } let pages_n: usize = packs_to_alloc / 2048; let mut lost_packs = packs_to_alloc - pages_n * 2048; let mut pages_to_alloc = pages_n; if lost_packs != 0 { pages_to_alloc += 1; } if lost_chunks != 0 { lost_packs -= 1; } let page = heap_info.find_free_pages_of_size(pages_to_alloc); if page == 0xFFFFFFFF { core::ptr::null_mut() } else { let tptr: usize = KHEAP_START + 0x400000 * page; let res = tptr % align; let uptr = if res == 0 { tptr } else { tptr + align - res }; //check bounds: more than start and less than 4GiB - 64B * n //but according to chunks error should never happen if uptr >= KHEAP_START && uptr <= 0xFFFFFFFF - 64 * n { for i in page..(page + pages_n) { heap_info.mark_packs_used(i, 0, 2048); } if lost_packs != 0 { heap_info.mark_packs_used(page + pages_to_alloc, 0, lost_packs); } if lost_chunks != 0 { heap_info.mark_chunks_used(page + pages_to_alloc, lost_packs, 0, lost_chunks); } uptr as *mut u8 } else { core::ptr::null_mut() } } } // returns pointer pub fn allocate_n_chunks(n: usize, align: usize) -> *mut u8 { if n < 32 { allocate_n_chunks_less_than_pack(n, align) } else if n < 32 * 2048 { allocate_n_chunks_less_than_page(n, align) } else { allocate_n_chunks_more_than_page(n, align) } } pub fn free_chunks(ptr: usize, n: usize) { let page: usize = (ptr - KHEAP_START) / 0x400000; let _32pack: usize = ((ptr - KHEAP_START) - (page * 0x400000)) / (32 * 64); let chunk: usize = ((ptr - KHEAP_START) - (page * 0x400000) - (_32pack * (32 * 64))) / 64; let mut heap_info = KHEAP_INFO.lock(); if n < 32 { heap_info.mark_chunks_free(page, _32pack, chunk, n); } else if n < 32 * 2048 { let packs_n: usize = n / 32; let lost_chunks = n - packs_n * 32; heap_info.mark_packs_free(page, _32pack, packs_n); if lost_chunks != 0 { heap_info.mark_chunks_free(page, _32pack + packs_n, 0, lost_chunks); } } else { let packs_n: usize = n / 32; let pages_n: usize = packs_n / 2048; let lost_packs: usize = packs_n - pages_n * 2048; let lost_chunks = n - packs_n * 32; for i in page..(page + pages_n) { heap_info.mark_packs_free(i, 0, 2048); } if lost_packs != 0 { heap_info.mark_packs_free(page + pages_n, 0, lost_packs); } if lost_chunks != 0 { heap_info.mark_chunks_free(page + pages_n, packs_n, 0, lost_chunks); } } } 

आवंटन और पृष्ठ दोष

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

आवंटनकर्ता का कार्यान्वयन बहुत सरल है - यह केवल ऊपर वर्णित तंत्र को संदर्भित करता है।

 use alloc::alloc::{GlobalAlloc, Layout}; pub struct Os1Allocator; unsafe impl Sync for Os1Allocator {} unsafe impl GlobalAlloc for Os1Allocator { unsafe fn alloc(&self, layout: Layout) -> *mut u8 { use super::logical::{KHEAP_CHUNK_SIZE, allocate_n_chunks}; let size = layout.size(); let mut chunk_count: usize = 1; if size > KHEAP_CHUNK_SIZE { chunk_count = size / KHEAP_CHUNK_SIZE; if KHEAP_CHUNK_SIZE * chunk_count != size { chunk_count += 1; } } allocate_n_chunks(chunk_count, layout.align()) } unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { use super::logical::{KHEAP_CHUNK_SIZE, free_chunks}; let size = layout.size(); let mut chunk_count: usize = 1; if size > KHEAP_CHUNK_SIZE { chunk_count = size / KHEAP_CHUNK_SIZE; if KHEAP_CHUNK_SIZE * chunk_count != size { chunk_count += 1; } } free_chunks(ptr as usize, chunk_count); } } 

Lib.rs में आवंटन निम्नानुसार है:

 #![feature(alloc, alloc_error_handler)] extern crate alloc; #[global_allocator] static ALLOCATOR: memory::allocate::Os1Allocator = memory::allocate::Os1Allocator; 

और जब हम अपने आप को इस तरह से आवंटित करने का प्रयास करते हैं, तो हमें पृष्ठ दोष अपवाद मिलता है, क्योंकि हमने अभी तक वर्चुअल मेमोरी के आवंटन पर काम नहीं किया है। खैर, यह कैसे! खैर, आपको पिछले लेख की सामग्री पर वापस जाना होगा और अपवादों को जोड़ना होगा। मैंने वर्चुअल मेमोरी के आलसी आवंटन को लागू करने का निर्णय लिया, अर्थात्, यह पृष्ठ मेमोरी अनुरोध के समय पर आवंटित नहीं किया गया था, लेकिन इसे एक्सेस करने के प्रयास के समय। सौभाग्य से, x86 प्रोसेसर इसकी अनुमति देता है और यहां तक ​​कि इसे प्रोत्साहित भी करता है। Page fault , , , — , , CR2 — , .

, . 32 ( , , 32 ), . Rust. , . , , iret , , Page fault Protection fault. Protection fault — , .

 eE_page_fault: pushad mov eax, [esp + 32] push eax mov eax, cr2 push eax call kE_page_fault pop eax pop eax popad add esp, 4 iret 

Rust , . , . . .

 bitflags! { struct PFErrorCode: usize { const PROTECTION = 1; //1 - protection caused, 0 - not present page caused const WRITE = 1 << 1; //1 - write caused, 0 - read caused const USER_MODE = 1 << 2; //1 - from user mode, 0 - from kernel const RESERVED = 1 << 3; //1 - reserved page (PAE/PSE), 0 - not const INSTRUCTION = 1 << 4; //1 - instruction fetch caused, 0 - not } } impl PFErrorCode { pub fn to_pd_flags(&self) -> super::super::paging::PDEntryFlags { use super::super::paging; let mut flags = paging::PDEntryFlags::empty(); if self.contains(PFErrorCode::WRITE) { flags.set(paging::PDEntryFlags::WRITABLE, true); } if self.contains(PFErrorCode::USER_MODE) { flags.set(paging::PDEntryFlags::USER_ACCESSIBLE, true); } flags } } #[no_mangle] pub unsafe extern fn kE_page_fault(ptr: usize, code: usize) { use super::super::paging; println!("Page fault occured at addr 0x{:X}, code {:X}", ptr, code); let phys_address = crate::memory::physical::alloc_page(); let code_flags: PFErrorCode = PFErrorCode::from_bits(code).unwrap(); if !code_flags.contains(PFErrorCode::PROTECTION) { //page not presented, we need to allocate the new one let mut flags: paging::PDEntryFlags = code_flags.to_pd_flags(); flags.set(paging::PDEntryFlags::HUGE_PAGE, true); paging::allocate_page(phys_address, ptr, flags); println!("Page frame allocated at Paddr {:#X} Laddr {:#X}", phys_address, ptr); } else { panic!("Protection error occured, cannot handle yet"); } } 

, . , . . , . , , :

  println!("memory: total {} used {} reserved {} free {}", memory::physical::total(), memory::physical::used(), memory::physical::reserved(), memory::physical::free()); use alloc::vec::Vec; let mut vec: Vec<usize> = Vec::new(); for i in 0..1000000 { vec.push(i); } println!("vec len {}, ptr is {:?}", vec.len(), vec.as_ptr()); println!("Still works, check reusage!"); let mut vec2: Vec<usize> = Vec::new(); for i in 0..10 { vec2.push(i); } println!("vec2 len {}, ptr is {:?}, vec is still here? {}", vec2.len(), vec2.as_ptr(), vec.get(1000).unwrap()); println!("Still works!"); println!("memory: total {} used {} reserved {} free {}", memory::physical::total(), memory::physical::used(), memory::physical::reserved(), memory::physical::free()); 

:

, , . 3,5 + 3 , . 3,5 .

IRQ 1 — Alt + PrntScrn :)

, , Rust — , — , !

, .

आपका ध्यान के लिए धन्यवाद!