net/hsr: Better variable names and update of contact info.

Signed-off-by: Arvid Brodin <arvid.brodin@alten.se>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 85 insertions, 85 deletions

diff --git a/net/hsr/hsr_main.c b/net/hsr/hsr_main.c
index 3fee5218a691..99b8fc4eca6c 100644
--- a/net/hsr/hsr_main.c
+++ b/net/hsr/hsr_main.c
@@ -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
@@ -26,30 +26,30 @@
 /* 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);