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 */
hsr_newlink(struct net_device * dev,struct rtnl_newlink_params * params,struct netlink_ext_ack * extack)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
hsr_dellink(struct net_device * dev,struct list_head * head)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
hsr_fill_info(struct sk_buff * skb,const struct net_device * dev)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 */
hsr_nl_ringerror(struct hsr_priv * hsr,unsigned char addr[ETH_ALEN],struct hsr_port * port)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 */
hsr_nl_nodedown(struct hsr_priv * hsr,unsigned char addr[ETH_ALEN])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 */
hsr_get_node_status(struct sk_buff * skb_in,struct genl_info * info)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 */
hsr_get_node_list(struct sk_buff * skb_in,struct genl_info * info)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
hsr_netlink_init(void)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
hsr_netlink_exit(void)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");
581