1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * OpenRISC process.c 4 * 5 * Linux architectural port borrowing liberally from similar works of 6 * others. All original copyrights apply as per the original source 7 * declaration. 8 * 9 * Modifications for the OpenRISC architecture: 10 * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com> 11 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se> 12 * 13 * This file handles the architecture-dependent parts of process handling... 14 */ 15 16 #define __KERNEL_SYSCALLS__ 17 #include <linux/cpu.h> 18 #include <linux/errno.h> 19 #include <linux/sched.h> 20 #include <linux/sched/debug.h> 21 #include <linux/sched/task.h> 22 #include <linux/sched/task_stack.h> 23 #include <linux/kernel.h> 24 #include <linux/export.h> 25 #include <linux/mm.h> 26 #include <linux/stddef.h> 27 #include <linux/unistd.h> 28 #include <linux/ptrace.h> 29 #include <linux/slab.h> 30 #include <linux/elfcore.h> 31 #include <linux/interrupt.h> 32 #include <linux/delay.h> 33 #include <linux/init_task.h> 34 #include <linux/mqueue.h> 35 #include <linux/fs.h> 36 #include <linux/reboot.h> 37 38 #include <linux/uaccess.h> 39 #include <asm/fpu.h> 40 #include <asm/io.h> 41 #include <asm/processor.h> 42 #include <asm/spr_defs.h> 43 #include <asm/switch_to.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(char *cmd) 55 { 56 do_kernel_restart(cmd); 57 58 __asm__("l.nop 13"); 59 60 /* Give a grace period for failure to restart of 1s */ 61 mdelay(1000); 62 63 /* Whoops - the platform was unable to reboot. Tell the user! */ 64 pr_emerg("Reboot failed -- System halted\n"); 65 while (1); 66 } 67 68 /* 69 * This is used if a sys-off handler was not set by a power management 70 * driver, in this case we can assume we are on a simulator. On 71 * OpenRISC simulators l.nop 1 will trigger the simulator exit. 72 */ 73 static void default_power_off(void) 74 { 75 __asm__("l.nop 1"); 76 } 77 78 /* 79 * Similar to machine_power_off, but don't shut off power. Add code 80 * here to freeze the system for e.g. post-mortem debug purpose when 81 * possible. This halt has nothing to do with the idle halt. 82 */ 83 void machine_halt(void) 84 { 85 printk(KERN_INFO "*** MACHINE HALT ***\n"); 86 __asm__("l.nop 1"); 87 } 88 89 /* If or when software power-off is implemented, add code here. */ 90 void machine_power_off(void) 91 { 92 printk(KERN_INFO "*** MACHINE POWER OFF ***\n"); 93 do_kernel_power_off(); 94 default_power_off(); 95 } 96 97 /* 98 * Send the doze signal to the cpu if available. 99 * Make sure, that all interrupts are enabled 100 */ 101 void arch_cpu_idle(void) 102 { 103 raw_local_irq_enable(); 104 if (mfspr(SPR_UPR) & SPR_UPR_PMP) 105 mtspr(SPR_PMR, mfspr(SPR_PMR) | SPR_PMR_DME); 106 raw_local_irq_disable(); 107 } 108 109 void (*pm_power_off)(void) = NULL; 110 EXPORT_SYMBOL(pm_power_off); 111 112 /* 113 * When a process does an "exec", machine state like FPU and debug 114 * registers need to be reset. This is a hook function for that. 115 * Currently we don't have any such state to reset, so this is empty. 116 */ 117 void flush_thread(void) 118 { 119 } 120 121 void show_regs(struct pt_regs *regs) 122 { 123 show_regs_print_info(KERN_DEFAULT); 124 /* __PHX__ cleanup this mess */ 125 show_registers(regs); 126 } 127 128 /* 129 * Copy the thread-specific (arch specific) info from the current 130 * process to the new one p 131 */ 132 extern asmlinkage void ret_from_fork(void); 133 134 /* 135 * copy_thread 136 * @clone_flags: flags 137 * @usp: user stack pointer or fn for kernel thread 138 * @arg: arg to fn for kernel thread; always NULL for userspace thread 139 * @p: the newly created task 140 * @tls: the Thread Local Storage pointer for the new process 141 * 142 * At the top of a newly initialized kernel stack are two stacked pt_reg 143 * structures. The first (topmost) is the userspace context of the thread. 144 * The second is the kernelspace context of the thread. 145 * 146 * A kernel thread will not be returning to userspace, so the topmost pt_regs 147 * struct can be uninitialized; it _does_ need to exist, though, because 148 * a kernel thread can become a userspace thread by doing a kernel_execve, in 149 * which case the topmost context will be initialized and used for 'returning' 150 * to userspace. 151 * 152 * The second pt_reg struct needs to be initialized to 'return' to 153 * ret_from_fork. A kernel thread will need to set r20 to the address of 154 * a function to call into (with arg in r22); userspace threads need to set 155 * r20 to NULL in which case ret_from_fork will just continue a return to 156 * userspace. 157 * 158 * A kernel thread 'fn' may return; this is effectively what happens when 159 * kernel_execve is called. In that case, the userspace pt_regs must have 160 * been initialized (which kernel_execve takes care of, see start_thread 161 * below); ret_from_fork will then continue its execution causing the 162 * 'kernel thread' to return to userspace as a userspace thread. 163 */ 164 165 int 166 copy_thread(struct task_struct *p, const struct kernel_clone_args *args) 167 { 168 unsigned long clone_flags = args->flags; 169 unsigned long usp = args->stack; 170 unsigned long tls = args->tls; 171 struct pt_regs *userregs; 172 struct pt_regs *kregs; 173 unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE; 174 unsigned long top_of_kernel_stack; 175 176 top_of_kernel_stack = sp; 177 178 /* Locate userspace context on stack... */ 179 sp -= STACK_FRAME_OVERHEAD; /* redzone */ 180 sp -= sizeof(struct pt_regs); 181 userregs = (struct pt_regs *) sp; 182 183 /* ...and kernel context */ 184 sp -= STACK_FRAME_OVERHEAD; /* redzone */ 185 sp -= sizeof(struct pt_regs); 186 kregs = (struct pt_regs *)sp; 187 188 if (unlikely(args->fn)) { 189 memset(kregs, 0, sizeof(struct pt_regs)); 190 kregs->gpr[20] = (unsigned long)args->fn; 191 kregs->gpr[22] = (unsigned long)args->fn_arg; 192 } else { 193 *userregs = *current_pt_regs(); 194 195 if (usp) 196 userregs->sp = usp; 197 198 /* 199 * For CLONE_SETTLS set "tp" (r10) to the TLS pointer. 200 */ 201 if (clone_flags & CLONE_SETTLS) 202 userregs->gpr[10] = tls; 203 204 userregs->gpr[11] = 0; /* Result from fork() */ 205 206 kregs->gpr[20] = 0; /* Userspace thread */ 207 } 208 209 /* 210 * _switch wants the kernel stack page in pt_regs->sp so that it 211 * can restore it to thread_info->ksp... see _switch for details. 212 */ 213 kregs->sp = top_of_kernel_stack; 214 kregs->gpr[9] = (unsigned long)ret_from_fork; 215 216 task_thread_info(p)->ksp = (unsigned long)kregs; 217 218 return 0; 219 } 220 221 /* 222 * Set up a thread for executing a new program 223 */ 224 void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp) 225 { 226 unsigned long sr = mfspr(SPR_SR) & ~SPR_SR_SM; 227 228 memset(regs, 0, sizeof(struct pt_regs)); 229 230 regs->pc = pc; 231 regs->sr = sr; 232 regs->sp = sp; 233 } 234 235 extern struct thread_info *_switch(struct thread_info *old_ti, 236 struct thread_info *new_ti); 237 extern int lwa_flag; 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 save_fpu(current); 249 250 /* current_set is an array of saved current pointers 251 * (one for each cpu). we need them at user->kernel transition, 252 * while we save them at kernel->user transition 253 */ 254 new_ti = new->stack; 255 old_ti = old->stack; 256 257 lwa_flag = 0; 258 259 current_thread_info_set[smp_processor_id()] = new_ti; 260 last = (_switch(old_ti, new_ti))->task; 261 262 restore_fpu(current); 263 264 local_irq_restore(flags); 265 266 return last; 267 } 268 269 /* 270 * Write out registers in core dump format, as defined by the 271 * struct user_regs_struct 272 */ 273 void dump_elf_thread(elf_greg_t *dest, struct pt_regs* regs) 274 { 275 dest[0] = 0; /* r0 */ 276 memcpy(dest+1, regs->gpr+1, 31*sizeof(unsigned long)); 277 dest[32] = regs->pc; 278 dest[33] = regs->sr; 279 dest[34] = 0; 280 dest[35] = 0; 281 } 282 283 unsigned long __get_wchan(struct task_struct *p) 284 { 285 /* TODO */ 286 287 return 0; 288 } 289