diff options
Diffstat (limited to 'sys/netlink/netlink_module.c')
| -rw-r--r-- | sys/netlink/netlink_module.c | 221 |
1 files changed, 221 insertions, 0 deletions
diff --git a/sys/netlink/netlink_module.c b/sys/netlink/netlink_module.c new file mode 100644 index 000000000000..6c3cd90e61ab --- /dev/null +++ b/sys/netlink/netlink_module.c @@ -0,0 +1,221 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (c) 2021 Ng Peng Nam Sean + * Copyright (c) 2022 Alexander V. Chernikov <melifaro@FreeBSD.org> + * + * 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 <sys/param.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/module.h> + +#include <sys/lock.h> +#include <sys/rmlock.h> +#include <sys/ck.h> +#include <sys/syslog.h> + +#include <netlink/netlink.h> +#include <netlink/netlink_ctl.h> +#include <netlink/netlink_var.h> +#include <netlink/route/route_var.h> + +#include <machine/atomic.h> + +FEATURE(netlink, "Netlink support"); + +#define DEBUG_MOD_NAME nl_mod +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include <netlink/netlink_debug.h> +_DECLARE_DEBUG(LOG_INFO); + + +#define NL_MAX_HANDLERS 20 +struct nl_proto_handler _nl_handlers[NL_MAX_HANDLERS]; +struct nl_proto_handler *nl_handlers = _nl_handlers; + +CK_LIST_HEAD(nl_control_head, nl_control); +static struct nl_control_head vnets_head = CK_LIST_HEAD_INITIALIZER(); + +VNET_DEFINE(struct nl_control, nl_ctl) = { + .ctl_port_head = CK_LIST_HEAD_INITIALIZER(), + .ctl_pcb_head = CK_LIST_HEAD_INITIALIZER(), +}; + +struct mtx nl_global_mtx; +MTX_SYSINIT(nl_global_mtx, &nl_global_mtx, "global netlink lock", MTX_DEF); + +#define NL_GLOBAL_LOCK() mtx_lock(&nl_global_mtx) +#define NL_GLOBAL_UNLOCK() mtx_unlock(&nl_global_mtx) + +int netlink_unloading = 0; + +static void +vnet_nl_init(const void *unused __unused) +{ + rm_init(&V_nl_ctl.ctl_lock, "netlink lock"); + + NL_GLOBAL_LOCK(); + CK_LIST_INSERT_HEAD(&vnets_head, &V_nl_ctl, ctl_next); + NL_LOG(LOG_DEBUG2, "VNET %p init done, inserted %p into global list", + curvnet, &V_nl_ctl); + NL_GLOBAL_UNLOCK(); +} +VNET_SYSINIT(vnet_nl_init, SI_SUB_INIT_IF, SI_ORDER_FIRST, vnet_nl_init, NULL); + +static void +vnet_nl_uninit(const void *unused __unused) +{ + /* Assume at the time all of the processes / sockets are dead */ + NL_GLOBAL_LOCK(); + NL_LOG(LOG_DEBUG2, "Removing %p from global list", &V_nl_ctl); + CK_LIST_REMOVE(&V_nl_ctl, ctl_next); + NL_GLOBAL_UNLOCK(); + + rm_destroy(&V_nl_ctl.ctl_lock); +} +VNET_SYSUNINIT(vnet_nl_uninit, SI_SUB_INIT_IF, SI_ORDER_FIRST, vnet_nl_uninit, + NULL); + +int +nl_verify_proto(int proto) +{ + if (proto < 0 || proto >= NL_MAX_HANDLERS) { + return (EINVAL); + } + int handler_defined = nl_handlers[proto].cb != NULL; + return (handler_defined ? 0 : EPROTONOSUPPORT); +} + +const char * +nl_get_proto_name(int proto) +{ + return (nl_handlers[proto].proto_name); +} + +bool +netlink_register_proto(int proto, const char *proto_name, nl_handler_f handler) +{ + if ((proto < 0) || (proto >= NL_MAX_HANDLERS)) + return (false); + NL_GLOBAL_LOCK(); + KASSERT((nl_handlers[proto].cb == NULL), ("netlink handler %d is already set", proto)); + nl_handlers[proto].cb = handler; + nl_handlers[proto].proto_name = proto_name; + NL_GLOBAL_UNLOCK(); + NL_LOG(LOG_DEBUG2, "Registered netlink %s(%d) handler", proto_name, proto); + return (true); +} + +bool +netlink_unregister_proto(int proto) +{ + if ((proto < 0) || (proto >= NL_MAX_HANDLERS)) + return (false); + NL_GLOBAL_LOCK(); + KASSERT((nl_handlers[proto].cb != NULL), ("netlink handler %d is not set", proto)); + nl_handlers[proto].cb = NULL; + nl_handlers[proto].proto_name = NULL; + NL_GLOBAL_UNLOCK(); + NL_LOG(LOG_DEBUG2, "Unregistered netlink proto %d handler", proto); + return (true); +} + +#if !defined(NETLINK) && defined(NETLINK_MODULE) +/* Non-stub function provider */ +const static struct nl_function_wrapper nl_module = { + .nlmsg_add = _nlmsg_add, + .nlmsg_refill_buffer = _nlmsg_refill_buffer, + .nlmsg_flush = _nlmsg_flush, + .nlmsg_end = _nlmsg_end, + .nlmsg_abort = _nlmsg_abort, + .nl_writer_unicast = _nl_writer_unicast, + .nl_writer_group = _nl_writer_group, + .nlmsg_end_dump = _nlmsg_end_dump, + .nl_modify_ifp_generic = _nl_modify_ifp_generic, + .nl_store_ifp_cookie = _nl_store_ifp_cookie, + .nl_get_thread_nlp = _nl_get_thread_nlp, +}; +#endif + +static bool +can_unload(void) +{ + struct nl_control *ctl; + bool result = true; + + NL_GLOBAL_LOCK(); + + CK_LIST_FOREACH(ctl, &vnets_head, ctl_next) { + NL_LOG(LOG_DEBUG2, "Iterating VNET head %p", ctl); + if (!CK_LIST_EMPTY(&ctl->ctl_pcb_head)) { + NL_LOG(LOG_NOTICE, "non-empty socket list in ctl %p", ctl); + result = false; + break; + } + } + + NL_GLOBAL_UNLOCK(); + + return (result); +} + +static int +netlink_modevent(module_t mod __unused, int what, void *priv __unused) +{ + int ret = 0; + + switch (what) { + case MOD_LOAD: + NL_LOG(LOG_DEBUG2, "Loading"); + nl_osd_register(); +#if !defined(NETLINK) && defined(NETLINK_MODULE) + nl_set_functions(&nl_module); +#endif + break; + + case MOD_UNLOAD: + NL_LOG(LOG_DEBUG2, "Unload called"); + if (can_unload()) { + NL_LOG(LOG_WARNING, "unloading"); + netlink_unloading = 1; +#if !defined(NETLINK) && defined(NETLINK_MODULE) + nl_set_functions(NULL); +#endif + nl_osd_unregister(); + } else + ret = EBUSY; + break; + + default: + ret = EOPNOTSUPP; + break; + } + + return (ret); +} +static moduledata_t netlink_mod = { "netlink", netlink_modevent, NULL }; + +DECLARE_MODULE(netlink, netlink_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); +MODULE_VERSION(netlink, 1); |