kernel/sysctl-test.c

   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  */
  16 static 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  */
  66 static 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  */
 112 static 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  */
 145 static 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  */
 181 static 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  */
 212 static 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  */
 241 static 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  */
 272 static 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  */
 303 static 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  */
 341 static 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
 370 /*
 371  * Test that registering an invalid extra value is not allowed.
 372  */
 373 static void sysctl_test_register_sysctl_sz_invalid_extra_value(
 374                 struct kunit *test)
 375 {
 376         unsigned char data = 0;
 377         struct ctl_table table_foo[] = {
 378                 {
 379                         .procname       = "foo",
 380                         .data           = &data,
 381                         .maxlen         = sizeof(u8),
 382                         .mode           = 0644,
 383                         .proc_handler   = proc_dou8vec_minmax,
 384                         .extra1         = SYSCTL_FOUR,
 385                         .extra2         = SYSCTL_ONE_THOUSAND,
 386                 },
 387         };
 388
 389         struct ctl_table table_bar[] = {
 390                 {
 391                         .procname       = "bar",
 392                         .data           = &data,
 393                         .maxlen         = sizeof(u8),
 394                         .mode           = 0644,
 395                         .proc_handler   = proc_dou8vec_minmax,
 396                         .extra1         = SYSCTL_NEG_ONE,
 397                         .extra2         = SYSCTL_ONE_HUNDRED,
 398                 },
 399         };
 400
 401         struct ctl_table table_qux[] = {
 402                 {
 403                         .procname       = "qux",
 404                         .data           = &data,
 405                         .maxlen         = sizeof(u8),
 406                         .mode           = 0644,
 407                         .proc_handler   = proc_dou8vec_minmax,
 408                         .extra1         = SYSCTL_ZERO,
 409                         .extra2         = SYSCTL_TWO_HUNDRED,
 410                 },
 411         };
 412
 413         KUNIT_EXPECT_NULL(test, register_sysctl("foo", table_foo));
 414         KUNIT_EXPECT_NULL(test, register_sysctl("foo", table_bar));
 415         KUNIT_EXPECT_NOT_NULL(test, register_sysctl("foo", table_qux));
 416 }
 417
 418 static struct kunit_case sysctl_test_cases[] = {
 419         KUNIT_CASE(sysctl_test_api_dointvec_null_tbl_data),
 420         KUNIT_CASE(sysctl_test_api_dointvec_table_maxlen_unset),
 421         KUNIT_CASE(sysctl_test_api_dointvec_table_len_is_zero),
 422         KUNIT_CASE(sysctl_test_api_dointvec_table_read_but_position_set),
 423         KUNIT_CASE(sysctl_test_dointvec_read_happy_single_positive),
 424         KUNIT_CASE(sysctl_test_dointvec_read_happy_single_negative),
 425         KUNIT_CASE(sysctl_test_dointvec_write_happy_single_positive),
 426         KUNIT_CASE(sysctl_test_dointvec_write_happy_single_negative),
 427         KUNIT_CASE(sysctl_test_api_dointvec_write_single_less_int_min),
 428         KUNIT_CASE(sysctl_test_api_dointvec_write_single_greater_int_max),
 429         KUNIT_CASE(sysctl_test_register_sysctl_sz_invalid_extra_value),
 430         {}
 431 };
 432
 433 static struct kunit_suite sysctl_test_suite = {
 434         .name = "sysctl_test",
 435         .test_cases = sysctl_test_cases,
 436 };
 437
 438 kunit_test_suites(&sysctl_test_suite);
 439
 440 MODULE_DESCRIPTION("KUnit test of proc sysctl");
 441 MODULE_LICENSE("GPL v2");