net/hsr/hsr_netlink.c

   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");