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