[09/13] staging/android: bring struct sync_pt back

Commit Message

Gustavo Padovan May 2, 2016, 3:23 p.m. UTC

From: Gustavo Padovan <[e-mail]>

Move the list_head members from sync_pt to struct fence was a mistake,
they will not be used by struct fence as planned before, so here we create
sync_pt again to bring the list heads back.

Signed-off-by: Gustavo Padovan <[e-mail]>
---
 drivers/staging/android/sync.c       | 40 ++++++++++++++++++------------------
 drivers/staging/android/sync.h       | 29 ++++++++++++++++++++++----
 drivers/staging/android/sync_debug.c | 16 +++++++--------
 include/linux/fence.h                |  2 --
 4 files changed, 53 insertions(+), 34 deletions(-)

Patch

diff --git a/drivers/staging/android/sync.c b/drivers/staging/android/sync.c
index c83a599..aab80ec 100644
--- a/drivers/staging/android/sync.c
+++ b/drivers/staging/android/sync.c
@@ -28,8 +28,6 @@ 
 #define CREATE_TRACE_POINTS
 #include "trace/sync.h"
 
-static const struct fence_ops timeline_fence_ops;
-
 struct sync_timeline *sync_timeline_create(const char *drv_name,
 					   const char *name)
 {
@@ -90,7 +88,7 @@  EXPORT_SYMBOL(sync_timeline_destroy);
 void sync_timeline_signal(struct sync_timeline *obj, unsigned int inc)
 {
 	unsigned long flags;
-	struct fence *fence, *next;
+	struct sync_pt *pt, *next;
 
 	trace_sync_timeline(obj);
 
@@ -98,37 +96,37 @@  void sync_timeline_signal(struct sync_timeline *obj, unsigned int inc)
 
 	obj->value += inc;
 
-	list_for_each_entry_safe(fence, next, &obj->active_list_head,
+	list_for_each_entry_safe(pt, next, &obj->active_list_head,
 				 active_list) {
-		if (fence_is_signaled_locked(fence))
-			list_del_init(&fence->active_list);
+		if (fence_is_signaled_locked(&pt->base))
+			list_del_init(&pt->active_list);
 	}
 
 	spin_unlock_irqrestore(&obj->child_list_lock, flags);
 }
 EXPORT_SYMBOL(sync_timeline_signal);
 
-struct fence *sync_pt_create(struct sync_timeline *obj, int size,
+struct sync_pt *sync_pt_create(struct sync_timeline *obj, int size,
 			     unsigned int value)
 {
 	unsigned long flags;
-	struct fence *fence;
+	struct sync_pt *pt;
 
-	if (size < sizeof(*fence))
+	if (size < sizeof(*pt))
 		return NULL;
 
-	fence = kzalloc(size, GFP_KERNEL);
-	if (!fence)
+	pt = kzalloc(size, GFP_KERNEL);
+	if (!pt)
 		return NULL;
 
 	spin_lock_irqsave(&obj->child_list_lock, flags);
 	sync_timeline_get(obj);
-	fence_init(fence, &timeline_fence_ops, &obj->child_list_lock,
+	fence_init(&pt->base, &timeline_fence_ops, &obj->child_list_lock,
 		   obj->context, value);
-	list_add_tail(&fence->child_list, &obj->child_list_head);
-	INIT_LIST_HEAD(&fence->active_list);
+	list_add_tail(&pt->child_list, &obj->child_list_head);
+	INIT_LIST_HEAD(&pt->active_list);
 	spin_unlock_irqrestore(&obj->child_list_lock, flags);
-	return fence;
+	return pt;
 }
 EXPORT_SYMBOL(sync_pt_create);
 
@@ -148,13 +146,14 @@  static const char *timeline_fence_get_timeline_name(struct fence *fence)
 
 static void timeline_fence_release(struct fence *fence)
 {
+	struct sync_pt *pt = fence_to_sync_pt(fence);
 	struct sync_timeline *parent = fence_parent(fence);
 	unsigned long flags;
 
 	spin_lock_irqsave(fence->lock, flags);
-	list_del(&fence->child_list);
-	if (WARN_ON_ONCE(!list_empty(&fence->active_list)))
-		list_del(&fence->active_list);
+	list_del(&pt->child_list);
+	if (WARN_ON_ONCE(!list_empty(&pt->active_list)))
+		list_del(&pt->active_list);
 	spin_unlock_irqrestore(fence->lock, flags);
 
 	sync_timeline_put(parent);
@@ -170,12 +169,13 @@  static bool timeline_fence_signaled(struct fence *fence)
 
 static bool timeline_fence_enable_signaling(struct fence *fence)
 {
+	struct sync_pt *pt = fence_to_sync_pt(fence);
 	struct sync_timeline *parent = fence_parent(fence);
 
 	if (timeline_fence_signaled(fence))
 		return false;
 
-	list_add_tail(&fence->active_list, &parent->active_list_head);
+	list_add_tail(&pt->active_list, &parent->active_list_head);
 	return true;
 }
 
@@ -193,7 +193,7 @@  static void timeline_fence_timeline_value_str(struct fence *fence,
 	snprintf(str, size, "%d", parent->value);
 }
 
-static const struct fence_ops timeline_fence_ops = {
+const struct fence_ops timeline_fence_ops = {
 	.get_driver_name = timeline_fence_get_driver_name,
 	.get_timeline_name = timeline_fence_get_timeline_name,
 	.enable_signaling = timeline_fence_enable_signaling,
diff --git a/drivers/staging/android/sync.h b/drivers/staging/android/sync.h
index f2fbf98..14b61cb 100644
--- a/drivers/staging/android/sync.h
+++ b/drivers/staging/android/sync.h
@@ -60,6 +60,27 @@  static inline struct sync_timeline *fence_parent(struct fence *fence)
 			    child_list_lock);
 }
 
+/**
+ * struct sync_pt - sync_pt object
+ * @base: base fence object
+ * @child_list: sync timeline child's list
+ * @active_list: sync timeline active child's list
+ */
+struct sync_pt {
+	struct fence base;
+	struct list_head child_list;
+	struct list_head active_list;
+};
+
+extern const struct fence_ops timeline_fence_ops;
+
+static inline struct sync_pt *fence_to_sync_pt(struct fence *fence)
+{
+	if (fence->ops != &timeline_fence_ops)
+		return NULL;
+	return container_of(fence, struct sync_pt, base);
+}
+
 /*
  * API for sync_timeline implementers
  */
@@ -101,13 +122,13 @@  void sync_timeline_signal(struct sync_timeline *obj, unsigned int inc);
  * @size:	size to allocate for this pt
  * @inc:	value of the fence
  *
- * Creates a new fence as a child of @parent.  @size bytes will be
+ * Creates a new sync_pt as a child of @parent.  @size bytes will be
  * allocated allowing for implementation specific data to be kept after
- * the generic sync_timeline struct. Returns the fence object or
+ * the generic sync_timeline struct. Returns the sync_pt object or
  * NULL in case of error.
  */
-struct fence *sync_pt_create(struct sync_timeline *parent, int size,
-			     unsigned int inc);
+struct sync_pt *sync_pt_create(struct sync_timeline *parent, int size,
+			       unsigned int inc);
 
 #ifdef CONFIG_DEBUG_FS
 
diff --git a/drivers/staging/android/sync_debug.c b/drivers/staging/android/sync_debug.c
index cb0f888..703f198 100644
--- a/drivers/staging/android/sync_debug.c
+++ b/drivers/staging/android/sync_debug.c
@@ -140,9 +140,9 @@  static void sync_print_obj(struct seq_file *s, struct sync_timeline *obj)
 
 	spin_lock_irqsave(&obj->child_list_lock, flags);
 	list_for_each(pos, &obj->child_list_head) {
-		struct fence *fence =
-			container_of(pos, struct fence, child_list);
-		sync_print_fence(s, fence, false);
+		struct sync_pt *pt =
+			container_of(pos, struct sync_pt, child_list);
+		sync_print_fence(s, &pt->base, false);
 	}
 	spin_unlock_irqrestore(&obj->child_list_lock, flags);
 }
@@ -240,7 +240,7 @@  static long sw_sync_ioctl_create_fence(struct sync_timeline *obj,
 {
 	int fd = get_unused_fd_flags(O_CLOEXEC);
 	int err;
-	struct fence *fence;
+	struct sync_pt *pt;
 	struct sync_file *sync_file;
 	struct sw_sync_create_fence_data data;
 
@@ -252,15 +252,15 @@  static long sw_sync_ioctl_create_fence(struct sync_timeline *obj,
 		goto err;
 	}
 
-	fence = sync_pt_create(obj, sizeof(*fence), data.value);
-	if (!fence) {
+	pt = sync_pt_create(obj, sizeof(*pt), data.value);
+	if (!pt) {
 		err = -ENOMEM;
 		goto err;
 	}
 
-	sync_file = sync_file_create(fence);
+	sync_file = sync_file_create(&pt->base);
 	if (!sync_file) {
-		fence_put(fence);
+		fence_put(&pt->base);
 		err = -ENOMEM;
 		goto err;
 	}
diff --git a/include/linux/fence.h b/include/linux/fence.h
index 2b17698..5aa95eb 100644
--- a/include/linux/fence.h
+++ b/include/linux/fence.h
@@ -79,8 +79,6 @@  struct fence {
 	unsigned long flags;
 	ktime_t timestamp;
 	int status;
-	struct list_head child_list;
-	struct list_head active_list;
 };
 
 enum fence_flag_bits {