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