Commit c5a75911 authored by Arvid Brodin's avatar Arvid Brodin Committed by David S. Miller

net/hsr: Use list_head (and rcu) instead of array for slave devices.

Signed-off-by: default avatarArvid Brodin <arvid.brodin@alten.se>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 51f3c605
This diff is collapsed.
This diff is collapsed.
......@@ -18,18 +18,16 @@ struct hsr_node;
struct hsr_node *hsr_find_node(struct list_head *node_db, struct sk_buff *skb);
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_node *hsr_merge_node(struct hsr_node *node, struct sk_buff *skb,
struct hsr_port *port);
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);
struct hsr_port *port);
void hsr_register_frame_in(struct hsr_node *node, enum hsr_dev_idx dev_idx);
void hsr_register_frame_in(struct hsr_node *node, struct hsr_port *port);
int hsr_register_frame_out(struct hsr_node *node, enum hsr_dev_idx dev_idx,
int hsr_register_frame_out(struct hsr_node *node, struct hsr_port *port,
struct sk_buff *skb);
void hsr_prune_nodes(unsigned long data);
......
......@@ -39,76 +39,25 @@ void unregister_hsr_master(struct hsr_priv *hsr)
}
}
bool is_hsr_slave(struct net_device *dev)
{
struct hsr_priv *hsr_it;
list_for_each_entry_rcu(hsr_it, &hsr_list, hsr_list) {
if (dev == hsr_it->slave[0])
return true;
if (dev == hsr_it->slave[1])
return true;
}
return false;
}
/* If dev is a HSR slave device, return the virtual master device. Return NULL
* otherwise.
*/
struct hsr_priv *get_hsr_master(struct net_device *dev)
{
struct hsr_priv *hsr;
rcu_read_lock();
list_for_each_entry_rcu(hsr, &hsr_list, hsr_list)
if ((dev == hsr->slave[0]) ||
(dev == hsr->slave[1])) {
rcu_read_unlock();
return hsr;
}
rcu_read_unlock();
return NULL;
}
/* If dev is a HSR slave device, return the other slave device. Return NULL
* otherwise.
*/
struct net_device *get_other_slave(struct hsr_priv *hsr,
struct net_device *dev)
{
if (dev == hsr->slave[0])
return hsr->slave[1];
if (dev == hsr->slave[1])
return hsr->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 net_device *dev;
struct hsr_port *port, *master;
struct hsr_priv *hsr;
int mtu_max;
int res;
struct net_device *dev;
dev = netdev_notifier_info_to_dev(ptr);
hsr = get_hsr_master(dev);
if (hsr) {
/* dev is a slave device */
slave = dev;
other_slave = get_other_slave(hsr, slave);
} else {
port = hsr_port_get_rtnl(dev);
if (port == NULL) {
if (!is_hsr_master(dev))
return NOTIFY_DONE;
return NOTIFY_DONE; /* Not an HSR device */
hsr = netdev_priv(dev);
slave = hsr->slave[0];
other_slave = hsr->slave[1];
port = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
} else {
hsr = port->hsr;
}
switch (event) {
......@@ -118,48 +67,41 @@ static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
hsr_check_carrier_and_operstate(hsr);
break;
case NETDEV_CHANGEADDR:
/* This should not happen since there's no ndo_set_mac_address()
* for HSR devices - i.e. not supported.
if (port->type == HSR_PT_MASTER) {
/* This should not happen since there's no
* ndo_set_mac_address() for HSR devices - i.e. not
* supported.
*/
if (dev == hsr->dev)
break;
}
if (dev == hsr->slave[0]) {
ether_addr_copy(hsr->dev->dev_addr, dev->dev_addr);
call_netdevice_notifiers(NETDEV_CHANGEADDR, hsr->dev);
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
if (port->type == HSR_PT_SLAVE_A) {
ether_addr_copy(master->dev->dev_addr, dev->dev_addr);
call_netdevice_notifiers(NETDEV_CHANGEADDR, master->dev);
}
/* Make sure we recognize frames from ourselves in hsr_rcv() */
other_slave = hsr->slave[1];
port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
res = hsr_create_self_node(&hsr->self_node_db,
hsr->dev->dev_addr,
other_slave ?
other_slave->dev_addr :
hsr->dev->dev_addr);
master->dev->dev_addr,
port ?
port->dev->dev_addr :
master->dev->dev_addr);
if (res)
netdev_warn(hsr->dev,
netdev_warn(master->dev,
"Could not update HSR node address.\n");
break;
case NETDEV_CHANGEMTU:
if (dev == hsr->dev)
if (port->type == HSR_PT_MASTER)
break; /* Handled in ndo_change_mtu() */
mtu_max = hsr_get_max_mtu(hsr);
if (hsr->dev->mtu > mtu_max)
dev_set_mtu(hsr->dev, mtu_max);
mtu_max = hsr_get_max_mtu(port->hsr);
master = hsr_port_get_hsr(port->hsr, HSR_PT_MASTER);
master->dev->mtu = mtu_max;
break;
case NETDEV_UNREGISTER:
if (dev == hsr->slave[0]) {
hsr->slave[0] = NULL;
hsr_del_slave(hsr, 0);
}
if (dev == hsr->slave[1]) {
hsr->slave[1] = NULL;
hsr_del_slave(hsr, 1);
}
/* There should really be a way to set a new slave device... */
hsr_del_port(port);
break;
case NETDEV_PRE_TYPE_CHANGE:
/* HSR works only on Ethernet devices. Refuse slave to change
......@@ -172,6 +114,16 @@ static int hsr_netdev_notify(struct notifier_block *nb, unsigned long event,
}
struct hsr_port *hsr_port_get_hsr(struct hsr_priv *hsr, enum hsr_port_type pt)
{
struct hsr_port *port;
hsr_for_each_port(hsr, port)
if (port->type == pt)
return port;
return NULL;
}
static struct notifier_block hsr_nb = {
.notifier_call = hsr_netdev_notify, /* Slave event notifications */
};
......
......@@ -136,20 +136,26 @@ struct hsr_ethhdr_sp {
} __packed;
enum hsr_dev_idx {
HSR_DEV_NONE = -1,
HSR_DEV_SLAVE_A = 0,
HSR_DEV_SLAVE_B,
HSR_DEV_MASTER,
enum hsr_port_type {
HSR_PT_NONE = 0, /* Must be 0, used by framereg */
HSR_PT_SLAVE_A,
HSR_PT_SLAVE_B,
HSR_PT_INTERLINK,
HSR_PT_MASTER,
HSR_PT_PORTS, /* This must be the last item in the enum */
};
struct hsr_port {
struct list_head port_list;
struct net_device *dev;
struct hsr_priv *hsr;
enum hsr_port_type type;
};
#define HSR_MAX_SLAVE (HSR_DEV_SLAVE_B + 1)
#define HSR_MAX_DEV (HSR_DEV_MASTER + 1)
struct hsr_priv {
struct list_head hsr_list; /* List of hsr devices */
struct rcu_head rcu_head;
struct net_device *dev;
struct net_device *slave[HSR_MAX_SLAVE];
struct list_head ports;
struct list_head node_db; /* Other HSR nodes */
struct list_head self_node_db; /* MACs of slaves */
struct timer_list announce_timer; /* Supervision frame dispatch */
......@@ -160,11 +166,6 @@ struct hsr_priv {
unsigned char sup_multicast_addr[ETH_ALEN];
};
void register_hsr_master(struct hsr_priv *hsr);
void unregister_hsr_master(struct hsr_priv *hsr);
bool is_hsr_slave(struct net_device *dev);
struct hsr_priv *get_hsr_master(struct net_device *dev);
struct net_device *get_other_slave(struct hsr_priv *hsr,
struct net_device *dev);
struct hsr_port *hsr_port_get_hsr(struct hsr_priv *hsr, enum hsr_port_type pt);
#endif /* __HSR_PRIVATE_H */
......@@ -64,7 +64,7 @@ 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;
struct net_device *slave;
struct hsr_port *port;
int res;
hsr = netdev_priv(dev);
......@@ -72,17 +72,17 @@ static int hsr_fill_info(struct sk_buff *skb, const struct net_device *dev)
res = 0;
rcu_read_lock();
slave = hsr->slave[0];
if (slave)
res = nla_put_u32(skb, IFLA_HSR_SLAVE1, slave->ifindex);
port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
if (port)
res = nla_put_u32(skb, IFLA_HSR_SLAVE1, port->dev->ifindex);
rcu_read_unlock();
if (res)
goto nla_put_failure;
rcu_read_lock();
slave = hsr->slave[1];
if (slave)
res = nla_put_u32(skb, IFLA_HSR_SLAVE2, slave->ifindex);
port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
if (port)
res = nla_put_u32(skb, IFLA_HSR_SLAVE2, port->dev->ifindex);
rcu_read_unlock();
if (res)
goto nla_put_failure;
......@@ -141,13 +141,12 @@ static const struct genl_multicast_group hsr_mcgrps[] = {
* (i.e. a link has failed somewhere).
*/
void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
enum hsr_dev_idx dev_idx)
struct hsr_port *port)
{
struct sk_buff *skb;
struct net_device *slave;
void *msg_head;
struct hsr_port *master;
int res;
int ifindex;
skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
if (!skb)
......@@ -161,15 +160,7 @@ void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
if (res < 0)
goto nla_put_failure;
rcu_read_lock();
slave = hsr->slave[dev_idx];
if (slave)
ifindex = slave->ifindex;
else
ifindex = -1;
rcu_read_unlock();
res = nla_put_u32(skb, HSR_A_IFINDEX, ifindex);
res = nla_put_u32(skb, HSR_A_IFINDEX, port->dev->ifindex);
if (res < 0)
goto nla_put_failure;
......@@ -182,7 +173,10 @@ void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
kfree_skb(skb);
fail:
netdev_warn(hsr->dev, "Could not send HSR ring error message\n");
rcu_read_lock();
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
netdev_warn(master->dev, "Could not send HSR ring error message\n");
rcu_read_unlock();
}
/* This is called when we haven't heard from the node with MAC address addr for
......@@ -192,6 +186,7 @@ void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN])
{
struct sk_buff *skb;
void *msg_head;
struct hsr_port *master;
int res;
skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
......@@ -216,7 +211,10 @@ void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN])
kfree_skb(skb);
fail:
netdev_warn(hsr->dev, "Could not send HSR node down\n");
rcu_read_lock();
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
netdev_warn(master->dev, "Could not send HSR node down\n");
rcu_read_unlock();
}
......@@ -232,12 +230,13 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
{
/* For receiving */
struct nlattr *na;
struct net_device *hsr_dev, *slave;
struct net_device *hsr_dev;
/* For sending */
struct sk_buff *skb_out;
void *msg_head;
struct hsr_priv *hsr;
struct hsr_port *port;
unsigned char hsr_node_addr_b[ETH_ALEN];
int hsr_node_if1_age;
u16 hsr_node_if1_seq;
......@@ -319,9 +318,10 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
if (res < 0)
goto nla_put_failure;
rcu_read_lock();
slave = hsr->slave[0];
if (slave)
res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX, slave->ifindex);
port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
if (port)
res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX,
port->dev->ifindex);
rcu_read_unlock();
if (res < 0)
goto nla_put_failure;
......@@ -333,9 +333,10 @@ static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
if (res < 0)
goto nla_put_failure;
rcu_read_lock();
slave = hsr->slave[1];
if (slave)
res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX, slave->ifindex);
port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
if (port)
res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX,
port->dev->ifindex);
rcu_read_unlock();
if (res < 0)
goto nla_put_failure;
......
......@@ -17,12 +17,13 @@
#include <uapi/linux/hsr_netlink.h>
struct hsr_priv;
struct hsr_port;
int __init hsr_netlink_init(void);
void __exit hsr_netlink_exit(void);
void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
int dev_idx);
struct hsr_port *port);
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);
......
......@@ -17,7 +17,7 @@
#include "hsr_framereg.h"
static int check_slave_ok(struct net_device *dev)
static int hsr_check_dev_ok(struct net_device *dev)
{
/* Don't allow HSR on non-ethernet like devices */
if ((dev->flags & IFF_LOOPBACK) || (dev->type != ARPHRD_ETHER) ||
......@@ -32,7 +32,7 @@ static int check_slave_ok(struct net_device *dev)
return -EINVAL;
}
if (is_hsr_slave(dev)) {
if (hsr_port_exists(dev)) {
netdev_info(dev, "This device is already a HSR slave.\n");
return -EINVAL;
}
......@@ -116,38 +116,29 @@ static bool is_supervision_frame(struct hsr_priv *hsr, struct sk_buff *skb)
rx_handler_result_t hsr_handle_frame(struct sk_buff **pskb)
{
struct sk_buff *skb = *pskb;
struct net_device *dev = skb->dev;
struct hsr_port *port, *other_port, *master;
struct hsr_priv *hsr;
struct net_device *other_slave;
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;
if (eth_hdr(skb)->h_proto != htons(ETH_P_PRP))
return RX_HANDLER_PASS;
hsr = get_hsr_master(dev);
if (!hsr) {
WARN_ON_ONCE(1);
return RX_HANDLER_PASS;
}
rcu_read_lock(); /* ports & node */
if (dev == hsr->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;
}
port = hsr_port_get_rcu(skb->dev);
hsr = port->hsr;
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
node = hsr_find_node(&hsr->self_node_db, skb);
if (node) {
/* Always kill frames sent by ourselves */
kfree_skb(skb);
return RX_HANDLER_CONSUMED;
ret = RX_HANDLER_CONSUMED;
goto finish;
}
/* Is this frame a candidate for local reception? */
......@@ -156,23 +147,22 @@ rx_handler_result_t hsr_handle_frame(struct sk_buff **pskb)
(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->dev->dev_addr)) {
else if (ether_addr_equal(eth_hdr(skb)->h_dest,
master->dev->dev_addr)) {
skb->pkt_type = PACKET_HOST;
deliver_to_self = true;
}
rcu_read_lock(); /* node_db */
node = hsr_find_node(&hsr->node_db, skb);
if (is_supervision_frame(hsr, skb)) {
skb_pull(skb, sizeof(struct hsr_sup_tag));
node = hsr_merge_node(hsr, node, skb, dev_in_idx);
node = hsr_merge_node(node, skb, port);
if (!node) {
rcu_read_unlock(); /* node_db */
kfree_skb(skb);
hsr->dev->stats.rx_dropped++;
return RX_HANDLER_CONSUMED;
master->dev->stats.rx_dropped++;
ret = RX_HANDLER_CONSUMED;
goto finish;
}
skb_push(skb, sizeof(struct hsr_sup_tag));
deliver_to_self = false;
......@@ -182,46 +172,51 @@ rx_handler_result_t hsr_handle_frame(struct sk_buff **pskb)
/* 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 RX_HANDLER_CONSUMED;
ret = RX_HANDLER_CONSUMED;
goto finish;
}
if (port->type == HSR_PT_SLAVE_A)
other_port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
else
other_port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
/* 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 (other_port)
dup_out = hsr_register_frame_out(node, other_port, skb);
else
dup_out = 0;
if (!dup_out)
hsr_register_frame_in(node, dev_in_idx);
hsr_register_frame_in(node, port);
/* Forward this frame? */
if (!dup_out && (skb->pkt_type != PACKET_HOST))
other_slave = get_other_slave(hsr, dev);
else
other_slave = NULL;
if (dup_out || (skb->pkt_type == PACKET_HOST))
other_port = NULL;
if (hsr_register_frame_out(node, HSR_DEV_MASTER, skb))
if (hsr_register_frame_out(node, master, skb))
deliver_to_self = false;
rcu_read_unlock(); /* node_db */
if (!deliver_to_self && !other_slave) {
if (!deliver_to_self && !other_port) {
kfree_skb(skb);
/* Circulated frame; silently remove it. */
return RX_HANDLER_CONSUMED;
ret = RX_HANDLER_CONSUMED;
goto finish;
}
skb_deliver = skb;
if (deliver_to_self && other_slave) {
if (deliver_to_self && other_port) {
/* 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->dev->stats.rx_dropped++;
master->dev->stats.rx_dropped++;
}
}
......@@ -230,7 +225,7 @@ rx_handler_result_t hsr_handle_frame(struct sk_buff **pskb)
skb_deliver = hsr_pull_tag(skb_deliver);
if (!skb_deliver) {
hsr->dev->stats.rx_dropped++;
master->dev->stats.rx_dropped++;
goto forward;
}
#if !defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
......@@ -253,82 +248,130 @@ rx_handler_result_t hsr_handle_frame(struct sk_buff **pskb)
skb_deliver->data -= HSR_HLEN;
skb_deliver->tail -= HSR_HLEN;
#endif
skb_deliver->dev = hsr->dev;
skb_deliver->dev = master->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->dev->stats.rx_dropped++;
master->dev->stats.rx_dropped++;
} else {
hsr->dev->stats.rx_packets++;
hsr->dev->stats.rx_bytes += skb->len;
master->dev->stats.rx_packets++;
master->dev->stats.rx_bytes += skb->len;
if (multicast_frame)
hsr->dev->stats.multicast++;
master->dev->stats.multicast++;
}
}
forward:
if (other_slave) {
if (other_port) {
skb_push(skb, ETH_HLEN);
skb->dev = other_slave;
skb->dev = other_port->dev;
dev_queue_xmit(skb);
}
return RX_HANDLER_CONSUMED;
ret = RX_HANDLER_CONSUMED;
finish:
rcu_read_unlock();
return ret;
}
int hsr_add_slave(struct hsr_priv *hsr, struct net_device *dev, int idx)
/* Setup device to be added to the HSR bridge. */
static int hsr_portdev_setup(struct net_device *dev, struct hsr_port *port)
{
int res;
dev_hold(dev);
res = check_slave_ok(dev);
res = dev_set_promiscuity(dev, 1);
if (res)
goto fail_promiscuity;
res = netdev_rx_handler_register(dev, hsr_handle_frame, port);
if (res)
goto fail;
goto fail_rx_handler;
dev_disable_lro(dev);
res = dev_set_promiscuity(dev, 1);
/* FIXME:
* What does net device "adjacency" mean? Should we do
* res = netdev_master_upper_dev_link(port->dev, port->hsr->dev); ?
*/
return 0;
fail_rx_handler:
dev_set_promiscuity(dev, -1);
fail_promiscuity:
dev_put(dev);
return res;
}
int hsr_add_port(struct hsr_priv *hsr, struct net_device *dev,
enum hsr_port_type type)
{
struct hsr_port *port, *master;
int res;
if (type != HSR_PT_MASTER) {
res = hsr_check_dev_ok(dev);
if (res)
goto fail;
return res;
}
res = netdev_rx_handler_register(dev, hsr_handle_frame, hsr);
port = hsr_port_get_hsr(hsr, type);
if (port != NULL)
return -EBUSY; /* This port already exists */
port = kzalloc(sizeof(*port), GFP_KERNEL);
if (port == NULL)
return -ENOMEM;
if (type != HSR_PT_MASTER) {
res = hsr_portdev_setup(dev, port);
if (res)
goto fail_rx_handler;
goto fail_dev_setup;
}
port->hsr = hsr;
port->dev = dev;
port->type = type;
list_add_tail_rcu(&port->port_list, &hsr->ports);
synchronize_rcu();
hsr->slave[idx] = dev;
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
/* Set required header length */
if (dev->hard_header_len + HSR_HLEN > hsr->dev->hard_header_len)
hsr->dev->hard_header_len = dev->hard_header_len + HSR_HLEN;
if (dev->hard_header_len + HSR_HLEN > master->dev->hard_header_len)
master->dev->hard_header_len = dev->hard_header_len + HSR_HLEN;
dev_set_mtu(hsr->dev, hsr_get_max_mtu(hsr));
dev_set_mtu(master->dev, hsr_get_max_mtu(hsr));
return 0;
fail_rx_handler:
dev_set_promiscuity(dev, -1);
fail:
dev_put(dev);
fail_dev_setup:
kfree(port);
return res;
}
void hsr_del_slave(struct hsr_priv *hsr, int idx)
void hsr_del_port(struct hsr_port *port)
{
struct net_device *slave;
slave = hsr->slave[idx];
hsr->slave[idx] = NULL;
struct hsr_priv *hsr;
struct hsr_port *master;
netdev_update_features(hsr->dev);
dev_set_mtu(hsr->dev, hsr_get_max_mtu(hsr));
hsr = port->hsr;
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
list_del_rcu(&port->port_list);
if (slave) {
netdev_rx_handler_unregister(slave);
dev_set_promiscuity(slave, -1);
if (port != master) {
dev_set_mtu(master->dev, hsr_get_max_mtu(hsr));
netdev_rx_handler_unregister(port->dev);
dev_set_promiscuity(port->dev, -1);
}
/* FIXME?
* netdev_upper_dev_unlink(port->dev, port->hsr->dev);
*/
synchronize_rcu();
dev_put(slave);
dev_put(port->dev);
}
......@@ -14,10 +14,35 @@
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/rtnetlink.h>
#include "hsr_main.h"
int hsr_add_slave(struct hsr_priv *hsr, struct net_device *dev, int idx);
void hsr_del_slave(struct hsr_priv *hsr, int idx);
int hsr_add_port(struct hsr_priv *hsr, struct net_device *dev,
enum hsr_port_type pt);
void hsr_del_port(struct hsr_port *port);
rx_handler_result_t hsr_handle_frame(struct sk_buff **pskb);
#define hsr_for_each_port(hsr, port) \
list_for_each_entry_rcu((port), &(hsr)->ports, port_list)
static inline bool hsr_port_exists(const struct net_device *dev)
{
return dev->rx_handler == hsr_handle_frame;
}
static inline struct hsr_port *hsr_port_get_rtnl(const struct net_device *dev)
{
ASSERT_RTNL();
return hsr_port_exists(dev) ?
rtnl_dereference(dev->rx_handler_data) : NULL;
}
static inline struct hsr_port *hsr_port_get_rcu(const struct net_device *dev)
{
return hsr_port_exists(dev) ?
rcu_dereference(dev->rx_handler_data) : NULL;
}
#endif /* __HSR_SLAVE_H */
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment