The ktf module itself and basic data structures for management of test cases and tests and contexts for tests. Also contains the top level include file for kernel clients in ktf.h.

More elaborate documentation follows towards the end of the patch set.

This patch set contains both user level and kernel code, we'll provide the full implementation of ktf on the kernel side in this and forthcoming patches, then the user space code to execute tests within the kernel and report results, then documentation before introducing a small self test suite of tests to test ktf itself, and some very simple additional example tests.

ktf.h: Defines the KTF user API for kernel clients ktf_test.c: Kernel side code for tracking and reporting ktf test results

Signed-off-by: Knut Omang knut.omang@oracle.com --- tools/testing/selftests/ktf/kernel/Makefile | 15 +- tools/testing/selftests/ktf/kernel/ktf.h | 604 ++++++++++++++++- tools/testing/selftests/ktf/kernel/ktf_context.c | 409 +++++++++++- tools/testing/selftests/ktf/kernel/ktf_test.c | 397 +++++++++++- tools/testing/selftests/ktf/kernel/ktf_test.h | 381 ++++++++++- 5 files changed, 1806 insertions(+) create mode 100644 tools/testing/selftests/ktf/kernel/Makefile create mode 100644 tools/testing/selftests/ktf/kernel/ktf.h create mode 100644 tools/testing/selftests/ktf/kernel/ktf_context.c create mode 100644 tools/testing/selftests/ktf/kernel/ktf_test.c create mode 100644 tools/testing/selftests/ktf/kernel/ktf_test.h

diff --git a/tools/testing/selftests/ktf/kernel/Makefile b/tools/testing/selftests/ktf/kernel/Makefile new file mode 100644 index 0000000..0897ae2 --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/Makefile @@ -0,0 +1,15 @@ +# Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved. +# +# SPDX-License-Identifier: GPL-2.0 +# +# Implementation of the kernel part of Kernel Test Framework (KTF), +# a framework for running unit test like tests within the kernel. +# + +obj-m := ktf.o + +include $(srctree)/$(src)/../scripts/ktf_syms.mk + +ktf-y := ktf_context.o ktf_nl.o ktf_map.o ktf_test.o ktf_debugfs.o ktf_cov.o \ + ktf_override.o ktf_netctx.o + diff --git a/tools/testing/selftests/ktf/kernel/ktf.h b/tools/testing/selftests/ktf/kernel/ktf.h new file mode 100644 index 0000000..ea270e7 --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf.h @@ -0,0 +1,604 @@ +/* + * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. + * Author: Knut Omang knut.omang@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * ktf.h: Defines the KTF user API for kernel clients + */ +#ifndef _KTF_H +#define _KTF_H + +#include <linux/completion.h> +#include <linux/kprobes.h> +#include <linux/kthread.h> +#include <linux/ptrace.h> +#include "ktf_test.h" +#include "ktf_override.h" +#include "ktf_map.h" +#include "ktf_unlproto.h" + +#define KTF_MAX_LOG 2048 + +/* Type for an optional configuration callback for contexts. + * Implementations should copy and store data into their private + * extensions of the context structure. The data pointer is + * only valid inside the callback: + */ +typedef int (*ktf_config_cb)(struct ktf_context *ctx, const void* data, size_t data_sz); +typedef void (*ktf_context_cb)(struct ktf_context *ctx); + +struct ktf_context_type; + +struct ktf_context { + struct ktf_map_elem elem; /* Linkage for ctx_map in handle */ + char name[KTF_MAX_KEY]; /* Context name used in map */ + struct ktf_handle *handle; /* Owner of this context */ + ktf_config_cb config_cb; /* Optional configuration callback */ + ktf_context_cb cleanup; /* Optional callback upon context release */ + int config_errno; /* If config_cb set: state of configuration */ + struct ktf_context_type *type; /* Associated type, must be set */ +}; + +typedef struct ktf_context* (*ktf_context_alloc)(struct ktf_context_type *ct); + +struct ktf_context_type { + struct ktf_map_elem elem; /* Linkage for map in handle */ + char name[KTF_MAX_KEY]; /* Context type name */ + struct ktf_handle *handle; /* Owner of this context type */ + ktf_context_alloc alloc; /* Allocate a new context of this type */ + ktf_config_cb config_cb; /* Configuration callback */ + ktf_context_cb cleanup; /* Optional callback upon context release */ +}; + +#include "ktf_netctx.h" + +/* type for a test function */ +struct ktf_test; + +/* state of running test, used to pass to threads spawned by test. */ +struct ktf_test_state; + +struct ktf_thread { + int (*func)(void *); + const char *name; + struct task_struct *task; + struct ktf_test_state state; + struct completion started; + struct completion completed; +}; + +typedef void (*ktf_test_adder)(void); + +/* Generic setup function for client modules */ +void ktf_add_tests(ktf_test_adder f); +int ktf_context_add(struct ktf_handle *handle, struct ktf_context* ctx, + const char* name, ktf_config_cb cfg_cb, const char *type); +struct ktf_context *ktf_context_add_from(struct ktf_handle *handle, const char *name, + struct ktf_context_type *ct); +const char *ktf_context_name(struct ktf_context *ctx); +struct ktf_context* ktf_find_context(struct ktf_handle *handle, const char* name); +struct ktf_context *ktf_find_first_context(struct ktf_handle *handle); +struct ktf_context *ktf_find_next_context(struct ktf_context* ctx); +void ktf_context_remove(struct ktf_context *ctx); +size_t ktf_has_contexts(struct ktf_handle *handle); +void ktf_context_remove_all(struct ktf_handle *handle); + +/* Called by framework when a configuration is supplied, + * returns the return value of the configuration callback. + */ +int ktf_context_set_config(struct ktf_context *ctx, const void* data, size_t data_sz); + +struct ktf_context *ktf_find_create_context(struct ktf_handle *handle, const char *name, + const char *type_name); +int ktf_handle_add_ctx_type(struct ktf_handle *handle, struct ktf_context_type *ct); +struct ktf_context_type *ktf_handle_get_ctx_type(struct ktf_handle *handle, + const char *type_name); + +/* Declare the implicit __test_handle as extern for .c files that use it + * when adding tests with ADD_TEST but where definition is in another .c file: + */ +extern struct ktf_handle __test_handle; + +/* Add/remove/find a context to/from the default handle */ +#define KTF_CONTEXT_ADD(__context, name) \ + ktf_context_add(&__test_handle, __context, name, NULL, "default") +#define KTF_CONTEXT_ADD_CFG(__context, name, __cb, __type_name) \ + ktf_context_add(&__test_handle, __context, name, __cb, __type_name) +#define KTF_CONTEXT_FIND(name) ktf_find_context(&__test_handle, name) +#define KTF_CONTEXT_GET(name, type) \ + container_of(KTF_CONTEXT_FIND(name), type, k) + +/* Add/remove/find a context to/from a given handle */ +#define KTF_CONTEXT_ADD_TO(__handle, __context, name) \ + ktf_context_add(&__handle, __context, name, NULL, "default") +#define KTF_CONTEXT_ADD_TO_CFG(__handle, __context, name, __cb, __type_name) \ + ktf_context_add(&__handle, __context, name, __cb, __type_name) +#define KTF_CONTEXT_FIND_IN(__handle, name) ktf_find_context(&__handle, name) +#define KTF_CONTEXT_GET_IN(__handle, name, type) \ + container_of(KTF_CONTEXT_FIND_IN(__handle, name), type, k) + +/* check if a context has been configured (if needed) */ +#define KTF_CONTEXT_CFG_OK(__context) \ + (__context->config_cb && !__context->config_errno) +#define KTF_CONTEXT_REMOVE(__context) ktf_context_remove(__context) + +/* Part of KTF support for hybrid tests: Safe get the out-of-band user data + * Silently return (ignoring the test) if no data is available. + * This is to avoid failing if a generic user program without + * specific support for the hybrid test attempts to run the test. + * Fail if an object of an unexpected size is provided. + */ +#define KTF_USERDATA(__kt_ptr, __priv_datatype, __priv_data) \ + struct __priv_datatype *__priv_data = (struct __priv_datatype *)__kt_ptr->data; \ + if (!__priv_data) return; \ + ASSERT_LONG_EQ(__kt_ptr->data_sz, sizeof(struct __priv_datatype)) + +/* KTF support for entry/return probes (via kprobes kretprobes). We use + * kretprobes as they support entry/return and do not induce panics when + * mixed with gkdb usage. + */ + +#if (defined(CONFIG_KPROBES) && defined(CONFIG_KRETPROBES) && \ + (defined(CONFIG_X86_64) || defined(CONFIG_ARM) || \ + defined(CONFIG_ARM64) || defined(CONFIG_SPARC))) +#define KTF_PROBE_SUPPORT +#else +static inline int ktf_no_probe_support(void) +{ + twarn("No support for k[ret]probes, or platform not supported.") + return -ENOTSUPP); +} +#endif + +/* Entry/return probe - type is handler type (entry_handler for entry, + * handler for return), func is function to be probed; probehandler is name + * of probe handling function we will invoke on entry/return. + */ +#define KTF_PROBE(type, func, probehandler) \ + static int probehandler(struct kretprobe_instance *, struct pt_regs *);\ + static struct kretprobe __ktf_##type##_##probehandler = { \ + .type = probehandler, \ + .data_size = 0, \ + .maxactive = 0, \ + .kp = { \ + .symbol_name = #func, \ + }, \ + }; \ + static int probehandler(struct kretprobe_instance *ri, \ + struct pt_regs *regs) + +#ifdef KTF_PROBE_SUPPORT +#define KTF_REGISTER_PROBE(type, func, probehandler) \ + register_kretprobe(&__ktf_##type##_##probehandler) +#else +#define KTF_REGISTER_PROBE(type, func, probehandler) \ + ktf_no_probe_support() +#endif + +/* Note on the complexity below - to re-use a statically-defined kretprobe for + * registration, we need to clean up state in the struct kretprobe. Hence + * we zero out the kretprobe and re-set the symbol name/handler. Not doing + * this means that re-registering fails with -EINVAL. + */ +#define KTF_UNREGISTER_PROBE(type, func, probehandler) \ + do { \ + unregister_kretprobe(&__ktf_##type##_##probehandler); \ + memset(&__ktf_##type##_##probehandler, 0, \ + sizeof(struct kretprobe)); \ + __ktf_##type##_##probehandler.kp.symbol_name = #func; \ + __ktf_##type##_##probehandler.type = probehandler; \ + } while (0) + +#define KTF_ENTRY_PROBE(func, probehandler) \ + KTF_PROBE(entry_handler, func, probehandler) + +#define KTF_REGISTER_ENTRY_PROBE(func, probehandler) \ + KTF_REGISTER_PROBE(entry_handler, func, probehandler) + +/* arch-specific calling conventions for kretprobes entry handlers. Define + * more args/architectures if needed. + */ +#ifdef KTF_PROBE_SUPPORT +#ifdef CONFIG_X86_64 +#define KTF_ENTRY_PROBE_ARG0 (regs->di) +#define KTF_ENTRY_PROBE_ARG1 (regs->si) +#endif /* CONFIG_X86_64 */ +#ifdef CONFIG_ARM +#define KTF_ENTRY_PROBE_ARG0 (regs->regs[0]) +#define KTF_ENTRY_PROBE_ARG1 (regs->regs[1]) +#endif /* CONFIG_ARM */ +#ifdef CONFIG_ARM64 +#define KTF_ENTRY_PROBE_ARG0 (regs->regs[0]) +#define KTF_ENTRY_PROBE_ARG1 (regs->regs[1]) +#endif /* CONFIG_ARM64 */ +#ifdef CONFIG_SPARC +#define KTF_ENTRY_PROBE_ARG0 (regs->u_regs[UREG_I0]) +#define KTF_ENTRY_PROBE_ARG1 (regs->u_regs[UREG_I1]) +#endif /* CONFIG_SPARC */ +#endif /* KTF_PROBE_SUPPORT */ + +/* For unsupported platforms. */ +#ifndef KTF_ENTRY_PROBE_ARG0 +#define KTF_ENTRY_PROBE_ARG0 (0) +#define KTF_ENTRY_PROBE_ARG1 (1) +#endif + +#define KTF_ENTRY_PROBE_RETURN(retval) \ + do { \ + return retval; \ + } while (0) + +#define KTF_UNREGISTER_ENTRY_PROBE(func, probehandler) \ + KTF_UNREGISTER_PROBE(entry_handler, func, probehandler) + +/* KTF support for return probes (via kprobes kretprobes) */ +#define KTF_RETURN_PROBE(func, probehandler) \ + KTF_PROBE(handler, func, probehandler) + +#define KTF_REGISTER_RETURN_PROBE(func, probehandler) \ + KTF_REGISTER_PROBE(handler, func, probehandler) + +/* KTF_*RETURN_VALUE() definitions for use within KTF_RETURN_PROBE() {} only. */ + +#define KTF_RETURN_VALUE() regs_return_value(regs) + +#ifdef KTF_PROBE_SUPPORT +#ifdef CONFIG_X86_64 +#define KTF_SET_RETURN_VALUE(value) regs->ax = (value) +#endif /* CONFIG_X86_64 */ +#if defined(CONFIG_ARM) || defined(CONFIG_ARM64) +#define KTF_SET_RETURN_VALUE(value) regs->regs[0] = (value) +#endif /* CONFIG_ARM[64] */ +#if defined(CONFIG_SPARC) +#define KTF_SET_RETURN_VALUE(value) regs->u_regs[UREG_I0] = (value) +#endif /* CONFIG_SPARC */ +#endif /* KTF_PROBE_SUPPORT */ + +/* For unsupported platforms. */ +#ifndef KTF_PROBE_SUPPORT +#define KTF_SET_RETURN_VALUE(value) do { } while (0) +#endif /* KTF_PROBE_SUPPORT */ + +#define KTF_UNREGISTER_RETURN_PROBE(func, probehandler) \ + KTF_UNREGISTER_PROBE(handler, func, probehandler) + +#define KTF_OVERRIDE(func, probehandler) \ + static int probehandler(struct kprobe *, struct pt_regs *);\ + static struct kprobe __ktf_override_##probehandler = { \ + .symbol_name = #func, \ + .pre_handler = probehandler, \ + .post_handler = ktf_post_handler, \ + .fault_handler = NULL, \ + .flags = 0, \ + }; \ + static int probehandler(struct kprobe *kp, struct pt_regs *regs) + +#ifdef KTF_PROBE_SUPPORT +#define KTF_REGISTER_OVERRIDE(func, probehandler) \ + ktf_register_override(&__ktf_override_##probehandler) +#else +#define KTF_REGISTER_OVERRIDE(func, probehandler) \ + ktf_no_probe_support() +#endif + +#define KTF_UNREGISTER_OVERRIDE(func, probehandler) \ + do { \ + unregister_kprobe(&__ktf_override_##probehandler); \ + memset(&__ktf_override_##probehandler, 0, \ + sizeof(struct kprobe)); \ + __ktf_override_##probehandler.symbol_name = #func; \ + __ktf_override_##probehandler.pre_handler = probehandler; \ + __ktf_override_##probehandler.post_handler = ktf_post_handler; \ + } while (0) + + +#define KTF_OVERRIDE_RETURN \ + do { \ + ktf_override_function_with_return(regs); \ + return 1; \ + } while (0) + +#ifdef KTF_PROBE_SUPPORT +#define KTF_SET_INSTRUCTION_POINTER(regs, value) \ + instruction_pointer_set(regs, (value)) +#else +#define KTF_SET_INSTRUCTION_POINTER(regs, value) do { } while (0) +#endif + +/* Interfaces for creating kthreads in tests. */ +#define KTF_THREAD_INIT(threadname, t) \ + do { \ + (t)->func = threadname; \ + (t)->name = #threadname; \ + (t)->state.self = self; \ + (t)->state.ctx = ctx; \ + (t)->state.iter = _i; \ + (t)->state.value = _value; \ + init_completion(&((t)->started)); \ + init_completion(&((t)->completed)); \ + } while (0) + +#define KTF_THREAD_RUN(t) \ + ((t)->task = kthread_run((t)->func, t, (t)->name)) + +#define KTF_THREAD_STOP(t) \ + do { \ + if ((t)->task) \ + kthread_stop((t)->task); \ + } while (0) + +/* Wraps thread execution to supply same variables as test case - this allows + * us to define assertions etc in thread context. + */ +#define KTF_THREAD(name) \ + static void __##name(struct ktf_thread *thread, struct ktf_test *self, \ + struct ktf_context *ctx, int _i, u32 _value); \ + static int name(void *data) \ + { \ + struct ktf_thread *t = data; \ + complete(&t->started); \ + __##name(t, t->state.self, t->state.ctx, t->state.iter, \ + t->state.value); \ + complete(&t->completed); \ + return 0; \ + } \ + static void __##name(struct ktf_thread *_thread, struct ktf_test *self,\ + struct ktf_context *ctx, int _i, u32 _value) + +#define KTF_THREAD_WAIT_STARTED(t) (wait_for_completion(&((t)->started))) +#define KTF_THREAD_WAIT_COMPLETED(t) (wait_for_completion(&((t)->completed))) + +u32 ktf_get_assertion_count(void); + +/** + * ASSERT_TRUE() - fail and return if @C evaluates to false + * @C: Boolean expression to evaluate + * + */ +#define ASSERT_TRUE(C) do { \ + if (!ktf_assert((C))) return; \ + } while (0) + +/** + * ASSERT_FALSE() - fail and return if @C evaluates to true + * @C: Boolean expression to evaluate + */ +#define ASSERT_FALSE(C) do { \ + if (!ktf_assert(!(C))) return; \ + } while (0) + +/** + * ASSERT_TRUE_GOTO() - fail and jump to @_lbl if @C evaluates to false + * @C: Boolean expression to evaluate + * @_lbl: Label to jump to in case of failure + */ +#define ASSERT_TRUE_GOTO(C,_lbl) { \ + if (!ktf_assert((C))) goto _lbl;\ +} + +/** + * ASSERT_FALSE_GOTO() - fail and jump to @_lbl if @C evaluates to true + * @C: Boolean expression to evaluate + * @_lbl: Label to jump to in case of failure + */ +#define ASSERT_FALSE_GOTO(C,_lbl) { \ + if (!ktf_assert(!(C))) goto _lbl;\ +} + +/** + * ASSERT_TRUE_RETVAL() - fail and return @V if @C evaluates to false + * @C: Boolean expression to evaluate + * @V: Value to return on failure + */ +#define ASSERT_TRUE_RETVAL(C, V) do { \ + if (!ktf_assert((C))) return V; \ +} while (0) + +/** + * ASSERT_FALSE() - fail and return @V if @C evaluates to true + * @C: Boolean expression to evaluate + * @V: Value to return on failure + */ +#define ASSERT_FALSE_RETVAL(C, V) do { \ + if (!ktf_assert(!(C))) return V; \ +} while (0) + +/** + * ASSERT_TRUE_CONT() - fail and continue if @C evaluates to false + * @C: Boolean expression to evaluate + */ +#define ASSERT_TRUE_CONT(C) { \ + if (!ktf_assert((C))) continue; \ +} + +/** + * ASSERT_FALSE_CONT() - fail and continue if @C evaluates to true + * @C: Boolean expression to evaluate + */ +#define ASSERT_FALSE_CONT(C) { \ + if (!ktf_assert(!(C))) continue; \ +} + +/** + * ASSERT_TRUE_BREAK() - fail and break if @C evaluates to false + * @C: Boolean expression to evaluate + */ +#define ASSERT_TRUE_BREAK(C) { \ + if (!ktf_assert((C))) break; \ +} + +/** + * ASSERT_FALSE_BREAK() - fail and break if @C evaluates to true + * @C: Boolean expression to evaluate + */ +#define ASSERT_FALSE_BREAK(C) { \ + if (!ktf_assert(!(C))) break; \ +} + +/** + * ASSERT_LONG_EQ() - compare two longs, fail and return if @X != @Y + * @X: Expected value + * @Y: Actual value + */ +#define ASSERT_LONG_EQ(X, Y) \ + ktf_assert_long_ret(X, ==, Y); + +#define ASSERT_LONG_NE(X, Y) \ + ktf_assert_long_ret(X, !=, Y); + +#define ASSERT_ADDR_EQ(X, Y) \ + ktf_assert_long_ret((u64)(X), ==, (u64)(Y)); + +#define ASSERT_ADDR_NE(X, Y) \ + ktf_assert_long_ret((u64)(X), !=, (u64)(Y)); + +#define ASSERT_INT_EQ(X, Y) \ + ktf_assert_int_ret(X, ==, Y); + +#define ASSERT_INT_GT(X, Y) \ + ktf_assert_int_ret(X, >, Y); + +/** + * ASSERT_LONG_EQ() - compare two longs, jump to @_lbl if @X != @Y + * @X: Expected value + * @Y: Actual value + * @_lbl: Label to jump to in case of failure + */ +#define ASSERT_LONG_EQ_GOTO(X, Y, _lbl) \ + ktf_assert_long_goto(X, ==, Y, _lbl) + +#define ASSERT_LONG_NE_GOTO(X, Y, _lbl) \ + ktf_assert_long_goto(X, !=, Y, _lbl) + +#define ASSERT_ADDR_EQ_GOTO(X, Y, _lbl) \ + ktf_assert_long_goto((u64)(X), ==, (u64)(Y), _lbl) + +#define ASSERT_ADDR_NE_GOTO(X, Y, _lbl) \ + ktf_assert_long_goto((u64)(X), !=, (u64)(Y), _lbl) + +#define ASSERT_INT_EQ_GOTO(X, Y, _lbl) \ + ktf_assert_int_goto(X, ==, Y, _lbl) + +#define ASSERT_INT_GE_GOTO(X, Y, _lbl) \ + ktf_assert_int_goto(X, >=, Y, _lbl) + +#define ASSERT_INT_GT_GOTO(X, Y, _lbl) \ + ktf_assert_int_goto(X, >, Y, _lbl) + +#define ASSERT_INT_LT_GOTO(X, Y, _lbl) \ + ktf_assert_int_goto(X, <, Y, _lbl) + +#define ASSERT_INT_NE(X,Y) \ + ktf_assert_int_ret(X, !=, Y); + +#define ASSERT_INT_NE_GOTO(X,Y,_lbl) \ + ktf_assert_int_goto(X, !=, Y, _lbl); + +/** + * EXPECT_TRUE() - fail if @C evaluates to false but allow test to continue + * @C: Boolean expression to evaluate + * + */ +#define EXPECT_TRUE(C) ktf_assert(C) +#define EXPECT_FALSE(C) ktf_assert(!(C)) + +#define OK_ADDR(X) (X && !IS_ERR(X)) + +/* Valid kernel address check */ +#define EXPECT_OK_ADDR(X) \ + ktf_assert_msg(OK_ADDR(X), "Invalid pointer '"#X"' - was 0x%Lx", (X)) + +#define ASSERT_OK_ADDR(X) do { \ + if (!ktf_assert_msg(OK_ADDR(X), "Invalid pointer '"#X"' - value 0x%Lx", (X))) \ + return; \ + } while (0) +#define ASSERT_OK_ADDR_GOTO(X,_lbl) do { \ + if (!ktf_assert_msg(OK_ADDR(X), "Invalid pointer '"#X"' - was 0x%Lx", (X))) \ + goto _lbl; \ + } while (0) + +#define ASSERT_OK_ADDR_BREAK(X) do { \ + if (!ktf_assert_msg(OK_ADDR(X), "Invalid pointer '"#X"' - was 0x%Lx", (X))) \ + break; \ + } while (0) + +#define EXPECT_INT_EQ(X,Y) ktf_assert_int(X, ==, Y) +#define EXPECT_INT_GT(X,Y) ktf_assert_int(X, >, Y) +#define EXPECT_INT_GE(X,Y) ktf_assert_int(X, >=, Y) +#define EXPECT_INT_LE(X,Y) ktf_assert_int(X, <=, Y) +#define EXPECT_INT_LT(X,Y) ktf_assert_int(X, <, Y) +#define EXPECT_INT_NE(X,Y) ktf_assert_int(X, !=, Y) + +#define EXPECT_LONG_EQ(X, Y) ktf_assert_long(X, ==, Y) +#define EXPECT_LONG_NE(X, Y) ktf_assert_long(X, !=, Y) +#define EXPECT_ADDR_EQ(X, Y) ktf_assert_long((u64)(X), ==, (u64)(Y)) +#define EXPECT_ADDR_NE(X, Y) ktf_assert_long((u64)(X), !=, (u64)(Y)) +#define EXPECT_LONG_GT(X, Y) ktf_assert_long(X, >, Y) +#define EXPECT_LONG_GE(X, Y) ktf_assert_long(X, >=, Y) +#define EXPECT_LONG_LE(X, Y) ktf_assert_long(X, <=, Y) +#define EXPECT_LONG_LT(X, Y) ktf_assert_long(X, <, Y) + +#define EXPECT_STREQ(X, Y) ktf_assert_str_eq(X, Y) +#define EXPECT_STRNE(X, Y) ktf_assert_str_ne(X, Y) + +extern ulong ktf_debug_mask; + +/* Defined debug bits - higher values should represent more + * verbose categories: + */ +#define T_INFO 0x1 +#define T_LIST 0x2 +#define T_INTR 0x200 +#define T_INFO_V 0x800 +#define T_DEBUG 0x1000 +#define T_MCAST 0x2000 +#define T_TRACE 0x100000 +#define T_DEBUG_V 0x200000 + +#define tlog(class, format, arg...) \ + do { \ + if (unlikely((ktf_debug_mask) & (class))) \ + printk(KERN_INFO \ + "ktf pid [%d] " "%s: " format "\n", \ + current->pid, __func__, \ + ## arg); \ + } while (0) +#define twarn(format, arg...) \ + do { \ + printk(KERN_WARNING \ + "ktf pid [%d] " "%s: " format "\n", \ + current->pid, __func__, \ + ## arg); \ + } while (0) +#define terr(format, arg...) \ + do { \ + printk(KERN_ERR \ + "ktf pid [%d] " "%s: " format "\n", \ + current->pid, __func__, \ + ## arg); \ + } while (0) +#define tlogs(class, stmt_list) \ + do { \ + if (unlikely((ktf_debug_mask) & (class))) { \ + stmt_list;\ + } \ + } while (0) + + +/* Look up the current address of a potentially local symbol - to allow testing + * against it. NB! This is a hack for unit testing internal unexposed interfaces and + * violates the module boundaries and has no fw/bw comp gauarantees, but are + * still very useful for detailed unit testing complex logic: + */ +void* ktf_find_symbol(const char *mod, const char *sym); + +unsigned long ktf_symbol_size(unsigned long addr); + +#define ktf_resolve_symbol(mname, sname) \ + do { \ + sname = ktf_find_symbol(#mname, #sname); \ + if (!sname) \ + return -ENOENT; \ + } while (0) +#endif diff --git a/tools/testing/selftests/ktf/kernel/ktf_context.c b/tools/testing/selftests/ktf/kernel/ktf_context.c new file mode 100644 index 0000000..5ff57a9 --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf_context.c @@ -0,0 +1,409 @@ +/* + * Copyright (c) 2009, 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Knut Omang knut.omang@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * kft_context.c: Main part of ktf kernel module that implements a generic + * unit test framework for tests written in kernel code, with support for + * gtest (googletest) user space tools for invocation and reporting. + */ + +#include <linux/module.h> +#include <linux/kallsyms.h> +#include <rdma/ib_verbs.h> +#include "ktf.h" +#include "ktf_test.h" +#include "ktf_debugfs.h" +#include "ktf_nl.h" + +MODULE_LICENSE("GPL"); + +ulong ktf_debug_mask = T_INFO; +EXPORT_SYMBOL(ktf_debug_mask); + +static unsigned int ktf_context_maxid; + +/* The role of context_lock is to synchronize modifications to + * the global list of context handles (handles that have contexts + * associated with them) and the context map. + * The map object has it's own locking, but must be kept in sync + * with changes to the global context list: + */ +static DEFINE_SPINLOCK(context_lock); + +/* global linked list of all ktf_handle objects that have contexts */ +LIST_HEAD(context_handles); + +module_param_named(debug_mask, ktf_debug_mask, ulong, 0644); + +static int __ktf_handle_add_ctx_type(struct ktf_handle *handle, + struct ktf_context_type *ct, + bool generic) +{ + unsigned long flags; + int ret; + + if (generic && !(ct->alloc && ct->config_cb)) { + terr("Mandatory configuration callbacks or values missing!"); + return -EINVAL; + } + + ct->handle = handle; + ktf_map_elem_init(&ct->elem, ct->name); + + spin_lock_irqsave(&context_lock, flags); + ret = ktf_map_insert(&handle->ctx_type_map, &ct->elem); + spin_unlock_irqrestore(&context_lock, flags); + return ret; +} + +static int __ktf_context_add(struct ktf_handle *handle, struct ktf_context *ctx, + const char *name, ktf_config_cb cfg_cb, + struct ktf_context_type *ct) +{ + unsigned long flags; + int ret; + + ktf_map_elem_init(&ctx->elem, name); + strncpy(ctx->name, name, KTF_MAX_NAME); + ctx->config_cb = cfg_cb; + ctx->config_errno = ENOENT; /* 0 here means configuration is ok */ + ctx->type = ct; + ctx->cleanup = ct->cleanup; + + spin_lock_irqsave(&context_lock, flags); + ret = ktf_map_insert(&handle->ctx_map, &ctx->elem); + if (!ret) { + ctx->handle = handle; + if (ktf_map_size(&handle->ctx_map) == 1) { + handle->id = ++ktf_context_maxid; + INIT_LIST_HEAD(&handle->handle_list); + list_add(&handle->handle_list, &context_handles); + } + } + spin_unlock_irqrestore(&context_lock, flags); + if (!ret) + tlog(T_DEBUG, "added %scontext %s with type %s", + (cfg_cb ? "configurable " : ""), name, ct->name); + return ret; +} + +int ktf_context_add(struct ktf_handle *handle, struct ktf_context *ctx, + const char *name, ktf_config_cb cfg_cb, + const char *type_name) +{ + struct ktf_context_type *ct = ktf_handle_get_ctx_type(handle, type_name); + int ret; + + if (!ct) { + ct = kzalloc(sizeof(*ct), GFP_KERNEL); + if (!ct) + return -ENOMEM; + strncpy(ct->name, type_name, KTF_MAX_KEY); + ret = __ktf_handle_add_ctx_type(handle, ct, false); + if (ret) { + kfree(ct); + return ret; + } + } + return __ktf_context_add(handle, ctx, name, cfg_cb, ct); +} +EXPORT_SYMBOL(ktf_context_add); + +struct ktf_context *ktf_context_add_from(struct ktf_handle *handle, const char *name, + struct ktf_context_type *ct) +{ + struct ktf_context *ctx; + int ret; + + if (!ct->alloc) { + terr("No alloc function supplied!"); + return NULL; + } + ctx = ct->alloc(ct); + if (!ctx) + return NULL; + ret = __ktf_context_add(handle, ctx, name, ct->config_cb, ct); + if (ret) + goto fail; + + ctx->cleanup = ct->cleanup; + return ctx; +fail: + kfree(ctx); + return NULL; +} +EXPORT_SYMBOL(ktf_context_add_from); + +int ktf_context_set_config(struct ktf_context *ctx, const void *data, size_t data_sz) +{ + int ret; + + if (ctx->config_cb) { + ret = ctx->config_cb(ctx, data, data_sz); + ctx->config_errno = ret; + } + return ctx->config_errno; +} +EXPORT_SYMBOL(ktf_context_set_config); + +const char *ktf_context_name(struct ktf_context *ctx) +{ + return ctx->elem.key; +} +EXPORT_SYMBOL(ktf_context_name); + +void ktf_context_remove(struct ktf_context *ctx) +{ + struct ktf_handle *handle; + unsigned long flags = 0; + + if (!ctx) { + terr("A test case tried to remove an invalid context!"); + return; + } + handle = ctx->handle; + + spin_lock_irqsave(&context_lock, flags); + ktf_map_remove(&handle->ctx_map, ctx->elem.key); + if (!ktf_has_contexts(handle)) + list_del(&handle->handle_list); + spin_unlock_irqrestore(&context_lock, flags); + + tlog(T_DEBUG, "removed context %s at %p", ctx->elem.key, ctx); + + if (ctx->cleanup) + ctx->cleanup(ctx); + /* Note: ctx may be freed here! */ +} +EXPORT_SYMBOL(ktf_context_remove); + +struct ktf_context *ktf_find_first_context(struct ktf_handle *handle) +{ + struct ktf_map_elem *elem = ktf_map_find_first(&handle->ctx_map); + + if (elem) + return container_of(elem, struct ktf_context, elem); + return NULL; +} + +struct ktf_context *ktf_find_context(struct ktf_handle *handle, const char *name) +{ + struct ktf_map_elem *elem; + + if (!name) + return NULL; + elem = ktf_map_find(&handle->ctx_map, name); + if (!elem) + return NULL; + return container_of(elem, struct ktf_context, elem); +} +EXPORT_SYMBOL(ktf_find_context); + +struct ktf_context *ktf_find_create_context(struct ktf_handle *handle, const char *name, + const char *type_name) +{ + struct ktf_context *ctx = ktf_find_context(handle, name); + + if (!ctx) { + struct ktf_context_type *ct = ktf_handle_get_ctx_type(handle, type_name); + + tlog(T_DEBUG, "type = %s, ct = %p", type_name, ct); + if (ct) + ctx = ktf_context_add_from(handle, name, ct); + } + return ctx; +} + +struct ktf_context *ktf_find_next_context(struct ktf_context *ctx) +{ + struct ktf_map_elem *elem = ktf_map_find_next(&ctx->elem); + + return container_of(elem, struct ktf_context, elem); +} + +size_t ktf_has_contexts(struct ktf_handle *handle) +{ + return ktf_map_size(&handle->ctx_map) > 0; +} +EXPORT_SYMBOL(ktf_has_contexts); + +void ktf_context_remove_all(struct ktf_handle *handle) +{ + struct ktf_context *curr; + + if (!ktf_has_contexts(handle)) + return; + + for (;;) { + curr = ktf_find_first_context(handle); + if (!curr) + break; + ktf_context_remove(curr); + } +} +EXPORT_SYMBOL(ktf_context_remove_all); + +/* Find the handle associated with handle id hid */ +struct ktf_handle *ktf_handle_find(int hid) +{ + struct ktf_handle *handle = NULL; + + list_for_each_entry(handle, &context_handles, handle_list) { + if (handle->id == hid) + break; + } + return handle; +} + +/* Allow user space to create new contexts of certain types + * based on configuration types. This allocates a new, uniquely named + * context type to enable it for user space usage. Caller must allocate and populate + * @ct with appropriate callbacks and value for the context type. + */ + +int ktf_handle_add_ctx_type(struct ktf_handle *handle, + struct ktf_context_type *ct) +{ + return __ktf_handle_add_ctx_type(handle, ct, true); +} +EXPORT_SYMBOL(ktf_handle_add_ctx_type); + +struct ktf_context_type *ktf_handle_get_ctx_type(struct ktf_handle *handle, + const char *type_name) +{ + struct ktf_map_elem *elem = ktf_map_find(&handle->ctx_type_map, type_name); + + tlog(T_DEBUG, "Lookup %s in map size %lu = %p\n", type_name, + ktf_map_size(&handle->ctx_type_map), elem); + if (!elem) + return NULL; + return container_of(elem, struct ktf_context_type, elem); +} + +void ktf_handle_cleanup_check(struct ktf_handle *handle) +{ + struct ktf_context *curr; + unsigned long flags; + + if (!ktf_has_contexts(handle)) + return; + + spin_lock_irqsave(&context_lock, flags); + + for (curr = ktf_find_first_context(handle); + curr; + curr = ktf_find_next_context(curr)) { + twarn("context %s found during handle %p cleanup", curr->elem.key, handle); + } + spin_unlock_irqrestore(&context_lock, flags); +} +EXPORT_SYMBOL(ktf_handle_cleanup_check); + +struct ktf_kernel_internals { + /* From module.h: Look up a module symbol - supports syntax module:name */ + unsigned long (*module_kallsyms_lookup_name)(const char *name); + /* From kallsyms.h: Look up a symbol w/size and offset */ + unsigned long (*kallsyms_lookup_size_offset)(unsigned long addr, + unsigned long *symbolsize, + unsigned long *offset); +}; + +static struct ktf_kernel_internals ki; + +static int __init ktf_init(void) +{ + int ret; + char *ks = "module_kallsyms_lookup_name"; + + /* We rely on being able to resolve this symbol for looking up module + * specific internal symbols (multiple modules may define the same symbol): + */ + ki.module_kallsyms_lookup_name = (void *)kallsyms_lookup_name(ks); + if (!ki.module_kallsyms_lookup_name) { + terr("Unable to look up "%s" in kallsyms - maybe interface has changed?", + ks); + return -EINVAL; + } + ks = "kallsyms_lookup_size_offset"; + ki.kallsyms_lookup_size_offset = (void *)kallsyms_lookup_name(ks); + if (!ki.kallsyms_lookup_size_offset) { + terr("Unable to look up "%s" in kallsyms - maybe interface has changed?", + ks); + return -EINVAL; + } + + ktf_debugfs_init(); + ret = ktf_nl_register(); + if (ret) { + terr("Unable to register protocol with netlink"); + ktf_debugfs_cleanup(); + goto failure; + } + + return 0; +failure: + return ret; +} + +static void __exit ktf_exit(void) +{ + ktf_nl_unregister(); + ktf_cleanup(); +} + +/* Generic setup function for client modules */ +void ktf_add_tests(ktf_test_adder f) +{ + f(); +} +EXPORT_SYMBOL(ktf_add_tests); + +/* Support for looking up kernel/module internal symbols to enable testing. + * A NULL mod means either we want the kernel-internal symbol or don't care + * which module the symbol is in. + */ +void *ktf_find_symbol(const char *mod, const char *sym) +{ + char sm[200]; + const char *symref; + unsigned long addr = 0; + + if (mod) { + sprintf(sm, "%s:%s", mod, sym); + symref = sm; + } else { + /* Try for kernel-internal symbol first; fall back to modules + * if that fails. + */ + symref = sym; + addr = kallsyms_lookup_name(symref); + } + if (!addr) + addr = ki.module_kallsyms_lookup_name(symref); + if (addr) { + tlog(T_DEBUG, "Found %s at %0lx\n", sym, addr); + } else { +#ifndef CONFIG_KALLSYMS_ALL + twarn("CONFIG_KALLSYMS_ALL is not set, so non-exported symbols are not available\n"); +#endif + tlog(T_INFO, "Fatal error: %s not found\n", sym); + return NULL; + } + return (void *)addr; +} +EXPORT_SYMBOL(ktf_find_symbol); + +unsigned long ktf_symbol_size(unsigned long addr) +{ + unsigned long size = 0; + + (void)ki.kallsyms_lookup_size_offset(addr, &size, NULL); + + return size; +} +EXPORT_SYMBOL(ktf_symbol_size); + +module_init(ktf_init); +module_exit(ktf_exit); diff --git a/tools/testing/selftests/ktf/kernel/ktf_test.c b/tools/testing/selftests/ktf/kernel/ktf_test.c new file mode 100644 index 0000000..1e287d0 --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf_test.c @@ -0,0 +1,397 @@ +/* + * Copyright (c) 2009, 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Knut Omang knut.omang@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * ktf_test.c: Kernel side code for tracking and reporting ktf test results + */ +#include <linux/module.h> +#include <linux/time.h> +#include "ktf_test.h" +#include <net/netlink.h> +#include <net/genetlink.h> + +#include "ktf_nl.h" +#include "ktf_unlproto.h" +#include "ktf.h" +#include "ktf_cov.h" +#include "ktf_debugfs.h" + +#define MAX_PRINTF 4096 + +/* Versioning check: + * For MAJOR or MINOR changes, both sides are required to + * have the same version. + * If MICRO has changed, some new functionality may have been added, but the + * old functionality should work as before. + * With only BUILD changes, the two versions are still compatible, + * but one might have bug fixes or minor enhancements. + */ +int ktf_version_check(u64 version) +{ + if (version != KTF_VERSION_LATEST) { + if (KTF_VERSION(MAJOR, version) == KTF_VERSION(MAJOR, KTF_VERSION_LATEST) && + KTF_VERSION(MINOR, version) == KTF_VERSION(MINOR, KTF_VERSION_LATEST)) + return 0; + terr("KTF version mismatch - expected %llu.%llu.%llu.%llu, got %llu.%llu.%llu.%llu", + KTF_VERSION(MAJOR, KTF_VERSION_LATEST), + KTF_VERSION(MINOR, KTF_VERSION_LATEST), + KTF_VERSION(MICRO, KTF_VERSION_LATEST), + KTF_VERSION(BUILD, KTF_VERSION_LATEST), + KTF_VERSION(MAJOR, version), + KTF_VERSION(MINOR, version), + KTF_VERSION(MICRO, version), + KTF_VERSION(BUILD, version)); + return -EINVAL; + } + return 0; +} + +static int ktf_handle_version_check(struct ktf_handle *th) +{ + return ktf_version_check(th->version); +} + +/* Function called when global references to test case reach 0. */ +static void ktf_case_free(struct ktf_map_elem *elem) +{ + struct ktf_case *tc = container_of(elem, struct ktf_case, kmap); + + kfree(tc); +} + +void ktf_case_get(struct ktf_case *tc) +{ + ktf_map_elem_get(&tc->kmap); +} + +void ktf_case_put(struct ktf_case *tc) +{ + ktf_map_elem_put(&tc->kmap); +} + +/* The global map from name to ktf_case */ +DEFINE_KTF_MAP(test_cases, NULL, ktf_case_free); + +/* a lock to protect this datastructure */ +static DEFINE_MUTEX(tc_lock); + +/* Current total number of test cases defined */ +size_t ktf_case_count(void) +{ + return ktf_map_size(&test_cases); +} + +const char *ktf_case_name(struct ktf_case *tc) +{ + return tc->kmap.key; +} + +static size_t ktf_case_test_count(struct ktf_case *tc) +{ + return ktf_map_size(&tc->tests); +} + +/* Called when test refcount reaches 0. */ +static void ktf_test_free(struct ktf_map_elem *elem) +{ + struct ktf_test *t = container_of(elem, struct ktf_test, kmap); + + kfree(t->log); + kfree(t); +} + +void ktf_test_get(struct ktf_test *t) +{ + ktf_map_elem_get(&t->kmap); +} + +void ktf_test_put(struct ktf_test *t) +{ + ktf_map_elem_put(&t->kmap); +} + +static struct ktf_case *ktf_case_create(const char *name) +{ + struct ktf_case *tc = kmalloc(sizeof(*tc), GFP_KERNEL); + int ret; + + if (!tc) + return tc; + + /* Initialize test case map of tests. */ + ktf_map_init(&tc->tests, NULL, ktf_test_free); + ret = ktf_map_elem_init(&tc->kmap, name); + if (ret) { + kfree(tc); + return NULL; + } + ktf_debugfs_create_testset(tc); + tlog(T_DEBUG, "ktf: Added test set %s\n", name); + return tc; +} + +struct ktf_case *ktf_case_find(const char *name) +{ + return ktf_map_find_entry(&test_cases, name, struct ktf_case, kmap); +} + +/* Returns with case refcount increased. Called with tc_lock held. */ +static struct ktf_case *ktf_case_find_create(const char *name) +{ + struct ktf_case *tc; + int ret = 0; + + tc = ktf_case_find(name); + if (!tc) { + tc = ktf_case_create(name); + if (tc) { + ret = ktf_map_insert(&test_cases, &tc->kmap); + if (ret) { + kfree(tc); + tc = NULL; + } + } + } + return tc; +} + +static atomic_t assert_cnt = ATOMIC_INIT(0); + +void flush_assert_cnt(struct ktf_test *self) +{ + if (atomic_read(&assert_cnt)) { + tlog(T_DEBUG, "update: %d asserts", atomic_read(&assert_cnt)); + if (self->skb) + nla_put_u32(self->skb, KTF_A_STAT, atomic_read(&assert_cnt)); + atomic_set(&assert_cnt, 0); + } +} + +u32 ktf_get_assertion_count(void) +{ + return atomic_read(&assert_cnt); +} +EXPORT_SYMBOL(ktf_get_assertion_count); + +static DEFINE_SPINLOCK(assert_lock); + +long _ktf_assert(struct ktf_test *self, int result, const char *file, + int line, const char *fmt, ...) +{ + int len; + va_list ap; + char *buf; + char bufprefix[256]; + unsigned long flags; + + if (result) { + atomic_inc(&assert_cnt); + } else { + flush_assert_cnt(self); + buf = kmalloc(MAX_PRINTF, GFP_KERNEL); + if (!buf) { + terr("file %s line %d: Unable to allocate memory for the error report!", + file, line); + goto out; + } + va_start(ap, fmt); + len = vsnprintf(buf, MAX_PRINTF - 1, fmt, ap); + buf[len] = 0; + va_end(ap); + if (self->skb) { + nla_put_u32(self->skb, KTF_A_STAT, result); + nla_put_string(self->skb, KTF_A_FILE, file); + nla_put_u32(self->skb, KTF_A_NUM, line); + nla_put_string(self->skb, KTF_A_STR, buf); + } + (void)snprintf(bufprefix, sizeof(bufprefix) - 1, + "file %s line %d: result %d: ", file, line, + result); + terr("%s%s", bufprefix, buf); + + /* Multiple threads may try to update log */ + spin_lock_irqsave(&assert_lock, flags); + (void)strncat(self->log, bufprefix, KTF_MAX_LOG); + (void)strncat(self->log, buf, KTF_MAX_LOG); + spin_unlock_irqrestore(&assert_lock, flags); + kfree(buf); + } +out: + return result; +} +EXPORT_SYMBOL(_ktf_assert); + +/* Add a test to a testcase: + * Tests are represented by ktf_test objects that are linked into + * a per-test case map TCase:tests map. + */ +void _ktf_add_test(struct __test_desc td, struct ktf_handle *th, + int _signal, int allowed_exit_value, + int start, int end) +{ + struct ktf_case *tc = NULL; + struct ktf_test *t; + char *log; + + if (ktf_handle_version_check(th)) + return; + + log = kzalloc(KTF_MAX_LOG, GFP_KERNEL); + if (!log) + return; + + t = kzalloc(sizeof(*t), GFP_KERNEL); + if (!t) { + kfree(log); + return; + } + t->tclass = td.tclass; + t->name = td.name; + t->fun = td.fun; + t->start = start; + t->end = end; + t->handle = th; + t->log = log; + + mutex_lock(&tc_lock); + tc = ktf_case_find_create(td.tclass); + if (!tc || ktf_map_elem_init(&t->kmap, td.name) || + ktf_map_insert(&tc->tests, &t->kmap)) { + terr("Failed to add test %s from %s to test case "%s"", + td.name, td.file, td.tclass); + if (tc) + ktf_case_put(tc); + mutex_unlock(&tc_lock); + kfree(log); + kfree(t); + return; + } + + ktf_debugfs_create_test(t); + + tlog(T_LIST, "Added test "%s.%s" start = %d, end = %d\n", + td.tclass, td.name, start, end); + + /* Now since we no longer reference tc/t outside of global map of test + * cases and per-testcase map of tests, drop their refcounts. This + * is safe to do as refcounts are > 0 due to references for map + * storage and debugfs. + */ + ktf_test_put(t); + ktf_case_put(tc); + mutex_unlock(&tc_lock); +} +EXPORT_SYMBOL(_ktf_add_test); + +void ktf_run_hook(struct sk_buff *skb, struct ktf_context *ctx, + struct ktf_test *t, u32 value, + void *oob_data, size_t oob_data_sz) +{ + int i; + + t->log[0] = '\0'; + t->skb = skb; + t->data = oob_data; + t->data_sz = oob_data_sz; + for (i = t->start; i < t->end; i++) { + if (!ctx && t->handle->require_context) { + terr("Test %s.%s requires a context, but none configured!", + t->tclass, t->name); + continue; + } + /* No need to bump refcnt, this is just for debugging. Nothing + * should reference the testcase via the handle's current test + * pointer. + */ + t->handle->current_test = t; + tlogs(T_DEBUG, + printk(KERN_INFO "Running test %s.%s", t->tclass, t->name); + if (ctx) + printk("_%s", ktf_context_name(ctx)); + printk("[%d:%d]\n", t->start, t->end); + ); + getnstimeofday(&t->lastrun); + t->fun(t, ctx, i, value); + flush_assert_cnt(t); + } + t->handle->current_test = NULL; +} + +/* Clean up all tests associated with a ktf_handle */ + +void ktf_test_cleanup(struct ktf_handle *th) +{ + struct ktf_test *t; + struct ktf_case *tc; + + /* Clean up tests which are associated with this handle. + * It's possible multiple modules contribute tests to a test case, + * so we can't just do this on a per-testcase basis. + */ + mutex_lock(&tc_lock); + + tc = ktf_map_first_entry(&test_cases, struct ktf_case, kmap); + while (tc) { + /* FIXME - this is inefficient. */ + t = ktf_map_first_entry(&tc->tests, struct ktf_test, kmap); + while (t) { + if (t->handle == th) { + tlog(T_DEBUG, "ktf: delete test %s.%s", + t->tclass, t->name); + /* removes ref for debugfs */ + ktf_debugfs_destroy_test(t); + /* removes ref for testset map of tests */ + ktf_map_remove_elem(&tc->tests, &t->kmap); + /* now remove our reference which we get + * from ktf_map_[first|next]_entry(). + * This final reference should result in + * the test being freed. + */ + ktf_test_put(t); + /* Need to reset to root */ + t = ktf_map_first_entry(&tc->tests, + struct ktf_test, kmap); + } else { + t = ktf_map_next_entry(t, kmap); + } + } + /* If no modules have tests for this test case, we can + * free resources safely. + */ + if (ktf_case_test_count(tc) == 0) { + ktf_debugfs_destroy_testset(tc); + ktf_map_remove_elem(&test_cases, &tc->kmap); + ktf_case_put(tc); + tc = ktf_map_first_entry(&test_cases, struct ktf_case, + kmap); + } else { + tc = ktf_map_next_entry(tc, kmap); + } + } + mutex_unlock(&tc_lock); +} +EXPORT_SYMBOL(ktf_test_cleanup); + +int ktf_cleanup(void) +{ + struct ktf_test *t; + struct ktf_case *tc; + + ktf_cov_cleanup(); + + /* Unloading of dependencies means we should have no testcases/tests. */ + mutex_lock(&tc_lock); + ktf_for_each_testcase(tc) { + twarn("(memory leak) test set %s still active at unload!", ktf_case_name(tc)); + ktf_testcase_for_each_test(t, tc) { + twarn("(memory leak) test set %s still active with test %s at unload!", + ktf_case_name(tc), t->name); + } + return -EBUSY; + } + ktf_debugfs_cleanup(); + mutex_unlock(&tc_lock); + return 0; +} diff --git a/tools/testing/selftests/ktf/kernel/ktf_test.h b/tools/testing/selftests/ktf/kernel/ktf_test.h new file mode 100644 index 0000000..9769664 --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf_test.h @@ -0,0 +1,381 @@ +/* + * Copyright (C) 2001, 2002, Arien Malec + * Copyright (C) 2011, 2017, Oracle and/or its affiliates. + * + * SPDX-License-Identifier: GPL-2.1 + * + * This file originates from check.h from the Check C unit test + * framework, adapted by Knut Omang to build with the linux kernel. + */ + +#ifndef KTF_TEST_H +#define KTF_TEST_H + +#include <net/netlink.h> +#include <linux/version.h> +#include "ktf_map.h" +#include "ktf_unlproto.h" + +/* A test context is an extendable object that a test client module + * can supply, and that all tests will be invoked with as an implicit + * 'ctx' argument: + */ +struct ktf_context; + +struct ktf_test; + +typedef void (*ktf_test_fun) (struct ktf_test *, struct ktf_context* tdev, int, u32); + +struct ktf_debugfs { + struct dentry *debugfs_results_testset; + struct dentry *debugfs_results_test; + struct dentry *debugfs_run_testset; + struct dentry *debugfs_run_test; +}; + +struct ktf_test { + struct ktf_map_elem kmap; /* linkage for test case list */ + const char* tclass; /* test class name */ + const char* name; /* Name of the test */ + ktf_test_fun fun; + int start; /* Start and end value to argument to fun */ + int end; /* Defines number of iterations */ + struct sk_buff *skb; /* sk_buff for recording assertion results */ + char *log; /* per-test log */ + void *data; /* Test specific out-of-band data */ + size_t data_sz; /* Size of the data element, if set */ + struct timespec lastrun; /* last time test was run */ + struct ktf_debugfs debugfs; /* debugfs info for test */ + struct ktf_handle *handle; /* Handler for owning module */ +}; + +struct ktf_case { + struct ktf_map_elem kmap; /* Linkage for ktf_map */ + struct ktf_map tests; /* List of tests to run */ + struct ktf_debugfs debugfs; /* debugfs handles for testset */ +}; + +/* Used for tests that spawn kthreads to pass state. We should probably + * look at passing data to tests like this to make things more extensible, + * but will defer for now as this would disrupt KTF consumers. + */ +struct ktf_test_state { + struct ktf_test *self; + struct ktf_context *ctx; + int iter; + u32 value; +}; + +extern struct ktf_map test_cases; + +/* Current total number of test cases defined */ +size_t ktf_case_count(void); +const char *ktf_case_name(struct ktf_case *); +/* Manage test case refcount. */ +void ktf_case_get(struct ktf_case *); +void ktf_case_put(struct ktf_case *); + +int ktf_version_check(u64 version); + +void ktf_run_hook(struct sk_buff *skb, struct ktf_context *ctx, + struct ktf_test *t, u32 value, + void *oob_data, size_t oob_data_sz); +void flush_assert_cnt(struct ktf_test *self); + +/* Representation of a test case (a group of tests) */ +struct ktf_case; + +struct ktf_case *ktf_case_find(const char *name); + +/* Each module client of the test framework is required to + * declare at least one ktf_handle via the macro + * DECLARE_KTF_HANDLE (below) + * If the module require extra data of some sorts, that + * can be embedded within the handle + */ +struct ktf_handle; + +/* Find the handle associated with handle id hid */ +struct ktf_handle *ktf_handle_find(int hid); + +/* Called upon ktf unload to clean up test cases */ +int ktf_cleanup(void); + +/* The list of handles that have contexts associated with them */ +extern struct list_head context_handles; + +struct __test_desc +{ + const char* tclass; /* Test class name */ + const char* name; /* Test name */ + const char* file; /* File that implements test */ + ktf_test_fun fun; +}; + +/* Manage refcount for tests. */ +void ktf_test_get(struct ktf_test *t); +void ktf_test_put(struct ktf_test *t); + +/* Add a test function to a test case for a given handle (macro version) */ +#define ktf_add_test_to(td, __test_handle) \ + _ktf_add_test(td##_setup, &__test_handle, 0, 0, 0, 1) + +/* Add a test function to a test case (macro version) */ +#define ktf_add_test(td) \ + _ktf_add_test(td##_setup, &__test_handle, 0, 0, 0, 1) + +/* Add a looping test function to a test case (macro version) + + The test will be called in a for(i = s; i < e; i++) loop with each + iteration being executed in a new context. The loop variable 'i' is + available in the test. + */ +#define ktf_add_loop_test(td,s,e) \ + _ktf_add_test(td##_setup, &__test_handle, 0,0,(s),(e)) + +/* Add a test function to a test case + (function version -- use this when the macro won't work +*/ +void _ktf_add_test(struct __test_desc td, struct ktf_handle *th, + int _signal, int allowed_exit_value, int start, int end); + +/* Internal function to mark the start of a test function */ +void ktf_fn_start (const char *fname, const char *file, int line); + +/* Add a test previously created with TEST() or TEST_F() */ +#define ADD_TEST(__testname)\ + ktf_add_test(__testname) + +#define ADD_TEST_TO(__handle, __testname) \ + ktf_add_test_to(__testname, __handle) + +#define ADD_LOOP_TEST(__testname, from, to) \ + ktf_add_loop_test(__testname, from, to) + +/* Remove a test previously added with ADD_TEST */ +#define DEL_TEST(__testname)\ + ktf_del_test(__testname) + +/* Iterate over all test cases. Implicitly bumps refcount for pos and + * decreases it after we iterate past it. + */ +#define ktf_for_each_testcase(pos) \ + ktf_map_for_each_entry(pos, &test_cases, kmap) + +/* Iterate over all tests for testcases. Implicitly bumps refcount for pos + * and decreases it again after we iterate past it. + */ +#define ktf_testcase_for_each_test(pos, tc) \ + ktf_map_for_each_entry(pos, &tc->tests, kmap) + +#define KTF_GEN_TYPEID_MAX 3 + +/* A test_handle identifies the calling module: + * Declare one in the module global scope using + * KTF_INIT() or KTF_HANDLE_INIT() + * and call KTF_CLEANUP() or KTF_HANDLE_CLEANUP() upon unload + */ + +struct ktf_handle { + struct list_head handle_list; /* Linkage for the global list of all handles with context */ + struct ktf_map ctx_type_map; /* a map from type_id to ktf_context_type (see ktf_context.c) */ + struct ktf_map ctx_map; /* a (possibly empty) map from name to context for this handle */ + unsigned int id; /* A unique nonzero ID for this handle, set iff contexts */ + bool require_context; /* If set, tests are only valid if a context is provided */ + u64 version; /* version assoc. with handle */ + struct ktf_test *current_test;/* Current test running */ +}; + +void ktf_test_cleanup(struct ktf_handle *th); +void ktf_handle_cleanup_check(struct ktf_handle *handle); +void ktf_cleanup_check(void); + +#define KTF_HANDLE_INIT_VERSION(__test_handle, __version, __need_ctx) \ + struct ktf_handle __test_handle = { \ + .handle_list = LIST_HEAD_INIT(__test_handle.handle_list), \ + .ctx_type_map = __KTF_MAP_INITIALIZER(__test_handle, NULL, NULL), \ + .ctx_map = __KTF_MAP_INITIALIZER(__test_handle, NULL, NULL), \ + .id = 0, \ + .require_context = __need_ctx, \ + .version = __version, \ + }; + +#define KTF_HANDLE_INIT(__test_handle) \ + KTF_HANDLE_INIT_VERSION(__test_handle, KTF_VERSION_LATEST, false) + +#define KTF_INIT() KTF_HANDLE_INIT(__test_handle) + +#define KTF_HANDLE_CTX_INIT(__test_handle) \ + KTF_HANDLE_INIT_VERSION(__test_handle, KTF_VERSION_LATEST, true) + +#define KTF_CTX_INIT() KTF_HANDLE_CTX_INIT(__test_handle) + +#define KTF_HANDLE_CLEANUP(__test_handle) \ + do { \ + ktf_context_remove_all(&__test_handle); \ + ktf_test_cleanup(&__test_handle); \ + } while (0) + +#define KTF_CLEANUP() KTF_HANDLE_CLEANUP(__test_handle) + +/* Start a unit test with TEST(suite_name,unit_name) +*/ +#define TEST(__testsuite, __testname)\ + static void __testname(struct ktf_test *self, struct ktf_context *ctx, \ + int _i, u32 _value); \ + struct __test_desc __testname##_setup = \ + { .tclass = "" # __testsuite "", .name = "" # __testname "",\ + .fun = __testname, .file = __FILE__ }; \ + \ + static void __testname(struct ktf_test *self, struct ktf_context* ctx, \ + int _i, u32 _value) + +/* Start a unit test using a fixture + * NB! Note the intentionally missing start parenthesis on DECLARE_F! + * + * Prep: + * DECLARE_F(fixture_name) + * <attributes> + * }; + * INIT_F(fixture_name,setup,teardown); + * + * Usage: + * SETUP_F(fixture_name,setup) + * { + * <setup code, set fixture_name->ok to true to have the test executed> + * } + * TEARDOWN_F(fixture_name,teardown) + * { + * <teardown code> + * } + * TEST_F(fixture_name,suite_name,test_name) + * { + * <test code> + * } + * + * setup must set ctx->ok to true to have the test itself executed + */ +#define DECLARE_F(__fixture) \ + struct __fixture { \ + void (*setup) (struct ktf_test *, struct ktf_context *, struct __fixture *); \ + void (*teardown) (struct ktf_test *, struct __fixture *); \ + bool ok; + +#define INIT_F(__fixture,__setup,__teardown) \ + void __setup(struct ktf_test *, struct ktf_context *, struct __fixture *); \ + void __teardown(struct ktf_test *, struct __fixture *); \ + static struct __fixture __fixture##_template = {\ + .setup = __setup, \ + .teardown = __teardown, \ + .ok = false,\ + } + +#define SETUP_F(__fixture, __setup) \ + void __setup(struct ktf_test *self, struct ktf_context *ctx, \ + struct __fixture *__fixture) + +#define TEARDOWN_F(__fixture, __teardown) \ + void __teardown(struct ktf_test *self, struct __fixture *__fixture) + +#define TEST_F(__fixture, __testsuite, __testname) \ + static void __testname##_body(struct ktf_test *, struct __fixture *, \ + int, u32); \ + static void __testname(struct ktf_test *, struct ktf_context *, int, \ + u32); \ + struct __test_desc __testname##_setup = \ + { .tclass = "" # __testsuite "", .name = "" # __testname "", \ + .fun = __testname }; \ + \ + static void __testname(struct ktf_test *self, struct ktf_context* ctx, \ + int _i, u32 _value) \ + { \ + struct __fixture f_ctx = __fixture##_template; \ + f_ctx.ok = false; \ + f_ctx.setup(self, ctx, &f_ctx); \ + if (!f_ctx.ok) return; \ + __testname##_body(self, &f_ctx, _i, _value); \ + f_ctx.teardown(self,&f_ctx); \ + } \ + static void __testname##_body(struct ktf_test *self, struct __fixture *ctx, \ + int _i, u32 _value) + +/* Fail the test case unless expr is true */ +/* The space before the comma sign before ## is essential to be compatible + with gcc 2.95.3 and earlier. +*/ +#define ktf_assert_msg(expr, format, ...) \ + _ktf_assert(self, expr, __FILE__, __LINE__, \ + format , ## __VA_ARGS__, NULL) + +#define ktf_assert(expr, ...)\ + _ktf_assert(self, expr, __FILE__, __LINE__, \ + "Failure '"#expr"' occurred " , ## __VA_ARGS__, NULL) + +/* Always fail */ +#define ktf_fail(...) _ktf_assert(self, 0, __FILE__, __LINE__, "Failed" , ## __VA_ARGS__, NULL) + +/* Non-macro version of ktf_assert, with more complicated interface + * returns nonzero if ok, 0 otherwise + */ +long _ktf_assert (struct ktf_test *self, int result, const char *file, + int line, const char *expr, ...); + +/* Integer comparsion macros with improved output compared to ktf_assert(). */ +/* O may be any comparion operator. */ +#define ktf_assert_int_goto(X, O, Y, _lbl) \ + do { int x = (X); int y = (Y);\ + if (!ktf_assert_msg(x O y, \ + "Assertion '"#X#O#Y"' failed: "#X"==0x%x, "#Y"==0x%x", x, y)) \ + goto _lbl;\ + } while (0) + +#define ktf_assert_int(X, O, Y) \ + do { int x = (X); int y = (Y);\ + ktf_assert_msg(x O y,\ + "Assertion '"#X#O#Y"' failed: "#X"==0x%x, "#Y"==0x%x", x, y);\ + } while (0) + +#define ktf_assert_int_ret(X, O, Y)\ + do { int x = (X); int y = (Y);\ + if (!ktf_assert_msg(x O y, \ + "Assertion '"#X#O#Y"' failed: "#X"==0x%lx, "#Y"==0x%lx", x, y)) \ + return;\ + } while (0) + +#define ktf_assert_long_goto(X, O, Y, _lbl) \ + do { long x = (X); long y = (Y);\ + if (!ktf_assert_msg(x O y, \ + "Assertion '"#X#O#Y"' failed: "#X"==0x%lx, "#Y"==0x%lx", x, y)) \ + goto _lbl;\ + } while (0) + +#define ktf_assert_long_ret(X, O, Y)\ + do { long x = (X); long y = (Y);\ + if (!ktf_assert_msg(x O y, \ + "Assertion '"#X#O#Y"' failed: "#X"==0x%lx, "#Y"==0x%lx", x, y)) \ + return;\ + } while (0) + +/* O may be any comparion operator. */ +#define ktf_assert_long(X, O, Y) \ + do { long x = (X); long y = (Y);\ + ktf_assert_msg(x O y,\ + "Assertion '"#X#O#Y"' failed: "#X"==0x%lx, "#Y"==0x%lx", x, y);\ + } while (0) + +/* String comparsion macros with improved output compared to ktf_assert() */ +#define ktf_assert_str_eq(X, Y) \ + do { const char* x = (X); const char* y = (Y);\ + ktf_assert_msg(strcmp(x,y) == 0,\ + "Assertion '"#X"=="#Y"' failed: "#X"=="%s", "#Y"=="%s"",\ + x, y);\ + } while (0) + +#define ktf_assert_str_ne(X, Y) \ + do { const char* x = (X); const char* y = (Y);\ + ktf_assert_msg(strcmp(x,y) != 0,\ + "Assertion '"#X"!="#Y"' failed: "#X"=="%s", "#Y"=="%s"",\ + x, y);\ + } while (0) + +#endif /* KTF_TEST_H */

This container is mapping from an index datatype to a "value" datatatype, using rbtree for the implementation. This datatype is used for various purposes by ktf to store and find data related to the actual test cases.

ktf_map.c: Implementation of a kernel version independent std::map like API ktf_map.h: simple objects with key lookup to be inlined into a

Signed-off-by: Knut Omang knut.omang@oracle.com --- tools/testing/selftests/ktf/kernel/ktf_map.c | 261 ++++++++++++++++++++- tools/testing/selftests/ktf/kernel/ktf_map.h | 154 ++++++++++++- 2 files changed, 415 insertions(+) create mode 100644 tools/testing/selftests/ktf/kernel/ktf_map.c create mode 100644 tools/testing/selftests/ktf/kernel/ktf_map.h

diff --git a/tools/testing/selftests/ktf/kernel/ktf_map.c b/tools/testing/selftests/ktf/kernel/ktf_map.c new file mode 100644 index 0000000..78ae5fb --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf_map.c @@ -0,0 +1,261 @@ +/* + * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Knut Omang knut.omang@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * ktf_map.c: Implementation of a kernel version independent std::map like API + * (made abstract to allow impl to change) + */ + +#include "ktf_map.h" +#include "ktf.h" + +void ktf_map_init(struct ktf_map *map, ktf_map_elem_comparefn elem_comparefn, + ktf_map_elem_freefn elem_freefn) +{ + map->root = RB_ROOT; + map->size = 0; + map->elem_comparefn = elem_comparefn; + map->elem_freefn = elem_freefn; + spin_lock_init(&map->lock); +} + +int ktf_map_elem_init(struct ktf_map_elem *elem, const char *key) +{ + memcpy(elem->key, key, KTF_MAX_KEY); + /* For strings that are too long, ensure truncation at + * KTF_MAX_NAME == KTF_MAX_KEY - 1 length: + */ + elem->key[KTF_MAX_NAME] = '\0'; + elem->map = NULL; + kref_init(&elem->refcount); + return 0; +} + +/* A convenience unsigned int compare function as an alternative + * to the string compare: + */ +int ktf_uint_compare(const char *ac, const char *bc) +{ + unsigned int a = *((unsigned int *)ac); + unsigned int b = *((unsigned int *)bc); + + return a > b ? 1 : (a < b ? -1 : 0); +} +EXPORT_SYMBOL(ktf_uint_compare); + +/* Copy "elem"s key representation into "name". For cases where no + * compare function is defined - i.e. string keys - just copy string, + * otherwise name is hexascii of first 8 bytes of key. + */ +char * +ktf_map_elem_name(struct ktf_map_elem *elem, char *name) +{ + if (!name) + return NULL; + + if (!elem || !elem->map) + (void)strlcpy(name, "<none>", KTF_MAX_NAME); + else if (!elem->map->elem_comparefn) + (void)strlcpy(name, elem->key, KTF_MAX_NAME); + else + (void)snprintf(name, KTF_MAX_NAME, "'%*ph'", 8, elem->key); + + return name; +} + +/* Called when refcount of elem is 0. */ +static void ktf_map_elem_release(struct kref *kref) +{ + struct ktf_map_elem *elem = container_of(kref, struct ktf_map_elem, + refcount); + struct ktf_map *map = elem->map; + char name[KTF_MAX_KEY]; + + tlog(T_DEBUG_V, "Releasing %s, %s free function", + ktf_map_elem_name(elem, name), + map && map->elem_freefn ? "calling" : "no"); + if (map && map->elem_freefn) + map->elem_freefn(elem); +} + +void ktf_map_elem_put(struct ktf_map_elem *elem) +{ + char name[KTF_MAX_KEY]; + + tlog(T_DEBUG_V, "Decreasing refcount for %s to %d", + ktf_map_elem_name(elem, name), + refcount_read(&elem->refcount.refcount) - 1); + kref_put(&elem->refcount, ktf_map_elem_release); +} + +void ktf_map_elem_get(struct ktf_map_elem *elem) +{ + char name[KTF_MAX_KEY]; + + tlog(T_DEBUG_V, "Increasing refcount for %s to %d", + ktf_map_elem_name(elem, name), + refcount_read(&elem->refcount.refcount) + 1); + kref_get(&elem->refcount); +} + +struct ktf_map_elem *ktf_map_find(struct ktf_map *map, const char *key) +{ + struct rb_node *node; + unsigned long flags; + + /* may be called in interrupt context */ + spin_lock_irqsave(&map->lock, flags); + node = map->root.rb_node; + + while (node) { + struct ktf_map_elem *elem = container_of(node, struct ktf_map_elem, node); + int result; + + if (map->elem_comparefn) + result = map->elem_comparefn(key, elem->key); + else + result = strncmp(key, elem->key, KTF_MAX_KEY); + + if (result < 0) { + node = node->rb_left; + } else if (result > 0) { + node = node->rb_right; + } else { + ktf_map_elem_get(elem); + spin_unlock_irqrestore(&map->lock, flags); + return elem; + } + } + spin_unlock_irqrestore(&map->lock, flags); + return NULL; +} + +/* Find the first map elem in 'map' */ +struct ktf_map_elem *ktf_map_find_first(struct ktf_map *map) +{ + struct ktf_map_elem *elem = NULL; + struct rb_node *node; + unsigned long flags; + + spin_lock_irqsave(&map->lock, flags); + node = rb_first(&map->root); + if (node) { + elem = container_of(node, struct ktf_map_elem, node); + ktf_map_elem_get(elem); + } + spin_unlock_irqrestore(&map->lock, flags); + return elem; +} + +/* Find the next element in the map after 'elem' if any */ +struct ktf_map_elem *ktf_map_find_next(struct ktf_map_elem *elem) +{ + struct ktf_map_elem *next = NULL; + struct ktf_map *map = elem->map; + struct rb_node *node; + unsigned long flags; + + if (!elem->map) + return NULL; + spin_lock_irqsave(&map->lock, flags); + node = rb_next(&elem->node); + + /* Assumption here - we don't need ref to elem any more. + * Common usage pattern is + * + * for (elem = ktf_map_elem_first(map); elem != NULL; + * elem = ktf_map_find_next(elem)) + * + * but if other use cases occur we may need to revisit. + * This assumption allows us to define our _for_each macros + * and still manage refcounts. + */ + ktf_map_elem_put(elem); + + if (node) { + next = container_of(node, struct ktf_map_elem, node); + ktf_map_elem_get(next); + } + spin_unlock_irqrestore(&map->lock, flags); + return next; +} + +int ktf_map_insert(struct ktf_map *map, struct ktf_map_elem *elem) +{ + struct rb_node **newobj, *parent = NULL; + unsigned long flags; + + spin_lock_irqsave(&map->lock, flags); + newobj = &map->root.rb_node; + while (*newobj) { + struct ktf_map_elem *this = container_of(*newobj, struct ktf_map_elem, node); + int result; + + if (map->elem_comparefn) + result = map->elem_comparefn(elem->key, this->key); + else + result = strncmp(elem->key, this->key, KTF_MAX_KEY); + + parent = *newobj; + if (result < 0) { + newobj = &((*newobj)->rb_left); + } else if (result > 0) { + newobj = &((*newobj)->rb_right); + } else { + spin_unlock_irqrestore(&map->lock, flags); + return -EEXIST; + } + } + + /* Add newobj node and rebalance tree. */ + rb_link_node(&elem->node, parent, newobj); + rb_insert_color(&elem->node, &map->root); + elem->map = map; + map->size++; + /* Bump reference count for map reference */ + ktf_map_elem_get(elem); + spin_unlock_irqrestore(&map->lock, flags); + return 0; +} + +void ktf_map_remove_elem(struct ktf_map *map, struct ktf_map_elem *elem) +{ + if (elem) { + rb_erase(&elem->node, &map->root); + map->size--; + ktf_map_elem_put(elem); + } +} + +struct ktf_map_elem *ktf_map_remove(struct ktf_map *map, const char *key) +{ + struct ktf_map_elem *elem; + unsigned long flags; + + elem = ktf_map_find(map, key); + spin_lock_irqsave(&map->lock, flags); + ktf_map_remove_elem(map, elem); + spin_unlock_irqrestore(&map->lock, flags); + return elem; +} + +void ktf_map_delete_all(struct ktf_map *map) +{ + struct ktf_map_elem *elem; + struct rb_node *node; + unsigned long flags; + + spin_lock_irqsave(&map->lock, flags); + do { + node = rb_first(&(map)->root); + if (node) { + rb_erase(node, &(map)->root); + map->size--; + elem = container_of(node, struct ktf_map_elem, node); + ktf_map_elem_put(elem); + } + } while (node); + spin_unlock_irqrestore(&map->lock, flags); +} diff --git a/tools/testing/selftests/ktf/kernel/ktf_map.h b/tools/testing/selftests/ktf/kernel/ktf_map.h new file mode 100644 index 0000000..1c8ae9b --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf_map.h @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Knut Omang knut.omang@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * ktf_map.h: simple objects with key lookup to be inlined into a + * larger object + */ + +#ifndef _KTF_MAP_H +#define _KTF_MAP_H +#include <linux/kref.h> +#include <linux/version.h> +#include <linux/rbtree.h> + +#define KTF_MAX_KEY 64 +#define KTF_MAX_NAME (KTF_MAX_KEY - 1) + +struct ktf_map_elem; + +/* Compare function called to compare element keys - optional and if + * not specified we revert to string comparison. Should return < 0 + * if first key < second, > 0 if first key > second, and 0 if they are + * identical. + */ +typedef int (*ktf_map_elem_comparefn)(const char *, const char *); + +/* A convenience unsigned int compare function as an alternative + * to the string compare: + */ +int ktf_uint_compare(const char *a, const char *b); + +/* Free function called when elem refcnt is 0 - optional and of course for + * dynamically-allocated elems only. + */ +typedef void (*ktf_map_elem_freefn)(struct ktf_map_elem *); + +struct ktf_map { + struct rb_root root; /* The rb tree holding the map */ + size_t size; /* Current size (number of elements) of the map */ + spinlock_t lock; /* held for map lookup etc */ + ktf_map_elem_comparefn elem_comparefn; /* Key comparison function */ + ktf_map_elem_freefn elem_freefn; /* Free function */ +}; + +struct ktf_map_elem { + struct rb_node node; /* Linkage for the map */ + char key[KTF_MAX_KEY+1] __aligned(8); + /* Key of the element - must be unique within the same map */ + struct ktf_map *map; /* owning map */ + struct kref refcount; /* reference count for element */ +}; + +#define __KTF_MAP_INITIALIZER(_mapname, _elem_comparefn, _elem_freefn) \ + { \ + .root = RB_ROOT, \ + .size = 0, \ + .lock = __SPIN_LOCK_UNLOCKED(_mapname), \ + .elem_comparefn = _elem_comparefn, \ + .elem_freefn = _elem_freefn, \ + } + +#define DEFINE_KTF_MAP(_mapname, _elem_comparefn, _elem_freefn) \ + struct ktf_map _mapname = __KTF_MAP_INITIALIZER(_mapname, _elem_comparefn, _elem_freefn) + +void ktf_map_init(struct ktf_map *map, ktf_map_elem_comparefn elem_comparefn, + ktf_map_elem_freefn elem_freefn); + +/* returns 0 upon success or -errno upon error */ +int ktf_map_elem_init(struct ktf_map_elem *elem, const char *key); + +/* increase/reduce reference count to element. If count reaches 0, the + * free function associated with map (if any) is called. + */ +void ktf_map_elem_get(struct ktf_map_elem *elem); +void ktf_map_elem_put(struct ktf_map_elem *elem); + +char *ktf_map_elem_name(struct ktf_map_elem *elem, char *name); + +/* Insert a new element in map - return 0 iff 'elem' was inserted or -1 if + * the key already existed - duplicates are not insterted. + */ +int ktf_map_insert(struct ktf_map *map, struct ktf_map_elem *elem); + +/* Find and return the element with 'key' */ +struct ktf_map_elem *ktf_map_find(struct ktf_map *map, const char *key); + +/* Find the first map elem in 'map' with reference count increased. */ +struct ktf_map_elem *ktf_map_find_first(struct ktf_map *map); + +/* Find the next element in the map after 'elem' if any. Decreases refcount + * for "elem" and increases it for returned map element - this helps manage + * reference counts when iterating over map elements. + */ +struct ktf_map_elem *ktf_map_find_next(struct ktf_map_elem *elem); + +/* Remove the element 'key' from the map and return a pointer to it with + * refcount increased. + */ +struct ktf_map_elem *ktf_map_remove(struct ktf_map *map, const char *key); + +/* Remove specific element elem from the map. Refcount is not increased + * as caller must already have had a reference. + */ +void ktf_map_remove_elem(struct ktf_map *map, struct ktf_map_elem *elem); + +void ktf_map_delete_all(struct ktf_map *map); + +static inline size_t ktf_map_size(struct ktf_map *map) { + return map->size; +} + +static inline bool ktf_map_empty(struct ktf_map *map) { + return map->size == 0; +} + +/* Gets first entry with refcount of entry increased for caller. */ +#define ktf_map_first_entry(_map, _type, _member) \ + ktf_map_empty(_map) ? NULL : \ + container_of(ktf_map_find_first(_map), _type, _member) + +/* Gets next elem after "pos", decreasing refcount for pos and increasing + * it for returned entry. + */ +#define ktf_map_next_entry(_pos, _member) ({ \ + struct ktf_map_elem *_e = ktf_map_find_next(&(_pos)->_member); \ + _e ? container_of(_e, typeof(*_pos), _member) : NULL; \ +}) + +/* Iterates over map elements, incrementing refcount for current element and + * decreasing it when we iterate to the next element. Important - if you + * break out of the loop via break/return, ensure ktf_map_elem_put(pos) + * is called for current element since we have a reference to it for the + * current loop body iteration. + */ +#define ktf_map_for_each(pos, map) \ + for (pos = ktf_map_find_first(map); pos != NULL; pos = ktf_map_find_next(pos)) + +/* Iterate over map elements in similar manner as above but using + * container_of() wrappers to work with the type embedding a + * "struct ktf_map_elem". + */ +#define ktf_map_for_each_entry(_pos, _map, _member) \ + for (_pos = ktf_map_first_entry(_map, typeof(*_pos), _member); \ + _pos != NULL; \ + _pos = ktf_map_next_entry(_pos, _member)) + +#define ktf_map_find_entry(_map, _key, _type, _member) ({ \ + struct ktf_map_elem *_entry = ktf_map_find(_map, _key); \ + _entry ? container_of(_entry, _type, _member) : NULL; \ +}) + +#endif

From: Alan Maguire alan.maguire@oracle.com

While test results is available via netlink from user space, sometimes it may be useful to be able to access the results from the kernel as well, for instance due to a crash. Make that possible via debugfs.

ktf_debugfs.h: Support for creating a debugfs representation of test

Signed-off-by: Alan Maguire alan.maguire@oracle.com Signed-off-by: Knut Omang knut.omang@oracle.com --- tools/testing/selftests/ktf/kernel/ktf_debugfs.c | 356 ++++++++++++++++- tools/testing/selftests/ktf/kernel/ktf_debugfs.h | 34 ++- 2 files changed, 390 insertions(+) create mode 100644 tools/testing/selftests/ktf/kernel/ktf_debugfs.c create mode 100644 tools/testing/selftests/ktf/kernel/ktf_debugfs.h

diff --git a/tools/testing/selftests/ktf/kernel/ktf_debugfs.c b/tools/testing/selftests/ktf/kernel/ktf_debugfs.c new file mode 100644 index 0000000..a20fbd2 --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf_debugfs.c @@ -0,0 +1,356 @@ +/* + * Copyright (c) 2009, 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Alan Maguire alan.maguire@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + */ +#include <asm/unistd.h> +#include <linux/module.h> +#include <linux/time.h> +#include "ktf_debugfs.h" +#include "ktf.h" +#include "ktf_test.h" +#include "ktf_cov.h" + +/* Create a debugfs representation of test sets/tests. Hierarchy looks like + * this: + * + * Path Semantics + * /sys/kernel/debug/ktf/run/<testset> Run all tests in testset + * /sys/kernel/debug/ktf/run/<testset>/<test> Run specific test in testset + * /sys/kernel/debug/ktf/results/<testset> Show results of last run for + * testset + * + * /sys/kernel/debug/ktf/results/<testset>/<test> + * Show results of last run for + * test + * + */ + +static struct dentry *ktf_debugfs_rootdir; +static struct dentry *ktf_debugfs_rundir; +static struct dentry *ktf_debugfs_resultsdir; +static struct dentry *ktf_debugfs_cov_file; + +static void ktf_debugfs_print_result(struct seq_file *seq, struct ktf_test *t) +{ + struct timespec now; + + if (t && strlen(t->log) > 0) { + getnstimeofday(&now); + seq_printf(seq, "[%s/%s, %ld seconds ago] %s\n", + t->tclass, t->name, + now.tv_sec - t->lastrun.tv_sec, t->log); + } +} + +/* /sys/kernel/debug/ktf/results/<testset>-tests/<test> shows specific result */ +static int ktf_debugfs_result(struct seq_file *seq, void *v) +{ + struct ktf_test *t = (struct ktf_test *)seq->private; + + ktf_debugfs_print_result(seq, t); + + return 0; +} + +/* /sys/kernel/debug/ktf/results/<testset> shows all results for testset. */ +static int ktf_debugfs_results_all(struct seq_file *seq, void *v) +{ + struct ktf_case *testset = (struct ktf_case *)seq->private; + struct ktf_test *t; + + if (!testset) + return 0; + + seq_printf(seq, "%s results:\n", ktf_case_name(testset)); + ktf_testcase_for_each_test(t, testset) + ktf_debugfs_print_result(seq, t); + + return 0; +} + +/* /sys/kernel/debug/ktf/run/<testset>-tests/<test> runs specific test. */ +static int ktf_debugfs_run(struct seq_file *seq, void *v) +{ + struct ktf_test *t = (struct ktf_test *)seq->private; + + if (!t) + return 0; + + ktf_run_hook(NULL, NULL, t, 0, NULL, 0); + ktf_debugfs_print_result(seq, t); + + return 0; +} + +/* /sys/kernel/debug/ktf/run/<testset> runs all tests in testset. */ +static int ktf_debugfs_run_all(struct seq_file *seq, void *v) +{ + struct ktf_case *testset = (struct ktf_case *)seq->private; + struct ktf_test *t; + + if (!testset) + return 0; + + seq_printf(seq, "Running %s\n", ktf_case_name(testset)); + ktf_testcase_for_each_test(t, testset) { + ktf_run_hook(NULL, NULL, t, 0, NULL, 0); + ktf_debugfs_print_result(seq, t); + } + + return 0; +} + +static int ktf_run_test_open(struct inode *inode, struct file *file) +{ + struct ktf_test *t; + + if (!try_module_get(THIS_MODULE)) + return -EIO; + + t = (struct ktf_test *)inode->i_private; + + return single_open(file, ktf_debugfs_run, t); +} + +static int ktf_debugfs_release(struct inode *inode, struct file *file) +{ + module_put(THIS_MODULE); + return single_release(inode, file); +} + +static const struct file_operations ktf_run_test_fops = { + .open = ktf_run_test_open, + .read = seq_read, + .llseek = seq_lseek, + .release = ktf_debugfs_release, +}; + +static int ktf_results_test_open(struct inode *inode, struct file *file) +{ + struct ktf_test *t; + + if (!try_module_get(THIS_MODULE)) + return -EIO; + + t = (struct ktf_test *)inode->i_private; + + return single_open(file, ktf_debugfs_result, t); +} + +static const struct file_operations ktf_results_test_fops = { + .open = ktf_results_test_open, + .read = seq_read, + .llseek = seq_lseek, + .release = ktf_debugfs_release, +}; + +static void _ktf_debugfs_destroy_test(struct ktf_test *t) +{ + if (!t) + return; + + tlog(T_DEBUG, "Destroying debugfs test %s", t->name); + debugfs_remove(t->debugfs.debugfs_results_test); + debugfs_remove(t->debugfs.debugfs_run_test); + memset(&t->debugfs, 0, sizeof(t->debugfs)); +} + +void ktf_debugfs_create_test(struct ktf_test *t) +{ + struct ktf_case *testset = ktf_case_find(t->tclass); + + if (!testset) + return; + + memset(&t->debugfs, 0, sizeof(t->debugfs)); + + t->debugfs.debugfs_results_test = + debugfs_create_file(t->name, S_IFREG | 0444, + testset->debugfs.debugfs_results_test, + t, &ktf_results_test_fops); + + if (t->debugfs.debugfs_results_test) { + t->debugfs.debugfs_run_test = + debugfs_create_file(t->name, S_IFREG | 0444, + testset->debugfs.debugfs_run_test, + t, &ktf_run_test_fops); + if (!t->debugfs.debugfs_run_test) { + _ktf_debugfs_destroy_test(t); + } else { + /* Take reference for test for debugfs */ + ktf_test_get(t); + } + } + /* Drop reference to testset from ktf_case_find(). */ + ktf_case_put(testset); +} + +void ktf_debugfs_destroy_test(struct ktf_test *t) +{ + _ktf_debugfs_destroy_test(t); + /* Release reference now debugfs files are gone. */ + ktf_test_put(t); +} + +static int ktf_results_testset_open(struct inode *inode, struct file *file) +{ + struct ktf_case *testset; + + if (!try_module_get(THIS_MODULE)) + return -EIO; + + testset = (struct ktf_case *)inode->i_private; + + return single_open(file, ktf_debugfs_results_all, testset); +} + +static const struct file_operations ktf_results_testset_fops = { + .open = ktf_results_testset_open, + .read = seq_read, + .llseek = seq_lseek, + .release = ktf_debugfs_release, +}; + +static int ktf_run_testset_open(struct inode *inode, struct file *file) +{ + struct ktf_case *testset; + + if (!try_module_get(THIS_MODULE)) + return -EIO; + + testset = (struct ktf_case *)inode->i_private; + + return single_open(file, ktf_debugfs_run_all, testset); +} + +static const struct file_operations ktf_run_testset_fops = { + .open = ktf_run_testset_open, + .read = seq_read, + .llseek = seq_lseek, + .release = ktf_debugfs_release, +}; + +static void _ktf_debugfs_destroy_testset(struct ktf_case *testset) +{ + debugfs_remove(testset->debugfs.debugfs_run_testset); + debugfs_remove(testset->debugfs.debugfs_run_test); + debugfs_remove(testset->debugfs.debugfs_results_testset); + debugfs_remove(testset->debugfs.debugfs_results_test); +} + +void ktf_debugfs_create_testset(struct ktf_case *testset) +{ + char tests_subdir[KTF_DEBUGFS_NAMESZ]; + const char *name = ktf_case_name(testset); + + memset(&testset->debugfs, 0, sizeof(testset->debugfs)); + + /* First add /sys/kernel/debug/ktf/[results|run]/<testset> */ + testset->debugfs.debugfs_results_testset = + debugfs_create_file(name, S_IFREG | 0444, + ktf_debugfs_resultsdir, + testset, &ktf_results_testset_fops); + if (!testset->debugfs.debugfs_results_testset) + goto err; + + testset->debugfs.debugfs_run_testset = + debugfs_create_file(name, S_IFREG | 0444, + ktf_debugfs_rundir, + testset, &ktf_run_testset_fops); + if (!testset->debugfs.debugfs_run_testset) + goto err; + + /* Now add parent directories for individual test result/run tests + * which live in + * /sys/kernel/debug/ktf/[results|run]/<testset>-tests/<testname> + */ + (void)snprintf(tests_subdir, sizeof(tests_subdir), "%s%s", + name, KTF_DEBUGFS_TESTS_SUFFIX); + + testset->debugfs.debugfs_results_test = + debugfs_create_dir(tests_subdir, ktf_debugfs_resultsdir); + if (!testset->debugfs.debugfs_results_test) + goto err; + + testset->debugfs.debugfs_run_test = + debugfs_create_dir(tests_subdir, ktf_debugfs_rundir); + if (!testset->debugfs.debugfs_run_test) + goto err; + + /* Take reference count for testset. One will do as we will always + * free testset debugfs resources together. + */ + ktf_case_get(testset); + return; +err: + _ktf_debugfs_destroy_testset(testset); +} + +void ktf_debugfs_destroy_testset(struct ktf_case *testset) +{ + tlog(T_DEBUG, "Destroying debugfs testset %s", ktf_case_name(testset)); + _ktf_debugfs_destroy_testset(testset); + /* Remove our debugfs reference cout to testset */ + ktf_case_put(testset); +} + +/* /sys/kernel/debug/ktf/coverage shows coverage statistics. */ +static int ktf_debugfs_cov(struct seq_file *seq, void *v) +{ + ktf_cov_seq_print(seq); + + return 0; +} + +static int ktf_cov_open(struct inode *inode, struct file *file) +{ + if (!try_module_get(THIS_MODULE)) + return -EIO; + + return single_open(file, ktf_debugfs_cov, NULL); +} + +static const struct file_operations ktf_cov_fops = { + .open = ktf_cov_open, + .read = seq_read, + .llseek = seq_lseek, + .release = ktf_debugfs_release, +}; + +void ktf_debugfs_cleanup(void) +{ + tlog(T_DEBUG, "Removing ktf debugfs dirs..."); + debugfs_remove(ktf_debugfs_cov_file); + debugfs_remove(ktf_debugfs_rundir); + debugfs_remove(ktf_debugfs_resultsdir); + debugfs_remove(ktf_debugfs_rootdir); +} + +void ktf_debugfs_init(void) +{ + ktf_debugfs_rootdir = debugfs_create_dir(KTF_DEBUGFS_ROOT, NULL); + if (!ktf_debugfs_rootdir) + goto err; + ktf_debugfs_rundir = debugfs_create_dir(KTF_DEBUGFS_RUN, + ktf_debugfs_rootdir); + if (!ktf_debugfs_rundir) + goto err; + ktf_debugfs_resultsdir = debugfs_create_dir(KTF_DEBUGFS_RESULTS, + ktf_debugfs_rootdir); + if (!ktf_debugfs_resultsdir) + goto err; + + ktf_debugfs_cov_file = debugfs_create_file(KTF_DEBUGFS_COV, + S_IFREG | 0444, + ktf_debugfs_rootdir, + NULL, + &ktf_cov_fops); + if (ktf_debugfs_cov_file) + return; +err: + terr("Could not init %s\n", KTF_DEBUGFS_ROOT); + ktf_debugfs_cleanup(); +} diff --git a/tools/testing/selftests/ktf/kernel/ktf_debugfs.h b/tools/testing/selftests/ktf/kernel/ktf_debugfs.h new file mode 100644 index 0000000..4dab1ea --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf_debugfs.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2009, 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Alan Maguire alan.maguire@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * ktf_debugfs.h: Support for creating a debugfs representation of test + * sets/tests. + */ + +#ifndef KTF_DEBUGFS_H +#define KTF_DEBUGFS_H +#include <linux/debugfs.h> + +#define KTF_DEBUGFS_ROOT "ktf" +#define KTF_DEBUGFS_RUN "run" +#define KTF_DEBUGFS_RESULTS "results" +#define KTF_DEBUGFS_COV "coverage" +#define KTF_DEBUGFS_TESTS_SUFFIX "-tests" + +#define KTF_DEBUGFS_NAMESZ 256 + +struct ktf_test; +struct ktf_case; + +void ktf_debugfs_create_test(struct ktf_test *); +void ktf_debugfs_destroy_test(struct ktf_test *); +void ktf_debugfs_create_testset(struct ktf_case *); +void ktf_debugfs_destroy_testset(struct ktf_case *); +void ktf_debugfs_init(void); +void ktf_debugfs_cleanup(void); + + +#endif

From: Alan Maguire alan.maguire@oracle.com

Allows reports of code coverage and memory allocation.

ktf_cov.c: Code coverage support implementation for KTF. ktf_cov.h: Code coverage support interface for KTF.

Signed-off-by: Alan Maguire alan.maguire@oracle.com Signed-off-by: Knut Omang knut.omang@oracle.com --- tools/testing/selftests/ktf/kernel/ktf_cov.c | 690 ++++++++++++++++++++- tools/testing/selftests/ktf/kernel/ktf_cov.h | 94 +++- 2 files changed, 784 insertions(+) create mode 100644 tools/testing/selftests/ktf/kernel/ktf_cov.c create mode 100644 tools/testing/selftests/ktf/kernel/ktf_cov.h

diff --git a/tools/testing/selftests/ktf/kernel/ktf_cov.c b/tools/testing/selftests/ktf/kernel/ktf_cov.c new file mode 100644 index 0000000..f917994 --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf_cov.c @@ -0,0 +1,690 @@ +/* + * Copyright (c) 2009, 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Alan Maguire alan.maguire@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * ktf_cov.c: Code coverage support implementation for KTF. + */ +#include <linux/kallsyms.h> +#include <linux/debugfs.h> +#include <linux/mm.h> +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/stacktrace.h> +#ifdef CONFIG_SLUB +#include <linux/slub_def.h> +#endif /* CONFIG_SLUB */ +#ifdef CONFIG_SLAB +#include <linux/slab_def.h> +#endif +#include <linux/string.h> +#include <linux/kprobes.h> +#include <linux/ptrace.h> +#include "ktf.h" +#include "ktf_map.h" +#include "ktf_cov.h" + +/* It may seem odd that we use a refcnt field in ktf_cov_entry structures + * in addition to using krefcount management via the ktf_map. The reasoning + * here is that if we enable and then disable coverage, we do not want to + * purge the entry data as we likely want to examine counts after disabling + * coverage. So the first enable will add entries to the cov_entry map and + * subsequent disable/enables will simply update the entry's refcnt. The + * free function below should only be called therefore from cleanup context + * when the cov entries are finally removed from the cov_entry map. + */ +static void ktf_cov_entry_free(struct ktf_map_elem *elem) +{ + struct ktf_cov_entry *entry = container_of(elem, struct ktf_cov_entry, + kmap); + if (entry->refcnt > 0) + unregister_kprobe(&entry->kprobe); + kfree(entry); +} + +/* Comparison function is subtle. We want to be able to compare key1 + * and key2 here, where key1 may either be an existing object, in which + * case it has an address and size; or it may be an object offset, in which + * case k1's address will be the address with offset of size 0. In both + * cases for the -1 case we can simply check if k1's address is less than + * k2's. For the 1 case, we need to ensure that the address is >= + * k2's address and it's size, since this ensures the address does not + * fall within the object bounds. Finally we are left with the case + * that k1.address >= k2.address _and_ it falls within the bounds of k2, + * which we consider a match. For a concrete example of how this matching + * is used, see how we walk the stack of functions within the kmalloc + * kretprobe below: we will have a function + offset on the stack, and we + * want to see if this offset falls within a function in our coverage entry + * map. If it does, we track the allocation. The implicit assumption is + * no overlap between different objects. + */ +static int ktf_cov_obj_compare(const char *key1, const char *key2) +{ + struct ktf_cov_obj_key *k1 = (struct ktf_cov_obj_key *)key1; + struct ktf_cov_obj_key *k2 = (struct ktf_cov_obj_key *)key2; + + if (k1->address < k2->address) + return -1; + if (k1->address >= (k2->address + k2->size)) + return 1; + return 0; +} + +void ktf_cov_entry_get(struct ktf_cov_entry *entry) +{ + ktf_map_elem_get(&entry->kmap); +} + +void ktf_cov_entry_put(struct ktf_cov_entry *entry) +{ + ktf_map_elem_put(&entry->kmap); +} + +/* Global map for address-> symbol/module mapping. Sort via symbol address + * and size combination, see ktf_cov_obj_compare() above for comparison + * logic. + */ +static DEFINE_KTF_MAP(cov_entry_map, ktf_cov_obj_compare, ktf_cov_entry_free); + +struct ktf_cov_entry *ktf_cov_entry_find(unsigned long addr, unsigned long size) +{ + struct ktf_cov_obj_key k; + + k.address = addr; + k.size = size; + + return ktf_map_find_entry(&cov_entry_map, (char *)&k, + struct ktf_cov_entry, kmap); +} + +static void ktf_cov_free(struct ktf_map_elem *elem) +{ + struct ktf_cov *cov = container_of(elem, struct ktf_cov, kmap); + + kfree(cov); +} + +void ktf_cov_put(struct ktf_cov *cov) +{ + ktf_map_elem_put(&cov->kmap); +} + +/* Coverage object map. Just modules supported for now, sort by name. */ +static DEFINE_KTF_MAP(cov_map, NULL, ktf_cov_free); + +struct ktf_cov *ktf_cov_find(const char *module) +{ + return ktf_map_find_entry(&cov_map, module, struct ktf_cov, kmap); +} + +/* cache for memory objects used to track allocations */ +static struct kmem_cache *cov_mem_cache; + +static void ktf_cov_mem_free(struct ktf_map_elem *elem) +{ + struct ktf_cov_mem *m = container_of(elem, struct ktf_cov_mem, + kmap); + + kmem_cache_free(cov_mem_cache, m); +} + +/* Global map for tracking memory allocations */ +DEFINE_KTF_MAP(cov_mem_map, ktf_cov_obj_compare, ktf_cov_mem_free); +EXPORT_SYMBOL(cov_mem_map); + +struct ktf_cov_mem *ktf_cov_mem_find(unsigned long addr, unsigned long size) +{ + struct ktf_cov_obj_key k; + + k.address = addr; + k.size = size; + + return ktf_map_find_entry(&cov_mem_map, (char *)&k, + struct ktf_cov_mem, kmap); +} + +void ktf_cov_mem_get(struct ktf_cov_mem *m) +{ + ktf_map_elem_get(&m->kmap); +} + +void ktf_cov_mem_put(struct ktf_cov_mem *m) +{ + ktf_map_elem_put(&m->kmap); +} + +static void ktf_cov_mem_remove(struct ktf_cov_mem *m) +{ + ktf_map_remove_elem(&cov_mem_map, &m->kmap); +} + +/* Do not use ktf_cov_entry_find() here as we can get entry directly + * from probe address (as probe is first field in struct ktf_cov_entry). + * No reference counting issues should apply as when entry refcnt drops + * to 0 we unregister the kprobe prior to freeing the entry. + */ +static int ktf_cov_handler(struct kprobe *p, struct pt_regs *regs) +{ + struct ktf_cov_entry *entry = (struct ktf_cov_entry *)p; + + /* Make sure probe is ours... */ + if (!entry || entry->magic != KTF_COV_ENTRY_MAGIC) + return 0; + entry->count++; + if (entry->count == 1 && entry->cov) + entry->cov->count++; + return 0; +} + +static int ktf_cov_init_symbol(void *data, const char *name, + struct module *mod, unsigned long addr) +{ + struct ktf_cov_entry *entry; + struct ktf_cov *cov = data; + char buf[256]; + + if (!mod || !cov) + return 0; + + if (!try_module_get(mod)) + return 0; + + /* module_mutex is grabbed by register_kprobe() */ + mutex_unlock(&module_mutex); + + /* We only care about symbols for cov-specified module. */ + if (strcmp(mod->name, cov->kmap.key)) + goto out; + + /* We don't probe ourselves and functions called within probe ctxt. */ + if (strncmp(name, "ktf_cov", strlen("ktf_cov")) == 0 || + strcmp(name, "ktf_map_find") == 0) + goto out; + + /* Check if we're already covered for this module/symbol. */ + entry = ktf_cov_entry_find(addr, 0); + if (entry) { + tlog(T_DEBUG, "%s already present in coverage: %s", + name, entry->name); + ktf_cov_entry_put(entry); + goto out; + } + entry = kzalloc(sizeof(*entry), GFP_KERNEL); + (void)strlcpy(entry->name, name, sizeof(entry->name)); + entry->magic = KTF_COV_ENTRY_MAGIC; + entry->cov = cov; + entry->refcnt = 1; + + entry->kprobe.pre_handler = ktf_cov_handler; + entry->kprobe.symbol_name = entry->name; + + /* Ugh - we try to register a kprobe as a means of determining + * if the symbol is a function. + */ + if (register_kprobe(&entry->kprobe) < 0) { + /* not a probe-able function */ + kfree(entry); + goto out; + } + entry->key.address = addr; + entry->key.size = ktf_symbol_size(addr); + (void)sprint_symbol(buf, entry->key.address); + if (ktf_map_elem_init(&entry->kmap, (char *)&entry->key) < 0 || + ktf_map_insert(&cov_entry_map, &entry->kmap) < 0) { + unregister_kprobe(&entry->kprobe); + kfree(entry); + goto out; + } + tlog(T_DEBUG, "Added %s/%s (%p, size %lu) to coverage: %s", + mod->name, entry->name, (void *)entry->kprobe.addr, + entry->key.size, buf); + + cov->total++; + ktf_cov_entry_put(entry); + +out: + mutex_lock(&module_mutex); + module_put(mod); + return 0; +} + +static int ktf_cov_kmem_cache_alloc_handler(struct kretprobe_instance *, + struct pt_regs *); + +static unsigned long register_kretprobe_size; + +/* Handler tracking allocations. Determine if any functions we are + * tracking coverage for (coverage entries) are on the stack; if so + * we track the allocation. + */ +static int ktf_cov_kmem_alloc_entry(struct ktf_cov_mem *m, unsigned long bytes) +{ + struct ktf_cov_entry *entry = NULL; + int n; + + /* We don't care about 0-length allocations. */ + if (!bytes) + return 0; + + /* Find first cov entry on stack to allow us to attribute traced + * allocation to first coverage entry we come across. + */ + m->nr_entries = stack_trace_save(m->stack_entries, KTF_COV_MAX_STACK_DEPTH, 1); + for (n = 0; n < m->nr_entries; n++) { + /* avoid recursive enter when allocating cov mem */ + if (m->stack_entries[n] == + (unsigned long)ktf_cov_kmem_cache_alloc_handler) + break; + /* ignore allocs as a result of registering probes */ + if (m->stack_entries[n] > + (unsigned long)register_kretprobe && + m->stack_entries[n] < ((unsigned long)register_kretprobe + + register_kretprobe_size)) + break; + entry = ktf_cov_entry_find(m->stack_entries[n], 0); + if (entry) + break; + } + if (!entry) { + m->nr_entries = 0; + return 0; + } + ktf_cov_entry_put(entry); + + m->key.size = bytes; + /* Have to wait until alloc returns to get key.address */ + + return 0; +} + +/* Handler tracking kmalloc allocations. */ +static int ktf_cov_kmalloc_entry_handler(struct kretprobe_instance *ri, + struct pt_regs *regs) +{ + struct ktf_cov_mem *m = (struct ktf_cov_mem *)ri->data; + unsigned long bytes = (unsigned long)KTF_ENTRY_PROBE_ARG0; + + return ktf_cov_kmem_alloc_entry(m, bytes); +} + +static int ktf_cov_kmem_cache_alloc_entry_handler(struct kretprobe_instance *ri, + struct pt_regs *regs) +{ + struct kmem_cache *cache = + (struct kmem_cache *)KTF_ENTRY_PROBE_ARG0; + struct ktf_cov_mem *m = (struct ktf_cov_mem *)ri->data; + unsigned long bytes; + + if (!cache) + return 0; + + bytes = cache->object_size; + if (cache == cov_mem_cache) + return 0; + return ktf_cov_kmem_alloc_entry(m, bytes); +} + +static int ktf_cov_kmem_alloc_return(struct ktf_cov_mem *m, + unsigned long ret) +{ + struct ktf_cov_mem *mm; + + m->key.address = ret; + mm = kmem_cache_alloc(cov_mem_cache, GFP_NOWAIT); + if (!mm) + return 0; + memcpy(mm, m, sizeof(*mm)); + if (ktf_map_elem_init(&mm->kmap, (char *)&mm->key) < 0 || + ktf_map_insert(&cov_mem_map, &mm->kmap) < 0) { + /* This can happen as inexplicably the same probe + * can fire twice for _kmalloc; this results in + * us attempting to add the same address twice, with + * the result that we get -EEXIST from ktf_map_insert() + * the second time. Annoying but the end result is + * we track the allocation once, which is what we want. + */ + terr("Failed to insert cov_mem %p", (void *)ret); + kmem_cache_free(cov_mem_cache, mm); + } + tlog(T_DEBUG, "cov_mem: tracking allocation %p", (void *)m->key.address); + m->nr_entries = 0; + return 0; +} + +static int ktf_cov_kmalloc_handler(struct kretprobe_instance *ri, + struct pt_regs *regs) +{ + struct ktf_cov_mem *m = (struct ktf_cov_mem *)ri->data; + unsigned long ret = regs_return_value(regs); + + if (m->nr_entries) + return ktf_cov_kmem_alloc_return(m, ret); + return 0; +} + +static int ktf_cov_kmem_cache_alloc_handler(struct kretprobe_instance *ri, + struct pt_regs *regs) +{ + struct kmem_cache *cache = + (struct kmem_cache *)KTF_ENTRY_PROBE_ARG0; + struct ktf_cov_mem *m = (struct ktf_cov_mem *)ri->data; + unsigned long ret = regs_return_value(regs); + + if (cache == cov_mem_cache) + return 0; + + if (m->nr_entries) + return ktf_cov_kmem_alloc_return(m, ret); + return 0; +} + +static int ktf_cov_kmem_free_entry(unsigned long tofree) +{ + struct ktf_cov_mem *m; + + if (!tofree) + return 0; + + m = ktf_cov_mem_find(tofree, 0); + if (m) { + tlog(T_DEBUG, "cov_mem: freeing allocation %p", + (void *)m->key.address); + ktf_cov_mem_remove(m); + ktf_cov_mem_put(m); + } + return 0; +} + +static int ktf_cov_kfree_entry_handler(struct kretprobe_instance *ri, + struct pt_regs *regs) +{ + unsigned long tofree = (unsigned long)KTF_ENTRY_PROBE_ARG0; + + if (!tofree) + return 0; + + return ktf_cov_kmem_free_entry(tofree); +} + +static int ktf_cov_kmem_cache_free_entry_handler(struct kretprobe_instance *ri, + struct pt_regs *regs) +{ + struct kmem_cache *cache = + (struct kmem_cache *)KTF_ENTRY_PROBE_ARG0; + unsigned long tofree = (unsigned long)KTF_ENTRY_PROBE_ARG1; + + if (!tofree || cache == cov_mem_cache) + return 0; + + return ktf_cov_kmem_free_entry(tofree); +} + +static struct kretprobe cov_mem_probes[] = { + { .kp = { .symbol_name = "__kmalloc" }, + .handler = ktf_cov_kmalloc_handler, + .entry_handler = ktf_cov_kmalloc_entry_handler, + .data_size = sizeof(struct ktf_cov_mem), + .maxactive = 0, /* assumes default value */ + }, + { .kp = { .symbol_name = "kmem_cache_alloc" }, + .handler = ktf_cov_kmem_cache_alloc_handler, + .entry_handler = ktf_cov_kmem_cache_alloc_entry_handler, + .data_size = sizeof(struct ktf_cov_mem), + .maxactive = 0, /* assumes default value */ + }, + { .kp = { .symbol_name = "kfree" }, + .handler = NULL, + .entry_handler = ktf_cov_kfree_entry_handler, + .data_size = 0, + .maxactive = 0, /* assumes default value */ + }, + { .kp = { .symbol_name = "kmem_cache_free" }, + .handler = NULL, + .entry_handler = ktf_cov_kmem_cache_free_entry_handler, + .data_size = 0, + .maxactive = 0, /* assumes default value */ + } +}; + +static int cov_opt_mem_cnt; + +static int ktf_cov_init_opts(struct ktf_cov *cov) +{ + int i, ret = 0; + + if (cov->opts & KTF_COV_OPT_MEM && ++cov_opt_mem_cnt == 1) { + if (!cov_mem_cache) { + cov_mem_cache = + kmem_cache_create("ktf_cov_mem_cache", + sizeof(struct ktf_cov_mem), 0, + SLAB_HWCACHE_ALIGN | SLAB_PANIC, + NULL); + + if (!cov_mem_cache) + return -ENOMEM; + } + + for (i = 0; i < ARRAY_SIZE(cov_mem_probes); i++) { + /* reset in case we're re-registering */ + cov_mem_probes[i].kp.addr = NULL; + cov_mem_probes[i].kp.flags = 0; + ret = register_kretprobe(&cov_mem_probes[i]); + if (ret) { + tlog(T_DEBUG, + "%d: failed to register retprobe for %s", + ret, cov_mem_probes[i].kp.symbol_name); + return ret; + } + } + } + + return ret; +} + +static void ktf_cov_cleanup_opts(struct ktf_cov *cov) +{ + int i; + + if (cov->opts & KTF_COV_OPT_MEM && --cov_opt_mem_cnt == 0) { + for (i = 0; i < ARRAY_SIZE(cov_mem_probes); i++) { + if (cov_mem_probes[i].nmissed > 0) { + tlog(T_INFO, "%s: retprobe missed %d.", + cov_mem_probes[i].kp.symbol_name, + cov_mem_probes[i].nmissed); + } + if (cov_mem_probes[i].kp.addr) + unregister_kretprobe(&cov_mem_probes[i]); + } + } +} + +/* If the module we are monitoring coverage for was unloaded/reloaded + * while coverage was disabled, we can end up re-enabling kprobes at + * different addresses for the same function. The problem is however + * we reference coverage entries by their address in the coverage + * entry map, so we need to clean it up to reflect the new locations + * of the probes. So we remove/re-add the entries with the updated + * addresses. It would obviously be easier to just remove the entries + * on coverage disable, but that limits our ability to examine coverage + * data - a common pattern is enable coverage, run test(s), disable + * coverage, check coverage data. + */ +static void ktf_cov_update_entries(const char *name, struct ktf_cov *cov) +{ + struct ktf_cov_entry *entry = ktf_map_first_entry(&cov_entry_map, + struct ktf_cov_entry, + kmap); + + while (entry) { + if (entry->cov != cov || + (unsigned long)entry->kprobe.addr == entry->key.address) { + entry = ktf_map_next_entry(entry, kmap); + continue; + } + + /* Address has changed; remove entry with old address as key + * and re-add with new address/size as key (size may have + * changed if module was re-compiled). + */ + ktf_map_remove_elem(&cov_entry_map, &entry->kmap); + entry->key.address = (unsigned long)entry->kprobe.addr; + entry->key.size = ktf_symbol_size(entry->key.address); + if (ktf_map_elem_init(&entry->kmap, (char *)&entry->key) < 0 || + ktf_map_insert(&cov_entry_map, &entry->kmap) < 0) { + tlog(T_DEBUG, "Failed to add %s/%s", name, entry->name); + unregister_kprobe(&entry->kprobe); + entry->refcnt--; + entry = ktf_map_next_entry(entry, kmap); + } else { + tlog(T_DEBUG, "Added %s/%s (%p, size %lu) to coverage", + name, entry->name, (void *)entry->key.address, + entry->key.size); + /* Map has changed, reset to root. */ + entry = ktf_map_first_entry(&cov_entry_map, + struct ktf_cov_entry, kmap); + } + } +} + +int ktf_cov_enable(const char *name, unsigned int opts) +{ + struct ktf_cov *cov = ktf_cov_find(name); + struct ktf_cov_entry *entry; + int ret = 0; + +#ifndef KTF_PROBE_SUPPORT + return -ENOTSUPP; +#endif + if (!cov) { + cov = kzalloc(sizeof(*cov), GFP_KERNEL); + if (!cov) + return -ENOMEM; + + cov->type = KTF_COV_TYPE_MODULE; + cov->opts = opts; + if (ktf_map_elem_init(&cov->kmap, name) < 0 || + ktf_map_insert(&cov_map, &cov->kmap) < 0) { + tlog(T_DEBUG, "cov %s already present", cov->kmap.key); + kfree(cov); + return -EEXIST; + } + register_kretprobe_size = + ktf_symbol_size((unsigned long)register_kretprobe); + mutex_lock(&module_mutex); + kallsyms_on_each_symbol(ktf_cov_init_symbol, cov); + mutex_unlock(&module_mutex); + } else { + ktf_map_for_each_entry(entry, &cov_entry_map, kmap) { + if (entry->cov != cov) + continue; + if (++entry->refcnt == 1) { + /* reset kprobe as we're re-registering */ + memset(&entry->kprobe, 0, + sizeof(entry->kprobe)); + entry->kprobe.pre_handler = ktf_cov_handler; + entry->kprobe.symbol_name = entry->name; + ret = register_kprobe(&entry->kprobe); + if (ret) { + tlog(T_DEBUG, "Failed to add %s/%s", + name, entry->name); + entry->refcnt--; + } + } + } + /* Probe addresses/function sizes for functions may have + * changed if module was unloaded/reloaded - entry map + * needs to be updated to use new address/size as key. + */ + ktf_cov_update_entries(name, cov); + } + + ret = ktf_cov_init_opts(cov); + + ktf_cov_put(cov); + + return ret; +} + +void ktf_cov_disable(const char *module) +{ + struct ktf_cov *cov = ktf_cov_find(module); + struct ktf_cov_entry *entry; + +#ifndef KTF_PROBE_SUPPORT + return; +#endif + + if (!cov) + return; + + ktf_map_for_each_entry(entry, &cov_entry_map, kmap) { + if (entry->cov == cov) { + if (--entry->refcnt == 0) { + unregister_kprobe(&entry->kprobe); + tlog(T_DEBUG, "Removed coverage %s/%s", + cov->kmap.key, entry->name); + } + } + } + ktf_cov_cleanup_opts(cov); + ktf_cov_put(cov); +} + +static void ktf_cov_mem_seq_print(struct seq_file *seq) +{ + struct ktf_cov_mem *m; + char buf[256]; + int n; + + seq_puts(seq, "\nMemory in use allocated by covered functions:\n\n"); + seq_printf(seq, "%44s %16s %10s\n", "ALLOCATION STACK", "ADDRESS", + "SIZE"); + ktf_for_each_cov_mem(m) { + for (n = 0; n < m->nr_entries; n++) { + sprint_symbol(buf, m->stack_entries[n]); + seq_printf(seq, "%44s", buf); + if (n == 0) + seq_printf(seq, " %16p %10lu", + (void *)m->key.address, + m->key.size); + seq_puts(seq, "\n"); + } + seq_puts(seq, "\n"); + } +} + +void ktf_cov_seq_print(struct seq_file *seq) +{ + struct ktf_cov_entry *entry; + struct ktf_cov *cov; + + seq_printf(seq, "%10s %44s %10s\n", "MODULE", "#FUNCTIONS", + "#CALLED"); + ktf_map_for_each_entry(cov, &cov_map, kmap) + seq_printf(seq, "%10s %44d %10d\n", + cov->kmap.key, cov->total, cov->count); + + seq_printf(seq, "\n%10s %44s %10s\n", "MODULE", "FUNCTION", "COUNT"); + ktf_map_for_each_entry(entry, &cov_entry_map, kmap) + seq_printf(seq, "%10s %44s %10d\n", + entry->cov ? entry->cov->kmap.key : "-", + entry->name, entry->count); + + ktf_cov_mem_seq_print(seq); +} + + +void ktf_cov_cleanup(void) +{ + struct ktf_cov *cov; + char name[KTF_MAX_KEY]; + + ktf_map_for_each_entry(cov, &cov_map, kmap) { + ktf_cov_disable(ktf_map_elem_name(&cov->kmap, name)); + } + ktf_map_delete_all(&cov_map); + ktf_map_delete_all(&cov_entry_map); + ktf_map_delete_all(&cov_mem_map); + kmem_cache_destroy(cov_mem_cache); +} diff --git a/tools/testing/selftests/ktf/kernel/ktf_cov.h b/tools/testing/selftests/ktf/kernel/ktf_cov.h new file mode 100644 index 0000000..56ae753 --- /dev/null +++ b/tools/testing/selftests/ktf/kernel/ktf_cov.h @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Alan Maguire alan.maguire@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * ktf_cov.h: Code coverage support interface for KTF. + */ + +#ifndef KTF_COV_H +#define KTF_COV_H + +#include <linux/debugfs.h> +#include <linux/module.h> +#include <linux/kprobes.h> +#include "ktf.h" +#include "ktf_map.h" + +enum ktf_cov_type { + KTF_COV_TYPE_MODULE, + KTF_COV_TYPE_MAX, +}; + +struct ktf_cov { + struct ktf_map_elem kmap; + enum ktf_cov_type type; /* only modules supported for now. */ + int count; /* number of unique functions called */ + int total; /* total number of functions */ + unsigned int opts; +}; + +/* Key for coverage entries (functions) consists in function address _and_ + * size - this allows us to find offsets in function on stack. Also used + * to track allocated memory - allocated address + size. + */ +struct ktf_cov_obj_key { + unsigned long address; + unsigned long size; +}; + +#define KTF_COV_ENTRY_MAGIC 0xc07e8a5e +struct ktf_cov_entry { + struct kprobe kprobe; + int magic; /* magic number identifying entry */ + struct ktf_map_elem kmap; + char name[KTF_MAX_KEY]; + struct ktf_cov_obj_key key; + struct ktf_cov *cov; + struct ktf_map cov_mem; + int refcnt; + int count; +}; + +#define KTF_COV_MAX_STACK_DEPTH 32 + +struct ktf_cov_mem { + struct ktf_map_elem kmap; + struct ktf_cov_obj_key key; + unsigned long flags; + unsigned int nr_entries; + unsigned long stack_entries[KTF_COV_MAX_STACK_DEPTH]; +}; + +#define KTF_COV_MEM_IGNORE 0x1 /* avoid recursive enter */ + +struct ktf_cov_mem_probe { + const char *name; + struct kretprobe kretprobe; +}; + +extern struct ktf_map cov_mem_map; + +#define ktf_for_each_cov_mem(pos) \ + ktf_map_for_each_entry(pos, &cov_mem_map, kmap) + +struct ktf_cov_entry *ktf_cov_entry_find(unsigned long, unsigned long); +void ktf_cov_entry_put(struct ktf_cov_entry *); +void ktf_cov_entry_get(struct ktf_cov_entry *); + +struct ktf_cov *ktf_cov_find(const char *); +void ktf_cov_put(struct ktf_cov *); +void ktf_cov_get(struct ktf_cov *); + +struct ktf_cov_mem *ktf_cov_mem_find(unsigned long, unsigned long); +void ktf_cov_mem_put(struct ktf_cov_mem *); +void ktf_cov_mem_get(struct ktf_cov_mem *); + +void ktf_cov_seq_print(struct seq_file *); +void ktf_cov_cleanup(void); + +int ktf_cov_enable(const char *, unsigned int); +void ktf_cov_disable(const char *); + +#endif

Takes an input file foo.txt with a list of symbols on the form:

#module foo #header foo.h private_foo_symbol_1 private_foo_symbol_2

and creates usable definitions to access these (requires CONFIG_KALLSYMS_ALL). This is useful to be able to easily and cleanly test internal interfaces of a module. Examples follows in the selftests later in the series.

Signed-off-by: Knut Omang knut.omang@oracle.com --- tools/testing/selftests/ktf/scripts/resolve | 188 +++++++++++++++++++++- 1 file changed, 188 insertions(+) create mode 100755 tools/testing/selftests/ktf/scripts/resolve

diff --git a/tools/testing/selftests/ktf/scripts/resolve b/tools/testing/selftests/ktf/scripts/resolve new file mode 100755 index 0000000..74005f7 --- /dev/null +++ b/tools/testing/selftests/ktf/scripts/resolve @@ -0,0 +1,188 @@ +#!/usr/bin/python + +# Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. +# Author: Knut Omang knut.omang@oracle.com +# +# SPDX-License-Identifier: GPL-2.0 +# +# A script to generate code and header definitions for +# module and kernel symbols not directly exposed to KTF. +# (See the documentation for KTF for details) +# + +import os, sys, re, shutil, string, ConfigParser + +def usage(): + print "Usage: resolve symbolfile outputfile" + exit(0) + +class FuncInfo: + def __init__(self, sym, re_sym, re_decl): + self.symbol = sym + self.re_sym = re_sym + self.re_decl = re_decl + + def __repr__(self): + return "FuncInfo: [%s: %s]" % (self.symbol, self.re_decl) + +class Module: + def __init__(self, name, header): + self.cur_header = header + self.prefix = "Z" + self.name = name + self.symbols = {} # Input: headerfile -> symbol list + self.func_def = [] # FuncInfo list + self.debug = False + all_modules.append(self) + + def log(self, str): + if self.debug: + print str + + def SetHeader(self, header): + self.cur_header = header + + def AddSymbol(self, sym): + try: + h = self.symbols[self.cur_header] + h.append(sym) + except: + self.symbols[self.cur_header] = [sym] + + # Open along include path: + def Open(self, filename): + for p in includepath: + try: + f = os.path.join(p, filename) + self.log(" -- trying " + f) + header = open(f,'r') + return header + except: + continue + sys.stderr.write(" ** unable to open "%s"\n" % filename) + return None + + # Parse the relevant header files for function defs: + def ParseDefs(self): + for hf in self.symbols.keys(): + self.log(" ** Parsing %s:" % hf) + header = self.Open(hf) + if header == None: + return + content = header.read() + symbols = self.symbols[hf] + types = r"(extern|u8|u16|u32|u64|int|long|size_t|off_t|loff_t|void|struct|union\s)(.*[*\s]" + funor = ")(" + "|".join(symbols) + r")(([^)]+);)$" + tt = types + funor + s = re.compile(tt, re.MULTILINE) + miter = s.finditer(content) + s_count = 0 + for m in miter: + sym = m.group(3) + re_name = "_".join([self.prefix, sym]) + re_decl = "%s%s(*%s)%s" % (m.group(1), m.group(2), re_name, m.group(4)) + self.func_def.append(FuncInfo(sym, re_name, re_decl)) + s_count = s_count + 1 + + if s_count != len(symbols): + print " ** Warning: File %s: Found %d definitions from %d symbols!" % \ + (hf, s_count, len(symbols)) + print " ** - please check/fix output manually!" + + # Output functions: + def write_funcs(self, file): + for fi in self.func_def: + file.write("\t%s\n"% fi.re_decl) + + def write_defines(self, file): + for fi in self.func_def: + file.write("#define %s ktf_syms.%s\n" % (fi.symbol, fi.re_sym)) + + def write_resolve_calls(self, file): + for fi in self.func_def: + file.write("\tktf_resolve_symbol(%s, %s);\n" % (self.name, fi.symbol)) + +usage_h = False +my_argv = [] +includepath = [""] + +for arg in sys.argv[1:]: + if arg == "-h": + usage_h = True + continue + incl = re.match(r"-I([^\s]+)", arg) + if incl != None: + includepath.append(incl.group(1)) + continue + genopt = re.match(r"-([^\s]+)", arg) + if genopt != None: + # Silently ignore other cc options as we accept cc-flags-y: + # + continue + my_argv.append(arg) + +# Main program: + +if len(my_argv) != 2 or usage_h: + usage() + +symfile = my_argv[0] +outputfile = my_argv[1] + +all_modules = [] +module = Module("kernel", None) # Default, at the top of the file is the main kernel symbols +header = None # A header directive is required before any symbols + +try: + file = open(symfile, 'r') +except: + print "Unable to open config file "%s"" % symfile + exit(1) +for line in file: + match = re.match(r"^#(\w+) ([\w.]+)\s*$", line) + if match != None: + cmd = match.group(1) + value = match.group(2) + if cmd == "module": + module = Module(value, header) + elif cmd == "header": + header = value + module.SetHeader(header) + else: + raise ResolveError("Unknown directive "%s"" % cmd) + #print "%s set to %s" % (cmd, value) + continue + match = re.match(r"\s*(\w+)\s*", line) + if match != None: + s = match.group(1) + module.AddSymbol(s) + +for m in all_modules: + m.ParseDefs() + +try: + output = open(outputfile, "w") +except: + print "Failed to open output header file "%s"" % outputfile +output.write('#ifndef _KTF_RESOLVE_H\n#define _KTF_RESOLVE_H\n') +output.write('#include "ktf.h"\n\nstruct ktf_syms {\n') + +for m in all_modules: + m.write_funcs(output) + +output.write('};\n\n') + +for m in all_modules: + m.write_defines(output) + +output.write('\n\nextern struct ktf_syms ktf_syms;\n') +output.write('\nint ktf_resolve_symbols(void);\n#ifndef KTF_CLIENT\n') +output.write('struct ktf_syms ktf_syms;\n\n') + +output.write('\nint ktf_resolve_symbols(void)\n{\n') + +for m in all_modules: + m.write_resolve_calls(output) + +output.write('\treturn 0;\n}\n\n#endif /* !KTF_CLIENT */\n#endif /* _KTF_RESOLVE_H */ \n') +output.close()

context.c: Parameterized context test case, kernel side: context.h: Parameterized context test case, kernel side. context_self.h: The data structure passed between user level and kernel for the hybrid.c: Hybrid (combined user level and kernel) self tests, hybrid.h: Hybrid (combined user level and kernel) self tests, hybrid_self.h: The data structure passed between user level and kernel for the self.c: Some simple self tests for KTF

Signed-off-by: Knut Omang knut.omang@oracle.com --- tools/testing/selftests/ktf/selftest/Makefile | 17 +- tools/testing/selftests/ktf/selftest/context.c | 149 +++- tools/testing/selftests/ktf/selftest/context.h | 15 +- tools/testing/selftests/ktf/selftest/context_self.h | 34 +- tools/testing/selftests/ktf/selftest/hybrid.c | 35 +- tools/testing/selftests/ktf/selftest/hybrid.h | 24 +- tools/testing/selftests/ktf/selftest/hybrid_self.h | 27 +- tools/testing/selftests/ktf/selftest/ktf_syms.txt | 17 +- tools/testing/selftests/ktf/selftest/self.c | 661 +++++++++++++- 9 files changed, 979 insertions(+) create mode 100644 tools/testing/selftests/ktf/selftest/Makefile create mode 100644 tools/testing/selftests/ktf/selftest/context.c create mode 100644 tools/testing/selftests/ktf/selftest/context.h create mode 100644 tools/testing/selftests/ktf/selftest/context_self.h create mode 100644 tools/testing/selftests/ktf/selftest/hybrid.c create mode 100644 tools/testing/selftests/ktf/selftest/hybrid.h create mode 100644 tools/testing/selftests/ktf/selftest/hybrid_self.h create mode 100644 tools/testing/selftests/ktf/selftest/ktf_syms.txt create mode 100644 tools/testing/selftests/ktf/selftest/self.c

diff --git a/tools/testing/selftests/ktf/selftest/Makefile b/tools/testing/selftests/ktf/selftest/Makefile new file mode 100644 index 0000000..8737bf4 --- /dev/null +++ b/tools/testing/selftests/ktf/selftest/Makefile @@ -0,0 +1,17 @@ +# Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved. +# +# SPDX-License-Identifier: GPL-2.0 +# +# Kernel module implementing a test suite for testing KTF itself +# + +ccflags-y += -Wno-vla + +ccflags-y += -I$(srctree)/$(src)/../kernel -I$(src) + +obj-m := selftest.o + +include $(srctree)/$(src)/../scripts/ktf_syms.mk + +selftest-y := self.o hybrid.o context.o + diff --git a/tools/testing/selftests/ktf/selftest/context.c b/tools/testing/selftests/ktf/selftest/context.c new file mode 100644 index 0000000..9129b5b --- /dev/null +++ b/tools/testing/selftests/ktf/selftest/context.c @@ -0,0 +1,149 @@ +/* Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: GPL-2.0 + * + * context.c: Parameterized context test case, kernel side: + */ + +#include "ktf.h" +#include "context.h" + +/* Declare a specific handle for this test to avoid interfering with the + * other tests: + */ +static KTF_HANDLE_INIT(ct_handle); + +struct param_test_ctx { + struct ktf_context k; + struct test_parameter_block p; +}; + +struct param_test_ctx param_ctx[2]; + +#define MYVALUE 0xdabadaba + +/* Declare the callback that accepts a parameter block */ +static int param_ctx_cb(struct ktf_context *ctx, const void *data, size_t data_sz) +{ + struct param_test_ctx *px = container_of(ctx, struct param_test_ctx, k); + struct test_parameter_block *pb = (struct test_parameter_block *)data; + long orig_myvalue; + + if (data_sz != sizeof(*pb)) + return -EINVAL; + /* check data validity here, if possible.. */ + orig_myvalue = px->p.myvalue; + memcpy(&px->p, pb, data_sz); + /* Enforce "policies" */ + px->p.myvalue = orig_myvalue; + return 0; +} + +TEST(selftest, param) +{ + struct param_test_ctx *px = container_of(ctx, struct param_test_ctx, k); + + /* Now, here we can fail (using ASSERT) or ignore by silently return + * depending on what's most useful, if a test hasn't been configured. + * For this selftest we just use EXPECT so we can have the actual current + * parameter values reported as well. + * + * Notice that these parameters are + * persistent throughout the instance 'life' of the kernel test module, + * so if one user program has configured them, then + * programs ignorant of the parameters may still end up + * executing the tests with previously configured parameters: + * + * This simplified example uses the same configuration struct for both + * context type IDs, but the idea is that they can be completely different. + */ + EXPECT_INT_EQ(ctx->config_errno, 0); + if (KTF_CONTEXT_CFG_OK(ctx)) { + switch (ctx->type->name[13]) { + case '1': + EXPECT_LONG_EQ(px->p.magic, CONTEXT_MAGIC1); + break; + case '2': + EXPECT_LONG_EQ(px->p.magic, CONTEXT_MAGIC2); + break; + case '3': + EXPECT_LONG_EQ(px->p.magic, CONTEXT_MAGIC3); + EXPECT_LONG_EQ(px->p.myvalue, MYVALUE); + break; + } + EXPECT_STREQ(px->p.s, CONTEXT_MSG); + } else { + EXPECT_LONG_EQ(px->p.magic, 0); + EXPECT_STREQ(px->p.s, ""); + } +} + +struct param_test_type { + struct ktf_context_type kt; + /* space for cfg data (such as constraints) for the context type */ + long myvalue; +}; + +static struct ktf_context *type3_alloc(struct ktf_context_type *ct) +{ + struct param_test_type *pct = container_of(ct, struct param_test_type, kt); + struct param_test_ctx *ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); + + ctx->p.myvalue = pct->myvalue; + return &ctx->k; +} + +static void type3_cleanup(struct ktf_context *ctx) +{ + struct param_test_ctx *px = container_of(ctx, struct param_test_ctx, k); + + kfree(px); +} + +TEST(selftest, dupltype) +{ + /* Verify that we cannot add the same context type twice */ + + static struct param_test_type dupltype = { + .myvalue = 0, + .kt.alloc = type3_alloc, + .kt.config_cb = param_ctx_cb, + .kt.cleanup = type3_cleanup, + .kt.name = "context_type_3" + }; + + ASSERT_INT_EQ(-EEXIST, ktf_handle_add_ctx_type(&ct_handle, &dupltype.kt)); +} + +void add_context_tests(void) +{ + int ret = KTF_CONTEXT_ADD_TO_CFG(ct_handle, &param_ctx[0].k, "context1", + param_ctx_cb, "context_type_1"); + + if (ret) + return; + + ret = KTF_CONTEXT_ADD_TO_CFG(ct_handle, &param_ctx[1].k, "context2", + param_ctx_cb, "context_type_2"); + if (ret) + return; + + { + static struct param_test_type ctx_type3 = { + .myvalue = MYVALUE, + .kt.alloc = type3_alloc, + .kt.config_cb = param_ctx_cb, + .kt.cleanup = type3_cleanup, + .kt.name = "context_type_3" + }; + ret = ktf_handle_add_ctx_type(&ct_handle, &ctx_type3.kt); + } + + ADD_TEST_TO(ct_handle, param); + ADD_TEST(dupltype); +} + +void context_tests_cleanup(void) +{ + KTF_HANDLE_CLEANUP(ct_handle); +} diff --git a/tools/testing/selftests/ktf/selftest/context.h b/tools/testing/selftests/ktf/selftest/context.h new file mode 100644 index 0000000..69b970a --- /dev/null +++ b/tools/testing/selftests/ktf/selftest/context.h @@ -0,0 +1,15 @@ +/* Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: GPL-2.0 + * + * context.h: Parameterized context test case, kernel side. + */ +#ifndef _CONTEXT_H +#define _CONTEXT_H + +#include "context_self.h" + +void add_context_tests(void); +void context_tests_cleanup(void); + +#endif diff --git a/tools/testing/selftests/ktf/selftest/context_self.h b/tools/testing/selftests/ktf/selftest/context_self.h new file mode 100644 index 0000000..3939559 --- /dev/null +++ b/tools/testing/selftests/ktf/selftest/context_self.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: GPL-2.0 + * + * context_self.h: The data structure passed between user level and kernel for the + * hybrid self tests. Included both from user space and kernel space and + * needs to be a C struct. + */ + +#ifndef KTF_CONTEXT_SELF_H +#define KTF_CONTEXT_SELF_H + +#define CONTEXT_SELF_MAX_TEXT 30 + +/* A simple example parameter block: + * For verification purposes it can be useful to have a field + * like 'magic' below, which serves for the purpose of + * a sanity check that the parameters sent by the user program + * actually corresponds to what the kernel expects: + */ +struct test_parameter_block { + long magic; + long myvalue; + char s[CONTEXT_SELF_MAX_TEXT+1]; +}; + +/* Constants for the selftest.param_context test: */ +#define CONTEXT_MSG "from user to kernel" +#define CONTEXT_MAGIC1 0xfaaa1234UL +#define CONTEXT_MAGIC2 0xaabbccUL +#define CONTEXT_MAGIC3 0x123456UL + +#endif diff --git a/tools/testing/selftests/ktf/selftest/hybrid.c b/tools/testing/selftests/ktf/selftest/hybrid.c new file mode 100644 index 0000000..999a7d8 --- /dev/null +++ b/tools/testing/selftests/ktf/selftest/hybrid.c @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: GPL-2.0 + * + * hybrid.c: Hybrid (combined user level and kernel) self tests, + * kernel side: + */ + +#include "ktf.h" +#include "hybrid.h" + +/* First a simple message passing test that just verifies that we receive + * "out-of-band" data from user space: + */ + +TEST(selftest, msg) +{ + /* Accept data of type 'struct hybrid_self_params' (defined in hybrid_self.h) + * from user mode. This functionality is to allow user mode to test something, + * for instance that a certain parameter is handled in a specific way in the kernel. + * The user then has the option to provide data to the kernel out-of-band to + * tell the kernel side what to expect. + * In this test, just verify that data has been transmitted correctly: + */ + KTF_USERDATA(self, hybrid_self_params, data); + + EXPECT_STREQ(data->text_val, HYBRID_MSG); + EXPECT_LONG_EQ(data->val, HYBRID_MSG_VAL); +} + +void add_hybrid_tests(void) +{ + ADD_TEST(msg); +} diff --git a/tools/testing/selftests/ktf/selftest/hybrid.h b/tools/testing/selftests/ktf/selftest/hybrid.h new file mode 100644 index 0000000..0ba6f72 --- /dev/null +++ b/tools/testing/selftests/ktf/selftest/hybrid.h @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: GPL-2.0 + * + * hybrid.h: Hybrid (combined user level and kernel) self tests, + * kernel side, internal interface: + */ + +#ifndef KTF_HYBRID_H +#define KTF_HYBRID_H + +#include "hybrid_self.h" + +/* The kernel part of hybrid tests must be added to KTFs set of tests like any other tests, + * in fact from KTF's kernel perspective it is like any other test, except that it likely will + * fail if called without the context provided from the user space side. + * + * This function adds the tests declared in hybrid.c + */ +void add_hybrid_tests(void); + + +#endif diff --git a/tools/testing/selftests/ktf/selftest/hybrid_self.h b/tools/testing/selftests/ktf/selftest/hybrid_self.h new file mode 100644 index 0000000..21c6c92 --- /dev/null +++ b/tools/testing/selftests/ktf/selftest/hybrid_self.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: GPL-2.0 + * + * hybrid_self.h: The data structure passed between user level and kernel for the + * hybrid self tests. Included both from user space and kernel space and + * needs to be a C struct. + */ + +#ifndef KTF_HYBRID_SELF_H +#define KTF_HYBRID_SELF_H + +#define HYBRID_SELF_MAX_TEXT 127 + +struct hybrid_self_params +{ + char text_val[HYBRID_SELF_MAX_TEXT+1]; + unsigned long val; +}; + + +/* Constants for the selftest.msg test: */ +#define HYBRID_MSG "a little test string" +#define HYBRID_MSG_VAL 0xffUL + +#endif diff --git a/tools/testing/selftests/ktf/selftest/ktf_syms.txt b/tools/testing/selftests/ktf/selftest/ktf_syms.txt new file mode 100644 index 0000000..721ae98 --- /dev/null +++ b/tools/testing/selftests/ktf/selftest/ktf_syms.txt @@ -0,0 +1,17 @@ +#module ktf +#header ktf_map.h +ktf_map_init +ktf_map_elem_init +ktf_map_insert +ktf_map_find +ktf_map_find_first +ktf_map_remove +ktf_map_elem_get +ktf_map_elem_put +ktf_map_find_next +ktf_map_delete_all +#header ktf_cov.h +ktf_cov_entry_find +ktf_cov_entry_put +ktf_cov_enable +ktf_cov_disable diff --git a/tools/testing/selftests/ktf/selftest/self.c b/tools/testing/selftests/ktf/selftest/self.c new file mode 100644 index 0000000..8b7a582 --- /dev/null +++ b/tools/testing/selftests/ktf/selftest/self.c @@ -0,0 +1,661 @@ +/* + * Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved. + * + * SPDX-License-Identifier: GPL-2.0 + * + * self.c: Some simple self tests for KTF + */ +#include <linux/module.h> +#include <linux/mm_types.h> +#include <linux/slab.h> +#include <linux/slab_def.h> + +#include "ktf.h" +#include "ktf_map.h" +#include "ktf_cov.h" +#include "ktf_syms.h" + +#include "hybrid.h" +#include "context.h" + +MODULE_LICENSE("GPL"); + +struct map_test_ctx { + struct ktf_context k; +}; + +static struct map_test_ctx s_mctx[4]; + +/* Declare a simple handle with no contexts for simple (unparameterized) tests: */ +KTF_INIT(); + +/* For tests that defines multiple test cases + * (e.g. if the test scope requires application of each test on several devices or + * other abstract contexts, definable by the test module) + */ +static KTF_HANDLE_INIT(dual_handle); +static KTF_HANDLE_INIT(single_handle); +static KTF_HANDLE_INIT(no_handle); +static KTF_HANDLE_INIT_VERSION(wrongversion_handle, 0, false); + +static struct map_test_ctx *to_mctx(struct ktf_context *ctx) +{ + return container_of(ctx, struct map_test_ctx, k); +} + +struct myelem { + struct ktf_map_elem foo; + int freed; + int order; +}; + +/* --- Simple insertion and removal test --- */ + +TEST(selftest, simplemap) +{ + int i; + const int nelems = 3; + struct map_test_ctx *mctx = to_mctx(ctx); + struct ktf_map tm; + struct myelem e[nelems]; + + if (mctx) + tlog(T_DEBUG, "ctx %s", mctx->k.elem.key); + else + tlog(T_DEBUG, "ctx <none>"); + + ktf_map_init(&tm, NULL, NULL); + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[0].foo, "foo")); + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[1].foo, "bar")); + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[2].foo, "zax")); + + for (i = 0; i < nelems; i++) { + EXPECT_LONG_EQ(i, ktf_map_size(&tm)); + EXPECT_INT_EQ(0, ktf_map_insert(&tm, &e[i].foo)); + } + EXPECT_LONG_EQ(i, ktf_map_size(&tm)); + + /* Should be sorted alphabetically so we get 'bar' back: */ + EXPECT_ADDR_EQ(&e[1].foo, ktf_map_find_first(&tm)); + + for (i = 0; i < nelems; i++) { + EXPECT_LONG_EQ(nelems - i, ktf_map_size(&tm)); + EXPECT_ADDR_EQ(&e[i].foo, ktf_map_remove(&tm, e[i].foo.key)); + } + EXPECT_LONG_EQ(0, ktf_map_size(&tm)); +} + +/* --- Reference counting test --- */ + +/* should be called when refcount is 0. */ +static void myelem_free(struct ktf_map_elem *elem) +{ + struct myelem *myelem = container_of(elem, struct myelem, foo); + + myelem->freed = 1; +} + +TEST(selftest, mapref) +{ + int i; + const int nelems = 3; + struct myelem e[nelems], *ep; + struct ktf_map tm; + struct ktf_map_elem *elem; + + ktf_map_init(&tm, NULL, myelem_free); + /* Init map elems with "foo" "bar" "zax" */ + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[0].foo, "foo")); + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[1].foo, "bar")); + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[2].foo, "zax")); + + /* Insert elems and drop our refcounts (map still holds ref) */ + for (i = 0; i < nelems; i++) { + EXPECT_INT_EQ(0, ktf_map_insert(&tm, &e[i].foo)); + ktf_map_elem_put(&e[i].foo); + } + + /* This macro takes (and drops) refcount for each elem */ + ktf_map_for_each_entry(ep, &tm, foo) + ep->freed = 0; + + for (i = 0; i < nelems; i++) { + elem = ktf_map_remove(&tm, e[i].foo.key); + EXPECT_INT_EQ(0, e[i].freed); + /* free our ref, now free function should be called. */ + ktf_map_elem_put(elem); + EXPECT_INT_EQ(1, e[i].freed); + } + + ktf_map_delete_all(&tm); + EXPECT_LONG_EQ(0, ktf_map_size(&tm)); +} + +/* --- Test that the expect macros work as if-then-else single statement */ +TEST(selftest, statements) +{ + char c; + char *cp = &c; + /* These are mostly intended as compilation syntax tests */ + if (_i) + EXPECT_TRUE(true); + else + EXPECT_FALSE(false); + if (_i) + ASSERT_TRUE(true); + else + ASSERT_FALSE(false); + if (_i) + ASSERT_OK_ADDR(cp); + else + ASSERT_OK_ADDR_GOTO(cp, out); + if (_i) + ASSERT_OK_ADDR_BREAK(cp); +out: + EXPECT_TRUE(true); +} + +/* --- Compare function test --- */ + +/* key comparison function */ +static int myelem_cmp(const char *key1, const char *key2) +{ + int i1 = *((int *)key1); + int i2 = *((int *)key2); + + if (i1 < i2) + return -1; + else if (i1 > i2) + return 1; + return 0; +} + +TEST(selftest, mapcmpfunc) +{ + int i; + const int nelems = 3; + struct myelem e[nelems], *ep; + struct ktf_map tm; + + ktf_map_init(&tm, myelem_cmp, NULL); + /* Init map elems with keys "foo" "bar" "zax" */ + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[0].foo, "foo")); + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[1].foo, "bar")); + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[2].foo, "zax")); + + /* Insert elems with order values 3, 2, 1. Ensure we see order + * 1, 2, 3 on retrieval. + */ + for (i = 0; i < nelems; i++) { + e[i].order = nelems - i; + EXPECT_INT_EQ(0, ktf_map_elem_init(&e[i].foo, + (char *)&e[i].order)); + EXPECT_INT_EQ(0, ktf_map_insert(&tm, &e[i].foo)); + } + i = 1; + /* Ensure ordering via compare function is respected */ + ktf_map_for_each_entry(ep, &tm, foo) + EXPECT_INT_EQ(ep->order, i++); + + ktf_map_delete_all(&tm); + EXPECT_LONG_EQ(0, ktf_map_size(&tm)); +} + +/* --- Verify that key name is truncated at KTF_MAX_NAME length --- */ + +TEST(selftest, map_keyoverflow) +{ + struct myelem e; + struct ktf_map tm; + char jumbokey[KTF_MAX_NAME + 2]; + char jumbokey_truncated[KTF_MAX_NAME + 1]; + + ktf_map_init(&tm, NULL, NULL); + memset(jumbokey, 'x', KTF_MAX_NAME + 1); + memset(jumbokey_truncated, 'x', KTF_MAX_NAME); + jumbokey_truncated[KTF_MAX_NAME] = '\0'; + EXPECT_INT_EQ(0, ktf_map_elem_init(&e.foo, jumbokey)); + EXPECT_TRUE(strcmp(e.foo.key, jumbokey_truncated) == 0); +} + +struct mykey { + unsigned long address; + unsigned long size; +}; + +/* Comparison here is to check if k1's address falls in range + * [k2->address, k2->address + k2->size]. Similar compare used in + * ktf_cov to figure out if a function address lies within the function + * code. + */ +static int custom_compare(const char *key1, const char *key2) +{ + struct mykey *k1 = (struct mykey *)key1; + struct mykey *k2 = (struct mykey *)key2; + + if (k1->address < k2->address) + return -1; + if (k1->address >= (k2->address + k2->size)) + return 1; + return 0; +} + +/* --- Verify that opaque keys with custom compare function work --- */ + +TEST(selftest, map_customkey) +{ + const int nelems = 3; + int baseaddr = 1024; + struct ktf_map cm; + struct mykey keys[nelems], search; + struct myelem elems[nelems]; + int i, j; + + ktf_map_init(&cm, custom_compare, NULL); + + /* Ensure we can add entries and then retrieve them via search key. */ + for (i = 0; i < nelems; i++) { + baseaddr += (i << 2); + keys[i].address = baseaddr; + keys[i].size = (i + 1) << 2; + ASSERT_INT_EQ_GOTO(ktf_map_elem_init(&elems[i].foo, + (char *)&keys[i]), + 0, done); + ASSERT_INT_EQ_GOTO(ktf_map_insert(&cm, &elems[i].foo), 0, done); + } + + baseaddr = 1024; + + /* Ensure all search addresses within range of [base address, size] + * find appropriate entries. + */ + for (i = 0; i < nelems; i++) { + baseaddr += (i << 2); + for (j = 0; j < (i + 1) << 2; j++) { + search.address = baseaddr + j; + search.size = 0; + ASSERT_ADDR_EQ_GOTO(ktf_map_find_entry(&cm, + (char *)&search, + struct myelem, + foo), + &elems[i], done); + } + } + +done: + ktf_map_delete_all(&cm); +} + +TEST(selftest, dummy) +{ + /* The default handle does not have any contexts in this test set */ + ASSERT_FALSE(ctx); +} + +TEST(selftest, wrongversion) +{ + tlog(T_INFO, "This test should never have run - wrong version\n!!!"); + EXPECT_TRUE(false); +} + +static void add_map_tests(void) +{ + ADD_TEST(dummy); + ADD_LOOP_TEST(statements, 0, 2); + ADD_TEST_TO(dual_handle, simplemap); + ADD_TEST_TO(dual_handle, mapref); + ADD_TEST_TO(dual_handle, mapcmpfunc); + ADD_TEST(map_keyoverflow); + ADD_TEST(map_customkey); + + terr("-- version check test: --"); + /* This should fail */ + ADD_TEST_TO(wrongversion_handle, wrongversion); +} + +static int probecount; +static int proberet; + +KTF_ENTRY_PROBE(printk, printkhandler) +{ + probecount++; + + KTF_ENTRY_PROBE_RETURN(0); +} + +static int entryarg0, entryarg1; + +KTF_ENTRY_PROBE(probeargtest, probeargtesthandler) +{ + entryarg0 = (int)KTF_ENTRY_PROBE_ARG0; + entryarg1 = (int)KTF_ENTRY_PROBE_ARG1; + KTF_ENTRY_PROBE_RETURN(0); +} + +noinline void probeargtest(int arg0, int arg1) +{ + tlog(T_INFO, "got args %d, %d\n", arg0, arg1); +} + +TEST(selftest, probeentry) +{ + probecount = 0; + ASSERT_INT_EQ(KTF_REGISTER_ENTRY_PROBE(printk, printkhandler), 0); + /* Need T_WARN for unconditional printk() */ + twarn("Testing kprobe entry..."); + ASSERT_INT_GT_GOTO(probecount, 0, done); + ASSERT_INT_EQ_GOTO(KTF_REGISTER_ENTRY_PROBE(probeargtest, + probeargtesthandler), + 0, done); + probeargtest(1, 2); + ASSERT_INT_EQ_GOTO(entryarg0, 1, done); + ASSERT_INT_EQ_GOTO(entryarg1, 2, done); +done: + KTF_UNREGISTER_ENTRY_PROBE(probeargtest, probeargtesthandler); + KTF_UNREGISTER_ENTRY_PROBE(printk, printkhandler); +} + +static int override_failed; + +noinline int myfunc(int i) +{ + override_failed = 1; + return i; +} + +KTF_OVERRIDE(myfunc, myfunc_override) +{ + KTF_SET_RETURN_VALUE(0); + KTF_OVERRIDE_RETURN; +} + +TEST(selftest, override) +{ + override_failed = 0; + + ASSERT_INT_EQ(KTF_REGISTER_OVERRIDE(myfunc, myfunc_override), 0); + + (void)myfunc(0); + + /* Verify override function runs instead. */ + ASSERT_TRUE_GOTO(override_failed == 0, done); + + /* Verify override function modifies return value. */ + ASSERT_INT_EQ_GOTO(myfunc(100), 0, done); + ASSERT_TRUE_GOTO(override_failed == 0, done); +done: + KTF_UNREGISTER_OVERRIDE(myfunc, myfunc_override); +} + +noinline int probesum(int a, int b) +{ + tlog(T_INFO, "Adding %d + %d", a, b); + return a + b; +} + +KTF_RETURN_PROBE(probesum, probesumhandler) +{ + tlog(T_DEBUG, "return value before modifying %ld", + regs_return_value(regs)); + KTF_SET_RETURN_VALUE(-1); + tlog(T_DEBUG, "return value after modifying %ld", + regs_return_value(regs)); + return 0; +} + +KTF_RETURN_PROBE(printk, printkrethandler) +{ + proberet = KTF_RETURN_VALUE(); + + return 0; +} + +TEST(selftest, probereturn) +{ + char *teststr = "Testing kprobe return..."; + + proberet = -1; + ASSERT_INT_EQ_GOTO(KTF_REGISTER_RETURN_PROBE(printk, printkrethandler), + 0, done); + printk(KERN_INFO "%s", teststr); + ASSERT_INT_EQ_GOTO(proberet, strlen(teststr), done); + + /* Now test modification of return value */ + ASSERT_INT_EQ_GOTO(probesum(1, 1), 2, done); + ASSERT_INT_EQ_GOTO(KTF_REGISTER_RETURN_PROBE(probesum, probesumhandler), + 0, done); + ASSERT_INT_EQ_GOTO(probesum(1, 1), -1, done); +done: + KTF_UNREGISTER_RETURN_PROBE(printk, printkrethandler); + KTF_UNREGISTER_RETURN_PROBE(probesum, probesumhandler); +} + +static void add_probe_tests(void) +{ + ADD_TEST(probeentry); + ADD_TEST(probereturn); + ADD_TEST(override); +} + +noinline void cov_counted(void) +{ + tlog(T_INFO, "got called!"); +} + +noinline void *doalloc(struct kmem_cache *c, size_t sz) +{ + if (c) + return kmem_cache_alloc(c, GFP_KERNEL); + return kmalloc(sz, GFP_KERNEL); +} + +TEST(selftest, acov) +{ + /* A very basic test just to enable and disable the coverage support, + * without the memory tracking option and without making use of it: + */ + ASSERT_INT_EQ(0, ktf_cov_enable((THIS_MODULE)->name, 0)); + ktf_cov_disable((THIS_MODULE)->name); +} + +TEST(selftest, cov) +{ + int foundp1 = 0, foundp2 = 0, foundp3 = 0, foundp4 = 0; + struct ktf_cov_entry *e; + struct ktf_cov_mem *m; + char *p1 = NULL, *p2 = NULL, *p3 = NULL, *p4 = NULL; + struct kmem_cache *c = NULL; + int oldcount; + + c = kmem_cache_create("selftest_cov_cache", + 32, 0, + SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL); + + ASSERT_ADDR_NE(NULL, c); + + tlog(T_INFO, "Allocated cache %p : %s %u\n", c, c->name, c->object_size); + ASSERT_INT_EQ(0, ktf_cov_enable((THIS_MODULE)->name, KTF_COV_OPT_MEM)); + + e = ktf_cov_entry_find((unsigned long)cov_counted, 0); + ASSERT_ADDR_NE_GOTO(e, NULL, done); + oldcount = e->count; + ktf_cov_entry_put(e); + cov_counted(); + e = ktf_cov_entry_find((unsigned long)cov_counted, 0); + ASSERT_ADDR_NE_GOTO(e, NULL, done); + if (e) { + ASSERT_INT_EQ(e->count, oldcount + 1); + ktf_cov_entry_put(e); + } + + /* Need to call a noinline fn to do allocs since this test function + * will be inlined; and to track allocations they need to come + * from this module. Don't need to do the same for kfree since + * we check every kfree() to see if it is freeing a tracked allocation. + */ + p1 = doalloc(NULL, 8); + ASSERT_ADDR_NE_GOTO(p1, NULL, done); + p2 = doalloc(NULL, 16); + ASSERT_ADDR_NE_GOTO(p2, NULL, done); + p3 = doalloc(c, 0); + ASSERT_ADDR_NE_GOTO(p3, NULL, done); + p4 = doalloc(c, 0); + ASSERT_ADDR_NE_GOTO(p4, NULL, done); + + ktf_for_each_cov_mem(m) { + if (m->key.address == (unsigned long)p1) + foundp1 = 1; + if (m->key.address == (unsigned long)p2 && m->key.size == 16) + foundp2 = 1; + if (m->key.address == (unsigned long)p3 && m->key.size == 32) + foundp3 = 1; + if (m->key.address == (unsigned long)p4) + foundp4 = 1; + } + ASSERT_INT_EQ_GOTO(foundp1, 1, done); + ASSERT_INT_EQ_GOTO(foundp2, 1, done); + ASSERT_INT_EQ_GOTO(foundp3, 1, done); + ASSERT_INT_EQ_GOTO(foundp4, 1, done); + kfree(p1); + kmem_cache_free(c, p4); + /* Didn't free p2/p3 - should still be on our cov_mem list */ + foundp1 = 0; + foundp2 = 0; + foundp3 = 0; + foundp4 = 0; + ktf_for_each_cov_mem(m) { + if (m->key.address == (unsigned long)p1) + foundp1 = 1; + if (m->key.address == (unsigned long)p2) + foundp2 = 1; + if (m->key.address == (unsigned long)p3) + foundp3 = 1; + if (m->key.address == (unsigned long)p4) + foundp4 = 1; + } + ASSERT_INT_EQ_GOTO(foundp2, 1, done); + ASSERT_INT_EQ_GOTO(foundp3, 1, done); + ASSERT_INT_EQ_GOTO(foundp1, 0, done); + ASSERT_INT_EQ_GOTO(foundp4, 0, done); +done: + kfree(p2); + if (p3) + kmem_cache_free(c, p3); + ktf_cov_disable((THIS_MODULE)->name); + kmem_cache_destroy(c); +} + +static void add_cov_tests(void) +{ + ADD_TEST(acov); + /* We still seem to have some subtle issues with the memory coverage test feature, + * as sometimes allocations made by the coverage framework itself, + * for this particular test survives the cleanup function. + * Whether it is our attempt to test ourselves or a more generic problem + * is not fully understood yet, so disable this test for now: + */ + /* ADD_TEST(cov); */ +} + +KTF_THREAD(test_thread) +{ + /* ensure assertions can work in thread context */ + ASSERT_INT_EQ(1, 1); +} + +#define NUM_TEST_THREADS 20 + +static struct ktf_thread test_threads[NUM_TEST_THREADS]; + +TEST(selftest, thread) +{ + int assertions, i; + + for (i = 0; i < NUM_TEST_THREADS; i++) { + KTF_THREAD_INIT(test_thread, &test_threads[i]); + KTF_THREAD_RUN(&test_threads[i]); + } + for (i = 0; i < NUM_TEST_THREADS; i++) + KTF_THREAD_WAIT_COMPLETED(&test_threads[i]); + + assertions = (int)ktf_get_assertion_count(); + + /* Verify assertion in thread */ + ASSERT_INT_EQ(assertions, NUM_TEST_THREADS); +} + +static void add_thread_tests(void) +{ + ADD_TEST(thread); +} + +static int selftest_module_var; + +/* + * Test that ktf_find_symbol works both for module symbols and + * core kernel symbols: + */ +TEST(selftest, symbol) +{ + /* Verify finding kernel-internal symbol works. */ + ASSERT_ADDR_NE(ktf_find_symbol(NULL, "skbuff_head_cache"), NULL); + + /* Verify finding module symbols works, both when we specify the + * module name and when we don't. + */ + ASSERT_ADDR_EQ(ktf_find_symbol(NULL, "selftest_module_var"), + &selftest_module_var); + + ASSERT_ADDR_EQ(ktf_find_symbol("selftest", "selftest_module_var"), + &selftest_module_var); +} + +static void add_symbol_tests(void) +{ + ADD_TEST(symbol); +} + +static int __init selftest_init(void) +{ + int ret = KTF_CONTEXT_ADD_TO(dual_handle, &s_mctx[1].k, "map1"); + + tlog(T_DEBUG, "map1 gets %d", ret); + if (ret) + return ret; + + ret = KTF_CONTEXT_ADD_TO(dual_handle, &s_mctx[2].k, "map2"); + if (ret) + goto fail; + + ret = KTF_CONTEXT_ADD_TO(single_handle, &s_mctx[3].k, "map3"); + if (ret) + goto fail; + + ktf_resolve_symbols(); + + add_map_tests(); + add_probe_tests(); + add_cov_tests(); + add_thread_tests(); + add_hybrid_tests(); + add_context_tests(); + add_symbol_tests(); + tlog(T_INFO, "selftest: loaded"); + return 0; +fail: + KTF_CLEANUP(); + return ret; +} + +static void __exit selftest_exit(void) +{ + context_tests_cleanup(); + KTF_HANDLE_CLEANUP(single_handle); + KTF_HANDLE_CLEANUP(dual_handle); + KTF_HANDLE_CLEANUP(no_handle); + KTF_CLEANUP(); + tlog(T_INFO, "selftest: unloaded"); +} + +module_init(selftest_init); +module_exit(selftest_exit);

Currently ktf only supports integration with googletest on the user side, but there's nothing that prevents integration towards other user land frameworks for running and reporting, if so desired.

Signed-off-by: Knut Omang knut.omang@oracle.com --- tools/testing/selftests/ktf/lib/ktf_run.cc | 177 ++++++++++++++++++- tools/testing/selftests/ktf/lib/ktf_unlproto.c | 21 ++- 2 files changed, 198 insertions(+) create mode 100644 tools/testing/selftests/ktf/lib/ktf_run.cc create mode 100644 tools/testing/selftests/ktf/lib/ktf_unlproto.c

diff --git a/tools/testing/selftests/ktf/lib/ktf_run.cc b/tools/testing/selftests/ktf/lib/ktf_run.cc new file mode 100644 index 0000000..a26e04c --- /dev/null +++ b/tools/testing/selftests/ktf/lib/ktf_run.cc @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Knut Omang knut.omang@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * ktf_run.cpp: + * Gtest integration of ktf kernel tests - + * e.g. tests that are fully implemented on the test driver side + * and only initiated via run_test below + */ + +#include "ktf_int.h" +#include <assert.h> +#include <errno.h> +#include "ktf_debug.h" + +namespace ktf +{ + +class KernelMetaFactory; + +class Kernel : public ::testing::TestWithParamstd::string +{ +public: + Kernel() + { + assert(false); // Should not be hit but is needed for template resolving + } + + Kernel(std::string& setname, std::string& testname) + { + log(KTF_INFO, "%s.%s\n", setname.c_str(), testname.c_str()); + + ukt = ktf::find_test(setname,testname,&ctx); + if (!ukt) { + fprintf(stderr, "**** Internal error: Could not find test %s.%s (set %s, name %s) ****\n", + setname.c_str(), testname.c_str(), setname.c_str(), testname.c_str()); + exit(7); + } + log(KTF_INFO, "### Kernel ctor %s (%ld,%ld)\n", ukt->name.c_str(), ukt->setnum, ukt->testnum); + } + + virtual ~Kernel() + { + log(KTF_INFO, "### Kernel dtor %s\n", ukt->name.c_str()); + + /* For some reason errno sometimes get set + * TBD: Figure out why - for now just reset it to avoid confusing the next test! + */ + if (errno) { + log(KTF_INFO, "### %s: errno was set to %d - resetting..\n", ukt->name.c_str(), errno); + errno = 0; + } + } + + virtual void TestBody(); +private: + ktf::KernelTest* ukt; + std::string ctx; + friend void setup(configurator c); + static int AddToRegistry(); + static configurator configurator_; +}; + + + +class TFactory : public ::testing::internal::ParameterizedTestFactory<Kernel> +{ +public: + TFactory(std::string s, ParamType parameter) + : ::testing::internal::ParameterizedTestFactory<Kernel>(parameter), + setname(s) + { + testname = parameter.c_str(); + } + + virtual ::testing::Test* CreateTest() + { + return new Kernel(setname,testname); + } + +private: + std::string setname; + std::string testname; +}; + + +class KernelMetaFactory : public ::testing::internal::TestMetaFactory<Kernel> +{ +public: + virtual ::testing::internal::TestFactoryBase* CreateTestFactory(ParamType parameter) { + TFactory* tf; + std::string setname = get_current_setname(); + tf = new TFactory(setname, parameter.c_str()); + return tf; + } +}; + +testing::internal::ParamGeneratorKernel::ParamType gtest_query_tests(void); +std::string gtest_name_from_info(const testing::TestParamInfoKernel::ParamType&); +void gtest_handle_test(int result, const char* file, int line, const char* report); + +#ifndef INSTANTIATE_TEST_SUITE_P +/* This rename happens in Googletest commit 3a460a26b7. + * Make sure we compile both before and after it: + */ +#define AddTestSuiteInstantiation AddTestCaseInstantiation +#endif + +int Kernel::AddToRegistry() +{ + if (!ktf::setup(ktf::gtest_handle_test)) return 1; + + /* Run query against kernel to figure out which tests that exists: */ + stringvec& t = ktf::query_testsets(); + + ::testing::internal::ParameterizedTestCaseInfo<Kernel>* tci = + ::testing::UnitTest::GetInstance()->parameterized_test_registry() + .GetTestCasePatternHolder<Kernel>( "Kernel", ::testing::internal::CodeLocation("", 0)); + + for (stringvec::iterator it = t.begin(); it != t.end(); ++it) + { + ::testing::internal::TestMetaFactory<Kernel>* mf = new KernelMetaFactory(); + tci->AddTestPattern(it->c_str(), "", mf); + } + + tci->AddTestSuiteInstantiation("", &gtest_query_tests, &gtest_name_from_info, NULL, 0); + return 0; +} + +void setup(configurator c) +{ + ktf::set_configurator(c); + Kernel::AddToRegistry(); +} + + +void Kernel::TestBody() +{ + run_test(ukt, ctx); +} + + +void gtest_handle_test(int result, const char* file, int line, const char* report) +{ + if (result >= 0) { + const ::testing::AssertionResult gtest_ar = + !result ? (testing::AssertionFailure() << report) : testing::AssertionSuccess(); + + if (result) { + /* We might get multiple partial results from the kernel in one positive + * result report: + */ +#if HAVE_ASSERT_COUNT + ::testing::UnitTest::GetInstance()->increment_success_assert_count(result); +#else + GTEST_SUCCEED(); +#endif + } else { + ::testing::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure, + file, line, gtest_ar.failure_message()) = ::testing::Message(); + } + } +} + +testing::internal::ParamGeneratorKernel::ParamType gtest_query_tests() +{ + return testing::ValuesIn(ktf::get_test_names()); +} + +std::string gtest_name_from_info(const testing::TestParamInfoKernel::ParamType& info) +{ + return info.param; +} + +} // end namespace ktf diff --git a/tools/testing/selftests/ktf/lib/ktf_unlproto.c b/tools/testing/selftests/ktf/lib/ktf_unlproto.c new file mode 100644 index 0000000..3929b03 --- /dev/null +++ b/tools/testing/selftests/ktf/lib/ktf_unlproto.c @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved. + * Author: Knut Omang knut.omang@oracle.com + * + * SPDX-License-Identifier: GPL-2.0 + * + * unlproto.c: This file is needed because the C struct init + * used in kernel/unlproto.h is not allowed in C++ + */ + +#include <netlink/netlink.h> +#include <netlink/genl/genl.h> +#include <netlink/genl/ctrl.h> +#define NL_INTERNAL 1 +#include "kernel/ktf_unlproto.h" + + +struct nla_policy *ktf_get_gnl_policy(void) +{ + return ktf_gnl_policy; +}

A few simple examples, and example of other test modules to make it easier to get started with ktf.

Signed-off-by: Knut Omang knut.omang@oracle.com --- tools/testing/selftests/ktf/examples/Makefile | 17 ++++- tools/testing/selftests/ktf/examples/h2.c | 45 +++++++++++- tools/testing/selftests/ktf/examples/h3.c | 84 ++++++++++++++++++++- tools/testing/selftests/ktf/examples/h4.c | 62 +++++++++++++++- tools/testing/selftests/ktf/examples/hello.c | 38 +++++++++- tools/testing/selftests/ktf/examples/kgdemo.c | 61 +++++++++++++++- 6 files changed, 307 insertions(+) create mode 100644 tools/testing/selftests/ktf/examples/Makefile create mode 100644 tools/testing/selftests/ktf/examples/h2.c create mode 100644 tools/testing/selftests/ktf/examples/h3.c create mode 100644 tools/testing/selftests/ktf/examples/h4.c create mode 100644 tools/testing/selftests/ktf/examples/hello.c create mode 100644 tools/testing/selftests/ktf/examples/kgdemo.c

diff --git a/tools/testing/selftests/ktf/examples/Makefile b/tools/testing/selftests/ktf/examples/Makefile new file mode 100644 index 0000000..f3cfcc9 --- /dev/null +++ b/tools/testing/selftests/ktf/examples/Makefile @@ -0,0 +1,17 @@ +# Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved. +# +# SPDX-License-Identifier: GPL-2.0 +# +# Kernel module implementing a few simple examples of KTF tests +# + +include $(srctree)/$(src)/../scripts/ktf_syms.mk + +ccflags-y += -I$(srctree)/$(src)/../kernel -I$(src) + +obj-m := hello.o h2.o h3.o h4.o + +ifdef CONFIG_KGDB +obj-m += kgdemo.o +endif + diff --git a/tools/testing/selftests/ktf/examples/h2.c b/tools/testing/selftests/ktf/examples/h2.c new file mode 100644 index 0000000..37a6fbb --- /dev/null +++ b/tools/testing/selftests/ktf/examples/h2.c @@ -0,0 +1,45 @@ +#include <linux/module.h> +#include "ktf.h" + +MODULE_LICENSE("GPL"); + +KTF_INIT(); + +#define MAX_CNT 3 + +struct hello_ctx { + struct ktf_context k; + int value[MAX_CNT]; +}; + +static struct hello_ctx myctx = { .value = { 0, 1, 4 } }; + +TEST(examples, cmp) +{ + struct hello_ctx *hctx = KTF_CONTEXT_GET("value", struct hello_ctx); + + EXPECT_INT_EQ(_i, hctx->value[_i]); +} + +static void add_tests(void) +{ + ADD_LOOP_TEST(cmp, 0, MAX_CNT); +} + +static int __init hello_init(void) +{ + KTF_CONTEXT_ADD(&myctx.k, "value"); + add_tests(); + return 0; +} + +static void __exit hello_exit(void) +{ + struct ktf_context *kctx = KTF_CONTEXT_FIND("value"); + + KTF_CONTEXT_REMOVE(kctx); + KTF_CLEANUP(); +} + +module_init(hello_init); +module_exit(hello_exit); diff --git a/tools/testing/selftests/ktf/examples/h3.c b/tools/testing/selftests/ktf/examples/h3.c new file mode 100644 index 0000000..a6aca98 --- /dev/null +++ b/tools/testing/selftests/ktf/examples/h3.c @@ -0,0 +1,84 @@ +#include <linux/module.h> +#include "ktf.h" + +MODULE_LICENSE("GPL"); + +KTF_INIT(); + +DECLARE_F(hello_fixture) + struct list_head head; +}; + +struct my_element { + struct list_head list; + int value; +}; + +SETUP_F(hello_fixture, hello_setup) +{ + int i; + + INIT_LIST_HEAD(&hello_fixture->head); + for (i = 0; i < 10; i++) { + struct my_element *e = kzalloc(sizeof(*e), GFP_KERNEL); + + e->value = i; + list_add_tail(&e->list, &hello_fixture->head); + } + hello_fixture->ok = true; +} + +TEARDOWN_F(hello_fixture, hello_teardown) +{ + struct list_head *p, *next_p; + + /* Just cleanup whatever is left after the test */ + list_for_each_safe(p, next_p, &hello_fixture->head) { + struct my_element *e = list_entry(p, struct my_element, list); + + list_del(&e->list); + kfree(e); + } + EXPECT_TRUE(list_empty(&hello_fixture->head)); +} + +INIT_F(hello_fixture, hello_setup, hello_teardown); + +TEST_F(hello_fixture, examples, hello_del) +{ + int cnt = 0; + int cnt_ones = 0; + struct my_element *e = kzalloc(sizeof(*e), GFP_KERNEL); + + e->value = 1; + list_add(&e->list, &ctx->head); + + list_for_each_entry(e, &ctx->head, list) { + if (e->value == 1) + cnt_ones++; + cnt++; + } + EXPECT_INT_EQ(11, cnt); + EXPECT_INT_EQ(2, cnt_ones); +} + +static void add_tests(void) +{ + ADD_TEST(hello_del); +} + +static int __init hello_init(void) +{ + add_tests(); + tlog(T_INFO, "hello: loaded"); + return 0; +} + +static void __exit hello_exit(void) +{ + KTF_CLEANUP(); + tlog(T_INFO, "hello: unloaded"); +} + +module_init(hello_init); +module_exit(hello_exit); diff --git a/tools/testing/selftests/ktf/examples/h4.c b/tools/testing/selftests/ktf/examples/h4.c new file mode 100644 index 0000000..3e85fef --- /dev/null +++ b/tools/testing/selftests/ktf/examples/h4.c @@ -0,0 +1,62 @@ +#include <linux/module.h> +#include "ktf.h" + +MODULE_LICENSE("GPL"); + +KTF_INIT(); + +static int count; +static int ret; + +KTF_ENTRY_PROBE(printk, printkhandler) +{ + count++; + + KTF_ENTRY_PROBE_RETURN(0); +} + +TEST(examples, entrycheck) +{ + count = 0; + ASSERT_INT_EQ_GOTO(KTF_REGISTER_ENTRY_PROBE(printk, printkhandler), + 0, done); + printk(KERN_INFO "Testing kprobe entry..."); + ASSERT_INT_GT_GOTO(count, 0, done); +done: + KTF_UNREGISTER_ENTRY_PROBE(printk, printkhandler); +} + +KTF_RETURN_PROBE(printk, printkrethandler) +{ + ret = KTF_RETURN_VALUE(); + + return 0; +} + +TEST(examples, returncheck) +{ + char *teststr = "Testing kprobe return..."; + + ret = -1; + ASSERT_INT_EQ_GOTO(KTF_REGISTER_RETURN_PROBE(printk, printkrethandler), + 0, done); + printk(KERN_INFO "%s", teststr); + ASSERT_INT_EQ_GOTO(ret, strlen(teststr), done); +done: + KTF_UNREGISTER_RETURN_PROBE(printk, printkrethandler); +} + +static int __init hello_init(void) +{ + ADD_TEST(entrycheck); + ADD_TEST(returncheck); + return 0; +} + +static void __exit hello_exit(void) +{ + KTF_CLEANUP(); +} + +module_init(hello_init); +module_exit(hello_exit); diff --git a/tools/testing/selftests/ktf/examples/hello.c b/tools/testing/selftests/ktf/examples/hello.c new file mode 100644 index 0000000..9c4713f --- /dev/null +++ b/tools/testing/selftests/ktf/examples/hello.c @@ -0,0 +1,38 @@ +#include <linux/module.h> +#include "ktf.h" + +MODULE_LICENSE("GPL"); + +KTF_INIT(); + +TEST(examples, hello_ok) +{ + EXPECT_TRUE(true); +} + +TEST(examples, hello_fail) +{ + EXPECT_TRUE(false); +} + +static void add_tests(void) +{ + ADD_TEST(hello_ok); + ADD_TEST(hello_fail); +} + +static int __init hello_init(void) +{ + add_tests(); + tlog(T_INFO, "hello: loaded"); + return 0; +} + +static void __exit hello_exit(void) +{ + KTF_CLEANUP(); + tlog(T_INFO, "hello: unloaded"); +} + +module_init(hello_init); +module_exit(hello_exit); diff --git a/tools/testing/selftests/ktf/examples/kgdemo.c b/tools/testing/selftests/ktf/examples/kgdemo.c new file mode 100644 index 0000000..9ce19ff --- /dev/null +++ b/tools/testing/selftests/ktf/examples/kgdemo.c @@ -0,0 +1,61 @@ +#include <linux/module.h> +#include "ktf.h" + +/* + * A trivial and somewhat rough example used by the author + * for pedagogical purposes, to demonstrate + * interactive debugging with kgdb. + * + * Requires a kernel built with CONFIG_KGDB + * + * Note: these test breaks into kgdb and/or creates a NULL + * pointer exception and corresponding stack dump, so + * try out in a test environment only! + */ + +MODULE_LICENSE("GPL"); + +KTF_INIT(); + +#define MAX_CNT 3 +#include <linux/kgdb.h> + +static int kgdemo_cnt; +static int *bogus_ref; + +TEST(kgdb, breakpoint) +{ + kgdemo_cnt = 0; + printk(KERN_INFO "** Please set kgdemo_cnt = 1 **\n"); + kgdb_breakpoint(); + EXPECT_INT_EQ(1, kgdemo_cnt); +} + +TEST(kgdb, nullpointer) +{ + int pre = kgdemo_cnt; + + int b = *bogus_ref++; + + EXPECT_INT_EQ(pre + 1, b); +} + +static void add_tests(void) +{ + ADD_TEST(breakpoint); + ADD_TEST(nullpointer); +} + +static int __init kgdemo_init(void) +{ + add_tests(); + return 0; +} + +static void __exit kgdemo_exit(void) +{ + KTF_CLEANUP(); +} + +module_init(kgdemo_init); +module_exit(kgdemo_exit);

Signed-off-by: Knut Omang knut.omang@oracle.com --- tools/testing/selftests/ktf/Makefile | 21 ++++- tools/testing/selftests/ktf/scripts/ktf_syms.mk | 16 +++- tools/testing/selftests/ktf/scripts/runtests.mk | 3 +- tools/testing/selftests/ktf/scripts/runtests.sh | 100 +++++++++++++++++- tools/testing/selftests/ktf/scripts/top_make.mk | 14 ++- 5 files changed, 154 insertions(+) create mode 100644 tools/testing/selftests/ktf/Makefile create mode 100644 tools/testing/selftests/ktf/scripts/ktf_syms.mk create mode 100644 tools/testing/selftests/ktf/scripts/runtests.mk create mode 100755 tools/testing/selftests/ktf/scripts/runtests.sh create mode 100644 tools/testing/selftests/ktf/scripts/top_make.mk

diff --git a/tools/testing/selftests/ktf/Makefile b/tools/testing/selftests/ktf/Makefile new file mode 100644 index 0000000..0fef39c --- /dev/null +++ b/tools/testing/selftests/ktf/Makefile @@ -0,0 +1,21 @@ + +ifneq ($(TARGETS),) +# We end up here if called from selftests/Makefile +# Invoke our "module target" to get everything built +all: + $(Q)$(MAKE) -C $(abs_objtree) M=tools/testing/selftests/ktf + +clean: + $(Q)$(MAKE) -C $(abs_objtree) M=tools/testing/selftests/ktf clean + +run_tests: + @echo "running tests" + $(MAKE) BUILD=$(abs_objtree)/tools/testing/selftests -f scripts/runtests.mk $@ + +endif +obj-m += kernel/ +obj-m += selftest/ +obj-m += examples/ +obj-m += lib/ +obj-m += user/ + diff --git a/tools/testing/selftests/ktf/scripts/ktf_syms.mk b/tools/testing/selftests/ktf/scripts/ktf_syms.mk new file mode 100644 index 0000000..a332223 --- /dev/null +++ b/tools/testing/selftests/ktf/scripts/ktf_syms.mk @@ -0,0 +1,16 @@ +ktf_symfile=$(shell (cd $(srctree)/$(src) && ls ktf_syms.txt 2> /dev/null || true)) +ktf_syms = $(ktf_symfile:%.txt=%.h) + +ifneq ($(ktf_symfile),) + +$(obj)/self.o: $(obj)/$(ktf_syms) + +ktf_scripts = $(srctree)/$(src)/../scripts + +$(obj)/$(ktf_syms): $(srctree)/$(src)/ktf_syms.txt $(ktf_scripts)/resolve + @echo " KTFSYMS $@" + $(Q)$(ktf_scripts)/resolve $(ccflags-y) $< $@ + +clean-files += $(ktf_syms) + +endif diff --git a/tools/testing/selftests/ktf/scripts/runtests.mk b/tools/testing/selftests/ktf/scripts/runtests.mk new file mode 100644 index 0000000..7fd3651 --- /dev/null +++ b/tools/testing/selftests/ktf/scripts/runtests.mk @@ -0,0 +1,3 @@ +TEST_PROGS := scripts/runtests.sh + +include ../lib.mk diff --git a/tools/testing/selftests/ktf/scripts/runtests.sh b/tools/testing/selftests/ktf/scripts/runtests.sh new file mode 100755 index 0000000..3396aec --- /dev/null +++ b/tools/testing/selftests/ktf/scripts/runtests.sh @@ -0,0 +1,100 @@ +#!/bin/bash -e + +verbose=1 + +# Convenience function to return a string that +# is a reverse list of the incoming arguments: +# +reverse() +{ + args=($*) + for (( i=((${#args[*]} - 1)); i >= 0; i-- )); do + echo ${args[$i]} + done +} + +# Set paths to a particular module - if no path is set to a module, use modprobe: +# +declare -A a_mpath +mpath() +{ + local module="$1" + local mpath="$2" + [[ $mpath != "" ]] || fail "Usage: mpath module path" + + a_mpath[$module]="$BUILD/$mpath" +} + +# Set parameters to load a given module with for test purposes: +declare -A a_params +params() +{ + local module="$1" + shift + a_params[$module]="$*" +} + +log() +{ + (( $verbose )) && echo $* +} + +mod_probe() +{ + local fm="" + local name="$1" + shift + + mp=${a_mpath[$name]} + if [[ $mp != "" ]]; then + fm="$mp" + fi + + is_loaded=$(lsmod | egrep "^$name" || true) + if [[ $is_loaded != "" ]]; then + echo "Module "$name" is already loaded!" 1>&2 + return 0 + fi + + if [[ $fm == "" ]]; then + log "Modprobing $name" + $sudo modprobe $name ${a_params[$name]} + else + fm=${a_mpath[$name]} + log "Insmod'ing module "$name"" 1>&2 + $sudo insmod $fm ${a_params[$name]} + fi +} + +# If/when more modules are to be loaded, this could go in a config file +# but for the purpose of this example, just do it inline: +# +mpath ktf ktf/kernel/ktf.ko +mpath selftest ktf/selftest/selftest.ko + +load_modules="ktf selftest" + +unload_modules=$(reverse $load_modules) + +sudo="" +if [[ $USER != "root" ]]; then + sudo="sudo" +fi + +for m in $load_modules; do + mod_probe $m +done + +if [[ $GTEST_PATH == "" ]];then + echo "Set environment variable GTEST_PATH to point to your googletest build!" + exit 1 +fi + +export LD_LIBRARY_PATH="$BUILD/ktf/lib:$GTEST_PATH/lib64:$GTEST_PATH/lib" +$BUILD/ktf/user/ktftest || stat=$? + +for m in $unload_modules; do + $sudo rmmod $m +done + +exit $stat diff --git a/tools/testing/selftests/ktf/scripts/top_make.mk b/tools/testing/selftests/ktf/scripts/top_make.mk new file mode 100644 index 0000000..978068e --- /dev/null +++ b/tools/testing/selftests/ktf/scripts/top_make.mk @@ -0,0 +1,14 @@ +ifneq ($(TARGETS),) +# We end up here if called from selftests/Makefile +# Invoke our "module target" to get everything built +all: + $(Q)$(MAKE) -C $(abs_objtree) M=tools/testing/selftests/ktf + +clean: + $(Q)$(MAKE) -C $(abs_objtree) M=tools/testing/selftests/ktf clean + +run_tests: + @echo "running tests" + $(MAKE) BUILD=$(abs_objtree)/tools/testing/selftests -f scripts/runtests.mk $@ + +endif

Signed-off-by: Knut Omang knut.omang@oracle.com --- Documentation/dev-tools/index.rst | 1 + 1 file changed, 1 insertion(+)

diff --git a/Documentation/dev-tools/index.rst b/Documentation/dev-tools/index.rst index b0522a4..f155205 100644 --- a/Documentation/dev-tools/index.rst +++ b/Documentation/dev-tools/index.rst @@ -24,6 +24,7 @@ whole; patches welcome! gdb-kernel-debugging kgdb kselftest + ktf/index

.. only:: subproject and html