1 /* $NetBSD: t_modctl.c,v 1.16 2020/02/22 19:54:34 pgoyette 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.16 2020/02/22 19:54:34 pgoyette 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 #include <sys/evcnt.h>
43
44 #include <prop/proplib.h>
45
46 #include <atf-c.h>
47
48 enum presence_check { all_checks, stat_check, sysctl_check, evcnt_check };
49
50 static void check_permission(void);
51 static bool get_modstat_info(const char *, modstat_t *);
52 static bool get_sysctl(const char *, void *buf, const size_t);
53 static bool k_helper_is_present_stat(void);
54 static bool k_helper_is_present_sysctl(void);
55 static bool k_helper_is_present_evcnt(void);
56 static bool k_helper_is_present(enum presence_check);
57 static int load(prop_dictionary_t, bool, const char *, ...);
58 static int unload(const char *, bool);
59 static void unload_cleanup(const char *);
60
61 /* --------------------------------------------------------------------- */
62 /* Auxiliary functions */
63 /* --------------------------------------------------------------------- */
64
65 /*
66 * A function checking whether we are allowed to load modules currently
67 * (either the kernel is not modular, or securelevel may prevent it)
68 */
69 static void
check_permission(void)70 check_permission(void)
71 {
72 int err;
73
74 err = modctl(MODCTL_EXISTS, 0);
75 if (err == 0) return;
76 if (errno == ENOSYS)
77 atf_tc_skip("Kernel does not have 'options MODULAR'.");
78 else if (errno == EPERM)
79 atf_tc_skip("Module loading administratively forbidden");
80 ATF_REQUIRE_EQ_MSG(errno, 0, "unexpected error %d from "
81 "modctl(MODCTL_EXISTS, 0)", errno);
82 }
83
84 static bool
get_modstat_info(const char * name,modstat_t * msdest)85 get_modstat_info(const char *name, modstat_t *msdest)
86 {
87 bool found;
88 size_t len;
89 int count;
90 struct iovec iov;
91 modstat_t *ms;
92 modstat_t m;
93
94 check_permission();
95 for (len = 8192; ;) {
96 iov.iov_base = malloc(len);
97 iov.iov_len = len;
98
99 errno = 0;
100
101 if (modctl(MODCTL_STAT, &iov) != 0) {
102 int err = errno;
103 fprintf(stderr, "modctl(MODCTL_STAT) failed: %s\n",
104 strerror(err));
105 atf_tc_fail("Failed to query module status");
106 }
107 if (len >= iov.iov_len)
108 break;
109 free(iov.iov_base);
110 len = iov.iov_len;
111 }
112
113 found = false;
114 count = *(int *)iov.iov_base;
115 ms = (modstat_t *)((char *)iov.iov_base + sizeof(int));
116 while ( count ) {
117 memcpy(&m, ms, sizeof(m));
118 if (strcmp(m.ms_name, name) == 0) {
119 if (msdest != NULL)
120 memcpy(msdest, &m, sizeof(*msdest));
121 found = true;
122 break;
123 }
124 ms++;
125 count--;
126 }
127
128 free(iov.iov_base);
129
130 return found;
131 }
132
133 /*
134 * Queries a sysctl property.
135 */
136 static bool
get_sysctl(const char * name,void * buf,const size_t len)137 get_sysctl(const char *name, void *buf, const size_t len)
138 {
139 size_t len2 = len;
140 printf("Querying sysctl variable: %s\n", name);
141 int ret = sysctlbyname(name, buf, &len2, NULL, 0);
142 if (ret == -1 && errno != ENOENT) {
143 fprintf(stderr, "sysctlbyname(2) failed: %s\n",
144 strerror(errno));
145 atf_tc_fail("Failed to query %s", name);
146 }
147 return ret != -1;
148 }
149
150 /*
151 * Returns a boolean indicating if the k_helper module was loaded
152 * successfully. This implementation uses modctl(2)'s MODCTL_STAT
153 * subcommand to do the check.
154 */
155 static bool
k_helper_is_present_stat(void)156 k_helper_is_present_stat(void)
157 {
158
159 return get_modstat_info("k_helper", NULL);
160 }
161
162 /*
163 * Returns a boolean indicating if the k_helper module was loaded
164 * successfully. This implementation uses the module's sysctl
165 * installed node to do the check.
166 */
167 static bool
k_helper_is_present_sysctl(void)168 k_helper_is_present_sysctl(void)
169 {
170 size_t present;
171
172 return get_sysctl("vendor.k_helper.present", &present,
173 sizeof(present));
174 }
175
176 /*
177 * Returns a boolean indicating if the k_helper module was loaded
178 * successfully. This implementation uses the module's evcnt
179 * to do the check.
180 */
181 static bool
k_helper_is_present_evcnt(void)182 k_helper_is_present_evcnt(void)
183 {
184 const int mib[4] = {CTL_KERN, KERN_EVCNT, EVCNT_TYPE_ANY,
185 KERN_EVCNT_COUNT_ANY };
186 int error;
187 size_t newlen, buflen = 0;
188 void *buf0, *buf = NULL;
189 const struct evcnt_sysctl *evs, *last_evs;
190
191 for (;;) {
192 if (buflen)
193 buf = malloc(buflen);
194 error = sysctl(mib, __arraycount(mib), buf, &newlen, NULL, 0);
195 if (error) {
196 if (buf)
197 free(buf);
198 return false;
199 }
200 if (newlen <= buflen) {
201 buflen = newlen;
202 break;
203 }
204 if (buf)
205 free(buf);
206 buflen = newlen;
207 }
208 evs = buf0 = buf;
209 last_evs = (void *)((char *)buf + buflen);
210 buflen /= sizeof(uint64_t);
211 while (evs < last_evs
212 && buflen >= sizeof(*evs)/sizeof(uint64_t)
213 && buflen >= evs->ev_len) {
214 if ( strncmp(evs->ev_strings, "k_helper", evs->ev_grouplen)
215 == 0) {
216 free(buf);
217 return true;
218 }
219 buflen -= evs->ev_len;
220 evs = (const void *)((const uint64_t *)evs + evs->ev_len);
221 }
222 free(buf);
223 return false;
224 }
225
226 /*
227 * Returns a boolean indicating if the k_helper module was loaded
228 * successfully. The 'how' parameter specifies the implementation to
229 * use to do the check.
230 */
231 static bool
k_helper_is_present(enum presence_check how)232 k_helper_is_present(enum presence_check how)
233 {
234 bool found;
235
236 switch (how) {
237 case all_checks:
238 found = k_helper_is_present_stat();
239 ATF_CHECK(k_helper_is_present_sysctl() == found);
240 ATF_CHECK(k_helper_is_present_evcnt() == found);
241 break;
242
243 case stat_check:
244 found = k_helper_is_present_stat();
245 break;
246
247 case sysctl_check:
248 found = k_helper_is_present_sysctl();
249 break;
250
251 case evcnt_check:
252 found = k_helper_is_present_evcnt();
253 break;
254
255 default:
256 found = false;
257 assert(found);
258 }
259
260 return found;
261 }
262
263 /*
264 * Loads the specified module from a file. If fatal is set and an error
265 * occurs when loading the module, an error message is printed and the
266 * test case is aborted.
267 */
268 static __printflike(3, 4) int
load(prop_dictionary_t props,bool fatal,const char * fmt,...)269 load(prop_dictionary_t props, bool fatal, const char *fmt, ...)
270 {
271 int err;
272 va_list ap;
273 char filename[MAXPATHLEN], *propsstr;
274 modctl_load_t ml;
275
276 check_permission();
277 if (props == NULL) {
278 props = prop_dictionary_create();
279 propsstr = prop_dictionary_externalize(props);
280 ATF_CHECK(propsstr != NULL);
281 prop_object_release(props);
282 } else {
283 propsstr = prop_dictionary_externalize(props);
284 ATF_CHECK(propsstr != NULL);
285 }
286
287 va_start(ap, fmt);
288 vsnprintf(filename, sizeof(filename), fmt, ap);
289 va_end(ap);
290
291 ml.ml_filename = filename;
292 ml.ml_flags = 0;
293 ml.ml_props = propsstr;
294 ml.ml_propslen = strlen(propsstr);
295
296 printf("Loading module %s\n", filename);
297 errno = err = 0;
298
299 if (modctl(MODCTL_LOAD, &ml) == -1) {
300 err = errno;
301 fprintf(stderr, "modctl(MODCTL_LOAD, %s), failed: %s\n",
302 filename, strerror(err));
303 if (fatal)
304 atf_tc_fail("Module load failed");
305 }
306
307 free(propsstr);
308
309 return err;
310 }
311
312 /*
313 * Unloads the specified module. If silent is true, nothing will be
314 * printed and no errors will be raised if the unload was unsuccessful.
315 */
316 static int
unload(const char * name,bool fatal)317 unload(const char *name, bool fatal)
318 {
319 int err;
320
321 check_permission();
322 printf("Unloading module %s\n", name);
323 errno = err = 0;
324
325 if (modctl(MODCTL_UNLOAD, __UNCONST(name)) == -1) {
326 err = errno;
327 fprintf(stderr, "modctl(MODCTL_UNLOAD, %s) failed: %s\n",
328 name, strerror(err));
329 if (fatal)
330 atf_tc_fail("Module unload failed");
331 }
332 return err;
333 }
334
335 /*
336 * A silent version of unload, to be called as part of the cleanup
337 * process only.
338 */
339 static void
unload_cleanup(const char * name)340 unload_cleanup(const char *name)
341 {
342
343 (void)modctl(MODCTL_UNLOAD, __UNCONST(name));
344 }
345
346 /* --------------------------------------------------------------------- */
347 /* Test cases */
348 /* --------------------------------------------------------------------- */
349
350 ATF_TC_WITH_CLEANUP(cmd_load);
ATF_TC_HEAD(cmd_load,tc)351 ATF_TC_HEAD(cmd_load, tc)
352 {
353 atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_LOAD command");
354 atf_tc_set_md_var(tc, "require.user", "root");
355 }
ATF_TC_BODY(cmd_load,tc)356 ATF_TC_BODY(cmd_load, tc)
357 {
358 char longname[MAXPATHLEN];
359 size_t i;
360
361 ATF_CHECK(load(NULL, false, " ") == ENOENT);
362 ATF_CHECK(load(NULL, false, "non-existent.o") == ENOENT);
363
364 for (i = 0; i < MAXPATHLEN - 1; i++)
365 longname[i] = 'a';
366 longname[MAXPATHLEN - 1] = '\0';
367 ATF_CHECK(load(NULL, false, "%s", longname) == ENAMETOOLONG);
368
369 ATF_CHECK(!k_helper_is_present(stat_check));
370 load(NULL, true, "%s/k_helper/k_helper.kmod",
371 atf_tc_get_config_var(tc, "srcdir"));
372 printf("Checking if load was successful\n");
373 ATF_CHECK(k_helper_is_present(stat_check));
374 }
ATF_TC_CLEANUP(cmd_load,tc)375 ATF_TC_CLEANUP(cmd_load, tc)
376 {
377 unload_cleanup("k_helper");
378 }
379
380 ATF_TC_WITH_CLEANUP(cmd_load_props);
ATF_TC_HEAD(cmd_load_props,tc)381 ATF_TC_HEAD(cmd_load_props, tc)
382 {
383 atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_LOAD command, "
384 "providing extra load-time properties");
385 atf_tc_set_md_var(tc, "require.user", "root");
386 }
ATF_TC_BODY(cmd_load_props,tc)387 ATF_TC_BODY(cmd_load_props, tc)
388 {
389 prop_dictionary_t props;
390
391 printf("Loading module without properties\n");
392 props = prop_dictionary_create();
393 load(props, true, "%s/k_helper/k_helper.kmod",
394 atf_tc_get_config_var(tc, "srcdir"));
395 prop_object_release(props);
396 {
397 int ok;
398 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_ok",
399 &ok, sizeof(ok)));
400 ATF_CHECK(!ok);
401 }
402 unload("k_helper", true);
403
404 printf("Loading module with a string property\n");
405 props = prop_dictionary_create();
406 prop_dictionary_set(props, "prop_str",
407 prop_string_create_cstring("1st string"));
408 load(props, true, "%s/k_helper/k_helper.kmod",
409 atf_tc_get_config_var(tc, "srcdir"));
410 prop_object_release(props);
411 {
412 int ok;
413 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_ok",
414 &ok, sizeof(ok)));
415 ATF_CHECK(ok);
416
417 char val[128];
418 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_val",
419 &val, sizeof(val)));
420 ATF_CHECK(strcmp(val, "1st string") == 0);
421 }
422 unload("k_helper", true);
423
424 printf("Loading module with a different string property\n");
425 props = prop_dictionary_create();
426 prop_dictionary_set(props, "prop_str",
427 prop_string_create_cstring("2nd string"));
428 load(props, true, "%s/k_helper/k_helper.kmod",
429 atf_tc_get_config_var(tc, "srcdir"));
430 prop_object_release(props);
431 {
432 int ok;
433 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_ok",
434 &ok, sizeof(ok)));
435 ATF_CHECK(ok);
436
437 char val[128];
438 ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_val",
439 &val, sizeof(val)));
440 ATF_CHECK(strcmp(val, "2nd string") == 0);
441 }
442 unload("k_helper", true);
443 }
ATF_TC_CLEANUP(cmd_load_props,tc)444 ATF_TC_CLEANUP(cmd_load_props, tc)
445 {
446 unload_cleanup("k_helper");
447 }
448
449 ATF_TC_WITH_CLEANUP(cmd_load_recurse);
ATF_TC_HEAD(cmd_load_recurse,tc)450 ATF_TC_HEAD(cmd_load_recurse, tc)
451 {
452 atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_LOAD command, "
453 "with recursive module_load()");
454 atf_tc_set_md_var(tc, "require.user", "root");
455 }
ATF_TC_BODY(cmd_load_recurse,tc)456 ATF_TC_BODY(cmd_load_recurse, tc)
457 {
458 prop_dictionary_t props;
459 char filename[MAXPATHLEN];
460
461 printf("Loading module with request to load another module\n");
462 props = prop_dictionary_create();
463 snprintf(filename, sizeof(filename), "%s/k_helper2/k_helper2.kmod",
464 atf_tc_get_config_var(tc, "srcdir"));
465 prop_dictionary_set(props, "prop_recurse",
466 prop_string_create_cstring(filename));
467 load(props, true, "%s/k_helper/k_helper.kmod",
468 atf_tc_get_config_var(tc, "srcdir"));
469 {
470 int ok;
471 ATF_CHECK(get_sysctl("vendor.k_helper.prop_int_load",
472 &ok, sizeof(ok)));
473 ATF_CHECK(ok == 0);
474 ATF_CHECK(get_sysctl("vendor.k_helper2.present",
475 &ok, sizeof(ok)));
476 ATF_CHECK(ok);
477 }
478 unload("k_helper", true);
479 unload("k_helper2", true);
480 }
ATF_TC_CLEANUP(cmd_load_recurse,tc)481 ATF_TC_CLEANUP(cmd_load_recurse, tc)
482 {
483 unload_cleanup("k_helper");
484 unload_cleanup("k_helper2");
485 }
486
487 ATF_TC_WITH_CLEANUP(cmd_stat);
ATF_TC_HEAD(cmd_stat,tc)488 ATF_TC_HEAD(cmd_stat, tc)
489 {
490 atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_STAT command");
491 atf_tc_set_md_var(tc, "require.user", "root");
492 }
ATF_TC_BODY(cmd_stat,tc)493 ATF_TC_BODY(cmd_stat, tc)
494 {
495 ATF_CHECK(!k_helper_is_present(all_checks));
496
497 load(NULL, true, "%s/k_helper/k_helper.kmod",
498 atf_tc_get_config_var(tc, "srcdir"));
499 ATF_CHECK(k_helper_is_present(all_checks));
500 {
501 modstat_t ms;
502 ATF_CHECK(get_modstat_info("k_helper", &ms));
503
504 ATF_CHECK(ms.ms_class == MODULE_CLASS_MISC);
505 ATF_CHECK(ms.ms_source == MODULE_SOURCE_FILESYS);
506 ATF_CHECK(ms.ms_refcnt == 0);
507 }
508 unload("k_helper", true);
509
510 ATF_CHECK(!k_helper_is_present(all_checks));
511 }
ATF_TC_CLEANUP(cmd_stat,tc)512 ATF_TC_CLEANUP(cmd_stat, tc)
513 {
514 unload_cleanup("k_helper");
515 }
516
517 ATF_TC_WITH_CLEANUP(cmd_unload);
ATF_TC_HEAD(cmd_unload,tc)518 ATF_TC_HEAD(cmd_unload, tc)
519 {
520 atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_UNLOAD command");
521 atf_tc_set_md_var(tc, "require.user", "root");
522 }
ATF_TC_BODY(cmd_unload,tc)523 ATF_TC_BODY(cmd_unload, tc)
524 {
525 load(NULL, true, "%s/k_helper/k_helper.kmod",
526 atf_tc_get_config_var(tc, "srcdir"));
527
528 ATF_CHECK(unload("", false) == ENOENT);
529 ATF_CHECK(unload("non-existent.kmod", false) == ENOENT);
530 ATF_CHECK(unload("k_helper.kmod", false) == ENOENT);
531
532 ATF_CHECK(k_helper_is_present(stat_check));
533 unload("k_helper", true);
534 printf("Checking if unload was successful\n");
535 ATF_CHECK(!k_helper_is_present(stat_check));
536 }
ATF_TC_CLEANUP(cmd_unload,tc)537 ATF_TC_CLEANUP(cmd_unload, tc)
538 {
539 unload_cleanup("k_helper");
540 }
541
542 /* --------------------------------------------------------------------- */
543 /* Main */
544 /* --------------------------------------------------------------------- */
545
ATF_TP_ADD_TCS(tp)546 ATF_TP_ADD_TCS(tp)
547 {
548
549 ATF_TP_ADD_TC(tp, cmd_load);
550 ATF_TP_ADD_TC(tp, cmd_load_props);
551 ATF_TP_ADD_TC(tp, cmd_stat);
552 ATF_TP_ADD_TC(tp, cmd_load_recurse);
553 ATF_TP_ADD_TC(tp, cmd_unload);
554
555 return atf_no_error();
556 }
557