net/hsr/hsr_slave.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
  12 #include "hsr_slave.h"
  13 #include <linux/etherdevice.h>
  14 #include <linux/if_arp.h>
  15 #include "hsr_main.h"
  16 #include "hsr_device.h"
  17 #include "hsr_forward.h"
  18 #include "hsr_framereg.h"
  19
  20
  21 static rx_handler_result_t hsr_handle_frame(struct sk_buff **pskb)
  22 {
  23         struct sk_buff *skb = *pskb;
  24         struct hsr_port *port;
  25         u16 protocol;
  26
  27         if (!skb_mac_header_was_set(skb)) {
  28                 WARN_ONCE(1, "%s: skb invalid", __func__);
  29                 return RX_HANDLER_PASS;
  30         }
  31
  32         rcu_read_lock(); /* hsr->node_db, hsr->ports */
  33         port = hsr_port_get_rcu(skb->dev);
  34         if (!port)
  35                 goto finish_pass;
  36
  37         if (hsr_addr_is_self(port->hsr, eth_hdr(skb)->h_source)) {
  38                 /* Directly kill frames sent by ourselves */
  39                 kfree_skb(skb);
  40                 goto finish_consume;
  41         }
  42
  43         protocol = eth_hdr(skb)->h_proto;
  44         if (protocol != htons(ETH_P_PRP) && protocol != htons(ETH_P_HSR))
  45                 goto finish_pass;
  46
  47         skb_push(skb, ETH_HLEN);
  48
  49         hsr_forward_skb(skb, port);
  50
  51 finish_consume:
  52         rcu_read_unlock(); /* hsr->node_db, hsr->ports */
  53         return RX_HANDLER_CONSUMED;
  54
  55 finish_pass:
  56         rcu_read_unlock(); /* hsr->node_db, hsr->ports */
  57         return RX_HANDLER_PASS;
  58 }
  59
  60 bool hsr_port_exists(const struct net_device *dev)
  61 {
  62         return rcu_access_pointer(dev->rx_handler) == hsr_handle_frame;
  63 }
  64
  65
  66 static int hsr_check_dev_ok(struct net_device *dev)
  67 {
  68         /* Don't allow HSR on non-ethernet like devices */
  69         if ((dev->flags & IFF_LOOPBACK) || (dev->type != ARPHRD_ETHER) ||
  70             (dev->addr_len != ETH_ALEN)) {
  71                 netdev_info(dev, "Cannot use loopback or non-ethernet device as HSR slave.\n");
  72                 return -EINVAL;
  73         }
  74
  75         /* Don't allow enslaving hsr devices */
  76         if (is_hsr_master(dev)) {
  77                 netdev_info(dev, "Cannot create trees of HSR devices.\n");
  78                 return -EINVAL;
  79         }
  80
  81         if (hsr_port_exists(dev)) {
  82                 netdev_info(dev, "This device is already a HSR slave.\n");
  83                 return -EINVAL;
  84         }
  85
  86         if (dev->priv_flags & IFF_802_1Q_VLAN) {
  87                 netdev_info(dev, "HSR on top of VLAN is not yet supported in this driver.\n");
  88                 return -EINVAL;
  89         }
  90
  91         if (dev->priv_flags & IFF_DONT_BRIDGE) {
  92                 netdev_info(dev, "This device does not support bridging.\n");
  93                 return -EOPNOTSUPP;
  94         }
  95
  96         /* HSR over bonded devices has not been tested, but I'm not sure it
  97          * won't work...
  98          */
  99
 100         return 0;
 101 }
 102
 103
 104 /* Setup device to be added to the HSR bridge. */
 105 static int hsr_portdev_setup(struct net_device *dev, struct hsr_port *port)
 106 {
 107         int res;
 108
 109         dev_hold(dev);
 110         res = dev_set_promiscuity(dev, 1);
 111         if (res)
 112                 goto fail_promiscuity;
 113
 114         /* FIXME:
 115          * What does net device "adjacency" mean? Should we do
 116          * res = netdev_master_upper_dev_link(port->dev, port->hsr->dev); ?
 117          */
 118
 119         res = netdev_rx_handler_register(dev, hsr_handle_frame, port);
 120         if (res)
 121                 goto fail_rx_handler;
 122         dev_disable_lro(dev);
 123
 124         return 0;
 125
 126 fail_rx_handler:
 127         dev_set_promiscuity(dev, -1);
 128 fail_promiscuity:
 129         dev_put(dev);
 130
 131         return res;
 132 }
 133
 134 int hsr_add_port(struct hsr_priv *hsr, struct net_device *dev,
 135                  enum hsr_port_type type)
 136 {
 137         struct hsr_port *port, *master;
 138         int res;
 139
 140         if (type != HSR_PT_MASTER) {
 141                 res = hsr_check_dev_ok(dev);
 142                 if (res)
 143                         return res;
 144         }
 145
 146         port = hsr_port_get_hsr(hsr, type);
 147         if (port != NULL)
 148                 return -EBUSY;  /* This port already exists */
 149
 150         port = kzalloc(sizeof(*port), GFP_KERNEL);
 151         if (port == NULL)
 152                 return -ENOMEM;
 153
 154         port->hsr = hsr;
 155         port->dev = dev;
 156         port->type = type;
 157
 158         if (type != HSR_PT_MASTER) {
 159                 res = hsr_portdev_setup(dev, port);
 160                 if (res)
 161                         goto fail_dev_setup;
 162         }
 163
 164         list_add_tail_rcu(&port->port_list, &hsr->ports);
 165         synchronize_rcu();
 166
 167         master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
 168         netdev_update_features(master->dev);
 169         dev_set_mtu(master->dev, hsr_get_max_mtu(hsr));
 170
 171         return 0;
 172
 173 fail_dev_setup:
 174         kfree(port);
 175         return res;
 176 }
 177
 178 void hsr_del_port(struct hsr_port *port)
 179 {
 180         struct hsr_priv *hsr;
 181         struct hsr_port *master;
 182
 183         hsr = port->hsr;
 184         master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
 185         list_del_rcu(&port->port_list);
 186
 187         if (port != master) {
 188                 if (master != NULL) {
 189                         netdev_update_features(master->dev);
 190                         dev_set_mtu(master->dev, hsr_get_max_mtu(hsr));
 191                 }
 192                 netdev_rx_handler_unregister(port->dev);
 193                 dev_set_promiscuity(port->dev, -1);
 194         }
 195
 196         /* FIXME?
 197          * netdev_upper_dev_unlink(port->dev, port->hsr->dev);
 198          */
 199
 200         synchronize_rcu();
 201
 202         if (port != master)
 203                 dev_put(port->dev);
 204 }