Minix/minix
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Importing NetBSD "Kyua" test framework

Browse Source 
To do so, a few dependencies have been imported:

 * external/bsd/lutok
 * external/mit/lua
 * external/public-domain/sqlite
 * external/public-domain/xz

The Kyua framework is the new generation of ATF (Automated Test
Framework), it is composed of:

 * external/bsd/atf
 * external/bsd/kyua-atf-compat
 * external/bsd/kyua-cli
 * external/bsd/kyua-tester
 * tests

Kyua/ATF being written in C++, it depends on libstdc++ which is
provided by GCC. As this is not part of the sources, Kyua is only
compiled when the native GCC utils are installed.

To install Kyua do the following:

 * In a cross-build enviromnent, add the following to the build.sh
   commandline: -V MKBINUTILS=yes -V MKGCCCMDS=yes

WARNING:
  At this point the import is still experimental, and not supported
  on native builds (a.k.a make build).

Change-Id: I26aee23c5bbd2d64adcb7c1beb98fe0d479d7ada
This commit is contained in:
Lionel Sambuc
2013-02-26 09:24:42 +01:00
committed by Gerrit Code Review
parent 003ff52ebb
commit 11be35a165
2893 changed files with 502052 additions and 2630 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
tests/modules/Makefile Normal file
View File

@@ -0,0 +1,25 @@
# $NetBSD: Makefile,v 1.10 2012/04/13 07:05:32 jruoho Exp $
.include <bsd.own.mk>
TESTSDIR= ${TESTSBASE}/modules
# Ideally this test could be in the parent Makefile, which could not descend
# into this directory at all. Unfortunately, the etc/mtree/NetBSD.dist file
# creates the 'modules' subdirectory unconditionally, which if left empty
# will confuse atf-run. Therefore we must install, at the very least, the
# Atffile into it.
TESTS_C= t_modctl
TESTS_C+= t_builtin
LDADD= -lprop
LDADD+= -lrumpfs_kernfs -lrumpvfs -lrump -lrumpuser -lpthread
TESTS_SH= t_abi_uvm
TESTS_SH+= t_modload
SUBDIR= k_helper
SUBDIR+= k_helper2
SUBDIR+= k_helper3
SUBDIR+= k_uvm
.include <bsd.test.mk>

1
tests/modules/Makefile.inc Normal file
View File

@@ -0,0 +1 @@
.include "../Makefile.inc"

14
tests/modules/k_helper/Makefile Normal file
View File

@@ -0,0 +1,14 @@
# $NetBSD: Makefile,v 1.5 2010/07/13 21:13:28 jmmv Exp $
.include <bsd.own.mk>
KMOD= k_helper
KMODULEDIR= ${DESTDIR}/${TESTSBASE}/modules/${KMOD}
SRCS= k_helper.c
ATFFILE= no
NOMAN= # defined
.include <bsd.test.mk>
.include <bsd.kmodule.mk>

202
tests/modules/k_helper/k_helper.c Normal file
View File

@@ -0,0 +1,202 @@
/* $NetBSD: k_helper.c,v 1.6 2012/06/03 10:59:44 dsl Exp $ */
/*
* Copyright (c) 2008 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: k_helper.c,v 1.6 2012/06/03 10:59:44 dsl Exp $");
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/sysctl.h>
#include <prop/proplib.h>
MODULE(MODULE_CLASS_MISC, k_helper, NULL);
/* --------------------------------------------------------------------- */
/* Sysctl interface to query information about the module. */
/* --------------------------------------------------------------------- */
/* TODO: Change the integer variables below that represent booleans to
* bools, once sysctl(8) supports CTLTYPE_BOOL nodes. */
static struct sysctllog *clogp;
static int present = 1;
static int prop_str_ok;
static char prop_str_val[128];
static int prop_int_ok;
static int64_t prop_int_val;
static int prop_int_load;
#define K_HELPER 0x12345678
#define K_HELPER_PRESENT 0
#define K_HELPER_PROP_STR_OK 1
#define K_HELPER_PROP_STR_VAL 2
#define K_HELPER_PROP_INT_OK 3
#define K_HELPER_PROP_INT_VAL 4
#define K_HELPER_PROP_INT_LOAD 5
SYSCTL_SETUP(sysctl_k_helper_setup, "sysctl k_helper subtree setup")
{
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_NODE, "k_helper", NULL,
NULL, 0, NULL, 0,
CTL_VENDOR, K_HELPER, CTL_EOL);
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_INT, "present",
SYSCTL_DESCR("Whether the module was loaded or not"),
NULL, 0, &present, 0,
CTL_VENDOR, K_HELPER, K_HELPER_PRESENT, CTL_EOL);
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_INT, "prop_str_ok",
SYSCTL_DESCR("String property's validity"),
NULL, 0, &prop_str_ok, 0,
CTL_VENDOR, K_HELPER, K_HELPER_PROP_STR_OK, CTL_EOL);
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_STRING, "prop_str_val",
SYSCTL_DESCR("String property's value"),
NULL, 0, prop_str_val, 0,
CTL_VENDOR, K_HELPER, K_HELPER_PROP_STR_VAL, CTL_EOL);
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_INT, "prop_int_ok",
SYSCTL_DESCR("String property's validity"),
NULL, 0, &prop_int_ok, 0,
CTL_VENDOR, K_HELPER, K_HELPER_PROP_INT_OK, CTL_EOL);
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_QUAD, "prop_int_val",
SYSCTL_DESCR("String property's value"),
NULL, 0, &prop_int_val, 0,
CTL_VENDOR, K_HELPER, K_HELPER_PROP_INT_VAL, CTL_EOL);
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_INT, "prop_int_load",
SYSCTL_DESCR("Status of recursive modload"),
NULL, 0, &prop_int_load, 0,
CTL_VENDOR, K_HELPER, K_HELPER_PROP_INT_LOAD, CTL_EOL);
}
/* --------------------------------------------------------------------- */
/* Module management. */
/* --------------------------------------------------------------------- */
static
int
k_helper_init(prop_dictionary_t props)
{
prop_object_t p;
p = prop_dictionary_get(props, "prop_str");
if (p == NULL)
prop_str_ok = 0;
else if (prop_object_type(p) != PROP_TYPE_STRING)
prop_str_ok = 0;
else {
const char *msg = prop_string_cstring_nocopy(p);
if (msg == NULL)
prop_str_ok = 0;
else {
strlcpy(prop_str_val, msg, sizeof(prop_str_val));
prop_str_ok = 1;
}
}
if (!prop_str_ok)
strlcpy(prop_str_val, "", sizeof(prop_str_val));
p = prop_dictionary_get(props, "prop_int");
if (p == NULL)
prop_int_ok = 0;
else if (prop_object_type(p) != PROP_TYPE_NUMBER)
prop_int_ok = 0;
else {
prop_int_val = prop_number_integer_value(p);
prop_int_ok = 1;
}
if (!prop_int_ok)
prop_int_val = -1;
p = prop_dictionary_get(props, "prop_recurse");
if (p != NULL && prop_object_type(p) == PROP_TYPE_STRING) {
const char *recurse_name = prop_string_cstring_nocopy(p);
if (recurse_name != NULL)
prop_int_load = module_load(recurse_name,
MODCTL_NO_PROP, NULL, MODULE_CLASS_ANY);
else
prop_int_load = -1;
} else
prop_int_load = -2;
sysctl_k_helper_setup(&clogp);
return 0;
}
static
int
k_helper_fini(void *arg)
{
sysctl_teardown(&clogp);
return 0;
}
static
int
k_helper_modcmd(modcmd_t cmd, void *arg)
{
int ret;
switch (cmd) {
case MODULE_CMD_INIT:
ret = k_helper_init(arg);
break;
case MODULE_CMD_FINI:
ret = k_helper_fini(arg);
break;
case MODULE_CMD_STAT:
default:
ret = ENOTTY;
}
return ret;
}

14
tests/modules/k_helper2/Makefile Normal file
View File

@@ -0,0 +1,14 @@
# $NetBSD: Makefile,v 1.1 2010/08/21 13:21:48 pgoyette Exp $
.include <bsd.own.mk>
KMOD= k_helper2
KMODULEDIR= ${DESTDIR}/${TESTSBASE}/modules/${KMOD}
SRCS= k_helper2.c
ATFFILE= no
NOMAN= # defined
.include <bsd.test.mk>
.include <bsd.kmodule.mk>

115
tests/modules/k_helper2/k_helper2.c Normal file
View File

@@ -0,0 +1,115 @@
/* $NetBSD: k_helper2.c,v 1.2 2010/11/03 16:10:23 christos Exp $ */
/*
* Copyright (c) 2010 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: k_helper2.c,v 1.2 2010/11/03 16:10:23 christos Exp $");
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/sysctl.h>
#include <prop/proplib.h>
MODULE(MODULE_CLASS_MISC, k_helper2, NULL);
/* --------------------------------------------------------------------- */
/* Sysctl interface to query information about the module. */
/* --------------------------------------------------------------------- */
/* TODO: Change the integer variables below that represent booleans to
* bools, once sysctl(8) supports CTLTYPE_BOOL nodes. */
static struct sysctllog *clogp;
static int present = 1;
#define K_HELPER2 0x23456781
#define K_HELPER_PRESENT 0
SYSCTL_SETUP(sysctl_k_helper2_setup, "sysctl k_helper subtree setup")
{
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_NODE, "k_helper2", NULL,
NULL, 0, NULL, 0,
CTL_VENDOR, K_HELPER2, CTL_EOL);
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_INT, "present",
SYSCTL_DESCR("Whether the module was loaded or not"),
NULL, 0, &present, 0,
CTL_VENDOR, K_HELPER2, K_HELPER_PRESENT, CTL_EOL);
}
/* --------------------------------------------------------------------- */
/* Module management. */
/* --------------------------------------------------------------------- */
static
int
k_helper2_init(prop_dictionary_t props)
{
sysctl_k_helper2_setup(&clogp);
return 0;
}
static
int
k_helper2_fini(void *arg)
{
sysctl_teardown(&clogp);
return 0;
}
static
int
k_helper2_modcmd(modcmd_t cmd, void *arg)
{
int ret;
switch (cmd) {
case MODULE_CMD_INIT:
ret = k_helper2_init(arg);
break;
case MODULE_CMD_FINI:
ret = k_helper2_fini(arg);
break;
case MODULE_CMD_STAT:
default:
ret = ENOTTY;
}
return ret;
}

14
tests/modules/k_helper3/Makefile Normal file
View File

@@ -0,0 +1,14 @@
# $NetBSD: Makefile,v 1.4 2012/04/14 02:46:17 pgoyette Exp $
.include <bsd.own.mk>
PROG= k_helper3
SRCS= k_helper3.c
BINDIR= ${TESTSBASE}/modules
LDADD+= -lprop
MAN= # defined
ATFFILE= no
.include <bsd.prog.mk>

102
tests/modules/k_helper3/k_helper3.c Normal file
View File

@@ -0,0 +1,102 @@
/* $NetBSD: k_helper3.c,v 1.3 2012/04/17 21:39:19 martin Exp $ */
/*-
* Copyright (c) 2012 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Jukka Ruohonen.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__RCSID("$NetBSD: k_helper3.c,v 1.3 2012/04/17 21:39:19 martin Exp $");
#include <sys/module.h>
#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <prop/proplib.h>
static int load(const char *, ...);
/*
* A program that loads a module and returns the errno(2) from modctl(8).
*/
int
main(int argc, char *argv[])
{
assert(argc == 3);
return load(argv[1], argv[2]);
}
static __printflike(1, 2) int
load(const char *fmt, ...)
{
char filename[MAXPATHLEN], *propsstr, *shortname, *dot;
prop_dictionary_t props;
modctl_load_t ml;
int serrno, rv;
va_list ap;
props = prop_dictionary_create();
propsstr = prop_dictionary_externalize(props);
assert(propsstr != NULL);
prop_object_release(props);
va_start(ap, fmt);
(void)vsnprintf(filename, sizeof(filename), fmt, ap);
va_end(ap);
ml.ml_filename = filename;
ml.ml_flags = 0;
ml.ml_props = propsstr;
ml.ml_propslen = strlen(propsstr);
printf("Loading module %s\n", filename);
errno = serrno = 0;
rv = modctl(MODCTL_LOAD, &ml);
if (rv != 0)
serrno = errno;
shortname = strrchr(filename, '/');
if (shortname != NULL)
shortname++;
else
shortname = filename;
dot = strrchr(shortname, '.');
if (dot)
*dot = 0;
(void)modctl(MODCTL_UNLOAD, shortname);
free(propsstr);
return serrno;
}

14
tests/modules/k_uvm/Makefile Normal file
View File

@@ -0,0 +1,14 @@
# $NetBSD: Makefile,v 1.1 2012/02/17 22:36:50 jmmv Exp $
.include <bsd.own.mk>
KMOD= k_uvm
KMODULEDIR= ${DESTDIR}/${TESTSBASE}/modules/${KMOD}
SRCS= k_uvm.c
ATFFILE= no
NOMAN= # defined
.include <bsd.test.mk>
.include <bsd.kmodule.mk>

113
tests/modules/k_uvm/k_uvm.c Normal file
View File

@@ -0,0 +1,113 @@
/* $NetBSD: k_uvm.c,v 1.1 2012/02/17 22:36:50 jmmv Exp $ */
/*
* Copyright (c) 2012 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: k_uvm.c,v 1.1 2012/02/17 22:36:50 jmmv Exp $");
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/sysctl.h>
MODULE(MODULE_CLASS_MISC, k_uvm, NULL);
/* --------------------------------------------------------------------- */
/* Sysctl interface to query information about the module. */
/* --------------------------------------------------------------------- */
static struct sysctllog *clogp;
static int page_size;
#define K_UVM 0x12345678
#define K_UVM_VALUE 0
SYSCTL_SETUP(sysctl_k_uvm_setup, "sysctl k_uvm subtree setup")
{
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_NODE, "k_uvm", NULL,
NULL, 0, NULL, 0,
CTL_VENDOR, K_UVM, CTL_EOL);
sysctl_createv(clog, 0, NULL, NULL,
CTLFLAG_PERMANENT,
CTLTYPE_INT, "page_size",
SYSCTL_DESCR("Value of PAGE_SIZE"),
NULL, 0, &page_size, 0,
CTL_VENDOR, K_UVM, K_UVM_VALUE, CTL_EOL);
}
/* --------------------------------------------------------------------- */
/* Module management. */
/* --------------------------------------------------------------------- */
static
int
k_uvm_init(prop_dictionary_t props)
{
page_size = PAGE_SIZE;
sysctl_k_uvm_setup(&clogp);
return 0;
}
static
int
k_uvm_fini(void *arg)
{
sysctl_teardown(&clogp);
return 0;
}
static
int
k_uvm_modcmd(modcmd_t cmd, void *arg)
{
int ret;
switch (cmd) {
case MODULE_CMD_INIT:
ret = k_uvm_init(arg);
break;
case MODULE_CMD_FINI:
ret = k_uvm_fini(arg);
break;
case MODULE_CMD_STAT:
default:
ret = ENOTTY;
}
return ret;
}

70
tests/modules/t_abi_uvm.sh Normal file
View File

@@ -0,0 +1,70 @@
# $NetBSD: t_abi_uvm.sh,v 1.3 2012/04/20 05:41:25 jruoho Exp $
#
# Copyright (c) 2012 The NetBSD Foundation, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
atf_test_case PAGE_SIZE cleanup
PAGE_SIZE_head() {
atf_set "descr" "Ensures that modules have access to PAGE_SIZE"
atf_set "require.user" "root"
}
PAGE_SIZE_body() {
# XXX: Adjust when modctl(8) fails consistently.
#
$(atf_get_srcdir)/k_helper3 \
"%s/k_helper/k_helper.kmod" $(atf_get_srcdir)
if [ $? -eq 1 ] || [ $? -eq 78 ]; then
atf_skip "host does not support modules"
fi
if modload $(atf_get_srcdir)/k_uvm/k_uvm.kmod; then
:
else
case "$(uname -m)" in
macppc)
atf_expect_fail "PR port-macppc/46041"
;;
esac
atf_fail "Failed to load k_uvm; missing uvmexp_pagesize?"
fi
kernel_pagesize="$(sysctl -n hw.pagesize || echo fail1)"
module_pagesize="$(sysctl -n vendor.k_uvm.page_size || echo fail2)"
echo "Kernel PAGE_SIZE: ${kernel_pagesize}"
echo "Module PAGE_SIZE: ${module_pagesize}"
atf_check_equal "${kernel_pagesize}" "${module_pagesize}"
atf_check -s eq:0 -o empty -e empty modunload k_uvm
}
PAGE_SIZE_cleanup() {
modunload k_uvm >/dev/null 2>&1 || true
}
atf_init_test_cases()
{
atf_add_test_case PAGE_SIZE
}

194
tests/modules/t_builtin.c Normal file
View File

@@ -0,0 +1,194 @@
/* $NetBSD: t_builtin.c,v 1.2 2010/11/03 16:10:23 christos Exp $ */
/*-
* Copyright (c) 2010 The NetBSD Foundation, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/types.h>
#include <sys/module.h>
#include <sys/mount.h>
#include <atf-c.h>
#include <fcntl.h>
#include <stdbool.h>
#include <miscfs/kernfs/kernfs.h>
#include <rump/rump.h>
#include <rump/rump_syscalls.h>
#include "../h_macros.h"
#define MYMP "/mnt"
#define HZFILE MYMP "/hz"
static char kernfs[] = "kernfs";
static bool
check_kernfs(void)
{
char buf[16];
bool rv = true;
int fd;
fd = rump_sys_open(HZFILE, O_RDONLY);
if (fd == -1)
return false;
if (rump_sys_read(fd, buf, sizeof(buf)) < 1)
rv = false;
RL(rump_sys_close(fd));
return rv;
}
ATF_TC(disable);
ATF_TC_HEAD(disable, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests that builtin modules can "
"be disabled");
}
ATF_TC_BODY(disable, tc)
{
rump_init();
RL(rump_sys_mkdir(MYMP, 0777));
RL(rump_sys_mount(MOUNT_KERNFS, MYMP, 0, NULL, 0));
ATF_REQUIRE(check_kernfs());
RL(rump_sys_unmount(MYMP, 0));
RL(rump_sys_modctl(MODCTL_UNLOAD, kernfs));
}
ATF_TC(noauto);
ATF_TC_HEAD(noauto, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests that disabled builtin modules "
"will not autoload");
}
ATF_TC_BODY(noauto, tc)
{
rump_init();
RL(rump_sys_mkdir(MYMP, 0777));
RL(rump_sys_modctl(MODCTL_UNLOAD, kernfs));
ATF_REQUIRE_ERRNO(ENODEV,
rump_sys_mount(MOUNT_KERNFS, MYMP, 0, NULL, 0) == -1);
}
ATF_TC(forcereload);
ATF_TC_HEAD(forcereload, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests that disabled builtin modules "
"can be force-reloaded");
}
ATF_TC_BODY(forcereload, tc)
{
struct modctl_load mod;
rump_init();
RL(rump_sys_mkdir(MYMP, 0777));
RL(rump_sys_modctl(MODCTL_UNLOAD, kernfs));
ATF_REQUIRE_ERRNO(ENODEV,
rump_sys_mount(MOUNT_KERNFS, MYMP, 0, NULL, 0) == -1);
memset(&mod, 0, sizeof(mod));
mod.ml_filename = kernfs;
mod.ml_flags = MODCTL_LOAD_FORCE;
RL(rump_sys_modctl(MODCTL_LOAD, &mod));
RL(rump_sys_mount(MOUNT_KERNFS, MYMP, 0, NULL, 0));
ATF_REQUIRE(check_kernfs());
RL(rump_sys_unmount(MYMP, 0));
}
ATF_TC(disabledstat);
ATF_TC_HEAD(disabledstat, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests that disabled builtin modules "
"show up in modstat with refcount -1");
}
ATF_TC_BODY(disabledstat, tc)
{
struct modstat ms[128];
struct iovec iov;
size_t i;
bool found = false;
rump_init();
RL(rump_sys_mkdir(MYMP, 0777));
RL(rump_sys_modctl(MODCTL_UNLOAD, kernfs));
iov.iov_base = ms;
iov.iov_len = sizeof(ms);
RL(rump_sys_modctl(MODCTL_STAT, &iov));
for (i = 0; i < __arraycount(ms); i++) {
if (strcmp(ms[i].ms_name, kernfs) == 0) {
ATF_REQUIRE_EQ(ms[i].ms_refcnt, (u_int)-1);
found = 1;
break;
}
}
ATF_REQUIRE(found);
}
ATF_TC(busydisable);
ATF_TC_HEAD(busydisable, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests that busy builtin modules "
"cannot be disabled");
}
ATF_TC_BODY(busydisable, tc)
{
rump_init();
RL(rump_sys_mkdir(MYMP, 0777));
RL(rump_sys_mount(MOUNT_KERNFS, MYMP, 0, NULL, 0));
ATF_REQUIRE(check_kernfs());
ATF_REQUIRE_ERRNO(EBUSY,
rump_sys_modctl(MODCTL_UNLOAD, kernfs) == -1);
}
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, disable);
ATF_TP_ADD_TC(tp, noauto);
ATF_TP_ADD_TC(tp, forcereload);
ATF_TP_ADD_TC(tp, disabledstat);
ATF_TP_ADD_TC(tp, busydisable);
return atf_no_error();
}

493
tests/modules/t_modctl.c Normal file
View File

@@ -0,0 +1,493 @@
/* $NetBSD: t_modctl.c,v 1.12 2012/08/20 08:07:52 martin Exp $ */
/*
* Copyright (c) 2008 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: t_modctl.c,v 1.12 2012/08/20 08:07:52 martin Exp $");
#include <sys/module.h>
#include <sys/sysctl.h>
#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <prop/proplib.h>
#include <atf-c.h>
enum presence_check { both_checks, stat_check, sysctl_check };
static void check_permission(void);
static bool get_modstat_info(const char *, modstat_t *);
static bool get_sysctl(const char *, void *buf, const size_t);
static bool k_helper_is_present_stat(void);
static bool k_helper_is_present_sysctl(void);
static bool k_helper_is_present(enum presence_check);
static int load(prop_dictionary_t, bool, const char *, ...);
static int unload(const char *, bool);
static void unload_cleanup(const char *);
/* --------------------------------------------------------------------- */
/* Auxiliary functions */
/* --------------------------------------------------------------------- */
/*
* A function checking wether we are allowed to load modules currently
* (either the kernel is not modular, or securelevel may prevent it)
*/
static void
check_permission(void)
{
int err;
err = modctl(MODCTL_EXISTS, 0);
if (err == 0) return;
if (errno == ENOSYS)
atf_tc_skip("Kernel does not have 'options MODULAR'.");
else if (errno == EPERM)
atf_tc_skip("Module loading administratively forbidden");
ATF_REQUIRE_EQ_MSG(errno, 0, "unexpected error %d from "
"modctl(MODCTL_EXISTS, 0)", errno);
}
static bool
get_modstat_info(const char *name, modstat_t *msdest)
{
bool found;
size_t len;
struct iovec iov;
modstat_t *ms;
check_permission();
for (len = 4096; ;) {
iov.iov_base = malloc(len);
iov.iov_len = len;
errno = 0;
if (modctl(MODCTL_STAT, &iov) != 0) {
int err = errno;
fprintf(stderr, "modctl(MODCTL_STAT) failed: %s\n",
strerror(err));
atf_tc_fail("Failed to query module status");
}
if (len >= iov.iov_len)
break;
free(iov.iov_base);
len = iov.iov_len;
}
found = false;
len = iov.iov_len / sizeof(modstat_t);
for (ms = (modstat_t *)iov.iov_base; len != 0 && !found;
ms++, len--) {
if (strcmp(ms->ms_name, name) == 0) {
if (msdest != NULL)
*msdest = *ms;
found = true;
}
}
free(iov.iov_base);
return found;
}
/*
* Queries a sysctl property.
*/
static bool
get_sysctl(const char *name, void *buf, const size_t len)
{
size_t len2 = len;
printf("Querying sysctl variable: %s\n", name);
int ret = sysctlbyname(name, buf, &len2, NULL, 0);
if (ret == -1 && errno != ENOENT) {
fprintf(stderr, "sysctlbyname(2) failed: %s\n",
strerror(errno));
atf_tc_fail("Failed to query %s", name);
}
return ret != -1;
}
/*
* Returns a boolean indicating if the k_helper module was loaded
* successfully. This implementation uses modctl(2)'s MODCTL_STAT
* subcommand to do the check.
*/
static bool
k_helper_is_present_stat(void)
{
return get_modstat_info("k_helper", NULL);
}
/*
* Returns a boolean indicating if the k_helper module was loaded
* successfully. This implementation uses the module's sysctl
* installed node to do the check.
*/
static bool
k_helper_is_present_sysctl(void)
{
size_t present;
return get_sysctl("vendor.k_helper.present", &present,
sizeof(present));
}
/*
* Returns a boolean indicating if the k_helper module was loaded
* successfully. The 'how' parameter specifies the implementation to
* use to do the check.
*/
static bool
k_helper_is_present(enum presence_check how)
{
bool found;
switch (how) {
case both_checks:
found = k_helper_is_present_stat();
ATF_CHECK(k_helper_is_present_sysctl() == found);
break;
case stat_check:
found = k_helper_is_present_stat();
break;
case sysctl_check:
found = k_helper_is_present_sysctl();
break;
default:
found = false;
assert(found);
}
return found;
}
/*
* Loads the specified module from a file. If fatal is set and an error
* occurs when loading the module, an error message is printed and the
* test case is aborted.
*/
static __printflike(3, 4) int
load(prop_dictionary_t props, bool fatal, const char *fmt, ...)
{
int err;
va_list ap;
char filename[MAXPATHLEN], *propsstr;
modctl_load_t ml;
check_permission();
if (props == NULL) {
props = prop_dictionary_create();
propsstr = prop_dictionary_externalize(props);
ATF_CHECK(propsstr != NULL);
prop_object_release(props);
} else {
propsstr = prop_dictionary_externalize(props);
ATF_CHECK(propsstr != NULL);
}
va_start(ap, fmt);
vsnprintf(filename, sizeof(filename), fmt, ap);
va_end(ap);
ml.ml_filename = filename;
ml.ml_flags = 0;
ml.ml_props = propsstr;
ml.ml_propslen = strlen(propsstr);
printf("Loading module %s\n", filename);
errno = err = 0;
if (modctl(MODCTL_LOAD, &ml) == -1) {
err = errno;
fprintf(stderr, "modctl(MODCTL_LOAD, %s), failed: %s\n",
filename, strerror(err));
if (fatal)
atf_tc_fail("Module load failed");
}
free(propsstr);
return err;
}
/*
* Unloads the specified module. If silent is true, nothing will be
* printed and no errors will be raised if the unload was unsuccessful.
*/
static int
unload(const char *name, bool fatal)
{
int err;
check_permission();
printf("Unloading module %s\n", name);
errno = err = 0;
if (modctl(MODCTL_UNLOAD, __UNCONST(name)) == -1) {
err = errno;
fprintf(stderr, "modctl(MODCTL_UNLOAD, %s) failed: %s\n",
name, strerror(err));
if (fatal)
atf_tc_fail("Module unload failed");
}
return err;
}
/*
* A silent version of unload, to be called as part of the cleanup
* process only.
*/
static void
unload_cleanup(const char *name)
{
(void)modctl(MODCTL_UNLOAD, __UNCONST(name));
}
/* --------------------------------------------------------------------- */
/* Test cases */
/* --------------------------------------------------------------------- */
ATF_TC_WITH_CLEANUP(cmd_load);
ATF_TC_HEAD(cmd_load, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_LOAD command");
atf_tc_set_md_var(tc, "require.user", "root");
}
ATF_TC_BODY(cmd_load, tc)
{
char longname[MAXPATHLEN];
size_t i;
ATF_CHECK(load(NULL, false, " ") == ENOENT);
ATF_CHECK(load(NULL, false, "non-existent.o") == ENOENT);
for (i = 0; i < MAXPATHLEN - 1; i++)
longname[i] = 'a';
longname[MAXPATHLEN - 1] = '\0';
ATF_CHECK(load(NULL, false, "%s", longname) == ENAMETOOLONG);
ATF_CHECK(!k_helper_is_present(stat_check));
load(NULL, true, "%s/k_helper/k_helper.kmod",
atf_tc_get_config_var(tc, "srcdir"));
printf("Checking if load was successful\n");
ATF_CHECK(k_helper_is_present(stat_check));
}
ATF_TC_CLEANUP(cmd_load, tc)
{
unload_cleanup("k_helper");
}
ATF_TC_WITH_CLEANUP(cmd_load_props);
ATF_TC_HEAD(cmd_load_props, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_LOAD command, "
"providing extra load-time properties");
atf_tc_set_md_var(tc, "require.user", "root");
}
ATF_TC_BODY(cmd_load_props, tc)
{
prop_dictionary_t props;
printf("Loading module without properties\n");
props = prop_dictionary_create();
load(props, true, "%s/k_helper/k_helper.kmod",
atf_tc_get_config_var(tc, "srcdir"));
prop_object_release(props);
{
int ok;
ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_ok",
&ok, sizeof(ok)));
ATF_CHECK(!ok);
}
unload("k_helper", true);
printf("Loading module with a string property\n");
props = prop_dictionary_create();
prop_dictionary_set(props, "prop_str",
prop_string_create_cstring("1st string"));
load(props, true, "%s/k_helper/k_helper.kmod",
atf_tc_get_config_var(tc, "srcdir"));
prop_object_release(props);
{
int ok;
ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_ok",
&ok, sizeof(ok)));
ATF_CHECK(ok);
char val[128];
ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_val",
&val, sizeof(val)));
ATF_CHECK(strcmp(val, "1st string") == 0);
}
unload("k_helper", true);
printf("Loading module with a different string property\n");
props = prop_dictionary_create();
prop_dictionary_set(props, "prop_str",
prop_string_create_cstring("2nd string"));
load(props, true, "%s/k_helper/k_helper.kmod",
atf_tc_get_config_var(tc, "srcdir"));
prop_object_release(props);
{
int ok;
ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_ok",
&ok, sizeof(ok)));
ATF_CHECK(ok);
char val[128];
ATF_CHECK(get_sysctl("vendor.k_helper.prop_str_val",
&val, sizeof(val)));
ATF_CHECK(strcmp(val, "2nd string") == 0);
}
unload("k_helper", true);
}
ATF_TC_CLEANUP(cmd_load_props, tc)
{
unload_cleanup("k_helper");
}
ATF_TC_WITH_CLEANUP(cmd_load_recurse);
ATF_TC_HEAD(cmd_load_recurse, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_LOAD command, "
"with recursive module_load()");
atf_tc_set_md_var(tc, "require.user", "root");
}
ATF_TC_BODY(cmd_load_recurse, tc)
{
prop_dictionary_t props;
char filename[MAXPATHLEN];
printf("Loading module with request to load another module\n");
props = prop_dictionary_create();
snprintf(filename, sizeof(filename), "%s/k_helper2/k_helper2.kmod",
atf_tc_get_config_var(tc, "srcdir"));
prop_dictionary_set(props, "prop_recurse",
prop_string_create_cstring(filename));
load(props, true, "%s/k_helper/k_helper.kmod",
atf_tc_get_config_var(tc, "srcdir"));
{
int ok;
ATF_CHECK(get_sysctl("vendor.k_helper.prop_int_load",
&ok, sizeof(ok)));
ATF_CHECK(ok == 0);
ATF_CHECK(get_sysctl("vendor.k_helper2.present",
&ok, sizeof(ok)));
ATF_CHECK(ok);
}
unload("k_helper", true);
unload("k_helper2", true);
}
ATF_TC_CLEANUP(cmd_load_recurse, tc)
{
unload_cleanup("k_helper");
unload_cleanup("k_helper2");
}
ATF_TC_WITH_CLEANUP(cmd_stat);
ATF_TC_HEAD(cmd_stat, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_STAT command");
atf_tc_set_md_var(tc, "require.user", "root");
}
ATF_TC_BODY(cmd_stat, tc)
{
ATF_CHECK(!k_helper_is_present(both_checks));
load(NULL, true, "%s/k_helper/k_helper.kmod",
atf_tc_get_config_var(tc, "srcdir"));
ATF_CHECK(k_helper_is_present(both_checks));
{
modstat_t ms;
ATF_CHECK(get_modstat_info("k_helper", &ms));
ATF_CHECK(ms.ms_class == MODULE_CLASS_MISC);
ATF_CHECK(ms.ms_source == MODULE_SOURCE_FILESYS);
ATF_CHECK(ms.ms_refcnt == 0);
}
unload("k_helper", true);
ATF_CHECK(!k_helper_is_present(both_checks));
}
ATF_TC_CLEANUP(cmd_stat, tc)
{
unload_cleanup("k_helper");
}
ATF_TC_WITH_CLEANUP(cmd_unload);
ATF_TC_HEAD(cmd_unload, tc)
{
atf_tc_set_md_var(tc, "descr", "Tests for the MODCTL_UNLOAD command");
atf_tc_set_md_var(tc, "require.user", "root");
}
ATF_TC_BODY(cmd_unload, tc)
{
load(NULL, true, "%s/k_helper/k_helper.kmod",
atf_tc_get_config_var(tc, "srcdir"));
ATF_CHECK(unload("", false) == ENOENT);
ATF_CHECK(unload("non-existent.kmod", false) == ENOENT);
ATF_CHECK(unload("k_helper.kmod", false) == ENOENT);
ATF_CHECK(k_helper_is_present(stat_check));
unload("k_helper", true);
printf("Checking if unload was successful\n");
ATF_CHECK(!k_helper_is_present(stat_check));
}
ATF_TC_CLEANUP(cmd_unload, tc)
{
unload_cleanup("k_helper");
}
/* --------------------------------------------------------------------- */
/* Main */
/* --------------------------------------------------------------------- */
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, cmd_load);
ATF_TP_ADD_TC(tp, cmd_load_props);
ATF_TP_ADD_TC(tp, cmd_stat);
ATF_TP_ADD_TC(tp, cmd_load_recurse);
ATF_TP_ADD_TC(tp, cmd_unload);
return atf_no_error();
}

205
tests/modules/t_modload.sh Normal file
View File

@@ -0,0 +1,205 @@
# $NetBSD: t_modload.sh,v 1.13 2012/04/20 05:41:25 jruoho Exp $
#
# Copyright (c) 2008 The NetBSD Foundation, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
check_sysctl() {
echo "${1} = ${2}" >expout
atf_check -s eq:0 -o file:expout -e empty sysctl ${1}
}
atf_test_case plain cleanup
plain_head() {
atf_set "descr" "Test load without arguments"
atf_set "require.user" "root"
}
plain_body() {
# XXX: Adjust when modctl(8) fails consistently.
#
$(atf_get_srcdir)/k_helper3 \
"%s/k_helper/k_helper.kmod" $(atf_get_srcdir)
if [ $? -eq 1 ] || [ $? -eq 78 ]; then
atf_skip "host does not support modules"
fi
cat >experr <<EOF
modload: No such file or directory
EOF
atf_check -s eq:1 -o empty -e ignore modload non-existent.o
atf_check -s eq:0 -o empty -e empty \
modload $(atf_get_srcdir)/k_helper/k_helper.kmod
check_sysctl vendor.k_helper.present 1
check_sysctl vendor.k_helper.prop_int_ok 0
check_sysctl vendor.k_helper.prop_str_ok 0
atf_check -s eq:0 -o empty -e empty modunload k_helper
touch done
}
plain_cleanup() {
test -f done || modunload k_helper >/dev/null 2>&1
}
atf_test_case bflag cleanup
bflag_head() {
atf_set "descr" "Test the -b flag"
atf_set "require.user" "root"
}
bflag_body() {
echo "Checking error conditions"
atf_check -s eq:1 -o empty -e save:stderr \
modload -b foo k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid parameter.*foo' stderr
atf_check -s eq:1 -o empty -e save:stderr \
modload -b foo= k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid boolean value' stderr
atf_check -s eq:1 -o empty -e save:stderr \
modload -b foo=bar k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid boolean value.*bar' stderr
atf_check -s eq:1 -o empty -e save:stderr \
modload -b foo=falsea k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid boolean value.*falsea' stderr
atf_check -s eq:1 -o empty -e save:stderr \
modload -b foo=truea k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid boolean value.*truea' stderr
# TODO Once sysctl(8) supports CTLTYPE_BOOL nodes.
#echo "Checking valid values"
}
bflag_cleanup() {
modunload k_helper >/dev/null 2>&1 || true
}
atf_test_case iflag cleanup
iflag_head() {
atf_set "descr" "Test the -i flag"
atf_set "require.user" "root"
}
iflag_body() {
# XXX: Adjust when modctl(8) fails consistently.
#
$(atf_get_srcdir)/k_helper3 \
"%s/k_helper/k_helper.kmod" $(atf_get_srcdir)
if [ $? -eq 1 ] || [ $? -eq 78 ]; then
atf_skip "host does not support modules"
fi
echo "Checking error conditions"
atf_check -s eq:1 -o empty -e save:stderr modload -i foo \
k_helper/k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid parameter.*foo' stderr
atf_check -s eq:1 -o empty -e save:stderr modload -i foo= \
k_helper/k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid integer value' stderr
atf_check -s eq:1 -o empty -e save:stderr \
modload -i foo=bar k_helper/k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid integer value.*bar' stderr
atf_check -s eq:1 -o empty -e save:stderr \
modload -i foo=123a k_helper/k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid integer value.*123a' stderr
echo "Checking valid values"
for v in 5 10; do
atf_check -s eq:0 -o empty -e empty \
modload -i prop_int="${v}" \
$(atf_get_srcdir)/k_helper/k_helper.kmod
check_sysctl vendor.k_helper.prop_int_ok 1
check_sysctl vendor.k_helper.prop_int_val "${v}"
atf_check -s eq:0 -o empty -e empty modunload k_helper
done
touch done
}
iflag_cleanup() {
test -f done || modunload k_helper >/dev/null 2>&1
}
atf_test_case sflag cleanup
sflag_head() {
atf_set "descr" "Test the -s flag"
atf_set "require.user" "root"
}
sflag_body() {
# XXX: Adjust when modctl(8) fails consistently.
#
$(atf_get_srcdir)/k_helper3 \
"%s/k_helper/k_helper.kmod" $(atf_get_srcdir)
if [ $? -eq 1 ] || [ $? -eq 78 ]; then
atf_skip "host does not support modules"
fi
echo "Checking error conditions"
atf_check -s eq:1 -o empty -e save:stderr modload -s foo \
k_helper/k_helper.kmod
atf_check -s eq:0 -o ignore -e empty \
grep 'Invalid parameter.*foo' stderr
echo "Checking valid values"
for v in '1st string' '2nd string'; do
atf_check -s eq:0 -o empty -e empty \
modload -s prop_str="${v}" \
$(atf_get_srcdir)/k_helper/k_helper.kmod
check_sysctl vendor.k_helper.prop_str_ok 1
check_sysctl vendor.k_helper.prop_str_val "${v}"
atf_check -s eq:0 -o empty -e empty modunload k_helper
done
touch done
}
sflag_cleanup() {
test -f done || modunload k_helper >/dev/null 2>&1
}
atf_init_test_cases()
{
atf_add_test_case plain
atf_add_test_case bflag
atf_add_test_case iflag
atf_add_test_case sflag
}