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 #endif /* CONFIG_PPC64 */ 309 310 new_thread = &new->thread; 311 old_thread = ¤t->thread; 312 313 #ifdef CONFIG_PPC64 314 /* 315 * Collect processor utilization data per process 316 */ 317 if (firmware_has_feature(FW_FEATURE_SPLPAR)) { 318 struct cpu_usage *cu = &__get_cpu_var(cpu_usage_array); 319 long unsigned start_tb, current_tb; 320 start_tb = old_thread->start_tb; 321 cu->current_tb = current_tb = mfspr(SPRN_PURR); 322 old_thread->accum_tb += (current_tb - start_tb); 323 new_thread->start_tb = current_tb; 324 } 325 #endif 326 327 local_irq_save(flags); 328 329 account_system_vtime(current); 330 account_process_vtime(current); 331 calculate_steal_time(); 332 333 last = _switch(old_thread, new_thread); 334 335 local_irq_restore(flags); 336 337 return last; 338 } 339 340 static int instructions_to_print = 16; 341 342 static void show_instructions(struct pt_regs *regs) 343 { 344 int i; 345 unsigned long pc = regs->nip - (instructions_to_print * 3 / 4 * 346 sizeof(int)); 347 348 printk("Instruction dump:"); 349 350 for (i = 0; i < instructions_to_print; i++) { 351 int instr; 352 353 if (!(i % 8)) 354 printk("\n"); 355 356 /* We use __get_user here *only* to avoid an OOPS on a 357 * bad address because the pc *should* only be a 358 * kernel address. 359 */ 360 if (!__kernel_text_address(pc) || 361 __get_user(instr, (unsigned int __user *)pc)) { 362 printk("XXXXXXXX "); 363 } else { 364 if (regs->nip == pc) 365 printk("<%08x> ", instr); 366 else 367 printk("%08x ", instr); 368 } 369 370 pc += sizeof(int); 371 } 372 373 printk("\n"); 374 } 375 376 static struct regbit { 377 unsigned long bit; 378 const char *name; 379 } msr_bits[] = { 380 {MSR_EE, "EE"}, 381 {MSR_PR, "PR"}, 382 {MSR_FP, "FP"}, 383 {MSR_ME, "ME"}, 384 {MSR_IR, "IR"}, 385 {MSR_DR, "DR"}, 386 {0, NULL} 387 }; 388 389 static void printbits(unsigned long val, struct regbit *bits) 390 { 391 const char *sep = ""; 392 393 printk("<"); 394 for (; bits->bit; ++bits) 395 if (val & bits->bit) { 396 printk("%s%s", sep, bits->name); 397 sep = ","; 398 } 399 printk(">"); 400 } 401 402 #ifdef CONFIG_PPC64 403 #define REG "%016lx" 404 #define REGS_PER_LINE 4 405 #define LAST_VOLATILE 13 406 #else 407 #define REG "%08lx" 408 #define REGS_PER_LINE 8 409 #define LAST_VOLATILE 12 410 #endif 411 412 void show_regs(struct pt_regs * regs) 413 { 414 int i, trap; 415 416 printk("NIP: "REG" LR: "REG" CTR: "REG"\n", 417 regs->nip, regs->link, regs->ctr); 418 printk("REGS: %p TRAP: %04lx %s (%s)\n", 419 regs, regs->trap, print_tainted(), init_utsname()->release); 420 printk("MSR: "REG" ", regs->msr); 421 printbits(regs->msr, msr_bits); 422 printk(" CR: %08lx XER: %08lx\n", regs->ccr, regs->xer); 423 trap = TRAP(regs); 424 if (trap == 0x300 || trap == 0x600) 425 printk("DAR: "REG", DSISR: "REG"\n", regs->dar, regs->dsisr); 426 printk("TASK = %p[%d] '%s' THREAD: %p", 427 current, current->pid, current->comm, task_thread_info(current)); 428 429 #ifdef CONFIG_SMP 430 printk(" CPU: %d", smp_processor_id()); 431 #endif /* CONFIG_SMP */ 432 433 for (i = 0; i < 32; i++) { 434 if ((i % REGS_PER_LINE) == 0) 435 printk("\n" KERN_INFO "GPR%02d: ", i); 436 printk(REG " ", regs->gpr[i]); 437 if (i == LAST_VOLATILE && !FULL_REGS(regs)) 438 break; 439 } 440 printk("\n"); 441 #ifdef CONFIG_KALLSYMS 442 /* 443 * Lookup NIP late so we have the best change of getting the 444 * above info out without failing 445 */ 446 printk("NIP ["REG"] ", regs->nip); 447 print_symbol("%s\n", regs->nip); 448 printk("LR ["REG"] ", regs->link); 449 print_symbol("%s\n", regs->link); 450 #endif 451 show_stack(current, (unsigned long *) regs->gpr[1]); 452 if (!user_mode(regs)) 453 show_instructions(regs); 454 } 455 456 void exit_thread(void) 457 { 458 discard_lazy_cpu_state(); 459 } 460 461 void flush_thread(void) 462 { 463 #ifdef CONFIG_PPC64 464 struct thread_info *t = current_thread_info(); 465 466 if (test_ti_thread_flag(t, TIF_ABI_PENDING)) { 467 clear_ti_thread_flag(t, TIF_ABI_PENDING); 468 if (test_ti_thread_flag(t, TIF_32BIT)) 469 clear_ti_thread_flag(t, TIF_32BIT); 470 else 471 set_ti_thread_flag(t, TIF_32BIT); 472 } 473 #endif 474 475 discard_lazy_cpu_state(); 476 477 #ifdef CONFIG_PPC64 /* for now */ 478 if (current->thread.dabr) { 479 current->thread.dabr = 0; 480 set_dabr(0); 481 } 482 #endif 483 } 484 485 void 486 release_thread(struct task_struct *t) 487 { 488 } 489 490 /* 491 * This gets called before we allocate a new thread and copy 492 * the current task into it. 493 */ 494 void prepare_to_copy(struct task_struct *tsk) 495 { 496 flush_fp_to_thread(current); 497 flush_altivec_to_thread(current); 498 flush_spe_to_thread(current); 499 } 500 501 /* 502 * Copy a thread.. 503 */ 504 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp, 505 unsigned long unused, struct task_struct *p, 506 struct pt_regs *regs) 507 { 508 struct pt_regs *childregs, *kregs; 509 extern void ret_from_fork(void); 510 unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE; 511 512 CHECK_FULL_REGS(regs); 513 /* Copy registers */ 514 sp -= sizeof(struct pt_regs); 515 childregs = (struct pt_regs *) sp; 516 *childregs = *regs; 517 if ((childregs->msr & MSR_PR) == 0) { 518 /* for kernel thread, set `current' and stackptr in new task */ 519 childregs->gpr[1] = sp + sizeof(struct pt_regs); 520 #ifdef CONFIG_PPC32 521 childregs->gpr[2] = (unsigned long) p; 522 #else 523 clear_tsk_thread_flag(p, TIF_32BIT); 524 #endif 525 p->thread.regs = NULL; /* no user register state */ 526 } else { 527 childregs->gpr[1] = usp; 528 p->thread.regs = childregs; 529 if (clone_flags & CLONE_SETTLS) { 530 #ifdef CONFIG_PPC64 531 if (!test_thread_flag(TIF_32BIT)) 532 childregs->gpr[13] = childregs->gpr[6]; 533 else 534 #endif 535 childregs->gpr[2] = childregs->gpr[6]; 536 } 537 } 538 childregs->gpr[3] = 0; /* Result from fork() */ 539 sp -= STACK_FRAME_OVERHEAD; 540 541 /* 542 * The way this works is that at some point in the future 543 * some task will call _switch to switch to the new task. 544 * That will pop off the stack frame created below and start 545 * the new task running at ret_from_fork. The new task will 546 * do some house keeping and then return from the fork or clone 547 * system call, using the stack frame created above. 548 */ 549 sp -= sizeof(struct pt_regs); 550 kregs = (struct pt_regs *) sp; 551 sp -= STACK_FRAME_OVERHEAD; 552 p->thread.ksp = sp; 553 554 #ifdef CONFIG_PPC64 555 if (cpu_has_feature(CPU_FTR_SLB)) { 556 unsigned long sp_vsid = get_kernel_vsid(sp); 557 unsigned long llp = mmu_psize_defs[mmu_linear_psize].sllp; 558 559 sp_vsid <<= SLB_VSID_SHIFT; 560 sp_vsid |= SLB_VSID_KERNEL | llp; 561 p->thread.ksp_vsid = sp_vsid; 562 } 563 564 /* 565 * The PPC64 ABI makes use of a TOC to contain function 566 * pointers. The function (ret_from_except) is actually a pointer 567 * to the TOC entry. The first entry is a pointer to the actual 568 * function. 569 */ 570 kregs->nip = *((unsigned long *)ret_from_fork); 571 #else 572 kregs->nip = (unsigned long)ret_from_fork; 573 #endif 574 575 return 0; 576 } 577 578 /* 579 * Set up a thread for executing a new program 580 */ 581 void start_thread(struct pt_regs *regs, unsigned long start, unsigned long sp) 582 { 583 #ifdef CONFIG_PPC64 584 unsigned long load_addr = regs->gpr[2]; /* saved by ELF_PLAT_INIT */ 585 #endif 586 587 set_fs(USER_DS); 588 589 /* 590 * If we exec out of a kernel thread then thread.regs will not be 591 * set. Do it now. 592 */ 593 if (!current->thread.regs) { 594 struct pt_regs *regs = task_stack_page(current) + THREAD_SIZE; 595 current->thread.regs = regs - 1; 596 } 597 598 memset(regs->gpr, 0, sizeof(regs->gpr)); 599 regs->ctr = 0; 600 regs->link = 0; 601 regs->xer = 0; 602 regs->ccr = 0; 603 regs->gpr[1] = sp; 604 605 #ifdef CONFIG_PPC32 606 regs->mq = 0; 607 regs->nip = start; 608 regs->msr = MSR_USER; 609 #else 610 if (!test_thread_flag(TIF_32BIT)) { 611 unsigned long entry, toc; 612 613 /* start is a relocated pointer to the function descriptor for 614 * the elf _start routine. The first entry in the function 615 * descriptor is the entry address of _start and the second 616 * entry is the TOC value we need to use. 617 */ 618 __get_user(entry, (unsigned long __user *)start); 619 __get_user(toc, (unsigned long __user *)start+1); 620 621 /* Check whether the e_entry function descriptor entries 622 * need to be relocated before we can use them. 623 */ 624 if (load_addr != 0) { 625 entry += load_addr; 626 toc += load_addr; 627 } 628 regs->nip = entry; 629 regs->gpr[2] = toc; 630 regs->msr = MSR_USER64; 631 } else { 632 regs->nip = start; 633 regs->gpr[2] = 0; 634 regs->msr = MSR_USER32; 635 } 636 #endif 637 638 discard_lazy_cpu_state(); 639 memset(current->thread.fpr, 0, sizeof(current->thread.fpr)); 640 current->thread.fpscr.val = 0; 641 #ifdef CONFIG_ALTIVEC 642 memset(current->thread.vr, 0, sizeof(current->thread.vr)); 643 memset(¤t->thread.vscr, 0, sizeof(current->thread.vscr)); 644 current->thread.vscr.u[3] = 0x00010000; /* Java mode disabled */ 645 current->thread.vrsave = 0; 646 current->thread.used_vr = 0; 647 #endif /* CONFIG_ALTIVEC */ 648 #ifdef CONFIG_SPE 649 memset(current->thread.evr, 0, sizeof(current->thread.evr)); 650 current->thread.acc = 0; 651 current->thread.spefscr = 0; 652 current->thread.used_spe = 0; 653 #endif /* CONFIG_SPE */ 654 } 655 656 #define PR_FP_ALL_EXCEPT (PR_FP_EXC_DIV | PR_FP_EXC_OVF | PR_FP_EXC_UND \ 657 | PR_FP_EXC_RES | PR_FP_EXC_INV) 658 659 int set_fpexc_mode(struct task_struct *tsk, unsigned int val) 660 { 661 struct pt_regs *regs = tsk->thread.regs; 662 663 /* This is a bit hairy. If we are an SPE enabled processor 664 * (have embedded fp) we store the IEEE exception enable flags in 665 * fpexc_mode. fpexc_mode is also used for setting FP exception 666 * mode (asyn, precise, disabled) for 'Classic' FP. */ 667 if (val & PR_FP_EXC_SW_ENABLE) { 668 #ifdef CONFIG_SPE 669 tsk->thread.fpexc_mode = val & 670 (PR_FP_EXC_SW_ENABLE | PR_FP_ALL_EXCEPT); 671 return 0; 672 #else 673 return -EINVAL; 674 #endif 675 } 676 677 /* on a CONFIG_SPE this does not hurt us. The bits that 678 * __pack_fe01 use do not overlap with bits used for 679 * PR_FP_EXC_SW_ENABLE. Additionally, the MSR[FE0,FE1] bits 680 * on CONFIG_SPE implementations are reserved so writing to 681 * them does not change anything */ 682 if (val > PR_FP_EXC_PRECISE) 683 return -EINVAL; 684 tsk->thread.fpexc_mode = __pack_fe01(val); 685 if (regs != NULL && (regs->msr & MSR_FP) != 0) 686 regs->msr = (regs->msr & ~(MSR_FE0|MSR_FE1)) 687 | tsk->thread.fpexc_mode; 688 return 0; 689 } 690 691 int get_fpexc_mode(struct task_struct *tsk, unsigned long adr) 692 { 693 unsigned int val; 694 695 if (tsk->thread.fpexc_mode & PR_FP_EXC_SW_ENABLE) 696 #ifdef CONFIG_SPE 697 val = tsk->thread.fpexc_mode; 698 #else 699 return -EINVAL; 700 #endif 701 else 702 val = __unpack_fe01(tsk->thread.fpexc_mode); 703 return put_user(val, (unsigned int __user *) adr); 704 } 705 706 int set_endian(struct task_struct *tsk, unsigned int val) 707 { 708 struct pt_regs *regs = tsk->thread.regs; 709 710 if ((val == PR_ENDIAN_LITTLE && !cpu_has_feature(CPU_FTR_REAL_LE)) || 711 (val == PR_ENDIAN_PPC_LITTLE && !cpu_has_feature(CPU_FTR_PPC_LE))) 712 return -EINVAL; 713 714 if (regs == NULL) 715 return -EINVAL; 716 717 if (val == PR_ENDIAN_BIG) 718 regs->msr &= ~MSR_LE; 719 else if (val == PR_ENDIAN_LITTLE || val == PR_ENDIAN_PPC_LITTLE) 720 regs->msr |= MSR_LE; 721 else 722 return -EINVAL; 723 724 return 0; 725 } 726 727 int get_endian(struct task_struct *tsk, unsigned long adr) 728 { 729 struct pt_regs *regs = tsk->thread.regs; 730 unsigned int val; 731 732 if (!cpu_has_feature(CPU_FTR_PPC_LE) && 733 !cpu_has_feature(CPU_FTR_REAL_LE)) 734 return -EINVAL; 735 736 if (regs == NULL) 737 return -EINVAL; 738 739 if (regs->msr & MSR_LE) { 740 if (cpu_has_feature(CPU_FTR_REAL_LE)) 741 val = PR_ENDIAN_LITTLE; 742 else 743 val = PR_ENDIAN_PPC_LITTLE; 744 } else 745 val = PR_ENDIAN_BIG; 746 747 return put_user(val, (unsigned int __user *)adr); 748 } 749 750 int set_unalign_ctl(struct task_struct *tsk, unsigned int val) 751 { 752 tsk->thread.align_ctl = val; 753 return 0; 754 } 755 756 int get_unalign_ctl(struct task_struct *tsk, unsigned long adr) 757 { 758 return put_user(tsk->thread.align_ctl, (unsigned int __user *)adr); 759 } 760 761 #define TRUNC_PTR(x) ((typeof(x))(((unsigned long)(x)) & 0xffffffff)) 762 763 int sys_clone(unsigned long clone_flags, unsigned long usp, 764 int __user *parent_tidp, void __user *child_threadptr, 765 int __user *child_tidp, int p6, 766 struct pt_regs *regs) 767 { 768 CHECK_FULL_REGS(regs); 769 if (usp == 0) 770 usp = regs->gpr[1]; /* stack pointer for child */ 771 #ifdef CONFIG_PPC64 772 if (test_thread_flag(TIF_32BIT)) { 773 parent_tidp = TRUNC_PTR(parent_tidp); 774 child_tidp = TRUNC_PTR(child_tidp); 775 } 776 #endif 777 return do_fork(clone_flags, usp, regs, 0, parent_tidp, child_tidp); 778 } 779 780 int sys_fork(unsigned long p1, unsigned long p2, unsigned long p3, 781 unsigned long p4, unsigned long p5, unsigned long p6, 782 struct pt_regs *regs) 783 { 784 CHECK_FULL_REGS(regs); 785 return do_fork(SIGCHLD, regs->gpr[1], regs, 0, NULL, NULL); 786 } 787 788 int sys_vfork(unsigned long p1, unsigned long p2, unsigned long p3, 789 unsigned long p4, unsigned long p5, unsigned long p6, 790 struct pt_regs *regs) 791 { 792 CHECK_FULL_REGS(regs); 793 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gpr[1], 794 regs, 0, NULL, NULL); 795 } 796 797 int sys_execve(unsigned long a0, unsigned long a1, unsigned long a2, 798 unsigned long a3, unsigned long a4, unsigned long a5, 799 struct pt_regs *regs) 800 { 801 int error; 802 char *filename; 803 804 filename = getname((char __user *) a0); 805 error = PTR_ERR(filename); 806 if (IS_ERR(filename)) 807 goto out; 808 flush_fp_to_thread(current); 809 flush_altivec_to_thread(current); 810 flush_spe_to_thread(current); 811 error = do_execve(filename, (char __user * __user *) a1, 812 (char __user * __user *) a2, regs); 813 if (error == 0) { 814 task_lock(current); 815 current->ptrace &= ~PT_DTRACE; 816 task_unlock(current); 817 } 818 putname(filename); 819 out: 820 return error; 821 } 822 823 #ifdef CONFIG_IRQSTACKS 824 static inline int valid_irq_stack(unsigned long sp, struct task_struct *p, 825 unsigned long nbytes) 826 { 827 unsigned long stack_page; 828 unsigned long cpu = task_cpu(p); 829 830 /* 831 * Avoid crashing if the stack has overflowed and corrupted 832 * task_cpu(p), which is in the thread_info struct. 833 */ 834 if (cpu < NR_CPUS && cpu_possible(cpu)) { 835 stack_page = (unsigned long) hardirq_ctx[cpu]; 836 if (sp >= stack_page + sizeof(struct thread_struct) 837 && sp <= stack_page + THREAD_SIZE - nbytes) 838 return 1; 839 840 stack_page = (unsigned long) softirq_ctx[cpu]; 841 if (sp >= stack_page + sizeof(struct thread_struct) 842 && sp <= stack_page + THREAD_SIZE - nbytes) 843 return 1; 844 } 845 return 0; 846 } 847 848 #else 849 #define valid_irq_stack(sp, p, nb) 0 850 #endif /* CONFIG_IRQSTACKS */ 851 852 int validate_sp(unsigned long sp, struct task_struct *p, 853 unsigned long nbytes) 854 { 855 unsigned long stack_page = (unsigned long)task_stack_page(p); 856 857 if (sp >= stack_page + sizeof(struct thread_struct) 858 && sp <= stack_page + THREAD_SIZE - nbytes) 859 return 1; 860 861 return valid_irq_stack(sp, p, nbytes); 862 } 863 864 #ifdef CONFIG_PPC64 865 #define MIN_STACK_FRAME 112 /* same as STACK_FRAME_OVERHEAD, in fact */ 866 #define FRAME_LR_SAVE 2 867 #define INT_FRAME_SIZE (sizeof(struct pt_regs) + STACK_FRAME_OVERHEAD + 288) 868 #define REGS_MARKER 0x7265677368657265ul 869 #define FRAME_MARKER 12 870 #else 871 #define MIN_STACK_FRAME 16 872 #define FRAME_LR_SAVE 1 873 #define INT_FRAME_SIZE (sizeof(struct pt_regs) + STACK_FRAME_OVERHEAD) 874 #define REGS_MARKER 0x72656773ul 875 #define FRAME_MARKER 2 876 #endif 877 878 EXPORT_SYMBOL(validate_sp); 879 880 unsigned long get_wchan(struct task_struct *p) 881 { 882 unsigned long ip, sp; 883 int count = 0; 884 885 if (!p || p == current || p->state == TASK_RUNNING) 886 return 0; 887 888 sp = p->thread.ksp; 889 if (!validate_sp(sp, p, MIN_STACK_FRAME)) 890 return 0; 891 892 do { 893 sp = *(unsigned long *)sp; 894 if (!validate_sp(sp, p, MIN_STACK_FRAME)) 895 return 0; 896 if (count > 0) { 897 ip = ((unsigned long *)sp)[FRAME_LR_SAVE]; 898 if (!in_sched_functions(ip)) 899 return ip; 900 } 901 } while (count++ < 16); 902 return 0; 903 } 904 905 static int kstack_depth_to_print = 64; 906 907 void show_stack(struct task_struct *tsk, unsigned long *stack) 908 { 909 unsigned long sp, ip, lr, newsp; 910 int count = 0; 911 int firstframe = 1; 912 913 sp = (unsigned long) stack; 914 if (tsk == NULL) 915 tsk = current; 916 if (sp == 0) { 917 if (tsk == current) 918 asm("mr %0,1" : "=r" (sp)); 919 else 920 sp = tsk->thread.ksp; 921 } 922 923 lr = 0; 924 printk("Call Trace:\n"); 925 do { 926 if (!validate_sp(sp, tsk, MIN_STACK_FRAME)) 927 return; 928 929 stack = (unsigned long *) sp; 930 newsp = stack[0]; 931 ip = stack[FRAME_LR_SAVE]; 932 if (!firstframe || ip != lr) { 933 printk("["REG"] ["REG"] ", sp, ip); 934 print_symbol("%s", ip); 935 if (firstframe) 936 printk(" (unreliable)"); 937 printk("\n"); 938 } 939 firstframe = 0; 940 941 /* 942 * See if this is an exception frame. 943 * We look for the "regshere" marker in the current frame. 944 */ 945 if (validate_sp(sp, tsk, INT_FRAME_SIZE) 946 && stack[FRAME_MARKER] == REGS_MARKER) { 947 struct pt_regs *regs = (struct pt_regs *) 948 (sp + STACK_FRAME_OVERHEAD); 949 printk("--- Exception: %lx", regs->trap); 950 print_symbol(" at %s\n", regs->nip); 951 lr = regs->link; 952 print_symbol(" LR = %s\n", lr); 953 firstframe = 1; 954 } 955 956 sp = newsp; 957 } while (count++ < kstack_depth_to_print); 958 } 959 960 void dump_stack(void) 961 { 962 show_stack(current, NULL); 963 } 964 EXPORT_SYMBOL(dump_stack); 965 966 #ifdef CONFIG_PPC64 967 void ppc64_runlatch_on(void) 968 { 969 unsigned long ctrl; 970 971 if (cpu_has_feature(CPU_FTR_CTRL) && !test_thread_flag(TIF_RUNLATCH)) { 972 HMT_medium(); 973 974 ctrl = mfspr(SPRN_CTRLF); 975 ctrl |= CTRL_RUNLATCH; 976 mtspr(SPRN_CTRLT, ctrl); 977 978 set_thread_flag(TIF_RUNLATCH); 979 } 980 } 981 982 void ppc64_runlatch_off(void) 983 { 984 unsigned long ctrl; 985 986 if (cpu_has_feature(CPU_FTR_CTRL) && test_thread_flag(TIF_RUNLATCH)) { 987 HMT_medium(); 988 989 clear_thread_flag(TIF_RUNLATCH); 990 991 ctrl = mfspr(SPRN_CTRLF); 992 ctrl &= ~CTRL_RUNLATCH; 993 mtspr(SPRN_CTRLT, ctrl); 994 } 995 } 996 #endif 997