net/hsr/hsr_device.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  * This file contains device methods for creating, using and destroying
  12  * virtual HSR devices.
  13  */
  14
  15 #include <linux/netdevice.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/etherdevice.h>
  18 #include <linux/if_arp.h>
  19 #include <linux/rtnetlink.h>
  20 #include <linux/pkt_sched.h>
  21 #include "hsr_device.h"
  22 #include "hsr_framereg.h"
  23 #include "hsr_main.h"
  24
  25
  26 static bool is_admin_up(struct net_device *dev)
  27 {
  28         return dev && (dev->flags & IFF_UP);
  29 }
  30
  31 static bool is_slave_up(struct net_device *dev)
  32 {
  33         return dev && is_admin_up(dev) && netif_oper_up(dev);
  34 }
  35
  36 static void __hsr_set_operstate(struct net_device *dev, int transition)
  37 {
  38         write_lock_bh(&dev_base_lock);
  39         if (dev->operstate != transition) {
  40                 dev->operstate = transition;
  41                 write_unlock_bh(&dev_base_lock);
  42                 netdev_state_change(dev);
  43         } else {
  44                 write_unlock_bh(&dev_base_lock);
  45         }
  46 }
  47
  48 void hsr_set_operstate(struct net_device *hsr_dev, struct net_device *slave1,
  49                        struct net_device *slave2)
  50 {
  51         if (!is_admin_up(hsr_dev)) {
  52                 __hsr_set_operstate(hsr_dev, IF_OPER_DOWN);
  53                 return;
  54         }
  55
  56         if (is_slave_up(slave1) || is_slave_up(slave2))
  57                 __hsr_set_operstate(hsr_dev, IF_OPER_UP);
  58         else
  59                 __hsr_set_operstate(hsr_dev, IF_OPER_LOWERLAYERDOWN);
  60 }
  61
  62 void hsr_set_carrier(struct net_device *hsr_dev, struct net_device *slave1,
  63                      struct net_device *slave2)
  64 {
  65         if (is_slave_up(slave1) || is_slave_up(slave2))
  66                 netif_carrier_on(hsr_dev);
  67         else
  68                 netif_carrier_off(hsr_dev);
  69 }
  70
  71
  72 void hsr_check_announce(struct net_device *hsr_dev, int old_operstate)
  73 {
  74         struct hsr_priv *hsr_priv;
  75
  76         hsr_priv = netdev_priv(hsr_dev);
  77
  78         if ((hsr_dev->operstate == IF_OPER_UP) && (old_operstate != IF_OPER_UP)) {
  79                 /* Went up */
  80                 hsr_priv->announce_count = 0;
  81                 hsr_priv->announce_timer.expires = jiffies +
  82                                 msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL);
  83                 add_timer(&hsr_priv->announce_timer);
  84         }
  85
  86         if ((hsr_dev->operstate != IF_OPER_UP) && (old_operstate == IF_OPER_UP))
  87                 /* Went down */
  88                 del_timer(&hsr_priv->announce_timer);
  89 }
  90
  91
  92 int hsr_get_max_mtu(struct hsr_priv *hsr_priv)
  93 {
  94         int mtu_max;
  95
  96         if (hsr_priv->slave[0] && hsr_priv->slave[1])
  97                 mtu_max = min(hsr_priv->slave[0]->mtu, hsr_priv->slave[1]->mtu);
  98         else if (hsr_priv->slave[0])
  99                 mtu_max = hsr_priv->slave[0]->mtu;
 100         else if (hsr_priv->slave[1])
 101                 mtu_max = hsr_priv->slave[1]->mtu;
 102         else
 103                 mtu_max = HSR_TAGLEN;
 104
 105         return mtu_max - HSR_TAGLEN;
 106 }
 107
 108 static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)
 109 {
 110         struct hsr_priv *hsr_priv;
 111
 112         hsr_priv = netdev_priv(dev);
 113
 114         if (new_mtu > hsr_get_max_mtu(hsr_priv)) {
 115                 netdev_info(hsr_priv->dev, "A HSR master's MTU cannot be greater than the smallest MTU of its slaves minus the HSR Tag length (%d octets).\n",
 116                             HSR_TAGLEN);
 117                 return -EINVAL;
 118         }
 119
 120         dev->mtu = new_mtu;
 121
 122         return 0;
 123 }
 124
 125 static int hsr_dev_open(struct net_device *dev)
 126 {
 127         struct hsr_priv *hsr_priv;
 128         int i;
 129         char *slave_name;
 130
 131         hsr_priv = netdev_priv(dev);
 132
 133         for (i = 0; i < HSR_MAX_SLAVE; i++) {
 134                 if (hsr_priv->slave[i])
 135                         slave_name = hsr_priv->slave[i]->name;
 136                 else
 137                         slave_name = "null";
 138
 139                 if (!is_slave_up(hsr_priv->slave[i]))
 140                         netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a working HSR network\n",
 141                                     'A' + i, slave_name);
 142         }
 143
 144         return 0;
 145 }
 146
 147 static int hsr_dev_close(struct net_device *dev)
 148 {
 149         /* Nothing to do here. We could try to restore the state of the slaves
 150          * to what they were before being changed by the hsr master dev's state,
 151          * but they might have been changed manually in the mean time too, so
 152          * taking them up or down here might be confusing and is probably not a
 153          * good idea.
 154          */
 155         return 0;
 156 }
 157
 158
 159 static void hsr_fill_tag(struct hsr_ethhdr *hsr_ethhdr, struct hsr_priv *hsr_priv)
 160 {
 161         unsigned long irqflags;
 162
 163         /* IEC 62439-1:2010, p 48, says the 4-bit "path" field can take values
 164          * between 0001-1001 ("ring identifier", for regular HSR frames),
 165          * or 1111 ("HSR management", supervision frames). Unfortunately, the
 166          * spec writers forgot to explain what a "ring identifier" is, or
 167          * how it is used. So we just set this to 0001 for regular frames,
 168          * and 1111 for supervision frames.
 169          */
 170         set_hsr_tag_path(&hsr_ethhdr->hsr_tag, 0x1);
 171
 172         /* IEC 62439-1:2010, p 12: "The link service data unit in an Ethernet
 173          * frame is the content of the frame located between the Length/Type
 174          * field and the Frame Check Sequence."
 175          *
 176          * IEC 62439-3, p 48, specifies the "original LPDU" to include the
 177          * original "LT" field (what "LT" means is not explained anywhere as
 178          * far as I can see - perhaps "Length/Type"?). So LSDU_size might
 179          * equal original length + 2.
 180          *   Also, the fact that this field is not used anywhere (might be used
 181          * by a RedBox connecting HSR and PRP nets?) means I cannot test its
 182          * correctness. Instead of guessing, I set this to 0 here, to make any
 183          * problems immediately apparent. Anyone using this driver with PRP/HSR
 184          * RedBoxes might need to fix this...
 185          */
 186         set_hsr_tag_LSDU_size(&hsr_ethhdr->hsr_tag, 0);
 187
 188         spin_lock_irqsave(&hsr_priv->seqnr_lock, irqflags);
 189         hsr_ethhdr->hsr_tag.sequence_nr = htons(hsr_priv->sequence_nr);
 190         hsr_priv->sequence_nr++;
 191         spin_unlock_irqrestore(&hsr_priv->seqnr_lock, irqflags);
 192
 193         hsr_ethhdr->hsr_tag.encap_proto = hsr_ethhdr->ethhdr.h_proto;
 194
 195         hsr_ethhdr->ethhdr.h_proto = htons(ETH_P_PRP);
 196 }
 197
 198 static int slave_xmit(struct sk_buff *skb, struct hsr_priv *hsr_priv,
 199                       enum hsr_dev_idx dev_idx)
 200 {
 201         struct hsr_ethhdr *hsr_ethhdr;
 202
 203         hsr_ethhdr = (struct hsr_ethhdr *) skb->data;
 204
 205         skb->dev = hsr_priv->slave[dev_idx];
 206
 207         hsr_addr_subst_dest(hsr_priv, &hsr_ethhdr->ethhdr, dev_idx);
 208
 209         /* Address substitution (IEC62439-3 pp 26, 50): replace mac
 210          * address of outgoing frame with that of the outgoing slave's.
 211          */
 212         ether_addr_copy(hsr_ethhdr->ethhdr.h_source, skb->dev->dev_addr);
 213
 214         return dev_queue_xmit(skb);
 215 }
 216
 217
 218 static int hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev)
 219 {
 220         struct hsr_priv *hsr_priv;
 221         struct hsr_ethhdr *hsr_ethhdr;
 222         struct sk_buff *skb2;
 223         int res1, res2;
 224
 225         hsr_priv = netdev_priv(dev);
 226         hsr_ethhdr = (struct hsr_ethhdr *) skb->data;
 227
 228         if ((skb->protocol != htons(ETH_P_PRP)) ||
 229             (hsr_ethhdr->ethhdr.h_proto != htons(ETH_P_PRP))) {
 230                 hsr_fill_tag(hsr_ethhdr, hsr_priv);
 231                 skb->protocol = htons(ETH_P_PRP);
 232         }
 233
 234         skb2 = pskb_copy(skb, GFP_ATOMIC);
 235
 236         res1 = NET_XMIT_DROP;
 237         if (likely(hsr_priv->slave[HSR_DEV_SLAVE_A]))
 238                 res1 = slave_xmit(skb, hsr_priv, HSR_DEV_SLAVE_A);
 239
 240         res2 = NET_XMIT_DROP;
 241         if (likely(skb2 && hsr_priv->slave[HSR_DEV_SLAVE_B]))
 242                 res2 = slave_xmit(skb2, hsr_priv, HSR_DEV_SLAVE_B);
 243
 244         if (likely(res1 == NET_XMIT_SUCCESS || res1 == NET_XMIT_CN ||
 245                    res2 == NET_XMIT_SUCCESS || res2 == NET_XMIT_CN)) {
 246                 hsr_priv->dev->stats.tx_packets++;
 247                 hsr_priv->dev->stats.tx_bytes += skb->len;
 248         } else {
 249                 hsr_priv->dev->stats.tx_dropped++;
 250         }
 251
 252         return NETDEV_TX_OK;
 253 }
 254
 255
 256 static int hsr_header_create(struct sk_buff *skb, struct net_device *dev,
 257                              unsigned short type, const void *daddr,
 258                              const void *saddr, unsigned int len)
 259 {
 260         int res;
 261
 262         /* Make room for the HSR tag now. We will fill it in later (in
 263          * hsr_dev_xmit)
 264          */
 265         if (skb_headroom(skb) < HSR_TAGLEN + ETH_HLEN)
 266                 return -ENOBUFS;
 267         skb_push(skb, HSR_TAGLEN);
 268
 269         /* To allow VLAN/HSR combos we should probably use
 270          * res = dev_hard_header(skb, dev, type, daddr, saddr, len + HSR_TAGLEN);
 271          * here instead. It would require other changes too, though - e.g.
 272          * separate headers for each slave etc...
 273          */
 274         res = eth_header(skb, dev, type, daddr, saddr, len + HSR_TAGLEN);
 275         if (res <= 0)
 276                 return res;
 277         skb_reset_mac_header(skb);
 278
 279         return res + HSR_TAGLEN;
 280 }
 281
 282
 283 static const struct header_ops hsr_header_ops = {
 284         .create  = hsr_header_create,
 285         .parse   = eth_header_parse,
 286 };
 287
 288
 289 /* HSR:2010 supervision frames should be padded so that the whole frame,
 290  * including headers and FCS, is 64 bytes (without VLAN).
 291  */
 292 static int hsr_pad(int size)
 293 {
 294         const int min_size = ETH_ZLEN - HSR_TAGLEN - ETH_HLEN;
 295
 296         if (size >= min_size)
 297                 return size;
 298         return min_size;
 299 }
 300
 301 static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
 302 {
 303         struct hsr_priv *hsr_priv;
 304         struct sk_buff *skb;
 305         int hlen, tlen;
 306         struct hsr_sup_tag *hsr_stag;
 307         struct hsr_sup_payload *hsr_sp;
 308         unsigned long irqflags;
 309
 310         hlen = LL_RESERVED_SPACE(hsr_dev);
 311         tlen = hsr_dev->needed_tailroom;
 312         skb = alloc_skb(hsr_pad(sizeof(struct hsr_sup_payload)) + hlen + tlen,
 313                         GFP_ATOMIC);
 314
 315         if (skb == NULL)
 316                 return;
 317
 318         hsr_priv = netdev_priv(hsr_dev);
 319
 320         skb_reserve(skb, hlen);
 321
 322         skb->dev = hsr_dev;
 323         skb->protocol = htons(ETH_P_PRP);
 324         skb->priority = TC_PRIO_CONTROL;
 325
 326         if (dev_hard_header(skb, skb->dev, ETH_P_PRP,
 327                             hsr_priv->sup_multicast_addr,
 328                             skb->dev->dev_addr, skb->len) < 0)
 329                 goto out;
 330
 331         skb_pull(skb, sizeof(struct ethhdr));
 332         hsr_stag = (typeof(hsr_stag)) skb->data;
 333
 334         set_hsr_stag_path(hsr_stag, 0xf);
 335         set_hsr_stag_HSR_Ver(hsr_stag, 0);
 336
 337         spin_lock_irqsave(&hsr_priv->seqnr_lock, irqflags);
 338         hsr_stag->sequence_nr = htons(hsr_priv->sequence_nr);
 339         hsr_priv->sequence_nr++;
 340         spin_unlock_irqrestore(&hsr_priv->seqnr_lock, irqflags);
 341
 342         hsr_stag->HSR_TLV_Type = type;
 343         hsr_stag->HSR_TLV_Length = 12;
 344
 345         skb_push(skb, sizeof(struct ethhdr));
 346
 347         /* Payload: MacAddressA */
 348         hsr_sp = (typeof(hsr_sp)) skb_put(skb, sizeof(*hsr_sp));
 349         ether_addr_copy(hsr_sp->MacAddressA, hsr_dev->dev_addr);
 350
 351         dev_queue_xmit(skb);
 352         return;
 353
 354 out:
 355         kfree_skb(skb);
 356 }
 357
 358
 359 /* Announce (supervision frame) timer function
 360  */
 361 static void hsr_announce(unsigned long data)
 362 {
 363         struct hsr_priv *hsr_priv;
 364
 365         hsr_priv = (struct hsr_priv *) data;
 366
 367         if (hsr_priv->announce_count < 3) {
 368                 send_hsr_supervision_frame(hsr_priv->dev, HSR_TLV_ANNOUNCE);
 369                 hsr_priv->announce_count++;
 370         } else {
 371                 send_hsr_supervision_frame(hsr_priv->dev, HSR_TLV_LIFE_CHECK);
 372         }
 373
 374         if (hsr_priv->announce_count < 3)
 375                 hsr_priv->announce_timer.expires = jiffies +
 376                                 msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL);
 377         else
 378                 hsr_priv->announce_timer.expires = jiffies +
 379                                 msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL);
 380
 381         if (is_admin_up(hsr_priv->dev))
 382                 add_timer(&hsr_priv->announce_timer);
 383 }
 384
 385
 386 static void restore_slaves(struct net_device *hsr_dev)
 387 {
 388         struct hsr_priv *hsr_priv;
 389         int i;
 390         int res;
 391
 392         hsr_priv = netdev_priv(hsr_dev);
 393
 394         rtnl_lock();
 395
 396         /* Restore promiscuity */
 397         for (i = 0; i < HSR_MAX_SLAVE; i++) {
 398                 if (!hsr_priv->slave[i])
 399                         continue;
 400                 res = dev_set_promiscuity(hsr_priv->slave[i], -1);
 401                 if (res)
 402                         netdev_info(hsr_dev,
 403                                     "Cannot restore slave promiscuity (%s, %d)\n",
 404                                     hsr_priv->slave[i]->name, res);
 405         }
 406
 407         rtnl_unlock();
 408 }
 409
 410 static void reclaim_hsr_dev(struct rcu_head *rh)
 411 {
 412         struct hsr_priv *hsr_priv;
 413
 414         hsr_priv = container_of(rh, struct hsr_priv, rcu_head);
 415         free_netdev(hsr_priv->dev);
 416 }
 417
 418
 419 /* According to comments in the declaration of struct net_device, this function
 420  * is "Called from unregister, can be used to call free_netdev". Ok then...
 421  */
 422 static void hsr_dev_destroy(struct net_device *hsr_dev)
 423 {
 424         struct hsr_priv *hsr_priv;
 425
 426         hsr_priv = netdev_priv(hsr_dev);
 427
 428         del_timer(&hsr_priv->announce_timer);
 429         unregister_hsr_master(hsr_priv);    /* calls list_del_rcu on hsr_priv */
 430         restore_slaves(hsr_dev);
 431         call_rcu(&hsr_priv->rcu_head, reclaim_hsr_dev);   /* reclaim hsr_priv */
 432 }
 433
 434 static const struct net_device_ops hsr_device_ops = {
 435         .ndo_change_mtu = hsr_dev_change_mtu,
 436         .ndo_open = hsr_dev_open,
 437         .ndo_stop = hsr_dev_close,
 438         .ndo_start_xmit = hsr_dev_xmit,
 439 };
 440
 441
 442 void hsr_dev_setup(struct net_device *dev)
 443 {
 444         random_ether_addr(dev->dev_addr);
 445
 446         ether_setup(dev);
 447         dev->header_ops          = &hsr_header_ops;
 448         dev->netdev_ops          = &hsr_device_ops;
 449         dev->tx_queue_len        = 0;
 450
 451         dev->destructor = hsr_dev_destroy;
 452 }
 453
 454
 455 /* Return true if dev is a HSR master; return false otherwise.
 456  */
 457 bool is_hsr_master(struct net_device *dev)
 458 {
 459         return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit);
 460 }
 461
 462 static int check_slave_ok(struct net_device *dev)
 463 {
 464         /* Don't allow HSR on non-ethernet like devices */
 465         if ((dev->flags & IFF_LOOPBACK) || (dev->type != ARPHRD_ETHER) ||
 466             (dev->addr_len != ETH_ALEN)) {
 467                 netdev_info(dev, "Cannot use loopback or non-ethernet device as HSR slave.\n");
 468                 return -EINVAL;
 469         }
 470
 471         /* Don't allow enslaving hsr devices */
 472         if (is_hsr_master(dev)) {
 473                 netdev_info(dev, "Cannot create trees of HSR devices.\n");
 474                 return -EINVAL;
 475         }
 476
 477         if (is_hsr_slave(dev)) {
 478                 netdev_info(dev, "This device is already a HSR slave.\n");
 479                 return -EINVAL;
 480         }
 481
 482         if (dev->priv_flags & IFF_802_1Q_VLAN) {
 483                 netdev_info(dev, "HSR on top of VLAN is not yet supported in this driver.\n");
 484                 return -EINVAL;
 485         }
 486
 487         /* HSR over bonded devices has not been tested, but I'm not sure it
 488          * won't work...
 489          */
 490
 491         return 0;
 492 }
 493
 494
 495 /* Default multicast address for HSR Supervision frames */
 496 static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = {
 497         0x01, 0x15, 0x4e, 0x00, 0x01, 0x00
 498 };
 499
 500 int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
 501                      unsigned char multicast_spec)
 502 {
 503         struct hsr_priv *hsr_priv;
 504         int i;
 505         int res;
 506
 507         hsr_priv = netdev_priv(hsr_dev);
 508         hsr_priv->dev = hsr_dev;
 509         INIT_LIST_HEAD(&hsr_priv->node_db);
 510         INIT_LIST_HEAD(&hsr_priv->self_node_db);
 511         for (i = 0; i < HSR_MAX_SLAVE; i++)
 512                 hsr_priv->slave[i] = slave[i];
 513
 514         spin_lock_init(&hsr_priv->seqnr_lock);
 515         /* Overflow soon to find bugs easier: */
 516         hsr_priv->sequence_nr = USHRT_MAX - 1024;
 517
 518         init_timer(&hsr_priv->announce_timer);
 519         hsr_priv->announce_timer.function = hsr_announce;
 520         hsr_priv->announce_timer.data = (unsigned long) hsr_priv;
 521
 522         ether_addr_copy(hsr_priv->sup_multicast_addr, def_multicast_addr);
 523         hsr_priv->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec;
 524
 525 /* FIXME: should I modify the value of these?
 526  *
 527  * - hsr_dev->flags - i.e.
 528  *                      IFF_MASTER/SLAVE?
 529  * - hsr_dev->priv_flags - i.e.
 530  *                      IFF_EBRIDGE?
 531  *                      IFF_TX_SKB_SHARING?
 532  *                      IFF_HSR_MASTER/SLAVE?
 533  */
 534
 535         for (i = 0; i < HSR_MAX_SLAVE; i++) {
 536                 res = check_slave_ok(slave[i]);
 537                 if (res)
 538                         return res;
 539         }
 540
 541         hsr_dev->features = slave[0]->features & slave[1]->features;
 542         /* Prevent recursive tx locking */
 543         hsr_dev->features |= NETIF_F_LLTX;
 544         /* VLAN on top of HSR needs testing and probably some work on
 545          * hsr_header_create() etc.
 546          */
 547         hsr_dev->features |= NETIF_F_VLAN_CHALLENGED;
 548
 549         /* Set hsr_dev's MAC address to that of mac_slave1 */
 550         ether_addr_copy(hsr_dev->dev_addr, hsr_priv->slave[0]->dev_addr);
 551
 552         /* Set required header length */
 553         for (i = 0; i < HSR_MAX_SLAVE; i++) {
 554                 if (slave[i]->hard_header_len + HSR_TAGLEN >
 555                                                 hsr_dev->hard_header_len)
 556                         hsr_dev->hard_header_len =
 557                                         slave[i]->hard_header_len + HSR_TAGLEN;
 558         }
 559
 560         /* MTU */
 561         for (i = 0; i < HSR_MAX_SLAVE; i++)
 562                 if (slave[i]->mtu - HSR_TAGLEN < hsr_dev->mtu)
 563                         hsr_dev->mtu = slave[i]->mtu - HSR_TAGLEN;
 564
 565         /* Make sure the 1st call to netif_carrier_on() gets through */
 566         netif_carrier_off(hsr_dev);
 567
 568         /* Promiscuity */
 569         for (i = 0; i < HSR_MAX_SLAVE; i++) {
 570                 res = dev_set_promiscuity(slave[i], 1);
 571                 if (res) {
 572                         netdev_info(hsr_dev, "Cannot set slave promiscuity (%s, %d)\n",
 573                                     slave[i]->name, res);
 574                         goto fail;
 575                 }
 576         }
 577
 578         /* Make sure we recognize frames from ourselves in hsr_rcv() */
 579         res = hsr_create_self_node(&hsr_priv->self_node_db,
 580                                         hsr_dev->dev_addr,
 581                                         hsr_priv->slave[1]->dev_addr);
 582         if (res < 0)
 583                 goto fail;
 584
 585         res = register_netdevice(hsr_dev);
 586         if (res)
 587                 goto fail;
 588
 589         register_hsr_master(hsr_priv);
 590
 591         return 0;
 592
 593 fail:
 594         restore_slaves(hsr_dev);
 595         return res;
 596 }