mirror of
https://github.com/RGBCube/serenity
synced 2025-07-25 21:07:35 +00:00
AK: Rename the common integer typedefs to make it obvious what they are.
These types can be picked up by including <AK/Types.h>: * u8, u16, u32, u64 (unsigned) * i8, i16, i32, i64 (signed)
This commit is contained in:
parent
c4c4bbc5ba
commit
27f699ef0c
208 changed files with 1603 additions and 1621 deletions
|
@ -13,7 +13,7 @@
|
|||
|
||||
struct [[gnu::packed]] DescriptorTablePointer
|
||||
{
|
||||
word limit;
|
||||
u16 limit;
|
||||
void* address;
|
||||
};
|
||||
|
||||
|
@ -24,18 +24,18 @@ static Descriptor s_gdt[256];
|
|||
|
||||
static IRQHandler* s_irq_handler[16];
|
||||
|
||||
static Vector<word>* s_gdt_freelist;
|
||||
static Vector<u16>* s_gdt_freelist;
|
||||
|
||||
static word s_gdt_length;
|
||||
static u16 s_gdt_length;
|
||||
|
||||
word gdt_alloc_entry()
|
||||
u16 gdt_alloc_entry()
|
||||
{
|
||||
ASSERT(s_gdt_freelist);
|
||||
ASSERT(!s_gdt_freelist->is_empty());
|
||||
return s_gdt_freelist->take_last();
|
||||
}
|
||||
|
||||
void gdt_free_entry(word entry)
|
||||
void gdt_free_entry(u16 entry)
|
||||
{
|
||||
s_gdt_freelist->append(entry);
|
||||
}
|
||||
|
@ -123,8 +123,8 @@ asm(
|
|||
template<typename DumpType>
|
||||
static void dump(const DumpType& regs)
|
||||
{
|
||||
word ss;
|
||||
dword esp;
|
||||
u16 ss;
|
||||
u32 esp;
|
||||
if (!current || current->process().is_ring0()) {
|
||||
ss = regs.ds;
|
||||
esp = regs.esp;
|
||||
|
@ -144,7 +144,7 @@ static void dump(const DumpType& regs)
|
|||
kprintf("ebp=%x esp=%x esi=%x edi=%x\n", regs.ebp, esp, regs.esi, regs.edi);
|
||||
|
||||
if (current && current->process().validate_read((void*)regs.eip, 8)) {
|
||||
byte* codeptr = (byte*)regs.eip;
|
||||
u8* codeptr = (u8*)regs.eip;
|
||||
kprintf("code: %b %b %b %b %b %b %b %b\n",
|
||||
codeptr[0],
|
||||
codeptr[1],
|
||||
|
@ -236,11 +236,11 @@ void exception_14_handler(RegisterDumpWithExceptionCode& regs)
|
|||
{
|
||||
ASSERT(current);
|
||||
|
||||
dword fault_address;
|
||||
u32 fault_address;
|
||||
asm("movl %%cr2, %%eax"
|
||||
: "=a"(fault_address));
|
||||
|
||||
dword fault_page_directory;
|
||||
u32 fault_page_directory;
|
||||
asm("movl %%cr3, %%eax"
|
||||
: "=a"(fault_page_directory));
|
||||
|
||||
|
@ -269,8 +269,8 @@ void exception_14_handler(RegisterDumpWithExceptionCode& regs)
|
|||
regs.exception_code & 2 ? "write to" : "read from",
|
||||
fault_address);
|
||||
|
||||
dword malloc_scrub_pattern = explode_byte(MALLOC_SCRUB_BYTE);
|
||||
dword free_scrub_pattern = explode_byte(FREE_SCRUB_BYTE);
|
||||
u32 malloc_scrub_pattern = explode_byte(MALLOC_SCRUB_BYTE);
|
||||
u32 free_scrub_pattern = explode_byte(FREE_SCRUB_BYTE);
|
||||
if ((fault_address & 0xffff0000) == (malloc_scrub_pattern & 0xffff0000)) {
|
||||
kprintf("\033[33;1mNote: Address %p looks like it may be uninitialized malloc() memory\033[0m\n", fault_address);
|
||||
} else if ((fault_address & 0xffff0000) == (free_scrub_pattern & 0xffff0000)) {
|
||||
|
@ -293,7 +293,7 @@ void exception_14_handler(RegisterDumpWithExceptionCode& regs)
|
|||
static void _exception##i() \
|
||||
{ \
|
||||
kprintf(msg "\n"); \
|
||||
dword cr0, cr2, cr3, cr4; \
|
||||
u32 cr0, cr2, cr3, cr4; \
|
||||
asm("movl %%cr0, %%eax" \
|
||||
: "=a"(cr0)); \
|
||||
asm("movl %%cr2, %%eax" \
|
||||
|
@ -319,9 +319,9 @@ EH(12, "Stack exception")
|
|||
EH(15, "Unknown error")
|
||||
EH(16, "Coprocessor error")
|
||||
|
||||
static void write_raw_gdt_entry(word selector, dword low, dword high)
|
||||
static void write_raw_gdt_entry(u16 selector, u32 low, u32 high)
|
||||
{
|
||||
word i = (selector & 0xfffc) >> 3;
|
||||
u16 i = (selector & 0xfffc) >> 3;
|
||||
s_gdt[i].low = low;
|
||||
s_gdt[i].high = high;
|
||||
|
||||
|
@ -329,14 +329,14 @@ static void write_raw_gdt_entry(word selector, dword low, dword high)
|
|||
s_gdtr.limit = (s_gdt_length + 1) * 8 - 1;
|
||||
}
|
||||
|
||||
void write_gdt_entry(word selector, Descriptor& descriptor)
|
||||
void write_gdt_entry(u16 selector, Descriptor& descriptor)
|
||||
{
|
||||
write_raw_gdt_entry(selector, descriptor.low, descriptor.high);
|
||||
}
|
||||
|
||||
Descriptor& get_gdt_entry(word selector)
|
||||
Descriptor& get_gdt_entry(u16 selector)
|
||||
{
|
||||
word i = (selector & 0xfffc) >> 3;
|
||||
u16 i = (selector & 0xfffc) >> 3;
|
||||
return *(Descriptor*)(&s_gdt[i]);
|
||||
}
|
||||
|
||||
|
@ -352,7 +352,7 @@ void gdt_init()
|
|||
{
|
||||
s_gdt_length = 5;
|
||||
|
||||
s_gdt_freelist = new Vector<word>();
|
||||
s_gdt_freelist = new Vector<u16>();
|
||||
s_gdt_freelist->ensure_capacity(256);
|
||||
for (size_t i = s_gdt_length; i < 256; ++i)
|
||||
s_gdt_freelist->append(i * 8);
|
||||
|
@ -389,30 +389,30 @@ static void unimp_trap()
|
|||
hang();
|
||||
}
|
||||
|
||||
void register_irq_handler(byte irq, IRQHandler& handler)
|
||||
void register_irq_handler(u8 irq, IRQHandler& handler)
|
||||
{
|
||||
ASSERT(!s_irq_handler[irq]);
|
||||
s_irq_handler[irq] = &handler;
|
||||
register_interrupt_handler(IRQ_VECTOR_BASE + irq, asm_irq_entry);
|
||||
}
|
||||
|
||||
void unregister_irq_handler(byte irq, IRQHandler& handler)
|
||||
void unregister_irq_handler(u8 irq, IRQHandler& handler)
|
||||
{
|
||||
ASSERT(s_irq_handler[irq] == &handler);
|
||||
s_irq_handler[irq] = nullptr;
|
||||
}
|
||||
|
||||
void register_interrupt_handler(byte index, void (*f)())
|
||||
void register_interrupt_handler(u8 index, void (*f)())
|
||||
{
|
||||
s_idt[index].low = 0x00080000 | LSW((f));
|
||||
s_idt[index].high = ((dword)(f)&0xffff0000) | 0x8e00;
|
||||
s_idt[index].high = ((u32)(f)&0xffff0000) | 0x8e00;
|
||||
flush_idt();
|
||||
}
|
||||
|
||||
void register_user_callable_interrupt_handler(byte index, void (*f)())
|
||||
void register_user_callable_interrupt_handler(u8 index, void (*f)())
|
||||
{
|
||||
s_idt[index].low = 0x00080000 | LSW((f));
|
||||
s_idt[index].high = ((dword)(f)&0xffff0000) | 0xef00;
|
||||
s_idt[index].high = ((u32)(f)&0xffff0000) | 0xef00;
|
||||
flush_idt();
|
||||
}
|
||||
|
||||
|
@ -437,7 +437,7 @@ void idt_init()
|
|||
s_idtr.address = s_idt;
|
||||
s_idtr.limit = 0x100 * 8 - 1;
|
||||
|
||||
for (byte i = 0xff; i > 0x10; --i)
|
||||
for (u8 i = 0xff; i > 0x10; --i)
|
||||
register_interrupt_handler(i, unimp_trap);
|
||||
|
||||
register_interrupt_handler(0x00, exception_0_entry);
|
||||
|
@ -460,28 +460,28 @@ void idt_init()
|
|||
|
||||
register_interrupt_handler(0x57, irq7_handler);
|
||||
|
||||
for (byte i = 0; i < 16; ++i) {
|
||||
for (u8 i = 0; i < 16; ++i) {
|
||||
s_irq_handler[i] = nullptr;
|
||||
}
|
||||
|
||||
flush_idt();
|
||||
}
|
||||
|
||||
void load_task_register(word selector)
|
||||
void load_task_register(u16 selector)
|
||||
{
|
||||
asm("ltr %0" ::"r"(selector));
|
||||
}
|
||||
|
||||
void handle_irq()
|
||||
{
|
||||
word isr = PIC::get_isr();
|
||||
u16 isr = PIC::get_isr();
|
||||
if (!isr) {
|
||||
kprintf("Spurious IRQ\n");
|
||||
return;
|
||||
}
|
||||
|
||||
byte irq = 0;
|
||||
for (byte i = 0; i < 16; ++i) {
|
||||
u8 irq = 0;
|
||||
for (u8 i = 0; i < 16; ++i) {
|
||||
if (i == 2)
|
||||
continue;
|
||||
if (isr & (1 << i)) {
|
||||
|
|
|
@ -13,45 +13,45 @@ class PageTableEntry;
|
|||
|
||||
struct [[gnu::packed]] TSS32
|
||||
{
|
||||
word backlink, __blh;
|
||||
dword esp0;
|
||||
word ss0, __ss0h;
|
||||
dword esp1;
|
||||
word ss1, __ss1h;
|
||||
dword esp2;
|
||||
word ss2, __ss2h;
|
||||
dword cr3, eip, eflags;
|
||||
dword eax, ecx, edx, ebx, esp, ebp, esi, edi;
|
||||
word es, __esh;
|
||||
word cs, __csh;
|
||||
word ss, __ssh;
|
||||
word ds, __dsh;
|
||||
word fs, __fsh;
|
||||
word gs, __gsh;
|
||||
word ldt, __ldth;
|
||||
word trace, iomapbase;
|
||||
u16 backlink, __blh;
|
||||
u32 esp0;
|
||||
u16 ss0, __ss0h;
|
||||
u32 esp1;
|
||||
u16 ss1, __ss1h;
|
||||
u32 esp2;
|
||||
u16 ss2, __ss2h;
|
||||
u32 cr3, eip, eflags;
|
||||
u32 eax, ecx, edx, ebx, esp, ebp, esi, edi;
|
||||
u16 es, __esh;
|
||||
u16 cs, __csh;
|
||||
u16 ss, __ssh;
|
||||
u16 ds, __dsh;
|
||||
u16 fs, __fsh;
|
||||
u16 gs, __gsh;
|
||||
u16 ldt, __ldth;
|
||||
u16 trace, iomapbase;
|
||||
};
|
||||
|
||||
union [[gnu::packed]] Descriptor
|
||||
{
|
||||
struct {
|
||||
word limit_lo;
|
||||
word base_lo;
|
||||
byte base_hi;
|
||||
byte type : 4;
|
||||
byte descriptor_type : 1;
|
||||
byte dpl : 2;
|
||||
byte segment_present : 1;
|
||||
byte limit_hi : 4;
|
||||
byte : 1;
|
||||
byte zero : 1;
|
||||
byte operation_size : 1;
|
||||
byte granularity : 1;
|
||||
byte base_hi2;
|
||||
u16 limit_lo;
|
||||
u16 base_lo;
|
||||
u8 base_hi;
|
||||
u8 type : 4;
|
||||
u8 descriptor_type : 1;
|
||||
u8 dpl : 2;
|
||||
u8 segment_present : 1;
|
||||
u8 limit_hi : 4;
|
||||
u8 : 1;
|
||||
u8 zero : 1;
|
||||
u8 operation_size : 1;
|
||||
u8 granularity : 1;
|
||||
u8 base_hi2;
|
||||
};
|
||||
struct {
|
||||
dword low;
|
||||
dword high;
|
||||
u32 low;
|
||||
u32 high;
|
||||
};
|
||||
|
||||
enum Type {
|
||||
|
@ -72,15 +72,15 @@ union [[gnu::packed]] Descriptor
|
|||
|
||||
void set_base(void* b)
|
||||
{
|
||||
base_lo = (dword)(b)&0xffff;
|
||||
base_hi = ((dword)(b) >> 16) & 0xff;
|
||||
base_hi2 = ((dword)(b) >> 24) & 0xff;
|
||||
base_lo = (u32)(b)&0xffff;
|
||||
base_hi = ((u32)(b) >> 16) & 0xff;
|
||||
base_hi2 = ((u32)(b) >> 24) & 0xff;
|
||||
}
|
||||
|
||||
void set_limit(dword l)
|
||||
void set_limit(u32 l)
|
||||
{
|
||||
limit_lo = (dword)l & 0xffff;
|
||||
limit_hi = ((dword)l >> 16) & 0xff;
|
||||
limit_lo = (u32)l & 0xffff;
|
||||
limit_hi = ((u32)l >> 16) & 0xff;
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -89,13 +89,13 @@ class PageDirectoryEntry {
|
|||
|
||||
public:
|
||||
PageTableEntry* page_table_base() { return reinterpret_cast<PageTableEntry*>(m_raw & 0xfffff000u); }
|
||||
void set_page_table_base(dword value)
|
||||
void set_page_table_base(u32 value)
|
||||
{
|
||||
m_raw &= 0xfff;
|
||||
m_raw |= value & 0xfffff000;
|
||||
}
|
||||
|
||||
dword raw() const { return m_raw; }
|
||||
u32 raw() const { return m_raw; }
|
||||
void copy_from(Badge<MemoryManager>, const PageDirectoryEntry& other) { m_raw = other.m_raw; }
|
||||
|
||||
enum Flags {
|
||||
|
@ -121,7 +121,7 @@ public:
|
|||
bool is_cache_disabled() const { return raw() & CacheDisabled; }
|
||||
void set_cache_disabled(bool b) { set_bit(CacheDisabled, b); }
|
||||
|
||||
void set_bit(byte bit, bool value)
|
||||
void set_bit(u8 bit, bool value)
|
||||
{
|
||||
if (value)
|
||||
m_raw |= bit;
|
||||
|
@ -130,7 +130,7 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
dword m_raw;
|
||||
u32 m_raw;
|
||||
};
|
||||
|
||||
class PageTableEntry {
|
||||
|
@ -138,13 +138,13 @@ class PageTableEntry {
|
|||
|
||||
public:
|
||||
void* physical_page_base() { return reinterpret_cast<void*>(m_raw & 0xfffff000u); }
|
||||
void set_physical_page_base(dword value)
|
||||
void set_physical_page_base(u32 value)
|
||||
{
|
||||
m_raw &= 0xfff;
|
||||
m_raw |= value & 0xfffff000;
|
||||
}
|
||||
|
||||
dword raw() const { return m_raw; }
|
||||
u32 raw() const { return m_raw; }
|
||||
|
||||
enum Flags {
|
||||
Present = 1 << 0,
|
||||
|
@ -169,7 +169,7 @@ public:
|
|||
bool is_cache_disabled() const { return raw() & CacheDisabled; }
|
||||
void set_cache_disabled(bool b) { set_bit(CacheDisabled, b); }
|
||||
|
||||
void set_bit(byte bit, bool value)
|
||||
void set_bit(u8 bit, bool value)
|
||||
{
|
||||
if (value)
|
||||
m_raw |= bit;
|
||||
|
@ -178,7 +178,7 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
dword m_raw;
|
||||
u32 m_raw;
|
||||
};
|
||||
|
||||
static_assert(sizeof(PageDirectoryEntry) == 4);
|
||||
|
@ -189,17 +189,17 @@ class IRQHandler;
|
|||
void gdt_init();
|
||||
void idt_init();
|
||||
void sse_init();
|
||||
void register_interrupt_handler(byte number, void (*f)());
|
||||
void register_user_callable_interrupt_handler(byte number, void (*f)());
|
||||
void register_irq_handler(byte number, IRQHandler&);
|
||||
void unregister_irq_handler(byte number, IRQHandler&);
|
||||
void register_interrupt_handler(u8 number, void (*f)());
|
||||
void register_user_callable_interrupt_handler(u8 number, void (*f)());
|
||||
void register_irq_handler(u8 number, IRQHandler&);
|
||||
void unregister_irq_handler(u8 number, IRQHandler&);
|
||||
void flush_idt();
|
||||
void flush_gdt();
|
||||
void load_task_register(word selector);
|
||||
word gdt_alloc_entry();
|
||||
void gdt_free_entry(word);
|
||||
Descriptor& get_gdt_entry(word selector);
|
||||
void write_gdt_entry(word selector, Descriptor&);
|
||||
void load_task_register(u16 selector);
|
||||
u16 gdt_alloc_entry();
|
||||
void gdt_free_entry(u16);
|
||||
Descriptor& get_gdt_entry(u16 selector);
|
||||
void write_gdt_entry(u16 selector, Descriptor&);
|
||||
|
||||
[[noreturn]] static inline void hang()
|
||||
{
|
||||
|
@ -208,8 +208,8 @@ void write_gdt_entry(word selector, Descriptor&);
|
|||
}
|
||||
}
|
||||
|
||||
#define LSW(x) ((dword)(x)&0xFFFF)
|
||||
#define MSW(x) (((dword)(x) >> 16) & 0xFFFF)
|
||||
#define LSW(x) ((u32)(x)&0xFFFF)
|
||||
#define MSW(x) (((u32)(x) >> 16) & 0xFFFF)
|
||||
#define LSB(x) ((x)&0xFF)
|
||||
#define MSB(x) (((x) >> 8) & 0xFF)
|
||||
|
||||
|
@ -220,17 +220,17 @@ void write_gdt_entry(word selector, Descriptor&);
|
|||
#define memory_barrier() asm volatile("" :: \
|
||||
: "memory")
|
||||
|
||||
inline dword cpu_cr3()
|
||||
inline u32 cpu_cr3()
|
||||
{
|
||||
dword cr3;
|
||||
u32 cr3;
|
||||
asm volatile("movl %%cr3, %%eax"
|
||||
: "=a"(cr3));
|
||||
return cr3;
|
||||
}
|
||||
|
||||
inline dword cpu_flags()
|
||||
inline u32 cpu_flags()
|
||||
{
|
||||
dword flags;
|
||||
u32 flags;
|
||||
asm volatile(
|
||||
"pushf\n"
|
||||
"pop %0\n"
|
||||
|
@ -259,7 +259,7 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
dword m_flags;
|
||||
u32 m_flags;
|
||||
};
|
||||
|
||||
class InterruptDisabler {
|
||||
|
@ -277,7 +277,7 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
dword m_flags;
|
||||
u32 m_flags;
|
||||
};
|
||||
|
||||
/* Map IRQ0-15 @ ISR 0x50-0x5F */
|
||||
|
@ -297,14 +297,14 @@ struct PageFaultFlags {
|
|||
|
||||
class PageFault {
|
||||
public:
|
||||
PageFault(word code, VirtualAddress vaddr)
|
||||
PageFault(u16 code, VirtualAddress vaddr)
|
||||
: m_code(code)
|
||||
, m_vaddr(vaddr)
|
||||
{
|
||||
}
|
||||
|
||||
VirtualAddress vaddr() const { return m_vaddr; }
|
||||
word code() const { return m_code; }
|
||||
u16 code() const { return m_code; }
|
||||
|
||||
bool is_not_present() const { return (m_code & 1) == PageFaultFlags::NotPresent; }
|
||||
bool is_protection_violation() const { return (m_code & 1) == PageFaultFlags::ProtectionViolation; }
|
||||
|
@ -315,86 +315,86 @@ public:
|
|||
bool is_instruction_fetch() const { return (m_code & 8) == PageFaultFlags::InstructionFetch; }
|
||||
|
||||
private:
|
||||
word m_code;
|
||||
u16 m_code;
|
||||
VirtualAddress m_vaddr;
|
||||
};
|
||||
|
||||
struct [[gnu::packed]] RegisterDump
|
||||
{
|
||||
word ss;
|
||||
word gs;
|
||||
word fs;
|
||||
word es;
|
||||
word ds;
|
||||
dword edi;
|
||||
dword esi;
|
||||
dword ebp;
|
||||
dword esp;
|
||||
dword ebx;
|
||||
dword edx;
|
||||
dword ecx;
|
||||
dword eax;
|
||||
dword eip;
|
||||
word cs;
|
||||
word __csPadding;
|
||||
dword eflags;
|
||||
dword esp_if_crossRing;
|
||||
word ss_if_crossRing;
|
||||
u16 ss;
|
||||
u16 gs;
|
||||
u16 fs;
|
||||
u16 es;
|
||||
u16 ds;
|
||||
u32 edi;
|
||||
u32 esi;
|
||||
u32 ebp;
|
||||
u32 esp;
|
||||
u32 ebx;
|
||||
u32 edx;
|
||||
u32 ecx;
|
||||
u32 eax;
|
||||
u32 eip;
|
||||
u16 cs;
|
||||
u16 __csPadding;
|
||||
u32 eflags;
|
||||
u32 esp_if_crossRing;
|
||||
u16 ss_if_crossRing;
|
||||
};
|
||||
|
||||
struct [[gnu::packed]] RegisterDumpWithExceptionCode
|
||||
{
|
||||
word ss;
|
||||
word gs;
|
||||
word fs;
|
||||
word es;
|
||||
word ds;
|
||||
dword edi;
|
||||
dword esi;
|
||||
dword ebp;
|
||||
dword esp;
|
||||
dword ebx;
|
||||
dword edx;
|
||||
dword ecx;
|
||||
dword eax;
|
||||
word exception_code;
|
||||
word __exception_code_padding;
|
||||
dword eip;
|
||||
word cs;
|
||||
word __csPadding;
|
||||
dword eflags;
|
||||
dword esp_if_crossRing;
|
||||
word ss_if_crossRing;
|
||||
u16 ss;
|
||||
u16 gs;
|
||||
u16 fs;
|
||||
u16 es;
|
||||
u16 ds;
|
||||
u32 edi;
|
||||
u32 esi;
|
||||
u32 ebp;
|
||||
u32 esp;
|
||||
u32 ebx;
|
||||
u32 edx;
|
||||
u32 ecx;
|
||||
u32 eax;
|
||||
u16 exception_code;
|
||||
u16 __exception_code_padding;
|
||||
u32 eip;
|
||||
u16 cs;
|
||||
u16 __csPadding;
|
||||
u32 eflags;
|
||||
u32 esp_if_crossRing;
|
||||
u16 ss_if_crossRing;
|
||||
};
|
||||
|
||||
struct [[gnu::aligned(16)]] FPUState
|
||||
{
|
||||
byte buffer[512];
|
||||
u8 buffer[512];
|
||||
};
|
||||
|
||||
inline constexpr dword page_base_of(dword address)
|
||||
inline constexpr u32 page_base_of(u32 address)
|
||||
{
|
||||
return address & 0xfffff000;
|
||||
}
|
||||
|
||||
class CPUID {
|
||||
public:
|
||||
CPUID(dword function) { asm volatile("cpuid"
|
||||
CPUID(u32 function) { asm volatile("cpuid"
|
||||
: "=a"(m_eax), "=b"(m_ebx), "=c"(m_ecx), "=d"(m_edx)
|
||||
: "a"(function), "c"(0)); }
|
||||
dword eax() const { return m_eax; }
|
||||
dword ebx() const { return m_ebx; }
|
||||
dword ecx() const { return m_ecx; }
|
||||
dword edx() const { return m_edx; }
|
||||
u32 eax() const { return m_eax; }
|
||||
u32 ebx() const { return m_ebx; }
|
||||
u32 ecx() const { return m_ecx; }
|
||||
u32 edx() const { return m_edx; }
|
||||
|
||||
private:
|
||||
dword m_eax { 0xffffffff };
|
||||
dword m_ebx { 0xffffffff };
|
||||
dword m_ecx { 0xffffffff };
|
||||
dword m_edx { 0xffffffff };
|
||||
u32 m_eax { 0xffffffff };
|
||||
u32 m_ebx { 0xffffffff };
|
||||
u32 m_ecx { 0xffffffff };
|
||||
u32 m_edx { 0xffffffff };
|
||||
};
|
||||
|
||||
inline void read_tsc(dword& lsw, dword& msw)
|
||||
inline void read_tsc(u32& lsw, u32& msw)
|
||||
{
|
||||
asm volatile("rdtsc"
|
||||
: "=d"(msw), "=a"(lsw));
|
||||
|
|
|
@ -3,13 +3,13 @@
|
|||
|
||||
namespace CMOS {
|
||||
|
||||
byte read(byte index)
|
||||
u8 read(u8 index)
|
||||
{
|
||||
IO::out8(0x70, index);
|
||||
return IO::in8(0x71);
|
||||
}
|
||||
|
||||
void write(byte index, byte data)
|
||||
void write(u8 index, u8 data)
|
||||
{
|
||||
IO::out8(0x70, index);
|
||||
IO::out8(0x71, data);
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
namespace CMOS {
|
||||
|
||||
byte read(byte index);
|
||||
void write(byte index, byte data);
|
||||
u8 read(u8 index);
|
||||
void write(u8 index, u8 data);
|
||||
|
||||
}
|
||||
|
|
|
@ -28,14 +28,14 @@ bool Console::can_read(FileDescription&) const
|
|||
return false;
|
||||
}
|
||||
|
||||
ssize_t Console::read(FileDescription&, byte*, ssize_t)
|
||||
ssize_t Console::read(FileDescription&, u8*, ssize_t)
|
||||
{
|
||||
// FIXME: Implement reading from the console.
|
||||
// Maybe we could use a ring buffer for this device?
|
||||
return 0;
|
||||
}
|
||||
|
||||
ssize_t Console::write(FileDescription&, const byte* data, ssize_t size)
|
||||
ssize_t Console::write(FileDescription&, const u8* data, ssize_t size)
|
||||
{
|
||||
if (!size)
|
||||
return 0;
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
class ConsoleImplementation {
|
||||
public:
|
||||
virtual ~ConsoleImplementation();
|
||||
virtual void on_sysconsole_receive(byte) = 0;
|
||||
virtual void on_sysconsole_receive(u8) = 0;
|
||||
};
|
||||
|
||||
class Console final : public CharacterDevice {
|
||||
|
@ -21,8 +21,8 @@ public:
|
|||
// ^CharacterDevice
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual const char* class_name() const override { return "Console"; }
|
||||
|
||||
void set_implementation(ConsoleImplementation* implementation) { m_implementation = implementation; }
|
||||
|
|
|
@ -43,7 +43,7 @@ BXVGADevice::BXVGADevice()
|
|||
m_framebuffer_address = PhysicalAddress(find_framebuffer_address());
|
||||
}
|
||||
|
||||
void BXVGADevice::set_register(word index, word data)
|
||||
void BXVGADevice::set_register(u16 index, u16 data)
|
||||
{
|
||||
IO::out16(VBE_DISPI_IOPORT_INDEX, index);
|
||||
IO::out16(VBE_DISPI_IOPORT_DATA, data);
|
||||
|
@ -54,10 +54,10 @@ void BXVGADevice::set_resolution(int width, int height)
|
|||
m_framebuffer_size = { width, height };
|
||||
|
||||
set_register(VBE_DISPI_INDEX_ENABLE, VBE_DISPI_DISABLED);
|
||||
set_register(VBE_DISPI_INDEX_XRES, (word)width);
|
||||
set_register(VBE_DISPI_INDEX_YRES, (word)height);
|
||||
set_register(VBE_DISPI_INDEX_VIRT_WIDTH, (word)width);
|
||||
set_register(VBE_DISPI_INDEX_VIRT_HEIGHT, (word)height * 2);
|
||||
set_register(VBE_DISPI_INDEX_XRES, (u16)width);
|
||||
set_register(VBE_DISPI_INDEX_YRES, (u16)height);
|
||||
set_register(VBE_DISPI_INDEX_VIRT_WIDTH, (u16)width);
|
||||
set_register(VBE_DISPI_INDEX_VIRT_HEIGHT, (u16)height * 2);
|
||||
set_register(VBE_DISPI_INDEX_BPP, 32);
|
||||
set_register(VBE_DISPI_INDEX_ENABLE, VBE_DISPI_ENABLED | VBE_DISPI_LFB_ENABLED);
|
||||
set_register(VBE_DISPI_INDEX_BANK, 0);
|
||||
|
@ -66,15 +66,15 @@ void BXVGADevice::set_resolution(int width, int height)
|
|||
void BXVGADevice::set_y_offset(int offset)
|
||||
{
|
||||
ASSERT(offset <= m_framebuffer_size.height());
|
||||
set_register(VBE_DISPI_INDEX_Y_OFFSET, (word)offset);
|
||||
set_register(VBE_DISPI_INDEX_Y_OFFSET, (u16)offset);
|
||||
}
|
||||
|
||||
dword BXVGADevice::find_framebuffer_address()
|
||||
u32 BXVGADevice::find_framebuffer_address()
|
||||
{
|
||||
// NOTE: The QEMU card has the same PCI ID as the Bochs one.
|
||||
static const PCI::ID bochs_vga_id = { 0x1234, 0x1111 };
|
||||
static const PCI::ID virtualbox_vga_id = { 0x80ee, 0xbeef };
|
||||
dword framebuffer_address = 0;
|
||||
u32 framebuffer_address = 0;
|
||||
PCI::enumerate_all([&framebuffer_address](const PCI::Address& address, PCI::ID id) {
|
||||
if (id == bochs_vga_id || id == virtualbox_vga_id) {
|
||||
framebuffer_address = PCI::get_BAR0(address) & 0xfffffff0;
|
||||
|
@ -133,12 +133,12 @@ bool BXVGADevice::can_write(FileDescription&) const
|
|||
ASSERT_NOT_REACHED();
|
||||
}
|
||||
|
||||
ssize_t BXVGADevice::read(FileDescription&, byte*, ssize_t)
|
||||
ssize_t BXVGADevice::read(FileDescription&, u8*, ssize_t)
|
||||
{
|
||||
ASSERT_NOT_REACHED();
|
||||
}
|
||||
|
||||
ssize_t BXVGADevice::write(FileDescription&, const byte*, ssize_t)
|
||||
ssize_t BXVGADevice::write(FileDescription&, const u8*, ssize_t)
|
||||
{
|
||||
ASSERT_NOT_REACHED();
|
||||
}
|
||||
|
|
|
@ -20,18 +20,18 @@ public:
|
|||
virtual int ioctl(FileDescription&, unsigned request, unsigned arg) override;
|
||||
virtual KResultOr<Region*> mmap(Process&, FileDescription&, VirtualAddress preferred_vaddr, size_t offset, size_t, int prot) override;
|
||||
|
||||
size_t framebuffer_size_in_bytes() const { return m_framebuffer_size.area() * sizeof(dword) * 2; }
|
||||
size_t framebuffer_size_in_bytes() const { return m_framebuffer_size.area() * sizeof(u32) * 2; }
|
||||
Size framebuffer_size() const { return m_framebuffer_size; }
|
||||
|
||||
private:
|
||||
virtual const char* class_name() const override { return "BXVGA"; }
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual bool can_write(FileDescription&) const override;
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
|
||||
void set_register(word index, word value);
|
||||
dword find_framebuffer_address();
|
||||
void set_register(u16 index, u16 value);
|
||||
u32 find_framebuffer_address();
|
||||
|
||||
PhysicalAddress m_framebuffer_address;
|
||||
Size m_framebuffer_size;
|
||||
|
|
|
@ -19,7 +19,7 @@ DebugLogDevice::~DebugLogDevice()
|
|||
{
|
||||
}
|
||||
|
||||
ssize_t DebugLogDevice::write(FileDescription&, const byte* data, ssize_t data_size)
|
||||
ssize_t DebugLogDevice::write(FileDescription&, const u8* data, ssize_t data_size)
|
||||
{
|
||||
for (int i = 0; i < data_size; ++i)
|
||||
IO::out8(0xe9, data[i]);
|
||||
|
|
|
@ -9,8 +9,8 @@ public:
|
|||
|
||||
private:
|
||||
// ^CharacterDevice
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override { return 0; }
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override { return 0; }
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
virtual bool can_read(FileDescription&) const override { return true; }
|
||||
virtual const char* class_name() const override { return "DebugLogDevice"; }
|
||||
|
|
|
@ -8,21 +8,21 @@ DiskDevice::~DiskDevice()
|
|||
{
|
||||
}
|
||||
|
||||
bool DiskDevice::read(DiskOffset offset, unsigned length, byte* out) const
|
||||
bool DiskDevice::read(DiskOffset offset, unsigned length, u8* out) const
|
||||
{
|
||||
ASSERT((offset % block_size()) == 0);
|
||||
ASSERT((length % block_size()) == 0);
|
||||
dword first_block = offset / block_size();
|
||||
dword end_block = (offset + length) / block_size();
|
||||
u32 first_block = offset / block_size();
|
||||
u32 end_block = (offset + length) / block_size();
|
||||
return const_cast<DiskDevice*>(this)->read_blocks(first_block, end_block - first_block, out);
|
||||
}
|
||||
|
||||
bool DiskDevice::write(DiskOffset offset, unsigned length, const byte* in)
|
||||
bool DiskDevice::write(DiskOffset offset, unsigned length, const u8* in)
|
||||
{
|
||||
ASSERT((offset % block_size()) == 0);
|
||||
ASSERT((length % block_size()) == 0);
|
||||
dword first_block = offset / block_size();
|
||||
dword end_block = (offset + length) / block_size();
|
||||
u32 first_block = offset / block_size();
|
||||
u32 end_block = (offset + length) / block_size();
|
||||
ASSERT(first_block <= 0xffffffff);
|
||||
ASSERT(end_block <= 0xffffffff);
|
||||
return write_blocks(first_block, end_block - first_block, in);
|
||||
|
|
|
@ -4,21 +4,21 @@
|
|||
#include <AK/Types.h>
|
||||
|
||||
// FIXME: Support 64-bit DiskOffset
|
||||
typedef dword DiskOffset;
|
||||
typedef u32 DiskOffset;
|
||||
|
||||
class DiskDevice : public RefCounted<DiskDevice> {
|
||||
public:
|
||||
virtual ~DiskDevice();
|
||||
|
||||
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 bool read_block(unsigned index, u8*) const = 0;
|
||||
virtual bool write_block(unsigned index, const u8*) = 0;
|
||||
virtual const char* class_name() const = 0;
|
||||
bool read(DiskOffset, unsigned length, byte*) const;
|
||||
bool write(DiskOffset, unsigned length, const byte*);
|
||||
bool read(DiskOffset, unsigned length, u8*) const;
|
||||
bool write(DiskOffset, unsigned length, const u8*);
|
||||
|
||||
virtual bool read_blocks(unsigned index, word count, byte*) = 0;
|
||||
virtual bool write_blocks(unsigned index, word count, const byte*) = 0;
|
||||
virtual bool read_blocks(unsigned index, u16 count, u8*) = 0;
|
||||
virtual bool write_blocks(unsigned index, u16 count, const u8*) = 0;
|
||||
|
||||
protected:
|
||||
DiskDevice();
|
||||
|
|
|
@ -22,7 +22,7 @@ unsigned DiskPartition::block_size() const
|
|||
return m_device->block_size();
|
||||
}
|
||||
|
||||
bool DiskPartition::read_block(unsigned index, byte* out) const
|
||||
bool DiskPartition::read_block(unsigned index, u8* out) const
|
||||
{
|
||||
#ifdef OFFD_DEBUG
|
||||
kprintf("DiskPartition::read_block %u (really: %u)\n", index, m_block_offset + index);
|
||||
|
@ -31,7 +31,7 @@ bool DiskPartition::read_block(unsigned index, byte* out) const
|
|||
return m_device->read_block(m_block_offset + index, out);
|
||||
}
|
||||
|
||||
bool DiskPartition::write_block(unsigned index, const byte* data)
|
||||
bool DiskPartition::write_block(unsigned index, const u8* data)
|
||||
{
|
||||
#ifdef OFFD_DEBUG
|
||||
kprintf("DiskPartition::write_block %u (really: %u)\n", index, m_block_offset + index);
|
||||
|
@ -40,7 +40,7 @@ bool DiskPartition::write_block(unsigned index, const byte* data)
|
|||
return m_device->write_block(m_block_offset + index, data);
|
||||
}
|
||||
|
||||
bool DiskPartition::read_blocks(unsigned index, word count, byte* out)
|
||||
bool DiskPartition::read_blocks(unsigned index, u16 count, u8* out)
|
||||
{
|
||||
#ifdef OFFD_DEBUG
|
||||
kprintf("DiskPartition::read_blocks %u (really: %u) count=%u\n", index, m_block_offset + index, count);
|
||||
|
@ -49,7 +49,7 @@ bool DiskPartition::read_blocks(unsigned index, word count, byte* out)
|
|||
return m_device->read_blocks(m_block_offset + index, count, out);
|
||||
}
|
||||
|
||||
bool DiskPartition::write_blocks(unsigned index, word count, const byte* data)
|
||||
bool DiskPartition::write_blocks(unsigned index, u16 count, const u8* data)
|
||||
{
|
||||
#ifdef OFFD_DEBUG
|
||||
kprintf("DiskPartition::write_blocks %u (really: %u) count=%u\n", index, m_block_offset + index, count);
|
||||
|
|
|
@ -9,10 +9,10 @@ public:
|
|||
virtual ~DiskPartition();
|
||||
|
||||
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;
|
||||
virtual bool read_blocks(unsigned index, word count, byte*) override;
|
||||
virtual bool write_blocks(unsigned index, word count, const byte*) override;
|
||||
virtual bool read_block(unsigned index, u8* out) const override;
|
||||
virtual bool write_block(unsigned index, const u8*) override;
|
||||
virtual bool read_blocks(unsigned index, u16 count, u8*) override;
|
||||
virtual bool write_blocks(unsigned index, u16 count, const u8*) override;
|
||||
|
||||
private:
|
||||
virtual const char* class_name() const override;
|
||||
|
|
|
@ -32,19 +32,19 @@ unsigned FileBackedDiskDevice::block_size() const
|
|||
return m_block_size;
|
||||
}
|
||||
|
||||
bool FileBackedDiskDevice::read_block(unsigned index, byte* out) const
|
||||
bool FileBackedDiskDevice::read_block(unsigned index, u8* out) const
|
||||
{
|
||||
DiskOffset offset = index * m_block_size;
|
||||
return read_internal(offset, block_size(), out);
|
||||
}
|
||||
|
||||
bool FileBackedDiskDevice::write_block(unsigned index, const byte* data)
|
||||
bool FileBackedDiskDevice::write_block(unsigned index, const u8* data)
|
||||
{
|
||||
DiskOffset offset = index * m_block_size;
|
||||
return write_internal(offset, block_size(), data);
|
||||
}
|
||||
|
||||
bool FileBackedDiskDevice::read_internal(DiskOffset offset, unsigned length, byte* out) const
|
||||
bool FileBackedDiskDevice::read_internal(DiskOffset offset, unsigned length, u8* out) const
|
||||
{
|
||||
#ifndef IGNORE_FILE_LENGTH
|
||||
if (offset + length >= m_file_length)
|
||||
|
@ -54,12 +54,12 @@ bool FileBackedDiskDevice::read_internal(DiskOffset offset, unsigned length, byt
|
|||
printf("[FileBackedDiskDevice] Read device @ offset %llx, length %u\n", offset, length);
|
||||
#endif
|
||||
fseeko(m_file, offset, SEEK_SET);
|
||||
unsigned nread = fread(out, sizeof(byte), length, m_file);
|
||||
unsigned nread = fread(out, sizeof(u8), length, m_file);
|
||||
ASSERT(nread == length);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool FileBackedDiskDevice::write_internal(DiskOffset offset, unsigned length, const byte* data)
|
||||
bool FileBackedDiskDevice::write_internal(DiskOffset offset, unsigned length, const u8* data)
|
||||
{
|
||||
#ifndef IGNORE_FILE_LENGTH
|
||||
if (offset + length >= m_file_length)
|
||||
|
@ -70,7 +70,7 @@ bool FileBackedDiskDevice::write_internal(DiskOffset offset, unsigned length, co
|
|||
#endif
|
||||
fseeko(m_file, offset, SEEK_SET);
|
||||
// size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
|
||||
unsigned nwritten = fwrite(data, sizeof(byte), length, m_file);
|
||||
unsigned nwritten = fwrite(data, sizeof(u8), length, m_file);
|
||||
ASSERT(nwritten == length);
|
||||
return true;
|
||||
}
|
||||
|
|
|
@ -14,14 +14,14 @@ public:
|
|||
bool is_valid() const { return m_file; }
|
||||
|
||||
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;
|
||||
virtual bool read_block(unsigned index, u8* out) const override;
|
||||
virtual bool write_block(unsigned index, const u8*) override;
|
||||
|
||||
private:
|
||||
virtual const char* class_name() const override;
|
||||
|
||||
bool read_internal(DiskOffset, unsigned length, byte* out) const;
|
||||
bool write_internal(DiskOffset, unsigned length, const byte* data);
|
||||
bool read_internal(DiskOffset, unsigned length, u8* out) const;
|
||||
bool write_internal(DiskOffset, unsigned length, const u8* data);
|
||||
|
||||
FileBackedDiskDevice(String&& imagePath, unsigned block_size);
|
||||
|
||||
|
|
|
@ -17,14 +17,14 @@ bool FullDevice::can_read(FileDescription&) const
|
|||
return true;
|
||||
}
|
||||
|
||||
ssize_t FullDevice::read(FileDescription&, byte* buffer, ssize_t size)
|
||||
ssize_t FullDevice::read(FileDescription&, u8* buffer, ssize_t size)
|
||||
{
|
||||
ssize_t count = min(PAGE_SIZE, size);
|
||||
memset(buffer, 0, (size_t)count);
|
||||
return count;
|
||||
}
|
||||
|
||||
ssize_t FullDevice::write(FileDescription&, const byte*, ssize_t size)
|
||||
ssize_t FullDevice::write(FileDescription&, const u8*, ssize_t size)
|
||||
{
|
||||
if (size == 0)
|
||||
return 0;
|
||||
|
|
|
@ -10,8 +10,8 @@ public:
|
|||
|
||||
private:
|
||||
// ^CharacterDevice
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
virtual const char* class_name() const override { return "FullDevice"; }
|
||||
|
|
|
@ -106,19 +106,19 @@ unsigned IDEDiskDevice::block_size() const
|
|||
return 512;
|
||||
}
|
||||
|
||||
bool IDEDiskDevice::read_blocks(unsigned index, word count, byte* out)
|
||||
bool IDEDiskDevice::read_blocks(unsigned index, u16 count, u8* out)
|
||||
{
|
||||
if (m_bus_master_base && m_dma_enabled.resource())
|
||||
return read_sectors_with_dma(index, count, out);
|
||||
return read_sectors(index, count, out);
|
||||
}
|
||||
|
||||
bool IDEDiskDevice::read_block(unsigned index, byte* out) const
|
||||
bool IDEDiskDevice::read_block(unsigned index, u8* out) const
|
||||
{
|
||||
return const_cast<IDEDiskDevice*>(this)->read_blocks(index, 1, out);
|
||||
}
|
||||
|
||||
bool IDEDiskDevice::write_blocks(unsigned index, word count, const byte* data)
|
||||
bool IDEDiskDevice::write_blocks(unsigned index, u16 count, const u8* data)
|
||||
{
|
||||
if (m_bus_master_base && m_dma_enabled.resource())
|
||||
return write_sectors_with_dma(index, count, data);
|
||||
|
@ -129,12 +129,12 @@ bool IDEDiskDevice::write_blocks(unsigned index, word count, const byte* data)
|
|||
return true;
|
||||
}
|
||||
|
||||
bool IDEDiskDevice::write_block(unsigned index, const byte* data)
|
||||
bool IDEDiskDevice::write_block(unsigned index, const u8* data)
|
||||
{
|
||||
return write_blocks(index, 1, data);
|
||||
}
|
||||
|
||||
static void print_ide_status(byte status)
|
||||
static void print_ide_status(u8 status)
|
||||
{
|
||||
kprintf("DRQ=%u BSY=%u DRDY=%u DSC=%u DF=%u CORR=%u IDX=%u ERR=%u\n",
|
||||
(status & ATA_SR_DRQ) != 0,
|
||||
|
@ -166,7 +166,7 @@ bool IDEDiskDevice::wait_for_irq()
|
|||
|
||||
void IDEDiskDevice::handle_irq()
|
||||
{
|
||||
byte status = IO::in8(m_io_base + ATA_REG_STATUS);
|
||||
u8 status = IO::in8(m_io_base + ATA_REG_STATUS);
|
||||
if (status & ATA_SR_ERR) {
|
||||
print_ide_status(status);
|
||||
m_device_error = IO::in8(m_io_base + ATA_REG_ERROR);
|
||||
|
@ -192,7 +192,7 @@ void IDEDiskDevice::initialize()
|
|||
});
|
||||
|
||||
#ifdef DISK_DEBUG
|
||||
byte status = IO::in8(m_io_base + ATA_REG_STATUS);
|
||||
u8 status = IO::in8(m_io_base + ATA_REG_STATUS);
|
||||
kprintf("initial status: ");
|
||||
print_ide_status(status);
|
||||
#endif
|
||||
|
@ -213,19 +213,19 @@ void IDEDiskDevice::initialize()
|
|||
|
||||
ByteBuffer wbuf = ByteBuffer::create_uninitialized(512);
|
||||
ByteBuffer bbuf = ByteBuffer::create_uninitialized(512);
|
||||
byte* b = bbuf.pointer();
|
||||
word* w = (word*)wbuf.pointer();
|
||||
const word* wbufbase = (word*)wbuf.pointer();
|
||||
u8* b = bbuf.pointer();
|
||||
u16* w = (u16*)wbuf.pointer();
|
||||
const u16* wbufbase = (u16*)wbuf.pointer();
|
||||
|
||||
for (dword i = 0; i < 256; ++i) {
|
||||
word data = IO::in16(m_io_base + ATA_REG_DATA);
|
||||
for (u32 i = 0; i < 256; ++i) {
|
||||
u16 data = IO::in16(m_io_base + ATA_REG_DATA);
|
||||
*(w++) = data;
|
||||
*(b++) = MSB(data);
|
||||
*(b++) = LSB(data);
|
||||
}
|
||||
|
||||
// "Unpad" the device name string.
|
||||
for (dword i = 93; i > 54 && bbuf[i] == ' '; --i)
|
||||
for (u32 i = 93; i > 54 && bbuf[i] == ' '; --i)
|
||||
bbuf[i] = 0;
|
||||
|
||||
m_cylinders = wbufbase[1];
|
||||
|
@ -249,13 +249,13 @@ void IDEDiskDevice::initialize()
|
|||
}
|
||||
}
|
||||
|
||||
static void wait_400ns(word io_base)
|
||||
static void wait_400ns(u16 io_base)
|
||||
{
|
||||
for (int i = 0; i < 4; ++i)
|
||||
IO::in8(io_base + ATA_REG_ALTSTATUS);
|
||||
}
|
||||
|
||||
bool IDEDiskDevice::read_sectors_with_dma(dword lba, word count, byte* outbuf)
|
||||
bool IDEDiskDevice::read_sectors_with_dma(u32 lba, u16 count, u8* outbuf)
|
||||
{
|
||||
LOCKER(m_lock);
|
||||
#ifdef DISK_DEBUG
|
||||
|
@ -275,7 +275,7 @@ bool IDEDiskDevice::read_sectors_with_dma(dword lba, word count, byte* outbuf)
|
|||
IO::out8(m_bus_master_base, 0);
|
||||
|
||||
// Write the PRDT location
|
||||
IO::out32(m_bus_master_base + 4, (dword)&m_prdt);
|
||||
IO::out32(m_bus_master_base + 4, (u32)&m_prdt);
|
||||
|
||||
// Turn on "Interrupt" and "Error" flag. The error flag should be cleared by hardware.
|
||||
IO::out8(m_bus_master_base + 2, IO::in8(m_bus_master_base + 2) | 0x6);
|
||||
|
@ -332,7 +332,7 @@ bool IDEDiskDevice::read_sectors_with_dma(dword lba, word count, byte* outbuf)
|
|||
return true;
|
||||
}
|
||||
|
||||
bool IDEDiskDevice::read_sectors(dword start_sector, word count, byte* outbuf)
|
||||
bool IDEDiskDevice::read_sectors(u32 start_sector, u16 count, u8* outbuf)
|
||||
{
|
||||
ASSERT(count <= 256);
|
||||
LOCKER(m_lock);
|
||||
|
@ -369,7 +369,7 @@ bool IDEDiskDevice::read_sectors(dword start_sector, word count, byte* outbuf)
|
|||
if (m_device_error)
|
||||
return false;
|
||||
|
||||
byte status = IO::in8(m_io_base + ATA_REG_STATUS);
|
||||
u8 status = IO::in8(m_io_base + ATA_REG_STATUS);
|
||||
ASSERT(status & ATA_SR_DRQ);
|
||||
#ifdef DISK_DEBUG
|
||||
kprintf("Retrieving %u bytes (status=%b), outbuf=%p...\n", count * 512, status, outbuf);
|
||||
|
@ -379,7 +379,7 @@ bool IDEDiskDevice::read_sectors(dword start_sector, word count, byte* outbuf)
|
|||
return true;
|
||||
}
|
||||
|
||||
bool IDEDiskDevice::write_sectors_with_dma(dword lba, word count, const byte* inbuf)
|
||||
bool IDEDiskDevice::write_sectors_with_dma(u32 lba, u16 count, const u8* inbuf)
|
||||
{
|
||||
LOCKER(m_lock);
|
||||
#ifdef DISK_DEBUG
|
||||
|
@ -401,7 +401,7 @@ bool IDEDiskDevice::write_sectors_with_dma(dword lba, word count, const byte* in
|
|||
IO::out8(m_bus_master_base, 0);
|
||||
|
||||
// Write the PRDT location
|
||||
IO::out32(m_bus_master_base + 4, (dword)&m_prdt);
|
||||
IO::out32(m_bus_master_base + 4, (u32)&m_prdt);
|
||||
|
||||
// Turn on "Interrupt" and "Error" flag. The error flag should be cleared by hardware.
|
||||
IO::out8(m_bus_master_base + 2, IO::in8(m_bus_master_base + 2) | 0x6);
|
||||
|
@ -453,7 +453,7 @@ bool IDEDiskDevice::write_sectors_with_dma(dword lba, word count, const byte* in
|
|||
return true;
|
||||
}
|
||||
|
||||
bool IDEDiskDevice::write_sectors(dword start_sector, word count, const byte* data)
|
||||
bool IDEDiskDevice::write_sectors(u32 start_sector, u16 count, const u8* data)
|
||||
{
|
||||
ASSERT(count <= 256);
|
||||
LOCKER(m_lock);
|
||||
|
@ -484,7 +484,7 @@ bool IDEDiskDevice::write_sectors(dword start_sector, word count, const byte* da
|
|||
while (!(IO::in8(m_io_base + ATA_REG_STATUS) & ATA_SR_DRQ))
|
||||
;
|
||||
|
||||
byte status = IO::in8(m_io_base + ATA_REG_STATUS);
|
||||
u8 status = IO::in8(m_io_base + ATA_REG_STATUS);
|
||||
ASSERT(status & ATA_SR_DRQ);
|
||||
IO::repeated_out16(m_io_base + ATA_REG_DATA, data, count * 256);
|
||||
|
||||
|
|
|
@ -10,8 +10,8 @@
|
|||
|
||||
struct PhysicalRegionDescriptor {
|
||||
PhysicalAddress offset;
|
||||
word size { 0 };
|
||||
word end_of_table { 0 };
|
||||
u16 size { 0 };
|
||||
u16 end_of_table { 0 };
|
||||
};
|
||||
|
||||
class IDEDiskDevice final : public IRQHandler
|
||||
|
@ -23,10 +23,10 @@ public:
|
|||
|
||||
// ^DiskDevice
|
||||
virtual unsigned block_size() const override;
|
||||
virtual bool read_block(unsigned index, byte*) const override;
|
||||
virtual bool write_block(unsigned index, const byte*) override;
|
||||
virtual bool read_blocks(unsigned index, word count, byte*) override;
|
||||
virtual bool write_blocks(unsigned index, word count, const byte*) override;
|
||||
virtual bool read_block(unsigned index, u8*) const override;
|
||||
virtual bool write_block(unsigned index, const u8*) override;
|
||||
virtual bool read_blocks(unsigned index, u16 count, u8*) override;
|
||||
virtual bool write_blocks(unsigned index, u16 count, const u8*) override;
|
||||
|
||||
protected:
|
||||
IDEDiskDevice();
|
||||
|
@ -40,22 +40,22 @@ private:
|
|||
|
||||
void initialize();
|
||||
bool wait_for_irq();
|
||||
bool read_sectors_with_dma(dword lba, word count, byte*);
|
||||
bool write_sectors_with_dma(dword lba, word count, const byte*);
|
||||
bool read_sectors(dword lba, word count, byte* buffer);
|
||||
bool write_sectors(dword lba, word count, const byte* data);
|
||||
bool read_sectors_with_dma(u32 lba, u16 count, u8*);
|
||||
bool write_sectors_with_dma(u32 lba, u16 count, const u8*);
|
||||
bool read_sectors(u32 lba, u16 count, u8* buffer);
|
||||
bool write_sectors(u32 lba, u16 count, const u8* data);
|
||||
|
||||
Lock m_lock { "IDEDiskDevice" };
|
||||
word m_cylinders { 0 };
|
||||
word m_heads { 0 };
|
||||
word m_sectors_per_track { 0 };
|
||||
word m_io_base { 0 };
|
||||
u16 m_cylinders { 0 };
|
||||
u16 m_heads { 0 };
|
||||
u16 m_sectors_per_track { 0 };
|
||||
u16 m_io_base { 0 };
|
||||
volatile bool m_interrupted { false };
|
||||
volatile byte m_device_error { 0 };
|
||||
volatile u8 m_device_error { 0 };
|
||||
|
||||
PCI::Address m_pci_address;
|
||||
PhysicalRegionDescriptor m_prdt;
|
||||
RefPtr<PhysicalPage> m_dma_buffer_page;
|
||||
word m_bus_master_base { 0 };
|
||||
u16 m_bus_master_base { 0 };
|
||||
Lockable<bool> m_dma_enabled;
|
||||
};
|
||||
|
|
|
@ -223,7 +223,7 @@ static KeyCode shifted_key_map[0x100] = {
|
|||
Key_Logo,
|
||||
};
|
||||
|
||||
void KeyboardDevice::key_state_changed(byte raw, bool pressed)
|
||||
void KeyboardDevice::key_state_changed(u8 raw, bool pressed)
|
||||
{
|
||||
Event event;
|
||||
event.key = (m_modifiers & Mod_Shift) ? shifted_key_map[raw] : unshifted_key_map[raw];
|
||||
|
@ -239,11 +239,11 @@ void KeyboardDevice::key_state_changed(byte raw, bool pressed)
|
|||
void KeyboardDevice::handle_irq()
|
||||
{
|
||||
for (;;) {
|
||||
byte status = IO::in8(I8042_STATUS);
|
||||
u8 status = IO::in8(I8042_STATUS);
|
||||
if (!(((status & I8042_WHICH_BUFFER) == I8042_KEYBOARD_BUFFER) && (status & I8042_BUFFER_FULL)))
|
||||
return;
|
||||
byte raw = IO::in8(I8042_BUFFER);
|
||||
byte ch = raw & 0x7f;
|
||||
u8 raw = IO::in8(I8042_BUFFER);
|
||||
u8 ch = raw & 0x7f;
|
||||
bool pressed = !(raw & 0x80);
|
||||
|
||||
#ifdef KEYBOARD_DEBUG
|
||||
|
@ -316,7 +316,7 @@ bool KeyboardDevice::can_read(FileDescription&) const
|
|||
return !m_queue.is_empty();
|
||||
}
|
||||
|
||||
ssize_t KeyboardDevice::read(FileDescription&, byte* buffer, ssize_t size)
|
||||
ssize_t KeyboardDevice::read(FileDescription&, u8* buffer, ssize_t size)
|
||||
{
|
||||
ssize_t nread = 0;
|
||||
while (nread < size) {
|
||||
|
@ -332,7 +332,7 @@ ssize_t KeyboardDevice::read(FileDescription&, byte* buffer, ssize_t size)
|
|||
return nread;
|
||||
}
|
||||
|
||||
ssize_t KeyboardDevice::write(FileDescription&, const byte*, ssize_t)
|
||||
ssize_t KeyboardDevice::write(FileDescription&, const u8*, ssize_t)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -23,9 +23,9 @@ public:
|
|||
void set_client(KeyboardClient* client) { m_client = client; }
|
||||
|
||||
// ^CharacterDevice
|
||||
virtual ssize_t read(FileDescription&, byte* buffer, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8* buffer, ssize_t) override;
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual ssize_t write(FileDescription&, const byte* buffer, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8* buffer, ssize_t) override;
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
|
||||
private:
|
||||
|
@ -35,8 +35,8 @@ private:
|
|||
// ^CharacterDevice
|
||||
virtual const char* class_name() const override { return "KeyboardDevice"; }
|
||||
|
||||
void key_state_changed(byte raw, bool pressed);
|
||||
void update_modifier(byte modifier, bool state)
|
||||
void key_state_changed(u8 raw, bool pressed);
|
||||
void update_modifier(u8 modifier, bool state)
|
||||
{
|
||||
if (state)
|
||||
m_modifiers |= modifier;
|
||||
|
@ -46,7 +46,7 @@ private:
|
|||
|
||||
KeyboardClient* m_client { nullptr };
|
||||
CircularQueue<Event, 16> m_queue;
|
||||
byte m_modifiers { 0 };
|
||||
u8 m_modifiers { 0 };
|
||||
};
|
||||
|
||||
class KeyboardClient {
|
||||
|
|
|
@ -8,23 +8,23 @@
|
|||
#define MBR_SIGNATURE 0xaa55
|
||||
|
||||
struct MBRPartitionEntry {
|
||||
byte status;
|
||||
byte chs1[3];
|
||||
byte type;
|
||||
byte chs2[3];
|
||||
dword offset;
|
||||
dword length;
|
||||
u8 status;
|
||||
u8 chs1[3];
|
||||
u8 type;
|
||||
u8 chs2[3];
|
||||
u32 offset;
|
||||
u32 length;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct MBRPartitionHeader {
|
||||
byte code1[218];
|
||||
word ts_zero;
|
||||
byte ts_drive, ts_seconds, ts_minutes, ts_hours;
|
||||
byte code2[216];
|
||||
dword disk_signature;
|
||||
word disk_signature_zero;
|
||||
u8 code1[218];
|
||||
u16 ts_zero;
|
||||
u8 ts_drive, ts_seconds, ts_minutes, ts_hours;
|
||||
u8 code2[216];
|
||||
u32 disk_signature;
|
||||
u16 disk_signature_zero;
|
||||
MBRPartitionEntry entry[4];
|
||||
word mbr_signature;
|
||||
u16 mbr_signature;
|
||||
} __attribute__((packed));
|
||||
|
||||
class MBRPartitionTable {
|
||||
|
@ -43,5 +43,5 @@ private:
|
|||
ByteBuffer read_header() const;
|
||||
const MBRPartitionHeader& header() const;
|
||||
|
||||
byte m_cached_header[512];
|
||||
u8 m_cached_header[512];
|
||||
};
|
||||
|
|
|
@ -25,12 +25,12 @@ bool NullDevice::can_read(FileDescription&) const
|
|||
return true;
|
||||
}
|
||||
|
||||
ssize_t NullDevice::read(FileDescription&, byte*, ssize_t)
|
||||
ssize_t NullDevice::read(FileDescription&, u8*, ssize_t)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
ssize_t NullDevice::write(FileDescription&, const byte*, ssize_t buffer_size)
|
||||
ssize_t NullDevice::write(FileDescription&, const u8*, ssize_t buffer_size)
|
||||
{
|
||||
return min(PAGE_SIZE, buffer_size);
|
||||
}
|
||||
|
|
|
@ -12,8 +12,8 @@ public:
|
|||
|
||||
private:
|
||||
// ^CharacterDevice
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual const char* class_name() const override { return "NullDevice"; }
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
void PCSpeaker::tone_on(int frequency)
|
||||
{
|
||||
IO::out8(PIT_CTL, TIMER2_SELECT | WRITE_WORD | MODE_SQUARE_WAVE);
|
||||
word timer_reload = BASE_FREQUENCY / frequency;
|
||||
u16 timer_reload = BASE_FREQUENCY / frequency;
|
||||
|
||||
IO::out8(TIMER2_CTL, LSB(timer_reload));
|
||||
IO::out8(TIMER2_CTL, MSB(timer_reload));
|
||||
|
|
|
@ -39,11 +39,11 @@ PS2MouseDevice& PS2MouseDevice::the()
|
|||
void PS2MouseDevice::handle_irq()
|
||||
{
|
||||
for (;;) {
|
||||
byte status = IO::in8(I8042_STATUS);
|
||||
u8 status = IO::in8(I8042_STATUS);
|
||||
if (!(((status & I8042_WHICH_BUFFER) == I8042_MOUSE_BUFFER) && (status & I8042_BUFFER_FULL)))
|
||||
return;
|
||||
|
||||
byte data = IO::in8(I8042_BUFFER);
|
||||
u8 data = IO::in8(I8042_BUFFER);
|
||||
m_data[m_data_state] = data;
|
||||
|
||||
auto commit_packet = [&] {
|
||||
|
@ -113,13 +113,13 @@ void PS2MouseDevice::parse_data_packet()
|
|||
m_queue.enqueue(packet);
|
||||
}
|
||||
|
||||
void PS2MouseDevice::wait_then_write(byte port, byte data)
|
||||
void PS2MouseDevice::wait_then_write(u8 port, u8 data)
|
||||
{
|
||||
prepare_for_output();
|
||||
IO::out8(port, data);
|
||||
}
|
||||
|
||||
byte PS2MouseDevice::wait_then_read(byte port)
|
||||
u8 PS2MouseDevice::wait_then_read(u8 port)
|
||||
{
|
||||
prepare_for_input();
|
||||
return IO::in8(port);
|
||||
|
@ -135,7 +135,7 @@ void PS2MouseDevice::initialize()
|
|||
|
||||
// Enable the PS/2 mouse IRQ (12).
|
||||
// NOTE: The keyboard uses IRQ 1 (and is enabled by bit 0 in this register).
|
||||
byte status = wait_then_read(0x60) | 2;
|
||||
u8 status = wait_then_read(0x60) | 2;
|
||||
wait_then_write(0x64, 0x60);
|
||||
wait_then_write(0x60, status);
|
||||
|
||||
|
@ -149,7 +149,7 @@ void PS2MouseDevice::initialize()
|
|||
|
||||
mouse_write(PS2MOUSE_GET_DEVICE_ID);
|
||||
expect_ack();
|
||||
byte device_id = mouse_read();
|
||||
u8 device_id = mouse_read();
|
||||
|
||||
if (device_id != PS2MOUSE_INTELLIMOUSE_ID) {
|
||||
// Send magical wheel initiation sequence.
|
||||
|
@ -183,7 +183,7 @@ void PS2MouseDevice::initialize()
|
|||
|
||||
void PS2MouseDevice::expect_ack()
|
||||
{
|
||||
byte data = mouse_read();
|
||||
u8 data = mouse_read();
|
||||
ASSERT(data == I8042_ACK);
|
||||
}
|
||||
|
||||
|
@ -203,7 +203,7 @@ void PS2MouseDevice::prepare_for_output()
|
|||
}
|
||||
}
|
||||
|
||||
void PS2MouseDevice::mouse_write(byte data)
|
||||
void PS2MouseDevice::mouse_write(u8 data)
|
||||
{
|
||||
prepare_for_output();
|
||||
IO::out8(0x64, 0xd4);
|
||||
|
@ -211,7 +211,7 @@ void PS2MouseDevice::mouse_write(byte data)
|
|||
IO::out8(0x60, data);
|
||||
}
|
||||
|
||||
byte PS2MouseDevice::mouse_read()
|
||||
u8 PS2MouseDevice::mouse_read()
|
||||
{
|
||||
prepare_for_input();
|
||||
return IO::in8(0x60);
|
||||
|
@ -222,7 +222,7 @@ bool PS2MouseDevice::can_read(FileDescription&) const
|
|||
return !m_queue.is_empty();
|
||||
}
|
||||
|
||||
ssize_t PS2MouseDevice::read(FileDescription&, byte* buffer, ssize_t size)
|
||||
ssize_t PS2MouseDevice::read(FileDescription&, u8* buffer, ssize_t size)
|
||||
{
|
||||
ssize_t nread = 0;
|
||||
while (nread < size) {
|
||||
|
@ -238,7 +238,7 @@ ssize_t PS2MouseDevice::read(FileDescription&, byte* buffer, ssize_t size)
|
|||
return nread;
|
||||
}
|
||||
|
||||
ssize_t PS2MouseDevice::write(FileDescription&, const byte*, ssize_t)
|
||||
ssize_t PS2MouseDevice::write(FileDescription&, const u8*, ssize_t)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -15,8 +15,8 @@ public:
|
|||
|
||||
// ^CharacterDevice
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
|
||||
private:
|
||||
|
@ -29,15 +29,15 @@ private:
|
|||
void initialize();
|
||||
void prepare_for_input();
|
||||
void prepare_for_output();
|
||||
void mouse_write(byte);
|
||||
byte mouse_read();
|
||||
void wait_then_write(byte port, byte data);
|
||||
byte wait_then_read(byte port);
|
||||
void mouse_write(u8);
|
||||
u8 mouse_read();
|
||||
void wait_then_write(u8 port, u8 data);
|
||||
u8 wait_then_read(u8 port);
|
||||
void parse_data_packet();
|
||||
void expect_ack();
|
||||
|
||||
CircularQueue<MousePacket, 100> m_queue;
|
||||
byte m_data_state { 0 };
|
||||
byte m_data[4];
|
||||
u8 m_data_state { 0 };
|
||||
u8 m_data[4];
|
||||
bool m_has_wheel { false };
|
||||
};
|
||||
|
|
|
@ -10,10 +10,10 @@ RandomDevice::~RandomDevice()
|
|||
{
|
||||
}
|
||||
|
||||
static dword next = 1;
|
||||
static u32 next = 1;
|
||||
|
||||
#define MY_RAND_MAX 4294967295U
|
||||
dword RandomDevice::random_value()
|
||||
u32 RandomDevice::random_value()
|
||||
{
|
||||
next = next * 1103515245 + 12345;
|
||||
return next;
|
||||
|
@ -31,18 +31,18 @@ bool RandomDevice::can_read(FileDescription&) const
|
|||
return true;
|
||||
}
|
||||
|
||||
ssize_t RandomDevice::read(FileDescription&, byte* buffer, ssize_t size)
|
||||
ssize_t RandomDevice::read(FileDescription&, u8* buffer, ssize_t size)
|
||||
{
|
||||
const int range = 'z' - 'a';
|
||||
ssize_t nread = min(size, PAGE_SIZE);
|
||||
for (ssize_t i = 0; i < nread; ++i) {
|
||||
dword r = random_value() % range;
|
||||
buffer[i] = (byte)('a' + r);
|
||||
u32 r = random_value() % range;
|
||||
buffer[i] = (u8)('a' + r);
|
||||
}
|
||||
return nread;
|
||||
}
|
||||
|
||||
ssize_t RandomDevice::write(FileDescription&, const byte*, ssize_t size)
|
||||
ssize_t RandomDevice::write(FileDescription&, const u8*, ssize_t size)
|
||||
{
|
||||
// FIXME: Use input for entropy? I guess that could be a neat feature?
|
||||
return min(PAGE_SIZE, size);
|
||||
|
|
|
@ -8,12 +8,12 @@ public:
|
|||
RandomDevice();
|
||||
virtual ~RandomDevice() override;
|
||||
|
||||
static dword random_value();
|
||||
static u32 random_value();
|
||||
|
||||
private:
|
||||
// ^CharacterDevice
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
virtual const char* class_name() const override { return "RandomDevice"; }
|
||||
|
|
|
@ -17,7 +17,7 @@ bool SerialDevice::can_read(FileDescription&) const
|
|||
return (get_line_status() & DataReady) != 0;
|
||||
}
|
||||
|
||||
ssize_t SerialDevice::read(FileDescription&, byte* buffer, ssize_t size)
|
||||
ssize_t SerialDevice::read(FileDescription&, u8* buffer, ssize_t size)
|
||||
{
|
||||
if (!size)
|
||||
return 0;
|
||||
|
@ -35,7 +35,7 @@ bool SerialDevice::can_write(FileDescription&) const
|
|||
return (get_line_status() & EmptyTransmitterHoldingRegister) != 0;
|
||||
}
|
||||
|
||||
ssize_t SerialDevice::write(FileDescription&, const byte* buffer, ssize_t size)
|
||||
ssize_t SerialDevice::write(FileDescription&, const u8* buffer, ssize_t size)
|
||||
{
|
||||
if (!size)
|
||||
return 0;
|
||||
|
|
|
@ -13,9 +13,9 @@ public:
|
|||
|
||||
// ^CharacterDevice
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual bool can_write(FileDescription&) const override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
|
||||
enum InterruptEnable {
|
||||
LowPowerMode = 0x01 << 5,
|
||||
|
|
|
@ -16,14 +16,14 @@ bool ZeroDevice::can_read(FileDescription&) const
|
|||
return true;
|
||||
}
|
||||
|
||||
ssize_t ZeroDevice::read(FileDescription&, byte* buffer, ssize_t size)
|
||||
ssize_t ZeroDevice::read(FileDescription&, u8* buffer, ssize_t size)
|
||||
{
|
||||
ssize_t count = min(PAGE_SIZE, size);
|
||||
memset(buffer, 0, (size_t)count);
|
||||
return count;
|
||||
}
|
||||
|
||||
ssize_t ZeroDevice::write(FileDescription&, const byte*, ssize_t size)
|
||||
ssize_t ZeroDevice::write(FileDescription&, const u8*, ssize_t size)
|
||||
{
|
||||
return min(PAGE_SIZE, size);
|
||||
}
|
||||
|
|
|
@ -10,8 +10,8 @@ public:
|
|||
|
||||
private:
|
||||
// ^CharacterDevice
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
virtual const char* class_name() const override { return "ZeroDevice"; }
|
||||
|
|
|
@ -17,7 +17,7 @@ void DoubleBuffer::flip()
|
|||
compute_emptiness();
|
||||
}
|
||||
|
||||
ssize_t DoubleBuffer::write(const byte* data, ssize_t size)
|
||||
ssize_t DoubleBuffer::write(const u8* data, ssize_t size)
|
||||
{
|
||||
if (!size)
|
||||
return 0;
|
||||
|
@ -27,7 +27,7 @@ ssize_t DoubleBuffer::write(const byte* data, ssize_t size)
|
|||
return size;
|
||||
}
|
||||
|
||||
ssize_t DoubleBuffer::read(byte* data, ssize_t size)
|
||||
ssize_t DoubleBuffer::read(u8* data, ssize_t size)
|
||||
{
|
||||
if (!size)
|
||||
return 0;
|
||||
|
|
|
@ -12,8 +12,8 @@ public:
|
|||
{
|
||||
}
|
||||
|
||||
ssize_t write(const byte*, ssize_t);
|
||||
ssize_t read(byte*, ssize_t);
|
||||
ssize_t write(const u8*, ssize_t);
|
||||
ssize_t read(u8*, ssize_t);
|
||||
|
||||
bool is_empty() const { return m_empty; }
|
||||
|
||||
|
@ -24,10 +24,10 @@ private:
|
|||
void flip();
|
||||
void compute_emptiness();
|
||||
|
||||
Vector<byte>* m_write_buffer { nullptr };
|
||||
Vector<byte>* m_read_buffer { nullptr };
|
||||
Vector<byte> m_buffer1;
|
||||
Vector<byte> m_buffer2;
|
||||
Vector<u8>* m_write_buffer { nullptr };
|
||||
Vector<u8>* m_read_buffer { nullptr };
|
||||
Vector<u8> m_buffer1;
|
||||
Vector<u8> m_buffer2;
|
||||
ssize_t m_read_buffer_index { 0 };
|
||||
bool m_empty { true };
|
||||
Lock m_lock { "DoubleBuffer" };
|
||||
|
|
|
@ -49,8 +49,8 @@ public:
|
|||
virtual bool can_read(FileDescription&) const = 0;
|
||||
virtual bool can_write(FileDescription&) const = 0;
|
||||
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) = 0;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) = 0;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) = 0;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) = 0;
|
||||
virtual int ioctl(FileDescription&, unsigned request, unsigned arg);
|
||||
virtual KResultOr<Region*> mmap(Process&, FileDescription&, VirtualAddress preferred_vaddr, size_t offset, size_t size, int prot);
|
||||
|
||||
|
|
|
@ -126,7 +126,7 @@ ByteBuffer DiskBackedFS::read_blocks(unsigned index, unsigned count) const
|
|||
if (count == 1)
|
||||
return read_block(index);
|
||||
auto blocks = ByteBuffer::create_uninitialized(count * block_size());
|
||||
byte* out = blocks.pointer();
|
||||
u8* out = blocks.pointer();
|
||||
|
||||
for (unsigned i = 0; i < count; ++i) {
|
||||
auto block = read_block(index + i);
|
||||
|
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
static const ssize_t max_inline_symlink_length = 60;
|
||||
|
||||
static byte to_ext2_file_type(mode_t mode)
|
||||
static u8 to_ext2_file_type(mode_t mode)
|
||||
{
|
||||
if (is_regular_file(mode))
|
||||
return EXT2_FT_REG_FILE;
|
||||
|
@ -59,7 +59,7 @@ ByteBuffer Ext2FS::read_super_block() const
|
|||
bool Ext2FS::write_super_block(const ext2_super_block& sb)
|
||||
{
|
||||
LOCKER(m_lock);
|
||||
const byte* raw = (const byte*)&sb;
|
||||
const u8* raw = (const u8*)&sb;
|
||||
bool success;
|
||||
success = device().write_block(2, raw);
|
||||
ASSERT(success);
|
||||
|
@ -479,7 +479,7 @@ RefPtr<Inode> Ext2FS::get_inode(InodeIdentifier inode) const
|
|||
return new_inode;
|
||||
}
|
||||
|
||||
ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription*) const
|
||||
ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, u8* buffer, FileDescription*) const
|
||||
{
|
||||
Locker inode_locker(m_lock);
|
||||
ASSERT(offset >= 0);
|
||||
|
@ -490,7 +490,7 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
|
|||
// This avoids wasting an entire block on short links. (Most links are short.)
|
||||
if (is_symlink() && size() < max_inline_symlink_length) {
|
||||
ssize_t nread = min((off_t)size() - offset, static_cast<off_t>(count));
|
||||
memcpy(buffer, ((const byte*)m_raw_inode.i_block) + offset, (size_t)nread);
|
||||
memcpy(buffer, ((const u8*)m_raw_inode.i_block) + offset, (size_t)nread);
|
||||
return nread;
|
||||
}
|
||||
|
||||
|
@ -518,7 +518,7 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
|
|||
|
||||
ssize_t nread = 0;
|
||||
int remaining_count = min((off_t)count, (off_t)size() - offset);
|
||||
byte* out = buffer;
|
||||
u8* out = buffer;
|
||||
|
||||
#ifdef EXT2_DEBUG
|
||||
kprintf("Ext2FS: Reading up to %u bytes %d bytes into inode %u:%u to %p\n", count, offset, identifier().fsid(), identifier().index(), buffer);
|
||||
|
@ -543,10 +543,10 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
|
|||
return nread;
|
||||
}
|
||||
|
||||
bool Ext2FSInode::resize(qword new_size)
|
||||
bool Ext2FSInode::resize(u64 new_size)
|
||||
{
|
||||
qword block_size = fs().block_size();
|
||||
qword old_size = size();
|
||||
u64 block_size = fs().block_size();
|
||||
u64 old_size = size();
|
||||
int blocks_needed_before = ceil_div(old_size, block_size);
|
||||
int blocks_needed_after = ceil_div(new_size, block_size);
|
||||
|
||||
|
@ -585,7 +585,7 @@ bool Ext2FSInode::resize(qword new_size)
|
|||
return true;
|
||||
}
|
||||
|
||||
ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data, FileDescription*)
|
||||
ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const u8* data, FileDescription*)
|
||||
{
|
||||
ASSERT(offset >= 0);
|
||||
ASSERT(count >= 0);
|
||||
|
@ -598,7 +598,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
|
|||
#ifdef EXT2_DEBUG
|
||||
dbgprintf("Ext2FSInode: write_bytes poking into i_block array for inline symlink '%s' (%u bytes)\n", String((const char*)data, count).characters(), count);
|
||||
#endif
|
||||
memcpy(((byte*)m_raw_inode.i_block) + offset, data, (size_t)count);
|
||||
memcpy(((u8*)m_raw_inode.i_block) + offset, data, (size_t)count);
|
||||
if ((offset + count) > (off_t)m_raw_inode.i_size)
|
||||
m_raw_inode.i_size = offset + count;
|
||||
set_metadata_dirty(true);
|
||||
|
@ -607,8 +607,8 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
|
|||
}
|
||||
|
||||
const ssize_t block_size = fs().block_size();
|
||||
qword old_size = size();
|
||||
qword new_size = max(static_cast<qword>(offset) + count, (qword)size());
|
||||
u64 old_size = size();
|
||||
u64 new_size = max(static_cast<u64>(offset) + count, (u64)size());
|
||||
|
||||
if (!resize(new_size))
|
||||
return -EIO;
|
||||
|
@ -624,7 +624,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
|
|||
|
||||
ssize_t nwritten = 0;
|
||||
int remaining_count = min((off_t)count, (off_t)new_size - offset);
|
||||
const byte* in = data;
|
||||
const u8* in = data;
|
||||
|
||||
#ifdef EXT2_DEBUG
|
||||
dbgprintf("Ext2FSInode::write_bytes: Writing %u bytes %d bytes into inode %u:%u from %p\n", count, offset, fsid(), index(), data);
|
||||
|
@ -733,20 +733,20 @@ bool Ext2FSInode::write_directory(const Vector<FS::DirectoryEntry>& entries)
|
|||
record_length += occupied_size - directory_size;
|
||||
|
||||
dbgprintf("* inode: %u", entry.inode.index());
|
||||
dbgprintf(", name_len: %u", word(entry.name_length));
|
||||
dbgprintf(", rec_len: %u", word(record_length));
|
||||
dbgprintf(", file_type: %u", byte(entry.file_type));
|
||||
dbgprintf(", name_len: %u", u16(entry.name_length));
|
||||
dbgprintf(", rec_len: %u", u16(record_length));
|
||||
dbgprintf(", file_type: %u", u8(entry.file_type));
|
||||
dbgprintf(", name: %s\n", entry.name);
|
||||
|
||||
stream << dword(entry.inode.index());
|
||||
stream << word(record_length);
|
||||
stream << byte(entry.name_length);
|
||||
stream << byte(entry.file_type);
|
||||
stream << u32(entry.inode.index());
|
||||
stream << u16(record_length);
|
||||
stream << u8(entry.name_length);
|
||||
stream << u8(entry.file_type);
|
||||
stream << entry.name;
|
||||
|
||||
int padding = record_length - entry.name_length - 8;
|
||||
for (int j = 0; j < padding; ++j)
|
||||
stream << byte(0);
|
||||
stream << u8(0);
|
||||
}
|
||||
|
||||
stream.fill_to_end(0);
|
||||
|
|
|
@ -25,12 +25,12 @@ public:
|
|||
|
||||
private:
|
||||
// ^Inode
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescription*) const override;
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, u8* buffer, FileDescription*) const override;
|
||||
virtual InodeMetadata metadata() const override;
|
||||
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
|
||||
virtual InodeIdentifier lookup(StringView name) override;
|
||||
virtual void flush_metadata() override;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const byte* data, FileDescription*) override;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const u8* data, FileDescription*) override;
|
||||
virtual KResult add_child(InodeIdentifier child_id, const StringView& name, mode_t) override;
|
||||
virtual KResult remove_child(const StringView& name) override;
|
||||
virtual int set_atime(time_t) override;
|
||||
|
@ -45,7 +45,7 @@ private:
|
|||
|
||||
bool write_directory(const Vector<FS::DirectoryEntry>&);
|
||||
void populate_lookup_cache() const;
|
||||
bool resize(qword);
|
||||
bool resize(u64);
|
||||
|
||||
Ext2FS& fs();
|
||||
const Ext2FS& fs() const;
|
||||
|
|
|
@ -16,7 +16,7 @@ Lockable<HashTable<FIFO*>>& all_fifos()
|
|||
return *s_table;
|
||||
}
|
||||
|
||||
RefPtr<FIFO> FIFO::from_fifo_id(dword id)
|
||||
RefPtr<FIFO> FIFO::from_fifo_id(u32 id)
|
||||
{
|
||||
auto* ptr = reinterpret_cast<FIFO*>(id);
|
||||
LOCKER(all_fifos().lock());
|
||||
|
@ -93,7 +93,7 @@ bool FIFO::can_write(FileDescription&) const
|
|||
return m_buffer.bytes_in_write_buffer() < 4096 || !m_readers;
|
||||
}
|
||||
|
||||
ssize_t FIFO::read(FileDescription&, byte* buffer, ssize_t size)
|
||||
ssize_t FIFO::read(FileDescription&, u8* buffer, ssize_t size)
|
||||
{
|
||||
if (!m_writers && m_buffer.is_empty())
|
||||
return 0;
|
||||
|
@ -107,7 +107,7 @@ ssize_t FIFO::read(FileDescription&, byte* buffer, ssize_t size)
|
|||
return nread;
|
||||
}
|
||||
|
||||
ssize_t FIFO::write(FileDescription&, const byte* buffer, ssize_t size)
|
||||
ssize_t FIFO::write(FileDescription&, const u8* buffer, ssize_t size)
|
||||
{
|
||||
if (!m_readers) {
|
||||
current->process().send_signal(SIGPIPE, ¤t->process());
|
||||
|
|
|
@ -8,13 +8,13 @@ class FileDescription;
|
|||
|
||||
class FIFO final : public File {
|
||||
public:
|
||||
enum class Direction : byte {
|
||||
enum class Direction : u8 {
|
||||
Neither,
|
||||
Reader,
|
||||
Writer
|
||||
};
|
||||
|
||||
static RefPtr<FIFO> from_fifo_id(dword);
|
||||
static RefPtr<FIFO> from_fifo_id(u32);
|
||||
|
||||
static NonnullRefPtr<FIFO> create(uid_t);
|
||||
virtual ~FIFO() override;
|
||||
|
@ -28,8 +28,8 @@ public:
|
|||
|
||||
private:
|
||||
// ^File
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual bool can_write(FileDescription&) const override;
|
||||
virtual String absolute_path(const FileDescription&) const override;
|
||||
|
|
|
@ -127,7 +127,7 @@ off_t FileDescription::seek(off_t offset, int whence)
|
|||
return m_current_offset;
|
||||
}
|
||||
|
||||
ssize_t FileDescription::read(byte* buffer, ssize_t count)
|
||||
ssize_t FileDescription::read(u8* buffer, ssize_t count)
|
||||
{
|
||||
int nread = m_file->read(*this, buffer, count);
|
||||
if (m_file->is_seekable())
|
||||
|
@ -135,7 +135,7 @@ ssize_t FileDescription::read(byte* buffer, ssize_t count)
|
|||
return nread;
|
||||
}
|
||||
|
||||
ssize_t FileDescription::write(const byte* data, ssize_t size)
|
||||
ssize_t FileDescription::write(const u8* data, ssize_t size)
|
||||
{
|
||||
int nwritten = m_file->write(*this, data, size);
|
||||
if (m_file->is_seekable())
|
||||
|
@ -167,7 +167,7 @@ bool FileDescription::is_directory() const
|
|||
return metadata().is_directory();
|
||||
}
|
||||
|
||||
ssize_t FileDescription::get_dir_entries(byte* buffer, ssize_t size)
|
||||
ssize_t FileDescription::get_dir_entries(u8* buffer, ssize_t size)
|
||||
{
|
||||
auto metadata = this->metadata();
|
||||
if (!metadata.is_valid())
|
||||
|
@ -180,9 +180,9 @@ ssize_t FileDescription::get_dir_entries(byte* buffer, ssize_t size)
|
|||
auto temp_buffer = ByteBuffer::create_uninitialized(size_to_allocate);
|
||||
BufferStream stream(temp_buffer);
|
||||
VFS::the().traverse_directory_inode(*m_inode, [&stream](auto& entry) {
|
||||
stream << (dword)entry.inode.index();
|
||||
stream << (byte)entry.file_type;
|
||||
stream << (dword)entry.name_length;
|
||||
stream << (u32)entry.inode.index();
|
||||
stream << (u8)entry.file_type;
|
||||
stream << (u32)entry.name_length;
|
||||
stream << entry.name;
|
||||
return true;
|
||||
});
|
||||
|
@ -318,7 +318,7 @@ const Socket* FileDescription::socket() const
|
|||
return static_cast<const Socket*>(m_file.ptr());
|
||||
}
|
||||
|
||||
void FileDescription::set_file_flags(dword flags)
|
||||
void FileDescription::set_file_flags(u32 flags)
|
||||
{
|
||||
m_is_blocking = !(flags & O_NONBLOCK);
|
||||
m_should_append = flags & O_APPEND;
|
||||
|
|
|
@ -30,8 +30,8 @@ public:
|
|||
int close();
|
||||
|
||||
off_t seek(off_t, int whence);
|
||||
ssize_t read(byte*, ssize_t);
|
||||
ssize_t write(const byte* data, ssize_t);
|
||||
ssize_t read(u8*, ssize_t);
|
||||
ssize_t write(const u8* data, ssize_t);
|
||||
KResult fstat(stat&);
|
||||
|
||||
KResult fchmod(mode_t);
|
||||
|
@ -39,7 +39,7 @@ public:
|
|||
bool can_read();
|
||||
bool can_write();
|
||||
|
||||
ssize_t get_dir_entries(byte* buffer, ssize_t);
|
||||
ssize_t get_dir_entries(u8* buffer, ssize_t);
|
||||
|
||||
ByteBuffer read_entire_file();
|
||||
|
||||
|
@ -74,8 +74,8 @@ public:
|
|||
bool should_append() const { return m_should_append; }
|
||||
void set_should_append(bool s) { m_should_append = s; }
|
||||
|
||||
dword file_flags() const { return m_file_flags; }
|
||||
void set_file_flags(dword);
|
||||
u32 file_flags() const { return m_file_flags; }
|
||||
void set_file_flags(u32);
|
||||
|
||||
bool is_socket() const;
|
||||
Socket* socket();
|
||||
|
@ -116,7 +116,7 @@ private:
|
|||
|
||||
ByteBuffer m_generator_cache;
|
||||
|
||||
dword m_file_flags { 0 };
|
||||
u32 m_file_flags { 0 };
|
||||
|
||||
bool m_is_blocking { true };
|
||||
bool m_should_append { false };
|
||||
|
|
|
@ -7,13 +7,13 @@
|
|||
#include <Kernel/VM/MemoryManager.h>
|
||||
#include <LibC/errno_numbers.h>
|
||||
|
||||
static dword s_lastFileSystemID;
|
||||
static HashMap<dword, FS*>* s_fs_map;
|
||||
static u32 s_lastFileSystemID;
|
||||
static HashMap<u32, FS*>* s_fs_map;
|
||||
|
||||
static HashMap<dword, FS*>& all_fses()
|
||||
static HashMap<u32, FS*>& all_fses()
|
||||
{
|
||||
if (!s_fs_map)
|
||||
s_fs_map = new HashMap<dword, FS*>();
|
||||
s_fs_map = new HashMap<u32, FS*>();
|
||||
return *s_fs_map;
|
||||
}
|
||||
|
||||
|
@ -28,7 +28,7 @@ FS::~FS()
|
|||
all_fses().remove(m_fsid);
|
||||
}
|
||||
|
||||
FS* FS::from_fsid(dword id)
|
||||
FS* FS::from_fsid(u32 id)
|
||||
{
|
||||
auto it = all_fses().find(id);
|
||||
if (it != all_fses().end())
|
||||
|
@ -36,7 +36,7 @@ FS* FS::from_fsid(dword id)
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
FS::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, byte ft)
|
||||
FS::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, u8 ft)
|
||||
: name_length(strlen(n))
|
||||
, inode(i)
|
||||
, file_type(ft)
|
||||
|
@ -45,7 +45,7 @@ FS::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, byte ft)
|
|||
name[name_length] = '\0';
|
||||
}
|
||||
|
||||
FS::DirectoryEntry::DirectoryEntry(const char* n, int nl, InodeIdentifier i, byte ft)
|
||||
FS::DirectoryEntry::DirectoryEntry(const char* n, int nl, InodeIdentifier i, u8 ft)
|
||||
: name_length(nl)
|
||||
, inode(i)
|
||||
, file_type(ft)
|
||||
|
|
|
@ -16,7 +16,7 @@
|
|||
#include <Kernel/KResult.h>
|
||||
#include <Kernel/Lock.h>
|
||||
|
||||
static const dword mepoch = 476763780;
|
||||
static const u32 mepoch = 476763780;
|
||||
|
||||
class Inode;
|
||||
class FileDescription;
|
||||
|
@ -30,7 +30,7 @@ public:
|
|||
virtual ~FS();
|
||||
|
||||
unsigned fsid() const { return m_fsid; }
|
||||
static FS* from_fsid(dword);
|
||||
static FS* from_fsid(u32);
|
||||
static void sync();
|
||||
static void lock_all();
|
||||
|
||||
|
@ -46,12 +46,12 @@ public:
|
|||
virtual unsigned free_inode_count() const { return 0; }
|
||||
|
||||
struct DirectoryEntry {
|
||||
DirectoryEntry(const char* name, InodeIdentifier, byte file_type);
|
||||
DirectoryEntry(const char* name, int name_length, InodeIdentifier, byte file_type);
|
||||
DirectoryEntry(const char* name, InodeIdentifier, u8 file_type);
|
||||
DirectoryEntry(const char* name, int name_length, InodeIdentifier, u8 file_type);
|
||||
char name[256];
|
||||
int name_length { 0 };
|
||||
InodeIdentifier inode;
|
||||
byte file_type { 0 };
|
||||
u8 file_type { 0 };
|
||||
};
|
||||
|
||||
virtual RefPtr<Inode> create_inode(InodeIdentifier parentInode, const String& name, mode_t, off_t size, dev_t, int& error) = 0;
|
||||
|
|
|
@ -35,7 +35,7 @@ ByteBuffer Inode::read_entire(FileDescription* descriptor) const
|
|||
StringBuilder builder(initial_size);
|
||||
|
||||
ssize_t nread;
|
||||
byte buffer[4096];
|
||||
u8 buffer[4096];
|
||||
off_t offset = 0;
|
||||
for (;;) {
|
||||
nread = read_bytes(offset, sizeof(buffer), buffer, descriptor);
|
||||
|
@ -76,7 +76,7 @@ void Inode::will_be_destroyed()
|
|||
flush_metadata();
|
||||
}
|
||||
|
||||
void Inode::inode_contents_changed(off_t offset, ssize_t size, const byte* data)
|
||||
void Inode::inode_contents_changed(off_t offset, ssize_t size, const u8* data)
|
||||
{
|
||||
if (m_vmo)
|
||||
m_vmo->inode_contents_changed({}, offset, size, data);
|
||||
|
|
|
@ -39,10 +39,10 @@ public:
|
|||
|
||||
ByteBuffer read_entire(FileDescription* = nullptr) const;
|
||||
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescription*) const = 0;
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, u8* buffer, FileDescription*) const = 0;
|
||||
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const = 0;
|
||||
virtual InodeIdentifier lookup(StringView name) = 0;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const byte* data, FileDescription*) = 0;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const u8* data, FileDescription*) = 0;
|
||||
virtual KResult add_child(InodeIdentifier child_id, const StringView& name, mode_t) = 0;
|
||||
virtual KResult remove_child(const StringView& name) = 0;
|
||||
virtual size_t directory_entry_count() const = 0;
|
||||
|
@ -76,7 +76,7 @@ public:
|
|||
protected:
|
||||
Inode(FS& fs, unsigned index);
|
||||
void set_metadata_dirty(bool b) { m_metadata_dirty = b; }
|
||||
void inode_contents_changed(off_t, ssize_t, const byte*);
|
||||
void inode_contents_changed(off_t, ssize_t, const u8*);
|
||||
void inode_size_changed(size_t old_size, size_t new_size);
|
||||
|
||||
mutable Lock m_lock { "Inode" };
|
||||
|
|
|
@ -13,12 +13,12 @@ InodeFile::~InodeFile()
|
|||
{
|
||||
}
|
||||
|
||||
ssize_t InodeFile::read(FileDescription& description, byte* buffer, ssize_t count)
|
||||
ssize_t InodeFile::read(FileDescription& description, u8* buffer, ssize_t count)
|
||||
{
|
||||
return m_inode->read_bytes(description.offset(), count, buffer, &description);
|
||||
}
|
||||
|
||||
ssize_t InodeFile::write(FileDescription& description, const byte* data, ssize_t count)
|
||||
ssize_t InodeFile::write(FileDescription& description, const u8* data, ssize_t count)
|
||||
{
|
||||
return m_inode->write_bytes(description.offset(), count, data, &description);
|
||||
}
|
||||
|
|
|
@ -19,8 +19,8 @@ public:
|
|||
virtual bool can_read(FileDescription&) const override { return true; }
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual KResultOr<Region*> mmap(Process&, FileDescription&, VirtualAddress preferred_vaddr, size_t offset, size_t size, int prot) override;
|
||||
|
||||
virtual String absolute_path(const FileDescription&) const override;
|
||||
|
|
|
@ -10,7 +10,7 @@ struct InodeMetadata;
|
|||
class InodeIdentifier {
|
||||
public:
|
||||
InodeIdentifier() {}
|
||||
InodeIdentifier(dword fsid, dword inode)
|
||||
InodeIdentifier(u32 fsid, u32 inode)
|
||||
: m_fsid(fsid)
|
||||
, m_index(inode)
|
||||
{
|
||||
|
@ -18,8 +18,8 @@ public:
|
|||
|
||||
bool is_valid() const { return m_fsid != 0 && m_index != 0; }
|
||||
|
||||
dword fsid() const { return m_fsid; }
|
||||
dword index() const { return m_index; }
|
||||
u32 fsid() const { return m_fsid; }
|
||||
u32 index() const { return m_index; }
|
||||
|
||||
FS* fs();
|
||||
const FS* fs() const;
|
||||
|
@ -39,6 +39,6 @@ public:
|
|||
String to_string() const { return String::format("%u:%u", m_fsid, m_index); }
|
||||
|
||||
private:
|
||||
dword m_fsid { 0 };
|
||||
dword m_index { 0 };
|
||||
u32 m_fsid { 0 };
|
||||
u32 m_index { 0 };
|
||||
};
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
class Process;
|
||||
|
||||
inline constexpr dword encoded_device(unsigned major, unsigned minor)
|
||||
inline constexpr u32 encoded_device(unsigned major, unsigned minor)
|
||||
{
|
||||
return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
|
||||
}
|
||||
|
|
|
@ -125,7 +125,7 @@ static inline InodeIdentifier to_parent_id(const InodeIdentifier& identifier)
|
|||
}
|
||||
|
||||
#if 0
|
||||
static inline byte to_unused_metadata(const InodeIdentifier& identifier)
|
||||
static inline u8 to_unused_metadata(const InodeIdentifier& identifier)
|
||||
{
|
||||
return (identifier.index() >> 8) & 0xf;
|
||||
}
|
||||
|
@ -254,7 +254,7 @@ ByteBuffer procfs$pci(InodeIdentifier)
|
|||
ByteBuffer procfs$uptime(InodeIdentifier)
|
||||
{
|
||||
StringBuilder builder;
|
||||
builder.appendf("%u\n", (dword)(g_uptime / 1000));
|
||||
builder.appendf("%u\n", (u32)(g_uptime / 1000));
|
||||
return builder.to_byte_buffer();
|
||||
}
|
||||
|
||||
|
@ -317,7 +317,7 @@ ByteBuffer procfs$pid_stack(InodeIdentifier identifier)
|
|||
auto& process = handle->process();
|
||||
ProcessPagingScope paging_scope(process);
|
||||
struct RecognizedSymbol {
|
||||
dword address;
|
||||
u32 address;
|
||||
const KSym* ksym;
|
||||
};
|
||||
StringBuilder builder;
|
||||
|
@ -325,8 +325,8 @@ ByteBuffer procfs$pid_stack(InodeIdentifier identifier)
|
|||
builder.appendf("Thread %d:\n", thread.tid());
|
||||
Vector<RecognizedSymbol, 64> recognized_symbols;
|
||||
recognized_symbols.append({ thread.tss().eip, ksymbolicate(thread.tss().eip) });
|
||||
for (dword* stack_ptr = (dword*)thread.frame_ptr(); process.validate_read_from_kernel(VirtualAddress((dword)stack_ptr)); stack_ptr = (dword*)*stack_ptr) {
|
||||
dword retaddr = stack_ptr[1];
|
||||
for (u32* stack_ptr = (u32*)thread.frame_ptr(); process.validate_read_from_kernel(VirtualAddress((u32)stack_ptr)); stack_ptr = (u32*)*stack_ptr) {
|
||||
u32 retaddr = stack_ptr[1];
|
||||
recognized_symbols.append({ retaddr, ksymbolicate(retaddr) });
|
||||
}
|
||||
|
||||
|
@ -397,7 +397,7 @@ ByteBuffer procfs$self(InodeIdentifier)
|
|||
{
|
||||
char buffer[16];
|
||||
ksprintf(buffer, "%u", current->pid());
|
||||
return ByteBuffer::copy((const byte*)buffer, strlen(buffer));
|
||||
return ByteBuffer::copy((const u8*)buffer, strlen(buffer));
|
||||
}
|
||||
|
||||
ByteBuffer procfs$mm(InodeIdentifier)
|
||||
|
@ -471,28 +471,28 @@ ByteBuffer procfs$cpuinfo(InodeIdentifier)
|
|||
{
|
||||
CPUID cpuid(0);
|
||||
builder.appendf("cpuid: ");
|
||||
auto emit_dword = [&](dword value) {
|
||||
auto emit_u32 = [&](u32 value) {
|
||||
builder.appendf("%c%c%c%c",
|
||||
value & 0xff,
|
||||
(value >> 8) & 0xff,
|
||||
(value >> 16) & 0xff,
|
||||
(value >> 24) & 0xff);
|
||||
};
|
||||
emit_dword(cpuid.ebx());
|
||||
emit_dword(cpuid.edx());
|
||||
emit_dword(cpuid.ecx());
|
||||
emit_u32(cpuid.ebx());
|
||||
emit_u32(cpuid.edx());
|
||||
emit_u32(cpuid.ecx());
|
||||
builder.appendf("\n");
|
||||
}
|
||||
{
|
||||
CPUID cpuid(1);
|
||||
dword stepping = cpuid.eax() & 0xf;
|
||||
dword model = (cpuid.eax() >> 4) & 0xf;
|
||||
dword family = (cpuid.eax() >> 8) & 0xf;
|
||||
dword type = (cpuid.eax() >> 12) & 0x3;
|
||||
dword extended_model = (cpuid.eax() >> 16) & 0xf;
|
||||
dword extended_family = (cpuid.eax() >> 20) & 0xff;
|
||||
dword display_model;
|
||||
dword display_family;
|
||||
u32 stepping = cpuid.eax() & 0xf;
|
||||
u32 model = (cpuid.eax() >> 4) & 0xf;
|
||||
u32 family = (cpuid.eax() >> 8) & 0xf;
|
||||
u32 type = (cpuid.eax() >> 12) & 0x3;
|
||||
u32 extended_model = (cpuid.eax() >> 16) & 0xf;
|
||||
u32 extended_family = (cpuid.eax() >> 20) & 0xff;
|
||||
u32 display_model;
|
||||
u32 display_family;
|
||||
if (family == 15) {
|
||||
display_family = family + extended_family;
|
||||
display_model = model + (extended_model << 4);
|
||||
|
@ -512,8 +512,8 @@ ByteBuffer procfs$cpuinfo(InodeIdentifier)
|
|||
// FIXME: Check first that this is supported by calling CPUID with eax=0x80000000
|
||||
// and verifying that the returned eax>=0x80000004.
|
||||
char buffer[48];
|
||||
dword* bufptr = reinterpret_cast<dword*>(buffer);
|
||||
auto copy_brand_string_part_to_buffer = [&](dword i) {
|
||||
u32* bufptr = reinterpret_cast<u32*>(buffer);
|
||||
auto copy_brand_string_part_to_buffer = [&](u32 i) {
|
||||
CPUID cpuid(0x80000002 + i);
|
||||
*bufptr++ = cpuid.eax();
|
||||
*bufptr++ = cpuid.ebx();
|
||||
|
@ -858,7 +858,7 @@ InodeMetadata ProcFSInode::metadata() const
|
|||
return metadata;
|
||||
}
|
||||
|
||||
ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription* description) const
|
||||
ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, u8* buffer, FileDescription* description) const
|
||||
{
|
||||
#ifdef PROCFS_DEBUG
|
||||
dbgprintf("ProcFS: read_bytes %u\n", index());
|
||||
|
@ -1061,7 +1061,7 @@ void ProcFSInode::flush_metadata()
|
|||
{
|
||||
}
|
||||
|
||||
ssize_t ProcFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer, FileDescription*)
|
||||
ssize_t ProcFSInode::write_bytes(off_t offset, ssize_t size, const u8* buffer, FileDescription*)
|
||||
{
|
||||
auto* directory_entry = fs().get_directory_entry(identifier());
|
||||
if (!directory_entry || !directory_entry->write_callback)
|
||||
|
|
|
@ -80,12 +80,12 @@ public:
|
|||
|
||||
private:
|
||||
// ^Inode
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescription*) const override;
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, u8* buffer, FileDescription*) const override;
|
||||
virtual InodeMetadata metadata() const override;
|
||||
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
|
||||
virtual InodeIdentifier lookup(StringView name) override;
|
||||
virtual void flush_metadata() override;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const byte* buffer, FileDescription*) override;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const u8* buffer, FileDescription*) override;
|
||||
virtual KResult add_child(InodeIdentifier child_id, const StringView& name, mode_t) override;
|
||||
virtual KResult remove_child(const StringView& name) override;
|
||||
virtual size_t directory_entry_count() const override;
|
||||
|
|
|
@ -185,7 +185,7 @@ InodeMetadata SynthFSInode::metadata() const
|
|||
return m_metadata;
|
||||
}
|
||||
|
||||
ssize_t SynthFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription* description) const
|
||||
ssize_t SynthFSInode::read_bytes(off_t offset, ssize_t count, u8* buffer, FileDescription* description) const
|
||||
{
|
||||
LOCKER(m_lock);
|
||||
#ifdef SYNTHFS_DEBUG
|
||||
|
@ -227,7 +227,7 @@ bool SynthFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&
|
|||
callback({ "..", 2, m_parent, 2 });
|
||||
|
||||
for (auto& child : m_children)
|
||||
callback({ child->m_name.characters(), child->m_name.length(), child->m_metadata.inode, child->m_metadata.is_directory() ? (byte)2 : (byte)1 });
|
||||
callback({ child->m_name.characters(), child->m_name.length(), child->m_metadata.inode, child->m_metadata.is_directory() ? (u8)2 : (u8)1 });
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -250,7 +250,7 @@ void SynthFSInode::flush_metadata()
|
|||
{
|
||||
}
|
||||
|
||||
ssize_t SynthFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer, FileDescription*)
|
||||
ssize_t SynthFSInode::write_bytes(off_t offset, ssize_t size, const u8* buffer, FileDescription*)
|
||||
{
|
||||
LOCKER(m_lock);
|
||||
if (!m_write_callback)
|
||||
|
|
|
@ -57,12 +57,12 @@ public:
|
|||
|
||||
private:
|
||||
// ^Inode
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescription*) const override;
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, u8* buffer, FileDescription*) const override;
|
||||
virtual InodeMetadata metadata() const override;
|
||||
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
|
||||
virtual InodeIdentifier lookup(StringView name) override;
|
||||
virtual void flush_metadata() override;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const byte* buffer, FileDescription*) override;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const u8* buffer, FileDescription*) override;
|
||||
virtual KResult add_child(InodeIdentifier child_id, const StringView& name, mode_t) override;
|
||||
virtual KResult remove_child(const StringView& name) override;
|
||||
virtual size_t directory_entry_count() const override;
|
||||
|
|
|
@ -516,7 +516,7 @@ KResult VFS::symlink(StringView target, StringView linkpath, Custody& base)
|
|||
auto new_file = parent_inode.fs().create_inode(parent_inode.identifier(), p.basename(), 0120644, 0, 0, error);
|
||||
if (!new_file)
|
||||
return KResult(error);
|
||||
ssize_t nwritten = new_file->write_bytes(0, target.length(), (const byte*)target.characters(), nullptr);
|
||||
ssize_t nwritten = new_file->write_bytes(0, target.length(), (const u8*)target.characters(), nullptr);
|
||||
if (nwritten < 0)
|
||||
return KResult(nwritten);
|
||||
return KSuccess;
|
||||
|
|
|
@ -107,7 +107,7 @@ private:
|
|||
|
||||
RefPtr<Inode> m_root_inode;
|
||||
Vector<OwnPtr<Mount>> m_mounts;
|
||||
HashMap<dword, Device*> m_devices;
|
||||
HashMap<u32, Device*> m_devices;
|
||||
|
||||
RefPtr<Custody> m_root_custody;
|
||||
};
|
||||
|
|
22
Kernel/IO.h
22
Kernel/IO.h
|
@ -4,34 +4,34 @@
|
|||
|
||||
namespace IO {
|
||||
|
||||
inline byte in8(word port)
|
||||
inline u8 in8(u16 port)
|
||||
{
|
||||
byte value;
|
||||
u8 value;
|
||||
asm volatile("inb %1, %0"
|
||||
: "=a"(value)
|
||||
: "Nd"(port));
|
||||
return value;
|
||||
}
|
||||
|
||||
inline word in16(word port)
|
||||
inline u16 in16(u16 port)
|
||||
{
|
||||
word value;
|
||||
u16 value;
|
||||
asm volatile("inw %1, %0"
|
||||
: "=a"(value)
|
||||
: "Nd"(port));
|
||||
return value;
|
||||
}
|
||||
|
||||
inline dword in32(word port)
|
||||
inline u32 in32(u16 port)
|
||||
{
|
||||
dword value;
|
||||
u32 value;
|
||||
asm volatile("inl %1, %0"
|
||||
: "=a"(value)
|
||||
: "Nd"(port));
|
||||
return value;
|
||||
}
|
||||
|
||||
inline void repeated_in16(word port, byte* buffer, int buffer_size)
|
||||
inline void repeated_in16(u16 port, u8* buffer, int buffer_size)
|
||||
{
|
||||
asm volatile("rep insw"
|
||||
: "+D"(buffer), "+c"(buffer_size)
|
||||
|
@ -39,22 +39,22 @@ inline void repeated_in16(word port, byte* buffer, int buffer_size)
|
|||
: "memory");
|
||||
}
|
||||
|
||||
inline void out8(word port, byte value)
|
||||
inline void out8(u16 port, u8 value)
|
||||
{
|
||||
asm volatile("outb %0, %1" ::"a"(value), "Nd"(port));
|
||||
}
|
||||
|
||||
inline void out16(word port, word value)
|
||||
inline void out16(u16 port, u16 value)
|
||||
{
|
||||
asm volatile("outw %0, %1" ::"a"(value), "Nd"(port));
|
||||
}
|
||||
|
||||
inline void out32(word port, dword value)
|
||||
inline void out32(u16 port, u32 value)
|
||||
{
|
||||
asm volatile("outl %0, %1" ::"a"(value), "Nd"(port));
|
||||
}
|
||||
|
||||
inline void repeated_out16(word port, const byte* data, int data_size)
|
||||
inline void repeated_out16(u16 port, const u8* data, int data_size)
|
||||
{
|
||||
asm volatile("rep outsw"
|
||||
: "+S"(data), "+c"(data_size)
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
#include "PIC.h"
|
||||
#include <Kernel/Arch/i386/CPU.h>
|
||||
|
||||
IRQHandler::IRQHandler(byte irq)
|
||||
IRQHandler::IRQHandler(u8 irq)
|
||||
: m_irq_number(irq)
|
||||
{
|
||||
register_irq_handler(m_irq_number, *this);
|
||||
|
|
|
@ -7,14 +7,14 @@ public:
|
|||
virtual ~IRQHandler();
|
||||
virtual void handle_irq() = 0;
|
||||
|
||||
byte irq_number() const { return m_irq_number; }
|
||||
u8 irq_number() const { return m_irq_number; }
|
||||
|
||||
void enable_irq();
|
||||
void disable_irq();
|
||||
|
||||
protected:
|
||||
explicit IRQHandler(byte irq);
|
||||
explicit IRQHandler(u8 irq);
|
||||
|
||||
private:
|
||||
byte m_irq_number { 0 };
|
||||
u8 m_irq_number { 0 };
|
||||
};
|
||||
|
|
|
@ -6,12 +6,12 @@
|
|||
#include <Kernel/FileSystem/FileDescription.h>
|
||||
|
||||
static KSym* s_ksyms;
|
||||
dword ksym_lowest_address;
|
||||
dword ksym_highest_address;
|
||||
dword ksym_count;
|
||||
u32 ksym_lowest_address;
|
||||
u32 ksym_highest_address;
|
||||
u32 ksym_count;
|
||||
bool ksyms_ready;
|
||||
|
||||
static byte parse_hex_digit(char nibble)
|
||||
static u8 parse_hex_digit(char nibble)
|
||||
{
|
||||
if (nibble >= '0' && nibble <= '9')
|
||||
return nibble - '0';
|
||||
|
@ -19,7 +19,7 @@ static byte parse_hex_digit(char nibble)
|
|||
return 10 + (nibble - 'a');
|
||||
}
|
||||
|
||||
const KSym* ksymbolicate(dword address)
|
||||
const KSym* ksymbolicate(u32 address)
|
||||
{
|
||||
if (address < ksym_lowest_address || address > ksym_highest_address)
|
||||
return nullptr;
|
||||
|
@ -36,7 +36,7 @@ static void load_ksyms_from_data(const ByteBuffer& buffer)
|
|||
ksym_highest_address = 0;
|
||||
auto* bufptr = (const char*)buffer.pointer();
|
||||
auto* start_of_name = bufptr;
|
||||
dword address = 0;
|
||||
u32 address = 0;
|
||||
|
||||
for (unsigned i = 0; i < 8; ++i)
|
||||
ksym_count = (ksym_count << 4) | parse_hex_digit(*(bufptr++));
|
||||
|
@ -76,7 +76,7 @@ static void load_ksyms_from_data(const ByteBuffer& buffer)
|
|||
ksyms_ready = true;
|
||||
}
|
||||
|
||||
[[gnu::noinline]] void dump_backtrace_impl(dword ebp, bool use_ksyms)
|
||||
[[gnu::noinline]] void dump_backtrace_impl(u32 ebp, bool use_ksyms)
|
||||
{
|
||||
if (!current) {
|
||||
//hang();
|
||||
|
@ -87,21 +87,21 @@ static void load_ksyms_from_data(const ByteBuffer& buffer)
|
|||
return;
|
||||
}
|
||||
struct RecognizedSymbol {
|
||||
dword address;
|
||||
u32 address;
|
||||
const KSym* ksym;
|
||||
};
|
||||
int max_recognized_symbol_count = 256;
|
||||
RecognizedSymbol recognized_symbols[max_recognized_symbol_count];
|
||||
int recognized_symbol_count = 0;
|
||||
if (use_ksyms) {
|
||||
for (dword* stack_ptr = (dword*)ebp; current->process().validate_read_from_kernel(VirtualAddress((dword)stack_ptr)); stack_ptr = (dword*)*stack_ptr) {
|
||||
dword retaddr = stack_ptr[1];
|
||||
for (u32* stack_ptr = (u32*)ebp; current->process().validate_read_from_kernel(VirtualAddress((u32)stack_ptr)); stack_ptr = (u32*)*stack_ptr) {
|
||||
u32 retaddr = stack_ptr[1];
|
||||
recognized_symbols[recognized_symbol_count++] = { retaddr, ksymbolicate(retaddr) };
|
||||
}
|
||||
} else {
|
||||
for (dword* stack_ptr = (dword*)ebp; current->process().validate_read_from_kernel(VirtualAddress((dword)stack_ptr)); stack_ptr = (dword*)*stack_ptr) {
|
||||
dword retaddr = stack_ptr[1];
|
||||
dbgprintf("%x (next: %x)\n", retaddr, stack_ptr ? (dword*)*stack_ptr : 0);
|
||||
for (u32* stack_ptr = (u32*)ebp; current->process().validate_read_from_kernel(VirtualAddress((u32)stack_ptr)); stack_ptr = (u32*)*stack_ptr) {
|
||||
u32 retaddr = stack_ptr[1];
|
||||
dbgprintf("%x (next: %x)\n", retaddr, stack_ptr ? (u32*)*stack_ptr : 0);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
@ -139,7 +139,7 @@ void dump_backtrace()
|
|||
return;
|
||||
}
|
||||
TemporaryChange change(in_dump_backtrace, true);
|
||||
dword ebp;
|
||||
u32 ebp;
|
||||
asm volatile("movl %%ebp, %%eax"
|
||||
: "=a"(ebp));
|
||||
dump_backtrace_impl(ebp, ksyms_ready);
|
||||
|
|
|
@ -4,16 +4,16 @@
|
|||
#include <AK/Vector.h>
|
||||
|
||||
struct KSym {
|
||||
dword address;
|
||||
u32 address;
|
||||
const char* name;
|
||||
};
|
||||
|
||||
const KSym* ksymbolicate(dword address);
|
||||
const KSym* ksymbolicate(u32 address);
|
||||
void load_ksyms();
|
||||
void init_ksyms();
|
||||
|
||||
extern bool ksyms_ready;
|
||||
extern dword ksym_lowest_address;
|
||||
extern dword ksym_highest_address;
|
||||
extern u32 ksym_lowest_address;
|
||||
extern u32 ksym_highest_address;
|
||||
|
||||
void dump_backtrace();
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
#include <AK/Types.h>
|
||||
|
||||
enum KeyCode : byte {
|
||||
enum KeyCode : u8 {
|
||||
Key_Invalid = 0,
|
||||
Key_Escape,
|
||||
Key_Tab,
|
||||
|
@ -126,8 +126,8 @@ enum KeyModifier {
|
|||
|
||||
struct KeyEvent {
|
||||
KeyCode key { Key_Invalid };
|
||||
byte character { 0 };
|
||||
byte flags { 0 };
|
||||
u8 character { 0 };
|
||||
u8 flags { 0 };
|
||||
bool alt() const { return flags & Mod_Alt; }
|
||||
bool ctrl() const { return flags & Mod_Ctrl; }
|
||||
bool shift() const { return flags & Mod_Shift; }
|
||||
|
|
|
@ -9,9 +9,9 @@
|
|||
class Thread;
|
||||
extern Thread* current;
|
||||
|
||||
static inline dword CAS(volatile dword* mem, dword newval, dword oldval)
|
||||
static inline u32 CAS(volatile u32* mem, u32 newval, u32 oldval)
|
||||
{
|
||||
dword ret;
|
||||
u32 ret;
|
||||
asm volatile(
|
||||
"cmpxchgl %2, %1"
|
||||
: "=a"(ret), "+m"(*mem)
|
||||
|
@ -35,8 +35,8 @@ public:
|
|||
const char* name() const { return m_name; }
|
||||
|
||||
private:
|
||||
volatile dword m_lock { 0 };
|
||||
dword m_level { 0 };
|
||||
volatile u32 m_lock { 0 };
|
||||
u32 m_level { 0 };
|
||||
Thread* m_holder { nullptr };
|
||||
const char* m_name { nullptr };
|
||||
};
|
||||
|
|
|
@ -4,5 +4,5 @@ struct MousePacket {
|
|||
int dx { 0 };
|
||||
int dy { 0 };
|
||||
int dz { 0 };
|
||||
byte buttons { 0 };
|
||||
unsigned char buttons { 0 };
|
||||
};
|
||||
|
|
|
@ -3,18 +3,18 @@
|
|||
#include <AK/Types.h>
|
||||
|
||||
struct multiboot_aout_symbol_table {
|
||||
dword tabsize;
|
||||
dword strsize;
|
||||
dword addr;
|
||||
dword reserved;
|
||||
u32 tabsize;
|
||||
u32 strsize;
|
||||
u32 addr;
|
||||
u32 reserved;
|
||||
};
|
||||
typedef struct multiboot_aout_symbol_table multiboot_aout_symbol_table_t;
|
||||
|
||||
struct multiboot_elf_section_header_table {
|
||||
dword num;
|
||||
dword size;
|
||||
dword addr;
|
||||
dword shndx;
|
||||
u32 num;
|
||||
u32 size;
|
||||
u32 addr;
|
||||
u32 shndx;
|
||||
};
|
||||
typedef struct multiboot_elf_section_header_table multiboot_elf_section_header_table_t;
|
||||
|
||||
|
@ -25,30 +25,30 @@ typedef struct multiboot_elf_section_header_table multiboot_elf_section_header_t
|
|||
#define MULTIBOOT_MEMORY_BADRAM 5
|
||||
|
||||
struct multiboot_mmap_entry {
|
||||
dword size;
|
||||
qword addr;
|
||||
qword len;
|
||||
dword type;
|
||||
u32 size;
|
||||
u64 addr;
|
||||
u64 len;
|
||||
u32 type;
|
||||
} __attribute__((packed));
|
||||
typedef struct multiboot_mmap_entry multiboot_memory_map_t;
|
||||
|
||||
struct multiboot_info {
|
||||
// Multiboot info version number.
|
||||
dword flags;
|
||||
u32 flags;
|
||||
|
||||
// Available memory from BIOS.
|
||||
dword mem_lower;
|
||||
dword mem_upper;
|
||||
u32 mem_lower;
|
||||
u32 mem_upper;
|
||||
|
||||
// "root" partition.
|
||||
dword boot_device;
|
||||
u32 boot_device;
|
||||
|
||||
// Kernel command line.
|
||||
dword cmdline;
|
||||
u32 cmdline;
|
||||
|
||||
// Boot-Module list.
|
||||
dword mods_count;
|
||||
dword mods_addr;
|
||||
u32 mods_count;
|
||||
u32 mods_addr;
|
||||
|
||||
union {
|
||||
multiboot_aout_symbol_table_t aout_sym;
|
||||
|
@ -56,53 +56,53 @@ struct multiboot_info {
|
|||
} u;
|
||||
|
||||
// Memory Mapping buffer.
|
||||
dword mmap_length;
|
||||
dword mmap_addr;
|
||||
u32 mmap_length;
|
||||
u32 mmap_addr;
|
||||
|
||||
// Drive Info buffer.
|
||||
dword drives_length;
|
||||
dword drives_addr;
|
||||
u32 drives_length;
|
||||
u32 drives_addr;
|
||||
|
||||
// ROM configuration table.
|
||||
dword config_table;
|
||||
u32 config_table;
|
||||
|
||||
// Boot Loader Name.
|
||||
dword boot_loader_name;
|
||||
u32 boot_loader_name;
|
||||
|
||||
// APM table.
|
||||
dword apm_table;
|
||||
u32 apm_table;
|
||||
|
||||
// Video.
|
||||
dword vbe_control_info;
|
||||
dword vbe_mode_info;
|
||||
word vbe_mode;
|
||||
word vbe_interface_seg;
|
||||
word vbe_interface_off;
|
||||
word vbe_interface_len;
|
||||
u32 vbe_control_info;
|
||||
u32 vbe_mode_info;
|
||||
u16 vbe_mode;
|
||||
u16 vbe_interface_seg;
|
||||
u16 vbe_interface_off;
|
||||
u16 vbe_interface_len;
|
||||
|
||||
qword framebuffer_addr;
|
||||
dword framebuffer_pitch;
|
||||
dword framebuffer_width;
|
||||
dword framebuffer_height;
|
||||
byte framebuffer_bpp;
|
||||
u64 framebuffer_addr;
|
||||
u32 framebuffer_pitch;
|
||||
u32 framebuffer_width;
|
||||
u32 framebuffer_height;
|
||||
u8 framebuffer_bpp;
|
||||
#define MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED 0
|
||||
#define MULTIBOOT_FRAMEBUFFER_TYPE_RGB 1
|
||||
#define MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT 2
|
||||
byte framebuffer_type;
|
||||
u8 framebuffer_type;
|
||||
union {
|
||||
struct
|
||||
{
|
||||
dword framebuffer_palette_addr;
|
||||
word framebuffer_palette_num_colors;
|
||||
u32 framebuffer_palette_addr;
|
||||
u16 framebuffer_palette_num_colors;
|
||||
};
|
||||
struct
|
||||
{
|
||||
byte framebuffer_red_field_position;
|
||||
byte framebuffer_red_mask_size;
|
||||
byte framebuffer_green_field_position;
|
||||
byte framebuffer_green_mask_size;
|
||||
byte framebuffer_blue_field_position;
|
||||
byte framebuffer_blue_mask_size;
|
||||
u8 framebuffer_red_field_position;
|
||||
u8 framebuffer_red_mask_size;
|
||||
u8 framebuffer_green_field_position;
|
||||
u8 framebuffer_green_mask_size;
|
||||
u8 framebuffer_blue_field_position;
|
||||
u8 framebuffer_blue_mask_size;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
|
@ -6,14 +6,14 @@
|
|||
#include <Kernel/Net/MACAddress.h>
|
||||
|
||||
struct ARPOperation {
|
||||
enum : word {
|
||||
enum : u16 {
|
||||
Request = 1,
|
||||
Response = 2,
|
||||
};
|
||||
};
|
||||
|
||||
struct ARPHardwareType {
|
||||
enum : word {
|
||||
enum : u16 {
|
||||
Ethernet = 1,
|
||||
};
|
||||
};
|
||||
|
@ -21,20 +21,20 @@ struct ARPHardwareType {
|
|||
class [[gnu::packed]] ARPPacket
|
||||
{
|
||||
public:
|
||||
word hardware_type() const { return m_hardware_type; }
|
||||
void set_hardware_type(word w) { m_hardware_type = w; }
|
||||
u16 hardware_type() const { return m_hardware_type; }
|
||||
void set_hardware_type(u16 w) { m_hardware_type = w; }
|
||||
|
||||
word protocol_type() const { return m_protocol_type; }
|
||||
void set_protocol_type(word w) { m_protocol_type = w; }
|
||||
u16 protocol_type() const { return m_protocol_type; }
|
||||
void set_protocol_type(u16 w) { m_protocol_type = w; }
|
||||
|
||||
byte hardware_address_length() const { return m_hardware_address_length; }
|
||||
void set_hardware_address_length(byte b) { m_hardware_address_length = b; }
|
||||
u8 hardware_address_length() const { return m_hardware_address_length; }
|
||||
void set_hardware_address_length(u8 b) { m_hardware_address_length = b; }
|
||||
|
||||
byte protocol_address_length() const { return m_protocol_address_length; }
|
||||
void set_protocol_address_length(byte b) { m_protocol_address_length = b; }
|
||||
u8 protocol_address_length() const { return m_protocol_address_length; }
|
||||
void set_protocol_address_length(u8 b) { m_protocol_address_length = b; }
|
||||
|
||||
word operation() const { return m_operation; }
|
||||
void set_operation(word w) { m_operation = w; }
|
||||
u16 operation() const { return m_operation; }
|
||||
void set_operation(u16 w) { m_operation = w; }
|
||||
|
||||
const MACAddress& sender_hardware_address() const { return m_sender_hardware_address; }
|
||||
void set_sender_hardware_address(const MACAddress& address) { m_sender_hardware_address = address; }
|
||||
|
@ -49,11 +49,11 @@ public:
|
|||
void set_target_protocol_address(const IPv4Address& address) { m_target_protocol_address = address; }
|
||||
|
||||
private:
|
||||
NetworkOrdered<word> m_hardware_type { ARPHardwareType::Ethernet };
|
||||
NetworkOrdered<word> m_protocol_type { EtherType::IPv4 };
|
||||
byte m_hardware_address_length { sizeof(MACAddress) };
|
||||
byte m_protocol_address_length { sizeof(IPv4Address) };
|
||||
NetworkOrdered<word> m_operation;
|
||||
NetworkOrdered<u16> m_hardware_type { ARPHardwareType::Ethernet };
|
||||
NetworkOrdered<u16> m_protocol_type { EtherType::IPv4 };
|
||||
u8 m_hardware_address_length { sizeof(MACAddress) };
|
||||
u8 m_protocol_address_length { sizeof(IPv4Address) };
|
||||
NetworkOrdered<u16> m_operation;
|
||||
MACAddress m_sender_hardware_address;
|
||||
IPv4Address m_sender_protocol_address;
|
||||
MACAddress m_target_hardware_address;
|
||||
|
|
|
@ -92,7 +92,7 @@ OwnPtr<E1000NetworkAdapter> E1000NetworkAdapter::autodetect()
|
|||
});
|
||||
if (found_address.is_null())
|
||||
return nullptr;
|
||||
byte irq = PCI::get_interrupt_line(found_address);
|
||||
u8 irq = PCI::get_interrupt_line(found_address);
|
||||
return make<E1000NetworkAdapter>(found_address, irq);
|
||||
}
|
||||
|
||||
|
@ -102,7 +102,7 @@ E1000NetworkAdapter* E1000NetworkAdapter::the()
|
|||
return s_the;
|
||||
}
|
||||
|
||||
E1000NetworkAdapter::E1000NetworkAdapter(PCI::Address pci_address, byte irq)
|
||||
E1000NetworkAdapter::E1000NetworkAdapter(PCI::Address pci_address, u8 irq)
|
||||
: IRQHandler(irq)
|
||||
, m_pci_address(pci_address)
|
||||
{
|
||||
|
@ -132,7 +132,7 @@ E1000NetworkAdapter::E1000NetworkAdapter(PCI::Address pci_address, byte irq)
|
|||
const auto& mac = mac_address();
|
||||
kprintf("E1000: MAC address: %b:%b:%b:%b:%b:%b\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
||||
|
||||
dword flags = in32(REG_CTRL);
|
||||
u32 flags = in32(REG_CTRL);
|
||||
out32(REG_CTRL, flags | ECTRL_SLU);
|
||||
|
||||
initialize_rx_descriptors();
|
||||
|
@ -153,9 +153,9 @@ void E1000NetworkAdapter::handle_irq()
|
|||
{
|
||||
out32(REG_IMASK, 0x1);
|
||||
|
||||
dword status = in32(0xc0);
|
||||
u32 status = in32(0xc0);
|
||||
if (status & 4) {
|
||||
dword flags = in32(REG_CTRL);
|
||||
u32 flags = in32(REG_CTRL);
|
||||
out32(REG_CTRL, flags | ECTRL_SLU);
|
||||
}
|
||||
if (status & 0x10) {
|
||||
|
@ -170,7 +170,7 @@ void E1000NetworkAdapter::detect_eeprom()
|
|||
{
|
||||
out32(REG_EEPROM, 0x1);
|
||||
for (volatile int i = 0; i < 999; ++i) {
|
||||
dword data = in32(REG_EEPROM);
|
||||
u32 data = in32(REG_EEPROM);
|
||||
if (data & 0x10) {
|
||||
m_has_eeprom = true;
|
||||
return;
|
||||
|
@ -179,16 +179,16 @@ void E1000NetworkAdapter::detect_eeprom()
|
|||
m_has_eeprom = false;
|
||||
}
|
||||
|
||||
dword E1000NetworkAdapter::read_eeprom(byte address)
|
||||
u32 E1000NetworkAdapter::read_eeprom(u8 address)
|
||||
{
|
||||
word data = 0;
|
||||
dword tmp = 0;
|
||||
u16 data = 0;
|
||||
u32 tmp = 0;
|
||||
if (m_has_eeprom) {
|
||||
out32(REG_EEPROM, ((dword)address << 8) | 1);
|
||||
out32(REG_EEPROM, ((u32)address << 8) | 1);
|
||||
while (!((tmp = in32(REG_EEPROM)) & (1 << 4)))
|
||||
;
|
||||
} else {
|
||||
out32(REG_EEPROM, ((dword)address << 2) | 1);
|
||||
out32(REG_EEPROM, ((u32)address << 2) | 1);
|
||||
while (!((tmp = in32(REG_EEPROM)) & (1 << 1)))
|
||||
;
|
||||
}
|
||||
|
@ -199,8 +199,8 @@ dword E1000NetworkAdapter::read_eeprom(byte address)
|
|||
void E1000NetworkAdapter::read_mac_address()
|
||||
{
|
||||
if (m_has_eeprom) {
|
||||
byte mac[6];
|
||||
dword tmp = read_eeprom(0);
|
||||
u8 mac[6];
|
||||
u32 tmp = read_eeprom(0);
|
||||
mac[0] = tmp & 0xff;
|
||||
mac[1] = tmp >> 8;
|
||||
tmp = read_eeprom(1);
|
||||
|
@ -217,14 +217,14 @@ void E1000NetworkAdapter::read_mac_address()
|
|||
|
||||
void E1000NetworkAdapter::initialize_rx_descriptors()
|
||||
{
|
||||
auto ptr = (dword)kmalloc_eternal(sizeof(e1000_rx_desc) * number_of_rx_descriptors + 16);
|
||||
auto ptr = (u32)kmalloc_eternal(sizeof(e1000_rx_desc) * number_of_rx_descriptors + 16);
|
||||
// Make sure it's 16-byte aligned.
|
||||
if (ptr % 16)
|
||||
ptr = (ptr + 16) - (ptr % 16);
|
||||
m_rx_descriptors = (e1000_rx_desc*)ptr;
|
||||
for (int i = 0; i < number_of_rx_descriptors; ++i) {
|
||||
auto& descriptor = m_rx_descriptors[i];
|
||||
descriptor.addr = (qword)kmalloc_eternal(8192 + 16);
|
||||
descriptor.addr = (u64)kmalloc_eternal(8192 + 16);
|
||||
descriptor.status = 0;
|
||||
}
|
||||
|
||||
|
@ -239,14 +239,14 @@ void E1000NetworkAdapter::initialize_rx_descriptors()
|
|||
|
||||
void E1000NetworkAdapter::initialize_tx_descriptors()
|
||||
{
|
||||
auto ptr = (dword)kmalloc_eternal(sizeof(e1000_tx_desc) * number_of_tx_descriptors + 16);
|
||||
auto ptr = (u32)kmalloc_eternal(sizeof(e1000_tx_desc) * number_of_tx_descriptors + 16);
|
||||
// Make sure it's 16-byte aligned.
|
||||
if (ptr % 16)
|
||||
ptr = (ptr + 16) - (ptr % 16);
|
||||
m_tx_descriptors = (e1000_tx_desc*)ptr;
|
||||
for (int i = 0; i < number_of_tx_descriptors; ++i) {
|
||||
auto& descriptor = m_tx_descriptors[i];
|
||||
descriptor.addr = (qword)kmalloc_eternal(8192 + 16);
|
||||
descriptor.addr = (u64)kmalloc_eternal(8192 + 16);
|
||||
descriptor.cmd = 0;
|
||||
}
|
||||
|
||||
|
@ -260,60 +260,60 @@ void E1000NetworkAdapter::initialize_tx_descriptors()
|
|||
out32(REG_TIPG, 0x0060200A);
|
||||
}
|
||||
|
||||
void E1000NetworkAdapter::out8(word address, byte data)
|
||||
void E1000NetworkAdapter::out8(u16 address, u8 data)
|
||||
{
|
||||
if (m_use_mmio) {
|
||||
auto* ptr = (volatile byte*)(m_mmio_base.get() + address);
|
||||
auto* ptr = (volatile u8*)(m_mmio_base.get() + address);
|
||||
*ptr = data;
|
||||
return;
|
||||
}
|
||||
IO::out8(m_io_base + address, data);
|
||||
}
|
||||
|
||||
void E1000NetworkAdapter::out16(word address, word data)
|
||||
void E1000NetworkAdapter::out16(u16 address, u16 data)
|
||||
{
|
||||
if (m_use_mmio) {
|
||||
auto* ptr = (volatile word*)(m_mmio_base.get() + address);
|
||||
auto* ptr = (volatile u16*)(m_mmio_base.get() + address);
|
||||
*ptr = data;
|
||||
return;
|
||||
}
|
||||
IO::out16(m_io_base + address, data);
|
||||
}
|
||||
|
||||
void E1000NetworkAdapter::out32(word address, dword data)
|
||||
void E1000NetworkAdapter::out32(u16 address, u32 data)
|
||||
{
|
||||
if (m_use_mmio) {
|
||||
auto* ptr = (volatile dword*)(m_mmio_base.get() + address);
|
||||
auto* ptr = (volatile u32*)(m_mmio_base.get() + address);
|
||||
*ptr = data;
|
||||
return;
|
||||
}
|
||||
IO::out32(m_io_base + address, data);
|
||||
}
|
||||
|
||||
byte E1000NetworkAdapter::in8(word address)
|
||||
u8 E1000NetworkAdapter::in8(u16 address)
|
||||
{
|
||||
if (m_use_mmio)
|
||||
return *(volatile byte*)(m_mmio_base.get() + address);
|
||||
return *(volatile u8*)(m_mmio_base.get() + address);
|
||||
return IO::in8(m_io_base + address);
|
||||
}
|
||||
|
||||
word E1000NetworkAdapter::in16(word address)
|
||||
u16 E1000NetworkAdapter::in16(u16 address)
|
||||
{
|
||||
if (m_use_mmio)
|
||||
return *(volatile word*)(m_mmio_base.get() + address);
|
||||
return *(volatile u16*)(m_mmio_base.get() + address);
|
||||
return IO::in16(m_io_base + address);
|
||||
}
|
||||
|
||||
dword E1000NetworkAdapter::in32(word address)
|
||||
u32 E1000NetworkAdapter::in32(u16 address)
|
||||
{
|
||||
if (m_use_mmio)
|
||||
return *(volatile dword*)(m_mmio_base.get() + address);
|
||||
return *(volatile u32*)(m_mmio_base.get() + address);
|
||||
return IO::in32(m_io_base + address);
|
||||
}
|
||||
|
||||
void E1000NetworkAdapter::send_raw(const byte* data, int length)
|
||||
void E1000NetworkAdapter::send_raw(const u8* data, int length)
|
||||
{
|
||||
dword tx_current = in32(REG_TXDESCTAIL);
|
||||
u32 tx_current = in32(REG_TXDESCTAIL);
|
||||
#ifdef E1000_DEBUG
|
||||
kprintf("E1000: Sending packet (%d bytes)\n", length);
|
||||
#endif
|
||||
|
@ -337,7 +337,7 @@ void E1000NetworkAdapter::send_raw(const byte* data, int length)
|
|||
|
||||
void E1000NetworkAdapter::receive()
|
||||
{
|
||||
dword rx_current;
|
||||
u32 rx_current;
|
||||
for (;;) {
|
||||
rx_current = in32(REG_RXDESCTAIL);
|
||||
if (rx_current == in32(REG_RXDESCHEAD))
|
||||
|
@ -345,8 +345,8 @@ void E1000NetworkAdapter::receive()
|
|||
rx_current = (rx_current + 1) % number_of_rx_descriptors;
|
||||
if (!(m_rx_descriptors[rx_current].status & 1))
|
||||
break;
|
||||
auto* buffer = (byte*)m_rx_descriptors[rx_current].addr;
|
||||
word length = m_rx_descriptors[rx_current].length;
|
||||
auto* buffer = (u8*)m_rx_descriptors[rx_current].addr;
|
||||
u16 length = m_rx_descriptors[rx_current].length;
|
||||
#ifdef E1000_DEBUG
|
||||
kprintf("E1000: Received 1 packet @ %p (%u) bytes!\n", buffer, length);
|
||||
#endif
|
||||
|
|
|
@ -13,10 +13,10 @@ public:
|
|||
|
||||
static OwnPtr<E1000NetworkAdapter> autodetect();
|
||||
|
||||
E1000NetworkAdapter(PCI::Address, byte irq);
|
||||
E1000NetworkAdapter(PCI::Address, u8 irq);
|
||||
virtual ~E1000NetworkAdapter() override;
|
||||
|
||||
virtual void send_raw(const byte*, int) override;
|
||||
virtual void send_raw(const u8*, int) override;
|
||||
|
||||
private:
|
||||
virtual void handle_irq() override;
|
||||
|
@ -44,28 +44,28 @@ private:
|
|||
};
|
||||
|
||||
void detect_eeprom();
|
||||
dword read_eeprom(byte address);
|
||||
u32 read_eeprom(u8 address);
|
||||
void read_mac_address();
|
||||
|
||||
void write_command(word address, dword);
|
||||
dword read_command(word address);
|
||||
void write_command(u16 address, u32);
|
||||
u32 read_command(u16 address);
|
||||
|
||||
void initialize_rx_descriptors();
|
||||
void initialize_tx_descriptors();
|
||||
|
||||
void out8(word address, byte);
|
||||
void out16(word address, word);
|
||||
void out32(word address, dword);
|
||||
byte in8(word address);
|
||||
word in16(word address);
|
||||
dword in32(word address);
|
||||
void out8(u16 address, u8);
|
||||
void out16(u16 address, u16);
|
||||
void out32(u16 address, u32);
|
||||
u8 in8(u16 address);
|
||||
u16 in16(u16 address);
|
||||
u32 in32(u16 address);
|
||||
|
||||
void receive();
|
||||
|
||||
PCI::Address m_pci_address;
|
||||
word m_io_base { 0 };
|
||||
u16 m_io_base { 0 };
|
||||
PhysicalAddress m_mmio_base;
|
||||
byte m_interrupt_line { 0 };
|
||||
u8 m_interrupt_line { 0 };
|
||||
bool m_has_eeprom { false };
|
||||
bool m_use_mmio { false };
|
||||
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
#include <AK/Types.h>
|
||||
|
||||
struct EtherType {
|
||||
enum : word {
|
||||
enum : u16 {
|
||||
ARP = 0x0806,
|
||||
IPv4 = 0x0800,
|
||||
};
|
||||
|
|
|
@ -15,8 +15,8 @@ public:
|
|||
MACAddress source() const { return m_source; }
|
||||
void set_source(const MACAddress& address) { m_source = address; }
|
||||
|
||||
word ether_type() const { return m_ether_type; }
|
||||
void set_ether_type(word ether_type) { m_ether_type = ether_type; }
|
||||
u16 ether_type() const { return m_ether_type; }
|
||||
void set_ether_type(u16 ether_type) { m_ether_type = ether_type; }
|
||||
|
||||
const void* payload() const { return &m_payload[0]; }
|
||||
void* payload() { return &m_payload[0]; }
|
||||
|
@ -24,8 +24,8 @@ public:
|
|||
private:
|
||||
MACAddress m_destination;
|
||||
MACAddress m_source;
|
||||
NetworkOrdered<word> m_ether_type;
|
||||
dword m_payload[0];
|
||||
NetworkOrdered<u16> m_ether_type;
|
||||
u32 m_payload[0];
|
||||
};
|
||||
|
||||
static_assert(sizeof(EthernetFrameHeader) == 14);
|
||||
|
|
|
@ -16,22 +16,22 @@ public:
|
|||
ICMPHeader() {}
|
||||
~ICMPHeader() {}
|
||||
|
||||
byte type() const { return m_type; }
|
||||
void set_type(byte b) { m_type = b; }
|
||||
u8 type() const { return m_type; }
|
||||
void set_type(u8 b) { m_type = b; }
|
||||
|
||||
byte code() const { return m_code; }
|
||||
void set_code(byte b) { m_code = b; }
|
||||
u8 code() const { return m_code; }
|
||||
void set_code(u8 b) { m_code = b; }
|
||||
|
||||
word checksum() const { return m_checksum; }
|
||||
void set_checksum(word w) { m_checksum = w; }
|
||||
u16 checksum() const { return m_checksum; }
|
||||
void set_checksum(u16 w) { m_checksum = w; }
|
||||
|
||||
const void* payload() const { return this + 1; }
|
||||
void* payload() { return this + 1; }
|
||||
|
||||
private:
|
||||
byte m_type { 0 };
|
||||
byte m_code { 0 };
|
||||
NetworkOrdered<word> m_checksum { 0 };
|
||||
u8 m_type { 0 };
|
||||
u8 m_code { 0 };
|
||||
NetworkOrdered<u16> m_checksum { 0 };
|
||||
// NOTE: The rest of the header is 4 bytes
|
||||
};
|
||||
|
||||
|
@ -40,8 +40,8 @@ static_assert(sizeof(ICMPHeader) == 4);
|
|||
struct [[gnu::packed]] ICMPEchoPacket
|
||||
{
|
||||
ICMPHeader header;
|
||||
NetworkOrdered<word> identifier;
|
||||
NetworkOrdered<word> sequence_number;
|
||||
NetworkOrdered<u16> identifier;
|
||||
NetworkOrdered<u16> sequence_number;
|
||||
void* payload() { return this + 1; }
|
||||
const void* payload() const { return this + 1; }
|
||||
};
|
||||
|
|
|
@ -6,37 +6,37 @@
|
|||
#include <AK/NetworkOrdered.h>
|
||||
#include <AK/Types.h>
|
||||
|
||||
enum class IPv4Protocol : word {
|
||||
enum class IPv4Protocol : u16 {
|
||||
ICMP = 1,
|
||||
TCP = 6,
|
||||
UDP = 17,
|
||||
};
|
||||
|
||||
NetworkOrdered<word> internet_checksum(const void*, size_t);
|
||||
NetworkOrdered<u16> internet_checksum(const void*, size_t);
|
||||
|
||||
class [[gnu::packed]] IPv4Packet
|
||||
{
|
||||
public:
|
||||
byte version() const { return (m_version_and_ihl >> 4) & 0xf; }
|
||||
void set_version(byte version) { m_version_and_ihl = (m_version_and_ihl & 0x0f) | (version << 4); }
|
||||
u8 version() const { return (m_version_and_ihl >> 4) & 0xf; }
|
||||
void set_version(u8 version) { m_version_and_ihl = (m_version_and_ihl & 0x0f) | (version << 4); }
|
||||
|
||||
byte internet_header_length() const { return m_version_and_ihl & 0xf; }
|
||||
void set_internet_header_length(byte ihl) { m_version_and_ihl = (m_version_and_ihl & 0xf0) | (ihl & 0x0f); }
|
||||
u8 internet_header_length() const { return m_version_and_ihl & 0xf; }
|
||||
void set_internet_header_length(u8 ihl) { m_version_and_ihl = (m_version_and_ihl & 0xf0) | (ihl & 0x0f); }
|
||||
|
||||
word length() const { return m_length; }
|
||||
void set_length(word length) { m_length = length; }
|
||||
u16 length() const { return m_length; }
|
||||
void set_length(u16 length) { m_length = length; }
|
||||
|
||||
word ident() const { return m_ident; }
|
||||
void set_ident(word ident) { m_ident = ident; }
|
||||
u16 ident() const { return m_ident; }
|
||||
void set_ident(u16 ident) { m_ident = ident; }
|
||||
|
||||
byte ttl() const { return m_ttl; }
|
||||
void set_ttl(byte ttl) { m_ttl = ttl; }
|
||||
u8 ttl() const { return m_ttl; }
|
||||
void set_ttl(u8 ttl) { m_ttl = ttl; }
|
||||
|
||||
byte protocol() const { return m_protocol; }
|
||||
void set_protocol(byte protocol) { m_protocol = protocol; }
|
||||
u8 protocol() const { return m_protocol; }
|
||||
void set_protocol(u8 protocol) { m_protocol = protocol; }
|
||||
|
||||
word checksum() const { return m_checksum; }
|
||||
void set_checksum(word checksum) { m_checksum = checksum; }
|
||||
u16 checksum() const { return m_checksum; }
|
||||
void set_checksum(u16 checksum) { m_checksum = checksum; }
|
||||
|
||||
const IPv4Address& source() const { return m_source; }
|
||||
void set_source(const IPv4Address& address) { m_source = address; }
|
||||
|
@ -47,33 +47,33 @@ public:
|
|||
void* payload() { return this + 1; }
|
||||
const void* payload() const { return this + 1; }
|
||||
|
||||
word payload_size() const { return m_length - sizeof(IPv4Packet); }
|
||||
u16 payload_size() const { return m_length - sizeof(IPv4Packet); }
|
||||
|
||||
NetworkOrdered<word> compute_checksum() const
|
||||
NetworkOrdered<u16> compute_checksum() const
|
||||
{
|
||||
ASSERT(!m_checksum);
|
||||
return internet_checksum(this, sizeof(IPv4Packet));
|
||||
}
|
||||
|
||||
private:
|
||||
byte m_version_and_ihl { 0 };
|
||||
byte m_dscp_and_ecn { 0 };
|
||||
NetworkOrdered<word> m_length;
|
||||
NetworkOrdered<word> m_ident;
|
||||
NetworkOrdered<word> m_flags_and_fragment;
|
||||
byte m_ttl { 0 };
|
||||
NetworkOrdered<byte> m_protocol;
|
||||
NetworkOrdered<word> m_checksum;
|
||||
u8 m_version_and_ihl { 0 };
|
||||
u8 m_dscp_and_ecn { 0 };
|
||||
NetworkOrdered<u16> m_length;
|
||||
NetworkOrdered<u16> m_ident;
|
||||
NetworkOrdered<u16> m_flags_and_fragment;
|
||||
u8 m_ttl { 0 };
|
||||
NetworkOrdered<u8> m_protocol;
|
||||
NetworkOrdered<u16> m_checksum;
|
||||
IPv4Address m_source;
|
||||
IPv4Address m_destination;
|
||||
};
|
||||
|
||||
static_assert(sizeof(IPv4Packet) == 20);
|
||||
|
||||
inline NetworkOrdered<word> internet_checksum(const void* ptr, size_t count)
|
||||
inline NetworkOrdered<u16> internet_checksum(const void* ptr, size_t count)
|
||||
{
|
||||
dword checksum = 0;
|
||||
auto* w = (const word*)ptr;
|
||||
u32 checksum = 0;
|
||||
auto* w = (const u16*)ptr;
|
||||
while (count > 1) {
|
||||
checksum += convert_between_host_and_network(*w++);
|
||||
if (checksum & 0x80000000)
|
||||
|
|
|
@ -81,7 +81,7 @@ KResult IPv4Socket::bind(const sockaddr* address, socklen_t address_size)
|
|||
return KResult(-EINVAL);
|
||||
|
||||
auto& ia = *(const sockaddr_in*)address;
|
||||
m_local_address = IPv4Address((const byte*)&ia.sin_addr.s_addr);
|
||||
m_local_address = IPv4Address((const u8*)&ia.sin_addr.s_addr);
|
||||
m_local_port = ntohs(ia.sin_port);
|
||||
|
||||
dbgprintf("IPv4Socket::bind %s{%p} to port %u\n", class_name(), this, m_local_port);
|
||||
|
@ -98,7 +98,7 @@ KResult IPv4Socket::connect(FileDescription& description, const sockaddr* addres
|
|||
return KResult(-EINVAL);
|
||||
|
||||
auto& ia = *(const sockaddr_in*)address;
|
||||
m_peer_address = IPv4Address((const byte*)&ia.sin_addr.s_addr);
|
||||
m_peer_address = IPv4Address((const u8*)&ia.sin_addr.s_addr);
|
||||
m_peer_port = ntohs(ia.sin_port);
|
||||
|
||||
return protocol_connect(description, should_block);
|
||||
|
@ -123,12 +123,12 @@ bool IPv4Socket::can_read(FileDescription& description) const
|
|||
return m_can_read;
|
||||
}
|
||||
|
||||
ssize_t IPv4Socket::read(FileDescription& description, byte* buffer, ssize_t size)
|
||||
ssize_t IPv4Socket::read(FileDescription& description, u8* buffer, ssize_t size)
|
||||
{
|
||||
return recvfrom(description, buffer, size, 0, nullptr, 0);
|
||||
}
|
||||
|
||||
ssize_t IPv4Socket::write(FileDescription& description, const byte* data, ssize_t size)
|
||||
ssize_t IPv4Socket::write(FileDescription& description, const u8* data, ssize_t size)
|
||||
{
|
||||
return sendto(description, data, size, 0, nullptr, 0);
|
||||
}
|
||||
|
@ -145,7 +145,7 @@ int IPv4Socket::allocate_local_port_if_needed()
|
|||
int port = protocol_allocate_local_port();
|
||||
if (port < 0)
|
||||
return port;
|
||||
m_local_port = (word)port;
|
||||
m_local_port = (u16)port;
|
||||
return port;
|
||||
}
|
||||
|
||||
|
@ -162,7 +162,7 @@ ssize_t IPv4Socket::sendto(FileDescription&, const void* data, size_t data_lengt
|
|||
}
|
||||
|
||||
auto& ia = *(const sockaddr_in*)addr;
|
||||
m_peer_address = IPv4Address((const byte*)&ia.sin_addr.s_addr);
|
||||
m_peer_address = IPv4Address((const u8*)&ia.sin_addr.s_addr);
|
||||
m_peer_port = ntohs(ia.sin_port);
|
||||
}
|
||||
|
||||
|
@ -249,7 +249,7 @@ ssize_t IPv4Socket::recvfrom(FileDescription& description, void* buffer, size_t
|
|||
return protocol_receive(packet.data, buffer, buffer_length, flags);
|
||||
}
|
||||
|
||||
void IPv4Socket::did_receive(const IPv4Address& source_address, word source_port, ByteBuffer&& packet)
|
||||
void IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port, ByteBuffer&& packet)
|
||||
{
|
||||
LOCKER(lock());
|
||||
auto packet_size = packet.size();
|
||||
|
|
|
@ -27,21 +27,21 @@ public:
|
|||
virtual void attach(FileDescription&) override;
|
||||
virtual void detach(FileDescription&) override;
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual bool can_write(FileDescription&) const override;
|
||||
virtual ssize_t sendto(FileDescription&, const void*, size_t, int, const sockaddr*, socklen_t) override;
|
||||
virtual ssize_t recvfrom(FileDescription&, void*, size_t, int flags, sockaddr*, socklen_t*) override;
|
||||
|
||||
void did_receive(const IPv4Address& peer_address, word peer_port, ByteBuffer&&);
|
||||
void did_receive(const IPv4Address& peer_address, u16 peer_port, ByteBuffer&&);
|
||||
|
||||
const IPv4Address& local_address() const;
|
||||
word local_port() const { return m_local_port; }
|
||||
void set_local_port(word port) { m_local_port = port; }
|
||||
u16 local_port() const { return m_local_port; }
|
||||
void set_local_port(u16 port) { m_local_port = port; }
|
||||
|
||||
const IPv4Address& peer_address() const { return m_peer_address; }
|
||||
word peer_port() const { return m_peer_port; }
|
||||
void set_peer_port(word port) { m_peer_port = port; }
|
||||
u16 peer_port() const { return m_peer_port; }
|
||||
void set_peer_port(u16 port) { m_peer_port = port; }
|
||||
|
||||
protected:
|
||||
IPv4Socket(int type, int protocol);
|
||||
|
@ -70,16 +70,16 @@ private:
|
|||
|
||||
struct ReceivedPacket {
|
||||
IPv4Address peer_address;
|
||||
word peer_port;
|
||||
u16 peer_port;
|
||||
ByteBuffer data;
|
||||
};
|
||||
|
||||
SinglyLinkedList<ReceivedPacket> m_receive_queue;
|
||||
|
||||
word m_local_port { 0 };
|
||||
word m_peer_port { 0 };
|
||||
u16 m_local_port { 0 };
|
||||
u16 m_peer_port { 0 };
|
||||
|
||||
dword m_bytes_received { 0 };
|
||||
u32 m_bytes_received { 0 };
|
||||
|
||||
bool m_can_read { false };
|
||||
};
|
||||
|
|
|
@ -155,7 +155,7 @@ bool LocalSocket::can_read(FileDescription& description) const
|
|||
ASSERT_NOT_REACHED();
|
||||
}
|
||||
|
||||
ssize_t LocalSocket::read(FileDescription& description, byte* buffer, ssize_t size)
|
||||
ssize_t LocalSocket::read(FileDescription& description, u8* buffer, ssize_t size)
|
||||
{
|
||||
auto role = description.socket_role();
|
||||
if (role == SocketRole::Accepted) {
|
||||
|
@ -184,7 +184,7 @@ bool LocalSocket::has_attached_peer(const FileDescription& description) const
|
|||
ASSERT_NOT_REACHED();
|
||||
}
|
||||
|
||||
ssize_t LocalSocket::write(FileDescription& description, const byte* data, ssize_t size)
|
||||
ssize_t LocalSocket::write(FileDescription& description, const u8* data, ssize_t size)
|
||||
{
|
||||
if (!has_attached_peer(description))
|
||||
return -EPIPE;
|
||||
|
@ -206,10 +206,10 @@ bool LocalSocket::can_write(FileDescription& description) const
|
|||
|
||||
ssize_t LocalSocket::sendto(FileDescription& description, const void* data, size_t data_size, int, const sockaddr*, socklen_t)
|
||||
{
|
||||
return write(description, (const byte*)data, data_size);
|
||||
return write(description, (const u8*)data, data_size);
|
||||
}
|
||||
|
||||
ssize_t LocalSocket::recvfrom(FileDescription& description, void* buffer, size_t buffer_size, int, sockaddr*, socklen_t*)
|
||||
{
|
||||
return read(description, (byte*)buffer, buffer_size);
|
||||
return read(description, (u8*)buffer, buffer_size);
|
||||
}
|
||||
|
|
|
@ -17,8 +17,8 @@ public:
|
|||
virtual void attach(FileDescription&) override;
|
||||
virtual void detach(FileDescription&) override;
|
||||
virtual bool can_read(FileDescription&) const override;
|
||||
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
|
||||
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
|
||||
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
|
||||
virtual bool can_write(FileDescription&) const override;
|
||||
virtual ssize_t sendto(FileDescription&, const void*, size_t, int, const sockaddr*, socklen_t) override;
|
||||
virtual ssize_t recvfrom(FileDescription&, void*, size_t, int flags, sockaddr*, socklen_t*) override;
|
||||
|
|
|
@ -18,7 +18,7 @@ LoopbackAdapter::~LoopbackAdapter()
|
|||
{
|
||||
}
|
||||
|
||||
void LoopbackAdapter::send_raw(const byte* data, int size)
|
||||
void LoopbackAdapter::send_raw(const u8* data, int size)
|
||||
{
|
||||
dbgprintf("LoopbackAdapter: Sending %d byte(s) to myself.\n", size);
|
||||
did_receive(data, size);
|
||||
|
|
|
@ -9,7 +9,7 @@ public:
|
|||
|
||||
virtual ~LoopbackAdapter() override;
|
||||
|
||||
virtual void send_raw(const byte*, int) override;
|
||||
virtual void send_raw(const u8*, int) override;
|
||||
virtual const char* class_name() const override { return "LoopbackAdapter"; }
|
||||
|
||||
private:
|
||||
|
|
|
@ -9,13 +9,13 @@ class [[gnu::packed]] MACAddress
|
|||
{
|
||||
public:
|
||||
MACAddress() {}
|
||||
MACAddress(const byte data[6])
|
||||
MACAddress(const u8 data[6])
|
||||
{
|
||||
memcpy(m_data, data, 6);
|
||||
}
|
||||
~MACAddress() {}
|
||||
|
||||
byte operator[](int i) const
|
||||
u8 operator[](int i) const
|
||||
{
|
||||
ASSERT(i >= 0 && i < 6);
|
||||
return m_data[i];
|
||||
|
@ -32,7 +32,7 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
byte m_data[6];
|
||||
u8 m_data[6];
|
||||
};
|
||||
|
||||
static_assert(sizeof(MACAddress) == 6);
|
||||
|
|
|
@ -53,7 +53,7 @@ void NetworkAdapter::send(const MACAddress& destination, const ARPPacket& packet
|
|||
eth->set_destination(destination);
|
||||
eth->set_ether_type(EtherType::ARP);
|
||||
memcpy(eth->payload(), &packet, sizeof(ARPPacket));
|
||||
send_raw((byte*)eth, size_in_bytes);
|
||||
send_raw((u8*)eth, size_in_bytes);
|
||||
}
|
||||
|
||||
void NetworkAdapter::send_ipv4(const MACAddress& destination_mac, const IPv4Address& destination_ipv4, IPv4Protocol protocol, ByteBuffer&& payload)
|
||||
|
@ -69,16 +69,16 @@ void NetworkAdapter::send_ipv4(const MACAddress& destination_mac, const IPv4Addr
|
|||
ipv4.set_internet_header_length(5);
|
||||
ipv4.set_source(ipv4_address());
|
||||
ipv4.set_destination(destination_ipv4);
|
||||
ipv4.set_protocol((byte)protocol);
|
||||
ipv4.set_protocol((u8)protocol);
|
||||
ipv4.set_length(sizeof(IPv4Packet) + payload.size());
|
||||
ipv4.set_ident(1);
|
||||
ipv4.set_ttl(64);
|
||||
ipv4.set_checksum(ipv4.compute_checksum());
|
||||
memcpy(ipv4.payload(), payload.pointer(), payload.size());
|
||||
send_raw((const byte*)ð, size_in_bytes);
|
||||
send_raw((const u8*)ð, size_in_bytes);
|
||||
}
|
||||
|
||||
void NetworkAdapter::did_receive(const byte* data, int length)
|
||||
void NetworkAdapter::did_receive(const u8* data, int length)
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
m_packet_queue.append(ByteBuffer::copy(data, length));
|
||||
|
|
|
@ -52,8 +52,8 @@ protected:
|
|||
NetworkAdapter();
|
||||
void set_interface_name(const StringView& basename);
|
||||
void set_mac_address(const MACAddress& mac_address) { m_mac_address = mac_address; }
|
||||
virtual void send_raw(const byte*, int) = 0;
|
||||
void did_receive(const byte*, int);
|
||||
virtual void send_raw(const u8*, int) = 0;
|
||||
void did_receive(const u8*, int);
|
||||
|
||||
private:
|
||||
MACAddress m_mac_address;
|
||||
|
|
|
@ -225,8 +225,8 @@ void handle_icmp(const EthernetFrameHeader& eth, int frame_size)
|
|||
auto& request = reinterpret_cast<const ICMPEchoPacket&>(icmp_header);
|
||||
kprintf("handle_icmp: EchoRequest from %s: id=%u, seq=%u\n",
|
||||
ipv4_packet.source().to_string().characters(),
|
||||
(word)request.identifier,
|
||||
(word)request.sequence_number);
|
||||
(u16)request.identifier,
|
||||
(u16)request.sequence_number);
|
||||
size_t icmp_packet_size = ipv4_packet.payload_size();
|
||||
auto buffer = ByteBuffer::create_zeroed(icmp_packet_size);
|
||||
auto& response = *(ICMPEchoPacket*)buffer.pointer();
|
||||
|
|
|
@ -9,7 +9,7 @@
|
|||
#include <Kernel/Lock.h>
|
||||
#include <Kernel/UnixTypes.h>
|
||||
|
||||
enum class SocketRole : byte {
|
||||
enum class SocketRole : u8 {
|
||||
None,
|
||||
Listener,
|
||||
Accepted,
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
#include <Kernel/Net/IPv4.h>
|
||||
|
||||
struct TCPFlags {
|
||||
enum : word {
|
||||
enum : u16 {
|
||||
FIN = 0x01,
|
||||
SYN = 0x02,
|
||||
RST = 0x04,
|
||||
|
@ -19,52 +19,52 @@ public:
|
|||
TCPPacket() {}
|
||||
~TCPPacket() {}
|
||||
|
||||
size_t header_size() const { return data_offset() * sizeof(dword); }
|
||||
size_t header_size() const { return data_offset() * sizeof(u32); }
|
||||
|
||||
word source_port() const { return m_source_port; }
|
||||
void set_source_port(word port) { m_source_port = port; }
|
||||
u16 source_port() const { return m_source_port; }
|
||||
void set_source_port(u16 port) { m_source_port = port; }
|
||||
|
||||
word destination_port() const { return m_destination_port; }
|
||||
void set_destination_port(word port) { m_destination_port = port; }
|
||||
u16 destination_port() const { return m_destination_port; }
|
||||
void set_destination_port(u16 port) { m_destination_port = port; }
|
||||
|
||||
dword sequence_number() const { return m_sequence_number; }
|
||||
void set_sequence_number(dword number) { m_sequence_number = number; }
|
||||
u32 sequence_number() const { return m_sequence_number; }
|
||||
void set_sequence_number(u32 number) { m_sequence_number = number; }
|
||||
|
||||
dword ack_number() const { return m_ack_number; }
|
||||
void set_ack_number(dword number) { m_ack_number = number; }
|
||||
u32 ack_number() const { return m_ack_number; }
|
||||
void set_ack_number(u32 number) { m_ack_number = number; }
|
||||
|
||||
word flags() const { return m_flags_and_data_offset & 0x1ff; }
|
||||
void set_flags(word flags) { m_flags_and_data_offset = (m_flags_and_data_offset & ~0x1ff) | (flags & 0x1ff); }
|
||||
u16 flags() const { return m_flags_and_data_offset & 0x1ff; }
|
||||
void set_flags(u16 flags) { m_flags_and_data_offset = (m_flags_and_data_offset & ~0x1ff) | (flags & 0x1ff); }
|
||||
|
||||
bool has_syn() const { return flags() & TCPFlags::SYN; }
|
||||
bool has_ack() const { return flags() & TCPFlags::ACK; }
|
||||
bool has_fin() const { return flags() & TCPFlags::FIN; }
|
||||
|
||||
byte data_offset() const { return (m_flags_and_data_offset & 0xf000) >> 12; }
|
||||
void set_data_offset(word data_offset) { m_flags_and_data_offset = (m_flags_and_data_offset & ~0xf000) | data_offset << 12; }
|
||||
u8 data_offset() const { return (m_flags_and_data_offset & 0xf000) >> 12; }
|
||||
void set_data_offset(u16 data_offset) { m_flags_and_data_offset = (m_flags_and_data_offset & ~0xf000) | data_offset << 12; }
|
||||
|
||||
word window_size() const { return m_window_size; }
|
||||
void set_window_size(word window_size) { m_window_size = window_size; }
|
||||
u16 window_size() const { return m_window_size; }
|
||||
void set_window_size(u16 window_size) { m_window_size = window_size; }
|
||||
|
||||
word checksum() const { return m_checksum; }
|
||||
void set_checksum(word checksum) { m_checksum = checksum; }
|
||||
u16 checksum() const { return m_checksum; }
|
||||
void set_checksum(u16 checksum) { m_checksum = checksum; }
|
||||
|
||||
word urgent() const { return m_urgent; }
|
||||
void set_urgent(word urgent) { m_urgent = urgent; }
|
||||
u16 urgent() const { return m_urgent; }
|
||||
void set_urgent(u16 urgent) { m_urgent = urgent; }
|
||||
|
||||
const void* payload() const { return ((const byte*)this) + header_size(); }
|
||||
void* payload() { return ((byte*)this) + header_size(); }
|
||||
const void* payload() const { return ((const u8*)this) + header_size(); }
|
||||
void* payload() { return ((u8*)this) + header_size(); }
|
||||
|
||||
private:
|
||||
NetworkOrdered<word> m_source_port;
|
||||
NetworkOrdered<word> m_destination_port;
|
||||
NetworkOrdered<dword> m_sequence_number;
|
||||
NetworkOrdered<dword> m_ack_number;
|
||||
NetworkOrdered<u16> m_source_port;
|
||||
NetworkOrdered<u16> m_destination_port;
|
||||
NetworkOrdered<u32> m_sequence_number;
|
||||
NetworkOrdered<u32> m_ack_number;
|
||||
|
||||
NetworkOrdered<word> m_flags_and_data_offset;
|
||||
NetworkOrdered<word> m_window_size;
|
||||
NetworkOrdered<word> m_checksum;
|
||||
NetworkOrdered<word> m_urgent;
|
||||
NetworkOrdered<u16> m_flags_and_data_offset;
|
||||
NetworkOrdered<u16> m_window_size;
|
||||
NetworkOrdered<u16> m_checksum;
|
||||
NetworkOrdered<u16> m_urgent;
|
||||
};
|
||||
|
||||
static_assert(sizeof(TCPPacket) == 20);
|
||||
|
|
|
@ -5,15 +5,15 @@
|
|||
#include <Kernel/Net/TCPSocket.h>
|
||||
#include <Kernel/Process.h>
|
||||
|
||||
Lockable<HashMap<word, TCPSocket*>>& TCPSocket::sockets_by_port()
|
||||
Lockable<HashMap<u16, TCPSocket*>>& TCPSocket::sockets_by_port()
|
||||
{
|
||||
static Lockable<HashMap<word, TCPSocket*>>* s_map;
|
||||
static Lockable<HashMap<u16, TCPSocket*>>* s_map;
|
||||
if (!s_map)
|
||||
s_map = new Lockable<HashMap<word, TCPSocket*>>;
|
||||
s_map = new Lockable<HashMap<u16, TCPSocket*>>;
|
||||
return *s_map;
|
||||
}
|
||||
|
||||
TCPSocketHandle TCPSocket::from_port(word port)
|
||||
TCPSocketHandle TCPSocket::from_port(u16 port)
|
||||
{
|
||||
RefPtr<TCPSocket> socket;
|
||||
{
|
||||
|
@ -65,7 +65,7 @@ int TCPSocket::protocol_send(const void* data, int data_length)
|
|||
return data_length;
|
||||
}
|
||||
|
||||
void TCPSocket::send_tcp_packet(word flags, const void* payload, int payload_size)
|
||||
void TCPSocket::send_tcp_packet(u16 flags, const void* payload, int payload_size)
|
||||
{
|
||||
// FIXME: Maybe the socket should be bound to an adapter instead of looking it up every time?
|
||||
auto* adapter = adapter_for_route_to(peer_address());
|
||||
|
@ -78,7 +78,7 @@ void TCPSocket::send_tcp_packet(word flags, const void* payload, int payload_siz
|
|||
tcp_packet.set_destination_port(peer_port());
|
||||
tcp_packet.set_window_size(1024);
|
||||
tcp_packet.set_sequence_number(m_sequence_number);
|
||||
tcp_packet.set_data_offset(sizeof(TCPPacket) / sizeof(dword));
|
||||
tcp_packet.set_data_offset(sizeof(TCPPacket) / sizeof(u32));
|
||||
tcp_packet.set_flags(flags);
|
||||
|
||||
if (flags & TCPFlags::ACK)
|
||||
|
@ -104,41 +104,41 @@ void TCPSocket::send_tcp_packet(word flags, const void* payload, int payload_siz
|
|||
adapter->send_ipv4(MACAddress(), peer_address(), IPv4Protocol::TCP, move(buffer));
|
||||
}
|
||||
|
||||
NetworkOrdered<word> TCPSocket::compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket& packet, word payload_size)
|
||||
NetworkOrdered<u16> TCPSocket::compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket& packet, u16 payload_size)
|
||||
{
|
||||
struct [[gnu::packed]] PseudoHeader
|
||||
{
|
||||
IPv4Address source;
|
||||
IPv4Address destination;
|
||||
byte zero;
|
||||
byte protocol;
|
||||
NetworkOrdered<word> payload_size;
|
||||
u8 zero;
|
||||
u8 protocol;
|
||||
NetworkOrdered<u16> payload_size;
|
||||
};
|
||||
|
||||
PseudoHeader pseudo_header { source, destination, 0, (byte)IPv4Protocol::TCP, sizeof(TCPPacket) + payload_size };
|
||||
PseudoHeader pseudo_header { source, destination, 0, (u8)IPv4Protocol::TCP, sizeof(TCPPacket) + payload_size };
|
||||
|
||||
dword checksum = 0;
|
||||
auto* w = (const NetworkOrdered<word>*)&pseudo_header;
|
||||
for (size_t i = 0; i < sizeof(pseudo_header) / sizeof(word); ++i) {
|
||||
u32 checksum = 0;
|
||||
auto* w = (const NetworkOrdered<u16>*)&pseudo_header;
|
||||
for (size_t i = 0; i < sizeof(pseudo_header) / sizeof(u16); ++i) {
|
||||
checksum += w[i];
|
||||
if (checksum > 0xffff)
|
||||
checksum = (checksum >> 16) + (checksum & 0xffff);
|
||||
}
|
||||
w = (const NetworkOrdered<word>*)&packet;
|
||||
for (size_t i = 0; i < sizeof(packet) / sizeof(word); ++i) {
|
||||
w = (const NetworkOrdered<u16>*)&packet;
|
||||
for (size_t i = 0; i < sizeof(packet) / sizeof(u16); ++i) {
|
||||
checksum += w[i];
|
||||
if (checksum > 0xffff)
|
||||
checksum = (checksum >> 16) + (checksum & 0xffff);
|
||||
}
|
||||
ASSERT(packet.data_offset() * 4 == sizeof(TCPPacket));
|
||||
w = (const NetworkOrdered<word>*)packet.payload();
|
||||
for (size_t i = 0; i < payload_size / sizeof(word); ++i) {
|
||||
w = (const NetworkOrdered<u16>*)packet.payload();
|
||||
for (size_t i = 0; i < payload_size / sizeof(u16); ++i) {
|
||||
checksum += w[i];
|
||||
if (checksum > 0xffff)
|
||||
checksum = (checksum >> 16) + (checksum & 0xffff);
|
||||
}
|
||||
if (payload_size & 1) {
|
||||
word expanded_byte = ((const byte*)packet.payload())[payload_size - 1] << 8;
|
||||
u16 expanded_byte = ((const u8*)packet.payload())[payload_size - 1] << 8;
|
||||
checksum += expanded_byte;
|
||||
if (checksum > 0xffff)
|
||||
checksum = (checksum >> 16) + (checksum & 0xffff);
|
||||
|
@ -171,13 +171,13 @@ KResult TCPSocket::protocol_connect(FileDescription& description, ShouldBlock sh
|
|||
|
||||
int TCPSocket::protocol_allocate_local_port()
|
||||
{
|
||||
static const word first_ephemeral_port = 32768;
|
||||
static const word last_ephemeral_port = 60999;
|
||||
static const word ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
|
||||
word first_scan_port = first_ephemeral_port + RandomDevice::random_value() % ephemeral_port_range_size;
|
||||
static const u16 first_ephemeral_port = 32768;
|
||||
static const u16 last_ephemeral_port = 60999;
|
||||
static const u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
|
||||
u16 first_scan_port = first_ephemeral_port + RandomDevice::random_value() % ephemeral_port_range_size;
|
||||
|
||||
LOCKER(sockets_by_port().lock());
|
||||
for (word port = first_scan_port;;) {
|
||||
for (u16 port = first_scan_port;;) {
|
||||
auto it = sockets_by_port().resource().find(port);
|
||||
if (it == sockets_by_port().resource().end()) {
|
||||
set_local_port(port);
|
||||
|
|
|
@ -17,21 +17,21 @@ public:
|
|||
State state() const { return m_state; }
|
||||
void set_state(State state) { m_state = state; }
|
||||
|
||||
void set_ack_number(dword n) { m_ack_number = n; }
|
||||
void set_sequence_number(dword n) { m_sequence_number = n; }
|
||||
dword ack_number() const { return m_ack_number; }
|
||||
dword sequence_number() const { return m_sequence_number; }
|
||||
void set_ack_number(u32 n) { m_ack_number = n; }
|
||||
void set_sequence_number(u32 n) { m_sequence_number = n; }
|
||||
u32 ack_number() const { return m_ack_number; }
|
||||
u32 sequence_number() const { return m_sequence_number; }
|
||||
|
||||
void send_tcp_packet(word flags, const void* = nullptr, int = 0);
|
||||
void send_tcp_packet(u16 flags, const void* = nullptr, int = 0);
|
||||
|
||||
static Lockable<HashMap<word, TCPSocket*>>& sockets_by_port();
|
||||
static TCPSocketHandle from_port(word);
|
||||
static Lockable<HashMap<u16, TCPSocket*>>& sockets_by_port();
|
||||
static TCPSocketHandle from_port(u16);
|
||||
|
||||
private:
|
||||
explicit TCPSocket(int protocol);
|
||||
virtual const char* class_name() const override { return "TCPSocket"; }
|
||||
|
||||
static NetworkOrdered<word> compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket&, word payload_size);
|
||||
static NetworkOrdered<u16> compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket&, u16 payload_size);
|
||||
|
||||
virtual int protocol_receive(const ByteBuffer&, void* buffer, size_t buffer_size, int flags) override;
|
||||
virtual int protocol_send(const void*, int) override;
|
||||
|
@ -40,8 +40,8 @@ private:
|
|||
virtual bool protocol_is_disconnected() const override;
|
||||
virtual KResult protocol_bind() override;
|
||||
|
||||
dword m_sequence_number { 0 };
|
||||
dword m_ack_number { 0 };
|
||||
u32 m_sequence_number { 0 };
|
||||
u32 m_ack_number { 0 };
|
||||
State m_state { State::Disconnected };
|
||||
};
|
||||
|
||||
|
|
|
@ -8,26 +8,26 @@ public:
|
|||
UDPPacket() {}
|
||||
~UDPPacket() {}
|
||||
|
||||
word source_port() const { return m_source_port; }
|
||||
void set_source_port(word port) { m_source_port = port; }
|
||||
u16 source_port() const { return m_source_port; }
|
||||
void set_source_port(u16 port) { m_source_port = port; }
|
||||
|
||||
word destination_port() const { return m_destination_port; }
|
||||
void set_destination_port(word port) { m_destination_port = port; }
|
||||
u16 destination_port() const { return m_destination_port; }
|
||||
void set_destination_port(u16 port) { m_destination_port = port; }
|
||||
|
||||
word length() const { return m_length; }
|
||||
void set_length(word length) { m_length = length; }
|
||||
u16 length() const { return m_length; }
|
||||
void set_length(u16 length) { m_length = length; }
|
||||
|
||||
word checksum() const { return m_checksum; }
|
||||
void set_checksum(word checksum) { m_checksum = checksum; }
|
||||
u16 checksum() const { return m_checksum; }
|
||||
void set_checksum(u16 checksum) { m_checksum = checksum; }
|
||||
|
||||
const void* payload() const { return this + 1; }
|
||||
void* payload() { return this + 1; }
|
||||
|
||||
private:
|
||||
NetworkOrdered<word> m_source_port;
|
||||
NetworkOrdered<word> m_destination_port;
|
||||
NetworkOrdered<word> m_length;
|
||||
NetworkOrdered<word> m_checksum;
|
||||
NetworkOrdered<u16> m_source_port;
|
||||
NetworkOrdered<u16> m_destination_port;
|
||||
NetworkOrdered<u16> m_length;
|
||||
NetworkOrdered<u16> m_checksum;
|
||||
};
|
||||
|
||||
static_assert(sizeof(UDPPacket) == 8);
|
||||
|
|
|
@ -5,15 +5,15 @@
|
|||
#include <Kernel/Net/UDPSocket.h>
|
||||
#include <Kernel/Process.h>
|
||||
|
||||
Lockable<HashMap<word, UDPSocket*>>& UDPSocket::sockets_by_port()
|
||||
Lockable<HashMap<u16, UDPSocket*>>& UDPSocket::sockets_by_port()
|
||||
{
|
||||
static Lockable<HashMap<word, UDPSocket*>>* s_map;
|
||||
static Lockable<HashMap<u16, UDPSocket*>>* s_map;
|
||||
if (!s_map)
|
||||
s_map = new Lockable<HashMap<word, UDPSocket*>>;
|
||||
s_map = new Lockable<HashMap<u16, UDPSocket*>>;
|
||||
return *s_map;
|
||||
}
|
||||
|
||||
UDPSocketHandle UDPSocket::from_port(word port)
|
||||
UDPSocketHandle UDPSocket::from_port(u16 port)
|
||||
{
|
||||
RefPtr<UDPSocket> socket;
|
||||
{
|
||||
|
@ -77,13 +77,13 @@ int UDPSocket::protocol_send(const void* data, int data_length)
|
|||
|
||||
int UDPSocket::protocol_allocate_local_port()
|
||||
{
|
||||
static const word first_ephemeral_port = 32768;
|
||||
static const word last_ephemeral_port = 60999;
|
||||
static const word ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
|
||||
word first_scan_port = first_ephemeral_port + RandomDevice::random_value() % ephemeral_port_range_size;
|
||||
static const u16 first_ephemeral_port = 32768;
|
||||
static const u16 last_ephemeral_port = 60999;
|
||||
static const u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
|
||||
u16 first_scan_port = first_ephemeral_port + RandomDevice::random_value() % ephemeral_port_range_size;
|
||||
|
||||
LOCKER(sockets_by_port().lock());
|
||||
for (word port = first_scan_port;;) {
|
||||
for (u16 port = first_scan_port;;) {
|
||||
auto it = sockets_by_port().resource().find(port);
|
||||
if (it == sockets_by_port().resource().end()) {
|
||||
set_local_port(port);
|
||||
|
|
|
@ -9,12 +9,12 @@ public:
|
|||
static NonnullRefPtr<UDPSocket> create(int protocol);
|
||||
virtual ~UDPSocket() override;
|
||||
|
||||
static UDPSocketHandle from_port(word);
|
||||
static UDPSocketHandle from_port(u16);
|
||||
|
||||
private:
|
||||
explicit UDPSocket(int protocol);
|
||||
virtual const char* class_name() const override { return "UDPSocket"; }
|
||||
static Lockable<HashMap<word, UDPSocket*>>& sockets_by_port();
|
||||
static Lockable<HashMap<u16, UDPSocket*>>& sockets_by_port();
|
||||
|
||||
virtual int protocol_receive(const ByteBuffer&, void* buffer, size_t buffer_size, int flags) override;
|
||||
virtual int protocol_send(const void*, int) override;
|
||||
|
|
|
@ -13,12 +13,12 @@
|
|||
#define PCI_LATENCY_TIMER 0x0d // byte
|
||||
#define PCI_HEADER_TYPE 0x0e // byte
|
||||
#define PCI_BIST 0x0f // byte
|
||||
#define PCI_BAR0 0x10 // dword
|
||||
#define PCI_BAR1 0x14 // dword
|
||||
#define PCI_BAR2 0x18 // dword
|
||||
#define PCI_BAR3 0x1C // dword
|
||||
#define PCI_BAR4 0x20 // dword
|
||||
#define PCI_BAR5 0x24 // dword
|
||||
#define PCI_BAR0 0x10 // u32
|
||||
#define PCI_BAR1 0x14 // u32
|
||||
#define PCI_BAR2 0x18 // u32
|
||||
#define PCI_BAR3 0x1C // u32
|
||||
#define PCI_BAR4 0x20 // u32
|
||||
#define PCI_BAR5 0x24 // u32
|
||||
#define PCI_INTERRUPT_LINE 0x3C // byte
|
||||
#define PCI_SECONDARY_BUS 0x19 // byte
|
||||
#define PCI_HEADER_TYPE_DEVICE 0
|
||||
|
@ -31,7 +31,7 @@
|
|||
namespace PCI {
|
||||
|
||||
template<typename T>
|
||||
T read_field(Address address, dword field)
|
||||
T read_field(Address address, u32 field)
|
||||
{
|
||||
IO::out32(PCI_ADDRESS_PORT, address.io_address_for_field(field));
|
||||
if constexpr (sizeof(T) == 4)
|
||||
|
@ -43,7 +43,7 @@ T read_field(Address address, dword field)
|
|||
}
|
||||
|
||||
template<typename T>
|
||||
void write_field(Address address, dword field, T value)
|
||||
void write_field(Address address, u32 field, T value)
|
||||
{
|
||||
IO::out32(PCI_ADDRESS_PORT, address.io_address_for_field(field));
|
||||
if constexpr (sizeof(T) == 4)
|
||||
|
@ -54,74 +54,74 @@ void write_field(Address address, dword field, T value)
|
|||
IO::out8(PCI_VALUE_PORT + (field & 3), value);
|
||||
}
|
||||
|
||||
word read_type(Address address)
|
||||
u16 read_type(Address address)
|
||||
{
|
||||
return (read_field<byte>(address, PCI_CLASS) << 8u) | read_field<byte>(address, PCI_SUBCLASS);
|
||||
return (read_field<u8>(address, PCI_CLASS) << 8u) | read_field<u8>(address, PCI_SUBCLASS);
|
||||
}
|
||||
|
||||
void enumerate_bus(int type, byte bus, Function<void(Address, ID)>&);
|
||||
void enumerate_bus(int type, u8 bus, Function<void(Address, ID)>&);
|
||||
|
||||
void enumerate_functions(int type, byte bus, byte slot, byte function, Function<void(Address, ID)>& callback)
|
||||
void enumerate_functions(int type, u8 bus, u8 slot, u8 function, Function<void(Address, ID)>& callback)
|
||||
{
|
||||
Address address(bus, slot, function);
|
||||
if (type == -1 || type == read_type(address))
|
||||
callback(address, { read_field<word>(address, PCI_VENDOR_ID), read_field<word>(address, PCI_DEVICE_ID) });
|
||||
callback(address, { read_field<u16>(address, PCI_VENDOR_ID), read_field<u16>(address, PCI_DEVICE_ID) });
|
||||
if (read_type(address) == PCI_TYPE_BRIDGE) {
|
||||
byte secondary_bus = read_field<byte>(address, PCI_SECONDARY_BUS);
|
||||
u8 secondary_bus = read_field<u8>(address, PCI_SECONDARY_BUS);
|
||||
kprintf("PCI: Found secondary bus: %u\n", secondary_bus);
|
||||
ASSERT(secondary_bus != bus);
|
||||
enumerate_bus(type, secondary_bus, callback);
|
||||
}
|
||||
}
|
||||
|
||||
void enumerate_slot(int type, byte bus, byte slot, Function<void(Address, ID)>& callback)
|
||||
void enumerate_slot(int type, u8 bus, u8 slot, Function<void(Address, ID)>& callback)
|
||||
{
|
||||
Address address(bus, slot, 0);
|
||||
if (read_field<word>(address, PCI_VENDOR_ID) == PCI_NONE)
|
||||
if (read_field<u16>(address, PCI_VENDOR_ID) == PCI_NONE)
|
||||
return;
|
||||
enumerate_functions(type, bus, slot, 0, callback);
|
||||
if (!(read_field<byte>(address, PCI_HEADER_TYPE) & 0x80))
|
||||
if (!(read_field<u8>(address, PCI_HEADER_TYPE) & 0x80))
|
||||
return;
|
||||
for (byte function = 1; function < 8; ++function) {
|
||||
for (u8 function = 1; function < 8; ++function) {
|
||||
Address address(bus, slot, function);
|
||||
if (read_field<word>(address, PCI_VENDOR_ID) != PCI_NONE)
|
||||
if (read_field<u16>(address, PCI_VENDOR_ID) != PCI_NONE)
|
||||
enumerate_functions(type, bus, slot, function, callback);
|
||||
}
|
||||
}
|
||||
|
||||
void enumerate_bus(int type, byte bus, Function<void(Address, ID)>& callback)
|
||||
void enumerate_bus(int type, u8 bus, Function<void(Address, ID)>& callback)
|
||||
{
|
||||
for (byte slot = 0; slot < 32; ++slot)
|
||||
for (u8 slot = 0; slot < 32; ++slot)
|
||||
enumerate_slot(type, bus, slot, callback);
|
||||
}
|
||||
|
||||
byte get_interrupt_line(Address address) { return read_field<byte>(address, PCI_INTERRUPT_LINE); }
|
||||
dword get_BAR0(Address address) { return read_field<dword>(address, PCI_BAR0); }
|
||||
dword get_BAR1(Address address) { return read_field<dword>(address, PCI_BAR1); }
|
||||
dword get_BAR2(Address address) { return read_field<dword>(address, PCI_BAR2); }
|
||||
dword get_BAR3(Address address) { return read_field<dword>(address, PCI_BAR3); }
|
||||
dword get_BAR4(Address address) { return read_field<dword>(address, PCI_BAR4); }
|
||||
dword get_BAR5(Address address) { return read_field<dword>(address, PCI_BAR5); }
|
||||
u8 get_interrupt_line(Address address) { return read_field<u8>(address, PCI_INTERRUPT_LINE); }
|
||||
u32 get_BAR0(Address address) { return read_field<u32>(address, PCI_BAR0); }
|
||||
u32 get_BAR1(Address address) { return read_field<u32>(address, PCI_BAR1); }
|
||||
u32 get_BAR2(Address address) { return read_field<u32>(address, PCI_BAR2); }
|
||||
u32 get_BAR3(Address address) { return read_field<u32>(address, PCI_BAR3); }
|
||||
u32 get_BAR4(Address address) { return read_field<u32>(address, PCI_BAR4); }
|
||||
u32 get_BAR5(Address address) { return read_field<u32>(address, PCI_BAR5); }
|
||||
|
||||
void enable_bus_mastering(Address address)
|
||||
{
|
||||
auto value = read_field<word>(address, PCI_COMMAND);
|
||||
auto value = read_field<u16>(address, PCI_COMMAND);
|
||||
value |= (1 << 2);
|
||||
value |= (1 << 0);
|
||||
write_field<word>(address, PCI_COMMAND, value);
|
||||
write_field<u16>(address, PCI_COMMAND, value);
|
||||
}
|
||||
|
||||
void enumerate_all(Function<void(Address, ID)> callback)
|
||||
{
|
||||
// Single PCI host controller.
|
||||
if ((read_field<byte>(Address(), PCI_HEADER_TYPE) & 0x80) == 0) {
|
||||
if ((read_field<u8>(Address(), PCI_HEADER_TYPE) & 0x80) == 0) {
|
||||
enumerate_bus(-1, 0, callback);
|
||||
return;
|
||||
}
|
||||
|
||||
// Multiple PCI host controllers.
|
||||
for (byte function = 0; function < 8; ++function) {
|
||||
if (read_field<word>(Address(0, 0, function), PCI_VENDOR_ID) == PCI_NONE)
|
||||
for (u8 function = 0; function < 8; ++function) {
|
||||
if (read_field<u16>(Address(0, 0, function), PCI_VENDOR_ID) == PCI_NONE)
|
||||
break;
|
||||
enumerate_bus(-1, function, callback);
|
||||
}
|
||||
|
|
34
Kernel/PCI.h
34
Kernel/PCI.h
|
@ -6,8 +6,8 @@
|
|||
namespace PCI {
|
||||
|
||||
struct ID {
|
||||
word vendor_id { 0 };
|
||||
word device_id { 0 };
|
||||
u16 vendor_id { 0 };
|
||||
u16 device_id { 0 };
|
||||
|
||||
bool is_null() const { return !vendor_id && !device_id; }
|
||||
|
||||
|
@ -19,7 +19,7 @@ struct ID {
|
|||
|
||||
struct Address {
|
||||
Address() {}
|
||||
Address(byte bus, byte slot, byte function)
|
||||
Address(u8 bus, u8 slot, u8 function)
|
||||
: m_bus(bus)
|
||||
, m_slot(slot)
|
||||
, m_function(function)
|
||||
|
@ -29,29 +29,29 @@ struct Address {
|
|||
bool is_null() const { return !m_bus && !m_slot && !m_function; }
|
||||
operator bool() const { return !is_null(); }
|
||||
|
||||
byte bus() const { return m_bus; }
|
||||
byte slot() const { return m_slot; }
|
||||
byte function() const { return m_function; }
|
||||
u8 bus() const { return m_bus; }
|
||||
u8 slot() const { return m_slot; }
|
||||
u8 function() const { return m_function; }
|
||||
|
||||
dword io_address_for_field(byte field) const
|
||||
u32 io_address_for_field(u8 field) const
|
||||
{
|
||||
return 0x80000000u | (m_bus << 16u) | (m_slot << 11u) | (m_function << 8u) | (field & 0xfc);
|
||||
}
|
||||
|
||||
private:
|
||||
byte m_bus { 0 };
|
||||
byte m_slot { 0 };
|
||||
byte m_function { 0 };
|
||||
u8 m_bus { 0 };
|
||||
u8 m_slot { 0 };
|
||||
u8 m_function { 0 };
|
||||
};
|
||||
|
||||
void enumerate_all(Function<void(Address, ID)>);
|
||||
byte get_interrupt_line(Address);
|
||||
dword get_BAR0(Address);
|
||||
dword get_BAR1(Address);
|
||||
dword get_BAR2(Address);
|
||||
dword get_BAR3(Address);
|
||||
dword get_BAR4(Address);
|
||||
dword get_BAR5(Address);
|
||||
u8 get_interrupt_line(Address);
|
||||
u32 get_BAR0(Address);
|
||||
u32 get_BAR1(Address);
|
||||
u32 get_BAR2(Address);
|
||||
u32 get_BAR3(Address);
|
||||
u32 get_BAR4(Address);
|
||||
u32 get_BAR5(Address);
|
||||
void enable_bus_mastering(Address);
|
||||
|
||||
}
|
||||
|
|
|
@ -19,9 +19,9 @@ static bool initialized;
|
|||
|
||||
namespace PIC {
|
||||
|
||||
void disable(byte irq)
|
||||
void disable(u8 irq)
|
||||
{
|
||||
byte imr;
|
||||
u8 imr;
|
||||
if (irq & 8) {
|
||||
imr = IO::in8(PIC1_CMD);
|
||||
imr |= 1 << (irq - 8);
|
||||
|
@ -33,9 +33,9 @@ void disable(byte irq)
|
|||
}
|
||||
}
|
||||
|
||||
void enable(byte irq)
|
||||
void enable(u8 irq)
|
||||
{
|
||||
byte imr;
|
||||
u8 imr;
|
||||
if (irq & 8) {
|
||||
imr = IO::in8(PIC1_CMD);
|
||||
imr &= ~(1 << (irq - 8));
|
||||
|
@ -47,7 +47,7 @@ void enable(byte irq)
|
|||
}
|
||||
}
|
||||
|
||||
void eoi(byte irq)
|
||||
void eoi(u8 irq)
|
||||
{
|
||||
if (irq & 8)
|
||||
IO::out8(PIC1_CTL, 0x20);
|
||||
|
@ -90,21 +90,21 @@ void initialize()
|
|||
#endif
|
||||
}
|
||||
|
||||
word get_isr()
|
||||
u16 get_isr()
|
||||
{
|
||||
IO::out8(PIC0_CTL, 0x0b);
|
||||
IO::out8(PIC1_CTL, 0x0b);
|
||||
byte isr0 = IO::in8(PIC0_CTL);
|
||||
byte isr1 = IO::in8(PIC1_CTL);
|
||||
u8 isr0 = IO::in8(PIC0_CTL);
|
||||
u8 isr1 = IO::in8(PIC1_CTL);
|
||||
return (isr1 << 8) | isr0;
|
||||
}
|
||||
|
||||
word get_irr()
|
||||
u16 get_irr()
|
||||
{
|
||||
IO::out8(PIC0_CTL, 0x0a);
|
||||
IO::out8(PIC1_CTL, 0x0a);
|
||||
byte irr0 = IO::in8(PIC0_CTL);
|
||||
byte irr1 = IO::in8(PIC1_CTL);
|
||||
u8 irr0 = IO::in8(PIC0_CTL);
|
||||
u8 irr1 = IO::in8(PIC1_CTL);
|
||||
return (irr1 << 8) | irr0;
|
||||
}
|
||||
|
||||
|
|
14
Kernel/PIC.h
14
Kernel/PIC.h
|
@ -4,23 +4,23 @@
|
|||
|
||||
namespace PIC {
|
||||
|
||||
void enable(byte number);
|
||||
void disable(byte number);
|
||||
void eoi(byte number);
|
||||
void enable(u8 number);
|
||||
void disable(u8 number);
|
||||
void eoi(u8 number);
|
||||
void initialize();
|
||||
word get_isr();
|
||||
word get_irr();
|
||||
u16 get_isr();
|
||||
u16 get_irr();
|
||||
|
||||
}
|
||||
|
||||
class IRQHandlerScope {
|
||||
public:
|
||||
explicit IRQHandlerScope(byte irq)
|
||||
explicit IRQHandlerScope(u8 irq)
|
||||
: m_irq(irq)
|
||||
{
|
||||
}
|
||||
~IRQHandlerScope() { PIC::eoi(m_irq); }
|
||||
|
||||
private:
|
||||
byte m_irq { 0 };
|
||||
u8 m_irq { 0 };
|
||||
};
|
||||
|
|
|
@ -1,24 +1,26 @@
|
|||
#pragma once
|
||||
|
||||
#include <AK/Types.h>
|
||||
|
||||
class PhysicalAddress {
|
||||
public:
|
||||
PhysicalAddress() {}
|
||||
explicit PhysicalAddress(dword address)
|
||||
explicit PhysicalAddress(u32 address)
|
||||
: m_address(address)
|
||||
{
|
||||
}
|
||||
|
||||
PhysicalAddress offset(dword o) const { return PhysicalAddress(m_address + o); }
|
||||
dword get() const { return m_address; }
|
||||
void set(dword address) { m_address = address; }
|
||||
void mask(dword m) { m_address &= m; }
|
||||
PhysicalAddress offset(u32 o) const { return PhysicalAddress(m_address + o); }
|
||||
u32 get() const { return m_address; }
|
||||
void set(u32 address) { m_address = address; }
|
||||
void mask(u32 m) { m_address &= m; }
|
||||
|
||||
bool is_null() const { return m_address == 0; }
|
||||
|
||||
byte* as_ptr() { return reinterpret_cast<byte*>(m_address); }
|
||||
const byte* as_ptr() const { return reinterpret_cast<const byte*>(m_address); }
|
||||
u8* as_ptr() { return reinterpret_cast<u8*>(m_address); }
|
||||
const u8* as_ptr() const { return reinterpret_cast<const u8*>(m_address); }
|
||||
|
||||
dword page_base() const { return m_address & 0xfffff000; }
|
||||
u32 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; }
|
||||
|
@ -28,5 +30,5 @@ public:
|
|||
bool operator<=(const PhysicalAddress& other) const { return m_address <= other.m_address; }
|
||||
|
||||
private:
|
||||
dword m_address { 0 };
|
||||
u32 m_address { 0 };
|
||||
};
|
||||
|
|
|
@ -154,7 +154,7 @@ int Process::sys$set_mmap_name(void* addr, size_t size, const char* name)
|
|||
{
|
||||
if (!validate_read_str(name))
|
||||
return -EFAULT;
|
||||
auto* region = region_from_range(VirtualAddress((dword)addr), size);
|
||||
auto* region = region_from_range(VirtualAddress((u32)addr), size);
|
||||
if (!region)
|
||||
return -EINVAL;
|
||||
region->set_name(String(name));
|
||||
|
@ -176,10 +176,10 @@ void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
|
|||
const char* name = params->name;
|
||||
if (size == 0)
|
||||
return (void*)-EINVAL;
|
||||
if ((dword)addr & ~PAGE_MASK)
|
||||
if ((u32)addr & ~PAGE_MASK)
|
||||
return (void*)-EINVAL;
|
||||
if (flags & MAP_ANONYMOUS) {
|
||||
auto* region = allocate_region(VirtualAddress((dword)addr), size, "mmap", prot, false);
|
||||
auto* region = allocate_region(VirtualAddress((u32)addr), size, "mmap", prot, false);
|
||||
if (!region)
|
||||
return (void*)-ENOMEM;
|
||||
if (flags & MAP_SHARED)
|
||||
|
@ -193,7 +193,7 @@ void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
|
|||
auto* description = file_description(fd);
|
||||
if (!description)
|
||||
return (void*)-EBADF;
|
||||
auto region_or_error = description->mmap(*this, VirtualAddress((dword)addr), offset, size, prot);
|
||||
auto region_or_error = description->mmap(*this, VirtualAddress((u32)addr), offset, size, prot);
|
||||
if (region_or_error.is_error())
|
||||
return (void*)(int)region_or_error.error();
|
||||
auto region = region_or_error.value();
|
||||
|
@ -206,7 +206,7 @@ void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
|
|||
|
||||
int Process::sys$munmap(void* addr, size_t size)
|
||||
{
|
||||
auto* region = region_from_range(VirtualAddress((dword)addr), size);
|
||||
auto* region = region_from_range(VirtualAddress((u32)addr), size);
|
||||
if (!region)
|
||||
return -EINVAL;
|
||||
if (!deallocate_region(*region))
|
||||
|
@ -323,7 +323,7 @@ int Process::do_exec(String path, Vector<String> arguments, Vector<String> envir
|
|||
if (!metadata.size)
|
||||
return -ENOTIMPL;
|
||||
|
||||
dword entry_eip = 0;
|
||||
u32 entry_eip = 0;
|
||||
// FIXME: Is there a race here?
|
||||
auto old_page_directory = move(m_page_directory);
|
||||
m_page_directory = PageDirectory::create_for_userspace();
|
||||
|
@ -420,7 +420,7 @@ int Process::do_exec(String path, Vector<String> arguments, Vector<String> envir
|
|||
m_name = parts.take_last();
|
||||
|
||||
// ss0 sp!!!!!!!!!
|
||||
dword old_esp0 = main_thread().m_tss.esp0;
|
||||
u32 old_esp0 = main_thread().m_tss.esp0;
|
||||
|
||||
memset(&main_thread().m_tss, 0, sizeof(main_thread().m_tss));
|
||||
main_thread().m_tss.eflags = 0x0202;
|
||||
|
@ -548,7 +548,7 @@ Process* Process::create_user_process(const String& path, uid_t uid, gid_t gid,
|
|||
Process* Process::create_kernel_process(String&& name, void (*e)())
|
||||
{
|
||||
auto* process = new Process(move(name), (uid_t)0, (gid_t)0, (pid_t)0, Ring0);
|
||||
process->main_thread().tss().eip = (dword)e;
|
||||
process->main_thread().tss().eip = (u32)e;
|
||||
|
||||
if (process->pid() != 0) {
|
||||
InterruptDisabler disabler;
|
||||
|
@ -679,18 +679,18 @@ void Process::create_signal_trampolines_if_needed()
|
|||
// FIXME: Remap as read-only after setup.
|
||||
auto* region = allocate_region(VirtualAddress(), PAGE_SIZE, "Signal trampolines", PROT_READ | PROT_WRITE | PROT_EXEC);
|
||||
m_return_to_ring3_from_signal_trampoline = region->vaddr();
|
||||
byte* code_ptr = m_return_to_ring3_from_signal_trampoline.as_ptr();
|
||||
u8* code_ptr = m_return_to_ring3_from_signal_trampoline.as_ptr();
|
||||
*code_ptr++ = 0x58; // pop eax (Argument to signal handler (ignored here))
|
||||
*code_ptr++ = 0x5a; // pop edx (Original signal mask to restore)
|
||||
*code_ptr++ = 0xb8; // mov eax, <dword>
|
||||
*(dword*)code_ptr = Syscall::SC_restore_signal_mask;
|
||||
code_ptr += sizeof(dword);
|
||||
*code_ptr++ = 0xb8; // mov eax, <u32>
|
||||
*(u32*)code_ptr = Syscall::SC_restore_signal_mask;
|
||||
code_ptr += sizeof(u32);
|
||||
*code_ptr++ = 0xcd; // int 0x82
|
||||
*code_ptr++ = 0x82;
|
||||
|
||||
*code_ptr++ = 0x83; // add esp, (stack alignment padding)
|
||||
*code_ptr++ = 0xc4;
|
||||
*code_ptr++ = sizeof(dword) * 3;
|
||||
*code_ptr++ = sizeof(u32) * 3;
|
||||
|
||||
*code_ptr++ = 0x61; // popa
|
||||
*code_ptr++ = 0x9d; // popf
|
||||
|
@ -698,26 +698,26 @@ void Process::create_signal_trampolines_if_needed()
|
|||
*code_ptr++ = 0x0f; // ud2
|
||||
*code_ptr++ = 0x0b;
|
||||
|
||||
m_return_to_ring0_from_signal_trampoline = VirtualAddress((dword)code_ptr);
|
||||
m_return_to_ring0_from_signal_trampoline = VirtualAddress((u32)code_ptr);
|
||||
*code_ptr++ = 0x58; // pop eax (Argument to signal handler (ignored here))
|
||||
*code_ptr++ = 0x5a; // pop edx (Original signal mask to restore)
|
||||
*code_ptr++ = 0xb8; // mov eax, <dword>
|
||||
*(dword*)code_ptr = Syscall::SC_restore_signal_mask;
|
||||
code_ptr += sizeof(dword);
|
||||
*code_ptr++ = 0xb8; // mov eax, <u32>
|
||||
*(u32*)code_ptr = Syscall::SC_restore_signal_mask;
|
||||
code_ptr += sizeof(u32);
|
||||
*code_ptr++ = 0xcd; // int 0x82
|
||||
// NOTE: Stack alignment padding doesn't matter when returning to ring0.
|
||||
// Nothing matters really, as we're returning by replacing the entire TSS.
|
||||
*code_ptr++ = 0x82;
|
||||
*code_ptr++ = 0xb8; // mov eax, <dword>
|
||||
*(dword*)code_ptr = Syscall::SC_sigreturn;
|
||||
code_ptr += sizeof(dword);
|
||||
*code_ptr++ = 0xb8; // mov eax, <u32>
|
||||
*(u32*)code_ptr = Syscall::SC_sigreturn;
|
||||
code_ptr += sizeof(u32);
|
||||
*code_ptr++ = 0xcd; // int 0x82
|
||||
*code_ptr++ = 0x82;
|
||||
*code_ptr++ = 0x0f; // ud2
|
||||
*code_ptr++ = 0x0b;
|
||||
}
|
||||
|
||||
int Process::sys$restore_signal_mask(dword mask)
|
||||
int Process::sys$restore_signal_mask(u32 mask)
|
||||
{
|
||||
current->m_signal_mask = mask;
|
||||
return 0;
|
||||
|
@ -740,7 +740,7 @@ void Process::sys$sigreturn()
|
|||
ASSERT_NOT_REACHED();
|
||||
}
|
||||
|
||||
void Process::crash(int signal, dword eip)
|
||||
void Process::crash(int signal, u32 eip)
|
||||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
ASSERT(!is_dead());
|
||||
|
@ -793,7 +793,7 @@ ssize_t Process::sys$get_dir_entries(int fd, void* buffer, ssize_t size)
|
|||
auto* description = file_description(fd);
|
||||
if (!description)
|
||||
return -EBADF;
|
||||
return description->get_dir_entries((byte*)buffer, size);
|
||||
return description->get_dir_entries((u8*)buffer, size);
|
||||
}
|
||||
|
||||
int Process::sys$lseek(int fd, off_t offset, int whence)
|
||||
|
@ -857,7 +857,7 @@ ssize_t Process::sys$writev(int fd, const struct iovec* iov, int iov_count)
|
|||
|
||||
int nwritten = 0;
|
||||
for (int i = 0; i < iov_count; ++i) {
|
||||
int rc = do_write(*description, (const byte*)iov[i].iov_base, iov[i].iov_len);
|
||||
int rc = do_write(*description, (const u8*)iov[i].iov_base, iov[i].iov_len);
|
||||
if (rc < 0) {
|
||||
if (nwritten == 0)
|
||||
return rc;
|
||||
|
@ -875,7 +875,7 @@ ssize_t Process::sys$writev(int fd, const struct iovec* iov, int iov_count)
|
|||
return nwritten;
|
||||
}
|
||||
|
||||
ssize_t Process::do_write(FileDescription& description, const byte* data, int data_size)
|
||||
ssize_t Process::do_write(FileDescription& description, const u8* data, int data_size)
|
||||
{
|
||||
ssize_t nwritten = 0;
|
||||
if (!description.is_blocking()) {
|
||||
|
@ -921,7 +921,7 @@ ssize_t Process::do_write(FileDescription& description, const byte* data, int da
|
|||
return nwritten;
|
||||
}
|
||||
|
||||
ssize_t Process::sys$write(int fd, const byte* data, ssize_t size)
|
||||
ssize_t Process::sys$write(int fd, const u8* data, ssize_t size)
|
||||
{
|
||||
if (size < 0)
|
||||
return -EINVAL;
|
||||
|
@ -944,7 +944,7 @@ ssize_t Process::sys$write(int fd, const byte* data, ssize_t size)
|
|||
return nwritten;
|
||||
}
|
||||
|
||||
ssize_t Process::sys$read(int fd, byte* buffer, ssize_t size)
|
||||
ssize_t Process::sys$read(int fd, u8* buffer, ssize_t size)
|
||||
{
|
||||
if (size < 0)
|
||||
return -EINVAL;
|
||||
|
@ -1005,7 +1005,7 @@ int Process::sys$access(const char* pathname, int mode)
|
|||
return VFS::the().access(StringView(pathname), mode, current_directory());
|
||||
}
|
||||
|
||||
int Process::sys$fcntl(int fd, int cmd, dword arg)
|
||||
int Process::sys$fcntl(int fd, int cmd, u32 arg)
|
||||
{
|
||||
(void)cmd;
|
||||
(void)arg;
|
||||
|
@ -1144,7 +1144,7 @@ int Process::sys$open(const char* path, int options, mode_t mode)
|
|||
if (options & O_DIRECTORY && !description->is_directory())
|
||||
return -ENOTDIR; // FIXME: This should be handled by VFS::open.
|
||||
description->set_file_flags(options);
|
||||
dword fd_flags = (options & O_CLOEXEC) ? FD_CLOEXEC : 0;
|
||||
u32 fd_flags = (options & O_CLOEXEC) ? FD_CLOEXEC : 0;
|
||||
m_fds[fd].set(move(description), fd_flags);
|
||||
return fd;
|
||||
}
|
||||
|
@ -1284,7 +1284,7 @@ int Process::sys$usleep(useconds_t usec)
|
|||
current->sleep(usec / 1000);
|
||||
if (current->m_wakeup_time > g_uptime) {
|
||||
ASSERT(current->m_was_interrupted_while_blocked);
|
||||
dword ticks_left_until_original_wakeup_time = current->m_wakeup_time - g_uptime;
|
||||
u32 ticks_left_until_original_wakeup_time = current->m_wakeup_time - g_uptime;
|
||||
return ticks_left_until_original_wakeup_time / TICKS_PER_SECOND;
|
||||
}
|
||||
return 0;
|
||||
|
@ -1297,7 +1297,7 @@ int Process::sys$sleep(unsigned seconds)
|
|||
current->sleep(seconds * TICKS_PER_SECOND);
|
||||
if (current->m_wakeup_time > g_uptime) {
|
||||
ASSERT(current->m_was_interrupted_while_blocked);
|
||||
dword ticks_left_until_original_wakeup_time = current->m_wakeup_time - g_uptime;
|
||||
u32 ticks_left_until_original_wakeup_time = current->m_wakeup_time - g_uptime;
|
||||
return ticks_left_until_original_wakeup_time / TICKS_PER_SECOND;
|
||||
}
|
||||
return 0;
|
||||
|
@ -1495,7 +1495,7 @@ bool Process::validate_read_str(const char* str)
|
|||
bool Process::validate_read(const void* address, ssize_t size) const
|
||||
{
|
||||
ASSERT(size >= 0);
|
||||
VirtualAddress first_address((dword)address);
|
||||
VirtualAddress first_address((u32)address);
|
||||
VirtualAddress last_address = first_address.offset(size - 1);
|
||||
if (is_ring0()) {
|
||||
auto kmc_result = check_kernel_memory_access(first_address, false);
|
||||
|
@ -1519,7 +1519,7 @@ bool Process::validate_read(const void* address, ssize_t size) const
|
|||
bool Process::validate_write(void* address, ssize_t size) const
|
||||
{
|
||||
ASSERT(size >= 0);
|
||||
VirtualAddress first_address((dword)address);
|
||||
VirtualAddress first_address((u32)address);
|
||||
VirtualAddress last_address = first_address.offset(size - 1);
|
||||
if (is_ring0()) {
|
||||
if (is_kmalloc_address(address))
|
||||
|
@ -1699,7 +1699,7 @@ int Process::sys$sigaction(int signum, const sigaction* act, sigaction* old_act)
|
|||
old_act->sa_sigaction = (decltype(old_act->sa_sigaction))action.handler_or_sigaction.get();
|
||||
}
|
||||
action.flags = act->sa_flags;
|
||||
action.handler_or_sigaction = VirtualAddress((dword)act->sa_sigaction);
|
||||
action.handler_or_sigaction = VirtualAddress((u32)act->sa_sigaction);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -1923,7 +1923,7 @@ int Process::sys$rmdir(const char* pathname)
|
|||
return VFS::the().rmdir(StringView(pathname), current_directory());
|
||||
}
|
||||
|
||||
int Process::sys$read_tsc(dword* lsw, dword* msw)
|
||||
int Process::sys$read_tsc(u32* lsw, u32* msw)
|
||||
{
|
||||
if (!validate_write_typed(lsw))
|
||||
return -EFAULT;
|
||||
|
@ -2587,7 +2587,7 @@ const char* to_string(Process::Priority priority)
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
void Process::terminate_due_to_signal(byte signal)
|
||||
void Process::terminate_due_to_signal(u8 signal)
|
||||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
ASSERT(signal < 32);
|
||||
|
@ -2597,7 +2597,7 @@ void Process::terminate_due_to_signal(byte signal)
|
|||
die();
|
||||
}
|
||||
|
||||
void Process::send_signal(byte signal, Process* sender)
|
||||
void Process::send_signal(u8 signal, Process* sender)
|
||||
{
|
||||
// FIXME(Thread): Find the appropriate thread to deliver the signal to.
|
||||
main_thread().send_signal(signal, sender);
|
||||
|
@ -2619,7 +2619,7 @@ int Process::sys$create_thread(int (*entry)(void*), void* argument)
|
|||
return -EFAULT;
|
||||
auto* thread = new Thread(*this);
|
||||
auto& tss = thread->tss();
|
||||
tss.eip = (dword)entry;
|
||||
tss.eip = (u32)entry;
|
||||
tss.eflags = 0x0202;
|
||||
tss.cr3 = page_directory().cr3();
|
||||
thread->make_userspace_stack_for_secondary_thread(argument);
|
||||
|
@ -2734,7 +2734,7 @@ void Process::FileDescriptionAndFlags::clear()
|
|||
flags = 0;
|
||||
}
|
||||
|
||||
void Process::FileDescriptionAndFlags::set(NonnullRefPtr<FileDescription>&& d, dword f)
|
||||
void Process::FileDescriptionAndFlags::set(NonnullRefPtr<FileDescription>&& d, u32 f)
|
||||
{
|
||||
description = move(d);
|
||||
flags = f;
|
||||
|
|
|
@ -120,8 +120,8 @@ public:
|
|||
mode_t sys$umask(mode_t);
|
||||
int sys$open(const char* path, int options, mode_t mode = 0);
|
||||
int sys$close(int fd);
|
||||
ssize_t sys$read(int fd, byte*, ssize_t);
|
||||
ssize_t sys$write(int fd, const byte*, ssize_t);
|
||||
ssize_t sys$read(int fd, u8*, ssize_t);
|
||||
ssize_t sys$write(int fd, const u8*, ssize_t);
|
||||
ssize_t sys$writev(int fd, const struct iovec* iov, int iov_count);
|
||||
int sys$fstat(int fd, stat*);
|
||||
int sys$lstat(const char*, stat*);
|
||||
|
@ -164,7 +164,7 @@ public:
|
|||
int sys$setuid(uid_t);
|
||||
unsigned sys$alarm(unsigned seconds);
|
||||
int sys$access(const char* pathname, int mode);
|
||||
int sys$fcntl(int fd, int cmd, dword extra_arg);
|
||||
int sys$fcntl(int fd, int cmd, u32 extra_arg);
|
||||
int sys$ioctl(int fd, unsigned request, unsigned arg);
|
||||
int sys$mkdir(const char* pathname, mode_t mode);
|
||||
clock_t sys$times(tms*);
|
||||
|
@ -173,7 +173,7 @@ public:
|
|||
int sys$unlink(const char* pathname);
|
||||
int sys$symlink(const char* target, const char* linkpath);
|
||||
int sys$rmdir(const char* pathname);
|
||||
int sys$read_tsc(dword* lsw, dword* msw);
|
||||
int sys$read_tsc(u32* lsw, u32* msw);
|
||||
int sys$chmod(const char* pathname, mode_t);
|
||||
int sys$fchmod(int fd, mode_t);
|
||||
int sys$chown(const char* pathname, uid_t, gid_t);
|
||||
|
@ -191,7 +191,7 @@ public:
|
|||
int sys$getpeername(int sockfd, sockaddr* addr, socklen_t* addrlen);
|
||||
int sys$sched_setparam(pid_t pid, const struct sched_param* param);
|
||||
int sys$sched_getparam(pid_t pid, struct sched_param* param);
|
||||
int sys$restore_signal_mask(dword mask);
|
||||
int sys$restore_signal_mask(u32 mask);
|
||||
int sys$create_thread(int (*)(void*), void*);
|
||||
void sys$exit_thread(int code);
|
||||
int sys$rename(const char* oldpath, const char* newpath);
|
||||
|
@ -205,7 +205,7 @@ public:
|
|||
|
||||
static void initialize();
|
||||
|
||||
[[noreturn]] void crash(int signal, dword eip);
|
||||
[[noreturn]] void crash(int signal, u32 eip);
|
||||
[[nodiscard]] static int reap(Process&);
|
||||
|
||||
const TTY* tty() const { return m_tty; }
|
||||
|
@ -218,11 +218,11 @@ public:
|
|||
ProcessTracer* tracer() { return m_tracer.ptr(); }
|
||||
ProcessTracer& ensure_tracer();
|
||||
|
||||
dword m_ticks_in_user { 0 };
|
||||
dword m_ticks_in_kernel { 0 };
|
||||
u32 m_ticks_in_user { 0 };
|
||||
u32 m_ticks_in_kernel { 0 };
|
||||
|
||||
dword m_ticks_in_user_for_dead_children { 0 };
|
||||
dword m_ticks_in_kernel_for_dead_children { 0 };
|
||||
u32 m_ticks_in_user_for_dead_children { 0 };
|
||||
u32 m_ticks_in_kernel_for_dead_children { 0 };
|
||||
|
||||
bool validate_read_from_kernel(VirtualAddress) const;
|
||||
|
||||
|
@ -257,8 +257,8 @@ public:
|
|||
void set_being_inspected(bool b) { m_being_inspected = b; }
|
||||
bool is_being_inspected() const { return m_being_inspected; }
|
||||
|
||||
void terminate_due_to_signal(byte signal);
|
||||
void send_signal(byte, Process* sender);
|
||||
void terminate_due_to_signal(u8 signal);
|
||||
void send_signal(u8, Process* sender);
|
||||
|
||||
int thread_count() const;
|
||||
|
||||
|
@ -279,7 +279,7 @@ private:
|
|||
Range allocate_range(VirtualAddress, size_t);
|
||||
|
||||
int do_exec(String path, Vector<String> arguments, Vector<String> environment);
|
||||
ssize_t do_write(FileDescription&, const byte*, int data_size);
|
||||
ssize_t do_write(FileDescription&, const u8*, int data_size);
|
||||
|
||||
int alloc_fd(int first_candidate_fd = 0);
|
||||
void disown_all_shared_buffers();
|
||||
|
@ -308,17 +308,17 @@ private:
|
|||
struct FileDescriptionAndFlags {
|
||||
operator bool() const { return !!description; }
|
||||
void clear();
|
||||
void set(NonnullRefPtr<FileDescription>&& d, dword f = 0);
|
||||
void set(NonnullRefPtr<FileDescription>&& d, u32 f = 0);
|
||||
RefPtr<FileDescription> description;
|
||||
dword flags { 0 };
|
||||
u32 flags { 0 };
|
||||
};
|
||||
Vector<FileDescriptionAndFlags> m_fds;
|
||||
RingLevel m_ring { Ring0 };
|
||||
|
||||
static const int m_max_open_file_descriptors { FD_SETSIZE };
|
||||
|
||||
byte m_termination_status { 0 };
|
||||
byte m_termination_signal { 0 };
|
||||
u8 m_termination_status { 0 };
|
||||
u8 m_termination_signal { 0 };
|
||||
|
||||
RefPtr<Custody> m_executable;
|
||||
RefPtr<Custody> m_cwd;
|
||||
|
@ -351,7 +351,7 @@ private:
|
|||
|
||||
Lock m_big_lock { "Process" };
|
||||
|
||||
qword m_alarm_deadline { 0 };
|
||||
u64 m_alarm_deadline { 0 };
|
||||
};
|
||||
|
||||
class ProcessInspectionHandle {
|
||||
|
|
|
@ -10,13 +10,13 @@ ProcessTracer::~ProcessTracer()
|
|||
{
|
||||
}
|
||||
|
||||
void ProcessTracer::did_syscall(dword function, dword arg1, dword arg2, dword arg3, dword result)
|
||||
void ProcessTracer::did_syscall(u32 function, u32 arg1, u32 arg2, u32 arg3, u32 result)
|
||||
{
|
||||
CallData data = { function, arg1, arg2, arg3, result };
|
||||
m_calls.enqueue(data);
|
||||
}
|
||||
|
||||
int ProcessTracer::read(FileDescription&, byte* buffer, int buffer_size)
|
||||
int ProcessTracer::read(FileDescription&, u8* buffer, int buffer_size)
|
||||
{
|
||||
if (m_calls.is_empty())
|
||||
return 0;
|
||||
|
|
|
@ -13,14 +13,14 @@ public:
|
|||
void set_dead() { m_dead = true; }
|
||||
|
||||
virtual bool can_read(FileDescription&) const override { return !m_calls.is_empty() || m_dead; }
|
||||
virtual int read(FileDescription&, byte*, int) override;
|
||||
virtual int read(FileDescription&, u8*, int) override;
|
||||
|
||||
virtual bool can_write(FileDescription&) const override { return true; }
|
||||
virtual int write(FileDescription&, const byte*, int) override { return -EIO; }
|
||||
virtual int write(FileDescription&, const u8*, int) override { return -EIO; }
|
||||
|
||||
virtual String absolute_path(const FileDescription&) const override;
|
||||
|
||||
void did_syscall(dword function, dword arg1, dword arg2, dword arg3, dword result);
|
||||
void did_syscall(u32 function, u32 arg1, u32 arg2, u32 arg3, u32 result);
|
||||
pid_t pid() const { return m_pid; }
|
||||
|
||||
private:
|
||||
|
@ -28,11 +28,11 @@ private:
|
|||
explicit ProcessTracer(pid_t);
|
||||
|
||||
struct CallData {
|
||||
dword function;
|
||||
dword arg1;
|
||||
dword arg2;
|
||||
dword arg3;
|
||||
dword result;
|
||||
u32 function;
|
||||
u32 arg1;
|
||||
u32 arg2;
|
||||
u32 arg3;
|
||||
u32 result;
|
||||
};
|
||||
|
||||
pid_t m_pid;
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue