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