[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 },
	[IFLA_HSR_INTERLINK]		= { .type = NLA_U32 },
};

/* 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_device *dev,
		       struct rtnl_newlink_params *params,
		       struct netlink_ext_ack *extack)
{
	struct net *link_net = rtnl_newlink_link_net(params);
	struct nlattr **data = params->data;
	enum hsr_version proto_version;
	unsigned char multicast_spec;
	u8 proto = HSR_PROTOCOL_HSR;

	struct net_device *link[2], *interlink = NULL;
	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(link_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(link_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_INTERLINK])
		interlink = __dev_get_by_index(link_net,
					       nla_get_u32(data[IFLA_HSR_INTERLINK]));

	if (interlink && interlink == link[0]) {
		NL_SET_ERR_MSG_MOD(extack, "Interlink and Slave1 are the same");
		return -EINVAL;
	}

	if (interlink && interlink == link[1]) {
		NL_SET_ERR_MSG_MOD(extack, "Interlink and Slave2 are the same");
		return -EINVAL;
	}

	multicast_spec = nla_get_u8_default(data[IFLA_HSR_MULTICAST_SPEC], 0);

	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;
		if (interlink) {
			NL_SET_ERR_MSG_MOD(extack,
					   "Interlink only works with HSR");
			return -EINVAL;
		}
	}

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

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

	timer_delete_sync(&hsr->prune_timer);
	timer_delete_sync(&hsr->prune_proxy_timer);
	timer_delete_sync(&hsr->announce_timer);
	timer_delete_sync(&hsr->announce_proxy_timer);

	hsr_debugfs_term(hsr);
	hsr_del_ports(hsr);

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