kernel_5.10 no rt

hc

2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f

 kernel/lib/test_ubsan.c
..
..
@@ -5,79 +5,78 @@
5
5
 
6
6
 typedef void(*test_ubsan_fp)(void);
7
7
 
8
-static void test_ubsan_add_overflow(void)
9
-{
10
-	volatile int val = INT_MAX;
11
-
12
-	val += 2;
13
-}
14
-
15
-static void test_ubsan_sub_overflow(void)
16
-{
17
-	volatile int val = INT_MIN;
18
-	volatile int val2 = 2;
19
-
20
-	val -= val2;
21
-}
22
-
23
-static void test_ubsan_mul_overflow(void)
24
-{
25
-	volatile int val = INT_MAX / 2;
26
-
27
-	val *= 3;
28
-}
29
-
30
-static void test_ubsan_negate_overflow(void)
31
-{
32
-	volatile int val = INT_MIN;
33
-
34
-	val = -val;
35
-}
8
+#define UBSAN_TEST(config, ...)	do {					\
9
+		pr_info("%s " __VA_ARGS__ "%s(%s=%s)\n", __func__,	\
10
+			sizeof(" " __VA_ARGS__) > 2 ? " " : "",		\
11
+			#config, IS_ENABLED(config) ? "y" : "n");	\
12
+	} while (0)
36
13
 
37
14
 static void test_ubsan_divrem_overflow(void)
38
15
 {
39
16
 	volatile int val = 16;
40
17
 	volatile int val2 = 0;
41
18
 
19
+	UBSAN_TEST(CONFIG_UBSAN_DIV_ZERO);
42
20
 	val /= val2;
43
-}
44
-
45
-static void test_ubsan_vla_bound_not_positive(void)
46
-{
47
-	volatile int size = -1;
48
-	char buf[size];
49
-
50
-	(void)buf;
51
21
 }
52
22
 
53
23
 static void test_ubsan_shift_out_of_bounds(void)
54
24
 {
55
-	volatile int val = -1;
56
-	int val2 = 10;
25
+	volatile int neg = -1, wrap = 4;
26
+	int val1 = 10;
27
+	int val2 = INT_MAX;
57
28
 
58
-	val2 <<= val;
29
+	UBSAN_TEST(CONFIG_UBSAN_SHIFT, "negative exponent");
30
+	val1 <<= neg;
31
+
32
+	UBSAN_TEST(CONFIG_UBSAN_SHIFT, "left overflow");
33
+	val2 <<= wrap;
59
34
 }
60
35
 
61
36
 static void test_ubsan_out_of_bounds(void)
62
37
 {
63
-	volatile int i = 4, j = 5;
64
-	volatile int arr[i];
38
+	volatile int i = 4, j = 5, k = -1;
39
+	volatile char above[4] = { }; /* Protect surrounding memory. */
40
+	volatile int arr[4];
41
+	volatile char below[4] = { }; /* Protect surrounding memory. */
65
42
 
43
+	above[0] = below[0];
44
+
45
+	UBSAN_TEST(CONFIG_UBSAN_BOUNDS, "above");
66
46
 	arr[j] = i;
47
+
48
+	UBSAN_TEST(CONFIG_UBSAN_BOUNDS, "below");
49
+	arr[k] = i;
67
50
 }
51
+
52
+enum ubsan_test_enum {
53
+	UBSAN_TEST_ZERO = 0,
54
+	UBSAN_TEST_ONE,
55
+	UBSAN_TEST_MAX,
56
+};
68
57
 
69
58
 static void test_ubsan_load_invalid_value(void)
70
59
 {
71
60
 	volatile char *dst, *src;
72
61
 	bool val, val2, *ptr;
73
-	char c = 4;
62
+	enum ubsan_test_enum eval, eval2, *eptr;
63
+	unsigned char c = 0xff;
74
64
 
65
+	UBSAN_TEST(CONFIG_UBSAN_BOOL, "bool");
75
66
 	dst = (char *)&val;
76
67
 	src = &c;
77
68
 	*dst = *src;
78
69
 
79
70
 	ptr = &val2;
80
71
 	val2 = val;
72
+
73
+	UBSAN_TEST(CONFIG_UBSAN_ENUM, "enum");
74
+	dst = (char *)&eval;
75
+	src = &c;
76
+	*dst = *src;
77
+
78
+	eptr = &eval2;
79
+	eval2 = eval;
81
80
 }
82
81
 
83
82
 static void test_ubsan_null_ptr_deref(void)
..
..
@@ -85,6 +84,7 @@
85
84
 	volatile int *ptr = NULL;
86
85
 	int val;
87
86
 
87
+	UBSAN_TEST(CONFIG_UBSAN_OBJECT_SIZE);
88
88
 	val = *ptr;
89
89
 }
90
90
 
..
..
@@ -93,33 +93,22 @@
93
93
 	volatile char arr[5] __aligned(4) = {1, 2, 3, 4, 5};
94
94
 	volatile int *ptr, val = 6;
95
95
 
96
+	UBSAN_TEST(CONFIG_UBSAN_ALIGNMENT);
96
97
 	ptr = (int *)(arr + 1);
97
98
 	*ptr = val;
98
99
 }
99
100
 
100
-static void test_ubsan_object_size_mismatch(void)
101
-{
102
-	/* "((aligned(8)))" helps this not into be misaligned for ptr-access. */
103
-	volatile int val __aligned(8) = 4;
104
-	volatile long long *ptr, val2;
105
-
106
-	ptr = (long long *)&val;
107
-	val2 = *ptr;
108
-}
109
-
110
101
 static const test_ubsan_fp test_ubsan_array[] = {
111
-	test_ubsan_add_overflow,
112
-	test_ubsan_sub_overflow,
113
-	test_ubsan_mul_overflow,
114
-	test_ubsan_negate_overflow,
115
-	test_ubsan_divrem_overflow,
116
-	test_ubsan_vla_bound_not_positive,
117
102
 	test_ubsan_shift_out_of_bounds,
118
103
 	test_ubsan_out_of_bounds,
119
104
 	test_ubsan_load_invalid_value,
120
-	//test_ubsan_null_ptr_deref, /* exclude it because there is a crash */
121
105
 	test_ubsan_misaligned_access,
122
-	test_ubsan_object_size_mismatch,
106
+};
107
+
108
+/* Excluded because they Oops the module. */
109
+static const test_ubsan_fp skip_ubsan_array[] = {
110
+	test_ubsan_divrem_overflow,
111
+	test_ubsan_null_ptr_deref,
123
112
 };
124
113
 
125
114
 static int __init test_ubsan_init(void)
..
..
@@ -129,7 +118,6 @@
129
118
 	for (i = 0; i < ARRAY_SIZE(test_ubsan_array); i++)
130
119
 		test_ubsan_array[i]();
131
120
 
132
-	(void)test_ubsan_null_ptr_deref; /* to avoid unsed-function warning */
133
121
 	return 0;
134
122
 }
135
123
 module_init(test_ubsan_init);