Make comparators take const operands.

This patch updates various parts of litmus that
utilize binheap and bheaps to use const operands.

12 files changed, 87 insertions, 86 deletions

diff --git a/include/litmus/edf_common.h b/include/litmus/edf_common.h
index e4b8b91e8d01..0eb7289f313b 100644
--- a/include/litmus/edf_common.h
+++ b/include/litmus/edf_common.h
@@ -15,21 +15,21 @@
 void edf_domain_init(rt_domain_t* rt, check_resched_needed_t resched,
                                 release_jobs_t release);
 
-int edf_higher_prio(struct task_struct* first, struct task_struct* second);
+int edf_higher_prio(const struct task_struct* first, const struct task_struct* second);
 
-int edf_ready_order(struct bheap_node* a, struct bheap_node* b);
+int edf_ready_order(const struct bheap_node* a, const struct bheap_node* b);
 
 /* binheap_nodes must be embedded within 'struct litmus_lock' */
-int edf_max_heap_order(struct binheap_node *a, struct binheap_node *b);
-int edf_min_heap_order(struct binheap_node *a, struct binheap_node *b);
-int edf_max_heap_base_priority_order(struct binheap_node *a,
-                                struct binheap_node *b);
-int edf_min_heap_base_priority_order(struct binheap_node *a,
-                                struct binheap_node *b);
+int edf_max_heap_order(const struct binheap_node *a, const struct binheap_node *b);
+int edf_min_heap_order(const struct binheap_node *a, const struct binheap_node *b);
+int edf_max_heap_base_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b);
+int edf_min_heap_base_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b);
 int edf_preemption_needed(rt_domain_t* rt, struct task_struct *t);
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
-int __edf_higher_prio(struct task_struct* first, comparison_mode_t first_mode,
-                                struct task_struct* second, comparison_mode_t second_mode);
+int __edf_higher_prio(const struct task_struct* first, comparison_mode_t first_mode,
+                                const struct task_struct* second, comparison_mode_t second_mode);
 #endif
 
 #endif
diff --git a/include/litmus/fp_common.h b/include/litmus/fp_common.h
index 19356c0fa6c1..e4ebb0b0b4ff 100644
--- a/include/litmus/fp_common.h
+++ b/include/litmus/fp_common.h
@@ -12,10 +12,10 @@
 void fp_domain_init(rt_domain_t* rt, check_resched_needed_t resched,
                     release_jobs_t release);
 
-int fp_higher_prio(struct task_struct* first,
-                   struct task_struct* second);
+int fp_higher_prio(const struct task_struct* first,
+                   const struct task_struct* second);
 
-int fp_ready_order(struct bheap_node* a, struct bheap_node* b);
+int fp_ready_order(const struct bheap_node* a, const struct bheap_node* b);
 
 #define FP_PRIO_BIT_WORDS (LITMUS_MAX_PRIORITY / BITS_PER_LONG)
 
diff --git a/include/litmus/sched_plugin.h b/include/litmus/sched_plugin.h
index fe15ce3e9e43..5a451859d281 100644
--- a/include/litmus/sched_plugin.h
+++ b/include/litmus/sched_plugin.h
@@ -63,7 +63,7 @@ typedef void (*task_cleanup_t)	(struct task_struct *);
 /**************************** misc ***************************/
 
 /* Called to compare the scheduling priorities between two tasks */
-typedef int (*higher_prio_t)(struct task_struct* a, struct task_struct* b);
+typedef int (*higher_prio_t)(const struct task_struct* a, const struct task_struct* b);
 
 /************** locking and inheritance routines *************/
 #ifdef CONFIG_LITMUS_LOCKING
@@ -94,8 +94,8 @@ typedef void (*nested_increase_prio_t)(struct task_struct* t,
 typedef void (*nested_decrease_prio_t)(struct task_struct* t,
                                 struct task_struct* prio_inh, raw_spinlock_t *to_unlock,
                                 unsigned long irqflags, int budget_triggered);
-typedef int (*__higher_prio_t)(struct task_struct* a, comparison_mode_t a_mod,
-                                struct task_struct* b, comparison_mode_t b_mod);
+typedef int (*__higher_prio_t)(const struct task_struct* a, comparison_mode_t a_mod,
+                                const struct task_struct* b, comparison_mode_t b_mod);
 #endif /* end LITMUS_NESTED_LOCKING */
 
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
diff --git a/litmus/aux_tasks.c b/litmus/aux_tasks.c
index a562dae87c75..1a085e226596 100644
--- a/litmus/aux_tasks.c
+++ b/litmus/aux_tasks.c
@@ -387,15 +387,15 @@ out:
         return retval;
 }
 
-static int aux_task_owner_max_priority_order(struct binheap_node *a,
-                                                                           struct binheap_node *b)
+static int aux_task_owner_max_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
-        struct task_struct *d_a =
+        const struct task_struct *d_a =
                         container_of(binheap_entry(a, struct rt_param, aux_task_owner_node),
-                                                        struct task_struct, rt_param);
-        struct task_struct *d_b =
+                                struct task_struct, rt_param);
+        const struct task_struct *d_b =
                         container_of(binheap_entry(b, struct rt_param, aux_task_owner_node),
-                                                        struct task_struct, rt_param);
+                                struct task_struct, rt_param);
 
         BUG_ON(!d_a);
         BUG_ON(!d_b);
diff --git a/litmus/edf_common.c b/litmus/edf_common.c
index e0d066e64504..eabd3bcb9e38 100644
--- a/litmus/edf_common.c
+++ b/litmus/edf_common.c
@@ -24,7 +24,7 @@
 
 #ifdef CONFIG_EDF_TIE_BREAK_HASH
 #include <linux/hash.h>
-static inline long edf_hash(struct task_struct *t)
+static inline long edf_hash(const struct task_struct *t)
 {
         /* pid is 32 bits, so normally we would shove that into the
          * upper 32-bits and and put the job number in the bottom
@@ -52,14 +52,14 @@ static inline long edf_hash(struct task_struct *t)
  */
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
 int __edf_higher_prio(
-        struct task_struct* first, comparison_mode_t first_mode,
-        struct task_struct* second, comparison_mode_t second_mode)
+        const struct task_struct* first, comparison_mode_t first_mode,
+        const struct task_struct* second, comparison_mode_t second_mode)
 #else
-int edf_higher_prio(struct task_struct* first, struct task_struct* second)
+int edf_higher_prio(const struct task_struct* first, const struct task_struct* second)
 #endif
 {
-        struct task_struct *first_task = first;
-        struct task_struct *second_task = second;
+        const struct task_struct *first_task = first;
+        const struct task_struct *second_task = second;
 
         /* There is no point in comparing a task to itself. */
         if (unlikely(first && first == second)) {
@@ -326,47 +326,47 @@ klmirqd_tie_break:
 }
 
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
-int edf_higher_prio(struct task_struct* first, struct task_struct* second)
+int edf_higher_prio(const struct task_struct* first, const struct task_struct* second)
 {
         return __edf_higher_prio(first, EFFECTIVE, second, EFFECTIVE);
 }
 
-int edf_max_heap_order(struct binheap_node *a, struct binheap_node *b)
+int edf_max_heap_order(const struct binheap_node *a, const struct binheap_node *b)
 {
-        struct nested_info *l_a = (struct nested_info *)binheap_entry(a,
+        const struct nested_info *l_a = (struct nested_info *)binheap_entry(a,
                                         struct nested_info, hp_binheap_node);
-        struct nested_info *l_b = (struct nested_info *)binheap_entry(b,
+        const struct nested_info *l_b = (struct nested_info *)binheap_entry(b,
                                         struct nested_info, hp_binheap_node);
 
         return __edf_higher_prio(l_a->hp_waiter_eff_prio, EFFECTIVE,
                                         l_b->hp_waiter_eff_prio, EFFECTIVE);
 }
 
-int edf_min_heap_order(struct binheap_node *a, struct binheap_node *b)
+int edf_min_heap_order(const struct binheap_node *a, const struct binheap_node *b)
 {
         return edf_max_heap_order(b, a);  /* swap comparison */
 }
 
-int edf_max_heap_base_priority_order(struct binheap_node *a,
-                                struct binheap_node *b)
+int edf_max_heap_base_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
-        struct nested_info *l_a = (struct nested_info *)binheap_entry(a,
+        const struct nested_info *l_a = (struct nested_info *)binheap_entry(a,
                                         struct nested_info, hp_binheap_node);
-        struct nested_info *l_b = (struct nested_info *)binheap_entry(b,
+        const struct nested_info *l_b = (struct nested_info *)binheap_entry(b,
                                         struct nested_info, hp_binheap_node);
 
         return __edf_higher_prio(l_a->hp_waiter_eff_prio, BASE,
                                         l_b->hp_waiter_eff_prio, BASE);
 }
 
-int edf_min_heap_base_priority_order(struct binheap_node *a,
-                                struct binheap_node *b)
+int edf_min_heap_base_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
         return edf_max_heap_base_priority_order(b, a);  /* swap comparison */
 }
 #endif
 
-int edf_ready_order(struct bheap_node* a, struct bheap_node* b)
+int edf_ready_order(const struct bheap_node* a, const struct bheap_node* b)
 {
         return edf_higher_prio(bheap2task(a), bheap2task(b));
 }
diff --git a/litmus/fp_common.c b/litmus/fp_common.c
index 964a4729deff..1e97175756c7 100644
--- a/litmus/fp_common.c
+++ b/litmus/fp_common.c
@@ -19,11 +19,11 @@
  *
  * both first and second may be NULL
  */
-int fp_higher_prio(struct task_struct* first,
-                   struct task_struct* second)
+int fp_higher_prio(const struct task_struct* first,
+                   const struct task_struct* second)
 {
-        struct task_struct *first_task = first;
-        struct task_struct *second_task = second;
+        const struct task_struct *first_task = first;
+        const struct task_struct *second_task = second;
 
         /* There is no point in comparing a task to itself. */
         if (unlikely(first && first == second)) {
@@ -80,7 +80,7 @@ int fp_higher_prio(struct task_struct* first,
                 return 0;
 }
 
-int fp_ready_order(struct bheap_node* a, struct bheap_node* b)
+int fp_ready_order(const struct bheap_node* a, const struct bheap_node* b)
 {
         return fp_higher_prio(bheap2task(a), bheap2task(b));
 }
diff --git a/litmus/nvidia_info.c b/litmus/nvidia_info.c
index d2fe0a6c1012..fd9b0a2a9bc6 100644
--- a/litmus/nvidia_info.c
+++ b/litmus/nvidia_info.c
@@ -642,8 +642,8 @@ static enum hrtimer_restart nvklmirqd_timer_func(struct hrtimer *timer)
 #endif
 
 
-static int gpu_owner_max_priority_order(struct binheap_node *a,
-                                struct binheap_node *b)
+static int gpu_owner_max_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
         struct task_struct *d_a =
                         container_of(
diff --git a/litmus/r2dglp_lock.c b/litmus/r2dglp_lock.c
index fd03b43c97cf..e37fafb8c8cd 100644
--- a/litmus/r2dglp_lock.c
+++ b/litmus/r2dglp_lock.c
@@ -16,11 +16,11 @@
 
 #define R2DGLP_INVAL_DISTANCE 0x7FFFFFFF
 
-int r2dglp_max_heap_base_priority_order(struct binheap_node *a,
-                                struct binheap_node *b)
+int r2dglp_max_heap_base_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
-        r2dglp_heap_node_t *d_a = binheap_entry(a, r2dglp_heap_node_t, node);
-        r2dglp_heap_node_t *d_b = binheap_entry(b, r2dglp_heap_node_t, node);
+        const r2dglp_heap_node_t *d_a = binheap_entry(a, r2dglp_heap_node_t, node);
+        const r2dglp_heap_node_t *d_b = binheap_entry(b, r2dglp_heap_node_t, node);
 
         BUG_ON(!d_a);
         BUG_ON(!d_b);
@@ -28,33 +28,34 @@ int r2dglp_max_heap_base_priority_order(struct binheap_node *a,
         return litmus->__compare(d_a->task, BASE, d_b->task, BASE);
 }
 
-int r2dglp_min_heap_base_priority_order(struct binheap_node *a,
-                                struct binheap_node *b)
+int r2dglp_min_heap_base_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
-        r2dglp_heap_node_t *d_a = binheap_entry(a, r2dglp_heap_node_t, node);
-        r2dglp_heap_node_t *d_b = binheap_entry(b, r2dglp_heap_node_t, node);
+        const r2dglp_heap_node_t *d_a = binheap_entry(a, r2dglp_heap_node_t, node);
+        const r2dglp_heap_node_t *d_b = binheap_entry(b, r2dglp_heap_node_t, node);
 
         return litmus->__compare(d_b->task, BASE, d_a->task, BASE);
 }
 
-int r2dglp_donor_max_heap_base_priority_order(struct binheap_node *a,
-                                struct binheap_node *b)
+int r2dglp_donor_max_heap_base_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
-        r2dglp_wait_state_t *d_a = binheap_entry(a, r2dglp_wait_state_t, node);
-        r2dglp_wait_state_t *d_b = binheap_entry(b, r2dglp_wait_state_t, node);
+        const  r2dglp_wait_state_t *d_a = binheap_entry(a, r2dglp_wait_state_t, node);
+        const r2dglp_wait_state_t *d_b = binheap_entry(b, r2dglp_wait_state_t, node);
 
         return litmus->__compare(d_a->task, BASE, d_b->task, BASE);
 }
 
 
-int r2dglp_min_heap_donee_order(struct binheap_node *a,
-                                struct binheap_node *b)
+int r2dglp_min_heap_donee_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
-        struct task_struct *prio_a, *prio_b;
+        const struct task_struct *prio_a;
+        const struct task_struct *prio_b;
 
-        r2dglp_donee_heap_node_t *d_a =
+        const r2dglp_donee_heap_node_t *d_a =
                 binheap_entry(a, r2dglp_donee_heap_node_t, node);
-        r2dglp_donee_heap_node_t *d_b =
+        const r2dglp_donee_heap_node_t *d_b =
                 binheap_entry(b, r2dglp_donee_heap_node_t, node);
 
         if(!d_a->donor_info) {
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index c5e7ca592d2b..db43c0a5e9d9 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -35,7 +35,7 @@ static int dummy_resched(rt_domain_t *rt)
         return 0;
 }
 
-static int dummy_order(struct bheap_node* a, struct bheap_node* b)
+static int dummy_order(const struct bheap_node* a, const struct bheap_node* b)
 {
         return 0;
 }
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index ed391ec0de55..b95ff3967633 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -159,11 +159,11 @@ static int num_gpu_clusters;
 static unsigned int gpu_cluster_size;
 #endif
 
-inline static struct task_struct* binheap_node_to_task(struct binheap_node *bn)
+inline static const struct task_struct* binheap_node_to_task(const struct binheap_node *bn)
 {
-        struct budget_tracker *bt =
+        const struct budget_tracker *bt =
                 binheap_entry(bn, struct budget_tracker, top_m_node);
-        struct task_struct *t =
+        const struct task_struct *t =
                 container_of(
                          container_of(bt, struct rt_param, budget),
                                  struct task_struct,
@@ -171,19 +171,19 @@ inline static struct task_struct* binheap_node_to_task(struct binheap_node *bn)
         return t;
 }
 
-static int cedf_max_heap_base_priority_order(struct binheap_node *a,
-                                struct binheap_node *b)
+static int cedf_max_heap_base_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
-        struct task_struct* t_a = binheap_node_to_task(a);
-        struct task_struct* t_b = binheap_node_to_task(b);
+        const struct task_struct* t_a = binheap_node_to_task(a);
+        const struct task_struct* t_b = binheap_node_to_task(b);
         return __edf_higher_prio(t_a, BASE, t_b, BASE);
 }
 
-static int cedf_min_heap_base_priority_order(struct binheap_node *a,
-                                struct binheap_node *b)
+static int cedf_min_heap_base_priority_order(const struct binheap_node *a,
+                                const struct binheap_node *b)
 {
-        struct task_struct* t_a = binheap_node_to_task(a);
-        struct task_struct* t_b = binheap_node_to_task(b);
+        const struct task_struct* t_a = binheap_node_to_task(a);
+        const struct task_struct* t_b = binheap_node_to_task(b);
         return __edf_higher_prio(t_b, BASE, t_a, BASE);
 }
 
@@ -299,10 +299,10 @@ static raw_spinlock_t* cedf_get_dgl_spinlock(struct task_struct *t)
  */
 #define VERBOSE_INIT
 
-static int cpu_lower_prio(struct binheap_node *_a, struct binheap_node *_b)
+static int cpu_lower_prio(const struct binheap_node *_a, const struct binheap_node *_b)
 {
-        cpu_entry_t *a = binheap_entry(_a, cpu_entry_t, hn);
-        cpu_entry_t *b = binheap_entry(_b, cpu_entry_t, hn);
+        const cpu_entry_t *a = binheap_entry(_a, cpu_entry_t, hn);
+        const cpu_entry_t *b = binheap_entry(_b, cpu_entry_t, hn);
 
         /* Note that a and b are inverted: we want the lowest-priority CPU at
          * the top of the heap.
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index ae322e75756e..c7f65abe6539 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -126,11 +126,11 @@ static rt_domain_t gsnedf;
 #define WANT_ALL_SCHED_EVENTS
  */
 
-static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
+static int cpu_lower_prio(const struct bheap_node *_a, const struct bheap_node *_b)
 {
-        cpu_entry_t *a, *b;
-        a = _a->value;
-        b = _b->value;
+        const cpu_entry_t *a = _a->value;
+        const cpu_entry_t *b = _b->value;
+
         /* Note that a and b are inverted: we want the lowest-priority CPU at
          * the top of the heap.
          */
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index 54613534c7f0..333403b12654 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -123,7 +123,7 @@ static long litmus_dummy_get_domain_proc_info(struct domain_proc_info **d)
 }
 
 #ifdef CONFIG_LITMUS_LOCKING
-static int litmus_dummy_compare(struct task_struct* a, struct task_struct* b)
+static int litmus_dummy_compare(const struct task_struct* a, const struct task_struct* b)
 {
         TRACE_CUR("WARNING: Dummy compare function called!\n");
         return 0;
@@ -175,8 +175,8 @@ static void litmus_dummy_nested_decrease_prio(struct task_struct* t,
 }
 
 static int litmus_dummy___compare(
-                                struct task_struct* a, comparison_mode_t a_mod,
-                                struct task_struct* b, comparison_mode_t b_mode)
+                                const struct task_struct* a, comparison_mode_t a_mod,
+                                const struct task_struct* b, comparison_mode_t b_mode)
 {
         TRACE_CUR("WARNING: Dummy compare function called!\n");
         return 0;