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