sched_trace: allow tasks to block on a lock id

Conflicts:

	litmus/Makefile
	litmus/sched_gsn_edf.c

8 files changed, 92 insertions, 17 deletions

diff --git a/include/litmus/locking.h b/include/litmus/locking.h
index 4d7b870cb443..41991d5af01b 100644
--- a/include/litmus/locking.h
+++ b/include/litmus/locking.h
@@ -9,6 +9,7 @@ struct litmus_lock_ops;
 struct litmus_lock {
         struct litmus_lock_ops *ops;
         int type;
+        int id;
 };
 
 struct litmus_lock_ops {
diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h
index c6897f799867..49972d75ef38 100644
--- a/include/litmus/sched_trace.h
+++ b/include/litmus/sched_trace.h
@@ -233,18 +233,28 @@ feather_callback void do_sched_trace_sys_release(unsigned long id,
                 trace_litmus_task_completion(t, forced);                \
         } while (0)
 
-#define sched_trace_task_block(t)                                       \
+#define sched_trace_task_block(t, i)                                    \
         do {                                                            \
                 SCHED_TRACE(SCHED_TRACE_BASE_ID + 7,                    \
                         do_sched_trace_task_block, t);                  \
-                trace_litmus_task_block(t);                             \
+                trace_litmus_task_block(t, i);                          \
         } while (0)
 
-#define sched_trace_task_resume(t)                                      \
+#define sched_trace_task_resume(t, i)                                   \
         do {                                                            \
                 SCHED_TRACE(SCHED_TRACE_BASE_ID + 8,                    \
                                 do_sched_trace_task_resume, t);         \
-                trace_litmus_task_resume(t);                            \
+                trace_litmus_task_resume(t, i);                         \
+        } while (0)
+
+#define sched_trace_resource_acquire(t, i)                              \
+        do {                                                            \
+                trace_litmus_resource_acquire(t, i);                    \
+        } while (0)
+
+#define sched_trace_resource_released(t, i)                             \
+        do {                                                            \
+                trace_litmus_resource_released(t, i);                   \
         } while (0)
 
 #define sched_trace_action(t, action)                                   \
diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h
index 4ad053eac27d..b3a8f166e65f 100644
--- a/include/trace/events/litmus.h
+++ b/include/trace/events/litmus.h
@@ -157,21 +157,71 @@ TRACE_EVENT(litmus_task_completion,
  */
 TRACE_EVENT(litmus_task_block,
 
-        TP_PROTO(struct task_struct *t),
+        TP_PROTO(struct task_struct *t, int lid),
 
-        TP_ARGS(t),
+        TP_ARGS(t, lid),
+
+        TP_STRUCT__entry(
+                __field( pid_t,         pid     )
+                __field( int,           lid      )
+                __field( unsigned long long,            when    )
+        ),
+
+        TP_fast_assign(
+                __entry->pid    = t ? t->pid : 0;
+                __entry->lid    = lid;
+                __entry->when   = litmus_clock();
+        ),
+
+        TP_printk("(%u) blocks on %d: %Lu\n", __entry->pid,
+                  __entry->lid, __entry->when)
+);
+
+/*
+ * Lock events
+ */
+TRACE_EVENT(litmus_resource_acquire,
+
+        TP_PROTO(struct task_struct *t, int lid),
+
+        TP_ARGS(t, lid),
+
+        TP_STRUCT__entry(
+                __field( pid_t,         pid     )
+                __field( int,           lid      )
+                __field( unsigned long long,            when    )
+        ),
+
+        TP_fast_assign(
+                __entry->pid    = t ? t->pid : 0;
+                __entry->lid    = lid;
+                __entry->when   = litmus_clock();
+        ),
+
+        TP_printk("(%u) acquires %d: %Lu\n", __entry->pid,
+                  __entry->lid, __entry->when)
+);
+
+TRACE_EVENT(litmus_resource_release,
+
+        TP_PROTO(struct task_struct *t, int lid),
+
+        TP_ARGS(t, lid),
 
         TP_STRUCT__entry(
                 __field( pid_t,         pid     )
+                __field( int,           lid      )
                 __field( unsigned long long,            when    )
         ),
 
         TP_fast_assign(
                 __entry->pid    = t ? t->pid : 0;
+                __entry->lid    = lid;
                 __entry->when   = litmus_clock();
         ),
 
-        TP_printk("(%u) blocks: %Lu\n", __entry->pid, __entry->when)
+        TP_printk("(%u) releases %d: %Lu\n", __entry->pid,
+                  __entry->lid, __entry->when)
 );
 
 /*
@@ -179,12 +229,13 @@ TRACE_EVENT(litmus_task_block,
  */
 TRACE_EVENT(litmus_task_resume,
 
-        TP_PROTO(struct task_struct *t),
+        TP_PROTO(struct task_struct *t, int lid),
 
-        TP_ARGS(t),
+        TP_ARGS(t, lid),
 
         TP_STRUCT__entry(
                 __field( pid_t,         pid     )
+                __field( int,           lid      )
                 __field( unsigned int,  job     )
                 __field( unsigned long long,            when    )
         ),
@@ -193,10 +244,12 @@ TRACE_EVENT(litmus_task_resume,
                 __entry->pid    = t ? t->pid : 0;
                 __entry->job    = t ? t->rt_param.job_params.job_no : 0;
                 __entry->when   = litmus_clock();
+                __entry->lid    = lid;
         ),
 
-        TP_printk("resume(job(%u, %u)): %Lu\n",
-                        __entry->pid, __entry->job, __entry->when)
+        TP_printk("resume(job(%u, %u)) on %d: %Lu\n",
+                  __entry->pid, __entry->job,
+                  __entry->lid, __entry->when)
 );
 
 /*
diff --git a/litmus/Makefile b/litmus/Makefile
index 7338180f196f..3487dfe8df05 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -16,8 +16,9 @@ obj-y     = sched_plugin.o litmus.o \
             srp.o \
             bheap.o \
             ctrldev.o \
-            sched_gsn_edf.o \
-            sched_psn_edf.o
+            domain.o \
+            sched_psn_edf.o \
+            sched_gsn_edf.o
 
 obj-$(CONFIG_PLUGIN_CEDF) += sched_cedf.o
 obj-$(CONFIG_PLUGIN_PFAIR) += sched_pfair.o
diff --git a/litmus/locking.c b/litmus/locking.c
index 0c1aa6aa40b7..447b8aaee8dc 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -28,14 +28,18 @@ static inline struct litmus_lock* get_lock(struct od_table_entry* entry)
         return (struct litmus_lock*) entry->obj->obj;
 }
 
+atomic_t lock_id = ATOMIC_INIT(0);
+
 static  int create_generic_lock(void** obj_ref, obj_type_t type, void* __user arg)
 {
         struct litmus_lock* lock;
         int err;
 
         err = litmus->allocate_lock(&lock, type, arg);
-        if (err == 0)
+        if (err == 0) {
+                lock->id = atomic_add_return(1, &lock_id);
                 *obj_ref = lock;
+        }
         return err;
 }
 
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 6ed504f4750e..f50b58c37b31 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -805,6 +805,8 @@ int gsnedf_fmlp_lock(struct litmus_lock* l)
                 /* release lock before sleeping */
                 spin_unlock_irqrestore(&sem->wait.lock, flags);
 
+                sched_trace_task_block(t, l->id);
+
                 /* We depend on the FIFO order.  Thus, we don't need to recheck
                  * when we wake up; we are guaranteed to have the lock since
                  * there is only one wake up per release.
@@ -812,7 +814,11 @@ int gsnedf_fmlp_lock(struct litmus_lock* l)
 
                 schedule();
 
+<<<<<<< HEAD
                 TS_LOCK_RESUME;
+=======
+                sched_trace_task_resume(t, l->id);
+>>>>>>> d47039b... sched_trace: allow tasks to block on a lock id
 
                 /* Since we hold the lock, no other task will change
                  * ->owner. We can thus check it without acquiring the spin
diff --git a/litmus/sched_litmus.c b/litmus/sched_litmus.c
index 5a15ce938984..659dc13d3fa9 100644
--- a/litmus/sched_litmus.c
+++ b/litmus/sched_litmus.c
@@ -160,7 +160,7 @@ static void enqueue_task_litmus(struct rq *rq, struct task_struct *p,
                                 int flags)
 {
         if (flags & ENQUEUE_WAKEUP) {
-                sched_trace_task_resume(p);
+                sched_trace_task_resume(p, 0);
                 tsk_rt(p)->present = 1;
                 /* LITMUS^RT plugins need to update the state
                  * _before_ making it available in global structures.
@@ -185,7 +185,7 @@ static void dequeue_task_litmus(struct rq *rq, struct task_struct *p,
         if (flags & DEQUEUE_SLEEP) {
                 litmus->task_block(p);
                 tsk_rt(p)->present = 0;
-                sched_trace_task_block(p);
+                sched_trace_task_block(p, 0);
 
                 rq->litmus.nr_running--;
         } else
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index a4ffb9bb9970..eaaec38f43da 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -284,7 +284,7 @@ static void psnedf_task_new(struct task_struct * t, int on_rq, int running)
         TRACE_TASK(t, "psn edf: task new, cpu = %d\n",
                    t->rt_param.task_params.cpu);
 
-        trace_litmus_server_param(0 - t->pid, -1 - get_partition(task),
+        trace_litmus_server_param(0 - t->pid, -1 - get_partition(t),
                                   get_exec_time(t), get_rt_period(t));
 
         /* setup job parameters */