zephyr: lib: alloc: fine-tune logic in z_impl_sof_heap_alloc()

Modify the special handling of SOF_MEM_FLAG_USER_SHARED_BUFFER and
SOF_MEM_FLAG_LARGE_BUFFER in z_impl_sof_heap_alloc().

First make the shared user heap special handling conditional on
CONFIG_SOF_USERSPACE_USE_SHARED_HEAP. This flag is a special case as it
is not a hint to the allocator but rather an explicit selector for a
specific heap (similar to SOF_MEM_FLAG_L3). If defined in build, and the
flag is passed to sof_heap_alloc(), the heap argument is ignored, and
instead the shared user heap instance is always used. No functional
change to current code.

Unlike the shared heap flag, SOF_MEM_FLAG_LARGE_BUFFER is a more
traditional flag, which serves as a hint to the allocator. Modify the
implementation to ignore this flag if the caller has passed a non-NULL
heap. Assumption here is that the heap user has passed is more suitable
for large buffers than use of default rballoc_align(), so the hint can
be ignored. This is especially important for cases where e.g. the caller
is allocating memory to a different memory domain and using default
rballoc_align() would result in access errors. If no heap is passed, the
existing logic to use rballoc_align() is used. Functionality is modified
only for cases where a custom heap is passed to alloc.

Signed-off-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>

Author: kv2019i

zephyr/lib/alloc.c

@@ -631,11 +631,26 @@ EXPORT_SYMBOL(rfree);
 void *z_impl_sof_heap_alloc(struct k_heap *heap, uint32_t flags, size_t bytes,
 			    size_t alignment)
 {
-	if (flags & (SOF_MEM_FLAG_LARGE_BUFFER | SOF_MEM_FLAG_USER_SHARED_BUFFER))
+#if CONFIG_SOF_USERSPACE_USE_SHARED_HEAP
+	/*
+	 * FLAG_USER_SHARED_BUFFER maps to a specific heap, so
+	 * the passed 'heap' can be ignored
+	 */
+	if (flags & SOF_MEM_FLAG_USER_SHARED_BUFFER)
 		return rballoc_align(flags, bytes, alignment);
+#endif
+
+	if (!heap) {
+		/*
+		 * Ensure virtual heap is utilized for large buffers
+		 * if no heap is explicitly passed. rballoc_align()
+		 * has this logic.
+		 */
+		if (flags & SOF_MEM_FLAG_LARGE_BUFFER)
+			return rballoc_align(flags, bytes, alignment);
 
-	if (!heap)
 		heap = &sof_heap;
+	}
 
 	if (flags & SOF_MEM_FLAG_COHERENT)
 		return heap_alloc_aligned(heap, alignment, bytes);

zephyr/syscall/alloc.c

@@ -12,7 +12,8 @@ static inline void *z_vrfy_sof_heap_alloc(struct k_heap *heap, uint32_t flags,
 {
 	/* only allow flags that are safe for user-space heap isolation */
 	static const uint32_t allowed_flags =
-		SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT | SOF_MEM_FLAG_DMA;
+		SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT | SOF_MEM_FLAG_DMA |
+		SOF_MEM_FLAG_LARGE_BUFFER;
 
 	K_OOPS(flags & ~allowed_flags);