forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
394 lines
11 KiB
394 lines
11 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* KUnit test of proc sysctl. |
|
*/ |
|
|
|
#include <kunit/test.h> |
|
#include <linux/sysctl.h> |
|
|
|
#define KUNIT_PROC_READ 0 |
|
#define KUNIT_PROC_WRITE 1 |
|
|
|
static int i_zero; |
|
static int i_one_hundred = 100; |
|
|
|
/* |
|
* Test that proc_dointvec will not try to use a NULL .data field even when the |
|
* length is non-zero. |
|
*/ |
|
static void sysctl_test_api_dointvec_null_tbl_data(struct kunit *test) |
|
{ |
|
struct ctl_table null_data_table = { |
|
.procname = "foo", |
|
/* |
|
* Here we are testing that proc_dointvec behaves correctly when |
|
* we give it a NULL .data field. Normally this would point to a |
|
* piece of memory where the value would be stored. |
|
*/ |
|
.data = NULL, |
|
.maxlen = sizeof(int), |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
/* |
|
* proc_dointvec expects a buffer in user space, so we allocate one. We |
|
* also need to cast it to __user so sparse doesn't get mad. |
|
*/ |
|
void __user *buffer = (void __user *)kunit_kzalloc(test, sizeof(int), |
|
GFP_USER); |
|
size_t len; |
|
loff_t pos; |
|
|
|
/* |
|
* We don't care what the starting length is since proc_dointvec should |
|
* not try to read because .data is NULL. |
|
*/ |
|
len = 1234; |
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&null_data_table, |
|
KUNIT_PROC_READ, buffer, &len, |
|
&pos)); |
|
KUNIT_EXPECT_EQ(test, 0, len); |
|
|
|
/* |
|
* See above. |
|
*/ |
|
len = 1234; |
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&null_data_table, |
|
KUNIT_PROC_WRITE, buffer, &len, |
|
&pos)); |
|
KUNIT_EXPECT_EQ(test, 0, len); |
|
} |
|
|
|
/* |
|
* Similar to the previous test, we create a struct ctrl_table that has a .data |
|
* field that proc_dointvec cannot do anything with; however, this time it is |
|
* because we tell proc_dointvec that the size is 0. |
|
*/ |
|
static void sysctl_test_api_dointvec_table_maxlen_unset(struct kunit *test) |
|
{ |
|
int data = 0; |
|
struct ctl_table data_maxlen_unset_table = { |
|
.procname = "foo", |
|
.data = &data, |
|
/* |
|
* So .data is no longer NULL, but we tell proc_dointvec its |
|
* length is 0, so it still shouldn't try to use it. |
|
*/ |
|
.maxlen = 0, |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
void __user *buffer = (void __user *)kunit_kzalloc(test, sizeof(int), |
|
GFP_USER); |
|
size_t len; |
|
loff_t pos; |
|
|
|
/* |
|
* As before, we don't care what buffer length is because proc_dointvec |
|
* cannot do anything because its internal .data buffer has zero length. |
|
*/ |
|
len = 1234; |
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&data_maxlen_unset_table, |
|
KUNIT_PROC_READ, buffer, &len, |
|
&pos)); |
|
KUNIT_EXPECT_EQ(test, 0, len); |
|
|
|
/* |
|
* See previous comment. |
|
*/ |
|
len = 1234; |
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&data_maxlen_unset_table, |
|
KUNIT_PROC_WRITE, buffer, &len, |
|
&pos)); |
|
KUNIT_EXPECT_EQ(test, 0, len); |
|
} |
|
|
|
/* |
|
* Here we provide a valid struct ctl_table, but we try to read and write from |
|
* it using a buffer of zero length, so it should still fail in a similar way as |
|
* before. |
|
*/ |
|
static void sysctl_test_api_dointvec_table_len_is_zero(struct kunit *test) |
|
{ |
|
int data = 0; |
|
/* Good table. */ |
|
struct ctl_table table = { |
|
.procname = "foo", |
|
.data = &data, |
|
.maxlen = sizeof(int), |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
void __user *buffer = (void __user *)kunit_kzalloc(test, sizeof(int), |
|
GFP_USER); |
|
/* |
|
* However, now our read/write buffer has zero length. |
|
*/ |
|
size_t len = 0; |
|
loff_t pos; |
|
|
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_READ, buffer, |
|
&len, &pos)); |
|
KUNIT_EXPECT_EQ(test, 0, len); |
|
|
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_WRITE, buffer, |
|
&len, &pos)); |
|
KUNIT_EXPECT_EQ(test, 0, len); |
|
} |
|
|
|
/* |
|
* Test that proc_dointvec refuses to read when the file position is non-zero. |
|
*/ |
|
static void sysctl_test_api_dointvec_table_read_but_position_set( |
|
struct kunit *test) |
|
{ |
|
int data = 0; |
|
/* Good table. */ |
|
struct ctl_table table = { |
|
.procname = "foo", |
|
.data = &data, |
|
.maxlen = sizeof(int), |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
void __user *buffer = (void __user *)kunit_kzalloc(test, sizeof(int), |
|
GFP_USER); |
|
/* |
|
* We don't care about our buffer length because we start off with a |
|
* non-zero file position. |
|
*/ |
|
size_t len = 1234; |
|
/* |
|
* proc_dointvec should refuse to read into the buffer since the file |
|
* pos is non-zero. |
|
*/ |
|
loff_t pos = 1; |
|
|
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_READ, buffer, |
|
&len, &pos)); |
|
KUNIT_EXPECT_EQ(test, 0, len); |
|
} |
|
|
|
/* |
|
* Test that we can read a two digit number in a sufficiently size buffer. |
|
* Nothing fancy. |
|
*/ |
|
static void sysctl_test_dointvec_read_happy_single_positive(struct kunit *test) |
|
{ |
|
int data = 0; |
|
/* Good table. */ |
|
struct ctl_table table = { |
|
.procname = "foo", |
|
.data = &data, |
|
.maxlen = sizeof(int), |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
size_t len = 4; |
|
loff_t pos = 0; |
|
char *buffer = kunit_kzalloc(test, len, GFP_USER); |
|
char __user *user_buffer = (char __user *)buffer; |
|
/* Store 13 in the data field. */ |
|
*((int *)table.data) = 13; |
|
|
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_READ, |
|
user_buffer, &len, &pos)); |
|
KUNIT_ASSERT_EQ(test, 3, len); |
|
buffer[len] = '\0'; |
|
/* And we read 13 back out. */ |
|
KUNIT_EXPECT_STREQ(test, "13\n", buffer); |
|
} |
|
|
|
/* |
|
* Same as previous test, just now with negative numbers. |
|
*/ |
|
static void sysctl_test_dointvec_read_happy_single_negative(struct kunit *test) |
|
{ |
|
int data = 0; |
|
/* Good table. */ |
|
struct ctl_table table = { |
|
.procname = "foo", |
|
.data = &data, |
|
.maxlen = sizeof(int), |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
size_t len = 5; |
|
loff_t pos = 0; |
|
char *buffer = kunit_kzalloc(test, len, GFP_USER); |
|
char __user *user_buffer = (char __user *)buffer; |
|
*((int *)table.data) = -16; |
|
|
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_READ, |
|
user_buffer, &len, &pos)); |
|
KUNIT_ASSERT_EQ(test, 4, len); |
|
buffer[len] = '\0'; |
|
KUNIT_EXPECT_STREQ(test, "-16\n", buffer); |
|
} |
|
|
|
/* |
|
* Test that a simple positive write works. |
|
*/ |
|
static void sysctl_test_dointvec_write_happy_single_positive(struct kunit *test) |
|
{ |
|
int data = 0; |
|
/* Good table. */ |
|
struct ctl_table table = { |
|
.procname = "foo", |
|
.data = &data, |
|
.maxlen = sizeof(int), |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
char input[] = "9"; |
|
size_t len = sizeof(input) - 1; |
|
loff_t pos = 0; |
|
char *buffer = kunit_kzalloc(test, len, GFP_USER); |
|
char __user *user_buffer = (char __user *)buffer; |
|
|
|
memcpy(buffer, input, len); |
|
|
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_WRITE, |
|
user_buffer, &len, &pos)); |
|
KUNIT_EXPECT_EQ(test, sizeof(input) - 1, len); |
|
KUNIT_EXPECT_EQ(test, sizeof(input) - 1, pos); |
|
KUNIT_EXPECT_EQ(test, 9, *((int *)table.data)); |
|
} |
|
|
|
/* |
|
* Same as previous test, but now with negative numbers. |
|
*/ |
|
static void sysctl_test_dointvec_write_happy_single_negative(struct kunit *test) |
|
{ |
|
int data = 0; |
|
struct ctl_table table = { |
|
.procname = "foo", |
|
.data = &data, |
|
.maxlen = sizeof(int), |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
char input[] = "-9"; |
|
size_t len = sizeof(input) - 1; |
|
loff_t pos = 0; |
|
char *buffer = kunit_kzalloc(test, len, GFP_USER); |
|
char __user *user_buffer = (char __user *)buffer; |
|
|
|
memcpy(buffer, input, len); |
|
|
|
KUNIT_EXPECT_EQ(test, 0, proc_dointvec(&table, KUNIT_PROC_WRITE, |
|
user_buffer, &len, &pos)); |
|
KUNIT_EXPECT_EQ(test, sizeof(input) - 1, len); |
|
KUNIT_EXPECT_EQ(test, sizeof(input) - 1, pos); |
|
KUNIT_EXPECT_EQ(test, -9, *((int *)table.data)); |
|
} |
|
|
|
/* |
|
* Test that writing a value smaller than the minimum possible value is not |
|
* allowed. |
|
*/ |
|
static void sysctl_test_api_dointvec_write_single_less_int_min( |
|
struct kunit *test) |
|
{ |
|
int data = 0; |
|
struct ctl_table table = { |
|
.procname = "foo", |
|
.data = &data, |
|
.maxlen = sizeof(int), |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
size_t max_len = 32, len = max_len; |
|
loff_t pos = 0; |
|
char *buffer = kunit_kzalloc(test, max_len, GFP_USER); |
|
char __user *user_buffer = (char __user *)buffer; |
|
unsigned long abs_of_less_than_min = (unsigned long)INT_MAX |
|
- (INT_MAX + INT_MIN) + 1; |
|
|
|
/* |
|
* We use this rigmarole to create a string that contains a value one |
|
* less than the minimum accepted value. |
|
*/ |
|
KUNIT_ASSERT_LT(test, |
|
(size_t)snprintf(buffer, max_len, "-%lu", |
|
abs_of_less_than_min), |
|
max_len); |
|
|
|
KUNIT_EXPECT_EQ(test, -EINVAL, proc_dointvec(&table, KUNIT_PROC_WRITE, |
|
user_buffer, &len, &pos)); |
|
KUNIT_EXPECT_EQ(test, max_len, len); |
|
KUNIT_EXPECT_EQ(test, 0, *((int *)table.data)); |
|
} |
|
|
|
/* |
|
* Test that writing the maximum possible value works. |
|
*/ |
|
static void sysctl_test_api_dointvec_write_single_greater_int_max( |
|
struct kunit *test) |
|
{ |
|
int data = 0; |
|
struct ctl_table table = { |
|
.procname = "foo", |
|
.data = &data, |
|
.maxlen = sizeof(int), |
|
.mode = 0644, |
|
.proc_handler = proc_dointvec, |
|
.extra1 = &i_zero, |
|
.extra2 = &i_one_hundred, |
|
}; |
|
size_t max_len = 32, len = max_len; |
|
loff_t pos = 0; |
|
char *buffer = kunit_kzalloc(test, max_len, GFP_USER); |
|
char __user *user_buffer = (char __user *)buffer; |
|
unsigned long greater_than_max = (unsigned long)INT_MAX + 1; |
|
|
|
KUNIT_ASSERT_GT(test, greater_than_max, (unsigned long)INT_MAX); |
|
KUNIT_ASSERT_LT(test, (size_t)snprintf(buffer, max_len, "%lu", |
|
greater_than_max), |
|
max_len); |
|
KUNIT_EXPECT_EQ(test, -EINVAL, proc_dointvec(&table, KUNIT_PROC_WRITE, |
|
user_buffer, &len, &pos)); |
|
KUNIT_ASSERT_EQ(test, max_len, len); |
|
KUNIT_EXPECT_EQ(test, 0, *((int *)table.data)); |
|
} |
|
|
|
static struct kunit_case sysctl_test_cases[] = { |
|
KUNIT_CASE(sysctl_test_api_dointvec_null_tbl_data), |
|
KUNIT_CASE(sysctl_test_api_dointvec_table_maxlen_unset), |
|
KUNIT_CASE(sysctl_test_api_dointvec_table_len_is_zero), |
|
KUNIT_CASE(sysctl_test_api_dointvec_table_read_but_position_set), |
|
KUNIT_CASE(sysctl_test_dointvec_read_happy_single_positive), |
|
KUNIT_CASE(sysctl_test_dointvec_read_happy_single_negative), |
|
KUNIT_CASE(sysctl_test_dointvec_write_happy_single_positive), |
|
KUNIT_CASE(sysctl_test_dointvec_write_happy_single_negative), |
|
KUNIT_CASE(sysctl_test_api_dointvec_write_single_less_int_min), |
|
KUNIT_CASE(sysctl_test_api_dointvec_write_single_greater_int_max), |
|
{} |
|
}; |
|
|
|
static struct kunit_suite sysctl_test_suite = { |
|
.name = "sysctl_test", |
|
.test_cases = sysctl_test_cases, |
|
}; |
|
|
|
kunit_test_suites(&sysctl_test_suite); |
|
|
|
MODULE_LICENSE("GPL v2");
|
|
|