[igt-dev] [PATCH 2/5] xe_vm: MMAP style VM binds section

Matthew Brost matthew.brost at intel.com
Fri Jul 14 04:13:38 UTC 2023


On Thu, Jul 13, 2023 at 11:24:47AM -0400, Rodrigo Vivi wrote:
> On Mon, Jul 10, 2023 at 07:58:53AM -0700, Matthew Brost wrote:
> > GPUVA added support for this let's test it.
> > 
> > Signed-off-by: Matthew Brost <matthew.brost at intel.com>
> > ---
> >  tests/xe/xe_vm.c | 350 ++++++++++++++++++++++++++++++++++++++++++-----
> >  1 file changed, 314 insertions(+), 36 deletions(-)
> > 
> > diff --git a/tests/xe/xe_vm.c b/tests/xe/xe_vm.c
> > index 04d6c3956..434bdb332 100644
> > --- a/tests/xe/xe_vm.c
> > +++ b/tests/xe/xe_vm.c
> > @@ -1249,9 +1249,9 @@ static void *hammer_thread(void *tdata)
> >  	return NULL;
> >  }
> >  
> > -#define MUNMAP_FLAG_USERPTR		(0x1 << 0)
> > -#define MUNMAP_FLAG_INVALIDATE		(0x1 << 1)
> > -#define MUNMAP_FLAG_HAMMER_FIRST_PAGE	(0x1 << 2)
> > +#define MAP_FLAG_USERPTR		(0x1 << 0)
> > +#define MAP_FLAG_INVALIDATE		(0x1 << 1)
> > +#define MAP_FLAG_HAMMER_FIRST_PAGE	(0x1 << 2)
> >  
> >  
> >  /**
> > @@ -1344,7 +1344,7 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
> >  	vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
> >  	bo_size = page_size * bo_n_pages;
> >  
> > -	if (flags & MUNMAP_FLAG_USERPTR) {
> > +	if (flags & MAP_FLAG_USERPTR) {
> >  		map = mmap(from_user_pointer(addr), bo_size, PROT_READ |
> >  			    PROT_WRITE, MAP_SHARED | MAP_FIXED |
> >  			    MAP_ANONYMOUS, -1, 0);
> > @@ -1363,7 +1363,7 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
> >  	/* Do initial binds */
> >  	bind_size = (page_size * bo_n_pages) / n_binds;
> >  	for (i = 0; i < n_binds; ++i) {
> > -		if (flags & MUNMAP_FLAG_USERPTR)
> > +		if (flags & MAP_FLAG_USERPTR)
> >  			xe_vm_bind_userptr_async(fd, vm, 0, addr, addr,
> >  						 bind_size, sync, 1);
> >  		else
> > @@ -1378,7 +1378,7 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
> >  	 * cause a fault if a rebind occurs during munmap style VM unbind
> >  	 * (partial VMAs unbound).
> >  	 */
> > -	if (flags & MUNMAP_FLAG_HAMMER_FIRST_PAGE) {
> > +	if (flags & MAP_FLAG_HAMMER_FIRST_PAGE) {
> >  		t.fd = fd;
> >  		t.vm = vm;
> >  #define PAGE_SIZE	4096
> > @@ -1437,7 +1437,7 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
> >  		data = map + i * page_size;
> >  		igt_assert_eq(data->data, 0xc0ffee);
> >  	}
> > -	if (flags & MUNMAP_FLAG_HAMMER_FIRST_PAGE) {
> > +	if (flags & MAP_FLAG_HAMMER_FIRST_PAGE) {
> >  		memset(map, 0, PAGE_SIZE / 2);
> >  		memset(map + PAGE_SIZE, 0, bo_size - PAGE_SIZE);
> >  	} else {
> > @@ -1487,7 +1487,7 @@ try_again_after_invalidate:
> >  			igt_assert_eq(data->data, 0xc0ffee);
> >  		}
> >  	}
> > -	if (flags & MUNMAP_FLAG_HAMMER_FIRST_PAGE) {
> > +	if (flags & MAP_FLAG_HAMMER_FIRST_PAGE) {
> >  		memset(map, 0, PAGE_SIZE / 2);
> >  		memset(map + PAGE_SIZE, 0, bo_size - PAGE_SIZE);
> >  	} else {
> > @@ -1498,7 +1498,7 @@ try_again_after_invalidate:
> >  	 * The munmap style VM unbind can create new VMAs, make sure those are
> >  	 * in the bookkeeping for another rebind after a userptr invalidate.
> >  	 */
> > -	if (flags & MUNMAP_FLAG_INVALIDATE && !invalidate++) {
> > +	if (flags & MAP_FLAG_INVALIDATE && !invalidate++) {
> >  		map = mmap(from_user_pointer(addr), bo_size, PROT_READ |
> >  			    PROT_WRITE, MAP_SHARED | MAP_FIXED |
> >  			    MAP_ANONYMOUS, -1, 0);
> > @@ -1509,7 +1509,7 @@ try_again_after_invalidate:
> >  	/* Confirm unbound region can be rebound */
> >  	syncobj_reset(fd, &sync[0].handle, 1);
> >  	sync[0].flags |= DRM_XE_SYNC_SIGNAL;
> > -	if (flags & MUNMAP_FLAG_USERPTR)
> > +	if (flags & MAP_FLAG_USERPTR)
> >  		xe_vm_bind_userptr_async(fd, vm, 0,
> >  					 addr + unbind_n_page_offfset * page_size,
> >  					 addr + unbind_n_page_offfset * page_size,
> > @@ -1557,7 +1557,7 @@ try_again_after_invalidate:
> >  		igt_assert_eq(data->data, 0xc0ffee);
> >  	}
> >  
> > -	if (flags & MUNMAP_FLAG_HAMMER_FIRST_PAGE) {
> > +	if (flags & MAP_FLAG_HAMMER_FIRST_PAGE) {
> >  		exit = 1;
> >  		pthread_join(t.thread, NULL);
> >  		pthread_barrier_destroy(&barrier);
> > @@ -1572,6 +1572,251 @@ try_again_after_invalidate:
> >  	xe_vm_destroy(fd, vm);
> >  }
> >  
> > +/**
> > + * SUBTEST: mmap-style-bind-%s
> > + * Description: Test mmap style unbind with %arg[1]
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + *
> > + * arg[1]:
> > + *
> > + * @all:				all
> > + * @one-partial:			one partial
> > + * @either-side-partial:		either side partial
> > + * @either-side-full:			either side full
> > + * @either-side-partial-hammer:		either side partial hammer
> > + * @end:				end
> > + * @front:				front
> > + * @many-all:				many all
> > + * @many-either-side-partial:		many either side partial
> > + * @many-either-side-partial-hammer:	many either side partial hammer
> > + * @userptr-all:			userptr all
> > + * @userptr-one-partial:		userptr one partial
> > + * @userptr-either-side-partial:	userptr either side partial
> > + * @userptr-either-side-full:		userptr either side full
> > + */
> > +
> > +static void
> > +test_mmap_style_bind(int fd, struct drm_xe_engine_class_instance *eci,
> > +		     int bo_n_pages, int n_binds, int unbind_n_page_offfset,
> > +		     int unbind_n_pages, unsigned int flags)
> > +{
> > +	struct drm_xe_sync sync[2] = {
> > +		{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
> > +		{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
> > +	};
> > +	struct drm_xe_exec exec = {
> > +		.num_batch_buffer = 1,
> > +		.num_syncs = 2,
> > +		.syncs = to_user_pointer(sync),
> > +	};
> > +	uint64_t addr = 0x1a0000, base_addr = 0x1a0000;
> > +	uint32_t vm;
> > +	uint32_t engine;
> > +	size_t bo_size;
> > +	uint32_t bo0 = 0, bo1 = 0;
> > +	uint64_t bind_size;
> > +	uint64_t page_size = xe_get_default_alignment(fd);
> 
> Do we have plans to add support to the other supported cases with different
> offsets, alignment, etc?
> 

The next patch does some of this. The way the test is structured you
just need to add a table entry too. 

> anyway this test looks correct to me
> 
> Reviewed-by: Rodrigo Vivi <rodrigo.vivi at intel.com>
> 

Thanks.

Matt

> > +	struct {
> > +		uint32_t batch[16];
> > +		uint64_t pad;
> > +		uint32_t data;
> > +	} *data;
> > +	void *map0, *map1;
> > +	int i, b;
> > +	struct thread_data t;
> > +	pthread_barrier_t barrier;
> > +	int exit = 0;
> > +
> > +	vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
> > +	bo_size = page_size * bo_n_pages;
> > +
> > +	if (flags & MAP_FLAG_USERPTR) {
> > +		map0 = mmap(from_user_pointer(addr), bo_size, PROT_READ |
> > +			    PROT_WRITE, MAP_SHARED | MAP_FIXED |
> > +			    MAP_ANONYMOUS, -1, 0);
> > +		map1 = mmap(from_user_pointer(addr + bo_size),
> > +			    bo_size, PROT_READ | PROT_WRITE, MAP_SHARED |
> > +			    MAP_FIXED | MAP_ANONYMOUS, -1, 0);
> > +		igt_assert(map0 != MAP_FAILED);
> > +		igt_assert(map1 != MAP_FAILED);
> > +	} else {
> > +		bo0 = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > +		map0 = xe_bo_map(fd, bo0, bo_size);
> > +		bo1 = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > +		map1 = xe_bo_map(fd, bo1, bo_size);
> > +	}
> > +	memset(map0, 0, bo_size);
> > +	memset(map1, 0, bo_size);
> > +
> > +	engine = xe_engine_create(fd, vm, eci, 0);
> > +
> > +	sync[0].handle = syncobj_create(fd, 0);
> > +	sync[1].handle = syncobj_create(fd, 0);
> > +
> > +	/* Do initial binds */
> > +	bind_size = (page_size * bo_n_pages) / n_binds;
> > +	for (i = 0; i < n_binds; ++i) {
> > +		if (flags & MAP_FLAG_USERPTR)
> > +			xe_vm_bind_userptr_async(fd, vm, 0, addr, addr,
> > +						 bind_size, sync, 1);
> > +		else
> > +			xe_vm_bind_async(fd, vm, 0, bo0, i * bind_size,
> > +					 addr, bind_size, sync, 1);
> > +		addr += bind_size;
> > +	}
> > +	addr = base_addr;
> > +
> > +	/*
> > +	 * Kick a thread to write the first page continously to ensure we can't
> > +	 * cause a fault if a rebind occurs during munmap style VM unbind
> > +	 * (partial VMAs unbound).
> > +	 */
> > +	if (flags & MAP_FLAG_HAMMER_FIRST_PAGE) {
> > +		t.fd = fd;
> > +		t.vm = vm;
> > +#define PAGE_SIZE	4096
> > +		t.addr = addr + PAGE_SIZE / 2;
> > +		t.eci = eci;
> > +		t.exit = &exit;
> > +		t.map = map0 + PAGE_SIZE / 2;
> > +		t.barrier = &barrier;
> > +		pthread_barrier_init(&barrier, NULL, 2);
> > +		pthread_create(&t.thread, 0, hammer_thread, &t);
> > +		pthread_barrier_wait(&barrier);
> > +	}
> > +
> > +	/* Verify we can use every page */
> > +	for (i = 0; i < n_binds; ++i) {
> > +		uint64_t batch_offset = (char *)&data->batch - (char *)data;
> > +		uint64_t batch_addr = addr + batch_offset;
> > +		uint64_t sdi_offset = (char *)&data->data - (char *)data;
> > +		uint64_t sdi_addr = addr + sdi_offset;
> > +		data = map0 + i * page_size;
> > +
> > +		b = 0;
> > +		data->batch[b++] = MI_STORE_DWORD_IMM_GEN4;
> > +		data->batch[b++] = sdi_addr;
> > +		data->batch[b++] = sdi_addr >> 32;
> > +		data->batch[b++] = 0xc0ffee;
> > +		data->batch[b++] = MI_BATCH_BUFFER_END;
> > +		igt_assert(b <= ARRAY_SIZE(data[i].batch));
> > +
> > +		sync[0].flags &= ~DRM_XE_SYNC_SIGNAL;
> > +		if (i)
> > +			syncobj_reset(fd, &sync[1].handle, 1);
> > +		sync[1].flags |= DRM_XE_SYNC_SIGNAL;
> > +
> > +		exec.engine_id = engine;
> > +		exec.address = batch_addr;
> > +		xe_exec(fd, &exec);
> > +
> > +		addr += page_size;
> > +	}
> > +	addr = base_addr;
> > +
> > +	/* Bind some of the pages to different BO / userptr */
> > +	syncobj_reset(fd, &sync[0].handle, 1);
> > +	sync[0].flags |= DRM_XE_SYNC_SIGNAL;
> > +	sync[1].flags &= ~DRM_XE_SYNC_SIGNAL;
> > +	if (flags & MAP_FLAG_USERPTR)
> > +		xe_vm_bind_userptr_async(fd, vm, 0, addr + bo_size +
> > +					 unbind_n_page_offfset * page_size,
> > +					 addr + unbind_n_page_offfset * page_size,
> > +					 unbind_n_pages * page_size, sync, 2);
> > +	else
> > +		xe_vm_bind_async(fd, vm, 0, bo1,
> > +				 unbind_n_page_offfset * page_size,
> > +				 addr + unbind_n_page_offfset * page_size,
> > +				 unbind_n_pages * page_size, sync, 2);
> > +	igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
> > +	igt_assert(syncobj_wait(fd, &sync[1].handle, 1, INT64_MAX, 0, NULL));
> > +
> > +	/* Verify all pages written */
> > +	for (i = 0; i < n_binds; ++i) {
> > +		data = map0 + i * page_size;
> > +		igt_assert_eq(data->data, 0xc0ffee);
> > +	}
> > +	if (flags & MAP_FLAG_HAMMER_FIRST_PAGE) {
> > +		memset(map0, 0, PAGE_SIZE / 2);
> > +		memset(map0 + PAGE_SIZE, 0, bo_size - PAGE_SIZE);
> > +	} else {
> > +		memset(map0, 0, bo_size);
> > +		memset(map1, 0, bo_size);
> > +	}
> > +
> > +	/* Verify we can use every page */
> > +	for (i = 0; i < n_binds; ++i) {
> > +		uint64_t batch_offset = (char *)&data->batch - (char *)data;
> > +		uint64_t batch_addr = addr + batch_offset;
> > +		uint64_t sdi_offset = (char *)&data->data - (char *)data;
> > +		uint64_t sdi_addr = addr + sdi_offset;
> > +
> > +		data = map0 + i * page_size;
> > +		b = 0;
> > +		data->batch[b++] = MI_STORE_DWORD_IMM_GEN4;
> > +		data->batch[b++] = sdi_addr;
> > +		data->batch[b++] = sdi_addr >> 32;
> > +		data->batch[b++] = 0xc0ffee;
> > +		data->batch[b++] = MI_BATCH_BUFFER_END;
> > +		igt_assert(b <= ARRAY_SIZE(data[i].batch));
> > +
> > +		data = map1 + i * page_size;
> > +		b = 0;
> > +		data->batch[b++] = MI_STORE_DWORD_IMM_GEN4;
> > +		data->batch[b++] = sdi_addr;
> > +		data->batch[b++] = sdi_addr >> 32;
> > +		data->batch[b++] = 0xc0ffee;
> > +		data->batch[b++] = MI_BATCH_BUFFER_END;
> > +		igt_assert(b <= ARRAY_SIZE(data[i].batch));
> > +
> > +		sync[0].flags &= ~DRM_XE_SYNC_SIGNAL;
> > +		if (i)
> > +			syncobj_reset(fd, &sync[1].handle, 1);
> > +		sync[1].flags |= DRM_XE_SYNC_SIGNAL;
> > +
> > +		exec.engine_id = engine;
> > +		exec.address = batch_addr;
> > +		xe_exec(fd, &exec);
> > +
> > +		addr += page_size;
> > +	}
> > +	addr = base_addr;
> > +
> > +	igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
> > +	igt_assert(syncobj_wait(fd, &sync[1].handle, 1, INT64_MAX, 0, NULL));
> > +
> > +	/* Verify all pages written */
> > +	for (i = 0; i < n_binds; ++i) {
> > +		uint32_t result = 0;
> > +
> > +		data = map0 + i * page_size;
> > +		result |= data->data;
> > +
> > +		data = map1 + i * page_size;
> > +		result |= data->data;
> > +
> > +		igt_assert_eq(result, 0xc0ffee);
> > +	}
> > +
> > +	if (flags & MAP_FLAG_HAMMER_FIRST_PAGE) {
> > +		exit = 1;
> > +		pthread_join(t.thread, NULL);
> > +		pthread_barrier_destroy(&barrier);
> > +	}
> > +
> > +	syncobj_destroy(fd, sync[0].handle);
> > +	syncobj_destroy(fd, sync[1].handle);
> > +	xe_engine_destroy(fd, engine);
> > +	munmap(map0, bo_size);
> > +	munmap(map1, bo_size);
> > +	if (bo0)
> > +		gem_close(fd, bo0);
> > +	if (bo1)
> > +		gem_close(fd, bo1);
> > +	xe_vm_destroy(fd, vm);
> > +}
> > +
> >  igt_main
> >  {
> >  	struct drm_xe_engine_class_instance *hwe, *hwe_non_copy = NULL;
> > @@ -1584,55 +1829,74 @@ igt_main
> >  		int unbind_n_page_offfset;
> >  		int unbind_n_pages;
> >  		unsigned int flags;
> > -	} sections[] = {
> > +	} munmap_sections[] = {
> >  		{ "all", 4, 2, 0, 4, 0 },
> >  		{ "one-partial", 4, 1, 1, 2, 0 },
> >  		{ "either-side-partial", 4, 2, 1, 2, 0 },
> >  		{ "either-side-partial-hammer", 4, 2, 1, 2,
> > -			MUNMAP_FLAG_HAMMER_FIRST_PAGE },
> > +			MAP_FLAG_HAMMER_FIRST_PAGE },
> >  		{ "either-side-full", 4, 4, 1, 2, 0 },
> >  		{ "end", 4, 2, 0, 3, 0 },
> >  		{ "front", 4, 2, 1, 3, 0 },
> >  		{ "many-all", 4 * 8, 2 * 8, 0 * 8, 4 * 8, 0 },
> >  		{ "many-either-side-partial", 4 * 8, 2 * 8, 1, 4 * 8 - 2, 0 },
> >  		{ "many-either-side-partial-hammer", 4 * 8, 2 * 8, 1, 4 * 8 - 2,
> > -			MUNMAP_FLAG_HAMMER_FIRST_PAGE },
> > +			MAP_FLAG_HAMMER_FIRST_PAGE },
> >  		{ "many-either-side-full", 4 * 8, 4 * 8, 1 * 8, 2 * 8, 0 },
> >  		{ "many-end", 4 * 8, 4, 0 * 8, 3 * 8 + 2, 0 },
> >  		{ "many-front", 4 * 8, 4, 1 * 8 - 2, 3 * 8 + 2, 0 },
> > -		{ "userptr-all", 4, 2, 0, 4, MUNMAP_FLAG_USERPTR },
> > -		{ "userptr-one-partial", 4, 1, 1, 2, MUNMAP_FLAG_USERPTR },
> > +		{ "userptr-all", 4, 2, 0, 4, MAP_FLAG_USERPTR },
> > +		{ "userptr-one-partial", 4, 1, 1, 2, MAP_FLAG_USERPTR },
> >  		{ "userptr-either-side-partial", 4, 2, 1, 2,
> > -			MUNMAP_FLAG_USERPTR },
> > +			MAP_FLAG_USERPTR },
> >  		{ "userptr-either-side-full", 4, 4, 1, 2,
> > -			MUNMAP_FLAG_USERPTR },
> > -		{ "userptr-end", 4, 2, 0, 3, MUNMAP_FLAG_USERPTR },
> > -		{ "userptr-front", 4, 2, 1, 3, MUNMAP_FLAG_USERPTR },
> > +			MAP_FLAG_USERPTR },
> > +		{ "userptr-end", 4, 2, 0, 3, MAP_FLAG_USERPTR },
> > +		{ "userptr-front", 4, 2, 1, 3, MAP_FLAG_USERPTR },
> >  		{ "userptr-many-all", 4 * 8, 2 * 8, 0 * 8, 4 * 8,
> > -			MUNMAP_FLAG_USERPTR },
> > +			MAP_FLAG_USERPTR },
> >  		{ "userptr-many-either-side-full", 4 * 8, 4 * 8, 1 * 8, 2 * 8,
> > -			MUNMAP_FLAG_USERPTR },
> > +			MAP_FLAG_USERPTR },
> >  		{ "userptr-many-end", 4 * 8, 4, 0 * 8, 3 * 8 + 2,
> > -			MUNMAP_FLAG_USERPTR },
> > +			MAP_FLAG_USERPTR },
> >  		{ "userptr-many-front", 4 * 8, 4, 1 * 8 - 2, 3 * 8 + 2,
> > -			MUNMAP_FLAG_USERPTR },
> > +			MAP_FLAG_USERPTR },
> >  		{ "userptr-inval-either-side-full", 4, 4, 1, 2,
> > -			MUNMAP_FLAG_USERPTR | MUNMAP_FLAG_INVALIDATE },
> > -		{ "userptr-inval-end", 4, 2, 0, 3, MUNMAP_FLAG_USERPTR |
> > -			MUNMAP_FLAG_INVALIDATE },
> > -		{ "userptr-inval-front", 4, 2, 1, 3, MUNMAP_FLAG_USERPTR |
> > -			MUNMAP_FLAG_INVALIDATE },
> > +			MAP_FLAG_USERPTR | MAP_FLAG_INVALIDATE },
> > +		{ "userptr-inval-end", 4, 2, 0, 3, MAP_FLAG_USERPTR |
> > +			MAP_FLAG_INVALIDATE },
> > +		{ "userptr-inval-front", 4, 2, 1, 3, MAP_FLAG_USERPTR |
> > +			MAP_FLAG_INVALIDATE },
> >  		{ "userptr-inval-many-all", 4 * 8, 2 * 8, 0 * 8, 4 * 8,
> > -			MUNMAP_FLAG_USERPTR | MUNMAP_FLAG_INVALIDATE },
> > +			MAP_FLAG_USERPTR | MAP_FLAG_INVALIDATE },
> >  		{ "userptr-inval-many-either-side-partial", 4 * 8, 2 * 8, 1,
> > -			4 * 8 - 2, MUNMAP_FLAG_USERPTR |
> > -				MUNMAP_FLAG_INVALIDATE },
> > +			4 * 8 - 2, MAP_FLAG_USERPTR |
> > +				MAP_FLAG_INVALIDATE },
> >  		{ "userptr-inval-many-either-side-full", 4 * 8, 4 * 8, 1 * 8,
> > -			2 * 8, MUNMAP_FLAG_USERPTR | MUNMAP_FLAG_INVALIDATE },
> > +			2 * 8, MAP_FLAG_USERPTR | MAP_FLAG_INVALIDATE },
> >  		{ "userptr-inval-many-end", 4 * 8, 4, 0 * 8, 3 * 8 + 2,
> > -			MUNMAP_FLAG_USERPTR | MUNMAP_FLAG_INVALIDATE },
> > +			MAP_FLAG_USERPTR | MAP_FLAG_INVALIDATE },
> >  		{ "userptr-inval-many-front", 4 * 8, 4, 1 * 8 - 2, 3 * 8 + 2,
> > -			MUNMAP_FLAG_USERPTR | MUNMAP_FLAG_INVALIDATE },
> > +			MAP_FLAG_USERPTR | MAP_FLAG_INVALIDATE },
> > +		{ NULL },
> > +	};
> > +	const struct section mmap_sections[] = {
> > +		{ "all", 4, 2, 0, 4, 0 },
> > +		{ "one-partial", 4, 1, 1, 2, 0 },
> > +		{ "either-side-partial", 4, 2, 1, 2, 0 },
> > +		{ "either-side-full", 4, 4, 1, 2, 0 },
> > +		{ "either-side-partial-hammer", 4, 2, 1, 2,
> > +			MAP_FLAG_HAMMER_FIRST_PAGE },
> > +		{ "end", 4, 2, 0, 3, 0 },
> > +		{ "front", 4, 2, 1, 3, 0 },
> > +		{ "many-all", 4 * 8, 2 * 8, 0 * 8, 4 * 8, 0 },
> > +		{ "many-either-side-partial", 4 * 8, 2 * 8, 1, 4 * 8 - 2, 0 },
> > +		{ "many-either-side-partial-hammer", 4 * 8, 2 * 8, 1, 4 * 8 - 2,
> > +			MAP_FLAG_HAMMER_FIRST_PAGE },
> > +		{ "userptr-all", 4, 2, 0, 4, MAP_FLAG_USERPTR },
> > +		{ "userptr-one-partial", 4, 1, 1, 2, MAP_FLAG_USERPTR },
> > +		{ "userptr-either-side-partial", 4, 2, 1, 2, MAP_FLAG_USERPTR },
> > +		{ "userptr-either-side-full", 4, 4, 1, 2, MAP_FLAG_USERPTR },
> >  		{ NULL },
> >  	};
> >  
> > @@ -1839,7 +2103,7 @@ igt_main
> >  			break;
> >  		}
> >  
> > -	for (const struct section *s = sections; s->name; s++) {
> > +	for (const struct section *s = munmap_sections; s->name; s++) {
> >  		igt_subtest_f("munmap-style-unbind-%s", s->name) {
> >  			igt_require_f(hwe_non_copy,
> >  				      "Requires non-copy engine to run\n");
> > @@ -1853,6 +2117,20 @@ igt_main
> >  		}
> >  	}
> >  
> > +	for (const struct section *s = mmap_sections; s->name; s++) {
> > +		igt_subtest_f("mmap-style-bind-%s", s->name) {
> > +			igt_require_f(hwe_non_copy,
> > +				      "Requires non-copy engine to run\n");
> > +
> > +			test_mmap_style_bind(fd, hwe_non_copy,
> > +					     s->bo_n_pages,
> > +					     s->n_binds,
> > +					     s->unbind_n_page_offfset,
> > +					     s->unbind_n_pages,
> > +					     s->flags);
> > +		}
> > +	}
> > +
> >  	igt_fixture
> >  		drm_close_driver(fd);
> >  }
> > -- 
> > 2.34.1
> > 


More information about the igt-dev mailing list