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