source: mainline/kernel/generic/src/ipc/irq.c@ 9306cd7

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 9306cd7 was 9306cd7, checked in by Jakub Jermar <jakub@…>, 8 years ago

Make IRQ subscribe/unsubscribe thread safe again
  • Property mode set to 100644
File size: 15.5 KB
Line 
1/*
2 * Copyright (c) 2006 Ondrej Palkovsky
3 * Copyright (c) 2006 Jakub Jermar
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup genericipc
31 * @{
32 */
33
34/**
35 * @file
36 * @brief IRQ notification framework.
37 *
38 * This framework allows applications to subscribe to receive a notification
39 * when interrupt is detected. The application may provide a simple 'top-half'
40 * handler as part of its registration, which can perform simple operations
41 * (read/write port/memory, add information to notification IPC message).
42 *
43 * The structure of a notification message is as follows:
44 * - IMETHOD: interface and method as set by the SYS_IPC_IRQ_SUBSCRIBE syscall
45 * - ARG1: payload modified by a 'top-half' handler (scratch[1])
46 * - ARG2: payload modified by a 'top-half' handler (scratch[2])
47 * - ARG3: payload modified by a 'top-half' handler (scratch[3])
48 * - ARG4: payload modified by a 'top-half' handler (scratch[4])
49 * - ARG5: payload modified by a 'top-half' handler (scratch[5])
50 * - in_phone_hash: interrupt counter (may be needed to assure correct order
51 * in multithreaded drivers)
52 *
53 * Note on synchronization for ipc_irq_subscribe(), ipc_irq_unsubscribe(),
54 * ipc_irq_cleanup() and IRQ handlers:
55 *
56 * By always taking all of the uspace IRQ hash table lock, IRQ structure lock
57 * and answerbox lock, we can rule out race conditions between the
58 * registration functions and also the cleanup function. Thus the observer can
59 * either see the IRQ structure present in both the hash table and the
60 * answerbox list or absent in both. Views in which the IRQ structure would be
61 * linked in the hash table but not in the answerbox list, or vice versa, are
62 * not possible.
63 *
64 * By always taking the hash table lock and the IRQ structure lock, we can
65 * rule out a scenario in which we would free up an IRQ structure, which is
66 * still referenced by, for example, an IRQ handler. The locking scheme forces
67 * us to lock the IRQ structure only after any progressing IRQs on that
68 * structure are finished. Because we hold the hash table lock, we prevent new
69 * IRQs from taking new references to the IRQ structure.
70 *
71 */
72
73#include <arch.h>
74#include <assert.h>
75#include <mm/slab.h>
76#include <mm/page.h>
77#include <mm/km.h>
78#include <errno.h>
79#include <ddi/irq.h>
80#include <ipc/ipc.h>
81#include <ipc/irq.h>
82#include <syscall/copy.h>
83#include <console/console.h>
84#include <print.h>
85#include <macros.h>
86#include <cap/cap.h>
87
88static void ranges_unmap(irq_pio_range_t *ranges, size_t rangecount)
89{
90 for (size_t i = 0; i < rangecount; i++) {
91#ifdef IO_SPACE_BOUNDARY
92 if ((void *) ranges[i].base >= IO_SPACE_BOUNDARY)
93#endif
94 km_unmap(ranges[i].base, ranges[i].size);
95 }
96}
97
98static int ranges_map_and_apply(irq_pio_range_t *ranges, size_t rangecount,
99 irq_cmd_t *cmds, size_t cmdcount)
100{
101 /* Copy the physical base addresses aside. */
102 uintptr_t *pbase = malloc(rangecount * sizeof(uintptr_t), 0);
103 for (size_t i = 0; i < rangecount; i++)
104 pbase[i] = ranges[i].base;
105
106 /* Map the PIO ranges into the kernel virtual address space. */
107 for (size_t i = 0; i < rangecount; i++) {
108#ifdef IO_SPACE_BOUNDARY
109 if ((void *) ranges[i].base < IO_SPACE_BOUNDARY)
110 continue;
111#endif
112 ranges[i].base = km_map(pbase[i], ranges[i].size,
113 PAGE_READ | PAGE_WRITE | PAGE_KERNEL | PAGE_NOT_CACHEABLE);
114 if (!ranges[i].base) {
115 ranges_unmap(ranges, i);
116 free(pbase);
117 return ENOMEM;
118 }
119 }
120
121 /* Rewrite the pseudocode addresses from physical to kernel virtual. */
122 for (size_t i = 0; i < cmdcount; i++) {
123 uintptr_t addr;
124 size_t size;
125
126 /* Process only commands that use an address. */
127 switch (cmds[i].cmd) {
128 case CMD_PIO_READ_8:
129 case CMD_PIO_WRITE_8:
130 case CMD_PIO_WRITE_A_8:
131 size = 1;
132 break;
133 case CMD_PIO_READ_16:
134 case CMD_PIO_WRITE_16:
135 case CMD_PIO_WRITE_A_16:
136 size = 2;
137 break;
138 case CMD_PIO_READ_32:
139 case CMD_PIO_WRITE_32:
140 case CMD_PIO_WRITE_A_32:
141 size = 4;
142 break;
143 default:
144 /* Move onto the next command. */
145 continue;
146 }
147
148 addr = (uintptr_t) cmds[i].addr;
149
150 size_t j;
151 for (j = 0; j < rangecount; j++) {
152 /* Find the matching range. */
153 if (!iswithin(pbase[j], ranges[j].size, addr, size))
154 continue;
155
156 /* Switch the command to a kernel virtual address. */
157 addr -= pbase[j];
158 addr += ranges[j].base;
159
160 cmds[i].addr = (void *) addr;
161 break;
162 }
163
164 if (j == rangecount) {
165 /*
166 * The address used in this command is outside of all
167 * defined ranges.
168 */
169 ranges_unmap(ranges, rangecount);
170 free(pbase);
171 return EINVAL;
172 }
173 }
174
175 free(pbase);
176 return EOK;
177}
178
179/** Statically check the top-half pseudocode
180 *
181 * Check the top-half pseudocode for invalid or unsafe
182 * constructs.
183 *
184 */
185static int code_check(irq_cmd_t *cmds, size_t cmdcount)
186{
187 for (size_t i = 0; i < cmdcount; i++) {
188 /*
189 * Check for accepted ranges.
190 */
191 if (cmds[i].cmd >= CMD_LAST)
192 return EINVAL;
193
194 if (cmds[i].srcarg >= IPC_CALL_LEN)
195 return EINVAL;
196
197 if (cmds[i].dstarg >= IPC_CALL_LEN)
198 return EINVAL;
199
200 switch (cmds[i].cmd) {
201 case CMD_PREDICATE:
202 /*
203 * Check for control flow overflow.
204 * Note that jumping just beyond the last
205 * command is a correct behaviour.
206 */
207 if (i + cmds[i].value > cmdcount)
208 return EINVAL;
209
210 break;
211 default:
212 break;
213 }
214 }
215
216 return EOK;
217}
218
219/** Free the top-half pseudocode.
220 *
221 * @param code Pointer to the top-half pseudocode.
222 *
223 */
224static void code_free(irq_code_t *code)
225{
226 if (code) {
227 ranges_unmap(code->ranges, code->rangecount);
228 free(code->ranges);
229 free(code->cmds);
230 free(code);
231 }
232}
233
234/** Copy the top-half pseudocode from userspace into the kernel.
235 *
236 * @param ucode Userspace address of the top-half pseudocode.
237 *
238 * @return Kernel address of the copied pseudocode.
239 *
240 */
241static irq_code_t *code_from_uspace(irq_code_t *ucode)
242{
243 irq_pio_range_t *ranges = NULL;
244 irq_cmd_t *cmds = NULL;
245
246 irq_code_t *code = malloc(sizeof(*code), 0);
247 int rc = copy_from_uspace(code, ucode, sizeof(*code));
248 if (rc != EOK)
249 goto error;
250
251 if ((code->rangecount > IRQ_MAX_RANGE_COUNT) ||
252 (code->cmdcount > IRQ_MAX_PROG_SIZE))
253 goto error;
254
255 ranges = malloc(sizeof(code->ranges[0]) * code->rangecount, 0);
256 rc = copy_from_uspace(ranges, code->ranges,
257 sizeof(code->ranges[0]) * code->rangecount);
258 if (rc != EOK)
259 goto error;
260
261 cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
262 rc = copy_from_uspace(cmds, code->cmds,
263 sizeof(code->cmds[0]) * code->cmdcount);
264 if (rc != EOK)
265 goto error;
266
267 rc = code_check(cmds, code->cmdcount);
268 if (rc != EOK)
269 goto error;
270
271 rc = ranges_map_and_apply(ranges, code->rangecount, cmds,
272 code->cmdcount);
273 if (rc != EOK)
274 goto error;
275
276 code->ranges = ranges;
277 code->cmds = cmds;
278
279 return code;
280
281error:
282 if (cmds)
283 free(cmds);
284
285 if (ranges)
286 free(ranges);
287
288 free(code);
289 return NULL;
290}
291
292/** Subscribe an answerbox as a receiving end for IRQ notifications.
293 *
294 * @param box Receiving answerbox.
295 * @param inr IRQ number.
296 * @param imethod Interface and method to be associated with the
297 * notification.
298 * @param ucode Uspace pointer to top-half pseudocode.
299 *
300 * @return IRQ capability handle.
301 * @return Negative error code.
302 *
303 */
304int ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
305 irq_code_t *ucode)
306{
307 sysarg_t key[] = {
308 [IRQ_HT_KEY_INR] = (sysarg_t) inr,
309 [IRQ_HT_KEY_MODE] = (sysarg_t) IRQ_HT_MODE_NO_CLAIM
310 };
311
312 if ((inr < 0) || (inr > last_inr))
313 return ELIMIT;
314
315 irq_code_t *code;
316 if (ucode) {
317 code = code_from_uspace(ucode);
318 if (!code)
319 return EBADMEM;
320 } else
321 code = NULL;
322
323 /*
324 * Allocate and populate the IRQ kernel object.
325 */
326 int handle = cap_alloc(TASK);
327 if (handle < 0)
328 return handle;
329 cap_t *cap = cap_get_current(handle, CAP_TYPE_ALLOCATED);
330 assert(cap);
331
332 irq_t *irq = &cap->irq;
333 irq_initialize(irq);
334 irq->inr = inr;
335 irq->claim = ipc_irq_top_half_claim;
336 irq->handler = ipc_irq_top_half_handler;
337 irq->notif_cfg.notify = true;
338 irq->notif_cfg.answerbox = box;
339 irq->notif_cfg.imethod = imethod;
340 irq->notif_cfg.code = code;
341 irq->notif_cfg.counter = 0;
342
343 /*
344 * Enlist the IRQ structure in the uspace IRQ hash table and the
345 * answerbox's list and make the IRQ capability valid.
346 */
347 irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
348 irq_spinlock_lock(&irq->lock, false);
349 irq_spinlock_lock(&box->irq_lock, false);
350
351 cap->type = CAP_TYPE_IRQ;
352 hash_table_insert(&irq_uspace_hash_table, key, &irq->link);
353 list_append(&irq->notif_cfg.link, &box->irq_list);
354
355 irq_spinlock_unlock(&box->irq_lock, false);
356 irq_spinlock_unlock(&irq->lock, false);
357 irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
358
359 return handle;
360}
361
362/** Unsubscribe task from IRQ notification.
363 *
364 * @param box Answerbox associated with the notification.
365 * @param handle IRQ capability handle.
366 *
367 * @return EOK on success or a negative error code.
368 *
369 */
370int ipc_irq_unsubscribe(answerbox_t *box, int handle)
371{
372 irq_spinlock_lock(&TASK->lock, true);
373 cap_t *cap = cap_get_current(handle, CAP_TYPE_IRQ);
374 if (!cap) {
375 irq_spinlock_unlock(&TASK->lock, true);
376 return ENOENT;
377 }
378 cap->type = CAP_TYPE_ALLOCATED;
379 irq_spinlock_unlock(&TASK->lock, true);
380
381 irq_t *irq = &cap->irq;
382
383 irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
384 irq_spinlock_lock(&irq->lock, false);
385 irq_spinlock_lock(&box->irq_lock, false);
386
387 assert(irq->notif_cfg.answerbox == box);
388
389 /* Remove the IRQ from the answerbox's list. */
390 list_remove(&irq->notif_cfg.link);
391
392 /* Remove the IRQ from the uspace IRQ hash table. */
393 hash_table_remove_item(&irq_uspace_hash_table, &irq->link);
394
395 irq_spinlock_unlock(&box->irq_lock, false);
396 /* irq->lock unlocked by the hash table remove_callback */
397 irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
398
399 /* Free up the pseudo code and associated structures. */
400 code_free(irq->notif_cfg.code);
401
402 /* Free up the IRQ capability and the underlying kernel object. */
403 cap_free(TASK, handle);
404
405 return EOK;
406}
407
408/** Add a call to the proper answerbox queue.
409 *
410 * Assume irq->lock is locked and interrupts disabled.
411 *
412 * @param irq IRQ structure referencing the target answerbox.
413 * @param call IRQ notification call.
414 *
415 */
416static void send_call(irq_t *irq, call_t *call)
417{
418 irq_spinlock_lock(&irq->notif_cfg.answerbox->irq_lock, false);
419 list_append(&call->ab_link, &irq->notif_cfg.answerbox->irq_notifs);
420 irq_spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock, false);
421
422 waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST);
423}
424
425/** Apply the top-half pseudo code to find out whether to accept the IRQ or not.
426 *
427 * @param irq IRQ structure.
428 *
429 * @return IRQ_ACCEPT if the interrupt is accepted by the
430 * pseudocode, IRQ_DECLINE otherwise.
431 *
432 */
433irq_ownership_t ipc_irq_top_half_claim(irq_t *irq)
434{
435 irq_code_t *code = irq->notif_cfg.code;
436 uint32_t *scratch = irq->notif_cfg.scratch;
437
438 if (!irq->notif_cfg.notify)
439 return IRQ_DECLINE;
440
441 if (!code)
442 return IRQ_DECLINE;
443
444 for (size_t i = 0; i < code->cmdcount; i++) {
445 uintptr_t srcarg = code->cmds[i].srcarg;
446 uintptr_t dstarg = code->cmds[i].dstarg;
447
448 switch (code->cmds[i].cmd) {
449 case CMD_PIO_READ_8:
450 scratch[dstarg] =
451 pio_read_8((ioport8_t *) code->cmds[i].addr);
452 break;
453 case CMD_PIO_READ_16:
454 scratch[dstarg] =
455 pio_read_16((ioport16_t *) code->cmds[i].addr);
456 break;
457 case CMD_PIO_READ_32:
458 scratch[dstarg] =
459 pio_read_32((ioport32_t *) code->cmds[i].addr);
460 break;
461 case CMD_PIO_WRITE_8:
462 pio_write_8((ioport8_t *) code->cmds[i].addr,
463 (uint8_t) code->cmds[i].value);
464 break;
465 case CMD_PIO_WRITE_16:
466 pio_write_16((ioport16_t *) code->cmds[i].addr,
467 (uint16_t) code->cmds[i].value);
468 break;
469 case CMD_PIO_WRITE_32:
470 pio_write_32((ioport32_t *) code->cmds[i].addr,
471 (uint32_t) code->cmds[i].value);
472 break;
473 case CMD_PIO_WRITE_A_8:
474 pio_write_8((ioport8_t *) code->cmds[i].addr,
475 (uint8_t) scratch[srcarg]);
476 break;
477 case CMD_PIO_WRITE_A_16:
478 pio_write_16((ioport16_t *) code->cmds[i].addr,
479 (uint16_t) scratch[srcarg]);
480 break;
481 case CMD_PIO_WRITE_A_32:
482 pio_write_32((ioport32_t *) code->cmds[i].addr,
483 (uint32_t) scratch[srcarg]);
484 break;
485 case CMD_LOAD:
486 scratch[dstarg] = code->cmds[i].value;
487 break;
488 case CMD_AND:
489 scratch[dstarg] = scratch[srcarg] &
490 code->cmds[i].value;
491 break;
492 case CMD_PREDICATE:
493 if (scratch[srcarg] == 0)
494 i += code->cmds[i].value;
495
496 break;
497 case CMD_ACCEPT:
498 return IRQ_ACCEPT;
499 case CMD_DECLINE:
500 default:
501 return IRQ_DECLINE;
502 }
503 }
504
505 return IRQ_DECLINE;
506}
507
508/* IRQ top-half handler.
509 *
510 * We expect interrupts to be disabled and the irq->lock already held.
511 *
512 * @param irq IRQ structure.
513 *
514 */
515void ipc_irq_top_half_handler(irq_t *irq)
516{
517 assert(irq);
518
519 assert(interrupts_disabled());
520 assert(irq_spinlock_locked(&irq->lock));
521
522 if (irq->notif_cfg.answerbox) {
523 call_t *call = ipc_call_alloc(FRAME_ATOMIC);
524 if (!call)
525 return;
526
527 call->flags |= IPC_CALL_NOTIF;
528 /* Put a counter to the message */
529 call->priv = ++irq->notif_cfg.counter;
530
531 /* Set up args */
532 IPC_SET_IMETHOD(call->data, irq->notif_cfg.imethod);
533 IPC_SET_ARG1(call->data, irq->notif_cfg.scratch[1]);
534 IPC_SET_ARG2(call->data, irq->notif_cfg.scratch[2]);
535 IPC_SET_ARG3(call->data, irq->notif_cfg.scratch[3]);
536 IPC_SET_ARG4(call->data, irq->notif_cfg.scratch[4]);
537 IPC_SET_ARG5(call->data, irq->notif_cfg.scratch[5]);
538
539 send_call(irq, call);
540 }
541}
542
543/** Send notification message.
544 *
545 * @param irq IRQ structure.
546 * @param a1 Driver-specific payload argument.
547 * @param a2 Driver-specific payload argument.
548 * @param a3 Driver-specific payload argument.
549 * @param a4 Driver-specific payload argument.
550 * @param a5 Driver-specific payload argument.
551 *
552 */
553void ipc_irq_send_msg(irq_t *irq, sysarg_t a1, sysarg_t a2, sysarg_t a3,
554 sysarg_t a4, sysarg_t a5)
555{
556 irq_spinlock_lock(&irq->lock, true);
557
558 if (irq->notif_cfg.answerbox) {
559 call_t *call = ipc_call_alloc(FRAME_ATOMIC);
560 if (!call) {
561 irq_spinlock_unlock(&irq->lock, true);
562 return;
563 }
564
565 call->flags |= IPC_CALL_NOTIF;
566 /* Put a counter to the message */
567 call->priv = ++irq->notif_cfg.counter;
568
569 IPC_SET_IMETHOD(call->data, irq->notif_cfg.imethod);
570 IPC_SET_ARG1(call->data, a1);
571 IPC_SET_ARG2(call->data, a2);
572 IPC_SET_ARG3(call->data, a3);
573 IPC_SET_ARG4(call->data, a4);
574 IPC_SET_ARG5(call->data, a5);
575
576 send_call(irq, call);
577 }
578
579 irq_spinlock_unlock(&irq->lock, true);
580}
581
582/** @}
583 */
Note: See TracBrowser for help on using the repository browser.