Annotation of prex-old/sys/kern/exception.c, Revision 1.1.1.1
1.1 nbrk 1: /*-
2: * Copyright (c) 2005-2007, 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: * exception.c - exception handling routines
32: */
33:
34: /**
35: * An user mode task can specify its own exception handler with
36: * exception_setup() system call.
37: *
38: * There are two different types of exceptions in a system - H/W and
39: * S/W exception. The kernel determines to which thread it delivers
40: * depending on the exception type.
41: *
42: * - H/W exception
43: *
44: * This type of exception is caused by H/W trap & fault. The
45: * exception will be sent to the thread which caused the trap.
46: * If no handler is specified by the task, it will be terminated
47: * by the kernel immediately.
48: *
49: * - S/W exception
50: *
51: * The user mode task can send S/W exception to another task by
52: * exception_raise() system call.
53: * The exception will be sent to the thread that is sleeping with
54: * exception_wait() call. If no thread is waiting for the exception,
55: * the exception is sent to the first thread in the target task.
56: *
57: * Kernel supports 32 types of exceptions. The following pre-defined
58: * exceptions are raised by kernel itself.
59: *
60: * Exception Type Reason
61: * --------- ---- -----------------------
62: * SIGILL h/w illegal instruction
63: * SIGTRAP h/w break point
64: * SIGFPE h/w math error
65: * SIGSEGV h/w invalid memory access
66: * SIGALRM s/w alarm event
67: *
68: * The POSIX emulation library will setup own exception handler to
69: * convert the Prex exceptions into UNIX signals. It will maintain its
70: * own signal mask, and transfer control to the POSIX signal handler.
71: */
72:
73: #include <kernel.h>
74: #include <event.h>
75: #include <task.h>
76: #include <thread.h>
77: #include <sched.h>
78: #include <task.h>
79: #include <irq.h>
80: #include <exception.h>
81:
82: static struct event exception_event;
83:
84: /*
85: * Install an exception handler for the current task.
86: * NULL can be specified as handler to remove current handler.
87: * If handler is removed, all pending exceptions are discarded
88: * immediately. In this case, all threads blocked in exception_wait()
89: * are unblocked.
90: *
91: * Only one exception handler can be set per task. If the previous
92: * handler exists in task, exception_setup() just override that
93: * handler.
94: */
95: int
96: exception_setup(void (*handler)(int, u_long))
97: {
98: task_t self;
99: list_t head, n;
100: thread_t th;
101:
102: if (handler != NULL && !user_area(handler))
103: return EFAULT;
104:
105: sched_lock();
106: self = cur_task();
107: if (self->exc_handler && handler == NULL) {
108: /*
109: * Remove existing exception handler. Do clean up
110: * job for all threads in the target task.
111: */
112: head = &self->threads;
113: for (n = list_first(head); n != head; n = list_next(n)) {
114: /*
115: * Clear pending exceptions.
116: */
117: th = list_entry(n, struct thread, task_link);
118: irq_lock();
119: th->exc_bitmap = 0;
120: irq_unlock();
121: /*
122: * If the thread is waiting for an exception,
123: * cancel it.
124: */
125: if (th->sleep_event == &exception_event)
126: sched_unsleep(th, SLP_BREAK);
127: }
128: }
129: self->exc_handler = handler;
130: sched_unlock();
131: return 0;
132: }
133:
134: /*
135: * exception_raise - raise an exception for specified task.
136: * @task: task id
137: * @exc: exception code
138: *
139: * The exception pending flag is marked here, and it is processed
140: * by exception_deliver() later. If the task want to raise an
141: * exception to another task, the caller task must have CAP_KILL
142: * capability. If the exception is sent to the kernel task, this
143: * routine just returns error.
144: */
145: int
146: exception_raise(task_t task, int exc)
147: {
148: int err;
149:
150: sched_lock();
151:
152: if (!task_valid(task)) {
153: err = ESRCH;
154: } else if (task != cur_task() && !task_capable(CAP_KILL)) {
155: err = EPERM;
156: } else if (task == &kern_task || task->exc_handler == NULL ||
157: list_empty(&task->threads)) {
158: err = EPERM;
159: } else {
160: err = exception_post(task, exc);
161: }
162: sched_unlock();
163: return err;
164: }
165:
166: /*
167: * Post an exception to the specified task.
168: */
169: int
170: exception_post(task_t task, int exc)
171: {
172: list_t head, n;
173: thread_t th;
174:
175: if (exc < 0 || exc >= NR_EXCS)
176: return EINVAL;
177:
178: /*
179: * Determine which thread should we send an exception.
180: * First, search the thread that is waiting an exception by
181: * calling exception_wait(). Then, if no thread is waiting
182: * exceptions, it is sent to the master thread in task.
183: */
184: head = &task->threads;
185: for (n = list_first(head); n != head; n = list_next(n)) {
186: th = list_entry(n, struct thread, task_link);
187: if (th->sleep_event == &exception_event)
188: break;
189: }
190: if (n == head) {
191: n = list_first(head);
192: th = list_entry(n, struct thread, task_link);
193: }
194: /*
195: * Mark pending bit for this exception.
196: */
197: irq_lock();
198: th->exc_bitmap |= (1 << exc);
199: irq_unlock();
200:
201: /*
202: * Wakeup the target thread regardless of its waiting
203: * event.
204: */
205: sched_unsleep(th, SLP_INTR);
206:
207: return 0;
208: }
209:
210: /*
211: * exception_wait - block a current thread until some exceptions are
212: * raised to the current thread.
213: * @exc: exception code returned.
214: *
215: * The routine returns EINTR on success.
216: */
217: int
218: exception_wait(int *exc)
219: {
220: int i, rc;
221:
222: if (cur_task()->exc_handler == NULL)
223: return EINVAL;
224: if (!user_area(exc))
225: return EFAULT;
226:
227: sched_lock();
228:
229: /*
230: * Sleep until some exceptions occur.
231: */
232: rc = sched_sleep(&exception_event);
233: if (rc == SLP_BREAK) {
234: sched_unlock();
235: return EINVAL;
236: }
237: irq_lock();
238: for (i = 0; i < NR_EXCS; i++) {
239: if (cur_thread->exc_bitmap & (1 << i))
240: break;
241: }
242: irq_unlock();
243: ASSERT(i != NR_EXCS);
244: sched_unlock();
245:
246: if (umem_copyout(&i, exc, sizeof(int)))
247: return EFAULT;
248: return EINTR;
249: }
250:
251: /*
252: * Mark an exception flag for the current thread.
253: *
254: * This is called from architecture dependent code when H/W trap is
255: * occurred. If current task does not have exception handler, then
256: * current task will be terminated.
257: * This routine may be called at interrupt level.
258: */
259: void
260: exception_mark(int exc)
261: {
262: ASSERT(exc > 0 && exc < NR_EXCS);
263:
264: /* Mark pending bit */
265: irq_lock();
266: cur_thread->exc_bitmap |= (1 << exc);
267: irq_unlock();
268: }
269:
270: /*
271: * Check if pending exception exists for current task, and deliver
272: * it to the exception handler if needed.
273: * All exception is delivered at the time when the control goes back
274: * to the user mode.
275: * This routine is called from architecture dependent code.
276: * Some application may use longjmp() during its signal handler.
277: * So, current context must be saved to user mode stack.
278: */
279: void
280: exception_deliver(void)
281: {
282: thread_t th = cur_thread;
283: task_t self = cur_task();
284: void (*handler)(int, u_long);
285: uint32_t bitmap;
286: int exc;
287:
288: sched_lock();
289: irq_lock();
290: bitmap = th->exc_bitmap;
291: irq_unlock();
292:
293: if (bitmap != 0) {
294: /*
295: * Find a pending exception.
296: */
297: for (exc = 0; exc < NR_EXCS; exc++) {
298: if (bitmap & (1 << exc))
299: break;
300: }
301: handler = self->exc_handler;
302: if (handler == NULL) {
303: printk("Exception #%d is not handled by task.\n", exc);
304: printk("Terminate task:%s (id:%x)\n",
305: self->name ? self->name : "no name", self);
306: task_terminate(self);
307: goto out;
308: }
309: /*
310: * Transfer control to an exception handler.
311: */
312: context_save(&th->context, exc);
313: context_set(&th->context, CTX_UENTRY, (u_long)handler);
314:
315: irq_lock();
316: th->exc_bitmap &= ~(1 << exc);
317: irq_unlock();
318: }
319: out:
320: sched_unlock();
321: }
322:
323: /*
324: * exception_return() is called from exception handler to restore
325: * the original context.
326: * @regs: context pointer which is passed to exception handler.
327: *
328: * TODO: should validate passed data area.
329: */
330: int
331: exception_return(void *regs)
332: {
333:
334: if ((regs == NULL) || !user_area(regs))
335: return EFAULT;
336:
337: context_restore(&cur_thread->context, regs);
338: return 0;
339: }
340:
341: void
342: exception_init(void)
343: {
344:
345: event_init(&exception_event, "exception");
346: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to exception.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / sys / kern