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         .id = GENL_ID_GENERATE,
 136         .hdrsize = 0,
 137         .name = "HSR",
 138         .version = 1,
 139         .maxattr = HSR_A_MAX,
 140 };
 141
 142 static const struct genl_multicast_group hsr_mcgrps[] = {
 143         { .name = "hsr-network", },
 144 };
 145
 146
 147
 148 /* This is called if for some node with MAC address addr, we only get frames
 149  * over one of the slave interfaces. This would indicate an open network ring
 150  * (i.e. a link has failed somewhere).
 151  */
 152 void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
 153                       struct hsr_port *port)
 154 {
 155         struct sk_buff *skb;
 156         void *msg_head;
 157         struct hsr_port *master;
 158         int res;
 159
 160         skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
 161         if (!skb)
 162                 goto fail;
 163
 164         msg_head = genlmsg_put(skb, 0, 0, &hsr_genl_family, 0, HSR_C_RING_ERROR);
 165         if (!msg_head)
 166                 goto nla_put_failure;
 167
 168         res = nla_put(skb, HSR_A_NODE_ADDR, ETH_ALEN, addr);
 169         if (res < 0)
 170                 goto nla_put_failure;
 171
 172         res = nla_put_u32(skb, HSR_A_IFINDEX, port->dev->ifindex);
 173         if (res < 0)
 174                 goto nla_put_failure;
 175
 176         genlmsg_end(skb, msg_head);
 177         genlmsg_multicast(&hsr_genl_family, skb, 0, 0, GFP_ATOMIC);
 178
 179         return;
 180
 181 nla_put_failure:
 182         kfree_skb(skb);
 183
 184 fail:
 185         rcu_read_lock();
 186         master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
 187         netdev_warn(master->dev, "Could not send HSR ring error message\n");
 188         rcu_read_unlock();
 189 }
 190
 191 /* This is called when we haven't heard from the node with MAC address addr for
 192  * some time (just before the node is removed from the node table/list).
 193  */
 194 void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN])
 195 {
 196         struct sk_buff *skb;
 197         void *msg_head;
 198         struct hsr_port *master;
 199         int res;
 200
 201         skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
 202         if (!skb)
 203                 goto fail;
 204
 205         msg_head = genlmsg_put(skb, 0, 0, &hsr_genl_family, 0, HSR_C_NODE_DOWN);
 206         if (!msg_head)
 207                 goto nla_put_failure;
 208
 209
 210         res = nla_put(skb, HSR_A_NODE_ADDR, ETH_ALEN, addr);
 211         if (res < 0)
 212                 goto nla_put_failure;
 213
 214         genlmsg_end(skb, msg_head);
 215         genlmsg_multicast(&hsr_genl_family, skb, 0, 0, GFP_ATOMIC);
 216
 217         return;
 218
 219 nla_put_failure:
 220         kfree_skb(skb);
 221
 222 fail:
 223         rcu_read_lock();
 224         master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
 225         netdev_warn(master->dev, "Could not send HSR node down\n");
 226         rcu_read_unlock();
 227 }
 228
 229
 230 /* HSR_C_GET_NODE_STATUS lets userspace query the internal HSR node table
 231  * about the status of a specific node in the network, defined by its MAC
 232  * address.
 233  *
 234  * Input: hsr ifindex, node mac address
 235  * Output: hsr ifindex, node mac address (copied from request),
 236  *         age of latest frame from node over slave 1, slave 2 [ms]
 237  */
 238 static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
 239 {
 240         /* For receiving */
 241         struct nlattr *na;
 242         struct net_device *hsr_dev;
 243
 244         /* For sending */
 245         struct sk_buff *skb_out;
 246         void *msg_head;
 247         struct hsr_priv *hsr;
 248         struct hsr_port *port;
 249         unsigned char hsr_node_addr_b[ETH_ALEN];
 250         int hsr_node_if1_age;
 251         u16 hsr_node_if1_seq;
 252         int hsr_node_if2_age;
 253         u16 hsr_node_if2_seq;
 254         int addr_b_ifindex;
 255         int res;
 256
 257         if (!info)
 258                 goto invalid;
 259
 260         na = info->attrs[HSR_A_IFINDEX];
 261         if (!na)
 262                 goto invalid;
 263         na = info->attrs[HSR_A_NODE_ADDR];
 264         if (!na)
 265                 goto invalid;
 266
 267         hsr_dev = __dev_get_by_index(genl_info_net(info),
 268                                         nla_get_u32(info->attrs[HSR_A_IFINDEX]));
 269         if (!hsr_dev)
 270                 goto invalid;
 271         if (!is_hsr_master(hsr_dev))
 272                 goto invalid;
 273
 274
 275         /* Send reply */
 276
 277         skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 278         if (!skb_out) {
 279                 res = -ENOMEM;
 280                 goto fail;
 281         }
 282
 283         msg_head = genlmsg_put(skb_out, NETLINK_CB(skb_in).portid,
 284                                 info->snd_seq, &hsr_genl_family, 0,
 285                                 HSR_C_SET_NODE_STATUS);
 286         if (!msg_head) {
 287                 res = -ENOMEM;
 288                 goto nla_put_failure;
 289         }
 290
 291         res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
 292         if (res < 0)
 293                 goto nla_put_failure;
 294
 295         hsr = netdev_priv(hsr_dev);
 296         res = hsr_get_node_data(hsr,
 297                         (unsigned char *) nla_data(info->attrs[HSR_A_NODE_ADDR]),
 298                         hsr_node_addr_b,
 299                         &addr_b_ifindex,
 300                         &hsr_node_if1_age,
 301                         &hsr_node_if1_seq,
 302                         &hsr_node_if2_age,
 303                         &hsr_node_if2_seq);
 304         if (res < 0)
 305                 goto nla_put_failure;
 306
 307         res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN,
 308                                         nla_data(info->attrs[HSR_A_NODE_ADDR]));
 309         if (res < 0)
 310                 goto nla_put_failure;
 311
 312         if (addr_b_ifindex > -1) {
 313                 res = nla_put(skb_out, HSR_A_NODE_ADDR_B, ETH_ALEN,
 314                                                                 hsr_node_addr_b);
 315                 if (res < 0)
 316                         goto nla_put_failure;
 317
 318                 res = nla_put_u32(skb_out, HSR_A_ADDR_B_IFINDEX, addr_b_ifindex);
 319                 if (res < 0)
 320                         goto nla_put_failure;
 321         }
 322
 323         res = nla_put_u32(skb_out, HSR_A_IF1_AGE, hsr_node_if1_age);
 324         if (res < 0)
 325                 goto nla_put_failure;
 326         res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq);
 327         if (res < 0)
 328                 goto nla_put_failure;
 329         rcu_read_lock();
 330         port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
 331         if (port)
 332                 res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX,
 333                                   port->dev->ifindex);
 334         rcu_read_unlock();
 335         if (res < 0)
 336                 goto nla_put_failure;
 337
 338         res = nla_put_u32(skb_out, HSR_A_IF2_AGE, hsr_node_if2_age);
 339         if (res < 0)
 340                 goto nla_put_failure;
 341         res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq);
 342         if (res < 0)
 343                 goto nla_put_failure;
 344         rcu_read_lock();
 345         port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
 346         if (port)
 347                 res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX,
 348                                   port->dev->ifindex);
 349         rcu_read_unlock();
 350         if (res < 0)
 351                 goto nla_put_failure;
 352
 353         genlmsg_end(skb_out, msg_head);
 354         genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);
 355
 356         return 0;
 357
 358 invalid:
 359         netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL);
 360         return 0;
 361
 362 nla_put_failure:
 363         kfree_skb(skb_out);
 364         /* Fall through */
 365
 366 fail:
 367         return res;
 368 }
 369
 370 /* Get a list of MacAddressA of all nodes known to this node (including self).
 371  */
 372 static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info)
 373 {
 374         /* For receiving */
 375         struct nlattr *na;
 376         struct net_device *hsr_dev;
 377
 378         /* For sending */
 379         struct sk_buff *skb_out;
 380         void *msg_head;
 381         struct hsr_priv *hsr;
 382         void *pos;
 383         unsigned char addr[ETH_ALEN];
 384         int res;
 385
 386         if (!info)
 387                 goto invalid;
 388
 389         na = info->attrs[HSR_A_IFINDEX];
 390         if (!na)
 391                 goto invalid;
 392
 393         hsr_dev = __dev_get_by_index(genl_info_net(info),
 394                                      nla_get_u32(info->attrs[HSR_A_IFINDEX]));
 395         if (!hsr_dev)
 396                 goto invalid;
 397         if (!is_hsr_master(hsr_dev))
 398                 goto invalid;
 399
 400
 401         /* Send reply */
 402
 403         skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 404         if (!skb_out) {
 405                 res = -ENOMEM;
 406                 goto fail;
 407         }
 408
 409         msg_head = genlmsg_put(skb_out, NETLINK_CB(skb_in).portid,
 410                                 info->snd_seq, &hsr_genl_family, 0,
 411                                 HSR_C_SET_NODE_LIST);
 412         if (!msg_head) {
 413                 res = -ENOMEM;
 414                 goto nla_put_failure;
 415         }
 416
 417         res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
 418         if (res < 0)
 419                 goto nla_put_failure;
 420
 421         hsr = netdev_priv(hsr_dev);
 422
 423         rcu_read_lock();
 424         pos = hsr_get_next_node(hsr, NULL, addr);
 425         while (pos) {
 426                 res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN, addr);
 427                 if (res < 0) {
 428                         rcu_read_unlock();
 429                         goto nla_put_failure;
 430                 }
 431                 pos = hsr_get_next_node(hsr, pos, addr);
 432         }
 433         rcu_read_unlock();
 434
 435         genlmsg_end(skb_out, msg_head);
 436         genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);
 437
 438         return 0;
 439
 440 invalid:
 441         netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL);
 442         return 0;
 443
 444 nla_put_failure:
 445         kfree_skb(skb_out);
 446         /* Fall through */
 447
 448 fail:
 449         return res;
 450 }
 451
 452
 453 static const struct genl_ops hsr_ops[] = {
 454         {
 455                 .cmd = HSR_C_GET_NODE_STATUS,
 456                 .flags = 0,
 457                 .policy = hsr_genl_policy,
 458                 .doit = hsr_get_node_status,
 459                 .dumpit = NULL,
 460         },
 461         {
 462                 .cmd = HSR_C_GET_NODE_LIST,
 463                 .flags = 0,
 464                 .policy = hsr_genl_policy,
 465                 .doit = hsr_get_node_list,
 466                 .dumpit = NULL,
 467         },
 468 };
 469
 470 int __init hsr_netlink_init(void)
 471 {
 472         int rc;
 473
 474         rc = rtnl_link_register(&hsr_link_ops);
 475         if (rc)
 476                 goto fail_rtnl_link_register;
 477
 478         rc = genl_register_family_with_ops_groups(&hsr_genl_family, hsr_ops,
 479                                                   hsr_mcgrps);
 480         if (rc)
 481                 goto fail_genl_register_family;
 482
 483         return 0;
 484
 485 fail_genl_register_family:
 486         rtnl_link_unregister(&hsr_link_ops);
 487 fail_rtnl_link_register:
 488
 489         return rc;
 490 }
 491
 492 void __exit hsr_netlink_exit(void)
 493 {
 494         genl_unregister_family(&hsr_genl_family);
 495         rtnl_link_unregister(&hsr_link_ops);
 496 }
 497
 498 MODULE_ALIAS_RTNL_LINK("hsr");