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

[Chris Wilson]

Quoting Antonio Argenziano (2018-02-16 00:43:00)
> 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)

unions are your friend here.

	struct igt_cork {
		enum igt_cork_type type;
		union igt_cork_type {
			int fd;

			struct igt_cork_vgem {
				int device;
				uint32_t fence;
			} vgem;

			struct igt_cork_sw_sync {
				int timeline;
			} sw_sync;
		};
	}

void igt_cork_init(struct igt_cork *cork, enum igt_cork_type)
{
	cork->type = type;
	cork->fd = -1;
}

#define IGT_CORK(name, type) struct igt_cork name = { .type = type, .fd = -1}
#define IGT_CORK_HANDLE(name) IGT_CORK(name, CORK_VGEM_HANDLE)
#define IGT_CORK_FENCE(name) IGT_CORK(name, CORK_SYNC_FD)

uint32_t igt_cork_plug(struct igt_cork *cork, int fd)
{
	igt_assert(cork->fd == -1);

	switch (method) {
	case CORK_SYNC_FD:
		return plug_sync_fd(&cork->sw_sync, fd);

	case CORK_VGEM_HANDLE:
		return plug_vgem_handle(&cork->vgem, fd);

	default:...
	}
}

void igt_cork_unplug(struct igt_cork *cork)
{
	switch (cork->type) {
	case CORK_SYNC_FD:
		return unplug_sync_fd(&cork->sw_sync);

	case CORK_VGEM_HANDLE:
		return unplug_vgem_handle(&cork->vgem);
	}
}