1 files changed, 32 insertions, 17 deletions

diff --git a/litmus/dgl.c b/litmus/dgl.c
index e2286b3e9239..cced7c259735 100644
--- a/litmus/dgl.c
+++ b/litmus/dgl.c
@@ -28,6 +28,11 @@
 #define req_group(r, i) (container_of(((void*)r) - sizeof(*r)*(i),      \
                                       struct dgl_group_req, requests))
 
+#define TRACE(fmt, args...) STRACE(fmt, ## args)
+#define TRACE_GREQ(greq, fmt, args...)                                 \
+        TRACE("(greq-%s/%d) " fmt, (greq->task ? greq->task->comm : "greq"), \
+              (greq->task ? greq->task->pid : (int)greq), ## args)
+
 /* Resource id -> word, bit */
 static inline void mask_idx(int resource, int *word, int *bit)
 {
@@ -35,7 +40,6 @@ static inline void mask_idx(int resource, int *word, int *bit)
         *bit  = resource % MASK_SIZE;
 }
 
-
 static void print_waiting(struct dgl *dgl, struct dgl_resource *resource)
 {
         struct dgl_req *pos;
@@ -45,12 +49,14 @@ static void print_waiting(struct dgl *dgl, struct dgl_resource *resource)
         TRACE("List for rid %d\n", resource_id(dgl, resource));
         list_for_each_entry(pos, &resource->waiting, list) {
                 greq = pos->greq;
-                TRACE("  0x%p with timestamp %llu\n", greq, greq->ts);
+                TRACE_GREQ(greq, "with timestamp %llu\n", greq->ts);
                 BUG_ON(greq->ts < last);
                 last = greq->ts;
         }
 }
 
+static void dummy_acquired(int cpu){}
+
 void dgl_init(struct dgl *dgl, unsigned long num_resources,
               unsigned long num_replicas)
 {
@@ -78,6 +84,7 @@ void dgl_init(struct dgl *dgl, unsigned long num_resources,
         dgl->requests = 0;
         dgl->running  = 0;
         dgl->ts = 0;
+        dgl->cpu_acquired = dummy_acquired;
 }
 
 void dgl_free(struct dgl *dgl)
@@ -130,7 +137,7 @@ void set_req(struct dgl *dgl, struct dgl_group_req *greq,
         mask_idx(resource, &word, &bit);
         __set_bit(bit, &greq->requested[word]);
 
-        TRACE("0x%p requesting %d of %d\n", greq, replicas, resource);
+        TRACE_GREQ(greq, "requesting %d of %d\n", replicas, resource);
 
         req = &greq->requests[resource];
         req->greq = greq;
@@ -153,27 +160,27 @@ static unsigned long try_acquire(struct dgl *dgl, struct dgl_resource *resource,
         rid  = resource_id(dgl, resource);
         greq = req->greq;
 
-        TRACE("0x%p greq\n", greq);
+        TRACE_GREQ(greq, "try acquire\n");
 
         head  = resource->waiting.next == &req->list;
         empty = list_empty(&resource->waiting);
         room  = resource->free_replicas >= req->replicas;
 
         if (! (room && (head || empty)) ) {
-                TRACE("0x%p cannot acquire %d replicas, %d free\n",
-                      greq, req->replicas, resource->free_replicas,
+                TRACE_GREQ(greq, "cannot acquire %d replicas, %d free\n",
+                      req->replicas, resource->free_replicas,
                       room, head, empty);
                 return 0;
         }
 
         resource->free_replicas -= req->replicas;
 
-        TRACE("0x%p acquired %d replicas of rid %d\n",
-              greq, req->replicas, rid);
+        TRACE_GREQ(greq, "0x%p acquired %d replicas of rid %d\n",
+                   req->replicas, rid);
 
         mask_idx(rid, &word, &bit);
 
-        TRACE("0x%p, %lu, 0x%p\n", greq->waiting, greq->waiting[word],
+        TRACE_GREQ(greq, "0x%p, %lu, 0x%p\n", greq->waiting, greq->waiting[word],
               &greq->waiting[word]);
 
         clear_bit(bit, &greq->waiting[word]);
@@ -186,11 +193,19 @@ static unsigned long try_acquire(struct dgl *dgl, struct dgl_resource *resource,
         }
 
         if (!waiting) {
-                TRACE("0x%p acquired all resources\n", greq);
+                TRACE_GREQ(greq, "acquired all resources on cpu %d\n", greq->cpu);
                 BUG_ON(dgl->acquired[greq->cpu]);
                 dgl->acquired[greq->cpu] = greq;
                 litmus_reschedule(greq->cpu);
                 dgl->running++;
+
+                if (greq->task) {
+                        BUG_ON(tsk_rt(greq->task)->linked_on == NO_CPU);
+                        set_rt_flags(greq->task, RT_F_RUNNING);
+                        sched_trace_task_resume(greq->task);
+                }
+
+                dgl->cpu_acquired(greq->cpu);
         }
 
         return 1;
@@ -208,7 +223,7 @@ void add_group_req(struct dgl *dgl, struct dgl_group_req *greq, int cpu)
         greq->cpu = cpu;
         greq->ts = dgl->ts++;
 
-        TRACE("0x%p group request added for CPU %d\n", greq, cpu);
+        TRACE_GREQ(greq, "group request added for CPU %d\n", cpu);
         BUG_ON(dgl->acquired[cpu] == greq);
 
         ++dgl->requests;
@@ -225,14 +240,14 @@ void add_group_req(struct dgl *dgl, struct dgl_group_req *greq, int cpu)
                 all_succ &= succ;
 
                 if (!succ) {
-                        TRACE("0x%p waiting on rid %d\n", greq, i);
+                        TRACE_GREQ(greq, "waiting on rid %d\n", i);
                         list_add_tail(&req->list, &resource->waiting);
                 }
         }
 
         /* Grant empty requests */
         if (all_succ && !dgl->acquired[cpu]) {
-                TRACE("0x%p empty group request acquired cpu %d\n", greq, cpu);
+                TRACE_GREQ(greq, "empty group request acquired cpu %d\n", cpu);
                 dgl->acquired[cpu] = greq;
                 ++dgl->running;
         }
@@ -251,12 +266,12 @@ void remove_group_req(struct dgl *dgl, struct dgl_group_req *greq)
         struct dgl_req *req, *next;
         struct dgl_resource *resource;
 
-        TRACE("0x%p removing group request for CPU %d\n", greq, greq->cpu);
+        TRACE_GREQ(greq, "removing group request for CPU %d\n", greq, greq->cpu);
 
         --dgl->requests;
 
         if (dgl->acquired[greq->cpu] == greq) {
-                TRACE("0x%p no longer acquired on CPU %d\n", greq, greq->cpu);
+                TRACE_GREQ(greq, "no longer acquired on CPU %d\n", greq->cpu);
                 dgl->acquired[greq->cpu] = NULL;
                 --dgl->running;
         }
@@ -275,8 +290,8 @@ void remove_group_req(struct dgl *dgl, struct dgl_group_req *greq)
                         /* Have resource */
                         resource->free_replicas += req->replicas;
                         BUG_ON(resource->free_replicas > dgl->num_replicas);
-                        TRACE("0x%p releasing %d of %d replicas, rid %d\n",
-                              greq, req->replicas, resource->free_replicas, i);
+                        TRACE_GREQ(greq, "releasing %d of %d replicas, rid %d\n",
+                              req->replicas, resource->free_replicas, i);
 
                         if (!list_empty(&resource->waiting)) {
                                 /* Give it to the next guy */