1 files changed, 199 insertions, 19 deletions

diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h
index 82bde8241298..7af12f49c600 100644
--- a/include/litmus/sched_trace.h
+++ b/include/litmus/sched_trace.h
@@ -10,13 +10,14 @@ struct st_trace_header {
         u8      type;           /* Of what type is this record?  */
         u8      cpu;            /* On which CPU was it recorded? */
         u16     pid;            /* PID of the task.              */
-        u32     job;            /* The job sequence number.      */
-};
+        u32 job:24;             /* The job sequence number.      */
+        u8  extra;
+} __attribute__((packed));
 
 #define ST_NAME_LEN 16
 struct st_name_data {
         char    cmd[ST_NAME_LEN];/* The name of the executable of this process. */
-};
+} __attribute__((packed));
 
 struct st_param_data {          /* regular params */
         u32     wcet;
@@ -25,30 +26,29 @@ struct st_param_data {		/* regular params */
         u8      partition;
         u8      class;
         u8      __unused[2];
-};
+} __attribute__((packed));
 
 struct st_release_data {        /* A job is was/is going to be released. */
         u64     release;        /* What's the release time?              */
         u64     deadline;       /* By when must it finish?               */
-};
+} __attribute__((packed));
 
 struct st_assigned_data {       /* A job was asigned to a CPU.           */
         u64     when;
         u8      target;         /* Where should it execute?              */
         u8      __unused[7];
-};
+} __attribute__((packed));
 
 struct st_switch_to_data {      /* A process was switched to on a given CPU.   */
         u64     when;           /* When did this occur?                        */
         u32     exec_time;      /* Time the current job has executed.          */
         u8      __unused[4];
-
-};
+} __attribute__((packed));
 
 struct st_switch_away_data {    /* A process was switched away from on a given CPU. */
         u64     when;
         u64     exec_time;
-};
+} __attribute__((packed));
 
 struct st_completion_data {     /* A job completed. */
         u64     when;
@@ -56,35 +56,108 @@ struct st_completion_data {	/* A job completed. */
                                  * next task automatically; set to 0 otherwise.
                                  */
         u8      __uflags:7;
-        u8      __unused[7];
-};
+        u16 nv_int_count;
+        u8      __unused[5];
+} __attribute__((packed));
 
 struct st_block_data {          /* A task blocks. */
         u64     when;
         u64     __unused;
-};
+} __attribute__((packed));
 
 struct st_resume_data {         /* A task resumes. */
         u64     when;
         u64     __unused;
-};
+} __attribute__((packed));
 
 struct st_action_data {
         u64     when;
         u8      action;
         u8      __unused[7];
-};
+} __attribute__((packed));
 
 struct st_sys_release_data {
         u64     when;
         u64     release;
-};
+} __attribute__((packed));
+
+
+struct st_tasklet_release_data {
+        u64 when;
+        u64 __unused;
+} __attribute__((packed));
+
+struct st_tasklet_begin_data {
+        u64 when;
+        u16 exe_pid;
+        u8  __unused[6];
+} __attribute__((packed));
+
+struct st_tasklet_end_data {
+        u64 when;
+        u16 exe_pid;
+        u8      flushed;
+        u8      __unused[5];
+} __attribute__((packed));
+
+
+struct st_work_release_data {
+        u64 when;
+        u64 __unused;
+} __attribute__((packed));
+
+struct st_work_begin_data {
+        u64 when;
+        u16 exe_pid;
+        u8      __unused[6];
+} __attribute__((packed));
+
+struct st_work_end_data {
+        u64 when;
+        u16 exe_pid;
+        u8      flushed;
+        u8      __unused[5];
+} __attribute__((packed));
+
+struct st_effective_priority_change_data {
+        u64 when;
+        u16 inh_pid;
+        u8      __unused[6];
+} __attribute__((packed));
+
+struct st_nv_interrupt_begin_data {
+        u64 when;
+        u32 device;
+        u32 serialNumber;
+} __attribute__((packed));
+
+struct st_nv_interrupt_end_data {
+        u64 when;
+        u32 device;
+        u32 serialNumber;
+} __attribute__((packed));
+
+struct st_prediction_err_data {
+        u64 distance;
+        u64 rel_err;
+} __attribute__((packed));
+
+struct st_migration_data {
+        u64 observed;
+        u64 estimated;
+} __attribute__((packed));
+
+struct migration_info {
+        u64 observed;
+        u64 estimated;
+        u8 distance;
+} __attribute__((packed));
 
 #define DATA(x) struct st_ ## x ## _data x;
 
 typedef enum {
-        ST_NAME = 1,            /* Start at one, so that we can spot
-                                 * uninitialized records. */
+    ST_NAME = 1, /* Start at one, so that we can spot
+                                  * uninitialized records. */
         ST_PARAM,
         ST_RELEASE,
         ST_ASSIGNED,
@@ -94,7 +167,19 @@ typedef enum {
         ST_BLOCK,
         ST_RESUME,
         ST_ACTION,
-        ST_SYS_RELEASE
+        ST_SYS_RELEASE,
+        ST_TASKLET_RELEASE,
+        ST_TASKLET_BEGIN,
+        ST_TASKLET_END,
+        ST_WORK_RELEASE,
+        ST_WORK_BEGIN,
+        ST_WORK_END,
+        ST_EFF_PRIO_CHANGE,
+        ST_NV_INTERRUPT_BEGIN,
+        ST_NV_INTERRUPT_END,
+
+        ST_PREDICTION_ERR,
+        ST_MIGRATION,
 } st_event_record_type_t;
 
 struct st_event_record {
@@ -113,8 +198,20 @@ struct st_event_record {
                 DATA(resume);
                 DATA(action);
                 DATA(sys_release);
+                DATA(tasklet_release);
+                DATA(tasklet_begin);
+                DATA(tasklet_end);
+                DATA(work_release);
+                DATA(work_begin);
+                DATA(work_end);
+                DATA(effective_priority_change);
+                DATA(nv_interrupt_begin);
+                DATA(nv_interrupt_end);
+
+                DATA(prediction_err);
+                DATA(migration);
         } data;
-};
+} __attribute__((packed));
 
 #undef DATA
 
@@ -129,6 +226,8 @@ struct st_event_record {
         ft_event1(id, callback, task)
 #define SCHED_TRACE2(id, callback, task, xtra) \
         ft_event2(id, callback, task, xtra)
+#define SCHED_TRACE3(id, callback, task, xtra1, xtra2) \
+        ft_event3(id, callback, task, xtra1, xtra2)
 
 /* provide prototypes; needed on sparc64 */
 #ifndef NO_TASK_TRACE_DECLS
@@ -155,12 +254,58 @@ feather_callback void do_sched_trace_action(unsigned long id,
 feather_callback void do_sched_trace_sys_release(unsigned long id,
                                                  lt_t* start);
 
+
+feather_callback void do_sched_trace_tasklet_release(unsigned long id,
+                                                                                                   struct task_struct* owner);
+feather_callback void do_sched_trace_tasklet_begin(unsigned long id,
+                                                                                                  struct task_struct* owner);
+feather_callback void do_sched_trace_tasklet_end(unsigned long id,
+                                                                                                 struct task_struct* owner,
+                                                                                                 unsigned long flushed);
+
+feather_callback void do_sched_trace_work_release(unsigned long id,
+                                                                                                         struct task_struct* owner);
+feather_callback void do_sched_trace_work_begin(unsigned long id,
+                                                                                                struct task_struct* owner,
+                                                                                                struct task_struct* exe);
+feather_callback void do_sched_trace_work_end(unsigned long id,
+                                                                                          struct task_struct* owner,
+                                                                                          struct task_struct* exe,
+                                                                                          unsigned long flushed);
+
+feather_callback void do_sched_trace_eff_prio_change(unsigned long id,
+                                                                                          struct task_struct* task,
+                                                                                          struct task_struct* inh);
+
+feather_callback void do_sched_trace_nv_interrupt_begin(unsigned long id,
+                                                                                                u32 device);
+feather_callback void do_sched_trace_nv_interrupt_end(unsigned long id,
+                                                                                                unsigned long unused);
+
+feather_callback void do_sched_trace_prediction_err(unsigned long id,
+                                                                                                          struct task_struct* task,
+                                                                                                          gpu_migration_dist_t* distance,
+                                                                                                          fp_t* rel_err);
+
+
+
+
+
+feather_callback void do_sched_trace_migration(unsigned long id,
+                                                                                          struct task_struct* task,
+                                                                                          struct migration_info* mig_info);
+
+
+/* returns true if we're tracing an interrupt on current CPU */
+/* int is_interrupt_tracing_active(void); */
+
 #endif
 
 #else
 
 #define SCHED_TRACE(id, callback, task)        /* no tracing */
 #define SCHED_TRACE2(id, callback, task, xtra) /* no tracing */
+#define SCHED_TRACE3(id, callback, task, xtra1, xtra2)
 
 #endif
 
@@ -252,6 +397,41 @@ feather_callback void do_sched_trace_sys_release(unsigned long id,
                 trace_litmus_sys_release(when);                         \
         } while (0)
 
+#define sched_trace_tasklet_release(t) \
+        SCHED_TRACE(SCHED_TRACE_BASE_ID + 11, do_sched_trace_tasklet_release, t)
+
+#define sched_trace_tasklet_begin(t) \
+        SCHED_TRACE(SCHED_TRACE_BASE_ID + 12, do_sched_trace_tasklet_begin, t)
+
+#define sched_trace_tasklet_end(t, flushed) \
+        SCHED_TRACE2(SCHED_TRACE_BASE_ID + 13, do_sched_trace_tasklet_end, t, flushed)
+
+
+#define sched_trace_work_release(t) \
+        SCHED_TRACE(SCHED_TRACE_BASE_ID + 14, do_sched_trace_work_release, t)
+
+#define sched_trace_work_begin(t, e) \
+        SCHED_TRACE2(SCHED_TRACE_BASE_ID + 15, do_sched_trace_work_begin, t, e)
+
+#define sched_trace_work_end(t, e, flushed) \
+        SCHED_TRACE3(SCHED_TRACE_BASE_ID + 16, do_sched_trace_work_end, t, e, flushed)
+
+
+#define sched_trace_eff_prio_change(t, inh) \
+        SCHED_TRACE2(SCHED_TRACE_BASE_ID + 17, do_sched_trace_eff_prio_change, t, inh)
+
+
+#define sched_trace_nv_interrupt_begin(d) \
+        SCHED_TRACE(SCHED_TRACE_BASE_ID + 18, do_sched_trace_nv_interrupt_begin, d)
+#define sched_trace_nv_interrupt_end(d) \
+        SCHED_TRACE(SCHED_TRACE_BASE_ID + 19, do_sched_trace_nv_interrupt_end, d)
+
+#define sched_trace_prediction_err(t, dist, rel_err) \
+        SCHED_TRACE3(SCHED_TRACE_BASE_ID + 20, do_sched_trace_prediction_err, t, dist, rel_err)
+
+#define sched_trace_migration(t, mig_info) \
+        SCHED_TRACE2(SCHED_TRACE_BASE_ID + 21, do_sched_trace_migration, t, mig_info)
+
 #define sched_trace_quantum_boundary() /* NOT IMPLEMENTED */
 
 #endif /* __KERNEL__ */