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 (t->flags & _TIF_ABI_PENDING) 469 t->flags ^= (_TIF_ABI_PENDING | _TIF_32BIT); 470 #endif 471 472 discard_lazy_cpu_state(); 473 474 #ifdef CONFIG_PPC64 /* for now */ 475 if (current->thread.dabr) { 476 current->thread.dabr = 0; 477 set_dabr(0); 478 } 479 #endif 480 } 481 482 void 483 release_thread(struct task_struct *t) 484 { 485 } 486 487 /* 488 * This gets called before we allocate a new thread and copy 489 * the current task into it. 490 */ 491 void prepare_to_copy(struct task_struct *tsk) 492 { 493 flush_fp_to_thread(current); 494 flush_altivec_to_thread(current); 495 flush_spe_to_thread(current); 496 } 497 498 /* 499 * Copy a thread.. 500 */ 501 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp, 502 unsigned long unused, struct task_struct *p, 503 struct pt_regs *regs) 504 { 505 struct pt_regs *childregs, *kregs; 506 extern void ret_from_fork(void); 507 unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE; 508 509 CHECK_FULL_REGS(regs); 510 /* Copy registers */ 511 sp -= sizeof(struct pt_regs); 512 childregs = (struct pt_regs *) sp; 513 *childregs = *regs; 514 if ((childregs->msr & MSR_PR) == 0) { 515 /* for kernel thread, set `current' and stackptr in new task */ 516 childregs->gpr[1] = sp + sizeof(struct pt_regs); 517 #ifdef CONFIG_PPC32 518 childregs->gpr[2] = (unsigned long) p; 519 #else 520 clear_tsk_thread_flag(p, TIF_32BIT); 521 #endif 522 p->thread.regs = NULL; /* no user register state */ 523 } else { 524 childregs->gpr[1] = usp; 525 p->thread.regs = childregs; 526 if (clone_flags & CLONE_SETTLS) { 527 #ifdef CONFIG_PPC64 528 if (!test_thread_flag(TIF_32BIT)) 529 childregs->gpr[13] = childregs->gpr[6]; 530 else 531 #endif 532 childregs->gpr[2] = childregs->gpr[6]; 533 } 534 } 535 childregs->gpr[3] = 0; /* Result from fork() */ 536 sp -= STACK_FRAME_OVERHEAD; 537 538 /* 539 * The way this works is that at some point in the future 540 * some task will call _switch to switch to the new task. 541 * That will pop off the stack frame created below and start 542 * the new task running at ret_from_fork. The new task will 543 * do some house keeping and then return from the fork or clone 544 * system call, using the stack frame created above. 545 */ 546 sp -= sizeof(struct pt_regs); 547 kregs = (struct pt_regs *) sp; 548 sp -= STACK_FRAME_OVERHEAD; 549 p->thread.ksp = sp; 550 551 #ifdef CONFIG_PPC64 552 if (cpu_has_feature(CPU_FTR_SLB)) { 553 unsigned long sp_vsid = get_kernel_vsid(sp); 554 unsigned long llp = mmu_psize_defs[mmu_linear_psize].sllp; 555 556 sp_vsid <<= SLB_VSID_SHIFT; 557 sp_vsid |= SLB_VSID_KERNEL | llp; 558 p->thread.ksp_vsid = sp_vsid; 559 } 560 561 /* 562 * The PPC64 ABI makes use of a TOC to contain function 563 * pointers. The function (ret_from_except) is actually a pointer 564 * to the TOC entry. The first entry is a pointer to the actual 565 * function. 566 */ 567 kregs->nip = *((unsigned long *)ret_from_fork); 568 #else 569 kregs->nip = (unsigned long)ret_from_fork; 570 p->thread.last_syscall = -1; 571 #endif 572 573 return 0; 574 } 575 576 /* 577 * Set up a thread for executing a new program 578 */ 579 void start_thread(struct pt_regs *regs, unsigned long start, unsigned long sp) 580 { 581 #ifdef CONFIG_PPC64 582 unsigned long load_addr = regs->gpr[2]; /* saved by ELF_PLAT_INIT */ 583 #endif 584 585 set_fs(USER_DS); 586 587 /* 588 * If we exec out of a kernel thread then thread.regs will not be 589 * set. Do it now. 590 */ 591 if (!current->thread.regs) { 592 struct pt_regs *regs = task_stack_page(current) + THREAD_SIZE; 593 current->thread.regs = regs - 1; 594 } 595 596 memset(regs->gpr, 0, sizeof(regs->gpr)); 597 regs->ctr = 0; 598 regs->link = 0; 599 regs->xer = 0; 600 regs->ccr = 0; 601 regs->gpr[1] = sp; 602 603 #ifdef CONFIG_PPC32 604 regs->mq = 0; 605 regs->nip = start; 606 regs->msr = MSR_USER; 607 #else 608 if (!test_thread_flag(TIF_32BIT)) { 609 unsigned long entry, toc; 610 611 /* start is a relocated pointer to the function descriptor for 612 * the elf _start routine. The first entry in the function 613 * descriptor is the entry address of _start and the second 614 * entry is the TOC value we need to use. 615 */ 616 __get_user(entry, (unsigned long __user *)start); 617 __get_user(toc, (unsigned long __user *)start+1); 618 619 /* Check whether the e_entry function descriptor entries 620 * need to be relocated before we can use them. 621 */ 622 if (load_addr != 0) { 623 entry += load_addr; 624 toc += load_addr; 625 } 626 regs->nip = entry; 627 regs->gpr[2] = toc; 628 regs->msr = MSR_USER64; 629 } else { 630 regs->nip = start; 631 regs->gpr[2] = 0; 632 regs->msr = MSR_USER32; 633 } 634 #endif 635 636 discard_lazy_cpu_state(); 637 memset(current->thread.fpr, 0, sizeof(current->thread.fpr)); 638 current->thread.fpscr.val = 0; 639 #ifdef CONFIG_ALTIVEC 640 memset(current->thread.vr, 0, sizeof(current->thread.vr)); 641 memset(¤t->thread.vscr, 0, sizeof(current->thread.vscr)); 642 current->thread.vscr.u[3] = 0x00010000; /* Java mode disabled */ 643 current->thread.vrsave = 0; 644 current->thread.used_vr = 0; 645 #endif /* CONFIG_ALTIVEC */ 646 #ifdef CONFIG_SPE 647 memset(current->thread.evr, 0, sizeof(current->thread.evr)); 648 current->thread.acc = 0; 649 current->thread.spefscr = 0; 650 current->thread.used_spe = 0; 651 #endif /* CONFIG_SPE */ 652 } 653 654 #define PR_FP_ALL_EXCEPT (PR_FP_EXC_DIV | PR_FP_EXC_OVF | PR_FP_EXC_UND \ 655 | PR_FP_EXC_RES | PR_FP_EXC_INV) 656 657 int set_fpexc_mode(struct task_struct *tsk, unsigned int val) 658 { 659 struct pt_regs *regs = tsk->thread.regs; 660 661 /* This is a bit hairy. If we are an SPE enabled processor 662 * (have embedded fp) we store the IEEE exception enable flags in 663 * fpexc_mode. fpexc_mode is also used for setting FP exception 664 * mode (asyn, precise, disabled) for 'Classic' FP. */ 665 if (val & PR_FP_EXC_SW_ENABLE) { 666 #ifdef CONFIG_SPE 667 tsk->thread.fpexc_mode = val & 668 (PR_FP_EXC_SW_ENABLE | PR_FP_ALL_EXCEPT); 669 return 0; 670 #else 671 return -EINVAL; 672 #endif 673 } 674 675 /* on a CONFIG_SPE this does not hurt us. The bits that 676 * __pack_fe01 use do not overlap with bits used for 677 * PR_FP_EXC_SW_ENABLE. Additionally, the MSR[FE0,FE1] bits 678 * on CONFIG_SPE implementations are reserved so writing to 679 * them does not change anything */ 680 if (val > PR_FP_EXC_PRECISE) 681 return -EINVAL; 682 tsk->thread.fpexc_mode = __pack_fe01(val); 683 if (regs != NULL && (regs->msr & MSR_FP) != 0) 684 regs->msr = (regs->msr & ~(MSR_FE0|MSR_FE1)) 685 | tsk->thread.fpexc_mode; 686 return 0; 687 } 688 689 int get_fpexc_mode(struct task_struct *tsk, unsigned long adr) 690 { 691 unsigned int val; 692 693 if (tsk->thread.fpexc_mode & PR_FP_EXC_SW_ENABLE) 694 #ifdef CONFIG_SPE 695 val = tsk->thread.fpexc_mode; 696 #else 697 return -EINVAL; 698 #endif 699 else 700 val = __unpack_fe01(tsk->thread.fpexc_mode); 701 return put_user(val, (unsigned int __user *) adr); 702 } 703 704 int set_endian(struct task_struct *tsk, unsigned int val) 705 { 706 struct pt_regs *regs = tsk->thread.regs; 707 708 if ((val == PR_ENDIAN_LITTLE && !cpu_has_feature(CPU_FTR_REAL_LE)) || 709 (val == PR_ENDIAN_PPC_LITTLE && !cpu_has_feature(CPU_FTR_PPC_LE))) 710 return -EINVAL; 711 712 if (regs == NULL) 713 return -EINVAL; 714 715 if (val == PR_ENDIAN_BIG) 716 regs->msr &= ~MSR_LE; 717 else if (val == PR_ENDIAN_LITTLE || val == PR_ENDIAN_PPC_LITTLE) 718 regs->msr |= MSR_LE; 719 else 720 return -EINVAL; 721 722 return 0; 723 } 724 725 int get_endian(struct task_struct *tsk, unsigned long adr) 726 { 727 struct pt_regs *regs = tsk->thread.regs; 728 unsigned int val; 729 730 if (!cpu_has_feature(CPU_FTR_PPC_LE) && 731 !cpu_has_feature(CPU_FTR_REAL_LE)) 732 return -EINVAL; 733 734 if (regs == NULL) 735 return -EINVAL; 736 737 if (regs->msr & MSR_LE) { 738 if (cpu_has_feature(CPU_FTR_REAL_LE)) 739 val = PR_ENDIAN_LITTLE; 740 else 741 val = PR_ENDIAN_PPC_LITTLE; 742 } else 743 val = PR_ENDIAN_BIG; 744 745 return put_user(val, (unsigned int __user *)adr); 746 } 747 748 int set_unalign_ctl(struct task_struct *tsk, unsigned int val) 749 { 750 tsk->thread.align_ctl = val; 751 return 0; 752 } 753 754 int get_unalign_ctl(struct task_struct *tsk, unsigned long adr) 755 { 756 return put_user(tsk->thread.align_ctl, (unsigned int __user *)adr); 757 } 758 759 #define TRUNC_PTR(x) ((typeof(x))(((unsigned long)(x)) & 0xffffffff)) 760 761 int sys_clone(unsigned long clone_flags, unsigned long usp, 762 int __user *parent_tidp, void __user *child_threadptr, 763 int __user *child_tidp, int p6, 764 struct pt_regs *regs) 765 { 766 CHECK_FULL_REGS(regs); 767 if (usp == 0) 768 usp = regs->gpr[1]; /* stack pointer for child */ 769 #ifdef CONFIG_PPC64 770 if (test_thread_flag(TIF_32BIT)) { 771 parent_tidp = TRUNC_PTR(parent_tidp); 772 child_tidp = TRUNC_PTR(child_tidp); 773 } 774 #endif 775 return do_fork(clone_flags, usp, regs, 0, parent_tidp, child_tidp); 776 } 777 778 int sys_fork(unsigned long p1, unsigned long p2, unsigned long p3, 779 unsigned long p4, unsigned long p5, unsigned long p6, 780 struct pt_regs *regs) 781 { 782 CHECK_FULL_REGS(regs); 783 return do_fork(SIGCHLD, regs->gpr[1], regs, 0, NULL, NULL); 784 } 785 786 int sys_vfork(unsigned long p1, unsigned long p2, unsigned long p3, 787 unsigned long p4, unsigned long p5, unsigned long p6, 788 struct pt_regs *regs) 789 { 790 CHECK_FULL_REGS(regs); 791 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gpr[1], 792 regs, 0, NULL, NULL); 793 } 794 795 int sys_execve(unsigned long a0, unsigned long a1, unsigned long a2, 796 unsigned long a3, unsigned long a4, unsigned long a5, 797 struct pt_regs *regs) 798 { 799 int error; 800 char *filename; 801 802 filename = getname((char __user *) a0); 803 error = PTR_ERR(filename); 804 if (IS_ERR(filename)) 805 goto out; 806 flush_fp_to_thread(current); 807 flush_altivec_to_thread(current); 808 flush_spe_to_thread(current); 809 error = do_execve(filename, (char __user * __user *) a1, 810 (char __user * __user *) a2, regs); 811 if (error == 0) { 812 task_lock(current); 813 current->ptrace &= ~PT_DTRACE; 814 task_unlock(current); 815 } 816 putname(filename); 817 out: 818 return error; 819 } 820 821 int validate_sp(unsigned long sp, struct task_struct *p, 822 unsigned long nbytes) 823 { 824 unsigned long stack_page = (unsigned long)task_stack_page(p); 825 826 if (sp >= stack_page + sizeof(struct thread_struct) 827 && sp <= stack_page + THREAD_SIZE - nbytes) 828 return 1; 829 830 #ifdef CONFIG_IRQSTACKS 831 stack_page = (unsigned long) hardirq_ctx[task_cpu(p)]; 832 if (sp >= stack_page + sizeof(struct thread_struct) 833 && sp <= stack_page + THREAD_SIZE - nbytes) 834 return 1; 835 836 stack_page = (unsigned long) softirq_ctx[task_cpu(p)]; 837 if (sp >= stack_page + sizeof(struct thread_struct) 838 && sp <= stack_page + THREAD_SIZE - nbytes) 839 return 1; 840 #endif 841 842 return 0; 843 } 844 845 #ifdef CONFIG_PPC64 846 #define MIN_STACK_FRAME 112 /* same as STACK_FRAME_OVERHEAD, in fact */ 847 #define FRAME_LR_SAVE 2 848 #define INT_FRAME_SIZE (sizeof(struct pt_regs) + STACK_FRAME_OVERHEAD + 288) 849 #define REGS_MARKER 0x7265677368657265ul 850 #define FRAME_MARKER 12 851 #else 852 #define MIN_STACK_FRAME 16 853 #define FRAME_LR_SAVE 1 854 #define INT_FRAME_SIZE (sizeof(struct pt_regs) + STACK_FRAME_OVERHEAD) 855 #define REGS_MARKER 0x72656773ul 856 #define FRAME_MARKER 2 857 #endif 858 859 EXPORT_SYMBOL(validate_sp); 860 861 unsigned long get_wchan(struct task_struct *p) 862 { 863 unsigned long ip, sp; 864 int count = 0; 865 866 if (!p || p == current || p->state == TASK_RUNNING) 867 return 0; 868 869 sp = p->thread.ksp; 870 if (!validate_sp(sp, p, MIN_STACK_FRAME)) 871 return 0; 872 873 do { 874 sp = *(unsigned long *)sp; 875 if (!validate_sp(sp, p, MIN_STACK_FRAME)) 876 return 0; 877 if (count > 0) { 878 ip = ((unsigned long *)sp)[FRAME_LR_SAVE]; 879 if (!in_sched_functions(ip)) 880 return ip; 881 } 882 } while (count++ < 16); 883 return 0; 884 } 885 886 static int kstack_depth_to_print = 64; 887 888 void show_stack(struct task_struct *tsk, unsigned long *stack) 889 { 890 unsigned long sp, ip, lr, newsp; 891 int count = 0; 892 int firstframe = 1; 893 894 sp = (unsigned long) stack; 895 if (tsk == NULL) 896 tsk = current; 897 if (sp == 0) { 898 if (tsk == current) 899 asm("mr %0,1" : "=r" (sp)); 900 else 901 sp = tsk->thread.ksp; 902 } 903 904 lr = 0; 905 printk("Call Trace:\n"); 906 do { 907 if (!validate_sp(sp, tsk, MIN_STACK_FRAME)) 908 return; 909 910 stack = (unsigned long *) sp; 911 newsp = stack[0]; 912 ip = stack[FRAME_LR_SAVE]; 913 if (!firstframe || ip != lr) { 914 printk("["REG"] ["REG"] ", sp, ip); 915 print_symbol("%s", ip); 916 if (firstframe) 917 printk(" (unreliable)"); 918 printk("\n"); 919 } 920 firstframe = 0; 921 922 /* 923 * See if this is an exception frame. 924 * We look for the "regshere" marker in the current frame. 925 */ 926 if (validate_sp(sp, tsk, INT_FRAME_SIZE) 927 && stack[FRAME_MARKER] == REGS_MARKER) { 928 struct pt_regs *regs = (struct pt_regs *) 929 (sp + STACK_FRAME_OVERHEAD); 930 printk("--- Exception: %lx", regs->trap); 931 print_symbol(" at %s\n", regs->nip); 932 lr = regs->link; 933 print_symbol(" LR = %s\n", lr); 934 firstframe = 1; 935 } 936 937 sp = newsp; 938 } while (count++ < kstack_depth_to_print); 939 } 940 941 void dump_stack(void) 942 { 943 show_stack(current, NULL); 944 } 945 EXPORT_SYMBOL(dump_stack); 946 947 #ifdef CONFIG_PPC64 948 void ppc64_runlatch_on(void) 949 { 950 unsigned long ctrl; 951 952 if (cpu_has_feature(CPU_FTR_CTRL) && !test_thread_flag(TIF_RUNLATCH)) { 953 HMT_medium(); 954 955 ctrl = mfspr(SPRN_CTRLF); 956 ctrl |= CTRL_RUNLATCH; 957 mtspr(SPRN_CTRLT, ctrl); 958 959 set_thread_flag(TIF_RUNLATCH); 960 } 961 } 962 963 void ppc64_runlatch_off(void) 964 { 965 unsigned long ctrl; 966 967 if (cpu_has_feature(CPU_FTR_CTRL) && test_thread_flag(TIF_RUNLATCH)) { 968 HMT_medium(); 969 970 clear_thread_flag(TIF_RUNLATCH); 971 972 ctrl = mfspr(SPRN_CTRLF); 973 ctrl &= ~CTRL_RUNLATCH; 974 mtspr(SPRN_CTRLT, ctrl); 975 } 976 } 977 #endif 978