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