Handled unlinked case in clear_priority_inheritance.

3 files changed, 28 insertions, 15 deletions

diff --git a/include/litmus/rt_domain.h b/include/litmus/rt_domain.h
index 691e2c15556c..3b3fd9d67ce7 100644
--- a/include/litmus/rt_domain.h
+++ b/include/litmus/rt_domain.h
@@ -73,6 +73,11 @@ void release_jobs_before_now(rt_domain_t* rt);
 void domain_suspend_releases(rt_domain_t* rt);
 void domain_resume_releases(rt_domain_t* rt);
 
+/* caller must hold release lock */
+struct release_heap* get_release_heap_res(rt_domain_t *rt,
+                                                struct reservation* res,
+                                                int use_task_heap);
+
 static inline struct task_struct* __next_ready(rt_domain_t* rt)
 {
         struct bheap_node *hn = bheap_peek(rt->order, &rt->ready_queue);
diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index 27aee598b6f4..cb38ba33dbb1 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -727,9 +727,6 @@ static void set_priority_inheritance(struct task_struct* t, struct task_struct*
 
         raw_spin_lock(&gedf_env->domain.ready_lock);
 
-        printk("Task %d had inherited prio=%llu, now will be prio=%llu\n",
-               t->pid, t_res->inh_res ? t_res->inh_res->priority : 0,
-                   prio_inh_res->priority);
         TRACE_TASK(t, "inherits priority from %s/%d\n", prio_inh->comm, prio_inh->pid);
         t_res->inh_res = prio_inh_res;
 
@@ -765,19 +762,30 @@ static void clear_priority_inheritance(struct task_struct* t)
         BUG_ON(!gedf_res->linked_on && !bheap_node_in_heap(t_res->heap_node));
 
         /* Check if rescheduling is necessary. We can't use heap_decrease()
-         * since the priority was effectively lowered. */
-
-        /* assumes high_res_prio in ext_reservation.c takes into account inh_task when doing prio comparisons */
-        /* only need to update the cpu position in heap to reflect gedf_res's change in prio.
-         * This only affects the cpu_heap when gedf_res is linked on a cpu and only on the cpu
-         * that it's linked on
-         */
-        if (gedf_res->linked_on)
+         * since the priority was effectively lowered. Instead, we
+         * update the position of the CPU on which it is linked.
+         * only need to update the cpu position in heap to reflect gedf_res's
+         * change in prio. This only affects the cpu_heap when gedf_res
+         * is linked on a cpu and only on the cpu that it's linked on. */
+        if (gedf_res->linked_on) {
                 update_cpu_position(gedf_res->linked_on, &gedf_env->cpu_heap);
-        check_for_preemptions(gedf_env);
+        }
+        else {
+                struct bheap *heap;
+                if (t_res->replenishment_time > litmus_clock()) {
+                        raw_spin_lock(&gedf_env->domain.release_lock);
+                        heap = &(get_release_heap_res(&gedf_env->domain, t_res, 0)->heap);
+                        raw_spin_unlock(&gedf_env->domain.release_lock);
+                }
+                else {
+                        heap = &(gedf_env->domain.ready_queue);
+                }
 
-        // TODO tamert: reschedule if necessary
-        // (the priority was effectively lowered)
+                bheap_delete(edf_ready_order, heap, t_res->heap_node);
+                bheap_insert(edf_ready_order, heap, t_res->heap_node);
+        }
+
+        check_for_preemptions(gedf_env);
 
         raw_spin_unlock(&gedf_env->domain.ready_lock);
 }
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index db3a48bff0d0..0e54e2c48d84 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -202,7 +202,7 @@ static struct release_heap* __get_release_heap(rt_domain_t *rt,
         return heap;
 }
 
-static struct release_heap* get_release_heap_res(rt_domain_t *rt,
+struct release_heap* get_release_heap_res(rt_domain_t *rt,
                                                  struct reservation* res,
                                                  int use_task_heap)
 {