1// SPDX-License-Identifier: GPL-2.0
2/*
3 * KUnit test of proc sysctl.
4 */
5
6#include <kunit/test.h>
7#include <linux/sysctl.h>
8
9#define KUNIT_PROC_READ 0
10#define KUNIT_PROC_WRITE 1
11
12/*
13 * Test that proc_dointvec will not try to use a NULL .data field even when the
14 * length is non-zero.
15 */
16static void sysctl_test_api_dointvec_null_tbl_data(struct kunit *test)
17{
18	struct ctl_table null_data_table = {
19		.procname = "foo",
20		/*
21		 * Here we are testing that proc_dointvec behaves correctly when
22		 * we give it a NULL .data field. Normally this would point to a
23		 * piece of memory where the value would be stored.
24		 */
25		.data		= NULL,
26		.maxlen		= sizeof(int),
27		.mode		= 0644,
28		.proc_handler	= proc_dointvec,
29		.extra1		= SYSCTL_ZERO,
30		.extra2         = SYSCTL_ONE_HUNDRED,
31	};
32	/*
33	 * proc_dointvec expects a buffer in user space, so we allocate one. We
34	 * also need to cast it to __user so sparse doesn't get mad.
35	 */
36	void __user *buffer = (void __user *)kunit_kzalloc(test, sizeof(int),
37							   GFP_USER);
38	size_t len;
39	loff_t pos;
40
41	/*
42	 * We don't care what the starting length is since proc_dointvec should
43	 * not try to read because .data is NULL.
44	 */
45	len = 1234;
46	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&null_data_table,
47					       KUNIT_PROC_READ, buffer, &len,
48					       &pos));
49	KUNIT_EXPECT_EQ(test, 0, len);
50
51	/*
52	 * See above.
53	 */
54	len = 1234;
55	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&null_data_table,
56					       KUNIT_PROC_WRITE, buffer, &len,
57					       &pos));
58	KUNIT_EXPECT_EQ(test, 0, len);
59}
60
61/*
62 * Similar to the previous test, we create a struct ctrl_table that has a .data
63 * field that proc_dointvec cannot do anything with; however, this time it is
64 * because we tell proc_dointvec that the size is 0.
65 */
66static void sysctl_test_api_dointvec_table_maxlen_unset(struct kunit *test)
67{
68	int data = 0;
69	struct ctl_table data_maxlen_unset_table = {
70		.procname = "foo",
71		.data		= &data,
72		/*
73		 * So .data is no longer NULL, but we tell proc_dointvec its
74		 * length is 0, so it still shouldn't try to use it.
75		 */
76		.maxlen		= 0,
77		.mode		= 0644,
78		.proc_handler	= proc_dointvec,
79		.extra1		= SYSCTL_ZERO,
80		.extra2         = SYSCTL_ONE_HUNDRED,
81	};
82	void __user *buffer = (void __user *)kunit_kzalloc(test, sizeof(int),
83							   GFP_USER);
84	size_t len;
85	loff_t pos;
86
87	/*
88	 * As before, we don't care what buffer length is because proc_dointvec
89	 * cannot do anything because its internal .data buffer has zero length.
90	 */
91	len = 1234;
92	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&data_maxlen_unset_table,
93					       KUNIT_PROC_READ, buffer, &len,
94					       &pos));
95	KUNIT_EXPECT_EQ(test, 0, len);
96
97	/*
98	 * See previous comment.
99	 */
100	len = 1234;
101	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&data_maxlen_unset_table,
102					       KUNIT_PROC_WRITE, buffer, &len,
103					       &pos));
104	KUNIT_EXPECT_EQ(test, 0, len);
105}
106
107/*
108 * Here we provide a valid struct ctl_table, but we try to read and write from
109 * it using a buffer of zero length, so it should still fail in a similar way as
110 * before.
111 */
112static void sysctl_test_api_dointvec_table_len_is_zero(struct kunit *test)
113{
114	int data = 0;
115	/* Good table. */
116	struct ctl_table table = {
117		.procname = "foo",
118		.data		= &data,
119		.maxlen		= sizeof(int),
120		.mode		= 0644,
121		.proc_handler	= proc_dointvec,
122		.extra1		= SYSCTL_ZERO,
123		.extra2         = SYSCTL_ONE_HUNDRED,
124	};
125	void __user *buffer = (void __user *)kunit_kzalloc(test, sizeof(int),
126							   GFP_USER);
127	/*
128	 * However, now our read/write buffer has zero length.
129	 */
130	size_t len = 0;
131	loff_t pos;
132
133	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_READ, buffer,
134					       &len, &pos));
135	KUNIT_EXPECT_EQ(test, 0, len);
136
137	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_WRITE, buffer,
138					       &len, &pos));
139	KUNIT_EXPECT_EQ(test, 0, len);
140}
141
142/*
143 * Test that proc_dointvec refuses to read when the file position is non-zero.
144 */
145static void sysctl_test_api_dointvec_table_read_but_position_set(
146		struct kunit *test)
147{
148	int data = 0;
149	/* Good table. */
150	struct ctl_table table = {
151		.procname = "foo",
152		.data		= &data,
153		.maxlen		= sizeof(int),
154		.mode		= 0644,
155		.proc_handler	= proc_dointvec,
156		.extra1		= SYSCTL_ZERO,
157		.extra2         = SYSCTL_ONE_HUNDRED,
158	};
159	void __user *buffer = (void __user *)kunit_kzalloc(test, sizeof(int),
160							   GFP_USER);
161	/*
162	 * We don't care about our buffer length because we start off with a
163	 * non-zero file position.
164	 */
165	size_t len = 1234;
166	/*
167	 * proc_dointvec should refuse to read into the buffer since the file
168	 * pos is non-zero.
169	 */
170	loff_t pos = 1;
171
172	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_READ, buffer,
173					       &len, &pos));
174	KUNIT_EXPECT_EQ(test, 0, len);
175}
176
177/*
178 * Test that we can read a two digit number in a sufficiently size buffer.
179 * Nothing fancy.
180 */
181static void sysctl_test_dointvec_read_happy_single_positive(struct kunit *test)
182{
183	int data = 0;
184	/* Good table. */
185	struct ctl_table table = {
186		.procname = "foo",
187		.data		= &data,
188		.maxlen		= sizeof(int),
189		.mode		= 0644,
190		.proc_handler	= proc_dointvec,
191		.extra1		= SYSCTL_ZERO,
192		.extra2         = SYSCTL_ONE_HUNDRED,
193	};
194	size_t len = 4;
195	loff_t pos = 0;
196	char *buffer = kunit_kzalloc(test, len, GFP_USER);
197	char __user *user_buffer = (char __user *)buffer;
198	/* Store 13 in the data field. */
199	*((int *)table.data) = 13;
200
201	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_READ,
202					       user_buffer, &len, &pos));
203	KUNIT_ASSERT_EQ(test, 3, len);
204	buffer[len] = '\0';
205	/* And we read 13 back out. */
206	KUNIT_EXPECT_STREQ(test, "13\n", buffer);
207}
208
209/*
210 * Same as previous test, just now with negative numbers.
211 */
212static void sysctl_test_dointvec_read_happy_single_negative(struct kunit *test)
213{
214	int data = 0;
215	/* Good table. */
216	struct ctl_table table = {
217		.procname = "foo",
218		.data		= &data,
219		.maxlen		= sizeof(int),
220		.mode		= 0644,
221		.proc_handler	= proc_dointvec,
222		.extra1		= SYSCTL_ZERO,
223		.extra2         = SYSCTL_ONE_HUNDRED,
224	};
225	size_t len = 5;
226	loff_t pos = 0;
227	char *buffer = kunit_kzalloc(test, len, GFP_USER);
228	char __user *user_buffer = (char __user *)buffer;
229	*((int *)table.data) = -16;
230
231	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_READ,
232					       user_buffer, &len, &pos));
233	KUNIT_ASSERT_EQ(test, 4, len);
234	buffer[len] = '\0';
235	KUNIT_EXPECT_STREQ(test, "-16\n", buffer);
236}
237
238/*
239 * Test that a simple positive write works.
240 */
241static void sysctl_test_dointvec_write_happy_single_positive(struct kunit *test)
242{
243	int data = 0;
244	/* Good table. */
245	struct ctl_table table = {
246		.procname = "foo",
247		.data		= &data,
248		.maxlen		= sizeof(int),
249		.mode		= 0644,
250		.proc_handler	= proc_dointvec,
251		.extra1		= SYSCTL_ZERO,
252		.extra2         = SYSCTL_ONE_HUNDRED,
253	};
254	char input[] = "9";
255	size_t len = sizeof(input) - 1;
256	loff_t pos = 0;
257	char *buffer = kunit_kzalloc(test, len, GFP_USER);
258	char __user *user_buffer = (char __user *)buffer;
259
260	memcpy(buffer, input, len);
261
262	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_WRITE,
263					       user_buffer, &len, &pos));
264	KUNIT_EXPECT_EQ(test, sizeof(input) - 1, len);
265	KUNIT_EXPECT_EQ(test, sizeof(input) - 1, pos);
266	KUNIT_EXPECT_EQ(test, 9, *((int *)table.data));
267}
268
269/*
270 * Same as previous test, but now with negative numbers.
271 */
272static void sysctl_test_dointvec_write_happy_single_negative(struct kunit *test)
273{
274	int data = 0;
275	struct ctl_table table = {
276		.procname = "foo",
277		.data		= &data,
278		.maxlen		= sizeof(int),
279		.mode		= 0644,
280		.proc_handler	= proc_dointvec,
281		.extra1		= SYSCTL_ZERO,
282		.extra2         = SYSCTL_ONE_HUNDRED,
283	};
284	char input[] = "-9";
285	size_t len = sizeof(input) - 1;
286	loff_t pos = 0;
287	char *buffer = kunit_kzalloc(test, len, GFP_USER);
288	char __user *user_buffer = (char __user *)buffer;
289
290	memcpy(buffer, input, len);
291
292	KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_WRITE,
293					       user_buffer, &len, &pos));
294	KUNIT_EXPECT_EQ(test, sizeof(input) - 1, len);
295	KUNIT_EXPECT_EQ(test, sizeof(input) - 1, pos);
296	KUNIT_EXPECT_EQ(test, -9, *((int *)table.data));
297}
298
299/*
300 * Test that writing a value smaller than the minimum possible value is not
301 * allowed.
302 */
303static void sysctl_test_api_dointvec_write_single_less_int_min(
304		struct kunit *test)
305{
306	int data = 0;
307	struct ctl_table table = {
308		.procname = "foo",
309		.data		= &data,
310		.maxlen		= sizeof(int),
311		.mode		= 0644,
312		.proc_handler	= proc_dointvec,
313		.extra1		= SYSCTL_ZERO,
314		.extra2         = SYSCTL_ONE_HUNDRED,
315	};
316	size_t max_len = 32, len = max_len;
317	loff_t pos = 0;
318	char *buffer = kunit_kzalloc(test, max_len, GFP_USER);
319	char __user *user_buffer = (char __user *)buffer;
320	unsigned long abs_of_less_than_min = (unsigned long)INT_MAX
321					     - (INT_MAX + INT_MIN) + 1;
322
323	/*
324	 * We use this rigmarole to create a string that contains a value one
325	 * less than the minimum accepted value.
326	 */
327	KUNIT_ASSERT_LT(test,
328			(size_t)snprintf(buffer, max_len, "-%lu",
329					 abs_of_less_than_min),
330			max_len);
331
332	KUNIT_EXPECT_EQ(test, -EINVAL, proc_dointvec(&table, KUNIT_PROC_WRITE,
333						     user_buffer, &len, &pos));
334	KUNIT_EXPECT_EQ(test, max_len, len);
335	KUNIT_EXPECT_EQ(test, 0, *((int *)table.data));
336}
337
338/*
339 * Test that writing the maximum possible value works.
340 */
341static void sysctl_test_api_dointvec_write_single_greater_int_max(
342		struct kunit *test)
343{
344	int data = 0;
345	struct ctl_table table = {
346		.procname = "foo",
347		.data		= &data,
348		.maxlen		= sizeof(int),
349		.mode		= 0644,
350		.proc_handler	= proc_dointvec,
351		.extra1		= SYSCTL_ZERO,
352		.extra2         = SYSCTL_ONE_HUNDRED,
353	};
354	size_t max_len = 32, len = max_len;
355	loff_t pos = 0;
356	char *buffer = kunit_kzalloc(test, max_len, GFP_USER);
357	char __user *user_buffer = (char __user *)buffer;
358	unsigned long greater_than_max = (unsigned long)INT_MAX + 1;
359
360	KUNIT_ASSERT_GT(test, greater_than_max, (unsigned long)INT_MAX);
361	KUNIT_ASSERT_LT(test, (size_t)snprintf(buffer, max_len, "%lu",
362					       greater_than_max),
363			max_len);
364	KUNIT_EXPECT_EQ(test, -EINVAL, proc_dointvec(&table, KUNIT_PROC_WRITE,
365						     user_buffer, &len, &pos));
366	KUNIT_ASSERT_EQ(test, max_len, len);
367	KUNIT_EXPECT_EQ(test, 0, *((int *)table.data));
368}
369
370static struct kunit_case sysctl_test_cases[] = {
371	KUNIT_CASE(sysctl_test_api_dointvec_null_tbl_data),
372	KUNIT_CASE(sysctl_test_api_dointvec_table_maxlen_unset),
373	KUNIT_CASE(sysctl_test_api_dointvec_table_len_is_zero),
374	KUNIT_CASE(sysctl_test_api_dointvec_table_read_but_position_set),
375	KUNIT_CASE(sysctl_test_dointvec_read_happy_single_positive),
376	KUNIT_CASE(sysctl_test_dointvec_read_happy_single_negative),
377	KUNIT_CASE(sysctl_test_dointvec_write_happy_single_positive),
378	KUNIT_CASE(sysctl_test_dointvec_write_happy_single_negative),
379	KUNIT_CASE(sysctl_test_api_dointvec_write_single_less_int_min),
380	KUNIT_CASE(sysctl_test_api_dointvec_write_single_greater_int_max),
381	{}
382};
383
384static struct kunit_suite sysctl_test_suite = {
385	.name = "sysctl_test",
386	.test_cases = sysctl_test_cases,
387};
388
389kunit_test_suites(&sysctl_test_suite);
390
391MODULE_LICENSE("GPL v2");
392