mirror of
https://github.com/freebsd/freebsd-src
synced 2024-09-06 17:18:32 +00:00
![Warner Losh](/assets/img/avatar_default.png)
Apply the following automated changes to try to eliminate no-longer-needed sys/cdefs.h includes as well as now-empty blank lines in a row. Remove /^#if.*\n#endif.*\n#include\s+<sys/cdefs.h>.*\n/ Remove /\n+#include\s+<sys/cdefs.h>.*\n+#if.*\n#endif.*\n+/ Remove /\n+#if.*\n#endif.*\n+/ Remove /^#if.*\n#endif.*\n/ Remove /\n+#include\s+<sys/cdefs.h>\n#include\s+<sys/types.h>/ Remove /\n+#include\s+<sys/cdefs.h>\n#include\s+<sys/param.h>/ Remove /\n+#include\s+<sys/cdefs.h>\n#include\s+<sys/capsicum.h>/ Sponsored by: Netflix
278 lines
6.7 KiB
C
278 lines
6.7 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*
|
|
* 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/types.h>
|
|
#include <sys/ck.h>
|
|
#include <sys/epoch.h>
|
|
#include <sys/eventhandler.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/sx.h>
|
|
|
|
#include <netlink/netlink.h>
|
|
#include <netlink/netlink_ctl.h>
|
|
#include <netlink/netlink_generic.h>
|
|
#include <netlink/netlink_var.h>
|
|
|
|
#define DEBUG_MOD_NAME nl_generic_kpi
|
|
#define DEBUG_MAX_LEVEL LOG_DEBUG3
|
|
#include <netlink/netlink_debug.h>
|
|
_DECLARE_DEBUG(LOG_INFO);
|
|
|
|
|
|
/*
|
|
* NETLINK_GENERIC families/groups registration logic
|
|
*/
|
|
|
|
#define GENL_LOCK() sx_xlock(&sx_lock)
|
|
#define GENL_UNLOCK() sx_xunlock(&sx_lock)
|
|
static struct sx sx_lock;
|
|
SX_SYSINIT(genl_lock, &sx_lock, "genetlink lock");
|
|
|
|
static struct genl_family families[MAX_FAMILIES];
|
|
static struct genl_group groups[MAX_GROUPS];
|
|
|
|
static struct genl_family *
|
|
find_family(const char *family_name)
|
|
{
|
|
for (int i = 0; i < MAX_FAMILIES; i++) {
|
|
struct genl_family *gf = &families[i];
|
|
if (gf->family_name != NULL && !strcmp(gf->family_name, family_name))
|
|
return (gf);
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
static struct genl_family *
|
|
find_empty_family_id(const char *family_name)
|
|
{
|
|
struct genl_family *gf = NULL;
|
|
|
|
if (!strcmp(family_name, CTRL_FAMILY_NAME)) {
|
|
gf = &families[0];
|
|
gf->family_id = GENL_MIN_ID;
|
|
} else {
|
|
/* Index 0 is reserved for the control family */
|
|
for (int i = 1; i < MAX_FAMILIES; i++) {
|
|
gf = &families[i];
|
|
if (gf->family_name == NULL) {
|
|
gf->family_id = GENL_MIN_ID + i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (gf);
|
|
}
|
|
|
|
uint32_t
|
|
genl_register_family(const char *family_name, size_t hdrsize, int family_version,
|
|
int max_attr_idx)
|
|
{
|
|
uint32_t family_id = 0;
|
|
|
|
MPASS(family_name != NULL);
|
|
if (find_family(family_name) != NULL)
|
|
return (0);
|
|
|
|
GENL_LOCK();
|
|
|
|
struct genl_family *gf = find_empty_family_id(family_name);
|
|
MPASS(gf != NULL);
|
|
|
|
gf->family_name = family_name;
|
|
gf->family_version = family_version;
|
|
gf->family_hdrsize = hdrsize;
|
|
gf->family_attr_max = max_attr_idx;
|
|
NL_LOG(LOG_DEBUG2, "Registered family %s id %d", gf->family_name, gf->family_id);
|
|
family_id = gf->family_id;
|
|
EVENTHANDLER_INVOKE(genl_family_event, gf, CTRL_CMD_NEWFAMILY);
|
|
|
|
GENL_UNLOCK();
|
|
|
|
return (family_id);
|
|
}
|
|
|
|
static void
|
|
free_family(struct genl_family *gf)
|
|
{
|
|
if (gf->family_cmds != NULL)
|
|
free(gf->family_cmds, M_NETLINK);
|
|
}
|
|
|
|
/*
|
|
* unregister groups of a given family
|
|
*/
|
|
static void
|
|
unregister_groups(const struct genl_family *gf)
|
|
{
|
|
|
|
for (int i = 0; i < MAX_GROUPS; i++) {
|
|
struct genl_group *gg = &groups[i];
|
|
if (gg->group_family == gf && gg->group_name != NULL) {
|
|
gg->group_family = NULL;
|
|
gg->group_name = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Can sleep, I guess
|
|
*/
|
|
bool
|
|
genl_unregister_family(const char *family_name)
|
|
{
|
|
bool found = false;
|
|
|
|
GENL_LOCK();
|
|
struct genl_family *gf = find_family(family_name);
|
|
|
|
if (gf != NULL) {
|
|
EVENTHANDLER_INVOKE(genl_family_event, gf, CTRL_CMD_DELFAMILY);
|
|
found = true;
|
|
unregister_groups(gf);
|
|
/* TODO: zero pointer first */
|
|
free_family(gf);
|
|
bzero(gf, sizeof(*gf));
|
|
}
|
|
GENL_UNLOCK();
|
|
|
|
return (found);
|
|
}
|
|
|
|
bool
|
|
genl_register_cmds(const char *family_name, const struct genl_cmd *cmds, int count)
|
|
{
|
|
GENL_LOCK();
|
|
struct genl_family *gf = find_family(family_name);
|
|
if (gf == NULL) {
|
|
GENL_UNLOCK();
|
|
return (false);
|
|
}
|
|
|
|
int cmd_size = gf->family_cmd_size;
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
MPASS(cmds[i].cmd_cb != NULL);
|
|
if (cmds[i].cmd_num >= cmd_size)
|
|
cmd_size = cmds[i].cmd_num + 1;
|
|
}
|
|
|
|
if (cmd_size > gf->family_cmd_size) {
|
|
/* need to realloc */
|
|
size_t sz = cmd_size * sizeof(struct genl_cmd);
|
|
void *data = malloc(sz, M_NETLINK, M_WAITOK | M_ZERO);
|
|
|
|
memcpy(data, gf->family_cmds, gf->family_cmd_size * sizeof(struct genl_cmd));
|
|
void *old_data = gf->family_cmds;
|
|
gf->family_cmds = data;
|
|
gf->family_cmd_size = cmd_size;
|
|
free(old_data, M_NETLINK);
|
|
}
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
const struct genl_cmd *cmd = &cmds[i];
|
|
MPASS(gf->family_cmds[cmd->cmd_num].cmd_cb == NULL);
|
|
gf->family_cmds[cmd->cmd_num] = cmds[i];
|
|
NL_LOG(LOG_DEBUG2, "Adding cmd %s(%d) to family %s",
|
|
cmd->cmd_name, cmd->cmd_num, gf->family_name);
|
|
}
|
|
GENL_UNLOCK();
|
|
return (true);
|
|
}
|
|
|
|
static struct genl_group *
|
|
find_group(const struct genl_family *gf, const char *group_name)
|
|
{
|
|
for (int i = 0; i < MAX_GROUPS; i++) {
|
|
struct genl_group *gg = &groups[i];
|
|
if (gg->group_family == gf && !strcmp(gg->group_name, group_name))
|
|
return (gg);
|
|
}
|
|
return (NULL);
|
|
}
|
|
|
|
uint32_t
|
|
genl_register_group(const char *family_name, const char *group_name)
|
|
{
|
|
uint32_t group_id = 0;
|
|
|
|
MPASS(family_name != NULL);
|
|
MPASS(group_name != NULL);
|
|
|
|
GENL_LOCK();
|
|
struct genl_family *gf = find_family(family_name);
|
|
|
|
if (gf == NULL || find_group(gf, group_name) != NULL) {
|
|
GENL_UNLOCK();
|
|
return (0);
|
|
}
|
|
|
|
for (int i = 0; i < MAX_GROUPS; i++) {
|
|
struct genl_group *gg = &groups[i];
|
|
if (gg->group_family == NULL) {
|
|
gf->family_num_groups++;
|
|
gg->group_family = gf;
|
|
gg->group_name = group_name;
|
|
group_id = i + MIN_GROUP_NUM;
|
|
break;
|
|
}
|
|
}
|
|
GENL_UNLOCK();
|
|
|
|
return (group_id);
|
|
}
|
|
|
|
/* accessors */
|
|
struct genl_family *
|
|
genl_get_family(uint32_t family_id)
|
|
{
|
|
return ((family_id < MAX_FAMILIES) ? &families[family_id] : NULL);
|
|
}
|
|
|
|
const char *
|
|
genl_get_family_name(const struct genl_family *gf)
|
|
{
|
|
return (gf->family_name);
|
|
}
|
|
|
|
uint32_t
|
|
genl_get_family_id(const struct genl_family *gf)
|
|
{
|
|
return (gf->family_id);
|
|
}
|
|
|
|
struct genl_group *
|
|
genl_get_group(uint32_t group_id)
|
|
{
|
|
return ((group_id < MAX_GROUPS) ? &groups[group_id] : NULL);
|
|
}
|
|
|