Linaro-mm-sig

linaro-mm-sig@lists.linaro.org

6 participants
2911 discussions

[PATCH 3/9] async: Extend kfence to allow struct embedding

by Chris Wilson

Provide a kfence_init() function for use for embedding the kfence into a parent structure. kfence_init() takes an optional function pointer argument should the caller wish to be notified when the kfence is complete. This is useful for allowing the kfences to drive other state machinery. Signed-off-by: Chris Wilson <chris(a)chris-wilson.co.uk> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Shuah Khan <shuahkh(a)osg.samsung.com> Cc: Tejun Heo <tj(a)kernel.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Ingo Molnar <mingo(a)kernel.org> Cc: Kees Cook <keescook(a)chromium.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> Cc: Dan Williams <dan.j.williams(a)intel.com> Cc: Andrey Ryabinin <aryabinin(a)virtuozzo.com> Cc: Davidlohr Bueso <dave(a)stgolabs.net> Cc: Nikolay Aleksandrov <nikolay(a)cumulusnetworks.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: "Peter Zijlstra (Intel)" <peterz(a)infradead.org> Cc: Rasmus Villemoes <linux(a)rasmusvillemoes.dk> Cc: Andy Shevchenko <andriy.shevchenko(a)linux.intel.com> Cc: Dmitry Vyukov <dvyukov(a)google.com> Cc: Alexander Potapenko <glider(a)google.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-media(a)vger.kernel.org Cc: dri-devel(a)lists.freedesktop.org Cc: linaro-mm-sig(a)lists.linaro.org --- include/linux/kfence.h | 5 ++++ kernel/async.c | 52 ++++++++++++++++++++++++++++++++++++---- lib/test-kfence.c | 64 +++++++++++++++++++++++++++++++++++++++++++------- 3 files changed, 109 insertions(+), 12 deletions(-) diff --git a/include/linux/kfence.h b/include/linux/kfence.h index 82eba8aacd02..82096bfafaa1 100644 --- a/include/linux/kfence.h +++ b/include/linux/kfence.h @@ -38,4 +38,9 @@ static inline bool kfence_complete(struct kfence *fence) } extern void kfence_put(struct kfence *fence); +typedef void (*kfence_notify_t)(struct kfence *); +#define __kfence_call __attribute__((aligned(4))) + +extern void kfence_init(struct kfence *fence, kfence_notify_t fn); + #endif /* _KFENCE_H_ */ diff --git a/kernel/async.c b/kernel/async.c index d0bcb7cc4884..db22b890711e 100644 --- a/kernel/async.c +++ b/kernel/async.c @@ -134,7 +134,17 @@ static atomic_t entry_count; * * The fence starts off pending a single signal. Once you have finished * setting up the fence, use kfence_signal() to allow it to wait upon - * its event sources. + * its event sources. To embed a kfence within another struct, use + * + * kfence_init() + * + * This can also be used to receive a callback when the kfence is completed + * (pending signal count hits 0). The callback is also called when the fence + * is released (the reference count hits 0, and the fence will be complete). + * Note that since the kfence is embedded inside another, its initial reference + * must not be dropped unless a callback is provided, or the kfence is the + * first member in the parent, and the parent was allocated by kmalloc (i.e. + * valid to be freed by kfree()). * * Use * @@ -151,7 +161,11 @@ static void kfence_free(struct kref *kref) WARN_ON(atomic_read(&fence->pending) > 0); - kfree(fence); + if (fence->flags) { + kfence_notify_t fn = (kfence_notify_t)fence->flags; + fn(fence); + } else + kfree(fence); } /** @@ -203,6 +217,11 @@ static void __kfence_signal(struct kfence *fence, if (!atomic_dec_and_test(&fence->pending)) return; + if (fence->flags) { + kfence_notify_t fn = (kfence_notify_t)fence->flags; + fn(fence); + } + atomic_dec(&fence->pending); __kfence_wake_up_all(fence, continuation); } @@ -240,7 +259,7 @@ void kfence_wait(struct kfence *fence) } EXPORT_SYMBOL_GPL(kfence_wait); -static void kfence_init(struct kfence *fence) +static void __kfence_init(struct kfence *fence) { init_waitqueue_head(&fence->wait); kref_init(&fence->kref); @@ -266,11 +285,36 @@ struct kfence *kfence_create(gfp_t gfp) if (!fence) return NULL; - kfence_init(fence); + __kfence_init(fence); return fence; } EXPORT_SYMBOL_GPL(kfence_create); +/** + * kfence_init - initialize a fence for use embedded within a struct + * @fence: this kfence + * @fn: a callback function for when the fence is complete, and when the + * fence is released + * + * This function initialises the @fence for use embedded within a parent + * structure. The optional @fn hook is called when the fence is completed + * (when all of its events sources have signaled their completion, i.e. + * pending signal count hits 0, fence_complete() however reports false as the + * fence is not considered complete until after the callback returns) and when + * the fence is subsequently released (the reference count hits 0, + * fence_complete() is then true). Note carefully that @fn will be called from + * atomic context. Also the lower 2 bits of the function pointer are used for + * storing flags, so the function must be aligned to at least 4 bytes - use + * __kfence_call as a function attribute to ensure correct alignment. + */ +void kfence_init(struct kfence *fence, kfence_notify_t fn) +{ + __kfence_init(fence); + BUG_ON((unsigned long)fn & KFENCE_CHECKED_BIT); + fence->flags = (unsigned long)fn; +} +EXPORT_SYMBOL_GPL(kfence_init); + static int kfence_wake(wait_queue_t *wq, unsigned mode, int flags, void *key) { list_del(&wq->task_list); diff --git a/lib/test-kfence.c b/lib/test-kfence.c index 1d9e4a5a2184..0604a27f68b2 100644 --- a/lib/test-kfence.c +++ b/lib/test-kfence.c @@ -9,9 +9,27 @@ #include <linux/module.h> #include <linux/slab.h> +static int __init __test_self(struct kfence *fence) +{ + if (kfence_complete(fence)) + return -EINVAL; + + kfence_signal(fence); + + if (!kfence_complete(fence)) + return -EINVAL; + + kfence_wait(fence); + if (!kfence_complete(fence)) + return -EINVAL; + + return 0; +} + static int __init test_self(void) { struct kfence *fence; + int ret; /* Test kfence signaling and completion testing */ pr_debug("%s\n", __func__); @@ -20,19 +38,43 @@ static int __init test_self(void) if (!fence) return -ENOMEM; - if (kfence_complete(fence)) - return -EINVAL; + ret = __test_self(fence); - kfence_signal(fence); + kfence_put(fence); + return ret; +} - if (!kfence_complete(fence)) - return -EINVAL; +struct test_stack { + struct kfence fence; + bool seen; +}; - kfence_wait(fence); - if (!kfence_complete(fence)) +static void __init __kfence_call fence_callback(struct kfence *fence) +{ + struct test_stack *ts = container_of(fence, typeof(*ts), fence); + ts->seen = true; +} + +static int __init test_stack(void) +{ + struct test_stack ts; + int ret; + + /* Test kfence signaling and completion testing (on stack) */ + pr_debug("%s\n", __func__); + + ts.seen = false; + kfence_init(&ts.fence, fence_callback); + + ret = __test_self(&ts.fence); + if (ret < 0) + return ret; + + if (!ts.seen) { + pr_err("fence callback not executed\n"); return -EINVAL; + } - kfence_put(fence); return 0; } @@ -413,6 +455,12 @@ static int __init test_kfence_init(void) return ret; } + ret = test_stack(); + if (ret < 0) { + pr_err("stack failed\n"); + return ret; + } + ret = test_dag(); if (ret < 0) { pr_err("DAG checker failed\n"); -- 2.8.1

8 years, 11 months

Re: [Linaro-mm-sig] [PATCH v5 0/4] Generic zpos property

by Benjamin Gaignard

htmldocs get information directly from the comments in .h and .c files 2016-07-07 18:09 GMT+02:00 Tobias Jakobi <tjakobi(a)math.uni-bielefeld.de>: > Benjamin Gaignard wrote: >> zpos new fields are correctly documented in drm-kms.html after running >> make htmldocs. > I'm not sure I understand. Where does htmldocs get the information from > then? > > - Tobias > > >> Benjamin >> >> 2016-07-07 16:01 GMT+02:00 Tobias Jakobi <tjakobi(a)math.uni-bielefeld.de>: >>> Hello Benjamin, >>> >>> >>> Benjamin Gaignard wrote: >>>> version 5: >>>> rebased on drm-next where Documentation/DocBook/gpu.tmpl doesn't >>>> exist anymore. >>> I think the documentation has just moved to Documentation/gpu, so the >>> zpos property should be documented there then. >>> >>> >>> With best wishes, >>> Tobias >>> >>> >>>> rework sti patch because some plane functions have changed since v4 >>>> >>>> version 4: >>>> make sure that normalized zpos value is stay in the defined property >>>> range and warn user if not. >>>> Fix NULL pointer bug in rcar-du while setting zpos value. >>>> No changes in the other drivers. >>>> >>>> version 3: >>>> use kmalloc_array instead of kmalloc. >>>> Correct normalize_zpos computation (comeback to Mareck original code) >>>> >>>> version 2: >>>> add a zpos property into drm_plane structure to simplify code. >>>> This allow to get/set zpos value in core and not in drivers code. >>>> Fix various remarks. >>>> >>>> version 1: >>>> refactor Marek's patches to have per plane zpos property instead of only >>>> one in core. >>>> >>>> Benjamin Gaignard (2): >>>> drm: sti: use generic zpos for plane >>>> drm: rcar: use generic code for managing zpos plane property >>>> >>>> Marek Szyprowski (2): >>>> drm: add generic zpos property >>>> drm/exynos: use generic code for managing zpos plane property >>>> >>>> drivers/gpu/drm/Makefile | 2 +- >>>> drivers/gpu/drm/drm_atomic.c | 4 + >>>> drivers/gpu/drm/drm_atomic_helper.c | 6 + >>>> drivers/gpu/drm/drm_blend.c | 227 ++++++++++++++++++++++++++++++ >>>> drivers/gpu/drm/drm_crtc_internal.h | 4 + >>>> drivers/gpu/drm/exynos/exynos_drm_drv.h | 2 - >>>> drivers/gpu/drm/exynos/exynos_drm_plane.c | 67 ++------- >>>> drivers/gpu/drm/exynos/exynos_mixer.c | 6 +- >>>> drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 2 +- >>>> drivers/gpu/drm/rcar-du/rcar_du_drv.h | 1 - >>>> drivers/gpu/drm/rcar-du/rcar_du_kms.c | 5 - >>>> drivers/gpu/drm/rcar-du/rcar_du_plane.c | 9 +- >>>> drivers/gpu/drm/rcar-du/rcar_du_plane.h | 2 - >>>> drivers/gpu/drm/sti/sti_cursor.c | 4 +- >>>> drivers/gpu/drm/sti/sti_gdp.c | 4 +- >>>> drivers/gpu/drm/sti/sti_hqvdp.c | 4 +- >>>> drivers/gpu/drm/sti/sti_mixer.c | 9 +- >>>> drivers/gpu/drm/sti/sti_plane.c | 76 ++++------ >>>> drivers/gpu/drm/sti/sti_plane.h | 7 +- >>>> include/drm/drm_crtc.h | 30 ++++ >>>> 20 files changed, 324 insertions(+), 147 deletions(-) >>>> create mode 100644 drivers/gpu/drm/drm_blend.c >>>> >>>> Cc: Inki Dae <inki.dae(a)samsung.com> >>>> Cc: Daniel Vetter <daniel(a)ffwll.ch> >>>> Cc: Ville Syrjala <ville.syrjala(a)linux.intel.com> >>>> Cc: Joonyoung Shim <jy0922.shim(a)samsung.com> >>>> Cc: Seung-Woo Kim <sw0312.kim(a)samsung.com> >>>> Cc: Andrzej Hajda <a.hajda(a)samsung.com> >>>> Cc: Krzysztof Kozlowski <k.kozlowski(a)samsung.com> >>>> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie(a)samsung.com> >>>> Cc: Tobias Jakobi <tjakobi(a)math.uni-bielefeld.de> >>>> Cc: Gustavo Padovan <gustavo(a)padovan.org> >>>> Cc: vincent.abriou(a)st.com >>>> Cc: fabien.dessenne(a)st.com >>>> Cc: Laurent Pinchart <laurent.pinchart(a)ideasonboard.com> >>>> >>> >> >> >> > -- Benjamin Gaignard Graphic Working Group Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog

8 years, 11 months

Re: [Linaro-mm-sig] [PATCH v5 0/4] Generic zpos property

by Benjamin Gaignard

zpos new fields are correctly documented in drm-kms.html after running make htmldocs. Benjamin 2016-07-07 16:01 GMT+02:00 Tobias Jakobi <tjakobi(a)math.uni-bielefeld.de>: > Hello Benjamin, > > > Benjamin Gaignard wrote: >> version 5: >> rebased on drm-next where Documentation/DocBook/gpu.tmpl doesn't >> exist anymore. > I think the documentation has just moved to Documentation/gpu, so the > zpos property should be documented there then. > > > With best wishes, > Tobias > > >> rework sti patch because some plane functions have changed since v4 >> >> version 4: >> make sure that normalized zpos value is stay in the defined property >> range and warn user if not. >> Fix NULL pointer bug in rcar-du while setting zpos value. >> No changes in the other drivers. >> >> version 3: >> use kmalloc_array instead of kmalloc. >> Correct normalize_zpos computation (comeback to Mareck original code) >> >> version 2: >> add a zpos property into drm_plane structure to simplify code. >> This allow to get/set zpos value in core and not in drivers code. >> Fix various remarks. >> >> version 1: >> refactor Marek's patches to have per plane zpos property instead of only >> one in core. >> >> Benjamin Gaignard (2): >> drm: sti: use generic zpos for plane >> drm: rcar: use generic code for managing zpos plane property >> >> Marek Szyprowski (2): >> drm: add generic zpos property >> drm/exynos: use generic code for managing zpos plane property >> >> drivers/gpu/drm/Makefile | 2 +- >> drivers/gpu/drm/drm_atomic.c | 4 + >> drivers/gpu/drm/drm_atomic_helper.c | 6 + >> drivers/gpu/drm/drm_blend.c | 227 ++++++++++++++++++++++++++++++ >> drivers/gpu/drm/drm_crtc_internal.h | 4 + >> drivers/gpu/drm/exynos/exynos_drm_drv.h | 2 - >> drivers/gpu/drm/exynos/exynos_drm_plane.c | 67 ++------- >> drivers/gpu/drm/exynos/exynos_mixer.c | 6 +- >> drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 2 +- >> drivers/gpu/drm/rcar-du/rcar_du_drv.h | 1 - >> drivers/gpu/drm/rcar-du/rcar_du_kms.c | 5 - >> drivers/gpu/drm/rcar-du/rcar_du_plane.c | 9 +- >> drivers/gpu/drm/rcar-du/rcar_du_plane.h | 2 - >> drivers/gpu/drm/sti/sti_cursor.c | 4 +- >> drivers/gpu/drm/sti/sti_gdp.c | 4 +- >> drivers/gpu/drm/sti/sti_hqvdp.c | 4 +- >> drivers/gpu/drm/sti/sti_mixer.c | 9 +- >> drivers/gpu/drm/sti/sti_plane.c | 76 ++++------ >> drivers/gpu/drm/sti/sti_plane.h | 7 +- >> include/drm/drm_crtc.h | 30 ++++ >> 20 files changed, 324 insertions(+), 147 deletions(-) >> create mode 100644 drivers/gpu/drm/drm_blend.c >> >> Cc: Inki Dae <inki.dae(a)samsung.com> >> Cc: Daniel Vetter <daniel(a)ffwll.ch> >> Cc: Ville Syrjala <ville.syrjala(a)linux.intel.com> >> Cc: Joonyoung Shim <jy0922.shim(a)samsung.com> >> Cc: Seung-Woo Kim <sw0312.kim(a)samsung.com> >> Cc: Andrzej Hajda <a.hajda(a)samsung.com> >> Cc: Krzysztof Kozlowski <k.kozlowski(a)samsung.com> >> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie(a)samsung.com> >> Cc: Tobias Jakobi <tjakobi(a)math.uni-bielefeld.de> >> Cc: Gustavo Padovan <gustavo(a)padovan.org> >> Cc: vincent.abriou(a)st.com >> Cc: fabien.dessenne(a)st.com >> Cc: Laurent Pinchart <laurent.pinchart(a)ideasonboard.com> >> > -- Benjamin Gaignard Graphic Working Group Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog

8 years, 12 months

[PATCH 9/9] async: Introduce a dependency resolver for parallel execution

by Chris Wilson

A challenge in driver initialisation is the coordination of many small sometimes independent, sometimes interdependent tasks. We would like to schedule the independent tasks for execution in parallel across as many cores as possible for rapid initialisation, and then schedule all the dependent tasks once they have completed, again running as many of those in parallel as is possible. Resolving the interdependencies by hand is time consuming and error prone. Instead, we want to declare what dependencies a particular task has, and what that task provides, and let a runtime dependency solver work out what tasks to run and when, and which in parallel. To this end, we introduce the struct async_dependency_graph building upon the kfence and async_work from the previous patches to allow for the runtime computation of the topological task ordering. The graph is constructed with async_dependency_graph_build(), which takes the task, its dependencies and what it provides, and builds the graph of kfences required for ordering. Additional kfences can be inserted through async_dependency_depends() and async_dependency_provides() for manual control of the execution order, and async_dependency_get() retrieves a kfence for inspection or waiting upon. Signed-off-by: Chris Wilson <chris(a)chris-wilson.co.uk> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Shuah Khan <shuahkh(a)osg.samsung.com> Cc: Tejun Heo <tj(a)kernel.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Ingo Molnar <mingo(a)kernel.org> Cc: Kees Cook <keescook(a)chromium.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> Cc: Dan Williams <dan.j.williams(a)intel.com> Cc: Andrey Ryabinin <aryabinin(a)virtuozzo.com> Cc: Davidlohr Bueso <dave(a)stgolabs.net> Cc: Nikolay Aleksandrov <nikolay(a)cumulusnetworks.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: "Peter Zijlstra (Intel)" <peterz(a)infradead.org> Cc: Rasmus Villemoes <linux(a)rasmusvillemoes.dk> Cc: Andy Shevchenko <andriy.shevchenko(a)linux.intel.com> Cc: Dmitry Vyukov <dvyukov(a)google.com> Cc: Alexander Potapenko <glider(a)google.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-media(a)vger.kernel.org Cc: dri-devel(a)lists.freedesktop.org Cc: linaro-mm-sig(a)lists.linaro.org --- include/linux/async.h | 37 +++ kernel/async.c | 250 ++++++++++++++++ lib/Kconfig.debug | 12 + lib/Makefile | 1 + lib/test-async-dependency-graph.c | 317 +++++++++++++++++++++ .../selftests/lib/async-dependency-graph.sh | 10 + 6 files changed, 627 insertions(+) create mode 100644 lib/test-async-dependency-graph.c create mode 100755 tools/testing/selftests/lib/async-dependency-graph.sh diff --git a/include/linux/async.h b/include/linux/async.h index 64a090e3f24f..c9cadb383813 100644 --- a/include/linux/async.h +++ b/include/linux/async.h @@ -15,6 +15,7 @@ #include <linux/types.h> #include <linux/kfence.h> #include <linux/list.h> +#include <linux/rbtree.h> typedef u64 async_cookie_t; typedef void (*async_func_t) (void *data, async_cookie_t cookie); @@ -101,4 +102,40 @@ extern async_cookie_t queue_async_work(struct async_domain *domain, gfp_t gfp); extern async_cookie_t schedule_async_work(struct async_work *work); +/* Build a graph of work based on dependencies generated by keywords. + * The graph must be acyclic. Can be used to both generate a topological + * ordering of tasks, and to execute independent chains of tasks in + * parallel. + */ + +struct async_dependency_graph { + struct rb_root root; + struct list_head list; +}; + +#define ASYNC_DEPENDENCY_GRAPH_INIT(_name) { \ + .root = RB_ROOT, \ + .list = LIST_HEAD_INIT(_name.list), \ +} +#define ASYNC_DEPENDENCY_GRAPH(_name) \ + struct async_dependency_graph _name = ASYNC_DEPENDENCY_GRAPH_INIT(_name) + +extern int async_dependency_graph_build(struct async_dependency_graph *adg, + async_func_t fn, void *data, + const char *depends, + const char *provides); + +extern int async_dependency_depends(struct async_dependency_graph *adg, + struct kfence *fence, + const char *depends); + +extern int async_dependency_provides(struct async_dependency_graph *adg, + struct kfence *fence, + const char *provides); + +extern struct kfence *async_dependency_get(struct async_dependency_graph *adg, + const char *name); + +extern void async_dependency_graph_execute(struct async_dependency_graph *adg); + #endif diff --git a/kernel/async.c b/kernel/async.c index a22945f4b4c4..8330d719074b 100644 --- a/kernel/async.c +++ b/kernel/async.c @@ -1005,3 +1005,253 @@ void init_async_domain(struct async_domain *domain, bool registered) domain->registered = registered; } EXPORT_SYMBOL_GPL(init_async_domain); + +struct async_dependency { + struct kfence fence; + struct rb_node node; + struct list_head link; + char name[0]; +}; + +static struct async_dependency * +__lookup_dependency(struct async_dependency_graph *adg, const char *name) +{ + struct rb_node **p, *parent; + struct async_dependency *d; + int len; + + parent = NULL; + p = &adg->root.rb_node; + while (*p) { + int cmp; + + parent = *p; + d = container_of(parent, typeof(*d), node); + + cmp = strcmp(name, d->name); + if (cmp < 0) + p = &parent->rb_left; + else if (cmp > 0) + p = &parent->rb_right; + else + return d; + } + + len = strlen(name) + 1; + d = kmalloc(sizeof(*d) + len, GFP_KERNEL); + if (!d) + return ERR_PTR(-ENOMEM); + + __kfence_init(&d->fence); + memcpy(d->name, name, len); + + rb_link_node(&d->node, parent, p); + rb_insert_color(&d->node, &adg->root); + list_add_tail(&d->link, &adg->list); + + return d; +} + +/** + * async_dependency_depends - declare a prerequisite fence for a named stage + * @adg: the async_dependency_graph for tracking the named stages + * @fence: the kfence to add that depends upon the named stage completing + * @depends: the named stage + * + * This function appends @fence into the async_dependency_graph @adg after + * the @depends stage is completed. That is the @fence is signaled once + * the chain of dependencies upto and including @depends is complete. + * + * Returns: 0 on success, negative error code on failure. + * In particular, note that if CONFIG_KFENCE_CHECK_DAG is enabled, the + * dependency graph will be checked for cycles, and -EINVAL reported + * in such cases. A dependency cycle leads to unexecutable code. + */ +int async_dependency_depends(struct async_dependency_graph *adg, + struct kfence *fence, + const char *depends) +{ + struct async_dependency *d; + + d = __lookup_dependency(adg, depends); + if (IS_ERR(d)) + return PTR_ERR(d); + + return kfence_add(fence, &d->fence, GFP_KERNEL); +} +EXPORT_SYMBOL_GPL(async_dependency_depends); + +/** + * async_dependency_provides - declare a named stage that should follow + * @adg: the async_dependency_graph for tracking the named stages + * @fence: the kfence to add that provides the named stage with a signal + * @depends: the named stage + * + * This function inserts @fence into the async_dependency_graph @adg before + * the @provides stage is signaled. That is the @fence signals the + * @provides stage once completed (and once all providers have completed, + * work from the @provides commences). + * + * Returns: 0 on success, negative error code on failure. + * In particular, note that if CONFIG_KFENCE_CHECK_DAG is enabled, the + * dependency graph will be checked for cycles, and -EINVAL reported + * in such cases. A dependency cycle leads to unexecutable code. + */ +int async_dependency_provides(struct async_dependency_graph *adg, + struct kfence *fence, + const char *provides) +{ + struct async_dependency *d; + + d = __lookup_dependency(adg, provides); + if (IS_ERR(d)) + return PTR_ERR(d); + + return kfence_add(&d->fence, fence, GFP_KERNEL); +} +EXPORT_SYMBOL_GPL(async_dependency_provides); + +/** + * async_dependency_get - lookup the kfence for a named stage + * @adg: the async_dependency_graph for tracking the named stages + * @name: the named stage + * + * This function lookups the kfence associated with the named stage. This + * fence will be signaled once the named stage is ready. For example, + * waiting on that fence will wait until all prior dependencies of that + * named stage have been completed. + * + * Returns: a new reference on the kfence. The caller must release the + * reference with kfence_put() when finished. + */ +struct kfence *async_dependency_get(struct async_dependency_graph *adg, + const char *name) +{ + struct async_dependency *d; + + d = __lookup_dependency(adg, name); + if (IS_ERR(d)) + return ERR_CAST(d); + + return kfence_get(&d->fence); +} +EXPORT_SYMBOL_GPL(async_dependency_get); + +static int __adg_for_each_token(struct async_dependency_graph *adg, + struct kfence *fence, + const char *string, + int (*fn)(struct async_dependency_graph *, + struct kfence *, + const char *)) +{ + char *tmp, *s, *t; + int ret = 0; + + if (!string) + return 0; + + tmp = kstrdup(string, GFP_KERNEL); + if (!tmp) + return -ENOMEM; + + for (s = tmp; (t = strsep(&s, ",")); ) { + if (*t == '\0') + continue; + + ret |= fn(adg, fence, t); + if (ret < 0) + break; + } + + kfree(tmp); + return ret; +} + +/** + * async_dependency_graph_build - insert a task into the dependency graph + * @adg: the async_dependency_graph for tracking the named stages + * @fn: the async_func_t to execute + * @data: the data to pass to the @fn + * @depends: a comma-separated list of named stages that must complete + * before the task can execute + * @provides: a comma-separated list of named stages that will be signaled + * when this task completes + * + * This function inserts the task @fn into the async_dependency_graph @adg + * after all the named stages in @depends have completed. Upon completion + * of the task, all the named stages in @provides are signaled (and once all + * their dependent tasks have also finished, the tasks afterwards will + * execute). + * + * If a task has no dependency (@depends is NULL or an empty string), it will + * be scheduled for execution as soon as it is inserted into the graph @adg. + * + * Returns: 0 on success, negative error code on failure. + * In particular, note that if CONFIG_KFENCE_CHECK_DAG is enabled, the + * dependency graph will be checked for cycles, and -EINVAL reported + * in such cases. A dependency cycle leads to unexecutable code. + */ +int +async_dependency_graph_build(struct async_dependency_graph *adg, + async_func_t fn, void *data, + const char *depends, const char *provides) +{ + struct async_work *work; + int ret; + + work = async_work_create(fn, data, GFP_KERNEL); + if (!work) + return -ENOMEM; + + ret = __adg_for_each_token(adg, &work->fence, depends, + async_dependency_depends); + if (ret < 0) + goto err; + + ret = __adg_for_each_token(adg, &work->fence, provides, + async_dependency_provides); + if (ret < 0) + goto err; + + if (!schedule_async_work(work)) { + ret = -ENOMEM; + goto err; + } + + ret = 0; +out: + async_work_put(work); + return ret; + +err: + clear_bit(ASYNC_WORK_BIT, &work->fence.flags); + kfence_signal(&work->fence); + goto out; +} +EXPORT_SYMBOL_GPL(async_dependency_graph_build); + +/** + * async_dependency_graph_execute - execute the dependency graph + * @adg: the async_dependency_graph + * + * This function marks the @adg as ready for execution. As soon as the + * dependencies of a task have been completed (in their entirety), that + * task is executed. Once completed, it signals the tasks that have listed + * its @provides as one of their @depends, and once ready (all @provides are + * complete) those tasks are scheduled for execution. + * + * Tasks are executed in the topological order of their dependencies. If two, + * or more, tasks are not dependent on each other they may be run concurrently. + * + * The graph @adg is freed upon execution. + */ +void async_dependency_graph_execute(struct async_dependency_graph *adg) +{ + struct async_dependency *d, *next; + + list_for_each_entry_safe(d, next, &adg->list, link) { + kfence_signal(&d->fence); + kfence_put(&d->fence); + } +} +EXPORT_SYMBOL_GPL(async_dependency_graph_execute); diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 47319f501954..4943b8dbcdf1 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -1798,6 +1798,18 @@ config ASYNC_DOMAIN_SELFTEST Say N if you are unsure. +config ASYNC_DEPENDENCY_GRAPH_SELFTEST + tristate "Asynchronous dependency graph self tests" + depends on DEBUG_KERNEL + default n + help + This option provides a kernel modules that can be used to test + the asynchronous dependency graph. This option is not useful for + distributions or general kernels, but only for kernel developers + working on the async_dependency_graph facility. + + Say N if you are unsure. + config BACKTRACE_SELF_TEST tristate "Self test for the backtrace code" depends on DEBUG_KERNEL diff --git a/lib/Makefile b/lib/Makefile index 82e8b5f77c44..fa7da38d4383 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -30,6 +30,7 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \ obj-$(CONFIG_ARCH_HAS_DEBUG_STRICT_USER_COPY_CHECKS) += usercopy.o obj-$(CONFIG_KFENCE_SELFTEST) += test-kfence.o obj-$(CONFIG_ASYNC_DOMAIN_SELFTEST) += test-async-domain.o +obj-$(CONFIG_ASYNC_DEPENDENCY_GRAPH_SELFTEST) += test-async-dependency-graph.o lib-$(CONFIG_MMU) += ioremap.o lib-$(CONFIG_SMP) += cpumask.o lib-$(CONFIG_HAS_DMA) += dma-noop.o diff --git a/lib/test-async-dependency-graph.c b/lib/test-async-dependency-graph.c new file mode 100644 index 000000000000..ebee26d7b99e --- /dev/null +++ b/lib/test-async-dependency-graph.c @@ -0,0 +1,317 @@ +/* + * Test cases for async-dependency-graph facility. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/async.h> +#include <linux/delay.h> +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/string.h> + +struct chain { + atomic_t idx; + unsigned long values[0]; +}; + +struct task_write { + struct chain *chain; + unsigned long value; +}; + +static void __init task_write(void *arg, async_cookie_t cookie) +{ + struct task_write *t = arg; + int idx = atomic_inc_return(&t->chain->idx) - 1; + WRITE_ONCE(t->chain->values[idx], t->value); +} + +static void __init task_nop(void *data, async_cookie_t cookie) +{ +} + +static int __init test_ordering(int nchain, int nwide) +{ + ASYNC_DEPENDENCY_GRAPH(adg); + struct chain **chains; + struct task_write *tests, *t; + int c, w, ret; + + /* Test implementation of simple chains within the dependency graphs */ + pr_debug("%s(nchain=%d, nwide=%d)\n", __func__, nchain, nwide); + + chains = kmalloc(sizeof(struct chain *)*nwide, GFP_KERNEL); + tests = kmalloc(sizeof(struct task_write)*nwide*nchain, GFP_KERNEL); + + if (!chains || !tests) + return -ENOMEM; + + t = tests; + for (w = 0; w < nwide; w++) { + char *depends = NULL, *provides; + + chains[w] = kzalloc(sizeof(struct chain) + + nchain*sizeof(unsigned long), + GFP_KERNEL); + + for (c = 0; c < nchain; c++) { + t->chain = chains[w]; + t->value = c; + provides = kasprintf(GFP_KERNEL, "%d.%d", c, w); + async_dependency_graph_build(&adg, task_write, t, + depends, provides); + kfree(depends); + depends = provides; + t++; + } + + kfree(depends); + } + async_dependency_graph_execute(&adg); + async_synchronize_full(); + + ret = 0; + kfree(tests); + for (w = 0; w < nwide; w++) { + for (c = 0; c < nchain; c++) { + if (chains[w]->values[c] != c) { + pr_err("%s(%d, %d): Invalid execution order (chain %d, position %d): found %d\n", + __func__, nchain, nwide, + w, c, (int)chains[w]->values[c]); + + ret = -EINVAL; + } + } + kfree(chains[w]); + } + kfree(chains); + + return ret; +} + +static int __init test_barrier(int nwide) +{ + ASYNC_DEPENDENCY_GRAPH(adg); + struct chain **chains; + struct task_write *tests, *t; + int c, w, ret; + + /* Test implementation of barriers within the dependency graphs */ + pr_debug("%s(nwide=%d)\n", __func__, nwide); + + chains = kmalloc(sizeof(struct chain *)*nwide, GFP_KERNEL); + tests = kmalloc(sizeof(struct task_write)*2*nwide, GFP_KERNEL); + if (!chains || !tests) + return -ENOMEM; + + t = tests; + + /* A,B act as a barrier running between the nops */ + for (w = 0; w < nwide; w++) { + char *provides, *depends; + + chains[w] = kzalloc(sizeof(struct chain) + + 2*sizeof(unsigned long), + GFP_KERNEL); + + depends = NULL; + + provides = kasprintf(GFP_KERNEL, "nop1.%d", w); + async_dependency_graph_build(&adg, task_nop, NULL, + depends, provides); + async_dependency_graph_build(&adg, task_nop, NULL, + depends, provides); + + kfree(depends); + depends = provides; + + provides = kasprintf(GFP_KERNEL, "A.%d", w); + t->chain = chains[w]; + t->value = 0; + async_dependency_graph_build(&adg, task_write, t, + depends, provides); + t++; + + kfree(depends); + depends = provides; + + provides = kasprintf(GFP_KERNEL, "nop2.%d", w); + async_dependency_graph_build(&adg, task_nop, NULL, + depends, provides); + kfree(provides); + + provides = kasprintf(GFP_KERNEL, "nop3.%d", w); + async_dependency_graph_build(&adg, task_nop, NULL, + depends, provides); + kfree(provides); + + kfree(depends); + depends = kasprintf(GFP_KERNEL, "nop2.%d,nop3.%d", w, w); + t->chain = chains[w]; + t->value = 1; + async_dependency_graph_build(&adg, task_write, t, + depends, NULL); + kfree(depends); + t++; + } + async_dependency_graph_execute(&adg); + async_synchronize_full(); + + ret = 0; + kfree(tests); + for (w = 0; w < nwide; w++) { + for (c = 0; c < 2; c++) { + if (chains[w]->values[c] != c) { + pr_err("%s(%d): Invalid execution order (chain %d, position %d): found %d\n", + __func__, nwide, + w, c, (int)chains[w]->values[c]); + + ret = -EINVAL; + } + } + kfree(chains[w]); + } + kfree(chains); + + return ret; +} + +static int __init test_dag(void) +{ + ASYNC_DEPENDENCY_GRAPH(adg); + + /* Test detection of cycles within the dependency graphs */ + pr_debug("%s\n", __func__); + + if (!config_enabled(CONFIG_KFENCE_CHECK_DAG)) + return 0; + + async_dependency_graph_build(&adg, task_nop, NULL, "__start__", "A"); + if (async_dependency_graph_build(&adg, task_nop, NULL, "A", "A") != -EINVAL) { + pr_err("Failed to detect AA cycle\n"); + return -EINVAL; + } + + async_dependency_graph_build(&adg, task_nop, NULL, "A", "B"); + if (async_dependency_graph_build(&adg, task_nop, NULL, "B", "A") != -EINVAL) { + pr_err("Failed to detect ABA cycle\n"); + return -EINVAL; + } + + async_dependency_graph_build(&adg, task_nop, NULL, "B", "C"); + if (async_dependency_graph_build(&adg, task_nop, NULL, "C", "A") != -EINVAL) { + pr_err("Failed to detect ABCA cycle\n"); + return -EINVAL; + } + + async_dependency_graph_execute(&adg); + async_synchronize_full(); + + return 0; +} + +static int __init perf_nop(int chain, int width, long timeout_us) +{ + ktime_t start; + long count, delay; + + count = 0; + start = ktime_get(); + do { + ASYNC_DEPENDENCY_GRAPH(adg); + ktime_t delta; + int c, w; + + for (w = 0; w < width; w++) { + char *depends = NULL, *provides; + + for (c = 0; c < chain; c++) { + provides = kasprintf(GFP_KERNEL, "%d.%d", c, w); + async_dependency_graph_build(&adg, + task_nop, NULL, + depends, provides); + kfree(depends); + depends = provides; + } + + kfree(depends); + } + async_dependency_graph_execute(&adg); + async_synchronize_full(); + delta = ktime_sub(ktime_get(), start); + delay = ktime_to_ns(delta) >> 10; + count += width * chain; + } while (delay < timeout_us); + + pr_info("%ld nop tasks (in chains of %d, %d chains in parallel) completed in %ldus\n", + count, chain, width, delay); + return 0; +} + +static int __init test_async_dependency_graph_init(void) +{ + int ret; + + pr_info("Testing async-dependency-graph\n"); + + ret = test_ordering(1, 1); + if (ret) + return ret; + + ret = test_ordering(2, 1); + if (ret) + return ret; + + ret = test_ordering(1, 2); + if (ret) + return ret; + + ret = test_ordering(2, 2); + if (ret) + return ret; + + ret = test_ordering(26, 26); + if (ret) + return ret; + + ret = test_dag(); + if (ret) + return ret; + + ret = test_barrier(1); + if (ret) + return ret; + + ret = test_barrier(16); + if (ret) + return ret; + + ret = perf_nop(1, 1, 100); + if (ret) + return ret; + + ret = perf_nop(256, 1, 2000); + if (ret) + return ret; + + ret = perf_nop(128, 2, 2000); + if (ret) + return ret; + + ret = perf_nop(16, 16, 2000); + if (ret) + return ret; + + return 0; +} + +static void __exit test_async_dependency_graph_cleanup(void) +{ +} + +module_init(test_async_dependency_graph_init); +module_exit(test_async_dependency_graph_cleanup); + +MODULE_AUTHOR("Intel Corporation"); +MODULE_LICENSE("GPL"); diff --git a/tools/testing/selftests/lib/async-dependency-graph.sh b/tools/testing/selftests/lib/async-dependency-graph.sh new file mode 100755 index 000000000000..ea4bbc76f60f --- /dev/null +++ b/tools/testing/selftests/lib/async-dependency-graph.sh @@ -0,0 +1,10 @@ +#!/bin/sh +# Runs infrastructure tests using test-async-dependency-graph kernel module + +if /sbin/modprobe -q test-async-dependency-graph; then + /sbin/modprobe -q -r test-async-dependency-graph + echo "async-dependency-graph: ok" +else + echo "async-dependency-graph: [FAIL]" + exit 1 +fi -- 2.8.1

9 years

[PATCH 8/9] async: Add execution barriers

by Chris Wilson

A frequent mode of operation is fanning out N tasks to execute in parallel, collating results, fanning out M tasks, rinse and repeat. This is also common to the notion of the async/sync kernel domain split. A barrier provides a mechanism by which all work queued after the barrier must wait (i.e. not be scheduled) until all work queued before the barrier is completed. Signed-off-by: Chris Wilson <chris(a)chris-wilson.co.uk> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Shuah Khan <shuahkh(a)osg.samsung.com> Cc: Tejun Heo <tj(a)kernel.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Ingo Molnar <mingo(a)kernel.org> Cc: Kees Cook <keescook(a)chromium.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> Cc: Dan Williams <dan.j.williams(a)intel.com> Cc: Andrey Ryabinin <aryabinin(a)virtuozzo.com> Cc: Davidlohr Bueso <dave(a)stgolabs.net> Cc: Nikolay Aleksandrov <nikolay(a)cumulusnetworks.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: "Peter Zijlstra (Intel)" <peterz(a)infradead.org> Cc: Rasmus Villemoes <linux(a)rasmusvillemoes.dk> Cc: Andy Shevchenko <andriy.shevchenko(a)linux.intel.com> Cc: Dmitry Vyukov <dvyukov(a)google.com> Cc: Alexander Potapenko <glider(a)google.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-media(a)vger.kernel.org Cc: dri-devel(a)lists.freedesktop.org Cc: linaro-mm-sig(a)lists.linaro.org --- include/linux/async.h | 4 ++++ kernel/async.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+) diff --git a/include/linux/async.h b/include/linux/async.h index 45d6c8323b60..64a090e3f24f 100644 --- a/include/linux/async.h +++ b/include/linux/async.h @@ -26,6 +26,7 @@ struct async_work { struct async_domain { struct list_head pending; + struct kfence *barrier; unsigned registered:1; }; @@ -59,6 +60,9 @@ extern void async_synchronize_cookie(async_cookie_t cookie); extern void async_synchronize_cookie_domain(async_cookie_t cookie, struct async_domain *domain); +extern void async_barrier(void); +extern void async_barrier_domain(struct async_domain *domain); + extern bool current_is_async(void); extern struct async_work * diff --git a/kernel/async.c b/kernel/async.c index 83007c39a113..a22945f4b4c4 100644 --- a/kernel/async.c +++ b/kernel/async.c @@ -724,6 +724,12 @@ struct async_work *async_work_create(async_func_t func, void *data, gfp_t gfp) } EXPORT_SYMBOL_GPL(async_work_create); +static void async_barrier_delete(struct async_domain *domain) +{ + kfence_put(domain->barrier); + domain->barrier = NULL; +} + async_cookie_t queue_async_work(struct async_domain *domain, struct async_work *work, gfp_t gfp) @@ -744,6 +750,9 @@ async_cookie_t queue_async_work(struct async_domain *domain, async_pending_count++; spin_unlock_irqrestore(&async_lock, flags); + if (!kfence_add(&entry->base.fence, domain->barrier, gfp)) + async_barrier_delete(domain); + /* mark that this task has queued an async job, used by module init */ current->flags |= PF_USED_ASYNC; @@ -811,6 +820,55 @@ async_cookie_t async_schedule_domain(async_func_t func, void *data, } EXPORT_SYMBOL_GPL(async_schedule_domain); +static struct kfence * __async_barrier_create(struct async_domain *domain) +{ + struct kfence *fence; + struct async_entry *entry; + unsigned long flags; + int ret; + + fence = kfence_create(GFP_KERNEL); + if (!fence) + goto out_sync; + + ret = 0; + spin_lock_irqsave(&async_lock, flags); + list_for_each_entry(entry, &domain->pending, pending_link[0]) { + ret |= kfence_add(fence, &entry->base.fence, GFP_ATOMIC); + if (ret < 0) + break; + } + spin_unlock_irqrestore(&async_lock, flags); + if (ret <= 0) + goto out_put; + + kfence_add(fence, domain->barrier, GFP_KERNEL); + kfence_signal(fence); + return fence; + +out_put: + kfence_signal(fence); + kfence_put(fence); +out_sync: + async_synchronize_full_domain(domain); + return NULL; +} + +void async_barrier(void) +{ + async_barrier_domain(&async_dfl_domain); +} +EXPORT_SYMBOL_GPL(async_barrier); + +void async_barrier_domain(struct async_domain *domain) +{ + struct kfence *barrier = __async_barrier_create(domain); + + kfence_put(domain->barrier); + domain->barrier = barrier; +} +EXPORT_SYMBOL_GPL(async_barrier_domain); + /** * async_synchronize_full - synchronize all asynchronous function calls * @@ -834,6 +892,8 @@ EXPORT_SYMBOL_GPL(async_synchronize_full); void async_unregister_domain(struct async_domain *domain) { WARN_ON(!list_empty(&domain->pending)); + + async_barrier_delete(domain); domain->registered = 0; } EXPORT_SYMBOL_GPL(async_unregister_domain); -- 2.8.1

9 years

[PATCH 7/9] async: Add support for explicit fine-grained barriers

by Chris Wilson

The current async-domain model supports running a multitude of independent tasks with a coarse synchronisation point. This is sufficient for its original purpose of allowing independent drivers to run concurrently during various phases (booting, early resume, late resume etc), and keep the asynchronous domain out of the synchronous kernel domains. However, for greater exploitation, drivers themselves want to schedule multiple tasks within a phase (or between phases) and control the order of execution within those tasks relative to each other. To enable this, we extend the synchronisation scheme based upon kfences and back every task with one. Any task may now wait upon the kfence before being scheduled, and equally the kfence may be used to wait on the task itself (rather than waiting on the cookie for all previous tasks to be completed). Signed-off-by: Chris Wilson <chris(a)chris-wilson.co.uk> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Shuah Khan <shuahkh(a)osg.samsung.com> Cc: Tejun Heo <tj(a)kernel.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Ingo Molnar <mingo(a)kernel.org> Cc: Kees Cook <keescook(a)chromium.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> Cc: Dan Williams <dan.j.williams(a)intel.com> Cc: Andrey Ryabinin <aryabinin(a)virtuozzo.com> Cc: Davidlohr Bueso <dave(a)stgolabs.net> Cc: Nikolay Aleksandrov <nikolay(a)cumulusnetworks.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: "Peter Zijlstra (Intel)" <peterz(a)infradead.org> Cc: Rasmus Villemoes <linux(a)rasmusvillemoes.dk> Cc: Andy Shevchenko <andriy.shevchenko(a)linux.intel.com> Cc: Dmitry Vyukov <dvyukov(a)google.com> Cc: Alexander Potapenko <glider(a)google.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-media(a)vger.kernel.org Cc: dri-devel(a)lists.freedesktop.org Cc: linaro-mm-sig(a)lists.linaro.org --- include/linux/async.h | 60 +++++++++- kernel/async.c | 244 +++++++++++++++++++++---------------- lib/test-async-domain.c | 311 +++++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 505 insertions(+), 110 deletions(-) diff --git a/include/linux/async.h b/include/linux/async.h index 6b0226bdaadc..45d6c8323b60 100644 --- a/include/linux/async.h +++ b/include/linux/async.h @@ -13,38 +13,88 @@ #define __ASYNC_H__ #include <linux/types.h> +#include <linux/kfence.h> #include <linux/list.h> typedef u64 async_cookie_t; typedef void (*async_func_t) (void *data, async_cookie_t cookie); + +struct async_work { + struct kfence fence; + /* private */ +}; + struct async_domain { struct list_head pending; unsigned registered:1; }; +#define ASYNC_DOMAIN_INIT(_name, _r) { \ + .pending = LIST_HEAD_INIT(_name.pending), \ + .registered = _r \ +} + /* * domain participates in global async_synchronize_full */ #define ASYNC_DOMAIN(_name) \ - struct async_domain _name = { .pending = LIST_HEAD_INIT(_name.pending), \ - .registered = 1 } + struct async_domain _name = ASYNC_DOMAIN_INIT(_name, 1) /* * domain is free to go out of scope as soon as all pending work is * complete, this domain does not participate in async_synchronize_full */ #define ASYNC_DOMAIN_EXCLUSIVE(_name) \ - struct async_domain _name = { .pending = LIST_HEAD_INIT(_name.pending), \ - .registered = 0 } + struct async_domain _name = ASYNC_DOMAIN_INIT(_name, 0) + +extern void init_async_domain(struct async_domain *domain, bool registered); extern async_cookie_t async_schedule(async_func_t func, void *data); extern async_cookie_t async_schedule_domain(async_func_t func, void *data, struct async_domain *domain); -void async_unregister_domain(struct async_domain *domain); +extern void async_unregister_domain(struct async_domain *domain); extern void async_synchronize_full(void); extern void async_synchronize_full_domain(struct async_domain *domain); extern void async_synchronize_cookie(async_cookie_t cookie); extern void async_synchronize_cookie_domain(async_cookie_t cookie, struct async_domain *domain); + extern bool current_is_async(void); + +extern struct async_work * +async_work_create(async_func_t func, void *data, gfp_t gfp); + +static inline struct async_work *async_work_get(struct async_work *work) +{ + kfence_get(&work->fence); + return work; +} + +static inline int +async_work_after(struct async_work *work, struct kfence *fence) +{ + return kfence_add(&work->fence, fence, GFP_KERNEL); +} + +static inline int +async_work_before(struct async_work *work, struct kfence *fence) +{ + return kfence_add(fence, &work->fence, GFP_KERNEL); +} + +static inline void async_work_wait(struct async_work *work) +{ + kfence_wait(&work->fence); +} + +static inline void async_work_put(struct async_work *work) +{ + kfence_put(&work->fence); +} + +extern async_cookie_t queue_async_work(struct async_domain *domain, + struct async_work *work, + gfp_t gfp); +extern async_cookie_t schedule_async_work(struct async_work *work); + #endif diff --git a/kernel/async.c b/kernel/async.c index 1fa1f39b5a74..83007c39a113 100644 --- a/kernel/async.c +++ b/kernel/async.c @@ -2,6 +2,7 @@ * async.c: Asynchronous function calls for boot performance * * (C) Copyright 2009 Intel Corporation + * (C) Copyright 2016 Intel Corporation * Author: Arjan van de Ven <arjan(a)linux.intel.com> * * This program is free software; you can redistribute it and/or @@ -62,28 +63,31 @@ asynchronous and synchronous parts of the kernel. #include "workqueue_internal.h" -static async_cookie_t next_cookie = 1; - #define MAX_WORK 32768 -#define ASYNC_COOKIE_MAX ULLONG_MAX /* infinity cookie */ - -static LIST_HEAD(async_global_pending); /* pending from all registered doms */ -static ASYNC_DOMAIN(async_dfl_domain); -static DEFINE_SPINLOCK(async_lock); struct async_entry { - struct list_head domain_list; - struct list_head global_list; - struct work_struct work; - async_cookie_t cookie; - async_func_t func; - void *data; - struct async_domain *domain; + struct async_work base; + struct work_struct work; + + struct list_head pending_link[2]; + + async_cookie_t cookie; + async_func_t func; + void *data; }; -static DECLARE_WAIT_QUEUE_HEAD(async_done); +static LIST_HEAD(async_global_pending); /* pending from all registered doms */ +static ASYNC_DOMAIN(async_dfl_domain); +static DEFINE_SPINLOCK(async_lock); +static unsigned async_pending_count; -static atomic_t entry_count; +static async_cookie_t assign_cookie(void) +{ + static async_cookie_t next_cookie; + if (++next_cookie == 0) + next_cookie = 1; + return next_cookie; +} /** * DOC: kfence overview @@ -166,6 +170,8 @@ static atomic_t entry_count; */ #define KFENCE_CHECKED_BIT 0 +#define ASYNC_WORK_BIT 1 +#define ASYNC_QUEUED_BIT 2 static void kfence_free(struct kref *kref) { @@ -173,7 +179,7 @@ static void kfence_free(struct kref *kref) WARN_ON(atomic_read(&fence->pending) > 0); - if (fence->flags) { + if (fence->flags && !test_bit(ASYNC_WORK_BIT, &fence->flags)) { kfence_notify_t fn = (kfence_notify_t)fence->flags; fn(fence); } else @@ -229,6 +235,13 @@ static void __kfence_signal(struct kfence *fence, if (!atomic_dec_and_test(&fence->pending)) return; + if (test_bit(ASYNC_WORK_BIT, &fence->flags)) { + struct async_entry *entry = + container_of(fence, typeof(*entry), base.fence); + queue_work(system_unbound_wq, &entry->work); + return; + } + if (fence->flags) { kfence_notify_t fn = (kfence_notify_t)fence->flags; fn(fence); @@ -322,7 +335,7 @@ EXPORT_SYMBOL_GPL(kfence_create); void kfence_init(struct kfence *fence, kfence_notify_t fn) { __kfence_init(fence); - BUG_ON((unsigned long)fn & KFENCE_CHECKED_BIT); + BUG_ON((unsigned long)fn & (KFENCE_CHECKED_BIT | ASYNC_WORK_BIT)); fence->flags = (unsigned long)fn; } EXPORT_SYMBOL_GPL(kfence_init); @@ -656,36 +669,10 @@ int kfence_add_delay(struct kfence *fence, } EXPORT_SYMBOL_GPL(kfence_add_delay); -static async_cookie_t lowest_in_progress(struct async_domain *domain) -{ - struct list_head *pending; - async_cookie_t ret = ASYNC_COOKIE_MAX; - unsigned long flags; - - spin_lock_irqsave(&async_lock, flags); - - if (domain) - pending = &domain->pending; - else - pending = &async_global_pending; - - if (!list_empty(pending)) - ret = list_first_entry(pending, struct async_entry, - domain_list)->cookie; - - spin_unlock_irqrestore(&async_lock, flags); - return ret; -} - -/* - * pick the first pending entry and run it - */ static void async_run_entry_fn(struct work_struct *work) { - struct async_entry *entry = - container_of(work, struct async_entry, work); - unsigned long flags; - ktime_t uninitialized_var(calltime), delta, rettime; + struct async_entry *entry = container_of(work, typeof(*entry), work); + ktime_t uninitialized_var(calltime); /* 1) run (and print duration) */ if (initcall_debug && system_state == SYSTEM_BOOTING) { @@ -696,8 +683,7 @@ static void async_run_entry_fn(struct work_struct *work) } entry->func(entry->data, entry->cookie); if (initcall_debug && system_state == SYSTEM_BOOTING) { - rettime = ktime_get(); - delta = ktime_sub(rettime, calltime); + ktime_t delta = ktime_sub(ktime_get(), calltime); pr_debug("initcall %lli_%pF returned 0 after %lld usecs\n", (long long)entry->cookie, entry->func, @@ -705,69 +691,71 @@ static void async_run_entry_fn(struct work_struct *work) } /* 2) remove self from the pending queues */ - spin_lock_irqsave(&async_lock, flags); - list_del_init(&entry->domain_list); - list_del_init(&entry->global_list); - - /* 3) free the entry */ - kfree(entry); - atomic_dec(&entry_count); + spin_lock_irq(&async_lock); + list_del(&entry->pending_link[0]); + list_del(&entry->pending_link[1]); + async_pending_count--; + spin_unlock_irq(&async_lock); - spin_unlock_irqrestore(&async_lock, flags); + /* 3) wake up any waiters */ + atomic_dec(&entry->base.fence.pending); + __kfence_wake_up_all(&entry->base.fence, NULL); - /* 4) wake up any waiters */ - wake_up(&async_done); + kfence_put(&entry->base.fence); } -static async_cookie_t __async_schedule(async_func_t func, void *data, struct async_domain *domain) +struct async_work *async_work_create(async_func_t func, void *data, gfp_t gfp) { struct async_entry *entry; - unsigned long flags; - async_cookie_t newcookie; - /* allow irq-off callers */ - entry = kzalloc(sizeof(struct async_entry), GFP_ATOMIC); + entry = kmalloc(sizeof(*entry), gfp); + if (!entry) + return NULL; - /* - * If we're out of memory or if there's too much work - * pending already, we execute synchronously. - */ - if (!entry || atomic_read(&entry_count) > MAX_WORK) { - kfree(entry); - spin_lock_irqsave(&async_lock, flags); - newcookie = next_cookie++; - spin_unlock_irqrestore(&async_lock, flags); + __kfence_init(&entry->base.fence); - /* low on memory.. run synchronously */ - func(data, newcookie); - return newcookie; - } - INIT_LIST_HEAD(&entry->domain_list); - INIT_LIST_HEAD(&entry->global_list); INIT_WORK(&entry->work, async_run_entry_fn); entry->func = func; entry->data = data; - entry->domain = domain; - spin_lock_irqsave(&async_lock, flags); + __set_bit(ASYNC_WORK_BIT, &entry->base.fence.flags); - /* allocate cookie and queue */ - newcookie = entry->cookie = next_cookie++; + return &entry->base; +} +EXPORT_SYMBOL_GPL(async_work_create); - list_add_tail(&entry->domain_list, &domain->pending); - if (domain->registered) - list_add_tail(&entry->global_list, &async_global_pending); +async_cookie_t queue_async_work(struct async_domain *domain, + struct async_work *work, + gfp_t gfp) +{ + struct async_entry *entry = container_of(work, typeof(*entry), base); + unsigned long flags; - atomic_inc(&entry_count); + if (WARN_ON(test_and_set_bit(ASYNC_QUEUED_BIT, + &entry->base.fence.flags))) + return 0; + + spin_lock_irqsave(&async_lock, flags); + entry->cookie = assign_cookie(); + list_add_tail(&entry->pending_link[0], &domain->pending); + INIT_LIST_HEAD(&entry->pending_link[1]); + if (domain->registered) + list_add_tail(&entry->pending_link[1], &async_global_pending); + async_pending_count++; spin_unlock_irqrestore(&async_lock, flags); /* mark that this task has queued an async job, used by module init */ current->flags |= PF_USED_ASYNC; - /* schedule for execution */ - queue_work(system_unbound_wq, &entry->work); + kfence_signal(kfence_get(&entry->base.fence)); - return newcookie; + return entry->cookie; +} +EXPORT_SYMBOL_GPL(queue_async_work); + +async_cookie_t schedule_async_work(struct async_work *work) +{ + return queue_async_work(&async_dfl_domain, work, GFP_KERNEL); } /** @@ -780,7 +768,7 @@ static async_cookie_t __async_schedule(async_func_t func, void *data, struct asy */ async_cookie_t async_schedule(async_func_t func, void *data) { - return __async_schedule(func, data, &async_dfl_domain); + return async_schedule_domain(func, data, &async_dfl_domain); } EXPORT_SYMBOL_GPL(async_schedule); @@ -799,7 +787,27 @@ EXPORT_SYMBOL_GPL(async_schedule); async_cookie_t async_schedule_domain(async_func_t func, void *data, struct async_domain *domain) { - return __async_schedule(func, data, domain); + struct async_work *work; + async_cookie_t cookie = 0; + + work = NULL; + if (READ_ONCE(async_pending_count) < MAX_WORK) + work = async_work_create(func, data, GFP_ATOMIC); + if (work) { + cookie = queue_async_work(domain, work, GFP_ATOMIC); + async_work_put(work); + } + if (!cookie) { + unsigned long flags; + + spin_lock_irqsave(&async_lock, flags); + cookie = assign_cookie(); + spin_unlock_irqrestore(&async_lock, flags); + + func(data, cookie); + } + + return cookie; } EXPORT_SYMBOL_GPL(async_schedule_domain); @@ -825,10 +833,8 @@ EXPORT_SYMBOL_GPL(async_synchronize_full); */ void async_unregister_domain(struct async_domain *domain) { - spin_lock_irq(&async_lock); - WARN_ON(!domain->registered || !list_empty(&domain->pending)); + WARN_ON(!list_empty(&domain->pending)); domain->registered = 0; - spin_unlock_irq(&async_lock); } EXPORT_SYMBOL_GPL(async_unregister_domain); @@ -841,7 +847,7 @@ EXPORT_SYMBOL_GPL(async_unregister_domain); */ void async_synchronize_full_domain(struct async_domain *domain) { - async_synchronize_cookie_domain(ASYNC_COOKIE_MAX, domain); + async_synchronize_cookie_domain(0, domain); } EXPORT_SYMBOL_GPL(async_synchronize_full_domain); @@ -856,19 +862,49 @@ EXPORT_SYMBOL_GPL(async_synchronize_full_domain); */ void async_synchronize_cookie_domain(async_cookie_t cookie, struct async_domain *domain) { - ktime_t uninitialized_var(starttime), delta, endtime; + ktime_t uninitialized_var(starttime); + struct list_head *pending; + + pending = domain ? &domain->pending : &async_global_pending; if (initcall_debug && system_state == SYSTEM_BOOTING) { pr_debug("async_waiting @ %i\n", task_pid_nr(current)); starttime = ktime_get(); } - wait_event(async_done, lowest_in_progress(domain) >= cookie); + do { + struct kfence *fence = NULL; + unsigned long flags; - if (initcall_debug && system_state == SYSTEM_BOOTING) { - endtime = ktime_get(); - delta = ktime_sub(endtime, starttime); + spin_lock_irqsave(&async_lock, flags); + if (!list_empty(pending)) { + struct async_entry *entry; + + if (cookie) { + entry = list_first_entry(pending, + struct async_entry, + pending_link[!domain]); + if ((s64)(cookie - entry->cookie) > 0) + fence = kfence_get(&entry->base.fence); + } else { + entry = list_last_entry(pending, + struct async_entry, + pending_link[!domain]); + cookie = entry->cookie; + fence = kfence_get(&entry->base.fence); + } + } + spin_unlock_irqrestore(&async_lock, flags); + + if (!fence) + break; + + kfence_wait(fence); + kfence_put(fence); + } while (1); + if (initcall_debug && system_state == SYSTEM_BOOTING) { + ktime_t delta = ktime_sub(ktime_get(), starttime); pr_debug("async_continuing @ %i after %lli usec\n", task_pid_nr(current), (long long)ktime_to_ns(delta) >> 10); @@ -901,3 +937,11 @@ bool current_is_async(void) return worker && worker->current_func == async_run_entry_fn; } EXPORT_SYMBOL_GPL(current_is_async); + +void init_async_domain(struct async_domain *domain, bool registered) +{ + memset(domain, 0, sizeof(*domain)); + INIT_LIST_HEAD(&domain->pending); + domain->registered = registered; +} +EXPORT_SYMBOL_GPL(init_async_domain); diff --git a/lib/test-async-domain.c b/lib/test-async-domain.c index 558a71414fb6..24c55537c678 100644 --- a/lib/test-async-domain.c +++ b/lib/test-async-domain.c @@ -21,6 +21,269 @@ static void task_B(void *data, async_cookie_t cookie) smp_store_mb(*result, 'B'); } +static int __init test_x(const char *name, + struct async_domain *domain, + async_func_t func, + const long expected) +{ + struct async_work *A; + long result = 0; + + A = async_work_create(func, &result, GFP_KERNEL); + if (!A) + return -ENOMEM; + + queue_async_work(domain, A, GFP_KERNEL); + async_work_wait(A); + async_work_put(A); + + if (READ_ONCE(result) != expected) { + pr_warn("%s expected %c [%ld], got %ld\n", + name, (char)expected, expected, result); + return -EINVAL; + } + + return 0; +} + +static int __init test_A(struct async_domain *domain) +{ + return test_x(__func__, domain, task_A, 'A'); +} + +static int __init test_B(struct async_domain *domain) +{ + return test_x(__func__, domain, task_B, 'B'); +} + +static int __init test_x_fence(const char *name, + struct async_domain *domain, + async_func_t func, + const long expected) +{ + struct async_work *A; + struct kfence *fence; + long result = 0; + + A = async_work_create(func, &result, GFP_KERNEL); + if (!A) + return -ENOMEM; + + fence = kfence_create(GFP_KERNEL); + if (!fence) + return -ENOMEM; + + queue_async_work(domain, A, GFP_KERNEL); + + kfence_add(fence, &A->fence, GFP_KERNEL); + kfence_signal(fence); + + kfence_wait(fence); + + async_work_put(A); + kfence_put(fence); + + if (READ_ONCE(result) != expected) { + pr_warn("%s expected %c [%ld], got %ld\n", + name, (char)expected, expected, result); + return -EINVAL; + } + + return 0; +} + +static int __init test_A_fence(struct async_domain *domain) +{ + return test_x_fence(__func__, domain, task_A, 'A'); +} + +static int __init test_B_fence(struct async_domain *domain) +{ + return test_x_fence(__func__, domain, task_B, 'B'); +} + +static int __init test_x_fence_y(const char *name, + struct async_domain *domain, + async_func_t x, + async_func_t y, + const long expected) +{ + struct async_work *A, *B; + struct kfence *fence; + long result = 0; + + A = async_work_create(x, &result, GFP_KERNEL); + if (!A) + return -ENOMEM; + + B = async_work_create(y, &result, GFP_KERNEL); + if (!B) + return -ENOMEM; + + fence = kfence_create(GFP_KERNEL); + if (!fence) + return -ENOMEM; + + kfence_add(fence, &A->fence, GFP_KERNEL); + kfence_signal(fence); + + queue_async_work(domain, A, GFP_KERNEL); + async_work_put(A); + + async_work_after(B, fence); + queue_async_work(domain, B, GFP_KERNEL); + kfence_put(fence); + + async_work_wait(B); + async_work_put(B); + + if (READ_ONCE(result) != expected) { + pr_warn("%s expected %c [%ld], got %ld\n", + name, (char)expected, expected, result); + return -EINVAL; + } + + return 0; +} + +static int __init test_A_fence_B(struct async_domain *domain) +{ + return test_x_fence_y(__func__, domain, task_A, task_B, 'B'); +} + +static int __init test_B_fence_A(struct async_domain *domain) +{ + return test_x_fence_y(__func__, domain, task_B, task_A, 'A'); +} + +struct long_context { + struct kfence *barrier; + long *src; + long result; +}; + +static void task_wait(void *data, async_cookie_t cookie) +{ + struct long_context *ctx = data; + + kfence_wait(ctx->barrier); + smp_store_mb(ctx->result, READ_ONCE(*ctx->src)); +} + +static int __init test_pause(struct async_domain *domain) +{ + struct long_context ctx; + struct async_work *A, *B; + const long expected = 'B'; + long out_B = 'A'; + + ctx.result = 0; + ctx.src = &out_B; + + A = async_work_create(task_wait, &ctx, GFP_KERNEL); + if (!A) + return -ENOMEM; + + B = async_work_create(task_B, &out_B, GFP_KERNEL); + if (!B) + return -ENOMEM; + + ctx.barrier = kfence_get(&B->fence); + + queue_async_work(domain, A, GFP_KERNEL); + queue_async_work(domain, B, GFP_KERNEL); + async_work_put(B); + + async_work_wait(A); + async_work_put(A); + + if (READ_ONCE(ctx.result) != expected) { + pr_warn("%s expected %c [%ld], got %ld\n", + __func__, (char)expected, expected, ctx.result); + return -EINVAL; + } + + kfence_put(ctx.barrier); + + return 0; +} + +static void task_signal(void *data, async_cookie_t cookie) +{ + struct long_context *ctx = data; + + kfence_signal(ctx->barrier); +} + +static int __init test_manual(struct async_domain *domain) +{ + struct long_context ctx; + struct async_work *A, *B, *C; + const long expected = 'B'; + long out_B = 'A'; + + ctx.result = 0; + ctx.src = &out_B; + ctx.barrier = kfence_create(GFP_KERNEL); + + A = async_work_create(task_wait, &ctx, GFP_KERNEL); + if (!A) + return -ENOMEM; + + B = async_work_create(task_B, &out_B, GFP_KERNEL); + if (!B) + return -ENOMEM; + + C = async_work_create(task_signal, &ctx, GFP_KERNEL); + if (!B) + return -ENOMEM; + + async_work_after(C, &B->fence); + + queue_async_work(domain, A, GFP_KERNEL); + queue_async_work(domain, B, GFP_KERNEL); + queue_async_work(domain, C, GFP_KERNEL); + + async_work_wait(A); + + async_work_put(C); + async_work_put(B); + async_work_put(A); + kfence_put(ctx.barrier); + + if (READ_ONCE(ctx.result) != expected) { + pr_warn("%s expected %c [%ld], got %ld\n", + __func__, (char)expected, expected, ctx.result); + return -EINVAL; + } + + return 0; +} + +static int __init test_sync(struct async_domain *domain) +{ + struct async_work *B; + const long expected = 'B'; + long result = 0; + + B = async_work_create(task_B, &result, GFP_KERNEL); + if (!B) + return -ENOMEM; + + queue_async_work(domain, B, GFP_KERNEL); + async_work_put(B); + + async_synchronize_full_domain(domain); + + if (READ_ONCE(result) != expected) { + pr_warn("%s expected %c [%ld], got %ld\n", + __func__, (char)expected, expected, result); + return -EINVAL; + } + + return 0; +} + static int __init test_implicit(struct async_domain *domain) { const long expected = 'B'; @@ -99,24 +362,62 @@ static int __init test_async_domain_init(void) pr_info("Testing async-domains\n"); - ret = test_implicit(&domain); + ret = test_A(&domain); if (ret) return ret; + ret = test_A_fence(&domain); + if (ret) + goto err; + + ret = test_A_fence_B(&domain); + if (ret) + goto err; + + ret = test_B(&domain); + if (ret) + goto err; + + ret = test_B_fence(&domain); + if (ret) + goto err; + + ret = test_B_fence_A(&domain); + if (ret) + goto err; + + ret = test_pause(&domain); + if (ret) + goto err; + + ret = test_manual(&domain); + if (ret) + goto err; + + ret = test_sync(&domain); + if (ret) + goto err; + + ret = test_implicit(&domain); + if (ret) + goto err; + ret = test_registered(&domain); if (ret) - return ret; + goto err; ret = perf_nop(1, 100); if (ret) - return ret; + goto err; ret = perf_nop(128, 1000); if (ret) - return ret; + goto err; +err: + async_synchronize_full_domain(&domain); async_unregister_domain(&domain); - return 0; + return ret; } static void __exit test_async_domain_cleanup(void) -- 2.8.1

9 years

[PATCH 6/9] async: Add a convenience wrapper for waiting on implicit dma-buf

by Chris Wilson

dma-buf implicitly track their (DMA) rendering using a reservation_object, which tracks ether the last write (in an exclusive fence) or the current renders (with a set of shared fences). To wait upon a reservation object in conjunction with other sources, kfence_add_reservation() extracts the DMA fences from the object and adds the individual waits for the kfence. Signed-off-by: Chris Wilson <chris(a)chris-wilson.co.uk> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Shuah Khan <shuahkh(a)osg.samsung.com> Cc: Tejun Heo <tj(a)kernel.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Ingo Molnar <mingo(a)kernel.org> Cc: Kees Cook <keescook(a)chromium.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> Cc: Dan Williams <dan.j.williams(a)intel.com> Cc: Andrey Ryabinin <aryabinin(a)virtuozzo.com> Cc: Davidlohr Bueso <dave(a)stgolabs.net> Cc: Nikolay Aleksandrov <nikolay(a)cumulusnetworks.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: "Peter Zijlstra (Intel)" <peterz(a)infradead.org> Cc: Rasmus Villemoes <linux(a)rasmusvillemoes.dk> Cc: Andy Shevchenko <andriy.shevchenko(a)linux.intel.com> Cc: Dmitry Vyukov <dvyukov(a)google.com> Cc: Alexander Potapenko <glider(a)google.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-media(a)vger.kernel.org Cc: dri-devel(a)lists.freedesktop.org Cc: linaro-mm-sig(a)lists.linaro.org --- include/linux/kfence.h | 5 ++++ kernel/async.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 65 insertions(+), 5 deletions(-) diff --git a/include/linux/kfence.h b/include/linux/kfence.h index 1abec5e6b23c..2f01eb052e4d 100644 --- a/include/linux/kfence.h +++ b/include/linux/kfence.h @@ -17,6 +17,7 @@ struct completion; struct fence; enum hrtimer_mode; +struct reservation_object; struct kfence { wait_queue_head_t wait; @@ -34,6 +35,10 @@ extern int kfence_add_completion(struct kfence *fence, extern int kfence_add_dma(struct kfence *fence, struct fence *dma, gfp_t gfp); +extern int kfence_add_reservation(struct kfence *fence, + struct reservation_object *resv, + bool write, + gfp_t gfp); extern int kfence_add_delay(struct kfence *fence, clockid_t clock, enum hrtimer_mode mode, ktime_t delay, u64 slack, diff --git a/kernel/async.c b/kernel/async.c index 5d02445e36b7..1fa1f39b5a74 100644 --- a/kernel/async.c +++ b/kernel/async.c @@ -54,9 +54,10 @@ asynchronous and synchronous parts of the kernel. #include <linux/kfence.h> #include <linux/ktime.h> #include <linux/export.h> -#include <linux/wait.h> +#include <linux/reservation.h> #include <linux/sched.h> #include <linux/slab.h> +#include <linux/wait.h> #include <linux/workqueue.h> #include "workqueue_internal.h" @@ -123,11 +124,17 @@ static atomic_t entry_count; * allowing multiple pending / signals to be sent before the kfence is * complete. * - * kfence_add() / kfence_add_completion() / kfence_add_dma() + * kfence_add() / kfence_add_completion() + * / kfence_add_dma() + * + * sets the kfence to wait upon another fence or completion respectively. To + * wait upon DMA activity, either use * - * sets the kfence to wait upon another fence, completion, or DMA fence - * respectively. To set the fence to wait for at least a certain period of - * time, or until after a certain point in time, use + * kfence_add_dma() or kfence_add_reservation() + * + * depending on the manner of DMA activity tracking. To set the fence to wait + * for at least a certain period of time, or until after a certain point in + * time, use * * kfence_add_timer() * @@ -547,6 +554,54 @@ int kfence_add_dma(struct kfence *fence, struct fence *dma, gfp_t gfp) EXPORT_SYMBOL_GPL(kfence_add_dma); /** + * kfence_add_reservation - set the fence to wait upon a reservation_object + * @fence: this kfence + * @resv: target reservation_object (collection of DMA fences) to wait upon + * @write: Wait for read or read/write access + * @gfp: the allowed allocation type + * + * kfence_add_reservation() causes the @fence to wait upon completion of the + * reservation object (a collection of DMA fences), either for read access + * or for read/write access. + * + * Returns 1 if the @fence was successfully to the waitqueues of @resv, 0 + * if @resev was already signaled (and so not added), or a negative error code. + */ +int kfence_add_reservation(struct kfence *fence, + struct reservation_object *resv, + bool write, + gfp_t gfp) +{ + struct fence *excl, **shared; + unsigned count, i; + int ret; + + ret = reservation_object_get_fences_rcu(resv, &excl, &count, &shared); + if (ret) + return ret; + + if (write) { + for (i = 0; i < count; i++) { + ret |= kfence_add_dma(fence, shared[i], gfp); + if (ret < 0) + goto out; + } + } + + if (excl) + ret |= kfence_add_dma(fence, excl, gfp); + +out: + fence_put(excl); + for (i = 0; i < count; i++) + fence_put(shared[i]); + kfree(shared); + + return ret; +} +EXPORT_SYMBOL_GPL(kfence_add_reservation); + +/** * kfence_add_delay - set the fence to wait for a period of time * @fence: this kfence * @clock: which clock to program -- 2.8.1

9 years

[PATCH 4/9] async: Extend kfences for listening on DMA fences

by Chris Wilson

dma-buf provides an interfaces for receiving notifications from DMA hardware. kfence provides a useful interface for collecting such fences and combining them with other events. Signed-off-by: Chris Wilson <chris(a)chris-wilson.co.uk> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Shuah Khan <shuahkh(a)osg.samsung.com> Cc: Tejun Heo <tj(a)kernel.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Ingo Molnar <mingo(a)kernel.org> Cc: Kees Cook <keescook(a)chromium.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> Cc: Dan Williams <dan.j.williams(a)intel.com> Cc: Andrey Ryabinin <aryabinin(a)virtuozzo.com> Cc: Davidlohr Bueso <dave(a)stgolabs.net> Cc: Nikolay Aleksandrov <nikolay(a)cumulusnetworks.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: "Peter Zijlstra (Intel)" <peterz(a)infradead.org> Cc: Rasmus Villemoes <linux(a)rasmusvillemoes.dk> Cc: Andy Shevchenko <andriy.shevchenko(a)linux.intel.com> Cc: Dmitry Vyukov <dvyukov(a)google.com> Cc: Alexander Potapenko <glider(a)google.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-media(a)vger.kernel.org Cc: dri-devel(a)lists.freedesktop.org Cc: linaro-mm-sig(a)lists.linaro.org --- include/linux/kfence.h | 4 ++++ kernel/async.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 65 insertions(+), 2 deletions(-) diff --git a/include/linux/kfence.h b/include/linux/kfence.h index 82096bfafaa1..d71f30c626ae 100644 --- a/include/linux/kfence.h +++ b/include/linux/kfence.h @@ -15,6 +15,7 @@ #include <linux/wait.h> struct completion; +struct fence; struct kfence { wait_queue_head_t wait; @@ -29,6 +30,9 @@ extern int kfence_add(struct kfence *fence, struct kfence *after, gfp_t gfp); extern int kfence_add_completion(struct kfence *fence, struct completion *x, gfp_t gfp); +extern int kfence_add_dma(struct kfence *fence, + struct fence *dma, + gfp_t gfp); extern void kfence_pending(struct kfence *fence); extern void kfence_signal(struct kfence *fence); extern void kfence_wait(struct kfence *fence); diff --git a/kernel/async.c b/kernel/async.c index db22b890711e..01552d23a916 100644 --- a/kernel/async.c +++ b/kernel/async.c @@ -50,6 +50,7 @@ asynchronous and synchronous parts of the kernel. #include <linux/async.h> #include <linux/atomic.h> +#include <linux/fence.h> #include <linux/kfence.h> #include <linux/ktime.h> #include <linux/export.h> @@ -122,9 +123,10 @@ static atomic_t entry_count; * allowing multiple pending / signals to be sent before the kfence is * complete. * - * kfence_add() / kfence_add_completion() + * kfence_add() / kfence_add_completion() / kfence_add_dma() * - * sets the kfence to wait upon another fence, or completion respectively. + * sets the kfence to wait upon another fence, completion, or DMA fence + * respectively. * * Unlike completions, kfences are expected to live inside more complex graphs * and form the basis for parallel execution of interdependent and so are @@ -484,6 +486,63 @@ int kfence_add_completion(struct kfence *fence, struct completion *x, gfp_t gfp) } EXPORT_SYMBOL_GPL(kfence_add_completion); +struct dma_fence_cb { + struct fence_cb base; + struct kfence *fence; +}; + +static void dma_kfence_wake(struct fence *dma, struct fence_cb *data) +{ + struct dma_fence_cb *cb = container_of(data, typeof(*cb), base); + kfence_signal(cb->fence); + kfence_put(cb->fence); + kfree(cb); +} + +/** + * kfence_add_dma - set the fence to wait upon a DMA fence + * @fence: this kfence + * @dma: target DMA fence to wait upon + * @gfp: the allowed allocation type + * + * kfence_add_dma() causes the @fence to wait upon completion of a DMA fence. + * + * Returns 1 if the @fence was successfully to the waitqueue of @dma, 0 + * if @dma was already signaled (and so not added), or a negative error code. + */ +int kfence_add_dma(struct kfence *fence, struct fence *dma, gfp_t gfp) +{ + struct dma_fence_cb *cb; + int ret; + + if (!dma || fence_is_signaled(dma)) + return 0; + + cb = kmalloc(sizeof(*cb), gfp); + if (!cb) { + if (!gfpflags_allow_blocking(gfp)) + return -ENOMEM; + + return fence_wait(dma, false); + } + + cb->fence = kfence_get(fence); + kfence_pending(fence); + + ret = fence_add_callback(dma, &cb->base, dma_kfence_wake); + if (ret == 0) { + /* signal fence add and is pending */ + ret = 1; + } else { + dma_kfence_wake(dma, &cb->base); + if (ret == -ENOENT) /* fence already signaled */ + ret = 0; + } + + return ret; +} +EXPORT_SYMBOL_GPL(kfence_add_dma); + static async_cookie_t lowest_in_progress(struct async_domain *domain) { struct list_head *pending; -- 2.8.1

9 years

[PATCH v4 0/4] Generic zpos property

by Benjamin Gaignard

version 4: make sure that normalized zpos value is stay in the defined property range and warn user if not. Fix NULL pointer bug in rcar-du while setting zpos value. No changes in the other drivers. version 3: use kmalloc_array instead of kmalloc. Correct normalize_zpos computation (comeback to Mareck original code) version 2: add a zpos property into drm_plane structure to simplify code. This allow to get/set zpos value in core and not in drivers code. Fix various remarks. version 1: refactor Marek's patches to have per plane zpos property instead of only one in core. Benjamin Gaignard (3): drm: add generic zpos property drm: sti: use generic zpos for plane drm: rcar: use generic code for managing zpos plane property Marek Szyprowski (1): drm/exynos: use generic code for managing zpos plane property Documentation/DocBook/gpu.tmpl | 10 ++ drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_atomic.c | 4 + drivers/gpu/drm/drm_atomic_helper.c | 6 + drivers/gpu/drm/drm_blend.c | 230 ++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_crtc_internal.h | 3 + drivers/gpu/drm/exynos/exynos_drm_drv.h | 2 - drivers/gpu/drm/exynos/exynos_drm_plane.c | 67 ++------- drivers/gpu/drm/exynos/exynos_mixer.c | 6 +- drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 2 +- drivers/gpu/drm/rcar-du/rcar_du_drv.h | 1 - drivers/gpu/drm/rcar-du/rcar_du_kms.c | 5 - drivers/gpu/drm/rcar-du/rcar_du_plane.c | 9 +- drivers/gpu/drm/rcar-du/rcar_du_plane.h | 2 - drivers/gpu/drm/sti/sti_mixer.c | 9 +- drivers/gpu/drm/sti/sti_plane.c | 80 ++++------- drivers/gpu/drm/sti/sti_plane.h | 2 - include/drm/drm_crtc.h | 30 ++++ 18 files changed, 331 insertions(+), 139 deletions(-) create mode 100644 drivers/gpu/drm/drm_blend.c Cc: Inki Dae <inki.dae(a)samsung.com> Cc: Daniel Vetter <daniel(a)ffwll.ch> Cc: Ville Syrjala <ville.syrjala(a)linux.intel.com> Cc: Joonyoung Shim <jy0922.shim(a)samsung.com> Cc: Seung-Woo Kim <sw0312.kim(a)samsung.com> Cc: Andrzej Hajda <a.hajda(a)samsung.com> Cc: Krzysztof Kozlowski <k.kozlowski(a)samsung.com> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie(a)samsung.com> Cc: Tobias Jakobi <tjakobi(a)math.uni-bielefeld.de> Cc: Gustavo Padovan <gustavo(a)padovan.org> Cc: vincent.abriou(a)st.com Cc: fabien.dessenne(a)st.com Cc: Laurent Pinchart <laurent.pinchart(a)ideasonboard.com> -- 1.9.1

9 years

[PATCH 0/3] dma-buf: debugfs fixes

by Mathias Krause

This small series is the v2 of the patch posted initially here: http://www.spinics.net/lists/linux-media/msg101347.html It not only fixes the type mix-up and addresses Daniel's remark (patch 1), it also smoothes out the error handling in dma_buf_init_debugfs() (patch 2) and removes the then unneeded function dma_buf_debugfs_create_file() (patch 3). Please apply! Mathias Krause (3): dma-buf: propagate errors from dma_buf_describe() on debugfs read dma-buf: remove dma_buf directory on bufinfo file creation errors dma-buf: remove dma_buf_debugfs_create_file() drivers/dma-buf/dma-buf.c | 44 ++++++++++++++------------------------------ include/linux/dma-buf.h | 2 -- 2 files changed, 14 insertions(+), 32 deletions(-) -- 1.7.10.4

9 years

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

Linaro-mm-sig