Consider three jobs:
Suppose that both H and L require some shared resource. If L acquires this shared resource (entering a critical section), and H subsequently requires it, H will block until L releases it (leaving its critical section). Without priority inheritance, process M could preempt process L during the critical section and delay its completion, in effect causing the lower-priority process M to indirectly preempt the high-priority process H. This is a priority inversion bug.
With priority inheritance, L will execute its critical section at H's high priority whenever H is blocked on the shared resource. As a result, M will be unable to preempt L and will be blocked. That is, the higher-priority job M must wait for the critical section of the lower priority job L to be executed, because L has inherited H's priority. When L exits its critical section, it regains its original (low) priority and awakens H (which was blocked by L). H, having high priority, preempts L and runs to completion. This enables M and L to resume in succession and run to completion without priority inversion.
"ERIKA Enterprise". Retrieved 2024-01-03. https://en.wikipedia.org/wiki/ERIKA_Enterprise ↩
"RT-mutex subsystem with PI support". Retrieved 2021-11-27. https://www.kernel.org/doc/html/v5.15/locking/rt-mutex.html ↩
"Resource-centric real-time kernel and middleware services" (PDF). p. 3. Retrieved 2024-01-01. https://apps.dtic.mil/sti/tr/pdf/ADA408745.pdf#page=7 ↩