Merge branch 'for-rmk/samsung6' of git://git.fluff.org/bjdooks/linux into devel-stable
[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 <linux/stackprotector.h>
18 #include <linux/cpu.h>
19 #include <linux/errno.h>
20 #include <linux/sched.h>
21 #include <linux/fs.h>
22 #include <linux/kernel.h>
23 #include <linux/mm.h>
24 #include <linux/elfcore.h>
25 #include <linux/smp.h>
26 #include <linux/slab.h>
27 #include <linux/user.h>
28 #include <linux/interrupt.h>
29 #include <linux/delay.h>
30 #include <linux/module.h>
31 #include <linux/ptrace.h>
32 #include <linux/notifier.h>
33 #include <linux/kprobes.h>
34 #include <linux/kdebug.h>
35 #include <linux/tick.h>
36 #include <linux/prctl.h>
37 #include <linux/uaccess.h>
38 #include <linux/io.h>
39 #include <linux/ftrace.h>
40
41 #include <asm/pgtable.h>
42 #include <asm/system.h>
43 #include <asm/processor.h>
44 #include <asm/i387.h>
45 #include <asm/mmu_context.h>
46 #include <asm/prctl.h>
47 #include <asm/desc.h>
48 #include <asm/proto.h>
49 #include <asm/ia32.h>
50 #include <asm/idle.h>
51 #include <asm/syscalls.h>
52 #include <asm/ds.h>
53 #include <asm/debugreg.h>
54
55 asmlinkage extern void ret_from_fork(void);
56
57 DEFINE_PER_CPU(unsigned long, old_rsp);
58 static DEFINE_PER_CPU(unsigned char, is_idle);
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         percpu_write(is_idle, 1);
77         atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
78 }
79
80 static void __exit_idle(void)
81 {
82         if (x86_test_and_clear_bit_percpu(0, is_idle) == 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
113         /*
114          * If we're the non-boot CPU, nothing set the stack canary up
115          * for us.  CPU0 already has it initialized but no harm in
116          * doing it again.  This is a good place for updating it, as
117          * we wont ever return from this function (so the invalid
118          * canaries already on the stack wont ever trigger).
119          */
120         boot_init_stack_canary();
121
122         /* endless idle loop with no priority at all */
123         while (1) {
124                 tick_nohz_stop_sched_tick(1);
125                 while (!need_resched()) {
126
127                         rmb();
128
129                         if (cpu_is_offline(smp_processor_id()))
130                                 play_dead();
131                         /*
132                          * Idle routines should keep interrupts disabled
133                          * from here on, until they go to idle.
134                          * Otherwise, idle callbacks can misfire.
135                          */
136                         local_irq_disable();
137                         enter_idle();
138                         /* Don't trace irqs off for idle */
139                         stop_critical_timings();
140                         pm_idle();
141                         start_critical_timings();
142                         /* In many cases the interrupt that ended idle
143                            has already called exit_idle. But some idle
144                            loops can be woken up without interrupt. */
145                         __exit_idle();
146                 }
147
148                 tick_nohz_restart_sched_tick();
149                 preempt_enable_no_resched();
150                 schedule();
151                 preempt_disable();
152         }
153 }
154
155 /* Prints also some state that isn't saved in the pt_regs */
156 void __show_regs(struct pt_regs *regs, int all)
157 {
158         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
159         unsigned long d0, d1, d2, d3, d6, d7;
160         unsigned int fsindex, gsindex;
161         unsigned int ds, cs, es;
162
163         show_regs_common();
164         printk(KERN_DEFAULT "RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->ip);
165         printk_address(regs->ip, 1);
166         printk(KERN_DEFAULT "RSP: %04lx:%016lx  EFLAGS: %08lx\n", regs->ss,
167                         regs->sp, regs->flags);
168         printk(KERN_DEFAULT "RAX: %016lx RBX: %016lx RCX: %016lx\n",
169                regs->ax, regs->bx, regs->cx);
170         printk(KERN_DEFAULT "RDX: %016lx RSI: %016lx RDI: %016lx\n",
171                regs->dx, regs->si, regs->di);
172         printk(KERN_DEFAULT "RBP: %016lx R08: %016lx R09: %016lx\n",
173                regs->bp, regs->r8, regs->r9);
174         printk(KERN_DEFAULT "R10: %016lx R11: %016lx R12: %016lx\n",
175                regs->r10, regs->r11, regs->r12);
176         printk(KERN_DEFAULT "R13: %016lx R14: %016lx R15: %016lx\n",
177                regs->r13, regs->r14, regs->r15);
178
179         asm("movl %%ds,%0" : "=r" (ds));
180         asm("movl %%cs,%0" : "=r" (cs));
181         asm("movl %%es,%0" : "=r" (es));
182         asm("movl %%fs,%0" : "=r" (fsindex));
183         asm("movl %%gs,%0" : "=r" (gsindex));
184
185         rdmsrl(MSR_FS_BASE, fs);
186         rdmsrl(MSR_GS_BASE, gs);
187         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
188
189         if (!all)
190                 return;
191
192         cr0 = read_cr0();
193         cr2 = read_cr2();
194         cr3 = read_cr3();
195         cr4 = read_cr4();
196
197         printk(KERN_DEFAULT "FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
198                fs, fsindex, gs, gsindex, shadowgs);
199         printk(KERN_DEFAULT "CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds,
200                         es, cr0);
201         printk(KERN_DEFAULT "CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3,
202                         cr4);
203
204         get_debugreg(d0, 0);
205         get_debugreg(d1, 1);
206         get_debugreg(d2, 2);
207         printk(KERN_DEFAULT "DR0: %016lx DR1: %016lx DR2: %016lx\n", d0, d1, d2);
208         get_debugreg(d3, 3);
209         get_debugreg(d6, 6);
210         get_debugreg(d7, 7);
211         printk(KERN_DEFAULT "DR3: %016lx DR6: %016lx DR7: %016lx\n", d3, d6, d7);
212 }
213
214 void show_regs(struct pt_regs *regs)
215 {
216         show_registers(regs);
217         show_trace(NULL, regs, (void *)(regs + 1), regs->bp);
218 }
219
220 void release_thread(struct task_struct *dead_task)
221 {
222         if (dead_task->mm) {
223                 if (dead_task->mm->context.size) {
224                         printk("WARNING: dead process %8s still has LDT? <%p/%d>\n",
225                                         dead_task->comm,
226                                         dead_task->mm->context.ldt,
227                                         dead_task->mm->context.size);
228                         BUG();
229                 }
230         }
231 }
232
233 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr)
234 {
235         struct user_desc ud = {
236                 .base_addr = addr,
237                 .limit = 0xfffff,
238                 .seg_32bit = 1,
239                 .limit_in_pages = 1,
240                 .useable = 1,
241         };
242         struct desc_struct *desc = t->thread.tls_array;
243         desc += tls;
244         fill_ldt(desc, &ud);
245 }
246
247 static inline u32 read_32bit_tls(struct task_struct *t, int tls)
248 {
249         return get_desc_base(&t->thread.tls_array[tls]);
250 }
251
252 /*
253  * This gets called before we allocate a new thread and copy
254  * the current task into it.
255  */
256 void prepare_to_copy(struct task_struct *tsk)
257 {
258         unlazy_fpu(tsk);
259 }
260
261 int copy_thread(unsigned long clone_flags, unsigned long sp,
262                 unsigned long unused,
263         struct task_struct *p, struct pt_regs *regs)
264 {
265         int err;
266         struct pt_regs *childregs;
267         struct task_struct *me = current;
268
269         childregs = ((struct pt_regs *)
270                         (THREAD_SIZE + task_stack_page(p))) - 1;
271         *childregs = *regs;
272
273         childregs->ax = 0;
274         if (user_mode(regs))
275                 childregs->sp = sp;
276         else
277                 childregs->sp = (unsigned long)childregs;
278
279         p->thread.sp = (unsigned long) childregs;
280         p->thread.sp0 = (unsigned long) (childregs+1);
281         p->thread.usersp = me->thread.usersp;
282
283         set_tsk_thread_flag(p, TIF_FORK);
284
285         p->thread.fs = me->thread.fs;
286         p->thread.gs = me->thread.gs;
287         p->thread.io_bitmap_ptr = NULL;
288
289         savesegment(gs, p->thread.gsindex);
290         savesegment(fs, p->thread.fsindex);
291         savesegment(es, p->thread.es);
292         savesegment(ds, p->thread.ds);
293
294         err = -ENOMEM;
295         memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
296
297         if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
298                 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
299                 if (!p->thread.io_bitmap_ptr) {
300                         p->thread.io_bitmap_max = 0;
301                         return -ENOMEM;
302                 }
303                 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr,
304                                 IO_BITMAP_BYTES);
305                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
306         }
307
308         /*
309          * Set a new TLS for the child thread?
310          */
311         if (clone_flags & CLONE_SETTLS) {
312 #ifdef CONFIG_IA32_EMULATION
313                 if (test_thread_flag(TIF_IA32))
314                         err = do_set_thread_area(p, -1,
315                                 (struct user_desc __user *)childregs->si, 0);
316                 else
317 #endif
318                         err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8);
319                 if (err)
320                         goto out;
321         }
322
323         clear_tsk_thread_flag(p, TIF_DS_AREA_MSR);
324         p->thread.ds_ctx = NULL;
325
326         clear_tsk_thread_flag(p, TIF_DEBUGCTLMSR);
327         p->thread.debugctlmsr = 0;
328
329         err = 0;
330 out:
331         if (err && p->thread.io_bitmap_ptr) {
332                 kfree(p->thread.io_bitmap_ptr);
333                 p->thread.io_bitmap_max = 0;
334         }
335
336         return err;
337 }
338
339 static void
340 start_thread_common(struct pt_regs *regs, unsigned long new_ip,
341                     unsigned long new_sp,
342                     unsigned int _cs, unsigned int _ss, unsigned int _ds)
343 {
344         loadsegment(fs, 0);
345         loadsegment(es, _ds);
346         loadsegment(ds, _ds);
347         load_gs_index(0);
348         regs->ip                = new_ip;
349         regs->sp                = new_sp;
350         percpu_write(old_rsp, new_sp);
351         regs->cs                = _cs;
352         regs->ss                = _ss;
353         regs->flags             = X86_EFLAGS_IF;
354         set_fs(USER_DS);
355         /*
356          * Free the old FP and other extended state
357          */
358         free_thread_xstate(current);
359 }
360
361 void
362 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
363 {
364         start_thread_common(regs, new_ip, new_sp,
365                             __USER_CS, __USER_DS, 0);
366 }
367
368 #ifdef CONFIG_IA32_EMULATION
369 void start_thread_ia32(struct pt_regs *regs, u32 new_ip, u32 new_sp)
370 {
371         start_thread_common(regs, new_ip, new_sp,
372                             __USER32_CS, __USER32_DS, __USER32_DS);
373 }
374 #endif
375
376 /*
377  *      switch_to(x,y) should switch tasks from x to y.
378  *
379  * This could still be optimized:
380  * - fold all the options into a flag word and test it with a single test.
381  * - could test fs/gs bitsliced
382  *
383  * Kprobes not supported here. Set the probe on schedule instead.
384  * Function graph tracer not supported too.
385  */
386 __notrace_funcgraph struct task_struct *
387 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
388 {
389         struct thread_struct *prev = &prev_p->thread;
390         struct thread_struct *next = &next_p->thread;
391         int cpu = smp_processor_id();
392         struct tss_struct *tss = &per_cpu(init_tss, cpu);
393         unsigned fsindex, gsindex;
394         bool preload_fpu;
395
396         /*
397          * If the task has used fpu the last 5 timeslices, just do a full
398          * restore of the math state immediately to avoid the trap; the
399          * chances of needing FPU soon are obviously high now
400          */
401         preload_fpu = tsk_used_math(next_p) && next_p->fpu_counter > 5;
402
403         /* we're going to use this soon, after a few expensive things */
404         if (preload_fpu)
405                 prefetch(next->xstate);
406
407         /*
408          * Reload esp0, LDT and the page table pointer:
409          */
410         load_sp0(tss, next);
411
412         /*
413          * Switch DS and ES.
414          * This won't pick up thread selector changes, but I guess that is ok.
415          */
416         savesegment(es, prev->es);
417         if (unlikely(next->es | prev->es))
418                 loadsegment(es, next->es);
419
420         savesegment(ds, prev->ds);
421         if (unlikely(next->ds | prev->ds))
422                 loadsegment(ds, next->ds);
423
424
425         /* We must save %fs and %gs before load_TLS() because
426          * %fs and %gs may be cleared by load_TLS().
427          *
428          * (e.g. xen_load_tls())
429          */
430         savesegment(fs, fsindex);
431         savesegment(gs, gsindex);
432
433         load_TLS(next, cpu);
434
435         /* Must be after DS reload */
436         unlazy_fpu(prev_p);
437
438         /* Make sure cpu is ready for new context */
439         if (preload_fpu)
440                 clts();
441
442         /*
443          * Leave lazy mode, flushing any hypercalls made here.
444          * This must be done before restoring TLS segments so
445          * the GDT and LDT are properly updated, and must be
446          * done before math_state_restore, so the TS bit is up
447          * to date.
448          */
449         arch_end_context_switch(next_p);
450
451         /*
452          * Switch FS and GS.
453          *
454          * Segment register != 0 always requires a reload.  Also
455          * reload when it has changed.  When prev process used 64bit
456          * base always reload to avoid an information leak.
457          */
458         if (unlikely(fsindex | next->fsindex | prev->fs)) {
459                 loadsegment(fs, next->fsindex);
460                 /*
461                  * Check if the user used a selector != 0; if yes
462                  *  clear 64bit base, since overloaded base is always
463                  *  mapped to the Null selector
464                  */
465                 if (fsindex)
466                         prev->fs = 0;
467         }
468         /* when next process has a 64bit base use it */
469         if (next->fs)
470                 wrmsrl(MSR_FS_BASE, next->fs);
471         prev->fsindex = fsindex;
472
473         if (unlikely(gsindex | next->gsindex | prev->gs)) {
474                 load_gs_index(next->gsindex);
475                 if (gsindex)
476                         prev->gs = 0;
477         }
478         if (next->gs)
479                 wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
480         prev->gsindex = gsindex;
481
482         /*
483          * Switch the PDA and FPU contexts.
484          */
485         prev->usersp = percpu_read(old_rsp);
486         percpu_write(old_rsp, next->usersp);
487         percpu_write(current_task, next_p);
488
489         percpu_write(kernel_stack,
490                   (unsigned long)task_stack_page(next_p) +
491                   THREAD_SIZE - KERNEL_STACK_OFFSET);
492
493         /*
494          * Now maybe reload the debug registers and handle I/O bitmaps
495          */
496         if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT ||
497                      task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
498                 __switch_to_xtra(prev_p, next_p, tss);
499
500         /*
501          * Preload the FPU context, now that we've determined that the
502          * task is likely to be using it. 
503          */
504         if (preload_fpu)
505                 __math_state_restore();
506
507         return prev_p;
508 }
509
510 void set_personality_64bit(void)
511 {
512         /* inherit personality from parent */
513
514         /* Make sure to be in 64bit mode */
515         clear_thread_flag(TIF_IA32);
516
517         /* TBD: overwrites user setup. Should have two bits.
518            But 64bit processes have always behaved this way,
519            so it's not too bad. The main problem is just that
520            32bit childs are affected again. */
521         current->personality &= ~READ_IMPLIES_EXEC;
522 }
523
524 void set_personality_ia32(void)
525 {
526         /* inherit personality from parent */
527
528         /* Make sure to be in 32bit mode */
529         set_thread_flag(TIF_IA32);
530         current->personality |= force_personality32;
531
532         /* Prepare the first "return" to user space */
533         current_thread_info()->status |= TS_COMPAT;
534 }
535
536 unsigned long get_wchan(struct task_struct *p)
537 {
538         unsigned long stack;
539         u64 fp, ip;
540         int count = 0;
541
542         if (!p || p == current || p->state == TASK_RUNNING)
543                 return 0;
544         stack = (unsigned long)task_stack_page(p);
545         if (p->thread.sp < stack || p->thread.sp >= stack+THREAD_SIZE)
546                 return 0;
547         fp = *(u64 *)(p->thread.sp);
548         do {
549                 if (fp < (unsigned long)stack ||
550                     fp >= (unsigned long)stack+THREAD_SIZE)
551                         return 0;
552                 ip = *(u64 *)(fp+8);
553                 if (!in_sched_functions(ip))
554                         return ip;
555                 fp = *(u64 *)fp;
556         } while (count++ < 16);
557         return 0;
558 }
559
560 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
561 {
562         int ret = 0;
563         int doit = task == current;
564         int cpu;
565
566         switch (code) {
567         case ARCH_SET_GS:
568                 if (addr >= TASK_SIZE_OF(task))
569                         return -EPERM;
570                 cpu = get_cpu();
571                 /* handle small bases via the GDT because that's faster to
572                    switch. */
573                 if (addr <= 0xffffffff) {
574                         set_32bit_tls(task, GS_TLS, addr);
575                         if (doit) {
576                                 load_TLS(&task->thread, cpu);
577                                 load_gs_index(GS_TLS_SEL);
578                         }
579                         task->thread.gsindex = GS_TLS_SEL;
580                         task->thread.gs = 0;
581                 } else {
582                         task->thread.gsindex = 0;
583                         task->thread.gs = addr;
584                         if (doit) {
585                                 load_gs_index(0);
586                                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
587                         }
588                 }
589                 put_cpu();
590                 break;
591         case ARCH_SET_FS:
592                 /* Not strictly needed for fs, but do it for symmetry
593                    with gs */
594                 if (addr >= TASK_SIZE_OF(task))
595                         return -EPERM;
596                 cpu = get_cpu();
597                 /* handle small bases via the GDT because that's faster to
598                    switch. */
599                 if (addr <= 0xffffffff) {
600                         set_32bit_tls(task, FS_TLS, addr);
601                         if (doit) {
602                                 load_TLS(&task->thread, cpu);
603                                 loadsegment(fs, FS_TLS_SEL);
604                         }
605                         task->thread.fsindex = FS_TLS_SEL;
606                         task->thread.fs = 0;
607                 } else {
608                         task->thread.fsindex = 0;
609                         task->thread.fs = addr;
610                         if (doit) {
611                                 /* set the selector to 0 to not confuse
612                                    __switch_to */
613                                 loadsegment(fs, 0);
614                                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
615                         }
616                 }
617                 put_cpu();
618                 break;
619         case ARCH_GET_FS: {
620                 unsigned long base;
621                 if (task->thread.fsindex == FS_TLS_SEL)
622                         base = read_32bit_tls(task, FS_TLS);
623                 else if (doit)
624                         rdmsrl(MSR_FS_BASE, base);
625                 else
626                         base = task->thread.fs;
627                 ret = put_user(base, (unsigned long __user *)addr);
628                 break;
629         }
630         case ARCH_GET_GS: {
631                 unsigned long base;
632                 unsigned gsindex;
633                 if (task->thread.gsindex == GS_TLS_SEL)
634                         base = read_32bit_tls(task, GS_TLS);
635                 else if (doit) {
636                         savesegment(gs, gsindex);
637                         if (gsindex)
638                                 rdmsrl(MSR_KERNEL_GS_BASE, base);
639                         else
640                                 base = task->thread.gs;
641                 } else
642                         base = task->thread.gs;
643                 ret = put_user(base, (unsigned long __user *)addr);
644                 break;
645         }
646
647         default:
648                 ret = -EINVAL;
649                 break;
650         }
651
652         return ret;
653 }
654
655 long sys_arch_prctl(int code, unsigned long addr)
656 {
657         return do_arch_prctl(current, code, addr);
658 }
659
660 unsigned long KSTK_ESP(struct task_struct *task)
661 {
662         return (test_tsk_thread_flag(task, TIF_IA32)) ?
663                         (task_pt_regs(task)->sp) : ((task)->thread.usersp);
664 }