 @@ -1,14 +1,14 @@
-/*	$NetBSD: linux_dma_resv.c,v 1.21 2021/12/19 12:36:02 riastradh Exp $	*/
+/*	$NetBSD: linux_dma_resv.c,v 1.22 2022/02/15 22:51:03 riastradh Exp $	*/
 /*-
  * Copyright (c) 2018 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Taylor R. Campbell.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -20,52 +20,63 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: linux_dma_resv.c,v 1.21 2021/12/19 12:36:02 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: linux_dma_resv.c,v 1.22 2022/02/15 22:51:03 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/poll.h>
 #include <sys/select.h>
 #include <linux/dma-fence.h>
 #include <linux/dma-resv.h>
 #include <linux/seqlock.h>
 #include <linux/ww_mutex.h>
 DEFINE_WW_CLASS(reservation_ww_class __cacheline_aligned);
 static struct dma_resv_list *
 objlist_tryalloc(uint32_t n)
+{
 	struct dma_resv_list *list;
 	list = kmem_alloc(offsetof(typeof(*list), shared[n]), KM_NOSLEEP);
 	if (list == NULL)
 		return NULL;
 	list->shared_max = n;
 	return list;
+}
 static struct dma_resv_list *
 objlist_alloc(uint32_t n)
+{
 	struct dma_resv_list *list;
 	list = kmem_alloc(offsetof(typeof(*list), shared[n]), KM_SLEEP);
 	list->shared_max = n;
 	return list;
+}
 static void
 objlist_free(struct dma_resv_list *list)
+{
 	uint32_t n = list->shared_max;
 	kmem_free(list, offsetof(typeof(*list), shared[n]));
+}
 static void
 objlist_free_cb(struct rcu_head *rcu)
+{
 	struct dma_resv_list *list = container_of(rcu,
 	    struct dma_resv_list, rol_rcu);
 @@ -336,39 +347,36 @@ dma_resv_reserve_shared(struct dma_resv
 	} else {
 		/* No list already.  We need space for num_fences.  */
 		n = num_fences;
+	}
 	/* If not, maybe there's a preallocated list ready.  */
 	if (prealloc != NULL) {
 		/* If there's enough room in it, stop here.  */
 		if (n <= prealloc->shared_max)
 			return 0;
 		/* Try to double its capacity.  */
 		nalloc = n > UINT32_MAX/2 ? UINT32_MAX : 2*n;
-		prealloc = objlist_tryalloc(nalloc);
+		prealloc = objlist_alloc(nalloc);
 		if (prealloc == NULL)
 			return -ENOMEM;
 		/* Swap the new preallocated list and free the old one.  */
 		objlist_free(robj->robj_prealloc);
 		robj->robj_prealloc = prealloc;
 	} else {
 		/* Start with some spare.  */
 		nalloc = n > UINT32_MAX/2 ? UINT32_MAX : MAX(2*n, 4);
-		prealloc = objlist_tryalloc(nalloc);
+		prealloc = objlist_alloc(nalloc);
 		if (prealloc == NULL)
 			return -ENOMEM;
 		/* Save the new preallocated list.  */
 		robj->robj_prealloc = prealloc;
+	}
 	/* Success!  */
 	return 0;
+}
 struct dma_resv_write_ticket {
 };
 /*
  * dma_resv_write_begin(robj, ticket)
 @@ -679,28 +687,30 @@ dma_resv_add_shared_fence(struct dma_res
 		 */
 		for (i = 0; i < shared_count; i++) {
 			if (replace == NULL &&
 			    list->shared[i]->context == fence->context) {
 				replace = list->shared[i];
 				prealloc->shared[i] = fence;
 			} else {
 				prealloc->shared[i] = list->shared[i];
+			}
+		}
 		prealloc->shared_count = shared_count;
 		/* If we didn't find one, add it at the end.  */
-		if (replace == NULL)
+		if (replace == NULL) {
 			KASSERT(prealloc->shared_count < prealloc->shared_max);
 			prealloc->shared[prealloc->shared_count++] = fence;
+		}
 		/*
 		 * Now ready to replace the list.  Begin an update.
 		 * Implies membar_producer for fence and prealloc.
 		 */
 		dma_resv_write_begin(robj, &ticket);
 		/* Replace the list.  */
 		atomic_store_relaxed(&robj->fence, prealloc);
 		robj->robj_prealloc = NULL;
 		/* Commit the update.  */
 		dma_resv_write_commit(robj, &ticket);
 @@ -909,31 +919,40 @@ dma_resv_copy_fences(struct dma_resv *ds
 	KASSERT(dma_resv_held(dst_robj));
 top:	KASSERT(fence == NULL);
 	/* Enter an RCU read section and get a read ticket.  */
 	rcu_read_lock();
 	dma_resv_read_begin(src_robj, &read_ticket);
 	/* Get the shared list.  */
 	if (!dma_resv_get_shared_reader(src_robj, &src_list, &shared_count,
 		&read_ticket))
 		goto restart;
-	if (src_list != NULL) {
+	if (src_list) {
-		/* Allocate a new list.  */
+		/* Allocate a new list, if necessary.  */
 		dst_list = objlist_tryalloc(shared_count);
 		if (dst_list == NULL)
-			return -ENOMEM;
+			dst_list = objlist_tryalloc(shared_count);
 		if (dst_list == NULL || dst_list->shared_max < shared_count) {
 			rcu_read_unlock();
 			if (dst_list) {
 				objlist_free(dst_list);
 				dst_list = NULL;
+			}
 			dst_list = objlist_alloc(shared_count);
 			dst_list->shared_count = 0; /* paranoia */
 			goto top;
+		}
 		/* Copy over all fences that are not yet signalled.  */
 		dst_list->shared_count = 0;
 		for (i = 0; i < shared_count; i++) {
 			KASSERT(fence == NULL);
 			fence = atomic_load_relaxed(&src_list->shared[i]);
 			if ((fence = dma_fence_get_rcu(fence)) == NULL)
 				goto restart;
 			if (dma_fence_is_signaled(fence)) {
 				dma_fence_put(fence);
 				fence = NULL;
 				continue;
+			}
 @@ -995,28 +1014,27 @@ top:	KASSERT(fence == NULL);
+	}
 	/* Success!  */
 	return 0;
 restart:
 	KASSERT(fence == NULL);
 	rcu_read_unlock();
 	if (dst_list) {
 		for (i = dst_list->shared_count; i --> 0;) {
 			dma_fence_put(dst_list->shared[i]);
 			dst_list->shared[i] = NULL; /* paranoia */
+		}
-		objlist_free(dst_list);
+		/* reuse dst_list allocation for the next attempt */
 		dst_list = NULL;
+	}
 	goto top;
+}
 /*
  * dma_resv_test_signaled_rcu(robj, shared)
+ *
  *	If shared is true, test whether all of the shared fences are
  *	signalled, or if there are none, test whether the exclusive
  *	fence is signalled.  If shared is false, test only whether the
  *	exclusive fence is signalled.
+ *
  *	XXX Why does this _not_ test the exclusive fence if shared is