Cleanup budget tracking in wait_for_release.

Also added logic for real-time tasks to prevent
worker threads (klmirqd and aux tasks) from inheriting
from tasks waiting for release.

1 files changed, 31 insertions, 7 deletions

diff --git a/litmus/sync.c b/litmus/sync.c
index 749ae62c2b87..dfd9e40ab28d 100644
--- a/litmus/sync.c
+++ b/litmus/sync.c
@@ -15,6 +15,7 @@
 #include <litmus/jobs.h>
 
 #include <litmus/sched_trace.h>
+#include <litmus/budget.h>
 
 struct ts_release_wait {
         struct list_head list;
@@ -39,6 +40,13 @@ static long do_wait_for_ts_release(struct timespec *wake)
 
         long ret = -ERESTARTSYS;
 
+        struct task_struct *t = current;
+        int is_rt = is_realtime(t);
+
+#if defined(CONFIG_REALTIME_AUX_TASKS) || defined(CONFIG_LITMUS_NVIDIA)
+        DECLARE_WORKER_VIS_FLAGS(vis_flags);
+#endif
+
         if (mutex_lock_interruptible(&task_release_lock))
                 goto out;
 
@@ -46,29 +54,45 @@ static long do_wait_for_ts_release(struct timespec *wake)
 
         mutex_unlock(&task_release_lock);
 
+        if (is_rt) {
+#if defined(CONFIG_REALTIME_AUX_TASKS) || defined(CONFIG_LITMUS_NVIDIA)
+                hide_from_workers(t, &vis_flags);
+#endif
+                bt_flag_set(t, BTF_WAITING_FOR_RELEASE);
+                mb();
+        }
+
         /* We are enqueued, now we wait for someone to wake us up. */
         ret = wait_for_completion_interruptible(&wait.completion);
 
+        if (is_rt) {
+                bt_flag_clear(t, BTF_WAITING_FOR_RELEASE);
+#if defined(CONFIG_REALTIME_AUX_TASKS) || defined(CONFIG_LITMUS_NVIDIA)
+                show_to_workers(t, &vis_flags);
+#endif
+        }
+
         if (!ret) {
-                if (is_realtime(current)) {
+                if (is_rt) {
                         lt_t phasedRelease = wait.ts_release_time
-                                        + current->rt_param.task_params.phase;
+                                        + t->rt_param.task_params.phase;
                         *wake = ns_to_timespec(phasedRelease);
 
                         /* Setting this flag before releasing ensures that this CPU
                          * will be the next CPU to requeue the task on a ready or
                          * release queue.
                          */
-                        tsk_rt(current)->completed = 1;
-                        tsk_rt(current)->job_params.backlog = 0;
-                        bt_flags_reset(current);
+                        tsk_rt(t)->completed = 1;
+                        tsk_rt(t)->job_params.backlog = 0;
+                        tsk_rt(t)->job_params.is_backlogged_job = 0;
+                        tsk_rt(t)->budget.suspend_timestamp = 0;
+                        bt_flag_clear(t, BTF_BUDGET_EXHAUSTED);
                         mb();
 
                         /* completion succeeded, set up release. subtract off
                          * period because schedule()->job_completion() will
                          * advances us to the correct time */
-                        litmus->release_at(current,
-                                phasedRelease - current->rt_param.task_params.period);
+                        litmus->release_at(t, phasedRelease - t->rt_param.task_params.period);
                         schedule();
                 }
                 else {