2019-04-05 20:31:34 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2014-07-05 01:34:38 +04:00
|
|
|
/* Copyright 2011-2014 Autronica Fire and Security AS
|
2013-10-31 00:10:47 +04:00
|
|
|
*
|
|
|
|
* Author(s):
|
2014-07-05 01:34:38 +04:00
|
|
|
* 2011-2014 Arvid Brodin, arvid.brodin@alten.se
|
2013-10-31 00:10:47 +04:00
|
|
|
* This file contains device methods for creating, using and destroying
|
2020-07-22 17:40:16 +03:00
|
|
|
* virtual HSR or PRP devices.
|
2013-10-31 00:10:47 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
|
|
|
#include <linux/pkt_sched.h>
|
|
|
|
#include "hsr_device.h"
|
2014-07-05 01:35:24 +04:00
|
|
|
#include "hsr_slave.h"
|
2013-10-31 00:10:47 +04:00
|
|
|
#include "hsr_framereg.h"
|
|
|
|
#include "hsr_main.h"
|
2014-07-05 01:41:03 +04:00
|
|
|
#include "hsr_forward.h"
|
2013-10-31 00:10:47 +04:00
|
|
|
|
|
|
|
static bool is_admin_up(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return dev && (dev->flags & IFF_UP);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool is_slave_up(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return dev && is_admin_up(dev) && netif_oper_up(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __hsr_set_operstate(struct net_device *dev, int transition)
|
|
|
|
{
|
2021-11-26 19:15:29 +03:00
|
|
|
write_lock(&dev_base_lock);
|
2013-10-31 00:10:47 +04:00
|
|
|
if (dev->operstate != transition) {
|
|
|
|
dev->operstate = transition;
|
2021-11-26 19:15:29 +03:00
|
|
|
write_unlock(&dev_base_lock);
|
2013-10-31 00:10:47 +04:00
|
|
|
netdev_state_change(dev);
|
|
|
|
} else {
|
2021-11-26 19:15:29 +03:00
|
|
|
write_unlock(&dev_base_lock);
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-05 01:38:05 +04:00
|
|
|
static void hsr_set_operstate(struct hsr_port *master, bool has_carrier)
|
2013-10-31 00:10:47 +04:00
|
|
|
{
|
2014-07-05 01:38:05 +04:00
|
|
|
if (!is_admin_up(master->dev)) {
|
|
|
|
__hsr_set_operstate(master->dev, IF_OPER_DOWN);
|
2013-10-31 00:10:47 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-07-05 01:36:40 +04:00
|
|
|
if (has_carrier)
|
2014-07-05 01:38:05 +04:00
|
|
|
__hsr_set_operstate(master->dev, IF_OPER_UP);
|
2013-10-31 00:10:47 +04:00
|
|
|
else
|
2014-07-05 01:38:05 +04:00
|
|
|
__hsr_set_operstate(master->dev, IF_OPER_LOWERLAYERDOWN);
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
|
|
|
|
2014-07-05 01:38:05 +04:00
|
|
|
static bool hsr_check_carrier(struct hsr_port *master)
|
2013-10-31 00:10:47 +04:00
|
|
|
{
|
2014-07-05 01:38:05 +04:00
|
|
|
struct hsr_port *port;
|
2014-07-05 01:36:40 +04:00
|
|
|
|
2020-02-28 21:01:56 +03:00
|
|
|
ASSERT_RTNL();
|
2014-07-05 01:38:05 +04:00
|
|
|
|
2020-02-28 21:01:56 +03:00
|
|
|
hsr_for_each_port(master->hsr, port) {
|
2019-04-05 20:31:25 +03:00
|
|
|
if (port->type != HSR_PT_MASTER && is_slave_up(port->dev)) {
|
2020-02-28 21:01:56 +03:00
|
|
|
netif_carrier_on(master->dev);
|
|
|
|
return true;
|
2014-07-05 01:38:05 +04:00
|
|
|
}
|
2020-02-28 21:01:56 +03:00
|
|
|
}
|
2014-07-05 01:36:40 +04:00
|
|
|
|
2020-02-28 21:01:56 +03:00
|
|
|
netif_carrier_off(master->dev);
|
2014-07-05 01:36:40 +04:00
|
|
|
|
2020-02-28 21:01:56 +03:00
|
|
|
return false;
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
|
|
|
|
2014-07-05 01:36:40 +04:00
|
|
|
static void hsr_check_announce(struct net_device *hsr_dev,
|
|
|
|
unsigned char old_operstate)
|
2013-10-31 00:10:47 +04:00
|
|
|
{
|
2014-07-05 01:34:38 +04:00
|
|
|
struct hsr_priv *hsr;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2014-07-05 01:34:38 +04:00
|
|
|
hsr = netdev_priv(hsr_dev);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2019-04-05 20:31:25 +03:00
|
|
|
if (hsr_dev->operstate == IF_OPER_UP && old_operstate != IF_OPER_UP) {
|
2013-10-31 00:10:47 +04:00
|
|
|
/* Went up */
|
2014-07-05 01:34:38 +04:00
|
|
|
hsr->announce_count = 0;
|
2019-03-07 20:36:33 +03:00
|
|
|
mod_timer(&hsr->announce_timer,
|
|
|
|
jiffies + msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL));
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
|
|
|
|
2019-04-05 20:31:25 +03:00
|
|
|
if (hsr_dev->operstate != IF_OPER_UP && old_operstate == IF_OPER_UP)
|
2013-10-31 00:10:47 +04:00
|
|
|
/* Went down */
|
2014-07-05 01:34:38 +04:00
|
|
|
del_timer(&hsr->announce_timer);
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
|
|
|
|
2014-07-05 01:36:40 +04:00
|
|
|
void hsr_check_carrier_and_operstate(struct hsr_priv *hsr)
|
|
|
|
{
|
2014-07-05 01:38:05 +04:00
|
|
|
struct hsr_port *master;
|
2014-07-05 01:36:40 +04:00
|
|
|
unsigned char old_operstate;
|
|
|
|
bool has_carrier;
|
|
|
|
|
2014-07-05 01:38:05 +04:00
|
|
|
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
|
2014-07-05 01:36:40 +04:00
|
|
|
/* netif_stacked_transfer_operstate() cannot be used here since
|
|
|
|
* it doesn't set IF_OPER_LOWERLAYERDOWN (?)
|
|
|
|
*/
|
2014-07-05 01:38:05 +04:00
|
|
|
old_operstate = master->dev->operstate;
|
|
|
|
has_carrier = hsr_check_carrier(master);
|
|
|
|
hsr_set_operstate(master, has_carrier);
|
|
|
|
hsr_check_announce(master->dev, old_operstate);
|
2014-07-05 01:36:40 +04:00
|
|
|
}
|
|
|
|
|
2014-07-05 01:34:38 +04:00
|
|
|
int hsr_get_max_mtu(struct hsr_priv *hsr)
|
2013-10-31 00:10:47 +04:00
|
|
|
{
|
2014-07-05 01:37:27 +04:00
|
|
|
unsigned int mtu_max;
|
2014-07-05 01:38:05 +04:00
|
|
|
struct hsr_port *port;
|
2014-07-05 01:37:27 +04:00
|
|
|
|
|
|
|
mtu_max = ETH_DATA_LEN;
|
2014-07-05 01:38:05 +04:00
|
|
|
hsr_for_each_port(hsr, port)
|
|
|
|
if (port->type != HSR_PT_MASTER)
|
|
|
|
mtu_max = min(port->dev->mtu, mtu_max);
|
2014-07-05 01:37:27 +04:00
|
|
|
|
|
|
|
if (mtu_max < HSR_HLEN)
|
|
|
|
return 0;
|
2014-07-05 01:34:38 +04:00
|
|
|
return mtu_max - HSR_HLEN;
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
{
|
2014-07-05 01:34:38 +04:00
|
|
|
struct hsr_priv *hsr;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2014-07-05 01:34:38 +04:00
|
|
|
hsr = netdev_priv(dev);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2014-07-05 01:34:38 +04:00
|
|
|
if (new_mtu > hsr_get_max_mtu(hsr)) {
|
2020-04-24 15:43:09 +03:00
|
|
|
netdev_info(dev, "A HSR master's MTU cannot be greater than the smallest MTU of its slaves minus the HSR Tag length (%d octets).\n",
|
2014-07-05 01:34:38 +04:00
|
|
|
HSR_HLEN);
|
2013-10-31 00:10:47 +04:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->mtu = new_mtu;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hsr_dev_open(struct net_device *dev)
|
|
|
|
{
|
2014-07-05 01:34:38 +04:00
|
|
|
struct hsr_priv *hsr;
|
2014-07-05 01:38:05 +04:00
|
|
|
struct hsr_port *port;
|
|
|
|
char designation;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2014-07-05 01:34:38 +04:00
|
|
|
hsr = netdev_priv(dev);
|
2014-07-05 01:38:05 +04:00
|
|
|
designation = '\0';
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2014-07-05 01:38:05 +04:00
|
|
|
hsr_for_each_port(hsr, port) {
|
|
|
|
if (port->type == HSR_PT_MASTER)
|
|
|
|
continue;
|
|
|
|
switch (port->type) {
|
|
|
|
case HSR_PT_SLAVE_A:
|
|
|
|
designation = 'A';
|
|
|
|
break;
|
|
|
|
case HSR_PT_SLAVE_B:
|
|
|
|
designation = 'B';
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
designation = '?';
|
|
|
|
}
|
|
|
|
if (!is_slave_up(port->dev))
|
|
|
|
netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a fully working HSR network\n",
|
|
|
|
designation, port->dev->name);
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
2014-07-05 01:38:05 +04:00
|
|
|
|
|
|
|
if (designation == '\0')
|
|
|
|
netdev_warn(dev, "No slave devices configured\n");
|
2013-10-31 00:10:47 +04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hsr_dev_close(struct net_device *dev)
|
|
|
|
{
|
2014-07-05 01:38:05 +04:00
|
|
|
/* Nothing to do here. */
|
2013-10-31 00:10:47 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-05 01:38:57 +04:00
|
|
|
static netdev_features_t hsr_features_recompute(struct hsr_priv *hsr,
|
|
|
|
netdev_features_t features)
|
|
|
|
{
|
|
|
|
netdev_features_t mask;
|
|
|
|
struct hsr_port *port;
|
|
|
|
|
|
|
|
mask = features;
|
|
|
|
|
|
|
|
/* Mask out all features that, if supported by one device, should be
|
|
|
|
* enabled for all devices (see NETIF_F_ONE_FOR_ALL).
|
|
|
|
*
|
|
|
|
* Anything that's off in mask will not be enabled - so only things
|
|
|
|
* that were in features originally, and also is in NETIF_F_ONE_FOR_ALL,
|
|
|
|
* may become enabled.
|
|
|
|
*/
|
|
|
|
features &= ~NETIF_F_ONE_FOR_ALL;
|
|
|
|
hsr_for_each_port(hsr, port)
|
|
|
|
features = netdev_increment_features(features,
|
|
|
|
port->dev->features,
|
|
|
|
mask);
|
|
|
|
|
|
|
|
return features;
|
|
|
|
}
|
|
|
|
|
|
|
|
static netdev_features_t hsr_fix_features(struct net_device *dev,
|
|
|
|
netdev_features_t features)
|
|
|
|
{
|
|
|
|
struct hsr_priv *hsr = netdev_priv(dev);
|
|
|
|
|
|
|
|
return hsr_features_recompute(hsr, features);
|
|
|
|
}
|
|
|
|
|
2020-06-28 22:53:35 +03:00
|
|
|
static netdev_tx_t hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev)
|
2013-10-31 00:10:47 +04:00
|
|
|
{
|
2014-07-05 01:41:03 +04:00
|
|
|
struct hsr_priv *hsr = netdev_priv(dev);
|
2014-07-05 01:38:05 +04:00
|
|
|
struct hsr_port *master;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2014-07-05 01:38:05 +04:00
|
|
|
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
|
2019-12-05 10:23:39 +03:00
|
|
|
if (master) {
|
|
|
|
skb->dev = master->dev;
|
2021-04-06 10:35:09 +03:00
|
|
|
skb_reset_mac_header(skb);
|
2021-05-24 21:50:54 +03:00
|
|
|
skb_reset_mac_len(skb);
|
2019-12-05 10:23:39 +03:00
|
|
|
hsr_forward_skb(skb, master);
|
|
|
|
} else {
|
|
|
|
atomic_long_inc(&dev->tx_dropped);
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
}
|
2013-10-31 00:10:47 +04:00
|
|
|
return NETDEV_TX_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct header_ops hsr_header_ops = {
|
2014-07-05 01:41:03 +04:00
|
|
|
.create = eth_header,
|
2013-10-31 00:10:47 +04:00
|
|
|
.parse = eth_header_parse,
|
|
|
|
};
|
|
|
|
|
2021-02-10 04:02:10 +03:00
|
|
|
static struct sk_buff *hsr_init_skb(struct hsr_port *master)
|
2013-10-31 00:10:47 +04:00
|
|
|
{
|
2020-07-22 17:40:17 +03:00
|
|
|
struct hsr_priv *hsr = master->hsr;
|
2013-10-31 00:10:47 +04:00
|
|
|
struct sk_buff *skb;
|
|
|
|
int hlen, tlen;
|
|
|
|
|
2014-07-05 01:38:05 +04:00
|
|
|
hlen = LL_RESERVED_SPACE(master->dev);
|
|
|
|
tlen = master->dev->needed_tailroom;
|
2020-07-22 17:40:19 +03:00
|
|
|
/* skb size is same for PRP/HSR frames, only difference
|
|
|
|
* being, for PRP it is a trailer and for HSR it is a
|
|
|
|
* header
|
|
|
|
*/
|
2021-02-10 04:02:10 +03:00
|
|
|
skb = dev_alloc_skb(sizeof(struct hsr_sup_tag) +
|
2019-04-05 20:31:27 +03:00
|
|
|
sizeof(struct hsr_sup_payload) + hlen + tlen);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2019-04-05 20:31:28 +03:00
|
|
|
if (!skb)
|
2020-07-22 17:40:17 +03:00
|
|
|
return skb;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
|
|
|
skb_reserve(skb, hlen);
|
2014-07-05 01:38:05 +04:00
|
|
|
skb->dev = master->dev;
|
2013-10-31 00:10:47 +04:00
|
|
|
skb->priority = TC_PRIO_CONTROL;
|
|
|
|
|
2021-02-10 04:02:10 +03:00
|
|
|
if (dev_hard_header(skb, skb->dev, ETH_P_PRP,
|
2020-07-22 17:40:17 +03:00
|
|
|
hsr->sup_multicast_addr,
|
2014-07-05 01:41:03 +04:00
|
|
|
skb->dev->dev_addr, skb->len) <= 0)
|
2013-10-31 00:10:47 +04:00
|
|
|
goto out;
|
2020-07-22 17:40:17 +03:00
|
|
|
|
2014-07-05 01:41:03 +04:00
|
|
|
skb_reset_mac_header(skb);
|
2021-05-24 21:50:54 +03:00
|
|
|
skb_reset_mac_len(skb);
|
2019-12-22 14:27:08 +03:00
|
|
|
skb_reset_network_header(skb);
|
|
|
|
skb_reset_transport_header(skb);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2020-07-22 17:40:17 +03:00
|
|
|
return skb;
|
|
|
|
out:
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void send_hsr_supervision_frame(struct hsr_port *master,
|
2020-07-22 17:40:18 +03:00
|
|
|
unsigned long *interval)
|
2020-07-22 17:40:17 +03:00
|
|
|
{
|
2020-07-22 17:40:18 +03:00
|
|
|
struct hsr_priv *hsr = master->hsr;
|
|
|
|
__u8 type = HSR_TLV_LIFE_CHECK;
|
2020-07-22 17:40:17 +03:00
|
|
|
struct hsr_sup_payload *hsr_sp;
|
|
|
|
struct hsr_sup_tag *hsr_stag;
|
|
|
|
unsigned long irqflags;
|
|
|
|
struct sk_buff *skb;
|
2020-07-22 17:40:18 +03:00
|
|
|
|
|
|
|
*interval = msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL);
|
|
|
|
if (hsr->announce_count < 3 && hsr->prot_version == 0) {
|
|
|
|
type = HSR_TLV_ANNOUNCE;
|
|
|
|
*interval = msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL);
|
|
|
|
hsr->announce_count++;
|
|
|
|
}
|
|
|
|
|
2021-02-10 04:02:10 +03:00
|
|
|
skb = hsr_init_skb(master);
|
2020-07-22 17:40:17 +03:00
|
|
|
if (!skb) {
|
|
|
|
WARN_ONCE(1, "HSR: Could not send supervision frame\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-06-18 17:52:04 +03:00
|
|
|
hsr_stag = skb_put(skb, sizeof(struct hsr_sup_tag));
|
2020-07-22 17:40:18 +03:00
|
|
|
set_hsr_stag_path(hsr_stag, (hsr->prot_version ? 0x0 : 0xf));
|
|
|
|
set_hsr_stag_HSR_ver(hsr_stag, hsr->prot_version);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2016-04-13 14:52:22 +03:00
|
|
|
/* From HSRv1 on we have separate supervision sequence numbers. */
|
2014-07-05 01:41:03 +04:00
|
|
|
spin_lock_irqsave(&master->hsr->seqnr_lock, irqflags);
|
2020-07-22 17:40:18 +03:00
|
|
|
if (hsr->prot_version > 0) {
|
|
|
|
hsr_stag->sequence_nr = htons(hsr->sup_sequence_nr);
|
|
|
|
hsr->sup_sequence_nr++;
|
2016-04-13 14:52:22 +03:00
|
|
|
} else {
|
2020-07-22 17:40:18 +03:00
|
|
|
hsr_stag->sequence_nr = htons(hsr->sequence_nr);
|
|
|
|
hsr->sequence_nr++;
|
2016-04-13 14:52:22 +03:00
|
|
|
}
|
2014-07-05 01:41:03 +04:00
|
|
|
spin_unlock_irqrestore(&master->hsr->seqnr_lock, irqflags);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2021-10-25 21:56:18 +03:00
|
|
|
hsr_stag->tlv.HSR_TLV_type = type;
|
2016-04-13 14:52:22 +03:00
|
|
|
/* TODO: Why 12 in HSRv0? */
|
2021-10-25 21:56:18 +03:00
|
|
|
hsr_stag->tlv.HSR_TLV_length = hsr->prot_version ?
|
2020-07-22 17:40:18 +03:00
|
|
|
sizeof(struct hsr_sup_payload) : 12;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
|
|
|
/* Payload: MacAddressA */
|
2017-06-18 17:52:04 +03:00
|
|
|
hsr_sp = skb_put(skb, sizeof(struct hsr_sup_payload));
|
2019-04-05 20:31:32 +03:00
|
|
|
ether_addr_copy(hsr_sp->macaddress_A, master->dev->dev_addr);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2021-02-10 04:02:10 +03:00
|
|
|
if (skb_put_padto(skb, ETH_ZLEN))
|
2017-08-21 22:59:10 +03:00
|
|
|
return;
|
2016-04-13 14:52:22 +03:00
|
|
|
|
2014-07-05 01:41:03 +04:00
|
|
|
hsr_forward_skb(skb, master);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2020-07-22 17:40:17 +03:00
|
|
|
return;
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
|
|
|
|
2020-07-22 17:40:19 +03:00
|
|
|
static void send_prp_supervision_frame(struct hsr_port *master,
|
|
|
|
unsigned long *interval)
|
|
|
|
{
|
|
|
|
struct hsr_priv *hsr = master->hsr;
|
|
|
|
struct hsr_sup_payload *hsr_sp;
|
|
|
|
struct hsr_sup_tag *hsr_stag;
|
|
|
|
unsigned long irqflags;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2021-02-10 04:02:10 +03:00
|
|
|
skb = hsr_init_skb(master);
|
2020-07-22 17:40:19 +03:00
|
|
|
if (!skb) {
|
|
|
|
WARN_ONCE(1, "PRP: Could not send supervision frame\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*interval = msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL);
|
|
|
|
hsr_stag = skb_put(skb, sizeof(struct hsr_sup_tag));
|
|
|
|
set_hsr_stag_path(hsr_stag, (hsr->prot_version ? 0x0 : 0xf));
|
|
|
|
set_hsr_stag_HSR_ver(hsr_stag, (hsr->prot_version ? 1 : 0));
|
|
|
|
|
|
|
|
/* From HSRv1 on we have separate supervision sequence numbers. */
|
|
|
|
spin_lock_irqsave(&master->hsr->seqnr_lock, irqflags);
|
|
|
|
hsr_stag->sequence_nr = htons(hsr->sup_sequence_nr);
|
|
|
|
hsr->sup_sequence_nr++;
|
2021-10-25 21:56:18 +03:00
|
|
|
hsr_stag->tlv.HSR_TLV_type = PRP_TLV_LIFE_CHECK_DD;
|
|
|
|
hsr_stag->tlv.HSR_TLV_length = sizeof(struct hsr_sup_payload);
|
2020-07-22 17:40:19 +03:00
|
|
|
|
|
|
|
/* Payload: MacAddressA */
|
|
|
|
hsr_sp = skb_put(skb, sizeof(struct hsr_sup_payload));
|
|
|
|
ether_addr_copy(hsr_sp->macaddress_A, master->dev->dev_addr);
|
|
|
|
|
2021-02-10 04:02:10 +03:00
|
|
|
if (skb_put_padto(skb, ETH_ZLEN)) {
|
2020-07-22 17:40:19 +03:00
|
|
|
spin_unlock_irqrestore(&master->hsr->seqnr_lock, irqflags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&master->hsr->seqnr_lock, irqflags);
|
|
|
|
|
|
|
|
hsr_forward_skb(skb, master);
|
|
|
|
}
|
|
|
|
|
2013-10-31 00:10:47 +04:00
|
|
|
/* Announce (supervision frame) timer function
|
|
|
|
*/
|
2017-10-24 11:46:16 +03:00
|
|
|
static void hsr_announce(struct timer_list *t)
|
2013-10-31 00:10:47 +04:00
|
|
|
{
|
2014-07-05 01:34:38 +04:00
|
|
|
struct hsr_priv *hsr;
|
2014-07-05 01:38:05 +04:00
|
|
|
struct hsr_port *master;
|
2019-03-07 20:36:33 +03:00
|
|
|
unsigned long interval;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2017-10-24 11:46:16 +03:00
|
|
|
hsr = from_timer(hsr, t, announce_timer);
|
2014-07-05 01:41:03 +04:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2014-07-05 01:38:05 +04:00
|
|
|
master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
|
2020-07-22 17:40:18 +03:00
|
|
|
hsr->proto_ops->send_sv_frame(master, &interval);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2014-07-05 01:38:05 +04:00
|
|
|
if (is_admin_up(master->dev))
|
2019-03-07 20:36:33 +03:00
|
|
|
mod_timer(&hsr->announce_timer, jiffies + interval);
|
2014-07-05 01:41:03 +04:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
|
|
|
|
2020-06-21 16:46:25 +03:00
|
|
|
void hsr_del_ports(struct hsr_priv *hsr)
|
2020-02-28 21:02:10 +03:00
|
|
|
{
|
|
|
|
struct hsr_port *port;
|
|
|
|
|
|
|
|
port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
|
|
|
|
if (port)
|
|
|
|
hsr_del_port(port);
|
|
|
|
|
|
|
|
port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
|
|
|
|
if (port)
|
|
|
|
hsr_del_port(port);
|
|
|
|
|
|
|
|
port = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
|
|
|
|
if (port)
|
|
|
|
hsr_del_port(port);
|
|
|
|
}
|
|
|
|
|
2013-10-31 00:10:47 +04:00
|
|
|
static const struct net_device_ops hsr_device_ops = {
|
|
|
|
.ndo_change_mtu = hsr_dev_change_mtu,
|
|
|
|
.ndo_open = hsr_dev_open,
|
|
|
|
.ndo_stop = hsr_dev_close,
|
|
|
|
.ndo_start_xmit = hsr_dev_xmit,
|
2014-07-05 01:38:57 +04:00
|
|
|
.ndo_fix_features = hsr_fix_features,
|
2013-10-31 00:10:47 +04:00
|
|
|
};
|
|
|
|
|
2014-07-05 01:39:42 +04:00
|
|
|
static struct device_type hsr_type = {
|
|
|
|
.name = "hsr",
|
|
|
|
};
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2020-07-22 17:40:18 +03:00
|
|
|
static struct hsr_proto_ops hsr_ops = {
|
|
|
|
.send_sv_frame = send_hsr_supervision_frame,
|
2020-07-22 17:40:20 +03:00
|
|
|
.create_tagged_frame = hsr_create_tagged_frame,
|
|
|
|
.get_untagged_frame = hsr_get_untagged_frame,
|
2021-02-10 04:02:11 +03:00
|
|
|
.drop_frame = hsr_drop_frame,
|
2020-07-22 17:40:20 +03:00
|
|
|
.fill_frame_info = hsr_fill_frame_info,
|
2020-07-22 17:40:21 +03:00
|
|
|
.invalid_dan_ingress_frame = hsr_invalid_dan_ingress_frame,
|
2020-07-22 17:40:18 +03:00
|
|
|
};
|
|
|
|
|
2020-07-22 17:40:20 +03:00
|
|
|
static struct hsr_proto_ops prp_ops = {
|
2020-07-22 17:40:19 +03:00
|
|
|
.send_sv_frame = send_prp_supervision_frame,
|
2020-07-22 17:40:21 +03:00
|
|
|
.create_tagged_frame = prp_create_tagged_frame,
|
|
|
|
.get_untagged_frame = prp_get_untagged_frame,
|
|
|
|
.drop_frame = prp_drop_frame,
|
|
|
|
.fill_frame_info = prp_fill_frame_info,
|
|
|
|
.handle_san_frame = prp_handle_san_frame,
|
|
|
|
.update_san_info = prp_update_san_info,
|
2020-07-22 17:40:19 +03:00
|
|
|
};
|
|
|
|
|
2013-10-31 00:10:47 +04:00
|
|
|
void hsr_dev_setup(struct net_device *dev)
|
|
|
|
{
|
2017-02-21 16:04:59 +03:00
|
|
|
eth_hw_addr_random(dev);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
|
|
|
ether_setup(dev);
|
net: use core MTU range checking in misc drivers
firewire-net:
- set min/max_mtu
- remove fwnet_change_mtu
nes:
- set max_mtu
- clean up nes_netdev_change_mtu
xpnet:
- set min/max_mtu
- remove xpnet_dev_change_mtu
hippi:
- set min/max_mtu
- remove hippi_change_mtu
batman-adv:
- set max_mtu
- remove batadv_interface_change_mtu
- initialization is a little async, not 100% certain that max_mtu is set
in the optimal place, don't have hardware to test with
rionet:
- set min/max_mtu
- remove rionet_change_mtu
slip:
- set min/max_mtu
- streamline sl_change_mtu
um/net_kern:
- remove pointless ndo_change_mtu
hsi/clients/ssi_protocol:
- use core MTU range checking
- remove now redundant ssip_pn_set_mtu
ipoib:
- set a default max MTU value
- Note: ipoib's actual max MTU can vary, depending on if the device is in
connected mode or not, so we'll just set the max_mtu value to the max
possible, and let the ndo_change_mtu function continue to validate any new
MTU change requests with checks for CM or not. Note that ipoib has no
min_mtu set, and thus, the network core's mtu > 0 check is the only lower
bounds here.
mptlan:
- use net core MTU range checking
- remove now redundant mpt_lan_change_mtu
fddi:
- min_mtu = 21, max_mtu = 4470
- remove now redundant fddi_change_mtu (including export)
fjes:
- min_mtu = 8192, max_mtu = 65536
- The max_mtu value is actually one over IP_MAX_MTU here, but the idea is to
get past the core net MTU range checks so fjes_change_mtu can validate a
new MTU against what it supports (see fjes_support_mtu in fjes_hw.c)
hsr:
- min_mtu = 0 (calls ether_setup, max_mtu is 1500)
f_phonet:
- min_mtu = 6, max_mtu = 65541
u_ether:
- min_mtu = 14, max_mtu = 15412
phonet/pep-gprs:
- min_mtu = 576, max_mtu = 65530
- remove redundant gprs_set_mtu
CC: netdev@vger.kernel.org
CC: linux-rdma@vger.kernel.org
CC: Stefan Richter <stefanr@s5r6.in-berlin.de>
CC: Faisal Latif <faisal.latif@intel.com>
CC: linux-rdma@vger.kernel.org
CC: Cliff Whickman <cpw@sgi.com>
CC: Robin Holt <robinmholt@gmail.com>
CC: Jes Sorensen <jes@trained-monkey.org>
CC: Marek Lindner <mareklindner@neomailbox.ch>
CC: Simon Wunderlich <sw@simonwunderlich.de>
CC: Antonio Quartulli <a@unstable.cc>
CC: Sathya Prakash <sathya.prakash@broadcom.com>
CC: Chaitra P B <chaitra.basappa@broadcom.com>
CC: Suganath Prabu Subramani <suganath-prabu.subramani@broadcom.com>
CC: MPT-FusionLinux.pdl@broadcom.com
CC: Sebastian Reichel <sre@kernel.org>
CC: Felipe Balbi <balbi@kernel.org>
CC: Arvid Brodin <arvid.brodin@alten.se>
CC: Remi Denis-Courmont <courmisch@gmail.com>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-20 20:55:22 +03:00
|
|
|
dev->min_mtu = 0;
|
2014-07-05 01:39:42 +04:00
|
|
|
dev->header_ops = &hsr_header_ops;
|
|
|
|
dev->netdev_ops = &hsr_device_ops;
|
|
|
|
SET_NETDEV_DEVTYPE(dev, &hsr_type);
|
2015-08-18 11:30:45 +03:00
|
|
|
dev->priv_flags |= IFF_NO_QUEUE;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-08 19:52:56 +03:00
|
|
|
dev->needs_free_netdev = true;
|
2014-07-05 01:38:57 +04:00
|
|
|
|
|
|
|
dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA |
|
|
|
|
NETIF_F_GSO_MASK | NETIF_F_HW_CSUM |
|
|
|
|
NETIF_F_HW_VLAN_CTAG_TX;
|
|
|
|
|
|
|
|
dev->features = dev->hw_features;
|
|
|
|
|
|
|
|
/* Prevent recursive tx locking */
|
|
|
|
dev->features |= NETIF_F_LLTX;
|
|
|
|
/* VLAN on top of HSR needs testing and probably some work on
|
|
|
|
* hsr_header_create() etc.
|
|
|
|
*/
|
|
|
|
dev->features |= NETIF_F_VLAN_CHALLENGED;
|
2014-07-05 01:39:42 +04:00
|
|
|
/* Not sure about this. Taken from bridge code. netdev_features.h says
|
|
|
|
* it means "Does not change network namespaces".
|
|
|
|
*/
|
|
|
|
dev->features |= NETIF_F_NETNS_LOCAL;
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Return true if dev is a HSR master; return false otherwise.
|
|
|
|
*/
|
2021-02-10 04:02:11 +03:00
|
|
|
bool is_hsr_master(struct net_device *dev)
|
2013-10-31 00:10:47 +04:00
|
|
|
{
|
|
|
|
return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit);
|
|
|
|
}
|
2021-02-10 04:02:11 +03:00
|
|
|
EXPORT_SYMBOL(is_hsr_master);
|
2013-10-31 00:10:47 +04:00
|
|
|
|
|
|
|
/* Default multicast address for HSR Supervision frames */
|
2014-02-18 22:37:20 +04:00
|
|
|
static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = {
|
2013-10-31 00:10:47 +04:00
|
|
|
0x01, 0x15, 0x4e, 0x00, 0x01, 0x00
|
|
|
|
};
|
|
|
|
|
|
|
|
int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
|
2020-02-28 21:01:35 +03:00
|
|
|
unsigned char multicast_spec, u8 protocol_version,
|
|
|
|
struct netlink_ext_ack *extack)
|
2013-10-31 00:10:47 +04:00
|
|
|
{
|
2020-07-02 20:06:19 +03:00
|
|
|
bool unregister = false;
|
2014-07-05 01:34:38 +04:00
|
|
|
struct hsr_priv *hsr;
|
2013-10-31 00:10:47 +04:00
|
|
|
int res;
|
|
|
|
|
2014-07-05 01:34:38 +04:00
|
|
|
hsr = netdev_priv(hsr_dev);
|
2014-07-05 01:38:05 +04:00
|
|
|
INIT_LIST_HEAD(&hsr->ports);
|
2014-07-05 01:34:38 +04:00
|
|
|
INIT_LIST_HEAD(&hsr->node_db);
|
|
|
|
INIT_LIST_HEAD(&hsr->self_node_db);
|
2019-12-22 14:26:54 +03:00
|
|
|
spin_lock_init(&hsr->list_lock);
|
2014-07-05 01:37:27 +04:00
|
|
|
|
2021-10-02 00:32:22 +03:00
|
|
|
eth_hw_addr_set(hsr_dev, slave[0]->dev_addr);
|
2014-07-05 01:37:27 +04:00
|
|
|
|
2020-07-22 17:40:19 +03:00
|
|
|
/* initialize protocol specific functions */
|
2020-07-22 17:40:21 +03:00
|
|
|
if (protocol_version == PRP_V1) {
|
|
|
|
/* For PRP, lan_id has most significant 3 bits holding
|
|
|
|
* the net_id of PRP_LAN_ID
|
|
|
|
*/
|
|
|
|
hsr->net_id = PRP_LAN_ID << 1;
|
2020-07-22 17:40:19 +03:00
|
|
|
hsr->proto_ops = &prp_ops;
|
2020-07-22 17:40:21 +03:00
|
|
|
} else {
|
2020-07-22 17:40:19 +03:00
|
|
|
hsr->proto_ops = &hsr_ops;
|
2020-07-22 17:40:21 +03:00
|
|
|
}
|
2020-07-22 17:40:19 +03:00
|
|
|
|
2014-07-05 01:37:27 +04:00
|
|
|
/* Make sure we recognize frames from ourselves in hsr_rcv() */
|
2019-12-22 14:26:54 +03:00
|
|
|
res = hsr_create_self_node(hsr, hsr_dev->dev_addr,
|
2014-07-05 01:37:27 +04:00
|
|
|
slave[1]->dev_addr);
|
|
|
|
if (res < 0)
|
|
|
|
return res;
|
|
|
|
|
2014-07-05 01:34:38 +04:00
|
|
|
spin_lock_init(&hsr->seqnr_lock);
|
2013-10-31 00:10:47 +04:00
|
|
|
/* Overflow soon to find bugs easier: */
|
2014-07-05 01:41:03 +04:00
|
|
|
hsr->sequence_nr = HSR_SEQNR_START;
|
2016-04-13 14:52:22 +03:00
|
|
|
hsr->sup_sequence_nr = HSR_SUP_SEQNR_START;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2017-10-24 11:46:16 +03:00
|
|
|
timer_setup(&hsr->announce_timer, hsr_announce, 0);
|
|
|
|
timer_setup(&hsr->prune_timer, hsr_prune_nodes, 0);
|
2014-07-05 01:35:47 +04:00
|
|
|
|
2014-07-05 01:34:38 +04:00
|
|
|
ether_addr_copy(hsr->sup_multicast_addr, def_multicast_addr);
|
|
|
|
hsr->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2019-04-05 20:31:32 +03:00
|
|
|
hsr->prot_version = protocol_version;
|
2016-04-13 14:52:22 +03:00
|
|
|
|
2013-10-31 00:10:47 +04:00
|
|
|
/* Make sure the 1st call to netif_carrier_on() gets through */
|
|
|
|
netif_carrier_off(hsr_dev);
|
|
|
|
|
2020-02-28 21:01:35 +03:00
|
|
|
res = hsr_add_port(hsr, hsr_dev, HSR_PT_MASTER, extack);
|
2013-10-31 00:10:47 +04:00
|
|
|
if (res)
|
2019-12-22 14:26:15 +03:00
|
|
|
goto err_add_master;
|
2014-07-05 01:37:27 +04:00
|
|
|
|
2014-07-05 01:38:05 +04:00
|
|
|
res = register_netdevice(hsr_dev);
|
2014-07-05 01:37:27 +04:00
|
|
|
if (res)
|
2019-12-22 14:26:15 +03:00
|
|
|
goto err_unregister;
|
2014-07-05 01:38:05 +04:00
|
|
|
|
2020-07-02 20:06:19 +03:00
|
|
|
unregister = true;
|
|
|
|
|
2020-02-28 21:01:35 +03:00
|
|
|
res = hsr_add_port(hsr, slave[0], HSR_PT_SLAVE_A, extack);
|
2014-07-05 01:38:05 +04:00
|
|
|
if (res)
|
2020-07-02 20:06:19 +03:00
|
|
|
goto err_unregister;
|
2019-12-22 14:26:15 +03:00
|
|
|
|
2020-02-28 21:01:35 +03:00
|
|
|
res = hsr_add_port(hsr, slave[1], HSR_PT_SLAVE_B, extack);
|
2014-07-05 01:38:05 +04:00
|
|
|
if (res)
|
2020-07-02 20:06:19 +03:00
|
|
|
goto err_unregister;
|
2013-10-31 00:10:47 +04:00
|
|
|
|
2019-12-22 14:26:15 +03:00
|
|
|
hsr_debugfs_init(hsr, hsr_dev);
|
2016-05-15 17:07:44 +03:00
|
|
|
mod_timer(&hsr->prune_timer, jiffies + msecs_to_jiffies(PRUNE_PERIOD));
|
2014-07-05 01:35:47 +04:00
|
|
|
|
2013-10-31 00:10:47 +04:00
|
|
|
return 0;
|
2014-07-05 01:38:05 +04:00
|
|
|
|
2019-12-22 14:26:15 +03:00
|
|
|
err_unregister:
|
2020-02-28 21:02:10 +03:00
|
|
|
hsr_del_ports(hsr);
|
2019-12-22 14:26:15 +03:00
|
|
|
err_add_master:
|
2019-12-22 14:26:54 +03:00
|
|
|
hsr_del_self_node(hsr);
|
2014-07-05 01:38:05 +04:00
|
|
|
|
2020-07-02 20:06:19 +03:00
|
|
|
if (unregister)
|
|
|
|
unregister_netdevice(hsr_dev);
|
2014-07-05 01:38:05 +04:00
|
|
|
return res;
|
2013-10-31 00:10:47 +04:00
|
|
|
}
|