mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-11-26 09:30:24 +00:00
fe237ee215
- Turn Keyboard into a CharacterDevice (85,1) at /dev/keyboard. - Implement MM::unmapRegionsForTask() and MM::unmapRegion() - Save SS correctly on interrupt. - Add a simple Spawn syscall for launching another process. - Move a bunch of IO syscall debug output behind DEBUG_IO. - Have ASSERT do a "cli" immediately when failing. This makes the output look proper every time. - Implement a bunch of syscalls in LibC. - Add a simple shell ("sh"). All it can do now is read a line of text from /dev/keyboard and then try launching the specified executable by calling spawn(). There are definitely bugs in here, but we're moving on forward.
156 lines
3.9 KiB
C++
156 lines
3.9 KiB
C++
#pragma once
|
|
|
|
#include "types.h"
|
|
#include "i386.h"
|
|
#include <AK/Retainable.h>
|
|
#include <AK/RetainPtr.h>
|
|
#include <AK/Vector.h>
|
|
#include <AK/HashMap.h>
|
|
#include "Task.h"
|
|
|
|
class Task;
|
|
|
|
enum class PageFaultResponse {
|
|
ShouldCrash,
|
|
Continue,
|
|
};
|
|
|
|
struct Zone : public Retainable<Zone> {
|
|
public:
|
|
~Zone() { }
|
|
size_t size() const { return m_pages.size() * PAGE_SIZE; }
|
|
|
|
const Vector<PhysicalAddress>& pages() const { return m_pages; }
|
|
|
|
private:
|
|
friend class MemoryManager;
|
|
friend bool copyToZone(Zone&, const void* data, size_t);
|
|
explicit Zone(Vector<PhysicalAddress>&& pages)
|
|
: m_pages(move(pages))
|
|
{
|
|
}
|
|
|
|
Vector<PhysicalAddress> m_pages;
|
|
};
|
|
|
|
bool copyToZone(Zone&, const void* data, size_t);
|
|
|
|
class MemoryManager {
|
|
public:
|
|
static MemoryManager& the();
|
|
|
|
PhysicalAddress pageDirectoryBase() const { return PhysicalAddress(reinterpret_cast<dword>(m_pageDirectory)); }
|
|
|
|
static void initialize();
|
|
|
|
PageFaultResponse handlePageFault(const PageFault&);
|
|
|
|
RetainPtr<Zone> createZone(size_t);
|
|
|
|
// HACK: don't use this jeez :(
|
|
byte* quickMapOnePage(PhysicalAddress);
|
|
|
|
bool mapRegion(Task&, Task::Region&);
|
|
bool unmapRegion(Task&, Task::Region&);
|
|
bool mapRegionsForTask(Task&);
|
|
bool unmapRegionsForTask(Task&);
|
|
|
|
private:
|
|
MemoryManager();
|
|
~MemoryManager();
|
|
|
|
void initializePaging();
|
|
|
|
void protectMap(LinearAddress, size_t length);
|
|
void identityMap(LinearAddress, size_t length);
|
|
|
|
Vector<PhysicalAddress> allocatePhysicalPages(size_t count);
|
|
|
|
struct PageDirectoryEntry {
|
|
explicit PageDirectoryEntry(dword* pde) : m_pde(pde) { }
|
|
|
|
dword* pageTableBase() { return reinterpret_cast<dword*>(raw() & 0xfffff000u); }
|
|
void setPageTableBase(dword value)
|
|
{
|
|
*m_pde &= 0xfff;
|
|
*m_pde |= value & 0xfffff000;
|
|
}
|
|
|
|
dword raw() const { return *m_pde; }
|
|
dword* ptr() { return m_pde; }
|
|
|
|
enum Flags {
|
|
Present = 1 << 0,
|
|
ReadWrite = 1 << 1,
|
|
UserSupervisor = 1 << 2,
|
|
};
|
|
|
|
bool isPresent() const { return raw() & Present; }
|
|
void setPresent(bool b) { setBit(Present, b); }
|
|
|
|
bool isUserAllowed() const { return raw() & UserSupervisor; }
|
|
void setUserAllowed(bool b) { setBit(UserSupervisor, b); }
|
|
|
|
bool isWritable() const { return raw() & ReadWrite; }
|
|
void setWritable(bool b) { setBit(ReadWrite, b); }
|
|
|
|
void setBit(byte bit, bool value)
|
|
{
|
|
if (value)
|
|
*m_pde |= bit;
|
|
else
|
|
*m_pde &= ~bit;
|
|
}
|
|
|
|
dword* m_pde;
|
|
};
|
|
|
|
struct PageTableEntry {
|
|
explicit PageTableEntry(dword* pte) : m_pte(pte) { }
|
|
|
|
dword* physicalPageBase() { return reinterpret_cast<dword*>(raw() & 0xfffff000u); }
|
|
void setPhysicalPageBase(dword value)
|
|
{
|
|
*m_pte &= 0xfffu;
|
|
*m_pte |= value & 0xfffff000u;
|
|
}
|
|
|
|
dword raw() const { return *m_pte; }
|
|
dword* ptr() { return m_pte; }
|
|
|
|
enum Flags {
|
|
Present = 1 << 0,
|
|
ReadWrite = 1 << 1,
|
|
UserSupervisor = 1 << 2,
|
|
};
|
|
|
|
bool isPresent() const { return raw() & Present; }
|
|
void setPresent(bool b) { setBit(Present, b); }
|
|
|
|
bool isUserAllowed() const { return raw() & UserSupervisor; }
|
|
void setUserAllowed(bool b) { setBit(UserSupervisor, b); }
|
|
|
|
bool isWritable() const { return raw() & ReadWrite; }
|
|
void setWritable(bool b) { setBit(ReadWrite, b); }
|
|
|
|
void setBit(byte bit, bool value)
|
|
{
|
|
if (value)
|
|
*m_pte |= bit;
|
|
else
|
|
*m_pte &= ~bit;
|
|
}
|
|
|
|
dword* m_pte;
|
|
};
|
|
|
|
PageTableEntry ensurePTE(LinearAddress);
|
|
|
|
dword* m_pageDirectory;
|
|
dword* m_pageTableZero;
|
|
dword* m_pageTableOne;
|
|
|
|
HashMap<int, RetainPtr<Zone>> m_zones;
|
|
|
|
Vector<PhysicalAddress> m_freePages;
|
|
};
|