err.no Git - linux-2.6/blob - arch/x86_64/kernel/process.c

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