1 // SPDX-License-Identifier: GPL-2.0-or-later O 1 // SPDX-License-Identifier: GPL-2.0-or-later OR copyleft-next-0.3.1
2 /* 2 /*
3 * proc sysctl test driver 3 * proc sysctl test driver
4 * 4 *
5 * Copyright (C) 2017 Luis R. Rodriguez <mcgro 5 * Copyright (C) 2017 Luis R. Rodriguez <mcgrof@kernel.org>
6 */ 6 */
7 7
8 /* 8 /*
9 * This module provides an interface to the pr 9 * This module provides an interface to the proc sysctl interfaces. This
10 * driver requires CONFIG_PROC_SYSCTL. It will 10 * driver requires CONFIG_PROC_SYSCTL. It will not normally be loaded by the
11 * system unless explicitly requested by name. 11 * system unless explicitly requested by name. You can also build this driver
12 * into your kernel. 12 * into your kernel.
13 */ 13 */
14 14
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 16
17 #include <linux/init.h> 17 #include <linux/init.h>
18 #include <linux/list.h> 18 #include <linux/list.h>
19 #include <linux/module.h> 19 #include <linux/module.h>
20 #include <linux/printk.h> 20 #include <linux/printk.h>
21 #include <linux/fs.h> 21 #include <linux/fs.h>
22 #include <linux/miscdevice.h> 22 #include <linux/miscdevice.h>
23 #include <linux/slab.h> 23 #include <linux/slab.h>
24 #include <linux/uaccess.h> 24 #include <linux/uaccess.h>
25 #include <linux/async.h> 25 #include <linux/async.h>
26 #include <linux/delay.h> 26 #include <linux/delay.h>
27 #include <linux/vmalloc.h> 27 #include <linux/vmalloc.h>
28 28
29 static int i_zero; 29 static int i_zero;
30 static int i_one_hundred = 100; 30 static int i_one_hundred = 100;
31 static int match_int_ok = 1; 31 static int match_int_ok = 1;
32 32
33 33
34 static struct { 34 static struct {
35 struct ctl_table_header *test_h_setup_ 35 struct ctl_table_header *test_h_setup_node;
36 struct ctl_table_header *test_h_mnt; 36 struct ctl_table_header *test_h_mnt;
37 struct ctl_table_header *test_h_mnterr 37 struct ctl_table_header *test_h_mnterror;
38 struct ctl_table_header *empty_add; 38 struct ctl_table_header *empty_add;
39 struct ctl_table_header *empty; 39 struct ctl_table_header *empty;
40 } sysctl_test_headers; 40 } sysctl_test_headers;
41 41
42 struct test_sysctl_data { 42 struct test_sysctl_data {
43 int int_0001; 43 int int_0001;
44 int int_0002; 44 int int_0002;
45 int int_0003[4]; 45 int int_0003[4];
46 46
47 int boot_int; 47 int boot_int;
48 48
49 unsigned int uint_0001; 49 unsigned int uint_0001;
50 50
51 char string_0001[65]; 51 char string_0001[65];
52 52
53 #define SYSCTL_TEST_BITMAP_SIZE 65536 53 #define SYSCTL_TEST_BITMAP_SIZE 65536
54 unsigned long *bitmap_0001; 54 unsigned long *bitmap_0001;
55 }; 55 };
56 56
57 static struct test_sysctl_data test_data = { 57 static struct test_sysctl_data test_data = {
58 .int_0001 = 60, 58 .int_0001 = 60,
59 .int_0002 = 1, 59 .int_0002 = 1,
60 60
61 .int_0003[0] = 0, 61 .int_0003[0] = 0,
62 .int_0003[1] = 1, 62 .int_0003[1] = 1,
63 .int_0003[2] = 2, 63 .int_0003[2] = 2,
64 .int_0003[3] = 3, 64 .int_0003[3] = 3,
65 65
66 .boot_int = 0, 66 .boot_int = 0,
67 67
68 .uint_0001 = 314, 68 .uint_0001 = 314,
69 69
70 .string_0001 = "(none)", 70 .string_0001 = "(none)",
71 }; 71 };
72 72
73 /* These are all under /proc/sys/debug/test_sy 73 /* These are all under /proc/sys/debug/test_sysctl/ */
74 static struct ctl_table test_table[] = { 74 static struct ctl_table test_table[] = {
75 { 75 {
76 .procname = "int_0001", 76 .procname = "int_0001",
77 .data = &test_data.i 77 .data = &test_data.int_0001,
78 .maxlen = sizeof(int), 78 .maxlen = sizeof(int),
79 .mode = 0644, 79 .mode = 0644,
80 .proc_handler = proc_dointve 80 .proc_handler = proc_dointvec_minmax,
81 .extra1 = &i_zero, 81 .extra1 = &i_zero,
82 .extra2 = &i_one_hundr 82 .extra2 = &i_one_hundred,
83 }, 83 },
84 { 84 {
85 .procname = "int_0002", 85 .procname = "int_0002",
86 .data = &test_data.i 86 .data = &test_data.int_0002,
87 .maxlen = sizeof(int), 87 .maxlen = sizeof(int),
88 .mode = 0644, 88 .mode = 0644,
89 .proc_handler = proc_dointve 89 .proc_handler = proc_dointvec,
90 }, 90 },
91 { 91 {
92 .procname = "int_0003", 92 .procname = "int_0003",
93 .data = &test_data.i 93 .data = &test_data.int_0003,
94 .maxlen = sizeof(test_ 94 .maxlen = sizeof(test_data.int_0003),
95 .mode = 0644, 95 .mode = 0644,
96 .proc_handler = proc_dointve 96 .proc_handler = proc_dointvec,
97 }, 97 },
98 { 98 {
99 .procname = "match_int", 99 .procname = "match_int",
100 .data = &match_int_o 100 .data = &match_int_ok,
101 .maxlen = sizeof(match 101 .maxlen = sizeof(match_int_ok),
102 .mode = 0444, 102 .mode = 0444,
103 .proc_handler = proc_dointve 103 .proc_handler = proc_dointvec,
104 }, 104 },
105 { 105 {
106 .procname = "boot_int", 106 .procname = "boot_int",
107 .data = &test_data.b 107 .data = &test_data.boot_int,
108 .maxlen = sizeof(test_ 108 .maxlen = sizeof(test_data.boot_int),
109 .mode = 0644, 109 .mode = 0644,
110 .proc_handler = proc_dointve 110 .proc_handler = proc_dointvec,
111 .extra1 = SYSCTL_ZERO, 111 .extra1 = SYSCTL_ZERO,
112 .extra2 = SYSCTL_ONE, 112 .extra2 = SYSCTL_ONE,
113 }, 113 },
114 { 114 {
115 .procname = "uint_0001", 115 .procname = "uint_0001",
116 .data = &test_data.u 116 .data = &test_data.uint_0001,
117 .maxlen = sizeof(unsig 117 .maxlen = sizeof(unsigned int),
118 .mode = 0644, 118 .mode = 0644,
119 .proc_handler = proc_douintv 119 .proc_handler = proc_douintvec,
120 }, 120 },
121 { 121 {
122 .procname = "string_0001 122 .procname = "string_0001",
123 .data = &test_data.s 123 .data = &test_data.string_0001,
124 .maxlen = sizeof(test_ 124 .maxlen = sizeof(test_data.string_0001),
125 .mode = 0644, 125 .mode = 0644,
126 .proc_handler = proc_dostrin 126 .proc_handler = proc_dostring,
127 }, 127 },
128 { 128 {
129 .procname = "bitmap_0001 129 .procname = "bitmap_0001",
130 .data = &test_data.b 130 .data = &test_data.bitmap_0001,
131 .maxlen = SYSCTL_TEST_ 131 .maxlen = SYSCTL_TEST_BITMAP_SIZE,
132 .mode = 0644, 132 .mode = 0644,
133 .proc_handler = proc_do_larg 133 .proc_handler = proc_do_large_bitmap,
134 }, 134 },
135 }; 135 };
136 136
137 static void test_sysctl_calc_match_int_ok(void 137 static void test_sysctl_calc_match_int_ok(void)
138 { 138 {
139 int i; 139 int i;
140 140
141 struct { 141 struct {
142 int defined; 142 int defined;
143 int wanted; 143 int wanted;
144 } match_int[] = { 144 } match_int[] = {
145 {.defined = *(int *)SYSCTL_ZER 145 {.defined = *(int *)SYSCTL_ZERO, .wanted = 0},
146 {.defined = *(int *)SYSCTL_ONE 146 {.defined = *(int *)SYSCTL_ONE, .wanted = 1},
147 {.defined = *(int *)SYSCTL_TWO 147 {.defined = *(int *)SYSCTL_TWO, .wanted = 2},
148 {.defined = *(int *)SYSCTL_THR 148 {.defined = *(int *)SYSCTL_THREE, .wanted = 3},
149 {.defined = *(int *)SYSCTL_FOU 149 {.defined = *(int *)SYSCTL_FOUR, .wanted = 4},
150 {.defined = *(int *)SYSCTL_ONE 150 {.defined = *(int *)SYSCTL_ONE_HUNDRED, .wanted = 100},
151 {.defined = *(int *)SYSCTL_TWO 151 {.defined = *(int *)SYSCTL_TWO_HUNDRED, .wanted = 200},
152 {.defined = *(int *)SYSCTL_ONE 152 {.defined = *(int *)SYSCTL_ONE_THOUSAND, .wanted = 1000},
153 {.defined = *(int *)SYSCTL_THR 153 {.defined = *(int *)SYSCTL_THREE_THOUSAND, .wanted = 3000},
154 {.defined = *(int *)SYSCTL_INT 154 {.defined = *(int *)SYSCTL_INT_MAX, .wanted = INT_MAX},
155 {.defined = *(int *)SYSCTL_MAX 155 {.defined = *(int *)SYSCTL_MAXOLDUID, .wanted = 65535},
156 {.defined = *(int *)SYSCTL_NEG 156 {.defined = *(int *)SYSCTL_NEG_ONE, .wanted = -1},
157 }; 157 };
158 158
159 for (i = 0; i < ARRAY_SIZE(match_int); 159 for (i = 0; i < ARRAY_SIZE(match_int); i++)
160 if (match_int[i].defined != ma 160 if (match_int[i].defined != match_int[i].wanted)
161 match_int_ok = 0; 161 match_int_ok = 0;
162 } 162 }
163 163
164 static int test_sysctl_setup_node_tests(void) 164 static int test_sysctl_setup_node_tests(void)
165 { 165 {
166 test_sysctl_calc_match_int_ok(); 166 test_sysctl_calc_match_int_ok();
167 test_data.bitmap_0001 = kzalloc(SYSCTL 167 test_data.bitmap_0001 = kzalloc(SYSCTL_TEST_BITMAP_SIZE/8, GFP_KERNEL);
168 if (!test_data.bitmap_0001) 168 if (!test_data.bitmap_0001)
169 return -ENOMEM; 169 return -ENOMEM;
170 sysctl_test_headers.test_h_setup_node 170 sysctl_test_headers.test_h_setup_node = register_sysctl("debug/test_sysctl", test_table);
171 if (!sysctl_test_headers.test_h_setup_ 171 if (!sysctl_test_headers.test_h_setup_node) {
172 kfree(test_data.bitmap_0001); 172 kfree(test_data.bitmap_0001);
173 return -ENOMEM; 173 return -ENOMEM;
174 } 174 }
175 175
176 return 0; 176 return 0;
177 } 177 }
178 178
179 /* Used to test that unregister actually remov 179 /* Used to test that unregister actually removes the directory */
180 static struct ctl_table test_table_unregister[ 180 static struct ctl_table test_table_unregister[] = {
181 { 181 {
182 .procname = "unregister_ 182 .procname = "unregister_error",
183 .data = &test_data.i 183 .data = &test_data.int_0001,
184 .maxlen = sizeof(int), 184 .maxlen = sizeof(int),
185 .mode = 0644, 185 .mode = 0644,
186 .proc_handler = proc_dointve 186 .proc_handler = proc_dointvec_minmax,
187 }, 187 },
188 }; 188 };
189 189
190 static int test_sysctl_run_unregister_nested(v 190 static int test_sysctl_run_unregister_nested(void)
191 { 191 {
192 struct ctl_table_header *unregister; 192 struct ctl_table_header *unregister;
193 193
194 unregister = register_sysctl("debug/te 194 unregister = register_sysctl("debug/test_sysctl/unregister_error",
195 test_table_ 195 test_table_unregister);
196 if (!unregister) 196 if (!unregister)
197 return -ENOMEM; 197 return -ENOMEM;
198 198
199 unregister_sysctl_table(unregister); 199 unregister_sysctl_table(unregister);
200 return 0; 200 return 0;
201 } 201 }
202 202
203 static int test_sysctl_run_register_mount_poin 203 static int test_sysctl_run_register_mount_point(void)
204 { 204 {
205 sysctl_test_headers.test_h_mnt 205 sysctl_test_headers.test_h_mnt
206 = register_sysctl_mount_point( 206 = register_sysctl_mount_point("debug/test_sysctl/mnt");
207 if (!sysctl_test_headers.test_h_mnt) 207 if (!sysctl_test_headers.test_h_mnt)
208 return -ENOMEM; 208 return -ENOMEM;
209 209
210 sysctl_test_headers.test_h_mnterror 210 sysctl_test_headers.test_h_mnterror
211 = register_sysctl("debug/test_ 211 = register_sysctl("debug/test_sysctl/mnt/mnt_error",
212 test_table_u 212 test_table_unregister);
213 /* 213 /*
214 * Don't check the result.: 214 * Don't check the result.:
215 * If it fails (expected behavior), re 215 * If it fails (expected behavior), return 0.
216 * If successful (missbehavior of regi 216 * If successful (missbehavior of register mount point), we want to see
217 * mnt_error when we run the sysctl te 217 * mnt_error when we run the sysctl test script
218 */ 218 */
219 219
220 return 0; 220 return 0;
221 } 221 }
222 222
223 static struct ctl_table test_table_empty[] = { 223 static struct ctl_table test_table_empty[] = { };
224 224
225 static int test_sysctl_run_register_empty(void 225 static int test_sysctl_run_register_empty(void)
226 { 226 {
227 /* Tets that an empty dir can be creat 227 /* Tets that an empty dir can be created */
228 sysctl_test_headers.empty_add 228 sysctl_test_headers.empty_add
229 = register_sysctl("debug/test_ 229 = register_sysctl("debug/test_sysctl/empty_add", test_table_empty);
230 if (!sysctl_test_headers.empty_add) 230 if (!sysctl_test_headers.empty_add)
231 return -ENOMEM; 231 return -ENOMEM;
232 232
233 /* Test that register on top of an emp 233 /* Test that register on top of an empty dir works */
234 sysctl_test_headers.empty 234 sysctl_test_headers.empty
235 = register_sysctl("debug/test_ 235 = register_sysctl("debug/test_sysctl/empty_add/empty", test_table_empty);
236 if (!sysctl_test_headers.empty) 236 if (!sysctl_test_headers.empty)
237 return -ENOMEM; 237 return -ENOMEM;
238 238
239 return 0; 239 return 0;
240 } 240 }
241 241
242 static int __init test_sysctl_init(void) 242 static int __init test_sysctl_init(void)
243 { 243 {
244 int err; 244 int err;
245 245
246 err = test_sysctl_setup_node_tests(); 246 err = test_sysctl_setup_node_tests();
247 if (err) 247 if (err)
248 goto out; 248 goto out;
249 249
250 err = test_sysctl_run_unregister_neste 250 err = test_sysctl_run_unregister_nested();
251 if (err) 251 if (err)
252 goto out; 252 goto out;
253 253
254 err = test_sysctl_run_register_mount_p 254 err = test_sysctl_run_register_mount_point();
255 if (err) 255 if (err)
256 goto out; 256 goto out;
257 257
258 err = test_sysctl_run_register_empty() 258 err = test_sysctl_run_register_empty();
259 259
260 out: 260 out:
261 return err; 261 return err;
262 } 262 }
263 module_init(test_sysctl_init); 263 module_init(test_sysctl_init);
264 264
265 static void __exit test_sysctl_exit(void) 265 static void __exit test_sysctl_exit(void)
266 { 266 {
267 kfree(test_data.bitmap_0001); 267 kfree(test_data.bitmap_0001);
268 if (sysctl_test_headers.test_h_setup_n 268 if (sysctl_test_headers.test_h_setup_node)
269 unregister_sysctl_table(sysctl 269 unregister_sysctl_table(sysctl_test_headers.test_h_setup_node);
270 if (sysctl_test_headers.test_h_mnt) 270 if (sysctl_test_headers.test_h_mnt)
271 unregister_sysctl_table(sysctl 271 unregister_sysctl_table(sysctl_test_headers.test_h_mnt);
272 if (sysctl_test_headers.test_h_mnterro 272 if (sysctl_test_headers.test_h_mnterror)
273 unregister_sysctl_table(sysctl 273 unregister_sysctl_table(sysctl_test_headers.test_h_mnterror);
274 if (sysctl_test_headers.empty) 274 if (sysctl_test_headers.empty)
275 unregister_sysctl_table(sysctl 275 unregister_sysctl_table(sysctl_test_headers.empty);
276 if (sysctl_test_headers.empty_add) 276 if (sysctl_test_headers.empty_add)
277 unregister_sysctl_table(sysctl 277 unregister_sysctl_table(sysctl_test_headers.empty_add);
278 } 278 }
279 279
280 module_exit(test_sysctl_exit); 280 module_exit(test_sysctl_exit);
281 281
282 MODULE_AUTHOR("Luis R. Rodriguez <mcgrof@kerne 282 MODULE_AUTHOR("Luis R. Rodriguez <mcgrof@kernel.org>");
283 MODULE_DESCRIPTION("proc sysctl test driver"); 283 MODULE_DESCRIPTION("proc sysctl test driver");
284 MODULE_LICENSE("GPL"); 284 MODULE_LICENSE("GPL");
285 285
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.