aboutsummaryrefslogtreecommitdiffstats
path: root/kernel/kcsan/test.c
blob: d26a052d338383bc9e037393148897a097ec616c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
// SPDX-License-Identifier: GPL-2.0

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/printk.h>
#include <linux/random.h>
#include <linux/types.h>

#include "encoding.h"

#define ITERS_PER_TEST 2000

/* Test requirements. */
static bool test_requires(void)
{
	/* random should be initialized for the below tests */
	return prandom_u32() + prandom_u32() != 0;
}

/*
 * Test watchpoint encode and decode: check that encoding some access's info,
 * and then subsequent decode preserves the access's info.
 */
static bool test_encode_decode(void)
{
	int i;

	for (i = 0; i < ITERS_PER_TEST; ++i) {
		size_t size = prandom_u32_max(MAX_ENCODABLE_SIZE) + 1;
		bool is_write = !!prandom_u32_max(2);
		unsigned long addr;

		prandom_bytes(&addr, sizeof(addr));
		if (WARN_ON(!check_encodable(addr, size)))
			return false;

		/* Encode and decode */
		{
			const long encoded_watchpoint =
				encode_watchpoint(addr, size, is_write);
			unsigned long verif_masked_addr;
			size_t verif_size;
			bool verif_is_write;

			/* Check special watchpoints */
			if (WARN_ON(decode_watchpoint(
				    INVALID_WATCHPOINT, &verif_masked_addr,
				    &verif_size, &verif_is_write)))
				return false;
			if (WARN_ON(decode_watchpoint(
				    CONSUMED_WATCHPOINT, &verif_masked_addr,
				    &verif_size, &verif_is_write)))
				return false;

			/* Check decoding watchpoint returns same data */
			if (WARN_ON(!decode_watchpoint(
				    encoded_watchpoint, &verif_masked_addr,
				    &verif_size, &verif_is_write)))
				return false;
			if (WARN_ON(verif_masked_addr !=
				    (addr & WATCHPOINT_ADDR_MASK)))
				goto fail;
			if (WARN_ON(verif_size != size))
				goto fail;
			if (WARN_ON(is_write != verif_is_write))
				goto fail;

			continue;
fail:
			pr_err("%s fail: %s %zu bytes @ %lx -> encoded: %lx -> %s %zu bytes @ %lx\n",
			       __func__, is_write ? "write" : "read", size,
			       addr, encoded_watchpoint,
			       verif_is_write ? "write" : "read", verif_size,
			       verif_masked_addr);
			return false;
		}
	}

	return true;
}

/* Test access matching function. */
static bool test_matching_access(void)
{
	if (WARN_ON(!matching_access(10, 1, 10, 1)))
		return false;
	if (WARN_ON(!matching_access(10, 2, 11, 1)))
		return false;
	if (WARN_ON(!matching_access(10, 1, 9, 2)))
		return false;
	if (WARN_ON(matching_access(10, 1, 11, 1)))
		return false;
	if (WARN_ON(matching_access(9, 1, 10, 1)))
		return false;

	/*
	 * An access of size 0 could match another access, as demonstrated here.
	 * Rather than add more comparisons to 'matching_access()', which would
	 * end up in the fast-path for *all* checks, check_access() simply
	 * returns for all accesses of size 0.
	 */
	if (WARN_ON(!matching_access(8, 8, 12, 0)))
		return false;

	return true;
}

static int __init kcsan_selftest(void)
{
	int passed = 0;
	int total = 0;

#define RUN_TEST(do_test)                                                      \
	do {                                                                   \
		++total;                                                       \
		if (do_test())                                                 \
			++passed;                                              \
		else                                                           \
			pr_err("KCSAN selftest: " #do_test " failed");         \
	} while (0)

	RUN_TEST(test_requires);
	RUN_TEST(test_encode_decode);
	RUN_TEST(test_matching_access);

	pr_info("KCSAN selftest: %d/%d tests passed\n", passed, total);
	if (passed != total)
		panic("KCSAN selftests failed");
	return 0;
}
postcore_initcall(kcsan_selftest);

Privacy Policy