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