Getting Started with QNX Neutrino - QNX Software Systems

Writing interrupt handlers
© 2009, QNX Software Systems GmbH & Co. KG.
InterruptAttach() to minimize this interrupt latency. This is because the kernel is
very fast at dispatching the ISR.
• Buffering — if your hardware has buffering in it, you may be able to get away with
InterruptAttachEvent() and a single-entry queueing mechanism like SIGEV_INTR
and InterruptWait(). This method lets the hardware interrupt as often as it wants,
while letting your thread pick the values out of the hardware’s buffer when it can.
Since the hardware is buffering the data, there’s no problem with interrupt
latencies.
ISR functions
The next issue we should tackle is the list of functions an ISR is allowed to call.
Let me digress just a little at this point. Historically, the reason that ISRs were so
difficult to write (and still are in most other operating systems) is that the ISR runs in a
special environment.
One particular thing that complicates writing ISRs is that the ISR isn’t actually a
“proper” thread as far as the kernel is concerned. It’s this weird “hardware” thread, if
you want to call it that. This means that the ISR isn’t allowed to do any “thread-level”
things, like messaging, synchronization, kernel calls, disk I/O, etc.
But doesn’t that make it much harder to write ISR routines? Yes it does. The solution,
therefore, is to do as little work as possible in the ISR, and do the rest of the work at
thread-level, where you have access to all the services.
Your goals in the ISR should be:
• Fetch information that is transitory.
• Clear the source of the ISR.
• Optionally dispatch a thread to get the “real” work done.
This “architecture” hinges on the fact that Neutrino has very fast context-switch times.
You know that you can get into your ISR quickly to do the time-critical work. You
also know that when the ISR returns an event to trigger thread-level work, that thread
will start quickly as well. It’s this “don’t do anything in the ISR” philosophy that
makes Neutrino ISRs so simple!
So, what calls can you use in the ISR? Here’s a summary (for the official list, see the
Summary of Safety Information appendix in the Neutrino Library Reference):
• atomic_*() functions (such as atomic_set())
• mem*() functions (such as memcpy())
• most str*() functions (such as strcmp()). Beware, though, that not all these are safe,
such as strdup() — it calls malloc(), which uses a mutex, and that’s not allowed.
For the string functions, you should really consult the individual entries in the
Neutrino Library Reference before using.
186 Chapter 4 • Interrupts April 30, 2009