Added CONFIG_REALTIME_AUX_TASKS option

Auxillary task features were enabled by CONFIG_LITMUS_LOCKING.
Made auxillary tasks a seperate feature that depends upon
CONFIG_LITMUS_LOCKING.

1 files changed, 31 insertions, 0 deletions

diff --git a/litmus/Kconfig b/litmus/Kconfig
index 95e0671e2aec..c5dbc4a176ae 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -34,6 +34,37 @@ config RELEASE_MASTER
            (http://www.cs.unc.edu/~anderson/papers.html).
            Currently only supported by GSN-EDF.
 
+config REALTIME_AUX_TASKS
+        bool "Real-Time Auxillary Tasks"
+        depends on LITMUS_LOCKING
+        default n
+        help
+                Adds a system call that forces all non-real-time threads in a process
+                to become auxillary real-time tasks. These tasks inherit the priority of
+                the highest-prio *BLOCKED* real-time task (non-auxillary) in the process.
+                This allows the integration of COTS code that has background helper threads
+                used primarily for message passing and synchronization. If these
+                background threads are NOT real-time scheduled, then unbounded priority
+                inversions may occur if a real-time task blocks on a non-real-time thread.
+
+                Beware of the following pitfalls:
+                  1) Auxillary threads should not be CPU intensive. They should mostly
+                     block on mutexes and condition variables. Violating this will
+                         likely prevent meaningful analysis.
+                  2) Since there may be more than one auxillary thread per process,
+                     priority inversions may occur with respect to single-threaded
+                         task models if/when one of threads are scheduled simultanously
+                         with another of the same identity.
+                  3) Busy-wait deadlock is likely between normal real-time tasks and
+                     auxillary tasks synchronize using _preemptive_ spinlocks that do
+                         not use priority inheritance.
+
+                These pitfalls are mitgated by the fact that auxillary tasks only
+                inherit priorities from blocked tasks (Blocking signifies that the
+                blocked task _may_ be waiting on an auxillary task to perform some
+                work.). Futher, auxillary tasks without an inherited priority are
+                _always_ scheduled with a priority less than any normal real-time task!!
+
 endmenu
 
 menu "Real-Time Synchronization"