sched_trace: Trace PGM node type parameters

6 files changed, 85 insertions, 11 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 6160a1635227..0ddc1973b0aa 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -51,6 +51,13 @@ typedef enum {
         TASK_EARLY
 } release_policy_t;
 
+typedef enum {
+        PGM_NOT_A_NODE,
+        PGM_SRC,
+        PGM_SINK,
+        PGM_INTERNAL
+} pgm_node_type_t;
+
 /* We use the common priority interpretation "lower index == higher priority",
  * which is commonly used in fixed-priority schedulability analysis papers.
  * So, a numerically lower priority value implies higher scheduling priority,
@@ -82,6 +89,7 @@ struct rt_task {
         task_class_t    cls;
         budget_policy_t  budget_policy;  /* ignored by pfair */
         release_policy_t release_policy;
+        pgm_node_type_t pgm_type;
 };
 
 union np_flag {
diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h
index 3d3b06ced797..8e2aefecd1fe 100644
--- a/include/litmus/sched_trace.h
+++ b/include/litmus/sched_trace.h
@@ -80,6 +80,12 @@ struct st_sys_release_data {
         u64     release;
 };
 
+struct st_pgm_param_data {
+        u32 node_type;
+        u16 graph_pid;
+        u8  __unused[10];
+};
+
 struct st_pgm_release_data {
         u64     release;        /* PGM-adjusted release time */
         u64     deadline;       /* PGM-adjusted deadline */
@@ -100,6 +106,7 @@ typedef enum {
         ST_RESUME,
         ST_ACTION,
         ST_SYS_RELEASE,
+        ST_PGM_PARAM,
         ST_PGM_RELEASE
 } st_event_record_type_t;
 
@@ -119,6 +126,7 @@ struct st_event_record {
                 DATA(resume);
                 DATA(action);
                 DATA(sys_release);
+                DATA(pgm_param);
                 DATA(pgm_release);
         } data;
 };
@@ -161,6 +169,8 @@ feather_callback void do_sched_trace_action(unsigned long id,
                                             unsigned long action);
 feather_callback void do_sched_trace_sys_release(unsigned long id,
                                                  lt_t* start);
+feather_callback void do_sched_trace_pgm_param(unsigned long id,
+                                                struct task_struct* task);
 feather_callback void do_sched_trace_pgm_release(unsigned long id,
                                                 struct task_struct* task);
 
@@ -188,6 +198,7 @@ feather_callback void do_sched_trace_pgm_release(unsigned long id,
 #define trace_litmus_task_block(t)
 #define trace_litmus_task_resume(t)
 #define trace_litmus_sys_release(start)
+#define trace_litmus_pgm_param(t)
 #define trace_litmus_pgm_release(t)
 
 #endif
@@ -262,10 +273,17 @@ feather_callback void do_sched_trace_pgm_release(unsigned long id,
                 trace_litmus_sys_release(when);                         \
         } while (0)
 
+#define sched_trace_pgm_param(t)                                        \
+        do {                                                                                    \
+                SCHED_TRACE(SCHED_TRACE_BASE_ID + 11,           \
+                                do_sched_trace_pgm_param, t);           \
+                trace_litmus_pgm_param(t);                                      \
+        } while (0)
+
 #define sched_trace_pgm_release(t)                                      \
-        do {                                                            \
-                SCHED_TRACE(SCHED_TRACE_BASE_ID + 11,                   \
-                                do_sched_trace_pgm_release, t); \
+        do {                                                                                    \
+                SCHED_TRACE(SCHED_TRACE_BASE_ID + 12,           \
+                                do_sched_trace_pgm_release, t);         \
                 trace_litmus_pgm_release(t);                            \
         } while (0)
 
diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h
index 0b4eac386dfe..0822328144bc 100644
--- a/include/trace/events/litmus.h
+++ b/include/trace/events/litmus.h
@@ -225,6 +225,27 @@ TRACE_EVENT(litmus_sys_release,
         TP_printk("SynRelease(%Lu) at %Lu\n", __entry->rel, __entry->when)
 );
 
+/* Tracing PGM node parameters */
+TRACE_EVENT(litmus_pgm_param,
+
+        TP_PROTO(struct task_struct *t),
+
+        TP_ARGS(t),
+
+        TP_STRUCT__entry(
+                __field( pid_t, pid )
+                __field( pgm_node_type_t, node_type )
+                __field( pid_t, graph_pid )
+        ),
+
+        TP_fast_assign(
+                __entry->pid            = t ? t->pid  : 0;
+                __entry->node_type      = t ? t->rt_params.task_params.pgm_type : PGM_NOT_A_NODE;
+                __entry->graph_pid      = t ? t->tgid : 0;
+        )
+
+        TP_printk("pgm node (%u, node type = %d) in graph (%u)\n",
+                __entry->pid, __entry->node_type, __entry->graph_pid);
 /*
  * Tracing PGM-adjusted job release
  */
diff --git a/litmus/litmus.c b/litmus/litmus.c
index ab0bcac13252..8937f5233b0e 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -107,12 +107,19 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param)
         if (tp.relative_deadline == 0)
                 tp.relative_deadline = tp.period;
 
-        if (tp.exec_cost <= 0)
+        if (tp.exec_cost <= 0) {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                                "because declared job execution time <= 0.", pid);
                 goto out_unlock;
-        if (tp.period <= 0)
+        }
+        if (tp.period <= 0) {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                                "because declared job period <= 0.", pid);
                 goto out_unlock;
-        if (!cpu_online(tp.cpu))
+        }
+        if (!cpu_online(tp.cpu)) {
                 goto out_unlock;
+        }
         if (min(tp.relative_deadline, tp.period) < tp.exec_cost) /*density check*/
         {
                 printk(KERN_INFO "litmus: real-time task %d rejected "
@@ -331,9 +338,13 @@ long litmus_admit_task(struct task_struct* tsk)
         if (get_rt_relative_deadline(tsk) == 0 ||
             get_exec_cost(tsk) >
                         min(get_rt_relative_deadline(tsk), get_rt_period(tsk)) ) {
+                printk(KERN_INFO "litmus: invalid task parameters "
+                        "(e = %llu, p = %llu, d = %llu)\n",
+                        get_exec_cost(tsk), get_rt_period(tsk),
+                        get_rt_relative_deadline(tsk));
                 TRACE_TASK(tsk,
                         "litmus admit: invalid task parameters "
-                        "(e = %lu, p = %lu, d = %lu)\n",
+                        "(e = %llu, p = %llu, d = %llu)\n",
                         get_exec_cost(tsk), get_rt_period(tsk),
                         get_rt_relative_deadline(tsk));
                 retval = -EINVAL;
@@ -341,6 +352,8 @@ long litmus_admit_task(struct task_struct* tsk)
         }
 
         if (!cpu_online(get_partition(tsk))) {
+                printk(KERN_INFO "litmus: cpu %d is not online\n",
+                           get_partition(tsk));
                 TRACE_TASK(tsk, "litmus admit: cpu %d is not online\n",
                            get_partition(tsk));
                 retval = -EINVAL;
@@ -369,6 +382,7 @@ long litmus_admit_task(struct task_struct* tsk)
         if (!retval) {
                 sched_trace_task_name(tsk);
                 sched_trace_task_param(tsk);
+                sched_trace_pgm_param(tsk);
                 atomic_inc(&rt_task_count);
         }
 
diff --git a/litmus/sched_cfl_split.c b/litmus/sched_cfl_split.c
index ad398470a495..b6dde71cdf84 100644
--- a/litmus/sched_cfl_split.c
+++ b/litmus/sched_cfl_split.c
@@ -850,8 +850,10 @@ static long cflsplit_admit_task(struct task_struct* tsk)
         if (remote_cluster(task_cpu(tsk)) != task_cpu_cluster(tsk)) {
                 unsigned int assigned_cpu = get_partition(tsk);
                 unsigned int cur_cpu = task_cpu(tsk);
-                TRACE_TASK(tsk, "cluster mismatch: assigned cpu %u but on cpu %u\n",
-                                                assigned_cpu, cur_cpu);
+                printk(KERN_INFO "cluster mismatch: %u assigned cpu %d but on cpu %d\n",
+                        tsk->pid, assigned_cpu, cur_cpu);
+                TRACE_TASK(tsk, "cluster mismatch: assigned cpu %d but on cpu %d\n",
+                        assigned_cpu, cur_cpu);
                 return -EINVAL;
         }
         return 0;
diff --git a/litmus/sched_task_trace.c b/litmus/sched_task_trace.c
index 422314f29a60..b9e772c07652 100644
--- a/litmus/sched_task_trace.c
+++ b/litmus/sched_task_trace.c
@@ -238,13 +238,24 @@ feather_callback void do_sched_trace_action(unsigned long id,
         }
 }
 
+feather_callback void do_sched_trace_pgm_param(unsigned long id, unsigned long _task)
+{
+        struct task_struct *t = (struct task_struct*) _task;
+        struct st_event_record* rec = get_record(ST_PGM_PARAM, t);
+        if (rec) {
+                rec->data.pgm_param.node_type = tsk_rt(t)->task_params.pgm_type;
+                rec->data.pgm_param.graph_pid = t->tgid;
+                put_record(rec);
+        }
+}
+
 feather_callback void do_sched_trace_pgm_release(unsigned long id, unsigned long _task)
 {
         struct task_struct *t = (struct task_struct*) _task;
         struct st_event_record* rec = get_record(ST_PGM_RELEASE, t);
         if (rec) {
-                rec->data.release.release  = get_release(t);
-                rec->data.release.deadline = get_deadline(t);
+                rec->data.pgm_release.release  = get_release(t);
+                rec->data.pgm_release.deadline = get_deadline(t);
                 put_record(rec);
         }
 }