net/hsr/hsr_netlink.c

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