| 43,6 → 43,7 |
|---|
| |
| #include <print.h> |
| #include <proc/thread.h> |
| #include <arch/interrupt.h> |
| |
| /* Open channel that is assigned automatically to new tasks */ |
| answerbox_t *ipc_phone_0 = NULL; |
| 49,6 → 50,14 |
|---|
| |
| static slab_cache_t *ipc_call_slab; |
| |
| typedef struct { |
| SPINLOCK_DECLARE(lock); |
| answerbox_t *box; |
| } ipc_irq_t; |
| |
| static ipc_irq_t *irq_conns = NULL; |
| static int irq_conns_size; |
| |
| /* Initialize new call */ |
| static void _ipc_call_init(call_t *call) |
| { |
| 61,12 → 70,14 |
|---|
| * |
| * The call is initialized, so that the reply will be directed |
| * to TASK->answerbox |
| * |
| * @param flags Parameters for slab_alloc (ATOMIC, etc.) |
| */ |
| call_t * ipc_call_alloc(void) |
| call_t * ipc_call_alloc(int flags) |
| { |
| call_t *call; |
| |
| call = slab_alloc(ipc_call_slab, 0); |
| call = slab_alloc(ipc_call_slab, flags); |
| _ipc_call_init(call); |
| |
| return call; |
| 90,11 → 101,13 |
|---|
| void ipc_answerbox_init(answerbox_t *box) |
| { |
| spinlock_initialize(&box->lock, "ipc_box_lock"); |
| spinlock_initialize(&box->irq_lock, "ipc_box_irqlock"); |
| waitq_initialize(&box->wq); |
| list_initialize(&box->connected_phones); |
| list_initialize(&box->calls); |
| list_initialize(&box->dispatched_calls); |
| list_initialize(&box->answers); |
| list_initialize(&box->irq_notifs); |
| box->task = TASK; |
| } |
| |
| 261,7 → 274,7 |
|---|
| phone->callee = NULL; |
| spinlock_unlock(&box->lock); |
| |
| call = ipc_call_alloc(); |
| call = ipc_call_alloc(0); |
| IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP); |
| call->flags |= IPC_CALL_DISCARD_ANSWER; |
| _ipc_call(phone, box, call); |
| 301,6 → 314,7 |
|---|
| call_t * ipc_wait_for_call(answerbox_t *box, int flags) |
| { |
| call_t *request; |
| ipl_t ipl; |
| |
| restart: |
| if (flags & IPC_WAIT_NONBLOCKING) { |
| 310,7 → 324,16 |
|---|
| waitq_sleep(&box->wq); |
| |
| spinlock_lock(&box->lock); |
| if (!list_empty(&box->answers)) { |
| if (!list_empty(&box->irq_notifs)) { |
| ipl = interrupts_disable(); |
| spinlock_lock(&box->irq_lock); |
| |
| request = list_get_instance(box->answers.next, call_t, list); |
| list_remove(&request->list); |
| |
| spinlock_unlock(&box->irq_lock); |
| interrupts_restore(ipl); |
| } else if (!list_empty(&box->answers)) { |
| /* Handle asynchronous answers */ |
| request = list_get_instance(box->answers.next, call_t, list); |
| list_remove(&request->list); |
| 333,15 → 356,6 |
|---|
| return request; |
| } |
| |
| /** Initilize ipc subsystem */ |
| void ipc_init(void) |
| { |
| ipc_call_slab = slab_cache_create("ipc_call", |
| sizeof(call_t), |
| 0, |
| NULL, NULL, 0); |
| } |
| |
| /** Answer all calls from list with EHANGUP msg */ |
| static void ipc_cleanup_call_list(link_t *lst) |
| { |
| 356,6 → 370,26 |
|---|
| } |
| } |
| |
| /** Disconnect all irq's notifications |
| * |
| * TODO: It may be better to do some linked list, so that |
| * we wouldn't need to go through whole array every cleanup |
| */ |
| static void ipc_irq_cleanup(answerbox_t *box) |
| { |
| int i; |
| ipl_t ipl; |
| |
| for (i=0; i < irq_conns_size; i++) { |
| ipl = interrupts_disable(); |
| spinlock_lock(&irq_conns[i].lock); |
| if (irq_conns[i].box == box) |
| irq_conns[i].box = NULL; |
| spinlock_unlock(&irq_conns[i].lock); |
| interrupts_restore(ipl); |
| } |
| } |
| |
| /** Cleans up all IPC communication of the given task |
| * |
| * |
| 370,6 → 404,9 |
|---|
| for (i=0;i < IPC_MAX_PHONES; i++) |
| ipc_phone_hangup(&task->phones[i]); |
| |
| /* Disconnect all connected irqs */ |
| ipc_irq_cleanup(&task->answerbox); |
| |
| /* Disconnect all phones connected to our answerbox */ |
| restart_phones: |
| spinlock_lock(&task->answerbox.lock); |
| 405,3 → 442,89 |
|---|
| ipc_call_free(call); |
| } |
| } |
| |
| /** Initialize table of interrupt handlers */ |
| static void ipc_irq_make_table(int irqcount) |
| { |
| int i; |
| |
| irq_conns_size = irqcount; |
| irq_conns = malloc(irqcount * (sizeof(*irq_conns)), 0); |
| for (i=0; i < irqcount; i++) { |
| spinlock_initialize(&irq_conns[i].lock, "irq_ipc_lock"); |
| irq_conns[i].box = NULL; |
| } |
| } |
| |
| void ipc_irq_unregister(answerbox_t *box, int irq) |
| { |
| ipl_t ipl; |
| |
| ipl = interrupts_disable(); |
| spinlock_lock(&irq_conns[irq].lock); |
| if (irq_conns[irq].box == box) |
| irq_conns[irq].box = NULL; |
| |
| spinlock_unlock(&irq_conns[irq].lock); |
| interrupts_restore(ipl); |
| } |
| |
| /** Register an answerbox as a receiving end of interrupts notifications */ |
| int ipc_irq_register(answerbox_t *box, int irq) |
| { |
| ipl_t ipl; |
| |
| ASSERT(irq_conns); |
| |
| ipl = interrupts_disable(); |
| spinlock_lock(&irq_conns[irq].lock); |
| |
| if (irq_conns[irq].box) { |
| spinlock_unlock(&irq_conns[irq].lock); |
| interrupts_restore(ipl); |
| return EEXISTS; |
| } |
| irq_conns[irq].box = box; |
| spinlock_unlock(&irq_conns[irq].lock); |
| interrupts_restore(ipl); |
| |
| return 0; |
| } |
| |
| /** Notify process that an irq had happend |
| * |
| * We expect interrupts to be disabled |
| */ |
| void ipc_irq_send_notif(int irq) |
| { |
| call_t *call; |
| |
| ASSERT(irq_conns); |
| spinlock_lock(&irq_conns[irq].lock); |
| |
| if (irq_conns[irq].box) { |
| call = ipc_call_alloc(FRAME_ATOMIC); |
| call->flags |= IPC_CALL_NOTIF; |
| IPC_SET_METHOD(call->data, IPC_M_INTERRUPT); |
| IPC_SET_ARG1(call->data, irq); |
| |
| spinlock_lock(&irq_conns[irq].box->irq_lock); |
| list_append(&call->list, &irq_conns[irq].box->irq_notifs); |
| spinlock_unlock(&irq_conns[irq].box->irq_lock); |
| |
| waitq_wakeup(&irq_conns[irq].box->wq, 0); |
| } |
| |
| spinlock_unlock(&irq_conns[irq].lock); |
| } |
| |
| /** Initilize ipc subsystem */ |
| void ipc_init(void) |
| { |
| ipc_call_slab = slab_cache_create("ipc_call", |
| sizeof(call_t), |
| 0, |
| NULL, NULL, 0); |
| ipc_irq_make_table(IRQ_COUNT); |
| } |
| |