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