1 /* 2 * linux/arch/x86-64/kernel/process.c 3 * 4 * Copyright (C) 1995 Linus Torvalds 5 * 6 * Pentium III FXSR, SSE support 7 * Gareth Hughes <gareth@valinux.com>, May 2000 8 * 9 * X86-64 port 10 * Andi Kleen. 11 * 12 * CPU hotplug support - ashok.raj@intel.com 13 */ 14 15 /* 16 * This file handles the architecture-dependent parts of process handling.. 17 */ 18 19 #include <stdarg.h> 20 21 #include <linux/cpu.h> 22 #include <linux/errno.h> 23 #include <linux/sched.h> 24 #include <linux/kernel.h> 25 #include <linux/mm.h> 26 #include <linux/fs.h> 27 #include <linux/elfcore.h> 28 #include <linux/smp.h> 29 #include <linux/slab.h> 30 #include <linux/user.h> 31 #include <linux/module.h> 32 #include <linux/a.out.h> 33 #include <linux/interrupt.h> 34 #include <linux/delay.h> 35 #include <linux/ptrace.h> 36 #include <linux/utsname.h> 37 #include <linux/random.h> 38 #include <linux/notifier.h> 39 #include <linux/kprobes.h> 40 #include <linux/kdebug.h> 41 42 #include <asm/uaccess.h> 43 #include <asm/pgtable.h> 44 #include <asm/system.h> 45 #include <asm/io.h> 46 #include <asm/processor.h> 47 #include <asm/i387.h> 48 #include <asm/mmu_context.h> 49 #include <asm/pda.h> 50 #include <asm/prctl.h> 51 #include <asm/desc.h> 52 #include <asm/proto.h> 53 #include <asm/ia32.h> 54 #include <asm/idle.h> 55 56 asmlinkage extern void ret_from_fork(void); 57 58 unsigned long kernel_thread_flags = CLONE_VM | CLONE_UNTRACED; 59 60 unsigned long boot_option_idle_override = 0; 61 EXPORT_SYMBOL(boot_option_idle_override); 62 63 /* 64 * Powermanagement idle function, if any.. 65 */ 66 void (*pm_idle)(void); 67 EXPORT_SYMBOL(pm_idle); 68 static DEFINE_PER_CPU(unsigned int, cpu_idle_state); 69 70 static ATOMIC_NOTIFIER_HEAD(idle_notifier); 71 72 void idle_notifier_register(struct notifier_block *n) 73 { 74 atomic_notifier_chain_register(&idle_notifier, n); 75 } 76 EXPORT_SYMBOL_GPL(idle_notifier_register); 77 78 void idle_notifier_unregister(struct notifier_block *n) 79 { 80 atomic_notifier_chain_unregister(&idle_notifier, n); 81 } 82 EXPORT_SYMBOL(idle_notifier_unregister); 83 84 void enter_idle(void) 85 { 86 write_pda(isidle, 1); 87 atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL); 88 } 89 90 static void __exit_idle(void) 91 { 92 if (test_and_clear_bit_pda(0, isidle) == 0) 93 return; 94 atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL); 95 } 96 97 /* Called from interrupts to signify idle end */ 98 void exit_idle(void) 99 { 100 /* idle loop has pid 0 */ 101 if (current->pid) 102 return; 103 __exit_idle(); 104 } 105 106 /* 107 * We use this if we don't have any better 108 * idle routine.. 109 */ 110 static void default_idle(void) 111 { 112 current_thread_info()->status &= ~TS_POLLING; 113 /* 114 * TS_POLLING-cleared state must be visible before we 115 * test NEED_RESCHED: 116 */ 117 smp_mb(); 118 local_irq_disable(); 119 if (!need_resched()) { 120 /* Enables interrupts one instruction before HLT. 121 x86 special cases this so there is no race. */ 122 safe_halt(); 123 } else 124 local_irq_enable(); 125 current_thread_info()->status |= TS_POLLING; 126 } 127 128 /* 129 * On SMP it's slightly faster (but much more power-consuming!) 130 * to poll the ->need_resched flag instead of waiting for the 131 * cross-CPU IPI to arrive. Use this option with caution. 132 */ 133 static void poll_idle (void) 134 { 135 local_irq_enable(); 136 cpu_relax(); 137 } 138 139 void cpu_idle_wait(void) 140 { 141 unsigned int cpu, this_cpu = get_cpu(); 142 cpumask_t map, tmp = current->cpus_allowed; 143 144 set_cpus_allowed(current, cpumask_of_cpu(this_cpu)); 145 put_cpu(); 146 147 cpus_clear(map); 148 for_each_online_cpu(cpu) { 149 per_cpu(cpu_idle_state, cpu) = 1; 150 cpu_set(cpu, map); 151 } 152 153 __get_cpu_var(cpu_idle_state) = 0; 154 155 wmb(); 156 do { 157 ssleep(1); 158 for_each_online_cpu(cpu) { 159 if (cpu_isset(cpu, map) && 160 !per_cpu(cpu_idle_state, cpu)) 161 cpu_clear(cpu, map); 162 } 163 cpus_and(map, map, cpu_online_map); 164 } while (!cpus_empty(map)); 165 166 set_cpus_allowed(current, tmp); 167 } 168 EXPORT_SYMBOL_GPL(cpu_idle_wait); 169 170 #ifdef CONFIG_HOTPLUG_CPU 171 DECLARE_PER_CPU(int, cpu_state); 172 173 #include <asm/nmi.h> 174 /* We halt the CPU with physical CPU hotplug */ 175 static inline void play_dead(void) 176 { 177 idle_task_exit(); 178 wbinvd(); 179 mb(); 180 /* Ack it */ 181 __get_cpu_var(cpu_state) = CPU_DEAD; 182 183 local_irq_disable(); 184 while (1) 185 halt(); 186 } 187 #else 188 static inline void play_dead(void) 189 { 190 BUG(); 191 } 192 #endif /* CONFIG_HOTPLUG_CPU */ 193 194 /* 195 * The idle thread. There's no useful work to be 196 * done, so just try to conserve power and have a 197 * low exit latency (ie sit in a loop waiting for 198 * somebody to say that they'd like to reschedule) 199 */ 200 void cpu_idle (void) 201 { 202 current_thread_info()->status |= TS_POLLING; 203 /* endless idle loop with no priority at all */ 204 while (1) { 205 while (!need_resched()) { 206 void (*idle)(void); 207 208 if (__get_cpu_var(cpu_idle_state)) 209 __get_cpu_var(cpu_idle_state) = 0; 210 211 rmb(); 212 idle = pm_idle; 213 if (!idle) 214 idle = default_idle; 215 if (cpu_is_offline(smp_processor_id())) 216 play_dead(); 217 /* 218 * Idle routines should keep interrupts disabled 219 * from here on, until they go to idle. 220 * Otherwise, idle callbacks can misfire. 221 */ 222 local_irq_disable(); 223 enter_idle(); 224 idle(); 225 /* In many cases the interrupt that ended idle 226 has already called exit_idle. But some idle 227 loops can be woken up without interrupt. */ 228 __exit_idle(); 229 } 230 231 preempt_enable_no_resched(); 232 schedule(); 233 preempt_disable(); 234 } 235 } 236 237 /* 238 * This uses new MONITOR/MWAIT instructions on P4 processors with PNI, 239 * which can obviate IPI to trigger checking of need_resched. 240 * We execute MONITOR against need_resched and enter optimized wait state 241 * through MWAIT. Whenever someone changes need_resched, we would be woken 242 * up from MWAIT (without an IPI). 243 * 244 * New with Core Duo processors, MWAIT can take some hints based on CPU 245 * capability. 246 */ 247 void mwait_idle_with_hints(unsigned long eax, unsigned long ecx) 248 { 249 if (!need_resched()) { 250 __monitor((void *)¤t_thread_info()->flags, 0, 0); 251 smp_mb(); 252 if (!need_resched()) 253 __mwait(eax, ecx); 254 } 255 } 256 257 /* Default MONITOR/MWAIT with no hints, used for default C1 state */ 258 static void mwait_idle(void) 259 { 260 if (!need_resched()) { 261 __monitor((void *)¤t_thread_info()->flags, 0, 0); 262 smp_mb(); 263 if (!need_resched()) 264 __sti_mwait(0, 0); 265 else 266 local_irq_enable(); 267 } else { 268 local_irq_enable(); 269 } 270 } 271 272 void __cpuinit select_idle_routine(const struct cpuinfo_x86 *c) 273 { 274 static int printed; 275 if (cpu_has(c, X86_FEATURE_MWAIT)) { 276 /* 277 * Skip, if setup has overridden idle. 278 * One CPU supports mwait => All CPUs supports mwait 279 */ 280 if (!pm_idle) { 281 if (!printed) { 282 printk(KERN_INFO "using mwait in idle threads.\n"); 283 printed = 1; 284 } 285 pm_idle = mwait_idle; 286 } 287 } 288 } 289 290 static int __init idle_setup (char *str) 291 { 292 if (!strcmp(str, "poll")) { 293 printk("using polling idle threads.\n"); 294 pm_idle = poll_idle; 295 } else if (!strcmp(str, "mwait")) 296 force_mwait = 1; 297 else 298 return -1; 299 300 boot_option_idle_override = 1; 301 return 0; 302 } 303 early_param("idle", idle_setup); 304 305 /* Prints also some state that isn't saved in the pt_regs */ 306 void __show_regs(struct pt_regs * regs) 307 { 308 unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs; 309 unsigned long d0, d1, d2, d3, d6, d7; 310 unsigned int fsindex,gsindex; 311 unsigned int ds,cs,es; 312 313 printk("\n"); 314 print_modules(); 315 printk("Pid: %d, comm: %.20s %s %s %.*s\n", 316 current->pid, current->comm, print_tainted(), 317 init_utsname()->release, 318 (int)strcspn(init_utsname()->version, " "), 319 init_utsname()->version); 320 printk("RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->rip); 321 printk_address(regs->rip); 322 printk("RSP: %04lx:%016lx EFLAGS: %08lx\n", regs->ss, regs->rsp, 323 regs->eflags); 324 printk("RAX: %016lx RBX: %016lx RCX: %016lx\n", 325 regs->rax, regs->rbx, regs->rcx); 326 printk("RDX: %016lx RSI: %016lx RDI: %016lx\n", 327 regs->rdx, regs->rsi, regs->rdi); 328 printk("RBP: %016lx R08: %016lx R09: %016lx\n", 329 regs->rbp, regs->r8, regs->r9); 330 printk("R10: %016lx R11: %016lx R12: %016lx\n", 331 regs->r10, regs->r11, regs->r12); 332 printk("R13: %016lx R14: %016lx R15: %016lx\n", 333 regs->r13, regs->r14, regs->r15); 334 335 asm("movl %%ds,%0" : "=r" (ds)); 336 asm("movl %%cs,%0" : "=r" (cs)); 337 asm("movl %%es,%0" : "=r" (es)); 338 asm("movl %%fs,%0" : "=r" (fsindex)); 339 asm("movl %%gs,%0" : "=r" (gsindex)); 340 341 rdmsrl(MSR_FS_BASE, fs); 342 rdmsrl(MSR_GS_BASE, gs); 343 rdmsrl(MSR_KERNEL_GS_BASE, shadowgs); 344 345 cr0 = read_cr0(); 346 cr2 = read_cr2(); 347 cr3 = read_cr3(); 348 cr4 = read_cr4(); 349 350 printk("FS: %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n", 351 fs,fsindex,gs,gsindex,shadowgs); 352 printk("CS: %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds, es, cr0); 353 printk("CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3, cr4); 354 355 get_debugreg(d0, 0); 356 get_debugreg(d1, 1); 357 get_debugreg(d2, 2); 358 printk("DR0: %016lx DR1: %016lx DR2: %016lx\n", d0, d1, d2); 359 get_debugreg(d3, 3); 360 get_debugreg(d6, 6); 361 get_debugreg(d7, 7); 362 printk("DR3: %016lx DR6: %016lx DR7: %016lx\n", d3, d6, d7); 363 } 364 365 void show_regs(struct pt_regs *regs) 366 { 367 printk("CPU %d:", smp_processor_id()); 368 __show_regs(regs); 369 show_trace(NULL, regs, (void *)(regs + 1)); 370 } 371 372 /* 373 * Free current thread data structures etc.. 374 */ 375 void exit_thread(void) 376 { 377 struct task_struct *me = current; 378 struct thread_struct *t = &me->thread; 379 380 if (me->thread.io_bitmap_ptr) { 381 struct tss_struct *tss = &per_cpu(init_tss, get_cpu()); 382 383 kfree(t->io_bitmap_ptr); 384 t->io_bitmap_ptr = NULL; 385 clear_thread_flag(TIF_IO_BITMAP); 386 /* 387 * Careful, clear this in the TSS too: 388 */ 389 memset(tss->io_bitmap, 0xff, t->io_bitmap_max); 390 t->io_bitmap_max = 0; 391 put_cpu(); 392 } 393 } 394 395 void flush_thread(void) 396 { 397 struct task_struct *tsk = current; 398 399 if (test_tsk_thread_flag(tsk, TIF_ABI_PENDING)) { 400 clear_tsk_thread_flag(tsk, TIF_ABI_PENDING); 401 if (test_tsk_thread_flag(tsk, TIF_IA32)) { 402 clear_tsk_thread_flag(tsk, TIF_IA32); 403 } else { 404 set_tsk_thread_flag(tsk, TIF_IA32); 405 current_thread_info()->status |= TS_COMPAT; 406 } 407 } 408 clear_tsk_thread_flag(tsk, TIF_DEBUG); 409 410 tsk->thread.debugreg0 = 0; 411 tsk->thread.debugreg1 = 0; 412 tsk->thread.debugreg2 = 0; 413 tsk->thread.debugreg3 = 0; 414 tsk->thread.debugreg6 = 0; 415 tsk->thread.debugreg7 = 0; 416 memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array)); 417 /* 418 * Forget coprocessor state.. 419 */ 420 clear_fpu(tsk); 421 clear_used_math(); 422 } 423 424 void release_thread(struct task_struct *dead_task) 425 { 426 if (dead_task->mm) { 427 if (dead_task->mm->context.size) { 428 printk("WARNING: dead process %8s still has LDT? <%p/%d>\n", 429 dead_task->comm, 430 dead_task->mm->context.ldt, 431 dead_task->mm->context.size); 432 BUG(); 433 } 434 } 435 } 436 437 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr) 438 { 439 struct user_desc ud = { 440 .base_addr = addr, 441 .limit = 0xfffff, 442 .seg_32bit = 1, 443 .limit_in_pages = 1, 444 .useable = 1, 445 }; 446 struct n_desc_struct *desc = (void *)t->thread.tls_array; 447 desc += tls; 448 desc->a = LDT_entry_a(&ud); 449 desc->b = LDT_entry_b(&ud); 450 } 451 452 static inline u32 read_32bit_tls(struct task_struct *t, int tls) 453 { 454 struct desc_struct *desc = (void *)t->thread.tls_array; 455 desc += tls; 456 return desc->base0 | 457 (((u32)desc->base1) << 16) | 458 (((u32)desc->base2) << 24); 459 } 460 461 /* 462 * This gets called before we allocate a new thread and copy 463 * the current task into it. 464 */ 465 void prepare_to_copy(struct task_struct *tsk) 466 { 467 unlazy_fpu(tsk); 468 } 469 470 int copy_thread(int nr, unsigned long clone_flags, unsigned long rsp, 471 unsigned long unused, 472 struct task_struct * p, struct pt_regs * regs) 473 { 474 int err; 475 struct pt_regs * childregs; 476 struct task_struct *me = current; 477 478 childregs = ((struct pt_regs *) 479 (THREAD_SIZE + task_stack_page(p))) - 1; 480 *childregs = *regs; 481 482 childregs->rax = 0; 483 childregs->rsp = rsp; 484 if (rsp == ~0UL) 485 childregs->rsp = (unsigned long)childregs; 486 487 p->thread.rsp = (unsigned long) childregs; 488 p->thread.rsp0 = (unsigned long) (childregs+1); 489 p->thread.userrsp = me->thread.userrsp; 490 491 set_tsk_thread_flag(p, TIF_FORK); 492 493 p->thread.fs = me->thread.fs; 494 p->thread.gs = me->thread.gs; 495 496 asm("mov %%gs,%0" : "=m" (p->thread.gsindex)); 497 asm("mov %%fs,%0" : "=m" (p->thread.fsindex)); 498 asm("mov %%es,%0" : "=m" (p->thread.es)); 499 asm("mov %%ds,%0" : "=m" (p->thread.ds)); 500 501 if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) { 502 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL); 503 if (!p->thread.io_bitmap_ptr) { 504 p->thread.io_bitmap_max = 0; 505 return -ENOMEM; 506 } 507 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr, 508 IO_BITMAP_BYTES); 509 set_tsk_thread_flag(p, TIF_IO_BITMAP); 510 } 511 512 /* 513 * Set a new TLS for the child thread? 514 */ 515 if (clone_flags & CLONE_SETTLS) { 516 #ifdef CONFIG_IA32_EMULATION 517 if (test_thread_flag(TIF_IA32)) 518 err = ia32_child_tls(p, childregs); 519 else 520 #endif 521 err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8); 522 if (err) 523 goto out; 524 } 525 err = 0; 526 out: 527 if (err && p->thread.io_bitmap_ptr) { 528 kfree(p->thread.io_bitmap_ptr); 529 p->thread.io_bitmap_max = 0; 530 } 531 return err; 532 } 533 534 /* 535 * This special macro can be used to load a debugging register 536 */ 537 #define loaddebug(thread,r) set_debugreg(thread->debugreg ## r, r) 538 539 static inline void __switch_to_xtra(struct task_struct *prev_p, 540 struct task_struct *next_p, 541 struct tss_struct *tss) 542 { 543 struct thread_struct *prev, *next; 544 545 prev = &prev_p->thread, 546 next = &next_p->thread; 547 548 if (test_tsk_thread_flag(next_p, TIF_DEBUG)) { 549 loaddebug(next, 0); 550 loaddebug(next, 1); 551 loaddebug(next, 2); 552 loaddebug(next, 3); 553 /* no 4 and 5 */ 554 loaddebug(next, 6); 555 loaddebug(next, 7); 556 } 557 558 if (test_tsk_thread_flag(next_p, TIF_IO_BITMAP)) { 559 /* 560 * Copy the relevant range of the IO bitmap. 561 * Normally this is 128 bytes or less: 562 */ 563 memcpy(tss->io_bitmap, next->io_bitmap_ptr, 564 max(prev->io_bitmap_max, next->io_bitmap_max)); 565 } else if (test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)) { 566 /* 567 * Clear any possible leftover bits: 568 */ 569 memset(tss->io_bitmap, 0xff, prev->io_bitmap_max); 570 } 571 } 572 573 /* 574 * switch_to(x,y) should switch tasks from x to y. 575 * 576 * This could still be optimized: 577 * - fold all the options into a flag word and test it with a single test. 578 * - could test fs/gs bitsliced 579 * 580 * Kprobes not supported here. Set the probe on schedule instead. 581 */ 582 __kprobes struct task_struct * 583 __switch_to(struct task_struct *prev_p, struct task_struct *next_p) 584 { 585 struct thread_struct *prev = &prev_p->thread, 586 *next = &next_p->thread; 587 int cpu = smp_processor_id(); 588 struct tss_struct *tss = &per_cpu(init_tss, cpu); 589 590 /* we're going to use this soon, after a few expensive things */ 591 if (next_p->fpu_counter>5) 592 prefetch(&next->i387.fxsave); 593 594 /* 595 * Reload esp0, LDT and the page table pointer: 596 */ 597 tss->rsp0 = next->rsp0; 598 599 /* 600 * Switch DS and ES. 601 * This won't pick up thread selector changes, but I guess that is ok. 602 */ 603 asm volatile("mov %%es,%0" : "=m" (prev->es)); 604 if (unlikely(next->es | prev->es)) 605 loadsegment(es, next->es); 606 607 asm volatile ("mov %%ds,%0" : "=m" (prev->ds)); 608 if (unlikely(next->ds | prev->ds)) 609 loadsegment(ds, next->ds); 610 611 load_TLS(next, cpu); 612 613 /* 614 * Switch FS and GS. 615 */ 616 { 617 unsigned fsindex; 618 asm volatile("movl %%fs,%0" : "=r" (fsindex)); 619 /* segment register != 0 always requires a reload. 620 also reload when it has changed. 621 when prev process used 64bit base always reload 622 to avoid an information leak. */ 623 if (unlikely(fsindex | next->fsindex | prev->fs)) { 624 loadsegment(fs, next->fsindex); 625 /* check if the user used a selector != 0 626 * if yes clear 64bit base, since overloaded base 627 * is always mapped to the Null selector 628 */ 629 if (fsindex) 630 prev->fs = 0; 631 } 632 /* when next process has a 64bit base use it */ 633 if (next->fs) 634 wrmsrl(MSR_FS_BASE, next->fs); 635 prev->fsindex = fsindex; 636 } 637 { 638 unsigned gsindex; 639 asm volatile("movl %%gs,%0" : "=r" (gsindex)); 640 if (unlikely(gsindex | next->gsindex | prev->gs)) { 641 load_gs_index(next->gsindex); 642 if (gsindex) 643 prev->gs = 0; 644 } 645 if (next->gs) 646 wrmsrl(MSR_KERNEL_GS_BASE, next->gs); 647 prev->gsindex = gsindex; 648 } 649 650 /* Must be after DS reload */ 651 unlazy_fpu(prev_p); 652 653 /* 654 * Switch the PDA and FPU contexts. 655 */ 656 prev->userrsp = read_pda(oldrsp); 657 write_pda(oldrsp, next->userrsp); 658 write_pda(pcurrent, next_p); 659 660 write_pda(kernelstack, 661 (unsigned long)task_stack_page(next_p) + THREAD_SIZE - PDA_STACKOFFSET); 662 #ifdef CONFIG_CC_STACKPROTECTOR 663 write_pda(stack_canary, next_p->stack_canary); 664 /* 665 * Build time only check to make sure the stack_canary is at 666 * offset 40 in the pda; this is a gcc ABI requirement 667 */ 668 BUILD_BUG_ON(offsetof(struct x8664_pda, stack_canary) != 40); 669 #endif 670 671 /* 672 * Now maybe reload the debug registers and handle I/O bitmaps 673 */ 674 if (unlikely((task_thread_info(next_p)->flags & _TIF_WORK_CTXSW)) 675 || test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)) 676 __switch_to_xtra(prev_p, next_p, tss); 677 678 /* If the task has used fpu the last 5 timeslices, just do a full 679 * restore of the math state immediately to avoid the trap; the 680 * chances of needing FPU soon are obviously high now 681 */ 682 if (next_p->fpu_counter>5) 683 math_state_restore(); 684 return prev_p; 685 } 686 687 /* 688 * sys_execve() executes a new program. 689 */ 690 asmlinkage 691 long sys_execve(char __user *name, char __user * __user *argv, 692 char __user * __user *envp, struct pt_regs regs) 693 { 694 long error; 695 char * filename; 696 697 filename = getname(name); 698 error = PTR_ERR(filename); 699 if (IS_ERR(filename)) 700 return error; 701 error = do_execve(filename, argv, envp, ®s); 702 if (error == 0) { 703 task_lock(current); 704 current->ptrace &= ~PT_DTRACE; 705 task_unlock(current); 706 } 707 putname(filename); 708 return error; 709 } 710 711 void set_personality_64bit(void) 712 { 713 /* inherit personality from parent */ 714 715 /* Make sure to be in 64bit mode */ 716 clear_thread_flag(TIF_IA32); 717 718 /* TBD: overwrites user setup. Should have two bits. 719 But 64bit processes have always behaved this way, 720 so it's not too bad. The main problem is just that 721 32bit childs are affected again. */ 722 current->personality &= ~READ_IMPLIES_EXEC; 723 } 724 725 asmlinkage long sys_fork(struct pt_regs *regs) 726 { 727 return do_fork(SIGCHLD, regs->rsp, regs, 0, NULL, NULL); 728 } 729 730 asmlinkage long 731 sys_clone(unsigned long clone_flags, unsigned long newsp, 732 void __user *parent_tid, void __user *child_tid, struct pt_regs *regs) 733 { 734 if (!newsp) 735 newsp = regs->rsp; 736 return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid); 737 } 738 739 /* 740 * This is trivial, and on the face of it looks like it 741 * could equally well be done in user mode. 742 * 743 * Not so, for quite unobvious reasons - register pressure. 744 * In user mode vfork() cannot have a stack frame, and if 745 * done by calling the "clone()" system call directly, you 746 * do not have enough call-clobbered registers to hold all 747 * the information you need. 748 */ 749 asmlinkage long sys_vfork(struct pt_regs *regs) 750 { 751 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->rsp, regs, 0, 752 NULL, NULL); 753 } 754 755 unsigned long get_wchan(struct task_struct *p) 756 { 757 unsigned long stack; 758 u64 fp,rip; 759 int count = 0; 760 761 if (!p || p == current || p->state==TASK_RUNNING) 762 return 0; 763 stack = (unsigned long)task_stack_page(p); 764 if (p->thread.rsp < stack || p->thread.rsp > stack+THREAD_SIZE) 765 return 0; 766 fp = *(u64 *)(p->thread.rsp); 767 do { 768 if (fp < (unsigned long)stack || 769 fp > (unsigned long)stack+THREAD_SIZE) 770 return 0; 771 rip = *(u64 *)(fp+8); 772 if (!in_sched_functions(rip)) 773 return rip; 774 fp = *(u64 *)fp; 775 } while (count++ < 16); 776 return 0; 777 } 778 779 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr) 780 { 781 int ret = 0; 782 int doit = task == current; 783 int cpu; 784 785 switch (code) { 786 case ARCH_SET_GS: 787 if (addr >= TASK_SIZE_OF(task)) 788 return -EPERM; 789 cpu = get_cpu(); 790 /* handle small bases via the GDT because that's faster to 791 switch. */ 792 if (addr <= 0xffffffff) { 793 set_32bit_tls(task, GS_TLS, addr); 794 if (doit) { 795 load_TLS(&task->thread, cpu); 796 load_gs_index(GS_TLS_SEL); 797 } 798 task->thread.gsindex = GS_TLS_SEL; 799 task->thread.gs = 0; 800 } else { 801 task->thread.gsindex = 0; 802 task->thread.gs = addr; 803 if (doit) { 804 load_gs_index(0); 805 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr); 806 } 807 } 808 put_cpu(); 809 break; 810 case ARCH_SET_FS: 811 /* Not strictly needed for fs, but do it for symmetry 812 with gs */ 813 if (addr >= TASK_SIZE_OF(task)) 814 return -EPERM; 815 cpu = get_cpu(); 816 /* handle small bases via the GDT because that's faster to 817 switch. */ 818 if (addr <= 0xffffffff) { 819 set_32bit_tls(task, FS_TLS, addr); 820 if (doit) { 821 load_TLS(&task->thread, cpu); 822 asm volatile("movl %0,%%fs" :: "r"(FS_TLS_SEL)); 823 } 824 task->thread.fsindex = FS_TLS_SEL; 825 task->thread.fs = 0; 826 } else { 827 task->thread.fsindex = 0; 828 task->thread.fs = addr; 829 if (doit) { 830 /* set the selector to 0 to not confuse 831 __switch_to */ 832 asm volatile("movl %0,%%fs" :: "r" (0)); 833 ret = checking_wrmsrl(MSR_FS_BASE, addr); 834 } 835 } 836 put_cpu(); 837 break; 838 case ARCH_GET_FS: { 839 unsigned long base; 840 if (task->thread.fsindex == FS_TLS_SEL) 841 base = read_32bit_tls(task, FS_TLS); 842 else if (doit) 843 rdmsrl(MSR_FS_BASE, base); 844 else 845 base = task->thread.fs; 846 ret = put_user(base, (unsigned long __user *)addr); 847 break; 848 } 849 case ARCH_GET_GS: { 850 unsigned long base; 851 unsigned gsindex; 852 if (task->thread.gsindex == GS_TLS_SEL) 853 base = read_32bit_tls(task, GS_TLS); 854 else if (doit) { 855 asm("movl %%gs,%0" : "=r" (gsindex)); 856 if (gsindex) 857 rdmsrl(MSR_KERNEL_GS_BASE, base); 858 else 859 base = task->thread.gs; 860 } 861 else 862 base = task->thread.gs; 863 ret = put_user(base, (unsigned long __user *)addr); 864 break; 865 } 866 867 default: 868 ret = -EINVAL; 869 break; 870 } 871 872 return ret; 873 } 874 875 long sys_arch_prctl(int code, unsigned long addr) 876 { 877 return do_arch_prctl(current, code, addr); 878 } 879 880 /* 881 * Capture the user space registers if the task is not running (in user space) 882 */ 883 int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs) 884 { 885 struct pt_regs *pp, ptregs; 886 887 pp = task_pt_regs(tsk); 888 889 ptregs = *pp; 890 ptregs.cs &= 0xffff; 891 ptregs.ss &= 0xffff; 892 893 elf_core_copy_regs(regs, &ptregs); 894 895 return 1; 896 } 897 898 unsigned long arch_align_stack(unsigned long sp) 899 { 900 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space) 901 sp -= get_random_int() % 8192; 902 return sp & ~0xf; 903 } 904