| 1 | /* |
| 2 | * OpenRISC process.c |
| 3 | * |
| 4 | * Linux architectural port borrowing liberally from similar works of |
| 5 | * others. All original copyrights apply as per the original source |
| 6 | * declaration. |
| 7 | * |
| 8 | * Modifications for the OpenRISC architecture: |
| 9 | * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com> |
| 10 | * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se> |
| 11 | * |
| 12 | * This program is free software; you can redistribute it and/or |
| 13 | * modify it under the terms of the GNU General Public License |
| 14 | * as published by the Free Software Foundation; either version |
| 15 | * 2 of the License, or (at your option) any later version. |
| 16 | * |
| 17 | * This file handles the architecture-dependent parts of process handling... |
| 18 | */ |
| 19 | |
| 20 | #define __KERNEL_SYSCALLS__ |
| 21 | #include <stdarg.h> |
| 22 | |
| 23 | #include <linux/errno.h> |
| 24 | #include <linux/sched.h> |
| 25 | #include <linux/kernel.h> |
| 26 | #include <linux/module.h> |
| 27 | #include <linux/mm.h> |
| 28 | #include <linux/stddef.h> |
| 29 | #include <linux/unistd.h> |
| 30 | #include <linux/ptrace.h> |
| 31 | #include <linux/slab.h> |
| 32 | #include <linux/elfcore.h> |
| 33 | #include <linux/interrupt.h> |
| 34 | #include <linux/delay.h> |
| 35 | #include <linux/init_task.h> |
| 36 | #include <linux/mqueue.h> |
| 37 | #include <linux/fs.h> |
| 38 | |
| 39 | #include <linux/uaccess.h> |
| 40 | #include <asm/pgtable.h> |
| 41 | #include <asm/io.h> |
| 42 | #include <asm/processor.h> |
| 43 | #include <asm/spr_defs.h> |
| 44 | |
| 45 | #include <linux/smp.h> |
| 46 | |
| 47 | /* |
| 48 | * Pointer to Current thread info structure. |
| 49 | * |
| 50 | * Used at user space -> kernel transitions. |
| 51 | */ |
| 52 | struct thread_info *current_thread_info_set[NR_CPUS] = { &init_thread_info, }; |
| 53 | |
| 54 | void machine_restart(void) |
| 55 | { |
| 56 | printk(KERN_INFO "*** MACHINE RESTART ***\n"); |
| 57 | __asm__("l.nop 1"); |
| 58 | } |
| 59 | |
| 60 | /* |
| 61 | * Similar to machine_power_off, but don't shut off power. Add code |
| 62 | * here to freeze the system for e.g. post-mortem debug purpose when |
| 63 | * possible. This halt has nothing to do with the idle halt. |
| 64 | */ |
| 65 | void machine_halt(void) |
| 66 | { |
| 67 | printk(KERN_INFO "*** MACHINE HALT ***\n"); |
| 68 | __asm__("l.nop 1"); |
| 69 | } |
| 70 | |
| 71 | /* If or when software power-off is implemented, add code here. */ |
| 72 | void machine_power_off(void) |
| 73 | { |
| 74 | printk(KERN_INFO "*** MACHINE POWER OFF ***\n"); |
| 75 | __asm__("l.nop 1"); |
| 76 | } |
| 77 | |
| 78 | void (*pm_power_off) (void) = machine_power_off; |
| 79 | |
| 80 | /* |
| 81 | * When a process does an "exec", machine state like FPU and debug |
| 82 | * registers need to be reset. This is a hook function for that. |
| 83 | * Currently we don't have any such state to reset, so this is empty. |
| 84 | */ |
| 85 | void flush_thread(void) |
| 86 | { |
| 87 | } |
| 88 | |
| 89 | void show_regs(struct pt_regs *regs) |
| 90 | { |
| 91 | extern void show_registers(struct pt_regs *regs); |
| 92 | |
| 93 | show_regs_print_info(KERN_DEFAULT); |
| 94 | /* __PHX__ cleanup this mess */ |
| 95 | show_registers(regs); |
| 96 | } |
| 97 | |
| 98 | unsigned long thread_saved_pc(struct task_struct *t) |
| 99 | { |
| 100 | return (unsigned long)user_regs(t->stack)->pc; |
| 101 | } |
| 102 | |
| 103 | void release_thread(struct task_struct *dead_task) |
| 104 | { |
| 105 | } |
| 106 | |
| 107 | /* |
| 108 | * Copy the thread-specific (arch specific) info from the current |
| 109 | * process to the new one p |
| 110 | */ |
| 111 | extern asmlinkage void ret_from_fork(void); |
| 112 | |
| 113 | /* |
| 114 | * copy_thread |
| 115 | * @clone_flags: flags |
| 116 | * @usp: user stack pointer or fn for kernel thread |
| 117 | * @arg: arg to fn for kernel thread; always NULL for userspace thread |
| 118 | * @p: the newly created task |
| 119 | * @regs: CPU context to copy for userspace thread; always NULL for kthread |
| 120 | * |
| 121 | * At the top of a newly initialized kernel stack are two stacked pt_reg |
| 122 | * structures. The first (topmost) is the userspace context of the thread. |
| 123 | * The second is the kernelspace context of the thread. |
| 124 | * |
| 125 | * A kernel thread will not be returning to userspace, so the topmost pt_regs |
| 126 | * struct can be uninitialized; it _does_ need to exist, though, because |
| 127 | * a kernel thread can become a userspace thread by doing a kernel_execve, in |
| 128 | * which case the topmost context will be initialized and used for 'returning' |
| 129 | * to userspace. |
| 130 | * |
| 131 | * The second pt_reg struct needs to be initialized to 'return' to |
| 132 | * ret_from_fork. A kernel thread will need to set r20 to the address of |
| 133 | * a function to call into (with arg in r22); userspace threads need to set |
| 134 | * r20 to NULL in which case ret_from_fork will just continue a return to |
| 135 | * userspace. |
| 136 | * |
| 137 | * A kernel thread 'fn' may return; this is effectively what happens when |
| 138 | * kernel_execve is called. In that case, the userspace pt_regs must have |
| 139 | * been initialized (which kernel_execve takes care of, see start_thread |
| 140 | * below); ret_from_fork will then continue its execution causing the |
| 141 | * 'kernel thread' to return to userspace as a userspace thread. |
| 142 | */ |
| 143 | |
| 144 | int |
| 145 | copy_thread(unsigned long clone_flags, unsigned long usp, |
| 146 | unsigned long arg, struct task_struct *p) |
| 147 | { |
| 148 | struct pt_regs *userregs; |
| 149 | struct pt_regs *kregs; |
| 150 | unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE; |
| 151 | unsigned long top_of_kernel_stack; |
| 152 | |
| 153 | top_of_kernel_stack = sp; |
| 154 | |
| 155 | p->set_child_tid = p->clear_child_tid = NULL; |
| 156 | |
| 157 | /* Locate userspace context on stack... */ |
| 158 | sp -= STACK_FRAME_OVERHEAD; /* redzone */ |
| 159 | sp -= sizeof(struct pt_regs); |
| 160 | userregs = (struct pt_regs *) sp; |
| 161 | |
| 162 | /* ...and kernel context */ |
| 163 | sp -= STACK_FRAME_OVERHEAD; /* redzone */ |
| 164 | sp -= sizeof(struct pt_regs); |
| 165 | kregs = (struct pt_regs *)sp; |
| 166 | |
| 167 | if (unlikely(p->flags & PF_KTHREAD)) { |
| 168 | memset(kregs, 0, sizeof(struct pt_regs)); |
| 169 | kregs->gpr[20] = usp; /* fn, kernel thread */ |
| 170 | kregs->gpr[22] = arg; |
| 171 | } else { |
| 172 | *userregs = *current_pt_regs(); |
| 173 | |
| 174 | if (usp) |
| 175 | userregs->sp = usp; |
| 176 | |
| 177 | /* |
| 178 | * For CLONE_SETTLS set "tp" (r10) to the TLS pointer passed to sys_clone. |
| 179 | * |
| 180 | * The kernel entry is: |
| 181 | * int clone (long flags, void *child_stack, int *parent_tid, |
| 182 | * int *child_tid, struct void *tls) |
| 183 | * |
| 184 | * This makes the source r7 in the kernel registers. |
| 185 | */ |
| 186 | if (clone_flags & CLONE_SETTLS) |
| 187 | userregs->gpr[10] = userregs->gpr[7]; |
| 188 | |
| 189 | userregs->gpr[11] = 0; /* Result from fork() */ |
| 190 | |
| 191 | kregs->gpr[20] = 0; /* Userspace thread */ |
| 192 | } |
| 193 | |
| 194 | /* |
| 195 | * _switch wants the kernel stack page in pt_regs->sp so that it |
| 196 | * can restore it to thread_info->ksp... see _switch for details. |
| 197 | */ |
| 198 | kregs->sp = top_of_kernel_stack; |
| 199 | kregs->gpr[9] = (unsigned long)ret_from_fork; |
| 200 | |
| 201 | task_thread_info(p)->ksp = (unsigned long)kregs; |
| 202 | |
| 203 | return 0; |
| 204 | } |
| 205 | |
| 206 | /* |
| 207 | * Set up a thread for executing a new program |
| 208 | */ |
| 209 | void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp) |
| 210 | { |
| 211 | unsigned long sr = mfspr(SPR_SR) & ~SPR_SR_SM; |
| 212 | |
| 213 | memset(regs, 0, sizeof(struct pt_regs)); |
| 214 | |
| 215 | regs->pc = pc; |
| 216 | regs->sr = sr; |
| 217 | regs->sp = sp; |
| 218 | } |
| 219 | |
| 220 | /* Fill in the fpu structure for a core dump. */ |
| 221 | int dump_fpu(struct pt_regs *regs, elf_fpregset_t * fpu) |
| 222 | { |
| 223 | /* TODO */ |
| 224 | return 0; |
| 225 | } |
| 226 | |
| 227 | extern struct thread_info *_switch(struct thread_info *old_ti, |
| 228 | struct thread_info *new_ti); |
| 229 | |
| 230 | struct task_struct *__switch_to(struct task_struct *old, |
| 231 | struct task_struct *new) |
| 232 | { |
| 233 | struct task_struct *last; |
| 234 | struct thread_info *new_ti, *old_ti; |
| 235 | unsigned long flags; |
| 236 | |
| 237 | local_irq_save(flags); |
| 238 | |
| 239 | /* current_set is an array of saved current pointers |
| 240 | * (one for each cpu). we need them at user->kernel transition, |
| 241 | * while we save them at kernel->user transition |
| 242 | */ |
| 243 | new_ti = new->stack; |
| 244 | old_ti = old->stack; |
| 245 | |
| 246 | current_thread_info_set[smp_processor_id()] = new_ti; |
| 247 | last = (_switch(old_ti, new_ti))->task; |
| 248 | |
| 249 | local_irq_restore(flags); |
| 250 | |
| 251 | return last; |
| 252 | } |
| 253 | |
| 254 | /* |
| 255 | * Write out registers in core dump format, as defined by the |
| 256 | * struct user_regs_struct |
| 257 | */ |
| 258 | void dump_elf_thread(elf_greg_t *dest, struct pt_regs* regs) |
| 259 | { |
| 260 | dest[0] = 0; /* r0 */ |
| 261 | memcpy(dest+1, regs->gpr+1, 31*sizeof(unsigned long)); |
| 262 | dest[32] = regs->pc; |
| 263 | dest[33] = regs->sr; |
| 264 | dest[34] = 0; |
| 265 | dest[35] = 0; |
| 266 | } |
| 267 | |
| 268 | unsigned long get_wchan(struct task_struct *p) |
| 269 | { |
| 270 | /* TODO */ |
| 271 | |
| 272 | return 0; |
| 273 | } |