diff --git a/sys/modules/ktest/Makefile b/sys/modules/ktest/Makefile --- a/sys/modules/ktest/Makefile +++ b/sys/modules/ktest/Makefile @@ -2,6 +2,7 @@ .include "${SYSDIR}/conf/kern.opts.mk" SUBDIR= ktest \ - ktest_example + ktest_example \ + ktest_netlink_message_writer .include diff --git a/sys/modules/ktest/ktest_example/Makefile b/sys/modules/ktest/ktest_example/Makefile --- a/sys/modules/ktest/ktest_example/Makefile +++ b/sys/modules/ktest/ktest_example/Makefile @@ -9,5 +9,6 @@ KMOD= ktest_example SRCS= ktest_example.c +SRCS+= opt_netlink.h .include diff --git a/sys/modules/ktest/ktest_netlink_message_writer/Makefile b/sys/modules/ktest/ktest_netlink_message_writer/Makefile new file mode 100644 --- /dev/null +++ b/sys/modules/ktest/ktest_netlink_message_writer/Makefile @@ -0,0 +1,15 @@ +# $FreeBSD$ + +PACKAGE= tests + +SYSDIR?=${SRCTOP}/sys +.include "${SYSDIR}/conf/kern.opts.mk" + +.PATH: ${SYSDIR}/netlink + +KMOD= ktest_netlink_message_writer +SRCS= ktest_netlink_message_writer.c +SRCS+= opt_netlink.h + +.include + diff --git a/sys/netlink/ktest_netlink_message_writer.h b/sys/netlink/ktest_netlink_message_writer.h new file mode 100644 --- /dev/null +++ b/sys/netlink/ktest_netlink_message_writer.h @@ -0,0 +1,53 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (c) 2023 Alexander V. Chernikov + * + * 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 AUTHOR 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 AUTHOR 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. + */ + +#ifndef _NETLINK_KTEST_NETLINK_MESSAGE_WRITER_H_ +#define _NETLINK_KTEST_NETLINK_MESSAGE_WRITER_H_ + +#if defined(_KERNEL) && defined(INVARIANTS) + +bool nlmsg_get_buf_type_wrapper(struct nl_writer *nw, int size, int type, bool waitok); +void nlmsg_set_callback_wrapper(struct nl_writer *nw); + +#ifndef KTEST_CALLER + +bool +nlmsg_get_buf_type_wrapper(struct nl_writer *nw, int size, int type, bool waitok) +{ + return (nlmsg_get_buf_type(nw, size, type, waitok)); +} + +void +nlmsg_set_callback_wrapper(struct nl_writer *nw) +{ + nlmsg_set_callback(nw); +} +#endif + +#endif + +#endif diff --git a/sys/netlink/ktest_netlink_message_writer.c b/sys/netlink/ktest_netlink_message_writer.c new file mode 100644 --- /dev/null +++ b/sys/netlink/ktest_netlink_message_writer.c @@ -0,0 +1,121 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (c) 2023 Alexander V. Chernikov + * + * 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 AUTHOR 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 AUTHOR 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 "opt_netlink.h" + +#include +#include +#include +#include +#include +#include +#include + +#define KTEST_CALLER +#include + +#ifdef INVARIANTS + +struct test_mbuf_attrs { + uint32_t size; + uint32_t expected_avail; + uint32_t wtype; + int waitok; +}; + +#define _OUT(_field) offsetof(struct test_mbuf_attrs, _field) +static const struct nlattr_parser nla_p_mbuf_w[] = { + { .type = 1, .off = _OUT(size), .cb = nlattr_get_uint32 }, + { .type = 2, .off = _OUT(expected_avail), .cb = nlattr_get_uint32 }, + { .type = 3, .off = _OUT(wtype), .cb = nlattr_get_uint32 }, + { .type = 4, .off = _OUT(waitok), .cb = nlattr_get_uint32 }, +}; +#undef _OUT +NL_DECLARE_ATTR_PARSER(mbuf_w_parser, nla_p_mbuf_w); + +static int +test_mbuf_writer_parser(struct ktest_test_context *ctx, struct nlattr *nla) +{ + struct test_mbuf_attrs *attrs = npt_alloc(ctx->npt, sizeof(*attrs)); + + ctx->arg = attrs; + if (attrs != NULL) + return (nl_parse_nested(nla, &mbuf_w_parser, ctx->npt, attrs)); + return (ENOMEM); +} + +static int +test_mbuf_writer(struct ktest_test_context *ctx) +{ + struct test_mbuf_attrs *attrs = ctx->arg; + bool ret; + struct nl_writer nw = {}; + + ret = nlmsg_get_buf_type_wrapper(&nw, attrs->size, attrs->wtype, attrs->waitok); + if (!ret) + return (EINVAL); + + int alloc_len = nw.alloc_len; + KTEST_LOG(ctx, "requested %u, allocated %d", attrs->size, alloc_len); + + /* Set cleanup callback */ + nw.writer_target = NS_WRITER_TARGET_SOCKET; + nlmsg_set_callback_wrapper(&nw); + + /* Mark enomem to avoid reallocation */ + nw.enomem = true; + + if (nlmsg_reserve_data(&nw, alloc_len, void *) == NULL) { + KTEST_LOG(ctx, "unable to get %d bytes from the writer", alloc_len); + return (EINVAL); + } + + /* Mark as empty to free the storage */ + nw.offset = 0; + nlmsg_flush(&nw); + + if (alloc_len < attrs->expected_avail) { + KTEST_LOG(ctx, "alloc_len %d, expected %u", + alloc_len, attrs->expected_avail); + return (EINVAL); + } + + return (0); +} +#endif + +static const struct ktest_test_info tests[] = { +//#ifdef INVARIANTS + { + .name = "test_mbuf_writer", + .desc = "test different mbuf sizes in the mbuf writer", + .func = &test_mbuf_writer, + .parse = &test_mbuf_writer_parser, + }, +//#endif +}; +KTEST_MODULE_DECLARE(ktest_netlink_message_writer, tests); diff --git a/sys/netlink/netlink_message_writer.c b/sys/netlink/netlink_message_writer.c --- a/sys/netlink/netlink_message_writer.c +++ b/sys/netlink/netlink_message_writer.c @@ -196,17 +196,23 @@ * This is the most efficient mechanism as it avoids double-copying. * * Allocates a single mbuf suitable to store up to @size bytes of data. - * If size < MHLEN (around 160 bytes), allocates mbuf with pkghdr - * If size <= MCLBYTES (2k), allocate a single mbuf cluster - * Otherwise, return NULL. + * If the allocation fails, tries to allocate mbuf from all available larger zones. + * returns NULL on final failure. */ static bool nlmsg_get_ns_mbuf(struct nl_writer *nw, int size, bool waitok) { - struct mbuf *m; - + size_t mbuf_sizes[] = { MHLEN, MCLBYTES, MJUMPAGESIZE, MJUM9BYTES, MJUM16BYTES }; int mflag = waitok ? M_WAITOK : M_NOWAIT; - m = m_get2(size, mflag, MT_DATA, M_PKTHDR); + struct mbuf *m = NULL; + + for (int i = 0; i < nitems(mbuf_sizes); i++) { + if (size <= mbuf_sizes[i]) { + m = m_get3(mbuf_sizes[i], mflag, MT_DATA, M_PKTHDR); + if (m != NULL) + break; + } + } if (__predict_false(m == NULL)) return (false); nw->alloc_len = M_TRAILINGSPACE(m); @@ -691,3 +697,5 @@ return (true); } + +#include diff --git a/sys/tests/ktest.h b/sys/tests/ktest.h --- a/sys/tests/ktest.h +++ b/sys/tests/ktest.h @@ -94,7 +94,7 @@ }; \ \ static moduledata_t _module_data = { \ - "__" #_n "_module", \ + #_n, \ ktest_default_modevent, \ &_module_info, \ }; \ @@ -102,6 +102,7 @@ DECLARE_MODULE(ktest_##_n, _module_data, SI_SUB_PSEUDO, SI_ORDER_ANY); \ MODULE_VERSION(ktest_##_n, 1); \ MODULE_DEPEND(ktest_##_n, ktestmod, 1, 1, 1); \ +MODULE_DEPEND(ktest_##_n, netlink, 1, 1, 1); \ #endif /* _KERNEL */ diff --git a/tests/atf_python/ktest.py b/tests/atf_python/ktest.py --- a/tests/atf_python/ktest.py +++ b/tests/atf_python/ktest.py @@ -91,7 +91,7 @@ ret = [] for rx_msg in NetlinkMultipartIterator(self.nlsock, nlmsg_seq, self.family_id): - # test_msg.print_message() + # rx_msg.print_message() tst = { "mod_name": rx_msg.get_nla(KtestAttrType.KTEST_ATTR_MOD_NAME).text, "name": rx_msg.get_nla(KtestAttrType.KTEST_ATTR_TEST_NAME).text, diff --git a/tests/sys/netlink/Makefile b/tests/sys/netlink/Makefile --- a/tests/sys/netlink/Makefile +++ b/tests/sys/netlink/Makefile @@ -11,6 +11,7 @@ ATF_TESTS_PYTEST += test_rtnl_ifaddr.py ATF_TESTS_PYTEST += test_rtnl_neigh.py ATF_TESTS_PYTEST += test_rtnl_route.py +ATF_TESTS_PYTEST += test_netlink_message_writer.py CFLAGS+= -I${.CURDIR:H:H:H}