tests/modules/t_modctl.c

   1 /*      $NetBSD: t_modctl.c,v 1.12 2012/08/20 08:07:52 martin Exp $     */
   2 /*
   3  * Copyright (c) 2008 The NetBSD Foundation, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  16  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  17  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  22  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  24  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  25  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  26  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __KERNEL_RCSID(0, "$NetBSD: t_modctl.c,v 1.12 2012/08/20 08:07:52 martin Exp $");
  31
  32 #include <sys/module.h>
  33 #include <sys/sysctl.h>
  34
  35 #include <assert.h>
  36 #include <errno.h>
  37 #include <stdarg.h>
  38 #include <stdbool.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42
  43 #include <prop/proplib.h>
  44
  45 #include <atf-c.h>
  46
  47 enum presence_check { both_checks, stat_check, sysctl_check };
  48
  49 static void     check_permission(void);
  50 static bool     get_modstat_info(const char *, modstat_t *);
  51 static bool     get_sysctl(const char *, void *buf, const size_t);
  52 static bool     k_helper_is_present_stat(void);
  53 static bool     k_helper_is_present_sysctl(void);
  54 static bool     k_helper_is_present(enum presence_check);
  55 static int      load(prop_dictionary_t, bool, const char *, ...);
  56 static int      unload(const char *, bool);
  57 static void     unload_cleanup(const char *);
  58
  59 /* --------------------------------------------------------------------- */
  60 /* Auxiliary functions                                                   */
  61 /* --------------------------------------------------------------------- */
  62
  63 /*
  64  * A function checking wether we are allowed to load modules currently
  65  * (either the kernel is not modular, or securelevel may prevent it)
  66  */
  67 static void
  68 check_permission(void)
  69 {
  70         int err;
  71
  72         err = modctl(MODCTL_EXISTS, 0);
  73         if (err == 0) return;
  74         if (errno == ENOSYS)
  75                 atf_tc_skip("Kernel does not have 'options MODULAR'.");
  76         else if (errno == EPERM)
  77                 atf_tc_skip("Module loading administratively forbidden");
  78         ATF_REQUIRE_EQ_MSG(errno, 0, "unexpected error %d from "
  79             "modctl(MODCTL_EXISTS, 0)", errno);
  80 }
  81
  82 static bool
  83 get_modstat_info(const char *name, modstat_t *msdest)
  84 {
  85         bool found;
  86         size_t len;
  87         struct iovec iov;
  88         modstat_t *ms;
  89
  90         check_permission();
  91         for (len = 4096; ;) {
  92                 iov.iov_base = malloc(len);
  93                 iov.iov_len = len;
  94
  95                 errno = 0;
  96
  97                 if (modctl(MODCTL_STAT, &iov) != 0) {
  98                         int err = errno;
  99                         fprintf(stderr, "modctl(MODCTL_STAT) failed: %s\n",
 100                             strerror(err));
 101                         atf_tc_fail("Failed to query module status");
 102                 }
 103                 if (len >= iov.iov_len)
 104                         break;
 105                 free(iov.iov_base);
 106                 len = iov.iov_len;
 107         }
 108
 109         found = false;
 110         len = iov.iov_len / sizeof(modstat_t);
 111         for (ms = (modstat_t *)iov.iov_base; len != 0 && !found;
 112             ms++, len--) {
 113                 if (strcmp(ms->ms_name, name) == 0) {
 114                         if (msdest != NULL)
 115                                 *msdest = *ms;
 116                         found = true;
 117                 }
 118         }
 119
 120         free(iov.iov_base);
 121
 122         return found;
 123 }
 124
 125 /*
 126  * Queries a sysctl property.
 127  */
 128 static bool
 129 get_sysctl(const char *name, void *buf, const size_t len)
 130 {
 131         size_t len2 = len;
 132         printf("Querying sysctl variable: %s\n", name);
 133         int ret = sysctlbyname(name, buf, &len2, NULL, 0);
 134         if (ret == -1 && errno != ENOENT) {
 135                 fprintf(stderr, "sysctlbyname(2) failed: %s\n",
 136                     strerror(errno));
 137                 atf_tc_fail("Failed to query %s", name);
 138         }
 139         return ret != -1;
 140 }
 141
 142 /*
 143  * Returns a boolean indicating if the k_helper module was loaded
 144  * successfully.  This implementation uses modctl(2)'s MODCTL_STAT
 145  * subcommand to do the check.
 146  */
 147 static bool
 148 k_helper_is_present_stat(void)
 149 {
 150
 151         return get_modstat_info("k_helper", NULL);
 152 }
 153
 154 /*
 155  * Returns a boolean indicating if the k_helper module was loaded
 156  * successfully.  This implementation uses the module's sysctl
 157  * installed node to do the check.
 158  */
 159 static bool
 160 k_helper_is_present_sysctl(void)
 161 {
 162         size_t present;
 163
 164         return get_sysctl("vendor.k_helper.present", &present,
 165             sizeof(present));
 166 }
 167
 168 /*
 169  * Returns a boolean indicating if the k_helper module was loaded
 170  * successfully.  The 'how' parameter specifies the implementation to
 171  * use to do the check.
 172  */
 173 static bool
 174 k_helper_is_present(enum presence_check how)
 175 {
 176         bool found;
 177
 178         switch (how) {
 179         case both_checks:
 180                 found = k_helper_is_present_stat();
 181                 ATF_CHECK(k_helper_is_present_sysctl() == found);
 182                 break;
 183
 184         case stat_check:
 185                 found = k_helper_is_present_stat();
 186                 break;
 187
 188         case sysctl_check:
 189                 found = k_helper_is_present_sysctl();
 190                 break;
 191
 192         default:
 193                 found = false;
 194                 assert(found);
 195         }
 196
 197         return found;
 198 }
 199
 200 /*
 201  * Loads the specified module from a file.  If fatal is set and an error
 202  * occurs when loading the module, an error message is printed and the
 203  * test case is aborted.
 204  */
 205 static __printflike(3, 4) int
 206 load(prop_dictionary_t props, bool fatal, const char *fmt, ...)
 207 {
 208         int err;
 209         va_list ap;
 210         char filename[MAXPATHLEN], *propsstr;
 211         modctl_load_t ml;
 212
 213         check_permission();
 214         if (props == NULL) {
 215                 props = prop_dictionary_create();
 216                 propsstr = prop_dictionary_externalize(props);
 217                 ATF_CHECK(propsstr != NULL);
 218                 prop_object_release(props);
 219         } else {
 220                 propsstr = prop_dictionary_externalize(props);
 221                 ATF_CHECK(propsstr != NULL);
 222         }
 223
 224         va_start(ap, fmt);
 225         vsnprintf(filename, sizeof(filename), fmt, ap);
 226         va_end(ap);
 227
 228         ml.ml_filename = filename;
 229         ml.ml_flags = 0;
 230         ml.ml_props = propsstr;
 231         ml.ml_propslen = strlen(propsstr);
 232
 233         printf("Loading module %s\n", filename);
 234         errno = err = 0;
 235
 236         if (modctl(MODCTL_LOAD, &ml) == -1) {
 237                 err = errno;
 238                 fprintf(stderr, "modctl(MODCTL_LOAD, %s), failed: %s\n",
 239                     filename, strerror(err));
 240                 if (fatal)
 241                         atf_tc_fail("Module load failed");
 242         }
 243
 244         free(propsstr);
 245
 246         return err;
 247 }
 248
 249 /*
 250  * Unloads the specified module.  If silent is true, nothing will be
 251  * printed and no errors will be raised if the unload was unsuccessful.
 252  */
 253 static int
 254 unload(const char *name, bool fatal)
 255 {
 256         int err;
 257
 258         check_permission();
 259         printf("Unloading module %s\n", name);
 260         errno = err = 0;
 261
 262         if (modctl(MODCTL_UNLOAD, __UNCONST(name)) == -1) {
 263                 err = errno;
 264                 fprintf(stderr, "modctl(MODCTL_UNLOAD, %s) failed: %s\n",
 265                     name, strerror(err));
 266                 if (fatal)
 267                         atf_tc_fail("Module unload failed");
 268         }
 269         return err;
 270 }
 271
 272 /*
 273  * A silent version of unload, to be called as part of the cleanup
 274  * process only.
 275  */
 276 static void
 277 unload_cleanup(const char *name)
 278 {
 279
 280         (void)modctl(MODCTL_UNLOAD, __UNCONST(name));
 281 }
 282
 283 /* --------------------------------------------------------------------- */
 284 /* Test cases                                                            */
 285 /* --------------------------------------------------------------------- */
 286
 287 ATF_TC_WITH_CLEANUP(cmd_load);
 288 ATF_TC_HEAD(cmd_load, tc)
 289 {
 290         atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_LOAD command");
 291         atf_tc_set_md_var(tc, "require.user", "root");
 292 }
 293 ATF_TC_BODY(cmd_load, tc)
 294 {
 295         char longname[MAXPATHLEN];
 296         size_t i;
 297
 298         ATF_CHECK(load(NULL, false, " ") == ENOENT);
 299         ATF_CHECK(load(NULL, false, "non-existent.o") == ENOENT);
 300
 301         for (i = 0; i < MAXPATHLEN - 1; i++)
 302                 longname[i] = 'a';
 303         longname[MAXPATHLEN - 1] = '\0';
 304         ATF_CHECK(load(NULL, false, "%s", longname) == ENAMETOOLONG);
 305
 306         ATF_CHECK(!k_helper_is_present(stat_check));
 307         load(NULL, true, "%s/k_helper/k_helper.kmod",
 308             atf_tc_get_config_var(tc, "srcdir"));
 309         printf("Checking if load was successful\n");
 310         ATF_CHECK(k_helper_is_present(stat_check));
 311 }
 312 ATF_TC_CLEANUP(cmd_load, tc)
 313 {
 314         unload_cleanup("k_helper");
 315 }
 316
 317 ATF_TC_WITH_CLEANUP(cmd_load_props);
 318 ATF_TC_HEAD(cmd_load_props, tc)
 319 {
 320         atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_LOAD command, "
 321             "providing extra load-time properties");
 322         atf_tc_set_md_var(tc, "require.user", "root");
 323 }
 324 ATF_TC_BODY(cmd_load_props, tc)
 325 {
 326         prop_dictionary_t props;
 327
 328         printf("Loading module without properties\n");
 329         props = prop_dictionary_create();
 330         load(props, true, "%s/k_helper/k_helper.kmod",
 331             atf_tc_get_config_var(tc, "srcdir"));
 332         prop_object_release(props);
 333         {
 334                 int ok;
 335                 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_ok",
 336                     &ok, sizeof(ok)));
 337                 ATF_CHECK(!ok);
 338         }
 339         unload("k_helper", true);
 340
 341         printf("Loading module with a string property\n");
 342         props = prop_dictionary_create();
 343         prop_dictionary_set(props, "prop_str",
 344             prop_string_create_cstring("1st string"));
 345         load(props, true, "%s/k_helper/k_helper.kmod",
 346             atf_tc_get_config_var(tc, "srcdir"));
 347         prop_object_release(props);
 348         {
 349                 int ok;
 350                 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_ok",
 351                     &ok, sizeof(ok)));
 352                 ATF_CHECK(ok);
 353
 354                 char val[128];
 355                 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_val",
 356                     &val, sizeof(val)));
 357                 ATF_CHECK(strcmp(val, "1st string") == 0);
 358         }
 359         unload("k_helper", true);
 360
 361         printf("Loading module with a different string property\n");
 362         props = prop_dictionary_create();
 363         prop_dictionary_set(props, "prop_str",
 364             prop_string_create_cstring("2nd string"));
 365         load(props, true, "%s/k_helper/k_helper.kmod",
 366             atf_tc_get_config_var(tc, "srcdir"));
 367         prop_object_release(props);
 368         {
 369                 int ok;
 370                 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_ok",
 371                     &ok, sizeof(ok)));
 372                 ATF_CHECK(ok);
 373
 374                 char val[128];
 375                 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_val",
 376                     &val, sizeof(val)));
 377                 ATF_CHECK(strcmp(val, "2nd string") == 0);
 378         }
 379         unload("k_helper", true);
 380 }
 381 ATF_TC_CLEANUP(cmd_load_props, tc)
 382 {
 383         unload_cleanup("k_helper");
 384 }
 385
 386 ATF_TC_WITH_CLEANUP(cmd_load_recurse);
 387 ATF_TC_HEAD(cmd_load_recurse, tc)
 388 {
 389         atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_LOAD command, "
 390             "with recursive module_load()");
 391         atf_tc_set_md_var(tc, "require.user", "root");
 392 }
 393 ATF_TC_BODY(cmd_load_recurse, tc)
 394 {
 395         prop_dictionary_t props;
 396         char filename[MAXPATHLEN];
 397
 398         printf("Loading module with request to load another module\n");
 399         props = prop_dictionary_create();
 400         snprintf(filename, sizeof(filename), "%s/k_helper2/k_helper2.kmod",
 401             atf_tc_get_config_var(tc, "srcdir"));
 402         prop_dictionary_set(props, "prop_recurse",
 403             prop_string_create_cstring(filename));
 404         load(props, true, "%s/k_helper/k_helper.kmod",
 405             atf_tc_get_config_var(tc, "srcdir"));
 406         {
 407                 int ok;
 408                 ATF_CHECK(get_sysctl("vendor.k_helper.prop_int_load",
 409                     &ok, sizeof(ok)));
 410                 ATF_CHECK(ok == 0);
 411                 ATF_CHECK(get_sysctl("vendor.k_helper2.present",
 412                     &ok, sizeof(ok)));
 413                 ATF_CHECK(ok);
 414         }
 415         unload("k_helper", true);
 416         unload("k_helper2", true);
 417 }
 418 ATF_TC_CLEANUP(cmd_load_recurse, tc)
 419 {
 420         unload_cleanup("k_helper");
 421         unload_cleanup("k_helper2");
 422 }
 423
 424 ATF_TC_WITH_CLEANUP(cmd_stat);
 425 ATF_TC_HEAD(cmd_stat, tc)
 426 {
 427         atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_STAT command");
 428         atf_tc_set_md_var(tc, "require.user", "root");
 429 }
 430 ATF_TC_BODY(cmd_stat, tc)
 431 {
 432         ATF_CHECK(!k_helper_is_present(both_checks));
 433
 434         load(NULL, true, "%s/k_helper/k_helper.kmod",
 435             atf_tc_get_config_var(tc, "srcdir"));
 436         ATF_CHECK(k_helper_is_present(both_checks));
 437         {
 438                 modstat_t ms;
 439                 ATF_CHECK(get_modstat_info("k_helper", &ms));
 440
 441                 ATF_CHECK(ms.ms_class == MODULE_CLASS_MISC);
 442                 ATF_CHECK(ms.ms_source == MODULE_SOURCE_FILESYS);
 443                 ATF_CHECK(ms.ms_refcnt == 0);
 444         }
 445         unload("k_helper", true);
 446
 447         ATF_CHECK(!k_helper_is_present(both_checks));
 448 }
 449 ATF_TC_CLEANUP(cmd_stat, tc)
 450 {
 451         unload_cleanup("k_helper");
 452 }
 453
 454 ATF_TC_WITH_CLEANUP(cmd_unload);
 455 ATF_TC_HEAD(cmd_unload, tc)
 456 {
 457         atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_UNLOAD command");
 458         atf_tc_set_md_var(tc, "require.user", "root");
 459 }
 460 ATF_TC_BODY(cmd_unload, tc)
 461 {
 462         load(NULL, true, "%s/k_helper/k_helper.kmod",
 463             atf_tc_get_config_var(tc, "srcdir"));
 464
 465         ATF_CHECK(unload("", false) == ENOENT);
 466         ATF_CHECK(unload("non-existent.kmod", false) == ENOENT);
 467         ATF_CHECK(unload("k_helper.kmod", false) == ENOENT);
 468
 469         ATF_CHECK(k_helper_is_present(stat_check));
 470         unload("k_helper", true);
 471         printf("Checking if unload was successful\n");
 472         ATF_CHECK(!k_helper_is_present(stat_check));
 473 }
 474 ATF_TC_CLEANUP(cmd_unload, tc)
 475 {
 476         unload_cleanup("k_helper");
 477 }
 478
 479 /* --------------------------------------------------------------------- */
 480 /* Main                                                                  */
 481 /* --------------------------------------------------------------------- */
 482
 483 ATF_TP_ADD_TCS(tp)
 484 {
 485
 486         ATF_TP_ADD_TC(tp, cmd_load);
 487         ATF_TP_ADD_TC(tp, cmd_load_props);
 488         ATF_TP_ADD_TC(tp, cmd_stat);
 489         ATF_TP_ADD_TC(tp, cmd_load_recurse);
 490         ATF_TP_ADD_TC(tp, cmd_unload);
 491
 492         return atf_no_error();
 493 }