mirror of
https://github.com/RGBCube/serenity
synced 2025-07-27 02:07:36 +00:00
Kernel: Rename LinearAddress => VirtualAddress.
This commit is contained in:
Andreas Kling
parent
0ed89440f1
commit
e42c3b4fd7
33 changed files with 272 additions and 272 deletions
|
|
@ -66,14 +66,14 @@ void MemoryManager::initialize_paging()
|
|||
dbgprintf("MM: Protect against null dereferences\n");
|
||||
#endif
|
||||
// Make null dereferences crash.
|
||||
map_protected(LinearAddress(0), PAGE_SIZE);
|
||||
map_protected(VirtualAddress(0), PAGE_SIZE);
|
||||
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: Identity map bottom 4MB\n");
|
||||
#endif
|
||||
// The bottom 4 MB (except for the null page) are identity mapped & supervisor only.
|
||||
// Every process shares these mappings.
|
||||
create_identity_mapping(kernel_page_directory(), LinearAddress(PAGE_SIZE), (4 * MB) - PAGE_SIZE);
|
||||
create_identity_mapping(kernel_page_directory(), VirtualAddress(PAGE_SIZE), (4 * MB) - PAGE_SIZE);
|
||||
|
||||
// Basic memory map:
|
||||
// 0 -> 512 kB Kernel code. Root page directory & PDE 0.
|
||||
|
|
@ -90,7 +90,7 @@ void MemoryManager::initialize_paging()
|
|||
dbgprintf("MM: 4MB-%uMB available for allocation\n", m_ram_size / 1048576);
|
||||
for (size_t i = (4 * MB); i < m_ram_size; i += PAGE_SIZE)
|
||||
m_free_physical_pages.append(PhysicalPage::create_eternal(PhysicalAddress(i), false));
|
||||
m_quickmap_addr = LinearAddress((1 * MB) - PAGE_SIZE);
|
||||
m_quickmap_addr = VirtualAddress((1 * MB) - PAGE_SIZE);
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: Quickmap will use P%x\n", m_quickmap_addr.get());
|
||||
dbgprintf("MM: Installing page directory\n");
|
||||
|
|
@ -118,12 +118,12 @@ RetainPtr<PhysicalPage> MemoryManager::allocate_page_table(PageDirectory& page_d
|
|||
return physical_page;
|
||||
}
|
||||
|
||||
void MemoryManager::remove_identity_mapping(PageDirectory& page_directory, LinearAddress laddr, size_t size)
|
||||
void MemoryManager::remove_identity_mapping(PageDirectory& page_directory, VirtualAddress vaddr, size_t size)
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
// FIXME: ASSERT(laddr is 4KB aligned);
|
||||
// FIXME: ASSERT(vaddr is 4KB aligned);
|
||||
for (dword offset = 0; offset < size; offset += PAGE_SIZE) {
|
||||
auto pte_address = laddr.offset(offset);
|
||||
auto pte_address = vaddr.offset(offset);
|
||||
auto pte = ensure_pte(page_directory, pte_address);
|
||||
pte.set_physical_page_base(0);
|
||||
pte.set_user_allowed(false);
|
||||
|
|
@ -133,16 +133,16 @@ void MemoryManager::remove_identity_mapping(PageDirectory& page_directory, Linea
|
|||
}
|
||||
}
|
||||
|
||||
auto MemoryManager::ensure_pte(PageDirectory& page_directory, LinearAddress laddr) -> PageTableEntry
|
||||
auto MemoryManager::ensure_pte(PageDirectory& page_directory, VirtualAddress vaddr) -> PageTableEntry
|
||||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
dword page_directory_index = (laddr.get() >> 22) & 0x3ff;
|
||||
dword page_table_index = (laddr.get() >> 12) & 0x3ff;
|
||||
dword page_directory_index = (vaddr.get() >> 22) & 0x3ff;
|
||||
dword page_table_index = (vaddr.get() >> 12) & 0x3ff;
|
||||
|
||||
PageDirectoryEntry pde = PageDirectoryEntry(&page_directory.entries()[page_directory_index]);
|
||||
if (!pde.is_present()) {
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: PDE %u not present (requested for L%x), allocating\n", page_directory_index, laddr.get());
|
||||
dbgprintf("MM: PDE %u not present (requested for L%x), allocating\n", page_directory_index, vaddr.get());
|
||||
#endif
|
||||
if (page_directory_index == 0) {
|
||||
ASSERT(&page_directory == m_kernel_page_directory);
|
||||
|
|
@ -159,7 +159,7 @@ auto MemoryManager::ensure_pte(PageDirectory& page_directory, LinearAddress ladd
|
|||
&page_directory == m_kernel_page_directory ? "Kernel" : "User",
|
||||
page_directory.cr3(),
|
||||
page_directory_index,
|
||||
laddr.get(),
|
||||
vaddr.get(),
|
||||
page_table->paddr().get());
|
||||
#endif
|
||||
|
||||
|
|
@ -173,12 +173,12 @@ auto MemoryManager::ensure_pte(PageDirectory& page_directory, LinearAddress ladd
|
|||
return PageTableEntry(&pde.page_table_base()[page_table_index]);
|
||||
}
|
||||
|
||||
void MemoryManager::map_protected(LinearAddress laddr, size_t length)
|
||||
void MemoryManager::map_protected(VirtualAddress vaddr, size_t length)
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
// FIXME: ASSERT(linearAddress is 4KB aligned);
|
||||
for (dword offset = 0; offset < length; offset += PAGE_SIZE) {
|
||||
auto pte_address = laddr.offset(offset);
|
||||
auto pte_address = vaddr.offset(offset);
|
||||
auto pte = ensure_pte(kernel_page_directory(), pte_address);
|
||||
pte.set_physical_page_base(pte_address.get());
|
||||
pte.set_user_allowed(false);
|
||||
|
|
@ -188,12 +188,12 @@ void MemoryManager::map_protected(LinearAddress laddr, size_t length)
|
|||
}
|
||||
}
|
||||
|
||||
void MemoryManager::create_identity_mapping(PageDirectory& page_directory, LinearAddress laddr, size_t size)
|
||||
void MemoryManager::create_identity_mapping(PageDirectory& page_directory, VirtualAddress vaddr, size_t size)
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
ASSERT((laddr.get() & ~PAGE_MASK) == 0);
|
||||
ASSERT((vaddr.get() & ~PAGE_MASK) == 0);
|
||||
for (dword offset = 0; offset < size; offset += PAGE_SIZE) {
|
||||
auto pte_address = laddr.offset(offset);
|
||||
auto pte_address = vaddr.offset(offset);
|
||||
auto pte = ensure_pte(page_directory, pte_address);
|
||||
pte.set_physical_page_base(pte_address.get());
|
||||
pte.set_user_allowed(false);
|
||||
|
|
@ -208,41 +208,41 @@ void MemoryManager::initialize()
|
|||
s_the = new MemoryManager;
|
||||
}
|
||||
|
||||
Region* MemoryManager::region_from_laddr(Process& process, LinearAddress laddr)
|
||||
Region* MemoryManager::region_from_vaddr(Process& process, VirtualAddress vaddr)
|
||||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
|
||||
if (laddr.get() >= 0xc0000000) {
|
||||
if (vaddr.get() >= 0xc0000000) {
|
||||
for (auto& region : MM.m_kernel_regions) {
|
||||
if (region->contains(laddr))
|
||||
if (region->contains(vaddr))
|
||||
return region;
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: Use a binary search tree (maybe red/black?) or some other more appropriate data structure!
|
||||
for (auto& region : process.m_regions) {
|
||||
if (region->contains(laddr))
|
||||
if (region->contains(vaddr))
|
||||
return region.ptr();
|
||||
}
|
||||
dbgprintf("%s(%u) Couldn't find region for L%x (CR3=%x)\n", process.name().characters(), process.pid(), laddr.get(), process.page_directory().cr3());
|
||||
dbgprintf("%s(%u) Couldn't find region for L%x (CR3=%x)\n", process.name().characters(), process.pid(), vaddr.get(), process.page_directory().cr3());
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const Region* MemoryManager::region_from_laddr(const Process& process, LinearAddress laddr)
|
||||
const Region* MemoryManager::region_from_vaddr(const Process& process, VirtualAddress vaddr)
|
||||
{
|
||||
if (laddr.get() >= 0xc0000000) {
|
||||
if (vaddr.get() >= 0xc0000000) {
|
||||
for (auto& region : MM.m_kernel_regions) {
|
||||
if (region->contains(laddr))
|
||||
if (region->contains(vaddr))
|
||||
return region;
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: Use a binary search tree (maybe red/black?) or some other more appropriate data structure!
|
||||
for (auto& region : process.m_regions) {
|
||||
if (region->contains(laddr))
|
||||
if (region->contains(vaddr))
|
||||
return region.ptr();
|
||||
}
|
||||
dbgprintf("%s(%u) Couldn't find region for L%x (CR3=%x)\n", process.name().characters(), process.pid(), laddr.get(), process.page_directory().cr3());
|
||||
dbgprintf("%s(%u) Couldn't find region for L%x (CR3=%x)\n", process.name().characters(), process.pid(), vaddr.get(), process.page_directory().cr3());
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
|
@ -290,7 +290,7 @@ bool MemoryManager::copy_on_write(Region& region, unsigned page_index_in_region)
|
|||
auto physical_page_to_copy = move(vmo.physical_pages()[page_index_in_region]);
|
||||
auto physical_page = allocate_physical_page(ShouldZeroFill::No);
|
||||
byte* dest_ptr = quickmap_page(*physical_page);
|
||||
const byte* src_ptr = region.laddr().offset(page_index_in_region * PAGE_SIZE).as_ptr();
|
||||
const byte* src_ptr = region.vaddr().offset(page_index_in_region * PAGE_SIZE).as_ptr();
|
||||
#ifdef PAGE_FAULT_DEBUG
|
||||
dbgprintf(" >> COW P%x <- P%x\n", physical_page->paddr().get(), physical_page_to_copy->paddr().get());
|
||||
#endif
|
||||
|
|
@ -345,7 +345,7 @@ bool MemoryManager::page_in_from_inode(Region& region, unsigned page_index_in_re
|
|||
return false;
|
||||
}
|
||||
remap_region_page(region, page_index_in_region, true);
|
||||
byte* dest_ptr = region.laddr().offset(page_index_in_region * PAGE_SIZE).as_ptr();
|
||||
byte* dest_ptr = region.vaddr().offset(page_index_in_region * PAGE_SIZE).as_ptr();
|
||||
memcpy(dest_ptr, page_buffer, PAGE_SIZE);
|
||||
return true;
|
||||
}
|
||||
|
|
@ -355,15 +355,15 @@ PageFaultResponse MemoryManager::handle_page_fault(const PageFault& fault)
|
|||
ASSERT_INTERRUPTS_DISABLED();
|
||||
ASSERT(current);
|
||||
#ifdef PAGE_FAULT_DEBUG
|
||||
dbgprintf("MM: handle_page_fault(%w) at L%x\n", fault.code(), fault.laddr().get());
|
||||
dbgprintf("MM: handle_page_fault(%w) at L%x\n", fault.code(), fault.vaddr().get());
|
||||
#endif
|
||||
ASSERT(fault.laddr() != m_quickmap_addr);
|
||||
auto* region = region_from_laddr(current->process(), fault.laddr());
|
||||
ASSERT(fault.vaddr() != m_quickmap_addr);
|
||||
auto* region = region_from_vaddr(current->process(), fault.vaddr());
|
||||
if (!region) {
|
||||
kprintf("NP(error) fault at invalid address L%x\n", fault.laddr().get());
|
||||
kprintf("NP(error) fault at invalid address L%x\n", fault.vaddr().get());
|
||||
return PageFaultResponse::ShouldCrash;
|
||||
}
|
||||
auto page_index_in_region = region->page_index_from_address(fault.laddr());
|
||||
auto page_index_in_region = region->page_index_from_address(fault.vaddr());
|
||||
if (fault.is_not_present()) {
|
||||
if (region->vmo().inode()) {
|
||||
#ifdef PAGE_FAULT_DEBUG
|
||||
|
|
@ -387,7 +387,7 @@ PageFaultResponse MemoryManager::handle_page_fault(const PageFault& fault)
|
|||
ASSERT(success);
|
||||
return PageFaultResponse::Continue;
|
||||
}
|
||||
kprintf("PV(error) fault in Region{%p}[%u] at L%x\n", region, page_index_in_region, fault.laddr().get());
|
||||
kprintf("PV(error) fault in Region{%p}[%u] at L%x\n", region, page_index_in_region, fault.vaddr().get());
|
||||
} else {
|
||||
ASSERT_NOT_REACHED();
|
||||
}
|
||||
|
|
@ -462,22 +462,22 @@ void MemoryManager::flush_entire_tlb()
|
|||
: "%eax", "memory");
|
||||
}
|
||||
|
||||
void MemoryManager::flush_tlb(LinearAddress laddr)
|
||||
void MemoryManager::flush_tlb(VirtualAddress vaddr)
|
||||
{
|
||||
asm volatile("invlpg %0"
|
||||
:
|
||||
: "m"(*(char*)laddr.get())
|
||||
: "m"(*(char*)vaddr.get())
|
||||
: "memory");
|
||||
}
|
||||
|
||||
void MemoryManager::map_for_kernel(LinearAddress laddr, PhysicalAddress paddr)
|
||||
void MemoryManager::map_for_kernel(VirtualAddress vaddr, PhysicalAddress paddr)
|
||||
{
|
||||
auto pte = ensure_pte(kernel_page_directory(), laddr);
|
||||
auto pte = ensure_pte(kernel_page_directory(), vaddr);
|
||||
pte.set_physical_page_base(paddr.get());
|
||||
pte.set_present(true);
|
||||
pte.set_writable(true);
|
||||
pte.set_user_allowed(false);
|
||||
flush_tlb(laddr);
|
||||
flush_tlb(vaddr);
|
||||
}
|
||||
|
||||
byte* MemoryManager::quickmap_page(PhysicalPage& physical_page)
|
||||
|
|
@ -485,35 +485,35 @@ byte* MemoryManager::quickmap_page(PhysicalPage& physical_page)
|
|||
ASSERT_INTERRUPTS_DISABLED();
|
||||
ASSERT(!m_quickmap_in_use);
|
||||
m_quickmap_in_use = true;
|
||||
auto page_laddr = m_quickmap_addr;
|
||||
auto pte = ensure_pte(kernel_page_directory(), page_laddr);
|
||||
auto page_vaddr = m_quickmap_addr;
|
||||
auto pte = ensure_pte(kernel_page_directory(), page_vaddr);
|
||||
pte.set_physical_page_base(physical_page.paddr().get());
|
||||
pte.set_present(true);
|
||||
pte.set_writable(true);
|
||||
pte.set_user_allowed(false);
|
||||
flush_tlb(page_laddr);
|
||||
flush_tlb(page_vaddr);
|
||||
ASSERT((dword)pte.physical_page_base() == physical_page.paddr().get());
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: >> quickmap_page L%x => P%x @ PTE=%p\n", page_laddr, physical_page.paddr().get(), pte.ptr());
|
||||
dbgprintf("MM: >> quickmap_page L%x => P%x @ PTE=%p\n", page_vaddr, physical_page.paddr().get(), pte.ptr());
|
||||
#endif
|
||||
return page_laddr.as_ptr();
|
||||
return page_vaddr.as_ptr();
|
||||
}
|
||||
|
||||
void MemoryManager::unquickmap_page()
|
||||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
ASSERT(m_quickmap_in_use);
|
||||
auto page_laddr = m_quickmap_addr;
|
||||
auto pte = ensure_pte(kernel_page_directory(), page_laddr);
|
||||
auto page_vaddr = m_quickmap_addr;
|
||||
auto pte = ensure_pte(kernel_page_directory(), page_vaddr);
|
||||
#ifdef MM_DEBUG
|
||||
auto old_physical_address = pte.physical_page_base();
|
||||
#endif
|
||||
pte.set_physical_page_base(0);
|
||||
pte.set_present(false);
|
||||
pte.set_writable(false);
|
||||
flush_tlb(page_laddr);
|
||||
flush_tlb(page_vaddr);
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: >> unquickmap_page L%x =/> P%x\n", page_laddr, old_physical_address);
|
||||
dbgprintf("MM: >> unquickmap_page L%x =/> P%x\n", page_vaddr, old_physical_address);
|
||||
#endif
|
||||
m_quickmap_in_use = false;
|
||||
}
|
||||
|
|
@ -522,8 +522,8 @@ void MemoryManager::remap_region_page(Region& region, unsigned page_index_in_reg
|
|||
{
|
||||
ASSERT(region.page_directory());
|
||||
InterruptDisabler disabler;
|
||||
auto page_laddr = region.laddr().offset(page_index_in_region * PAGE_SIZE);
|
||||
auto pte = ensure_pte(*region.page_directory(), page_laddr);
|
||||
auto page_vaddr = region.vaddr().offset(page_index_in_region * PAGE_SIZE);
|
||||
auto pte = ensure_pte(*region.page_directory(), page_vaddr);
|
||||
auto& physical_page = region.vmo().physical_pages()[page_index_in_region];
|
||||
ASSERT(physical_page);
|
||||
pte.set_physical_page_base(physical_page->paddr().get());
|
||||
|
|
@ -535,9 +535,9 @@ void MemoryManager::remap_region_page(Region& region, unsigned page_index_in_reg
|
|||
pte.set_cache_disabled(!region.vmo().m_allow_cpu_caching);
|
||||
pte.set_write_through(!region.vmo().m_allow_cpu_caching);
|
||||
pte.set_user_allowed(user_allowed);
|
||||
region.page_directory()->flush(page_laddr);
|
||||
region.page_directory()->flush(page_vaddr);
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: >> remap_region_page (PD=%x, PTE=P%x) '%s' L%x => P%x (@%p)\n", region.page_directory()->cr3(), pte.ptr(), region.name().characters(), page_laddr.get(), physical_page->paddr().get(), physical_page.ptr());
|
||||
dbgprintf("MM: >> remap_region_page (PD=%x, PTE=P%x) '%s' L%x => P%x (@%p)\n", region.page_directory()->cr3(), pte.ptr(), region.name().characters(), page_vaddr.get(), physical_page->paddr().get(), physical_page.ptr());
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -545,10 +545,10 @@ void MemoryManager::remap_region(PageDirectory& page_directory, Region& region)
|
|||
{
|
||||
InterruptDisabler disabler;
|
||||
ASSERT(region.page_directory() == &page_directory);
|
||||
map_region_at_address(page_directory, region, region.laddr(), true);
|
||||
map_region_at_address(page_directory, region, region.vaddr(), true);
|
||||
}
|
||||
|
||||
void MemoryManager::map_region_at_address(PageDirectory& page_directory, Region& region, LinearAddress laddr, bool user_allowed)
|
||||
void MemoryManager::map_region_at_address(PageDirectory& page_directory, Region& region, VirtualAddress vaddr, bool user_allowed)
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
region.set_page_directory(page_directory);
|
||||
|
|
@ -557,8 +557,8 @@ void MemoryManager::map_region_at_address(PageDirectory& page_directory, Region&
|
|||
dbgprintf("MM: map_region_at_address will map VMO pages %u - %u (VMO page count: %u)\n", region.first_page_index(), region.last_page_index(), vmo.page_count());
|
||||
#endif
|
||||
for (size_t i = 0; i < region.page_count(); ++i) {
|
||||
auto page_laddr = laddr.offset(i * PAGE_SIZE);
|
||||
auto pte = ensure_pte(page_directory, page_laddr);
|
||||
auto page_vaddr = vaddr.offset(i * PAGE_SIZE);
|
||||
auto pte = ensure_pte(page_directory, page_vaddr);
|
||||
auto& physical_page = vmo.physical_pages()[region.first_page_index() + i];
|
||||
if (physical_page) {
|
||||
pte.set_physical_page_base(physical_page->paddr().get());
|
||||
|
|
@ -576,9 +576,9 @@ void MemoryManager::map_region_at_address(PageDirectory& page_directory, Region&
|
|||
pte.set_writable(region.is_writable());
|
||||
}
|
||||
pte.set_user_allowed(user_allowed);
|
||||
page_directory.flush(page_laddr);
|
||||
page_directory.flush(page_vaddr);
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: >> map_region_at_address (PD=%x) '%s' L%x => P%x (@%p)\n", &page_directory, region.name().characters(), page_laddr, physical_page ? physical_page->paddr().get() : 0, physical_page.ptr());
|
||||
dbgprintf("MM: >> map_region_at_address (PD=%x) '%s' L%x => P%x (@%p)\n", &page_directory, region.name().characters(), page_vaddr, physical_page ? physical_page->paddr().get() : 0, physical_page.ptr());
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
@ -588,16 +588,16 @@ bool MemoryManager::unmap_region(Region& region)
|
|||
ASSERT(region.page_directory());
|
||||
InterruptDisabler disabler;
|
||||
for (size_t i = 0; i < region.page_count(); ++i) {
|
||||
auto laddr = region.laddr().offset(i * PAGE_SIZE);
|
||||
auto pte = ensure_pte(*region.page_directory(), laddr);
|
||||
auto vaddr = region.vaddr().offset(i * PAGE_SIZE);
|
||||
auto pte = ensure_pte(*region.page_directory(), vaddr);
|
||||
pte.set_physical_page_base(0);
|
||||
pte.set_present(false);
|
||||
pte.set_writable(false);
|
||||
pte.set_user_allowed(false);
|
||||
region.page_directory()->flush(laddr);
|
||||
region.page_directory()->flush(vaddr);
|
||||
#ifdef MM_DEBUG
|
||||
auto& physical_page = region.vmo().physical_pages()[region.first_page_index() + i];
|
||||
dbgprintf("MM: >> Unmapped L%x => P%x <<\n", laddr, physical_page ? physical_page->paddr().get() : 0);
|
||||
dbgprintf("MM: >> Unmapped L%x => P%x <<\n", vaddr, physical_page ? physical_page->paddr().get() : 0);
|
||||
#endif
|
||||
}
|
||||
region.release_page_directory();
|
||||
|
|
@ -606,19 +606,19 @@ bool MemoryManager::unmap_region(Region& region)
|
|||
|
||||
bool MemoryManager::map_region(Process& process, Region& region)
|
||||
{
|
||||
map_region_at_address(process.page_directory(), region, region.laddr(), true);
|
||||
map_region_at_address(process.page_directory(), region, region.vaddr(), true);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool MemoryManager::validate_user_read(const Process& process, LinearAddress laddr) const
|
||||
bool MemoryManager::validate_user_read(const Process& process, VirtualAddress vaddr) const
|
||||
{
|
||||
auto* region = region_from_laddr(process, laddr);
|
||||
auto* region = region_from_vaddr(process, vaddr);
|
||||
return region && region->is_readable();
|
||||
}
|
||||
|
||||
bool MemoryManager::validate_user_write(const Process& process, LinearAddress laddr) const
|
||||
bool MemoryManager::validate_user_write(const Process& process, VirtualAddress vaddr) const
|
||||
{
|
||||
auto* region = region_from_laddr(process, laddr);
|
||||
auto* region = region_from_vaddr(process, vaddr);
|
||||
return region && region->is_writable();
|
||||
}
|
||||
|
||||
|
|
@ -637,7 +637,7 @@ void MemoryManager::unregister_vmo(VMObject& vmo)
|
|||
void MemoryManager::register_region(Region& region)
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
if (region.laddr().get() >= 0xc0000000)
|
||||
if (region.vaddr().get() >= 0xc0000000)
|
||||
m_kernel_regions.set(®ion);
|
||||
else
|
||||
m_user_regions.set(®ion);
|
||||
|
|
@ -646,7 +646,7 @@ void MemoryManager::register_region(Region& region)
|
|||
void MemoryManager::unregister_region(Region& region)
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
if (region.laddr().get() >= 0xc0000000)
|
||||
if (region.vaddr().get() >= 0xc0000000)
|
||||
m_kernel_regions.remove(®ion);
|
||||
else
|
||||
m_user_regions.remove(®ion);
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
#include <AK/Vector.h>
|
||||
#include <AK/Weakable.h>
|
||||
#include <Kernel/FileSystem/InodeIdentifier.h>
|
||||
#include <Kernel/LinearAddress.h>
|
||||
#include <Kernel/VirtualAddress.h>
|
||||
#include <Kernel/VM/PhysicalPage.h>
|
||||
#include <Kernel/VM/Region.h>
|
||||
#include <Kernel/VM/VMObject.h>
|
||||
|
|
@ -52,8 +52,8 @@ public:
|
|||
|
||||
void enter_process_paging_scope(Process&);
|
||||
|
||||
bool validate_user_read(const Process&, LinearAddress) const;
|
||||
bool validate_user_write(const Process&, LinearAddress) const;
|
||||
bool validate_user_read(const Process&, VirtualAddress) const;
|
||||
bool validate_user_write(const Process&, VirtualAddress) const;
|
||||
|
||||
enum class ShouldZeroFill
|
||||
{
|
||||
|
|
@ -71,10 +71,10 @@ public:
|
|||
int user_physical_pages_in_existence() const { return s_user_physical_pages_in_existence; }
|
||||
int super_physical_pages_in_existence() const { return s_super_physical_pages_in_existence; }
|
||||
|
||||
void map_for_kernel(LinearAddress, PhysicalAddress);
|
||||
void map_for_kernel(VirtualAddress, PhysicalAddress);
|
||||
|
||||
RetainPtr<Region> allocate_kernel_region(size_t, String&& name);
|
||||
void map_region_at_address(PageDirectory&, Region&, LinearAddress, bool user_accessible);
|
||||
void map_region_at_address(PageDirectory&, Region&, VirtualAddress, bool user_accessible);
|
||||
|
||||
private:
|
||||
MemoryManager();
|
||||
|
|
@ -89,17 +89,17 @@ private:
|
|||
|
||||
void initialize_paging();
|
||||
void flush_entire_tlb();
|
||||
void flush_tlb(LinearAddress);
|
||||
void flush_tlb(VirtualAddress);
|
||||
|
||||
RetainPtr<PhysicalPage> allocate_page_table(PageDirectory&, unsigned index);
|
||||
|
||||
void map_protected(LinearAddress, size_t length);
|
||||
void map_protected(VirtualAddress, size_t length);
|
||||
|
||||
void create_identity_mapping(PageDirectory&, LinearAddress, size_t length);
|
||||
void remove_identity_mapping(PageDirectory&, LinearAddress, size_t);
|
||||
void create_identity_mapping(PageDirectory&, VirtualAddress, size_t length);
|
||||
void remove_identity_mapping(PageDirectory&, VirtualAddress, size_t);
|
||||
|
||||
static Region* region_from_laddr(Process&, LinearAddress);
|
||||
static const Region* region_from_laddr(const Process&, LinearAddress);
|
||||
static Region* region_from_vaddr(Process&, VirtualAddress);
|
||||
static const Region* region_from_vaddr(const Process&, VirtualAddress);
|
||||
|
||||
bool copy_on_write(Region&, unsigned page_index_in_region);
|
||||
bool page_in_from_inode(Region&, unsigned page_index_in_region);
|
||||
|
|
@ -215,12 +215,12 @@ private:
|
|||
static unsigned s_user_physical_pages_in_existence;
|
||||
static unsigned s_super_physical_pages_in_existence;
|
||||
|
||||
PageTableEntry ensure_pte(PageDirectory&, LinearAddress);
|
||||
PageTableEntry ensure_pte(PageDirectory&, VirtualAddress);
|
||||
|
||||
RetainPtr<PageDirectory> m_kernel_page_directory;
|
||||
dword* m_page_table_zero;
|
||||
|
||||
LinearAddress m_quickmap_addr;
|
||||
VirtualAddress m_quickmap_addr;
|
||||
|
||||
Vector<Retained<PhysicalPage>> m_free_physical_pages;
|
||||
Vector<Retained<PhysicalPage>> m_free_supervisor_physical_pages;
|
||||
|
|
|
|||
|
|
@ -7,13 +7,13 @@ static const dword userspace_range_base = 0x01000000;
|
|||
static const dword kernelspace_range_base = 0xc0000000;
|
||||
|
||||
PageDirectory::PageDirectory(PhysicalAddress paddr)
|
||||
: m_range_allocator(LinearAddress(0xc0000000), 0x3f000000)
|
||||
: m_range_allocator(VirtualAddress(0xc0000000), 0x3f000000)
|
||||
{
|
||||
m_directory_page = PhysicalPage::create_eternal(paddr, true);
|
||||
}
|
||||
|
||||
PageDirectory::PageDirectory(const RangeAllocator* parent_range_allocator)
|
||||
: m_range_allocator(parent_range_allocator ? RangeAllocator(*parent_range_allocator) : RangeAllocator(LinearAddress(userspace_range_base), kernelspace_range_base - userspace_range_base))
|
||||
: m_range_allocator(parent_range_allocator ? RangeAllocator(*parent_range_allocator) : RangeAllocator(VirtualAddress(userspace_range_base), kernelspace_range_base - userspace_range_base))
|
||||
{
|
||||
MM.populate_page_directory(*this);
|
||||
}
|
||||
|
|
@ -25,13 +25,13 @@ PageDirectory::~PageDirectory()
|
|||
#endif
|
||||
}
|
||||
|
||||
void PageDirectory::flush(LinearAddress laddr)
|
||||
void PageDirectory::flush(VirtualAddress vaddr)
|
||||
{
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: Flush page L%x\n", laddr.get());
|
||||
dbgprintf("MM: Flush page L%x\n", vaddr.get());
|
||||
#endif
|
||||
if (!current)
|
||||
return;
|
||||
if (this == &MM.kernel_page_directory() || ¤t->process().page_directory() == this)
|
||||
MM.flush_tlb(laddr);
|
||||
MM.flush_tlb(vaddr);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ public:
|
|||
dword cr3() const { return m_directory_page->paddr().get(); }
|
||||
dword* entries() { return reinterpret_cast<dword*>(cr3()); }
|
||||
|
||||
void flush(LinearAddress);
|
||||
void flush(VirtualAddress);
|
||||
|
||||
RangeAllocator& range_allocator() { return m_range_allocator; }
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
//#define VRA_DEBUG
|
||||
|
||||
RangeAllocator::RangeAllocator(LinearAddress base, size_t size)
|
||||
RangeAllocator::RangeAllocator(VirtualAddress base, size_t size)
|
||||
{
|
||||
m_available_ranges.append({ base, size });
|
||||
#ifdef VRA_DEBUG
|
||||
|
|
@ -82,7 +82,7 @@ Range RangeAllocator::allocate_anywhere(size_t size)
|
|||
return {};
|
||||
}
|
||||
|
||||
Range RangeAllocator::allocate_specific(LinearAddress base, size_t size)
|
||||
Range RangeAllocator::allocate_specific(VirtualAddress base, size_t size)
|
||||
{
|
||||
Range allocated_range(base, size);
|
||||
for (int i = 0; i < m_available_ranges.size(); ++i) {
|
||||
|
|
|
|||
|
|
@ -1,33 +1,33 @@
|
|||
#pragma once
|
||||
|
||||
#include <AK/Vector.h>
|
||||
#include <Kernel/LinearAddress.h>
|
||||
#include <Kernel/VirtualAddress.h>
|
||||
|
||||
class Range {
|
||||
friend class RangeAllocator;
|
||||
|
||||
public:
|
||||
Range() {}
|
||||
Range(LinearAddress base, size_t size)
|
||||
Range(VirtualAddress base, size_t size)
|
||||
: m_base(base)
|
||||
, m_size(size)
|
||||
{
|
||||
}
|
||||
|
||||
LinearAddress base() const { return m_base; }
|
||||
VirtualAddress base() const { return m_base; }
|
||||
size_t size() const { return m_size; }
|
||||
bool is_valid() const { return !m_base.is_null(); }
|
||||
|
||||
bool contains(LinearAddress laddr) const { return laddr >= base() && laddr < end(); }
|
||||
bool contains(VirtualAddress vaddr) const { return vaddr >= base() && vaddr < end(); }
|
||||
|
||||
LinearAddress end() const { return m_base.offset(m_size); }
|
||||
VirtualAddress end() const { return m_base.offset(m_size); }
|
||||
|
||||
bool operator==(const Range& other) const
|
||||
{
|
||||
return m_base == other.m_base && m_size == other.m_size;
|
||||
}
|
||||
|
||||
bool contains(LinearAddress base, size_t size) const
|
||||
bool contains(VirtualAddress base, size_t size) const
|
||||
{
|
||||
return base >= m_base && base.offset(size) <= end();
|
||||
}
|
||||
|
|
@ -40,18 +40,18 @@ public:
|
|||
Vector<Range, 2> carve(const Range&);
|
||||
|
||||
private:
|
||||
LinearAddress m_base;
|
||||
VirtualAddress m_base;
|
||||
size_t m_size { 0 };
|
||||
};
|
||||
|
||||
class RangeAllocator {
|
||||
public:
|
||||
RangeAllocator(LinearAddress, size_t);
|
||||
RangeAllocator(VirtualAddress, size_t);
|
||||
RangeAllocator(const RangeAllocator&);
|
||||
~RangeAllocator();
|
||||
|
||||
Range allocate_anywhere(size_t);
|
||||
Range allocate_specific(LinearAddress, size_t);
|
||||
Range allocate_specific(VirtualAddress, size_t);
|
||||
void deallocate(Range);
|
||||
|
||||
void dump() const;
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ Retained<Region> Region::clone()
|
|||
current->process().name().characters(),
|
||||
current->pid(),
|
||||
m_name.characters(),
|
||||
laddr().get());
|
||||
vaddr().get());
|
||||
#endif
|
||||
// Create a new region backed by the same VMObject.
|
||||
return adopt(*new Region(m_range, m_vmo.copy_ref(), m_offset_in_vmo, String(m_name), m_access));
|
||||
|
|
@ -86,7 +86,7 @@ Retained<Region> Region::clone()
|
|||
current->process().name().characters(),
|
||||
current->pid(),
|
||||
m_name.characters(),
|
||||
laddr().get());
|
||||
vaddr().get());
|
||||
#endif
|
||||
// Set up a COW region. The parent (this) region becomes COW as well!
|
||||
m_cow_map.fill(true);
|
||||
|
|
@ -98,7 +98,7 @@ int Region::commit()
|
|||
{
|
||||
InterruptDisabler disabler;
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: commit %u pages in Region %p (VMO=%p) at L%x\n", vmo().page_count(), this, &vmo(), laddr().get());
|
||||
dbgprintf("MM: commit %u pages in Region %p (VMO=%p) at L%x\n", vmo().page_count(), this, &vmo(), vaddr().get());
|
||||
#endif
|
||||
for (size_t i = first_page_index(); i <= last_page_index(); ++i) {
|
||||
if (!vmo().physical_pages()[i].is_null())
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ public:
|
|||
Region(const Range&, RetainPtr<Inode>&&, String&&, byte access);
|
||||
~Region();
|
||||
|
||||
LinearAddress laddr() const { return m_range.base(); }
|
||||
VirtualAddress vaddr() const { return m_range.base(); }
|
||||
size_t size() const { return m_range.size(); }
|
||||
bool is_readable() const { return m_access & Access::Read; }
|
||||
bool is_writable() const { return m_access & Access::Write; }
|
||||
|
|
@ -41,14 +41,14 @@ public:
|
|||
|
||||
Retained<Region> clone();
|
||||
|
||||
bool contains(LinearAddress laddr) const
|
||||
bool contains(VirtualAddress vaddr) const
|
||||
{
|
||||
return m_range.contains(laddr);
|
||||
return m_range.contains(vaddr);
|
||||
}
|
||||
|
||||
unsigned page_index_from_address(LinearAddress laddr) const
|
||||
unsigned page_index_from_address(VirtualAddress vaddr) const
|
||||
{
|
||||
return (laddr - m_range.base()).get() / PAGE_SIZE;
|
||||
return (vaddr - m_range.base()).get() / PAGE_SIZE;
|
||||
}
|
||||
|
||||
size_t first_page_index() const
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue