Fixed sched_trace records for state transitions.

This commit is dirty and will be cleaned up when blocking states are tested.

6 files changed, 81 insertions, 65 deletions

diff --git a/include/litmus/sched_mc.h b/include/litmus/sched_mc.h
index 12afd5525fc..05bac64caa3 100644
--- a/include/litmus/sched_mc.h
+++ b/include/litmus/sched_mc.h
@@ -31,7 +31,7 @@ struct mc_data {
 #define is_ghost(t)                                                     \
         (get_rt_job(t) < get_user_job(t) && (tsk_rt(t)->completed))
 #define ce_sid(ce) \
-        (-((ce)->level * num_online_cpus() + crit_cpu(ce)->cpu + 1))
+        (-(num_online_cpus() + (ce)->level * num_online_cpus() + crit_cpu(ce)->cpu + 1))
 
 #define TS "(%s/%d:%d:%d:%s)"
 #define TA(t) (t) ? is_ghost(t) ? "ghost" : t->comm : "NULL",   \
diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h
index 59fa5db6f40..6bad8a78e4a 100644
--- a/include/litmus/sched_trace.h
+++ b/include/litmus/sched_trace.h
@@ -205,8 +205,8 @@ feather_callback void do_sched_trace_task_tardy(unsigned long id,
 
 #define trace_litmus_container_param(cid, name)
 #define trace_litmus_server_param(sid, cid, wcet, time)
-#define trace_litmus_server_switch_to(sid, job, tid, tjob)
-#define trace_litmus_server_switch_away(sid, job, tid, tjob)
+#define trace_litmus_server_switch_to(sid, job, tid, tjob, cpu)
+#define trace_litmus_server_switch_away(sid, job, tid, tjob, cpu)
 #define trace_litmus_server_release(sid, job, release, deadline)
 #define trace_litmus_server_completion(sid, job)
 #define trace_litmus_server_block(sid)
@@ -328,14 +328,14 @@ feather_callback void do_sched_trace_task_tardy(unsigned long id,
                 trace_litmus_server_param(sid, cid, wcet, period);      \
         } while(0)
 
-#define sched_trace_server_switch_to(sid, job, tid, tjob)               \
+#define sched_trace_server_switch_to(sid, job, tid, tjob, cpu)          \
         do {                                                            \
-                trace_litmus_server_switch_to(sid, job, tid, tjob);     \
+                trace_litmus_server_switch_to(sid, job, tid, tjob, cpu);\
         } while(0)
 
-#define sched_trace_server_switch_away(sid, job, tid, tjob)             \
+#define sched_trace_server_switch_away(sid, job, tid, tjob, cpu)        \
         do {                                                            \
-                trace_litmus_server_switch_away(sid, job, tid, tjob);   \
+                trace_litmus_server_switch_away(sid, job, tid, tjob, cpu);\
         } while (0)
 
 #define sched_trace_server_release(sid, job, job_params)                \
diff --git a/include/litmus/server.h b/include/litmus/server.h
index c950325954f..35a2ad85cf3 100644
--- a/include/litmus/server.h
+++ b/include/litmus/server.h
@@ -1,7 +1,7 @@
 #ifndef __SERVER_H
 #define __SERVER_H
 
-enum server_state { SS_ACTIVE, SS_REMOVED , SS_BLOCKED};
+enum server_state { SS_ACTIVE, SS_REMOVED , SS_BLOCKED };
 
 /*
  * An accounting class only.
@@ -9,15 +9,17 @@ enum server_state { SS_ACTIVE, SS_REMOVED , SS_BLOCKED};
 struct server {
         int                     sid;
         unsigned int           *job;
-        int                     cpu;
+        int                    *cpu;
+        int                     parent;
 
         unsigned int            in_transit:1;
 
         enum server_state       state;
+        enum server_state       last;
         struct task_struct     *linked;
 };
 
-void server_init(struct server *server, int sid, int *job);
+void server_init(struct server *server, int sid, int *job, int *cpu);
 void server_state_change(struct server *server, enum server_state state,
                          unsigned int transit);
 
diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h
index f7143aa0d18..95aae9460cb 100644
--- a/include/trace/events/litmus.h
+++ b/include/trace/events/litmus.h
@@ -347,15 +347,16 @@ TRACE_EVENT(litmus_server_param,
 
 TRACE_EVENT(litmus_server_switch_to,
 
-        TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob),
+        TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob, int cpu),
 
-        TP_ARGS(sid, job, tid, tjob),
+        TP_ARGS(sid, job, tid, tjob, cpu),
 
         TP_STRUCT__entry(
                 __field( int, sid)
                 __field( unsigned int, job)
                 __field( int, tid)
                 __field( unsigned int, tjob)
+                __field( int, cpu)
         ),
 
         TP_fast_assign(
@@ -363,23 +364,25 @@ TRACE_EVENT(litmus_server_switch_to,
                 __entry->tid = tid;
                 __entry->job = job;
                 __entry->tjob = tjob;
+                __entry->cpu = cpu;
         ),
 
-        TP_printk("switch_to(server(%d, %u)): (%d, %d)\n",
-                  __entry->sid, __entry->job, __entry->tid, __entry->tjob)
+        TP_printk("switch_to(server(%d, %u)): (%d, %d) on %d\n",
+                  __entry->sid, __entry->job, __entry->tid, __entry->tjob, __entry->cpu)
 );
 
 TRACE_EVENT(litmus_server_switch_away,
 
-        TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob),
+            TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob, int cpu),
 
-        TP_ARGS(sid, job, tid, tjob),
+            TP_ARGS(sid, job, tid, tjob, cpu),
 
         TP_STRUCT__entry(
                 __field( int, sid)
                 __field( unsigned int, job)
                 __field( int, tid)
                 __field( unsigned int, tjob)
+                __field( int, cpu)
         ),
 
         TP_fast_assign(
@@ -387,10 +390,11 @@ TRACE_EVENT(litmus_server_switch_away,
                 __entry->tid = tid;
                 __entry->job = job;
                 __entry->tjob = tjob;
+                __entry->cpu = cpu;
         ),
 
-        TP_printk("switch_away(server(%d, %u)): (%d, %d)\n",
-                  __entry->sid, __entry->job, __entry->tid, __entry->tjob)
+        TP_printk("switch_away(server(%d, %u)): (%d, %d) on %d\n",
+                  __entry->sid, __entry->job, __entry->tid, __entry->tjob, __entry->cpu)
 );
 
 TRACE_EVENT(litmus_server_release,
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index f0200176c49..17e1f47173d 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -122,8 +122,9 @@ static int acquire_resources(struct task_struct *t)
         }
 
         acquired = has_resources(t, cpu);
-        if (acquired)
+        if (acquired) {
                 server_state_change(task_server, SS_ACTIVE, 0);
+        }
         raw_spin_unlock(&dgl_lock);
 
         return acquired;
@@ -235,13 +236,8 @@ static void fix_crit_position(struct crit_entry *ce)
 {
         struct server *server = &ce->server;
         if (is_global(ce->domain) && server->in_transit) {
-                if (SS_ACTIVE == server->state) {
-                        server_state_change(server, SS_ACTIVE, 0);
-                        update_crit_position(ce);
-                } else if (SS_REMOVED == server->state) {
-                        server_state_change(server, SS_REMOVED, 0);
-                        update_crit_position(ce);
-                }
+                server_state_change(server, server->state, 0);
+                update_crit_position(ce);
         }
 }
 
@@ -259,12 +255,12 @@ static inline struct crit_entry* lowest_prio_cpu(struct domain *dom)
                 hn = bheap_peek(cpu_lower_prio, heap);
                 ce = (hn) ? hn->value : NULL;
                 if (ce) {
-                        if (ce->server.state == SS_ACTIVE)
+                        if (ce->server.in_transit)
+                                fix_crit_position(ce);
+                        else if (ce->server.state == SS_ACTIVE)
                                 res = ce;
                         else if (ce->server.state == SS_REMOVED)
                                 ce = NULL;
-                        else
-                                fix_crit_position(ce);
                 }
         } while (ce && !res);
 
@@ -323,7 +319,6 @@ static void start_crit(struct crit_entry *ce)
 #endif
         }
 
-        task_server->cpu = ce_sid(ce);
         server_state_change(task_server, SS_ACTIVE, 0);
 }
 
@@ -344,7 +339,6 @@ static void stop_crit(struct crit_entry *ce)
         }
 
         server_state_change(task_server, SS_REMOVED, 0);
-        task_server->cpu = 0;
 }
 
 /**
@@ -371,17 +365,17 @@ static void link_task_to_crit(struct crit_entry *ce,
 
                 TRACE_MC_TASK(ce->server.linked, "Unlinking\n");
 
-                ce->server.linked->rt_param.linked_on  = NO_CPU;
-                ce->server.linked->rt_param.server.cpu = 0;
                 stop_crit(ce);
+                tsk_rt(ce->server.linked)->server.parent = 0;
+                ce->server.linked->rt_param.linked_on = NO_CPU;
         }
 
         /* Actually link task */
         ce->server.linked = task;
         if (task) {
                 /* Block if task cannot acquire resources */
-                task->rt_param.linked_on  = crit_cpu(ce)->cpu;
-                task->rt_param.server.cpu = ce_sid(ce);
+                task->rt_param.linked_on = crit_cpu(ce)->cpu;
+                tsk_rt(task)->server.parent = ce_sid(ce);
 
                 if (ce->domain->acquire_resources(task)) {
                         start_crit(ce);
@@ -449,6 +443,7 @@ static void low_prio_arrival(struct task_struct *task)
 #endif
         {
 arrive:
+                TRACE_MC_TASK(task, "On interrupt master, requeueing task\n");
                 job_arrival(task);
         }
 }
@@ -499,14 +494,16 @@ static void link_task_to_cpu(struct cpu_entry *entry, struct task_struct *task)
                 server = &tsk_rt(entry->linked)->server;
                 sched_trace_server_switch_away(server->sid, *server->job,
                                                entry->linked->pid,
-                                               get_user_job(entry->linked));
+                                               get_user_job(entry->linked),
+                                               entry->cpu);
         }
 
         if (task) {
                 server = &tsk_rt(task)->server;
                 sched_trace_server_switch_to(server->sid, *server->job,
                                              task->pid,
-                                             get_user_job(task));
+                                             get_user_job(task),
+                                             entry->cpu);
         }
 
         entry->linked = task;
@@ -517,6 +514,7 @@ static void link_task_to_cpu(struct cpu_entry *entry, struct task_struct *task)
                 server = &ce->server;
 
                 if (server->state == SS_REMOVED) {
+                        TRACE_CRIT_ENTRY(ce, "Moving up to active\n");
                         server_state_change(server, SS_ACTIVE, 1);
                 }
         }
@@ -600,8 +598,9 @@ static void update_crit_levels(struct cpu_entry *entry)
                         if (ce->server.linked) {
                                 link_task_to_crit(ce, NULL);
                         }
+                        TRACE_CRIT_ENTRY(ce, "Removing lower crit\n");
                         server_state_change(server, SS_REMOVED, 1);
-                        TRACE_CRIT_ENTRY(ce, "(SS_REMOVE)\n");
+
                 }
         }
         /* Need to unlock so we can access domains */
@@ -728,12 +727,12 @@ static void remove_from_all(struct task_struct* task)
                 ce = &entry->crit_entries[tsk_mc_crit(task)];
                 if (task->rt_param.linked_on != NO_CPU) {
                         BUG_ON(ce->server.linked != task);
-                        link_task_to_crit(ce, NULL);
-                        update_crit_position(ce);
                         if (entry->linked == task) {
                                 update = 1;
                                 link_task_to_cpu(entry, NULL);
                         }
+                        link_task_to_crit(ce, NULL);
+                        update_crit_position(ce);
                 } else {
                         TRACE_MC_TASK(task, "Unlinked before we got lock!\n");
                 }
@@ -985,7 +984,8 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
         sched_trace_server_param(-t->pid, t->pid,
                                  get_exec_cost(t), get_rt_period(t));
         server_init(&tsk_rt(t)->server, -t->pid,
-                    &tsk_rt(t)->job_params.job_no);
+                    &tsk_rt(t)->job_params.job_no,
+                    &tsk_rt(t)->linked_on);
         tsk_rt(t)->task_params.budget_policy = PRECISE_ENFORCEMENT;
 
         BUG_ON(!tsk_rt(t)->server.job);
@@ -1559,8 +1559,8 @@ static void init_crit_entry(struct crit_entry *ce, enum crit_level level,
         ce->server.linked = NULL;
         ce->node   = node;
         ce->domain = &dom_data->domain;
-        server_init(&ce->server, ce_sid(ce), 0);
-        ce->server.cpu = -entry->cpu - 1;
+        server_init(&ce->server, ce_sid(ce), 0, &entry->cpu);
+        ce->server.parent = -entry->cpu - 1;
 #ifdef CONFIG_MERGE_TIMERS
         init_event(&ce->event, level, mc_ghost_exhausted,
                    event_list_alloc(GFP_ATOMIC));
diff --git a/litmus/server.c b/litmus/server.c
index 3ff48e8316a..6e713a24fd3 100644
--- a/litmus/server.c
+++ b/litmus/server.c
@@ -13,9 +13,9 @@
 
 #define server_job(s) ((s)->job ? *(s)->job : 0)
 #define trace_switch(s, type) sched_trace_server_switch_ ##type (       \
-        (s)->cpu, 0, (s)->sid, server_job(s))
+        (s)->parent, 0, (s)->sid, server_job(s), *(s)->cpu)
 #define trace_transition(s, type)                                       \
-        sched_trace_server_switch_ ##type(0, 0, (s)->sid, server_job(s))
+        sched_trace_server_switch_ ##type(0, 0, (s)->sid, server_job(s), *(s)->cpu)
 
 #define NCS(x) case x: return #x
 
@@ -29,12 +29,13 @@ static const char* server_state_name(enum server_state state)
         }
 }
 
-void server_init(struct server *server, int sid, int *job)
+void server_init(struct server *server, int sid, int *job, int *cpu)
 {
         server->sid = sid;
         server->job = job;
 
-        server->cpu = 0;
+        server->cpu = cpu;
+        server->parent = 0;
         server->state = SS_REMOVED;
         server->linked = 0;
         server->in_transit = 0;
@@ -43,38 +44,45 @@ void server_init(struct server *server, int sid, int *job)
 void server_state_change(struct server *server, enum server_state state,
                          unsigned int transit)
 {
+        enum server_state last = server->state;
+
         if (!server->in_transit && transit &&
-            server->state == state)
+            server->state == state) {
+                STRACE("Ignoring transit state when target same\n");
                 return;
-        if (server->in_transit == transit && state == server->state)
+        }
+        if (server->in_transit == transit && state == server->state) {
+                STRACE("Ignoring identical change\n");
                 return;
-
-        if (server->in_transit && transit) {
-                sched_trace_server_completion(server->sid, 0);
-                goto set_state;
         }
 
         if (server->in_transit) {
+                STRACE("Transition end\n");
                 trace_transition(server, away);
-        } else {
-                switch (server->state) {
-                case SS_BLOCKED:
-                        sched_trace_server_resume(server->sid);
-                        break;
-                case SS_ACTIVE:
-                        trace_switch(server, away);
-                        break;
-                }
+                last = server->last;
+        }
+
+        if (server->state == SS_BLOCKED) {
+                STRACE("Server resume\n");
+                sched_trace_server_resume(server->sid);
         }
 
         if (transit) {
+                STRACE("Transition begin\n");
                 trace_transition(server, to);
         } else {
+                if (last == SS_ACTIVE) {
+                        STRACE("Switch from server\n");
+                        trace_switch(server, away);
+                }
+
                 switch (state) {
                 case SS_BLOCKED:
+                        STRACE("Server block\n");
                         sched_trace_server_block(server->sid);
                         break;
                 case SS_ACTIVE:
+                        STRACE("Switch to server\n");
                         trace_switch(server, to);
                         break;
                 }
@@ -82,11 +90,13 @@ void server_state_change(struct server *server, enum server_state state,
 
  set_state:
 #ifdef CONFIG_PREEMPT_STATE_TRACE
-        STRACE("server: %d - (%s:%d)->(%s:%d)\n",
-               server->sid,
+        STRACE("server: %d (parent: %d, cpu: %d, job: %d) - (%s:%d)->(%s:%d) at %llu\n",
+               server->sid, server->parent, *server->cpu, (server->job) ? *server->job : 0,
                server_state_name(server->state), server->in_transit,
-               server_state_name(state), transit);
+               server_state_name(state), transit,
+               litmus_clock());
 #endif
+        server->last = server->state;
         server->state = state;
         server->in_transit = transit;
 }