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> |
Ingo Molnar | b17b015 | 2017-02-08 18:51:35 +0100 | [diff] [blame] | 25 | #include <linux/sched/debug.h> |
Ingo Molnar | 2993002 | 2017-02-08 18:51:36 +0100 | [diff] [blame] | 26 | #include <linux/sched/task.h> |
Ingo Molnar | 68db0cf | 2017-02-08 18:51:37 +0100 | [diff] [blame] | 27 | #include <linux/sched/task_stack.h> |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 28 | #include <linux/kernel.h> |
Stafford Horne | 1938852 | 2017-03-14 22:54:22 +0900 | [diff] [blame] | 29 | #include <linux/export.h> |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 30 | #include <linux/mm.h> |
| 31 | #include <linux/stddef.h> |
| 32 | #include <linux/unistd.h> |
| 33 | #include <linux/ptrace.h> |
| 34 | #include <linux/slab.h> |
| 35 | #include <linux/elfcore.h> |
| 36 | #include <linux/interrupt.h> |
| 37 | #include <linux/delay.h> |
| 38 | #include <linux/init_task.h> |
| 39 | #include <linux/mqueue.h> |
| 40 | #include <linux/fs.h> |
| 41 | |
Linus Torvalds | 7c0f6ba | 2016-12-24 11:46:01 -0800 | [diff] [blame] | 42 | #include <linux/uaccess.h> |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 43 | #include <asm/pgtable.h> |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 44 | #include <asm/io.h> |
| 45 | #include <asm/processor.h> |
| 46 | #include <asm/spr_defs.h> |
| 47 | |
| 48 | #include <linux/smp.h> |
| 49 | |
| 50 | /* |
| 51 | * Pointer to Current thread info structure. |
| 52 | * |
| 53 | * Used at user space -> kernel transitions. |
| 54 | */ |
| 55 | struct thread_info *current_thread_info_set[NR_CPUS] = { &init_thread_info, }; |
| 56 | |
| 57 | void machine_restart(void) |
| 58 | { |
| 59 | printk(KERN_INFO "*** MACHINE RESTART ***\n"); |
| 60 | __asm__("l.nop 1"); |
| 61 | } |
| 62 | |
| 63 | /* |
| 64 | * Similar to machine_power_off, but don't shut off power. Add code |
| 65 | * here to freeze the system for e.g. post-mortem debug purpose when |
| 66 | * possible. This halt has nothing to do with the idle halt. |
| 67 | */ |
| 68 | void machine_halt(void) |
| 69 | { |
| 70 | printk(KERN_INFO "*** MACHINE HALT ***\n"); |
| 71 | __asm__("l.nop 1"); |
| 72 | } |
| 73 | |
| 74 | /* If or when software power-off is implemented, add code here. */ |
| 75 | void machine_power_off(void) |
| 76 | { |
| 77 | printk(KERN_INFO "*** MACHINE POWER OFF ***\n"); |
| 78 | __asm__("l.nop 1"); |
| 79 | } |
| 80 | |
Sebastian Macke | e29d11c | 2014-07-20 15:13:31 +0000 | [diff] [blame] | 81 | /* |
| 82 | * Send the doze signal to the cpu if available. |
| 83 | * Make sure, that all interrupts are enabled |
| 84 | */ |
| 85 | void arch_cpu_idle(void) |
| 86 | { |
| 87 | local_irq_enable(); |
| 88 | if (mfspr(SPR_UPR) & SPR_UPR_PMP) |
| 89 | mtspr(SPR_PMR, mfspr(SPR_PMR) | SPR_PMR_DME); |
| 90 | } |
| 91 | |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 92 | void (*pm_power_off) (void) = machine_power_off; |
Stafford Horne | 363dad5 | 2017-03-14 22:52:49 +0900 | [diff] [blame] | 93 | EXPORT_SYMBOL(pm_power_off); |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 94 | |
| 95 | /* |
| 96 | * When a process does an "exec", machine state like FPU and debug |
| 97 | * registers need to be reset. This is a hook function for that. |
| 98 | * Currently we don't have any such state to reset, so this is empty. |
| 99 | */ |
| 100 | void flush_thread(void) |
| 101 | { |
| 102 | } |
| 103 | |
| 104 | void show_regs(struct pt_regs *regs) |
| 105 | { |
| 106 | extern void show_registers(struct pt_regs *regs); |
| 107 | |
Tejun Heo | a43cb95 | 2013-04-30 15:27:17 -0700 | [diff] [blame] | 108 | show_regs_print_info(KERN_DEFAULT); |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 109 | /* __PHX__ cleanup this mess */ |
| 110 | show_registers(regs); |
| 111 | } |
| 112 | |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 113 | void release_thread(struct task_struct *dead_task) |
| 114 | { |
| 115 | } |
| 116 | |
| 117 | /* |
| 118 | * Copy the thread-specific (arch specific) info from the current |
| 119 | * process to the new one p |
| 120 | */ |
| 121 | extern asmlinkage void ret_from_fork(void); |
| 122 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 123 | /* |
| 124 | * copy_thread |
| 125 | * @clone_flags: flags |
| 126 | * @usp: user stack pointer or fn for kernel thread |
| 127 | * @arg: arg to fn for kernel thread; always NULL for userspace thread |
| 128 | * @p: the newly created task |
| 129 | * @regs: CPU context to copy for userspace thread; always NULL for kthread |
| 130 | * |
| 131 | * At the top of a newly initialized kernel stack are two stacked pt_reg |
| 132 | * structures. The first (topmost) is the userspace context of the thread. |
| 133 | * The second is the kernelspace context of the thread. |
| 134 | * |
| 135 | * A kernel thread will not be returning to userspace, so the topmost pt_regs |
| 136 | * struct can be uninitialized; it _does_ need to exist, though, because |
| 137 | * a kernel thread can become a userspace thread by doing a kernel_execve, in |
| 138 | * which case the topmost context will be initialized and used for 'returning' |
| 139 | * to userspace. |
| 140 | * |
| 141 | * The second pt_reg struct needs to be initialized to 'return' to |
| 142 | * ret_from_fork. A kernel thread will need to set r20 to the address of |
| 143 | * a function to call into (with arg in r22); userspace threads need to set |
| 144 | * r20 to NULL in which case ret_from_fork will just continue a return to |
| 145 | * userspace. |
| 146 | * |
| 147 | * A kernel thread 'fn' may return; this is effectively what happens when |
| 148 | * kernel_execve is called. In that case, the userspace pt_regs must have |
| 149 | * been initialized (which kernel_execve takes care of, see start_thread |
| 150 | * below); ret_from_fork will then continue its execution causing the |
| 151 | * 'kernel thread' to return to userspace as a userspace thread. |
| 152 | */ |
| 153 | |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 154 | int |
| 155 | copy_thread(unsigned long clone_flags, unsigned long usp, |
Al Viro | afa86fc | 2012-10-22 22:51:14 -0400 | [diff] [blame] | 156 | unsigned long arg, struct task_struct *p) |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 157 | { |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 158 | struct pt_regs *userregs; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 159 | struct pt_regs *kregs; |
| 160 | unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 161 | unsigned long top_of_kernel_stack; |
| 162 | |
| 163 | top_of_kernel_stack = sp; |
| 164 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 165 | /* Locate userspace context on stack... */ |
| 166 | sp -= STACK_FRAME_OVERHEAD; /* redzone */ |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 167 | sp -= sizeof(struct pt_regs); |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 168 | userregs = (struct pt_regs *) sp; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 169 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 170 | /* ...and kernel context */ |
| 171 | sp -= STACK_FRAME_OVERHEAD; /* redzone */ |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 172 | sp -= sizeof(struct pt_regs); |
| 173 | kregs = (struct pt_regs *)sp; |
| 174 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 175 | if (unlikely(p->flags & PF_KTHREAD)) { |
| 176 | memset(kregs, 0, sizeof(struct pt_regs)); |
| 177 | kregs->gpr[20] = usp; /* fn, kernel thread */ |
| 178 | kregs->gpr[22] = arg; |
| 179 | } else { |
Al Viro | 39d91a9 | 2012-10-26 19:37:49 -0400 | [diff] [blame] | 180 | *userregs = *current_pt_regs(); |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 181 | |
Al Viro | 39d91a9 | 2012-10-26 19:37:49 -0400 | [diff] [blame] | 182 | if (usp) |
| 183 | userregs->sp = usp; |
Christian Svensson | e60aa2f | 2014-01-25 15:48:54 +0000 | [diff] [blame] | 184 | |
| 185 | /* |
| 186 | * For CLONE_SETTLS set "tp" (r10) to the TLS pointer passed to sys_clone. |
| 187 | * |
| 188 | * The kernel entry is: |
| 189 | * int clone (long flags, void *child_stack, int *parent_tid, |
| 190 | * int *child_tid, struct void *tls) |
| 191 | * |
| 192 | * This makes the source r7 in the kernel registers. |
| 193 | */ |
| 194 | if (clone_flags & CLONE_SETTLS) |
| 195 | userregs->gpr[10] = userregs->gpr[7]; |
| 196 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 197 | userregs->gpr[11] = 0; /* Result from fork() */ |
| 198 | |
| 199 | kregs->gpr[20] = 0; /* Userspace thread */ |
| 200 | } |
| 201 | |
| 202 | /* |
| 203 | * _switch wants the kernel stack page in pt_regs->sp so that it |
| 204 | * can restore it to thread_info->ksp... see _switch for details. |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 205 | */ |
| 206 | kregs->sp = top_of_kernel_stack; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 207 | kregs->gpr[9] = (unsigned long)ret_from_fork; |
| 208 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 209 | task_thread_info(p)->ksp = (unsigned long)kregs; |
| 210 | |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 211 | return 0; |
| 212 | } |
| 213 | |
| 214 | /* |
| 215 | * Set up a thread for executing a new program |
| 216 | */ |
| 217 | void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp) |
| 218 | { |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 219 | unsigned long sr = mfspr(SPR_SR) & ~SPR_SR_SM; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 220 | |
Jonas Bonn | cbf23cf | 2012-10-19 18:07:44 +0200 | [diff] [blame] | 221 | memset(regs, 0, sizeof(struct pt_regs)); |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 222 | |
| 223 | regs->pc = pc; |
| 224 | regs->sr = sr; |
| 225 | regs->sp = sp; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 226 | } |
| 227 | |
| 228 | /* Fill in the fpu structure for a core dump. */ |
| 229 | int dump_fpu(struct pt_regs *regs, elf_fpregset_t * fpu) |
| 230 | { |
| 231 | /* TODO */ |
| 232 | return 0; |
| 233 | } |
| 234 | |
| 235 | extern struct thread_info *_switch(struct thread_info *old_ti, |
| 236 | struct thread_info *new_ti); |
Stefan Kristiansson | 63104c0 | 2014-11-03 14:28:14 +0200 | [diff] [blame] | 237 | extern int lwa_flag; |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 238 | |
| 239 | struct task_struct *__switch_to(struct task_struct *old, |
| 240 | struct task_struct *new) |
| 241 | { |
| 242 | struct task_struct *last; |
| 243 | struct thread_info *new_ti, *old_ti; |
| 244 | unsigned long flags; |
| 245 | |
| 246 | local_irq_save(flags); |
| 247 | |
| 248 | /* current_set is an array of saved current pointers |
| 249 | * (one for each cpu). we need them at user->kernel transition, |
| 250 | * while we save them at kernel->user transition |
| 251 | */ |
| 252 | new_ti = new->stack; |
| 253 | old_ti = old->stack; |
| 254 | |
Stefan Kristiansson | 63104c0 | 2014-11-03 14:28:14 +0200 | [diff] [blame] | 255 | lwa_flag = 0; |
| 256 | |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 257 | current_thread_info_set[smp_processor_id()] = new_ti; |
| 258 | last = (_switch(old_ti, new_ti))->task; |
| 259 | |
| 260 | local_irq_restore(flags); |
| 261 | |
| 262 | return last; |
| 263 | } |
| 264 | |
| 265 | /* |
| 266 | * Write out registers in core dump format, as defined by the |
| 267 | * struct user_regs_struct |
| 268 | */ |
| 269 | void dump_elf_thread(elf_greg_t *dest, struct pt_regs* regs) |
| 270 | { |
| 271 | dest[0] = 0; /* r0 */ |
| 272 | memcpy(dest+1, regs->gpr+1, 31*sizeof(unsigned long)); |
| 273 | dest[32] = regs->pc; |
| 274 | dest[33] = regs->sr; |
| 275 | dest[34] = 0; |
| 276 | dest[35] = 0; |
| 277 | } |
| 278 | |
Jonas Bonn | 88ef7f3 | 2011-06-04 22:30:12 +0300 | [diff] [blame] | 279 | unsigned long get_wchan(struct task_struct *p) |
| 280 | { |
| 281 | /* TODO */ |
| 282 | |
| 283 | return 0; |
| 284 | } |