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