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
47enum presence_check { both_checks, stat_check, sysctl_check };
48
49static void	check_permission(void);
50static bool	get_modstat_info(const char *, modstat_t *);
51static bool	get_sysctl(const char *, void *buf, const size_t);
52static bool	k_helper_is_present_stat(void);
53static bool	k_helper_is_present_sysctl(void);
54static bool	k_helper_is_present(enum presence_check);
55static int	load(prop_dictionary_t, bool, const char *, ...);
56static int	unload(const char *, bool);
57static 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 */
67static void
68check_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
82static bool
83get_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 */
128static bool
129get_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 */
147static bool
148k_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 */
159static bool
160k_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 */
173static bool
174k_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 */
205static __printflike(3, 4) int
206load(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 */
253static int
254unload(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 */
276static void
277unload_cleanup(const char *name)
278{
279
280	(void)modctl(MODCTL_UNLOAD, __UNCONST(name));
281}
282
283/* --------------------------------------------------------------------- */
284/* Test cases                                                            */
285/* --------------------------------------------------------------------- */
286
287ATF_TC_WITH_CLEANUP(cmd_load);
288ATF_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}
293ATF_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}
312ATF_TC_CLEANUP(cmd_load, tc)
313{
314	unload_cleanup("k_helper");
315}
316
317ATF_TC_WITH_CLEANUP(cmd_load_props);
318ATF_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}
324ATF_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}
381ATF_TC_CLEANUP(cmd_load_props, tc)
382{
383	unload_cleanup("k_helper");
384}
385
386ATF_TC_WITH_CLEANUP(cmd_load_recurse);
387ATF_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}
393ATF_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}
418ATF_TC_CLEANUP(cmd_load_recurse, tc)
419{
420	unload_cleanup("k_helper");
421	unload_cleanup("k_helper2");
422}
423
424ATF_TC_WITH_CLEANUP(cmd_stat);
425ATF_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}
430ATF_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}
449ATF_TC_CLEANUP(cmd_stat, tc)
450{
451	unload_cleanup("k_helper");
452}
453
454ATF_TC_WITH_CLEANUP(cmd_unload);
455ATF_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}
460ATF_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}
474ATF_TC_CLEANUP(cmd_unload, tc)
475{
476	unload_cleanup("k_helper");
477}
478
479/* --------------------------------------------------------------------- */
480/* Main                                                                  */
481/* --------------------------------------------------------------------- */
482
483ATF_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}
494