dma-buf: Introduce selftesting framework (9536b64a) · Commits · 戴 / test

drivers/dma-buf/Kconfig

+5 −0

Original line number	Original line	Diff line number	Diff line
	@@ -39,4 +39,9 @@ config UDMABUF
	A driver to let userspace turn memfd regions into dma-bufs.		A driver to let userspace turn memfd regions into dma-bufs.
	Qemu can use this to create host dmabufs for guest framebuffers.		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		endmenu

drivers/dma-buf/Makefile

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -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_SYNC_FILE) += sync_file.o
	obj-$(CONFIG_SW_SYNC) += sw_sync.o sync_debug.o		obj-$(CONFIG_SW_SYNC) += sw_sync.o sync_debug.o
	obj-$(CONFIG_UDMABUF) += udmabuf.o		obj-$(CONFIG_UDMABUF) += udmabuf.o

			dmabuf_selftests-y := selftest.o
			obj-$(CONFIG_DMABUF_SELFTESTS) += dmabuf_selftests.o

drivers/dma-buf/selftest.c

0 → 100644

+167 −0

Original line number	Original line	Diff line number	Diff line
			/* 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");

drivers/dma-buf/selftest.h

0 → 100644

+30 −0

Original line number	Original line	Diff line number	Diff line
			// 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__ */

drivers/dma-buf/selftests.h

0 → 100644

+12 −0

Original line number	Original line	Diff line number	Diff line
			/* 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) */

Admin message