[igt-dev] [PATCH i-g-t v3 01/11] lib/igt_dummyload: add igt_cork

[Antonio Argenziano]

From: Daniele Ceraolo Spurio <daniele.ceraolospurio at intel.com>

The "cork" bo (imported bo with attached fence) and fence is used in several
tests to stall execution. Moving it to a common place makes the codebase
cleaner.

Note that the actual test updates is done in follow up patches as it is
simpler to do in one go after one more common function is added in the
next patch.

v2: don't use new/free naming, don't use dynamic alloc (Chris)
v3: add sw_sync common functions. (Chris)

Signed-off-by: Daniele Ceraolo Spurio <daniele.ceraolospurio at intel.com>
Signed-off-by: Antonio Argenziano <antonio.argenziano at intel.com>
Cc: Chris Wilson <chris at chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio at intel.com>
---
 lib/igt_dummyload.c | 119 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_dummyload.h |  15 +++++++
 2 files changed, 134 insertions(+)

diff --git a/lib/igt_dummyload.c b/lib/igt_dummyload.c
index 27eb402b..bd12d283 100644
--- a/lib/igt_dummyload.c
+++ b/lib/igt_dummyload.c
@@ -29,12 +29,14 @@
 #include <i915_drm.h>
 
 #include "igt_core.h"
+#include "drmtest.h"
 #include "igt_dummyload.h"
 #include "igt_gt.h"
 #include "intel_chipset.h"
 #include "intel_reg.h"
 #include "ioctl_wrappers.h"
 #include "sw_sync.h"
+#include "igt_vgem.h"
 
 /**
  * SECTION:igt_dummyload
@@ -371,3 +373,120 @@ void igt_terminate_spin_batches(void)
 		igt_spin_batch_end(iter);
 	pthread_mutex_unlock(&list_lock);
 }
+
+static uint32_t igt_cork_plug_vgem(int fd, struct igt_cork_vgem *cork)
+{
+	struct vgem_bo bo;
+	int dmabuf;
+	uint32_t handle;
+
+	cork->device = drm_open_driver(DRIVER_VGEM);
+	igt_require(vgem_has_fences(cork->device));
+
+	bo.width = bo.height = 1;
+	bo.bpp = 4;
+	vgem_create(cork->device, &bo);
+	cork->fence = vgem_fence_attach(cork->device, &bo, VGEM_FENCE_WRITE);
+
+	dmabuf = prime_handle_to_fd(cork->device, bo.handle);
+	handle = prime_fd_to_handle(fd, dmabuf);
+	close(dmabuf);
+
+	return handle;
+}
+
+static void igt_cork_unplug_vgem(struct igt_cork_vgem *cork)
+{
+	igt_assert(cork->device);
+
+	vgem_fence_signal(cork->device, cork->fence);
+	close(cork->device);
+	cork->device = -1;
+}
+
+static uint32_t igt_cork_plug_sw_sync(struct igt_cork_sw_sync *cork)
+{
+	int fence;
+
+	igt_require_sw_sync();
+
+	cork->timeline = sw_sync_timeline_create();
+	fence = sw_sync_timeline_create_fence(cork->timeline, 1);
+
+	return fence;
+}
+
+static void igt_cork_unplug_sw_sync(struct igt_cork_sw_sync *cork)
+{
+	sw_sync_timeline_inc(cork->timeline, 1);
+	close(cork->timeline);
+}
+
+/**
+ * igt_cork_plug:
+ * @fd: open drm file descriptor
+ * @method: method to utilize for corking.
+ * @cork: structure that will be filled with the state of the cork bo.
+ * Note: this has to match the corking method.
+ *
+ * This function provides a mechanism to stall submission. It provides two
+ * blocking methods:
+ *
+ * VGEM_BO.
+ * Imports a vgem bo with a fence attached to it. This bo can be used as a
+ * dependency during submission to stall execution until the fence is signaled.
+ *
+ * SW_SYNC:
+ * Creates a timeline and then a fence on that timeline. The fence can be used
+ * as an input fence to a request, the request will be stalled until the fence
+ * is signaled.
+ *
+ * The parameters required to unblock the execution and to cleanup are stored in
+ * the provided cork structure.
+ *
+ * Returns:
+ * Handle of the imported BO / Sw sync fence FD.
+ */
+uint32_t igt_cork_plug(int fd, unsigned method, void *cork)
+{
+	igt_assert(cork);
+
+	switch (method) {
+		case SW_SYNC:
+			return igt_cork_plug_sw_sync((struct igt_cork_sw_sync*) cork);
+			break;
+		case VGEM_BO:
+			return igt_cork_plug_vgem(fd, (struct igt_cork_vgem*) cork);
+			break;
+		default:
+			igt_assert_f(0, "Invalid corking method!");
+			break;
+	};
+}
+
+/**
+ * igt_cork_unplug:
+ * @method: method to utilize for corking.
+ * @cork: cork state from igt_cork_plug()
+ *
+ * This function unblocks the execution by signaling the fence attached to the
+ * imported bo and does the necessary post-processing.
+ *
+ * NOTE: the handle returned by igt_cork_plug is not closed during this phase.
+ */
+void igt_cork_unplug(unsigned method, void *cork)
+{
+	igt_assert(cork);
+
+	switch (method) {
+		case SW_SYNC:
+			igt_cork_unplug_sw_sync((struct igt_cork_sw_sync*) cork);
+			break;
+		case VGEM_BO:
+			igt_cork_unplug_vgem((struct igt_cork_vgem*) cork);
+			break;
+		default:
+			igt_assert_f(0, "Invalid unplugging method!");
+			break;
+	};
+}
diff --git a/lib/igt_dummyload.h b/lib/igt_dummyload.h
index ffa7e351..08bd2ed2 100644
--- a/lib/igt_dummyload.h
+++ b/lib/igt_dummyload.h
@@ -61,4 +61,19 @@ void igt_spin_batch_free(int fd, igt_spin_t *spin);
 
 void igt_terminate_spin_batches(void);
 
+#define SW_SYNC 1
+#define VGEM_BO 2
+
+struct igt_cork_vgem {
+	int device;
+	uint32_t fence;
+};
+
+struct igt_cork_sw_sync {
+	int timeline;
+};
+
+uint32_t igt_cork_plug(int fd, unsigned method, void *cork);
+void igt_cork_unplug(unsigned method, void *cork);
+
 #endif /* __IGT_DUMMYLOAD_H__ */
-- 
2.14.2