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