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          * Switch FS and GS.
 567          */
 568         {
 569                 unsigned fsindex;
 570                 savesegment(fs, fsindex);
 571                 /* segment register != 0 always requires a reload.
 572                    also reload when it has changed.
 573                    when prev process used 64bit base always reload
 574                    to avoid an information leak. */
 575                 if (unlikely(fsindex | next->fsindex | prev->fs)) {
 576                         loadsegment(fs, next->fsindex);
 577                         /* check if the user used a selector != 0
 578                          * if yes clear 64bit base, since overloaded base
 579                          * is always mapped to the Null selector
 580                          */
 581                         if (fsindex)
 582                         prev->fs = 0;
 583                 }
 584                 /* when next process has a 64bit base use it */
 585                 if (next->fs)
 586                         wrmsrl(MSR_FS_BASE, next->fs);
 587                 prev->fsindex = fsindex;
 588         }
 589         {
 590                 unsigned gsindex;
 591                 savesegment(gs, gsindex);
 592                 if (unlikely(gsindex | next->gsindex | prev->gs)) {
 593                         load_gs_index(next->gsindex);
 594                         if (gsindex)
 595                         prev->gs = 0;
 596                 }
 597                 if (next->gs)
 598                         wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
 599                 prev->gsindex = gsindex;
 600         }
 601
 602         /* Must be after DS reload */
 603         unlazy_fpu(prev_p);
 604
 605         /*
 606          * Switch the PDA and FPU contexts.
 607          */
 608         prev->usersp = read_pda(oldrsp);
 609         write_pda(oldrsp, next->usersp);
 610         write_pda(pcurrent, next_p);
 611
 612         write_pda(kernelstack,
 613         (unsigned long)task_stack_page(next_p) + THREAD_SIZE - PDA_STACKOFFSET);
 614 #ifdef CONFIG_CC_STACKPROTECTOR
 615         write_pda(stack_canary, next_p->stack_canary);
 616         /*
 617          * Build time only check to make sure the stack_canary is at
 618          * offset 40 in the pda; this is a gcc ABI requirement
 619          */
 620         BUILD_BUG_ON(offsetof(struct x8664_pda, stack_canary) != 40);
 621 #endif
 622
 623         /*
 624          * Now maybe reload the debug registers and handle I/O bitmaps
 625          */
 626         if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT ||
 627                      task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
 628                 __switch_to_xtra(prev_p, next_p, tss);
 629
 630         /* If the task has used fpu the last 5 timeslices, just do a full
 631          * restore of the math state immediately to avoid the trap; the
 632          * chances of needing FPU soon are obviously high now
 633          *
 634          * tsk_used_math() checks prevent calling math_state_restore(),
 635          * which can sleep in the case of !tsk_used_math()
 636          */
 637         if (tsk_used_math(next_p) && next_p->fpu_counter > 5)
 638                 math_state_restore();
 639         return prev_p;
 640 }
 641
 642 /*
 643  * sys_execve() executes a new program.
 644  */
 645 asmlinkage
 646 long sys_execve(char __user *name, char __user * __user *argv,
 647                 char __user * __user *envp, struct pt_regs *regs)
 648 {
 649         long error;
 650         char * filename;
 651
 652         filename = getname(name);
 653         error = PTR_ERR(filename);
 654         if (IS_ERR(filename))
 655                 return error;
 656         error = do_execve(filename, argv, envp, regs);
 657         putname(filename);
 658         return error;
 659 }
 660
 661 void set_personality_64bit(void)
 662 {
 663         /* inherit personality from parent */
 664
 665         /* Make sure to be in 64bit mode */
 666         clear_thread_flag(TIF_IA32);
 667
 668         /* TBD: overwrites user setup. Should have two bits.
 669            But 64bit processes have always behaved this way,
 670            so it's not too bad. The main problem is just that
 671            32bit childs are affected again. */
 672         current->personality &= ~READ_IMPLIES_EXEC;
 673 }
 674
 675 asmlinkage long sys_fork(struct pt_regs *regs)
 676 {
 677         return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
 678 }
 679
 680 asmlinkage long
 681 sys_clone(unsigned long clone_flags, unsigned long newsp,
 682           void __user *parent_tid, void __user *child_tid, struct pt_regs *regs)
 683 {
 684         if (!newsp)
 685                 newsp = regs->sp;
 686         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
 687 }
 688
 689 /*
 690  * This is trivial, and on the face of it looks like it
 691  * could equally well be done in user mode.
 692  *
 693  * Not so, for quite unobvious reasons - register pressure.
 694  * In user mode vfork() cannot have a stack frame, and if
 695  * done by calling the "clone()" system call directly, you
 696  * do not have enough call-clobbered registers to hold all
 697  * the information you need.
 698  */
 699 asmlinkage long sys_vfork(struct pt_regs *regs)
 700 {
 701         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->sp, regs, 0,
 702                     NULL, NULL);
 703 }
 704
 705 unsigned long get_wchan(struct task_struct *p)
 706 {
 707         unsigned long stack;
 708         u64 fp,ip;
 709         int count = 0;
 710
 711         if (!p || p == current || p->state==TASK_RUNNING)
 712                 return 0;
 713         stack = (unsigned long)task_stack_page(p);
 714         if (p->thread.sp < stack || p->thread.sp > stack+THREAD_SIZE)
 715                 return 0;
 716         fp = *(u64 *)(p->thread.sp);
 717         do {
 718                 if (fp < (unsigned long)stack ||
 719                     fp > (unsigned long)stack+THREAD_SIZE)
 720                         return 0;
 721                 ip = *(u64 *)(fp+8);
 722                 if (!in_sched_functions(ip))
 723                         return ip;
 724                 fp = *(u64 *)fp;
 725         } while (count++ < 16);
 726         return 0;
 727 }
 728
 729 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
 730 {
 731         int ret = 0;
 732         int doit = task == current;
 733         int cpu;
 734
 735         switch (code) {
 736         case ARCH_SET_GS:
 737                 if (addr >= TASK_SIZE_OF(task))
 738                         return -EPERM;
 739                 cpu = get_cpu();
 740                 /* handle small bases via the GDT because that's faster to
 741                    switch. */
 742                 if (addr <= 0xffffffff) {
 743                         set_32bit_tls(task, GS_TLS, addr);
 744                         if (doit) {
 745                                 load_TLS(&task->thread, cpu);
 746                                 load_gs_index(GS_TLS_SEL);
 747                         }
 748                         task->thread.gsindex = GS_TLS_SEL;
 749                         task->thread.gs = 0;
 750                 } else {
 751                         task->thread.gsindex = 0;
 752                         task->thread.gs = addr;
 753                         if (doit) {
 754                                 load_gs_index(0);
 755                                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
 756                         }
 757                 }
 758                 put_cpu();
 759                 break;
 760         case ARCH_SET_FS:
 761                 /* Not strictly needed for fs, but do it for symmetry
 762                    with gs */
 763                 if (addr >= TASK_SIZE_OF(task))
 764                         return -EPERM;
 765                 cpu = get_cpu();
 766                 /* handle small bases via the GDT because that's faster to
 767                    switch. */
 768                 if (addr <= 0xffffffff) {
 769                         set_32bit_tls(task, FS_TLS, addr);
 770                         if (doit) {
 771                                 load_TLS(&task->thread, cpu);
 772                                 loadsegment(fs, FS_TLS_SEL);
 773                         }
 774                         task->thread.fsindex = FS_TLS_SEL;
 775                         task->thread.fs = 0;
 776                 } else {
 777                         task->thread.fsindex = 0;
 778                         task->thread.fs = addr;
 779                         if (doit) {
 780                                 /* set the selector to 0 to not confuse
 781                                    __switch_to */
 782                                 loadsegment(fs, 0);
 783                                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
 784                         }
 785                 }
 786                 put_cpu();
 787                 break;
 788         case ARCH_GET_FS: {
 789                 unsigned long base;
 790                 if (task->thread.fsindex == FS_TLS_SEL)
 791                         base = read_32bit_tls(task, FS_TLS);
 792                 else if (doit)
 793                         rdmsrl(MSR_FS_BASE, base);
 794                 else
 795                         base = task->thread.fs;
 796                 ret = put_user(base, (unsigned long __user *)addr);
 797                 break;
 798         }
 799         case ARCH_GET_GS: {
 800                 unsigned long base;
 801                 unsigned gsindex;
 802                 if (task->thread.gsindex == GS_TLS_SEL)
 803                         base = read_32bit_tls(task, GS_TLS);
 804                 else if (doit) {
 805                         savesegment(gs, gsindex);
 806                         if (gsindex)
 807                                 rdmsrl(MSR_KERNEL_GS_BASE, base);
 808                         else
 809                                 base = task->thread.gs;
 810                 }
 811                 else
 812                         base = task->thread.gs;
 813                 ret = put_user(base, (unsigned long __user *)addr);
 814                 break;
 815         }
 816
 817         default:
 818                 ret = -EINVAL;
 819                 break;
 820         }
 821
 822         return ret;
 823 }
 824
 825 long sys_arch_prctl(int code, unsigned long addr)
 826 {
 827         return do_arch_prctl(current, code, addr);
 828 }
 829
 830 unsigned long arch_align_stack(unsigned long sp)
 831 {
 832         if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
 833                 sp -= get_random_int() % 8192;
 834         return sp & ~0xf;
 835 }
 836
 837 unsigned long arch_randomize_brk(struct mm_struct *mm)
 838 {
 839         unsigned long range_end = mm->brk + 0x02000000;
 840         return randomize_range(mm->brk, range_end, 0) ? : mm->brk;
 841 }