korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-28 22:54:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

net: hsr: use hlist_head instead of list_head for mac addresses

Browse Source 
Currently, HSR manages mac addresses of known HSR nodes by using list_head.
It takes a lot of time when there are a lot of registered nodes due to
finding specific mac address nodes by using linear search. We can be
reducing the time by using hlist. Thus, this patch moves list_head to
hlist_head for mac addresses and this allows for further improvement of
network performance.

    Condition: registered 10,000 known HSR nodes
    Before:
    # iperf3 -c 192.168.10.1 -i 1 -t 10
    Connecting to host 192.168.10.1, port 5201
    [  5] local 192.168.10.2 port 59442 connected to 192.168.10.1 port 5201
    [ ID] Interval           Transfer     Bitrate         Retr  Cwnd
    [  5]   0.00-1.49   sec  3.75 MBytes  21.1 Mbits/sec    0    158 KBytes
    [  5]   1.49-2.05   sec  1.25 MBytes  18.7 Mbits/sec    0    166 KBytes
    [  5]   2.05-3.06   sec  2.44 MBytes  20.3 Mbits/sec   56   16.9 KBytes
    [  5]   3.06-4.08   sec  1.43 MBytes  11.7 Mbits/sec   11   38.0 KBytes
    [  5]   4.08-5.00   sec   951 KBytes  8.49 Mbits/sec    0   56.3 KBytes

    After:
    # iperf3 -c 192.168.10.1 -i 1 -t 10
    Connecting to host 192.168.10.1, port 5201
    [  5] local 192.168.10.2 port 36460 connected to 192.168.10.1 port 5201
    [ ID] Interval           Transfer     Bitrate         Retr  Cwnd
    [  5]   0.00-1.00   sec  7.39 MBytes  62.0 Mbits/sec    3    130 KBytes
    [  5]   1.00-2.00   sec  5.06 MBytes  42.4 Mbits/sec   16    113 KBytes
    [  5]   2.00-3.00   sec  8.58 MBytes  72.0 Mbits/sec   42   94.3 KBytes
    [  5]   3.00-4.00   sec  7.44 MBytes  62.4 Mbits/sec    2    131 KBytes
    [  5]   4.00-5.07   sec  8.13 MBytes  63.5 Mbits/sec   38   92.9 KBytes

Signed-off-by: Juhee Kang <claudiajkang@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Juhee Kang 2022-02-05 15:40:38 +00:00 committed by David S. Miller
parent 5a8fb33e53
commit 4acc45db71
7 changed files with 166 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
net/hsr/hsr_debugfs.c
View File

@ -17,6 +17,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/debugfs.h> #include <linux/debugfs.h>
#include <linux/jhash.h>
#include "hsr_main.h" #include "hsr_main.h"
#include "hsr_framereg.h" #include "hsr_framereg.h"
@ -28,6 +29,7 @@ hsr_node_table_show(struct seq_file *sfp, void *data)
{ {
struct hsr_priv *priv = (struct hsr_priv *)sfp->private; struct hsr_priv *priv = (struct hsr_priv *)sfp->private;
struct hsr_node *node; struct hsr_node *node;
int i;
seq_printf(sfp, "Node Table entries for (%s) device\n", seq_printf(sfp, "Node Table entries for (%s) device\n",
(priv->prot_version == PRP_V1 ? "PRP" : "HSR")); (priv->prot_version == PRP_V1 ? "PRP" : "HSR"));
@ -39,22 +41,28 @@ hsr_node_table_show(struct seq_file *sfp, void *data)
seq_puts(sfp, "DAN-H\n"); seq_puts(sfp, "DAN-H\n");
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(node, &priv->node_db, mac_list) {
/* skip self node */
if (hsr_addr_is_self(priv, node->macaddress_A))
continue;
seq_printf(sfp, "%pM ", &node->macaddress_A[0]);
seq_printf(sfp, "%pM ", &node->macaddress_B[0]);
seq_printf(sfp, "%10lx, ", node->time_in[HSR_PT_SLAVE_A]);
seq_printf(sfp, "%10lx, ", node->time_in[HSR_PT_SLAVE_B]);
seq_printf(sfp, "%14x, ", node->addr_B_port);
if (priv->prot_version == PRP_V1) for (i = 0 ; i < priv->hash_buckets; i++) {
seq_printf(sfp, "%5x, %5x, %5x\n", hlist_for_each_entry_rcu(node, &priv->node_db[i], mac_list) {
node->san_a, node->san_b, /* skip self node */
(node->san_a == 0 && node->san_b == 0)); if (hsr_addr_is_self(priv, node->macaddress_A))
else continue;
seq_printf(sfp, "%5x\n", 1); seq_printf(sfp, "%pM ", &node->macaddress_A[0]);
seq_printf(sfp, "%pM ", &node->macaddress_B[0]);
seq_printf(sfp, "%10lx, ",
node->time_in[HSR_PT_SLAVE_A]);
seq_printf(sfp, "%10lx, ",
node->time_in[HSR_PT_SLAVE_B]);
seq_printf(sfp, "%14x, ", node->addr_B_port);
if (priv->prot_version == PRP_V1)
seq_printf(sfp, "%5x, %5x, %5x\n",
node->san_a, node->san_b,
(node->san_a == 0 &&
node->san_b == 0));
else
seq_printf(sfp, "%5x\n", 1);
}
} }
rcu_read_unlock(); rcu_read_unlock();
return 0; return 0;

10
net/hsr/hsr_device.c
View File

@ -485,12 +485,16 @@ int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
{ {
bool unregister = false; bool unregister = false;
struct hsr_priv *hsr; struct hsr_priv *hsr;
int res; int res, i;
hsr = netdev_priv(hsr_dev); hsr = netdev_priv(hsr_dev);
INIT_LIST_HEAD(&hsr->ports); INIT_LIST_HEAD(&hsr->ports);
INIT_LIST_HEAD(&hsr->node_db); INIT_HLIST_HEAD(&hsr->self_node_db);
INIT_LIST_HEAD(&hsr->self_node_db); hsr->hash_buckets = HSR_HSIZE;
get_random_bytes(&hsr->hash_seed, sizeof(hsr->hash_seed));
for (i = 0; i < hsr->hash_buckets; i++)
INIT_HLIST_HEAD(&hsr->node_db[i]);
spin_lock_init(&hsr->list_lock); spin_lock_init(&hsr->list_lock);
eth_hw_addr_set(hsr_dev, slave[0]->dev_addr); eth_hw_addr_set(hsr_dev, slave[0]->dev_addr);

7
net/hsr/hsr_forward.c
View File

@ -570,20 +570,23 @@ static int fill_frame_info(struct hsr_frame_info *frame,
struct ethhdr *ethhdr; struct ethhdr *ethhdr;
__be16 proto; __be16 proto;
int ret; int ret;
u32 hash;
/* Check if skb contains ethhdr */ /* Check if skb contains ethhdr */
if (skb->mac_len < sizeof(struct ethhdr)) if (skb->mac_len < sizeof(struct ethhdr))
return -EINVAL; return -EINVAL;
memset(frame, 0, sizeof(*frame)); memset(frame, 0, sizeof(*frame));
ethhdr = (struct ethhdr *)skb_mac_header(skb);
hash = hsr_mac_hash(port->hsr, ethhdr->h_source);
frame->is_supervision = is_supervision_frame(port->hsr, skb); frame->is_supervision = is_supervision_frame(port->hsr, skb);
frame->node_src = hsr_get_node(port, &hsr->node_db, skb, frame->node_src = hsr_get_node(port, &hsr->node_db[hash], skb,
frame->is_supervision, frame->is_supervision,
port->type); port->type);
if (!frame->node_src) if (!frame->node_src)
return -1; /* Unknown node and !is_supervision, or no mem */ return -1; /* Unknown node and !is_supervision, or no mem */
ethhdr = (struct ethhdr *)skb_mac_header(skb);
frame->is_vlan = false; frame->is_vlan = false;
proto = ethhdr->h_proto; proto = ethhdr->h_proto;

192
net/hsr/hsr_framereg.c
View File

@ -15,11 +15,28 @@
#include <linux/etherdevice.h> #include <linux/etherdevice.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/rculist.h> #include <linux/rculist.h>
#include <linux/jhash.h>
#include "hsr_main.h" #include "hsr_main.h"
#include "hsr_framereg.h" #include "hsr_framereg.h"
#include "hsr_netlink.h" #include "hsr_netlink.h"
/* TODO: use hash lists for mac addresses (linux/jhash.h)? */ u32 hsr_mac_hash(struct hsr_priv *hsr, const unsigned char *addr)
{
u32 hash = jhash(addr, ETH_ALEN, hsr->hash_seed);
return reciprocal_scale(hash, hsr->hash_buckets);
}
struct hsr_node *hsr_node_get_first(struct hlist_head *head)
{
struct hlist_node *first;
first = rcu_dereference(hlist_first_rcu(head));
if (first)
return hlist_entry(first, struct hsr_node, mac_list);
return NULL;
}
/* seq_nr_after(a, b) - return true if a is after (higher in sequence than) b, /* seq_nr_after(a, b) - return true if a is after (higher in sequence than) b,
* false otherwise. * false otherwise.
@ -42,8 +59,7 @@ bool hsr_addr_is_self(struct hsr_priv *hsr, unsigned char *addr)
{ {
struct hsr_node *node; struct hsr_node *node;
node = list_first_or_null_rcu(&hsr->self_node_db, struct hsr_node, node = hsr_node_get_first(&hsr->self_node_db);
mac_list);
if (!node) { if (!node) {
WARN_ONCE(1, "HSR: No self node\n"); WARN_ONCE(1, "HSR: No self node\n");
return false; return false;
@ -59,12 +75,12 @@ bool hsr_addr_is_self(struct hsr_priv *hsr, unsigned char *addr)
/* Search for mac entry. Caller must hold rcu read lock. /* Search for mac entry. Caller must hold rcu read lock.
*/ */
static struct hsr_node *find_node_by_addr_A(struct list_head *node_db, static struct hsr_node *find_node_by_addr_A(struct hlist_head *node_db,
const unsigned char addr[ETH_ALEN]) const unsigned char addr[ETH_ALEN])
{ {
struct hsr_node *node; struct hsr_node *node;
list_for_each_entry_rcu(node, node_db, mac_list) { hlist_for_each_entry_rcu(node, node_db, mac_list) {
if (ether_addr_equal(node->macaddress_A, addr)) if (ether_addr_equal(node->macaddress_A, addr))
return node; return node;
} }
@ -79,7 +95,7 @@ int hsr_create_self_node(struct hsr_priv *hsr,
const unsigned char addr_a[ETH_ALEN], const unsigned char addr_a[ETH_ALEN],
const unsigned char addr_b[ETH_ALEN]) const unsigned char addr_b[ETH_ALEN])
{ {
struct list_head *self_node_db = &hsr->self_node_db; struct hlist_head *self_node_db = &hsr->self_node_db;
struct hsr_node *node, *oldnode; struct hsr_node *node, *oldnode;
node = kmalloc(sizeof(*node), GFP_KERNEL); node = kmalloc(sizeof(*node), GFP_KERNEL);
@ -90,14 +106,13 @@ int hsr_create_self_node(struct hsr_priv *hsr,
ether_addr_copy(node->macaddress_B, addr_b); ether_addr_copy(node->macaddress_B, addr_b);
spin_lock_bh(&hsr->list_lock); spin_lock_bh(&hsr->list_lock);
oldnode = list_first_or_null_rcu(self_node_db, oldnode = hsr_node_get_first(self_node_db);
struct hsr_node, mac_list);
if (oldnode) { if (oldnode) {
list_replace_rcu(&oldnode->mac_list, &node->mac_list); hlist_replace_rcu(&oldnode->mac_list, &node->mac_list);
spin_unlock_bh(&hsr->list_lock); spin_unlock_bh(&hsr->list_lock);
kfree_rcu(oldnode, rcu_head); kfree_rcu(oldnode, rcu_head);
} else { } else {
list_add_tail_rcu(&node->mac_list, self_node_db); hlist_add_tail_rcu(&node->mac_list, self_node_db);
spin_unlock_bh(&hsr->list_lock); spin_unlock_bh(&hsr->list_lock);
} }
@ -106,25 +121,25 @@ int hsr_create_self_node(struct hsr_priv *hsr,
void hsr_del_self_node(struct hsr_priv *hsr) void hsr_del_self_node(struct hsr_priv *hsr)
{ {
struct list_head *self_node_db = &hsr->self_node_db; struct hlist_head *self_node_db = &hsr->self_node_db;
struct hsr_node *node; struct hsr_node *node;
spin_lock_bh(&hsr->list_lock); spin_lock_bh(&hsr->list_lock);
node = list_first_or_null_rcu(self_node_db, struct hsr_node, mac_list); node = hsr_node_get_first(self_node_db);
if (node) { if (node) {
list_del_rcu(&node->mac_list); hlist_del_rcu(&node->mac_list);
kfree_rcu(node, rcu_head); kfree_rcu(node, rcu_head);
} }
spin_unlock_bh(&hsr->list_lock); spin_unlock_bh(&hsr->list_lock);
} }
void hsr_del_nodes(struct list_head *node_db) void hsr_del_nodes(struct hlist_head *node_db)
{ {
struct hsr_node *node; struct hsr_node *node;
struct hsr_node *tmp; struct hlist_node *tmp;
list_for_each_entry_safe(node, tmp, node_db, mac_list) hlist_for_each_entry_safe(node, tmp, node_db, mac_list)
kfree(node); kfree_rcu(node, rcu_head);
} }
void prp_handle_san_frame(bool san, enum hsr_port_type port, void prp_handle_san_frame(bool san, enum hsr_port_type port,
@ -145,7 +160,7 @@ void prp_handle_san_frame(bool san, enum hsr_port_type port,
* originating from the newly added node. * originating from the newly added node.
*/ */
static struct hsr_node *hsr_add_node(struct hsr_priv *hsr, static struct hsr_node *hsr_add_node(struct hsr_priv *hsr,
struct list_head *node_db, struct hlist_head *node_db,
unsigned char addr[], unsigned char addr[],
u16 seq_out, bool san, u16 seq_out, bool san,
enum hsr_port_type rx_port) enum hsr_port_type rx_port)
@ -175,14 +190,14 @@ static struct hsr_node *hsr_add_node(struct hsr_priv *hsr,
hsr->proto_ops->handle_san_frame(san, rx_port, new_node); hsr->proto_ops->handle_san_frame(san, rx_port, new_node);
spin_lock_bh(&hsr->list_lock); spin_lock_bh(&hsr->list_lock);
list_for_each_entry_rcu(node, node_db, mac_list, hlist_for_each_entry_rcu(node, node_db, mac_list,
lockdep_is_held(&hsr->list_lock)) { lockdep_is_held(&hsr->list_lock)) {
if (ether_addr_equal(node->macaddress_A, addr)) if (ether_addr_equal(node->macaddress_A, addr))
goto out; goto out;
if (ether_addr_equal(node->macaddress_B, addr)) if (ether_addr_equal(node->macaddress_B, addr))
goto out; goto out;
} }
list_add_tail_rcu(&new_node->mac_list, node_db); hlist_add_tail_rcu(&new_node->mac_list, node_db);
spin_unlock_bh(&hsr->list_lock); spin_unlock_bh(&hsr->list_lock);
return new_node; return new_node;
out: out:
@ -202,7 +217,7 @@ void prp_update_san_info(struct hsr_node *node, bool is_sup)
/* Get the hsr_node from which 'skb' was sent. /* Get the hsr_node from which 'skb' was sent.
*/ */
struct hsr_node *hsr_get_node(struct hsr_port *port, struct list_head *node_db, struct hsr_node *hsr_get_node(struct hsr_port *port, struct hlist_head *node_db,
struct sk_buff *skb, bool is_sup, struct sk_buff *skb, bool is_sup,
enum hsr_port_type rx_port) enum hsr_port_type rx_port)
{ {
@ -218,7 +233,7 @@ struct hsr_node *hsr_get_node(struct hsr_port *port, struct list_head *node_db,
ethhdr = (struct ethhdr *)skb_mac_header(skb); ethhdr = (struct ethhdr *)skb_mac_header(skb);
list_for_each_entry_rcu(node, node_db, mac_list) { hlist_for_each_entry_rcu(node, node_db, mac_list) {
if (ether_addr_equal(node->macaddress_A, ethhdr->h_source)) { if (ether_addr_equal(node->macaddress_A, ethhdr->h_source)) {
if (hsr->proto_ops->update_san_info) if (hsr->proto_ops->update_san_info)
hsr->proto_ops->update_san_info(node, is_sup); hsr->proto_ops->update_san_info(node, is_sup);
@ -268,11 +283,12 @@ void hsr_handle_sup_frame(struct hsr_frame_info *frame)
struct hsr_sup_tlv *hsr_sup_tlv; struct hsr_sup_tlv *hsr_sup_tlv;
struct hsr_node *node_real; struct hsr_node *node_real;
struct sk_buff *skb = NULL; struct sk_buff *skb = NULL;
struct list_head *node_db; struct hlist_head *node_db;
struct ethhdr *ethhdr; struct ethhdr *ethhdr;
int i; int i;
unsigned int pull_size = 0; unsigned int pull_size = 0;
unsigned int total_pull_size = 0; unsigned int total_pull_size = 0;
u32 hash;
/* Here either frame->skb_hsr or frame->skb_prp should be /* Here either frame->skb_hsr or frame->skb_prp should be
* valid as supervision frame always will have protocol * valid as supervision frame always will have protocol
@ -310,11 +326,13 @@ void hsr_handle_sup_frame(struct hsr_frame_info *frame)
hsr_sp = (struct hsr_sup_payload *)skb->data; hsr_sp = (struct hsr_sup_payload *)skb->data;
/* Merge node_curr (registered on macaddress_B) into node_real */ /* Merge node_curr (registered on macaddress_B) into node_real */
node_db = &port_rcv->hsr->node_db; node_db = port_rcv->hsr->node_db;
node_real = find_node_by_addr_A(node_db, hsr_sp->macaddress_A); hash = hsr_mac_hash(hsr, hsr_sp->macaddress_A);
node_real = find_node_by_addr_A(&node_db[hash], hsr_sp->macaddress_A);
if (!node_real) if (!node_real)
/* No frame received from AddrA of this node yet */ /* No frame received from AddrA of this node yet */
node_real = hsr_add_node(hsr, node_db, hsr_sp->macaddress_A, node_real = hsr_add_node(hsr, &node_db[hash],
hsr_sp->macaddress_A,
HSR_SEQNR_START - 1, true, HSR_SEQNR_START - 1, true,
port_rcv->type); port_rcv->type);
if (!node_real) if (!node_real)
@ -348,7 +366,8 @@ void hsr_handle_sup_frame(struct hsr_frame_info *frame)
hsr_sp = (struct hsr_sup_payload *)skb->data; hsr_sp = (struct hsr_sup_payload *)skb->data;
/* Check if redbox mac and node mac are equal. */ /* Check if redbox mac and node mac are equal. */
if (!ether_addr_equal(node_real->macaddress_A, hsr_sp->macaddress_A)) { if (!ether_addr_equal(node_real->macaddress_A,
hsr_sp->macaddress_A)) {
/* This is a redbox supervision frame for a VDAN! */ /* This is a redbox supervision frame for a VDAN! */
goto done; goto done;
} }
@ -368,7 +387,7 @@ void hsr_handle_sup_frame(struct hsr_frame_info *frame)
node_real->addr_B_port = port_rcv->type; node_real->addr_B_port = port_rcv->type;
spin_lock_bh(&hsr->list_lock); spin_lock_bh(&hsr->list_lock);
list_del_rcu(&node_curr->mac_list); hlist_del_rcu(&node_curr->mac_list);
spin_unlock_bh(&hsr->list_lock); spin_unlock_bh(&hsr->list_lock);
kfree_rcu(node_curr, rcu_head); kfree_rcu(node_curr, rcu_head);
@ -406,6 +425,7 @@ void hsr_addr_subst_dest(struct hsr_node *node_src, struct sk_buff *skb,
struct hsr_port *port) struct hsr_port *port)
{ {
struct hsr_node *node_dst; struct hsr_node *node_dst;
u32 hash;
if (!skb_mac_header_was_set(skb)) { if (!skb_mac_header_was_set(skb)) {
WARN_ONCE(1, "%s: Mac header not set\n", __func__); WARN_ONCE(1, "%s: Mac header not set\n", __func__);
@ -415,7 +435,8 @@ void hsr_addr_subst_dest(struct hsr_node *node_src, struct sk_buff *skb,
if (!is_unicast_ether_addr(eth_hdr(skb)->h_dest)) if (!is_unicast_ether_addr(eth_hdr(skb)->h_dest))
return; return;
node_dst = find_node_by_addr_A(&port->hsr->node_db, hash = hsr_mac_hash(port->hsr, eth_hdr(skb)->h_dest);
node_dst = find_node_by_addr_A(&port->hsr->node_db[hash],
eth_hdr(skb)->h_dest); eth_hdr(skb)->h_dest);
if (!node_dst) { if (!node_dst) {
if (net_ratelimit()) if (net_ratelimit())
@ -491,59 +512,73 @@ static struct hsr_port *get_late_port(struct hsr_priv *hsr,
void hsr_prune_nodes(struct timer_list *t) void hsr_prune_nodes(struct timer_list *t)
{ {
struct hsr_priv *hsr = from_timer(hsr, t, prune_timer); struct hsr_priv *hsr = from_timer(hsr, t, prune_timer);
struct hlist_node *tmp;
struct hsr_node *node; struct hsr_node *node;
struct hsr_node *tmp;
struct hsr_port *port; struct hsr_port *port;
unsigned long timestamp; unsigned long timestamp;
unsigned long time_a, time_b; unsigned long time_a, time_b;
int i;
spin_lock_bh(&hsr->list_lock); spin_lock_bh(&hsr->list_lock);
list_for_each_entry_safe(node, tmp, &hsr->node_db, mac_list) {
/* Don't prune own node. Neither time_in[HSR_PT_SLAVE_A]
* nor time_in[HSR_PT_SLAVE_B], will ever be updated for
* the master port. Thus the master node will be repeatedly
* pruned leading to packet loss.
*/
if (hsr_addr_is_self(hsr, node->macaddress_A))
continue;
/* Shorthand */ for (i = 0; i < hsr->hash_buckets; i++) {
time_a = node->time_in[HSR_PT_SLAVE_A]; hlist_for_each_entry_safe(node, tmp, &hsr->node_db[i],
time_b = node->time_in[HSR_PT_SLAVE_B]; mac_list) {
/* Don't prune own node.
* Neither time_in[HSR_PT_SLAVE_A]
* nor time_in[HSR_PT_SLAVE_B], will ever be updated
* for the master port. Thus the master node will be
* repeatedly pruned leading to packet loss.
*/
if (hsr_addr_is_self(hsr, node->macaddress_A))
continue;
/* Check for timestamps old enough to risk wrap-around */ /* Shorthand */
if (time_after(jiffies, time_a + MAX_JIFFY_OFFSET / 2)) time_a = node->time_in[HSR_PT_SLAVE_A];
node->time_in_stale[HSR_PT_SLAVE_A] = true; time_b = node->time_in[HSR_PT_SLAVE_B];
if (time_after(jiffies, time_b + MAX_JIFFY_OFFSET / 2))
node->time_in_stale[HSR_PT_SLAVE_B] = true;
/* Get age of newest frame from node. /* Check for timestamps old enough to
* At least one time_in is OK here; nodes get pruned long * risk wrap-around
* before both time_ins can get stale */
*/ if (time_after(jiffies, time_a + MAX_JIFFY_OFFSET / 2))
timestamp = time_a; node->time_in_stale[HSR_PT_SLAVE_A] = true;
if (node->time_in_stale[HSR_PT_SLAVE_A] || if (time_after(jiffies, time_b + MAX_JIFFY_OFFSET / 2))
(!node->time_in_stale[HSR_PT_SLAVE_B] && node->time_in_stale[HSR_PT_SLAVE_B] = true;
time_after(time_b, time_a)))
timestamp = time_b;
/* Warn of ring error only as long as we get frames at all */ /* Get age of newest frame from node.
if (time_is_after_jiffies(timestamp + * At least one time_in is OK here; nodes get pruned
msecs_to_jiffies(1.5 * MAX_SLAVE_DIFF))) { * long before both time_ins can get stale
rcu_read_lock(); */
port = get_late_port(hsr, node); timestamp = time_a;
if (port) if (node->time_in_stale[HSR_PT_SLAVE_A] ||
hsr_nl_ringerror(hsr, node->macaddress_A, port); (!node->time_in_stale[HSR_PT_SLAVE_B] &&
rcu_read_unlock(); time_after(time_b, time_a)))
} timestamp = time_b;
/* Prune old entries */ /* Warn of ring error only as long as we get
if (time_is_before_jiffies(timestamp + * frames at all
msecs_to_jiffies(HSR_NODE_FORGET_TIME))) { */
hsr_nl_nodedown(hsr, node->macaddress_A); if (time_is_after_jiffies(timestamp +
list_del_rcu(&node->mac_list); msecs_to_jiffies(1.5 * MAX_SLAVE_DIFF))) {
/* Note that we need to free this entry later: */ rcu_read_lock();
kfree_rcu(node, rcu_head); port = get_late_port(hsr, node);
if (port)
hsr_nl_ringerror(hsr,
node->macaddress_A,
port);
rcu_read_unlock();
}
/* Prune old entries */
if (time_is_before_jiffies(timestamp +
msecs_to_jiffies(HSR_NODE_FORGET_TIME))) {
hsr_nl_nodedown(hsr, node->macaddress_A);
hlist_del_rcu(&node->mac_list);
/* Note that we need to free this
* entry later:
*/
kfree_rcu(node, rcu_head);
}
} }
} }
spin_unlock_bh(&hsr->list_lock); spin_unlock_bh(&hsr->list_lock);
@ -557,17 +592,19 @@ void *hsr_get_next_node(struct hsr_priv *hsr, void *_pos,
unsigned char addr[ETH_ALEN]) unsigned char addr[ETH_ALEN])
{ {
struct hsr_node *node; struct hsr_node *node;
u32 hash;
hash = hsr_mac_hash(hsr, addr);
if (!_pos) { if (!_pos) {
node = list_first_or_null_rcu(&hsr->node_db, node = hsr_node_get_first(&hsr->node_db[hash]);
struct hsr_node, mac_list);
if (node) if (node)
ether_addr_copy(addr, node->macaddress_A); ether_addr_copy(addr, node->macaddress_A);
return node; return node;
} }
node = _pos; node = _pos;
list_for_each_entry_continue_rcu(node, &hsr->node_db, mac_list) { hlist_for_each_entry_continue_rcu(node, mac_list) {
ether_addr_copy(addr, node->macaddress_A); ether_addr_copy(addr, node->macaddress_A);
return node; return node;
} }
@ -587,8 +624,11 @@ int hsr_get_node_data(struct hsr_priv *hsr,
struct hsr_node *node; struct hsr_node *node;
struct hsr_port *port; struct hsr_port *port;
unsigned long tdiff; unsigned long tdiff;
u32 hash;
node = find_node_by_addr_A(&hsr->node_db, addr); hash = hsr_mac_hash(hsr, addr);
node = find_node_by_addr_A(&hsr->node_db[hash], addr);
if (!node) if (!node)
return -ENOENT; return -ENOENT;

8
net/hsr/hsr_framereg.h
View File

@ -28,9 +28,11 @@ struct hsr_frame_info {
bool is_from_san; bool is_from_san;
}; };
u32 hsr_mac_hash(struct hsr_priv *hsr, const unsigned char *addr);
struct hsr_node *hsr_node_get_first(struct hlist_head *head);
void hsr_del_self_node(struct hsr_priv *hsr); void hsr_del_self_node(struct hsr_priv *hsr);
void hsr_del_nodes(struct list_head *node_db); void hsr_del_nodes(struct hlist_head *node_db);
struct hsr_node *hsr_get_node(struct hsr_port *port, struct list_head *node_db, struct hsr_node *hsr_get_node(struct hsr_port *port, struct hlist_head *node_db,
struct sk_buff *skb, bool is_sup, struct sk_buff *skb, bool is_sup,
enum hsr_port_type rx_port); enum hsr_port_type rx_port);
void hsr_handle_sup_frame(struct hsr_frame_info *frame); void hsr_handle_sup_frame(struct hsr_frame_info *frame);
@ -68,7 +70,7 @@ void prp_handle_san_frame(bool san, enum hsr_port_type port,
void prp_update_san_info(struct hsr_node *node, bool is_sup); void prp_update_san_info(struct hsr_node *node, bool is_sup);
struct hsr_node { struct hsr_node {
struct list_head mac_list; struct hlist_node mac_list;
unsigned char macaddress_A[ETH_ALEN]; unsigned char macaddress_A[ETH_ALEN];
unsigned char macaddress_B[ETH_ALEN]; unsigned char macaddress_B[ETH_ALEN];
/* Local slave through which AddrB frames are received from this node */ /* Local slave through which AddrB frames are received from this node */

9
net/hsr/hsr_main.h
View File

@ -63,6 +63,9 @@ struct hsr_tag {
#define HSR_V1_SUP_LSDUSIZE 52 #define HSR_V1_SUP_LSDUSIZE 52
#define HSR_HSIZE_SHIFT 8
#define HSR_HSIZE BIT(HSR_HSIZE_SHIFT)
/* The helper functions below assumes that 'path' occupies the 4 most /* The helper functions below assumes that 'path' occupies the 4 most
* significant bits of the 16-bit field shared by 'path' and 'LSDU_size' (or * significant bits of the 16-bit field shared by 'path' and 'LSDU_size' (or
* equivalently, the 4 most significant bits of HSR tag byte 14). * equivalently, the 4 most significant bits of HSR tag byte 14).
@ -201,8 +204,8 @@ struct hsr_proto_ops {
struct hsr_priv { struct hsr_priv {
struct rcu_head rcu_head; struct rcu_head rcu_head;
struct list_head ports; struct list_head ports;
struct list_head node_db; /* Known HSR nodes */ struct hlist_head node_db[HSR_HSIZE]; /* Known HSR nodes */
struct list_head self_node_db; /* MACs of slaves */ struct hlist_head self_node_db; /* MACs of slaves */
struct timer_list announce_timer; /* Supervision frame dispatch */ struct timer_list announce_timer; /* Supervision frame dispatch */
struct timer_list prune_timer; struct timer_list prune_timer;
int announce_count; int announce_count;
@ -212,6 +215,8 @@ struct hsr_priv {
spinlock_t seqnr_lock; /* locking for sequence_nr */ spinlock_t seqnr_lock; /* locking for sequence_nr */
spinlock_t list_lock; /* locking for node list */ spinlock_t list_lock; /* locking for node list */
struct hsr_proto_ops *proto_ops; struct hsr_proto_ops *proto_ops;
u32 hash_buckets;
u32 hash_seed;
#define PRP_LAN_ID 0x5 /* 0x1010 for A and 0x1011 for B. Bit 0 is set #define PRP_LAN_ID 0x5 /* 0x1010 for A and 0x1011 for B. Bit 0 is set
* based on SLAVE_A or SLAVE_B * based on SLAVE_A or SLAVE_B
*/ */

4
net/hsr/hsr_netlink.c
View File

@ -105,6 +105,7 @@ static int hsr_newlink(struct net *src_net, struct net_device *dev,
static void hsr_dellink(struct net_device *dev, struct list_head *head) static void hsr_dellink(struct net_device *dev, struct list_head *head)
{ {
struct hsr_priv *hsr = netdev_priv(dev); struct hsr_priv *hsr = netdev_priv(dev);
int i;
del_timer_sync(&hsr->prune_timer); del_timer_sync(&hsr->prune_timer);
del_timer_sync(&hsr->announce_timer); del_timer_sync(&hsr->announce_timer);
@ -113,7 +114,8 @@ static void hsr_dellink(struct net_device *dev, struct list_head *head)
hsr_del_ports(hsr); hsr_del_ports(hsr);
hsr_del_self_node(hsr); hsr_del_self_node(hsr);
hsr_del_nodes(&hsr->node_db); for (i = 0; i < hsr->hash_buckets; i++)
hsr_del_nodes(&hsr->node_db[i]);
unregister_netdevice_queue(dev, head); unregister_netdevice_queue(dev, head);
} }