1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-24 22:17:42 +00:00

Kernel: Finally stop exposing Region members to the public.

This commit is contained in:
Andreas Kling 2019-01-24 18:09:46 +01:00
parent e683f611f1
commit aa24547e12
9 changed files with 132 additions and 106 deletions

View file

@ -164,12 +164,12 @@ auto MemoryManager::ensure_pte(PageDirectory& page_directory, LinearAddress ladd
return PageTableEntry(&pde.pageTableBase()[page_table_index]); return PageTableEntry(&pde.pageTableBase()[page_table_index]);
} }
void MemoryManager::map_protected(LinearAddress linearAddress, size_t length) void MemoryManager::map_protected(LinearAddress laddr, size_t length)
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
// FIXME: ASSERT(linearAddress is 4KB aligned); // FIXME: ASSERT(linearAddress is 4KB aligned);
for (dword offset = 0; offset < length; offset += PAGE_SIZE) { for (dword offset = 0; offset < length; offset += PAGE_SIZE) {
auto pteAddress = linearAddress.offset(offset); auto pteAddress = laddr.offset(offset);
auto pte = ensure_pte(kernel_page_directory(), pteAddress); auto pte = ensure_pte(kernel_page_directory(), pteAddress);
pte.set_physical_page_base(pteAddress.get()); pte.set_physical_page_base(pteAddress.get());
pte.set_user_allowed(false); pte.set_user_allowed(false);
@ -223,7 +223,7 @@ bool MemoryManager::zero_page(Region& region, unsigned page_index_in_region)
dbgprintf(" >> ZERO P%x\n", physical_page->paddr().get()); dbgprintf(" >> ZERO P%x\n", physical_page->paddr().get());
#endif #endif
unquickmap_page(); unquickmap_page();
region.cow_map.set(page_index_in_region, false); region.m_cow_map.set(page_index_in_region, false);
vmo.physical_pages()[page_index_in_region] = move(physical_page); vmo.physical_pages()[page_index_in_region] = move(physical_page);
remap_region_page(region, page_index_in_region, true); remap_region_page(region, page_index_in_region, true);
return true; return true;
@ -237,7 +237,7 @@ bool MemoryManager::copy_on_write(Region& region, unsigned page_index_in_region)
#ifdef PAGE_FAULT_DEBUG #ifdef PAGE_FAULT_DEBUG
dbgprintf(" >> It's a COW page but nobody is sharing it anymore. Remap r/w\n"); dbgprintf(" >> It's a COW page but nobody is sharing it anymore. Remap r/w\n");
#endif #endif
region.cow_map.set(page_index_in_region, false); region.m_cow_map.set(page_index_in_region, false);
remap_region_page(region, page_index_in_region, true); remap_region_page(region, page_index_in_region, true);
return true; return true;
} }
@ -248,14 +248,14 @@ 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_to_copy = move(vmo.physical_pages()[page_index_in_region]);
auto physical_page = allocate_physical_page(); auto physical_page = allocate_physical_page();
byte* dest_ptr = quickmap_page(*physical_page); byte* dest_ptr = quickmap_page(*physical_page);
const byte* src_ptr = region.linearAddress.offset(page_index_in_region * PAGE_SIZE).asPtr(); const byte* src_ptr = region.laddr().offset(page_index_in_region * PAGE_SIZE).as_ptr();
#ifdef PAGE_FAULT_DEBUG #ifdef PAGE_FAULT_DEBUG
dbgprintf(" >> COW P%x <- P%x\n", physical_page->paddr().get(), physical_page_to_copy->paddr().get()); dbgprintf(" >> COW P%x <- P%x\n", physical_page->paddr().get(), physical_page_to_copy->paddr().get());
#endif #endif
memcpy(dest_ptr, src_ptr, PAGE_SIZE); memcpy(dest_ptr, src_ptr, PAGE_SIZE);
vmo.physical_pages()[page_index_in_region] = move(physical_page); vmo.physical_pages()[page_index_in_region] = move(physical_page);
unquickmap_page(); unquickmap_page();
region.cow_map.set(page_index_in_region, false); region.m_cow_map.set(page_index_in_region, false);
remap_region_page(region, page_index_in_region, true); remap_region_page(region, page_index_in_region, true);
return true; return true;
} }
@ -282,7 +282,7 @@ bool Region::page_in()
bool MemoryManager::page_in_from_inode(Region& region, unsigned page_index_in_region) bool MemoryManager::page_in_from_inode(Region& region, unsigned page_index_in_region)
{ {
ASSERT(region.m_page_directory); ASSERT(region.page_directory());
auto& vmo = region.vmo(); auto& vmo = region.vmo();
ASSERT(!vmo.is_anonymous()); ASSERT(!vmo.is_anonymous());
ASSERT(vmo.inode()); ASSERT(vmo.inode());
@ -295,7 +295,7 @@ bool MemoryManager::page_in_from_inode(Region& region, unsigned page_index_in_re
return false; return false;
} }
remap_region_page(region, page_index_in_region, true); remap_region_page(region, page_index_in_region, true);
byte* dest_ptr = region.linearAddress.offset(page_index_in_region * PAGE_SIZE).asPtr(); byte* dest_ptr = region.laddr().offset(page_index_in_region * PAGE_SIZE).as_ptr();
#ifdef MM_DEBUG #ifdef MM_DEBUG
dbgprintf("MM: page_in_from_inode ready to read from inode, will write to L%x!\n", dest_ptr); dbgprintf("MM: page_in_from_inode ready to read from inode, will write to L%x!\n", dest_ptr);
#endif #endif
@ -337,7 +337,7 @@ PageFaultResponse MemoryManager::handle_page_fault(const PageFault& fault)
return PageFaultResponse::Continue; return PageFaultResponse::Continue;
} }
} else if (fault.is_protection_violation()) { } else if (fault.is_protection_violation()) {
if (region->cow_map.get(page_index_in_region)) { if (region->m_cow_map.get(page_index_in_region)) {
dbgprintf("PV(cow) fault in Region{%p}[%u]\n", region, page_index_in_region); dbgprintf("PV(cow) fault in Region{%p}[%u]\n", region, page_index_in_region);
bool success = copy_on_write(*region, page_index_in_region); bool success = copy_on_write(*region, page_index_in_region);
ASSERT(success); ASSERT(success);
@ -406,7 +406,7 @@ byte* MemoryManager::quickmap_page(PhysicalPage& physical_page)
#ifdef MM_DEBUG #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_laddr, physical_page.paddr().get(), pte.ptr());
#endif #endif
return page_laddr.asPtr(); return page_laddr.as_ptr();
} }
void MemoryManager::unquickmap_page() void MemoryManager::unquickmap_page()
@ -428,35 +428,35 @@ void MemoryManager::unquickmap_page()
void MemoryManager::remap_region_page(Region& region, unsigned page_index_in_region, bool user_allowed) void MemoryManager::remap_region_page(Region& region, unsigned page_index_in_region, bool user_allowed)
{ {
ASSERT(region.m_page_directory); ASSERT(region.page_directory());
InterruptDisabler disabler; InterruptDisabler disabler;
auto page_laddr = region.linearAddress.offset(page_index_in_region * PAGE_SIZE); auto page_laddr = region.laddr().offset(page_index_in_region * PAGE_SIZE);
auto pte = ensure_pte(*region.m_page_directory, page_laddr); auto pte = ensure_pte(*region.page_directory(), page_laddr);
auto& physical_page = region.vmo().physical_pages()[page_index_in_region]; auto& physical_page = region.vmo().physical_pages()[page_index_in_region];
ASSERT(physical_page); ASSERT(physical_page);
pte.set_physical_page_base(physical_page->paddr().get()); pte.set_physical_page_base(physical_page->paddr().get());
pte.set_present(true); // FIXME: Maybe we should use the is_readable flag here? pte.set_present(true); // FIXME: Maybe we should use the is_readable flag here?
if (region.cow_map.get(page_index_in_region)) if (region.m_cow_map.get(page_index_in_region))
pte.set_writable(false); pte.set_writable(false);
else else
pte.set_writable(region.is_writable); pte.set_writable(region.is_writable());
pte.set_user_allowed(user_allowed); pte.set_user_allowed(user_allowed);
region.m_page_directory->flush(page_laddr); region.page_directory()->flush(page_laddr);
#ifdef MM_DEBUG #ifdef MM_DEBUG
dbgprintf("MM: >> remap_region_page (PD=%x, PTE=P%x) '%s' L%x => P%x (@%p)\n", region.m_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_laddr.get(), physical_page->paddr().get(), physical_page.ptr());
#endif #endif
} }
void MemoryManager::remap_region(Process& process, Region& region) void MemoryManager::remap_region(Process& process, Region& region)
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
map_region_at_address(process.page_directory(), region, region.linearAddress, true); map_region_at_address(process.page_directory(), region, region.laddr(), 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, LinearAddress laddr, bool user_allowed)
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
region.m_page_directory = page_directory; region.set_page_directory(page_directory);
auto& vmo = region.vmo(); auto& vmo = region.vmo();
#ifdef MM_DEBUG #ifdef MM_DEBUG
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()); 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());
@ -469,14 +469,14 @@ void MemoryManager::map_region_at_address(PageDirectory& page_directory, Region&
pte.set_physical_page_base(physical_page->paddr().get()); pte.set_physical_page_base(physical_page->paddr().get());
pte.set_present(true); // FIXME: Maybe we should use the is_readable flag here? pte.set_present(true); // FIXME: Maybe we should use the is_readable flag here?
// FIXME: It seems wrong that the *region* cow map is essentially using *VMO* relative indices. // FIXME: It seems wrong that the *region* cow map is essentially using *VMO* relative indices.
if (region.cow_map.get(region.first_page_index() + i)) if (region.m_cow_map.get(region.first_page_index() + i))
pte.set_writable(false); pte.set_writable(false);
else else
pte.set_writable(region.is_writable); pte.set_writable(region.is_writable());
} else { } else {
pte.set_physical_page_base(0); pte.set_physical_page_base(0);
pte.set_present(false); pte.set_present(false);
pte.set_writable(region.is_writable); pte.set_writable(region.is_writable());
} }
pte.set_user_allowed(user_allowed); pte.set_user_allowed(user_allowed);
page_directory.flush(page_laddr); page_directory.flush(page_laddr);
@ -488,28 +488,28 @@ void MemoryManager::map_region_at_address(PageDirectory& page_directory, Region&
bool MemoryManager::unmap_region(Region& region) bool MemoryManager::unmap_region(Region& region)
{ {
ASSERT(region.m_page_directory); ASSERT(region.page_directory());
InterruptDisabler disabler; InterruptDisabler disabler;
for (size_t i = 0; i < region.page_count(); ++i) { for (size_t i = 0; i < region.page_count(); ++i) {
auto laddr = region.linearAddress.offset(i * PAGE_SIZE); auto laddr = region.laddr().offset(i * PAGE_SIZE);
auto pte = ensure_pte(*region.m_page_directory, laddr); auto pte = ensure_pte(*region.page_directory(), laddr);
pte.set_physical_page_base(0); pte.set_physical_page_base(0);
pte.set_present(false); pte.set_present(false);
pte.set_writable(false); pte.set_writable(false);
pte.set_user_allowed(false); pte.set_user_allowed(false);
region.m_page_directory->flush(laddr); region.page_directory()->flush(laddr);
#ifdef MM_DEBUG #ifdef MM_DEBUG
auto& physical_page = region.vmo().physical_pages()[region.first_page_index() + i]; 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", laddr, physical_page ? physical_page->paddr().get() : 0);
#endif #endif
} }
region.m_page_directory.clear(); region.release_page_directory();
return true; return true;
} }
bool MemoryManager::map_region(Process& process, Region& region) bool MemoryManager::map_region(Process& process, Region& region)
{ {
map_region_at_address(process.page_directory(), region, region.linearAddress, true); map_region_at_address(process.page_directory(), region, region.laddr(), true);
return true; return true;
} }
@ -549,57 +549,57 @@ RetainPtr<Region> Region::clone()
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
if (m_shared || (is_readable && !is_writable)) { if (m_shared || (m_readable && !m_writable)) {
// Create a new region backed by the same VMObject. // Create a new region backed by the same VMObject.
return adopt(*new Region(linearAddress, size, m_vmo.copyRef(), m_offset_in_vmo, String(name), is_readable, is_writable)); return adopt(*new Region(laddr(), size(), m_vmo.copyRef(), m_offset_in_vmo, String(m_name), m_readable, m_writable));
} }
dbgprintf("%s<%u> Region::clone(): cowing %s (L%x)\n", dbgprintf("%s<%u> Region::clone(): cowing %s (L%x)\n",
current->name().characters(), current->name().characters(),
current->pid(), current->pid(),
name.characters(), m_name.characters(),
linearAddress.get()); laddr().get());
// Set up a COW region. The parent (this) region becomes COW as well! // Set up a COW region. The parent (this) region becomes COW as well!
for (size_t i = 0; i < page_count(); ++i) for (size_t i = 0; i < page_count(); ++i)
cow_map.set(i, true); m_cow_map.set(i, true);
MM.remap_region(*current, *this); MM.remap_region(*current, *this);
return adopt(*new Region(linearAddress, size, m_vmo->clone(), m_offset_in_vmo, String(name), is_readable, is_writable, true)); return adopt(*new Region(laddr(), size(), m_vmo->clone(), m_offset_in_vmo, String(m_name), m_readable, m_writable, true));
} }
Region::Region(LinearAddress a, size_t s, String&& n, bool r, bool w, bool cow) Region::Region(LinearAddress a, size_t s, String&& n, bool r, bool w, bool cow)
: linearAddress(a) : m_laddr(a)
, size(s) , m_size(s)
, m_vmo(VMObject::create_anonymous(s)) , m_vmo(VMObject::create_anonymous(s))
, name(move(n)) , m_name(move(n))
, is_readable(r) , m_readable(r)
, is_writable(w) , m_writable(w)
, cow_map(Bitmap::create(m_vmo->page_count(), cow)) , m_cow_map(Bitmap::create(m_vmo->page_count(), cow))
{ {
m_vmo->set_name(name); m_vmo->set_name(m_name);
MM.register_region(*this); MM.register_region(*this);
} }
Region::Region(LinearAddress a, size_t s, RetainPtr<Inode>&& inode, String&& n, bool r, bool w) Region::Region(LinearAddress a, size_t s, RetainPtr<Inode>&& inode, String&& n, bool r, bool w)
: linearAddress(a) : m_laddr(a)
, size(s) , m_size(s)
, m_vmo(VMObject::create_file_backed(move(inode), s)) , m_vmo(VMObject::create_file_backed(move(inode), s))
, name(move(n)) , m_name(move(n))
, is_readable(r) , m_readable(r)
, is_writable(w) , m_writable(w)
, cow_map(Bitmap::create(m_vmo->page_count())) , m_cow_map(Bitmap::create(m_vmo->page_count()))
{ {
MM.register_region(*this); MM.register_region(*this);
} }
Region::Region(LinearAddress a, size_t s, RetainPtr<VMObject>&& vmo, size_t offset_in_vmo, String&& n, bool r, bool w, bool cow) Region::Region(LinearAddress a, size_t s, RetainPtr<VMObject>&& vmo, size_t offset_in_vmo, String&& n, bool r, bool w, bool cow)
: linearAddress(a) : m_laddr(a)
, size(s) , m_size(s)
, m_offset_in_vmo(offset_in_vmo) , m_offset_in_vmo(offset_in_vmo)
, m_vmo(move(vmo)) , m_vmo(move(vmo))
, name(move(n)) , m_name(move(n))
, is_readable(r) , m_readable(r)
, is_writable(w) , m_writable(w)
, cow_map(Bitmap::create(m_vmo->page_count(), cow)) , m_cow_map(Bitmap::create(m_vmo->page_count(), cow))
{ {
MM.register_region(*this); MM.register_region(*this);
} }
@ -713,7 +713,7 @@ int Region::commit()
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
#ifdef MM_DEBUG #ifdef MM_DEBUG
dbgprintf("MM: commit %u pages in Region %p (VMO=%p) at L%x\n", vmo().page_count(), this, &vmo(), linearAddress.get()); dbgprintf("MM: commit %u pages in Region %p (VMO=%p) at L%x\n", vmo().page_count(), this, &vmo(), laddr.get());
#endif #endif
for (size_t i = first_page_index(); i <= last_page_index(); ++i) { for (size_t i = first_page_index(); i <= last_page_index(); ++i) {
if (!vmo().physical_pages()[i].is_null()) if (!vmo().physical_pages()[i].is_null())

View file

@ -111,12 +111,21 @@ private:
}; };
class Region : public Retainable<Region> { class Region : public Retainable<Region> {
friend class MemoryManager;
public: public:
Region(LinearAddress, size_t, String&&, bool r, bool w, bool cow = false); Region(LinearAddress, size_t, String&&, bool r, bool w, bool cow = false);
Region(LinearAddress, size_t, RetainPtr<VMObject>&&, size_t offset_in_vmo, String&&, bool r, bool w, bool cow = false); Region(LinearAddress, size_t, RetainPtr<VMObject>&&, size_t offset_in_vmo, String&&, bool r, bool w, bool cow = false);
Region(LinearAddress, size_t, RetainPtr<Inode>&&, String&&, bool r, bool w); Region(LinearAddress, size_t, RetainPtr<Inode>&&, String&&, bool r, bool w);
~Region(); ~Region();
LinearAddress laddr() const { return m_laddr; }
size_t size() const { return m_size; }
bool is_readable() const { return m_readable; }
bool is_writable() const { return m_writable; }
String name() const { return m_name; }
void set_name(String&& name) { m_name = move(name); }
const VMObject& vmo() const { return *m_vmo; } const VMObject& vmo() const { return *m_vmo; }
VMObject& vmo() { return *m_vmo; } VMObject& vmo() { return *m_vmo; }
@ -125,12 +134,12 @@ public:
RetainPtr<Region> clone(); RetainPtr<Region> clone();
bool contains(LinearAddress laddr) const bool contains(LinearAddress laddr) const
{ {
return laddr >= linearAddress && laddr < linearAddress.offset(size); return laddr >= m_laddr && laddr < m_laddr.offset(size());
} }
unsigned page_index_from_address(LinearAddress laddr) const unsigned page_index_from_address(LinearAddress laddr) const
{ {
return (laddr - linearAddress).get() / PAGE_SIZE; return (laddr - m_laddr).get() / PAGE_SIZE;
} }
size_t first_page_index() const size_t first_page_index() const
@ -145,7 +154,7 @@ public:
size_t page_count() const size_t page_count() const
{ {
return size / PAGE_SIZE; return m_size / PAGE_SIZE;
} }
bool page_in(); bool page_in();
@ -153,16 +162,33 @@ public:
size_t committed() const; size_t committed() const;
PageDirectory* page_directory() { return m_page_directory.ptr(); }
void set_page_directory(PageDirectory& page_directory)
{
ASSERT(!m_page_directory || m_page_directory.ptr() == &page_directory);
m_page_directory = page_directory;
}
void release_page_directory()
{
ASSERT(m_page_directory);
m_page_directory.clear();
}
const Bitmap& cow_map() const { return m_cow_map; }
private:
RetainPtr<PageDirectory> m_page_directory; RetainPtr<PageDirectory> m_page_directory;
LinearAddress linearAddress; LinearAddress m_laddr;
size_t size { 0 }; size_t m_size { 0 };
size_t m_offset_in_vmo { 0 }; size_t m_offset_in_vmo { 0 };
RetainPtr<VMObject> m_vmo; RetainPtr<VMObject> m_vmo;
String name; String m_name;
bool is_readable { true }; bool m_readable { true };
bool is_writable { true }; bool m_writable { true };
bool m_shared { false }; bool m_shared { false };
Bitmap cow_map; Bitmap m_cow_map;
}; };
#define MM MemoryManager::the() #define MM MemoryManager::the()

View file

@ -52,11 +52,11 @@ ByteBuffer procfs$pid_vm(Process& process)
builder.appendf("BEGIN END SIZE COMMIT NAME\n"); builder.appendf("BEGIN END SIZE COMMIT NAME\n");
for (auto& region : process.regions()) { for (auto& region : process.regions()) {
builder.appendf("%x -- %x %x %x %s\n", builder.appendf("%x -- %x %x %x %s\n",
region->linearAddress.get(), region->laddr().get(),
region->linearAddress.offset(region->size - 1).get(), region->laddr().offset(region->size() - 1).get(),
region->size, region->size(),
region->committed(), region->committed(),
region->name.characters()); region->name().characters());
} }
return builder.to_byte_buffer(); return builder.to_byte_buffer();
} }
@ -68,10 +68,10 @@ ByteBuffer procfs$pid_vmo(Process& process)
builder.appendf("BEGIN END SIZE NAME\n"); builder.appendf("BEGIN END SIZE NAME\n");
for (auto& region : process.regions()) { for (auto& region : process.regions()) {
builder.appendf("%x -- %x %x %s\n", builder.appendf("%x -- %x %x %s\n",
region->linearAddress.get(), region->laddr().get(),
region->linearAddress.offset(region->size - 1).get(), region->laddr().offset(region->size() - 1).get(),
region->size, region->size(),
region->name.characters()); region->name().characters());
builder.appendf("VMO: %s \"%s\" @ %x(%u)\n", builder.appendf("VMO: %s \"%s\" @ %x(%u)\n",
region->vmo().is_anonymous() ? "anonymous" : "file-backed", region->vmo().is_anonymous() ? "anonymous" : "file-backed",
region->vmo().name().characters(), region->vmo().name().characters(),
@ -81,7 +81,7 @@ ByteBuffer procfs$pid_vmo(Process& process)
auto& physical_page = region->vmo().physical_pages()[i]; auto& physical_page = region->vmo().physical_pages()[i];
builder.appendf("P%x%s(%u) ", builder.appendf("P%x%s(%u) ",
physical_page ? physical_page->paddr().get() : 0, physical_page ? physical_page->paddr().get() : 0,
region->cow_map.get(i) ? "!" : "", region->cow_map().get(i) ? "!" : "",
physical_page ? physical_page->retain_count() : 0 physical_page ? physical_page->retain_count() : 0
); );
} }

View file

@ -132,7 +132,7 @@ bool Process::deallocate_region(Region& region)
Region* Process::regionFromRange(LinearAddress laddr, size_t size) Region* Process::regionFromRange(LinearAddress laddr, size_t size)
{ {
for (auto& region : m_regions) { for (auto& region : m_regions) {
if (region->linearAddress == laddr && region->size == size) if (region->laddr() == laddr && region->size() == size)
return region.ptr(); return region.ptr();
} }
return nullptr; return nullptr;
@ -145,7 +145,7 @@ int Process::sys$set_mmap_name(void* addr, size_t size, const char* name)
auto* region = regionFromRange(LinearAddress((dword)addr), size); auto* region = regionFromRange(LinearAddress((dword)addr), size);
if (!region) if (!region)
return -EINVAL; return -EINVAL;
region->name = name; region->set_name(String(name));
return 0; return 0;
} }
@ -170,7 +170,7 @@ void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
auto* region = allocate_region(LinearAddress(), size, "mmap", prot & PROT_READ, prot & PROT_WRITE, false); auto* region = allocate_region(LinearAddress(), size, "mmap", prot & PROT_READ, prot & PROT_WRITE, false);
if (!region) if (!region)
return (void*)-ENOMEM; return (void*)-ENOMEM;
return region->linearAddress.asPtr(); return region->laddr().as_ptr();
} }
if (offset & ~PAGE_MASK) if (offset & ~PAGE_MASK)
return (void*)-EINVAL; return (void*)-EINVAL;
@ -187,7 +187,7 @@ void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
auto* region = allocate_file_backed_region(LinearAddress(), size, descriptor->inode(), move(region_name), prot & PROT_READ, prot & PROT_WRITE); auto* region = allocate_file_backed_region(LinearAddress(), size, descriptor->inode(), move(region_name), prot & PROT_READ, prot & PROT_WRITE);
if (!region) if (!region)
return (void*)-ENOMEM; return (void*)-ENOMEM;
return region->linearAddress.asPtr(); return region->laddr().as_ptr();
} }
int Process::sys$munmap(void* addr, size_t size) int Process::sys$munmap(void* addr, size_t size)
@ -229,7 +229,7 @@ Process* Process::fork(RegisterDump& regs)
for (auto& region : m_regions) { for (auto& region : m_regions) {
#ifdef FORK_DEBUG #ifdef FORK_DEBUG
dbgprintf("fork: cloning Region{%p} \"%s\" L%x\n", region.ptr(), region->name.characters(), region->linearAddress.get()); dbgprintf("fork: cloning Region{%p} \"%s\" L%x\n", region.ptr(), region->name.characters(), region->laddr().get());
#endif #endif
auto cloned_region = region->clone(); auto cloned_region = region->clone();
child->m_regions.append(move(cloned_region)); child->m_regions.append(move(cloned_region));
@ -324,20 +324,20 @@ int Process::do_exec(const String& path, Vector<String>&& arguments, Vector<Stri
InterruptDisabler disabler; InterruptDisabler disabler;
// Okay, here comes the sleight of hand, pay close attention.. // Okay, here comes the sleight of hand, pay close attention..
auto old_regions = move(m_regions); auto old_regions = move(m_regions);
ELFLoader loader(region->linearAddress.asPtr()); ELFLoader loader(region->laddr().as_ptr());
loader.map_section_hook = [&] (LinearAddress laddr, size_t size, size_t alignment, size_t offset_in_image, bool is_readable, bool is_writable, const String& name) { loader.map_section_hook = [&] (LinearAddress laddr, size_t size, size_t alignment, size_t offset_in_image, bool is_readable, bool is_writable, const String& name) {
ASSERT(size); ASSERT(size);
ASSERT(alignment == PAGE_SIZE); ASSERT(alignment == PAGE_SIZE);
size = ((size / 4096) + 1) * 4096; // FIXME: Use ceil_div? size = ((size / 4096) + 1) * 4096; // FIXME: Use ceil_div?
(void) allocate_region_with_vmo(laddr, size, vmo.copyRef(), offset_in_image, String(name), is_readable, is_writable); (void) allocate_region_with_vmo(laddr, size, vmo.copyRef(), offset_in_image, String(name), is_readable, is_writable);
return laddr.asPtr(); return laddr.as_ptr();
}; };
loader.alloc_section_hook = [&] (LinearAddress laddr, size_t size, size_t alignment, bool is_readable, bool is_writable, const String& name) { loader.alloc_section_hook = [&] (LinearAddress laddr, size_t size, size_t alignment, bool is_readable, bool is_writable, const String& name) {
ASSERT(size); ASSERT(size);
ASSERT(alignment == PAGE_SIZE); ASSERT(alignment == PAGE_SIZE);
size = ((size / 4096) + 1) * 4096; // FIXME: Use ceil_div? size = ((size / 4096) + 1) * 4096; // FIXME: Use ceil_div?
(void) allocate_region(laddr, size, String(name), is_readable, is_writable); (void) allocate_region(laddr, size, String(name), is_readable, is_writable);
return laddr.asPtr(); return laddr.as_ptr();
}; };
bool success = loader.load(); bool success = loader.load();
if (!success) { if (!success) {
@ -399,7 +399,7 @@ int Process::do_exec(const String& path, Vector<String>&& arguments, Vector<Stri
m_tss.cr3 = page_directory().cr3(); m_tss.cr3 = page_directory().cr3();
m_stack_region = allocate_region(LinearAddress(), defaultStackSize, "stack"); m_stack_region = allocate_region(LinearAddress(), defaultStackSize, "stack");
ASSERT(m_stack_region); ASSERT(m_stack_region);
m_stackTop3 = m_stack_region->linearAddress.offset(defaultStackSize).get(); m_stackTop3 = m_stack_region->laddr().offset(defaultStackSize).get();
m_tss.esp = m_stackTop3; m_tss.esp = m_stackTop3;
m_tss.ss0 = 0x10; m_tss.ss0 = 0x10;
m_tss.esp0 = old_esp0; m_tss.esp0 = old_esp0;
@ -521,7 +521,7 @@ int Process::sys$get_environment(char*** environ)
if (!region) if (!region)
return -ENOMEM; return -ENOMEM;
MM.map_region(*this, *region); MM.map_region(*this, *region);
char* envpage = (char*)region->linearAddress.get(); char* envpage = (char*)region->laddr().get();
*environ = (char**)envpage; *environ = (char**)envpage;
char* bufptr = envpage + (sizeof(char*) * (m_initial_environment.size() + 1)); char* bufptr = envpage + (sizeof(char*) * (m_initial_environment.size() + 1));
for (size_t i = 0; i < m_initial_environment.size(); ++i) { for (size_t i = 0; i < m_initial_environment.size(); ++i) {
@ -540,7 +540,7 @@ int Process::sys$get_arguments(int* argc, char*** argv)
if (!region) if (!region)
return -ENOMEM; return -ENOMEM;
MM.map_region(*this, *region); MM.map_region(*this, *region);
char* argpage = (char*)region->linearAddress.get(); char* argpage = (char*)region->laddr().get();
*argc = m_initial_arguments.size(); *argc = m_initial_arguments.size();
*argv = (char**)argpage; *argv = (char**)argpage;
char* bufptr = argpage + (sizeof(char*) * (m_initial_arguments.size() + 1)); char* bufptr = argpage + (sizeof(char*) * (m_initial_arguments.size() + 1));
@ -674,7 +674,7 @@ Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring
} else { } else {
auto* region = allocate_region(LinearAddress(), defaultStackSize, "stack"); auto* region = allocate_region(LinearAddress(), defaultStackSize, "stack");
ASSERT(region); ASSERT(region);
m_stackTop3 = region->linearAddress.offset(defaultStackSize).get(); m_stackTop3 = region->laddr().offset(defaultStackSize).get();
m_tss.esp = m_stackTop3; m_tss.esp = m_stackTop3;
} }
} }
@ -713,10 +713,10 @@ void Process::dumpRegions()
kprintf("BEGIN END SIZE NAME\n"); kprintf("BEGIN END SIZE NAME\n");
for (auto& region : m_regions) { for (auto& region : m_regions) {
kprintf("%x -- %x %x %s\n", kprintf("%x -- %x %x %s\n",
region->linearAddress.get(), region->laddr().get(),
region->linearAddress.offset(region->size - 1).get(), region->laddr().offset(region->size() - 1).get(),
region->size, region->size(),
region->name.characters()); region->name().characters());
} }
} }
@ -798,7 +798,7 @@ bool Process::dispatch_signal(byte signal)
m_pending_signals &= ~(1 << signal); m_pending_signals &= ~(1 << signal);
if (handler_laddr.asPtr() == SIG_IGN) { if (handler_laddr.as_ptr() == SIG_IGN) {
dbgprintf("%s(%u) ignored signal %u\n", name().characters(), pid(), signal); return false; dbgprintf("%s(%u) ignored signal %u\n", name().characters(), pid(), signal); return false;
} }
@ -828,9 +828,9 @@ bool Process::dispatch_signal(byte signal)
ASSERT(m_signal_stack_user_region); ASSERT(m_signal_stack_user_region);
} }
m_tss.ss = 0x23; m_tss.ss = 0x23;
m_tss.esp = m_signal_stack_user_region->linearAddress.offset(defaultStackSize).get() & 0xfffffff8; m_tss.esp = m_signal_stack_user_region->laddr().offset(defaultStackSize).get() & 0xfffffff8;
m_tss.ss0 = 0x10; m_tss.ss0 = 0x10;
m_tss.esp0 = m_signal_stack_kernel_region->linearAddress.offset(defaultStackSize).get() & 0xfffffff8; m_tss.esp0 = m_signal_stack_kernel_region->laddr().offset(defaultStackSize).get() & 0xfffffff8;
push_value_on_stack(ret_eflags); push_value_on_stack(ret_eflags);
push_value_on_stack(ret_cs); push_value_on_stack(ret_cs);
push_value_on_stack(ret_eip); push_value_on_stack(ret_eip);
@ -863,8 +863,8 @@ bool Process::dispatch_signal(byte signal)
// FIXME: This should be a global trampoline shared by all processes, not one created per process! // FIXME: This should be a global trampoline shared by all processes, not one created per process!
// FIXME: Remap as read-only after setup. // FIXME: Remap as read-only after setup.
auto* region = allocate_region(LinearAddress(), PAGE_SIZE, "signal_trampoline", true, true); auto* region = allocate_region(LinearAddress(), PAGE_SIZE, "signal_trampoline", true, true);
m_return_to_ring3_from_signal_trampoline = region->linearAddress; m_return_to_ring3_from_signal_trampoline = region->laddr();
byte* code_ptr = m_return_to_ring3_from_signal_trampoline.asPtr(); byte* code_ptr = m_return_to_ring3_from_signal_trampoline.as_ptr();
*code_ptr++ = 0x61; // popa *code_ptr++ = 0x61; // popa
*code_ptr++ = 0x9d; // popf *code_ptr++ = 0x9d; // popf
*code_ptr++ = 0xc3; // ret *code_ptr++ = 0xc3; // ret
@ -1598,9 +1598,9 @@ bool Process::validate_read_from_kernel(LinearAddress laddr) const
// FIXME: What if we're indexing into the ksym with the highest address though? // FIXME: What if we're indexing into the ksym with the highest address though?
if (laddr.get() >= ksym_lowest_address && laddr.get() <= ksym_highest_address) if (laddr.get() >= ksym_lowest_address && laddr.get() <= ksym_highest_address)
return true; return true;
if (is_kmalloc_address(laddr.asPtr())) if (is_kmalloc_address(laddr.as_ptr()))
return true; return true;
return validate_read(laddr.asPtr(), 1); return validate_read(laddr.as_ptr(), 1);
} }
bool Process::validate_read(const void* address, size_t size) const bool Process::validate_read(const void* address, size_t size) const
@ -1917,7 +1917,7 @@ DisplayInfo Process::get_display_info()
auto framebuffer_vmo = VMObject::create_framebuffer_wrapper(PhysicalAddress(vmode->framebuffer), framebuffer_size); auto framebuffer_vmo = VMObject::create_framebuffer_wrapper(PhysicalAddress(vmode->framebuffer), framebuffer_size);
m_display_framebuffer_region = allocate_region_with_vmo(LinearAddress(0xe0000000), framebuffer_size, move(framebuffer_vmo), 0, "framebuffer", true, true); m_display_framebuffer_region = allocate_region_with_vmo(LinearAddress(0xe0000000), framebuffer_size, move(framebuffer_vmo), 0, "framebuffer", true, true);
} }
info.framebuffer = m_display_framebuffer_region->linearAddress.asPtr(); info.framebuffer = m_display_framebuffer_region->laddr().as_ptr();
return info; return info;
} }

View file

@ -100,7 +100,7 @@ int Process::gui$get_window_backing_store(int window_id, GUI_WindowBackingStoreI
info->bpp = sizeof(RGBA32); info->bpp = sizeof(RGBA32);
info->pitch = window.backing()->pitch(); info->pitch = window.backing()->pitch();
info->size = window.backing()->size(); info->size = window.backing()->size();
info->pixels = reinterpret_cast<RGBA32*>(window.backing()->client_region()->linearAddress.asPtr()); info->pixels = reinterpret_cast<RGBA32*>(window.backing()->client_region()->laddr().as_ptr());
return 0; return 0;
} }

View file

@ -61,10 +61,10 @@ public:
bool is_null() const { return m_address == 0; } bool is_null() const { return m_address == 0; }
byte* asPtr() { return reinterpret_cast<byte*>(m_address); } byte* as_ptr() { return reinterpret_cast<byte*>(m_address); }
const byte* asPtr() const { return reinterpret_cast<const byte*>(m_address); } const byte* as_ptr() const { return reinterpret_cast<const byte*>(m_address); }
dword pageBase() const { return m_address & 0xfffff000; } dword page_base() const { return m_address & 0xfffff000; }
bool operator==(const PhysicalAddress& other) const { return m_address == other.m_address; } bool operator==(const PhysicalAddress& other) const { return m_address == other.m_address; }
@ -91,10 +91,10 @@ public:
bool operator==(const LinearAddress& other) const { return m_address == other.m_address; } bool operator==(const LinearAddress& other) const { return m_address == other.m_address; }
bool operator!=(const LinearAddress& other) const { return m_address != other.m_address; } bool operator!=(const LinearAddress& other) const { return m_address != other.m_address; }
byte* asPtr() { return reinterpret_cast<byte*>(m_address); } byte* as_ptr() { return reinterpret_cast<byte*>(m_address); }
const byte* asPtr() const { return reinterpret_cast<const byte*>(m_address); } const byte* as_ptr() const { return reinterpret_cast<const byte*>(m_address); }
dword pageBase() const { return m_address & 0xfffff000; } dword page_base() const { return m_address & 0xfffff000; }
private: private:
dword m_address { 0 }; dword m_address { 0 };

View file

@ -9,7 +9,7 @@ int ispunct(int c)
int isprint(int c) int isprint(int c)
{ {
return c >= 0x20 && c != 0x7f; return isdigit(c) || isupper(c) || islower(c) || ispunct(c) || isspace(c);
} }
int isalnum(int c) int isalnum(int c)

View file

@ -30,7 +30,7 @@ GraphicsBitmap::GraphicsBitmap(Process& process, const Size& size)
m_server_region = server.allocate_region_with_vmo(LinearAddress(), size_in_bytes, move(vmo), 0, "GraphicsBitmap (server)", true, false); m_server_region = server.allocate_region_with_vmo(LinearAddress(), size_in_bytes, move(vmo), 0, "GraphicsBitmap (server)", true, false);
m_server_region->set_shared(true); m_server_region->set_shared(true);
} }
m_data = (RGBA32*)m_server_region->linearAddress.asPtr(); m_data = (RGBA32*)m_server_region->laddr().as_ptr();
} }
#endif #endif

View file

@ -116,7 +116,7 @@ WSWindowManager::WSWindowManager()
auto size = m_screen_rect.size(); auto size = m_screen_rect.size();
m_front_bitmap = GraphicsBitmap::create_wrapper(size, m_screen.scanline(0)); m_front_bitmap = GraphicsBitmap::create_wrapper(size, m_screen.scanline(0));
auto* region = current->allocate_region(LinearAddress(), size.width() * size.height() * sizeof(RGBA32), "BackBitmap", true, true, true); auto* region = current->allocate_region(LinearAddress(), size.width() * size.height() * sizeof(RGBA32), "BackBitmap", true, true, true);
m_back_bitmap = GraphicsBitmap::create_wrapper(m_screen_rect.size(), (RGBA32*)region->linearAddress.get()); m_back_bitmap = GraphicsBitmap::create_wrapper(m_screen_rect.size(), (RGBA32*)region->laddr().get());
m_front_painter = make<Painter>(*m_front_bitmap); m_front_painter = make<Painter>(*m_front_bitmap);
m_back_painter = make<Painter>(*m_back_bitmap); m_back_painter = make<Painter>(*m_back_bitmap);