dma-buf: Introduce selftesting framework

In light of recent review slip ups, the absence of a suite of tests for
dma-buf became apparent. Given the current plethora of testing
frameworks, opt for one already in use by Intel's CI and so allow easy
hook up into igt.

We introduce a new module that when loaded will execute the list of
selftests and their subtest. The names of the selftests are put into the
modinfo as parameters so that igt can identify each, and run them
independently, principally for ease of error reporting.

Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Tomi Sarvela <tomi.p.sarvela@intel.com>
Acked-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: https://patchwork.freedesktop.org/patch/msgid/20190819095928.32091-1-chris@chris-wilson.co.uk

5 files changed, 217 insertions, 0 deletions

diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig
index b6a9c2f1bc41..a23b6752d11a 100644
--- a/drivers/dma-buf/Kconfig
+++ b/drivers/dma-buf/Kconfig
@@ -39,4 +39,9 @@ config UDMABUF
           A driver to let userspace turn memfd regions into dma-bufs.
           Qemu can use this to create host dmabufs for guest framebuffers.
 
+config DMABUF_SELFTESTS
+        tristate "Selftests for the dma-buf interfaces"
+        default n
+        depends on DMA_SHARED_BUFFER
+
 endmenu
diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile
index dcfb01e7c6f4..b5ae122a9349 100644
--- a/drivers/dma-buf/Makefile
+++ b/drivers/dma-buf/Makefile
@@ -4,3 +4,6 @@ obj-y := dma-buf.o dma-fence.o dma-fence-array.o dma-fence-chain.o \
 obj-$(CONFIG_SYNC_FILE)         += sync_file.o
 obj-$(CONFIG_SW_SYNC)           += sw_sync.o sync_debug.o
 obj-$(CONFIG_UDMABUF)           += udmabuf.o
+
+dmabuf_selftests-y := selftest.o
+obj-$(CONFIG_DMABUF_SELFTESTS)  += dmabuf_selftests.o
diff --git a/drivers/dma-buf/selftest.c b/drivers/dma-buf/selftest.c
new file mode 100644
index 000000000000..c60b6944b4bd
--- /dev/null
+++ b/drivers/dma-buf/selftest.c
@@ -0,0 +1,167 @@
+/* SPDX-License-Identifier: MIT */
+
+/*
+ * Copyright © 2019 Intel Corporation
+ */
+
+#include <linux/compiler.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/sched/signal.h>
+#include <linux/slab.h>
+
+#include "selftest.h"
+
+enum {
+#define selftest(n, func) __idx_##n,
+#include "selftests.h"
+#undef selftest
+};
+
+#define selftest(n, f) [__idx_##n] = { .name = #n, .func = f },
+static struct selftest {
+        bool enabled;
+        const char *name;
+        int (*func)(void);
+} selftests[] = {
+#include "selftests.h"
+};
+#undef selftest
+
+/* Embed the line number into the parameter name so that we can order tests */
+#define param(n) __PASTE(igt__, __PASTE(__PASTE(__LINE__, __), n))
+#define selftest_0(n, func, id) \
+module_param_named(id, selftests[__idx_##n].enabled, bool, 0400);
+#define selftest(n, func) selftest_0(n, func, param(n))
+#include "selftests.h"
+#undef selftest
+
+int __sanitycheck__(void)
+{
+        pr_debug("Hello World!\n");
+        return 0;
+}
+
+static char *__st_filter;
+
+static bool apply_subtest_filter(const char *caller, const char *name)
+{
+        char *filter, *sep, *tok;
+        bool result = true;
+
+        filter = kstrdup(__st_filter, GFP_KERNEL);
+        for (sep = filter; (tok = strsep(&sep, ","));) {
+                bool allow = true;
+                char *sl;
+
+                if (*tok == '!') {
+                        allow = false;
+                        tok++;
+                }
+
+                if (*tok == '\0')
+                        continue;
+
+                sl = strchr(tok, '/');
+                if (sl) {
+                        *sl++ = '\0';
+                        if (strcmp(tok, caller)) {
+                                if (allow)
+                                        result = false;
+                                continue;
+                        }
+                        tok = sl;
+                }
+
+                if (strcmp(tok, name)) {
+                        if (allow)
+                                result = false;
+                        continue;
+                }
+
+                result = allow;
+                break;
+        }
+        kfree(filter);
+
+        return result;
+}
+
+int
+__subtests(const char *caller, const struct subtest *st, int count, void *data)
+{
+        int err;
+
+        for (; count--; st++) {
+                cond_resched();
+                if (signal_pending(current))
+                        return -EINTR;
+
+                if (!apply_subtest_filter(caller, st->name))
+                        continue;
+
+                pr_info("dma-buf: Running %s/%s\n", caller, st->name);
+
+                err = st->func(data);
+                if (err && err != -EINTR) {
+                        pr_err("dma-buf/%s: %s failed with error %d\n",
+                               caller, st->name, err);
+                        return err;
+                }
+        }
+
+        return 0;
+}
+
+static void set_default_test_all(struct selftest *st, unsigned long count)
+{
+        unsigned long i;
+
+        for (i = 0; i < count; i++)
+                if (st[i].enabled)
+                        return;
+
+        for (i = 0; i < count; i++)
+                st[i].enabled = true;
+}
+
+static int run_selftests(struct selftest *st, unsigned long count)
+{
+        int err = 0;
+
+        set_default_test_all(st, count);
+
+        /* Tests are listed in natural order in selftests.h */
+        for (; count--; st++) {
+                if (!st->enabled)
+                        continue;
+
+                pr_info("dma-buf: Running %s\n", st->name);
+                err = st->func();
+                if (err)
+                        break;
+        }
+
+        if (WARN(err > 0 || err == -ENOTTY,
+                 "%s returned %d, conflicting with selftest's magic values!\n",
+                 st->name, err))
+                err = -1;
+
+        return err;
+}
+
+static int __init st_init(void)
+{
+        return run_selftests(selftests, ARRAY_SIZE(selftests));
+}
+
+static void __exit st_exit(void)
+{
+}
+
+module_param_named(st_filter, __st_filter, charp, 0400);
+module_init(st_init);
+module_exit(st_exit);
+
+MODULE_DESCRIPTION("Self-test harness for dma-buf");
+MODULE_LICENSE("GPL and additional rights");
diff --git a/drivers/dma-buf/selftest.h b/drivers/dma-buf/selftest.h
new file mode 100644
index 000000000000..45793aff6142
--- /dev/null
+++ b/drivers/dma-buf/selftest.h
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+
+/*
+ * Copyright © 2019 Intel Corporation
+ */
+
+#ifndef __SELFTEST_H__
+#define __SELFTEST_H__
+
+#include <linux/compiler.h>
+
+#define selftest(name, func) int func(void);
+#include "selftests.h"
+#undef selftest
+
+struct subtest {
+        int (*func)(void *data);
+        const char *name;
+};
+
+int __subtests(const char *caller,
+               const struct subtest *st,
+               int count,
+               void *data);
+#define subtests(T, data) \
+        __subtests(__func__, T, ARRAY_SIZE(T), data)
+
+#define SUBTEST(x) { x, #x }
+
+#endif /* __SELFTEST_H__ */
diff --git a/drivers/dma-buf/selftests.h b/drivers/dma-buf/selftests.h
new file mode 100644
index 000000000000..44b44390d23a
--- /dev/null
+++ b/drivers/dma-buf/selftests.h
@@ -0,0 +1,12 @@
+/* SPDX-License-Identifier: MIT */
+/* List each unit test as selftest(name, function)
+ *
+ * The name is used as both an enum and expanded as subtest__name to create
+ * a module parameter. It must be unique and legal for a C identifier.
+ *
+ * The function should be of type int function(void). It may be conditionally
+ * compiled using #if IS_ENABLED(DRM_I915_SELFTEST).
+ *
+ * Tests are executed in order by igt/dmabuf_selftest
+ */
+selftest(sanitycheck, __sanitycheck__) /* keep first (igt selfcheck) */