hsr_netlink.c

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