[linux-block.git] / net / hsr / hsr_netlink.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright 2011-2014 Autronica Fire and Security AS
 *
 * Author(s):
 *	2011-2014 Arvid Brodin, arvid.brodin@alten.se
 *
 * Routines for handling Netlink messages for HSR and PRP.
 */

#include "hsr_netlink.h"
#include <linux/kernel.h>
#include <net/rtnetlink.h>
#include <net/genetlink.h>
#include "hsr_main.h"
#include "hsr_device.h"
#include "hsr_framereg.h"

static const struct nla_policy hsr_policy[IFLA_HSR_MAX + 1] = {
	[IFLA_HSR_SLAVE1]		= { .type = NLA_U32 },
	[IFLA_HSR_SLAVE2]		= { .type = NLA_U32 },
	[IFLA_HSR_MULTICAST_SPEC]	= { .type = NLA_U8 },
	[IFLA_HSR_VERSION]	= { .type = NLA_U8 },
	[IFLA_HSR_SUPERVISION_ADDR]	= { .len = ETH_ALEN },
	[IFLA_HSR_SEQ_NR]		= { .type = NLA_U16 },
	[IFLA_HSR_PROTOCOL]		= { .type = NLA_U8 },
};

/* Here, it seems a netdevice has already been allocated for us, and the
 * hsr_dev_setup routine has been executed. Nice!
 */
static int hsr_newlink(struct net *src_net, struct net_device *dev,
		       struct nlattr *tb[], struct nlattr *data[],
		       struct netlink_ext_ack *extack)
{
	enum hsr_version proto_version;
	unsigned char multicast_spec;
	u8 proto = HSR_PROTOCOL_HSR;
	struct net_device *link[2];

	if (!data) {
		NL_SET_ERR_MSG_MOD(extack, "No slave devices specified");
		return -EINVAL;
	}
	if (!data[IFLA_HSR_SLAVE1]) {
		NL_SET_ERR_MSG_MOD(extack, "Slave1 device not specified");
		return -EINVAL;
	}
	link[0] = __dev_get_by_index(src_net,
				     nla_get_u32(data[IFLA_HSR_SLAVE1]));
	if (!link[0]) {
		NL_SET_ERR_MSG_MOD(extack, "Slave1 does not exist");
		return -EINVAL;
	}
	if (!data[IFLA_HSR_SLAVE2]) {
		NL_SET_ERR_MSG_MOD(extack, "Slave2 device not specified");
		return -EINVAL;
	}
	link[1] = __dev_get_by_index(src_net,
				     nla_get_u32(data[IFLA_HSR_SLAVE2]));
	if (!link[1]) {
		NL_SET_ERR_MSG_MOD(extack, "Slave2 does not exist");
		return -EINVAL;
	}

	if (link[0] == link[1]) {
		NL_SET_ERR_MSG_MOD(extack, "Slave1 and Slave2 are same");
		return -EINVAL;
	}

	if (!data[IFLA_HSR_MULTICAST_SPEC])
		multicast_spec = 0;
	else
		multicast_spec = nla_get_u8(data[IFLA_HSR_MULTICAST_SPEC]);

	if (data[IFLA_HSR_PROTOCOL])
		proto = nla_get_u8(data[IFLA_HSR_PROTOCOL]);

	if (proto >= HSR_PROTOCOL_MAX) {
		NL_SET_ERR_MSG_MOD(extack, "Unsupported protocol");
		return -EINVAL;
	}

	if (!data[IFLA_HSR_VERSION]) {
		proto_version = HSR_V0;
	} else {
		if (proto == HSR_PROTOCOL_PRP) {
			NL_SET_ERR_MSG_MOD(extack, "PRP version unsupported");
			return -EINVAL;
		}

		proto_version = nla_get_u8(data[IFLA_HSR_VERSION]);
		if (proto_version > HSR_V1) {
			NL_SET_ERR_MSG_MOD(extack,
					   "Only HSR version 0/1 supported");
			return -EINVAL;
		}
	}

	if (proto == HSR_PROTOCOL_PRP)
		proto_version = PRP_V1;

	return hsr_dev_finalize(dev, link, multicast_spec, proto_version, extack);
}

static void hsr_dellink(struct net_device *dev, struct list_head *head)
{
	struct hsr_priv *hsr = netdev_priv(dev);

	del_timer_sync(&hsr->prune_timer);
	del_timer_sync(&hsr->announce_timer);

	hsr_debugfs_term(hsr);
	hsr_del_ports(hsr);

	hsr_del_self_node(hsr);
	hsr_del_nodes(&hsr->node_db);

	unregister_netdevice_queue(dev, head);
}

static int hsr_fill_info(struct sk_buff *skb, const struct net_device *dev)
{
	struct hsr_priv *hsr = netdev_priv(dev);
	u8 proto = HSR_PROTOCOL_HSR;
	struct hsr_port *port;

	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
	if (port) {
		if (nla_put_u32(skb, IFLA_HSR_SLAVE1, port->dev->ifindex))
			goto nla_put_failure;
	}

	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
	if (port) {
		if (nla_put_u32(skb, IFLA_HSR_SLAVE2, port->dev->ifindex))
			goto nla_put_failure;
	}

	if (nla_put(skb, IFLA_HSR_SUPERVISION_ADDR, ETH_ALEN,
		    hsr->sup_multicast_addr) ||
	    nla_put_u16(skb, IFLA_HSR_SEQ_NR, hsr->sequence_nr))
		goto nla_put_failure;
	if (hsr->prot_version == PRP_V1)
		proto = HSR_PROTOCOL_PRP;
	if (nla_put_u8(skb, IFLA_HSR_PROTOCOL, proto))
		goto nla_put_failure;

	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

static struct rtnl_link_ops hsr_link_ops __read_mostly = {
	.kind		= "hsr",
	.maxtype	= IFLA_HSR_MAX,
	.policy		= hsr_policy,
	.priv_size	= sizeof(struct hsr_priv),
	.setup		= hsr_dev_setup,
	.newlink	= hsr_newlink,
	.dellink	= hsr_dellink,
	.fill_info	= hsr_fill_info,
};

/* attribute policy */
static const struct nla_policy hsr_genl_policy[HSR_A_MAX + 1] = {
	[HSR_A_NODE_ADDR] = { .len = ETH_ALEN },
	[HSR_A_NODE_ADDR_B] = { .len = ETH_ALEN },
	[HSR_A_IFINDEX] = { .type = NLA_U32 },
	[HSR_A_IF1_AGE] = { .type = NLA_U32 },
	[HSR_A_IF2_AGE] = { .type = NLA_U32 },
	[HSR_A_IF1_SEQ] = { .type = NLA_U16 },
	[HSR_A_IF2_SEQ] = { .type = NLA_U16 },
};

static struct genl_family hsr_genl_family;

static const struct genl_multicast_group hsr_mcgrps[] = {
	{ .name = "hsr-network", },
};

/* This is called if for some node with MAC address addr, we only get frames
 * over one of the slave interfaces. This would indicate an open network ring
 * (i.e. a link has failed somewhere).
 */
void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
		      struct hsr_port *port)
{
	struct sk_buff *skb;
	void *msg_head;
	struct hsr_port *master;
	int res;

	skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	if (!skb)
		goto fail;

	msg_head = genlmsg_put(skb, 0, 0, &hsr_genl_family, 0,
			       HSR_C_RING_ERROR);
	if (!msg_head)
		goto nla_put_failure;

	res = nla_put(skb, HSR_A_NODE_ADDR, ETH_ALEN, addr);
	if (res < 0)
		goto nla_put_failure;

	res = nla_put_u32(skb, HSR_A_IFINDEX, port->dev->ifindex);
	if (res < 0)
		goto nla_put_failure;

	genlmsg_end(skb, msg_head);
	genlmsg_multicast(&hsr_genl_family, skb, 0, 0, GFP_ATOMIC);

	return;

nla_put_failure:
	kfree_skb(skb);

fail:
	rcu_read_lock();
	master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
	netdev_warn(master->dev, "Could not send HSR ring error message\n");
	rcu_read_unlock();
}

/* This is called when we haven't heard from the node with MAC address addr for
 * some time (just before the node is removed from the node table/list).
 */
void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN])
{
	struct sk_buff *skb;
	void *msg_head;
	struct hsr_port *master;
	int res;

	skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	if (!skb)
		goto fail;

	msg_head = genlmsg_put(skb, 0, 0, &hsr_genl_family, 0, HSR_C_NODE_DOWN);
	if (!msg_head)
		goto nla_put_failure;

	res = nla_put(skb, HSR_A_NODE_ADDR, ETH_ALEN, addr);
	if (res < 0)
		goto nla_put_failure;

	genlmsg_end(skb, msg_head);
	genlmsg_multicast(&hsr_genl_family, skb, 0, 0, GFP_ATOMIC);

	return;

nla_put_failure:
	kfree_skb(skb);

fail:
	rcu_read_lock();
	master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
	netdev_warn(master->dev, "Could not send HSR node down\n");
	rcu_read_unlock();
}

/* HSR_C_GET_NODE_STATUS lets userspace query the internal HSR node table
 * about the status of a specific node in the network, defined by its MAC
 * address.
 *
 * Input: hsr ifindex, node mac address
 * Output: hsr ifindex, node mac address (copied from request),
 *	   age of latest frame from node over slave 1, slave 2 [ms]
 */
static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
{
	/* For receiving */
	struct nlattr *na;
	struct net_device *hsr_dev;

	/* For sending */
	struct sk_buff *skb_out;
	void *msg_head;
	struct hsr_priv *hsr;
	struct hsr_port *port;
	unsigned char hsr_node_addr_b[ETH_ALEN];
	int hsr_node_if1_age;
	u16 hsr_node_if1_seq;
	int hsr_node_if2_age;
	u16 hsr_node_if2_seq;
	int addr_b_ifindex;
	int res;

	if (!info)
		goto invalid;

	na = info->attrs[HSR_A_IFINDEX];
	if (!na)
		goto invalid;
	na = info->attrs[HSR_A_NODE_ADDR];
	if (!na)
		goto invalid;

	rcu_read_lock();
	hsr_dev = dev_get_by_index_rcu(genl_info_net(info),
				       nla_get_u32(info->attrs[HSR_A_IFINDEX]));
	if (!hsr_dev)
		goto rcu_unlock;
	if (!is_hsr_master(hsr_dev))
		goto rcu_unlock;

	/* Send reply */
	skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	if (!skb_out) {
		res = -ENOMEM;
		goto fail;
	}

	msg_head = genlmsg_put(skb_out, NETLINK_CB(skb_in).portid,
			       info->snd_seq, &hsr_genl_family, 0,
			       HSR_C_SET_NODE_STATUS);
	if (!msg_head) {
		res = -ENOMEM;
		goto nla_put_failure;
	}

	res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
	if (res < 0)
		goto nla_put_failure;

	hsr = netdev_priv(hsr_dev);
	res = hsr_get_node_data(hsr,
				(unsigned char *)
				nla_data(info->attrs[HSR_A_NODE_ADDR]),
					 hsr_node_addr_b,
					 &addr_b_ifindex,
					 &hsr_node_if1_age,
					 &hsr_node_if1_seq,
					 &hsr_node_if2_age,
					 &hsr_node_if2_seq);
	if (res < 0)
		goto nla_put_failure;

	res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN,
		      nla_data(info->attrs[HSR_A_NODE_ADDR]));
	if (res < 0)
		goto nla_put_failure;

	if (addr_b_ifindex > -1) {
		res = nla_put(skb_out, HSR_A_NODE_ADDR_B, ETH_ALEN,
			      hsr_node_addr_b);
		if (res < 0)
			goto nla_put_failure;

		res = nla_put_u32(skb_out, HSR_A_ADDR_B_IFINDEX,
				  addr_b_ifindex);
		if (res < 0)
			goto nla_put_failure;
	}

	res = nla_put_u32(skb_out, HSR_A_IF1_AGE, hsr_node_if1_age);
	if (res < 0)
		goto nla_put_failure;
	res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq);
	if (res < 0)
		goto nla_put_failure;
	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
	if (port)
		res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX,
				  port->dev->ifindex);
	if (res < 0)
		goto nla_put_failure;

	res = nla_put_u32(skb_out, HSR_A_IF2_AGE, hsr_node_if2_age);
	if (res < 0)
		goto nla_put_failure;
	res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq);
	if (res < 0)
		goto nla_put_failure;
	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
	if (port)
		res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX,
				  port->dev->ifindex);
	if (res < 0)
		goto nla_put_failure;

	rcu_read_unlock();

	genlmsg_end(skb_out, msg_head);
	genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);

	return 0;

rcu_unlock:
	rcu_read_unlock();
invalid:
	netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL, NULL);
	return 0;

nla_put_failure:
	kfree_skb(skb_out);
	/* Fall through */

fail:
	rcu_read_unlock();
	return res;
}

/* Get a list of MacAddressA of all nodes known to this node (including self).
 */
static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info)
{
	unsigned char addr[ETH_ALEN];
	struct net_device *hsr_dev;
	struct sk_buff *skb_out;
	struct hsr_priv *hsr;
	bool restart = false;
	struct nlattr *na;
	void *pos = NULL;
	void *msg_head;
	int res;

	if (!info)
		goto invalid;

	na = info->attrs[HSR_A_IFINDEX];
	if (!na)
		goto invalid;

	rcu_read_lock();
	hsr_dev = dev_get_by_index_rcu(genl_info_net(info),
				       nla_get_u32(info->attrs[HSR_A_IFINDEX]));
	if (!hsr_dev)
		goto rcu_unlock;
	if (!is_hsr_master(hsr_dev))
		goto rcu_unlock;

restart:
	/* Send reply */
	skb_out = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
	if (!skb_out) {
		res = -ENOMEM;
		goto fail;
	}

	msg_head = genlmsg_put(skb_out, NETLINK_CB(skb_in).portid,
			       info->snd_seq, &hsr_genl_family, 0,
			       HSR_C_SET_NODE_LIST);
	if (!msg_head) {
		res = -ENOMEM;
		goto nla_put_failure;
	}

	if (!restart) {
		res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
		if (res < 0)
			goto nla_put_failure;
	}

	hsr = netdev_priv(hsr_dev);

	if (!pos)
		pos = hsr_get_next_node(hsr, NULL, addr);
	while (pos) {
		res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN, addr);
		if (res < 0) {
			if (res == -EMSGSIZE) {
				genlmsg_end(skb_out, msg_head);
				genlmsg_unicast(genl_info_net(info), skb_out,
						info->snd_portid);
				restart = true;
				goto restart;
			}
			goto nla_put_failure;
		}
		pos = hsr_get_next_node(hsr, pos, addr);
	}
	rcu_read_unlock();

	genlmsg_end(skb_out, msg_head);
	genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);

	return 0;

rcu_unlock:
	rcu_read_unlock();
invalid:
	netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL, NULL);
	return 0;

nla_put_failure:
	nlmsg_free(skb_out);
	/* Fall through */

fail:
	rcu_read_unlock();
	return res;
}

static const struct genl_small_ops hsr_ops[] = {
	{
		.cmd = HSR_C_GET_NODE_STATUS,
		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
		.flags = 0,
		.doit = hsr_get_node_status,
		.dumpit = NULL,
	},
	{
		.cmd = HSR_C_GET_NODE_LIST,
		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
		.flags = 0,
		.doit = hsr_get_node_list,
		.dumpit = NULL,
	},
};

static struct genl_family hsr_genl_family __ro_after_init = {
	.hdrsize = 0,
	.name = "HSR",
	.version = 1,
	.maxattr = HSR_A_MAX,
	.policy = hsr_genl_policy,
	.netnsok = true,
	.module = THIS_MODULE,
	.small_ops = hsr_ops,
	.n_small_ops = ARRAY_SIZE(hsr_ops),
	.resv_start_op = HSR_C_SET_NODE_LIST + 1,
	.mcgrps = hsr_mcgrps,
	.n_mcgrps = ARRAY_SIZE(hsr_mcgrps),
};

int __init hsr_netlink_init(void)
{
	int rc;

	rc = rtnl_link_register(&hsr_link_ops);
	if (rc)
		goto fail_rtnl_link_register;

	rc = genl_register_family(&hsr_genl_family);
	if (rc)
		goto fail_genl_register_family;

	hsr_debugfs_create_root();
	return 0;

fail_genl_register_family:
	rtnl_link_unregister(&hsr_link_ops);
fail_rtnl_link_register:

	return rc;
}

void __exit hsr_netlink_exit(void)
{
	genl_unregister_family(&hsr_genl_family);
	rtnl_link_unregister(&hsr_link_ops);
}

MODULE_ALIAS_RTNL_LINK("hsr");
Commit	Line	Data
0e7623bd	1	// SPDX-License-Identifier: GPL-2.0
70ebe4a4	2	/* Copyright 2011-2014 Autronica Fire and Security AS
f421436a AB	3	*
f421436a AB	4	* Author(s):
70ebe4a4	5	* 2011-2014 Arvid Brodin, arvid.brodin@alten.se
f421436a	6	*
8f4c0e01	7	* Routines for handling Netlink messages for HSR and PRP.
f421436a AB	8	*/
	9
	10	#include "hsr_netlink.h"
	11	#include <linux/kernel.h>
	12	#include <net/rtnetlink.h>
	13	#include <net/genetlink.h>
	14	#include "hsr_main.h"
	15	#include "hsr_device.h"
	16	#include "hsr_framereg.h"
	17
	18	static const struct nla_policy hsr_policy[IFLA_HSR_MAX + 1] = {
	19	[IFLA_HSR_SLAVE1] = { .type = NLA_U32 },
	20	[IFLA_HSR_SLAVE2] = { .type = NLA_U32 },
	21	[IFLA_HSR_MULTICAST_SPEC] = { .type = NLA_U8 },
ee1c2797	22	[IFLA_HSR_VERSION] = { .type = NLA_U8 },
f9375729	23	[IFLA_HSR_SUPERVISION_ADDR] = { .len = ETH_ALEN },
98bf8362	24	[IFLA_HSR_SEQ_NR] = { .type = NLA_U16 },
8f4c0e01	25	[IFLA_HSR_PROTOCOL] = { .type = NLA_U8 },
f421436a AB	26	};
f421436a AB	27
f421436a AB	28	/* Here, it seems a netdevice has already been allocated for us, and the
	29	* hsr_dev_setup routine has been executed. Nice!
	30	*/
	31	static int hsr_newlink(struct net src_net, struct net_device dev,
7a3f4a18 MS	32	struct nlattr tb[], struct nlattr data[],
7a3f4a18 MS	33	struct netlink_ext_ack *extack)
f421436a	34	{
8f4c0e01 MK	35	enum hsr_version proto_version;
	36	unsigned char multicast_spec;
	37	u8 proto = HSR_PROTOCOL_HSR;
f421436a	38	struct net_device *link[2];
f421436a	39
a718dcc5	40	if (!data) {
13eeb5fe	41	NL_SET_ERR_MSG_MOD(extack, "No slave devices specified");
a718dcc5 AB	42	return -EINVAL;
a718dcc5 AB	43	}
f421436a	44	if (!data[IFLA_HSR_SLAVE1]) {
13eeb5fe	45	NL_SET_ERR_MSG_MOD(extack, "Slave1 device not specified");
f421436a AB	46	return -EINVAL;
f421436a AB	47	}
d595b85a MK	48	link[0] = __dev_get_by_index(src_net,
d595b85a MK	49	nla_get_u32(data[IFLA_HSR_SLAVE1]));
13eeb5fe TY	50	if (!link[0]) {
	51	NL_SET_ERR_MSG_MOD(extack, "Slave1 does not exist");
	52	return -EINVAL;
	53	}
f421436a	54	if (!data[IFLA_HSR_SLAVE2]) {
13eeb5fe	55	NL_SET_ERR_MSG_MOD(extack, "Slave2 device not specified");
f421436a AB	56	return -EINVAL;
f421436a AB	57	}
d595b85a MK	58	link[1] = __dev_get_by_index(src_net,
d595b85a MK	59	nla_get_u32(data[IFLA_HSR_SLAVE2]));
13eeb5fe TY	60	if (!link[1]) {
	61	NL_SET_ERR_MSG_MOD(extack, "Slave2 does not exist");
	62	return -EINVAL;
	63	}
f421436a	64
13eeb5fe TY	65	if (link[0] == link[1]) {
13eeb5fe TY	66	NL_SET_ERR_MSG_MOD(extack, "Slave1 and Slave2 are same");
f421436a	67	return -EINVAL;
13eeb5fe	68	}
f421436a AB	69
	70	if (!data[IFLA_HSR_MULTICAST_SPEC])
	71	multicast_spec = 0;
	72	else
	73	multicast_spec = nla_get_u8(data[IFLA_HSR_MULTICAST_SPEC]);
	74
8f4c0e01 MK	75	if (data[IFLA_HSR_PROTOCOL])
	76	proto = nla_get_u8(data[IFLA_HSR_PROTOCOL]);
	77
	78	if (proto >= HSR_PROTOCOL_MAX) {
b87f9fe1	79	NL_SET_ERR_MSG_MOD(extack, "Unsupported protocol");
8f4c0e01 MK	80	return -EINVAL;
	81	}
	82
4faab8c4	83	if (!data[IFLA_HSR_VERSION]) {
8f4c0e01	84	proto_version = HSR_V0;
4faab8c4	85	} else {
8f4c0e01	86	if (proto == HSR_PROTOCOL_PRP) {
b87f9fe1	87	NL_SET_ERR_MSG_MOD(extack, "PRP version unsupported");
8f4c0e01 MK	88	return -EINVAL;
	89	}
	90
	91	proto_version = nla_get_u8(data[IFLA_HSR_VERSION]);
	92	if (proto_version > HSR_V1) {
4faab8c4	93	NL_SET_ERR_MSG_MOD(extack,
b87f9fe1	94	"Only HSR version 0/1 supported");
4faab8c4 TY	95	return -EINVAL;
	96	}
	97	}
ee1c2797	98
8f4c0e01 MK	99	if (proto == HSR_PROTOCOL_PRP)
	100	proto_version = PRP_V1;
	101
	102	return hsr_dev_finalize(dev, link, multicast_spec, proto_version, extack);
f421436a AB	103	}
f421436a AB	104
de0083c7 TY	105	static void hsr_dellink(struct net_device dev, struct list_head head)
	106	{
	107	struct hsr_priv *hsr = netdev_priv(dev);
	108
	109	del_timer_sync(&hsr->prune_timer);
	110	del_timer_sync(&hsr->announce_timer);
	111
	112	hsr_debugfs_term(hsr);
	113	hsr_del_ports(hsr);
	114
	115	hsr_del_self_node(hsr);
e012764c	116	hsr_del_nodes(&hsr->node_db);
de0083c7 TY	117
	118	unregister_netdevice_queue(dev, head);
	119	}
	120
98bf8362 AB	121	static int hsr_fill_info(struct sk_buff skb, const struct net_device dev)
98bf8362 AB	122	{
81390d0c	123	struct hsr_priv *hsr = netdev_priv(dev);
8f4c0e01	124	u8 proto = HSR_PROTOCOL_HSR;
c5a75911	125	struct hsr_port *port;
98bf8362	126
c5a75911	127	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
81390d0c TY	128	if (port) {
	129	if (nla_put_u32(skb, IFLA_HSR_SLAVE1, port->dev->ifindex))
	130	goto nla_put_failure;
	131	}
51f3c605	132
c5a75911	133	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
81390d0c TY	134	if (port) {
	135	if (nla_put_u32(skb, IFLA_HSR_SLAVE2, port->dev->ifindex))
	136	goto nla_put_failure;
	137	}
98bf8362 AB	138
98bf8362 AB	139	if (nla_put(skb, IFLA_HSR_SUPERVISION_ADDR, ETH_ALEN,
70ebe4a4 AB	140	hsr->sup_multicast_addr) \|\|
70ebe4a4 AB	141	nla_put_u16(skb, IFLA_HSR_SEQ_NR, hsr->sequence_nr))
98bf8362	142	goto nla_put_failure;
8f4c0e01 MK	143	if (hsr->prot_version == PRP_V1)
	144	proto = HSR_PROTOCOL_PRP;
	145	if (nla_put_u8(skb, IFLA_HSR_PROTOCOL, proto))
	146	goto nla_put_failure;
98bf8362 AB	147
	148	return 0;
	149
	150	nla_put_failure:
	151	return -EMSGSIZE;
	152	}
	153
f421436a AB	154	static struct rtnl_link_ops hsr_link_ops __read_mostly = {
	155	.kind = "hsr",
	156	.maxtype = IFLA_HSR_MAX,
	157	.policy = hsr_policy,
	158	.priv_size = sizeof(struct hsr_priv),
	159	.setup = hsr_dev_setup,
	160	.newlink = hsr_newlink,
de0083c7	161	.dellink = hsr_dellink,
98bf8362	162	.fill_info = hsr_fill_info,
f421436a AB	163	};
f421436a AB	164
f421436a	165	/* attribute policy */
f421436a	166	static const struct nla_policy hsr_genl_policy[HSR_A_MAX + 1] = {
f9375729 PH	167	[HSR_A_NODE_ADDR] = { .len = ETH_ALEN },
f9375729 PH	168	[HSR_A_NODE_ADDR_B] = { .len = ETH_ALEN },
f421436a AB	169	[HSR_A_IFINDEX] = { .type = NLA_U32 },
	170	[HSR_A_IF1_AGE] = { .type = NLA_U32 },
	171	[HSR_A_IF2_AGE] = { .type = NLA_U32 },
	172	[HSR_A_IF1_SEQ] = { .type = NLA_U16 },
	173	[HSR_A_IF2_SEQ] = { .type = NLA_U16 },
	174	};
	175
489111e5	176	static struct genl_family hsr_genl_family;
f421436a	177
2a94fe48 JB	178	static const struct genl_multicast_group hsr_mcgrps[] = {
2a94fe48 JB	179	{ .name = "hsr-network", },
f421436a AB	180	};
f421436a AB	181
f421436a AB	182	/* This is called if for some node with MAC address addr, we only get frames
	183	* over one of the slave interfaces. This would indicate an open network ring
	184	* (i.e. a link has failed somewhere).
	185	*/
70ebe4a4	186	void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
c5a75911	187	struct hsr_port *port)
f421436a AB	188	{
	189	struct sk_buff *skb;
	190	void *msg_head;
c5a75911	191	struct hsr_port *master;
f421436a	192	int res;
f421436a AB	193
	194	skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	195	if (!skb)
	196	goto fail;
	197
d595b85a MK	198	msg_head = genlmsg_put(skb, 0, 0, &hsr_genl_family, 0,
d595b85a MK	199	HSR_C_RING_ERROR);
f421436a AB	200	if (!msg_head)
	201	goto nla_put_failure;
	202
	203	res = nla_put(skb, HSR_A_NODE_ADDR, ETH_ALEN, addr);
	204	if (res < 0)
	205	goto nla_put_failure;
	206
c5a75911	207	res = nla_put_u32(skb, HSR_A_IFINDEX, port->dev->ifindex);
f421436a AB	208	if (res < 0)
	209	goto nla_put_failure;
	210
	211	genlmsg_end(skb, msg_head);
2a94fe48	212	genlmsg_multicast(&hsr_genl_family, skb, 0, 0, GFP_ATOMIC);
f421436a AB	213
	214	return;
	215
	216	nla_put_failure:
	217	kfree_skb(skb);
	218
	219	fail:
c5a75911 AB	220	rcu_read_lock();
	221	master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
	222	netdev_warn(master->dev, "Could not send HSR ring error message\n");
	223	rcu_read_unlock();
f421436a AB	224	}
	225
	226	/* This is called when we haven't heard from the node with MAC address addr for
	227	* some time (just before the node is removed from the node table/list).
	228	*/
70ebe4a4	229	void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN])
f421436a AB	230	{
	231	struct sk_buff *skb;
	232	void *msg_head;
c5a75911	233	struct hsr_port *master;
f421436a AB	234	int res;
	235
	236	skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
	237	if (!skb)
	238	goto fail;
	239
	240	msg_head = genlmsg_put(skb, 0, 0, &hsr_genl_family, 0, HSR_C_NODE_DOWN);
	241	if (!msg_head)
	242	goto nla_put_failure;
	243
f421436a AB	244	res = nla_put(skb, HSR_A_NODE_ADDR, ETH_ALEN, addr);
	245	if (res < 0)
	246	goto nla_put_failure;
	247
	248	genlmsg_end(skb, msg_head);
2a94fe48	249	genlmsg_multicast(&hsr_genl_family, skb, 0, 0, GFP_ATOMIC);
f421436a AB	250
	251	return;
	252
	253	nla_put_failure:
	254	kfree_skb(skb);
	255
	256	fail:
c5a75911 AB	257	rcu_read_lock();
	258	master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
	259	netdev_warn(master->dev, "Could not send HSR node down\n");
	260	rcu_read_unlock();
f421436a AB	261	}
f421436a AB	262
f421436a AB	263	/* HSR_C_GET_NODE_STATUS lets userspace query the internal HSR node table
	264	* about the status of a specific node in the network, defined by its MAC
	265	* address.
	266	*
	267	* Input: hsr ifindex, node mac address
	268	* Output: hsr ifindex, node mac address (copied from request),
	269	* age of latest frame from node over slave 1, slave 2 [ms]
	270	*/
	271	static int hsr_get_node_status(struct sk_buff skb_in, struct genl_info info)
	272	{
	273	/* For receiving */
	274	struct nlattr *na;
c5a75911	275	struct net_device *hsr_dev;
f421436a AB	276
	277	/* For sending */
	278	struct sk_buff *skb_out;
	279	void *msg_head;
70ebe4a4	280	struct hsr_priv *hsr;
c5a75911	281	struct hsr_port *port;
f421436a AB	282	unsigned char hsr_node_addr_b[ETH_ALEN];
	283	int hsr_node_if1_age;
	284	u16 hsr_node_if1_seq;
	285	int hsr_node_if2_age;
	286	u16 hsr_node_if2_seq;
	287	int addr_b_ifindex;
	288	int res;
	289
	290	if (!info)
	291	goto invalid;
	292
	293	na = info->attrs[HSR_A_IFINDEX];
	294	if (!na)
	295	goto invalid;
	296	na = info->attrs[HSR_A_NODE_ADDR];
	297	if (!na)
	298	goto invalid;
	299
173756b8 TY	300	rcu_read_lock();
	301	hsr_dev = dev_get_by_index_rcu(genl_info_net(info),
	302	nla_get_u32(info->attrs[HSR_A_IFINDEX]));
f421436a	303	if (!hsr_dev)
173756b8	304	goto rcu_unlock;
f421436a	305	if (!is_hsr_master(hsr_dev))
173756b8	306	goto rcu_unlock;
f421436a	307
f421436a	308	/* Send reply */
173756b8	309	skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
f421436a AB	310	if (!skb_out) {
	311	res = -ENOMEM;
	312	goto fail;
	313	}
	314
	315	msg_head = genlmsg_put(skb_out, NETLINK_CB(skb_in).portid,
4fe25bd8 MK	316	info->snd_seq, &hsr_genl_family, 0,
4fe25bd8 MK	317	HSR_C_SET_NODE_STATUS);
f421436a AB	318	if (!msg_head) {
	319	res = -ENOMEM;
	320	goto nla_put_failure;
	321	}
	322
	323	res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
	324	if (res < 0)
	325	goto nla_put_failure;
	326
70ebe4a4 AB	327	hsr = netdev_priv(hsr_dev);
70ebe4a4 AB	328	res = hsr_get_node_data(hsr,
d595b85a MK	329	(unsigned char *)
	330	nla_data(info->attrs[HSR_A_NODE_ADDR]),
	331	hsr_node_addr_b,
	332	&addr_b_ifindex,
	333	&hsr_node_if1_age,
	334	&hsr_node_if1_seq,
	335	&hsr_node_if2_age,
	336	&hsr_node_if2_seq);
f421436a	337	if (res < 0)
84a035f6	338	goto nla_put_failure;
f421436a AB	339
f421436a AB	340	res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN,
4fe25bd8	341	nla_data(info->attrs[HSR_A_NODE_ADDR]));
f421436a AB	342	if (res < 0)
	343	goto nla_put_failure;
	344
	345	if (addr_b_ifindex > -1) {
	346	res = nla_put(skb_out, HSR_A_NODE_ADDR_B, ETH_ALEN,
d595b85a	347	hsr_node_addr_b);
f421436a AB	348	if (res < 0)
	349	goto nla_put_failure;
	350
d595b85a MK	351	res = nla_put_u32(skb_out, HSR_A_ADDR_B_IFINDEX,
d595b85a MK	352	addr_b_ifindex);
f421436a AB	353	if (res < 0)
	354	goto nla_put_failure;
	355	}
	356
	357	res = nla_put_u32(skb_out, HSR_A_IF1_AGE, hsr_node_if1_age);
	358	if (res < 0)
	359	goto nla_put_failure;
	360	res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq);
	361	if (res < 0)
	362	goto nla_put_failure;
c5a75911 AB	363	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
	364	if (port)
	365	res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX,
	366	port->dev->ifindex);
f421436a AB	367	if (res < 0)
	368	goto nla_put_failure;
	369
	370	res = nla_put_u32(skb_out, HSR_A_IF2_AGE, hsr_node_if2_age);
	371	if (res < 0)
	372	goto nla_put_failure;
	373	res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq);
	374	if (res < 0)
	375	goto nla_put_failure;
c5a75911 AB	376	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
	377	if (port)
	378	res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX,
	379	port->dev->ifindex);
51f3c605 AB	380	if (res < 0)
51f3c605 AB	381	goto nla_put_failure;
f421436a	382
173756b8 TY	383	rcu_read_unlock();
173756b8 TY	384
f421436a AB	385	genlmsg_end(skb_out, msg_head);
	386	genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);
	387
	388	return 0;
	389
173756b8 TY	390	rcu_unlock:
173756b8 TY	391	rcu_read_unlock();
f421436a	392	invalid:
2d4bc933	393	netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL, NULL);
f421436a AB	394	return 0;
	395
	396	nla_put_failure:
	397	kfree_skb(skb_out);
	398	/* Fall through */
	399
	400	fail:
173756b8	401	rcu_read_unlock();
f421436a AB	402	return res;
	403	}
	404
f266a683	405	/* Get a list of MacAddressA of all nodes known to this node (including self).
f421436a AB	406	*/
	407	static int hsr_get_node_list(struct sk_buff skb_in, struct genl_info info)
	408	{
ca19c70f	409	unsigned char addr[ETH_ALEN];
f421436a	410	struct net_device *hsr_dev;
f421436a	411	struct sk_buff *skb_out;
70ebe4a4	412	struct hsr_priv *hsr;
ca19c70f TY	413	bool restart = false;
	414	struct nlattr *na;
	415	void *pos = NULL;
	416	void *msg_head;
f421436a AB	417	int res;
	418
	419	if (!info)
	420	goto invalid;
	421
	422	na = info->attrs[HSR_A_IFINDEX];
	423	if (!na)
	424	goto invalid;
	425
173756b8 TY	426	rcu_read_lock();
	427	hsr_dev = dev_get_by_index_rcu(genl_info_net(info),
	428	nla_get_u32(info->attrs[HSR_A_IFINDEX]));
f421436a	429	if (!hsr_dev)
173756b8	430	goto rcu_unlock;
f421436a	431	if (!is_hsr_master(hsr_dev))
173756b8	432	goto rcu_unlock;
f421436a	433
ca19c70f	434	restart:
f421436a	435	/* Send reply */
ca19c70f	436	skb_out = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
f421436a AB	437	if (!skb_out) {
	438	res = -ENOMEM;
	439	goto fail;
	440	}
	441
	442	msg_head = genlmsg_put(skb_out, NETLINK_CB(skb_in).portid,
4fe25bd8 MK	443	info->snd_seq, &hsr_genl_family, 0,
4fe25bd8 MK	444	HSR_C_SET_NODE_LIST);
f421436a AB	445	if (!msg_head) {
	446	res = -ENOMEM;
	447	goto nla_put_failure;
	448	}
	449
ca19c70f TY	450	if (!restart) {
	451	res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
	452	if (res < 0)
	453	goto nla_put_failure;
	454	}
f421436a	455
70ebe4a4	456	hsr = netdev_priv(hsr_dev);
f421436a	457
ca19c70f TY	458	if (!pos)
ca19c70f TY	459	pos = hsr_get_next_node(hsr, NULL, addr);
f421436a AB	460	while (pos) {
	461	res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN, addr);
	462	if (res < 0) {
ca19c70f TY	463	if (res == -EMSGSIZE) {
	464	genlmsg_end(skb_out, msg_head);
	465	genlmsg_unicast(genl_info_net(info), skb_out,
	466	info->snd_portid);
	467	restart = true;
	468	goto restart;
	469	}
f421436a AB	470	goto nla_put_failure;
f421436a AB	471	}
70ebe4a4	472	pos = hsr_get_next_node(hsr, pos, addr);
f421436a AB	473	}
	474	rcu_read_unlock();
	475
	476	genlmsg_end(skb_out, msg_head);
	477	genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);
	478
	479	return 0;
	480
173756b8 TY	481	rcu_unlock:
173756b8 TY	482	rcu_read_unlock();
f421436a	483	invalid:
2d4bc933	484	netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL, NULL);
f421436a AB	485	return 0;
	486
	487	nla_put_failure:
ca19c70f	488	nlmsg_free(skb_out);
f421436a AB	489	/* Fall through */
	490
	491	fail:
173756b8	492	rcu_read_unlock();
f421436a AB	493	return res;
	494	}
	495
66a9b928	496	static const struct genl_small_ops hsr_ops[] = {
9504b3ee JB	497	{
9504b3ee JB	498	.cmd = HSR_C_GET_NODE_STATUS,
ef6243ac	499	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
9504b3ee	500	.flags = 0,
9504b3ee JB	501	.doit = hsr_get_node_status,
	502	.dumpit = NULL,
	503	},
	504	{
	505	.cmd = HSR_C_GET_NODE_LIST,
ef6243ac	506	.validate = GENL_DONT_VALIDATE_STRICT \| GENL_DONT_VALIDATE_DUMP,
9504b3ee	507	.flags = 0,
9504b3ee JB	508	.doit = hsr_get_node_list,
	509	.dumpit = NULL,
	510	},
f421436a AB	511	};
f421436a AB	512
56989f6d	513	static struct genl_family hsr_genl_family __ro_after_init = {
489111e5 JB	514	.hdrsize = 0,
	515	.name = "HSR",
	516	.version = 1,
	517	.maxattr = HSR_A_MAX,
3b0f31f2	518	.policy = hsr_genl_policy,
09e91dbe	519	.netnsok = true,
489111e5	520	.module = THIS_MODULE,
66a9b928 JK	521	.small_ops = hsr_ops,
66a9b928 JK	522	.n_small_ops = ARRAY_SIZE(hsr_ops),
9c5d03d3	523	.resv_start_op = HSR_C_SET_NODE_LIST + 1,
489111e5 JB	524	.mcgrps = hsr_mcgrps,
	525	.n_mcgrps = ARRAY_SIZE(hsr_mcgrps),
	526	};
	527
f421436a AB	528	int __init hsr_netlink_init(void)
	529	{
	530	int rc;
	531
	532	rc = rtnl_link_register(&hsr_link_ops);
	533	if (rc)
	534	goto fail_rtnl_link_register;
	535
489111e5	536	rc = genl_register_family(&hsr_genl_family);
f421436a AB	537	if (rc)
	538	goto fail_genl_register_family;
	539
c6c4ccd7	540	hsr_debugfs_create_root();
f421436a AB	541	return 0;
f421436a AB	542
f421436a AB	543	fail_genl_register_family:
	544	rtnl_link_unregister(&hsr_link_ops);
	545	fail_rtnl_link_register:
	546
	547	return rc;
	548	}
	549
	550	void __exit hsr_netlink_exit(void)
	551	{
f421436a	552	genl_unregister_family(&hsr_genl_family);
f421436a AB	553	rtnl_link_unregister(&hsr_link_ops);
	554	}
	555
	556	MODULE_ALIAS_RTNL_LINK("hsr");