src/system/kernel/arch/m68k/arch_thread.cpp

   1 /*
   2  * Copyright 2003-2011, 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 <arch_thread.h>
  16
  17 #include <string.h>
  18
  19 #include <arch_cpu.h>
  20 #include <arch/thread.h>
  21 #include <boot/stage2.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 "paging/M68KPagingMethod.h"
  30 #include "paging/M68KPagingStructures.h"
  31 #include "paging/M68KVMTranslationMap.h"
  32
  33
  34 #warning M68K: writeme!
  35 // Valid initial arch_thread state. We just memcpy() it when initializing
  36 // a new thread structure.
  37 static struct arch_thread sInitialState;
  38
  39 Thread *gCurrentThread;
  40
  41 // Helper function for thread creation, defined in arch_asm.S.
  42 extern "C" void m68k_kernel_thread_root();
  43
  44
  45 void
  46 m68k_push_iframe(struct iframe_stack *stack, struct iframe *frame)
  47 {
  48         ASSERT(stack->index < IFRAME_TRACE_DEPTH);
  49         stack->frames[stack->index++] = frame;
  50 }
  51
  52
  53 void
  54 m68k_pop_iframe(struct iframe_stack *stack)
  55 {
  56         ASSERT(stack->index > 0);
  57         stack->index--;
  58 }
  59
  60
  61 /**     Returns the current iframe structure of the running thread.
  62  *      This function must only be called in a context where it's actually
  63  *      sure that such iframe exists; ie. from syscalls, but usually not
  64  *      from standard kernel threads.
  65  */
  66 static struct iframe *
  67 m68k_get_current_iframe(void)
  68 {
  69         Thread *thread = thread_get_current_thread();
  70
  71         ASSERT(thread->arch_info.iframes.index >= 0);
  72         return thread->arch_info.iframes.frames[thread->arch_info.iframes.index - 1];
  73 }
  74
  75
  76 /** \brief Returns the current thread's topmost (i.e. most recent)
  77  *  userland->kernel transition iframe (usually the first one, save for
  78  *  interrupts in signal handlers).
  79  *  \return The iframe, or \c NULL, if there is no such iframe (e.g. when
  80  *          the thread is a kernel thread).
  81  */
  82 struct iframe *
  83 m68k_get_user_iframe(void)
  84 {
  85         Thread *thread = thread_get_current_thread();
  86         int i;
  87
  88         for (i = thread->arch_info.iframes.index - 1; i >= 0; i--) {
  89                 struct iframe *frame = thread->arch_info.iframes.frames[i];
  90                 if ((frame->cpu.sr & (1 << M68K_SR_S)) == 0)
  91                         return frame;
  92         }
  93
  94         return NULL;
  95 }
  96
  97
  98 uint32
  99 m68k_next_page_directory(Thread *from, Thread *to)
 100 {
 101         VMAddressSpace* toAddressSpace = to->team->address_space;
 102         if (from->team->address_space == toAddressSpace) {
 103                 // don't change the pgdir, same address space
 104                 return 0;
 105         }
 106
 107         if (toAddressSpace == NULL)
 108                 toAddressSpace = VMAddressSpace::Kernel();
 109
 110         return static_cast<M68KVMTranslationMap*>(toAddressSpace->TranslationMap())
 111                 ->PagingStructures()->pgroot_phys;
 112 }
 113
 114 // #pragma mark -
 115
 116
 117 status_t
 118 arch_thread_init(struct kernel_args *args)
 119 {
 120         // Initialize the static initial arch_thread state (sInitialState).
 121         // Currently nothing to do, i.e. zero initialized is just fine.
 122
 123         return B_OK;
 124 }
 125
 126
 127 status_t
 128 arch_team_init_team_struct(Team *team, bool kernel)
 129 {
 130         // Nothing to do. The structure is empty.
 131         return B_OK;
 132 }
 133
 134
 135 status_t
 136 arch_thread_init_thread_struct(Thread *thread)
 137 {
 138         // set up an initial state (stack & fpu)
 139         memcpy(&thread->arch_info, &sInitialState, sizeof(struct arch_thread));
 140
 141         return B_OK;
 142 }
 143
 144
 145 void
 146 arch_thread_init_kthread_stack(Thread* thread, void* _stack, void* _stackTop,
 147         void (*function)(void*), const void* data)
 148 {
 149 #if 0
 150         addr_t *kstack = (addr_t *)t->kernel_stack_base;
 151         addr_t *kstackTop = (addr_t *)t->kernel_stack_base;
 152
 153         // clear the kernel stack
 154 #ifdef DEBUG_KERNEL_STACKS
 155 #       ifdef STACK_GROWS_DOWNWARDS
 156         memset((void *)((addr_t)kstack + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE), 0,
 157                 KERNEL_STACK_SIZE);
 158 #       else
 159         memset(kstack, 0, KERNEL_STACK_SIZE);
 160 #       endif
 161 #else
 162         memset(kstack, 0, KERNEL_STACK_SIZE);
 163 #endif
 164
 165         // space for frame pointer and return address, and stack frames must be
 166         // 16 byte aligned
 167         kstackTop -= 2;
 168         kstackTop = (addr_t*)((addr_t)kstackTop & ~0xf);
 169
 170         // LR, CR, r2, r13-r31, f13-f31, as pushed by m68k_context_switch()
 171         kstackTop -= 22 + 2 * 19;
 172
 173         // let LR point to m68k_kernel_thread_root()
 174         kstackTop[0] = (addr_t)&m68k_kernel_thread_root;
 175
 176         // the arguments of m68k_kernel_thread_root() are the functions to call,
 177         // provided in registers r13-r15
 178         kstackTop[3] = (addr_t)entry_func;
 179         kstackTop[4] = (addr_t)start_func;
 180         kstackTop[5] = (addr_t)exit_func;
 181
 182         // save this stack position
 183         t->arch_info.sp = (void *)kstackTop;
 184
 185         return B_OK;
 186 #else
 187         panic("arch_thread_init_kthread_stack(): Implement me!");
 188 #endif
 189 }
 190
 191
 192 status_t
 193 arch_thread_init_tls(Thread *thread)
 194 {
 195         // TODO: Implement!
 196         return B_OK;
 197 }
 198
 199
 200 void
 201 arch_thread_context_switch(Thread *from, Thread *to)
 202 {
 203         addr_t newPageDirectory;
 204
 205         newPageDirectory = (addr_t)m68k_next_page_directory(from, to);
 206
 207         if ((newPageDirectory % B_PAGE_SIZE) != 0)
 208                 panic("arch_thread_context_switch: bad pgdir 0x%lx\n", newPageDirectory);
 209 #warning M68K: export from arch_vm.c
 210
 211         //m68k_set_pgdir((void *)newPageDirectory);
 212         gM68KPagingMethod->SetPageRoot(newPageDirectory);
 213
 214         m68k_context_switch(&from->arch_info.sp, to->arch_info.sp);
 215 }
 216
 217
 218 void
 219 arch_thread_dump_info(void *info)
 220 {
 221         struct arch_thread *at = (struct arch_thread *)info;
 222
 223         dprintf("\tsp: %p\n", at->sp);
 224 }
 225
 226
 227 status_t
 228 arch_thread_enter_userspace(Thread *thread, addr_t entry, void *arg1, void *arg2)
 229 {
 230         panic("arch_thread_enter_uspace(): not yet implemented\n");
 231         return B_ERROR;
 232 }
 233
 234
 235 bool
 236 arch_on_signal_stack(Thread *thread)
 237 {
 238         return false;
 239 }
 240
 241
 242 status_t
 243 arch_setup_signal_frame(Thread *thread, struct sigaction *sa,
 244         struct signal_frame_data *signalFrameData)
 245 {
 246         return B_ERROR;
 247 }
 248
 249
 250 int64
 251 arch_restore_signal_frame(struct signal_frame_data* signalFrameData)
 252 {
 253         return 0;
 254 }
 255
 256
 257 void
 258 arch_check_syscall_restart(Thread *thread)
 259 {
 260 }
 261
 262
 263 /**     Saves everything needed to restore the frame in the child fork in the
 264  *      arch_fork_arg structure to be passed to arch_restore_fork_frame().
 265  *      Also makes sure to return the right value.
 266  */
 267
 268 void
 269 arch_store_fork_frame(struct arch_fork_arg *arg)
 270 {
 271 }
 272
 273
 274 /** Restores the frame from a forked team as specified by the provided
 275  *      arch_fork_arg structure.
 276  *      Needs to be called from within the child team, ie. instead of
 277  *      arch_thread_enter_uspace() as thread "starter".
 278  *      This function does not return to the caller, but will enter userland
 279  *      in the child team at the same position where the parent team left of.
 280  */
 281
 282 void
 283 arch_restore_fork_frame(struct arch_fork_arg *arg)
 284 {
 285 }
 286