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         savesegment(gs, p->thread.gsindex);
 339         savesegment(fs, p->thread.fsindex);
 340         savesegment(es, p->thread.es);
 341         savesegment(ds, 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         loadsegment(fs, 0);
 381         loadsegment(es, 0);
 382         loadsegment(ds, 0);
 383         load_gs_index(0);
 384         regs->ip                = new_ip;
 385         regs->sp                = new_sp;
 386         write_pda(oldrsp, new_sp);
 387         regs->cs                = __USER_CS;
 388         regs->ss                = __USER_DS;
 389         regs->flags             = 0x200;
 390         set_fs(USER_DS);
 391         /*
 392          * Free the old FP and other extended state
 393          */
 394         free_thread_xstate(current);
 395 }
 396 EXPORT_SYMBOL_GPL(start_thread);
 397
 398 static void hard_disable_TSC(void)
 399 {
 400         write_cr4(read_cr4() | X86_CR4_TSD);
 401 }
 402
 403 void disable_TSC(void)
 404 {
 405         preempt_disable();
 406         if (!test_and_set_thread_flag(TIF_NOTSC))
 407                 /*
 408                  * Must flip the CPU state synchronously with
 409                  * TIF_NOTSC in the current running context.
 410                  */
 411                 hard_disable_TSC();
 412         preempt_enable();
 413 }
 414
 415 static void hard_enable_TSC(void)
 416 {
 417         write_cr4(read_cr4() & ~X86_CR4_TSD);
 418 }
 419
 420 static void enable_TSC(void)
 421 {
 422         preempt_disable();
 423         if (test_and_clear_thread_flag(TIF_NOTSC))
 424                 /*
 425                  * Must flip the CPU state synchronously with
 426                  * TIF_NOTSC in the current running context.
 427                  */
 428                 hard_enable_TSC();
 429         preempt_enable();
 430 }
 431
 432 int get_tsc_mode(unsigned long adr)
 433 {
 434         unsigned int val;
 435
 436         if (test_thread_flag(TIF_NOTSC))
 437                 val = PR_TSC_SIGSEGV;
 438         else
 439                 val = PR_TSC_ENABLE;
 440
 441         return put_user(val, (unsigned int __user *)adr);
 442 }
 443
 444 int set_tsc_mode(unsigned int val)
 445 {
 446         if (val == PR_TSC_SIGSEGV)
 447                 disable_TSC();
 448         else if (val == PR_TSC_ENABLE)
 449                 enable_TSC();
 450         else
 451                 return -EINVAL;
 452
 453         return 0;
 454 }
 455
 456 /*
 457  * This special macro can be used to load a debugging register
 458  */
 459 #define loaddebug(thread, r) set_debugreg(thread->debugreg ## r, r)
 460
 461 static inline void __switch_to_xtra(struct task_struct *prev_p,
 462                                     struct task_struct *next_p,
 463                                     struct tss_struct *tss)
 464 {
 465         struct thread_struct *prev, *next;
 466         unsigned long debugctl;
 467
 468         prev = &prev_p->thread,
 469         next = &next_p->thread;
 470
 471         debugctl = prev->debugctlmsr;
 472         if (next->ds_area_msr != prev->ds_area_msr) {
 473                 /* we clear debugctl to make sure DS
 474                  * is not in use when we change it */
 475                 debugctl = 0;
 476                 update_debugctlmsr(0);
 477                 wrmsrl(MSR_IA32_DS_AREA, next->ds_area_msr);
 478         }
 479
 480         if (next->debugctlmsr != debugctl)
 481                 update_debugctlmsr(next->debugctlmsr);
 482
 483         if (test_tsk_thread_flag(next_p, TIF_DEBUG)) {
 484                 loaddebug(next, 0);
 485                 loaddebug(next, 1);
 486                 loaddebug(next, 2);
 487                 loaddebug(next, 3);
 488                 /* no 4 and 5 */
 489                 loaddebug(next, 6);
 490                 loaddebug(next, 7);
 491         }
 492
 493         if (test_tsk_thread_flag(prev_p, TIF_NOTSC) ^
 494             test_tsk_thread_flag(next_p, TIF_NOTSC)) {
 495                 /* prev and next are different */
 496                 if (test_tsk_thread_flag(next_p, TIF_NOTSC))
 497                         hard_disable_TSC();
 498                 else
 499                         hard_enable_TSC();
 500         }
 501
 502         if (test_tsk_thread_flag(next_p, TIF_IO_BITMAP)) {
 503                 /*
 504                  * Copy the relevant range of the IO bitmap.
 505                  * Normally this is 128 bytes or less:
 506                  */
 507                 memcpy(tss->io_bitmap, next->io_bitmap_ptr,
 508                        max(prev->io_bitmap_max, next->io_bitmap_max));
 509         } else if (test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)) {
 510                 /*
 511                  * Clear any possible leftover bits:
 512                  */
 513                 memset(tss->io_bitmap, 0xff, prev->io_bitmap_max);
 514         }
 515
 516 #ifdef X86_BTS
 517         if (test_tsk_thread_flag(prev_p, TIF_BTS_TRACE_TS))
 518                 ptrace_bts_take_timestamp(prev_p, BTS_TASK_DEPARTS);
 519
 520         if (test_tsk_thread_flag(next_p, TIF_BTS_TRACE_TS))
 521                 ptrace_bts_take_timestamp(next_p, BTS_TASK_ARRIVES);
 522 #endif
 523 }
 524
 525 /*
 526  *      switch_to(x,y) should switch tasks from x to y.
 527  *
 528  * This could still be optimized:
 529  * - fold all the options into a flag word and test it with a single test.
 530  * - could test fs/gs bitsliced
 531  *
 532  * Kprobes not supported here. Set the probe on schedule instead.
 533  */
 534 struct task_struct *
 535 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 536 {
 537         struct thread_struct *prev = &prev_p->thread,
 538                                  *next = &next_p->thread;
 539         int cpu = smp_processor_id();
 540         struct tss_struct *tss = &per_cpu(init_tss, cpu);
 541
 542         /* we're going to use this soon, after a few expensive things */
 543         if (next_p->fpu_counter>5)
 544                 prefetch(next->xstate);
 545
 546         /*
 547          * Reload esp0, LDT and the page table pointer:
 548          */
 549         load_sp0(tss, next);
 550
 551         /*
 552          * Switch DS and ES.
 553          * This won't pick up thread selector changes, but I guess that is ok.
 554          */
 555         savesegment(es, prev->es);
 556         if (unlikely(next->es | prev->es))
 557                 loadsegment(es, next->es);
 558
 559         savesegment(ds, prev->ds);
 560         if (unlikely(next->ds | prev->ds))
 561                 loadsegment(ds, next->ds);
 562
 563         load_TLS(next, cpu);
 564
 565         /*
 566          * Leave lazy mode, flushing any hypercalls made here.
 567          * This must be done before restoring TLS segments so
 568          * the GDT and LDT are properly updated, and must be
 569          * done before math_state_restore, so the TS bit is up
 570          * to date.
 571          */
 572         arch_leave_lazy_cpu_mode();
 573
 574         /*
 575          * Switch FS and GS.
 576          */
 577         {
 578                 unsigned fsindex;
 579                 savesegment(fs, fsindex);
 580                 /* segment register != 0 always requires a reload.
 581                    also reload when it has changed.
 582                    when prev process used 64bit base always reload
 583                    to avoid an information leak. */
 584                 if (unlikely(fsindex | next->fsindex | prev->fs)) {
 585                         loadsegment(fs, next->fsindex);
 586                         /* check if the user used a selector != 0
 587                          * if yes clear 64bit base, since overloaded base
 588                          * is always mapped to the Null selector
 589                          */
 590                         if (fsindex)
 591                         prev->fs = 0;
 592                 }
 593                 /* when next process has a 64bit base use it */
 594                 if (next->fs)
 595                         wrmsrl(MSR_FS_BASE, next->fs);
 596                 prev->fsindex = fsindex;
 597         }
 598         {
 599                 unsigned gsindex;
 600                 savesegment(gs, gsindex);
 601                 if (unlikely(gsindex | next->gsindex | prev->gs)) {
 602                         load_gs_index(next->gsindex);
 603                         if (gsindex)
 604                         prev->gs = 0;
 605                 }
 606                 if (next->gs)
 607                         wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
 608                 prev->gsindex = gsindex;
 609         }
 610
 611         /* Must be after DS reload */
 612         unlazy_fpu(prev_p);
 613
 614         /*
 615          * Switch the PDA and FPU contexts.
 616          */
 617         prev->usersp = read_pda(oldrsp);
 618         write_pda(oldrsp, next->usersp);
 619         write_pda(pcurrent, next_p);
 620
 621         write_pda(kernelstack,
 622         (unsigned long)task_stack_page(next_p) + THREAD_SIZE - PDA_STACKOFFSET);
 623 #ifdef CONFIG_CC_STACKPROTECTOR
 624         write_pda(stack_canary, next_p->stack_canary);
 625         /*
 626          * Build time only check to make sure the stack_canary is at
 627          * offset 40 in the pda; this is a gcc ABI requirement
 628          */
 629         BUILD_BUG_ON(offsetof(struct x8664_pda, stack_canary) != 40);
 630 #endif
 631
 632         /*
 633          * Now maybe reload the debug registers and handle I/O bitmaps
 634          */
 635         if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT ||
 636                      task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
 637                 __switch_to_xtra(prev_p, next_p, tss);
 638
 639         /* If the task has used fpu the last 5 timeslices, just do a full
 640          * restore of the math state immediately to avoid the trap; the
 641          * chances of needing FPU soon are obviously high now
 642          *
 643          * tsk_used_math() checks prevent calling math_state_restore(),
 644          * which can sleep in the case of !tsk_used_math()
 645          */
 646         if (tsk_used_math(next_p) && next_p->fpu_counter > 5)
 647                 math_state_restore();
 648         return prev_p;
 649 }
 650
 651 /*
 652  * sys_execve() executes a new program.
 653  */
 654 asmlinkage
 655 long sys_execve(char __user *name, char __user * __user *argv,
 656                 char __user * __user *envp, struct pt_regs *regs)
 657 {
 658         long error;
 659         char * filename;
 660
 661         filename = getname(name);
 662         error = PTR_ERR(filename);
 663         if (IS_ERR(filename))
 664                 return error;
 665         error = do_execve(filename, argv, envp, regs);
 666         putname(filename);
 667         return error;
 668 }
 669
 670 void set_personality_64bit(void)
 671 {
 672         /* inherit personality from parent */
 673
 674         /* Make sure to be in 64bit mode */
 675         clear_thread_flag(TIF_IA32);
 676
 677         /* TBD: overwrites user setup. Should have two bits.
 678            But 64bit processes have always behaved this way,
 679            so it's not too bad. The main problem is just that
 680            32bit childs are affected again. */
 681         current->personality &= ~READ_IMPLIES_EXEC;
 682 }
 683
 684 asmlinkage long sys_fork(struct pt_regs *regs)
 685 {
 686         return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
 687 }
 688
 689 asmlinkage long
 690 sys_clone(unsigned long clone_flags, unsigned long newsp,
 691           void __user *parent_tid, void __user *child_tid, struct pt_regs *regs)
 692 {
 693         if (!newsp)
 694                 newsp = regs->sp;
 695         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
 696 }
 697
 698 /*
 699  * This is trivial, and on the face of it looks like it
 700  * could equally well be done in user mode.
 701  *
 702  * Not so, for quite unobvious reasons - register pressure.
 703  * In user mode vfork() cannot have a stack frame, and if
 704  * done by calling the "clone()" system call directly, you
 705  * do not have enough call-clobbered registers to hold all
 706  * the information you need.
 707  */
 708 asmlinkage long sys_vfork(struct pt_regs *regs)
 709 {
 710         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->sp, regs, 0,
 711                     NULL, NULL);
 712 }
 713
 714 unsigned long get_wchan(struct task_struct *p)
 715 {
 716         unsigned long stack;
 717         u64 fp,ip;
 718         int count = 0;
 719
 720         if (!p || p == current || p->state==TASK_RUNNING)
 721                 return 0;
 722         stack = (unsigned long)task_stack_page(p);
 723         if (p->thread.sp < stack || p->thread.sp > stack+THREAD_SIZE)
 724                 return 0;
 725         fp = *(u64 *)(p->thread.sp);
 726         do {
 727                 if (fp < (unsigned long)stack ||
 728                     fp > (unsigned long)stack+THREAD_SIZE)
 729                         return 0;
 730                 ip = *(u64 *)(fp+8);
 731                 if (!in_sched_functions(ip))
 732                         return ip;
 733                 fp = *(u64 *)fp;
 734         } while (count++ < 16);
 735         return 0;
 736 }
 737
 738 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
 739 {
 740         int ret = 0;
 741         int doit = task == current;
 742         int cpu;
 743
 744         switch (code) {
 745         case ARCH_SET_GS:
 746                 if (addr >= TASK_SIZE_OF(task))
 747                         return -EPERM;
 748                 cpu = get_cpu();
 749                 /* handle small bases via the GDT because that's faster to
 750                    switch. */
 751                 if (addr <= 0xffffffff) {
 752                         set_32bit_tls(task, GS_TLS, addr);
 753                         if (doit) {
 754                                 load_TLS(&task->thread, cpu);
 755                                 load_gs_index(GS_TLS_SEL);
 756                         }
 757                         task->thread.gsindex = GS_TLS_SEL;
 758                         task->thread.gs = 0;
 759                 } else {
 760                         task->thread.gsindex = 0;
 761                         task->thread.gs = addr;
 762                         if (doit) {
 763                                 load_gs_index(0);
 764                                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
 765                         }
 766                 }
 767                 put_cpu();
 768                 break;
 769         case ARCH_SET_FS:
 770                 /* Not strictly needed for fs, but do it for symmetry
 771                    with gs */
 772                 if (addr >= TASK_SIZE_OF(task))
 773                         return -EPERM;
 774                 cpu = get_cpu();
 775                 /* handle small bases via the GDT because that's faster to
 776                    switch. */
 777                 if (addr <= 0xffffffff) {
 778                         set_32bit_tls(task, FS_TLS, addr);
 779                         if (doit) {
 780                                 load_TLS(&task->thread, cpu);
 781                                 loadsegment(fs, FS_TLS_SEL);
 782                         }
 783                         task->thread.fsindex = FS_TLS_SEL;
 784                         task->thread.fs = 0;
 785                 } else {
 786                         task->thread.fsindex = 0;
 787                         task->thread.fs = addr;
 788                         if (doit) {
 789                                 /* set the selector to 0 to not confuse
 790                                    __switch_to */
 791                                 loadsegment(fs, 0);
 792                                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
 793                         }
 794                 }
 795                 put_cpu();
 796                 break;
 797         case ARCH_GET_FS: {
 798                 unsigned long base;
 799                 if (task->thread.fsindex == FS_TLS_SEL)
 800                         base = read_32bit_tls(task, FS_TLS);
 801                 else if (doit)
 802                         rdmsrl(MSR_FS_BASE, base);
 803                 else
 804                         base = task->thread.fs;
 805                 ret = put_user(base, (unsigned long __user *)addr);
 806                 break;
 807         }
 808         case ARCH_GET_GS: {
 809                 unsigned long base;
 810                 unsigned gsindex;
 811                 if (task->thread.gsindex == GS_TLS_SEL)
 812                         base = read_32bit_tls(task, GS_TLS);
 813                 else if (doit) {
 814                         savesegment(gs, gsindex);
 815                         if (gsindex)
 816                                 rdmsrl(MSR_KERNEL_GS_BASE, base);
 817                         else
 818                                 base = task->thread.gs;
 819                 }
 820                 else
 821                         base = task->thread.gs;
 822                 ret = put_user(base, (unsigned long __user *)addr);
 823                 break;
 824         }
 825
 826         default:
 827                 ret = -EINVAL;
 828                 break;
 829         }
 830
 831         return ret;
 832 }
 833
 834 long sys_arch_prctl(int code, unsigned long addr)
 835 {
 836         return do_arch_prctl(current, code, addr);
 837 }
 838
 839 unsigned long arch_align_stack(unsigned long sp)
 840 {
 841         if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
 842                 sp -= get_random_int() % 8192;
 843         return sp & ~0xf;
 844 }
 845
 846 unsigned long arch_randomize_brk(struct mm_struct *mm)
 847 {
 848         unsigned long range_end = mm->brk + 0x02000000;
 849         return randomize_range(mm->brk, range_end, 0) ? : mm->brk;
 850 }