Merge ../linux-2.6
[linux-2.6] / arch / x86_64 / kernel / process.c
1 /*
2  *  linux/arch/x86-64/kernel/process.c
3  *
4  *  Copyright (C) 1995  Linus Torvalds
5  *
6  *  Pentium III FXSR, SSE support
7  *      Gareth Hughes <gareth@valinux.com>, May 2000
8  * 
9  *  X86-64 port
10  *      Andi Kleen.
11  *
12  *      CPU hotplug support - ashok.raj@intel.com
13  *  $Id: process.c,v 1.38 2002/01/15 10:08:03 ak Exp $
14  */
15
16 /*
17  * This file handles the architecture-dependent parts of process handling..
18  */
19
20 #include <stdarg.h>
21
22 #include <linux/cpu.h>
23 #include <linux/errno.h>
24 #include <linux/sched.h>
25 #include <linux/kernel.h>
26 #include <linux/mm.h>
27 #include <linux/elfcore.h>
28 #include <linux/smp.h>
29 #include <linux/slab.h>
30 #include <linux/user.h>
31 #include <linux/module.h>
32 #include <linux/a.out.h>
33 #include <linux/interrupt.h>
34 #include <linux/delay.h>
35 #include <linux/ptrace.h>
36 #include <linux/utsname.h>
37 #include <linux/random.h>
38 #include <linux/kprobes.h>
39
40 #include <asm/uaccess.h>
41 #include <asm/pgtable.h>
42 #include <asm/system.h>
43 #include <asm/io.h>
44 #include <asm/processor.h>
45 #include <asm/i387.h>
46 #include <asm/mmu_context.h>
47 #include <asm/pda.h>
48 #include <asm/prctl.h>
49 #include <asm/kdebug.h>
50 #include <asm/desc.h>
51 #include <asm/proto.h>
52 #include <asm/ia32.h>
53
54 asmlinkage extern void ret_from_fork(void);
55
56 unsigned long kernel_thread_flags = CLONE_VM | CLONE_UNTRACED;
57
58 static atomic_t hlt_counter = ATOMIC_INIT(0);
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 static DEFINE_PER_CPU(unsigned int, cpu_idle_state);
68
69 void disable_hlt(void)
70 {
71         atomic_inc(&hlt_counter);
72 }
73
74 EXPORT_SYMBOL(disable_hlt);
75
76 void enable_hlt(void)
77 {
78         atomic_dec(&hlt_counter);
79 }
80
81 EXPORT_SYMBOL(enable_hlt);
82
83 /*
84  * We use this if we don't have any better
85  * idle routine..
86  */
87 void default_idle(void)
88 {
89         local_irq_enable();
90
91         if (!atomic_read(&hlt_counter)) {
92                 clear_thread_flag(TIF_POLLING_NRFLAG);
93                 smp_mb__after_clear_bit();
94                 while (!need_resched()) {
95                         local_irq_disable();
96                         if (!need_resched())
97                                 safe_halt();
98                         else
99                                 local_irq_enable();
100                 }
101                 set_thread_flag(TIF_POLLING_NRFLAG);
102         } else {
103                 while (!need_resched())
104                         cpu_relax();
105         }
106 }
107
108 /*
109  * On SMP it's slightly faster (but much more power-consuming!)
110  * to poll the ->need_resched flag instead of waiting for the
111  * cross-CPU IPI to arrive. Use this option with caution.
112  */
113 static void poll_idle (void)
114 {
115         local_irq_enable();
116
117         asm volatile(
118                 "2:"
119                 "testl %0,%1;"
120                 "rep; nop;"
121                 "je 2b;"
122                 : :
123                 "i" (_TIF_NEED_RESCHED),
124                 "m" (current_thread_info()->flags));
125 }
126
127 void cpu_idle_wait(void)
128 {
129         unsigned int cpu, this_cpu = get_cpu();
130         cpumask_t map;
131
132         set_cpus_allowed(current, cpumask_of_cpu(this_cpu));
133         put_cpu();
134
135         cpus_clear(map);
136         for_each_online_cpu(cpu) {
137                 per_cpu(cpu_idle_state, cpu) = 1;
138                 cpu_set(cpu, map);
139         }
140
141         __get_cpu_var(cpu_idle_state) = 0;
142
143         wmb();
144         do {
145                 ssleep(1);
146                 for_each_online_cpu(cpu) {
147                         if (cpu_isset(cpu, map) &&
148                                         !per_cpu(cpu_idle_state, cpu))
149                                 cpu_clear(cpu, map);
150                 }
151                 cpus_and(map, map, cpu_online_map);
152         } while (!cpus_empty(map));
153 }
154 EXPORT_SYMBOL_GPL(cpu_idle_wait);
155
156 #ifdef CONFIG_HOTPLUG_CPU
157 DECLARE_PER_CPU(int, cpu_state);
158
159 #include <asm/nmi.h>
160 /* We don't actually take CPU down, just spin without interrupts. */
161 static inline void play_dead(void)
162 {
163         idle_task_exit();
164         wbinvd();
165         mb();
166         /* Ack it */
167         __get_cpu_var(cpu_state) = CPU_DEAD;
168
169         while (1)
170                 safe_halt();
171 }
172 #else
173 static inline void play_dead(void)
174 {
175         BUG();
176 }
177 #endif /* CONFIG_HOTPLUG_CPU */
178
179 /*
180  * The idle thread. There's no useful work to be
181  * done, so just try to conserve power and have a
182  * low exit latency (ie sit in a loop waiting for
183  * somebody to say that they'd like to reschedule)
184  */
185 void cpu_idle (void)
186 {
187         set_thread_flag(TIF_POLLING_NRFLAG);
188
189         /* endless idle loop with no priority at all */
190         while (1) {
191                 while (!need_resched()) {
192                         void (*idle)(void);
193
194                         if (__get_cpu_var(cpu_idle_state))
195                                 __get_cpu_var(cpu_idle_state) = 0;
196
197                         rmb();
198                         idle = pm_idle;
199                         if (!idle)
200                                 idle = default_idle;
201                         if (cpu_is_offline(smp_processor_id()))
202                                 play_dead();
203                         idle();
204                 }
205
206                 preempt_enable_no_resched();
207                 schedule();
208                 preempt_disable();
209         }
210 }
211
212 /*
213  * This uses new MONITOR/MWAIT instructions on P4 processors with PNI,
214  * which can obviate IPI to trigger checking of need_resched.
215  * We execute MONITOR against need_resched and enter optimized wait state
216  * through MWAIT. Whenever someone changes need_resched, we would be woken
217  * up from MWAIT (without an IPI).
218  */
219 static void mwait_idle(void)
220 {
221         local_irq_enable();
222
223         while (!need_resched()) {
224                 __monitor((void *)&current_thread_info()->flags, 0, 0);
225                 smp_mb();
226                 if (need_resched())
227                         break;
228                 __mwait(0, 0);
229         }
230 }
231
232 void __cpuinit select_idle_routine(const struct cpuinfo_x86 *c)
233 {
234         static int printed;
235         if (cpu_has(c, X86_FEATURE_MWAIT)) {
236                 /*
237                  * Skip, if setup has overridden idle.
238                  * One CPU supports mwait => All CPUs supports mwait
239                  */
240                 if (!pm_idle) {
241                         if (!printed) {
242                                 printk("using mwait in idle threads.\n");
243                                 printed = 1;
244                         }
245                         pm_idle = mwait_idle;
246                 }
247         }
248 }
249
250 static int __init idle_setup (char *str)
251 {
252         if (!strncmp(str, "poll", 4)) {
253                 printk("using polling idle threads.\n");
254                 pm_idle = poll_idle;
255         }
256
257         boot_option_idle_override = 1;
258         return 1;
259 }
260
261 __setup("idle=", idle_setup);
262
263 /* Prints also some state that isn't saved in the pt_regs */ 
264 void __show_regs(struct pt_regs * regs)
265 {
266         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
267         unsigned int fsindex,gsindex;
268         unsigned int ds,cs,es; 
269
270         printk("\n");
271         print_modules();
272         printk("Pid: %d, comm: %.20s %s %s %.*s\n",
273                 current->pid, current->comm, print_tainted(),
274                 system_utsname.release,
275                 (int)strcspn(system_utsname.version, " "),
276                 system_utsname.version);
277         printk("RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->rip);
278         printk_address(regs->rip); 
279         printk("\nRSP: %04lx:%016lx  EFLAGS: %08lx\n", regs->ss, regs->rsp,
280                 regs->eflags);
281         printk("RAX: %016lx RBX: %016lx RCX: %016lx\n",
282                regs->rax, regs->rbx, regs->rcx);
283         printk("RDX: %016lx RSI: %016lx RDI: %016lx\n",
284                regs->rdx, regs->rsi, regs->rdi); 
285         printk("RBP: %016lx R08: %016lx R09: %016lx\n",
286                regs->rbp, regs->r8, regs->r9); 
287         printk("R10: %016lx R11: %016lx R12: %016lx\n",
288                regs->r10, regs->r11, regs->r12); 
289         printk("R13: %016lx R14: %016lx R15: %016lx\n",
290                regs->r13, regs->r14, regs->r15); 
291
292         asm("movl %%ds,%0" : "=r" (ds)); 
293         asm("movl %%cs,%0" : "=r" (cs)); 
294         asm("movl %%es,%0" : "=r" (es)); 
295         asm("movl %%fs,%0" : "=r" (fsindex));
296         asm("movl %%gs,%0" : "=r" (gsindex));
297
298         rdmsrl(MSR_FS_BASE, fs);
299         rdmsrl(MSR_GS_BASE, gs); 
300         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs); 
301
302         asm("movq %%cr0, %0": "=r" (cr0));
303         asm("movq %%cr2, %0": "=r" (cr2));
304         asm("movq %%cr3, %0": "=r" (cr3));
305         asm("movq %%cr4, %0": "=r" (cr4));
306
307         printk("FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n", 
308                fs,fsindex,gs,gsindex,shadowgs); 
309         printk("CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds, es, cr0); 
310         printk("CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3, cr4);
311 }
312
313 void show_regs(struct pt_regs *regs)
314 {
315         printk("CPU %d:", smp_processor_id());
316         __show_regs(regs);
317         show_trace(&regs->rsp);
318 }
319
320 /*
321  * Free current thread data structures etc..
322  */
323 void exit_thread(void)
324 {
325         struct task_struct *me = current;
326         struct thread_struct *t = &me->thread;
327
328         /*
329          * Remove function-return probe instances associated with this task
330          * and put them back on the free list. Do not insert an exit probe for
331          * this function, it will be disabled by kprobe_flush_task if you do.
332          */
333         kprobe_flush_task(me);
334
335         if (me->thread.io_bitmap_ptr) { 
336                 struct tss_struct *tss = &per_cpu(init_tss, get_cpu());
337
338                 kfree(t->io_bitmap_ptr);
339                 t->io_bitmap_ptr = NULL;
340                 /*
341                  * Careful, clear this in the TSS too:
342                  */
343                 memset(tss->io_bitmap, 0xff, t->io_bitmap_max);
344                 t->io_bitmap_max = 0;
345                 put_cpu();
346         }
347 }
348
349 void flush_thread(void)
350 {
351         struct task_struct *tsk = current;
352         struct thread_info *t = current_thread_info();
353
354         if (t->flags & _TIF_ABI_PENDING)
355                 t->flags ^= (_TIF_ABI_PENDING | _TIF_IA32);
356
357         tsk->thread.debugreg0 = 0;
358         tsk->thread.debugreg1 = 0;
359         tsk->thread.debugreg2 = 0;
360         tsk->thread.debugreg3 = 0;
361         tsk->thread.debugreg6 = 0;
362         tsk->thread.debugreg7 = 0;
363         memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));        
364         /*
365          * Forget coprocessor state..
366          */
367         clear_fpu(tsk);
368         clear_used_math();
369 }
370
371 void release_thread(struct task_struct *dead_task)
372 {
373         if (dead_task->mm) {
374                 if (dead_task->mm->context.size) {
375                         printk("WARNING: dead process %8s still has LDT? <%p/%d>\n",
376                                         dead_task->comm,
377                                         dead_task->mm->context.ldt,
378                                         dead_task->mm->context.size);
379                         BUG();
380                 }
381         }
382 }
383
384 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr)
385 {
386         struct user_desc ud = { 
387                 .base_addr = addr,
388                 .limit = 0xfffff,
389                 .seg_32bit = 1,
390                 .limit_in_pages = 1,
391                 .useable = 1,
392         };
393         struct n_desc_struct *desc = (void *)t->thread.tls_array;
394         desc += tls;
395         desc->a = LDT_entry_a(&ud); 
396         desc->b = LDT_entry_b(&ud); 
397 }
398
399 static inline u32 read_32bit_tls(struct task_struct *t, int tls)
400 {
401         struct desc_struct *desc = (void *)t->thread.tls_array;
402         desc += tls;
403         return desc->base0 | 
404                 (((u32)desc->base1) << 16) | 
405                 (((u32)desc->base2) << 24);
406 }
407
408 /*
409  * This gets called before we allocate a new thread and copy
410  * the current task into it.
411  */
412 void prepare_to_copy(struct task_struct *tsk)
413 {
414         unlazy_fpu(tsk);
415 }
416
417 int copy_thread(int nr, unsigned long clone_flags, unsigned long rsp, 
418                 unsigned long unused,
419         struct task_struct * p, struct pt_regs * regs)
420 {
421         int err;
422         struct pt_regs * childregs;
423         struct task_struct *me = current;
424
425         childregs = ((struct pt_regs *)
426                         (THREAD_SIZE + (unsigned long) p->thread_info)) - 1;
427         *childregs = *regs;
428
429         childregs->rax = 0;
430         childregs->rsp = rsp;
431         if (rsp == ~0UL)
432                 childregs->rsp = (unsigned long)childregs;
433
434         p->thread.rsp = (unsigned long) childregs;
435         p->thread.rsp0 = (unsigned long) (childregs+1);
436         p->thread.userrsp = me->thread.userrsp; 
437
438         set_ti_thread_flag(p->thread_info, TIF_FORK);
439
440         p->thread.fs = me->thread.fs;
441         p->thread.gs = me->thread.gs;
442
443         asm("mov %%gs,%0" : "=m" (p->thread.gsindex));
444         asm("mov %%fs,%0" : "=m" (p->thread.fsindex));
445         asm("mov %%es,%0" : "=m" (p->thread.es));
446         asm("mov %%ds,%0" : "=m" (p->thread.ds));
447
448         if (unlikely(me->thread.io_bitmap_ptr != NULL)) { 
449                 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
450                 if (!p->thread.io_bitmap_ptr) {
451                         p->thread.io_bitmap_max = 0;
452                         return -ENOMEM;
453                 }
454                 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr,
455                                 IO_BITMAP_BYTES);
456         } 
457
458         /*
459          * Set a new TLS for the child thread?
460          */
461         if (clone_flags & CLONE_SETTLS) {
462 #ifdef CONFIG_IA32_EMULATION
463                 if (test_thread_flag(TIF_IA32))
464                         err = ia32_child_tls(p, childregs); 
465                 else                    
466 #endif   
467                         err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8); 
468                 if (err) 
469                         goto out;
470         }
471         err = 0;
472 out:
473         if (err && p->thread.io_bitmap_ptr) {
474                 kfree(p->thread.io_bitmap_ptr);
475                 p->thread.io_bitmap_max = 0;
476         }
477         return err;
478 }
479
480 /*
481  * This special macro can be used to load a debugging register
482  */
483 #define loaddebug(thread,r) set_debug(thread->debugreg ## r, r)
484
485 /*
486  *      switch_to(x,y) should switch tasks from x to y.
487  *
488  * This could still be optimized: 
489  * - fold all the options into a flag word and test it with a single test.
490  * - could test fs/gs bitsliced
491  */
492 struct task_struct *
493 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
494 {
495         struct thread_struct *prev = &prev_p->thread,
496                                  *next = &next_p->thread;
497         int cpu = smp_processor_id();  
498         struct tss_struct *tss = &per_cpu(init_tss, cpu);
499
500         unlazy_fpu(prev_p);
501
502         /*
503          * Reload esp0, LDT and the page table pointer:
504          */
505         tss->rsp0 = next->rsp0;
506
507         /* 
508          * Switch DS and ES.
509          * This won't pick up thread selector changes, but I guess that is ok.
510          */
511         asm volatile("mov %%es,%0" : "=m" (prev->es));
512         if (unlikely(next->es | prev->es))
513                 loadsegment(es, next->es); 
514         
515         asm volatile ("mov %%ds,%0" : "=m" (prev->ds));
516         if (unlikely(next->ds | prev->ds))
517                 loadsegment(ds, next->ds);
518
519         load_TLS(next, cpu);
520
521         /* 
522          * Switch FS and GS.
523          */
524         { 
525                 unsigned fsindex;
526                 asm volatile("movl %%fs,%0" : "=r" (fsindex)); 
527                 /* segment register != 0 always requires a reload. 
528                    also reload when it has changed. 
529                    when prev process used 64bit base always reload
530                    to avoid an information leak. */
531                 if (unlikely(fsindex | next->fsindex | prev->fs)) {
532                         loadsegment(fs, next->fsindex);
533                         /* check if the user used a selector != 0
534                          * if yes clear 64bit base, since overloaded base
535                          * is always mapped to the Null selector
536                          */
537                         if (fsindex)
538                         prev->fs = 0;                           
539                 }
540                 /* when next process has a 64bit base use it */
541                 if (next->fs) 
542                         wrmsrl(MSR_FS_BASE, next->fs); 
543                 prev->fsindex = fsindex;
544         }
545         { 
546                 unsigned gsindex;
547                 asm volatile("movl %%gs,%0" : "=r" (gsindex)); 
548                 if (unlikely(gsindex | next->gsindex | prev->gs)) {
549                         load_gs_index(next->gsindex);
550                         if (gsindex)
551                         prev->gs = 0;                           
552                 }
553                 if (next->gs)
554                         wrmsrl(MSR_KERNEL_GS_BASE, next->gs); 
555                 prev->gsindex = gsindex;
556         }
557
558         /* 
559          * Switch the PDA context.
560          */
561         prev->userrsp = read_pda(oldrsp); 
562         write_pda(oldrsp, next->userrsp); 
563         write_pda(pcurrent, next_p); 
564         write_pda(kernelstack,
565             (unsigned long)next_p->thread_info + THREAD_SIZE - PDA_STACKOFFSET);
566
567         /*
568          * Now maybe reload the debug registers
569          */
570         if (unlikely(next->debugreg7)) {
571                 loaddebug(next, 0);
572                 loaddebug(next, 1);
573                 loaddebug(next, 2);
574                 loaddebug(next, 3);
575                 /* no 4 and 5 */
576                 loaddebug(next, 6);
577                 loaddebug(next, 7);
578         }
579
580
581         /* 
582          * Handle the IO bitmap 
583          */ 
584         if (unlikely(prev->io_bitmap_ptr || next->io_bitmap_ptr)) {
585                 if (next->io_bitmap_ptr)
586                         /*
587                          * Copy the relevant range of the IO bitmap.
588                          * Normally this is 128 bytes or less:
589                          */
590                         memcpy(tss->io_bitmap, next->io_bitmap_ptr,
591                                 max(prev->io_bitmap_max, next->io_bitmap_max));
592                 else {
593                         /*
594                          * Clear any possible leftover bits:
595                          */
596                         memset(tss->io_bitmap, 0xff, prev->io_bitmap_max);
597                 }
598         }
599
600         return prev_p;
601 }
602
603 /*
604  * sys_execve() executes a new program.
605  */
606 asmlinkage 
607 long sys_execve(char __user *name, char __user * __user *argv,
608                 char __user * __user *envp, struct pt_regs regs)
609 {
610         long error;
611         char * filename;
612
613         filename = getname(name);
614         error = PTR_ERR(filename);
615         if (IS_ERR(filename)) 
616                 return error;
617         error = do_execve(filename, argv, envp, &regs); 
618         if (error == 0) {
619                 task_lock(current);
620                 current->ptrace &= ~PT_DTRACE;
621                 task_unlock(current);
622         }
623         putname(filename);
624         return error;
625 }
626
627 void set_personality_64bit(void)
628 {
629         /* inherit personality from parent */
630
631         /* Make sure to be in 64bit mode */
632         clear_thread_flag(TIF_IA32); 
633
634         /* TBD: overwrites user setup. Should have two bits.
635            But 64bit processes have always behaved this way,
636            so it's not too bad. The main problem is just that
637            32bit childs are affected again. */
638         current->personality &= ~READ_IMPLIES_EXEC;
639 }
640
641 asmlinkage long sys_fork(struct pt_regs *regs)
642 {
643         return do_fork(SIGCHLD, regs->rsp, regs, 0, NULL, NULL);
644 }
645
646 asmlinkage long
647 sys_clone(unsigned long clone_flags, unsigned long newsp,
648           void __user *parent_tid, void __user *child_tid, struct pt_regs *regs)
649 {
650         if (!newsp)
651                 newsp = regs->rsp;
652         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
653 }
654
655 /*
656  * This is trivial, and on the face of it looks like it
657  * could equally well be done in user mode.
658  *
659  * Not so, for quite unobvious reasons - register pressure.
660  * In user mode vfork() cannot have a stack frame, and if
661  * done by calling the "clone()" system call directly, you
662  * do not have enough call-clobbered registers to hold all
663  * the information you need.
664  */
665 asmlinkage long sys_vfork(struct pt_regs *regs)
666 {
667         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->rsp, regs, 0,
668                     NULL, NULL);
669 }
670
671 unsigned long get_wchan(struct task_struct *p)
672 {
673         unsigned long stack;
674         u64 fp,rip;
675         int count = 0;
676
677         if (!p || p == current || p->state==TASK_RUNNING)
678                 return 0; 
679         stack = (unsigned long)p->thread_info; 
680         if (p->thread.rsp < stack || p->thread.rsp > stack+THREAD_SIZE)
681                 return 0;
682         fp = *(u64 *)(p->thread.rsp);
683         do { 
684                 if (fp < (unsigned long)stack ||
685                     fp > (unsigned long)stack+THREAD_SIZE)
686                         return 0; 
687                 rip = *(u64 *)(fp+8); 
688                 if (!in_sched_functions(rip))
689                         return rip; 
690                 fp = *(u64 *)fp; 
691         } while (count++ < 16); 
692         return 0;
693 }
694
695 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
696
697         int ret = 0; 
698         int doit = task == current;
699         int cpu;
700
701         switch (code) { 
702         case ARCH_SET_GS:
703                 if (addr >= TASK_SIZE_OF(task))
704                         return -EPERM; 
705                 cpu = get_cpu();
706                 /* handle small bases via the GDT because that's faster to 
707                    switch. */
708                 if (addr <= 0xffffffff) {  
709                         set_32bit_tls(task, GS_TLS, addr); 
710                         if (doit) { 
711                                 load_TLS(&task->thread, cpu);
712                                 load_gs_index(GS_TLS_SEL); 
713                         }
714                         task->thread.gsindex = GS_TLS_SEL; 
715                         task->thread.gs = 0;
716                 } else { 
717                         task->thread.gsindex = 0;
718                         task->thread.gs = addr;
719                         if (doit) {
720                                 load_gs_index(0);
721                                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
722                         } 
723                 }
724                 put_cpu();
725                 break;
726         case ARCH_SET_FS:
727                 /* Not strictly needed for fs, but do it for symmetry
728                    with gs */
729                 if (addr >= TASK_SIZE_OF(task))
730                         return -EPERM; 
731                 cpu = get_cpu();
732                 /* handle small bases via the GDT because that's faster to 
733                    switch. */
734                 if (addr <= 0xffffffff) { 
735                         set_32bit_tls(task, FS_TLS, addr);
736                         if (doit) { 
737                                 load_TLS(&task->thread, cpu); 
738                                 asm volatile("movl %0,%%fs" :: "r"(FS_TLS_SEL));
739                         }
740                         task->thread.fsindex = FS_TLS_SEL;
741                         task->thread.fs = 0;
742                 } else { 
743                         task->thread.fsindex = 0;
744                         task->thread.fs = addr;
745                         if (doit) {
746                                 /* set the selector to 0 to not confuse
747                                    __switch_to */
748                                 asm volatile("movl %0,%%fs" :: "r" (0));
749                                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
750                         }
751                 }
752                 put_cpu();
753                 break;
754         case ARCH_GET_FS: { 
755                 unsigned long base; 
756                 if (task->thread.fsindex == FS_TLS_SEL)
757                         base = read_32bit_tls(task, FS_TLS);
758                 else if (doit)
759                         rdmsrl(MSR_FS_BASE, base);
760                 else
761                         base = task->thread.fs;
762                 ret = put_user(base, (unsigned long __user *)addr); 
763                 break; 
764         }
765         case ARCH_GET_GS: { 
766                 unsigned long base;
767                 if (task->thread.gsindex == GS_TLS_SEL)
768                         base = read_32bit_tls(task, GS_TLS);
769                 else if (doit)
770                         rdmsrl(MSR_KERNEL_GS_BASE, base);
771                 else
772                         base = task->thread.gs;
773                 ret = put_user(base, (unsigned long __user *)addr); 
774                 break;
775         }
776
777         default:
778                 ret = -EINVAL;
779                 break;
780         } 
781
782         return ret;     
783
784
785 long sys_arch_prctl(int code, unsigned long addr)
786 {
787         return do_arch_prctl(current, code, addr);
788
789
790 /* 
791  * Capture the user space registers if the task is not running (in user space)
792  */
793 int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
794 {
795         struct pt_regs *pp, ptregs;
796
797         pp = (struct pt_regs *)(tsk->thread.rsp0);
798         --pp; 
799
800         ptregs = *pp; 
801         ptregs.cs &= 0xffff;
802         ptregs.ss &= 0xffff;
803
804         elf_core_copy_regs(regs, &ptregs);
805  
806         return 1;
807 }
808
809 unsigned long arch_align_stack(unsigned long sp)
810 {
811         if (randomize_va_space)
812                 sp -= get_random_int() % 8192;
813         return sp & ~0xf;
814 }