Added logic to set_priority_inheritance.

Remaining work for global OMLP is just to add a check for inh_res
in higher_res_prio.

1 files changed, 50 insertions, 5 deletions

diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index dc30ea0395d1..416ef050fee8 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -725,12 +725,60 @@ static void set_priority_inheritance(struct task_struct* t, struct task_struct*
         struct gedf_reservation_environment *gedf_env;
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
 
+        struct gedf_reservation *gedf_res;
+        gedf_res = container_of(t_res, struct gedf_reservation, res);
+
         raw_spin_lock(&gedf_env->domain.ready_lock);
 
         TRACE_TASK(t, "inherits priority from %s/%d\n", prio_inh->comm, prio_inh->pid);
         t_res->inh_res = prio_inh_res;
 
-        // TODO tamert: actually try and handle the change to the priority
+        linked_on = gedf_res->linked_on;
+
+        /* If it is scheduled, then we need to reorder the CPU heap. */
+        if (linked_on) {
+                TRACE_TASK(t, "%s: linked  on %d\n",
+                           __FUNCTION__, linked_on->id);
+                /* holder is scheduled; need to re-order CPUs. */
+                update_cpu_position(gedf_res->linked_on, &gedf_env->cpu_heap);
+        } else {
+                /* holder may be queued: first stop queue changes */
+                raw_spin_lock(&gedf_env->domain.release_lock);
+                if (is_queued_res(t_res)) {
+                        TRACE_TASK(t, "%s: is queued\n",
+                                   __FUNCTION__);
+                        /* We need to update the position of holder in some
+                         * heap. Note that this could be a release heap if we
+                         * budget enforcement is used and this job overran. */
+                        check_preempt =
+                                !bheap_decrease(edf_ready_order,
+                                               t_res->heap_node);
+                } else {
+                        /* Nothing to do: if it is not queued and not linked
+                         * then it is either sleeping or currently being moved
+                         * by other code (e.g., a timer interrupt handler) that
+                         * will use the correct priority when enqueuing the
+                         * task. */
+                        TRACE_TASK(t, "%s: is NOT queued => Done.\n",
+                                   __FUNCTION__);
+                }
+                raw_spin_unlock(&gedf_env->domain.release_lock);
+
+                /* If holder was enqueued in a release heap, then the following
+                 * preemption check is pointless, but we can't easily detect
+                 * that case. If you want to fix this, then consider that
+                 * simply adding a state flag requires O(n) time to update when
+                 * releasing n tasks, which conflicts with the goal to have
+                 * O(log n) merges. */
+                if (check_preempt) {
+                        /* heap_decrease() hit the top level of the heap: make
+                         * sure preemption checks get the right task, not the
+                         * potentially stale cache. */
+                        bheap_uncache_min(edf_ready_order,
+                                         &gedf_env->domain.ready_queue);
+                        check_for_preemptions(gedf_env);
+                }
+        }
 
         raw_spin_unlock(&gedf_env->domain.ready_lock);
 }
@@ -909,9 +957,6 @@ int gedf_env_omlp_lock(struct litmus_lock* l)
         struct reservation *t_res = (struct reservation *) tsk_rt(t)->plugin_state;
 
         struct gedf_reservation *gedf_res = container_of(t_res, struct gedf_reservation, res);
-        BUG_ON(!gedf_res->linked_on && !bheap_node_in_heap(t_res->heap_node));
-        BUG_ON(!gedf_res->res.cur_budget);
-        BUG_ON(gedf_res->res.replenishment_time > litmus_clock());
 
         spin_lock_irqsave(&sem->fifo_wait.lock, flags);
 
@@ -943,7 +988,7 @@ int gedf_env_omlp_lock(struct litmus_lock* l)
                 BUG_ON(!gedf_res->linked_on && !bheap_node_in_heap(t_res->heap_node));
 
                 schedule(); // will have issues if the reservation
-                            // is not linked or on the ready queue (wtf?!)
+                            // is not linked or on the ready queue
 
                 TS_LOCK_RESUME;