Bananymous
/
banan-os
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Kernel: Rename rsp->sp and rip->ip 

This makes more sense if we support i386
This commit is contained in:
Bananymous 2024-03-22 14:48:33 +02:00
parent 3e4d410646
commit fe17958b9f
13 changed files with 108 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/arch/i386/Syscall.S
View File

@ -3,7 +3,7 @@ sys_fork_trampoline:
subl $4, %esp subl $4, %esp
pushl %ebx pushl %ebx
pushl %ebp pushl %ebp
call read_rip call read_ip
testl %eax, %eax testl %eax, %eax
je .done je .done
subl $8, %esp subl $8, %esp

12
kernel/arch/i386/Thread.S
View File

@ -1,6 +1,6 @@
# uint32_t read_rip() # uint32_t read_ip()
.global read_rip .global read_ip
read_rip: read_ip:
popl %eax popl %eax
jmp *%eax jmp *%eax
@ -9,7 +9,7 @@ exit_thread_trampoline:
pushl (%esp) pushl (%esp)
ret ret
# void start_thread(uint32_t esp, uint32_t eip) # void start_thread(uint32_t sp, uint32_t ip)
.global start_thread .global start_thread
start_thread: start_thread:
movl 8(%esp), %ecx movl 8(%esp), %ecx
@ -19,7 +19,7 @@ start_thread:
sti sti
jmp *%ecx jmp *%ecx
# void continue_thread(uint32_t rsp, uint32_t rip) # void continue_thread(uint32_t sp, uint32_t ip)
.global continue_thread .global continue_thread
continue_thread: continue_thread:
movl 8(%esp), %ecx movl 8(%esp), %ecx
@ -27,7 +27,7 @@ continue_thread:
movl $0, %eax movl $0, %eax
jmp *%ecx jmp *%ecx
# void thread_jump_userspace(uint32_t rsp, uint32_t rip) # void thread_jump_userspace(uint32_t sp, uint32_t ip)
.global thread_jump_userspace .global thread_jump_userspace
thread_jump_userspace: thread_jump_userspace:
movl $0x23, %eax movl $0x23, %eax

20
kernel/arch/x86_64/IDT.cpp
View File

@ -161,24 +161,24 @@ namespace Kernel
if (tid) if (tid)
{ {
Thread::current().set_return_rsp(interrupt_stack.rsp); Thread::current().set_return_sp(interrupt_stack.sp);
Thread::current().set_return_rip(interrupt_stack.rip); Thread::current().set_return_ip(interrupt_stack.ip);
if (isr == ISR::PageFault) if (isr == ISR::PageFault)
{ {
// Check if stack is OOB // Check if stack is OOB
auto& stack = Thread::current().stack(); auto& stack = Thread::current().stack();
auto& istack = Thread::current().interrupt_stack(); auto& istack = Thread::current().interrupt_stack();
if (stack.vaddr() < interrupt_stack.rsp && interrupt_stack.rsp <= stack.vaddr() + stack.size()) if (stack.vaddr() < interrupt_stack.sp && interrupt_stack.sp <= stack.vaddr() + stack.size())
; // using normal stack ; // using normal stack
else if (istack.vaddr() < interrupt_stack.rsp && interrupt_stack.rsp <= istack.vaddr() + istack.size()) else if (istack.vaddr() < interrupt_stack.sp && interrupt_stack.sp <= istack.vaddr() + istack.size())
; // using interrupt stack ; // using interrupt stack
else else
{ {
derrorln("Stack pointer out of bounds!"); derrorln("Stack pointer out of bounds!");
derrorln("rip {H}", interrupt_stack.rip); derrorln("rip {H}", interrupt_stack.ip);
derrorln("rsp {H}, stack {H}->{H}, istack {H}->{H}", derrorln("rsp {H}, stack {H}->{H}, istack {H}->{H}",
interrupt_stack.rsp, interrupt_stack.sp,
stack.vaddr(), stack.vaddr() + stack.size(), stack.vaddr(), stack.vaddr() + stack.size(),
istack.vaddr(), istack.vaddr() + istack.size() istack.vaddr(), istack.vaddr() + istack.size()
); );
@ -225,9 +225,9 @@ namespace Kernel
#endif #endif
} }
if (PageTable::current().get_page_flags(interrupt_stack.rip & PAGE_ADDR_MASK) & PageTable::Flags::Present) if (PageTable::current().get_page_flags(interrupt_stack.ip & PAGE_ADDR_MASK) & PageTable::Flags::Present)
{ {
auto* machine_code = (const uint8_t*)interrupt_stack.rip; auto* machine_code = (const uint8_t*)interrupt_stack.ip;
dwarnln("While executing: {2H}{2H}{2H}{2H}{2H}{2H}{2H}{2H}", dwarnln("While executing: {2H}{2H}{2H}{2H}{2H}{2H}{2H}{2H}",
machine_code[0], machine_code[0],
machine_code[1], machine_code[1],
@ -308,8 +308,8 @@ done:
if (Scheduler::current_tid()) if (Scheduler::current_tid())
{ {
Thread::current().set_return_rsp(interrupt_stack.rsp); Thread::current().set_return_sp(interrupt_stack.sp);
Thread::current().set_return_rip(interrupt_stack.rip); Thread::current().set_return_ip(interrupt_stack.ip);
} }
if (!InterruptController::get().is_in_service(irq)) if (!InterruptController::get().is_in_service(irq))

2
kernel/arch/x86_64/Syscall.S
View File

@ -6,7 +6,7 @@ sys_fork_trampoline:
pushq %r13 pushq %r13
pushq %r14 pushq %r14
pushq %r15 pushq %r15
call read_rip call read_ip
testq %rax, %rax testq %rax, %rax
je .done je .done
movq %rax, %rsi movq %rax, %rsi

12
kernel/arch/x86_64/Thread.S
View File

@ -1,6 +1,6 @@
# uint64_t read_rip() # uint64_t read_()
.global read_rip .global read_ip
read_rip: read_ip:
popq %rax popq %rax
jmp *%rax jmp *%rax
@ -8,7 +8,7 @@ exit_thread_trampoline:
movq 8(%rsp), %rdi movq 8(%rsp), %rdi
ret ret
# void start_thread(uint64_t rsp, uint64_t rip) # void start_thread(uint64_t sp, uint64_t ip)
.global start_thread .global start_thread
start_thread: start_thread:
movq %rdi, %rsp movq %rdi, %rsp
@ -18,14 +18,14 @@ start_thread:
sti sti
jmp *%rsi jmp *%rsi
# void continue_thread(uint64_t rsp, uint64_t rip) # void continue_thread(uint64_t sp, uint64_t ip)
.global continue_thread .global continue_thread
continue_thread: continue_thread:
movq %rdi, %rsp movq %rdi, %rsp
movq $0, %rax movq $0, %rax
jmp *%rsi jmp *%rsi
# void thread_userspace_trampoline(uint64_t rsp, uint64_t rip, int argc, char** argv, char** envp) # void thread_userspace_trampoline(uint64_t sp, uint64_t ip, int argc, char** argv, char** envp)
.global thread_userspace_trampoline .global thread_userspace_trampoline
thread_userspace_trampoline: thread_userspace_trampoline:
pushq $0x23 pushq $0x23

6
kernel/include/kernel/Arch.h
View File

@ -21,8 +21,4 @@
#include <stdint.h> #include <stdint.h>
#ifdef __cplusplus extern "C" uintptr_t read_ip();
extern "C" uintptr_t read_rip();
#else
extern uintptr_t read_rip();
#endif

10
kernel/include/kernel/InterruptStack.h
View File

@ -7,11 +7,11 @@ namespace Kernel
struct InterruptStack struct InterruptStack
{ {
uint64_t rip; uintptr_t ip;
uint64_t cs; uintptr_t cs;
uint64_t flags; uintptr_t flags;
uint64_t rsp; uintptr_t sp;
uint64_t ss; uintptr_t ss;
}; };
} }

26
kernel/include/kernel/Thread.h
View File

@ -33,7 +33,7 @@ namespace Kernel
static BAN::ErrorOr<Thread*> create_userspace(Process*); static BAN::ErrorOr<Thread*> create_userspace(Process*);
~Thread(); ~Thread();
BAN::ErrorOr<Thread*> clone(Process*, uintptr_t rsp, uintptr_t rip); BAN::ErrorOr<Thread*> clone(Process*, uintptr_t sp, uintptr_t ip);
void setup_exec(); void setup_exec();
void setup_process_cleanup(); void setup_process_cleanup();
@ -52,17 +52,17 @@ namespace Kernel
BAN::ErrorOr<void> block_or_eintr_or_timeout(Semaphore& semaphore, uint64_t timeout_ms, bool etimedout); BAN::ErrorOr<void> block_or_eintr_or_timeout(Semaphore& semaphore, uint64_t timeout_ms, bool etimedout);
BAN::ErrorOr<void> block_or_eintr_or_waketime(Semaphore& semaphore, uint64_t wake_time_ms, bool etimedout); BAN::ErrorOr<void> block_or_eintr_or_waketime(Semaphore& semaphore, uint64_t wake_time_ms, bool etimedout);
void set_return_rsp(uintptr_t& rsp) { m_return_rsp = &rsp; } void set_return_sp(uintptr_t& sp) { m_return_sp = &sp; }
void set_return_rip(uintptr_t& rip) { m_return_rip = &rip; } void set_return_ip(uintptr_t& ip) { m_return_ip = &ip; }
uintptr_t return_rsp() { ASSERT(m_return_rsp); return *m_return_rsp; } uintptr_t return_sp() { ASSERT(m_return_sp); return *m_return_sp; }
uintptr_t return_rip() { ASSERT(m_return_rip); return *m_return_rip; } uintptr_t return_ip() { ASSERT(m_return_ip); return *m_return_ip; }
pid_t tid() const { return m_tid; } pid_t tid() const { return m_tid; }
void set_rsp(uintptr_t rsp) { m_rsp = rsp; validate_stack(); } void set_sp(uintptr_t sp) { m_sp = sp; validate_stack(); }
void set_rip(uintptr_t rip) { m_rip = rip; } void set_ip(uintptr_t ip) { m_ip = ip; }
uintptr_t rsp() const { return m_rsp; } uintptr_t sp() const { return m_sp; }
uintptr_t rip() const { return m_rip; } uintptr_t ip() const { return m_ip; }
void set_started() { ASSERT(m_state == State::NotStarted); m_state = State::Executing; } void set_started() { ASSERT(m_state == State::NotStarted); m_state = State::Executing; }
State state() const { return m_state; } State state() const { return m_state; }
@ -104,15 +104,15 @@ namespace Kernel
static constexpr size_t m_interrupt_stack_size = PAGE_SIZE * 2; static constexpr size_t m_interrupt_stack_size = PAGE_SIZE * 2;
BAN::UniqPtr<VirtualRange> m_interrupt_stack; BAN::UniqPtr<VirtualRange> m_interrupt_stack;
BAN::UniqPtr<VirtualRange> m_stack; BAN::UniqPtr<VirtualRange> m_stack;
uintptr_t m_rip { 0 }; uintptr_t m_ip { 0 };
uintptr_t m_rsp { 0 }; uintptr_t m_sp { 0 };
const pid_t m_tid { 0 }; const pid_t m_tid { 0 };
State m_state { State::NotStarted }; State m_state { State::NotStarted };
Process* m_process { nullptr }; Process* m_process { nullptr };
bool m_is_userspace { false }; bool m_is_userspace { false };
uintptr_t* m_return_rsp { nullptr }; uintptr_t* m_return_sp { nullptr };
uintptr_t* m_return_rip { nullptr }; uintptr_t* m_return_ip { nullptr };
uint64_t m_signal_pending_mask { 0 }; uint64_t m_signal_pending_mask { 0 };
uint64_t m_signal_block_mask { 0 }; uint64_t m_signal_block_mask { 0 };

18
kernel/kernel/Debug.cpp
View File

@ -21,8 +21,8 @@ namespace Debug
struct stackframe struct stackframe
{ {
stackframe* rbp; stackframe* bp;
uintptr_t rip; uintptr_t ip;
}; };
SpinLockGuard _(s_debug_lock); SpinLockGuard _(s_debug_lock);
@ -33,8 +33,8 @@ namespace Debug
dprintln("Could not get frame address"); dprintln("Could not get frame address");
return; return;
} }
uintptr_t first_rip = frame->rip; uintptr_t first_ip = frame->ip;
uintptr_t last_rip = 0; uintptr_t last_ip = 0;
bool first = true; bool first = true;
BAN::Formatter::print(Debug::putchar, "\e[36mStack trace:\r\n"); BAN::Formatter::print(Debug::putchar, "\e[36mStack trace:\r\n");
@ -46,21 +46,21 @@ namespace Debug
break; break;
} }
BAN::Formatter::print(Debug::putchar, " {}\r\n", (void*)frame->rip); BAN::Formatter::print(Debug::putchar, " {}\r\n", (void*)frame->ip);
if (!first && frame->rip == first_rip) if (!first && frame->ip == first_ip)
{ {
derrorln("looping kernel panic :("); derrorln("looping kernel panic :(");
break; break;
} }
else if (!first && frame->rip == last_rip) else if (!first && frame->ip == last_ip)
{ {
derrorln("repeating stack trace"); derrorln("repeating stack trace");
break; break;
} }
last_rip = frame->rip; last_ip = frame->ip;
frame = frame->rbp; frame = frame->bp;
first = false; first = false;
} }
BAN::Formatter::print(Debug::putchar, "\e[m"); BAN::Formatter::print(Debug::putchar, "\e[m");

4
kernel/kernel/Process.cpp
View File

@ -390,7 +390,7 @@ namespace Kernel
return TRY(LibELF::LoadableELF::load_from_inode(page_table, file.inode)); return TRY(LibELF::LoadableELF::load_from_inode(page_table, file.inode));
} }
BAN::ErrorOr<long> Process::sys_fork(uintptr_t rsp, uintptr_t rip) BAN::ErrorOr<long> Process::sys_fork(uintptr_t sp, uintptr_t ip)
{ {
auto page_table = BAN::UniqPtr<PageTable>::adopt(TRY(PageTable::create_userspace())); auto page_table = BAN::UniqPtr<PageTable>::adopt(TRY(PageTable::create_userspace()));
@ -423,7 +423,7 @@ namespace Kernel
ASSERT(this == &Process::current()); ASSERT(this == &Process::current());
// FIXME: this should be able to fail // FIXME: this should be able to fail
Thread* thread = MUST(Thread::current().clone(forked, rsp, rip)); Thread* thread = MUST(Thread::current().clone(forked, sp, ip));
forked->add_thread(thread); forked->add_thread(thread);
forked->register_to_scheduler(); forked->register_to_scheduler();

18
kernel/kernel/Scheduler.cpp
View File

@ -11,8 +11,8 @@
namespace Kernel namespace Kernel
{ {
extern "C" [[noreturn]] void start_thread(uintptr_t rsp, uintptr_t rip); extern "C" [[noreturn]] void start_thread(uintptr_t sp, uintptr_t ip);
extern "C" [[noreturn]] void continue_thread(uintptr_t rsp, uintptr_t rip); extern "C" [[noreturn]] void continue_thread(uintptr_t sp, uintptr_t ip);
static Scheduler* s_instance = nullptr; static Scheduler* s_instance = nullptr;
static BAN::Atomic<bool> s_started { false }; static BAN::Atomic<bool> s_started { false };
@ -144,18 +144,18 @@ namespace Kernel
{ {
ASSERT(m_lock.current_processor_has_lock()); ASSERT(m_lock.current_processor_has_lock());
uintptr_t rsp, rip; uintptr_t sp, ip;
push_callee_saved(); push_callee_saved();
if (!(rip = read_rip())) if (!(ip = read_ip()))
{ {
pop_callee_saved(); pop_callee_saved();
return true; return true;
} }
read_rsp(rsp); read_rsp(sp);
Thread& current = current_thread(); Thread& current = current_thread();
current.set_rip(rip); current.set_ip(ip);
current.set_rsp(rsp); current.set_sp(sp);
load_temp_stack(); load_temp_stack();
@ -261,12 +261,12 @@ namespace Kernel
case Thread::State::NotStarted: case Thread::State::NotStarted:
current->set_started(); current->set_started();
m_lock.unlock(InterruptState::Disabled); m_lock.unlock(InterruptState::Disabled);
start_thread(current->rsp(), current->rip()); start_thread(current->sp(), current->ip());
case Thread::State::Executing: case Thread::State::Executing:
m_lock.unlock(InterruptState::Disabled); m_lock.unlock(InterruptState::Disabled);
while (current->can_add_signal_to_execute()) while (current->can_add_signal_to_execute())
current->handle_signal(); current->handle_signal();
continue_thread(current->rsp(), current->rip()); continue_thread(current->sp(), current->ip());
case Thread::State::Terminated: case Thread::State::Terminated:
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }

8
kernel/kernel/Syscall.cpp
View File

@ -10,9 +10,9 @@
namespace Kernel namespace Kernel
{ {
extern "C" long sys_fork(uintptr_t rsp, uintptr_t rip) extern "C" long sys_fork(uintptr_t sp, uintptr_t ip)
{ {
auto ret = Process::current().sys_fork(rsp, rip); auto ret = Process::current().sys_fork(sp, ip);
if (ret.is_error()) if (ret.is_error())
return -ret.error().get_error_code(); return -ret.error().get_error_code();
return ret.value(); return ret.value();
@ -32,8 +32,8 @@ namespace Kernel
{ {
ASSERT((interrupt_stack.cs & 0b11) == 0b11); ASSERT((interrupt_stack.cs & 0b11) == 0b11);
Thread::current().set_return_rsp(interrupt_stack.rsp); Thread::current().set_return_sp(interrupt_stack.sp);
Thread::current().set_return_rip(interrupt_stack.rip); Thread::current().set_return_ip(interrupt_stack.ip);
asm volatile("sti"); asm volatile("sti");

82
kernel/kernel/Thread.cpp
View File

@ -12,8 +12,8 @@
namespace Kernel namespace Kernel
{ {
extern "C" void thread_userspace_trampoline(uint64_t rsp, uint64_t rip, int argc, char** argv, char** envp); extern "C" void thread_userspace_trampoline(uint64_t sp, uint64_t ip, int argc, char** argv, char** envp);
extern "C" uintptr_t read_rip(); extern "C" uintptr_t read_ip();
extern "C" void signal_trampoline(); extern "C" void signal_trampoline();
@ -46,14 +46,14 @@ namespace Kernel
PageTable::Flags::ReadWrite | PageTable::Flags::Present, PageTable::Flags::ReadWrite | PageTable::Flags::Present,
true true
)); ));
thread->m_rsp = thread->stack_base() + thread->stack_size(); thread->m_sp = thread->stack_base() + thread->stack_size();
thread->m_rip = (uintptr_t)entry; thread->m_ip = (uintptr_t)entry;
// Initialize stack for returning // Initialize stack for returning
write_to_stack(thread->m_rsp, nullptr); // alignment write_to_stack(thread->m_sp, nullptr); // alignment
write_to_stack(thread->m_rsp, thread); write_to_stack(thread->m_sp, thread);
write_to_stack(thread->m_rsp, &Thread::on_exit); write_to_stack(thread->m_sp, &Thread::on_exit);
write_to_stack(thread->m_rsp, data); write_to_stack(thread->m_sp, data);
thread_deleter.disable(); thread_deleter.disable();
@ -144,7 +144,7 @@ namespace Kernel
{ {
} }
BAN::ErrorOr<Thread*> Thread::clone(Process* new_process, uintptr_t rsp, uintptr_t rip) BAN::ErrorOr<Thread*> Thread::clone(Process* new_process, uintptr_t sp, uintptr_t ip)
{ {
ASSERT(m_is_userspace); ASSERT(m_is_userspace);
ASSERT(m_state == State::Executing); ASSERT(m_state == State::Executing);
@ -161,8 +161,8 @@ namespace Kernel
thread->m_state = State::Executing; thread->m_state = State::Executing;
thread->m_rip = rip; thread->m_ip = ip;
thread->m_rsp = rsp; thread->m_sp = sp;
thread_deleter.disable(); thread_deleter.disable();
@ -177,24 +177,24 @@ namespace Kernel
[](void*) [](void*)
{ {
const auto& info = Process::current().userspace_info(); const auto& info = Process::current().userspace_info();
thread_userspace_trampoline(Thread::current().rsp(), info.entry, info.argc, info.argv, info.envp); thread_userspace_trampoline(Thread::current().sp(), info.entry, info.argc, info.argv, info.envp);
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
); );
m_rsp = stack_base() + stack_size(); m_sp = stack_base() + stack_size();
m_rip = (uintptr_t)entry_trampoline; m_ip = (uintptr_t)entry_trampoline;
// Signal mask is inherited // Signal mask is inherited
// Setup stack for returning // Setup stack for returning
ASSERT(m_rsp % PAGE_SIZE == 0); ASSERT(m_sp % PAGE_SIZE == 0);
PageTable::with_fast_page(process().page_table().physical_address_of(m_rsp - PAGE_SIZE), [&] { PageTable::with_fast_page(process().page_table().physical_address_of(m_sp - PAGE_SIZE), [&] {
uintptr_t rsp = PageTable::fast_page() + PAGE_SIZE; uintptr_t sp = PageTable::fast_page() + PAGE_SIZE;
write_to_stack(rsp, nullptr); // alignment write_to_stack(sp, nullptr); // alignment
write_to_stack(rsp, this); write_to_stack(sp, this);
write_to_stack(rsp, &Thread::on_exit); write_to_stack(sp, &Thread::on_exit);
write_to_stack(rsp, nullptr); write_to_stack(sp, nullptr);
m_rsp -= 4 * sizeof(uintptr_t); m_sp -= 4 * sizeof(uintptr_t);
}); });
} }
@ -210,20 +210,20 @@ namespace Kernel
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
); );
m_rsp = stack_base() + stack_size(); m_sp = stack_base() + stack_size();
m_rip = (uintptr_t)entry; m_ip = (uintptr_t)entry;
m_signal_pending_mask = 0; m_signal_pending_mask = 0;
m_signal_block_mask = ~0ull; m_signal_block_mask = ~0ull;
ASSERT(m_rsp % PAGE_SIZE == 0); ASSERT(m_sp % PAGE_SIZE == 0);
PageTable::with_fast_page(process().page_table().physical_address_of(m_rsp - PAGE_SIZE), [&] { PageTable::with_fast_page(process().page_table().physical_address_of(m_sp - PAGE_SIZE), [&] {
uintptr_t rsp = PageTable::fast_page() + PAGE_SIZE; uintptr_t sp = PageTable::fast_page() + PAGE_SIZE;
write_to_stack(rsp, nullptr); // alignment write_to_stack(sp, nullptr); // alignment
write_to_stack(rsp, this); write_to_stack(sp, this);
write_to_stack(rsp, &Thread::on_exit); write_to_stack(sp, &Thread::on_exit);
write_to_stack(rsp, m_process); write_to_stack(sp, m_process);
m_rsp -= 4 * sizeof(uintptr_t); m_sp -= 4 * sizeof(uintptr_t);
}); });
} }
@ -250,7 +250,7 @@ namespace Kernel
if (!is_userspace() || m_state != State::Executing) if (!is_userspace() || m_state != State::Executing)
return false; return false;
auto& interrupt_stack = *reinterpret_cast<InterruptStack*>(interrupt_stack_base() + interrupt_stack_size() - sizeof(InterruptStack)); auto& interrupt_stack = *reinterpret_cast<InterruptStack*>(interrupt_stack_base() + interrupt_stack_size() - sizeof(InterruptStack));
return interrupt_stack.rip == (uintptr_t)signal_trampoline; return interrupt_stack.ip == (uintptr_t)signal_trampoline;
} }
void Thread::handle_signal(int signal) void Thread::handle_signal(int signal)
@ -290,11 +290,11 @@ namespace Kernel
else if (signal_handler != (vaddr_t)SIG_DFL) else if (signal_handler != (vaddr_t)SIG_DFL)
{ {
// call userspace signal handlers // call userspace signal handlers
interrupt_stack.rsp -= 128; // skip possible red-zone interrupt_stack.sp -= 128; // skip possible red-zone
write_to_stack(interrupt_stack.rsp, interrupt_stack.rip); write_to_stack(interrupt_stack.sp, interrupt_stack.ip);
write_to_stack(interrupt_stack.rsp, signal); write_to_stack(interrupt_stack.sp, signal);
write_to_stack(interrupt_stack.rsp, signal_handler); write_to_stack(interrupt_stack.sp, signal_handler);
interrupt_stack.rip = (uintptr_t)signal_trampoline; interrupt_stack.ip = (uintptr_t)signal_trampoline;
} }
else else
{ {
@ -392,11 +392,11 @@ namespace Kernel
void Thread::validate_stack() const void Thread::validate_stack() const
{ {
if (stack_base() <= m_rsp && m_rsp <= stack_base() + stack_size()) if (stack_base() <= m_sp && m_sp <= stack_base() + stack_size())
return; return;
if (interrupt_stack_base() <= m_rsp && m_rsp <= interrupt_stack_base() + interrupt_stack_size()) if (interrupt_stack_base() <= m_sp && m_sp <= interrupt_stack_base() + interrupt_stack_size())
return; return;
Kernel::panic("rsp {8H}, stack {8H}->{8H}, interrupt_stack {8H}->{8H}", m_rsp, Kernel::panic("sp {8H}, stack {8H}->{8H}, interrupt_stack {8H}->{8H}", m_sp,
stack_base(), stack_base() + stack_size(), stack_base(), stack_base() + stack_size(),
interrupt_stack_base(), interrupt_stack_base() + interrupt_stack_size() interrupt_stack_base(), interrupt_stack_base() + interrupt_stack_size()
); );