1 files changed, 120 insertions, 0 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index ce24e62eee81..4fa705e65f0c 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -95,6 +95,126 @@ void litmus_exit_task(struct task_struct *tsk);
 #define is_be(t)                \
         (tsk_rt(t)->task_params.cls == RT_CLASS_BEST_EFFORT)
 
+
+
+/* budget-related functions and macros */
+
+inline static int budget_exhausted(struct task_struct* t) {
+        return get_exec_time(t) >= get_exec_cost(t);
+}
+
+inline static int budget_remaining(struct task_struct* t) {
+        return (!budget_exhausted(t)) ? (get_exec_cost(t) - get_exec_time(t)) : 0;
+}
+
+#define budget_enforced(t) (\
+tsk_rt(t)->task_params.budget_policy != NO_ENFORCEMENT)
+
+#define budget_precisely_tracked(t) (\
+tsk_rt(t)->task_params.budget_policy == PRECISE_ENFORCEMENT || \
+tsk_rt(t)->task_params.budget_signal_policy == PRECISE_SIGNALS)
+
+#define budget_quantum_tracked(t) (\
+tsk_rt(t)->task_params.budget_policy == QUANTUM_ENFORCEMENT || \
+tsk_rt(t)->task_params.budget_signal_policy == QUANTUM_SIGNALS)
+
+#define budget_signalled(t) (\
+tsk_rt(t)->task_params.budget_signal_policy != NO_SIGNALS)
+
+#define budget_precisely_signalled(t) (\
+tsk_rt(t)->task_params.budget_policy == PRECISE_SIGNALS)
+
+#define bt_flag_is_set(t, flag_nr) (\
+test_bit(flag_nr, &tsk_rt(t)->budget.flags))
+
+#define bt_flag_test_and_set(t, flag_nr) (\
+test_and_set_bit(flag_nr, &tsk_rt(t)->budget.flags))
+
+#define bt_flag_set(t, flag_nr) (\
+set_bit(flag_nr, &tsk_rt(t)->budget.flags))
+
+#define bt_flag_clear(t, flag_nr) (\
+clear_bit(flag_nr, &tsk_rt(t)->budget.flags))
+
+#define bt_flags_reset(t) (\
+tsk_rt(t)->budget.flags = 0)
+
+#define requeue_preempted_job(t) \
+(t && (!budget_exhausted(t) || !budget_enforced(t)))
+
+
+#ifdef CONFIG_LITMUS_LOCKING
+static inline void set_inh_task_linkback(struct task_struct* t, struct task_struct* linkto)
+{
+        const int MAX_IDX = BITS_PER_LONG - 1;
+
+        int success = 0;
+        int old_idx = tsk_rt(t)->inh_task_linkback_idx;
+
+        /* is the linkback already set? */
+        if (old_idx >= 0 && old_idx <= MAX_IDX) {
+                if ((BIT_MASK(old_idx) & tsk_rt(linkto)->used_linkback_slots) &&
+                        (tsk_rt(linkto)->inh_task_linkbacks[old_idx] == t)) {
+                        TRACE_TASK(t, "linkback is current.\n");
+                        return;
+                }
+                BUG();
+        }
+
+        /* kludge: upper limit on num linkbacks */
+        BUG_ON(tsk_rt(linkto)->used_linkback_slots == ~0ul);
+
+        while(!success) {
+                int b = find_first_zero_bit(&tsk_rt(linkto)->used_linkback_slots,
+                                        sizeof(tsk_rt(linkto)->used_linkback_slots));
+
+                BUG_ON(b > MAX_IDX);
+
+                /* set bit... */
+                if (!test_and_set_bit(b, &tsk_rt(linkto)->used_linkback_slots)) {
+                        TRACE_TASK(t, "linking back to %s/%d in slot %d\n", linkto->comm, linkto->pid, b);
+                        if (tsk_rt(linkto)->inh_task_linkbacks[b])
+                                TRACE_TASK(t, "%s/%d already has %s/%d in slot %d\n",
+                                                   linkto->comm, linkto->pid,
+                                                   tsk_rt(linkto)->inh_task_linkbacks[b]->comm,
+                                                   tsk_rt(linkto)->inh_task_linkbacks[b]->pid,
+                                                   b);
+
+                        /* TODO: allow dirty data to remain in [b] after code is tested */
+                        BUG_ON(tsk_rt(linkto)->inh_task_linkbacks[b] != NULL);
+                        /* ...before setting slot */
+                        tsk_rt(linkto)->inh_task_linkbacks[b] = t;
+                        tsk_rt(t)->inh_task_linkback_idx = b;
+                        success = 1;
+                }
+        }
+}
+
+static inline void clear_inh_task_linkback(struct task_struct* t, struct task_struct* linkedto)
+{
+        const int MAX_IDX = BITS_PER_LONG - 1;
+
+        int success = 0;
+        int slot = tsk_rt(t)->inh_task_linkback_idx;
+
+        if (slot < 0) {
+                TRACE_TASK(t, "assuming linkback already cleared.\n");
+                return;
+        }
+
+        BUG_ON(slot > MAX_IDX);
+        BUG_ON(tsk_rt(linkedto)->inh_task_linkbacks[slot] != t);
+
+        /* be safe - clear slot before clearing the bit */
+        tsk_rt(t)->inh_task_linkback_idx = -1;
+        tsk_rt(linkedto)->inh_task_linkbacks[slot] = NULL;
+
+        success = test_and_clear_bit(slot, &tsk_rt(linkedto)->used_linkback_slots);
+
+        BUG_ON(!success);
+}
+#endif
+
 /* Our notion of time within LITMUS: kernel monotonic time. */
 static inline lt_t litmus_clock(void)
 {