Ceiling priority and priority inversion

[l_mathias@hotmail.com (Mathias)]

I an pretty new with Ada and wonder if someone out there can help me clarify
how the pragma Locking_Policy(Ceiling_Priority) works.

To prevent priority inversion when multiple tasks simultaneously access a
protected object you should apply the pragma
Locking_Policy(Ceiling_Priority).

As I interpret the book "Concurrency in Ada" by Burns and Wellings it works
as follows:
The effect of the pragma Locking_Policy(Ceiling_Priority) is that all tasks
accessing subroutines in a protected object execute these with the ceiling
priority. If you omit the pragma Priority in the protected object, the
compiler assigns the ceiling priority of the protected object to the highest
priority defined for the system.

Let's say for an example that the protected object is a buffer shared
between a number of tasks, among which one is a  low priority application
task and another is an interrupt handler. Using Ceiling_Priority will cause
all tasks executing within the protected object do so with interrupt
priority. Doesn't this potentially cause a kind of priority inversion? When
the application task executes within the buffer it preempts all other tasks
in the system, even interrupts.

Shouldn't it instead work like the following? If a low priority task is
executing within a protected object and a task with a higher priority tries
to gain access this object. Then the low priority task should be raised to
the priority level of the waiting task. But if there is no concurrent access
the low priority task executes with its base priority.


Thanks for any help

/Mathias Larsson