- 根目录:
- net
- hsr
- hsr_main.c
/* Copyright 2011-2013 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
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* Author(s):
* 2011-2013 Arvid Brodin, arvid.brodin@xdin.com
*
* In addition to routines for registering and unregistering HSR support, this
* file also contains the receive routine that handles all incoming frames with
* Ethertype (protocol) ETH_P_PRP (HSRv0), and network device event handling.
*/
#include <linux/netdevice.h>
#include <linux/rculist.h>
#include <linux/timer.h>
#include <linux/etherdevice.h>
#include "hsr_main.h"
#include "hsr_device.h"
#include "hsr_netlink.h"
#include "hsr_framereg.h"
/* List of all registered virtual HSR devices */
static LIST_HEAD(hsr_list);
void register_hsr_master(struct hsr_priv *hsr_priv)
{
list_add_tail_rcu(&hsr_priv->hsr_list, &hsr_list);
}
void unregister_hsr_master(struct hsr_priv *hsr_priv)
{
struct hsr_priv *hsr_priv_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);
return;
}
}
bool is_hsr_slave(struct net_device *dev)
{
struct hsr_priv *hsr_priv_it;
list_for_each_entry_rcu(hsr_priv_it, &hsr_list, hsr_list) {
if (dev == hsr_priv_it->slave[0])
return true;
if (dev == hsr_priv_it->slave[1])
return true;
}
return false;
}
/* If dev is a HSR slave device, return the virtual master device. Return NULL
* otherwise.
*/
static struct hsr_priv *get_hsr_master(struct net_device *dev)
{
struct hsr_priv *hsr_priv;
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])) {
rcu_read_unlock();
return hsr_priv;
}
rcu_read_unlock();
return NULL;
}
/* 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,
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];
return NULL;
}
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;
int old_operstate;
int mtu_max;
int res;
struct net_device *dev;
dev = netdev_notifier_info_to_dev(ptr);
hsr_priv = get_hsr_master(dev);
if (hsr_priv) {
/* dev is a slave device */
slave = dev;
other_slave = get_other_slave(hsr_priv, 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];
}
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);
/* 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);
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)
break;
if (dev == hsr_priv->slave[0])
memcpy(hsr_priv->dev->dev_addr,
hsr_priv->slave[0]->dev_addr, ETH_ALEN);
/* 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);
if (res)
netdev_warn(hsr_priv->dev,
"Could not update HSR node address.\n");
if (dev == hsr_priv->slave[0])
call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr_priv->dev);
break;
case NETDEV_CHANGEMTU:
if (dev == hsr_priv->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);
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;
/* There should really be a way to set a new slave device... */
break;
case NETDEV_PRE_TYPE_CHANGE:
/* HSR works only on Ethernet devices. Refuse slave to change
* its type.
*/
return NOTIFY_BAD;
}
return NOTIFY_DONE;
}
static struct timer_list prune_timer;
static void prune_nodes_all(unsigned long data)
{
struct hsr_priv *hsr_priv;
rcu_read_lock();
list_for_each_entry_rcu(hsr_priv, &hsr_list, hsr_list)
hsr_prune_nodes(hsr_priv);
rcu_read_unlock();
prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD);
add_timer(&prune_timer);
}
static struct sk_buff *hsr_pull_tag(struct sk_buff *skb)
{
struct hsr_tag *hsr_tag;
struct sk_buff *skb2;
skb2 = skb_share_check(skb, GFP_ATOMIC);
if (unlikely(!skb2))
goto err_free;
skb = skb2;
if (unlikely(!pskb_may_pull(skb, HSR_TAGLEN)))
goto err_free;
hsr_tag = (struct hsr_tag *) skb->data;
skb->protocol = hsr_tag->encap_proto;
skb_pull(skb, HSR_TAGLEN);
return skb;
err_free:
kfree_skb(skb);
return NULL;
}
/* The uses I can see for these HSR supervision frames are:
* 1) Use the frames that are sent after node initialization ("HSR_TLV.Type =
* 22") to reset any sequence_nr counters belonging to that node. Useful if
* the other node's counter has been reset for some reason.
* --
* Or not - resetting the counter and bridging the frame would create a
* loop, unfortunately.
*
* 2) Use the LifeCheck frames to detect ring breaks. I.e. if no LifeCheck
* frame is received from a particular node, we know something is wrong.
* We just register these (as with normal frames) and throw them away.
*
* 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)
{
struct hsr_sup_tag *hsr_stag;
if (!ether_addr_equal(eth_hdr(skb)->h_dest,
hsr_priv->sup_multicast_addr))
return false;
hsr_stag = (struct hsr_sup_tag *) skb->data;
if (get_hsr_stag_path(hsr_stag) != 0x0f)
return false;
if ((hsr_stag->HSR_TLV_Type != HSR_TLV_ANNOUNCE) &&
(hsr_stag->HSR_TLV_Type != HSR_TLV_LIFE_CHECK))
return false;
if (hsr_stag->HSR_TLV_Length != 12)
return false;
return true;
}
/* Implementation somewhat according to IEC-62439-3, p. 43
*/
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 net_device *other_slave;
struct node_entry *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);
if (!hsr_priv) {
/* 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]) {
dev_in_idx = HSR_DEV_SLAVE_A;
dev_other_idx = HSR_DEV_SLAVE_B;
} else {
dev_in_idx = HSR_DEV_SLAVE_B;
dev_other_idx = HSR_DEV_SLAVE_A;
}
node = hsr_find_node(&hsr_priv->self_node_db, skb);
if (node) {
/* Always kill frames sent by ourselves */
kfree_skb(skb);
return NET_RX_SUCCESS;
}
/* Is this frame a candidate for local reception? */
deliver_to_self = false;
if ((skb->pkt_type == PACKET_HOST) ||
(skb->pkt_type == PACKET_MULTICAST) ||
(skb->pkt_type == PACKET_BROADCAST))
deliver_to_self = true;
else if (ether_addr_equal(eth_hdr(skb)->h_dest,
hsr_priv->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);
if (is_supervision_frame(hsr_priv, skb)) {
skb_pull(skb, sizeof(struct hsr_sup_tag));
node = hsr_merge_node(hsr_priv, node, skb, dev_in_idx);
if (!node) {
rcu_read_unlock(); /* node_db */
kfree_skb(skb);
hsr_priv->dev->stats.rx_dropped++;
return NET_RX_DROP;
}
skb_push(skb, sizeof(struct hsr_sup_tag));
deliver_to_self = false;
}
if (!node) {
/* Source node unknown; this might be a HSR frame from
* another net (different multicast address). Ignore it.
*/
rcu_read_unlock(); /* node_db */
kfree_skb(skb);
return NET_RX_SUCCESS;
}
/* Register ALL incoming frames as outgoing through the other interface.
* This allows us to register frames as incoming only if they are valid
* for the receiving interface, without using a specific counter for
* incoming frames.
*/
dup_out = hsr_register_frame_out(node, dev_other_idx, skb);
if (!dup_out)
hsr_register_frame_in(node, dev_in_idx);
/* Forward this frame? */
if (!dup_out && (skb->pkt_type != PACKET_HOST))
other_slave = get_other_slave(hsr_priv, dev);
else
other_slave = NULL;
if (hsr_register_frame_out(node, HSR_DEV_MASTER, skb))
deliver_to_self = false;
rcu_read_unlock(); /* node_db */
if (!deliver_to_self && !other_slave) {
kfree_skb(skb);
/* Circulated frame; silently remove it. */
return NET_RX_SUCCESS;
}
skb_deliver = skb;
if (deliver_to_self && other_slave) {
/* skb_clone() is not enough since we will strip the hsr tag
* and do address substitution below
*/
skb_deliver = pskb_copy(skb, GFP_ATOMIC);
if (!skb_deliver) {
deliver_to_self = false;
hsr_priv->dev->stats.rx_dropped++;
}
}
if (deliver_to_self) {
bool multicast_frame;
skb_deliver = hsr_pull_tag(skb_deliver);
if (!skb_deliver) {
hsr_priv->dev->stats.rx_dropped++;
goto forward;
}
#if !defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
/* Move everything in the header that is after the HSR tag,
* to work around alignment problems caused by the 6-byte HSR
* 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,
skb_headlen(skb_deliver));
/* Adjust skb members so they correspond with the move above.
* This cannot possibly underflow skb->data since hsr_pull_tag()
* above succeeded.
* At this point in the protocol stack, the transport and
* network headers have not been set yet, and we haven't touched
* 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;
#endif
skb_deliver->dev = hsr_priv->dev;
hsr_addr_subst_source(hsr_priv, 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++;
} else {
hsr_priv->dev->stats.rx_packets++;
hsr_priv->dev->stats.rx_bytes += skb->len;
if (multicast_frame)
hsr_priv->dev->stats.multicast++;
}
}
forward:
if (other_slave) {
skb_push(skb, ETH_HLEN);
skb->dev = other_slave;
dev_queue_xmit(skb);
}
return NET_RX_SUCCESS;
}
static struct packet_type hsr_pt __read_mostly = {
.type = htons(ETH_P_PRP),
.func = hsr_rcv,
};
static struct notifier_block hsr_nb = {
.notifier_call = hsr_netdev_notify, /* Slave event notifications */
};
static int __init hsr_init(void)
{
int res;
BUILD_BUG_ON(sizeof(struct hsr_tag) != HSR_TAGLEN);
dev_add_pack(&hsr_pt);
init_timer(&prune_timer);
prune_timer.function = prune_nodes_all;
prune_timer.data = 0;
prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD);
add_timer(&prune_timer);
register_netdevice_notifier(&hsr_nb);
res = hsr_netlink_init();
return res;
}
static void __exit hsr_exit(void)
{
unregister_netdevice_notifier(&hsr_nb);
del_timer(&prune_timer);
hsr_netlink_exit();
dev_remove_pack(&hsr_pt);
}
module_init(hsr_init);
module_exit(hsr_exit);
MODULE_LICENSE("GPL");