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