1 /* 2 * Copyright 2003-2023, Haiku Inc. All rights reserved. 3 * Distributed under the terms of the MIT License. 4 * 5 * Authors: 6 * Axel Dörfler <axeld@pinc-software.de> 7 * Ingo Weinhold <bonefish@cs.tu-berlin.de> 8 * François Revol <revol@free.fr> 9 * 10 * Copyright 2001, Travis Geiselbrecht. All rights reserved. 11 * Distributed under the terms of the NewOS License. 12 */ 13 14 15 #include <thread.h> 16 #include <arch_thread.h> 17 18 #include <arch_cpu.h> 19 #include <arch/thread.h> 20 #include <boot/stage2.h> 21 #include <commpage.h> 22 #include <kernel.h> 23 #include <thread.h> 24 #include <vm/vm_types.h> 25 #include <vm/VMAddressSpace.h> 26 #include <arch_vm.h> 27 #include <arch/vm_translation_map.h> 28 29 #include <string.h> 30 31 #include "ARMPagingStructures.h" 32 #include "ARMVMTranslationMap.h" 33 34 //#define TRACE_ARCH_THREAD 35 #ifdef TRACE_ARCH_THREAD 36 # define TRACE(x...) dprintf(x) 37 #else 38 # define TRACE(x...) ; 39 #endif 40 41 // Valid initial arch_thread state. We just memcpy() it when initializing 42 // a new thread structure. 43 static struct arch_thread sInitialState; 44 45 46 void 47 arm_push_iframe(struct iframe_stack *stack, struct iframe *frame) 48 { 49 ASSERT(stack->index < IFRAME_TRACE_DEPTH); 50 stack->frames[stack->index++] = frame; 51 } 52 53 54 void 55 arm_pop_iframe(struct iframe_stack *stack) 56 { 57 ASSERT(stack->index > 0); 58 stack->index--; 59 } 60 61 62 63 status_t 64 arch_thread_init(struct kernel_args *args) 65 { 66 // Initialize the static initial arch_thread state (sInitialState). 67 // Currently nothing to do, i.e. zero initialized is just fine. 68 69 return B_OK; 70 } 71 72 73 status_t 74 arch_team_init_team_struct(Team *team, bool kernel) 75 { 76 // Nothing to do. The structure is empty. 77 return B_OK; 78 } 79 80 81 status_t 82 arch_thread_init_thread_struct(Thread *thread) 83 { 84 // set up an initial state (stack & fpu) 85 memcpy(&thread->arch_info, &sInitialState, sizeof(struct arch_thread)); 86 87 return B_OK; 88 } 89 90 91 void 92 arch_thread_init_kthread_stack(Thread* thread, void* _stack, void* _stackTop, 93 void (*function)(void*), const void* data) 94 { 95 addr_t* stackTop = (addr_t*)_stackTop; 96 97 TRACE("arch_thread_init_kthread_stack(%s): stack top %p, function %p, data: " 98 "%p\n", thread->name, stackTop, function, data); 99 100 // push the function address -- that's the return address used after the 101 // context switch (lr/r14 register) 102 *--stackTop = (addr_t)function; 103 104 // simulate storing registers r1-r12 105 for (int i = 1; i <= 12; i++) 106 *--stackTop = 0; 107 108 // push the function argument as r0 109 *--stackTop = (addr_t)data; 110 111 // save the stack position 112 thread->arch_info.sp = stackTop; 113 } 114 115 116 status_t 117 arch_thread_init_tls(Thread *thread) 118 { 119 thread->user_local_storage = 120 thread->user_stack_base + thread->user_stack_size; 121 return B_OK; 122 } 123 124 125 void 126 arm_swap_pgdir(uint32_t pageDirectoryAddress) 127 { 128 // Set translation table base 129 asm volatile("MCR p15, 0, %[addr], c2, c0, 0"::[addr] "r" (pageDirectoryAddress)); 130 isb(); 131 132 arch_cpu_global_TLB_invalidate(); 133 134 //TODO: update Context ID (incl. ASID) 135 //TODO: check if any additional TLB or Cache maintenance is needed 136 } 137 138 139 void 140 arm_set_tls_context(Thread *thread) 141 { 142 // Set TPIDRURO to point to TLS base 143 asm volatile("MCR p15, 0, %0, c13, c0, 3" 144 : : "r" (thread->user_local_storage)); 145 } 146 147 148 void 149 arch_thread_context_switch(Thread *from, Thread *to) 150 { 151 arm_set_tls_context(to); 152 153 VMAddressSpace *oldAddressSpace = from->team->address_space; 154 VMTranslationMap *oldTranslationMap = oldAddressSpace->TranslationMap(); 155 phys_addr_t oldPageDirectoryAddress = 156 ((ARMVMTranslationMap *)oldTranslationMap)->PagingStructures()->pgdir_phys; 157 158 VMAddressSpace *newAddressSpace = to->team->address_space; 159 VMTranslationMap *newTranslationMap = newAddressSpace->TranslationMap(); 160 phys_addr_t newPageDirectoryAddress = 161 ((ARMVMTranslationMap *)newTranslationMap)->PagingStructures()->pgdir_phys; 162 163 if (oldPageDirectoryAddress != newPageDirectoryAddress) { 164 TRACE("arch_thread_context_switch: swap pgdir: " 165 "0x%08" B_PRIxPHYSADDR " -> 0x%08" B_PRIxPHYSADDR "\n", 166 oldPageDirectoryAddress, newPageDirectoryAddress); 167 arm_swap_pgdir(newPageDirectoryAddress); 168 } 169 170 TRACE("arch_thread_context_switch: %p(%s/%p) -> %p(%s/%p)\n", 171 from, from->name, from->arch_info.sp, to, to->name, to->arch_info.sp); 172 arm_save_fpu(&from->arch_info.fpuContext); 173 arm_restore_fpu(&to->arch_info.fpuContext); 174 arm_context_switch(&from->arch_info, &to->arch_info); 175 TRACE("arch_thread_context_switch %p %p\n", to, from); 176 } 177 178 179 void 180 arch_thread_dump_info(void *info) 181 { 182 struct arch_thread *at = (struct arch_thread *)info; 183 184 dprintf("\tsp: %p\n", at->sp); 185 } 186 187 188 status_t 189 arch_thread_enter_userspace(Thread *thread, addr_t entry, 190 void *args1, void *args2) 191 { 192 arm_set_tls_context(thread); 193 194 addr_t stackTop = thread->user_stack_base + thread->user_stack_size; 195 196 TRACE("arch_thread_enter_userspace: entry 0x%" B_PRIxADDR ", args %p %p, " 197 "ustack_top 0x%" B_PRIxADDR "\n", entry, args1, args2, stackTop); 198 199 //stackTop = arch_randomize_stack_pointer(stackTop - sizeof(args)); 200 201 // Copy the address of the stub that calls exit_thread() when the thread 202 // entry function returns to LR to act as the return address. 203 // The stub is inside commpage. 204 addr_t commPageAddress = (addr_t)thread->team->commpage_address; 205 206 disable_interrupts(); 207 208 // prepare the user iframe 209 iframe frame = {}; 210 frame.r0 = (uint32)args1; 211 frame.r1 = (uint32)args2; 212 frame.usr_sp = stackTop; 213 frame.usr_lr = ((addr_t*)commPageAddress)[COMMPAGE_ENTRY_ARM_THREAD_EXIT] 214 + commPageAddress; 215 frame.pc = entry; 216 217 // return to userland 218 arch_return_to_userland(&frame); 219 220 // normally we don't get here 221 return B_ERROR; 222 } 223 224 225 bool 226 arch_on_signal_stack(Thread *thread) 227 { 228 struct iframe* frame = thread->arch_info.userFrame; 229 if (frame == NULL) { 230 panic("arch_on_signal_stack(): No user iframe!"); 231 return false; 232 } 233 234 return frame->usr_sp >= thread->signal_stack_base 235 && frame->usr_sp < thread->signal_stack_base 236 + thread->signal_stack_size; 237 } 238 239 240 static uint8* 241 get_signal_stack(Thread* thread, struct iframe* frame, 242 struct sigaction* action, size_t spaceNeeded) 243 { 244 // use the alternate signal stack if we should and can 245 if (thread->signal_stack_enabled && (action->sa_flags & SA_ONSTACK) != 0 246 && (frame->usr_sp < thread->signal_stack_base 247 || frame->usr_sp >= thread->signal_stack_base + thread->signal_stack_size)) { 248 addr_t stackTop = thread->signal_stack_base + thread->signal_stack_size; 249 return (uint8*)ROUNDDOWN(stackTop - spaceNeeded, 16); 250 } 251 252 return (uint8*)ROUNDDOWN(frame->usr_sp - spaceNeeded, 16); 253 } 254 255 256 status_t 257 arch_setup_signal_frame(Thread *thread, struct sigaction *sa, 258 struct signal_frame_data *signalFrameData) 259 { 260 iframe* frame = thread->arch_info.userFrame; 261 if (frame == NULL) { 262 panic("arch_setup_signal_frame(): No user iframe!"); 263 return B_ERROR; 264 } 265 266 // store the register state in signalFrameData->context.uc_mcontext 267 signalFrameData->context.uc_mcontext.r0 = frame->r0; 268 signalFrameData->context.uc_mcontext.r1 = frame->r1; 269 signalFrameData->context.uc_mcontext.r2 = frame->r2; 270 signalFrameData->context.uc_mcontext.r3 = frame->r3; 271 signalFrameData->context.uc_mcontext.r4 = frame->r4; 272 signalFrameData->context.uc_mcontext.r5 = frame->r5; 273 signalFrameData->context.uc_mcontext.r6 = frame->r6; 274 signalFrameData->context.uc_mcontext.r7 = frame->r7; 275 signalFrameData->context.uc_mcontext.r8 = frame->r8; 276 signalFrameData->context.uc_mcontext.r9 = frame->r9; 277 signalFrameData->context.uc_mcontext.r10 = frame->r10; 278 signalFrameData->context.uc_mcontext.r11 = frame->r11; 279 signalFrameData->context.uc_mcontext.r12 = frame->r12; 280 signalFrameData->context.uc_mcontext.r13 = frame->usr_sp; 281 signalFrameData->context.uc_mcontext.r14 = frame->usr_lr; 282 signalFrameData->context.uc_mcontext.r15 = frame->pc; 283 signalFrameData->context.uc_mcontext.cpsr = frame->spsr; 284 285 arm_save_fpu((arch_fpu_context*)&signalFrameData->context.uc_mcontext.d[0]); 286 287 // Fill in signalFrameData->context.uc_stack 288 signal_get_user_stack(frame->usr_sp, &signalFrameData->context.uc_stack); 289 290 // store oldR0 in syscall_restart_return_value 291 signalFrameData->syscall_restart_return_value = thread->arch_info.oldR0; 292 293 // get the stack to use -- that's either the current one or a special signal stack 294 uint8* userStack = get_signal_stack(thread, frame, sa, 295 sizeof(*signalFrameData)); 296 297 // copy the signal frame data onto the stack 298 status_t res = user_memcpy(userStack, signalFrameData, 299 sizeof(*signalFrameData)); 300 if (res < B_OK) 301 return res; 302 303 // prepare the user stack frame for a function call to the signal handler wrapper function 304 addr_t commpageAddr = (addr_t)thread->team->commpage_address; 305 addr_t signalHandlerAddr; 306 ASSERT(user_memcpy(&signalHandlerAddr, 307 &((addr_t*)commpageAddr)[COMMPAGE_ENTRY_ARM_SIGNAL_HANDLER], 308 sizeof(signalHandlerAddr)) >= B_OK); 309 signalHandlerAddr += commpageAddr; 310 311 frame->usr_lr = frame->pc; 312 frame->usr_sp = (addr_t)userStack; 313 frame->pc = signalHandlerAddr; 314 frame->r0 = frame->usr_sp; 315 316 return B_OK; 317 } 318 319 320 int64 321 arch_restore_signal_frame(struct signal_frame_data* signalFrameData) 322 { 323 iframe* frame = thread_get_current_thread()->arch_info.userFrame; 324 if (frame == NULL) { 325 panic("arch_restore_signal_frame(): No user iframe!"); 326 return 0; 327 } 328 329 thread_get_current_thread()->arch_info.oldR0 330 = signalFrameData->syscall_restart_return_value; 331 332 frame->r0 = signalFrameData->context.uc_mcontext.r0; 333 frame->r1 = signalFrameData->context.uc_mcontext.r1; 334 frame->r2 = signalFrameData->context.uc_mcontext.r2; 335 frame->r3 = signalFrameData->context.uc_mcontext.r3; 336 frame->r4 = signalFrameData->context.uc_mcontext.r4; 337 frame->r5 = signalFrameData->context.uc_mcontext.r5; 338 frame->r6 = signalFrameData->context.uc_mcontext.r6; 339 frame->r7 = signalFrameData->context.uc_mcontext.r7; 340 frame->r8 = signalFrameData->context.uc_mcontext.r8; 341 frame->r9 = signalFrameData->context.uc_mcontext.r9; 342 frame->r10 = signalFrameData->context.uc_mcontext.r10; 343 frame->r11 = signalFrameData->context.uc_mcontext.r11; 344 frame->r12 = signalFrameData->context.uc_mcontext.r12; 345 frame->usr_sp = signalFrameData->context.uc_mcontext.r13; 346 frame->usr_lr = signalFrameData->context.uc_mcontext.r14; 347 frame->pc = signalFrameData->context.uc_mcontext.r15; 348 frame->spsr = signalFrameData->context.uc_mcontext.cpsr; 349 350 arm_restore_fpu((arch_fpu_context*)&signalFrameData->context.uc_mcontext.d[0]); 351 352 return frame->r0; 353 } 354 355 356 void 357 arch_check_syscall_restart(Thread *thread) 358 { 359 } 360 361 362 /** Saves everything needed to restore the frame in the child fork in the 363 * arch_fork_arg structure to be passed to arch_restore_fork_frame(). 364 * Also makes sure to return the right value. 365 */ 366 void 367 arch_store_fork_frame(struct arch_fork_arg *arg) 368 { 369 struct iframe* frame = thread_get_current_thread()->arch_info.userFrame; 370 if (frame == NULL) { 371 panic("arch_store_fork_frame(): No user iframe!"); 372 } 373 374 arg->frame = *frame; 375 arg->frame.r0 = 0; // fork return value 376 } 377 378 379 /** Restores the frame from a forked team as specified by the provided 380 * arch_fork_arg structure. 381 * Needs to be called from within the child team, ie. instead of 382 * arch_thread_enter_uspace() as thread "starter". 383 * This function does not return to the caller, but will enter userland 384 * in the child team at the same position where the parent team left of. 385 */ 386 void 387 arch_restore_fork_frame(struct arch_fork_arg *arg) 388 { 389 disable_interrupts(); 390 arch_return_to_userland(&arg->frame); 391 } 392