diff --git a/Kernel/VM/MemoryManager.cpp b/Kernel/VM/MemoryManager.cpp index 049727d55a..82912807ed 100644 --- a/Kernel/VM/MemoryManager.cpp +++ b/Kernel/VM/MemoryManager.cpp @@ -108,13 +108,13 @@ void MemoryManager::protect_kernel_image() { ScopedSpinLock page_lock(kernel_page_directory().get_lock()); // Disable writing to the kernel text and rodata segments. - for (size_t i = (FlatPtr)&start_of_kernel_text; i < (FlatPtr)&start_of_kernel_data; i += PAGE_SIZE) { + for (auto i = (FlatPtr)&start_of_kernel_text; i < (FlatPtr)&start_of_kernel_data; i += PAGE_SIZE) { auto& pte = *ensure_pte(kernel_page_directory(), VirtualAddress(i)); pte.set_writable(false); } if (Processor::current().has_feature(CPUFeature::NX)) { // Disable execution of the kernel data, bss and heap segments. - for (size_t i = (FlatPtr)&start_of_kernel_data; i < (FlatPtr)&end_of_kernel_image; i += PAGE_SIZE) { + for (auto i = (FlatPtr)&start_of_kernel_data; i < (FlatPtr)&end_of_kernel_image; i += PAGE_SIZE) { auto& pte = *ensure_pte(kernel_page_directory(), VirtualAddress(i)); pte.set_execute_disabled(true); } @@ -153,7 +153,7 @@ bool MemoryManager::is_allowed_to_mmap_to_userspace(PhysicalAddress start_addres continue; if (!(current_range.start.offset(current_range.length) > start_address)) continue; - if (!(current_range.length >= range.size())) + if (current_range.length < range.size()) return false; return true; } @@ -162,7 +162,7 @@ bool MemoryManager::is_allowed_to_mmap_to_userspace(PhysicalAddress start_addres void MemoryManager::parse_memory_map() { - RefPtr region; + RefPtr physical_region; // Register used memory regions that we know of. m_used_memory_ranges.ensure_capacity(4); @@ -186,10 +186,10 @@ void MemoryManager::parse_memory_map() } for (auto* mmap = mmap_begin; mmap < mmap_end; mmap++) { - klog() << "MM: Multiboot mmap: address = " << String::format("0x%016llx", mmap->addr) << ", length = " << String::format("0x%016llx", mmap->len) << ", type = 0x" << String::format("%x", mmap->type); + dmesgln("MM: Multiboot mmap: address={:p}, length={}, type={}", mmap->addr, mmap->len, mmap->type); auto start_address = PhysicalAddress(mmap->addr); - size_t length = static_cast(mmap->len); + auto length = static_cast(mmap->len); switch (mmap->type) { case (MULTIBOOT_MEMORY_AVAILABLE): m_physical_memory_ranges.append(PhysicalMemoryRange { PhysicalMemoryRangeType::Usable, start_address, length }); @@ -222,17 +222,17 @@ void MemoryManager::parse_memory_map() // Fix up unaligned memory regions. auto diff = (FlatPtr)mmap->addr % PAGE_SIZE; if (diff != 0) { - klog() << "MM: got an unaligned region base from the bootloader; correcting " << String::format("%p", (void*)mmap->addr) << " by " << diff << " bytes"; + dmesgln("MM: Got an unaligned physical_region from the bootloader; correcting {:p} by {} bytes", mmap->addr, diff); diff = PAGE_SIZE - diff; mmap->addr += diff; mmap->len -= diff; } if ((mmap->len % PAGE_SIZE) != 0) { - klog() << "MM: got an unaligned region length from the bootloader; correcting " << mmap->len << " by " << (mmap->len % PAGE_SIZE) << " bytes"; + dmesgln("MM: Got an unaligned physical_region from the bootloader; correcting length {} by {} bytes", mmap->len, mmap->len % PAGE_SIZE); mmap->len -= mmap->len % PAGE_SIZE; } if (mmap->len < PAGE_SIZE) { - klog() << "MM: memory region from bootloader is too small; we want >= " << PAGE_SIZE << " bytes, but got " << mmap->len << " bytes"; + dmesgln("MM: Memory physical_region from bootloader is too small; we want >= {} bytes, but got {} bytes", PAGE_SIZE, mmap->len); continue; } @@ -250,29 +250,29 @@ void MemoryManager::parse_memory_map() if (should_skip) continue; - // Assign page to user physical region. - if (region.is_null() || region->upper().offset(PAGE_SIZE) != addr) { + // Assign page to user physical physical_region. + if (physical_region.is_null() || physical_region->upper().offset(PAGE_SIZE) != addr) { m_user_physical_regions.append(PhysicalRegion::create(addr, addr)); - region = m_user_physical_regions.last(); + physical_region = m_user_physical_regions.last(); } else { - region->expand(region->lower(), addr); + physical_region->expand(physical_region->lower(), addr); } } } - // Append statically-allocated super physical region. + // Append statically-allocated super physical physical_region. m_super_physical_regions.append(PhysicalRegion::create( PhysicalAddress(virtual_to_low_physical(FlatPtr(super_pages))), PhysicalAddress(virtual_to_low_physical(FlatPtr(super_pages + sizeof(super_pages)))))); for (auto& region : m_super_physical_regions) { m_super_physical_pages += region.finalize_capacity(); - klog() << "MM: Super physical region: " << region.lower() << " - " << region.upper(); + dmesgln("MM: Super physical region: {} - {}", region.lower(), region.upper()); } for (auto& region : m_user_physical_regions) { m_user_physical_pages += region.finalize_capacity(); - klog() << "MM: User physical region: " << region.lower() << " - " << region.upper(); + dmesgln("MM: User physical region: {} - {}", region.lower(), region.upper()); } ASSERT(m_super_physical_pages > 0); @@ -447,7 +447,7 @@ PageFaultResponse MemoryManager::handle_page_fault(const PageFault& fault) #endif auto* region = find_region_from_vaddr(fault.vaddr()); if (!region) { - klog() << "CPU[" << Processor::id() << "] NP(error) fault at invalid address " << fault.vaddr(); + dmesgln("CPU[{}] NP(error) fault at invalid address {}", Processor::id(), fault.vaddr()); return PageFaultResponse::ShouldCrash; } @@ -571,7 +571,7 @@ void MemoryManager::deallocate_user_physical_page(const PhysicalPage& page) return; } - klog() << "MM: deallocate_user_physical_page couldn't figure out region for user page @ " << page.paddr(); + dmesgln("MM: deallocate_user_physical_page couldn't figure out region for user page @ {}", page.paddr()); ASSERT_NOT_REACHED(); } @@ -626,7 +626,7 @@ RefPtr MemoryManager::allocate_user_physical_page(ShouldZeroFill s return IterationDecision::Continue; int purged_page_count = static_cast(vmobject).purge_with_interrupts_disabled({}); if (purged_page_count) { - klog() << "MM: Purge saved the day! Purged " << purged_page_count << " pages from AnonymousVMObject{" << &vmobject << "}"; + dbgln("MM: Purge saved the day! Purged {} pages from AnonymousVMObject", purged_page_count); page = find_free_user_physical_page(false); purged_pages = true; ASSERT(page); @@ -634,9 +634,8 @@ RefPtr MemoryManager::allocate_user_physical_page(ShouldZeroFill s } return IterationDecision::Continue; }); - if (!page) { - klog() << "MM: no user physical pages available"; + dmesgln("MM: no user physical pages available"); return {}; } } @@ -657,7 +656,7 @@ void MemoryManager::deallocate_supervisor_physical_page(const PhysicalPage& page ScopedSpinLock lock(s_mm_lock); for (auto& region : m_super_physical_regions) { if (!region.contains(page)) { - klog() << "MM: deallocate_supervisor_physical_page: " << page.paddr() << " not in " << region.lower() << " -> " << region.upper(); + dbgln("MM: deallocate_supervisor_physical_page: {} not in {} - {}", page.paddr(), region.lower(), region.upper()); continue; } @@ -666,7 +665,7 @@ void MemoryManager::deallocate_supervisor_physical_page(const PhysicalPage& page return; } - klog() << "MM: deallocate_supervisor_physical_page couldn't figure out region for super page @ " << page.paddr(); + dbgln("MM: deallocate_supervisor_physical_page couldn't figure out region for super page @ {}", page.paddr()); ASSERT_NOT_REACHED(); } @@ -685,10 +684,10 @@ NonnullRefPtrVector MemoryManager::allocate_contiguous_supervisor_ if (physical_pages.is_empty()) { if (m_super_physical_regions.is_empty()) { - klog() << "MM: no super physical regions available (?)"; + dmesgln("MM: no super physical regions available (?)"); } - klog() << "MM: no super physical pages available"; + dmesgln("MM: no super physical pages available"); ASSERT_NOT_REACHED(); return {}; } @@ -712,10 +711,10 @@ RefPtr MemoryManager::allocate_supervisor_physical_page() if (!page) { if (m_super_physical_regions.is_empty()) { - klog() << "MM: no super physical regions available (?)"; + dmesgln("MM: no super physical regions available (?)"); } - klog() << "MM: no super physical pages available"; + dmesgln("MM: no super physical pages available"); ASSERT_NOT_REACHED(); return {}; } @@ -879,11 +878,18 @@ void MemoryManager::unregister_region(Region& region) void MemoryManager::dump_kernel_regions() { - klog() << "Kernel regions:"; - klog() << "BEGIN END SIZE ACCESS NAME"; + dbgln("Kernel regions:"); + dbgln("BEGIN END SIZE ACCESS NAME"); ScopedSpinLock lock(s_mm_lock); - for (auto& region : MM.m_kernel_regions) { - klog() << String::format("%08x", region.vaddr().get()) << " -- " << String::format("%08x", region.vaddr().offset(region.size() - 1).get()) << " " << String::format("%08zx", region.size()) << " " << (region.is_readable() ? 'R' : ' ') << (region.is_writable() ? 'W' : ' ') << (region.is_executable() ? 'X' : ' ') << (region.is_shared() ? 'S' : ' ') << (region.is_stack() ? 'T' : ' ') << (region.vmobject().is_anonymous() ? 'A' : ' ') << " " << region.name().characters(); + for (auto& region : m_kernel_regions) { + dbgln("{:08x} -- {:08x} {:08x} {:c}{:c}{:c}{:c}{:c} {}", region.vaddr().get(), region.vaddr().offset(region.size() - 1).get(), region.size(), + region.is_readable() ? 'R' : ' ', + region.is_writable() ? 'W' : ' ', + region.is_executable() ? 'X' : ' ', + region.is_shared() ? 'S' : ' ', + region.is_stack() ? 'T' : ' ', + region.is_syscall_region() ? 'C' : ' ', + region.name()); } }