Annotation of prex-old/sys/arch/i386/i386/context.c, Revision 1.1.1.1
1.1 nbrk 1: /*-
2: * Copyright (c) 2005, 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: */
29:
30: /*
31: * context.c - context management routines
32: */
33:
34: /*
35: * The context consists of kernel/user mode registers, and
36: * kernel stack. The user mode registers are always saved to the
37: * kernel 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 frame
40: * at the top of the kernel stack. Before the control returns to user
41: * mode next time, these register value will be restored automatically.
42: *
43: * All thread owns its context to keep its execution state. The
44: * scheduler will switch the context to change an active thread.
45: */
46:
47: #include <kernel.h>
48: #include <cpu.h>
49: #include <locore.h>
50:
51: /*
52: * Exception frame - stack layout for exception handler
53: */
54: struct exc_frame {
55: void *ret; /* Return address */
56: u_long code; /* Argument 1 */
57: struct cpu_regs *uregs; /* Argument 2 */
58: };
59:
60: /*
61: * Initialize specified context.
62: * @ctx: context id (pointer)
63: * @kstack: kernel stack for the context
64: *
65: * All thread will start at syscall_ret().
66: * In this time, the interrupt and I/O access are enabled.
67: */
68: void
69: context_init(context_t ctx, u_long kstack)
70: {
71: struct kern_regs *k;
72: struct cpu_regs *u;
73:
74: ctx->uregs = (struct cpu_regs *)(kstack - sizeof(struct cpu_regs));
75: ctx->esp0 = kstack;
76:
77: /* Initialize kernel mode registers */
78: k = &ctx->kregs;
79: k->eip = (u_long)syscall_ret;
80: k->esp = (u_long)ctx->uregs - sizeof(u_long);
81:
82: /* Reset minimum user mode registers */
83: u = ctx->uregs;
84: u->eax = 0;
85: u->eflags = EFL_IF | EFL_IOPL_KERN;
86: }
87:
88: /*
89: * Set data to the specific register stored in context.
90: * @type: register type to be set
91: * @val: register value to be set
92: *
93: * Note: When user mode program counter is set, all register
94: * values except stack pointer are reset to default value.
95: */
96: void
97: context_set(context_t ctx, int type, u_long val)
98: {
99: struct kern_regs *k;
100: struct cpu_regs *u;
101:
102: switch (type) {
103: case CTX_UENTRY: /* User mode program counter */
104: u = ctx->uregs;
105: u->eax = u->ebx = u->ecx = u->edx =
106: u->edi = u->esi = u->ebp = 0;
107: u->cs = USER_CS | 3;
108: u->ds = u->es = USER_DS | 3;
109: u->eflags = EFL_IF | EFL_IOPL_KERN;
110: u->eip = val;
111: break;
112: case CTX_USTACK: /* User mode stack pointer */
113: u = ctx->uregs;
114: u->esp = val;
115: u->ss = USER_DS | 3;
116: break;
117: case CTX_KENTRY: /* Kernel mode program counter */
118: k = &ctx->kregs;
119: k->eip = val;
120: break;
121: case CTX_KARG: /* Kernel mode argument */
122: k = &ctx->kregs;
123: *(u_long *)(k->esp + sizeof(u_long) * 2) = val;
124: break;
125: }
126: }
127:
128: /*
129: * Switch to new context
130: *
131: * Kernel mode registers and kernel stack pointer are switched to the
132: * next context.
133: *
134: * We don't use x86 task switch mechanism to minimize the context space.
135: * The system has only one TSS(task state segment), and the context
136: * switching is done by changing the register value in this TSS. Processor
137: * will reload them automatically when it enters to the kernel mode in
138: * 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
145: context_switch(context_t prev, context_t next)
146: {
147: /* Set kernel stack pointer in TSS (esp0). */
148: tss_set((u_long)next->esp0);
149:
150: /* Save the previous context, and restore the next context */
151: cpu_switch(&prev->kregs, &next->kregs);
152: }
153:
154: /*
155: * Save user mode context to handle exceptions.
156: * @exc: exception code passed to the exception handler
157: *
158: * Copy current user mode registers in the kernel stack to the user
159: * mode stack. The user stack pointer is adjusted for this area.
160: * So that the exception handler can get the register state of
161: * the target thread.
162: *
163: * It builds arguments for the exception handler in the following
164: * format.
165: *
166: * void exception_handler(int exc, void *regs);
167: */
168: void
169: context_save(context_t ctx, int exc)
170: {
171: struct cpu_regs *cur, *sav;
172: struct exc_frame *frm;
173:
174: /* Copy current register context into user mode stack */
175: cur = ctx->uregs;
176: sav = (struct cpu_regs *)(cur->esp - sizeof(struct cpu_regs));
177: memcpy(sav, cur, sizeof(struct cpu_regs));
178:
179: /* Setup exception frame for exception handler */
180: frm = (struct exc_frame *)(sav - sizeof(struct exc_frame));
181: frm->uregs = sav;
182: frm->code = exc;
183: frm->ret = NULL;
184: cur->esp = (u_long)frm;
185: }
186:
187: /*
188: * Restore register context to return from the exception handler.
189: * @regs: pointer to user mode register context.
190: */
191: void
192: context_restore(context_t ctx, void *regs)
193: {
194: struct cpu_regs *cur;
195:
196: /* Restore user mode context */
197: cur = ctx->uregs;
198: memcpy(cur, regs, sizeof(struct cpu_regs));
199:
200: /* Correct some registers for fail safe */
201: cur->cs = USER_CS | 3;
202: cur->ss = cur->ds = cur->es = USER_DS | 3;
203: cur->eflags |= EFL_IF;
204:
205: ASSERT(cur->eip && user_area(cur->eip));
206: ASSERT(cur->esp && user_area(cur->esp));
207: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to context.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / sys / arch / i386 / i386