nucleus:shared irq, draft v.2
RFC PATCH 1/1 nucleus:shared irq, draft v.2
Hi everybody,
I'm presenting it one last time as a draft, so it's a right time to give all the remarks concerning design/implementation issues for all interested parties.
Any feedback is wellcome.
--
Best regards,
Dmitry Adamushko
intr.h renamed from intr-cvs.h +13 -3
@@ -26,21 +26,31 @@#define XN_ISR_CHAINED 0x1#define XN_ISR_ENABLE 0x2 +/* Creation flags. */ +#define XN_ISR_SHARED 0x1 +#if defined(__KERNEL__) || defined(__XENO_UVM__) || defined(__XENO_SIM__)struct xnintr ;typedef struct xnintr { -unsigned irq;/* !< IRQ number. */ +xnholder_t link; +#define link2intr (laddr) \ +((xnintr_t *)(((char *)laddr) - (int)(&((xnintr_t *)0)->link))) +xnisr_t isr;/* !< Interrupt service routine. */ -xniack_t iack;/* !< Interrupt acknowledge routine. */ +void *cookie;/* !< User-defined cookie value. */ unsigned long hits;/* !< Number of receipts (since attachment). */ -void *cookie;/* !< User-defined cookie value. */ +xnflags_t flags;/* !< Creation flags. */ + +unsigned irq;/* !< IRQ number. */ + +xniack_t iack;/* !< Interrupt acknowledge routine. */ }xnintr_t ;
intr.c renamed from intr-cvs.c +153 -6
206 lines not on this page · raw message
Quoted 6 lines · Dmitry Adamushko
Hi everybody,
I'm presenting it one last time as a draft, so it's a right time to give all the remarks concerning design/implementation issues for all interested parties.
Quoted 6 lines
Any feedback is wellcome.
--
Best regards,
Dmitry Adamushko
My mail client unfortunately refused to inline your patches, so I have to:
Quoted 2 lines
intr.c renamed from intr-cvs.c +0
-0
[...]
Quoted 32 lines
intr.c renamed from intr-cvs.c +25
-1@@ -204,11 +242,66 @@int xnintr_attach (xnintr_t *intr,void *cookie) { +rthal_irq_handler_t irq_handler; +unsigned irq = intr->irq; +xnshared_irq_t *shirq; +int err =0 ; +spl_t s; + intr->hits =0 ; intr->cookie = cookie; -return xnarch_hook_irq (intr->irq,&xnintr_irq_handler,intr->iack,intr); + +xnlock_get_irqsave (&nklock,s); + + irq_handler =rthal_irq_handler (&rthal_domain,irq); + +if (irq_handler) + { +xnintr_t *old; + shirq =rthal_irq_cookie (&rthal_domain,irq); + +if (irq_handler != &xnintr_irq_handler) + { + err = -EBUSY ; + goto unlock_and_exit; + } + + old =link2intr (getheadq (&shirq->handlers)); + +if (!(old->flags & intr->flags &XN_ISR_SHARED ))
intr.c line 281
Quoted 10 lines
intr.c renamed from intr-cvs.c +10
-0+ { + err = -EBUSY ; + goto unlock_and_exit; + } + +appendq (&shirq->handlers,&intr->link); + } +else + { + shirq =xnmalloc (sizeof (*shirq));
Why not allocating that piece of memory before taking the global lock? If you don't need it, you can drop it again afterward. If you need but the returned pointer is NULL, you can still check at the same place you do now. Just an idea to avoid complex functions inside the global lock for new xeno-code.
intr.c
Quoted 61 lines
intr.c renamed from intr-cvs.c +47
-1+ +if (!shirq) + { + err = -ENOMEM ; + goto unlock_and_exit; + } + +initq (&shirq->handlers); +appendq (&shirq->handlers,&intr->link); + + err =xnarch_hook_irq (irq,&xnintr_irq_handler,intr->iack,shirq); + +if (err) +xnfree (shirq); + } + +unlock_and_exit: + +xnlock_put_irqrestore (&nklock,s); +return err; } +/*! * \fn int xnintr_detach (xnintr_t *intr) * \brief Detach an interrupt object. @@ -241,7 +334,32 @@int xnintr_detach (xnintr_t *intr) { -return xnarch_release_irq (intr->irq); +unsigned irq = intr->irq; +xnshared_irq_t *shirq; +int cleanup =0 ; +int err =0 ; +spl_t s; + +xnlock_get_irqsave (&nklock,s); + + shirq =rthal_irq_cookie (&rthal_domain,irq); + +removeq (&shirq->handlers,&intr->link); + +if (!countq (&shirq->handlers)) + { + err =xnarch_release_irq (irq); + cleanup =1 ; + } + +xnlock_put_irqrestore (&nklock,s); + +xnintr_shirq_spin (shirq); + +if (cleanup) +xnfree (shirq); + +return err; }/*! @@ -350,17 +468,45 @@
I guess here starts the new IRQ handler. BTW, diff -p helps a lot when reading patches as a human being and not as a patch tool. ;)
Quoted 10 lines
intr.c renamed from intr-cvs.c +4
-2{xnsched_t *sched =xnpod_current_sched (); -xnintr_t *intr = (xnintr_t *)cookie; -int s; +xnshared_irq_t *shirq = (xnshared_irq_t *)cookie; +xnholder_t holder; +spl_t flags; +int s =0 ;
intr.c line 485
Quoted 10 lines
intr.c renamed from intr-cvs.c +6
-0xnarch_memory_barrier ();xnltt_log_event (xeno_ev_ienter,irq); +xnlock_get_irqsave (&nklock,flags); + + shirq =rthal_irq_cookie (&rthal_domain,irq); +xnintr_shirq_lock (shirq); + +xnlock_put_irqrestore (&nklock,flags);
Why "_irqsave" in IRQ context?
Regarding this locking isssue in general, I first had some RCU-mechanism in mind to avoid the reader-side lock in the IRQ handler. But as IRQs typically touch some nucleus service with its own nklock-acquire anyway, optimising this here does not seem to be worth the effort now. As long as we have the global lock, it's ok and much simpler I think.
Quoted 19 lines
intr.c renamed from intr-cvs.c +17
-1+ +if (!shirq) + { +xnintr_shirq_unlock (shirq); +xnltt_log_event (xeno_ev_iexit,irq); +return ; + } + ++sched->inesting; - s = intr->isr (intr); + + holder =getheadq (&shirq->handlers); + +while (holder) + { +xnintr_t *intr =link2intr (holder); + holder =nextq (&shirq->handlers,holder); + + s |= intr->isr (intr);
intr.c line 512
Quoted 10 lines
intr.c renamed from intr-cvs.c +5
-1+ ++intr->hits; + } + +xnintr_shirq_unlock (shirq); + --sched->inesting; - ++intr->hits;if (s &XN_ISR_ENABLE )xnarch_enable_irq (irq);
Looking forward to see this in Xenomai - at letting some real tests run with it. :)
Jan
Quoted 46 lines · Jan Kiszka
My mail client unfortunately refused to inline your patches, so I have to:
Quoted 2 lines
intr.c renamed from intr-cvs.c +0
-0[...]
intr.c line 209
Quoted 13 lines
intr.c renamed from intr-cvs.c +6
-1@@ -204,11 +242,66 @@int xnintr_attach (xnintr_t *intr,void *cookie) { +rthal_irq_handler_t irq_handler; +unsigned irq = intr->irq; +xnshared_irq_t *shirq; +int err =0 ; +spl_t s; + intr->hits =0 ; intr->cookie = cookie; -return
xnarch_hook_irq(intr->irq,&xnintr_irq_handler,intr->iack,intr);Quoted 27 lines
intr.c renamed from intr-cvs.c +27
-0+ +xnlock_get_irqsave (&nklock,s); + + irq_handler =rthal_irq_handler (&rthal_domain,irq); + +if (irq_handler) + { +xnintr_t *old; + shirq =rthal_irq_cookie (&rthal_domain,irq); + +if (irq_handler != &xnintr_irq_handler) + { + err = -EBUSY ; + goto unlock_and_exit; + } + + old =link2intr (getheadq (&shirq->handlers)); + +if (!(old->flags & intr->flags &XN_ISR_SHARED )) + { + err = -EBUSY ; + goto unlock_and_exit; + } + +appendq (&shirq->handlers,&intr->link); + } +else
Quoted 8 lines
intr.c line 281
Quoted 2 lines
intr.c renamed from intr-cvs.c +2
-0+ { + shirq =xnmalloc (sizeof (*shirq));Why not allocating that piece of memory before taking the global lock? If you don't need it, you can drop it again afterward. If you need but the returned pointer is NULL, you can still check at the same place you do now. Just an idea to avoid complex functions inside the global lock for new xeno-code.
Ack. I thought about that actually.
Quoted 89 lines
intr.c
Quoted 62 lines
intr.c renamed from intr-cvs.c +47
-1+ +if (!shirq) + { + err = -ENOMEM ; + goto unlock_and_exit; + } + +initq (&shirq->handlers); +appendq (&shirq->handlers,&intr->link); + + err =xnarch_hook_irq (irq,&xnintr_irq_handler,intr->iack,shirq); + +if (err) +xnfree (shirq); + } + +unlock_and_exit: + +xnlock_put_irqrestore (&nklock,s); +return err; } +/*! * \fn int xnintr_detach (xnintr_t *intr) * \brief Detach an interrupt object. @@ -241,7 +334,32 @@int xnintr_detach (xnintr_t *intr) { -return xnarch_release_irq (intr->irq); +unsigned irq = intr->irq; +xnshared_irq_t *shirq; +int cleanup =0 ; +int err =0 ; +spl_t s; + +xnlock_get_irqsave (&nklock,s); + + shirq =rthal_irq_cookie (&rthal_domain,irq); + +removeq (&shirq->handlers,&intr->link); + +if (!countq (&shirq->handlers)) + { + err =xnarch_release_irq (irq); + cleanup =1 ; + } + +xnlock_put_irqrestore (&nklock,s); + +xnintr_shirq_spin (shirq); + +if (cleanup) +xnfree (shirq); + +return err; }/*! @@ -350,17 +468,45 @@I guess here starts the new IRQ handler. BTW, diff -p helps a lot when reading patches as a human being and not as a patch tool. ;)
Quoted 10 lines
intr.c renamed from intr-cvs.c +4
-2{xnsched_t *sched =xnpod_current_sched (); -xnintr_t *intr = (xnintr_t *)cookie; -int s; +xnshared_irq_t *shirq = (xnshared_irq_t *)cookie; +xnholder_t holder; +spl_t flags; +int s =0 ;intr.c line 485
Quoted 10 lines
intr.c renamed from intr-cvs.c +6
-0xnarch_memory_barrier ();xnltt_log_event (xeno_ev_ienter,irq); +xnlock_get_irqsave (&nklock,flags); + + shirq =rthal_irq_cookie (&rthal_domain,irq); +xnintr_shirq_lock (shirq); + +xnlock_put_irqrestore (&nklock,flags);Why "
_irqsave" in IRQ context?
Quoted 5 lines
Regarding this locking isssue in general, I first had some RCU-mechanism in mind to avoid the reader-side lock in the IRQ handler. But as IRQs typically touch some nucleus service with its own nklock-acquire anyway, optimising this here does not seem to be worth the effort now. As long as we have the global lock, it's ok and much simpler I think.
As Gilles has pointed out, nklock is dangerous here so let's forget about it so far.
Actually, the way the shirq->handlers list is used remains some kind of RCU, I guess.
Look, xnintr_irq_handler() doesn't hold the lock while iterating through the list.
That's why xnintr_shirq_spin() is there, I tried to explain the idea in my previous answer to the Gilles's letter.
Actually, I still have some doubts regarding this way, in particular, whether everything is ok with atomicity.
I don't have my computer at hand and it seems I am occuping the comp of my friend at the moment :) I'll post other details later if need be.
Quoted 28 lines
Quoted 28 lines
intr.c renamed from intr-cvs.c +22
-2+ +if (!shirq) + { +xnintr_shirq_unlock (shirq); +xnltt_log_event (xeno_ev_iexit,irq); +return ; + } + ++sched->inesting; - s = intr->isr (intr); + + holder =getheadq (&shirq->handlers); + +while (holder) + { +xnintr_t *intr =link2intr (holder); + holder =nextq (&shirq->handlers,holder); + + s |= intr->isr (intr); + ++intr->hits; + } + +xnintr_shirq_unlock (shirq); + --sched->inesting; - ++intr->hits;
Quoted 5 lines
intr.c line 512
Quoted 2 lines
intr.c renamed from intr-cvs.c +0
-0if (s &XN_ISR_ENABLE )xnarch_enable_irq (irq);Looking forward to see this in Xenomai - at letting some real tests run with it. :)
So am I. Heh.. :)
Quoted 4 lines
Jan
--
Best regards,
Dmitry Adamushko
A message that is not in the archive (sent off-list or not yet received): [email protected]
Quoted 22 lines · Gilles Chanteperdrix
Quoted 3 lines · Dmitry Adamushko
Hi everybody,
I'm presenting it one last time as a draft, so it's a right time to give
all
Quoted 4 lines
the remarks concerning design/implementation issues for all interested parties.
Any feedback is wellcome.
Maybe I missed some recent changes in Xenomai HAL or Adeos, in which case, please forget my remark, but calling
xnarch_hook_irq, i.e.rthal_irq_requestwhen nklock is locked, irq off, may lead to deadlock on multi-processor machines. The situation is (or used to be) as follows:CPU1
holds the nklock
callsrthal_irq_request, which callsipipe_critical_enter, which:
triggers the critical IPI
spins, waiting for other CPUs to enter__ipipe_do_critical_sync
Quoted 4 lines
CPU2
spins on nklock, irq off
never handles the critical IPI, because irqs are off
Nop, your remark is actually right to the place. I had some doubts regarding the use of nklock here but, flankly, I didn't even consider that possible deadlock. Thanks for a hint.
Quoted 4 lines
I only skimmed over the discussion about
ipipe_virtualize_irq_from. I do not know if it finally flushes all pending interrupts an all CPUs when called with a NULL handler. But if it does, the call toxnintr_shirq_spinseems redundant inxnintr_detach.
Well, the problem is that the shirq->handlers list, i.e. the shirq object itself may be in use
at the moment when xnintr_detach() is called. That said, the shirq object as well as all the elements of shirq->handlers (those that have been removed by xnintr_detach() from the list) must remain valid as long as there is a isr handler for the given irq running (i.e. xnintr_irq_handler() ).
To sum it up:
xnintr_shirq_spin() is for:
o "shirq" must be deleted only when the xnintr_irq_handler() for the given irq has completed;
o even if there is no need to delete the "shirq" object (there are other intr objects in the list) the xnintr_detach() must wait until the handler gets completed, thas keeping intr->link valid.
Ok, maybe my explanation is a bit confusing but the direct analogy is the way used in Linux, namely the synchroize_irq() call (take a look at how it's used in free_irq()).
This is a kind of RCU. The element is removed from the list but it's completely freed only when all the read clients are completed (in our case, xnintr_irq_handler() and handle_IRQ_events() in Linux).
Quoted 6 lines
--
Gilles Chanteperdrix.
--
Best regards,
Dmitry Adamushko
Quoted 23 lines · Gilles Chanteperdrix
Quoted 3 lines · Dmitry Adamushko
Hi everybody,
I'm presenting it one last time as a draft, so it's a right time to give
all
Quoted 4 lines
the remarks concerning design/implementation issues for all interested parties.
Any feedback is wellcome.
Maybe I missed some recent changes in Xenomai HAL or Adeos, in which case, please forget my remark, but calling
xnarch_hook_irq, i.e.rthal_irq_requestwhen nklock is locked, irq off, may lead to deadlock on multi-processor machines. The situation is (or used to be) as follows:CPU1
holds the nklock
callsrthal_irq_request, which callsipipe_critical_enter, which:
triggers the critical IPI
spins, waiting for other CPUs to enter__ipipe_do_critical_sync
Quoted 3 lines
CPU2
spins on nklock, irq off
never handles the critical IPI, because irqs are off
So this a generic "problem" here with spinning on _any_ lock when irqs are off. And we can't use just a irq_save/restore -less counterparts (even if we would have those) since there is a need to be synchronized wrt the irq-handler.
Ok, maybe there is another way rather than the nklock (or any other lock) or the lock can be used in a different way to avoid deadlock.
I only skimmed over the discussion about ipipe_virtualize_irq_from. I do
Quoted 9 lines
not know if it finally flushes all pending interrupts an all CPUs when called with a NULL handler. But if it does, the call to
xnintr_shirq_spinseems redundant inxnintr_detach.--
Gilles Chanteperdrix.
--
Best regards,
Dmitry Adamushko