mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-04-22 04:25:13 +00:00
Yet more coding style fixes.
This commit is contained in:
Andreas Kling
parent
f31e1ceab0
commit
aff89d2fd7
Notes:
sideshowbarker
2024-07-19 16:08:58 +09:00
Author: https://github.com/awesomekling Commit: https://github.com/SerenityOS/serenity/commit/aff89d2fd7c
18 changed files with 197 additions and 199 deletions
|
|
@ -8,35 +8,35 @@ namespace AK {
|
|||
FileSystemPath::FileSystemPath(const 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"
|
||||
(void) resolveSymbolicLinks;
|
||||
(void) resolve_symbolic_links;
|
||||
auto parts = m_string.split('/');
|
||||
Vector<String> canonicalParts;
|
||||
Vector<String> canonical_parts;
|
||||
|
||||
for (auto& part : parts) {
|
||||
if (part == ".")
|
||||
continue;
|
||||
if (part == "..") {
|
||||
if (!canonicalParts.isEmpty())
|
||||
canonicalParts.takeLast();
|
||||
if (!canonical_parts.isEmpty())
|
||||
canonical_parts.takeLast();
|
||||
continue;
|
||||
}
|
||||
if (!part.isEmpty())
|
||||
canonicalParts.append(part);
|
||||
canonical_parts.append(part);
|
||||
}
|
||||
if (canonicalParts.isEmpty()) {
|
||||
if (canonical_parts.isEmpty()) {
|
||||
m_string = m_basename = "/";
|
||||
return true;
|
||||
}
|
||||
|
||||
m_basename = canonicalParts.last();
|
||||
m_basename = canonical_parts.last();
|
||||
StringBuilder builder;
|
||||
for (auto& cpart : canonicalParts) {
|
||||
for (auto& cpart : canonical_parts) {
|
||||
builder.append('/');
|
||||
builder.append(move(cpart));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,17 +9,17 @@ public:
|
|||
FileSystemPath() { }
|
||||
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 basename() const { return m_basename; }
|
||||
|
||||
private:
|
||||
bool canonicalize(bool resolveSymbolicLinks = false);
|
||||
bool canonicalize(bool resolve_symbolic_links = false);
|
||||
|
||||
String m_string;
|
||||
String m_basename;
|
||||
bool m_isValid { false };
|
||||
bool m_is_valid { false };
|
||||
};
|
||||
|
||||
};
|
||||
|
|
|
|||
|
|
@ -42,11 +42,11 @@ ssize_t Console::write(const byte* data, size_t size)
|
|||
if (!m_implementation)
|
||||
return 0;
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
putChar(data[i]);
|
||||
put_char(data[i]);
|
||||
return size;
|
||||
}
|
||||
|
||||
void Console::putChar(char ch)
|
||||
void Console::put_char(char ch)
|
||||
{
|
||||
#ifdef CONSOLE_OUT_TO_E9
|
||||
//if (ch != 27)
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ public:
|
|||
|
||||
void setImplementation(ConsoleImplementation* implementation) { m_implementation = implementation; }
|
||||
|
||||
void putChar(char);
|
||||
void put_char(char);
|
||||
|
||||
private:
|
||||
ConsoleImplementation* m_implementation { nullptr };
|
||||
|
|
|
|||
|
|
@ -52,18 +52,18 @@ const char* IDEDiskDevice::class_name() const
|
|||
return "IDEDiskDevice";
|
||||
}
|
||||
|
||||
unsigned IDEDiskDevice::blockSize() const
|
||||
unsigned IDEDiskDevice::block_size() const
|
||||
{
|
||||
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);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool IDEDiskDevice::writeBlock(unsigned index, const byte* data)
|
||||
bool IDEDiskDevice::write_block(unsigned index, const byte* data)
|
||||
{
|
||||
write_sectors(index, 1, data);
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -11,9 +11,9 @@ public:
|
|||
virtual ~IDEDiskDevice() override;
|
||||
|
||||
// ^DiskDevice
|
||||
virtual unsigned blockSize() const override;
|
||||
virtual bool readBlock(unsigned index, byte*) const override;
|
||||
virtual bool writeBlock(unsigned index, const byte*) override;
|
||||
virtual unsigned block_size() const override;
|
||||
virtual bool read_block(unsigned index, byte*) const override;
|
||||
virtual bool write_block(unsigned index, const byte*) override;
|
||||
|
||||
protected:
|
||||
IDEDiskDevice();
|
||||
|
|
|
|||
|
|
@ -21,12 +21,12 @@ MemoryManager& MM
|
|||
MemoryManager::MemoryManager()
|
||||
{
|
||||
m_kernel_page_directory = (PageDirectory*)0x4000;
|
||||
m_pageTableZero = (dword*)0x6000;
|
||||
m_pageTableOne = (dword*)0x7000;
|
||||
m_page_table_zero = (dword*)0x6000;
|
||||
m_page_table_one = (dword*)0x7000;
|
||||
|
||||
m_next_laddr.set(0xd0000000);
|
||||
|
||||
initializePaging();
|
||||
initialize_paging();
|
||||
}
|
||||
|
||||
MemoryManager::~MemoryManager()
|
||||
|
|
@ -60,12 +60,12 @@ void MemoryManager::release_page_directory(PageDirectory& page_directory)
|
|||
#endif
|
||||
}
|
||||
|
||||
void MemoryManager::initializePaging()
|
||||
void MemoryManager::initialize_paging()
|
||||
{
|
||||
static_assert(sizeof(MemoryManager::PageDirectoryEntry) == 4);
|
||||
static_assert(sizeof(MemoryManager::PageTableEntry) == 4);
|
||||
memset(m_pageTableZero, 0, PAGE_SIZE);
|
||||
memset(m_pageTableOne, 0, PAGE_SIZE);
|
||||
memset(m_page_table_zero, 0, PAGE_SIZE);
|
||||
memset(m_page_table_one, 0, PAGE_SIZE);
|
||||
memset(m_kernel_page_directory, 0, sizeof(PageDirectory));
|
||||
|
||||
#ifdef MM_DEBUG
|
||||
|
|
@ -73,7 +73,7 @@ void MemoryManager::initializePaging()
|
|||
#endif
|
||||
|
||||
// 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.
|
||||
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);
|
||||
for (dword offset = 0; offset < size; offset += PAGE_SIZE) {
|
||||
auto pte_address = laddr.offset(offset);
|
||||
auto pte = ensurePTE(m_kernel_page_directory, pte_address);
|
||||
pte.setPhysicalPageBase(0);
|
||||
pte.setUserAllowed(false);
|
||||
pte.setPresent(true);
|
||||
pte.setWritable(true);
|
||||
flushTLB(pte_address);
|
||||
auto pte = ensure_pte(m_kernel_page_directory, pte_address);
|
||||
pte.set_physical_page_base(0);
|
||||
pte.set_user_allowed(false);
|
||||
pte.set_present(true);
|
||||
pte.set_writable(true);
|
||||
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();
|
||||
dword page_directory_index = (laddr.get() >> 22) & 0x3ff;
|
||||
dword page_table_index = (laddr.get() >> 12) & 0x3ff;
|
||||
|
||||
PageDirectoryEntry pde = PageDirectoryEntry(&page_directory->entries[page_directory_index]);
|
||||
if (!pde.isPresent()) {
|
||||
if (!pde.is_present()) {
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: PDE %u not present, allocating\n", page_directory_index);
|
||||
#endif
|
||||
if (page_directory_index == 0) {
|
||||
ASSERT(page_directory == m_kernel_page_directory);
|
||||
pde.setPageTableBase((dword)m_pageTableZero);
|
||||
pde.setUserAllowed(false);
|
||||
pde.setPresent(true);
|
||||
pde.setWritable(true);
|
||||
pde.setPageTableBase((dword)m_page_table_zero);
|
||||
pde.set_user_allowed(false);
|
||||
pde.set_present(true);
|
||||
pde.set_writable(true);
|
||||
} else if (page_directory_index == 1) {
|
||||
ASSERT(page_directory == m_kernel_page_directory);
|
||||
pde.setPageTableBase((dword)m_pageTableOne);
|
||||
pde.setUserAllowed(false);
|
||||
pde.setPresent(true);
|
||||
pde.setWritable(true);
|
||||
pde.setPageTableBase((dword)m_page_table_one);
|
||||
pde.set_user_allowed(false);
|
||||
pde.set_present(true);
|
||||
pde.set_writable(true);
|
||||
} else {
|
||||
auto page_table = allocate_page_table(*page_directory, page_directory_index);
|
||||
#ifdef MM_DEBUG
|
||||
|
|
@ -167,27 +167,27 @@ auto MemoryManager::ensurePTE(PageDirectory* page_directory, LinearAddress laddr
|
|||
#endif
|
||||
|
||||
pde.setPageTableBase(page_table->paddr().get());
|
||||
pde.setUserAllowed(true);
|
||||
pde.setPresent(true);
|
||||
pde.setWritable(true);
|
||||
pde.set_user_allowed(true);
|
||||
pde.set_present(true);
|
||||
pde.set_writable(true);
|
||||
page_directory->physical_pages[page_directory_index] = move(page_table);
|
||||
}
|
||||
}
|
||||
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;
|
||||
// FIXME: ASSERT(linearAddress is 4KB aligned);
|
||||
for (dword offset = 0; offset < length; offset += PAGE_SIZE) {
|
||||
auto pteAddress = linearAddress.offset(offset);
|
||||
auto pte = ensurePTE(m_kernel_page_directory, pteAddress);
|
||||
pte.setPhysicalPageBase(pteAddress.get());
|
||||
pte.setUserAllowed(false);
|
||||
pte.setPresent(false);
|
||||
pte.setWritable(false);
|
||||
flushTLB(pteAddress);
|
||||
auto pte = ensure_pte(m_kernel_page_directory, pteAddress);
|
||||
pte.set_physical_page_base(pteAddress.get());
|
||||
pte.set_user_allowed(false);
|
||||
pte.set_present(false);
|
||||
pte.set_writable(false);
|
||||
flush_tlb(pteAddress);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -197,12 +197,12 @@ void MemoryManager::create_identity_mapping(LinearAddress laddr, size_t size)
|
|||
// FIXME: ASSERT(laddr is 4KB aligned);
|
||||
for (dword offset = 0; offset < size; offset += PAGE_SIZE) {
|
||||
auto pteAddress = laddr.offset(offset);
|
||||
auto pte = ensurePTE(m_kernel_page_directory, pteAddress);
|
||||
pte.setPhysicalPageBase(pteAddress.get());
|
||||
pte.setUserAllowed(false);
|
||||
pte.setPresent(true);
|
||||
pte.setWritable(true);
|
||||
flushTLB(pteAddress);
|
||||
auto pte = ensure_pte(m_kernel_page_directory, pteAddress);
|
||||
pte.set_physical_page_base(pteAddress.get());
|
||||
pte.set_user_allowed(false);
|
||||
pte.set_present(true);
|
||||
pte.set_writable(true);
|
||||
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");
|
||||
}
|
||||
|
||||
void MemoryManager::flushEntireTLB()
|
||||
void MemoryManager::flush_entire_tlb()
|
||||
{
|
||||
asm volatile(
|
||||
"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");
|
||||
}
|
||||
|
|
@ -406,12 +406,12 @@ byte* MemoryManager::quickmap_page(PhysicalPage& physical_page)
|
|||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
auto page_laddr = LinearAddress(4 * MB);
|
||||
auto pte = ensurePTE(m_kernel_page_directory, page_laddr);
|
||||
pte.setPhysicalPageBase(physical_page.paddr().get());
|
||||
pte.setPresent(true); // FIXME: Maybe we should use the is_readable flag here?
|
||||
pte.setWritable(true);
|
||||
pte.setUserAllowed(false);
|
||||
flushTLB(page_laddr);
|
||||
auto pte = ensure_pte(m_kernel_page_directory, page_laddr);
|
||||
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_writable(true);
|
||||
pte.set_user_allowed(false);
|
||||
flush_tlb(page_laddr);
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: >> quickmap_page L%x => P%x\n", page_laddr, physical_page.paddr().get());
|
||||
#endif
|
||||
|
|
@ -422,15 +422,15 @@ void MemoryManager::unquickmap_page()
|
|||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
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
|
||||
auto old_physical_address = pte.physicalPageBase();
|
||||
#endif
|
||||
pte.setPhysicalPageBase(0);
|
||||
pte.setPresent(false);
|
||||
pte.setWritable(false);
|
||||
pte.setUserAllowed(false);
|
||||
flushTLB(page_laddr);
|
||||
pte.set_physical_page_base(0);
|
||||
pte.set_present(false);
|
||||
pte.set_writable(false);
|
||||
pte.set_user_allowed(false);
|
||||
flush_tlb(page_laddr);
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: >> unquickmap_page L%x =/> P%x\n", page_laddr, old_physical_address);
|
||||
#endif
|
||||
|
|
@ -440,18 +440,18 @@ void MemoryManager::remap_region_page(PageDirectory* page_directory, Region& reg
|
|||
{
|
||||
InterruptDisabler disabler;
|
||||
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];
|
||||
ASSERT(physical_page);
|
||||
pte.setPhysicalPageBase(physical_page->paddr().get());
|
||||
pte.setPresent(true); // FIXME: Maybe we should use the is_readable flag here?
|
||||
pte.set_physical_page_base(physical_page->paddr().get());
|
||||
pte.set_present(true); // FIXME: Maybe we should use the is_readable flag here?
|
||||
if (region.cow_map.get(page_index_in_region))
|
||||
pte.setWritable(false);
|
||||
pte.set_writable(false);
|
||||
else
|
||||
pte.setWritable(region.is_writable);
|
||||
pte.setUserAllowed(user_allowed);
|
||||
pte.set_writable(region.is_writable);
|
||||
pte.set_user_allowed(user_allowed);
|
||||
if (page_directory->is_active())
|
||||
flushTLB(page_laddr);
|
||||
flush_tlb(page_laddr);
|
||||
#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());
|
||||
#endif
|
||||
|
|
@ -472,23 +472,23 @@ void MemoryManager::map_region_at_address(PageDirectory* page_directory, Region&
|
|||
#endif
|
||||
for (size_t i = region.first_page_index(); i <= region.last_page_index(); ++i) {
|
||||
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];
|
||||
if (physical_page) {
|
||||
pte.setPhysicalPageBase(physical_page->paddr().get());
|
||||
pte.setPresent(true); // FIXME: Maybe we should use the is_readable flag here?
|
||||
pte.set_physical_page_base(physical_page->paddr().get());
|
||||
pte.set_present(true); // FIXME: Maybe we should use the is_readable flag here?
|
||||
if (region.cow_map.get(i))
|
||||
pte.setWritable(false);
|
||||
pte.set_writable(false);
|
||||
else
|
||||
pte.setWritable(region.is_writable);
|
||||
pte.set_writable(region.is_writable);
|
||||
} else {
|
||||
pte.setPhysicalPageBase(0);
|
||||
pte.setPresent(false);
|
||||
pte.setWritable(region.is_writable);
|
||||
pte.set_physical_page_base(0);
|
||||
pte.set_present(false);
|
||||
pte.set_writable(region.is_writable);
|
||||
}
|
||||
pte.setUserAllowed(user_allowed);
|
||||
pte.set_user_allowed(user_allowed);
|
||||
if (page_directory->is_active())
|
||||
flushTLB(page_laddr);
|
||||
flush_tlb(page_laddr);
|
||||
#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());
|
||||
#endif
|
||||
|
|
@ -503,13 +503,13 @@ void MemoryManager::unmap_range(PageDirectory* page_directory, LinearAddress lad
|
|||
size_t numPages = size / PAGE_SIZE;
|
||||
for (size_t i = 0; i < numPages; ++i) {
|
||||
auto page_laddr = laddr.offset(i * PAGE_SIZE);
|
||||
auto pte = ensurePTE(page_directory, page_laddr);
|
||||
pte.setPhysicalPageBase(0);
|
||||
pte.setPresent(false);
|
||||
pte.setWritable(false);
|
||||
pte.setUserAllowed(false);
|
||||
auto pte = ensure_pte(page_directory, page_laddr);
|
||||
pte.set_physical_page_base(0);
|
||||
pte.set_present(false);
|
||||
pte.set_writable(false);
|
||||
pte.set_user_allowed(false);
|
||||
if (page_directory->is_active())
|
||||
flushTLB(page_laddr);
|
||||
flush_tlb(page_laddr);
|
||||
#ifdef MM_DEBUG
|
||||
dbgprintf("MM: << unmap_range L%x =/> 0\n", page_laddr);
|
||||
#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);
|
||||
}
|
||||
|
||||
bool MemoryManager::unmapRegion(Process& process, Region& region)
|
||||
bool MemoryManager::unmap_region(Process& process, Region& region)
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
for (size_t i = 0; i < region.page_count(); ++i) {
|
||||
auto laddr = region.linearAddress.offset(i * PAGE_SIZE);
|
||||
auto pte = ensurePTE(process.m_page_directory, laddr);
|
||||
pte.setPhysicalPageBase(0);
|
||||
pte.setPresent(false);
|
||||
pte.setWritable(false);
|
||||
pte.setUserAllowed(false);
|
||||
auto pte = ensure_pte(process.m_page_directory, laddr);
|
||||
pte.set_physical_page_base(0);
|
||||
pte.set_present(false);
|
||||
pte.set_writable(false);
|
||||
pte.set_user_allowed(false);
|
||||
if (process.m_page_directory->is_active())
|
||||
flushTLB(laddr);
|
||||
flush_tlb(laddr);
|
||||
#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);
|
||||
|
|
@ -568,7 +568,7 @@ bool MemoryManager::unmapRegion(Process& process, Region& region)
|
|||
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);
|
||||
return true;
|
||||
|
|
@ -579,12 +579,12 @@ bool MemoryManager::validate_user_read(const Process& process, LinearAddress lad
|
|||
dword pageDirectoryIndex = (laddr.get() >> 22) & 0x3ff;
|
||||
dword pageTableIndex = (laddr.get() >> 12) & 0x3ff;
|
||||
auto pde = PageDirectoryEntry(&process.m_page_directory->entries[pageDirectoryIndex]);
|
||||
if (!pde.isPresent())
|
||||
if (!pde.is_present())
|
||||
return false;
|
||||
auto pte = PageTableEntry(&pde.pageTableBase()[pageTableIndex]);
|
||||
if (!pte.isPresent())
|
||||
if (!pte.is_present())
|
||||
return false;
|
||||
if (!pte.isUserAllowed())
|
||||
if (!pte.is_user_allowed())
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
|
@ -594,14 +594,14 @@ bool MemoryManager::validate_user_write(const Process& process, LinearAddress la
|
|||
dword pageDirectoryIndex = (laddr.get() >> 22) & 0x3ff;
|
||||
dword pageTableIndex = (laddr.get() >> 12) & 0x3ff;
|
||||
auto pde = PageDirectoryEntry(&process.m_page_directory->entries[pageDirectoryIndex]);
|
||||
if (!pde.isPresent())
|
||||
if (!pde.is_present())
|
||||
return false;
|
||||
auto pte = PageTableEntry(&pde.pageTableBase()[pageTableIndex]);
|
||||
if (!pte.isPresent())
|
||||
if (!pte.is_present())
|
||||
return false;
|
||||
if (!pte.isUserAllowed())
|
||||
if (!pte.is_user_allowed())
|
||||
return false;
|
||||
if (!pte.isWritable())
|
||||
if (!pte.is_writable())
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -156,14 +156,12 @@ class MemoryManager {
|
|||
public:
|
||||
static MemoryManager& the() PURE;
|
||||
|
||||
PhysicalAddress pageDirectoryBase() const { return PhysicalAddress(reinterpret_cast<dword>(m_kernel_page_directory)); }
|
||||
|
||||
static void initialize();
|
||||
|
||||
PageFaultResponse handle_page_fault(const PageFault&);
|
||||
|
||||
bool mapRegion(Process&, Region&);
|
||||
bool unmapRegion(Process&, Region&);
|
||||
bool map_region(Process&, Region&);
|
||||
bool unmap_region(Process&, Region&);
|
||||
|
||||
void populate_page_directory(PageDirectory&);
|
||||
void release_page_directory(PageDirectory&);
|
||||
|
|
@ -195,14 +193,14 @@ private:
|
|||
void unmap_range(PageDirectory*, LinearAddress, size_t);
|
||||
void remap_region_page(PageDirectory*, Region&, unsigned page_index_in_region, bool user_allowed);
|
||||
|
||||
void initializePaging();
|
||||
void flushEntireTLB();
|
||||
void flushTLB(LinearAddress);
|
||||
void initialize_paging();
|
||||
void flush_entire_tlb();
|
||||
void flush_tlb(LinearAddress);
|
||||
|
||||
RetainPtr<PhysicalPage> allocate_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 remove_identity_mapping(LinearAddress, size_t);
|
||||
|
|
@ -235,16 +233,16 @@ private:
|
|||
UserSupervisor = 1 << 2,
|
||||
};
|
||||
|
||||
bool isPresent() const { return raw() & Present; }
|
||||
void setPresent(bool b) { setBit(Present, b); }
|
||||
bool is_present() const { return raw() & Present; }
|
||||
void set_present(bool b) { set_bit(Present, b); }
|
||||
|
||||
bool isUserAllowed() const { return raw() & UserSupervisor; }
|
||||
void setUserAllowed(bool b) { setBit(UserSupervisor, b); }
|
||||
bool is_user_allowed() const { return raw() & UserSupervisor; }
|
||||
void set_user_allowed(bool b) { set_bit(UserSupervisor, b); }
|
||||
|
||||
bool isWritable() const { return raw() & ReadWrite; }
|
||||
void setWritable(bool b) { setBit(ReadWrite, b); }
|
||||
bool is_writable() const { return raw() & ReadWrite; }
|
||||
void set_writable(bool b) { set_bit(ReadWrite, b); }
|
||||
|
||||
void setBit(byte bit, bool value)
|
||||
void set_bit(byte bit, bool value)
|
||||
{
|
||||
if (value)
|
||||
*m_pde |= bit;
|
||||
|
|
@ -258,8 +256,8 @@ private:
|
|||
struct PageTableEntry {
|
||||
explicit PageTableEntry(dword* pte) : m_pte(pte) { }
|
||||
|
||||
dword* physicalPageBase() { return reinterpret_cast<dword*>(raw() & 0xfffff000u); }
|
||||
void setPhysicalPageBase(dword value)
|
||||
dword* physical_page_base() { return reinterpret_cast<dword*>(raw() & 0xfffff000u); }
|
||||
void set_physical_page_base(dword value)
|
||||
{
|
||||
*m_pte &= 0xfffu;
|
||||
*m_pte |= value & 0xfffff000u;
|
||||
|
|
@ -274,16 +272,16 @@ private:
|
|||
UserSupervisor = 1 << 2,
|
||||
};
|
||||
|
||||
bool isPresent() const { return raw() & Present; }
|
||||
void setPresent(bool b) { setBit(Present, b); }
|
||||
bool is_present() const { return raw() & Present; }
|
||||
void set_present(bool b) { set_bit(Present, b); }
|
||||
|
||||
bool isUserAllowed() const { return raw() & UserSupervisor; }
|
||||
void setUserAllowed(bool b) { setBit(UserSupervisor, b); }
|
||||
bool is_user_allowed() const { return raw() & UserSupervisor; }
|
||||
void set_user_allowed(bool b) { set_bit(UserSupervisor, b); }
|
||||
|
||||
bool isWritable() const { return raw() & ReadWrite; }
|
||||
void setWritable(bool b) { setBit(ReadWrite, b); }
|
||||
bool is_writable() const { return raw() & ReadWrite; }
|
||||
void set_writable(bool b) { set_bit(ReadWrite, b); }
|
||||
|
||||
void setBit(byte bit, bool value)
|
||||
void set_bit(byte bit, bool value)
|
||||
{
|
||||
if (value)
|
||||
*m_pte |= bit;
|
||||
|
|
@ -294,11 +292,11 @@ private:
|
|||
dword* m_pte;
|
||||
};
|
||||
|
||||
PageTableEntry ensurePTE(PageDirectory*, LinearAddress);
|
||||
PageTableEntry ensure_pte(PageDirectory*, LinearAddress);
|
||||
|
||||
PageDirectory* m_kernel_page_directory;
|
||||
dword* m_pageTableZero;
|
||||
dword* m_pageTableOne;
|
||||
dword* m_page_table_zero;
|
||||
dword* m_page_table_one;
|
||||
|
||||
LinearAddress m_next_laddr;
|
||||
|
||||
|
|
|
|||
|
|
@ -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)));
|
||||
if (commit)
|
||||
m_regions.last()->commit(*this);
|
||||
MM.mapRegion(*this, *m_regions.last());
|
||||
MM.map_region(*this, *m_regions.last());
|
||||
return m_regions.last().ptr();
|
||||
}
|
||||
|
||||
|
|
@ -91,7 +91,7 @@ Region* Process::allocate_file_backed_region(LinearAddress laddr, size_t size, R
|
|||
}
|
||||
laddr.mask(0xfffff000);
|
||||
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();
|
||||
}
|
||||
|
||||
|
|
@ -107,7 +107,7 @@ Region* Process::allocate_region_with_vmo(LinearAddress laddr, size_t size, Reta
|
|||
offset_in_vmo &= PAGE_MASK;
|
||||
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)));
|
||||
MM.mapRegion(*this, *m_regions.last());
|
||||
MM.map_region(*this, *m_regions.last());
|
||||
return m_regions.last().ptr();
|
||||
}
|
||||
|
||||
|
|
@ -116,7 +116,7 @@ bool Process::deallocate_region(Region& region)
|
|||
InterruptDisabler disabler;
|
||||
for (size_t i = 0; i < m_regions.size(); ++i) {
|
||||
if (m_regions[i].ptr() == ®ion) {
|
||||
MM.unmapRegion(*this, region);
|
||||
MM.unmap_region(*this, region);
|
||||
m_regions.remove(i);
|
||||
return true;
|
||||
}
|
||||
|
|
@ -231,7 +231,7 @@ Process* Process::fork(RegisterDump& regs)
|
|||
#endif
|
||||
auto cloned_region = region->clone();
|
||||
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 :^)
|
||||
|
|
@ -510,7 +510,7 @@ int Process::sys$get_environment(char*** environ)
|
|||
auto* region = allocate_region(LinearAddress(), PAGE_SIZE, "environ");
|
||||
if (!region)
|
||||
return -ENOMEM;
|
||||
MM.mapRegion(*this, *region);
|
||||
MM.map_region(*this, *region);
|
||||
char* envpage = (char*)region->linearAddress.get();
|
||||
*environ = (char**)envpage;
|
||||
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");
|
||||
if (!region)
|
||||
return -ENOMEM;
|
||||
MM.mapRegion(*this, *region);
|
||||
MM.map_region(*this, *region);
|
||||
char* argpage = (char*)region->linearAddress.get();
|
||||
*argc = m_arguments.size();
|
||||
*argv = (char**)argpage;
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ static dword handle(RegisterDump& regs, dword function, dword arg1, dword arg2,
|
|||
Scheduler::yield();
|
||||
break;
|
||||
case Syscall::SC_putch:
|
||||
Console::the().putChar(arg1 & 0xff);
|
||||
Console::the().put_char(arg1 & 0xff);
|
||||
break;
|
||||
case Syscall::SC_sleep:
|
||||
return current->sys$sleep((unsigned)arg1);
|
||||
|
|
|
|||
|
|
@ -181,7 +181,7 @@ static int sh_cd(int argc, const char** argv)
|
|||
sprintf(pathbuf, "%s/%s", g->cwd.characters(), argv[1]);
|
||||
|
||||
FileSystemPath canonicalPath(pathbuf);
|
||||
if (!canonicalPath.isValid()) {
|
||||
if (!canonicalPath.is_valid()) {
|
||||
printf("FileSystemPath failed to canonicalize '%s'\n", pathbuf);
|
||||
return 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,32 +11,32 @@ DiskDevice::~DiskDevice()
|
|||
bool DiskDevice::read(DiskOffset offset, unsigned length, byte* out) const
|
||||
{
|
||||
//kprintf("DD::read %u x%u\n", offset, length);
|
||||
ASSERT((offset % blockSize()) == 0);
|
||||
ASSERT((length % blockSize()) == 0);
|
||||
dword firstBlock = offset / blockSize();
|
||||
dword endBlock = (offset + length) / blockSize();
|
||||
ASSERT((offset % block_size()) == 0);
|
||||
ASSERT((length % block_size()) == 0);
|
||||
dword firstBlock = offset / block_size();
|
||||
dword endBlock = (offset + length) / block_size();
|
||||
byte* outptr = out;
|
||||
for (unsigned bi = firstBlock; bi < endBlock; ++bi) {
|
||||
if (!readBlock(bi, outptr))
|
||||
if (!read_block(bi, outptr))
|
||||
return false;
|
||||
outptr += blockSize();
|
||||
outptr += block_size();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool DiskDevice::write(DiskOffset offset, unsigned length, const byte* in)
|
||||
{
|
||||
ASSERT((offset % blockSize()) == 0);
|
||||
ASSERT((length % blockSize()) == 0);
|
||||
dword firstBlock = offset / blockSize();
|
||||
dword endBlock = (offset + length) / blockSize();
|
||||
ASSERT((offset % block_size()) == 0);
|
||||
ASSERT((length % block_size()) == 0);
|
||||
dword firstBlock = offset / block_size();
|
||||
dword endBlock = (offset + length) / block_size();
|
||||
ASSERT(firstBlock <= 0xffffffff);
|
||||
ASSERT(endBlock <= 0xffffffff);
|
||||
const byte* inptr = in;
|
||||
for (unsigned bi = firstBlock; bi < endBlock; ++bi) {
|
||||
if (!writeBlock(bi, inptr))
|
||||
if (!write_block(bi, inptr))
|
||||
return false;
|
||||
inptr += blockSize();
|
||||
inptr += block_size();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,9 +14,9 @@ class DiskDevice : public Retainable<DiskDevice> {
|
|||
public:
|
||||
virtual ~DiskDevice();
|
||||
|
||||
virtual unsigned blockSize() const = 0;
|
||||
virtual bool readBlock(unsigned index, byte*) const = 0;
|
||||
virtual bool writeBlock(unsigned index, const byte*) = 0;
|
||||
virtual unsigned block_size() const = 0;
|
||||
virtual bool read_block(unsigned index, byte*) const = 0;
|
||||
virtual bool write_block(unsigned index, const byte*) = 0;
|
||||
virtual const char* class_name() const = 0;
|
||||
bool read(DiskOffset, unsigned length, byte*) const;
|
||||
bool write(DiskOffset, unsigned length, const byte*);
|
||||
|
|
|
|||
|
|
@ -28,8 +28,8 @@ Ext2FS::~Ext2FS()
|
|||
ByteBuffer Ext2FS::read_super_block() const
|
||||
{
|
||||
auto buffer = ByteBuffer::createUninitialized(1024);
|
||||
device().readBlock(2, buffer.pointer());
|
||||
device().readBlock(3, buffer.offsetPointer(512));
|
||||
device().read_block(2, buffer.pointer());
|
||||
device().read_block(3, buffer.offsetPointer(512));
|
||||
return buffer;
|
||||
}
|
||||
|
||||
|
|
@ -37,9 +37,9 @@ bool Ext2FS::write_super_block(const ext2_super_block& sb)
|
|||
{
|
||||
const byte* raw = (const byte*)&sb;
|
||||
bool success;
|
||||
success = device().writeBlock(2, raw);
|
||||
success = device().write_block(2, raw);
|
||||
ASSERT(success);
|
||||
success = device().writeBlock(3, raw + 512);
|
||||
success = device().write_block(3, raw + 512);
|
||||
ASSERT(success);
|
||||
// FIXME: This is an ugly way to refresh the superblock cache. :-|
|
||||
super_block();
|
||||
|
|
|
|||
|
|
@ -7,44 +7,44 @@
|
|||
//#define FBBD_DEBUG
|
||||
#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)
|
||||
: m_imagePath(std::move(imagePath))
|
||||
, m_blockSize(blockSize)
|
||||
FileBackedDiskDevice::FileBackedDiskDevice(String&& image_path, unsigned block_size)
|
||||
: m_image_path(move(image_path))
|
||||
, m_block_size(block_size)
|
||||
{
|
||||
struct stat st;
|
||||
int result = stat(m_imagePath.characters(), &st);
|
||||
int result = stat(m_image_path.characters(), &st);
|
||||
ASSERT(result != -1);
|
||||
m_fileLength = st.st_size;
|
||||
m_file = fopen(m_imagePath.characters(), "r+");
|
||||
m_file_length = st.st_size;
|
||||
m_file = fopen(m_image_path.characters(), "r+");
|
||||
}
|
||||
|
||||
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;
|
||||
return readInternal(offset, blockSize(), out);
|
||||
DiskOffset offset = index * m_block_size;
|
||||
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;
|
||||
return writeInternal(offset, blockSize(), data);
|
||||
DiskOffset offset = index * m_block_size;
|
||||
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
|
||||
if (offset + length >= m_fileLength)
|
||||
|
|
@ -59,7 +59,7 @@ bool FileBackedDiskDevice::readInternal(DiskOffset offset, unsigned length, byte
|
|||
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
|
||||
if (offset + length >= m_fileLength)
|
||||
|
|
|
|||
|
|
@ -8,26 +8,26 @@
|
|||
|
||||
class FileBackedDiskDevice final : public DiskDevice {
|
||||
public:
|
||||
static RetainPtr<FileBackedDiskDevice> create(String&& imagePath, unsigned blockSize);
|
||||
static RetainPtr<FileBackedDiskDevice> create(String&& image_path, unsigned block_size);
|
||||
virtual ~FileBackedDiskDevice() override;
|
||||
|
||||
bool isValid() const { return m_file; }
|
||||
bool is_valid() const { return m_file; }
|
||||
|
||||
virtual unsigned blockSize() const override;
|
||||
virtual bool readBlock(unsigned index, byte* out) const override;
|
||||
virtual bool writeBlock(unsigned index, const byte*) override;
|
||||
virtual unsigned block_size() const override;
|
||||
virtual bool read_block(unsigned index, byte* out) const override;
|
||||
virtual bool write_block(unsigned index, const byte*) override;
|
||||
|
||||
private:
|
||||
virtual const char* class_name() const override;
|
||||
|
||||
bool readInternal(DiskOffset, unsigned length, byte* out) const;
|
||||
bool writeInternal(DiskOffset, unsigned length, const byte* data);
|
||||
bool read_internal(DiskOffset, unsigned length, byte* out) const;
|
||||
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 };
|
||||
DiskOffset m_fileLength { 0 };
|
||||
unsigned m_blockSize { 0 };
|
||||
DiskOffset m_file_length { 0 };
|
||||
unsigned m_block_size { 0 };
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -296,7 +296,7 @@ bool VFS::mkdir(const String& path, mode_t mode, InodeIdentifier base, int& erro
|
|||
error = EWHYTHO;
|
||||
// FIXME: This won't work nicely across mount boundaries.
|
||||
FileSystemPath p(path);
|
||||
if (!p.isValid()) {
|
||||
if (!p.is_valid()) {
|
||||
error = -EINVAL;
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -237,7 +237,7 @@ int main(int c, char** v)
|
|||
RetainPtr<FS> makeFileSystem(const char* imagePath)
|
||||
{
|
||||
auto fsImage = FileBackedDiskDevice::create(imagePath, 512);
|
||||
if (!fsImage->isValid()) {
|
||||
if (!fsImage->is_valid()) {
|
||||
fprintf(stderr, "Failed to open fs image file '%s'\n", imagePath);
|
||||
exit(1);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue