]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - arch/i386/kernel/process.c
[PATCH] i386: Convert PDA into the percpu section
[mirror_ubuntu-jammy-kernel.git] / arch / i386 / kernel / process.c
CommitLineData
1da177e4
LT
1/*
2 * linux/arch/i386/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
10/*
11 * This file handles the architecture-dependent parts of process handling..
12 */
13
14#include <stdarg.h>
15
f3705136 16#include <linux/cpu.h>
1da177e4
LT
17#include <linux/errno.h>
18#include <linux/sched.h>
19#include <linux/fs.h>
20#include <linux/kernel.h>
21#include <linux/mm.h>
22#include <linux/elfcore.h>
23#include <linux/smp.h>
24#include <linux/smp_lock.h>
25#include <linux/stddef.h>
26#include <linux/slab.h>
27#include <linux/vmalloc.h>
28#include <linux/user.h>
29#include <linux/a.out.h>
30#include <linux/interrupt.h>
1da177e4
LT
31#include <linux/utsname.h>
32#include <linux/delay.h>
33#include <linux/reboot.h>
34#include <linux/init.h>
35#include <linux/mc146818rtc.h>
36#include <linux/module.h>
37#include <linux/kallsyms.h>
38#include <linux/ptrace.h>
39#include <linux/random.h>
c16b63e0 40#include <linux/personality.h>
74167347 41#include <linux/tick.h>
7c3576d2 42#include <linux/percpu.h>
1da177e4
LT
43
44#include <asm/uaccess.h>
45#include <asm/pgtable.h>
46#include <asm/system.h>
47#include <asm/io.h>
48#include <asm/ldt.h>
49#include <asm/processor.h>
50#include <asm/i387.h>
1da177e4 51#include <asm/desc.h>
64ca9004 52#include <asm/vm86.h>
1da177e4
LT
53#ifdef CONFIG_MATH_EMULATION
54#include <asm/math_emu.h>
55#endif
56
1da177e4
LT
57#include <linux/err.h>
58
f3705136
ZM
59#include <asm/tlbflush.h>
60#include <asm/cpu.h>
61
1da177e4
LT
62asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
63
64static int hlt_counter;
65
66unsigned long boot_option_idle_override = 0;
67EXPORT_SYMBOL(boot_option_idle_override);
68
7c3576d2
JF
69DEFINE_PER_CPU(struct task_struct *, current_task) = &init_task;
70EXPORT_PER_CPU_SYMBOL(current_task);
71
72DEFINE_PER_CPU(int, cpu_number);
73EXPORT_PER_CPU_SYMBOL(cpu_number);
74
1da177e4
LT
75/*
76 * Return saved PC of a blocked thread.
77 */
78unsigned long thread_saved_pc(struct task_struct *tsk)
79{
80 return ((unsigned long *)tsk->thread.esp)[3];
81}
82
83/*
84 * Powermanagement idle function, if any..
85 */
86void (*pm_idle)(void);
129f6946 87EXPORT_SYMBOL(pm_idle);
1da177e4
LT
88static DEFINE_PER_CPU(unsigned int, cpu_idle_state);
89
90void disable_hlt(void)
91{
92 hlt_counter++;
93}
94
95EXPORT_SYMBOL(disable_hlt);
96
97void enable_hlt(void)
98{
99 hlt_counter--;
100}
101
102EXPORT_SYMBOL(enable_hlt);
103
104/*
105 * We use this if we don't have any better
106 * idle routine..
107 */
108void default_idle(void)
109{
110 if (!hlt_counter && boot_cpu_data.hlt_works_ok) {
495ab9c0 111 current_thread_info()->status &= ~TS_POLLING;
0888f06a
IM
112 /*
113 * TS_POLLING-cleared state must be visible before we
114 * test NEED_RESCHED:
115 */
116 smp_mb();
117
72690a21
AK
118 local_irq_disable();
119 if (!need_resched())
120 safe_halt(); /* enables interrupts racelessly */
121 else
122 local_irq_enable();
495ab9c0 123 current_thread_info()->status |= TS_POLLING;
1da177e4 124 } else {
72690a21
AK
125 /* loop is done by the caller */
126 cpu_relax();
1da177e4
LT
127 }
128}
129f6946
AD
129#ifdef CONFIG_APM_MODULE
130EXPORT_SYMBOL(default_idle);
131#endif
1da177e4
LT
132
133/*
134 * On SMP it's slightly faster (but much more power-consuming!)
135 * to poll the ->work.need_resched flag instead of waiting for the
136 * cross-CPU IPI to arrive. Use this option with caution.
137 */
138static void poll_idle (void)
139{
72690a21 140 cpu_relax();
1da177e4
LT
141}
142
f3705136
ZM
143#ifdef CONFIG_HOTPLUG_CPU
144#include <asm/nmi.h>
145/* We don't actually take CPU down, just spin without interrupts. */
146static inline void play_dead(void)
147{
e1367daf
LS
148 /* This must be done before dead CPU ack */
149 cpu_exit_clear();
150 wbinvd();
151 mb();
f3705136
ZM
152 /* Ack it */
153 __get_cpu_var(cpu_state) = CPU_DEAD;
154
e1367daf
LS
155 /*
156 * With physical CPU hotplug, we should halt the cpu
157 */
f3705136 158 local_irq_disable();
e1367daf 159 while (1)
f2ab4461 160 halt();
f3705136
ZM
161}
162#else
163static inline void play_dead(void)
164{
165 BUG();
166}
167#endif /* CONFIG_HOTPLUG_CPU */
168
1da177e4
LT
169/*
170 * The idle thread. There's no useful work to be
171 * done, so just try to conserve power and have a
172 * low exit latency (ie sit in a loop waiting for
173 * somebody to say that they'd like to reschedule)
174 */
f3705136 175void cpu_idle(void)
1da177e4 176{
5bfb5d69 177 int cpu = smp_processor_id();
f3705136 178
495ab9c0 179 current_thread_info()->status |= TS_POLLING;
64c7c8f8 180
1da177e4
LT
181 /* endless idle loop with no priority at all */
182 while (1) {
74167347 183 tick_nohz_stop_sched_tick();
1da177e4
LT
184 while (!need_resched()) {
185 void (*idle)(void);
186
187 if (__get_cpu_var(cpu_idle_state))
188 __get_cpu_var(cpu_idle_state) = 0;
189
190 rmb();
191 idle = pm_idle;
192
193 if (!idle)
194 idle = default_idle;
195
f3705136
ZM
196 if (cpu_is_offline(cpu))
197 play_dead();
198
1da177e4
LT
199 __get_cpu_var(irq_stat).idle_timestamp = jiffies;
200 idle();
201 }
74167347 202 tick_nohz_restart_sched_tick();
5bfb5d69 203 preempt_enable_no_resched();
1da177e4 204 schedule();
5bfb5d69 205 preempt_disable();
1da177e4
LT
206 }
207}
208
209void cpu_idle_wait(void)
210{
211 unsigned int cpu, this_cpu = get_cpu();
dc1829a4 212 cpumask_t map, tmp = current->cpus_allowed;
1da177e4
LT
213
214 set_cpus_allowed(current, cpumask_of_cpu(this_cpu));
215 put_cpu();
216
217 cpus_clear(map);
218 for_each_online_cpu(cpu) {
219 per_cpu(cpu_idle_state, cpu) = 1;
220 cpu_set(cpu, map);
221 }
222
223 __get_cpu_var(cpu_idle_state) = 0;
224
225 wmb();
226 do {
227 ssleep(1);
228 for_each_online_cpu(cpu) {
229 if (cpu_isset(cpu, map) && !per_cpu(cpu_idle_state, cpu))
230 cpu_clear(cpu, map);
231 }
232 cpus_and(map, map, cpu_online_map);
233 } while (!cpus_empty(map));
dc1829a4
IM
234
235 set_cpus_allowed(current, tmp);
1da177e4
LT
236}
237EXPORT_SYMBOL_GPL(cpu_idle_wait);
238
239/*
240 * This uses new MONITOR/MWAIT instructions on P4 processors with PNI,
241 * which can obviate IPI to trigger checking of need_resched.
242 * We execute MONITOR against need_resched and enter optimized wait state
243 * through MWAIT. Whenever someone changes need_resched, we would be woken
244 * up from MWAIT (without an IPI).
991528d7
VP
245 *
246 * New with Core Duo processors, MWAIT can take some hints based on CPU
247 * capability.
1da177e4 248 */
991528d7 249void mwait_idle_with_hints(unsigned long eax, unsigned long ecx)
1da177e4 250{
991528d7 251 if (!need_resched()) {
64c7c8f8
NP
252 __monitor((void *)&current_thread_info()->flags, 0, 0);
253 smp_mb();
991528d7 254 if (!need_resched())
ea3d5226 255 __mwait(eax, ecx);
1da177e4
LT
256 }
257}
258
991528d7
VP
259/* Default MONITOR/MWAIT with no hints, used for default C1 state */
260static void mwait_idle(void)
261{
262 local_irq_enable();
72690a21 263 mwait_idle_with_hints(0, 0);
991528d7
VP
264}
265
0bb3184d 266void __devinit select_idle_routine(const struct cpuinfo_x86 *c)
1da177e4
LT
267{
268 if (cpu_has(c, X86_FEATURE_MWAIT)) {
269 printk("monitor/mwait feature present.\n");
270 /*
271 * Skip, if setup has overridden idle.
272 * One CPU supports mwait => All CPUs supports mwait
273 */
274 if (!pm_idle) {
275 printk("using mwait in idle threads.\n");
276 pm_idle = mwait_idle;
277 }
278 }
279}
280
f039b754 281static int __init idle_setup(char *str)
1da177e4 282{
f039b754 283 if (!strcmp(str, "poll")) {
1da177e4
LT
284 printk("using polling idle threads.\n");
285 pm_idle = poll_idle;
286#ifdef CONFIG_X86_SMP
287 if (smp_num_siblings > 1)
288 printk("WARNING: polling idle and HT enabled, performance may degrade.\n");
289#endif
f039b754
AK
290 } else if (!strcmp(str, "mwait"))
291 force_mwait = 1;
292 else
293 return -1;
1da177e4
LT
294
295 boot_option_idle_override = 1;
f039b754 296 return 0;
1da177e4 297}
f039b754 298early_param("idle", idle_setup);
1da177e4
LT
299
300void show_regs(struct pt_regs * regs)
301{
302 unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L;
303
304 printk("\n");
305 printk("Pid: %d, comm: %20s\n", current->pid, current->comm);
306 printk("EIP: %04x:[<%08lx>] CPU: %d\n",0xffff & regs->xcs,regs->eip, smp_processor_id());
307 print_symbol("EIP is at %s\n", regs->eip);
308
db753bdf 309 if (user_mode_vm(regs))
1da177e4 310 printk(" ESP: %04x:%08lx",0xffff & regs->xss,regs->esp);
b53e8f68 311 printk(" EFLAGS: %08lx %s (%s %.*s)\n",
96b644bd
SH
312 regs->eflags, print_tainted(), init_utsname()->release,
313 (int)strcspn(init_utsname()->version, " "),
314 init_utsname()->version);
1da177e4
LT
315 printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n",
316 regs->eax,regs->ebx,regs->ecx,regs->edx);
317 printk("ESI: %08lx EDI: %08lx EBP: %08lx",
318 regs->esi, regs->edi, regs->ebp);
464d1a78
JF
319 printk(" DS: %04x ES: %04x FS: %04x\n",
320 0xffff & regs->xds,0xffff & regs->xes, 0xffff & regs->xfs);
1da177e4 321
4bb0d3ec
ZA
322 cr0 = read_cr0();
323 cr2 = read_cr2();
324 cr3 = read_cr3();
ff6e8c0d 325 cr4 = read_cr4_safe();
1da177e4 326 printk("CR0: %08lx CR2: %08lx CR3: %08lx CR4: %08lx\n", cr0, cr2, cr3, cr4);
176a2718 327 show_trace(NULL, regs, &regs->esp);
1da177e4
LT
328}
329
330/*
331 * This gets run with %ebx containing the
332 * function to call, and %edx containing
333 * the "args".
334 */
335extern void kernel_thread_helper(void);
1da177e4
LT
336
337/*
338 * Create a kernel thread
339 */
340int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
341{
342 struct pt_regs regs;
343
344 memset(&regs, 0, sizeof(regs));
345
346 regs.ebx = (unsigned long) fn;
347 regs.edx = (unsigned long) arg;
348
349 regs.xds = __USER_DS;
350 regs.xes = __USER_DS;
7c3576d2 351 regs.xfs = __KERNEL_PERCPU;
1da177e4
LT
352 regs.orig_eax = -1;
353 regs.eip = (unsigned long) kernel_thread_helper;
78be3706 354 regs.xcs = __KERNEL_CS | get_kernel_rpl();
1da177e4
LT
355 regs.eflags = X86_EFLAGS_IF | X86_EFLAGS_SF | X86_EFLAGS_PF | 0x2;
356
357 /* Ok, create the new process.. */
8cf2c519 358 return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
1da177e4 359}
129f6946 360EXPORT_SYMBOL(kernel_thread);
1da177e4
LT
361
362/*
363 * Free current thread data structures etc..
364 */
365void exit_thread(void)
366{
1da177e4 367 /* The process may have allocated an io port bitmap... nuke it. */
b3cf2576
SE
368 if (unlikely(test_thread_flag(TIF_IO_BITMAP))) {
369 struct task_struct *tsk = current;
370 struct thread_struct *t = &tsk->thread;
1da177e4
LT
371 int cpu = get_cpu();
372 struct tss_struct *tss = &per_cpu(init_tss, cpu);
373
374 kfree(t->io_bitmap_ptr);
375 t->io_bitmap_ptr = NULL;
b3cf2576 376 clear_thread_flag(TIF_IO_BITMAP);
1da177e4
LT
377 /*
378 * Careful, clear this in the TSS too:
379 */
380 memset(tss->io_bitmap, 0xff, tss->io_bitmap_max);
381 t->io_bitmap_max = 0;
382 tss->io_bitmap_owner = NULL;
383 tss->io_bitmap_max = 0;
a75c54f9 384 tss->x86_tss.io_bitmap_base = INVALID_IO_BITMAP_OFFSET;
1da177e4
LT
385 put_cpu();
386 }
387}
388
389void flush_thread(void)
390{
391 struct task_struct *tsk = current;
392
393 memset(tsk->thread.debugreg, 0, sizeof(unsigned long)*8);
394 memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
b3cf2576 395 clear_tsk_thread_flag(tsk, TIF_DEBUG);
1da177e4
LT
396 /*
397 * Forget coprocessor state..
398 */
399 clear_fpu(tsk);
400 clear_used_math();
401}
402
403void release_thread(struct task_struct *dead_task)
404{
2684927c 405 BUG_ON(dead_task->mm);
1da177e4
LT
406 release_vm86_irqs(dead_task);
407}
408
409/*
410 * This gets called before we allocate a new thread and copy
411 * the current task into it.
412 */
413void prepare_to_copy(struct task_struct *tsk)
414{
415 unlazy_fpu(tsk);
416}
417
418int copy_thread(int nr, unsigned long clone_flags, unsigned long esp,
419 unsigned long unused,
420 struct task_struct * p, struct pt_regs * regs)
421{
422 struct pt_regs * childregs;
423 struct task_struct *tsk;
424 int err;
425
07b047fc 426 childregs = task_pt_regs(p);
f48d9663
AN
427 *childregs = *regs;
428 childregs->eax = 0;
429 childregs->esp = esp;
430
431 p->thread.esp = (unsigned long) childregs;
432 p->thread.esp0 = (unsigned long) (childregs+1);
1da177e4
LT
433
434 p->thread.eip = (unsigned long) ret_from_fork;
435
464d1a78 436 savesegment(gs,p->thread.gs);
1da177e4
LT
437
438 tsk = current;
b3cf2576 439 if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
52978be6
AD
440 p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
441 IO_BITMAP_BYTES, GFP_KERNEL);
1da177e4
LT
442 if (!p->thread.io_bitmap_ptr) {
443 p->thread.io_bitmap_max = 0;
444 return -ENOMEM;
445 }
b3cf2576 446 set_tsk_thread_flag(p, TIF_IO_BITMAP);
1da177e4
LT
447 }
448
449 /*
450 * Set a new TLS for the child thread?
451 */
452 if (clone_flags & CLONE_SETTLS) {
453 struct desc_struct *desc;
454 struct user_desc info;
455 int idx;
456
457 err = -EFAULT;
458 if (copy_from_user(&info, (void __user *)childregs->esi, sizeof(info)))
459 goto out;
460 err = -EINVAL;
461 if (LDT_empty(&info))
462 goto out;
463
464 idx = info.entry_number;
465 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
466 goto out;
467
468 desc = p->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
469 desc->a = LDT_entry_a(&info);
470 desc->b = LDT_entry_b(&info);
471 }
472
473 err = 0;
474 out:
475 if (err && p->thread.io_bitmap_ptr) {
476 kfree(p->thread.io_bitmap_ptr);
477 p->thread.io_bitmap_max = 0;
478 }
479 return err;
480}
481
482/*
483 * fill in the user structure for a core dump..
484 */
485void dump_thread(struct pt_regs * regs, struct user * dump)
486{
487 int i;
488
489/* changed the size calculations - should hopefully work better. lbt */
490 dump->magic = CMAGIC;
491 dump->start_code = 0;
492 dump->start_stack = regs->esp & ~(PAGE_SIZE - 1);
493 dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
494 dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
495 dump->u_dsize -= dump->u_tsize;
496 dump->u_ssize = 0;
497 for (i = 0; i < 8; i++)
498 dump->u_debugreg[i] = current->thread.debugreg[i];
499
500 if (dump->start_stack < TASK_SIZE)
501 dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
502
503 dump->regs.ebx = regs->ebx;
504 dump->regs.ecx = regs->ecx;
505 dump->regs.edx = regs->edx;
506 dump->regs.esi = regs->esi;
507 dump->regs.edi = regs->edi;
508 dump->regs.ebp = regs->ebp;
509 dump->regs.eax = regs->eax;
510 dump->regs.ds = regs->xds;
511 dump->regs.es = regs->xes;
464d1a78
JF
512 dump->regs.fs = regs->xfs;
513 savesegment(gs,dump->regs.gs);
1da177e4
LT
514 dump->regs.orig_eax = regs->orig_eax;
515 dump->regs.eip = regs->eip;
516 dump->regs.cs = regs->xcs;
517 dump->regs.eflags = regs->eflags;
518 dump->regs.esp = regs->esp;
519 dump->regs.ss = regs->xss;
520
521 dump->u_fpvalid = dump_fpu (regs, &dump->i387);
522}
129f6946 523EXPORT_SYMBOL(dump_thread);
1da177e4
LT
524
525/*
526 * Capture the user space registers if the task is not running (in user space)
527 */
528int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
529{
07b047fc 530 struct pt_regs ptregs = *task_pt_regs(tsk);
1da177e4
LT
531 ptregs.xcs &= 0xffff;
532 ptregs.xds &= 0xffff;
533 ptregs.xes &= 0xffff;
534 ptregs.xss &= 0xffff;
535
536 elf_core_copy_regs(regs, &ptregs);
537
538 return 1;
539}
540
b3cf2576
SE
541static noinline void __switch_to_xtra(struct task_struct *next_p,
542 struct tss_struct *tss)
1da177e4 543{
b3cf2576
SE
544 struct thread_struct *next;
545
546 next = &next_p->thread;
547
548 if (test_tsk_thread_flag(next_p, TIF_DEBUG)) {
549 set_debugreg(next->debugreg[0], 0);
550 set_debugreg(next->debugreg[1], 1);
551 set_debugreg(next->debugreg[2], 2);
552 set_debugreg(next->debugreg[3], 3);
553 /* no 4 and 5 */
554 set_debugreg(next->debugreg[6], 6);
555 set_debugreg(next->debugreg[7], 7);
556 }
557
558 if (!test_tsk_thread_flag(next_p, TIF_IO_BITMAP)) {
1da177e4
LT
559 /*
560 * Disable the bitmap via an invalid offset. We still cache
561 * the previous bitmap owner and the IO bitmap contents:
562 */
a75c54f9 563 tss->x86_tss.io_bitmap_base = INVALID_IO_BITMAP_OFFSET;
1da177e4
LT
564 return;
565 }
b3cf2576 566
1da177e4
LT
567 if (likely(next == tss->io_bitmap_owner)) {
568 /*
569 * Previous owner of the bitmap (hence the bitmap content)
570 * matches the next task, we dont have to do anything but
571 * to set a valid offset in the TSS:
572 */
a75c54f9 573 tss->x86_tss.io_bitmap_base = IO_BITMAP_OFFSET;
1da177e4
LT
574 return;
575 }
576 /*
577 * Lazy TSS's I/O bitmap copy. We set an invalid offset here
578 * and we let the task to get a GPF in case an I/O instruction
579 * is performed. The handler of the GPF will verify that the
580 * faulting task has a valid I/O bitmap and, it true, does the
581 * real copy and restart the instruction. This will save us
582 * redundant copies when the currently switched task does not
583 * perform any I/O during its timeslice.
584 */
a75c54f9 585 tss->x86_tss.io_bitmap_base = INVALID_IO_BITMAP_OFFSET_LAZY;
1da177e4 586}
1da177e4 587
ffaa8bd6
AA
588/*
589 * This function selects if the context switch from prev to next
590 * has to tweak the TSC disable bit in the cr4.
591 */
592static inline void disable_tsc(struct task_struct *prev_p,
593 struct task_struct *next_p)
594{
595 struct thread_info *prev, *next;
596
597 /*
598 * gcc should eliminate the ->thread_info dereference if
599 * has_secure_computing returns 0 at compile time (SECCOMP=n).
600 */
06b425d8
AV
601 prev = task_thread_info(prev_p);
602 next = task_thread_info(next_p);
ffaa8bd6
AA
603
604 if (has_secure_computing(prev) || has_secure_computing(next)) {
605 /* slow path here */
606 if (has_secure_computing(prev) &&
607 !has_secure_computing(next)) {
608 write_cr4(read_cr4() & ~X86_CR4_TSD);
609 } else if (!has_secure_computing(prev) &&
610 has_secure_computing(next))
611 write_cr4(read_cr4() | X86_CR4_TSD);
612 }
613}
614
1da177e4
LT
615/*
616 * switch_to(x,yn) should switch tasks from x to y.
617 *
618 * We fsave/fwait so that an exception goes off at the right time
619 * (as a call from the fsave or fwait in effect) rather than to
620 * the wrong process. Lazy FP saving no longer makes any sense
621 * with modern CPU's, and this simplifies a lot of things (SMP
622 * and UP become the same).
623 *
624 * NOTE! We used to use the x86 hardware context switching. The
625 * reason for not using it any more becomes apparent when you
626 * try to recover gracefully from saved state that is no longer
627 * valid (stale segment register values in particular). With the
628 * hardware task-switch, there is no way to fix up bad state in
629 * a reasonable manner.
630 *
631 * The fact that Intel documents the hardware task-switching to
632 * be slow is a fairly red herring - this code is not noticeably
633 * faster. However, there _is_ some room for improvement here,
634 * so the performance issues may eventually be a valid point.
635 * More important, however, is the fact that this allows us much
636 * more flexibility.
637 *
638 * The return value (in %eax) will be the "prev" task after
639 * the task-switch, and shows up in ret_from_fork in entry.S,
640 * for example.
641 */
642struct task_struct fastcall * __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
643{
644 struct thread_struct *prev = &prev_p->thread,
645 *next = &next_p->thread;
646 int cpu = smp_processor_id();
647 struct tss_struct *tss = &per_cpu(init_tss, cpu);
648
649 /* never put a printk in __switch_to... printk() calls wake_up*() indirectly */
650
651 __unlazy_fpu(prev_p);
652
acc20761
CE
653
654 /* we're going to use this soon, after a few expensive things */
655 if (next_p->fpu_counter > 5)
656 prefetch(&next->i387.fxsave);
657
1da177e4 658 /*
e7a2ff59 659 * Reload esp0.
1da177e4
LT
660 */
661 load_esp0(tss, next);
662
663 /*
464d1a78 664 * Save away %gs. No need to save %fs, as it was saved on the
f95d47ca
JF
665 * stack on entry. No need to save %es and %ds, as those are
666 * always kernel segments while inside the kernel. Doing this
667 * before setting the new TLS descriptors avoids the situation
668 * where we temporarily have non-reloadable segments in %fs
669 * and %gs. This could be an issue if the NMI handler ever
670 * used %fs or %gs (it does not today), or if the kernel is
671 * running inside of a hypervisor layer.
1da177e4 672 */
464d1a78 673 savesegment(gs, prev->gs);
1da177e4
LT
674
675 /*
e7a2ff59 676 * Load the per-thread Thread-Local Storage descriptor.
1da177e4 677 */
e7a2ff59 678 load_TLS(next, cpu);
1da177e4 679
8b151144
ZA
680 /*
681 * Restore IOPL if needed. In normal use, the flags restore
682 * in the switch assembly will handle this. But if the kernel
683 * is running virtualized at a non-zero CPL, the popf will
684 * not restore flags, so it must be done in a separate step.
685 */
686 if (get_kernel_rpl() && unlikely(prev->iopl != next->iopl))
687 set_iopl_mask(next->iopl);
688
1da177e4 689 /*
b3cf2576 690 * Now maybe handle debug registers and/or IO bitmaps
1da177e4 691 */
facf0147
CE
692 if (unlikely((task_thread_info(next_p)->flags & _TIF_WORK_CTXSW)
693 || test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)))
b3cf2576 694 __switch_to_xtra(next_p, tss);
1da177e4 695
ffaa8bd6
AA
696 disable_tsc(prev_p, next_p);
697
9226d125
ZA
698 /*
699 * Leave lazy mode, flushing any hypercalls made here.
700 * This must be done before restoring TLS segments so
701 * the GDT and LDT are properly updated, and must be
702 * done before math_state_restore, so the TS bit is up
703 * to date.
704 */
705 arch_leave_lazy_cpu_mode();
706
acc20761
CE
707 /* If the task has used fpu the last 5 timeslices, just do a full
708 * restore of the math state immediately to avoid the trap; the
709 * chances of needing FPU soon are obviously high now
710 */
711 if (next_p->fpu_counter > 5)
712 math_state_restore();
713
9226d125
ZA
714 /*
715 * Restore %gs if needed (which is common)
716 */
717 if (prev->gs | next->gs)
718 loadsegment(gs, next->gs);
719
7c3576d2 720 x86_write_percpu(current_task, next_p);
9226d125 721
1da177e4
LT
722 return prev_p;
723}
724
725asmlinkage int sys_fork(struct pt_regs regs)
726{
727 return do_fork(SIGCHLD, regs.esp, &regs, 0, NULL, NULL);
728}
729
730asmlinkage int sys_clone(struct pt_regs regs)
731{
732 unsigned long clone_flags;
733 unsigned long newsp;
734 int __user *parent_tidptr, *child_tidptr;
735
736 clone_flags = regs.ebx;
737 newsp = regs.ecx;
738 parent_tidptr = (int __user *)regs.edx;
739 child_tidptr = (int __user *)regs.edi;
740 if (!newsp)
741 newsp = regs.esp;
742 return do_fork(clone_flags, newsp, &regs, 0, parent_tidptr, child_tidptr);
743}
744
745/*
746 * This is trivial, and on the face of it looks like it
747 * could equally well be done in user mode.
748 *
749 * Not so, for quite unobvious reasons - register pressure.
750 * In user mode vfork() cannot have a stack frame, and if
751 * done by calling the "clone()" system call directly, you
752 * do not have enough call-clobbered registers to hold all
753 * the information you need.
754 */
755asmlinkage int sys_vfork(struct pt_regs regs)
756{
757 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.esp, &regs, 0, NULL, NULL);
758}
759
760/*
761 * sys_execve() executes a new program.
762 */
763asmlinkage int sys_execve(struct pt_regs regs)
764{
765 int error;
766 char * filename;
767
768 filename = getname((char __user *) regs.ebx);
769 error = PTR_ERR(filename);
770 if (IS_ERR(filename))
771 goto out;
772 error = do_execve(filename,
773 (char __user * __user *) regs.ecx,
774 (char __user * __user *) regs.edx,
775 &regs);
776 if (error == 0) {
777 task_lock(current);
778 current->ptrace &= ~PT_DTRACE;
779 task_unlock(current);
780 /* Make sure we don't return using sysenter.. */
781 set_thread_flag(TIF_IRET);
782 }
783 putname(filename);
784out:
785 return error;
786}
787
788#define top_esp (THREAD_SIZE - sizeof(unsigned long))
789#define top_ebp (THREAD_SIZE - 2*sizeof(unsigned long))
790
791unsigned long get_wchan(struct task_struct *p)
792{
793 unsigned long ebp, esp, eip;
794 unsigned long stack_page;
795 int count = 0;
796 if (!p || p == current || p->state == TASK_RUNNING)
797 return 0;
65e0fdff 798 stack_page = (unsigned long)task_stack_page(p);
1da177e4
LT
799 esp = p->thread.esp;
800 if (!stack_page || esp < stack_page || esp > top_esp+stack_page)
801 return 0;
802 /* include/asm-i386/system.h:switch_to() pushes ebp last. */
803 ebp = *(unsigned long *) esp;
804 do {
805 if (ebp < stack_page || ebp > top_ebp+stack_page)
806 return 0;
807 eip = *(unsigned long *) (ebp+4);
808 if (!in_sched_functions(eip))
809 return eip;
810 ebp = *(unsigned long *) ebp;
811 } while (count++ < 16);
812 return 0;
813}
814
815/*
816 * sys_alloc_thread_area: get a yet unused TLS descriptor index.
817 */
818static int get_free_idx(void)
819{
820 struct thread_struct *t = &current->thread;
821 int idx;
822
823 for (idx = 0; idx < GDT_ENTRY_TLS_ENTRIES; idx++)
824 if (desc_empty(t->tls_array + idx))
825 return idx + GDT_ENTRY_TLS_MIN;
826 return -ESRCH;
827}
828
829/*
830 * Set a given TLS descriptor:
831 */
832asmlinkage int sys_set_thread_area(struct user_desc __user *u_info)
833{
834 struct thread_struct *t = &current->thread;
835 struct user_desc info;
836 struct desc_struct *desc;
837 int cpu, idx;
838
839 if (copy_from_user(&info, u_info, sizeof(info)))
840 return -EFAULT;
841 idx = info.entry_number;
842
843 /*
844 * index -1 means the kernel should try to find and
845 * allocate an empty descriptor:
846 */
847 if (idx == -1) {
848 idx = get_free_idx();
849 if (idx < 0)
850 return idx;
851 if (put_user(idx, &u_info->entry_number))
852 return -EFAULT;
853 }
854
855 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
856 return -EINVAL;
857
858 desc = t->tls_array + idx - GDT_ENTRY_TLS_MIN;
859
860 /*
861 * We must not get preempted while modifying the TLS.
862 */
863 cpu = get_cpu();
864
865 if (LDT_empty(&info)) {
866 desc->a = 0;
867 desc->b = 0;
868 } else {
869 desc->a = LDT_entry_a(&info);
870 desc->b = LDT_entry_b(&info);
871 }
872 load_TLS(t, cpu);
873
874 put_cpu();
875
876 return 0;
877}
878
879/*
880 * Get the current Thread-Local Storage area:
881 */
882
883#define GET_BASE(desc) ( \
884 (((desc)->a >> 16) & 0x0000ffff) | \
885 (((desc)->b << 16) & 0x00ff0000) | \
886 ( (desc)->b & 0xff000000) )
887
888#define GET_LIMIT(desc) ( \
889 ((desc)->a & 0x0ffff) | \
890 ((desc)->b & 0xf0000) )
891
892#define GET_32BIT(desc) (((desc)->b >> 22) & 1)
893#define GET_CONTENTS(desc) (((desc)->b >> 10) & 3)
894#define GET_WRITABLE(desc) (((desc)->b >> 9) & 1)
895#define GET_LIMIT_PAGES(desc) (((desc)->b >> 23) & 1)
896#define GET_PRESENT(desc) (((desc)->b >> 15) & 1)
897#define GET_USEABLE(desc) (((desc)->b >> 20) & 1)
898
899asmlinkage int sys_get_thread_area(struct user_desc __user *u_info)
900{
901 struct user_desc info;
902 struct desc_struct *desc;
903 int idx;
904
905 if (get_user(idx, &u_info->entry_number))
906 return -EFAULT;
907 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
908 return -EINVAL;
909
71ae18ec
PBG
910 memset(&info, 0, sizeof(info));
911
1da177e4
LT
912 desc = current->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
913
914 info.entry_number = idx;
915 info.base_addr = GET_BASE(desc);
916 info.limit = GET_LIMIT(desc);
917 info.seg_32bit = GET_32BIT(desc);
918 info.contents = GET_CONTENTS(desc);
919 info.read_exec_only = !GET_WRITABLE(desc);
920 info.limit_in_pages = GET_LIMIT_PAGES(desc);
921 info.seg_not_present = !GET_PRESENT(desc);
922 info.useable = GET_USEABLE(desc);
923
924 if (copy_to_user(u_info, &info, sizeof(info)))
925 return -EFAULT;
926 return 0;
927}
928
929unsigned long arch_align_stack(unsigned long sp)
930{
c16b63e0 931 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
1da177e4
LT
932 sp -= get_random_int() % 8192;
933 return sp & ~0xf;
934}