arch/x86/kernel/process_64.c

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