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