Prex Home / Browse Source - Prex Version: 0.9.0

root/bsp/hal/x86/arch/context.c

DEFINITIONS

1. context_set
2. context_switch
3. context_save
4. context_restore
5. context_dump

   1 /*-
   2  * Copyright (c) 2005-2009, Kohsuke Ohtani
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the author nor the names of any co-contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  30 /*
  31  * context.c - context management routines
  32  */
  34 /*
  35  * The context consists of kernel/user mode registers, and kernel
  36  * stack. The user mode registers are always saved to the kernel
  37  * stack when processor enters kernel mode by H/W or S/W events.
  38  *
  39  * The user mode registers are located in the interrupt/trap
  40  * frame at the top of the kernel stack. Before the control
  41  * returns to user mode next time, these register value will be
  42  * restored automatically.
  43  *
  44  * All thread owns its context to keep its execution state. The
  45  * scheduler will switch the context to change an active thread.
  46  */
  48 #include <kernel.h>
  49 #include <kmem.h>
  50 #include <cpu.h>
  51 #include <trap.h>
  52 #include <context.h>
  53 #include <locore.h>
  55 /*
  56  * Set user mode registers into the specific context.
  57  *
  58  * Note: When user mode program counter is set, all register
  59  * values except a stack pointer are reset to default value.
  60  */
  61 void
context_set(context_t ctx, int type, register_t val)
  63 {
  64         struct kern_regs *k;
  65         struct cpu_regs *u;
uint32_t *argp;
k = &ctx->kregs;
  70         switch (type) {
  71         case CTX_KSTACK:
  72                 /* Set kernel mode stack pointer */
ctx->uregs = (struct cpu_regs *)
  74                                 ((uint32_t)val - sizeof(struct cpu_regs));
ctx->esp0 = (uint32_t)val;
k->eip = (uint32_t)&syscall_ret;
k->esp = (uint32_t)ctx->uregs - sizeof(uint32_t);
  80                 /* Reset minimum user mode registers */
u = ctx->uregs;
u->eax = 0;
u->eflags = (uint32_t)(EFL_IF | EFL_IOPL_KERN);
  84                 break;
  86         case CTX_KENTRY:
  87                 /* Kernel mode program counter */
k->eip = (uint32_t)val;
  89                 break;
  91         case CTX_KARG:
  92                 /* Kernel mode argument */
argp = (uint32_t *)(k->esp + sizeof(uint32_t) * 2);
  94                 *argp = (uint32_t)val;
  95                 break;
  97         case CTX_USTACK:
  98                 /* User mode stack pointer */
u = ctx->uregs;
u->esp = (uint32_t)val;
u->ss = (uint32_t)(USER_DS | 3); /* fail safe */
 102                 break;
 104         case CTX_UENTRY:
 105                 /* User mode program counter */
u = ctx->uregs;
u->eip = (uint32_t)val;
u->cs = (uint32_t)(USER_CS | 3);
u->ds = u->es = (uint32_t)(USER_DS | 3);
u->eflags = (uint32_t)(EFL_IF | EFL_IOPL_KERN);
u->eax = u->ebx = u->ecx = u->edx =
u->edi = u->esi = u->ebp = 0;
 113                 break;
 115         case CTX_UARG:
 116                 /* User mode argument */
u = ctx->uregs;
argp = (uint32_t *)(u->esp + sizeof(uint32_t));
copyout(&val, argp, sizeof(uint32_t));
 120                 break;
 122         default:
 123                 /* invalid */
 124                 break;
 125         }
 126 }
 128 /*
 129  * Switch to new context
 130  *
 131  * Kernel mode registers and kernel stack pointer are switched to
 132  * the next context.
 133  *
 134  * We don't use x86 task switch mechanism to minimize the context
 135  * space. The system has only one TSS(task state segment), and
 136  * the context switching is done by changing the register value
 137  * in this TSS. Processor will reload them automatically when it
 138  * enters to the kernel mode in next time.
 139  *
 140  * It is assumed all interrupts are disabled by caller.
 141  *
 142  * TODO: FPU context is not switched as of now.
 143  */
 144 void
context_switch(context_t prev, context_t next)
 146 {
 147         /* Set kernel stack pointer in TSS (esp0). */
tss_set((uint32_t)next->esp0);
 150         /* Save the previous context, and restore the next context */
cpu_switch(&prev->kregs, &next->kregs);
 152 }
 154 /*
 155  * Save user mode context to handle exceptions.
 156  *
 157  * Copy current user mode registers in the kernel stack to the
 158  * user mode stack. The user stack pointer is adjusted for this
 159  * area. So that the exception handler can get the register
 160  * state of the target thread.
 161  *
 162  * It builds arguments for the exception handler in the following
 163  * format.
 164  *
 165  *   void exception_handler(int exc, void *regs);
 166  */
 167 void
context_save(context_t ctx)
 169 {
 170         struct cpu_regs *cur, *sav;
 172         /* Copy current register context into user mode stack */
cur = ctx->uregs;
sav = (struct cpu_regs *)(cur->esp - sizeof(*sav));
copyout(cur, sav, sizeof(*sav));
ctx->saved_regs = sav;
 180         /* Adjust stack pointer */
cur->esp = (uint32_t)sav - (sizeof(uint32_t) * 2);
 182 }
 184 /*
 185  * Restore register context to return from the exception handler.
 186  */
 187 void
context_restore(context_t ctx)
 189 {
 190         struct cpu_regs *cur;
 192         /* Restore user mode context */
cur = ctx->uregs;
copyin(ctx->saved_regs, cur, sizeof(*cur));
 196         /* Correct some registers for fail safe */
cur->cs = (uint32_t)(USER_CS | 3);
cur->ss = cur->ds = cur->es = (uint32_t)(USER_DS | 3);
cur->eflags |= EFL_IF;
 200 }
 202 void
context_dump(context_t ctx)
 204 {
 206 #ifdef DEBUG
trap_dump(ctx->uregs);
 208 #endif
 209 }