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