Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 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 <asm/uaccess.h> |
| 40 | #include <asm/pgtable.h> |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 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 | /* __PHX__ cleanup this mess */ |
| 94 | show_registers(regs); |
| 95 | } |
| 96 | |
| 97 | unsigned long thread_saved_pc(struct task_struct *t) |
| 98 | { |
| 99 | return (unsigned long)user_regs(t->stack)->pc; |
| 100 | } |
| 101 | |
| 102 | void release_thread(struct task_struct *dead_task) |
| 103 | { |
| 104 | } |
| 105 | |
| 106 | /* |
| 107 | * Copy the thread-specific (arch specific) info from the current |
| 108 | * process to the new one p |
| 109 | */ |
| 110 | extern asmlinkage void ret_from_fork(void); |
| 111 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 112 | /* |
| 113 | * copy_thread |
| 114 | * @clone_flags: flags |
| 115 | * @usp: user stack pointer or fn for kernel thread |
| 116 | * @arg: arg to fn for kernel thread; always NULL for userspace thread |
| 117 | * @p: the newly created task |
| 118 | * @regs: CPU context to copy for userspace thread; always NULL for kthread |
| 119 | * |
| 120 | * At the top of a newly initialized kernel stack are two stacked pt_reg |
| 121 | * structures. The first (topmost) is the userspace context of the thread. |
| 122 | * The second is the kernelspace context of the thread. |
| 123 | * |
| 124 | * A kernel thread will not be returning to userspace, so the topmost pt_regs |
| 125 | * struct can be uninitialized; it _does_ need to exist, though, because |
| 126 | * a kernel thread can become a userspace thread by doing a kernel_execve, in |
| 127 | * which case the topmost context will be initialized and used for 'returning' |
| 128 | * to userspace. |
| 129 | * |
| 130 | * The second pt_reg struct needs to be initialized to 'return' to |
| 131 | * ret_from_fork. A kernel thread will need to set r20 to the address of |
| 132 | * a function to call into (with arg in r22); userspace threads need to set |
| 133 | * r20 to NULL in which case ret_from_fork will just continue a return to |
| 134 | * userspace. |
| 135 | * |
| 136 | * A kernel thread 'fn' may return; this is effectively what happens when |
| 137 | * kernel_execve is called. In that case, the userspace pt_regs must have |
| 138 | * been initialized (which kernel_execve takes care of, see start_thread |
| 139 | * below); ret_from_fork will then continue its execution causing the |
| 140 | * 'kernel thread' to return to userspace as a userspace thread. |
| 141 | */ |
| 142 | |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 143 | int |
| 144 | copy_thread(unsigned long clone_flags, unsigned long usp, |
Al Viro | afa86fc | 2012-10-22 22:51:14 -0400 | [diff] [blame] | 145 | unsigned long arg, struct task_struct *p) |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 146 | { |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 147 | struct pt_regs *userregs; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 148 | struct pt_regs *kregs; |
| 149 | unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 150 | unsigned long top_of_kernel_stack; |
| 151 | |
| 152 | top_of_kernel_stack = sp; |
| 153 | |
| 154 | p->set_child_tid = p->clear_child_tid = NULL; |
| 155 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 156 | /* Locate userspace context on stack... */ |
| 157 | sp -= STACK_FRAME_OVERHEAD; /* redzone */ |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 158 | sp -= sizeof(struct pt_regs); |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 159 | userregs = (struct pt_regs *) sp; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 160 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 161 | /* ...and kernel context */ |
| 162 | sp -= STACK_FRAME_OVERHEAD; /* redzone */ |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 163 | sp -= sizeof(struct pt_regs); |
| 164 | kregs = (struct pt_regs *)sp; |
| 165 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 166 | if (unlikely(p->flags & PF_KTHREAD)) { |
| 167 | memset(kregs, 0, sizeof(struct pt_regs)); |
| 168 | kregs->gpr[20] = usp; /* fn, kernel thread */ |
| 169 | kregs->gpr[22] = arg; |
| 170 | } else { |
Al Viro | 39d91a9 | 2012-10-26 19:37:49 -0400 | [diff] [blame] | 171 | *userregs = *current_pt_regs(); |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 172 | |
Al Viro | 39d91a9 | 2012-10-26 19:37:49 -0400 | [diff] [blame] | 173 | if (usp) |
| 174 | userregs->sp = usp; |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 175 | userregs->gpr[11] = 0; /* Result from fork() */ |
| 176 | |
| 177 | kregs->gpr[20] = 0; /* Userspace thread */ |
| 178 | } |
| 179 | |
| 180 | /* |
| 181 | * _switch wants the kernel stack page in pt_regs->sp so that it |
| 182 | * can restore it to thread_info->ksp... see _switch for details. |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 183 | */ |
| 184 | kregs->sp = top_of_kernel_stack; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 185 | kregs->gpr[9] = (unsigned long)ret_from_fork; |
| 186 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 187 | task_thread_info(p)->ksp = (unsigned long)kregs; |
| 188 | |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 189 | return 0; |
| 190 | } |
| 191 | |
| 192 | /* |
| 193 | * Set up a thread for executing a new program |
| 194 | */ |
| 195 | void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp) |
| 196 | { |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 197 | unsigned long sr = mfspr(SPR_SR) & ~SPR_SR_SM; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 198 | |
| 199 | set_fs(USER_DS); |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 200 | memset(regs, 0, sizeof(struct pt_regs)); |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 201 | |
| 202 | regs->pc = pc; |
| 203 | regs->sr = sr; |
| 204 | regs->sp = sp; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | /* Fill in the fpu structure for a core dump. */ |
| 208 | int dump_fpu(struct pt_regs *regs, elf_fpregset_t * fpu) |
| 209 | { |
| 210 | /* TODO */ |
| 211 | return 0; |
| 212 | } |
| 213 | |
| 214 | extern struct thread_info *_switch(struct thread_info *old_ti, |
| 215 | struct thread_info *new_ti); |
| 216 | |
| 217 | struct task_struct *__switch_to(struct task_struct *old, |
| 218 | struct task_struct *new) |
| 219 | { |
| 220 | struct task_struct *last; |
| 221 | struct thread_info *new_ti, *old_ti; |
| 222 | unsigned long flags; |
| 223 | |
| 224 | local_irq_save(flags); |
| 225 | |
| 226 | /* current_set is an array of saved current pointers |
| 227 | * (one for each cpu). we need them at user->kernel transition, |
| 228 | * while we save them at kernel->user transition |
| 229 | */ |
| 230 | new_ti = new->stack; |
| 231 | old_ti = old->stack; |
| 232 | |
| 233 | current_thread_info_set[smp_processor_id()] = new_ti; |
| 234 | last = (_switch(old_ti, new_ti))->task; |
| 235 | |
| 236 | local_irq_restore(flags); |
| 237 | |
| 238 | return last; |
| 239 | } |
| 240 | |
| 241 | /* |
| 242 | * Write out registers in core dump format, as defined by the |
| 243 | * struct user_regs_struct |
| 244 | */ |
| 245 | void dump_elf_thread(elf_greg_t *dest, struct pt_regs* regs) |
| 246 | { |
| 247 | dest[0] = 0; /* r0 */ |
| 248 | memcpy(dest+1, regs->gpr+1, 31*sizeof(unsigned long)); |
| 249 | dest[32] = regs->pc; |
| 250 | dest[33] = regs->sr; |
| 251 | dest[34] = 0; |
| 252 | dest[35] = 0; |
| 253 | } |
| 254 | |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 255 | unsigned long get_wchan(struct task_struct *p) |
| 256 | { |
| 257 | /* TODO */ |
| 258 | |
| 259 | return 0; |
| 260 | } |