[PATCH 1/2] dma-buf: add dma_fence_unwrap
Christian König
christian.koenig at amd.com
Fri Mar 25 07:42:46 UTC 2022
Once more a ping on this here.
It's fixing a warning with sync_files and is already tested.
Regards,
Christian.
Am 21.03.22 um 11:31 schrieb Christian König:
> [Adding Daniel]
>
> Just once more a ping for this.
>
> It's an important bug fix and the end user already reported that it
> works.
>
> Regards,
> Christian.
>
> Am 14.03.22 um 12:14 schrieb Christian König:
>> Just a gentle ping.
>>
>> This series is an important fix for drm-misc-next-fixes.
>>
>> Regards,
>> Christian.
>>
>> Am 11.03.22 um 12:02 schrieb Christian König:
>>> Add a general purpose helper to deep dive into
>>> dma_fence_chain/dma_fence_array
>>> structures and iterate over all the fences in them.
>>>
>>> This is useful when we need to flatten out all fences in those
>>> structures.
>>>
>>> Signed-off-by: Christian König <christian.koenig at amd.com>
>>> ---
>>> Documentation/driver-api/dma-buf.rst | 6 +
>>> drivers/dma-buf/Makefile | 1 +
>>> drivers/dma-buf/selftests.h | 1 +
>>> drivers/dma-buf/st-dma-fence-unwrap.c | 279
>>> ++++++++++++++++++++++++++
>>> include/linux/dma-fence-unwrap.h | 99 +++++++++
>>> 5 files changed, 386 insertions(+)
>>> create mode 100644 drivers/dma-buf/st-dma-fence-unwrap.c
>>> create mode 100644 include/linux/dma-fence-unwrap.h
>>>
>>> diff --git a/Documentation/driver-api/dma-buf.rst
>>> b/Documentation/driver-api/dma-buf.rst
>>> index 2cd7db82d9fe..7209500f08c8 100644
>>> --- a/Documentation/driver-api/dma-buf.rst
>>> +++ b/Documentation/driver-api/dma-buf.rst
>>> @@ -194,6 +194,12 @@ DMA Fence Chain
>>> .. kernel-doc:: include/linux/dma-fence-chain.h
>>> :internal:
>>> +DMA Fence unwrap
>>> +~~~~~~~~~~~~~~~~
>>> +
>>> +.. kernel-doc:: include/linux/dma-fence-unwrap.h
>>> + :internal:
>>> +
>>> DMA Fence uABI/Sync File
>>> ~~~~~~~~~~~~~~~~~~~~~~~~
>>> diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile
>>> index 511805dbeb75..4c9eb53ba3f8 100644
>>> --- a/drivers/dma-buf/Makefile
>>> +++ b/drivers/dma-buf/Makefile
>>> @@ -12,6 +12,7 @@ dmabuf_selftests-y := \
>>> selftest.o \
>>> st-dma-fence.o \
>>> st-dma-fence-chain.o \
>>> + st-dma-fence-unwrap.o \
>>> st-dma-resv.o
>>> obj-$(CONFIG_DMABUF_SELFTESTS) += dmabuf_selftests.o
>>> diff --git a/drivers/dma-buf/selftests.h b/drivers/dma-buf/selftests.h
>>> index 97d73aaa31da..851965867d9c 100644
>>> --- a/drivers/dma-buf/selftests.h
>>> +++ b/drivers/dma-buf/selftests.h
>>> @@ -12,4 +12,5 @@
>>> selftest(sanitycheck, __sanitycheck__) /* keep first (igt
>>> selfcheck) */
>>> selftest(dma_fence, dma_fence)
>>> selftest(dma_fence_chain, dma_fence_chain)
>>> +selftest(dma_fence_unwrap, dma_fence_unwrap)
>>> selftest(dma_resv, dma_resv)
>>> diff --git a/drivers/dma-buf/st-dma-fence-unwrap.c
>>> b/drivers/dma-buf/st-dma-fence-unwrap.c
>>> new file mode 100644
>>> index 000000000000..d821faaebe93
>>> --- /dev/null
>>> +++ b/drivers/dma-buf/st-dma-fence-unwrap.c
>>> @@ -0,0 +1,279 @@
>>> +// SPDX-License-Identifier: MIT
>>> +
>>> +/*
>>> + * Copyright (C) 2022 Advanced Micro Devices, Inc.
>>> + */
>>> +
>>> +#include <linux/dma-fence-unwrap.h>
>>> +#if 0
>>> +#include <linux/kernel.h>
>>> +#include <linux/kthread.h>
>>> +#include <linux/mm.h>
>>> +#include <linux/sched/signal.h>
>>> +#include <linux/slab.h>
>>> +#include <linux/spinlock.h>
>>> +#include <linux/random.h>
>>> +#endif
>>> +
>>> +#include "selftest.h"
>>> +
>>> +#define CHAIN_SZ (4 << 10)
>>> +
>>> +static struct kmem_cache *slab_fences;
>>> +
>>> +static inline struct mock_fence {
>>> + struct dma_fence base;
>>> + spinlock_t lock;
>>> +} *to_mock_fence(struct dma_fence *f) {
>>> + return container_of(f, struct mock_fence, base);
>>> +}
>>> +
>>> +static const char *mock_name(struct dma_fence *f)
>>> +{
>>> + return "mock";
>>> +}
>>> +
>>> +static void mock_fence_release(struct dma_fence *f)
>>> +{
>>> + kmem_cache_free(slab_fences, to_mock_fence(f));
>>> +}
>>> +
>>> +static const struct dma_fence_ops mock_ops = {
>>> + .get_driver_name = mock_name,
>>> + .get_timeline_name = mock_name,
>>> + .release = mock_fence_release,
>>> +};
>>> +
>>> +static struct dma_fence *mock_fence(void)
>>> +{
>>> + struct mock_fence *f;
>>> +
>>> + f = kmem_cache_alloc(slab_fences, GFP_KERNEL);
>>> + if (!f)
>>> + return NULL;
>>> +
>>> + spin_lock_init(&f->lock);
>>> + dma_fence_init(&f->base, &mock_ops, &f->lock, 0, 0);
>>> +
>>> + return &f->base;
>>> +}
>>> +
>>> +static struct dma_fence *mock_array(unsigned int num_fences, ...)
>>> +{
>>> + struct dma_fence_array *array;
>>> + struct dma_fence **fences;
>>> + va_list valist;
>>> + int i;
>>> +
>>> + fences = kcalloc(num_fences, sizeof(*fences), GFP_KERNEL);
>>> + if (!fences)
>>> + return NULL;
>>> +
>>> + va_start(valist, num_fences);
>>> + for (i = 0; i < num_fences; ++i)
>>> + fences[i] = va_arg(valist, typeof(*fences));
>>> + va_end(valist);
>>> +
>>> + array = dma_fence_array_create(num_fences, fences,
>>> + dma_fence_context_alloc(1),
>>> + 1, false);
>>> + if (!array)
>>> + goto cleanup;
>>> + return &array->base;
>>> +
>>> +cleanup:
>>> + for (i = 0; i < num_fences; ++i)
>>> + dma_fence_put(fences[i]);
>>> + kfree(fences);
>>> + return NULL;
>>> +}
>>> +
>>> +static struct dma_fence *mock_chain(struct dma_fence *prev,
>>> + struct dma_fence *fence)
>>> +{
>>> + struct dma_fence_chain *f;
>>> +
>>> + f = dma_fence_chain_alloc();
>>> + if (!f) {
>>> + dma_fence_put(prev);
>>> + dma_fence_put(fence);
>>> + return NULL;
>>> + }
>>> +
>>> + dma_fence_chain_init(f, prev, fence, 1);
>>> + return &f->base;
>>> +}
>>> +
>>> +static int sanitycheck(void *arg)
>>> +{
>>> + struct dma_fence *f, *chain, *array;
>>> + int err = 0;
>>> +
>>> + f = mock_fence();
>>> + if (!f)
>>> + return -ENOMEM;
>>> +
>>> + array = mock_array(1, f);
>>> + if (!array)
>>> + return -ENOMEM;
>>> +
>>> + chain = mock_chain(NULL, array);
>>> + if (!chain)
>>> + return -ENOMEM;
>>> +
>>> + dma_fence_signal(f);
>>> + dma_fence_put(chain);
>>> + return err;
>>> +}
>>> +
>>> +static int unwrap_array(void *arg)
>>> +{
>>> + struct dma_fence *fence, *f1, *f2, *array;
>>> + struct dma_fence_unwrap iter;
>>> + int err = 0;
>>> +
>>> + f1 = mock_fence();
>>> + if (!f1)
>>> + return -ENOMEM;
>>> +
>>> + f2 = mock_fence();
>>> + if (!f2) {
>>> + dma_fence_put(f1);
>>> + return -ENOMEM;
>>> + }
>>> +
>>> + array = mock_array(2, f1, f2);
>>> + if (!array)
>>> + return -ENOMEM;
>>> +
>>> + dma_fence_unwrap_for_each(fence, &iter, array) {
>>> + if (fence == f1) {
>>> + f1 = NULL;
>>> + } else if (fence == f2) {
>>> + f2 = NULL;
>>> + } else {
>>> + pr_err("Unexpected fence!\n");
>>> + err = -EINVAL;
>>> + }
>>> + }
>>> +
>>> + if (f1 || f2) {
>>> + pr_err("Not all fences seen!\n");
>>> + err = -EINVAL;
>>> + }
>>> +
>>> + dma_fence_signal(f1);
>>> + dma_fence_signal(f2);
>>> + dma_fence_put(array);
>>> + return 0;
>>> +}
>>> +
>>> +static int unwrap_chain(void *arg)
>>> +{
>>> + struct dma_fence *fence, *f1, *f2, *chain;
>>> + struct dma_fence_unwrap iter;
>>> + int err = 0;
>>> +
>>> + f1 = mock_fence();
>>> + if (!f1)
>>> + return -ENOMEM;
>>> +
>>> + f2 = mock_fence();
>>> + if (!f2) {
>>> + dma_fence_put(f1);
>>> + return -ENOMEM;
>>> + }
>>> +
>>> + chain = mock_chain(f1, f2);
>>> + if (!chain)
>>> + return -ENOMEM;
>>> +
>>> + dma_fence_unwrap_for_each(fence, &iter, chain) {
>>> + if (fence == f1) {
>>> + f1 = NULL;
>>> + } else if (fence == f2) {
>>> + f2 = NULL;
>>> + } else {
>>> + pr_err("Unexpected fence!\n");
>>> + err = -EINVAL;
>>> + }
>>> + }
>>> +
>>> + if (f1 || f2) {
>>> + pr_err("Not all fences seen!\n");
>>> + err = -EINVAL;
>>> + }
>>> +
>>> + dma_fence_signal(f1);
>>> + dma_fence_signal(f2);
>>> + dma_fence_put(chain);
>>> + return 0;
>>> +}
>>> +
>>> +static int unwrap_chain_array(void *arg)
>>> +{
>>> + struct dma_fence *fence, *f1, *f2, *array, *chain;
>>> + struct dma_fence_unwrap iter;
>>> + int err = 0;
>>> +
>>> + f1 = mock_fence();
>>> + if (!f1)
>>> + return -ENOMEM;
>>> +
>>> + f2 = mock_fence();
>>> + if (!f2) {
>>> + dma_fence_put(f1);
>>> + return -ENOMEM;
>>> + }
>>> +
>>> + array = mock_array(2, f1, f2);
>>> + if (!array)
>>> + return -ENOMEM;
>>> +
>>> + chain = mock_chain(NULL, array);
>>> + if (!chain)
>>> + return -ENOMEM;
>>> +
>>> + dma_fence_unwrap_for_each(fence, &iter, chain) {
>>> + if (fence == f1) {
>>> + f1 = NULL;
>>> + } else if (fence == f2) {
>>> + f2 = NULL;
>>> + } else {
>>> + pr_err("Unexpected fence!\n");
>>> + err = -EINVAL;
>>> + }
>>> + }
>>> +
>>> + if (f1 || f2) {
>>> + pr_err("Not all fences seen!\n");
>>> + err = -EINVAL;
>>> + }
>>> +
>>> + dma_fence_signal(f1);
>>> + dma_fence_signal(f2);
>>> + dma_fence_put(chain);
>>> + return 0;
>>> +}
>>> +
>>> +int dma_fence_unwrap(void)
>>> +{
>>> + static const struct subtest tests[] = {
>>> + SUBTEST(sanitycheck),
>>> + SUBTEST(unwrap_array),
>>> + SUBTEST(unwrap_chain),
>>> + SUBTEST(unwrap_chain_array),
>>> + };
>>> + int ret;
>>> +
>>> + slab_fences = KMEM_CACHE(mock_fence,
>>> + SLAB_TYPESAFE_BY_RCU |
>>> + SLAB_HWCACHE_ALIGN);
>>> + if (!slab_fences)
>>> + return -ENOMEM;
>>> +
>>> + ret = subtests(tests, NULL);
>>> +
>>> + kmem_cache_destroy(slab_fences);
>>> + return ret;
>>> +}
>>> diff --git a/include/linux/dma-fence-unwrap.h
>>> b/include/linux/dma-fence-unwrap.h
>>> new file mode 100644
>>> index 000000000000..54963df00c98
>>> --- /dev/null
>>> +++ b/include/linux/dma-fence-unwrap.h
>>> @@ -0,0 +1,99 @@
>>> +/* SPDX-License-Identifier: GPL-2.0-only */
>>> +/*
>>> + * fence-chain: chain fences together in a timeline
>>> + *
>>> + * Copyright (C) 2022 Advanced Micro Devices, Inc.
>>> + * Authors:
>>> + * Christian König <christian.koenig at amd.com>
>>> + */
>>> +
>>> +#ifndef __LINUX_DMA_FENCE_UNWRAP_H
>>> +#define __LINUX_DMA_FENCE_UNWRAP_H
>>> +
>>> +#include <linux/dma-fence-chain.h>
>>> +#include <linux/dma-fence-array.h>
>>> +
>>> +/**
>>> + * struct dma_fence_unwrap - cursor into the container structure
>>> + */
>>> +struct dma_fence_unwrap {
>>> + /**
>>> + * @chain: potential dma_fence_chain, but can be other fence as
>>> well
>>> + */
>>> + struct dma_fence *chain;
>>> + /**
>>> + * @array: potential dma_fence_array, but can be other fence as
>>> well
>>> + */
>>> + struct dma_fence *array;
>>> + /**
>>> + * @index: last returned index if @array is really a
>>> dma_fence_array
>>> + */
>>> + unsigned int index;
>>> +};
>>> +
>>> +/**
>>> + * dma_fence_unwrap_array - helper to unwrap dma_fence_arrays
>>> + * @cursor: cursor to initialize
>>> + *
>>> + * Helper function to unwrap dma_fence_array containers, don't
>>> touch directly.
>>> + * Use dma_fence_unwrap_first/next instead.
>>> + */
>>> +static inline struct dma_fence *
>>> +dma_fence_unwrap_array(struct dma_fence_unwrap * cursor)
>>> +{
>>> + cursor->array = dma_fence_chain_contained(cursor->chain);
>>> + cursor->index = 0;
>>> + return dma_fence_array_first(cursor->array);
>>> +}
>>> +
>>> +/**
>>> + * dma_fence_unwrap_first - return the first fence from fence
>>> containers
>>> + * @head: the entrypoint into the containers
>>> + * @cursor: current position inside the containers
>>> + *
>>> + * Unwraps potential dma_fence_chain/dma_fence_array containers and
>>> return the
>>> + * first fence.
>>> + */
>>> +static inline struct dma_fence *
>>> +dma_fence_unwrap_first(struct dma_fence *head, struct
>>> dma_fence_unwrap *cursor)
>>> +{
>>> + cursor->chain = dma_fence_get(head);
>>> + return dma_fence_unwrap_array(cursor);
>>> +}
>>> +
>>> +/**
>>> + * dma_fence_unwrap_next - return the next fence from a fence
>>> containers
>>> + * @cursor: current position inside the containers
>>> + *
>>> + * Continue unwrapping the dma_fence_chain/dma_fence_array
>>> containers and return
>>> + * the next fence from them.
>>> + */
>>> +static inline struct dma_fence *
>>> +dma_fence_unwrap_next(struct dma_fence_unwrap *cursor)
>>> +{
>>> + struct dma_fence *tmp;
>>> +
>>> + ++cursor->index;
>>> + tmp = dma_fence_array_next(cursor->array, cursor->index);
>>> + if (tmp)
>>> + return tmp;
>>> +
>>> + cursor->chain = dma_fence_chain_walk(cursor->chain);
>>> + return dma_fence_unwrap_array(cursor);
>>> +}
>>> +
>>> +/**
>>> + * dma_fence_unwrap_for_each - iterate over all fences in containers
>>> + * @fence: current fence
>>> + * @cursor: current position inside the containers
>>> + * @head: starting point for the iterator
>>> + *
>>> + * Unwrap dma_fence_chain and dma_fence_array containers and deep
>>> dive into all
>>> + * potential fences in them. If @head is just a normal fence only
>>> that one is
>>> + * returned.
>>> + */
>>> +#define dma_fence_unwrap_for_each(fence, cursor, head) \
>>> + for (fence = dma_fence_unwrap_first(head, cursor); fence; \
>>> + fence = dma_fence_unwrap_next(cursor))
>>> +
>>> +#endif
>>
>
More information about the dri-devel
mailing list