net/hsr: Better variable names and update of contact info.
authorArvid Brodin <arvid.brodin@alten.se>
Fri, 4 Jul 2014 21:34:38 +0000 (23:34 +0200)
committerDavid S. Miller <davem@davemloft.net>
Tue, 8 Jul 2014 18:35:30 +0000 (11:35 -0700)
Signed-off-by: Arvid Brodin <arvid.brodin@alten.se>
Signed-off-by: David S. Miller <davem@davemloft.net>
net/hsr/hsr_device.c
net/hsr/hsr_device.h
net/hsr/hsr_framereg.c
net/hsr/hsr_framereg.h
net/hsr/hsr_main.c
net/hsr/hsr_main.h
net/hsr/hsr_netlink.c
net/hsr/hsr_netlink.h

index e5302b7f7ca9f0f6f67954689572d6a5b09a3c74..4dc2a4207ee23be6a0f501765703dbf9fa2e25cf 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright 2011-2013 Autronica Fire and Security AS
+/* Copyright 2011-2014 Autronica Fire and Security AS
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -6,7 +6,7 @@
  * any later version.
  *
  * Author(s):
- *     2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *     2011-2014 Arvid Brodin, arvid.brodin@alten.se
  *
  * This file contains device methods for creating, using and destroying
  * virtual HSR devices.
@@ -71,49 +71,49 @@ void hsr_set_carrier(struct net_device *hsr_dev, struct net_device *slave1,
 
 void hsr_check_announce(struct net_device *hsr_dev, int old_operstate)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
 
-       hsr_priv = netdev_priv(hsr_dev);
+       hsr = netdev_priv(hsr_dev);
 
        if ((hsr_dev->operstate == IF_OPER_UP) && (old_operstate != IF_OPER_UP)) {
                /* Went up */
-               hsr_priv->announce_count = 0;
-               hsr_priv->announce_timer.expires = jiffies +
+               hsr->announce_count = 0;
+               hsr->announce_timer.expires = jiffies +
                                msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL);
-               add_timer(&hsr_priv->announce_timer);
+               add_timer(&hsr->announce_timer);
        }
 
        if ((hsr_dev->operstate != IF_OPER_UP) && (old_operstate == IF_OPER_UP))
                /* Went down */
-               del_timer(&hsr_priv->announce_timer);
+               del_timer(&hsr->announce_timer);
 }
 
 
-int hsr_get_max_mtu(struct hsr_priv *hsr_priv)
+int hsr_get_max_mtu(struct hsr_priv *hsr)
 {
        int mtu_max;
 
-       if (hsr_priv->slave[0] && hsr_priv->slave[1])
-               mtu_max = min(hsr_priv->slave[0]->mtu, hsr_priv->slave[1]->mtu);
-       else if (hsr_priv->slave[0])
-               mtu_max = hsr_priv->slave[0]->mtu;
-       else if (hsr_priv->slave[1])
-               mtu_max = hsr_priv->slave[1]->mtu;
+       if (hsr->slave[0] && hsr->slave[1])
+               mtu_max = min(hsr->slave[0]->mtu, hsr->slave[1]->mtu);
+       else if (hsr->slave[0])
+               mtu_max = hsr->slave[0]->mtu;
+       else if (hsr->slave[1])
+               mtu_max = hsr->slave[1]->mtu;
        else
-               mtu_max = HSR_TAGLEN;
+               mtu_max = HSR_HLEN;
 
-       return mtu_max - HSR_TAGLEN;
+       return mtu_max - HSR_HLEN;
 }
 
 static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
 
-       hsr_priv = netdev_priv(dev);
+       hsr = netdev_priv(dev);
 
-       if (new_mtu > hsr_get_max_mtu(hsr_priv)) {
-               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",
-                           HSR_TAGLEN);
+       if (new_mtu > hsr_get_max_mtu(hsr)) {
+               netdev_info(hsr->dev, "A HSR master's MTU cannot be greater than the smallest MTU of its slaves minus the HSR Tag length (%d octets).\n",
+                           HSR_HLEN);
                return -EINVAL;
        }
 
@@ -124,19 +124,19 @@ static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)
 
 static int hsr_dev_open(struct net_device *dev)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
        int i;
        char *slave_name;
 
-       hsr_priv = netdev_priv(dev);
+       hsr = netdev_priv(dev);
 
        for (i = 0; i < HSR_MAX_SLAVE; i++) {
-               if (hsr_priv->slave[i])
-                       slave_name = hsr_priv->slave[i]->name;
+               if (hsr->slave[i])
+                       slave_name = hsr->slave[i]->name;
                else
                        slave_name = "null";
 
-               if (!is_slave_up(hsr_priv->slave[i]))
+               if (!is_slave_up(hsr->slave[i]))
                        netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a working HSR network\n",
                                    'A' + i, slave_name);
        }
@@ -156,7 +156,7 @@ static int hsr_dev_close(struct net_device *dev)
 }
 
 
-static void hsr_fill_tag(struct hsr_ethhdr *hsr_ethhdr, struct hsr_priv *hsr_priv)
+static void hsr_fill_tag(struct hsr_ethhdr *hsr_ethhdr, struct hsr_priv *hsr)
 {
        unsigned long irqflags;
 
@@ -185,26 +185,26 @@ static void hsr_fill_tag(struct hsr_ethhdr *hsr_ethhdr, struct hsr_priv *hsr_pri
         */
        set_hsr_tag_LSDU_size(&hsr_ethhdr->hsr_tag, 0);
 
-       spin_lock_irqsave(&hsr_priv->seqnr_lock, irqflags);
-       hsr_ethhdr->hsr_tag.sequence_nr = htons(hsr_priv->sequence_nr);
-       hsr_priv->sequence_nr++;
-       spin_unlock_irqrestore(&hsr_priv->seqnr_lock, irqflags);
+       spin_lock_irqsave(&hsr->seqnr_lock, irqflags);
+       hsr_ethhdr->hsr_tag.sequence_nr = htons(hsr->sequence_nr);
+       hsr->sequence_nr++;
+       spin_unlock_irqrestore(&hsr->seqnr_lock, irqflags);
 
        hsr_ethhdr->hsr_tag.encap_proto = hsr_ethhdr->ethhdr.h_proto;
 
        hsr_ethhdr->ethhdr.h_proto = htons(ETH_P_PRP);
 }
 
-static int slave_xmit(struct sk_buff *skb, struct hsr_priv *hsr_priv,
+static int slave_xmit(struct sk_buff *skb, struct hsr_priv *hsr,
                      enum hsr_dev_idx dev_idx)
 {
        struct hsr_ethhdr *hsr_ethhdr;
 
        hsr_ethhdr = (struct hsr_ethhdr *) skb->data;
 
-       skb->dev = hsr_priv->slave[dev_idx];
+       skb->dev = hsr->slave[dev_idx];
 
-       hsr_addr_subst_dest(hsr_priv, &hsr_ethhdr->ethhdr, dev_idx);
+       hsr_addr_subst_dest(hsr, &hsr_ethhdr->ethhdr, dev_idx);
 
        /* Address substitution (IEC62439-3 pp 26, 50): replace mac
         * address of outgoing frame with that of the outgoing slave's.
@@ -217,36 +217,36 @@ static int slave_xmit(struct sk_buff *skb, struct hsr_priv *hsr_priv,
 
 static int hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
        struct hsr_ethhdr *hsr_ethhdr;
        struct sk_buff *skb2;
        int res1, res2;
 
-       hsr_priv = netdev_priv(dev);
+       hsr = netdev_priv(dev);
        hsr_ethhdr = (struct hsr_ethhdr *) skb->data;
 
        if ((skb->protocol != htons(ETH_P_PRP)) ||
            (hsr_ethhdr->ethhdr.h_proto != htons(ETH_P_PRP))) {
-               hsr_fill_tag(hsr_ethhdr, hsr_priv);
+               hsr_fill_tag(hsr_ethhdr, hsr);
                skb->protocol = htons(ETH_P_PRP);
        }
 
        skb2 = pskb_copy(skb, GFP_ATOMIC);
 
        res1 = NET_XMIT_DROP;
-       if (likely(hsr_priv->slave[HSR_DEV_SLAVE_A]))
-               res1 = slave_xmit(skb, hsr_priv, HSR_DEV_SLAVE_A);
+       if (likely(hsr->slave[HSR_DEV_SLAVE_A]))
+               res1 = slave_xmit(skb, hsr, HSR_DEV_SLAVE_A);
 
        res2 = NET_XMIT_DROP;
-       if (likely(skb2 && hsr_priv->slave[HSR_DEV_SLAVE_B]))
-               res2 = slave_xmit(skb2, hsr_priv, HSR_DEV_SLAVE_B);
+       if (likely(skb2 && hsr->slave[HSR_DEV_SLAVE_B]))
+               res2 = slave_xmit(skb2, hsr, HSR_DEV_SLAVE_B);
 
        if (likely(res1 == NET_XMIT_SUCCESS || res1 == NET_XMIT_CN ||
                   res2 == NET_XMIT_SUCCESS || res2 == NET_XMIT_CN)) {
-               hsr_priv->dev->stats.tx_packets++;
-               hsr_priv->dev->stats.tx_bytes += skb->len;
+               hsr->dev->stats.tx_packets++;
+               hsr->dev->stats.tx_bytes += skb->len;
        } else {
-               hsr_priv->dev->stats.tx_dropped++;
+               hsr->dev->stats.tx_dropped++;
        }
 
        return NETDEV_TX_OK;
@@ -262,21 +262,21 @@ static int hsr_header_create(struct sk_buff *skb, struct net_device *dev,
        /* Make room for the HSR tag now. We will fill it in later (in
         * hsr_dev_xmit)
         */
-       if (skb_headroom(skb) < HSR_TAGLEN + ETH_HLEN)
+       if (skb_headroom(skb) < HSR_HLEN + ETH_HLEN)
                return -ENOBUFS;
-       skb_push(skb, HSR_TAGLEN);
+       skb_push(skb, HSR_HLEN);
 
        /* To allow VLAN/HSR combos we should probably use
-        * res = dev_hard_header(skb, dev, type, daddr, saddr, len + HSR_TAGLEN);
+        * res = dev_hard_header(skb, dev, type, daddr, saddr, len + HSR_HLEN);
         * here instead. It would require other changes too, though - e.g.
         * separate headers for each slave etc...
         */
-       res = eth_header(skb, dev, type, daddr, saddr, len + HSR_TAGLEN);
+       res = eth_header(skb, dev, type, daddr, saddr, len + HSR_HLEN);
        if (res <= 0)
                return res;
        skb_reset_mac_header(skb);
 
-       return res + HSR_TAGLEN;
+       return res + HSR_HLEN;
 }
 
 
@@ -291,7 +291,7 @@ static const struct header_ops hsr_header_ops = {
  */
 static int hsr_pad(int size)
 {
-       const int min_size = ETH_ZLEN - HSR_TAGLEN - ETH_HLEN;
+       const int min_size = ETH_ZLEN - HSR_HLEN - ETH_HLEN;
 
        if (size >= min_size)
                return size;
@@ -300,7 +300,7 @@ static int hsr_pad(int size)
 
 static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
        struct sk_buff *skb;
        int hlen, tlen;
        struct hsr_sup_tag *hsr_stag;
@@ -315,7 +315,7 @@ static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
        if (skb == NULL)
                return;
 
-       hsr_priv = netdev_priv(hsr_dev);
+       hsr = netdev_priv(hsr_dev);
 
        skb_reserve(skb, hlen);
 
@@ -324,7 +324,7 @@ static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
        skb->priority = TC_PRIO_CONTROL;
 
        if (dev_hard_header(skb, skb->dev, ETH_P_PRP,
-                           hsr_priv->sup_multicast_addr,
+                           hsr->sup_multicast_addr,
                            skb->dev->dev_addr, skb->len) < 0)
                goto out;
 
@@ -334,10 +334,10 @@ static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
        set_hsr_stag_path(hsr_stag, 0xf);
        set_hsr_stag_HSR_Ver(hsr_stag, 0);
 
-       spin_lock_irqsave(&hsr_priv->seqnr_lock, irqflags);
-       hsr_stag->sequence_nr = htons(hsr_priv->sequence_nr);
-       hsr_priv->sequence_nr++;
-       spin_unlock_irqrestore(&hsr_priv->seqnr_lock, irqflags);
+       spin_lock_irqsave(&hsr->seqnr_lock, irqflags);
+       hsr_stag->sequence_nr = htons(hsr->sequence_nr);
+       hsr->sequence_nr++;
+       spin_unlock_irqrestore(&hsr->seqnr_lock, irqflags);
 
        hsr_stag->HSR_TLV_Type = type;
        hsr_stag->HSR_TLV_Length = 12;
@@ -360,48 +360,48 @@ out:
  */
 static void hsr_announce(unsigned long data)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
 
-       hsr_priv = (struct hsr_priv *) data;
+       hsr = (struct hsr_priv *) data;
 
-       if (hsr_priv->announce_count < 3) {
-               send_hsr_supervision_frame(hsr_priv->dev, HSR_TLV_ANNOUNCE);
-               hsr_priv->announce_count++;
+       if (hsr->announce_count < 3) {
+               send_hsr_supervision_frame(hsr->dev, HSR_TLV_ANNOUNCE);
+               hsr->announce_count++;
        } else {
-               send_hsr_supervision_frame(hsr_priv->dev, HSR_TLV_LIFE_CHECK);
+               send_hsr_supervision_frame(hsr->dev, HSR_TLV_LIFE_CHECK);
        }
 
-       if (hsr_priv->announce_count < 3)
-               hsr_priv->announce_timer.expires = jiffies +
+       if (hsr->announce_count < 3)
+               hsr->announce_timer.expires = jiffies +
                                msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL);
        else
-               hsr_priv->announce_timer.expires = jiffies +
+               hsr->announce_timer.expires = jiffies +
                                msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL);
 
-       if (is_admin_up(hsr_priv->dev))
-               add_timer(&hsr_priv->announce_timer);
+       if (is_admin_up(hsr->dev))
+               add_timer(&hsr->announce_timer);
 }
 
 
 static void restore_slaves(struct net_device *hsr_dev)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
        int i;
        int res;
 
-       hsr_priv = netdev_priv(hsr_dev);
+       hsr = netdev_priv(hsr_dev);
 
        rtnl_lock();
 
        /* Restore promiscuity */
        for (i = 0; i < HSR_MAX_SLAVE; i++) {
-               if (!hsr_priv->slave[i])
+               if (!hsr->slave[i])
                        continue;
-               res = dev_set_promiscuity(hsr_priv->slave[i], -1);
+               res = dev_set_promiscuity(hsr->slave[i], -1);
                if (res)
                        netdev_info(hsr_dev,
                                    "Cannot restore slave promiscuity (%s, %d)\n",
-                                   hsr_priv->slave[i]->name, res);
+                                   hsr->slave[i]->name, res);
        }
 
        rtnl_unlock();
@@ -409,10 +409,10 @@ static void restore_slaves(struct net_device *hsr_dev)
 
 static void reclaim_hsr_dev(struct rcu_head *rh)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
 
-       hsr_priv = container_of(rh, struct hsr_priv, rcu_head);
-       free_netdev(hsr_priv->dev);
+       hsr = container_of(rh, struct hsr_priv, rcu_head);
+       free_netdev(hsr->dev);
 }
 
 
@@ -421,14 +421,14 @@ static void reclaim_hsr_dev(struct rcu_head *rh)
  */
 static void hsr_dev_destroy(struct net_device *hsr_dev)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
 
-       hsr_priv = netdev_priv(hsr_dev);
+       hsr = netdev_priv(hsr_dev);
 
-       del_timer(&hsr_priv->announce_timer);
-       unregister_hsr_master(hsr_priv);    /* calls list_del_rcu on hsr_priv */
+       del_timer(&hsr->announce_timer);
+       unregister_hsr_master(hsr);    /* calls list_del_rcu on hsr */
        restore_slaves(hsr_dev);
-       call_rcu(&hsr_priv->rcu_head, reclaim_hsr_dev);   /* reclaim hsr_priv */
+       call_rcu(&hsr->rcu_head, reclaim_hsr_dev);   /* reclaim hsr */
 }
 
 static const struct net_device_ops hsr_device_ops = {
@@ -500,27 +500,27 @@ static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = {
 int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
                     unsigned char multicast_spec)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
        int i;
        int res;
 
-       hsr_priv = netdev_priv(hsr_dev);
-       hsr_priv->dev = hsr_dev;
-       INIT_LIST_HEAD(&hsr_priv->node_db);
-       INIT_LIST_HEAD(&hsr_priv->self_node_db);
+       hsr = netdev_priv(hsr_dev);
+       hsr->dev = hsr_dev;
+       INIT_LIST_HEAD(&hsr->node_db);
+       INIT_LIST_HEAD(&hsr->self_node_db);
        for (i = 0; i < HSR_MAX_SLAVE; i++)
-               hsr_priv->slave[i] = slave[i];
+               hsr->slave[i] = slave[i];
 
-       spin_lock_init(&hsr_priv->seqnr_lock);
+       spin_lock_init(&hsr->seqnr_lock);
        /* Overflow soon to find bugs easier: */
-       hsr_priv->sequence_nr = USHRT_MAX - 1024;
+       hsr->sequence_nr = USHRT_MAX - 1024;
 
-       init_timer(&hsr_priv->announce_timer);
-       hsr_priv->announce_timer.function = hsr_announce;
-       hsr_priv->announce_timer.data = (unsigned long) hsr_priv;
+       init_timer(&hsr->announce_timer);
+       hsr->announce_timer.function = hsr_announce;
+       hsr->announce_timer.data = (unsigned long) hsr;
 
-       ether_addr_copy(hsr_priv->sup_multicast_addr, def_multicast_addr);
-       hsr_priv->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec;
+       ether_addr_copy(hsr->sup_multicast_addr, def_multicast_addr);
+       hsr->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec;
 
 /* FIXME: should I modify the value of these?
  *
@@ -547,20 +547,20 @@ int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
        hsr_dev->features |= NETIF_F_VLAN_CHALLENGED;
 
        /* Set hsr_dev's MAC address to that of mac_slave1 */
-       ether_addr_copy(hsr_dev->dev_addr, hsr_priv->slave[0]->dev_addr);
+       ether_addr_copy(hsr_dev->dev_addr, hsr->slave[0]->dev_addr);
 
        /* Set required header length */
        for (i = 0; i < HSR_MAX_SLAVE; i++) {
-               if (slave[i]->hard_header_len + HSR_TAGLEN >
+               if (slave[i]->hard_header_len + HSR_HLEN >
                                                hsr_dev->hard_header_len)
                        hsr_dev->hard_header_len =
-                                       slave[i]->hard_header_len + HSR_TAGLEN;
+                                       slave[i]->hard_header_len + HSR_HLEN;
        }
 
        /* MTU */
        for (i = 0; i < HSR_MAX_SLAVE; i++)
-               if (slave[i]->mtu - HSR_TAGLEN < hsr_dev->mtu)
-                       hsr_dev->mtu = slave[i]->mtu - HSR_TAGLEN;
+               if (slave[i]->mtu - HSR_HLEN < hsr_dev->mtu)
+                       hsr_dev->mtu = slave[i]->mtu - HSR_HLEN;
 
        /* Make sure the 1st call to netif_carrier_on() gets through */
        netif_carrier_off(hsr_dev);
@@ -576,9 +576,8 @@ int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
        }
 
        /* Make sure we recognize frames from ourselves in hsr_rcv() */
-       res = hsr_create_self_node(&hsr_priv->self_node_db,
-                                       hsr_dev->dev_addr,
-                                       hsr_priv->slave[1]->dev_addr);
+       res = hsr_create_self_node(&hsr->self_node_db, hsr_dev->dev_addr,
+                                  hsr->slave[1]->dev_addr);
        if (res < 0)
                goto fail;
 
@@ -586,7 +585,7 @@ int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
        if (res)
                goto fail;
 
-       register_hsr_master(hsr_priv);
+       register_hsr_master(hsr);
 
        return 0;
 
index 2c7148e73914e9b6c5dd96a1ea488edd7402d451..feb744f90f3d6a8cb4e2bcd91d60c277369809eb 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright 2011-2013 Autronica Fire and Security AS
+/* Copyright 2011-2014 Autronica Fire and Security AS
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -6,7 +6,7 @@
  * any later version.
  *
  * Author(s):
- *     2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *     2011-2014 Arvid Brodin, arvid.brodin@alten.se
  */
 
 #ifndef __HSR_DEVICE_H
@@ -24,6 +24,6 @@ void hsr_set_carrier(struct net_device *hsr_dev, struct net_device *slave1,
                     struct net_device *slave2);
 void hsr_check_announce(struct net_device *hsr_dev, int old_operstate);
 bool is_hsr_master(struct net_device *dev);
-int hsr_get_max_mtu(struct hsr_priv *hsr_priv);
+int hsr_get_max_mtu(struct hsr_priv *hsr);
 
 #endif /* __HSR_DEVICE_H */
index 83e58449366a92bcc4e349241337914bca8dcd10..b419edbd70122c5715c29490c854903a8182b457 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright 2011-2013 Autronica Fire and Security AS
+/* Copyright 2011-2014 Autronica Fire and Security AS
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -6,7 +6,7 @@
  * any later version.
  *
  * Author(s):
- *     2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *     2011-2014 Arvid Brodin, arvid.brodin@alten.se
  *
  * The HSR spec says never to forward the same frame twice on the same
  * interface. A frame is identified by its source MAC address and its HSR
 #include "hsr_netlink.h"
 
 
-struct node_entry {
-       struct list_head mac_list;
-       unsigned char   MacAddressA[ETH_ALEN];
-       unsigned char   MacAddressB[ETH_ALEN];
-       enum hsr_dev_idx   AddrB_if;    /* The local slave through which AddrB
-                                        * frames are received from this node
-                                        */
-       unsigned long   time_in[HSR_MAX_SLAVE];
-       bool            time_in_stale[HSR_MAX_SLAVE];
-       u16             seq_out[HSR_MAX_DEV];
-       struct rcu_head rcu_head;
+struct hsr_node {
+       struct list_head        mac_list;
+       unsigned char           MacAddressA[ETH_ALEN];
+       unsigned char           MacAddressB[ETH_ALEN];
+       enum hsr_dev_idx        AddrB_if;/* The local slave through which AddrB
+                                         * frames are received from this node
+                                         */
+       unsigned long           time_in[HSR_MAX_SLAVE];
+       bool                    time_in_stale[HSR_MAX_SLAVE];
+       u16                     seq_out[HSR_MAX_DEV];
+       struct rcu_head         rcu_head;
 };
 
 /*     TODO: use hash lists for mac addresses (linux/jhash.h)?    */
@@ -42,10 +42,10 @@ struct node_entry {
 
 /* Search for mac entry. Caller must hold rcu read lock.
  */
-static struct node_entry *find_node_by_AddrA(struct list_head *node_db,
-                                            const unsigned char addr[ETH_ALEN])
+static struct hsr_node *find_node_by_AddrA(struct list_head *node_db,
+                                          const unsigned char addr[ETH_ALEN])
 {
-       struct node_entry *node;
+       struct hsr_node *node;
 
        list_for_each_entry_rcu(node, node_db, mac_list) {
                if (ether_addr_equal(node->MacAddressA, addr))
@@ -58,10 +58,10 @@ static struct node_entry *find_node_by_AddrA(struct list_head *node_db,
 
 /* Search for mac entry. Caller must hold rcu read lock.
  */
-static struct node_entry *find_node_by_AddrB(struct list_head *node_db,
-                                            const unsigned char addr[ETH_ALEN])
+static struct hsr_node *find_node_by_AddrB(struct list_head *node_db,
+                                          const unsigned char addr[ETH_ALEN])
 {
-       struct node_entry *node;
+       struct hsr_node *node;
 
        list_for_each_entry_rcu(node, node_db, mac_list) {
                if (ether_addr_equal(node->MacAddressB, addr))
@@ -74,9 +74,9 @@ static struct node_entry *find_node_by_AddrB(struct list_head *node_db,
 
 /* Search for mac entry. Caller must hold rcu read lock.
  */
-struct node_entry *hsr_find_node(struct list_head *node_db, struct sk_buff *skb)
+struct hsr_node *hsr_find_node(struct list_head *node_db, struct sk_buff *skb)
 {
-       struct node_entry *node;
+       struct hsr_node *node;
        struct ethhdr *ethhdr;
 
        if (!skb_mac_header_was_set(skb))
@@ -102,7 +102,7 @@ int hsr_create_self_node(struct list_head *self_node_db,
                         unsigned char addr_a[ETH_ALEN],
                         unsigned char addr_b[ETH_ALEN])
 {
-       struct node_entry *node, *oldnode;
+       struct hsr_node *node, *oldnode;
 
        node = kmalloc(sizeof(*node), GFP_KERNEL);
        if (!node)
@@ -113,7 +113,7 @@ int hsr_create_self_node(struct list_head *self_node_db,
 
        rcu_read_lock();
        oldnode = list_first_or_null_rcu(self_node_db,
-                                               struct node_entry, mac_list);
+                                               struct hsr_node, mac_list);
        if (oldnode) {
                list_replace_rcu(&oldnode->mac_list, &node->mac_list);
                rcu_read_unlock();
@@ -154,10 +154,10 @@ int hsr_create_self_node(struct list_head *self_node_db,
  * We also need to detect if the sender's SlaveA and SlaveB cables have been
  * swapped.
  */
-struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
-                                 struct node_entry *node,
-                                 struct sk_buff *skb,
-                                 enum hsr_dev_idx dev_idx)
+struct hsr_node *hsr_merge_node(struct hsr_priv *hsr,
+                               struct hsr_node *node,
+                               struct sk_buff *skb,
+                               enum hsr_dev_idx dev_idx)
 {
        struct hsr_sup_payload *hsr_sp;
        struct hsr_ethhdr_sp *hsr_ethsup;
@@ -194,7 +194,7 @@ struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
        if (node)
                return node;
 
-       node = find_node_by_AddrA(&hsr_priv->node_db, hsr_sp->MacAddressA);
+       node = find_node_by_AddrA(&hsr->node_db, hsr_sp->MacAddressA);
        if (node) {
                /* Node is known, but frame was received from an unknown
                 * address. Node is PICS_SUBS capable; merge its AddrB.
@@ -224,7 +224,7 @@ struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
        for (i = 0; i < HSR_MAX_DEV; i++)
                node->seq_out[i] = ntohs(hsr_ethsup->hsr_sup.sequence_nr) - 1;
 
-       list_add_tail_rcu(&node->mac_list, &hsr_priv->node_db);
+       list_add_tail_rcu(&node->mac_list, &hsr->node_db);
 
        return node;
 }
@@ -236,10 +236,10 @@ struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
  * address with that node's "official" address (MacAddressA) so that upper
  * layers recognize where it came from.
  */
-void hsr_addr_subst_source(struct hsr_priv *hsr_priv, struct sk_buff *skb)
+void hsr_addr_subst_source(struct hsr_priv *hsr, struct sk_buff *skb)
 {
        struct ethhdr *ethhdr;
-       struct node_entry *node;
+       struct hsr_node *node;
 
        if (!skb_mac_header_was_set(skb)) {
                WARN_ONCE(1, "%s: Mac header not set\n", __func__);
@@ -248,7 +248,7 @@ void hsr_addr_subst_source(struct hsr_priv *hsr_priv, struct sk_buff *skb)
        ethhdr = (struct ethhdr *) skb_mac_header(skb);
 
        rcu_read_lock();
-       node = find_node_by_AddrB(&hsr_priv->node_db, ethhdr->h_source);
+       node = find_node_by_AddrB(&hsr->node_db, ethhdr->h_source);
        if (node)
                ether_addr_copy(ethhdr->h_source, node->MacAddressA);
        rcu_read_unlock();
@@ -264,13 +264,13 @@ void hsr_addr_subst_source(struct hsr_priv *hsr_priv, struct sk_buff *skb)
  * This is needed to keep the packets flowing through switches that learn on
  * which "side" the different interfaces are.
  */
-void hsr_addr_subst_dest(struct hsr_priv *hsr_priv, struct ethhdr *ethhdr,
+void hsr_addr_subst_dest(struct hsr_priv *hsr, struct ethhdr *ethhdr,
                         enum hsr_dev_idx dev_idx)
 {
-       struct node_entry *node;
+       struct hsr_node *node;
 
        rcu_read_lock();
-       node = find_node_by_AddrA(&hsr_priv->node_db, ethhdr->h_dest);
+       node = find_node_by_AddrA(&hsr->node_db, ethhdr->h_dest);
        if (node && (node->AddrB_if == dev_idx))
                ether_addr_copy(ethhdr->h_dest, node->MacAddressB);
        rcu_read_unlock();
@@ -295,7 +295,7 @@ static bool seq_nr_after(u16 a, u16 b)
 #define seq_nr_before_or_eq(a, b)      (!seq_nr_after((a), (b)))
 
 
-void hsr_register_frame_in(struct node_entry *node, enum hsr_dev_idx dev_idx)
+void hsr_register_frame_in(struct hsr_node *node, enum hsr_dev_idx dev_idx)
 {
        if ((dev_idx < 0) || (dev_idx >= HSR_MAX_SLAVE)) {
                WARN_ONCE(1, "%s: Invalid dev_idx (%d)\n", __func__, dev_idx);
@@ -314,7 +314,7 @@ void hsr_register_frame_in(struct node_entry *node, enum hsr_dev_idx dev_idx)
  *      0 otherwise, or
  *      negative error code on error
  */
-int hsr_register_frame_out(struct node_entry *node, enum hsr_dev_idx dev_idx,
+int hsr_register_frame_out(struct hsr_node *node, enum hsr_dev_idx dev_idx,
                           struct sk_buff *skb)
 {
        struct hsr_ethhdr *hsr_ethhdr;
@@ -340,7 +340,7 @@ int hsr_register_frame_out(struct node_entry *node, enum hsr_dev_idx dev_idx,
 
 
 
-static bool is_late(struct node_entry *node, enum hsr_dev_idx dev_idx)
+static bool is_late(struct hsr_node *node, enum hsr_dev_idx dev_idx)
 {
        enum hsr_dev_idx other;
 
@@ -366,14 +366,14 @@ static bool is_late(struct node_entry *node, enum hsr_dev_idx dev_idx)
 /* Remove stale sequence_nr records. Called by timer every
  * HSR_LIFE_CHECK_INTERVAL (two seconds or so).
  */
-void hsr_prune_nodes(struct hsr_priv *hsr_priv)
+void hsr_prune_nodes(struct hsr_priv *hsr)
 {
-       struct node_entry *node;
+       struct hsr_node *node;
        unsigned long timestamp;
        unsigned long time_a, time_b;
 
        rcu_read_lock();
-       list_for_each_entry_rcu(node, &hsr_priv->node_db, mac_list) {
+       list_for_each_entry_rcu(node, &hsr->node_db, mac_list) {
                /* Shorthand */
                time_a = node->time_in[HSR_DEV_SLAVE_A];
                time_b = node->time_in[HSR_DEV_SLAVE_B];
@@ -399,17 +399,17 @@ void hsr_prune_nodes(struct hsr_priv *hsr_priv)
                                        msecs_to_jiffies(1.5*MAX_SLAVE_DIFF))) {
 
                        if (is_late(node, HSR_DEV_SLAVE_A))
-                               hsr_nl_ringerror(hsr_priv, node->MacAddressA,
+                               hsr_nl_ringerror(hsr, node->MacAddressA,
                                                 HSR_DEV_SLAVE_A);
                        else if (is_late(node, HSR_DEV_SLAVE_B))
-                               hsr_nl_ringerror(hsr_priv, node->MacAddressA,
+                               hsr_nl_ringerror(hsr, node->MacAddressA,
                                                 HSR_DEV_SLAVE_B);
                }
 
                /* Prune old entries */
                if (time_is_before_jiffies(timestamp +
                                        msecs_to_jiffies(HSR_NODE_FORGET_TIME))) {
-                       hsr_nl_nodedown(hsr_priv, node->MacAddressA);
+                       hsr_nl_nodedown(hsr, node->MacAddressA);
                        list_del_rcu(&node->mac_list);
                        /* Note that we need to free this entry later: */
                        kfree_rcu(node, rcu_head);
@@ -419,21 +419,21 @@ void hsr_prune_nodes(struct hsr_priv *hsr_priv)
 }
 
 
-void *hsr_get_next_node(struct hsr_priv *hsr_priv, void *_pos,
+void *hsr_get_next_node(struct hsr_priv *hsr, void *_pos,
                        unsigned char addr[ETH_ALEN])
 {
-       struct node_entry *node;
+       struct hsr_node *node;
 
        if (!_pos) {
-               node = list_first_or_null_rcu(&hsr_priv->node_db,
-                                               struct node_entry, mac_list);
+               node = list_first_or_null_rcu(&hsr->node_db,
+                                             struct hsr_node, mac_list);
                if (node)
                        ether_addr_copy(addr, node->MacAddressA);
                return node;
        }
 
        node = _pos;
-       list_for_each_entry_continue_rcu(node, &hsr_priv->node_db, mac_list) {
+       list_for_each_entry_continue_rcu(node, &hsr->node_db, mac_list) {
                ether_addr_copy(addr, node->MacAddressA);
                return node;
        }
@@ -442,7 +442,7 @@ void *hsr_get_next_node(struct hsr_priv *hsr_priv, void *_pos,
 }
 
 
-int hsr_get_node_data(struct hsr_priv *hsr_priv,
+int hsr_get_node_data(struct hsr_priv *hsr,
                      const unsigned char *addr,
                      unsigned char addr_b[ETH_ALEN],
                      unsigned int *addr_b_ifindex,
@@ -451,12 +451,12 @@ int hsr_get_node_data(struct hsr_priv *hsr_priv,
                      int *if2_age,
                      u16 *if2_seq)
 {
-       struct node_entry *node;
+       struct hsr_node *node;
        unsigned long tdiff;
 
 
        rcu_read_lock();
-       node = find_node_by_AddrA(&hsr_priv->node_db, addr);
+       node = find_node_by_AddrA(&hsr->node_db, addr);
        if (!node) {
                rcu_read_unlock();
                return -ENOENT; /* No such entry */
@@ -488,8 +488,8 @@ int hsr_get_node_data(struct hsr_priv *hsr_priv,
        *if1_seq = node->seq_out[HSR_DEV_SLAVE_B];
        *if2_seq = node->seq_out[HSR_DEV_SLAVE_A];
 
-       if ((node->AddrB_if != HSR_DEV_NONE) && hsr_priv->slave[node->AddrB_if])
-               *addr_b_ifindex = hsr_priv->slave[node->AddrB_if]->ifindex;
+       if ((node->AddrB_if != HSR_DEV_NONE) && hsr->slave[node->AddrB_if])
+               *addr_b_ifindex = hsr->slave[node->AddrB_if]->ifindex;
        else
                *addr_b_ifindex = -1;
 
index e6c4022030ad17f74d6007d44d9fc9231ea01fac..3675139df379b61becf41d713586af94f8076936 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright 2011-2013 Autronica Fire and Security AS
+/* Copyright 2011-2014 Autronica Fire and Security AS
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -6,42 +6,42 @@
  * any later version.
  *
  * Author(s):
- *     2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *     2011-2014 Arvid Brodin, arvid.brodin@alten.se
  */
 
-#ifndef _HSR_FRAMEREG_H
-#define _HSR_FRAMEREG_H
+#ifndef __HSR_FRAMEREG_H
+#define __HSR_FRAMEREG_H
 
 #include "hsr_main.h"
 
-struct node_entry;
+struct hsr_node;
 
-struct node_entry *hsr_find_node(struct list_head *node_db, struct sk_buff *skb);
+struct hsr_node *hsr_find_node(struct list_head *node_db, struct sk_buff *skb);
 
-struct node_entry *hsr_merge_node(struct hsr_priv *hsr_priv,
-                                 struct node_entry *node,
-                                 struct sk_buff *skb,
-                                 enum hsr_dev_idx dev_idx);
+struct hsr_node *hsr_merge_node(struct hsr_priv *hsr,
+                               struct hsr_node *node,
+                               struct sk_buff *skb,
+                               enum hsr_dev_idx dev_idx);
 
-void hsr_addr_subst_source(struct hsr_priv *hsr_priv, struct sk_buff *skb);
-void hsr_addr_subst_dest(struct hsr_priv *hsr_priv, struct ethhdr *ethhdr,
+void hsr_addr_subst_source(struct hsr_priv *hsr, struct sk_buff *skb);
+void hsr_addr_subst_dest(struct hsr_priv *hsr, struct ethhdr *ethhdr,
                         enum hsr_dev_idx dev_idx);
 
-void hsr_register_frame_in(struct node_entry *node, enum hsr_dev_idx dev_idx);
+void hsr_register_frame_in(struct hsr_node *node, enum hsr_dev_idx dev_idx);
 
-int hsr_register_frame_out(struct node_entry *node, enum hsr_dev_idx dev_idx,
+int hsr_register_frame_out(struct hsr_node *node, enum hsr_dev_idx dev_idx,
                           struct sk_buff *skb);
 
-void hsr_prune_nodes(struct hsr_priv *hsr_priv);
+void hsr_prune_nodes(struct hsr_priv *hsr);
 
 int hsr_create_self_node(struct list_head *self_node_db,
                         unsigned char addr_a[ETH_ALEN],
                         unsigned char addr_b[ETH_ALEN]);
 
-void *hsr_get_next_node(struct hsr_priv *hsr_priv, void *_pos,
+void *hsr_get_next_node(struct hsr_priv *hsr, void *_pos,
                        unsigned char addr[ETH_ALEN]);
 
-int hsr_get_node_data(struct hsr_priv *hsr_priv,
+int hsr_get_node_data(struct hsr_priv *hsr,
                      const unsigned char *addr,
                      unsigned char addr_b[ETH_ALEN],
                      unsigned int *addr_b_ifindex,
@@ -50,4 +50,4 @@ int hsr_get_node_data(struct hsr_priv *hsr_priv,
                      int *if2_age,
                      u16 *if2_seq);
 
-#endif /* _HSR_FRAMEREG_H */
+#endif /* __HSR_FRAMEREG_H */
index 3fee5218a691f20c8b028e7ed2738febc7dfd0b7..99b8fc4eca6c126809ee1fda49900177f6d8917b 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright 2011-2013 Autronica Fire and Security AS
+/* Copyright 2011-2014 Autronica Fire and Security AS
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -6,7 +6,7 @@
  * any later version.
  *
  * Author(s):
- *     2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *     2011-2014 Arvid Brodin, arvid.brodin@alten.se
  *
  * In addition to routines for registering and unregistering HSR support, this
  * file also contains the receive routine that handles all incoming frames with
 /* List of all registered virtual HSR devices */
 static LIST_HEAD(hsr_list);
 
-void register_hsr_master(struct hsr_priv *hsr_priv)
+void register_hsr_master(struct hsr_priv *hsr)
 {
-       list_add_tail_rcu(&hsr_priv->hsr_list, &hsr_list);
+       list_add_tail_rcu(&hsr->hsr_list, &hsr_list);
 }
 
-void unregister_hsr_master(struct hsr_priv *hsr_priv)
+void unregister_hsr_master(struct hsr_priv *hsr)
 {
-       struct hsr_priv *hsr_priv_it;
+       struct hsr_priv *hsr_it;
 
-       list_for_each_entry(hsr_priv_it, &hsr_list, hsr_list)
-               if (hsr_priv_it == hsr_priv) {
-                       list_del_rcu(&hsr_priv_it->hsr_list);
+       list_for_each_entry(hsr_it, &hsr_list, hsr_list)
+               if (hsr_it == hsr) {
+                       list_del_rcu(&hsr_it->hsr_list);
                        return;
                }
 }
 
 bool is_hsr_slave(struct net_device *dev)
 {
-       struct hsr_priv *hsr_priv_it;
+       struct hsr_priv *hsr_it;
 
-       list_for_each_entry_rcu(hsr_priv_it, &hsr_list, hsr_list) {
-               if (dev == hsr_priv_it->slave[0])
+       list_for_each_entry_rcu(hsr_it, &hsr_list, hsr_list) {
+               if (dev == hsr_it->slave[0])
                        return true;
-               if (dev == hsr_priv_it->slave[1])
+               if (dev == hsr_it->slave[1])
                        return true;
        }
 
@@ -62,14 +62,14 @@ bool is_hsr_slave(struct net_device *dev)
  */
 static struct hsr_priv *get_hsr_master(struct net_device *dev)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
 
        rcu_read_lock();
-       list_for_each_entry_rcu(hsr_priv, &hsr_list, hsr_list)
-               if ((dev == hsr_priv->slave[0]) ||
-                   (dev == hsr_priv->slave[1])) {
+       list_for_each_entry_rcu(hsr, &hsr_list, hsr_list)
+               if ((dev == hsr->slave[0]) ||
+                   (dev == hsr->slave[1])) {
                        rcu_read_unlock();
-                       return hsr_priv;
+                       return hsr;
                }
 
        rcu_read_unlock();
@@ -80,13 +80,13 @@ static struct hsr_priv *get_hsr_master(struct net_device *dev)
 /* If dev is a HSR slave device, return the other slave device. Return NULL
  * otherwise.
  */
-static struct net_device *get_other_slave(struct hsr_priv *hsr_priv,
+static struct net_device *get_other_slave(struct hsr_priv *hsr,
                                          struct net_device *dev)
 {
-       if (dev == hsr_priv->slave[0])
-               return hsr_priv->slave[1];
-       if (dev == hsr_priv->slave[1])
-               return hsr_priv->slave[0];
+       if (dev == hsr->slave[0])
+               return hsr->slave[1];
+       if (dev == hsr->slave[1])
+               return hsr->slave[0];
 
        return NULL;
 }
@@ -96,7 +96,7 @@ static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
                             void *ptr)
 {
        struct net_device *slave, *other_slave;
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
        int old_operstate;
        int mtu_max;
        int res;
@@ -104,68 +104,68 @@ static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
 
        dev = netdev_notifier_info_to_dev(ptr);
 
-       hsr_priv = get_hsr_master(dev);
-       if (hsr_priv) {
+       hsr = get_hsr_master(dev);
+       if (hsr) {
                /* dev is a slave device */
                slave = dev;
-               other_slave = get_other_slave(hsr_priv, slave);
+               other_slave = get_other_slave(hsr, slave);
        } else {
                if (!is_hsr_master(dev))
                        return NOTIFY_DONE;
-               hsr_priv = netdev_priv(dev);
-               slave = hsr_priv->slave[0];
-               other_slave = hsr_priv->slave[1];
+               hsr = netdev_priv(dev);
+               slave = hsr->slave[0];
+               other_slave = hsr->slave[1];
        }
 
        switch (event) {
        case NETDEV_UP:         /* Administrative state DOWN */
        case NETDEV_DOWN:       /* Administrative state UP */
        case NETDEV_CHANGE:     /* Link (carrier) state changes */
-               old_operstate = hsr_priv->dev->operstate;
-               hsr_set_carrier(hsr_priv->dev, slave, other_slave);
+               old_operstate = hsr->dev->operstate;
+               hsr_set_carrier(hsr->dev, slave, other_slave);
                /* netif_stacked_transfer_operstate() cannot be used here since
                 * it doesn't set IF_OPER_LOWERLAYERDOWN (?)
                 */
-               hsr_set_operstate(hsr_priv->dev, slave, other_slave);
-               hsr_check_announce(hsr_priv->dev, old_operstate);
+               hsr_set_operstate(hsr->dev, slave, other_slave);
+               hsr_check_announce(hsr->dev, old_operstate);
                break;
        case NETDEV_CHANGEADDR:
 
                /* This should not happen since there's no ndo_set_mac_address()
                 * for HSR devices - i.e. not supported.
                 */
-               if (dev == hsr_priv->dev)
+               if (dev == hsr->dev)
                        break;
 
-               if (dev == hsr_priv->slave[0])
-                       ether_addr_copy(hsr_priv->dev->dev_addr,
-                                       hsr_priv->slave[0]->dev_addr);
+               if (dev == hsr->slave[0])
+                       ether_addr_copy(hsr->dev->dev_addr,
+                                       hsr->slave[0]->dev_addr);
 
                /* Make sure we recognize frames from ourselves in hsr_rcv() */
-               res = hsr_create_self_node(&hsr_priv->self_node_db,
-                                          hsr_priv->dev->dev_addr,
-                                          hsr_priv->slave[1] ?
-                                               hsr_priv->slave[1]->dev_addr :
-                                               hsr_priv->dev->dev_addr);
+               res = hsr_create_self_node(&hsr->self_node_db,
+                                          hsr->dev->dev_addr,
+                                          hsr->slave[1] ?
+                                               hsr->slave[1]->dev_addr :
+                                               hsr->dev->dev_addr);
                if (res)
-                       netdev_warn(hsr_priv->dev,
+                       netdev_warn(hsr->dev,
                                    "Could not update HSR node address.\n");
 
-               if (dev == hsr_priv->slave[0])
-                       call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr_priv->dev);
+               if (dev == hsr->slave[0])
+                       call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr->dev);
                break;
        case NETDEV_CHANGEMTU:
-               if (dev == hsr_priv->dev)
+               if (dev == hsr->dev)
                        break; /* Handled in ndo_change_mtu() */
-               mtu_max = hsr_get_max_mtu(hsr_priv);
-               if (hsr_priv->dev->mtu > mtu_max)
-                       dev_set_mtu(hsr_priv->dev, mtu_max);
+               mtu_max = hsr_get_max_mtu(hsr);
+               if (hsr->dev->mtu > mtu_max)
+                       dev_set_mtu(hsr->dev, mtu_max);
                break;
        case NETDEV_UNREGISTER:
-               if (dev == hsr_priv->slave[0])
-                       hsr_priv->slave[0] = NULL;
-               if (dev == hsr_priv->slave[1])
-                       hsr_priv->slave[1] = NULL;
+               if (dev == hsr->slave[0])
+                       hsr->slave[0] = NULL;
+               if (dev == hsr->slave[1])
+                       hsr->slave[1] = NULL;
 
                /* There should really be a way to set a new slave device... */
 
@@ -185,11 +185,11 @@ static struct timer_list prune_timer;
 
 static void prune_nodes_all(unsigned long data)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
 
        rcu_read_lock();
-       list_for_each_entry_rcu(hsr_priv, &hsr_list, hsr_list)
-               hsr_prune_nodes(hsr_priv);
+       list_for_each_entry_rcu(hsr, &hsr_list, hsr_list)
+               hsr_prune_nodes(hsr);
        rcu_read_unlock();
 
        prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD);
@@ -207,12 +207,12 @@ static struct sk_buff *hsr_pull_tag(struct sk_buff *skb)
                goto err_free;
        skb = skb2;
 
-       if (unlikely(!pskb_may_pull(skb, HSR_TAGLEN)))
+       if (unlikely(!pskb_may_pull(skb, HSR_HLEN)))
                goto err_free;
 
        hsr_tag = (struct hsr_tag *) skb->data;
        skb->protocol = hsr_tag->encap_proto;
-       skb_pull(skb, HSR_TAGLEN);
+       skb_pull(skb, HSR_HLEN);
 
        return skb;
 
@@ -237,12 +237,12 @@ err_free:
  * 3) Allow different MAC addresses for the two slave interfaces, using the
  *    MacAddressA field.
  */
-static bool is_supervision_frame(struct hsr_priv *hsr_priv, struct sk_buff *skb)
+static bool is_supervision_frame(struct hsr_priv *hsr, struct sk_buff *skb)
 {
        struct hsr_sup_tag *hsr_stag;
 
        if (!ether_addr_equal(eth_hdr(skb)->h_dest,
-                             hsr_priv->sup_multicast_addr))
+                             hsr->sup_multicast_addr))
                return false;
 
        hsr_stag = (struct hsr_sup_tag *) skb->data;
@@ -263,25 +263,25 @@ static bool is_supervision_frame(struct hsr_priv *hsr_priv, struct sk_buff *skb)
 static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                   struct packet_type *pt, struct net_device *orig_dev)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
        struct net_device *other_slave;
-       struct node_entry *node;
+       struct hsr_node *node;
        bool deliver_to_self;
        struct sk_buff *skb_deliver;
        enum hsr_dev_idx dev_in_idx, dev_other_idx;
        bool dup_out;
        int ret;
 
-       hsr_priv = get_hsr_master(dev);
+       hsr = get_hsr_master(dev);
 
-       if (!hsr_priv) {
+       if (!hsr) {
                /* Non-HSR-slave device 'dev' is connected to a HSR network */
                kfree_skb(skb);
                dev->stats.rx_errors++;
                return NET_RX_SUCCESS;
        }
 
-       if (dev == hsr_priv->slave[0]) {
+       if (dev == hsr->slave[0]) {
                dev_in_idx = HSR_DEV_SLAVE_A;
                dev_other_idx = HSR_DEV_SLAVE_B;
        } else {
@@ -289,7 +289,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                dev_other_idx = HSR_DEV_SLAVE_A;
        }
 
-       node = hsr_find_node(&hsr_priv->self_node_db, skb);
+       node = hsr_find_node(&hsr->self_node_db, skb);
        if (node) {
                /* Always kill frames sent by ourselves */
                kfree_skb(skb);
@@ -303,22 +303,22 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
            (skb->pkt_type == PACKET_BROADCAST))
                deliver_to_self = true;
        else if (ether_addr_equal(eth_hdr(skb)->h_dest,
-                                    hsr_priv->dev->dev_addr)) {
+                                    hsr->dev->dev_addr)) {
                skb->pkt_type = PACKET_HOST;
                deliver_to_self = true;
        }
 
 
        rcu_read_lock(); /* node_db */
-       node = hsr_find_node(&hsr_priv->node_db, skb);
+       node = hsr_find_node(&hsr->node_db, skb);
 
-       if (is_supervision_frame(hsr_priv, skb)) {
+       if (is_supervision_frame(hsr, skb)) {
                skb_pull(skb, sizeof(struct hsr_sup_tag));
-               node = hsr_merge_node(hsr_priv, node, skb, dev_in_idx);
+               node = hsr_merge_node(hsr, node, skb, dev_in_idx);
                if (!node) {
                        rcu_read_unlock(); /* node_db */
                        kfree_skb(skb);
-                       hsr_priv->dev->stats.rx_dropped++;
+                       hsr->dev->stats.rx_dropped++;
                        return NET_RX_DROP;
                }
                skb_push(skb, sizeof(struct hsr_sup_tag));
@@ -345,7 +345,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
 
        /* Forward this frame? */
        if (!dup_out && (skb->pkt_type != PACKET_HOST))
-               other_slave = get_other_slave(hsr_priv, dev);
+               other_slave = get_other_slave(hsr, dev);
        else
                other_slave = NULL;
 
@@ -368,7 +368,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                skb_deliver = pskb_copy(skb, GFP_ATOMIC);
                if (!skb_deliver) {
                        deliver_to_self = false;
-                       hsr_priv->dev->stats.rx_dropped++;
+                       hsr->dev->stats.rx_dropped++;
                }
        }
 
@@ -377,7 +377,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
 
                skb_deliver = hsr_pull_tag(skb_deliver);
                if (!skb_deliver) {
-                       hsr_priv->dev->stats.rx_dropped++;
+                       hsr->dev->stats.rx_dropped++;
                        goto forward;
                }
 #if !defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
@@ -386,7 +386,7 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                 * tag. In practice, this removes/overwrites the HSR tag in
                 * the header and restores a "standard" packet.
                 */
-               memmove(skb_deliver->data - HSR_TAGLEN, skb_deliver->data,
+               memmove(skb_deliver->data - HSR_HLEN, skb_deliver->data,
                        skb_headlen(skb_deliver));
 
                /* Adjust skb members so they correspond with the move above.
@@ -397,20 +397,20 @@ static int hsr_rcv(struct sk_buff *skb, struct net_device *dev,
                 * the mac header nor the head. So we only need to adjust data
                 * and tail:
                 */
-               skb_deliver->data -= HSR_TAGLEN;
-               skb_deliver->tail -= HSR_TAGLEN;
+               skb_deliver->data -= HSR_HLEN;
+               skb_deliver->tail -= HSR_HLEN;
 #endif
-               skb_deliver->dev = hsr_priv->dev;
-               hsr_addr_subst_source(hsr_priv, skb_deliver);
+               skb_deliver->dev = hsr->dev;
+               hsr_addr_subst_source(hsr, skb_deliver);
                multicast_frame = (skb_deliver->pkt_type == PACKET_MULTICAST);
                ret = netif_rx(skb_deliver);
                if (ret == NET_RX_DROP) {
-                       hsr_priv->dev->stats.rx_dropped++;
+                       hsr->dev->stats.rx_dropped++;
                } else {
-                       hsr_priv->dev->stats.rx_packets++;
-                       hsr_priv->dev->stats.rx_bytes += skb->len;
+                       hsr->dev->stats.rx_packets++;
+                       hsr->dev->stats.rx_bytes += skb->len;
                        if (multicast_frame)
-                               hsr_priv->dev->stats.multicast++;
+                               hsr->dev->stats.multicast++;
                }
        }
 
@@ -439,7 +439,7 @@ static int __init hsr_init(void)
 {
        int res;
 
-       BUILD_BUG_ON(sizeof(struct hsr_tag) != HSR_TAGLEN);
+       BUILD_BUG_ON(sizeof(struct hsr_tag) != HSR_HLEN);
 
        dev_add_pack(&hsr_pt);
 
index 56fe060c0ab1872330adda30daace83c429313ff..360a49af0c1b2621821e81d872caf97fdca130ff 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright 2011-2013 Autronica Fire and Security AS
+/* Copyright 2011-2014 Autronica Fire and Security AS
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -6,11 +6,11 @@
  * any later version.
  *
  * Author(s):
- *     2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *     2011-2014 Arvid Brodin, arvid.brodin@alten.se
  */
 
-#ifndef _HSR_PRIVATE_H
-#define _HSR_PRIVATE_H
+#ifndef __HSR_PRIVATE_H
+#define __HSR_PRIVATE_H
 
 #include <linux/netdevice.h>
 #include <linux/list.h>
  * path, LSDU_size, sequence Nr }. But we let eth_header() create { h_dest,
  * h_source, h_proto = 0x88FB }, and add { path, LSDU_size, sequence Nr,
  * encapsulated protocol } instead.
+ *
+ * Field names as defined in the IEC:2010 standard for HSR.
  */
-#define HSR_TAGLEN     6
-
-/* Field names below as defined in the IEC:2010 standard for HSR. */
 struct hsr_tag {
        __be16          path_and_LSDU_size;
        __be16          sequence_nr;
        __be16          encap_proto;
 } __packed;
 
+#define HSR_HLEN       6
 
 /* The helper functions below assumes that 'path' occupies the 4 most
  * significant bits of the 16-bit field shared by 'path' and 'LSDU_size' (or
@@ -159,8 +159,8 @@ struct hsr_priv {
        unsigned char           sup_multicast_addr[ETH_ALEN];
 };
 
-void register_hsr_master(struct hsr_priv *hsr_priv);
-void unregister_hsr_master(struct hsr_priv *hsr_priv);
+void register_hsr_master(struct hsr_priv *hsr);
+void unregister_hsr_master(struct hsr_priv *hsr);
 bool is_hsr_slave(struct net_device *dev);
 
-#endif /*  _HSR_PRIVATE_H */
+#endif /*  __HSR_PRIVATE_H */
index 01a5261ac7a5520230fb0d2e147ffd3cf0a930ec..bea250ec3586f1590b8a71f2614d9ff8cee374bf 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright 2011-2013 Autronica Fire and Security AS
+/* Copyright 2011-2014 Autronica Fire and Security AS
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -6,7 +6,7 @@
  * any later version.
  *
  * Author(s):
- *     2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *     2011-2014 Arvid Brodin, arvid.brodin@alten.se
  *
  * Routines for handling Netlink messages for HSR.
  */
@@ -63,21 +63,21 @@ static int hsr_newlink(struct net *src_net, struct net_device *dev,
 
 static int hsr_fill_info(struct sk_buff *skb, const struct net_device *dev)
 {
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
 
-       hsr_priv = netdev_priv(dev);
+       hsr = netdev_priv(dev);
 
-       if (hsr_priv->slave[0])
-               if (nla_put_u32(skb, IFLA_HSR_SLAVE1, hsr_priv->slave[0]->ifindex))
+       if (hsr->slave[0])
+               if (nla_put_u32(skb, IFLA_HSR_SLAVE1, hsr->slave[0]->ifindex))
                        goto nla_put_failure;
 
-       if (hsr_priv->slave[1])
-               if (nla_put_u32(skb, IFLA_HSR_SLAVE2, hsr_priv->slave[1]->ifindex))
+       if (hsr->slave[1])
+               if (nla_put_u32(skb, IFLA_HSR_SLAVE2, hsr->slave[1]->ifindex))
                        goto nla_put_failure;
 
        if (nla_put(skb, IFLA_HSR_SUPERVISION_ADDR, ETH_ALEN,
-                   hsr_priv->sup_multicast_addr) ||
-           nla_put_u16(skb, IFLA_HSR_SEQ_NR, hsr_priv->sequence_nr))
+                   hsr->sup_multicast_addr) ||
+           nla_put_u16(skb, IFLA_HSR_SEQ_NR, hsr->sequence_nr))
                goto nla_put_failure;
 
        return 0;
@@ -128,7 +128,7 @@ static const struct genl_multicast_group hsr_mcgrps[] = {
  * over one of the slave interfaces. This would indicate an open network ring
  * (i.e. a link has failed somewhere).
  */
-void hsr_nl_ringerror(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN],
+void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
                      enum hsr_dev_idx dev_idx)
 {
        struct sk_buff *skb;
@@ -148,8 +148,8 @@ void hsr_nl_ringerror(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN],
        if (res < 0)
                goto nla_put_failure;
 
-       if (hsr_priv->slave[dev_idx])
-               ifindex = hsr_priv->slave[dev_idx]->ifindex;
+       if (hsr->slave[dev_idx])
+               ifindex = hsr->slave[dev_idx]->ifindex;
        else
                ifindex = -1;
        res = nla_put_u32(skb, HSR_A_IFINDEX, ifindex);
@@ -165,13 +165,13 @@ nla_put_failure:
        kfree_skb(skb);
 
 fail:
-       netdev_warn(hsr_priv->dev, "Could not send HSR ring error message\n");
+       netdev_warn(hsr->dev, "Could not send HSR ring error message\n");
 }
 
 /* This is called when we haven't heard from the node with MAC address addr for
  * some time (just before the node is removed from the node table/list).
  */
-void hsr_nl_nodedown(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN])
+void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN])
 {
        struct sk_buff *skb;
        void *msg_head;
@@ -199,7 +199,7 @@ nla_put_failure:
        kfree_skb(skb);
 
 fail:
-       netdev_warn(hsr_priv->dev, "Could not send HSR node down\n");
+       netdev_warn(hsr->dev, "Could not send HSR node down\n");
 }
 
 
@@ -220,7 +220,7 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
        /* For sending */
        struct sk_buff *skb_out;
        void *msg_head;
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
        unsigned char hsr_node_addr_b[ETH_ALEN];
        int hsr_node_if1_age;
        u16 hsr_node_if1_seq;
@@ -267,8 +267,8 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
        if (res < 0)
                goto nla_put_failure;
 
-       hsr_priv = netdev_priv(hsr_dev);
-       res = hsr_get_node_data(hsr_priv,
+       hsr = netdev_priv(hsr_dev);
+       res = hsr_get_node_data(hsr,
                        (unsigned char *) nla_data(info->attrs[HSR_A_NODE_ADDR]),
                        hsr_node_addr_b,
                        &addr_b_ifindex,
@@ -301,9 +301,9 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
        res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq);
        if (res < 0)
                goto nla_put_failure;
-       if (hsr_priv->slave[0])
+       if (hsr->slave[0])
                res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX,
-                                               hsr_priv->slave[0]->ifindex);
+                                               hsr->slave[0]->ifindex);
        if (res < 0)
                goto nla_put_failure;
 
@@ -313,9 +313,9 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
        res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq);
        if (res < 0)
                goto nla_put_failure;
-       if (hsr_priv->slave[1])
+       if (hsr->slave[1])
                res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX,
-                                               hsr_priv->slave[1]->ifindex);
+                                               hsr->slave[1]->ifindex);
 
        genlmsg_end(skb_out, msg_head);
        genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);
@@ -345,7 +345,7 @@ static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info)
        /* For sending */
        struct sk_buff *skb_out;
        void *msg_head;
-       struct hsr_priv *hsr_priv;
+       struct hsr_priv *hsr;
        void *pos;
        unsigned char addr[ETH_ALEN];
        int res;
@@ -385,17 +385,17 @@ static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info)
        if (res < 0)
                goto nla_put_failure;
 
-       hsr_priv = netdev_priv(hsr_dev);
+       hsr = netdev_priv(hsr_dev);
 
        rcu_read_lock();
-       pos = hsr_get_next_node(hsr_priv, NULL, addr);
+       pos = hsr_get_next_node(hsr, NULL, addr);
        while (pos) {
                res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN, addr);
                if (res < 0) {
                        rcu_read_unlock();
                        goto nla_put_failure;
                }
-               pos = hsr_get_next_node(hsr_priv, pos, addr);
+               pos = hsr_get_next_node(hsr, pos, addr);
        }
        rcu_read_unlock();
 
index d4579dcc3c7d50adde22a34c01008c46028283d8..3047f9cea5f52808229c64408b2a3b4526290ff2 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright 2011-2013 Autronica Fire and Security AS
+/* Copyright 2011-2014 Autronica Fire and Security AS
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -6,7 +6,7 @@
  * any later version.
  *
  * Author(s):
- *     2011-2013 Arvid Brodin, arvid.brodin@xdin.com
+ *     2011-2014 Arvid Brodin, arvid.brodin@alten.se
  */
 
 #ifndef __HSR_NETLINK_H
@@ -21,9 +21,9 @@ struct hsr_priv;
 int __init hsr_netlink_init(void);
 void __exit hsr_netlink_exit(void);
 
-void hsr_nl_ringerror(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN],
+void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
                      int dev_idx);
-void hsr_nl_nodedown(struct hsr_priv *hsr_priv, unsigned char addr[ETH_ALEN]);
+void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN]);
 void hsr_nl_framedrop(int dropcount, int dev_idx);
 void hsr_nl_linkdown(int dev_idx);