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