RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 05:37:35 +00:00
Code Issues Activity Actions

Kernel: Tighten some typing in Arch/i386/CPU.h

Browse source 
Use more appropriate types for some things.
This commit is contained in:
Andreas Kling 2021-02-25 10:29:41 +01:00
parent 8706ccfadd
commit 53c6c29158
3 changed files with 49 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

27
Kernel/Arch/i386/CPU.cpp
View file

@ -37,8 +37,6 @@
#include <Kernel/IO.h> #include <Kernel/IO.h>
#include <Kernel/Interrupts/APIC.h> #include <Kernel/Interrupts/APIC.h>
#include <Kernel/Interrupts/GenericInterruptHandler.h> #include <Kernel/Interrupts/GenericInterruptHandler.h>
#include <Kernel/Interrupts/IRQHandler.h>
#include <Kernel/Interrupts/InterruptManagement.h>
#include <Kernel/Interrupts/SharedIRQHandler.h> #include <Kernel/Interrupts/SharedIRQHandler.h>
#include <Kernel/Interrupts/SpuriousInterruptHandler.h> #include <Kernel/Interrupts/SpuriousInterruptHandler.h>
#include <Kernel/Interrupts/UnhandledInterruptHandler.h> #include <Kernel/Interrupts/UnhandledInterruptHandler.h>
@ -46,7 +44,6 @@
#include <Kernel/Panic.h> #include <Kernel/Panic.h>
#include <Kernel/Process.h> #include <Kernel/Process.h>
#include <Kernel/Random.h> #include <Kernel/Random.h>
#include <Kernel/SpinLock.h>
#include <Kernel/Thread.h> #include <Kernel/Thread.h>
#include <Kernel/VM/MemoryManager.h> #include <Kernel/VM/MemoryManager.h>
#include <Kernel/VM/PageDirectory.h> #include <Kernel/VM/PageDirectory.h>
@ -454,16 +451,16 @@ void unregister_generic_interrupt_handler(u8 interrupt_number, GenericInterruptH
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
UNMAP_AFTER_INIT void register_interrupt_handler(u8 index, void (*f)()) UNMAP_AFTER_INIT void register_interrupt_handler(u8 index, void (*handler)())
{ {
s_idt[index].low = 0x00080000 | LSW((f)); s_idt[index].low = 0x00080000 | LSW((FlatPtr)(handler));
s_idt[index].high = ((u32)(f)&0xffff0000) | 0x8e00; s_idt[index].high = ((FlatPtr)(handler)&0xffff0000) | 0x8e00;
} }
UNMAP_AFTER_INIT void register_user_callable_interrupt_handler(u8 index, void (*f)()) UNMAP_AFTER_INIT void register_user_callable_interrupt_handler(u8 index, void (*handler)())
{ {
s_idt[index].low = 0x00080000 | LSW((f)); s_idt[index].low = 0x00080000 | LSW(((FlatPtr)handler));
s_idt[index].high = ((u32)(f)&0xffff0000) | 0xef00; s_idt[index].high = ((FlatPtr)(handler)&0xffff0000) | 0xef00;
} }
UNMAP_AFTER_INIT void flush_idt() UNMAP_AFTER_INIT void flush_idt()
@ -1268,7 +1265,7 @@ extern "C" void enter_thread_context(Thread* from_thread, Thread* to_thread)
auto& processor = Processor::current(); auto& processor = Processor::current();
auto& tls_descriptor = processor.get_gdt_entry(GDT_SELECTOR_TLS); auto& tls_descriptor = processor.get_gdt_entry(GDT_SELECTOR_TLS);
tls_descriptor.set_base(to_thread->thread_specific_data().as_ptr()); tls_descriptor.set_base(to_thread->thread_specific_data());
tls_descriptor.set_limit(to_thread->thread_specific_region_size()); tls_descriptor.set_limit(to_thread->thread_specific_region_size());
if (from_tss.cr3 != to_tss.cr3) if (from_tss.cr3 != to_tss.cr3)
@ -2184,7 +2181,7 @@ UNMAP_AFTER_INIT void Processor::gdt_init()
write_raw_gdt_entry(GDT_SELECTOR_CODE3, 0x0000ffff, 0x00cffa00); // code3 write_raw_gdt_entry(GDT_SELECTOR_CODE3, 0x0000ffff, 0x00cffa00); // code3
write_raw_gdt_entry(GDT_SELECTOR_DATA3, 0x0000ffff, 0x00cff200); // data3 write_raw_gdt_entry(GDT_SELECTOR_DATA3, 0x0000ffff, 0x00cff200); // data3
Descriptor tls_descriptor; Descriptor tls_descriptor {};
tls_descriptor.low = tls_descriptor.high = 0; tls_descriptor.low = tls_descriptor.high = 0;
tls_descriptor.dpl = 3; tls_descriptor.dpl = 3;
tls_descriptor.segment_present = 1; tls_descriptor.segment_present = 1;
@ -2195,8 +2192,8 @@ UNMAP_AFTER_INIT void Processor::gdt_init()
tls_descriptor.type = 2; tls_descriptor.type = 2;
write_gdt_entry(GDT_SELECTOR_TLS, tls_descriptor); // tls3 write_gdt_entry(GDT_SELECTOR_TLS, tls_descriptor); // tls3
Descriptor fs_descriptor; Descriptor fs_descriptor {};
fs_descriptor.set_base(this); fs_descriptor.set_base(VirtualAddress { this });
fs_descriptor.set_limit(sizeof(Processor)); fs_descriptor.set_limit(sizeof(Processor));
fs_descriptor.dpl = 0; fs_descriptor.dpl = 0;
fs_descriptor.segment_present = 1; fs_descriptor.segment_present = 1;
@ -2207,8 +2204,8 @@ UNMAP_AFTER_INIT void Processor::gdt_init()
fs_descriptor.type = 2; fs_descriptor.type = 2;
write_gdt_entry(GDT_SELECTOR_PROC, fs_descriptor); // fs0 write_gdt_entry(GDT_SELECTOR_PROC, fs_descriptor); // fs0
Descriptor tss_descriptor; Descriptor tss_descriptor {};
tss_descriptor.set_base(&m_tss); tss_descriptor.set_base(VirtualAddress { &m_tss });
tss_descriptor.set_limit(sizeof(TSS32)); tss_descriptor.set_limit(sizeof(TSS32));
tss_descriptor.dpl = 0; tss_descriptor.dpl = 0;
tss_descriptor.segment_present = 1; tss_descriptor.segment_present = 1;

67
Kernel/Arch/i386/CPU.h
View file

@ -117,25 +117,25 @@ union [[gnu::packed]] Descriptor {
TrapGate_32bit = 0xf, TrapGate_32bit = 0xf,
}; };
void* get_base() const VirtualAddress base() const
{ {
u32 b = base_lo; FlatPtr base = base_lo;
b |= base_hi << 16; base |= base_hi << 16u;
b |= base_hi2 << 24; base |= base_hi2 << 24u;
return reinterpret_cast<void*>(b); return VirtualAddress { base };
} }
void set_base(void* b) void set_base(VirtualAddress base)
{ {
base_lo = (u32)(b)&0xffff; base_lo = base.get() & 0xffffu;
base_hi = ((u32)(b) >> 16) & 0xff; base_hi = (base.get() >> 16u) & 0xffu;
base_hi2 = ((u32)(b) >> 24) & 0xff; base_hi2 = (base.get() >> 24u) & 0xffu;
} }
void set_limit(u32 l) void set_limit(u32 length)
{ {
limit_lo = (u32)l & 0xffff; limit_lo = length & 0xffff;
limit_hi = ((u32)l >> 16) & 0xf; limit_hi = (length >> 16) & 0xf;
} }
}; };
@ -277,8 +277,8 @@ struct RegisterState;
const DescriptorTablePointer& get_gdtr(); const DescriptorTablePointer& get_gdtr();
const DescriptorTablePointer& get_idtr(); const DescriptorTablePointer& get_idtr();
void register_interrupt_handler(u8 number, void (*f)()); void register_interrupt_handler(u8 number, void (*handler)());
void register_user_callable_interrupt_handler(u8 number, void (*f)()); void register_user_callable_interrupt_handler(u8 number, void (*handler)());
GenericInterruptHandler& get_interrupt_handler(u8 interrupt_number); GenericInterruptHandler& get_interrupt_handler(u8 interrupt_number);
void register_generic_interrupt_handler(u8 number, GenericInterruptHandler&); void register_generic_interrupt_handler(u8 number, GenericInterruptHandler&);
void unregister_generic_interrupt_handler(u8 number, GenericInterruptHandler&); void unregister_generic_interrupt_handler(u8 number, GenericInterruptHandler&);
@ -306,31 +306,31 @@ inline u32 cpu_flags()
return flags; return flags;
} }
inline void set_fs(u32 segment) inline void set_fs(u16 segment)
{ {
asm volatile( asm volatile(
"movl %%eax, %%fs" ::"a"(segment) "mov %%ax, %%fs" ::"a"(segment)
: "memory"); : "memory");
} }
inline void set_gs(u32 segment) inline void set_gs(u16 segment)
{ {
asm volatile( asm volatile(
"movl %%eax, %%gs" ::"a"(segment) "mov %%ax, %%gs" ::"a"(segment)
: "memory"); : "memory");
} }
inline u32 get_fs() inline u16 get_fs()
{ {
u32 fs; u16 fs;
asm("mov %%fs, %%eax" asm("mov %%fs, %%eax"
: "=a"(fs)); : "=a"(fs));
return fs; return fs;
} }
inline u32 get_gs() inline u16 get_gs()
{ {
u32 gs; u16 gs;
asm("mov %%gs, %%eax" asm("mov %%gs, %%eax"
: "=a"(gs)); : "=a"(gs));
return gs; return gs;
@ -346,6 +346,11 @@ inline u32 read_fs_u32(u32 offset)
return val; return val;
} }
inline FlatPtr read_fs_ptr(u32 offset)
{
return read_fs_u32(offset);
}
inline void write_fs_u32(u32 offset, u32 val) inline void write_fs_u32(u32 offset, u32 val)
{ {
asm volatile( asm volatile(
@ -502,18 +507,18 @@ u32 read_dr6();
static inline bool is_kernel_mode() static inline bool is_kernel_mode()
{ {
u32 cs; u16 cs;
asm volatile( asm volatile(
"movl %%cs, %[cs] \n" "mov %%cs, %[cs] \n"
: [cs] "=g"(cs)); : [cs] "=g"(cs));
return (cs & 3) == 0; return (cs & 3) == 0;
} }
class CPUID { class CPUID {
public: public:
CPUID(u32 function) { asm volatile("cpuid" explicit CPUID(u32 function) { asm volatile("cpuid"
: "=a"(m_eax), "=b"(m_ebx), "=c"(m_ecx), "=d"(m_edx) : "=a"(m_eax), "=b"(m_ebx), "=c"(m_ecx), "=d"(m_edx)
: "a"(function), "c"(0)); } : "a"(function), "c"(0)); }
u32 eax() const { return m_eax; } u32 eax() const { return m_eax; }
u32 ebx() const { return m_ebx; } u32 ebx() const { return m_ebx; }
u32 ecx() const { return m_ecx; } u32 ecx() const { return m_ecx; }
@ -768,7 +773,7 @@ public:
ALWAYS_INLINE static Processor& current() ALWAYS_INLINE static Processor& current()
{ {
return *(Processor*)read_fs_u32(__builtin_offsetof(Processor, m_self)); return *(Processor*)read_fs_ptr(__builtin_offsetof(Processor, m_self));
} }
ALWAYS_INLINE static bool is_initialized() ALWAYS_INLINE static bool is_initialized()
@ -814,7 +819,7 @@ public:
// to another processor, which would lead us to get the wrong thread. // to another processor, which would lead us to get the wrong thread.
// To avoid having to disable interrupts, we can just read the field // To avoid having to disable interrupts, we can just read the field
// directly in an atomic fashion, similar to Processor::current. // directly in an atomic fashion, similar to Processor::current.
return (Thread*)read_fs_u32(__builtin_offsetof(Processor, m_current_thread)); return (Thread*)read_fs_ptr(__builtin_offsetof(Processor, m_current_thread));
} }
ALWAYS_INLINE static void set_current_thread(Thread& current_thread) ALWAYS_INLINE static void set_current_thread(Thread& current_thread)
@ -836,7 +841,7 @@ public:
ALWAYS_INLINE static u32 id() ALWAYS_INLINE static u32 id()
{ {
// See comment in Processor::current_thread // See comment in Processor::current_thread
return read_fs_u32(__builtin_offsetof(Processor, m_cpu)); return read_fs_ptr(__builtin_offsetof(Processor, m_cpu));
} }
ALWAYS_INLINE u32 raise_irq() ALWAYS_INLINE u32 raise_irq()
@ -1066,7 +1071,7 @@ struct TrapFrame {
TrapFrame& operator=(TrapFrame&&) = delete; TrapFrame& operator=(TrapFrame&&) = delete;
}; };
#define TRAP_FRAME_SIZE (3 * 4) #define TRAP_FRAME_SIZE (3 * sizeof(FlatPtr))
static_assert(TRAP_FRAME_SIZE == sizeof(TrapFrame)); static_assert(TRAP_FRAME_SIZE == sizeof(TrapFrame));
extern "C" void enter_trap_no_irq(TrapFrame*); extern "C" void enter_trap_no_irq(TrapFrame*);

2
Kernel/Syscalls/mmap.cpp
View file

@ -576,7 +576,7 @@ void* Process::sys$allocate_tls(size_t size)
return (void*)-EFAULT; return (void*)-EFAULT;
auto& tls_descriptor = Processor::current().get_gdt_entry(GDT_SELECTOR_TLS); auto& tls_descriptor = Processor::current().get_gdt_entry(GDT_SELECTOR_TLS);
tls_descriptor.set_base(main_thread->thread_specific_data().as_ptr()); tls_descriptor.set_base(main_thread->thread_specific_data());
tls_descriptor.set_limit(main_thread->thread_specific_region_size()); tls_descriptor.set_limit(main_thread->thread_specific_region_size());
return m_master_tls_region.unsafe_ptr()->vaddr().as_ptr(); return m_master_tls_region.unsafe_ptr()->vaddr().as_ptr();