mirror of
https://github.com/torvalds/linux.git
synced 2026-03-08 01:24:47 +01:00
aae9d6b616
The HSR duplicate discard algorithm had even more basic problems than the described for PRP in the previous patch. It relied only on the last received sequence number to decide if a new frame should be forwarded to any port. This does not work correctly in any case where frames are received out of order. The linked bug report claims that this can even happen with perfectly fine links due to the order in which incoming frames are processed (which can be unexpected on multi-core systems). The issue also occasionally shows up in the HSR selftests. The main reason is that the sequence number that was last forwarded to the master port may have skipped a number which will in turn never be delivered to the host. As the problem (we accidentally skip over a sequence number that has not been received but will be received in the future) is similar to PRP, we can apply a similar solution. The duplicate discard algorithm based on the "sparse bitmap" works well for HSR if it is extended to track one bitmap for each port (A, B, master, interlink). To do this, change the sequence number blocks to contain a flexible array member as the last member that can keep chunks for as many bitmaps as we need. This design makes it easy to reuse the same algorithm in a potential PRP RedBox implementation. The duplicate discard algorithm functions are modified to deal with sequence number blocks of different sizes and to correctly use the array of bitmap chunks. There is a notable speciality for HSR: the port type has a special port type NONE with value 0. This leads to the number of port types being 5 instead of actually 4. To save memory, remove the NONE port from the bitmap (by subtracting 1) when setting up the block buffer and when accessing the bitmap chunks in the array. Removing the old algorithm allows us to get rid of a few fields that are not needed any more: time_out and seq_out for each port. We can also remove some functions that were only necessary for the previous duplicate discard algorithm. The removal of seq_out is possible despite its previous usage in hsr_register_frame_in: it was used to prevent updates to time_in when "invalid" sequence numbers were received. With the new duplicate discard algorithm, time_in has no relevance for the expiry of sequence numbers anymore. They will expire based on the timestamps in the sequence number blocks after at most 400ms. There is no need that a node "re-registers" to "resume communication": after 400ms, all sequence numbers are accepted again. Also, according to the IEC 62439-3:2021, all nodes are supposed to send no traffic for 500ms after boot to lead exactly to this expiry of seen sequence numbers. time_in is still used for pruning nodes from the node table after no traffic has been received for 60sec. Pruning is only needed if the node is really gone and has not been sending any traffic for that period. seq_out was also used to report the last incoming sequence number from a node through netlink. I am not sure how useful this value is to userspace at all, but added getting it from the sequence number blocks. This number can be outdated after node merging until a new block has been added. Update the KUnit test for the PRP duplicate discard so that the node allocation matches and expectations on the removed fields are removed. Reported-by: Yoann Congal <yoann.congal@smile.fr> Closes: https://lore.kernel.org/netdev/7d221a07-8358-4c0b-a09c-3b029c052245@smile.fr/ Signed-off-by: Felix Maurer <fmaurer@redhat.com> Reviewed-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> Link: https://patch.msgid.link/36dc3bc5bdb7e68b70bb5ef86f53ca95a3f35418.1770299429.git.fmaurer@redhat.com Signed-off-by: Paolo Abeni <pabeni@redhat.com>
126 lines
3.7 KiB
C
126 lines
3.7 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/* Copyright 2011-2014 Autronica Fire and Security AS
|
|
*
|
|
* Author(s):
|
|
* 2011-2014 Arvid Brodin, arvid.brodin@alten.se
|
|
*
|
|
* include file for HSR and PRP.
|
|
*/
|
|
|
|
#ifndef __HSR_FRAMEREG_H
|
|
#define __HSR_FRAMEREG_H
|
|
|
|
#include "hsr_main.h"
|
|
|
|
struct hsr_node;
|
|
|
|
struct hsr_frame_info {
|
|
struct sk_buff *skb_std;
|
|
struct sk_buff *skb_hsr;
|
|
struct sk_buff *skb_prp;
|
|
struct hsr_port *port_rcv;
|
|
struct hsr_node *node_src;
|
|
u16 sequence_nr;
|
|
bool is_supervision;
|
|
bool is_proxy_supervision;
|
|
bool is_vlan;
|
|
bool is_local_dest;
|
|
bool is_local_exclusive;
|
|
bool is_from_san;
|
|
};
|
|
|
|
void hsr_del_self_node(struct hsr_priv *hsr);
|
|
void hsr_del_nodes(struct list_head *node_db);
|
|
struct hsr_node *hsr_get_node(struct hsr_port *port, struct list_head *node_db,
|
|
struct sk_buff *skb, bool is_sup,
|
|
enum hsr_port_type rx_port);
|
|
void hsr_handle_sup_frame(struct hsr_frame_info *frame);
|
|
bool hsr_addr_is_self(struct hsr_priv *hsr, unsigned char *addr);
|
|
bool hsr_addr_is_redbox(struct hsr_priv *hsr, unsigned char *addr);
|
|
|
|
void hsr_addr_subst_source(struct hsr_node *node, struct sk_buff *skb);
|
|
void hsr_addr_subst_dest(struct hsr_node *node_src, struct sk_buff *skb,
|
|
struct hsr_port *port);
|
|
|
|
void hsr_register_frame_in(struct hsr_node *node, struct hsr_port *port,
|
|
u16 sequence_nr);
|
|
int hsr_register_frame_out(struct hsr_port *port, struct hsr_frame_info *frame);
|
|
|
|
void hsr_prune_nodes(struct timer_list *t);
|
|
void hsr_prune_proxy_nodes(struct timer_list *t);
|
|
|
|
int hsr_create_self_node(struct hsr_priv *hsr,
|
|
const unsigned char addr_a[ETH_ALEN],
|
|
const unsigned char addr_b[ETH_ALEN]);
|
|
|
|
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,
|
|
const unsigned char *addr,
|
|
unsigned char addr_b[ETH_ALEN],
|
|
unsigned int *addr_b_ifindex,
|
|
int *if1_age,
|
|
u16 *if1_seq,
|
|
int *if2_age,
|
|
u16 *if2_seq);
|
|
|
|
void prp_handle_san_frame(bool san, enum hsr_port_type port,
|
|
struct hsr_node *node);
|
|
void prp_update_san_info(struct hsr_node *node, bool is_sup);
|
|
|
|
bool hsr_is_node_in_db(struct list_head *node_db,
|
|
const unsigned char addr[ETH_ALEN]);
|
|
|
|
int prp_register_frame_out(struct hsr_port *port, struct hsr_frame_info *frame);
|
|
|
|
#if IS_ENABLED(CONFIG_KUNIT)
|
|
struct hsr_seq_block *hsr_get_seq_block(struct hsr_node *node, u16 block_idx);
|
|
#endif
|
|
|
|
#define HSR_SEQ_BLOCK_SHIFT 7 /* 128 bits */
|
|
#define HSR_SEQ_BLOCK_SIZE (1 << HSR_SEQ_BLOCK_SHIFT)
|
|
#define HSR_SEQ_BLOCK_MASK (HSR_SEQ_BLOCK_SIZE - 1)
|
|
#define HSR_MAX_SEQ_BLOCKS 64
|
|
|
|
#define hsr_seq_block_index(sequence_nr) ((sequence_nr) >> HSR_SEQ_BLOCK_SHIFT)
|
|
#define hsr_seq_block_bit(sequence_nr) ((sequence_nr) & HSR_SEQ_BLOCK_MASK)
|
|
|
|
struct hsr_seq_block {
|
|
unsigned long time;
|
|
u16 block_idx;
|
|
/* Should be a flexible array member of what DECLARE_BITMAP() would
|
|
* produce.
|
|
*/
|
|
unsigned long seq_nrs[][BITS_TO_LONGS(HSR_SEQ_BLOCK_SIZE)];
|
|
};
|
|
|
|
struct hsr_node {
|
|
struct list_head mac_list;
|
|
/* Protect R/W access seq_blocks */
|
|
spinlock_t seq_out_lock;
|
|
unsigned char macaddress_A[ETH_ALEN];
|
|
unsigned char macaddress_B[ETH_ALEN];
|
|
/* Local slave through which AddrB frames are received from this node */
|
|
enum hsr_port_type addr_B_port;
|
|
unsigned long time_in[HSR_PT_PORTS];
|
|
bool time_in_stale[HSR_PT_PORTS];
|
|
/* if the node is a SAN */
|
|
bool san_a;
|
|
bool san_b;
|
|
bool removed;
|
|
/* Duplicate detection */
|
|
struct xarray seq_blocks;
|
|
void *block_buf;
|
|
unsigned int next_block;
|
|
unsigned int seq_port_cnt;
|
|
struct rcu_head rcu_head;
|
|
};
|
|
|
|
static inline size_t hsr_seq_block_size(struct hsr_node *node)
|
|
{
|
|
WARN_ON_ONCE(node->seq_port_cnt == 0);
|
|
return struct_size_t(struct hsr_seq_block, seq_nrs, node->seq_port_cnt);
|
|
}
|
|
|
|
#endif /* __HSR_FRAMEREG_H */
|