RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 11:08:11 +00:00
Code Issues Activity Actions

Yet more coding style fixes.

Browse source
This commit is contained in:
Andreas Kling 2018-12-03 01:38:22 +01:00
parent f31e1ceab0
commit aff89d2fd7
18 changed files with 197 additions and 199 deletions
Download patch file Download diff file Expand all files Collapse all files

20
AK/FileSystemPath.cpp
View file

@ -8,35 +8,35 @@ namespace AK {
FileSystemPath::FileSystemPath(const String& s) FileSystemPath::FileSystemPath(const String& s)
: m_string(s) : m_string(s)
{ {
m_isValid = canonicalize(); m_is_valid = canonicalize();
} }
bool FileSystemPath::canonicalize(bool resolveSymbolicLinks) bool FileSystemPath::canonicalize(bool resolve_symbolic_links)
{ {
// FIXME: Implement "resolveSymbolicLinks" // FIXME: Implement "resolveSymbolicLinks"
(void) resolveSymbolicLinks; (void) resolve_symbolic_links;
auto parts = m_string.split('/'); auto parts = m_string.split('/');
Vector<String> canonicalParts; Vector<String> canonical_parts;
for (auto& part : parts) { for (auto& part : parts) {
if (part == ".") if (part == ".")
continue; continue;
if (part == "..") { if (part == "..") {
if (!canonicalParts.isEmpty()) if (!canonical_parts.isEmpty())
canonicalParts.takeLast(); canonical_parts.takeLast();
continue; continue;
} }
if (!part.isEmpty()) if (!part.isEmpty())
canonicalParts.append(part); canonical_parts.append(part);
} }
if (canonicalParts.isEmpty()) { if (canonical_parts.isEmpty()) {
m_string = m_basename = "/"; m_string = m_basename = "/";
return true; return true;
} }
m_basename = canonicalParts.last(); m_basename = canonical_parts.last();
StringBuilder builder; StringBuilder builder;
for (auto& cpart : canonicalParts) { for (auto& cpart : canonical_parts) {
builder.append('/'); builder.append('/');
builder.append(move(cpart)); builder.append(move(cpart));
} }

6
AK/FileSystemPath.h
View file

@ -9,17 +9,17 @@ public:
FileSystemPath() { } FileSystemPath() { }
explicit FileSystemPath(const String&); explicit FileSystemPath(const String&);
bool isValid() const { return m_isValid; } bool is_valid() const { return m_is_valid; }
String string() const { return m_string; } String string() const { return m_string; }
String basename() const { return m_basename; } String basename() const { return m_basename; }
private: private:
bool canonicalize(bool resolveSymbolicLinks = false); bool canonicalize(bool resolve_symbolic_links = false);
String m_string; String m_string;
String m_basename; String m_basename;
bool m_isValid { false }; bool m_is_valid { false };
}; };
}; };

4
Kernel/Console.cpp
View file

@ -42,11 +42,11 @@ ssize_t Console::write(const byte* data, size_t size)
if (!m_implementation) if (!m_implementation)
return 0; return 0;
for (size_t i = 0; i < size; ++i) for (size_t i = 0; i < size; ++i)
putChar(data[i]); put_char(data[i]);
return size; return size;
} }
void Console::putChar(char ch) void Console::put_char(char ch)
{ {
#ifdef CONSOLE_OUT_TO_E9 #ifdef CONSOLE_OUT_TO_E9
//if (ch != 27) //if (ch != 27)

2
Kernel/Console.h
View file

@ -24,7 +24,7 @@ public:
void setImplementation(ConsoleImplementation* implementation) { m_implementation = implementation; } void setImplementation(ConsoleImplementation* implementation) { m_implementation = implementation; }
void putChar(char); void put_char(char);
private: private:
ConsoleImplementation* m_implementation { nullptr }; ConsoleImplementation* m_implementation { nullptr };

6
Kernel/IDEDiskDevice.cpp
View file

@ -52,18 +52,18 @@ const char* IDEDiskDevice::class_name() const
return "IDEDiskDevice"; return "IDEDiskDevice";
} }
unsigned IDEDiskDevice::blockSize() const unsigned IDEDiskDevice::block_size() const
{ {
return 512; return 512;
} }
bool IDEDiskDevice::readBlock(unsigned index, byte* out) const bool IDEDiskDevice::read_block(unsigned index, byte* out) const
{ {
const_cast<IDEDiskDevice&>(*this).read_sectors(index, 1, out); const_cast<IDEDiskDevice&>(*this).read_sectors(index, 1, out);
return true; return true;
} }
bool IDEDiskDevice::writeBlock(unsigned index, const byte* data) bool IDEDiskDevice::write_block(unsigned index, const byte* data)
{ {
write_sectors(index, 1, data); write_sectors(index, 1, data);
return true; return true;

6
Kernel/IDEDiskDevice.h
View file

@ -11,9 +11,9 @@ public:
virtual ~IDEDiskDevice() override; virtual ~IDEDiskDevice() override;
// ^DiskDevice // ^DiskDevice
virtual unsigned blockSize() const override; virtual unsigned block_size() const override;
virtual bool readBlock(unsigned index, byte*) const override; virtual bool read_block(unsigned index, byte*) const override;
virtual bool writeBlock(unsigned index, const byte*) override; virtual bool write_block(unsigned index, const byte*) override;
protected: protected:
IDEDiskDevice(); IDEDiskDevice();

182
Kernel/MemoryManager.cpp
View file

@ -21,12 +21,12 @@ MemoryManager& MM
MemoryManager::MemoryManager() MemoryManager::MemoryManager()
{ {
m_kernel_page_directory = (PageDirectory*)0x4000; m_kernel_page_directory = (PageDirectory*)0x4000;
m_pageTableZero = (dword*)0x6000; m_page_table_zero = (dword*)0x6000;
m_pageTableOne = (dword*)0x7000; m_page_table_one = (dword*)0x7000;
m_next_laddr.set(0xd0000000); m_next_laddr.set(0xd0000000);
initializePaging(); initialize_paging();
} }
MemoryManager::~MemoryManager() MemoryManager::~MemoryManager()
@ -60,12 +60,12 @@ void MemoryManager::release_page_directory(PageDirectory& page_directory)
#endif #endif
} }
void MemoryManager::initializePaging() void MemoryManager::initialize_paging()
{ {
static_assert(sizeof(MemoryManager::PageDirectoryEntry) == 4); static_assert(sizeof(MemoryManager::PageDirectoryEntry) == 4);
static_assert(sizeof(MemoryManager::PageTableEntry) == 4); static_assert(sizeof(MemoryManager::PageTableEntry) == 4);
memset(m_pageTableZero, 0, PAGE_SIZE); memset(m_page_table_zero, 0, PAGE_SIZE);
memset(m_pageTableOne, 0, PAGE_SIZE); memset(m_page_table_one, 0, PAGE_SIZE);
memset(m_kernel_page_directory, 0, sizeof(PageDirectory)); memset(m_kernel_page_directory, 0, sizeof(PageDirectory));
#ifdef MM_DEBUG #ifdef MM_DEBUG
@ -73,7 +73,7 @@ void MemoryManager::initializePaging()
#endif #endif
// Make null dereferences crash. // Make null dereferences crash.
protectMap(LinearAddress(0), PAGE_SIZE); map_protected(LinearAddress(0), PAGE_SIZE);
// The bottom 4 MB are identity mapped & supervisor only. Every process shares these mappings. // The bottom 4 MB are identity mapped & supervisor only. Every process shares these mappings.
create_identity_mapping(LinearAddress(PAGE_SIZE), 4 * MB); create_identity_mapping(LinearAddress(PAGE_SIZE), 4 * MB);
@ -123,38 +123,38 @@ void MemoryManager::remove_identity_mapping(LinearAddress laddr, size_t size)
// FIXME: ASSERT(laddr is 4KB aligned); // FIXME: ASSERT(laddr is 4KB aligned);
for (dword offset = 0; offset < size; offset += PAGE_SIZE) { for (dword offset = 0; offset < size; offset += PAGE_SIZE) {
auto pte_address = laddr.offset(offset); auto pte_address = laddr.offset(offset);
auto pte = ensurePTE(m_kernel_page_directory, pte_address); auto pte = ensure_pte(m_kernel_page_directory, pte_address);
pte.setPhysicalPageBase(0); pte.set_physical_page_base(0);
pte.setUserAllowed(false); pte.set_user_allowed(false);
pte.setPresent(true); pte.set_present(true);
pte.setWritable(true); pte.set_writable(true);
flushTLB(pte_address); flush_tlb(pte_address);
} }
} }
auto MemoryManager::ensurePTE(PageDirectory* page_directory, LinearAddress laddr) -> PageTableEntry auto MemoryManager::ensure_pte(PageDirectory* page_directory, LinearAddress laddr) -> PageTableEntry
{ {
ASSERT_INTERRUPTS_DISABLED(); ASSERT_INTERRUPTS_DISABLED();
dword page_directory_index = (laddr.get() >> 22) & 0x3ff; dword page_directory_index = (laddr.get() >> 22) & 0x3ff;
dword page_table_index = (laddr.get() >> 12) & 0x3ff; dword page_table_index = (laddr.get() >> 12) & 0x3ff;
PageDirectoryEntry pde = PageDirectoryEntry(&page_directory->entries[page_directory_index]); PageDirectoryEntry pde = PageDirectoryEntry(&page_directory->entries[page_directory_index]);
if (!pde.isPresent()) { if (!pde.is_present()) {
#ifdef MM_DEBUG #ifdef MM_DEBUG
dbgprintf("MM: PDE %u not present, allocating\n", page_directory_index); dbgprintf("MM: PDE %u not present, allocating\n", page_directory_index);
#endif #endif
if (page_directory_index == 0) { if (page_directory_index == 0) {
ASSERT(page_directory == m_kernel_page_directory); ASSERT(page_directory == m_kernel_page_directory);
pde.setPageTableBase((dword)m_pageTableZero); pde.setPageTableBase((dword)m_page_table_zero);
pde.setUserAllowed(false); pde.set_user_allowed(false);
pde.setPresent(true); pde.set_present(true);
pde.setWritable(true); pde.set_writable(true);
} else if (page_directory_index == 1) { } else if (page_directory_index == 1) {
ASSERT(page_directory == m_kernel_page_directory); ASSERT(page_directory == m_kernel_page_directory);
pde.setPageTableBase((dword)m_pageTableOne); pde.setPageTableBase((dword)m_page_table_one);
pde.setUserAllowed(false); pde.set_user_allowed(false);
pde.setPresent(true); pde.set_present(true);
pde.setWritable(true); pde.set_writable(true);
} else { } else {
auto page_table = allocate_page_table(*page_directory, page_directory_index); auto page_table = allocate_page_table(*page_directory, page_directory_index);
#ifdef MM_DEBUG #ifdef MM_DEBUG
@ -167,27 +167,27 @@ auto MemoryManager::ensurePTE(PageDirectory* page_directory, LinearAddress laddr
#endif #endif
pde.setPageTableBase(page_table->paddr().get()); pde.setPageTableBase(page_table->paddr().get());
pde.setUserAllowed(true); pde.set_user_allowed(true);
pde.setPresent(true); pde.set_present(true);
pde.setWritable(true); pde.set_writable(true);
page_directory->physical_pages[page_directory_index] = move(page_table); page_directory->physical_pages[page_directory_index] = move(page_table);
} }
} }
return PageTableEntry(&pde.pageTableBase()[page_table_index]); return PageTableEntry(&pde.pageTableBase()[page_table_index]);
} }
void MemoryManager::protectMap(LinearAddress linearAddress, size_t length) void MemoryManager::map_protected(LinearAddress linearAddress, 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 = linearAddress.offset(offset);
auto pte = ensurePTE(m_kernel_page_directory, pteAddress); auto pte = ensure_pte(m_kernel_page_directory, pteAddress);
pte.setPhysicalPageBase(pteAddress.get()); pte.set_physical_page_base(pteAddress.get());
pte.setUserAllowed(false); pte.set_user_allowed(false);
pte.setPresent(false); pte.set_present(false);
pte.setWritable(false); pte.set_writable(false);
flushTLB(pteAddress); flush_tlb(pteAddress);
} }
} }
@ -197,12 +197,12 @@ void MemoryManager::create_identity_mapping(LinearAddress laddr, size_t size)
// FIXME: ASSERT(laddr is 4KB aligned); // FIXME: ASSERT(laddr is 4KB aligned);
for (dword offset = 0; offset < size; offset += PAGE_SIZE) { for (dword offset = 0; offset < size; offset += PAGE_SIZE) {
auto pteAddress = laddr.offset(offset); auto pteAddress = laddr.offset(offset);
auto pte = ensurePTE(m_kernel_page_directory, pteAddress); auto pte = ensure_pte(m_kernel_page_directory, pteAddress);
pte.setPhysicalPageBase(pteAddress.get()); pte.set_physical_page_base(pteAddress.get());
pte.setUserAllowed(false); pte.set_user_allowed(false);
pte.setPresent(true); pte.set_present(true);
pte.setWritable(true); pte.set_writable(true);
flushTLB(pteAddress); flush_tlb(pteAddress);
} }
} }
@ -389,7 +389,7 @@ void MemoryManager::enter_process_paging_scope(Process& process)
asm volatile("movl %%eax, %%cr3"::"a"(process.m_page_directory):"memory"); asm volatile("movl %%eax, %%cr3"::"a"(process.m_page_directory):"memory");
} }
void MemoryManager::flushEntireTLB() void MemoryManager::flush_entire_tlb()
{ {
asm volatile( asm volatile(
"mov %cr3, %eax\n" "mov %cr3, %eax\n"
@ -397,7 +397,7 @@ void MemoryManager::flushEntireTLB()
); );
} }
void MemoryManager::flushTLB(LinearAddress laddr) void MemoryManager::flush_tlb(LinearAddress laddr)
{ {
asm volatile("invlpg %0": :"m" (*(char*)laddr.get()) : "memory"); asm volatile("invlpg %0": :"m" (*(char*)laddr.get()) : "memory");
} }
@ -406,12 +406,12 @@ byte* MemoryManager::quickmap_page(PhysicalPage& physical_page)
{ {
ASSERT_INTERRUPTS_DISABLED(); ASSERT_INTERRUPTS_DISABLED();
auto page_laddr = LinearAddress(4 * MB); auto page_laddr = LinearAddress(4 * MB);
auto pte = ensurePTE(m_kernel_page_directory, page_laddr); auto pte = ensure_pte(m_kernel_page_directory, page_laddr);
pte.setPhysicalPageBase(physical_page.paddr().get()); pte.set_physical_page_base(physical_page.paddr().get());
pte.setPresent(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?
pte.setWritable(true); pte.set_writable(true);
pte.setUserAllowed(false); pte.set_user_allowed(false);
flushTLB(page_laddr); flush_tlb(page_laddr);
#ifdef MM_DEBUG #ifdef MM_DEBUG
dbgprintf("MM: >> quickmap_page L%x => P%x\n", page_laddr, physical_page.paddr().get()); dbgprintf("MM: >> quickmap_page L%x => P%x\n", page_laddr, physical_page.paddr().get());
#endif #endif
@ -422,15 +422,15 @@ void MemoryManager::unquickmap_page()
{ {
ASSERT_INTERRUPTS_DISABLED(); ASSERT_INTERRUPTS_DISABLED();
auto page_laddr = LinearAddress(4 * MB); auto page_laddr = LinearAddress(4 * MB);
auto pte = ensurePTE(m_kernel_page_directory, page_laddr); auto pte = ensure_pte(m_kernel_page_directory, page_laddr);
#ifdef MM_DEBUG #ifdef MM_DEBUG
auto old_physical_address = pte.physicalPageBase(); auto old_physical_address = pte.physicalPageBase();
#endif #endif
pte.setPhysicalPageBase(0); pte.set_physical_page_base(0);
pte.setPresent(false); pte.set_present(false);
pte.setWritable(false); pte.set_writable(false);
pte.setUserAllowed(false); pte.set_user_allowed(false);
flushTLB(page_laddr); flush_tlb(page_laddr);
#ifdef MM_DEBUG #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_laddr, old_physical_address);
#endif #endif
@ -440,18 +440,18 @@ void MemoryManager::remap_region_page(PageDirectory* page_directory, Region& reg
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
auto page_laddr = region.linearAddress.offset(page_index_in_region * PAGE_SIZE); auto page_laddr = region.linearAddress.offset(page_index_in_region * PAGE_SIZE);
auto pte = ensurePTE(page_directory, page_laddr); auto pte = ensure_pte(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.setPhysicalPageBase(physical_page->paddr().get()); pte.set_physical_page_base(physical_page->paddr().get());
pte.setPresent(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.cow_map.get(page_index_in_region))
pte.setWritable(false); pte.set_writable(false);
else else
pte.setWritable(region.is_writable); pte.set_writable(region.is_writable);
pte.setUserAllowed(user_allowed); pte.set_user_allowed(user_allowed);
if (page_directory->is_active()) if (page_directory->is_active())
flushTLB(page_laddr); flush_tlb(page_laddr);
#ifdef MM_DEBUG #ifdef MM_DEBUG
dbgprintf("MM: >> remap_region_page (PD=%x) '%s' L%x => P%x (@%p)\n", page_directory, region.name.characters(), page_laddr.get(), physical_page->paddr().get(), physical_page.ptr()); dbgprintf("MM: >> remap_region_page (PD=%x) '%s' L%x => P%x (@%p)\n", page_directory, region.name.characters(), page_laddr.get(), physical_page->paddr().get(), physical_page.ptr());
#endif #endif
@ -472,23 +472,23 @@ void MemoryManager::map_region_at_address(PageDirectory* page_directory, Region&
#endif #endif
for (size_t i = region.first_page_index(); i <= region.last_page_index(); ++i) { for (size_t i = region.first_page_index(); i <= region.last_page_index(); ++i) {
auto page_laddr = laddr.offset(i * PAGE_SIZE); auto page_laddr = laddr.offset(i * PAGE_SIZE);
auto pte = ensurePTE(page_directory, page_laddr); auto pte = ensure_pte(page_directory, page_laddr);
auto& physical_page = vmo.physical_pages()[i]; auto& physical_page = vmo.physical_pages()[i];
if (physical_page) { if (physical_page) {
pte.setPhysicalPageBase(physical_page->paddr().get()); pte.set_physical_page_base(physical_page->paddr().get());
pte.setPresent(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(i)) if (region.cow_map.get(i))
pte.setWritable(false); pte.set_writable(false);
else else
pte.setWritable(region.is_writable); pte.set_writable(region.is_writable);
} else { } else {
pte.setPhysicalPageBase(0); pte.set_physical_page_base(0);
pte.setPresent(false); pte.set_present(false);
pte.setWritable(region.is_writable); pte.set_writable(region.is_writable);
} }
pte.setUserAllowed(user_allowed); pte.set_user_allowed(user_allowed);
if (page_directory->is_active()) if (page_directory->is_active())
flushTLB(page_laddr); flush_tlb(page_laddr);
#ifdef MM_DEBUG #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_laddr, physical_page ? physical_page->paddr().get() : 0, physical_page.ptr());
#endif #endif
@ -503,13 +503,13 @@ void MemoryManager::unmap_range(PageDirectory* page_directory, LinearAddress lad
size_t numPages = size / PAGE_SIZE; size_t numPages = size / PAGE_SIZE;
for (size_t i = 0; i < numPages; ++i) { for (size_t i = 0; i < numPages; ++i) {
auto page_laddr = laddr.offset(i * PAGE_SIZE); auto page_laddr = laddr.offset(i * PAGE_SIZE);
auto pte = ensurePTE(page_directory, page_laddr); auto pte = ensure_pte(page_directory, page_laddr);
pte.setPhysicalPageBase(0); pte.set_physical_page_base(0);
pte.setPresent(false); pte.set_present(false);
pte.setWritable(false); pte.set_writable(false);
pte.setUserAllowed(false); pte.set_user_allowed(false);
if (page_directory->is_active()) if (page_directory->is_active())
flushTLB(page_laddr); flush_tlb(page_laddr);
#ifdef MM_DEBUG #ifdef MM_DEBUG
dbgprintf("MM: << unmap_range L%x =/> 0\n", page_laddr); dbgprintf("MM: << unmap_range L%x =/> 0\n", page_laddr);
#endif #endif
@ -548,18 +548,18 @@ void MemoryManager::remove_kernel_alias_for_region(Region& region, byte* addr)
unmap_range(m_kernel_page_directory, LinearAddress((dword)addr), region.size); unmap_range(m_kernel_page_directory, LinearAddress((dword)addr), region.size);
} }
bool MemoryManager::unmapRegion(Process& process, Region& region) bool MemoryManager::unmap_region(Process& process, Region& region)
{ {
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.linearAddress.offset(i * PAGE_SIZE);
auto pte = ensurePTE(process.m_page_directory, laddr); auto pte = ensure_pte(process.m_page_directory, laddr);
pte.setPhysicalPageBase(0); pte.set_physical_page_base(0);
pte.setPresent(false); pte.set_present(false);
pte.setWritable(false); pte.set_writable(false);
pte.setUserAllowed(false); pte.set_user_allowed(false);
if (process.m_page_directory->is_active()) if (process.m_page_directory->is_active())
flushTLB(laddr); flush_tlb(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);
@ -568,7 +568,7 @@ bool MemoryManager::unmapRegion(Process& process, Region& region)
return true; return true;
} }
bool MemoryManager::mapRegion(Process& process, Region& region) bool MemoryManager::map_region(Process& process, Region& region)
{ {
map_region_at_address(process.m_page_directory, region, region.linearAddress, true); map_region_at_address(process.m_page_directory, region, region.linearAddress, true);
return true; return true;
@ -579,12 +579,12 @@ bool MemoryManager::validate_user_read(const Process& process, LinearAddress lad
dword pageDirectoryIndex = (laddr.get() >> 22) & 0x3ff; dword pageDirectoryIndex = (laddr.get() >> 22) & 0x3ff;
dword pageTableIndex = (laddr.get() >> 12) & 0x3ff; dword pageTableIndex = (laddr.get() >> 12) & 0x3ff;
auto pde = PageDirectoryEntry(&process.m_page_directory->entries[pageDirectoryIndex]); auto pde = PageDirectoryEntry(&process.m_page_directory->entries[pageDirectoryIndex]);
if (!pde.isPresent()) if (!pde.is_present())
return false; return false;
auto pte = PageTableEntry(&pde.pageTableBase()[pageTableIndex]); auto pte = PageTableEntry(&pde.pageTableBase()[pageTableIndex]);
if (!pte.isPresent()) if (!pte.is_present())
return false; return false;
if (!pte.isUserAllowed()) if (!pte.is_user_allowed())
return false; return false;
return true; return true;
} }
@ -594,14 +594,14 @@ bool MemoryManager::validate_user_write(const Process& process, LinearAddress la
dword pageDirectoryIndex = (laddr.get() >> 22) & 0x3ff; dword pageDirectoryIndex = (laddr.get() >> 22) & 0x3ff;
dword pageTableIndex = (laddr.get() >> 12) & 0x3ff; dword pageTableIndex = (laddr.get() >> 12) & 0x3ff;
auto pde = PageDirectoryEntry(&process.m_page_directory->entries[pageDirectoryIndex]); auto pde = PageDirectoryEntry(&process.m_page_directory->entries[pageDirectoryIndex]);
if (!pde.isPresent()) if (!pde.is_present())
return false; return false;
auto pte = PageTableEntry(&pde.pageTableBase()[pageTableIndex]); auto pte = PageTableEntry(&pde.pageTableBase()[pageTableIndex]);
if (!pte.isPresent()) if (!pte.is_present())
return false; return false;
if (!pte.isUserAllowed()) if (!pte.is_user_allowed())
return false; return false;
if (!pte.isWritable()) if (!pte.is_writable())
return false; return false;
return true; return true;
} }

52
Kernel/MemoryManager.h
View file

@ -156,14 +156,12 @@ class MemoryManager {
public: public:
static MemoryManager& the() PURE; static MemoryManager& the() PURE;
PhysicalAddress pageDirectoryBase() const { return PhysicalAddress(reinterpret_cast<dword>(m_kernel_page_directory)); }
static void initialize(); static void initialize();
PageFaultResponse handle_page_fault(const PageFault&); PageFaultResponse handle_page_fault(const PageFault&);
bool mapRegion(Process&, Region&); bool map_region(Process&, Region&);
bool unmapRegion(Process&, Region&); bool unmap_region(Process&, Region&);
void populate_page_directory(PageDirectory&); void populate_page_directory(PageDirectory&);
void release_page_directory(PageDirectory&); void release_page_directory(PageDirectory&);
@ -195,14 +193,14 @@ private:
void unmap_range(PageDirectory*, LinearAddress, size_t); void unmap_range(PageDirectory*, LinearAddress, size_t);
void remap_region_page(PageDirectory*, Region&, unsigned page_index_in_region, bool user_allowed); void remap_region_page(PageDirectory*, Region&, unsigned page_index_in_region, bool user_allowed);
void initializePaging(); void initialize_paging();
void flushEntireTLB(); void flush_entire_tlb();
void flushTLB(LinearAddress); void flush_tlb(LinearAddress);
RetainPtr<PhysicalPage> allocate_page_table(PageDirectory&, unsigned index); RetainPtr<PhysicalPage> allocate_page_table(PageDirectory&, unsigned index);
void deallocate_page_table(PageDirectory&, unsigned index); void deallocate_page_table(PageDirectory&, unsigned index);
void protectMap(LinearAddress, size_t length); void map_protected(LinearAddress, size_t length);
void create_identity_mapping(LinearAddress, size_t length); void create_identity_mapping(LinearAddress, size_t length);
void remove_identity_mapping(LinearAddress, size_t); void remove_identity_mapping(LinearAddress, size_t);
@ -235,16 +233,16 @@ private:
UserSupervisor = 1 << 2, UserSupervisor = 1 << 2,
}; };
bool isPresent() const { return raw() & Present; } bool is_present() const { return raw() & Present; }
void setPresent(bool b) { setBit(Present, b); } void set_present(bool b) { set_bit(Present, b); }
bool isUserAllowed() const { return raw() & UserSupervisor; } bool is_user_allowed() const { return raw() & UserSupervisor; }
void setUserAllowed(bool b) { setBit(UserSupervisor, b); } void set_user_allowed(bool b) { set_bit(UserSupervisor, b); }
bool isWritable() const { return raw() & ReadWrite; } bool is_writable() const { return raw() & ReadWrite; }
void setWritable(bool b) { setBit(ReadWrite, b); } void set_writable(bool b) { set_bit(ReadWrite, b); }
void setBit(byte bit, bool value) void set_bit(byte bit, bool value)
{ {
if (value) if (value)
*m_pde |= bit; *m_pde |= bit;
@ -258,8 +256,8 @@ private:
struct PageTableEntry { struct PageTableEntry {
explicit PageTableEntry(dword* pte) : m_pte(pte) { } explicit PageTableEntry(dword* pte) : m_pte(pte) { }
dword* physicalPageBase() { return reinterpret_cast<dword*>(raw() & 0xfffff000u); } dword* physical_page_base() { return reinterpret_cast<dword*>(raw() & 0xfffff000u); }
void setPhysicalPageBase(dword value) void set_physical_page_base(dword value)
{ {
*m_pte &= 0xfffu; *m_pte &= 0xfffu;
*m_pte |= value & 0xfffff000u; *m_pte |= value & 0xfffff000u;
@ -274,16 +272,16 @@ private:
UserSupervisor = 1 << 2, UserSupervisor = 1 << 2,
}; };
bool isPresent() const { return raw() & Present; } bool is_present() const { return raw() & Present; }
void setPresent(bool b) { setBit(Present, b); } void set_present(bool b) { set_bit(Present, b); }
bool isUserAllowed() const { return raw() & UserSupervisor; } bool is_user_allowed() const { return raw() & UserSupervisor; }
void setUserAllowed(bool b) { setBit(UserSupervisor, b); } void set_user_allowed(bool b) { set_bit(UserSupervisor, b); }
bool isWritable() const { return raw() & ReadWrite; } bool is_writable() const { return raw() & ReadWrite; }
void setWritable(bool b) { setBit(ReadWrite, b); } void set_writable(bool b) { set_bit(ReadWrite, b); }
void setBit(byte bit, bool value) void set_bit(byte bit, bool value)
{ {
if (value) if (value)
*m_pte |= bit; *m_pte |= bit;
@ -294,11 +292,11 @@ private:
dword* m_pte; dword* m_pte;
}; };
PageTableEntry ensurePTE(PageDirectory*, LinearAddress); PageTableEntry ensure_pte(PageDirectory*, LinearAddress);
PageDirectory* m_kernel_page_directory; PageDirectory* m_kernel_page_directory;
dword* m_pageTableZero; dword* m_page_table_zero;
dword* m_pageTableOne; dword* m_page_table_one;
LinearAddress m_next_laddr; LinearAddress m_next_laddr;

14
Kernel/Process.cpp
View file

@ -76,7 +76,7 @@ Region* Process::allocate_region(LinearAddress laddr, size_t size, String&& name
m_regions.append(adopt(*new Region(laddr, size, move(name), is_readable, is_writable))); m_regions.append(adopt(*new Region(laddr, size, move(name), is_readable, is_writable)));
if (commit) if (commit)
m_regions.last()->commit(*this); m_regions.last()->commit(*this);
MM.mapRegion(*this, *m_regions.last()); MM.map_region(*this, *m_regions.last());
return m_regions.last().ptr(); return m_regions.last().ptr();
} }
@ -91,7 +91,7 @@ Region* Process::allocate_file_backed_region(LinearAddress laddr, size_t size, R
} }
laddr.mask(0xfffff000); laddr.mask(0xfffff000);
m_regions.append(adopt(*new Region(laddr, size, move(vnode), move(name), is_readable, is_writable))); m_regions.append(adopt(*new Region(laddr, size, move(vnode), move(name), is_readable, is_writable)));
MM.mapRegion(*this, *m_regions.last()); MM.map_region(*this, *m_regions.last());
return m_regions.last().ptr(); return m_regions.last().ptr();
} }
@ -107,7 +107,7 @@ Region* Process::allocate_region_with_vmo(LinearAddress laddr, size_t size, Reta
offset_in_vmo &= PAGE_MASK; offset_in_vmo &= PAGE_MASK;
size = ceilDiv(size, PAGE_SIZE) * PAGE_SIZE; size = ceilDiv(size, PAGE_SIZE) * PAGE_SIZE;
m_regions.append(adopt(*new Region(laddr, size, move(vmo), offset_in_vmo, move(name), is_readable, is_writable))); m_regions.append(adopt(*new Region(laddr, size, move(vmo), offset_in_vmo, move(name), is_readable, is_writable)));
MM.mapRegion(*this, *m_regions.last()); MM.map_region(*this, *m_regions.last());
return m_regions.last().ptr(); return m_regions.last().ptr();
} }
@ -116,7 +116,7 @@ bool Process::deallocate_region(Region& region)
InterruptDisabler disabler; InterruptDisabler disabler;
for (size_t i = 0; i < m_regions.size(); ++i) { for (size_t i = 0; i < m_regions.size(); ++i) {
if (m_regions[i].ptr() == &region) { if (m_regions[i].ptr() == &region) {
MM.unmapRegion(*this, region); MM.unmap_region(*this, region);
m_regions.remove(i); m_regions.remove(i);
return true; return true;
} }
@ -231,7 +231,7 @@ Process* Process::fork(RegisterDump& regs)
#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));
MM.mapRegion(*child, *child->m_regions.last()); MM.map_region(*child, *child->m_regions.last());
} }
child->m_tss.eax = 0; // fork() returns 0 in the child :^) child->m_tss.eax = 0; // fork() returns 0 in the child :^)
@ -510,7 +510,7 @@ int Process::sys$get_environment(char*** environ)
auto* region = allocate_region(LinearAddress(), PAGE_SIZE, "environ"); auto* region = allocate_region(LinearAddress(), PAGE_SIZE, "environ");
if (!region) if (!region)
return -ENOMEM; return -ENOMEM;
MM.mapRegion(*this, *region); MM.map_region(*this, *region);
char* envpage = (char*)region->linearAddress.get(); char* envpage = (char*)region->linearAddress.get();
*environ = (char**)envpage; *environ = (char**)envpage;
char* bufptr = envpage + (sizeof(char*) * (m_initialEnvironment.size() + 1)); char* bufptr = envpage + (sizeof(char*) * (m_initialEnvironment.size() + 1));
@ -529,7 +529,7 @@ int Process::sys$get_arguments(int* argc, char*** argv)
auto* region = allocate_region(LinearAddress(), PAGE_SIZE, "argv"); auto* region = allocate_region(LinearAddress(), PAGE_SIZE, "argv");
if (!region) if (!region)
return -ENOMEM; return -ENOMEM;
MM.mapRegion(*this, *region); MM.map_region(*this, *region);
char* argpage = (char*)region->linearAddress.get(); char* argpage = (char*)region->linearAddress.get();
*argc = m_arguments.size(); *argc = m_arguments.size();
*argv = (char**)argpage; *argv = (char**)argpage;

2
Kernel/Syscall.cpp
View file

@ -52,7 +52,7 @@ static dword handle(RegisterDump& regs, dword function, dword arg1, dword arg2,
Scheduler::yield(); Scheduler::yield();
break; break;
case Syscall::SC_putch: case Syscall::SC_putch:
Console::the().putChar(arg1 & 0xff); Console::the().put_char(arg1 & 0xff);
break; break;
case Syscall::SC_sleep: case Syscall::SC_sleep:
return current->sys$sleep((unsigned)arg1); return current->sys$sleep((unsigned)arg1);

2
Userland/sh.cpp
View file

@ -181,7 +181,7 @@ static int sh_cd(int argc, const char** argv)
sprintf(pathbuf, "%s/%s", g->cwd.characters(), argv[1]); sprintf(pathbuf, "%s/%s", g->cwd.characters(), argv[1]);
FileSystemPath canonicalPath(pathbuf); FileSystemPath canonicalPath(pathbuf);
if (!canonicalPath.isValid()) { if (!canonicalPath.is_valid()) {
printf("FileSystemPath failed to canonicalize '%s'\n", pathbuf); printf("FileSystemPath failed to canonicalize '%s'\n", pathbuf);
return 1; return 1;
} }

24
VirtualFileSystem/DiskDevice.cpp
View file

@ -11,32 +11,32 @@ DiskDevice::~DiskDevice()
bool DiskDevice::read(DiskOffset offset, unsigned length, byte* out) const bool DiskDevice::read(DiskOffset offset, unsigned length, byte* out) const
{ {
//kprintf("DD::read %u x%u\n", offset, length); //kprintf("DD::read %u x%u\n", offset, length);
ASSERT((offset % blockSize()) == 0); ASSERT((offset % block_size()) == 0);
ASSERT((length % blockSize()) == 0); ASSERT((length % block_size()) == 0);
dword firstBlock = offset / blockSize(); dword firstBlock = offset / block_size();
dword endBlock = (offset + length) / blockSize(); dword endBlock = (offset + length) / block_size();
byte* outptr = out; byte* outptr = out;
for (unsigned bi = firstBlock; bi < endBlock; ++bi) { for (unsigned bi = firstBlock; bi < endBlock; ++bi) {
if (!readBlock(bi, outptr)) if (!read_block(bi, outptr))
return false; return false;
outptr += blockSize(); outptr += block_size();
} }
return true; return true;
} }
bool DiskDevice::write(DiskOffset offset, unsigned length, const byte* in) bool DiskDevice::write(DiskOffset offset, unsigned length, const byte* in)
{ {
ASSERT((offset % blockSize()) == 0); ASSERT((offset % block_size()) == 0);
ASSERT((length % blockSize()) == 0); ASSERT((length % block_size()) == 0);
dword firstBlock = offset / blockSize(); dword firstBlock = offset / block_size();
dword endBlock = (offset + length) / blockSize(); dword endBlock = (offset + length) / block_size();
ASSERT(firstBlock <= 0xffffffff); ASSERT(firstBlock <= 0xffffffff);
ASSERT(endBlock <= 0xffffffff); ASSERT(endBlock <= 0xffffffff);
const byte* inptr = in; const byte* inptr = in;
for (unsigned bi = firstBlock; bi < endBlock; ++bi) { for (unsigned bi = firstBlock; bi < endBlock; ++bi) {
if (!writeBlock(bi, inptr)) if (!write_block(bi, inptr))
return false; return false;
inptr += blockSize(); inptr += block_size();
} }
return true; return true;
} }

6
VirtualFileSystem/DiskDevice.h
View file

@ -14,9 +14,9 @@ class DiskDevice : public Retainable<DiskDevice> {
public: public:
virtual ~DiskDevice(); virtual ~DiskDevice();
virtual unsigned blockSize() const = 0; virtual unsigned block_size() const = 0;
virtual bool readBlock(unsigned index, byte*) const = 0; virtual bool read_block(unsigned index, byte*) const = 0;
virtual bool writeBlock(unsigned index, const byte*) = 0; virtual bool write_block(unsigned index, const byte*) = 0;
virtual const char* class_name() const = 0; virtual const char* class_name() const = 0;
bool read(DiskOffset, unsigned length, byte*) const; bool read(DiskOffset, unsigned length, byte*) const;
bool write(DiskOffset, unsigned length, const byte*); bool write(DiskOffset, unsigned length, const byte*);

8
VirtualFileSystem/Ext2FileSystem.cpp
View file

@ -28,8 +28,8 @@ Ext2FS::~Ext2FS()
ByteBuffer Ext2FS::read_super_block() const ByteBuffer Ext2FS::read_super_block() const
{ {
auto buffer = ByteBuffer::createUninitialized(1024); auto buffer = ByteBuffer::createUninitialized(1024);
device().readBlock(2, buffer.pointer()); device().read_block(2, buffer.pointer());
device().readBlock(3, buffer.offsetPointer(512)); device().read_block(3, buffer.offsetPointer(512));
return buffer; return buffer;
} }
@ -37,9 +37,9 @@ bool Ext2FS::write_super_block(const ext2_super_block& sb)
{ {
const byte* raw = (const byte*)&sb; const byte* raw = (const byte*)&sb;
bool success; bool success;
success = device().writeBlock(2, raw); success = device().write_block(2, raw);
ASSERT(success); ASSERT(success);
success = device().writeBlock(3, raw + 512); success = device().write_block(3, raw + 512);
ASSERT(success); ASSERT(success);
// FIXME: This is an ugly way to refresh the superblock cache. :-| // FIXME: This is an ugly way to refresh the superblock cache. :-|
super_block(); super_block();

36
VirtualFileSystem/FileBackedDiskDevice.cpp
View file

@ -7,44 +7,44 @@
//#define FBBD_DEBUG //#define FBBD_DEBUG
#define IGNORE_FILE_LENGTH // Useful for e.g /dev/hda2 #define IGNORE_FILE_LENGTH // Useful for e.g /dev/hda2
RetainPtr<FileBackedDiskDevice> FileBackedDiskDevice::create(String&& imagePath, unsigned blockSize) RetainPtr<FileBackedDiskDevice> FileBackedDiskDevice::create(String&& image_path, unsigned block_size)
{ {
return adopt(*new FileBackedDiskDevice(std::move(imagePath), blockSize)); return adopt(*new FileBackedDiskDevice(move(image_path), block_size));
} }
FileBackedDiskDevice::FileBackedDiskDevice(String&& imagePath, unsigned blockSize) FileBackedDiskDevice::FileBackedDiskDevice(String&& image_path, unsigned block_size)
: m_imagePath(std::move(imagePath)) : m_image_path(move(image_path))
, m_blockSize(blockSize) , m_block_size(block_size)
{ {
struct stat st; struct stat st;
int result = stat(m_imagePath.characters(), &st); int result = stat(m_image_path.characters(), &st);
ASSERT(result != -1); ASSERT(result != -1);
m_fileLength = st.st_size; m_file_length = st.st_size;
m_file = fopen(m_imagePath.characters(), "r+"); m_file = fopen(m_image_path.characters(), "r+");
} }
FileBackedDiskDevice::~FileBackedDiskDevice() FileBackedDiskDevice::~FileBackedDiskDevice()
{ {
} }
unsigned FileBackedDiskDevice::blockSize() const unsigned FileBackedDiskDevice::block_size() const
{ {
return m_blockSize; return m_block_size;
} }
bool FileBackedDiskDevice::readBlock(unsigned index, byte* out) const bool FileBackedDiskDevice::read_block(unsigned index, byte* out) const
{ {
DiskOffset offset = index * m_blockSize; DiskOffset offset = index * m_block_size;
return readInternal(offset, blockSize(), out); return read_internal(offset, block_size(), out);
} }
bool FileBackedDiskDevice::writeBlock(unsigned index, const byte* data) bool FileBackedDiskDevice::write_block(unsigned index, const byte* data)
{ {
DiskOffset offset = index * m_blockSize; DiskOffset offset = index * m_block_size;
return writeInternal(offset, blockSize(), data); return write_internal(offset, block_size(), data);
} }
bool FileBackedDiskDevice::readInternal(DiskOffset offset, unsigned length, byte* out) const bool FileBackedDiskDevice::read_internal(DiskOffset offset, unsigned length, byte* out) const
{ {
#ifndef IGNORE_FILE_LENGTH #ifndef IGNORE_FILE_LENGTH
if (offset + length >= m_fileLength) if (offset + length >= m_fileLength)
@ -59,7 +59,7 @@ bool FileBackedDiskDevice::readInternal(DiskOffset offset, unsigned length, byte
return true; return true;
} }
bool FileBackedDiskDevice::writeInternal(DiskOffset offset, unsigned length, const byte* data) bool FileBackedDiskDevice::write_internal(DiskOffset offset, unsigned length, const byte* data)
{ {
#ifndef IGNORE_FILE_LENGTH #ifndef IGNORE_FILE_LENGTH
if (offset + length >= m_fileLength) if (offset + length >= m_fileLength)

22
VirtualFileSystem/FileBackedDiskDevice.h
View file

@ -8,26 +8,26 @@
class FileBackedDiskDevice final : public DiskDevice { class FileBackedDiskDevice final : public DiskDevice {
public: public:
static RetainPtr<FileBackedDiskDevice> create(String&& imagePath, unsigned blockSize); static RetainPtr<FileBackedDiskDevice> create(String&& image_path, unsigned block_size);
virtual ~FileBackedDiskDevice() override; virtual ~FileBackedDiskDevice() override;
bool isValid() const { return m_file; } bool is_valid() const { return m_file; }
virtual unsigned blockSize() const override; virtual unsigned block_size() const override;
virtual bool readBlock(unsigned index, byte* out) const override; virtual bool read_block(unsigned index, byte* out) const override;
virtual bool writeBlock(unsigned index, const byte*) override; virtual bool write_block(unsigned index, const byte*) override;
private: private:
virtual const char* class_name() const override; virtual const char* class_name() const override;
bool readInternal(DiskOffset, unsigned length, byte* out) const; bool read_internal(DiskOffset, unsigned length, byte* out) const;
bool writeInternal(DiskOffset, unsigned length, const byte* data); bool write_internal(DiskOffset, unsigned length, const byte* data);
FileBackedDiskDevice(String&& imagePath, unsigned blockSize); FileBackedDiskDevice(String&& imagePath, unsigned block_size);
String m_imagePath; String m_image_path;
FILE* m_file { nullptr }; FILE* m_file { nullptr };
DiskOffset m_fileLength { 0 }; DiskOffset m_file_length { 0 };
unsigned m_blockSize { 0 }; unsigned m_block_size { 0 };
}; };

2
VirtualFileSystem/VirtualFileSystem.cpp
View file

@ -296,7 +296,7 @@ bool VFS::mkdir(const String& path, mode_t mode, InodeIdentifier base, int& erro
error = EWHYTHO; error = EWHYTHO;
// FIXME: This won't work nicely across mount boundaries. // FIXME: This won't work nicely across mount boundaries.
FileSystemPath p(path); FileSystemPath p(path);
if (!p.isValid()) { if (!p.is_valid()) {
error = -EINVAL; error = -EINVAL;
return false; return false;
} }

2
VirtualFileSystem/test.cpp
View file

@ -237,7 +237,7 @@ int main(int c, char** v)
RetainPtr<FS> makeFileSystem(const char* imagePath) RetainPtr<FS> makeFileSystem(const char* imagePath)
{ {
auto fsImage = FileBackedDiskDevice::create(imagePath, 512); auto fsImage = FileBackedDiskDevice::create(imagePath, 512);
if (!fsImage->isValid()) { if (!fsImage->is_valid()) {
fprintf(stderr, "Failed to open fs image file '%s'\n", imagePath); fprintf(stderr, "Failed to open fs image file '%s'\n", imagePath);
exit(1); exit(1);
} }