net/hsr/hsr_main.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 <linux/netdevice.h>
  13 #include <linux/rculist.h>
  14 #include <linux/timer.h>
  15 #include <linux/etherdevice.h>
  16 #include "hsr_main.h"
  17 #include "hsr_device.h"
  18 #include "hsr_netlink.h"
  19 #include "hsr_framereg.h"
  20
  21
  22 /* List of all registered virtual HSR devices */
  23 static LIST_HEAD(hsr_list);
  24
  25 void register_hsr_master(struct hsr_priv *hsr)
  26 {
  27         list_add_tail_rcu(&hsr->hsr_list, &hsr_list);
  28 }
  29
  30 void unregister_hsr_master(struct hsr_priv *hsr)
  31 {
  32         struct hsr_priv *hsr_it;
  33
  34         list_for_each_entry(hsr_it, &hsr_list, hsr_list)
  35                 if (hsr_it == hsr) {
  36                         list_del_rcu(&hsr_it->hsr_list);
  37                         return;
  38                 }
  39 }
  40
  41 bool is_hsr_slave(struct net_device *dev)
  42 {
  43         struct hsr_priv *hsr_it;
  44
  45         list_for_each_entry_rcu(hsr_it, &hsr_list, hsr_list) {
  46                 if (dev == hsr_it->slave[0])
  47                         return true;
  48                 if (dev == hsr_it->slave[1])
  49                         return true;
  50         }
  51
  52         return false;
  53 }
  54
  55 /* If dev is a HSR slave device, return the virtual master device. Return NULL
  56  * otherwise.
  57  */
  58 struct hsr_priv *get_hsr_master(struct net_device *dev)
  59 {
  60         struct hsr_priv *hsr;
  61
  62         rcu_read_lock();
  63         list_for_each_entry_rcu(hsr, &hsr_list, hsr_list)
  64                 if ((dev == hsr->slave[0]) ||
  65                     (dev == hsr->slave[1])) {
  66                         rcu_read_unlock();
  67                         return hsr;
  68                 }
  69
  70         rcu_read_unlock();
  71         return NULL;
  72 }
  73
  74 /* If dev is a HSR slave device, return the other slave device. Return NULL
  75  * otherwise.
  76  */
  77 struct net_device *get_other_slave(struct hsr_priv *hsr,
  78                                    struct net_device *dev)
  79 {
  80         if (dev == hsr->slave[0])
  81                 return hsr->slave[1];
  82         if (dev == hsr->slave[1])
  83                 return hsr->slave[0];
  84
  85         return NULL;
  86 }
  87
  88
  89 static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
  90                              void *ptr)
  91 {
  92         struct net_device *slave, *other_slave;
  93         struct hsr_priv *hsr;
  94         int mtu_max;
  95         int res;
  96         struct net_device *dev;
  97
  98         dev = netdev_notifier_info_to_dev(ptr);
  99
 100         hsr = get_hsr_master(dev);
 101         if (hsr) {
 102                 /* dev is a slave device */
 103                 slave = dev;
 104                 other_slave = get_other_slave(hsr, slave);
 105         } else {
 106                 if (!is_hsr_master(dev))
 107                         return NOTIFY_DONE;
 108                 hsr = netdev_priv(dev);
 109                 slave = hsr->slave[0];
 110                 other_slave = hsr->slave[1];
 111         }
 112
 113         switch (event) {
 114         case NETDEV_UP:         /* Administrative state DOWN */
 115         case NETDEV_DOWN:       /* Administrative state UP */
 116         case NETDEV_CHANGE:     /* Link (carrier) state changes */
 117                 hsr_check_carrier_and_operstate(hsr);
 118                 break;
 119         case NETDEV_CHANGEADDR:
 120
 121                 /* This should not happen since there's no ndo_set_mac_address()
 122                  * for HSR devices - i.e. not supported.
 123                  */
 124                 if (dev == hsr->dev)
 125                         break;
 126
 127                 if (dev == hsr->slave[0])
 128                         ether_addr_copy(hsr->dev->dev_addr,
 129                                         hsr->slave[0]->dev_addr);
 130
 131                 /* Make sure we recognize frames from ourselves in hsr_rcv() */
 132                 res = hsr_create_self_node(&hsr->self_node_db,
 133                                            hsr->dev->dev_addr,
 134                                            hsr->slave[1] ?
 135                                                 hsr->slave[1]->dev_addr :
 136                                                 hsr->dev->dev_addr);
 137                 if (res)
 138                         netdev_warn(hsr->dev,
 139                                     "Could not update HSR node address.\n");
 140
 141                 if (dev == hsr->slave[0])
 142                         call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr->dev);
 143                 break;
 144         case NETDEV_CHANGEMTU:
 145                 if (dev == hsr->dev)
 146                         break; /* Handled in ndo_change_mtu() */
 147                 mtu_max = hsr_get_max_mtu(hsr);
 148                 if (hsr->dev->mtu > mtu_max)
 149                         dev_set_mtu(hsr->dev, mtu_max);
 150                 break;
 151         case NETDEV_UNREGISTER:
 152                 if (dev == hsr->slave[0])
 153                         hsr->slave[0] = NULL;
 154                 if (dev == hsr->slave[1])
 155                         hsr->slave[1] = NULL;
 156
 157                 /* There should really be a way to set a new slave device... */
 158
 159                 break;
 160         case NETDEV_PRE_TYPE_CHANGE:
 161                 /* HSR works only on Ethernet devices. Refuse slave to change
 162                  * its type.
 163                  */
 164                 return NOTIFY_BAD;
 165         }
 166
 167         return NOTIFY_DONE;
 168 }
 169
 170
 171 static struct notifier_block hsr_nb = {
 172         .notifier_call = hsr_netdev_notify,     /* Slave event notifications */
 173 };
 174
 175
 176 static int __init hsr_init(void)
 177 {
 178         int res;
 179
 180         BUILD_BUG_ON(sizeof(struct hsr_tag) != HSR_HLEN);
 181
 182         register_netdevice_notifier(&hsr_nb);
 183         res = hsr_netlink_init();
 184
 185         return res;
 186 }
 187
 188 static void __exit hsr_exit(void)
 189 {
 190         unregister_netdevice_notifier(&hsr_nb);
 191         hsr_netlink_exit();
 192 }
 193
 194 module_init(hsr_init);
 195 module_exit(hsr_exit);
 196 MODULE_LICENSE("GPL");