Modify sync_fence_create to accept a 'struct fence' instead of
'struct sync_pt'.  This will allow drm drivers to create sync_fence
objects and pass sync fd's between user space with minimal modifications,
without ever creating sync_timeline or sync_pt objects, and without
implementing the sync_timeline_ops interface.

Modify the sync driver debug code to not assume that every 'struct fence'
(that is associated with a 'struct sync_fence') is embedded within a
'struct sync_pt'.

Signed-off-by: Lauri Peltonen <lpelto...@nvidia.com>
---
 drivers/staging/android/sw_sync.c    |  2 +-
 drivers/staging/android/sync.c       | 10 ++++-----
 drivers/staging/android/sync.h       |  6 +++---
 drivers/staging/android/sync_debug.c | 40 ++++++++++++++++--------------------
 4 files changed, 27 insertions(+), 31 deletions(-)

diff --git a/drivers/staging/android/sw_sync.c 
b/drivers/staging/android/sw_sync.c
index c90838d36953..bec8039df6f2 100644
--- a/drivers/staging/android/sw_sync.c
+++ b/drivers/staging/android/sw_sync.c
@@ -185,7 +185,7 @@ static long sw_sync_ioctl_create_fence(struct 
sw_sync_timeline *obj,
        }
 
        data.name[sizeof(data.name) - 1] = '\0';
-       fence = sync_fence_create(data.name, pt);
+       fence = sync_fence_create(data.name, &pt->base);
        if (fence == NULL) {
                sync_pt_free(pt);
                err = -ENOMEM;
diff --git a/drivers/staging/android/sync.c b/drivers/staging/android/sync.c
index f83e00c78051..11e6944922e0 100644
--- a/drivers/staging/android/sync.c
+++ b/drivers/staging/android/sync.c
@@ -187,8 +187,8 @@ static void fence_check_cb_func(struct fence *f, struct 
fence_cb *cb)
                wake_up_all(&fence->wq);
 }
 
-/* TODO: implement a create which takes more that one sync_pt */
-struct sync_fence *sync_fence_create(const char *name, struct sync_pt *pt)
+/* TODO: implement a create which takes more that one pt */
+struct sync_fence *sync_fence_create(const char *name, struct fence *pt)
 {
        struct sync_fence *fence;
 
@@ -199,10 +199,10 @@ struct sync_fence *sync_fence_create(const char *name, 
struct sync_pt *pt)
        fence->num_fences = 1;
        atomic_set(&fence->status, 1);
 
-       fence->cbs[0].sync_pt = &pt->base;
+       fence->cbs[0].sync_pt = pt;
        fence->cbs[0].fence = fence;
-       if (fence_add_callback(&pt->base, &fence->cbs[0].cb,
-                              fence_check_cb_func))
+       if (fence_add_callback(pt, &fence->cbs[0].cb,
+                               fence_check_cb_func))
                atomic_dec(&fence->status);
 
        sync_fence_debug_add(fence);
diff --git a/drivers/staging/android/sync.h b/drivers/staging/android/sync.h
index a21b79fb4c8e..af0daa65bfa9 100644
--- a/drivers/staging/android/sync.h
+++ b/drivers/staging/android/sync.h
@@ -246,13 +246,13 @@ void sync_pt_free(struct sync_pt *pt);
 
 /**
  * sync_fence_create() - creates a sync fence
- * @name:      name of fence to create
- * @pt:                sync_pt to add to the fence
+ * @name:      name of sync fence to create
+ * @pt:                fence to add to the sync fence
  *
  * Creates a fence containg @pt.  Once this is called, the fence takes
  * ownership of @pt.
  */
-struct sync_fence *sync_fence_create(const char *name, struct sync_pt *pt);
+struct sync_fence *sync_fence_create(const char *name, struct fence *pt);
 
 /*
  * API for sync_fence consumers
diff --git a/drivers/staging/android/sync_debug.c 
b/drivers/staging/android/sync_debug.c
index 91ed2c4cff45..5e0860ebf7b5 100644
--- a/drivers/staging/android/sync_debug.c
+++ b/drivers/staging/android/sync_debug.c
@@ -82,34 +82,34 @@ static const char *sync_status_str(int status)
        return "error";
 }
 
-static void sync_print_pt(struct seq_file *s, struct sync_pt *pt, bool fence)
+static void sync_print_pt(struct seq_file *s, struct fence *pt, bool fence)
 {
        int status = 1;
-       struct sync_timeline *parent = sync_pt_parent(pt);
 
-       if (fence_is_signaled_locked(&pt->base))
-               status = pt->base.status;
+       if (fence_is_signaled_locked(pt))
+               status = pt->status;
 
-       seq_printf(s, "  %s%spt %s",
-                  fence ? parent->name : "",
-                  fence ? "_" : "",
-                  sync_status_str(status));
+       if (fence)
+               seq_printf(s, "  %d_pt %s", pt->context,
+                          sync_status_str(status));
+       else
+               seq_printf(s, "  pt %s", sync_status_str(status));
 
        if (status <= 0) {
                struct timespec64 ts64 =
-                       ktime_to_timespec64(pt->base.timestamp);
+                       ktime_to_timespec64(pt->timestamp);
 
                seq_printf(s, "@%lld.%09ld", (s64)ts64.tv_sec, ts64.tv_nsec);
        }
 
-       if (parent->ops->timeline_value_str &&
-           parent->ops->pt_value_str) {
+       if (pt->ops->timeline_value_str &&
+           pt->ops->fence_value_str) {
                char value[64];
 
-               parent->ops->pt_value_str(pt, value, sizeof(value));
+               pt->ops->fence_value_str(pt, value, sizeof(value));
                seq_printf(s, ": %s", value);
                if (fence) {
-                       parent->ops->timeline_value_str(parent, value,
+                       pt->ops->timeline_value_str(pt, value,
                                                    sizeof(value));
                        seq_printf(s, " / %s", value);
                }
@@ -123,7 +123,8 @@ static void sync_print_obj(struct seq_file *s, struct 
sync_timeline *obj)
        struct list_head *pos;
        unsigned long flags;
 
-       seq_printf(s, "%s %s", obj->name, obj->ops->driver_name);
+       seq_printf(s, "%d %s %s", obj->context, obj->name,
+                  obj->ops->driver_name);
 
        if (obj->ops->timeline_value_str) {
                char value[64];
@@ -138,7 +139,7 @@ static void sync_print_obj(struct seq_file *s, struct 
sync_timeline *obj)
        list_for_each(pos, &obj->child_list_head) {
                struct sync_pt *pt =
                        container_of(pos, struct sync_pt, child_list);
-               sync_print_pt(s, pt, false);
+               sync_print_pt(s, &pt->base, false);
        }
        spin_unlock_irqrestore(&obj->child_list_lock, flags);
 }
@@ -152,13 +153,8 @@ static void sync_print_fence(struct seq_file *s, struct 
sync_fence *fence)
        seq_printf(s, "[%p] %s: %s\n", fence, fence->name,
                   sync_status_str(atomic_read(&fence->status)));
 
-       for (i = 0; i < fence->num_fences; ++i) {
-               struct sync_pt *pt =
-                       container_of(fence->cbs[i].sync_pt,
-                                    struct sync_pt, base);
-
-               sync_print_pt(s, pt, true);
-       }
+       for (i = 0; i < fence->num_fences; ++i)
+               sync_print_pt(s, fence->cbs[i].sync_pt, true);
 
        spin_lock_irqsave(&fence->wq.lock, flags);
        list_for_each_entry(pos, &fence->wq.task_list, task_list) {
-- 
2.1.4

_______________________________________________
devel mailing list
de...@linuxdriverproject.org
http://driverdev.linuxdriverproject.org/mailman/listinfo/driverdev-devel

Reply via email to