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         tsk->fpu_counter = 0;
 267         clear_fpu(tsk);
 268         clear_used_math();
 269 }
 270
 271 void release_thread(struct task_struct *dead_task)
 272 {
 273         if (dead_task->mm) {
 274                 if (dead_task->mm->context.size) {
 275                         printk("WARNING: dead process %8s still has LDT? <%p/%d>\n",
 276                                         dead_task->comm,
 277                                         dead_task->mm->context.ldt,
 278                                         dead_task->mm->context.size);
 279                         BUG();
 280                 }
 281         }
 282 }
 283
 284 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr)
 285 {
 286         struct user_desc ud = {
 287                 .base_addr = addr,
 288                 .limit = 0xfffff,
 289                 .seg_32bit = 1,
 290                 .limit_in_pages = 1,
 291                 .useable = 1,
 292         };
 293         struct desc_struct *desc = t->thread.tls_array;
 294         desc += tls;
 295         fill_ldt(desc, &ud);
 296 }
 297
 298 static inline u32 read_32bit_tls(struct task_struct *t, int tls)
 299 {
 300         return get_desc_base(&t->thread.tls_array[tls]);
 301 }
 302
 303 /*
 304  * This gets called before we allocate a new thread and copy
 305  * the current task into it.
 306  */
 307 void prepare_to_copy(struct task_struct *tsk)
 308 {
 309         unlazy_fpu(tsk);
 310 }
 311
 312 int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
 313                 unsigned long unused,
 314         struct task_struct * p, struct pt_regs * regs)
 315 {
 316         int err;
 317         struct pt_regs * childregs;
 318         struct task_struct *me = current;
 319
 320         childregs = ((struct pt_regs *)
 321                         (THREAD_SIZE + task_stack_page(p))) - 1;
 322         *childregs = *regs;
 323
 324         childregs->ax = 0;
 325         childregs->sp = sp;
 326         if (sp == ~0UL)
 327                 childregs->sp = (unsigned long)childregs;
 328
 329         p->thread.sp = (unsigned long) childregs;
 330         p->thread.sp0 = (unsigned long) (childregs+1);
 331         p->thread.usersp = me->thread.usersp;
 332
 333         set_tsk_thread_flag(p, TIF_FORK);
 334
 335         p->thread.fs = me->thread.fs;
 336         p->thread.gs = me->thread.gs;
 337
 338         asm("mov %%gs,%0" : "=m" (p->thread.gsindex));
 339         asm("mov %%fs,%0" : "=m" (p->thread.fsindex));
 340         asm("mov %%es,%0" : "=m" (p->thread.es));
 341         asm("mov %%ds,%0" : "=m" (p->thread.ds));
 342
 343         if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
 344                 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
 345                 if (!p->thread.io_bitmap_ptr) {
 346                         p->thread.io_bitmap_max = 0;
 347                         return -ENOMEM;
 348                 }
 349                 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr,
 350                                 IO_BITMAP_BYTES);
 351                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
 352         }
 353
 354         /*
 355          * Set a new TLS for the child thread?
 356          */
 357         if (clone_flags & CLONE_SETTLS) {
 358 #ifdef CONFIG_IA32_EMULATION
 359                 if (test_thread_flag(TIF_IA32))
 360                         err = do_set_thread_area(p, -1,
 361                                 (struct user_desc __user *)childregs->si, 0);
 362                 else
 363 #endif
 364                         err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8);
 365                 if (err)
 366                         goto out;
 367         }
 368         err = 0;
 369 out:
 370         if (err && p->thread.io_bitmap_ptr) {
 371                 kfree(p->thread.io_bitmap_ptr);
 372                 p->thread.io_bitmap_max = 0;
 373         }
 374         return err;
 375 }
 376
 377 void
 378 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
 379 {
 380         asm volatile("movl %0, %%fs; movl %0, %%es; movl %0, %%ds" :: "r"(0));
 381         load_gs_index(0);
 382         regs->ip                = new_ip;
 383         regs->sp                = new_sp;
 384         write_pda(oldrsp, new_sp);
 385         regs->cs                = __USER_CS;
 386         regs->ss                = __USER_DS;
 387         regs->flags             = 0x200;
 388         set_fs(USER_DS);
 389         /*
 390          * Free the old FP and other extended state
 391          */
 392         free_thread_xstate(current);
 393 }
 394 EXPORT_SYMBOL_GPL(start_thread);
 395
 396 static void hard_disable_TSC(void)
 397 {
 398         write_cr4(read_cr4() | X86_CR4_TSD);
 399 }
 400
 401 void disable_TSC(void)
 402 {
 403         preempt_disable();
 404         if (!test_and_set_thread_flag(TIF_NOTSC))
 405                 /*
 406                  * Must flip the CPU state synchronously with
 407                  * TIF_NOTSC in the current running context.
 408                  */
 409                 hard_disable_TSC();
 410         preempt_enable();
 411 }
 412
 413 static void hard_enable_TSC(void)
 414 {
 415         write_cr4(read_cr4() & ~X86_CR4_TSD);
 416 }
 417
 418 static void enable_TSC(void)
 419 {
 420         preempt_disable();
 421         if (test_and_clear_thread_flag(TIF_NOTSC))
 422                 /*
 423                  * Must flip the CPU state synchronously with
 424                  * TIF_NOTSC in the current running context.
 425                  */
 426                 hard_enable_TSC();
 427         preempt_enable();
 428 }
 429
 430 int get_tsc_mode(unsigned long adr)
 431 {
 432         unsigned int val;
 433
 434         if (test_thread_flag(TIF_NOTSC))
 435                 val = PR_TSC_SIGSEGV;
 436         else
 437                 val = PR_TSC_ENABLE;
 438
 439         return put_user(val, (unsigned int __user *)adr);
 440 }
 441
 442 int set_tsc_mode(unsigned int val)
 443 {
 444         if (val == PR_TSC_SIGSEGV)
 445                 disable_TSC();
 446         else if (val == PR_TSC_ENABLE)
 447                 enable_TSC();
 448         else
 449                 return -EINVAL;
 450
 451         return 0;
 452 }
 453
 454 /*
 455  * This special macro can be used to load a debugging register
 456  */
 457 #define loaddebug(thread, r) set_debugreg(thread->debugreg ## r, r)
 458
 459 static inline void __switch_to_xtra(struct task_struct *prev_p,
 460                                     struct task_struct *next_p,
 461                                     struct tss_struct *tss)
 462 {
 463         struct thread_struct *prev, *next;
 464         unsigned long debugctl;
 465
 466         prev = &prev_p->thread,
 467         next = &next_p->thread;
 468
 469         debugctl = prev->debugctlmsr;
 470         if (next->ds_area_msr != prev->ds_area_msr) {
 471                 /* we clear debugctl to make sure DS
 472                  * is not in use when we change it */
 473                 debugctl = 0;
 474                 update_debugctlmsr(0);
 475                 wrmsrl(MSR_IA32_DS_AREA, next->ds_area_msr);
 476         }
 477
 478         if (next->debugctlmsr != debugctl)
 479                 update_debugctlmsr(next->debugctlmsr);
 480
 481         if (test_tsk_thread_flag(next_p, TIF_DEBUG)) {
 482                 loaddebug(next, 0);
 483                 loaddebug(next, 1);
 484                 loaddebug(next, 2);
 485                 loaddebug(next, 3);
 486                 /* no 4 and 5 */
 487                 loaddebug(next, 6);
 488                 loaddebug(next, 7);
 489         }
 490
 491         if (test_tsk_thread_flag(prev_p, TIF_NOTSC) ^
 492             test_tsk_thread_flag(next_p, TIF_NOTSC)) {
 493                 /* prev and next are different */
 494                 if (test_tsk_thread_flag(next_p, TIF_NOTSC))
 495                         hard_disable_TSC();
 496                 else
 497                         hard_enable_TSC();
 498         }
 499
 500         if (test_tsk_thread_flag(next_p, TIF_IO_BITMAP)) {
 501                 /*
 502                  * Copy the relevant range of the IO bitmap.
 503                  * Normally this is 128 bytes or less:
 504                  */
 505                 memcpy(tss->io_bitmap, next->io_bitmap_ptr,
 506                        max(prev->io_bitmap_max, next->io_bitmap_max));
 507         } else if (test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)) {
 508                 /*
 509                  * Clear any possible leftover bits:
 510                  */
 511                 memset(tss->io_bitmap, 0xff, prev->io_bitmap_max);
 512         }
 513
 514 #ifdef X86_BTS
 515         if (test_tsk_thread_flag(prev_p, TIF_BTS_TRACE_TS))
 516                 ptrace_bts_take_timestamp(prev_p, BTS_TASK_DEPARTS);
 517
 518         if (test_tsk_thread_flag(next_p, TIF_BTS_TRACE_TS))
 519                 ptrace_bts_take_timestamp(next_p, BTS_TASK_ARRIVES);
 520 #endif
 521 }
 522
 523 /*
 524  *      switch_to(x,y) should switch tasks from x to y.
 525  *
 526  * This could still be optimized:
 527  * - fold all the options into a flag word and test it with a single test.
 528  * - could test fs/gs bitsliced
 529  *
 530  * Kprobes not supported here. Set the probe on schedule instead.
 531  */
 532 struct task_struct *
 533 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 534 {
 535         struct thread_struct *prev = &prev_p->thread,
 536                                  *next = &next_p->thread;
 537         int cpu = smp_processor_id();
 538         struct tss_struct *tss = &per_cpu(init_tss, cpu);
 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         asm volatile("mov %%es,%0" : "=m" (prev->es));
 554         if (unlikely(next->es | prev->es))
 555                 loadsegment(es, next->es);
 556
 557         asm volatile ("mov %%ds,%0" : "=m" (prev->ds));
 558         if (unlikely(next->ds | prev->ds))
 559                 loadsegment(ds, next->ds);
 560
 561         load_TLS(next, cpu);
 562
 563         /*
 564          * Switch FS and GS.
 565          */
 566         {
 567                 unsigned fsindex;
 568                 asm volatile("movl %%fs,%0" : "=r" (fsindex));
 569                 /* segment register != 0 always requires a reload.
 570                    also reload when it has changed.
 571                    when prev process used 64bit base always reload
 572                    to avoid an information leak. */
 573                 if (unlikely(fsindex | next->fsindex | prev->fs)) {
 574                         loadsegment(fs, next->fsindex);
 575                         /* check if the user used a selector != 0
 576                          * if yes clear 64bit base, since overloaded base
 577                          * is always mapped to the Null selector
 578                          */
 579                         if (fsindex)
 580                         prev->fs = 0;
 581                 }
 582                 /* when next process has a 64bit base use it */
 583                 if (next->fs)
 584                         wrmsrl(MSR_FS_BASE, next->fs);
 585                 prev->fsindex = fsindex;
 586         }
 587         {
 588                 unsigned gsindex;
 589                 asm volatile("movl %%gs,%0" : "=r" (gsindex));
 590                 if (unlikely(gsindex | next->gsindex | prev->gs)) {
 591                         load_gs_index(next->gsindex);
 592                         if (gsindex)
 593                         prev->gs = 0;
 594                 }
 595                 if (next->gs)
 596                         wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
 597                 prev->gsindex = gsindex;
 598         }
 599
 600         /* Must be after DS reload */
 601         unlazy_fpu(prev_p);
 602
 603         /*
 604          * Switch the PDA and FPU contexts.
 605          */
 606         prev->usersp = read_pda(oldrsp);
 607         write_pda(oldrsp, next->usersp);
 608         write_pda(pcurrent, next_p);
 609
 610         write_pda(kernelstack,
 611         (unsigned long)task_stack_page(next_p) + THREAD_SIZE - PDA_STACKOFFSET);
 612 #ifdef CONFIG_CC_STACKPROTECTOR
 613         write_pda(stack_canary, next_p->stack_canary);
 614         /*
 615          * Build time only check to make sure the stack_canary is at
 616          * offset 40 in the pda; this is a gcc ABI requirement
 617          */
 618         BUILD_BUG_ON(offsetof(struct x8664_pda, stack_canary) != 40);
 619 #endif
 620
 621         /*
 622          * Now maybe reload the debug registers and handle I/O bitmaps
 623          */
 624         if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT ||
 625                      task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
 626                 __switch_to_xtra(prev_p, next_p, tss);
 627
 628         /* If the task has used fpu the last 5 timeslices, just do a full
 629          * restore of the math state immediately to avoid the trap; the
 630          * chances of needing FPU soon are obviously high now
 631          *
 632          * tsk_used_math() checks prevent calling math_state_restore(),
 633          * which can sleep in the case of !tsk_used_math()
 634          */
 635         if (tsk_used_math(next_p) && next_p->fpu_counter > 5)
 636                 math_state_restore();
 637         return prev_p;
 638 }
 639
 640 /*
 641  * sys_execve() executes a new program.
 642  */
 643 asmlinkage
 644 long sys_execve(char __user *name, char __user * __user *argv,
 645                 char __user * __user *envp, struct pt_regs *regs)
 646 {
 647         long error;
 648         char * filename;
 649
 650         filename = getname(name);
 651         error = PTR_ERR(filename);
 652         if (IS_ERR(filename))
 653                 return error;
 654         error = do_execve(filename, argv, envp, regs);
 655         putname(filename);
 656         return error;
 657 }
 658
 659 void set_personality_64bit(void)
 660 {
 661         /* inherit personality from parent */
 662
 663         /* Make sure to be in 64bit mode */
 664         clear_thread_flag(TIF_IA32);
 665
 666         /* TBD: overwrites user setup. Should have two bits.
 667            But 64bit processes have always behaved this way,
 668            so it's not too bad. The main problem is just that
 669            32bit childs are affected again. */
 670         current->personality &= ~READ_IMPLIES_EXEC;
 671 }
 672
 673 asmlinkage long sys_fork(struct pt_regs *regs)
 674 {
 675         return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
 676 }
 677
 678 asmlinkage long
 679 sys_clone(unsigned long clone_flags, unsigned long newsp,
 680           void __user *parent_tid, void __user *child_tid, struct pt_regs *regs)
 681 {
 682         if (!newsp)
 683                 newsp = regs->sp;
 684         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
 685 }
 686
 687 /*
 688  * This is trivial, and on the face of it looks like it
 689  * could equally well be done in user mode.
 690  *
 691  * Not so, for quite unobvious reasons - register pressure.
 692  * In user mode vfork() cannot have a stack frame, and if
 693  * done by calling the "clone()" system call directly, you
 694  * do not have enough call-clobbered registers to hold all
 695  * the information you need.
 696  */
 697 asmlinkage long sys_vfork(struct pt_regs *regs)
 698 {
 699         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->sp, regs, 0,
 700                     NULL, NULL);
 701 }
 702
 703 unsigned long get_wchan(struct task_struct *p)
 704 {
 705         unsigned long stack;
 706         u64 fp,ip;
 707         int count = 0;
 708
 709         if (!p || p == current || p->state==TASK_RUNNING)
 710                 return 0;
 711         stack = (unsigned long)task_stack_page(p);
 712         if (p->thread.sp < stack || p->thread.sp > stack+THREAD_SIZE)
 713                 return 0;
 714         fp = *(u64 *)(p->thread.sp);
 715         do {
 716                 if (fp < (unsigned long)stack ||
 717                     fp > (unsigned long)stack+THREAD_SIZE)
 718                         return 0;
 719                 ip = *(u64 *)(fp+8);
 720                 if (!in_sched_functions(ip))
 721                         return ip;
 722                 fp = *(u64 *)fp;
 723         } while (count++ < 16);
 724         return 0;
 725 }
 726
 727 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
 728 {
 729         int ret = 0;
 730         int doit = task == current;
 731         int cpu;
 732
 733         switch (code) {
 734         case ARCH_SET_GS:
 735                 if (addr >= TASK_SIZE_OF(task))
 736                         return -EPERM;
 737                 cpu = get_cpu();
 738                 /* handle small bases via the GDT because that's faster to
 739                    switch. */
 740                 if (addr <= 0xffffffff) {
 741                         set_32bit_tls(task, GS_TLS, addr);
 742                         if (doit) {
 743                                 load_TLS(&task->thread, cpu);
 744                                 load_gs_index(GS_TLS_SEL);
 745                         }
 746                         task->thread.gsindex = GS_TLS_SEL;
 747                         task->thread.gs = 0;
 748                 } else {
 749                         task->thread.gsindex = 0;
 750                         task->thread.gs = addr;
 751                         if (doit) {
 752                                 load_gs_index(0);
 753                                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
 754                         }
 755                 }
 756                 put_cpu();
 757                 break;
 758         case ARCH_SET_FS:
 759                 /* Not strictly needed for fs, but do it for symmetry
 760                    with gs */
 761                 if (addr >= TASK_SIZE_OF(task))
 762                         return -EPERM;
 763                 cpu = get_cpu();
 764                 /* handle small bases via the GDT because that's faster to
 765                    switch. */
 766                 if (addr <= 0xffffffff) {
 767                         set_32bit_tls(task, FS_TLS, addr);
 768                         if (doit) {
 769                                 load_TLS(&task->thread, cpu);
 770                                 asm volatile("movl %0,%%fs" :: "r"(FS_TLS_SEL));
 771                         }
 772                         task->thread.fsindex = FS_TLS_SEL;
 773                         task->thread.fs = 0;
 774                 } else {
 775                         task->thread.fsindex = 0;
 776                         task->thread.fs = addr;
 777                         if (doit) {
 778                                 /* set the selector to 0 to not confuse
 779                                    __switch_to */
 780                                 asm volatile("movl %0,%%fs" :: "r" (0));
 781                                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
 782                         }
 783                 }
 784                 put_cpu();
 785                 break;
 786         case ARCH_GET_FS: {
 787                 unsigned long base;
 788                 if (task->thread.fsindex == FS_TLS_SEL)
 789                         base = read_32bit_tls(task, FS_TLS);
 790                 else if (doit)
 791                         rdmsrl(MSR_FS_BASE, base);
 792                 else
 793                         base = task->thread.fs;
 794                 ret = put_user(base, (unsigned long __user *)addr);
 795                 break;
 796         }
 797         case ARCH_GET_GS: {
 798                 unsigned long base;
 799                 unsigned gsindex;
 800                 if (task->thread.gsindex == GS_TLS_SEL)
 801                         base = read_32bit_tls(task, GS_TLS);
 802                 else if (doit) {
 803                         asm("movl %%gs,%0" : "=r" (gsindex));
 804                         if (gsindex)
 805                                 rdmsrl(MSR_KERNEL_GS_BASE, base);
 806                         else
 807                                 base = task->thread.gs;
 808                 }
 809                 else
 810                         base = task->thread.gs;
 811                 ret = put_user(base, (unsigned long __user *)addr);
 812                 break;
 813         }
 814
 815         default:
 816                 ret = -EINVAL;
 817                 break;
 818         }
 819
 820         return ret;
 821 }
 822
 823 long sys_arch_prctl(int code, unsigned long addr)
 824 {
 825         return do_arch_prctl(current, code, addr);
 826 }
 827
 828 unsigned long arch_align_stack(unsigned long sp)
 829 {
 830         if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
 831                 sp -= get_random_int() % 8192;
 832         return sp & ~0xf;
 833 }
 834
 835 unsigned long arch_randomize_brk(struct mm_struct *mm)
 836 {
 837         unsigned long range_end = mm->brk + 0x02000000;
 838         return randomize_range(mm->brk, range_end, 0) ? : mm->brk;
 839 }