[linux-block.git] / net / core / netdev-genl.c

// SPDX-License-Identifier: GPL-2.0-only

#include <linux/netdevice.h>
#include <linux/notifier.h>
#include <linux/rtnetlink.h>
#include <net/net_namespace.h>
#include <net/sock.h>

#include "netdev-genl-gen.h"

static int
netdev_nl_dev_fill(struct net_device *netdev, struct sk_buff *rsp,
		   u32 portid, u32 seq, int flags, u32 cmd)
{
	void *hdr;

	hdr = genlmsg_put(rsp, portid, seq, &netdev_nl_family, flags, cmd);
	if (!hdr)
		return -EMSGSIZE;

	if (nla_put_u32(rsp, NETDEV_A_DEV_IFINDEX, netdev->ifindex) ||
	    nla_put_u64_64bit(rsp, NETDEV_A_DEV_XDP_FEATURES,
			      netdev->xdp_features, NETDEV_A_DEV_PAD)) {
		genlmsg_cancel(rsp, hdr);
		return -EINVAL;
	}

	genlmsg_end(rsp, hdr);

	return 0;
}

static void
netdev_genl_dev_notify(struct net_device *netdev, int cmd)
{
	struct sk_buff *ntf;

	if (!genl_has_listeners(&netdev_nl_family, dev_net(netdev),
				NETDEV_NLGRP_MGMT))
		return;

	ntf = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (!ntf)
		return;

	if (netdev_nl_dev_fill(netdev, ntf, 0, 0, 0, cmd)) {
		nlmsg_free(ntf);
		return;
	}

	genlmsg_multicast_netns(&netdev_nl_family, dev_net(netdev), ntf,
				0, NETDEV_NLGRP_MGMT, GFP_KERNEL);
}

int netdev_nl_dev_get_doit(struct sk_buff *skb, struct genl_info *info)
{
	struct net_device *netdev;
	struct sk_buff *rsp;
	u32 ifindex;
	int err;

	if (GENL_REQ_ATTR_CHECK(info, NETDEV_A_DEV_IFINDEX))
		return -EINVAL;

	ifindex = nla_get_u32(info->attrs[NETDEV_A_DEV_IFINDEX]);

	rsp = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (!rsp)
		return -ENOMEM;

	rtnl_lock();

	netdev = __dev_get_by_index(genl_info_net(info), ifindex);
	if (netdev)
		err = netdev_nl_dev_fill(netdev, rsp, info->snd_portid,
					 info->snd_seq, 0, info->genlhdr->cmd);
	else
		err = -ENODEV;

	rtnl_unlock();

	if (err)
		goto err_free_msg;

	return genlmsg_reply(rsp, info);

err_free_msg:
	nlmsg_free(rsp);
	return err;
}

int netdev_nl_dev_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	struct net_device *netdev;
	int idx = 0, s_idx;
	int h, s_h;
	int err;

	s_h = cb->args[0];
	s_idx = cb->args[1];

	rtnl_lock();

	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		struct hlist_head *head;

		idx = 0;
		head = &net->dev_index_head[h];
		hlist_for_each_entry(netdev, head, index_hlist) {
			if (idx < s_idx)
				goto cont;
			err = netdev_nl_dev_fill(netdev, skb,
						 NETLINK_CB(cb->skb).portid,
						 cb->nlh->nlmsg_seq, 0,
						 NETDEV_CMD_DEV_GET);
			if (err < 0)
				break;
cont:
			idx++;
		}
	}

	rtnl_unlock();

	if (err != -EMSGSIZE)
		return err;

	cb->args[1] = idx;
	cb->args[0] = h;
	cb->seq = net->dev_base_seq;

	return skb->len;
}

static int netdev_genl_netdevice_event(struct notifier_block *nb,
				       unsigned long event, void *ptr)
{
	struct net_device *netdev = netdev_notifier_info_to_dev(ptr);

	switch (event) {
	case NETDEV_REGISTER:
		netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_ADD_NTF);
		break;
	case NETDEV_UNREGISTER:
		netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_DEL_NTF);
		break;
	case NETDEV_XDP_FEAT_CHANGE:
		netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_CHANGE_NTF);
		break;
	}

	return NOTIFY_OK;
}

static struct notifier_block netdev_genl_nb = {
	.notifier_call	= netdev_genl_netdevice_event,
};

static int __init netdev_genl_init(void)
{
	int err;

	err = register_netdevice_notifier(&netdev_genl_nb);
	if (err)
		return err;

	err = genl_register_family(&netdev_nl_family);
	if (err)
		goto err_unreg_ntf;

	return 0;

err_unreg_ntf:
	unregister_netdevice_notifier(&netdev_genl_nb);
	return err;
}

subsys_initcall(netdev_genl_init);
Commit	Line	Data
d3d854fd JK	1	// SPDX-License-Identifier: GPL-2.0-only
	2
	3	#include <linux/netdevice.h>
	4	#include <linux/notifier.h>
	5	#include <linux/rtnetlink.h>
	6	#include <net/net_namespace.h>
	7	#include <net/sock.h>
	8
	9	#include "netdev-genl-gen.h"
	10
	11	static int
	12	netdev_nl_dev_fill(struct net_device netdev, struct sk_buff rsp,
	13	u32 portid, u32 seq, int flags, u32 cmd)
	14	{
	15	void *hdr;
	16
	17	hdr = genlmsg_put(rsp, portid, seq, &netdev_nl_family, flags, cmd);
	18	if (!hdr)
	19	return -EMSGSIZE;
	20
	21	if (nla_put_u32(rsp, NETDEV_A_DEV_IFINDEX, netdev->ifindex) \|\|
	22	nla_put_u64_64bit(rsp, NETDEV_A_DEV_XDP_FEATURES,
	23	netdev->xdp_features, NETDEV_A_DEV_PAD)) {
	24	genlmsg_cancel(rsp, hdr);
	25	return -EINVAL;
	26	}
	27
	28	genlmsg_end(rsp, hdr);
	29
	30	return 0;
	31	}
	32
	33	static void
	34	netdev_genl_dev_notify(struct net_device *netdev, int cmd)
	35	{
	36	struct sk_buff *ntf;
	37
	38	if (!genl_has_listeners(&netdev_nl_family, dev_net(netdev),
	39	NETDEV_NLGRP_MGMT))
	40	return;
	41
	42	ntf = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
	43	if (!ntf)
	44	return;
	45
	46	if (netdev_nl_dev_fill(netdev, ntf, 0, 0, 0, cmd)) {
	47	nlmsg_free(ntf);
	48	return;
	49	}
	50
	51	genlmsg_multicast_netns(&netdev_nl_family, dev_net(netdev), ntf,
	52	0, NETDEV_NLGRP_MGMT, GFP_KERNEL);
	53	}
	54
	55	int netdev_nl_dev_get_doit(struct sk_buff skb, struct genl_info info)
	56	{
	57	struct net_device *netdev;
	58	struct sk_buff *rsp;
	59	u32 ifindex;
	60	int err;
	61
	62	if (GENL_REQ_ATTR_CHECK(info, NETDEV_A_DEV_IFINDEX))
	63	return -EINVAL;
	64
65	ifindex = nla_get_u32(info->attrs[NETDEV_A_DEV_IFINDEX]);
66
67	rsp = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
68	if (!rsp)
69	return -ENOMEM;
70
71	rtnl_lock();
72
73	netdev = __dev_get_by_index(genl_info_net(info), ifindex);
74	if (netdev)
75	err = netdev_nl_dev_fill(netdev, rsp, info->snd_portid,
76	info->snd_seq, 0, info->genlhdr->cmd);
77	else
78	err = -ENODEV;
79
80	rtnl_unlock();
81
82	if (err)
83	goto err_free_msg;
84
85	return genlmsg_reply(rsp, info);
86
87	err_free_msg:
88	nlmsg_free(rsp);
89	return err;
90	}
91
92	int netdev_nl_dev_get_dumpit(struct sk_buff skb, struct netlink_callback cb)
93	{
94	struct net *net = sock_net(skb->sk);
95	struct net_device *netdev;
96	int idx = 0, s_idx;
97	int h, s_h;
98	int err;
99
100	s_h = cb->args[0];
101	s_idx = cb->args[1];
102
103	rtnl_lock();
104
105	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
106	struct hlist_head *head;
107
108	idx = 0;
109	head = &net->dev_index_head[h];
110	hlist_for_each_entry(netdev, head, index_hlist) {
111	if (idx < s_idx)
112	goto cont;
113	err = netdev_nl_dev_fill(netdev, skb,
114	NETLINK_CB(cb->skb).portid,
115	cb->nlh->nlmsg_seq, 0,
116	NETDEV_CMD_DEV_GET);
117	if (err < 0)
118	break;
119	cont:
120	idx++;
121	}
122	}
123
124	rtnl_unlock();
125
126	if (err != -EMSGSIZE)
127	return err;
128
129	cb->args[1] = idx;
130	cb->args[0] = h;
131	cb->seq = net->dev_base_seq;
132
133	return skb->len;
134	}
135
136	static int netdev_genl_netdevice_event(struct notifier_block *nb,
137	unsigned long event, void *ptr)
138	{
139	struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
140
141	switch (event) {
142	case NETDEV_REGISTER:
143	netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_ADD_NTF);
144	break;
145	case NETDEV_UNREGISTER:
146	netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_DEL_NTF);
147	break;
148	case NETDEV_XDP_FEAT_CHANGE:
149	netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_CHANGE_NTF);
150	break;
151	}
152
153	return NOTIFY_OK;
154	}
155
156	static struct notifier_block netdev_genl_nb = {
157	.notifier_call = netdev_genl_netdevice_event,
158	};
159
160	static int __init netdev_genl_init(void)
161	{
162	int err;
163
164	err = register_netdevice_notifier(&netdev_genl_nb);
165	if (err)
166	return err;
167
168	err = genl_register_family(&netdev_nl_family);
169	if (err)
170	goto err_unreg_ntf;
171
172	return 0;
173
174	err_unreg_ntf:
175	unregister_netdevice_notifier(&netdev_genl_nb);
176	return err;
177	}
178
179	subsys_initcall(netdev_genl_init);