net/hsr: Better variable names and update of contact info. (70ebe4a4) · Commits · e / devices / android_kernel_teracube_2e

net/hsr/hsr_device.c

+103 −104

Original line number	Diff line number	Diff line
		/* 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 @@ static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type)
		*/
		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;

net/hsr/hsr_device.h

+3 −3

Original line number	Diff line number	Diff line
		/* 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 */

net/hsr/hsr_framereg.c

+54 −54

Original line number	Diff line number	Diff line
		/* 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
		@@ -23,7 +23,7 @@
		#include "hsr_netlink.h"


		struct node_entry {
		struct hsr_node {
		struct list_head mac_list;
		unsigned char MacAddressA[ETH_ALEN];
		unsigned char MacAddressB[ETH_ALEN];
		@@ -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,
		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,
		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,8 +154,8 @@ 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 hsr_node hsr_merge_node(struct hsr_priv hsr,
		struct hsr_node *node,
		struct sk_buff *skb,
		enum hsr_dev_idx dev_idx)
		{
		@@ -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;

net/hsr/hsr_framereg.h

+18 −18

Original line number	Diff line number	Diff line
		/* 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 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 */

net/hsr/hsr_main.c

+85 −85

File changed.

Preview size limit exceeded, changes collapsed.