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