linux/arch/i386/kernel/process.c |
|---|
| Linux 2.5.53 |
Description
Ce fichier contient les codes sources linux/arch/i386/kernel/process.c lequel permet la gestion des processus avec une architecture 80386.
Code source
Voici le code source en langage de programmation C du fichier du système d'exploitation Linux :
- /*
- * linux/arch/i386/kernel/process.c
- *
- * Copyright (C) 1995 Linus Torvalds
- *
- * Pentium III FXSR, SSE support
- * Gareth Hughes <gareth@valinux.com>, May 2000
- */
- /*
- * This file handles the architecture-dependent parts of process handling..
- */
- #define __KERNEL_SYSCALLS__
- #include <stdarg.h>
- #include <linux/errno.h>
- #include <linux/sched.h>
- #include <linux/fs.h>
- #include <linux/kernel.h>
- #include <linux/mm.h>
- #include <linux/elfcore.h>
- #include <linux/smp.h>
- #include <linux/smp_lock.h>
- #include <linux/stddef.h>
- #include <linux/unistd.h>
- #include <linux/slab.h>
- #include <linux/vmalloc.h>
- #include <linux/user.h>
- #include <linux/a.out.h>
- #include <linux/interrupt.h>
- #include <linux/config.h>
- #include <linux/delay.h>
- #include <linux/reboot.h>
- #include <linux/init.h>
- #include <linux/mc146818rtc.h>
- #include <linux/module.h>
- #include <linux/kallsyms.h>
- #include <asm/uaccess.h>
- #include <asm/pgtable.h>
- #include <asm/system.h>
- #include <asm/io.h>
- #include <asm/ldt.h>
- #include <asm/processor.h>
- #include <asm/i387.h>
- #include <asm/irq.h>
- #include <asm/desc.h>
- #ifdef CONFIG_MATH_EMULATION
- #include <asm/math_emu.h>
- #endif
- #include <linux/irq.h>
- #include <linux/err.h>
- asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
- int hlt_counter;
- /*
- * Return saved PC of a blocked thread.
- */
- unsigned long thread_saved_pc(struct task_struct *tsk)
- {
- return ((unsigned long *)tsk->thread.esp)[3];
- }
- /*
- * Powermanagement idle function, if any..
- */
- void (*pm_idle)(void);
- void disable_hlt(void)
- {
- hlt_counter++;
- }
- void enable_hlt(void)
- {
- hlt_counter--;
- }
- /*
- * We use this if we don't have any better
- * idle routine..
- */
- void default_idle(void)
- {
- if (current_cpu_data.hlt_works_ok && !hlt_counter) {
- local_irq_disable();
- if (!need_resched())
- safe_halt();
- else
- local_irq_enable();
- }
- }
- /*
- * On SMP it's slightly faster (but much more power-consuming!)
- * to poll the ->work.need_resched flag instead of waiting for the
- * cross-CPU IPI to arrive. Use this option with caution.
- */
- static void poll_idle (void)
- {
- int oldval;
- local_irq_enable();
- /*
- * Deal with another CPU just having chosen a thread to
- * run here:
- */
- oldval = test_and_clear_thread_flag(TIF_NEED_RESCHED);
- if (!oldval) {
- set_thread_flag(TIF_POLLING_NRFLAG);
- asm volatile(
- "2:"
- "testl %0, %1;"
- "rep; nop;"
- "je 2b;"
- : : "i"(_TIF_NEED_RESCHED), "m" (current_thread_info()->flags));
- clear_thread_flag(TIF_POLLING_NRFLAG);
- } else {
- set_need_resched();
- }
- }
- /*
- * The idle thread. There's no useful work to be
- * done, so just try to conserve power and have a
- * low exit latency (ie sit in a loop waiting for
- * somebody to say that they'd like to reschedule)
- */
- void cpu_idle (void)
- {
- /* endless idle loop with no priority at all */
- while (1) {
- void (*idle)(void) = pm_idle;
- if (!idle)
- idle = default_idle;
- irq_stat[smp_processor_id()].idle_timestamp = jiffies;
- while (!need_resched())
- idle();
- schedule();
- }
- }
- static int __init idle_setup (char *str)
- {
- if (!strncmp(str, "poll", 4)) {
- printk("using polling idle threads.\n");
- pm_idle = poll_idle;
- }
- return 1;
- }
- __setup("idle=", idle_setup);
- void show_regs(struct pt_regs * regs)
- {
- unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L;
- printk("\n");
- printk("Pid: %d, comm: %20s\n", current->pid, current->comm);
- printk("EIP: %04x:[<%08lx>] CPU: %d\n",0xffff & regs->xcs,regs->eip, smp_processor_id());
- print_symbol("EIP is at %s\n", regs->eip);
- if (regs->xcs & 3)
- printk(" ESP: %04x:%08lx",0xffff & regs->xss,regs->esp);
- printk(" EFLAGS: %08lx %s\n",regs->eflags, print_tainted());
- printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n",
- regs->eax,regs->ebx,regs->ecx,regs->edx);
- printk("ESI: %08lx EDI: %08lx EBP: %08lx",
- regs->esi, regs->edi, regs->ebp);
- printk(" DS: %04x ES: %04x\n",
- 0xffff & regs->xds,0xffff & regs->xes);
- __asm__("movl %%cr0, %0": "=r" (cr0));
- __asm__("movl %%cr2, %0": "=r" (cr2));
- __asm__("movl %%cr3, %0": "=r" (cr3));
- /* This could fault if %cr4 does not exist */
- __asm__("1: movl %%cr4, %0 \n"
- "2: \n"
- ".section __ex_table,\"a\" \n"
- ".long 1b,2b \n"
- ".previous \n"
- : "=r" (cr4): "0" (0));
- printk("CR0: %08lx CR2: %08lx CR3: %08lx CR4: %08lx\n", cr0, cr2, cr3, cr4);
- show_trace(®s->esp);
- }
- /*
- * This gets run with %ebx containing the
- * function to call, and %edx containing
- * the "args".
- */
- extern void kernel_thread_helper(void);
- __asm__(".align 4\n"
- "kernel_thread_helper:\n\t"
- "movl %edx,%eax\n\t"
- "pushl %edx\n\t"
- "call *%ebx\n\t"
- "pushl %eax\n\t"
- "call do_exit");
- /*
- * Create a kernel thread
- */
- int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
- {
- struct task_struct *p;
- struct pt_regs regs;
- memset(®s, 0, sizeof(regs));
- regs.ebx = (unsigned long) fn;
- regs.edx = (unsigned long) arg;
- regs.xds = __KERNEL_DS;
- regs.xes = __KERNEL_DS;
- regs.orig_eax = -1;
- regs.eip = (unsigned long) kernel_thread_helper;
- regs.xcs = __KERNEL_CS;
- regs.eflags = 0x286;
- /* Ok, create the new process.. */
- p = do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, ®s, 0, NULL, NULL);
- return IS_ERR(p) ? PTR_ERR(p) : p->pid;
- }
- /*
- * Free current thread data structures etc..
- */
- void exit_thread(void)
- {
- struct task_struct *tsk = current;
- /* The process may have allocated an io port bitmap... nuke it. */
- if (unlikely(NULL != tsk->thread.ts_io_bitmap)) {
- kfree(tsk->thread.ts_io_bitmap);
- tsk->thread.ts_io_bitmap = NULL;
- }
- }
- void flush_thread(void)
- {
- struct task_struct *tsk = current;
- memset(tsk->thread.debugreg, 0, sizeof(unsigned long)*8);
- memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
- /*
- * Forget coprocessor state..
- */
- clear_fpu(tsk);
- tsk->used_math = 0;
- }
- void release_thread(struct task_struct *dead_task)
- {
- if (dead_task->mm) {
- // temporary debugging check
- if (dead_task->mm->context.size) {
- printk("WARNING: dead process %8s still has LDT? <%p/%d>\n",
- dead_task->comm,
- dead_task->mm->context.ldt,
- dead_task->mm->context.size);
- BUG();
- }
- }
- release_x86_irqs(dead_task);
- }
- /*
- * Save a segment.
- */
- #define savesegment(seg,value) \
- asm volatile("movl %%" #seg ",%0":"=m" (*(int *)&(value)))
- int copy_thread(int nr, unsigned long clone_flags, unsigned long esp,
- unsigned long unused,
- struct task_struct * p, struct pt_regs * regs)
- {
- struct pt_regs * childregs;
- struct task_struct *tsk;
- childregs = ((struct pt_regs *) (THREAD_SIZE + (unsigned long) p->thread_info)) - 1;
- struct_cpy(childregs, regs);
- childregs->eax = 0;
- childregs->esp = esp;
- p->set_child_tid = p->clear_child_tid = NULL;
- p->thread.esp = (unsigned long) childregs;
- p->thread.esp0 = (unsigned long) (childregs+1);
- p->thread.eip = (unsigned long) ret_from_fork;
- savesegment(fs,p->thread.fs);
- savesegment(gs,p->thread.gs);
- tsk = current;
- unlazy_fpu(tsk);
- struct_cpy(&p->thread.i387, &tsk->thread.i387);
- if (unlikely(NULL != tsk->thread.ts_io_bitmap)) {
- p->thread.ts_io_bitmap = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
- if (!p->thread.ts_io_bitmap)
- return -ENOMEM;
- memcpy(p->thread.ts_io_bitmap, tsk->thread.ts_io_bitmap,
- IO_BITMAP_BYTES);
- }
- /*
- * Set a new TLS for the child thread?
- */
- if (clone_flags & CLONE_SETTLS) {
- struct desc_struct *desc;
- struct user_desc info;
- int idx;
- if (copy_from_user(&info, (void *)childregs->esi, sizeof(info)))
- return -EFAULT;
- if (LDT_empty(&info))
- return -EINVAL;
- idx = info.entry_number;
- if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
- return -EINVAL;
- desc = p->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
- desc->a = LDT_entry_a(&info);
- desc->b = LDT_entry_b(&info);
- }
- return 0;
- }
- /*
- * fill in the user structure for a core dump..
- */
- void dump_thread(struct pt_regs * regs, struct user * dump)
- {
- int i;
- /* changed the size calculations - should hopefully work better. lbt */
- dump->magic = CMAGIC;
- dump->start_code = 0;
- dump->start_stack = regs->esp & ~(PAGE_SIZE - 1);
- dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
- dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
- dump->u_dsize -= dump->u_tsize;
- dump->u_ssize = 0;
- for (i = 0; i < 8; i++)
- dump->u_debugreg[i] = current->thread.debugreg[i];
- if (dump->start_stack < TASK_SIZE)
- dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
- dump->regs.ebx = regs->ebx;
- dump->regs.ecx = regs->ecx;
- dump->regs.edx = regs->edx;
- dump->regs.esi = regs->esi;
- dump->regs.edi = regs->edi;
- dump->regs.ebp = regs->ebp;
- dump->regs.eax = regs->eax;
- dump->regs.ds = regs->xds;
- dump->regs.es = regs->xes;
- savesegment(fs,dump->regs.fs);
- savesegment(gs,dump->regs.gs);
- dump->regs.orig_eax = regs->orig_eax;
- dump->regs.eip = regs->eip;
- dump->regs.cs = regs->xcs;
- dump->regs.eflags = regs->eflags;
- dump->regs.esp = regs->esp;
- dump->regs.ss = regs->xss;
- dump->u_fpvalid = dump_fpu (regs, &dump->i387);
- }
- /*
- * Capture the user space registers if the task is not running (in user space)
- */
- int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
- {
- struct pt_regs ptregs;
-
- ptregs = *(struct pt_regs *)
- ((unsigned long)tsk->thread_info+THREAD_SIZE - sizeof(ptregs));
- ptregs.xcs &= 0xffff;
- ptregs.xds &= 0xffff;
- ptregs.xes &= 0xffff;
- ptregs.xss &= 0xffff;
- elf_core_copy_regs(regs, &ptregs);
- return 1;
- }
- /*
- * This special macro can be used to load a debugging register
- */
- #define loaddebug(thread,register) \
- __asm__("movl %0,%%db" #register \
- : /* no output */ \
- :"r" (thread->debugreg[register]))
- /*
- * switch_to(x,yn) should switch tasks from x to y.
- *
- * We fsave/fwait so that an exception goes off at the right time
- * (as a call from the fsave or fwait in effect) rather than to
- * the wrong process. Lazy FP saving no longer makes any sense
- * with modern CPU's, and this simplifies a lot of things (SMP
- * and UP become the same).
- *
- * NOTE! We used to use the x86 hardware context switching. The
- * reason for not using it any more becomes apparent when you
- * try to recover gracefully from saved state that is no longer
- * valid (stale segment register values in particular). With the
- * hardware task-switch, there is no way to fix up bad state in
- * a reasonable manner.
- *
- * The fact that Intel documents the hardware task-switching to
- * be slow is a fairly red herring - this code is not noticeably
- * faster. However, there _is_ some room for improvement here,
- * so the performance issues may eventually be a valid point.
- * More important, however, is the fact that this allows us much
- * more flexibility.
- */
- void __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
- {
- struct thread_struct *prev = &prev_p->thread,
- *next = &next_p->thread;
- int cpu = smp_processor_id();
- struct tss_struct *tss = init_tss + cpu;
- /* never put a printk in __switch_to... printk() calls wake_up*() indirectly */
- unlazy_fpu(prev_p);
- /*
- * Reload esp0, LDT and the page table pointer:
- */
- load_esp0(tss, next->esp0);
- /*
- * Load the per-thread Thread-Local Storage descriptor.
- */
- load_TLS(next, cpu);
- /*
- * Save away %fs and %gs. No need to save %es and %ds, as
- * those are always kernel segments while inside the kernel.
- */
- asm volatile("movl %%fs,%0":"=m" (*(int *)&prev->fs));
- asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->gs));
- /*
- * Restore %fs and %gs if needed.
- */
- if (unlikely(prev->fs | prev->gs | next->fs | next->gs)) {
- loadsegment(fs, next->fs);
- loadsegment(gs, next->gs);
- }
- /*
- * Now maybe reload the debug registers
- */
- if (unlikely(next->debugreg[7])) {
- loaddebug(next, 0);
- loaddebug(next, 1);
- loaddebug(next, 2);
- loaddebug(next, 3);
- /* no 4 and 5 */
- loaddebug(next, 6);
- loaddebug(next, 7);
- }
- if (unlikely(prev->ts_io_bitmap || next->ts_io_bitmap)) {
- if (next->ts_io_bitmap) {
- /*
- * 4 cachelines copy ... not good, but not that
- * bad either. Anyone got something better?
- * This only affects processes which use ioperm().
- * [Putting the TSSs into 4k-tlb mapped regions
- * and playing VM tricks to switch the IO bitmap
- * is not really acceptable.]
- */
- memcpy(tss->io_bitmap, next->ts_io_bitmap,
- IO_BITMAP_BYTES);
- tss->bitmap = IO_BITMAP_OFFSET;
- } else
- /*
- * a bitmap offset pointing outside of the TSS limit
- * causes a nicely controllable SIGSEGV if a process
- * tries to use a port IO instruction. The first
- * sys_ioperm() call sets up the bitmap properly.
- */
- tss->bitmap = INVALID_IO_BITMAP_OFFSET;
- }
- }
- asmlinkage int sys_fork(struct pt_regs regs)
- {
- struct task_struct *p;
- p = do_fork(SIGCHLD, regs.esp, ®s, 0, NULL, NULL);
- return IS_ERR(p) ? PTR_ERR(p) : p->pid;
- }
- asmlinkage int sys_clone(struct pt_regs regs)
- {
- struct task_struct *p;
- unsigned long clone_flags;
- unsigned long newsp;
- int *parent_tidptr, *child_tidptr;
- clone_flags = regs.ebx;
- newsp = regs.ecx;
- parent_tidptr = (int *)regs.edx;
- child_tidptr = (int *)regs.edi;
- if (!newsp)
- newsp = regs.esp;
- p = do_fork(clone_flags & ~CLONE_IDLETASK, newsp, ®s, 0, parent_tidptr, child_tidptr);
- return IS_ERR(p) ? PTR_ERR(p) : p->pid;
- }
- /*
- * This is trivial, and on the face of it looks like it
- * could equally well be done in user mode.
- *
- * Not so, for quite unobvious reasons - register pressure.
- * In user mode vfork() cannot have a stack frame, and if
- * done by calling the "clone()" system call directly, you
- * do not have enough call-clobbered registers to hold all
- * the information you need.
- */
- asmlinkage int sys_vfork(struct pt_regs regs)
- {
- struct task_struct *p;
- p = do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.esp, ®s, 0, NULL, NULL);
- return IS_ERR(p) ? PTR_ERR(p) : p->pid;
- }
- /*
- * sys_execve() executes a new program.
- */
- asmlinkage int sys_execve(struct pt_regs regs)
- {
- int error;
- char * filename;
- filename = getname((char *) regs.ebx);
- error = PTR_ERR(filename);
- if (IS_ERR(filename))
- goto out;
- error = do_execve(filename, (char **) regs.ecx, (char **) regs.edx, ®s);
- if (error == 0)
- current->ptrace &= ~PT_DTRACE;
- putname(filename);
- out:
- return error;
- }
- /*
- * These bracket the sleeping functions..
- */
- extern void scheduling_functions_start_here(void);
- extern void scheduling_functions_end_here(void);
- #define first_sched ((unsigned long) scheduling_functions_start_here)
- #define last_sched ((unsigned long) scheduling_functions_end_here)
- unsigned long get_wchan(struct task_struct *p)
- {
- unsigned long ebp, esp, eip;
- unsigned long stack_page;
- int count = 0;
- if (!p || p == current || p->state == TASK_RUNNING)
- return 0;
- stack_page = (unsigned long)p->thread_info;
- esp = p->thread.esp;
- if (!stack_page || esp < stack_page || esp > 8188+stack_page)
- return 0;
- /* include/asm-i386/system.h:switch_to() pushes ebp last. */
- ebp = *(unsigned long *) esp;
- do {
- if (ebp < stack_page || ebp > 8184+stack_page)
- return 0;
- eip = *(unsigned long *) (ebp+4);
- if (eip < first_sched || eip >= last_sched)
- return eip;
- ebp = *(unsigned long *) ebp;
- } while (count++ < 16);
- return 0;
- }
- #undef last_sched
- #undef first_sched
- /*
- * sys_alloc_thread_area: get a yet unused TLS descriptor index.
- */
- static int get_free_idx(void)
- {
- struct thread_struct *t = ¤t->thread;
- int idx;
- for (idx = 0; idx < GDT_ENTRY_TLS_ENTRIES; idx++)
- if (desc_empty(t->tls_array + idx))
- return idx + GDT_ENTRY_TLS_MIN;
- return -ESRCH;
- }
- /*
- * Set a given TLS descriptor:
- */
- asmlinkage int sys_set_thread_area(struct user_desc *u_info)
- {
- struct thread_struct *t = ¤t->thread;
- struct user_desc info;
- struct desc_struct *desc;
- int cpu, idx;
- if (copy_from_user(&info, u_info, sizeof(info)))
- return -EFAULT;
- idx = info.entry_number;
- /*
- * index -1 means the kernel should try to find and
- * allocate an empty descriptor:
- */
- if (idx == -1) {
- idx = get_free_idx();
- if (idx < 0)
- return idx;
- if (put_user(idx, &u_info->entry_number))
- return -EFAULT;
- }
- if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
- return -EINVAL;
- desc = t->tls_array + idx - GDT_ENTRY_TLS_MIN;
- /*
- * We must not get preempted while modifying the TLS.
- */
- cpu = get_cpu();
- if (LDT_empty(&info)) {
- desc->a = 0;
- desc->b = 0;
- } else {
- desc->a = LDT_entry_a(&info);
- desc->b = LDT_entry_b(&info);
- }
- load_TLS(t, cpu);
- put_cpu();
- return 0;
- }
- /*
- * Get the current Thread-Local Storage area:
- */
- #define GET_BASE(desc) ( \
- (((desc)->a >> 16) & 0x0000ffff) | \
- (((desc)->b << 16) & 0x00ff0000) | \
- ( (desc)->b & 0xff000000) )
- #define GET_LIMIT(desc) ( \
- ((desc)->a & 0x0ffff) | \
- ((desc)->b & 0xf0000) )
-
- #define GET_32BIT(desc) (((desc)->b >> 23) & 1)
- #define GET_CONTENTS(desc) (((desc)->b >> 10) & 3)
- #define GET_WRITABLE(desc) (((desc)->b >> 9) & 1)
- #define GET_LIMIT_PAGES(desc) (((desc)->b >> 23) & 1)
- #define GET_PRESENT(desc) (((desc)->b >> 15) & 1)
- #define GET_USEABLE(desc) (((desc)->b >> 20) & 1)
- asmlinkage int sys_get_thread_area(struct user_desc *u_info)
- {
- struct user_desc info;
- struct desc_struct *desc;
- int idx;
- if (get_user(idx, &u_info->entry_number))
- return -EFAULT;
- if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
- return -EINVAL;
- desc = current->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
- info.entry_number = idx;
- info.base_addr = GET_BASE(desc);
- info.limit = GET_LIMIT(desc);
- info.seg_32bit = GET_32BIT(desc);
- info.contents = GET_CONTENTS(desc);
- info.read_exec_only = !GET_WRITABLE(desc);
- info.limit_in_pages = GET_LIMIT_PAGES(desc);
- info.seg_not_present = !GET_PRESENT(desc);
- info.useable = GET_USEABLE(desc);
- if (copy_to_user(u_info, &info, sizeof(info)))
- return -EFAULT;
- return 0;
- }
Dernière mise à jour : Samedi, le 2 juin 2018