Annotation of prex/sys/kern/exception.c, Revision 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: *
! 87: * NULL can be specified as handler to remove current handler.
! 88: * If handler is removed, all pending exceptions are discarded
! 89: * immediately. In this case, all threads blocked in
! 90: * exception_wait() are unblocked.
! 91: *
! 92: * Only one exception handler can be set per task. If the
! 93: * previous handler exists in task, exception_setup() just
! 94: * override that handler.
! 95: */
! 96: int
! 97: exception_setup(void (*handler)(int))
! 98: {
! 99: task_t self = cur_task();
! 100: list_t head, n;
! 101: thread_t th;
! 102:
! 103: if (handler != NULL && !user_area(handler))
! 104: return EFAULT;
! 105:
! 106: sched_lock();
! 107: if (self->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->excbits = 0;
! 120: irq_unlock();
! 121:
! 122: /*
! 123: * If the thread is waiting for an exception,
! 124: * cancel it.
! 125: */
! 126: if (th->slpevt == &exception_event)
! 127: sched_unsleep(th, SLP_BREAK);
! 128: }
! 129: }
! 130: self->handler = handler;
! 131: sched_unlock();
! 132: return 0;
! 133: }
! 134:
! 135: /*
! 136: * exception_raise - system call to raise an exception.
! 137: *
! 138: * The exception pending flag is marked here, and it is
! 139: * processed by exception_deliver() later. If the task
! 140: * want to raise an exception to another task, the caller
! 141: * task must have CAP_KILL capability. If the exception
! 142: * is sent to the kernel task, this routine just returns
! 143: * 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: goto out;
! 155: }
! 156: if (task != cur_task() && !task_capable(CAP_KILL)) {
! 157: err = EPERM;
! 158: goto out;
! 159: }
! 160: if (task == &kern_task || task->handler == NULL ||
! 161: list_empty(&task->threads)) {
! 162: err = EPERM;
! 163: goto out;
! 164: }
! 165: err = exception_post(task, exc);
! 166: out:
! 167: sched_unlock();
! 168: return err;
! 169: }
! 170:
! 171: /*
! 172: * exception_post-- the internal version of exception_raise().
! 173: */
! 174: int
! 175: exception_post(task_t task, int exc)
! 176: {
! 177: list_t head, n;
! 178: thread_t th;
! 179:
! 180: if (exc < 0 || exc >= NEXC)
! 181: return EINVAL;
! 182:
! 183: /*
! 184: * Determine which thread should we send an exception.
! 185: * First, search the thread that is waiting an exception
! 186: * by calling exception_wait(). Then, if no thread is
! 187: * waiting exceptions, it is sent to the master thread in
! 188: * task.
! 189: */
! 190: head = &task->threads;
! 191: for (n = list_first(head); n != head; n = list_next(n)) {
! 192: th = list_entry(n, struct thread, task_link);
! 193: if (th->slpevt == &exception_event)
! 194: break;
! 195: }
! 196: if (n == head) {
! 197: n = list_first(head);
! 198: th = list_entry(n, struct thread, task_link);
! 199: }
! 200: /*
! 201: * Mark pending bit for this exception.
! 202: */
! 203: irq_lock();
! 204: th->excbits |= (1 << exc);
! 205: irq_unlock();
! 206:
! 207: /*
! 208: * Wakeup the target thread regardless of its
! 209: * waiting event.
! 210: */
! 211: sched_unsleep(th, SLP_INTR);
! 212:
! 213: return 0;
! 214: }
! 215:
! 216: /*
! 217: * exception_wait - block a current thread until some exceptions
! 218: * are raised to the current thread.
! 219: *
! 220: * The routine returns EINTR on success.
! 221: */
! 222: int
! 223: exception_wait(int *exc)
! 224: {
! 225: task_t self = cur_task();
! 226: int i, rc;
! 227:
! 228: self = cur_task();
! 229: if (self->handler == NULL)
! 230: return EINVAL;
! 231: if (!user_area(exc))
! 232: return EFAULT;
! 233:
! 234: sched_lock();
! 235:
! 236: /*
! 237: * Sleep until some exceptions occur.
! 238: */
! 239: rc = sched_sleep(&exception_event);
! 240: if (rc == SLP_BREAK) {
! 241: sched_unlock();
! 242: return EINVAL;
! 243: }
! 244: irq_lock();
! 245: for (i = 0; i < NEXC; i++) {
! 246: if (cur_thread->excbits & (1 << i))
! 247: break;
! 248: }
! 249: irq_unlock();
! 250: ASSERT(i != NEXC);
! 251: sched_unlock();
! 252:
! 253: if (umem_copyout(&i, exc, sizeof(i)))
! 254: return EFAULT;
! 255: return EINTR;
! 256: }
! 257:
! 258: /*
! 259: * Mark an exception flag for the current thread.
! 260: *
! 261: * This is called from architecture dependent code when H/W
! 262: * trap is occurred. If current task does not have exception
! 263: * handler, then current task will be terminated. This routine
! 264: * may be called at interrupt level.
! 265: */
! 266: void
! 267: exception_mark(int exc)
! 268: {
! 269: ASSERT(exc > 0 && exc < NEXC);
! 270:
! 271: /* Mark pending bit */
! 272: irq_lock();
! 273: cur_thread->excbits |= (1 << exc);
! 274: irq_unlock();
! 275: }
! 276:
! 277: /*
! 278: * exception_deliver - deliver pending exception to the task.
! 279: *
! 280: * Check if pending exception exists for current task, and
! 281: * deliver it to the exception handler if needed. All
! 282: * exception is delivered at the time when the control goes
! 283: * back to the user mode. This routine is called from
! 284: * architecture dependent code. Some application may use
! 285: * longjmp() during its signal handler. So, current context
! 286: * must be saved to user mode stack.
! 287: */
! 288: void
! 289: exception_deliver(void)
! 290: {
! 291: thread_t th = cur_thread;
! 292: task_t self = cur_task();
! 293: void (*handler)(int);
! 294: uint32_t bitmap;
! 295: int exc;
! 296:
! 297: sched_lock();
! 298: irq_lock();
! 299: bitmap = th->excbits;
! 300: irq_unlock();
! 301:
! 302: if (bitmap != 0) {
! 303: /*
! 304: * Find a pending exception.
! 305: */
! 306: for (exc = 0; exc < NEXC; exc++) {
! 307: if (bitmap & (1 << exc))
! 308: break;
! 309: }
! 310: handler = self->handler;
! 311: if (handler == NULL) {
! 312: DPRINTF(("Exception #%d is not handled by task.\n",
! 313: exc));
! 314: DPRINTF(("Terminate task:%s (id:%x)\n",
! 315: self->name != NULL ? self->name : "no name",
! 316: self));
! 317:
! 318: task_terminate(self);
! 319: goto out;
! 320: }
! 321: /*
! 322: * Transfer control to an exception handler.
! 323: */
! 324: context_save(&th->ctx);
! 325: context_set(&th->ctx, CTX_UENTRY, (vaddr_t)handler);
! 326: context_set(&th->ctx, CTX_UARG, (vaddr_t)exc);
! 327:
! 328: irq_lock();
! 329: th->excbits &= ~(1 << exc);
! 330: irq_unlock();
! 331: }
! 332: out:
! 333: sched_unlock();
! 334: }
! 335:
! 336: /*
! 337: * exception_return() is called from exception handler to
! 338: * restore the original context.
! 339: */
! 340: int
! 341: exception_return(void)
! 342: {
! 343:
! 344: context_restore(&cur_thread->ctx);
! 345: return 0;
! 346: }
! 347:
! 348: void
! 349: exception_init(void)
! 350: {
! 351:
! 352: event_init(&exception_event, "exception");
! 353: }
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 / sys / kern