David S. Miller | 64d329e | 2007-10-27 00:17:01 -0700 | [diff] [blame] | 1 | /* linux/arch/sparc/kernel/process.c |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * |
David S. Miller | 4fe3ebe | 2008-07-17 22:11:32 -0700 | [diff] [blame] | 3 | * Copyright (C) 1995, 2008 David S. Miller (davem@davemloft.net) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be) |
| 5 | */ |
| 6 | |
| 7 | /* |
| 8 | * This file handles the architecture-dependent parts of process handling.. |
| 9 | */ |
| 10 | |
| 11 | #include <stdarg.h> |
| 12 | |
| 13 | #include <linux/errno.h> |
| 14 | #include <linux/module.h> |
| 15 | #include <linux/sched.h> |
| 16 | #include <linux/kernel.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #include <linux/mm.h> |
| 18 | #include <linux/stddef.h> |
| 19 | #include <linux/ptrace.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/user.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | #include <linux/smp.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #include <linux/reboot.h> |
| 23 | #include <linux/delay.h> |
| 24 | #include <linux/pm.h> |
| 25 | #include <linux/init.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 26 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | |
| 28 | #include <asm/auxio.h> |
| 29 | #include <asm/oplib.h> |
| 30 | #include <asm/uaccess.h> |
| 31 | #include <asm/system.h> |
| 32 | #include <asm/page.h> |
| 33 | #include <asm/pgalloc.h> |
| 34 | #include <asm/pgtable.h> |
| 35 | #include <asm/delay.h> |
| 36 | #include <asm/processor.h> |
| 37 | #include <asm/psr.h> |
| 38 | #include <asm/elf.h> |
David S. Miller | c73fcc8 | 2007-07-20 16:59:26 -0700 | [diff] [blame] | 39 | #include <asm/prom.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | #include <asm/unistd.h> |
| 41 | |
| 42 | /* |
| 43 | * Power management idle function |
| 44 | * Set in pm platform drivers (apc.c and pmc.c) |
| 45 | */ |
| 46 | void (*pm_idle)(void); |
Sam Ravnborg | 6943f3d | 2009-01-08 16:58:05 -0800 | [diff] [blame] | 47 | EXPORT_SYMBOL(pm_idle); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | |
| 49 | /* |
| 50 | * Power-off handler instantiation for pm.h compliance |
| 51 | * This is done via auxio, but could be used as a fallback |
| 52 | * handler when auxio is not present-- unused for now... |
| 53 | */ |
Al Viro | 304cd3e | 2006-01-18 19:40:48 -0500 | [diff] [blame] | 54 | void (*pm_power_off)(void) = machine_power_off; |
Al Viro | 89eb169 | 2007-01-30 13:23:25 +0000 | [diff] [blame] | 55 | EXPORT_SYMBOL(pm_power_off); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | |
| 57 | /* |
| 58 | * sysctl - toggle power-off restriction for serial console |
| 59 | * systems in machine_power_off() |
| 60 | */ |
| 61 | int scons_pwroff = 1; |
| 62 | |
| 63 | extern void fpsave(unsigned long *, unsigned long *, void *, unsigned long *); |
| 64 | |
| 65 | struct task_struct *last_task_used_math = NULL; |
| 66 | struct thread_info *current_set[NR_CPUS]; |
| 67 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | #ifndef CONFIG_SMP |
| 69 | |
| 70 | #define SUN4C_FAULT_HIGH 100 |
| 71 | |
| 72 | /* |
| 73 | * the idle loop on a Sparc... ;) |
| 74 | */ |
| 75 | void cpu_idle(void) |
| 76 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | /* endless idle loop with no priority at all */ |
| 78 | for (;;) { |
Adrian Bunk | 5110bd2 | 2008-08-31 20:59:37 -0700 | [diff] [blame] | 79 | if (ARCH_SUN4C) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | static int count = HZ; |
| 81 | static unsigned long last_jiffies; |
| 82 | static unsigned long last_faults; |
| 83 | static unsigned long fps; |
| 84 | unsigned long now; |
| 85 | unsigned long faults; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | |
| 87 | extern unsigned long sun4c_kernel_faults; |
| 88 | extern void sun4c_grow_kernel_ring(void); |
| 89 | |
Nick Piggin | 64c7c8f | 2005-11-08 21:39:04 -0800 | [diff] [blame] | 90 | local_irq_disable(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | now = jiffies; |
| 92 | count -= (now - last_jiffies); |
| 93 | last_jiffies = now; |
| 94 | if (count < 0) { |
| 95 | count += HZ; |
| 96 | faults = sun4c_kernel_faults; |
| 97 | fps = (fps + (faults - last_faults)) >> 1; |
| 98 | last_faults = faults; |
| 99 | #if 0 |
| 100 | printk("kernel faults / second = %ld\n", fps); |
| 101 | #endif |
| 102 | if (fps >= SUN4C_FAULT_HIGH) { |
| 103 | sun4c_grow_kernel_ring(); |
| 104 | } |
| 105 | } |
Nick Piggin | 64c7c8f | 2005-11-08 21:39:04 -0800 | [diff] [blame] | 106 | local_irq_enable(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | } |
| 108 | |
Nick Piggin | 64c7c8f | 2005-11-08 21:39:04 -0800 | [diff] [blame] | 109 | if (pm_idle) { |
| 110 | while (!need_resched()) |
| 111 | (*pm_idle)(); |
| 112 | } else { |
| 113 | while (!need_resched()) |
| 114 | cpu_relax(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | } |
Thomas Gleixner | bd2f553 | 2011-03-21 12:33:18 +0100 | [diff] [blame^] | 116 | schedule_preempt_disabled(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | check_pgt_cache(); |
| 118 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | } |
| 120 | |
| 121 | #else |
| 122 | |
| 123 | /* This is being executed in task 0 'user space'. */ |
| 124 | void cpu_idle(void) |
| 125 | { |
Nick Piggin | 64c7c8f | 2005-11-08 21:39:04 -0800 | [diff] [blame] | 126 | set_thread_flag(TIF_POLLING_NRFLAG); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | /* endless idle loop with no priority at all */ |
| 128 | while(1) { |
Daniel Hellstrom | 2645e72 | 2011-04-25 21:48:17 +0000 | [diff] [blame] | 129 | #ifdef CONFIG_SPARC_LEON |
| 130 | if (pm_idle) { |
| 131 | while (!need_resched()) |
| 132 | (*pm_idle)(); |
| 133 | } else |
| 134 | #endif |
| 135 | { |
| 136 | while (!need_resched()) |
| 137 | cpu_relax(); |
| 138 | } |
Thomas Gleixner | bd2f553 | 2011-03-21 12:33:18 +0100 | [diff] [blame^] | 139 | schedule_preempt_disabled(); |
Nick Piggin | 64c7c8f | 2005-11-08 21:39:04 -0800 | [diff] [blame] | 140 | check_pgt_cache(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | } |
| 142 | } |
| 143 | |
| 144 | #endif |
| 145 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | /* XXX cli/sti -> local_irq_xxx here, check this works once SMP is fixed. */ |
| 147 | void machine_halt(void) |
| 148 | { |
| 149 | local_irq_enable(); |
| 150 | mdelay(8); |
| 151 | local_irq_disable(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | prom_halt(); |
| 153 | panic("Halt failed!"); |
| 154 | } |
| 155 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | void machine_restart(char * cmd) |
| 157 | { |
| 158 | char *p; |
| 159 | |
| 160 | local_irq_enable(); |
| 161 | mdelay(8); |
| 162 | local_irq_disable(); |
| 163 | |
| 164 | p = strchr (reboot_command, '\n'); |
| 165 | if (p) *p = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | if (cmd) |
| 167 | prom_reboot(cmd); |
| 168 | if (*reboot_command) |
| 169 | prom_reboot(reboot_command); |
| 170 | prom_feval ("reset"); |
| 171 | panic("Reboot failed!"); |
| 172 | } |
| 173 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | void machine_power_off(void) |
| 175 | { |
David S. Miller | c73fcc8 | 2007-07-20 16:59:26 -0700 | [diff] [blame] | 176 | if (auxio_power_register && |
| 177 | (strcmp(of_console_device->type, "serial") || scons_pwroff)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | *auxio_power_register |= AUXIO_POWER_OFF; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | machine_halt(); |
| 180 | } |
| 181 | |
Adrian Bunk | c61c65c | 2008-06-05 11:40:58 -0700 | [diff] [blame] | 182 | #if 0 |
| 183 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | static DEFINE_SPINLOCK(sparc_backtrace_lock); |
| 185 | |
| 186 | void __show_backtrace(unsigned long fp) |
| 187 | { |
Sam Ravnborg | 4d7b92a | 2009-01-02 19:32:59 -0800 | [diff] [blame] | 188 | struct reg_window32 *rw; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | unsigned long flags; |
| 190 | int cpu = smp_processor_id(); |
| 191 | |
| 192 | spin_lock_irqsave(&sparc_backtrace_lock, flags); |
| 193 | |
Sam Ravnborg | 4d7b92a | 2009-01-02 19:32:59 -0800 | [diff] [blame] | 194 | rw = (struct reg_window32 *)fp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | while(rw && (((unsigned long) rw) >= PAGE_OFFSET) && |
| 196 | !(((unsigned long) rw) & 0x7)) { |
| 197 | printk("CPU[%d]: ARGS[%08lx,%08lx,%08lx,%08lx,%08lx,%08lx] " |
| 198 | "FP[%08lx] CALLER[%08lx]: ", cpu, |
| 199 | rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3], |
| 200 | rw->ins[4], rw->ins[5], |
| 201 | rw->ins[6], |
| 202 | rw->ins[7]); |
David S. Miller | 4fe3ebe | 2008-07-17 22:11:32 -0700 | [diff] [blame] | 203 | printk("%pS\n", (void *) rw->ins[7]); |
Sam Ravnborg | 4d7b92a | 2009-01-02 19:32:59 -0800 | [diff] [blame] | 204 | rw = (struct reg_window32 *) rw->ins[6]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | } |
| 206 | spin_unlock_irqrestore(&sparc_backtrace_lock, flags); |
| 207 | } |
| 208 | |
| 209 | #define __SAVE __asm__ __volatile__("save %sp, -0x40, %sp\n\t") |
| 210 | #define __RESTORE __asm__ __volatile__("restore %g0, %g0, %g0\n\t") |
| 211 | #define __GET_FP(fp) __asm__ __volatile__("mov %%i6, %0" : "=r" (fp)) |
| 212 | |
| 213 | void show_backtrace(void) |
| 214 | { |
| 215 | unsigned long fp; |
| 216 | |
| 217 | __SAVE; __SAVE; __SAVE; __SAVE; |
| 218 | __SAVE; __SAVE; __SAVE; __SAVE; |
| 219 | __RESTORE; __RESTORE; __RESTORE; __RESTORE; |
| 220 | __RESTORE; __RESTORE; __RESTORE; __RESTORE; |
| 221 | |
| 222 | __GET_FP(fp); |
| 223 | |
| 224 | __show_backtrace(fp); |
| 225 | } |
| 226 | |
| 227 | #ifdef CONFIG_SMP |
| 228 | void smp_show_backtrace_all_cpus(void) |
| 229 | { |
| 230 | xc0((smpfunc_t) show_backtrace); |
| 231 | show_backtrace(); |
| 232 | } |
| 233 | #endif |
| 234 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | void show_stackframe(struct sparc_stackf *sf) |
| 236 | { |
| 237 | unsigned long size; |
| 238 | unsigned long *stk; |
| 239 | int i; |
| 240 | |
| 241 | printk("l0: %08lx l1: %08lx l2: %08lx l3: %08lx " |
| 242 | "l4: %08lx l5: %08lx l6: %08lx l7: %08lx\n", |
| 243 | sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3], |
| 244 | sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]); |
| 245 | printk("i0: %08lx i1: %08lx i2: %08lx i3: %08lx " |
| 246 | "i4: %08lx i5: %08lx fp: %08lx i7: %08lx\n", |
| 247 | sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3], |
| 248 | sf->ins[4], sf->ins[5], (unsigned long)sf->fp, sf->callers_pc); |
| 249 | printk("sp: %08lx x0: %08lx x1: %08lx x2: %08lx " |
| 250 | "x3: %08lx x4: %08lx x5: %08lx xx: %08lx\n", |
| 251 | (unsigned long)sf->structptr, sf->xargs[0], sf->xargs[1], |
| 252 | sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5], |
| 253 | sf->xxargs[0]); |
| 254 | size = ((unsigned long)sf->fp) - ((unsigned long)sf); |
| 255 | size -= STACKFRAME_SZ; |
| 256 | stk = (unsigned long *)((unsigned long)sf + STACKFRAME_SZ); |
| 257 | i = 0; |
| 258 | do { |
| 259 | printk("s%d: %08lx\n", i++, *stk++); |
| 260 | } while ((size -= sizeof(unsigned long))); |
| 261 | } |
| 262 | #endif |
| 263 | |
| 264 | void show_regs(struct pt_regs *r) |
| 265 | { |
Sam Ravnborg | 4d7b92a | 2009-01-02 19:32:59 -0800 | [diff] [blame] | 266 | struct reg_window32 *rw = (struct reg_window32 *) r->u_regs[14]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 267 | |
| 268 | printk("PSR: %08lx PC: %08lx NPC: %08lx Y: %08lx %s\n", |
| 269 | r->psr, r->pc, r->npc, r->y, print_tainted()); |
David S. Miller | 4fe3ebe | 2008-07-17 22:11:32 -0700 | [diff] [blame] | 270 | printk("PC: <%pS>\n", (void *) r->pc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | printk("%%G: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", |
| 272 | r->u_regs[0], r->u_regs[1], r->u_regs[2], r->u_regs[3], |
| 273 | r->u_regs[4], r->u_regs[5], r->u_regs[6], r->u_regs[7]); |
| 274 | printk("%%O: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", |
| 275 | r->u_regs[8], r->u_regs[9], r->u_regs[10], r->u_regs[11], |
| 276 | r->u_regs[12], r->u_regs[13], r->u_regs[14], r->u_regs[15]); |
David S. Miller | 4fe3ebe | 2008-07-17 22:11:32 -0700 | [diff] [blame] | 277 | printk("RPC: <%pS>\n", (void *) r->u_regs[15]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | |
| 279 | printk("%%L: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", |
| 280 | rw->locals[0], rw->locals[1], rw->locals[2], rw->locals[3], |
| 281 | rw->locals[4], rw->locals[5], rw->locals[6], rw->locals[7]); |
| 282 | printk("%%I: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", |
| 283 | rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3], |
| 284 | rw->ins[4], rw->ins[5], rw->ins[6], rw->ins[7]); |
| 285 | } |
| 286 | |
| 287 | /* |
| 288 | * The show_stack is an external API which we do not use ourselves. |
| 289 | * The oops is printed in die_if_kernel. |
| 290 | */ |
| 291 | void show_stack(struct task_struct *tsk, unsigned long *_ksp) |
| 292 | { |
| 293 | unsigned long pc, fp; |
| 294 | unsigned long task_base; |
Sam Ravnborg | 4d7b92a | 2009-01-02 19:32:59 -0800 | [diff] [blame] | 295 | struct reg_window32 *rw; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | int count = 0; |
| 297 | |
| 298 | if (tsk != NULL) |
Al Viro | 36483c6 | 2006-01-12 01:05:47 -0800 | [diff] [blame] | 299 | task_base = (unsigned long) task_stack_page(tsk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | else |
| 301 | task_base = (unsigned long) current_thread_info(); |
| 302 | |
| 303 | fp = (unsigned long) _ksp; |
| 304 | do { |
| 305 | /* Bogus frame pointer? */ |
| 306 | if (fp < (task_base + sizeof(struct thread_info)) || |
| 307 | fp >= (task_base + (PAGE_SIZE << 1))) |
| 308 | break; |
Sam Ravnborg | 4d7b92a | 2009-01-02 19:32:59 -0800 | [diff] [blame] | 309 | rw = (struct reg_window32 *) fp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 310 | pc = rw->ins[7]; |
| 311 | printk("[%08lx : ", pc); |
David S. Miller | 4fe3ebe | 2008-07-17 22:11:32 -0700 | [diff] [blame] | 312 | printk("%pS ] ", (void *) pc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 313 | fp = rw->ins[6]; |
| 314 | } while (++count < 16); |
| 315 | printk("\n"); |
| 316 | } |
| 317 | |
Tom 'spot' Callaway | 24dc6ea | 2005-04-24 20:46:49 -0700 | [diff] [blame] | 318 | void dump_stack(void) |
| 319 | { |
| 320 | unsigned long *ksp; |
| 321 | |
| 322 | __asm__ __volatile__("mov %%fp, %0" |
| 323 | : "=r" (ksp)); |
| 324 | show_stack(current, ksp); |
| 325 | } |
| 326 | |
| 327 | EXPORT_SYMBOL(dump_stack); |
| 328 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | /* |
| 330 | * Note: sparc64 has a pretty intricated thread_saved_pc, check it out. |
| 331 | */ |
| 332 | unsigned long thread_saved_pc(struct task_struct *tsk) |
| 333 | { |
Al Viro | d562ef6 | 2006-01-12 01:05:46 -0800 | [diff] [blame] | 334 | return task_thread_info(tsk)->kpc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | } |
| 336 | |
| 337 | /* |
| 338 | * Free current thread data structures etc.. |
| 339 | */ |
| 340 | void exit_thread(void) |
| 341 | { |
| 342 | #ifndef CONFIG_SMP |
| 343 | if(last_task_used_math == current) { |
| 344 | #else |
William Lee Irwin III | 54f565e | 2007-03-12 17:08:25 -0700 | [diff] [blame] | 345 | if (test_thread_flag(TIF_USEDFPU)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 346 | #endif |
| 347 | /* Keep process from leaving FPU in a bogon state. */ |
| 348 | put_psr(get_psr() | PSR_EF); |
| 349 | fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr, |
| 350 | ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth); |
| 351 | #ifndef CONFIG_SMP |
| 352 | last_task_used_math = NULL; |
| 353 | #else |
William Lee Irwin III | 54f565e | 2007-03-12 17:08:25 -0700 | [diff] [blame] | 354 | clear_thread_flag(TIF_USEDFPU); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | #endif |
| 356 | } |
| 357 | } |
| 358 | |
| 359 | void flush_thread(void) |
| 360 | { |
| 361 | current_thread_info()->w_saved = 0; |
| 362 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 363 | #ifndef CONFIG_SMP |
| 364 | if(last_task_used_math == current) { |
| 365 | #else |
William Lee Irwin III | 54f565e | 2007-03-12 17:08:25 -0700 | [diff] [blame] | 366 | if (test_thread_flag(TIF_USEDFPU)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 367 | #endif |
| 368 | /* Clean the fpu. */ |
| 369 | put_psr(get_psr() | PSR_EF); |
| 370 | fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr, |
| 371 | ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth); |
| 372 | #ifndef CONFIG_SMP |
| 373 | last_task_used_math = NULL; |
| 374 | #else |
William Lee Irwin III | 54f565e | 2007-03-12 17:08:25 -0700 | [diff] [blame] | 375 | clear_thread_flag(TIF_USEDFPU); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | #endif |
| 377 | } |
| 378 | |
Mathias Krause | ddd53bf | 2011-09-20 14:22:59 -0700 | [diff] [blame] | 379 | /* This task is no longer a kernel thread. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 380 | if (current->thread.flags & SPARC_FLAG_KTHREAD) { |
| 381 | current->thread.flags &= ~SPARC_FLAG_KTHREAD; |
| 382 | |
| 383 | /* We must fixup kregs as well. */ |
| 384 | /* XXX This was not fixed for ti for a while, worked. Unused? */ |
| 385 | current->thread.kregs = (struct pt_regs *) |
Al Viro | 36483c6 | 2006-01-12 01:05:47 -0800 | [diff] [blame] | 386 | (task_stack_page(current) + (THREAD_SIZE - TRACEREG_SZ)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | } |
| 388 | } |
| 389 | |
David S. Miller | 64d329e | 2007-10-27 00:17:01 -0700 | [diff] [blame] | 390 | static inline struct sparc_stackf __user * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | clone_stackframe(struct sparc_stackf __user *dst, |
| 392 | struct sparc_stackf __user *src) |
| 393 | { |
| 394 | unsigned long size, fp; |
| 395 | struct sparc_stackf *tmp; |
| 396 | struct sparc_stackf __user *sp; |
| 397 | |
| 398 | if (get_user(tmp, &src->fp)) |
| 399 | return NULL; |
| 400 | |
| 401 | fp = (unsigned long) tmp; |
| 402 | size = (fp - ((unsigned long) src)); |
| 403 | fp = (unsigned long) dst; |
| 404 | sp = (struct sparc_stackf __user *)(fp - size); |
| 405 | |
| 406 | /* do_fork() grabs the parent semaphore, we must release it |
| 407 | * temporarily so we can build the child clone stack frame |
| 408 | * without deadlocking. |
| 409 | */ |
| 410 | if (__copy_user(sp, src, size)) |
| 411 | sp = NULL; |
| 412 | else if (put_user(fp, &sp->fp)) |
| 413 | sp = NULL; |
| 414 | |
| 415 | return sp; |
| 416 | } |
| 417 | |
| 418 | asmlinkage int sparc_do_fork(unsigned long clone_flags, |
| 419 | unsigned long stack_start, |
| 420 | struct pt_regs *regs, |
| 421 | unsigned long stack_size) |
| 422 | { |
| 423 | unsigned long parent_tid_ptr, child_tid_ptr; |
David S. Miller | 1e38c12 | 2008-05-07 16:21:28 -0700 | [diff] [blame] | 424 | unsigned long orig_i1 = regs->u_regs[UREG_I1]; |
| 425 | long ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 426 | |
| 427 | parent_tid_ptr = regs->u_regs[UREG_I2]; |
| 428 | child_tid_ptr = regs->u_regs[UREG_I4]; |
| 429 | |
David S. Miller | 1e38c12 | 2008-05-07 16:21:28 -0700 | [diff] [blame] | 430 | ret = do_fork(clone_flags, stack_start, |
| 431 | regs, stack_size, |
| 432 | (int __user *) parent_tid_ptr, |
| 433 | (int __user *) child_tid_ptr); |
| 434 | |
| 435 | /* If we get an error and potentially restart the system |
| 436 | * call, we're screwed because copy_thread() clobbered |
| 437 | * the parent's %o1. So detect that case and restore it |
| 438 | * here. |
| 439 | */ |
| 440 | if ((unsigned long)ret >= -ERESTART_RESTARTBLOCK) |
| 441 | regs->u_regs[UREG_I1] = orig_i1; |
| 442 | |
| 443 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 444 | } |
| 445 | |
| 446 | /* Copy a Sparc thread. The fork() return value conventions |
| 447 | * under SunOS are nothing short of bletcherous: |
| 448 | * Parent --> %o0 == childs pid, %o1 == 0 |
| 449 | * Child --> %o0 == parents pid, %o1 == 1 |
| 450 | * |
| 451 | * NOTE: We have a separate fork kpsr/kwim because |
| 452 | * the parent could change these values between |
| 453 | * sys_fork invocation and when we reach here |
| 454 | * if the parent should sleep while trying to |
| 455 | * allocate the task_struct and kernel stack in |
| 456 | * do_fork(). |
| 457 | * XXX See comment above sys_vfork in sparc64. todo. |
| 458 | */ |
| 459 | extern void ret_from_fork(void); |
| 460 | |
Alexey Dobriyan | 6f2c55b | 2009-04-02 16:56:59 -0700 | [diff] [blame] | 461 | int copy_thread(unsigned long clone_flags, unsigned long sp, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 462 | unsigned long unused, |
| 463 | struct task_struct *p, struct pt_regs *regs) |
| 464 | { |
Al Viro | 36483c6 | 2006-01-12 01:05:47 -0800 | [diff] [blame] | 465 | struct thread_info *ti = task_thread_info(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 466 | struct pt_regs *childregs; |
| 467 | char *new_stack; |
| 468 | |
| 469 | #ifndef CONFIG_SMP |
| 470 | if(last_task_used_math == current) { |
| 471 | #else |
William Lee Irwin III | 54f565e | 2007-03-12 17:08:25 -0700 | [diff] [blame] | 472 | if (test_thread_flag(TIF_USEDFPU)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 473 | #endif |
| 474 | put_psr(get_psr() | PSR_EF); |
| 475 | fpsave(&p->thread.float_regs[0], &p->thread.fsr, |
| 476 | &p->thread.fpqueue[0], &p->thread.fpqdepth); |
| 477 | #ifdef CONFIG_SMP |
William Lee Irwin III | 54f565e | 2007-03-12 17:08:25 -0700 | [diff] [blame] | 478 | clear_thread_flag(TIF_USEDFPU); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 479 | #endif |
| 480 | } |
| 481 | |
| 482 | /* |
| 483 | * p->thread_info new_stack childregs |
| 484 | * ! ! ! {if(PSR_PS) } |
| 485 | * V V (stk.fr.) V (pt_regs) { (stk.fr.) } |
| 486 | * +----- - - - - - ------+===========+============={+==========}+ |
| 487 | */ |
Al Viro | 36483c6 | 2006-01-12 01:05:47 -0800 | [diff] [blame] | 488 | new_stack = task_stack_page(p) + THREAD_SIZE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 489 | if (regs->psr & PSR_PS) |
| 490 | new_stack -= STACKFRAME_SZ; |
| 491 | new_stack -= STACKFRAME_SZ + TRACEREG_SZ; |
| 492 | memcpy(new_stack, (char *)regs - STACKFRAME_SZ, STACKFRAME_SZ + TRACEREG_SZ); |
| 493 | childregs = (struct pt_regs *) (new_stack + STACKFRAME_SZ); |
| 494 | |
| 495 | /* |
| 496 | * A new process must start with interrupts closed in 2.5, |
| 497 | * because this is how Mingo's scheduler works (see schedule_tail |
| 498 | * and finish_arch_switch). If we do not do it, a timer interrupt hits |
| 499 | * before we unlock, attempts to re-take the rq->lock, and then we die. |
| 500 | * Thus, kpsr|=PSR_PIL. |
| 501 | */ |
| 502 | ti->ksp = (unsigned long) new_stack; |
| 503 | ti->kpc = (((unsigned long) ret_from_fork) - 0x8); |
| 504 | ti->kpsr = current->thread.fork_kpsr | PSR_PIL; |
| 505 | ti->kwim = current->thread.fork_kwim; |
| 506 | |
| 507 | if(regs->psr & PSR_PS) { |
| 508 | extern struct pt_regs fake_swapper_regs; |
| 509 | |
| 510 | p->thread.kregs = &fake_swapper_regs; |
| 511 | new_stack += STACKFRAME_SZ + TRACEREG_SZ; |
| 512 | childregs->u_regs[UREG_FP] = (unsigned long) new_stack; |
| 513 | p->thread.flags |= SPARC_FLAG_KTHREAD; |
| 514 | p->thread.current_ds = KERNEL_DS; |
| 515 | memcpy(new_stack, (void *)regs->u_regs[UREG_FP], STACKFRAME_SZ); |
| 516 | childregs->u_regs[UREG_G6] = (unsigned long) ti; |
| 517 | } else { |
| 518 | p->thread.kregs = childregs; |
| 519 | childregs->u_regs[UREG_FP] = sp; |
| 520 | p->thread.flags &= ~SPARC_FLAG_KTHREAD; |
| 521 | p->thread.current_ds = USER_DS; |
| 522 | |
| 523 | if (sp != regs->u_regs[UREG_FP]) { |
| 524 | struct sparc_stackf __user *childstack; |
| 525 | struct sparc_stackf __user *parentstack; |
| 526 | |
| 527 | /* |
| 528 | * This is a clone() call with supplied user stack. |
| 529 | * Set some valid stack frames to give to the child. |
| 530 | */ |
| 531 | childstack = (struct sparc_stackf __user *) |
David S. Miller | 440ab7a | 2010-02-11 12:29:16 -0800 | [diff] [blame] | 532 | (sp & ~0xfUL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 533 | parentstack = (struct sparc_stackf __user *) |
| 534 | regs->u_regs[UREG_FP]; |
| 535 | |
| 536 | #if 0 |
| 537 | printk("clone: parent stack:\n"); |
| 538 | show_stackframe(parentstack); |
| 539 | #endif |
| 540 | |
| 541 | childstack = clone_stackframe(childstack, parentstack); |
| 542 | if (!childstack) |
| 543 | return -EFAULT; |
| 544 | |
| 545 | #if 0 |
| 546 | printk("clone: child stack:\n"); |
| 547 | show_stackframe(childstack); |
| 548 | #endif |
| 549 | |
| 550 | childregs->u_regs[UREG_FP] = (unsigned long)childstack; |
| 551 | } |
| 552 | } |
| 553 | |
| 554 | #ifdef CONFIG_SMP |
| 555 | /* FPU must be disabled on SMP. */ |
| 556 | childregs->psr &= ~PSR_EF; |
| 557 | #endif |
| 558 | |
| 559 | /* Set the return value for the child. */ |
| 560 | childregs->u_regs[UREG_I0] = current->pid; |
| 561 | childregs->u_regs[UREG_I1] = 1; |
| 562 | |
| 563 | /* Set the return value for the parent. */ |
| 564 | regs->u_regs[UREG_I1] = 0; |
| 565 | |
| 566 | if (clone_flags & CLONE_SETTLS) |
| 567 | childregs->u_regs[UREG_G7] = regs->u_regs[UREG_I3]; |
| 568 | |
| 569 | return 0; |
| 570 | } |
| 571 | |
| 572 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 573 | * fill in the fpu structure for a core dump. |
| 574 | */ |
| 575 | int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs) |
| 576 | { |
| 577 | if (used_math()) { |
| 578 | memset(fpregs, 0, sizeof(*fpregs)); |
| 579 | fpregs->pr_q_entrysize = 8; |
| 580 | return 1; |
| 581 | } |
| 582 | #ifdef CONFIG_SMP |
William Lee Irwin III | 54f565e | 2007-03-12 17:08:25 -0700 | [diff] [blame] | 583 | if (test_thread_flag(TIF_USEDFPU)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 584 | put_psr(get_psr() | PSR_EF); |
| 585 | fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr, |
| 586 | ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth); |
| 587 | if (regs != NULL) { |
| 588 | regs->psr &= ~(PSR_EF); |
William Lee Irwin III | 54f565e | 2007-03-12 17:08:25 -0700 | [diff] [blame] | 589 | clear_thread_flag(TIF_USEDFPU); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 590 | } |
| 591 | } |
| 592 | #else |
| 593 | if (current == last_task_used_math) { |
| 594 | put_psr(get_psr() | PSR_EF); |
| 595 | fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr, |
| 596 | ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth); |
| 597 | if (regs != NULL) { |
| 598 | regs->psr &= ~(PSR_EF); |
| 599 | last_task_used_math = NULL; |
| 600 | } |
| 601 | } |
| 602 | #endif |
| 603 | memcpy(&fpregs->pr_fr.pr_regs[0], |
| 604 | ¤t->thread.float_regs[0], |
| 605 | (sizeof(unsigned long) * 32)); |
| 606 | fpregs->pr_fsr = current->thread.fsr; |
| 607 | fpregs->pr_qcnt = current->thread.fpqdepth; |
| 608 | fpregs->pr_q_entrysize = 8; |
| 609 | fpregs->pr_en = 1; |
| 610 | if(fpregs->pr_qcnt != 0) { |
| 611 | memcpy(&fpregs->pr_q[0], |
| 612 | ¤t->thread.fpqueue[0], |
| 613 | sizeof(struct fpq) * fpregs->pr_qcnt); |
| 614 | } |
| 615 | /* Zero out the rest. */ |
| 616 | memset(&fpregs->pr_q[fpregs->pr_qcnt], 0, |
| 617 | sizeof(struct fpq) * (32 - fpregs->pr_qcnt)); |
| 618 | return 1; |
| 619 | } |
| 620 | |
| 621 | /* |
| 622 | * sparc_execve() executes a new program after the asm stub has set |
| 623 | * things up for us. This should basically do what I want it to. |
| 624 | */ |
| 625 | asmlinkage int sparc_execve(struct pt_regs *regs) |
| 626 | { |
| 627 | int error, base = 0; |
| 628 | char *filename; |
| 629 | |
| 630 | /* Check for indirect call. */ |
| 631 | if(regs->u_regs[UREG_G1] == 0) |
| 632 | base = 1; |
| 633 | |
| 634 | filename = getname((char __user *)regs->u_regs[base + UREG_I0]); |
| 635 | error = PTR_ERR(filename); |
| 636 | if(IS_ERR(filename)) |
| 637 | goto out; |
| 638 | error = do_execve(filename, |
David Howells | d762746 | 2010-08-17 23:52:56 +0100 | [diff] [blame] | 639 | (const char __user *const __user *) |
| 640 | regs->u_regs[base + UREG_I1], |
| 641 | (const char __user *const __user *) |
| 642 | regs->u_regs[base + UREG_I2], |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 643 | regs); |
| 644 | putname(filename); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 645 | out: |
| 646 | return error; |
| 647 | } |
| 648 | |
| 649 | /* |
| 650 | * This is the mechanism for creating a new kernel thread. |
| 651 | * |
| 652 | * NOTE! Only a kernel-only process(ie the swapper or direct descendants |
| 653 | * who haven't done an "execve()") should use this: it will work within |
| 654 | * a system call from a "real" process, but the process memory space will |
Simon Arlott | d1a78c3 | 2007-05-11 13:51:23 -0700 | [diff] [blame] | 655 | * not be freed until both the parent and the child have exited. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 656 | */ |
| 657 | pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) |
| 658 | { |
| 659 | long retval; |
| 660 | |
| 661 | __asm__ __volatile__("mov %4, %%g2\n\t" /* Set aside fn ptr... */ |
| 662 | "mov %5, %%g3\n\t" /* and arg. */ |
| 663 | "mov %1, %%g1\n\t" |
| 664 | "mov %2, %%o0\n\t" /* Clone flags. */ |
| 665 | "mov 0, %%o1\n\t" /* usp arg == 0 */ |
| 666 | "t 0x10\n\t" /* Linux/Sparc clone(). */ |
| 667 | "cmp %%o1, 0\n\t" |
| 668 | "be 1f\n\t" /* The parent, just return. */ |
| 669 | " nop\n\t" /* Delay slot. */ |
| 670 | "jmpl %%g2, %%o7\n\t" /* Call the function. */ |
| 671 | " mov %%g3, %%o0\n\t" /* Get back the arg in delay. */ |
| 672 | "mov %3, %%g1\n\t" |
| 673 | "t 0x10\n\t" /* Linux/Sparc exit(). */ |
| 674 | /* Notreached by child. */ |
| 675 | "1: mov %%o0, %0\n\t" : |
| 676 | "=r" (retval) : |
| 677 | "i" (__NR_clone), "r" (flags | CLONE_VM | CLONE_UNTRACED), |
| 678 | "i" (__NR_exit), "r" (fn), "r" (arg) : |
| 679 | "g1", "g2", "g3", "o0", "o1", "memory", "cc"); |
| 680 | return retval; |
| 681 | } |
Sam Ravnborg | 6943f3d | 2009-01-08 16:58:05 -0800 | [diff] [blame] | 682 | EXPORT_SYMBOL(kernel_thread); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 683 | |
| 684 | unsigned long get_wchan(struct task_struct *task) |
| 685 | { |
| 686 | unsigned long pc, fp, bias = 0; |
| 687 | unsigned long task_base = (unsigned long) task; |
| 688 | unsigned long ret = 0; |
Sam Ravnborg | 4d7b92a | 2009-01-02 19:32:59 -0800 | [diff] [blame] | 689 | struct reg_window32 *rw; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 690 | int count = 0; |
| 691 | |
| 692 | if (!task || task == current || |
| 693 | task->state == TASK_RUNNING) |
| 694 | goto out; |
| 695 | |
Al Viro | d562ef6 | 2006-01-12 01:05:46 -0800 | [diff] [blame] | 696 | fp = task_thread_info(task)->ksp + bias; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 697 | do { |
| 698 | /* Bogus frame pointer? */ |
| 699 | if (fp < (task_base + sizeof(struct thread_info)) || |
| 700 | fp >= (task_base + (2 * PAGE_SIZE))) |
| 701 | break; |
Sam Ravnborg | 4d7b92a | 2009-01-02 19:32:59 -0800 | [diff] [blame] | 702 | rw = (struct reg_window32 *) fp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 703 | pc = rw->ins[7]; |
| 704 | if (!in_sched_functions(pc)) { |
| 705 | ret = pc; |
| 706 | goto out; |
| 707 | } |
| 708 | fp = rw->ins[6] + bias; |
| 709 | } while (++count < 16); |
| 710 | |
| 711 | out: |
| 712 | return ret; |
| 713 | } |
| 714 | |