1 /* arch/sparc64/kernel/process.c 2 * 3 * Copyright (C) 1995, 1996, 2008 David S. Miller (davem@davemloft.net) 4 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be) 5 * Copyright (C) 1997, 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 6 */ 7 8 /* 9 * This file handles the architecture-dependent parts of process handling.. 10 */ 11 12 #include <stdarg.h> 13 14 #include <linux/errno.h> 15 #include <linux/export.h> 16 #include <linux/sched.h> 17 #include <linux/kernel.h> 18 #include <linux/mm.h> 19 #include <linux/fs.h> 20 #include <linux/smp.h> 21 #include <linux/stddef.h> 22 #include <linux/ptrace.h> 23 #include <linux/slab.h> 24 #include <linux/user.h> 25 #include <linux/delay.h> 26 #include <linux/compat.h> 27 #include <linux/tick.h> 28 #include <linux/init.h> 29 #include <linux/cpu.h> 30 #include <linux/perf_event.h> 31 #include <linux/elfcore.h> 32 #include <linux/sysrq.h> 33 #include <linux/nmi.h> 34 35 #include <asm/uaccess.h> 36 #include <asm/page.h> 37 #include <asm/pgalloc.h> 38 #include <asm/pgtable.h> 39 #include <asm/processor.h> 40 #include <asm/pstate.h> 41 #include <asm/elf.h> 42 #include <asm/fpumacro.h> 43 #include <asm/head.h> 44 #include <asm/cpudata.h> 45 #include <asm/mmu_context.h> 46 #include <asm/unistd.h> 47 #include <asm/hypervisor.h> 48 #include <asm/syscalls.h> 49 #include <asm/irq_regs.h> 50 #include <asm/smp.h> 51 #include <asm/pcr.h> 52 53 #include "kstack.h" 54 55 static void sparc64_yield(int cpu) 56 { 57 if (tlb_type != hypervisor) { 58 touch_nmi_watchdog(); 59 return; 60 } 61 62 clear_thread_flag(TIF_POLLING_NRFLAG); 63 smp_mb__after_clear_bit(); 64 65 while (!need_resched() && !cpu_is_offline(cpu)) { 66 unsigned long pstate; 67 68 /* Disable interrupts. */ 69 __asm__ __volatile__( 70 "rdpr %%pstate, %0\n\t" 71 "andn %0, %1, %0\n\t" 72 "wrpr %0, %%g0, %%pstate" 73 : "=&r" (pstate) 74 : "i" (PSTATE_IE)); 75 76 if (!need_resched() && !cpu_is_offline(cpu)) 77 sun4v_cpu_yield(); 78 79 /* Re-enable interrupts. */ 80 __asm__ __volatile__( 81 "rdpr %%pstate, %0\n\t" 82 "or %0, %1, %0\n\t" 83 "wrpr %0, %%g0, %%pstate" 84 : "=&r" (pstate) 85 : "i" (PSTATE_IE)); 86 } 87 88 set_thread_flag(TIF_POLLING_NRFLAG); 89 } 90 91 /* The idle loop on sparc64. */ 92 void cpu_idle(void) 93 { 94 int cpu = smp_processor_id(); 95 96 set_thread_flag(TIF_POLLING_NRFLAG); 97 98 while(1) { 99 tick_nohz_idle_enter(); 100 rcu_idle_enter(); 101 102 while (!need_resched() && !cpu_is_offline(cpu)) 103 sparc64_yield(cpu); 104 105 rcu_idle_exit(); 106 tick_nohz_idle_exit(); 107 108 #ifdef CONFIG_HOTPLUG_CPU 109 if (cpu_is_offline(cpu)) { 110 sched_preempt_enable_no_resched(); 111 cpu_play_dead(); 112 } 113 #endif 114 schedule_preempt_disabled(); 115 } 116 } 117 118 #ifdef CONFIG_COMPAT 119 static void show_regwindow32(struct pt_regs *regs) 120 { 121 struct reg_window32 __user *rw; 122 struct reg_window32 r_w; 123 mm_segment_t old_fs; 124 125 __asm__ __volatile__ ("flushw"); 126 rw = compat_ptr((unsigned)regs->u_regs[14]); 127 old_fs = get_fs(); 128 set_fs (USER_DS); 129 if (copy_from_user (&r_w, rw, sizeof(r_w))) { 130 set_fs (old_fs); 131 return; 132 } 133 134 set_fs (old_fs); 135 printk("l0: %08x l1: %08x l2: %08x l3: %08x " 136 "l4: %08x l5: %08x l6: %08x l7: %08x\n", 137 r_w.locals[0], r_w.locals[1], r_w.locals[2], r_w.locals[3], 138 r_w.locals[4], r_w.locals[5], r_w.locals[6], r_w.locals[7]); 139 printk("i0: %08x i1: %08x i2: %08x i3: %08x " 140 "i4: %08x i5: %08x i6: %08x i7: %08x\n", 141 r_w.ins[0], r_w.ins[1], r_w.ins[2], r_w.ins[3], 142 r_w.ins[4], r_w.ins[5], r_w.ins[6], r_w.ins[7]); 143 } 144 #else 145 #define show_regwindow32(regs) do { } while (0) 146 #endif 147 148 static void show_regwindow(struct pt_regs *regs) 149 { 150 struct reg_window __user *rw; 151 struct reg_window *rwk; 152 struct reg_window r_w; 153 mm_segment_t old_fs; 154 155 if ((regs->tstate & TSTATE_PRIV) || !(test_thread_flag(TIF_32BIT))) { 156 __asm__ __volatile__ ("flushw"); 157 rw = (struct reg_window __user *) 158 (regs->u_regs[14] + STACK_BIAS); 159 rwk = (struct reg_window *) 160 (regs->u_regs[14] + STACK_BIAS); 161 if (!(regs->tstate & TSTATE_PRIV)) { 162 old_fs = get_fs(); 163 set_fs (USER_DS); 164 if (copy_from_user (&r_w, rw, sizeof(r_w))) { 165 set_fs (old_fs); 166 return; 167 } 168 rwk = &r_w; 169 set_fs (old_fs); 170 } 171 } else { 172 show_regwindow32(regs); 173 return; 174 } 175 printk("l0: %016lx l1: %016lx l2: %016lx l3: %016lx\n", 176 rwk->locals[0], rwk->locals[1], rwk->locals[2], rwk->locals[3]); 177 printk("l4: %016lx l5: %016lx l6: %016lx l7: %016lx\n", 178 rwk->locals[4], rwk->locals[5], rwk->locals[6], rwk->locals[7]); 179 printk("i0: %016lx i1: %016lx i2: %016lx i3: %016lx\n", 180 rwk->ins[0], rwk->ins[1], rwk->ins[2], rwk->ins[3]); 181 printk("i4: %016lx i5: %016lx i6: %016lx i7: %016lx\n", 182 rwk->ins[4], rwk->ins[5], rwk->ins[6], rwk->ins[7]); 183 if (regs->tstate & TSTATE_PRIV) 184 printk("I7: <%pS>\n", (void *) rwk->ins[7]); 185 } 186 187 void show_regs(struct pt_regs *regs) 188 { 189 printk("TSTATE: %016lx TPC: %016lx TNPC: %016lx Y: %08x %s\n", regs->tstate, 190 regs->tpc, regs->tnpc, regs->y, print_tainted()); 191 printk("TPC: <%pS>\n", (void *) regs->tpc); 192 printk("g0: %016lx g1: %016lx g2: %016lx g3: %016lx\n", 193 regs->u_regs[0], regs->u_regs[1], regs->u_regs[2], 194 regs->u_regs[3]); 195 printk("g4: %016lx g5: %016lx g6: %016lx g7: %016lx\n", 196 regs->u_regs[4], regs->u_regs[5], regs->u_regs[6], 197 regs->u_regs[7]); 198 printk("o0: %016lx o1: %016lx o2: %016lx o3: %016lx\n", 199 regs->u_regs[8], regs->u_regs[9], regs->u_regs[10], 200 regs->u_regs[11]); 201 printk("o4: %016lx o5: %016lx sp: %016lx ret_pc: %016lx\n", 202 regs->u_regs[12], regs->u_regs[13], regs->u_regs[14], 203 regs->u_regs[15]); 204 printk("RPC: <%pS>\n", (void *) regs->u_regs[15]); 205 show_regwindow(regs); 206 show_stack(current, (unsigned long *) regs->u_regs[UREG_FP]); 207 } 208 209 union global_cpu_snapshot global_cpu_snapshot[NR_CPUS]; 210 static DEFINE_SPINLOCK(global_cpu_snapshot_lock); 211 212 static void __global_reg_self(struct thread_info *tp, struct pt_regs *regs, 213 int this_cpu) 214 { 215 struct global_reg_snapshot *rp; 216 217 flushw_all(); 218 219 rp = &global_cpu_snapshot[this_cpu].reg; 220 221 rp->tstate = regs->tstate; 222 rp->tpc = regs->tpc; 223 rp->tnpc = regs->tnpc; 224 rp->o7 = regs->u_regs[UREG_I7]; 225 226 if (regs->tstate & TSTATE_PRIV) { 227 struct reg_window *rw; 228 229 rw = (struct reg_window *) 230 (regs->u_regs[UREG_FP] + STACK_BIAS); 231 if (kstack_valid(tp, (unsigned long) rw)) { 232 rp->i7 = rw->ins[7]; 233 rw = (struct reg_window *) 234 (rw->ins[6] + STACK_BIAS); 235 if (kstack_valid(tp, (unsigned long) rw)) 236 rp->rpc = rw->ins[7]; 237 } 238 } else { 239 rp->i7 = 0; 240 rp->rpc = 0; 241 } 242 rp->thread = tp; 243 } 244 245 /* In order to avoid hangs we do not try to synchronize with the 246 * global register dump client cpus. The last store they make is to 247 * the thread pointer, so do a short poll waiting for that to become 248 * non-NULL. 249 */ 250 static void __global_reg_poll(struct global_reg_snapshot *gp) 251 { 252 int limit = 0; 253 254 while (!gp->thread && ++limit < 100) { 255 barrier(); 256 udelay(1); 257 } 258 } 259 260 void arch_trigger_all_cpu_backtrace(void) 261 { 262 struct thread_info *tp = current_thread_info(); 263 struct pt_regs *regs = get_irq_regs(); 264 unsigned long flags; 265 int this_cpu, cpu; 266 267 if (!regs) 268 regs = tp->kregs; 269 270 spin_lock_irqsave(&global_cpu_snapshot_lock, flags); 271 272 memset(global_cpu_snapshot, 0, sizeof(global_cpu_snapshot)); 273 274 this_cpu = raw_smp_processor_id(); 275 276 __global_reg_self(tp, regs, this_cpu); 277 278 smp_fetch_global_regs(); 279 280 for_each_online_cpu(cpu) { 281 struct global_reg_snapshot *gp = &global_cpu_snapshot[cpu].reg; 282 283 __global_reg_poll(gp); 284 285 tp = gp->thread; 286 printk("%c CPU[%3d]: TSTATE[%016lx] TPC[%016lx] TNPC[%016lx] TASK[%s:%d]\n", 287 (cpu == this_cpu ? '*' : ' '), cpu, 288 gp->tstate, gp->tpc, gp->tnpc, 289 ((tp && tp->task) ? tp->task->comm : "NULL"), 290 ((tp && tp->task) ? tp->task->pid : -1)); 291 292 if (gp->tstate & TSTATE_PRIV) { 293 printk(" TPC[%pS] O7[%pS] I7[%pS] RPC[%pS]\n", 294 (void *) gp->tpc, 295 (void *) gp->o7, 296 (void *) gp->i7, 297 (void *) gp->rpc); 298 } else { 299 printk(" TPC[%lx] O7[%lx] I7[%lx] RPC[%lx]\n", 300 gp->tpc, gp->o7, gp->i7, gp->rpc); 301 } 302 } 303 304 memset(global_cpu_snapshot, 0, sizeof(global_cpu_snapshot)); 305 306 spin_unlock_irqrestore(&global_cpu_snapshot_lock, flags); 307 } 308 309 #ifdef CONFIG_MAGIC_SYSRQ 310 311 static void sysrq_handle_globreg(int key) 312 { 313 arch_trigger_all_cpu_backtrace(); 314 } 315 316 static struct sysrq_key_op sparc_globalreg_op = { 317 .handler = sysrq_handle_globreg, 318 .help_msg = "global-regs(Y)", 319 .action_msg = "Show Global CPU Regs", 320 }; 321 322 static void __global_pmu_self(int this_cpu) 323 { 324 struct global_pmu_snapshot *pp; 325 int i, num; 326 327 pp = &global_cpu_snapshot[this_cpu].pmu; 328 329 num = 1; 330 if (tlb_type == hypervisor && 331 sun4v_chip_type >= SUN4V_CHIP_NIAGARA4) 332 num = 4; 333 334 for (i = 0; i < num; i++) { 335 pp->pcr[i] = pcr_ops->read_pcr(i); 336 pp->pic[i] = pcr_ops->read_pic(i); 337 } 338 } 339 340 static void __global_pmu_poll(struct global_pmu_snapshot *pp) 341 { 342 int limit = 0; 343 344 while (!pp->pcr[0] && ++limit < 100) { 345 barrier(); 346 udelay(1); 347 } 348 } 349 350 static void pmu_snapshot_all_cpus(void) 351 { 352 unsigned long flags; 353 int this_cpu, cpu; 354 355 spin_lock_irqsave(&global_cpu_snapshot_lock, flags); 356 357 memset(global_cpu_snapshot, 0, sizeof(global_cpu_snapshot)); 358 359 this_cpu = raw_smp_processor_id(); 360 361 __global_pmu_self(this_cpu); 362 363 smp_fetch_global_pmu(); 364 365 for_each_online_cpu(cpu) { 366 struct global_pmu_snapshot *pp = &global_cpu_snapshot[cpu].pmu; 367 368 __global_pmu_poll(pp); 369 370 printk("%c CPU[%3d]: PCR[%08lx:%08lx:%08lx:%08lx] PIC[%08lx:%08lx:%08lx:%08lx]\n", 371 (cpu == this_cpu ? '*' : ' '), cpu, 372 pp->pcr[0], pp->pcr[1], pp->pcr[2], pp->pcr[3], 373 pp->pic[0], pp->pic[1], pp->pic[2], pp->pic[3]); 374 } 375 376 memset(global_cpu_snapshot, 0, sizeof(global_cpu_snapshot)); 377 378 spin_unlock_irqrestore(&global_cpu_snapshot_lock, flags); 379 } 380 381 static void sysrq_handle_globpmu(int key) 382 { 383 pmu_snapshot_all_cpus(); 384 } 385 386 static struct sysrq_key_op sparc_globalpmu_op = { 387 .handler = sysrq_handle_globpmu, 388 .help_msg = "global-pmu(X)", 389 .action_msg = "Show Global PMU Regs", 390 }; 391 392 static int __init sparc_sysrq_init(void) 393 { 394 int ret = register_sysrq_key('y', &sparc_globalreg_op); 395 396 if (!ret) 397 ret = register_sysrq_key('x', &sparc_globalpmu_op); 398 return ret; 399 } 400 401 core_initcall(sparc_sysrq_init); 402 403 #endif 404 405 unsigned long thread_saved_pc(struct task_struct *tsk) 406 { 407 struct thread_info *ti = task_thread_info(tsk); 408 unsigned long ret = 0xdeadbeefUL; 409 410 if (ti && ti->ksp) { 411 unsigned long *sp; 412 sp = (unsigned long *)(ti->ksp + STACK_BIAS); 413 if (((unsigned long)sp & (sizeof(long) - 1)) == 0UL && 414 sp[14]) { 415 unsigned long *fp; 416 fp = (unsigned long *)(sp[14] + STACK_BIAS); 417 if (((unsigned long)fp & (sizeof(long) - 1)) == 0UL) 418 ret = fp[15]; 419 } 420 } 421 return ret; 422 } 423 424 /* Free current thread data structures etc.. */ 425 void exit_thread(void) 426 { 427 struct thread_info *t = current_thread_info(); 428 429 if (t->utraps) { 430 if (t->utraps[0] < 2) 431 kfree (t->utraps); 432 else 433 t->utraps[0]--; 434 } 435 } 436 437 void flush_thread(void) 438 { 439 struct thread_info *t = current_thread_info(); 440 struct mm_struct *mm; 441 442 mm = t->task->mm; 443 if (mm) 444 tsb_context_switch(mm); 445 446 set_thread_wsaved(0); 447 448 /* Clear FPU register state. */ 449 t->fpsaved[0] = 0; 450 } 451 452 /* It's a bit more tricky when 64-bit tasks are involved... */ 453 static unsigned long clone_stackframe(unsigned long csp, unsigned long psp) 454 { 455 unsigned long fp, distance, rval; 456 457 if (!(test_thread_flag(TIF_32BIT))) { 458 csp += STACK_BIAS; 459 psp += STACK_BIAS; 460 __get_user(fp, &(((struct reg_window __user *)psp)->ins[6])); 461 fp += STACK_BIAS; 462 } else 463 __get_user(fp, &(((struct reg_window32 __user *)psp)->ins[6])); 464 465 /* Now align the stack as this is mandatory in the Sparc ABI 466 * due to how register windows work. This hides the 467 * restriction from thread libraries etc. 468 */ 469 csp &= ~15UL; 470 471 distance = fp - psp; 472 rval = (csp - distance); 473 if (copy_in_user((void __user *) rval, (void __user *) psp, distance)) 474 rval = 0; 475 else if (test_thread_flag(TIF_32BIT)) { 476 if (put_user(((u32)csp), 477 &(((struct reg_window32 __user *)rval)->ins[6]))) 478 rval = 0; 479 } else { 480 if (put_user(((u64)csp - STACK_BIAS), 481 &(((struct reg_window __user *)rval)->ins[6]))) 482 rval = 0; 483 else 484 rval = rval - STACK_BIAS; 485 } 486 487 return rval; 488 } 489 490 /* Standard stuff. */ 491 static inline void shift_window_buffer(int first_win, int last_win, 492 struct thread_info *t) 493 { 494 int i; 495 496 for (i = first_win; i < last_win; i++) { 497 t->rwbuf_stkptrs[i] = t->rwbuf_stkptrs[i+1]; 498 memcpy(&t->reg_window[i], &t->reg_window[i+1], 499 sizeof(struct reg_window)); 500 } 501 } 502 503 void synchronize_user_stack(void) 504 { 505 struct thread_info *t = current_thread_info(); 506 unsigned long window; 507 508 flush_user_windows(); 509 if ((window = get_thread_wsaved()) != 0) { 510 int winsize = sizeof(struct reg_window); 511 int bias = 0; 512 513 if (test_thread_flag(TIF_32BIT)) 514 winsize = sizeof(struct reg_window32); 515 else 516 bias = STACK_BIAS; 517 518 window -= 1; 519 do { 520 unsigned long sp = (t->rwbuf_stkptrs[window] + bias); 521 struct reg_window *rwin = &t->reg_window[window]; 522 523 if (!copy_to_user((char __user *)sp, rwin, winsize)) { 524 shift_window_buffer(window, get_thread_wsaved() - 1, t); 525 set_thread_wsaved(get_thread_wsaved() - 1); 526 } 527 } while (window--); 528 } 529 } 530 531 static void stack_unaligned(unsigned long sp) 532 { 533 siginfo_t info; 534 535 info.si_signo = SIGBUS; 536 info.si_errno = 0; 537 info.si_code = BUS_ADRALN; 538 info.si_addr = (void __user *) sp; 539 info.si_trapno = 0; 540 force_sig_info(SIGBUS, &info, current); 541 } 542 543 void fault_in_user_windows(void) 544 { 545 struct thread_info *t = current_thread_info(); 546 unsigned long window; 547 int winsize = sizeof(struct reg_window); 548 int bias = 0; 549 550 if (test_thread_flag(TIF_32BIT)) 551 winsize = sizeof(struct reg_window32); 552 else 553 bias = STACK_BIAS; 554 555 flush_user_windows(); 556 window = get_thread_wsaved(); 557 558 if (likely(window != 0)) { 559 window -= 1; 560 do { 561 unsigned long sp = (t->rwbuf_stkptrs[window] + bias); 562 struct reg_window *rwin = &t->reg_window[window]; 563 564 if (unlikely(sp & 0x7UL)) 565 stack_unaligned(sp); 566 567 if (unlikely(copy_to_user((char __user *)sp, 568 rwin, winsize))) 569 goto barf; 570 } while (window--); 571 } 572 set_thread_wsaved(0); 573 return; 574 575 barf: 576 set_thread_wsaved(window + 1); 577 do_exit(SIGILL); 578 } 579 580 asmlinkage long sparc_do_fork(unsigned long clone_flags, 581 unsigned long stack_start, 582 struct pt_regs *regs, 583 unsigned long stack_size) 584 { 585 int __user *parent_tid_ptr, *child_tid_ptr; 586 unsigned long orig_i1 = regs->u_regs[UREG_I1]; 587 long ret; 588 589 #ifdef CONFIG_COMPAT 590 if (test_thread_flag(TIF_32BIT)) { 591 parent_tid_ptr = compat_ptr(regs->u_regs[UREG_I2]); 592 child_tid_ptr = compat_ptr(regs->u_regs[UREG_I4]); 593 } else 594 #endif 595 { 596 parent_tid_ptr = (int __user *) regs->u_regs[UREG_I2]; 597 child_tid_ptr = (int __user *) regs->u_regs[UREG_I4]; 598 } 599 600 ret = do_fork(clone_flags, stack_start, 601 regs, stack_size, 602 parent_tid_ptr, child_tid_ptr); 603 604 /* If we get an error and potentially restart the system 605 * call, we're screwed because copy_thread() clobbered 606 * the parent's %o1. So detect that case and restore it 607 * here. 608 */ 609 if ((unsigned long)ret >= -ERESTART_RESTARTBLOCK) 610 regs->u_regs[UREG_I1] = orig_i1; 611 612 return ret; 613 } 614 615 /* Copy a Sparc thread. The fork() return value conventions 616 * under SunOS are nothing short of bletcherous: 617 * Parent --> %o0 == childs pid, %o1 == 0 618 * Child --> %o0 == parents pid, %o1 == 1 619 */ 620 int copy_thread(unsigned long clone_flags, unsigned long sp, 621 unsigned long unused, 622 struct task_struct *p, struct pt_regs *regs) 623 { 624 struct thread_info *t = task_thread_info(p); 625 struct sparc_stackf *parent_sf; 626 unsigned long child_stack_sz; 627 char *child_trap_frame; 628 int kernel_thread; 629 630 kernel_thread = (regs->tstate & TSTATE_PRIV) ? 1 : 0; 631 parent_sf = ((struct sparc_stackf *) regs) - 1; 632 633 /* Calculate offset to stack_frame & pt_regs */ 634 child_stack_sz = ((STACKFRAME_SZ + TRACEREG_SZ) + 635 (kernel_thread ? STACKFRAME_SZ : 0)); 636 child_trap_frame = (task_stack_page(p) + 637 (THREAD_SIZE - child_stack_sz)); 638 memcpy(child_trap_frame, parent_sf, child_stack_sz); 639 640 t->flags = (t->flags & ~((0xffUL << TI_FLAG_CWP_SHIFT) | 641 (0xffUL << TI_FLAG_CURRENT_DS_SHIFT))) | 642 (((regs->tstate + 1) & TSTATE_CWP) << TI_FLAG_CWP_SHIFT); 643 t->new_child = 1; 644 t->ksp = ((unsigned long) child_trap_frame) - STACK_BIAS; 645 t->kregs = (struct pt_regs *) (child_trap_frame + 646 sizeof(struct sparc_stackf)); 647 t->fpsaved[0] = 0; 648 649 if (kernel_thread) { 650 struct sparc_stackf *child_sf = (struct sparc_stackf *) 651 (child_trap_frame + (STACKFRAME_SZ + TRACEREG_SZ)); 652 653 /* Zero terminate the stack backtrace. */ 654 child_sf->fp = NULL; 655 t->kregs->u_regs[UREG_FP] = 656 ((unsigned long) child_sf) - STACK_BIAS; 657 658 t->flags |= ((long)ASI_P << TI_FLAG_CURRENT_DS_SHIFT); 659 t->kregs->u_regs[UREG_G6] = (unsigned long) t; 660 t->kregs->u_regs[UREG_G4] = (unsigned long) t->task; 661 } else { 662 if (t->flags & _TIF_32BIT) { 663 sp &= 0x00000000ffffffffUL; 664 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 665 } 666 t->kregs->u_regs[UREG_FP] = sp; 667 t->flags |= ((long)ASI_AIUS << TI_FLAG_CURRENT_DS_SHIFT); 668 if (sp != regs->u_regs[UREG_FP]) { 669 unsigned long csp; 670 671 csp = clone_stackframe(sp, regs->u_regs[UREG_FP]); 672 if (!csp) 673 return -EFAULT; 674 t->kregs->u_regs[UREG_FP] = csp; 675 } 676 if (t->utraps) 677 t->utraps[0]++; 678 } 679 680 /* Set the return value for the child. */ 681 t->kregs->u_regs[UREG_I0] = current->pid; 682 t->kregs->u_regs[UREG_I1] = 1; 683 684 /* Set the second return value for the parent. */ 685 regs->u_regs[UREG_I1] = 0; 686 687 if (clone_flags & CLONE_SETTLS) 688 t->kregs->u_regs[UREG_G7] = regs->u_regs[UREG_I3]; 689 690 return 0; 691 } 692 693 /* 694 * This is the mechanism for creating a new kernel thread. 695 * 696 * NOTE! Only a kernel-only process(ie the swapper or direct descendants 697 * who haven't done an "execve()") should use this: it will work within 698 * a system call from a "real" process, but the process memory space will 699 * not be freed until both the parent and the child have exited. 700 */ 701 pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) 702 { 703 long retval; 704 705 /* If the parent runs before fn(arg) is called by the child, 706 * the input registers of this function can be clobbered. 707 * So we stash 'fn' and 'arg' into global registers which 708 * will not be modified by the parent. 709 */ 710 __asm__ __volatile__("mov %4, %%g2\n\t" /* Save FN into global */ 711 "mov %5, %%g3\n\t" /* Save ARG into global */ 712 "mov %1, %%g1\n\t" /* Clone syscall nr. */ 713 "mov %2, %%o0\n\t" /* Clone flags. */ 714 "mov 0, %%o1\n\t" /* usp arg == 0 */ 715 "t 0x6d\n\t" /* Linux/Sparc clone(). */ 716 "brz,a,pn %%o1, 1f\n\t" /* Parent, just return. */ 717 " mov %%o0, %0\n\t" 718 "jmpl %%g2, %%o7\n\t" /* Call the function. */ 719 " mov %%g3, %%o0\n\t" /* Set arg in delay. */ 720 "mov %3, %%g1\n\t" 721 "t 0x6d\n\t" /* Linux/Sparc exit(). */ 722 /* Notreached by child. */ 723 "1:" : 724 "=r" (retval) : 725 "i" (__NR_clone), "r" (flags | CLONE_VM | CLONE_UNTRACED), 726 "i" (__NR_exit), "r" (fn), "r" (arg) : 727 "g1", "g2", "g3", "o0", "o1", "memory", "cc"); 728 return retval; 729 } 730 EXPORT_SYMBOL(kernel_thread); 731 732 typedef struct { 733 union { 734 unsigned int pr_regs[32]; 735 unsigned long pr_dregs[16]; 736 } pr_fr; 737 unsigned int __unused; 738 unsigned int pr_fsr; 739 unsigned char pr_qcnt; 740 unsigned char pr_q_entrysize; 741 unsigned char pr_en; 742 unsigned int pr_q[64]; 743 } elf_fpregset_t32; 744 745 /* 746 * fill in the fpu structure for a core dump. 747 */ 748 int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs) 749 { 750 unsigned long *kfpregs = current_thread_info()->fpregs; 751 unsigned long fprs = current_thread_info()->fpsaved[0]; 752 753 if (test_thread_flag(TIF_32BIT)) { 754 elf_fpregset_t32 *fpregs32 = (elf_fpregset_t32 *)fpregs; 755 756 if (fprs & FPRS_DL) 757 memcpy(&fpregs32->pr_fr.pr_regs[0], kfpregs, 758 sizeof(unsigned int) * 32); 759 else 760 memset(&fpregs32->pr_fr.pr_regs[0], 0, 761 sizeof(unsigned int) * 32); 762 fpregs32->pr_qcnt = 0; 763 fpregs32->pr_q_entrysize = 8; 764 memset(&fpregs32->pr_q[0], 0, 765 (sizeof(unsigned int) * 64)); 766 if (fprs & FPRS_FEF) { 767 fpregs32->pr_fsr = (unsigned int) current_thread_info()->xfsr[0]; 768 fpregs32->pr_en = 1; 769 } else { 770 fpregs32->pr_fsr = 0; 771 fpregs32->pr_en = 0; 772 } 773 } else { 774 if(fprs & FPRS_DL) 775 memcpy(&fpregs->pr_regs[0], kfpregs, 776 sizeof(unsigned int) * 32); 777 else 778 memset(&fpregs->pr_regs[0], 0, 779 sizeof(unsigned int) * 32); 780 if(fprs & FPRS_DU) 781 memcpy(&fpregs->pr_regs[16], kfpregs+16, 782 sizeof(unsigned int) * 32); 783 else 784 memset(&fpregs->pr_regs[16], 0, 785 sizeof(unsigned int) * 32); 786 if(fprs & FPRS_FEF) { 787 fpregs->pr_fsr = current_thread_info()->xfsr[0]; 788 fpregs->pr_gsr = current_thread_info()->gsr[0]; 789 } else { 790 fpregs->pr_fsr = fpregs->pr_gsr = 0; 791 } 792 fpregs->pr_fprs = fprs; 793 } 794 return 1; 795 } 796 EXPORT_SYMBOL(dump_fpu); 797 798 /* 799 * sparc_execve() executes a new program after the asm stub has set 800 * things up for us. This should basically do what I want it to. 801 */ 802 asmlinkage int sparc_execve(struct pt_regs *regs) 803 { 804 int error, base = 0; 805 struct filename *filename; 806 807 /* User register window flush is done by entry.S */ 808 809 /* Check for indirect call. */ 810 if (regs->u_regs[UREG_G1] == 0) 811 base = 1; 812 813 filename = getname((char __user *)regs->u_regs[base + UREG_I0]); 814 error = PTR_ERR(filename); 815 if (IS_ERR(filename)) 816 goto out; 817 error = do_execve(filename->name, 818 (const char __user *const __user *) 819 regs->u_regs[base + UREG_I1], 820 (const char __user *const __user *) 821 regs->u_regs[base + UREG_I2], regs); 822 putname(filename); 823 if (!error) { 824 fprs_write(0); 825 current_thread_info()->xfsr[0] = 0; 826 current_thread_info()->fpsaved[0] = 0; 827 regs->tstate &= ~TSTATE_PEF; 828 } 829 out: 830 return error; 831 } 832 833 unsigned long get_wchan(struct task_struct *task) 834 { 835 unsigned long pc, fp, bias = 0; 836 struct thread_info *tp; 837 struct reg_window *rw; 838 unsigned long ret = 0; 839 int count = 0; 840 841 if (!task || task == current || 842 task->state == TASK_RUNNING) 843 goto out; 844 845 tp = task_thread_info(task); 846 bias = STACK_BIAS; 847 fp = task_thread_info(task)->ksp + bias; 848 849 do { 850 if (!kstack_valid(tp, fp)) 851 break; 852 rw = (struct reg_window *) fp; 853 pc = rw->ins[7]; 854 if (!in_sched_functions(pc)) { 855 ret = pc; 856 goto out; 857 } 858 fp = rw->ins[6] + bias; 859 } while (++count < 16); 860 861 out: 862 return ret; 863 } 864