1 /* 2 * Derived from "arch/i386/kernel/process.c" 3 * Copyright (C) 1995 Linus Torvalds 4 * 5 * Updated and modified by Cort Dougan (cort@cs.nmt.edu) and 6 * Paul Mackerras (paulus@cs.anu.edu.au) 7 * 8 * PowerPC version 9 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * as published by the Free Software Foundation; either version 14 * 2 of the License, or (at your option) any later version. 15 */ 16 17 #include <linux/errno.h> 18 #include <linux/sched.h> 19 #include <linux/kernel.h> 20 #include <linux/mm.h> 21 #include <linux/smp.h> 22 #include <linux/smp_lock.h> 23 #include <linux/stddef.h> 24 #include <linux/unistd.h> 25 #include <linux/ptrace.h> 26 #include <linux/slab.h> 27 #include <linux/user.h> 28 #include <linux/elf.h> 29 #include <linux/init.h> 30 #include <linux/prctl.h> 31 #include <linux/init_task.h> 32 #include <linux/module.h> 33 #include <linux/kallsyms.h> 34 #include <linux/mqueue.h> 35 #include <linux/hardirq.h> 36 #include <linux/utsname.h> 37 38 #include <asm/pgtable.h> 39 #include <asm/uaccess.h> 40 #include <asm/system.h> 41 #include <asm/io.h> 42 #include <asm/processor.h> 43 #include <asm/mmu.h> 44 #include <asm/prom.h> 45 #include <asm/machdep.h> 46 #include <asm/time.h> 47 #include <asm/syscalls.h> 48 #ifdef CONFIG_PPC64 49 #include <asm/firmware.h> 50 #endif 51 52 extern unsigned long _get_SP(void); 53 54 #ifndef CONFIG_SMP 55 struct task_struct *last_task_used_math = NULL; 56 struct task_struct *last_task_used_altivec = NULL; 57 struct task_struct *last_task_used_spe = NULL; 58 #endif 59 60 /* 61 * Make sure the floating-point register state in the 62 * the thread_struct is up to date for task tsk. 63 */ 64 void flush_fp_to_thread(struct task_struct *tsk) 65 { 66 if (tsk->thread.regs) { 67 /* 68 * We need to disable preemption here because if we didn't, 69 * another process could get scheduled after the regs->msr 70 * test but before we have finished saving the FP registers 71 * to the thread_struct. That process could take over the 72 * FPU, and then when we get scheduled again we would store 73 * bogus values for the remaining FP registers. 74 */ 75 preempt_disable(); 76 if (tsk->thread.regs->msr & MSR_FP) { 77 #ifdef CONFIG_SMP 78 /* 79 * This should only ever be called for current or 80 * for a stopped child process. Since we save away 81 * the FP register state on context switch on SMP, 82 * there is something wrong if a stopped child appears 83 * to still have its FP state in the CPU registers. 84 */ 85 BUG_ON(tsk != current); 86 #endif 87 giveup_fpu(current); 88 } 89 preempt_enable(); 90 } 91 } 92 93 void enable_kernel_fp(void) 94 { 95 WARN_ON(preemptible()); 96 97 #ifdef CONFIG_SMP 98 if (current->thread.regs && (current->thread.regs->msr & MSR_FP)) 99 giveup_fpu(current); 100 else 101 giveup_fpu(NULL); /* just enables FP for kernel */ 102 #else 103 giveup_fpu(last_task_used_math); 104 #endif /* CONFIG_SMP */ 105 } 106 EXPORT_SYMBOL(enable_kernel_fp); 107 108 int dump_task_fpu(struct task_struct *tsk, elf_fpregset_t *fpregs) 109 { 110 if (!tsk->thread.regs) 111 return 0; 112 flush_fp_to_thread(current); 113 114 memcpy(fpregs, &tsk->thread.fpr[0], sizeof(*fpregs)); 115 116 return 1; 117 } 118 119 #ifdef CONFIG_ALTIVEC 120 void enable_kernel_altivec(void) 121 { 122 WARN_ON(preemptible()); 123 124 #ifdef CONFIG_SMP 125 if (current->thread.regs && (current->thread.regs->msr & MSR_VEC)) 126 giveup_altivec(current); 127 else 128 giveup_altivec(NULL); /* just enable AltiVec for kernel - force */ 129 #else 130 giveup_altivec(last_task_used_altivec); 131 #endif /* CONFIG_SMP */ 132 } 133 EXPORT_SYMBOL(enable_kernel_altivec); 134 135 /* 136 * Make sure the VMX/Altivec register state in the 137 * the thread_struct is up to date for task tsk. 138 */ 139 void flush_altivec_to_thread(struct task_struct *tsk) 140 { 141 if (tsk->thread.regs) { 142 preempt_disable(); 143 if (tsk->thread.regs->msr & MSR_VEC) { 144 #ifdef CONFIG_SMP 145 BUG_ON(tsk != current); 146 #endif 147 giveup_altivec(current); 148 } 149 preempt_enable(); 150 } 151 } 152 153 int dump_task_altivec(struct pt_regs *regs, elf_vrregset_t *vrregs) 154 { 155 flush_altivec_to_thread(current); 156 memcpy(vrregs, ¤t->thread.vr[0], sizeof(*vrregs)); 157 return 1; 158 } 159 #endif /* CONFIG_ALTIVEC */ 160 161 #ifdef CONFIG_SPE 162 163 void enable_kernel_spe(void) 164 { 165 WARN_ON(preemptible()); 166 167 #ifdef CONFIG_SMP 168 if (current->thread.regs && (current->thread.regs->msr & MSR_SPE)) 169 giveup_spe(current); 170 else 171 giveup_spe(NULL); /* just enable SPE for kernel - force */ 172 #else 173 giveup_spe(last_task_used_spe); 174 #endif /* __SMP __ */ 175 } 176 EXPORT_SYMBOL(enable_kernel_spe); 177 178 void flush_spe_to_thread(struct task_struct *tsk) 179 { 180 if (tsk->thread.regs) { 181 preempt_disable(); 182 if (tsk->thread.regs->msr & MSR_SPE) { 183 #ifdef CONFIG_SMP 184 BUG_ON(tsk != current); 185 #endif 186 giveup_spe(current); 187 } 188 preempt_enable(); 189 } 190 } 191 192 int dump_spe(struct pt_regs *regs, elf_vrregset_t *evrregs) 193 { 194 flush_spe_to_thread(current); 195 /* We copy u32 evr[32] + u64 acc + u32 spefscr -> 35 */ 196 memcpy(evrregs, ¤t->thread.evr[0], sizeof(u32) * 35); 197 return 1; 198 } 199 #endif /* CONFIG_SPE */ 200 201 #ifndef CONFIG_SMP 202 /* 203 * If we are doing lazy switching of CPU state (FP, altivec or SPE), 204 * and the current task has some state, discard it. 205 */ 206 void discard_lazy_cpu_state(void) 207 { 208 preempt_disable(); 209 if (last_task_used_math == current) 210 last_task_used_math = NULL; 211 #ifdef CONFIG_ALTIVEC 212 if (last_task_used_altivec == current) 213 last_task_used_altivec = NULL; 214 #endif /* CONFIG_ALTIVEC */ 215 #ifdef CONFIG_SPE 216 if (last_task_used_spe == current) 217 last_task_used_spe = NULL; 218 #endif 219 preempt_enable(); 220 } 221 #endif /* CONFIG_SMP */ 222 223 #ifdef CONFIG_PPC_MERGE /* XXX for now */ 224 int set_dabr(unsigned long dabr) 225 { 226 if (ppc_md.set_dabr) 227 return ppc_md.set_dabr(dabr); 228 229 mtspr(SPRN_DABR, dabr); 230 return 0; 231 } 232 #endif 233 234 #ifdef CONFIG_PPC64 235 DEFINE_PER_CPU(struct cpu_usage, cpu_usage_array); 236 static DEFINE_PER_CPU(unsigned long, current_dabr); 237 #endif 238 239 struct task_struct *__switch_to(struct task_struct *prev, 240 struct task_struct *new) 241 { 242 struct thread_struct *new_thread, *old_thread; 243 unsigned long flags; 244 struct task_struct *last; 245 246 #ifdef CONFIG_SMP 247 /* avoid complexity of lazy save/restore of fpu 248 * by just saving it every time we switch out if 249 * this task used the fpu during the last quantum. 250 * 251 * If it tries to use the fpu again, it'll trap and 252 * reload its fp regs. So we don't have to do a restore 253 * every switch, just a save. 254 * -- Cort 255 */ 256 if (prev->thread.regs && (prev->thread.regs->msr & MSR_FP)) 257 giveup_fpu(prev); 258 #ifdef CONFIG_ALTIVEC 259 /* 260 * If the previous thread used altivec in the last quantum 261 * (thus changing altivec regs) then save them. 262 * We used to check the VRSAVE register but not all apps 263 * set it, so we don't rely on it now (and in fact we need 264 * to save & restore VSCR even if VRSAVE == 0). -- paulus 265 * 266 * On SMP we always save/restore altivec regs just to avoid the 267 * complexity of changing processors. 268 * -- Cort 269 */ 270 if (prev->thread.regs && (prev->thread.regs->msr & MSR_VEC)) 271 giveup_altivec(prev); 272 #endif /* CONFIG_ALTIVEC */ 273 #ifdef CONFIG_SPE 274 /* 275 * If the previous thread used spe in the last quantum 276 * (thus changing spe regs) then save them. 277 * 278 * On SMP we always save/restore spe regs just to avoid the 279 * complexity of changing processors. 280 */ 281 if ((prev->thread.regs && (prev->thread.regs->msr & MSR_SPE))) 282 giveup_spe(prev); 283 #endif /* CONFIG_SPE */ 284 285 #else /* CONFIG_SMP */ 286 #ifdef CONFIG_ALTIVEC 287 /* Avoid the trap. On smp this this never happens since 288 * we don't set last_task_used_altivec -- Cort 289 */ 290 if (new->thread.regs && last_task_used_altivec == new) 291 new->thread.regs->msr |= MSR_VEC; 292 #endif /* CONFIG_ALTIVEC */ 293 #ifdef CONFIG_SPE 294 /* Avoid the trap. On smp this this never happens since 295 * we don't set last_task_used_spe 296 */ 297 if (new->thread.regs && last_task_used_spe == new) 298 new->thread.regs->msr |= MSR_SPE; 299 #endif /* CONFIG_SPE */ 300 301 #endif /* CONFIG_SMP */ 302 303 #ifdef CONFIG_PPC64 /* for now */ 304 if (unlikely(__get_cpu_var(current_dabr) != new->thread.dabr)) { 305 set_dabr(new->thread.dabr); 306 __get_cpu_var(current_dabr) = new->thread.dabr; 307 } 308 309 flush_tlb_pending(); 310 #endif 311 312 new_thread = &new->thread; 313 old_thread = ¤t->thread; 314 315 #ifdef CONFIG_PPC64 316 /* 317 * Collect processor utilization data per process 318 */ 319 if (firmware_has_feature(FW_FEATURE_SPLPAR)) { 320 struct cpu_usage *cu = &__get_cpu_var(cpu_usage_array); 321 long unsigned start_tb, current_tb; 322 start_tb = old_thread->start_tb; 323 cu->current_tb = current_tb = mfspr(SPRN_PURR); 324 old_thread->accum_tb += (current_tb - start_tb); 325 new_thread->start_tb = current_tb; 326 } 327 #endif 328 329 local_irq_save(flags); 330 331 account_system_vtime(current); 332 account_process_vtime(current); 333 calculate_steal_time(); 334 335 last = _switch(old_thread, new_thread); 336 337 local_irq_restore(flags); 338 339 return last; 340 } 341 342 static int instructions_to_print = 16; 343 344 static void show_instructions(struct pt_regs *regs) 345 { 346 int i; 347 unsigned long pc = regs->nip - (instructions_to_print * 3 / 4 * 348 sizeof(int)); 349 350 printk("Instruction dump:"); 351 352 for (i = 0; i < instructions_to_print; i++) { 353 int instr; 354 355 if (!(i % 8)) 356 printk("\n"); 357 358 /* We use __get_user here *only* to avoid an OOPS on a 359 * bad address because the pc *should* only be a 360 * kernel address. 361 */ 362 if (!__kernel_text_address(pc) || 363 __get_user(instr, (unsigned int __user *)pc)) { 364 printk("XXXXXXXX "); 365 } else { 366 if (regs->nip == pc) 367 printk("<%08x> ", instr); 368 else 369 printk("%08x ", instr); 370 } 371 372 pc += sizeof(int); 373 } 374 375 printk("\n"); 376 } 377 378 static struct regbit { 379 unsigned long bit; 380 const char *name; 381 } msr_bits[] = { 382 {MSR_EE, "EE"}, 383 {MSR_PR, "PR"}, 384 {MSR_FP, "FP"}, 385 {MSR_ME, "ME"}, 386 {MSR_IR, "IR"}, 387 {MSR_DR, "DR"}, 388 {0, NULL} 389 }; 390 391 static void printbits(unsigned long val, struct regbit *bits) 392 { 393 const char *sep = ""; 394 395 printk("<"); 396 for (; bits->bit; ++bits) 397 if (val & bits->bit) { 398 printk("%s%s", sep, bits->name); 399 sep = ","; 400 } 401 printk(">"); 402 } 403 404 #ifdef CONFIG_PPC64 405 #define REG "%016lX" 406 #define REGS_PER_LINE 4 407 #define LAST_VOLATILE 13 408 #else 409 #define REG "%08lX" 410 #define REGS_PER_LINE 8 411 #define LAST_VOLATILE 12 412 #endif 413 414 void show_regs(struct pt_regs * regs) 415 { 416 int i, trap; 417 418 printk("NIP: "REG" LR: "REG" CTR: "REG"\n", 419 regs->nip, regs->link, regs->ctr); 420 printk("REGS: %p TRAP: %04lx %s (%s)\n", 421 regs, regs->trap, print_tainted(), init_utsname()->release); 422 printk("MSR: "REG" ", regs->msr); 423 printbits(regs->msr, msr_bits); 424 printk(" CR: %08lX XER: %08lX\n", regs->ccr, regs->xer); 425 trap = TRAP(regs); 426 if (trap == 0x300 || trap == 0x600) 427 printk("DAR: "REG", DSISR: "REG"\n", regs->dar, regs->dsisr); 428 printk("TASK = %p[%d] '%s' THREAD: %p", 429 current, current->pid, current->comm, task_thread_info(current)); 430 431 #ifdef CONFIG_SMP 432 printk(" CPU: %d", smp_processor_id()); 433 #endif /* CONFIG_SMP */ 434 435 for (i = 0; i < 32; i++) { 436 if ((i % REGS_PER_LINE) == 0) 437 printk("\n" KERN_INFO "GPR%02d: ", i); 438 printk(REG " ", regs->gpr[i]); 439 if (i == LAST_VOLATILE && !FULL_REGS(regs)) 440 break; 441 } 442 printk("\n"); 443 #ifdef CONFIG_KALLSYMS 444 /* 445 * Lookup NIP late so we have the best change of getting the 446 * above info out without failing 447 */ 448 printk("NIP ["REG"] ", regs->nip); 449 print_symbol("%s\n", regs->nip); 450 printk("LR ["REG"] ", regs->link); 451 print_symbol("%s\n", regs->link); 452 #endif 453 show_stack(current, (unsigned long *) regs->gpr[1]); 454 if (!user_mode(regs)) 455 show_instructions(regs); 456 } 457 458 void exit_thread(void) 459 { 460 discard_lazy_cpu_state(); 461 } 462 463 void flush_thread(void) 464 { 465 #ifdef CONFIG_PPC64 466 struct thread_info *t = current_thread_info(); 467 468 if (test_ti_thread_flag(t, TIF_ABI_PENDING)) { 469 clear_ti_thread_flag(t, TIF_ABI_PENDING); 470 if (test_ti_thread_flag(t, TIF_32BIT)) 471 clear_ti_thread_flag(t, TIF_32BIT); 472 else 473 set_ti_thread_flag(t, TIF_32BIT); 474 } 475 #endif 476 477 discard_lazy_cpu_state(); 478 479 #ifdef CONFIG_PPC64 /* for now */ 480 if (current->thread.dabr) { 481 current->thread.dabr = 0; 482 set_dabr(0); 483 } 484 #endif 485 } 486 487 void 488 release_thread(struct task_struct *t) 489 { 490 } 491 492 /* 493 * This gets called before we allocate a new thread and copy 494 * the current task into it. 495 */ 496 void prepare_to_copy(struct task_struct *tsk) 497 { 498 flush_fp_to_thread(current); 499 flush_altivec_to_thread(current); 500 flush_spe_to_thread(current); 501 } 502 503 /* 504 * Copy a thread.. 505 */ 506 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp, 507 unsigned long unused, struct task_struct *p, 508 struct pt_regs *regs) 509 { 510 struct pt_regs *childregs, *kregs; 511 extern void ret_from_fork(void); 512 unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE; 513 514 CHECK_FULL_REGS(regs); 515 /* Copy registers */ 516 sp -= sizeof(struct pt_regs); 517 childregs = (struct pt_regs *) sp; 518 *childregs = *regs; 519 if ((childregs->msr & MSR_PR) == 0) { 520 /* for kernel thread, set `current' and stackptr in new task */ 521 childregs->gpr[1] = sp + sizeof(struct pt_regs); 522 #ifdef CONFIG_PPC32 523 childregs->gpr[2] = (unsigned long) p; 524 #else 525 clear_tsk_thread_flag(p, TIF_32BIT); 526 #endif 527 p->thread.regs = NULL; /* no user register state */ 528 } else { 529 childregs->gpr[1] = usp; 530 p->thread.regs = childregs; 531 if (clone_flags & CLONE_SETTLS) { 532 #ifdef CONFIG_PPC64 533 if (!test_thread_flag(TIF_32BIT)) 534 childregs->gpr[13] = childregs->gpr[6]; 535 else 536 #endif 537 childregs->gpr[2] = childregs->gpr[6]; 538 } 539 } 540 childregs->gpr[3] = 0; /* Result from fork() */ 541 sp -= STACK_FRAME_OVERHEAD; 542 543 /* 544 * The way this works is that at some point in the future 545 * some task will call _switch to switch to the new task. 546 * That will pop off the stack frame created below and start 547 * the new task running at ret_from_fork. The new task will 548 * do some house keeping and then return from the fork or clone 549 * system call, using the stack frame created above. 550 */ 551 sp -= sizeof(struct pt_regs); 552 kregs = (struct pt_regs *) sp; 553 sp -= STACK_FRAME_OVERHEAD; 554 p->thread.ksp = sp; 555 556 #ifdef CONFIG_PPC64 557 if (cpu_has_feature(CPU_FTR_SLB)) { 558 unsigned long sp_vsid = get_kernel_vsid(sp); 559 unsigned long llp = mmu_psize_defs[mmu_linear_psize].sllp; 560 561 sp_vsid <<= SLB_VSID_SHIFT; 562 sp_vsid |= SLB_VSID_KERNEL | llp; 563 p->thread.ksp_vsid = sp_vsid; 564 } 565 566 /* 567 * The PPC64 ABI makes use of a TOC to contain function 568 * pointers. The function (ret_from_except) is actually a pointer 569 * to the TOC entry. The first entry is a pointer to the actual 570 * function. 571 */ 572 kregs->nip = *((unsigned long *)ret_from_fork); 573 #else 574 kregs->nip = (unsigned long)ret_from_fork; 575 p->thread.last_syscall = -1; 576 #endif 577 578 return 0; 579 } 580 581 /* 582 * Set up a thread for executing a new program 583 */ 584 void start_thread(struct pt_regs *regs, unsigned long start, unsigned long sp) 585 { 586 #ifdef CONFIG_PPC64 587 unsigned long load_addr = regs->gpr[2]; /* saved by ELF_PLAT_INIT */ 588 #endif 589 590 set_fs(USER_DS); 591 592 /* 593 * If we exec out of a kernel thread then thread.regs will not be 594 * set. Do it now. 595 */ 596 if (!current->thread.regs) { 597 struct pt_regs *regs = task_stack_page(current) + THREAD_SIZE; 598 current->thread.regs = regs - 1; 599 } 600 601 memset(regs->gpr, 0, sizeof(regs->gpr)); 602 regs->ctr = 0; 603 regs->link = 0; 604 regs->xer = 0; 605 regs->ccr = 0; 606 regs->gpr[1] = sp; 607 608 #ifdef CONFIG_PPC32 609 regs->mq = 0; 610 regs->nip = start; 611 regs->msr = MSR_USER; 612 #else 613 if (!test_thread_flag(TIF_32BIT)) { 614 unsigned long entry, toc; 615 616 /* start is a relocated pointer to the function descriptor for 617 * the elf _start routine. The first entry in the function 618 * descriptor is the entry address of _start and the second 619 * entry is the TOC value we need to use. 620 */ 621 __get_user(entry, (unsigned long __user *)start); 622 __get_user(toc, (unsigned long __user *)start+1); 623 624 /* Check whether the e_entry function descriptor entries 625 * need to be relocated before we can use them. 626 */ 627 if (load_addr != 0) { 628 entry += load_addr; 629 toc += load_addr; 630 } 631 regs->nip = entry; 632 regs->gpr[2] = toc; 633 regs->msr = MSR_USER64; 634 } else { 635 regs->nip = start; 636 regs->gpr[2] = 0; 637 regs->msr = MSR_USER32; 638 } 639 #endif 640 641 discard_lazy_cpu_state(); 642 memset(current->thread.fpr, 0, sizeof(current->thread.fpr)); 643 current->thread.fpscr.val = 0; 644 #ifdef CONFIG_ALTIVEC 645 memset(current->thread.vr, 0, sizeof(current->thread.vr)); 646 memset(¤t->thread.vscr, 0, sizeof(current->thread.vscr)); 647 current->thread.vscr.u[3] = 0x00010000; /* Java mode disabled */ 648 current->thread.vrsave = 0; 649 current->thread.used_vr = 0; 650 #endif /* CONFIG_ALTIVEC */ 651 #ifdef CONFIG_SPE 652 memset(current->thread.evr, 0, sizeof(current->thread.evr)); 653 current->thread.acc = 0; 654 current->thread.spefscr = 0; 655 current->thread.used_spe = 0; 656 #endif /* CONFIG_SPE */ 657 } 658 659 #define PR_FP_ALL_EXCEPT (PR_FP_EXC_DIV | PR_FP_EXC_OVF | PR_FP_EXC_UND \ 660 | PR_FP_EXC_RES | PR_FP_EXC_INV) 661 662 int set_fpexc_mode(struct task_struct *tsk, unsigned int val) 663 { 664 struct pt_regs *regs = tsk->thread.regs; 665 666 /* This is a bit hairy. If we are an SPE enabled processor 667 * (have embedded fp) we store the IEEE exception enable flags in 668 * fpexc_mode. fpexc_mode is also used for setting FP exception 669 * mode (asyn, precise, disabled) for 'Classic' FP. */ 670 if (val & PR_FP_EXC_SW_ENABLE) { 671 #ifdef CONFIG_SPE 672 tsk->thread.fpexc_mode = val & 673 (PR_FP_EXC_SW_ENABLE | PR_FP_ALL_EXCEPT); 674 return 0; 675 #else 676 return -EINVAL; 677 #endif 678 } 679 680 /* on a CONFIG_SPE this does not hurt us. The bits that 681 * __pack_fe01 use do not overlap with bits used for 682 * PR_FP_EXC_SW_ENABLE. Additionally, the MSR[FE0,FE1] bits 683 * on CONFIG_SPE implementations are reserved so writing to 684 * them does not change anything */ 685 if (val > PR_FP_EXC_PRECISE) 686 return -EINVAL; 687 tsk->thread.fpexc_mode = __pack_fe01(val); 688 if (regs != NULL && (regs->msr & MSR_FP) != 0) 689 regs->msr = (regs->msr & ~(MSR_FE0|MSR_FE1)) 690 | tsk->thread.fpexc_mode; 691 return 0; 692 } 693 694 int get_fpexc_mode(struct task_struct *tsk, unsigned long adr) 695 { 696 unsigned int val; 697 698 if (tsk->thread.fpexc_mode & PR_FP_EXC_SW_ENABLE) 699 #ifdef CONFIG_SPE 700 val = tsk->thread.fpexc_mode; 701 #else 702 return -EINVAL; 703 #endif 704 else 705 val = __unpack_fe01(tsk->thread.fpexc_mode); 706 return put_user(val, (unsigned int __user *) adr); 707 } 708 709 int set_endian(struct task_struct *tsk, unsigned int val) 710 { 711 struct pt_regs *regs = tsk->thread.regs; 712 713 if ((val == PR_ENDIAN_LITTLE && !cpu_has_feature(CPU_FTR_REAL_LE)) || 714 (val == PR_ENDIAN_PPC_LITTLE && !cpu_has_feature(CPU_FTR_PPC_LE))) 715 return -EINVAL; 716 717 if (regs == NULL) 718 return -EINVAL; 719 720 if (val == PR_ENDIAN_BIG) 721 regs->msr &= ~MSR_LE; 722 else if (val == PR_ENDIAN_LITTLE || val == PR_ENDIAN_PPC_LITTLE) 723 regs->msr |= MSR_LE; 724 else 725 return -EINVAL; 726 727 return 0; 728 } 729 730 int get_endian(struct task_struct *tsk, unsigned long adr) 731 { 732 struct pt_regs *regs = tsk->thread.regs; 733 unsigned int val; 734 735 if (!cpu_has_feature(CPU_FTR_PPC_LE) && 736 !cpu_has_feature(CPU_FTR_REAL_LE)) 737 return -EINVAL; 738 739 if (regs == NULL) 740 return -EINVAL; 741 742 if (regs->msr & MSR_LE) { 743 if (cpu_has_feature(CPU_FTR_REAL_LE)) 744 val = PR_ENDIAN_LITTLE; 745 else 746 val = PR_ENDIAN_PPC_LITTLE; 747 } else 748 val = PR_ENDIAN_BIG; 749 750 return put_user(val, (unsigned int __user *)adr); 751 } 752 753 int set_unalign_ctl(struct task_struct *tsk, unsigned int val) 754 { 755 tsk->thread.align_ctl = val; 756 return 0; 757 } 758 759 int get_unalign_ctl(struct task_struct *tsk, unsigned long adr) 760 { 761 return put_user(tsk->thread.align_ctl, (unsigned int __user *)adr); 762 } 763 764 #define TRUNC_PTR(x) ((typeof(x))(((unsigned long)(x)) & 0xffffffff)) 765 766 int sys_clone(unsigned long clone_flags, unsigned long usp, 767 int __user *parent_tidp, void __user *child_threadptr, 768 int __user *child_tidp, int p6, 769 struct pt_regs *regs) 770 { 771 CHECK_FULL_REGS(regs); 772 if (usp == 0) 773 usp = regs->gpr[1]; /* stack pointer for child */ 774 #ifdef CONFIG_PPC64 775 if (test_thread_flag(TIF_32BIT)) { 776 parent_tidp = TRUNC_PTR(parent_tidp); 777 child_tidp = TRUNC_PTR(child_tidp); 778 } 779 #endif 780 return do_fork(clone_flags, usp, regs, 0, parent_tidp, child_tidp); 781 } 782 783 int sys_fork(unsigned long p1, unsigned long p2, unsigned long p3, 784 unsigned long p4, unsigned long p5, unsigned long p6, 785 struct pt_regs *regs) 786 { 787 CHECK_FULL_REGS(regs); 788 return do_fork(SIGCHLD, regs->gpr[1], regs, 0, NULL, NULL); 789 } 790 791 int sys_vfork(unsigned long p1, unsigned long p2, unsigned long p3, 792 unsigned long p4, unsigned long p5, unsigned long p6, 793 struct pt_regs *regs) 794 { 795 CHECK_FULL_REGS(regs); 796 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gpr[1], 797 regs, 0, NULL, NULL); 798 } 799 800 int sys_execve(unsigned long a0, unsigned long a1, unsigned long a2, 801 unsigned long a3, unsigned long a4, unsigned long a5, 802 struct pt_regs *regs) 803 { 804 int error; 805 char *filename; 806 807 filename = getname((char __user *) a0); 808 error = PTR_ERR(filename); 809 if (IS_ERR(filename)) 810 goto out; 811 flush_fp_to_thread(current); 812 flush_altivec_to_thread(current); 813 flush_spe_to_thread(current); 814 error = do_execve(filename, (char __user * __user *) a1, 815 (char __user * __user *) a2, regs); 816 if (error == 0) { 817 task_lock(current); 818 current->ptrace &= ~PT_DTRACE; 819 task_unlock(current); 820 } 821 putname(filename); 822 out: 823 return error; 824 } 825 826 int validate_sp(unsigned long sp, struct task_struct *p, 827 unsigned long nbytes) 828 { 829 unsigned long stack_page = (unsigned long)task_stack_page(p); 830 831 if (sp >= stack_page + sizeof(struct thread_struct) 832 && sp <= stack_page + THREAD_SIZE - nbytes) 833 return 1; 834 835 #ifdef CONFIG_IRQSTACKS 836 stack_page = (unsigned long) hardirq_ctx[task_cpu(p)]; 837 if (sp >= stack_page + sizeof(struct thread_struct) 838 && sp <= stack_page + THREAD_SIZE - nbytes) 839 return 1; 840 841 stack_page = (unsigned long) softirq_ctx[task_cpu(p)]; 842 if (sp >= stack_page + sizeof(struct thread_struct) 843 && sp <= stack_page + THREAD_SIZE - nbytes) 844 return 1; 845 #endif 846 847 return 0; 848 } 849 850 #ifdef CONFIG_PPC64 851 #define MIN_STACK_FRAME 112 /* same as STACK_FRAME_OVERHEAD, in fact */ 852 #define FRAME_LR_SAVE 2 853 #define INT_FRAME_SIZE (sizeof(struct pt_regs) + STACK_FRAME_OVERHEAD + 288) 854 #define REGS_MARKER 0x7265677368657265ul 855 #define FRAME_MARKER 12 856 #else 857 #define MIN_STACK_FRAME 16 858 #define FRAME_LR_SAVE 1 859 #define INT_FRAME_SIZE (sizeof(struct pt_regs) + STACK_FRAME_OVERHEAD) 860 #define REGS_MARKER 0x72656773ul 861 #define FRAME_MARKER 2 862 #endif 863 864 EXPORT_SYMBOL(validate_sp); 865 866 unsigned long get_wchan(struct task_struct *p) 867 { 868 unsigned long ip, sp; 869 int count = 0; 870 871 if (!p || p == current || p->state == TASK_RUNNING) 872 return 0; 873 874 sp = p->thread.ksp; 875 if (!validate_sp(sp, p, MIN_STACK_FRAME)) 876 return 0; 877 878 do { 879 sp = *(unsigned long *)sp; 880 if (!validate_sp(sp, p, MIN_STACK_FRAME)) 881 return 0; 882 if (count > 0) { 883 ip = ((unsigned long *)sp)[FRAME_LR_SAVE]; 884 if (!in_sched_functions(ip)) 885 return ip; 886 } 887 } while (count++ < 16); 888 return 0; 889 } 890 891 static int kstack_depth_to_print = 64; 892 893 void show_stack(struct task_struct *tsk, unsigned long *stack) 894 { 895 unsigned long sp, ip, lr, newsp; 896 int count = 0; 897 int firstframe = 1; 898 899 sp = (unsigned long) stack; 900 if (tsk == NULL) 901 tsk = current; 902 if (sp == 0) { 903 if (tsk == current) 904 asm("mr %0,1" : "=r" (sp)); 905 else 906 sp = tsk->thread.ksp; 907 } 908 909 lr = 0; 910 printk("Call Trace:\n"); 911 do { 912 if (!validate_sp(sp, tsk, MIN_STACK_FRAME)) 913 return; 914 915 stack = (unsigned long *) sp; 916 newsp = stack[0]; 917 ip = stack[FRAME_LR_SAVE]; 918 if (!firstframe || ip != lr) { 919 printk("["REG"] ["REG"] ", sp, ip); 920 print_symbol("%s", ip); 921 if (firstframe) 922 printk(" (unreliable)"); 923 printk("\n"); 924 } 925 firstframe = 0; 926 927 /* 928 * See if this is an exception frame. 929 * We look for the "regshere" marker in the current frame. 930 */ 931 if (validate_sp(sp, tsk, INT_FRAME_SIZE) 932 && stack[FRAME_MARKER] == REGS_MARKER) { 933 struct pt_regs *regs = (struct pt_regs *) 934 (sp + STACK_FRAME_OVERHEAD); 935 printk("--- Exception: %lx", regs->trap); 936 print_symbol(" at %s\n", regs->nip); 937 lr = regs->link; 938 print_symbol(" LR = %s\n", lr); 939 firstframe = 1; 940 } 941 942 sp = newsp; 943 } while (count++ < kstack_depth_to_print); 944 } 945 946 void dump_stack(void) 947 { 948 show_stack(current, NULL); 949 } 950 EXPORT_SYMBOL(dump_stack); 951 952 #ifdef CONFIG_PPC64 953 void ppc64_runlatch_on(void) 954 { 955 unsigned long ctrl; 956 957 if (cpu_has_feature(CPU_FTR_CTRL) && !test_thread_flag(TIF_RUNLATCH)) { 958 HMT_medium(); 959 960 ctrl = mfspr(SPRN_CTRLF); 961 ctrl |= CTRL_RUNLATCH; 962 mtspr(SPRN_CTRLT, ctrl); 963 964 set_thread_flag(TIF_RUNLATCH); 965 } 966 } 967 968 void ppc64_runlatch_off(void) 969 { 970 unsigned long ctrl; 971 972 if (cpu_has_feature(CPU_FTR_CTRL) && test_thread_flag(TIF_RUNLATCH)) { 973 HMT_medium(); 974 975 clear_thread_flag(TIF_RUNLATCH); 976 977 ctrl = mfspr(SPRN_CTRLF); 978 ctrl &= ~CTRL_RUNLATCH; 979 mtspr(SPRN_CTRLT, ctrl); 980 } 981 } 982 #endif 983