net/hsr/hsr_netlink.c

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