pull request: batman-adv 2026-06-19
Subsystems (3)
Simon Wunderlich
maintainercover pull request: batman-adv 2026-06-19
Dear net maintainers,
here are some bugfixes for batman-adv which we would like to have integrated into net.
Please pull or let me know of any problem!
Thank you,
Simon
The following changes since commit dad4d4b92a9b9f0edb8c66deda049da1b62f6089:
Merge git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net (2026-06-11 14:33:35 -0700)
are available in the Git repository at:
https://git.open-mesh.org/batadv.git tags/batadv-net-pullrequest-20260619
for you to fetch changes up to edb557b2ba38fea2c5eb710cf366c797e187218c:
batman-adv: tvlv: avoid race of cifsnotfound handler state (2026-06-14 12:33:18 +0200)
----------------------------------------------------------------
Here are some batman-adv bugfixes, all by Sven Eckelmann:
- gw: don't deselect gateway with active hardif
- TTL fixes in bcast/mcast and fragmentation handling (4 patches)
- BATMAN V: prevent OGM aggregation on disabled hardif
- tp_meter: concurrency and range fixes, add cap to unacked list (4 patches)
- tt: fix unchecked VLAN ID in tt for local add and roam (2 patches)
- dat: check VLAN ID in the hash
- tvlv: enforce 2-byte alignment
- tvlv: avoid race of cifsnotfound handler state
----------------------------------------------------------------
Sven Eckelmann (15):
batman-adv: gw: don't deselect gateway with active hardif
batman-adv: ensure bcast is writable before modifying TTL
batman-adv: fix (m|b)cast csum after decrementing TTL
batman-adv: frag: ensure fragment is writable before modifying TTL
batman-adv: frag: avoid underflow of TTL
batman-adv: v: prevent OGM aggregation on disabled hardif
batman-adv: tp_meter: restrict number of unacked list entries
batman-adv: tp_meter: annotate last_recv_time access with READ/WRITE_ONCE
batman-adv: tp_meter: prevent parallel modifications of last_recv
batman-adv: tp_meter: handle overlapping packets
batman-adv: tt: don't merge change entries with different VIDs
batman-adv: tt: track roam count per VID
batman-adv: dat: prevent false sharing between VLANs
batman-adv: tvlv: enforce 2-byte alignment
batman-adv: tvlv: avoid race of cifsnotfound handler state
net/batman-adv/bat_iv_ogm.c | 11 ++++- net/batman-adv/bat_v.c | 1 + net/batman-adv/bat_v_ogm.c | 23 ++++++++++- net/batman-adv/distributed-arp-table.c | 12 ++++-- net/batman-adv/fragmentation.c | 22 +++++++++- net/batman-adv/fragmentation.h | 3 +- net/batman-adv/hard-interface.c | 28 +------------ net/batman-adv/routing.c | 73 +++++++++++++++++++++++++++++++-- net/batman-adv/tp_meter.c | 74 ++++++++++++++++++++++------------ net/batman-adv/translation-table.c | 12 +++++- net/batman-adv/tvlv.c | 69 ++++++++++++++++++++++++++++--- net/batman-adv/types.h | 21 ++++++---- 12 files changed, 270 insertions(+), 79 deletions(-)
Simon Wunderlich
maintainerPATCH 1/15 batman-adv: gw: don't deselect gateway with active hardif
From: Sven Eckelmann <[email protected]>
The batadv_hardif_cnt() was previously checking if there is an batadv_hard_iface->mesh_iface which is has the same mesh_iface. And since batadv_hardif_disable_interface() was resetting the batadv_hard_iface->mesh_iface after this check, it had to verify whether *1* interface was still part of the mesh_iface before it started the gateway deselection.
But after batadv_hardif_cnt() is now checking the lower interfaces of mesh_iface and batadv_hardif_disable_interface() already removed the interface via netdev_upper_dev_unlink() earlier in this function, the check must now make sure that *0* interfaces can be found by batadv_hardif_cnt() before selected gateway must be deselected. Otherwise the deselection would already happen one batadv_hard_iface too early.
Because a 0 hardif count from batadv_hardif_cnt() is equal to an empty list, it is possible to replace the counting with a simple list_empty().
--- net/batman-adv/hard-interface.c | 28 ++-------------------------- 1 file changed, 2 insertions(+), 26 deletions(-)
net/batman-adv/hard-interface.c +2 -26
@@ -814,30 +814,6 @@ int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface,return ret; } -/** -* batadv_hardif_cnt() - get number of interfaces enslaved to mesh interface -* @mesh_iface: mesh interface to check -* -* This function is only using RCU for locking - the result can therefore be -* off when another function is modifying the list at the same time. The -* caller can use the rtnl_lock to make sure that the count is accurate. -* -* Return: number of connected/enslaved hard interfaces -*/ -static size_t batadv_hardif_cnt (struct net_device *mesh_iface) -{ -struct batadv_hard_iface *hard_iface; -struct list_head *iter; -size_t count =0 ; - -rcu_read_lock (); -netdev_for_each_lower_private_rcu (mesh_iface, hard_iface, iter) - count++; -rcu_read_unlock (); - -return count; -} -/** * batadv_hardif_disable_interface() - Remove hard interface from mesh interface * @hard_iface: hard interface to be removed
@@ -878,8 +854,8 @@ void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface)netdev_upper_dev_unlink (hard_iface->net_dev, hard_iface->mesh_iface);batadv_hardif_recalc_extra_skbroom (hard_iface->mesh_iface); -/* nobody uses this interface anymore */ -if (batadv_hardif_cnt (hard_iface->mesh_iface) <=1 ) +/* nobody uses this mesh interface anymore */ +if (list_empty (&hard_iface->mesh_iface->adj_list.lower))batadv_gw_check_client_stop (bat_priv); hard_iface->mesh_iface =NULL ;
Signature · 1 line
2.47.3
Re: [PATCH net 01/15] batman-adv: gw: don't deselect gateway with active hardif
This series was applied to netdev/net.git (main) by Sven Eckelmann <[email protected]>:
Hello:
This series was applied to netdev/net.git (main)
by Sven Eckelmann <[email protected]>:
Quoted 10 lines · On Fri, 19 Jun 2026 09:00:31 +0200 you wrote:
From: Sven Eckelmann <[email protected]>
The
batadv_hardif_cnt()was previously checking if there is anbatadv_hard_iface->mesh_ifacewhich is has the samemesh_iface. And sincebatadv_hardif_disable_interface()was resetting thebatadv_hard_iface->mesh_ifaceafter this check, it had to verify whether *1* interface was still part of themesh_ifacebefore it started the gateway deselection.[...]
Here is the summary with links:
- [net,01/15] batman-adv: gw: don't deselect gateway with active hardif
https://git.kernel.org/netdev/net/c/df97a7107b16 - [net,02/15] batman-adv: ensure bcast is writable before modifying TTL https://git.kernel.org/netdev/net/c/4cd6d3a4b96a - [net,03/15] batman-adv: fix (m|b)cast csum after decrementing TTL https://git.kernel.org/netdev/net/c/e728bbdf3266 - [net,04/15] batman-adv: frag: ensure fragment is writable before modifying TTL https://git.kernel.org/netdev/net/c/b7293c6e8c15 - [net,05/15] batman-adv: frag: avoid underflow of TTL https://git.kernel.org/netdev/net/c/493d9d2528e1 - [net,06/15] batman-adv: v: prevent OGM aggregation on disabled hardif https://git.kernel.org/netdev/net/c/d11c00b95b2a - [net,07/15] batman-adv: tp_meter: restrict number of unacked list entries https://git.kernel.org/netdev/net/c/e7c775110e18 - [net,08/15] batman-adv: tp_meter: annotate last_recv_time access with READ/WRITE_ONCE https://git.kernel.org/netdev/net/c/d67c728f07fc - [net,09/15] batman-adv: tp_meter: prevent parallel modifications of last_recv https://git.kernel.org/netdev/net/c/6dde0cfcb36e - [net,10/15] batman-adv: tp_meter: handle overlapping packets https://git.kernel.org/netdev/net/c/cbde75c38b21 - [net,11/15] batman-adv: tt: don't merge change entries with different VIDs https://git.kernel.org/netdev/net/c/f08e06c2d5c3 - [net,12/15] batman-adv: tt: track roam count per VID https://git.kernel.org/netdev/net/c/12407d5f61c2 - [net,13/15] batman-adv: dat: prevent false sharing between VLANs https://git.kernel.org/netdev/net/c/20d7658b7416 - [net,14/15] batman-adv: tvlv: enforce 2-byte alignment https://git.kernel.org/netdev/net/c/32a679925552 - [net,15/15] batman-adv: tvlv: avoid race of cifsnotfound handler state https://git.kernel.org/netdev/net/c/edb557b2ba38
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html
Simon Wunderlich
maintainerPATCH 2/15 batman-adv: ensure bcast is writable before modifying TTL
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
Before batman-adv is allowed to write to an skb, it either has to have its own copy of the skb or used skb_cow() to ensure that the data part is not shared.
The old implementation used a shared queue and created copies before attempting to write to it. But with the new implementation, the broadcast packet is already modified when it gets received. Potentially writing to shared buffers in this process.
Adding a skb_cow() right before this operation avoids this and can at the same time prepare it for the modifications required to rebroadcast the packet.
--- net/batman-adv/routing.c | 6 ++++++ 1 file changed, 6 insertions(+)
net/batman-adv/routing.c +6 -0
@@ -1191,6 +1191,12 @@ int batadv_recv_bcast_packet(struct sk_buff *skb,if (batadv_is_my_mac (bat_priv, bcast_packet->orig)) goto free_skb; +/* create a copy of the skb, if needed, to modify it. */ +if (skb_cow (skb,ETH_HLEN ) <0 ) + goto free_skb; + + bcast_packet = (struct batadv_bcast_packet *)skb->data; +if (bcast_packet->ttl-- <2 ) goto free_skb;
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 3/15 batman-adv: fix (m|b)cast csum after decrementing TTL
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
The broadcast and multicast packets can be received at the same time by the local system and forwarded to other nodes. Both are simply decrementing the TTL at the beginning of the receive path - independent of chosen paths (receive/forward). But such a modification of the data conflicts with the hw csum. This is not a problem when the packet is directly forwarded but can cause errors in the local receive path.
Such a problem can then trigger a "hw csum failure". The receiver path must therefore ensure that the csum is fixed for each modification of the payload before batadv_interface_rx() is reached.
Since all batman-adv packet types with a ttl have it as u8 at offset 2, a helper can be used for all of them. But it is only used at the moment for batadv_bcast_packet and batadv_mcast_packet because they are the only ones which deliver the packet locally but unconditionally modify the TTL.
--- net/batman-adv/routing.c | 58 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 56 insertions(+), 2 deletions(-)
net/batman-adv/routing.c +56 -2
@@ -8,6 +8,7 @@#include "main.h" #include <linux/atomic.h> +#include <linux/build_bug.h> #include <linux/byteorder/generic.h> #include <linux/compiler.h> #include <linux/errno.h>
@@ -204,6 +205,59 @@ bool batadv_check_management_packet(struct sk_buff *skb,return true; } +/** +* batadv_skb_decrement_ttl() - decrement ttl in a batman-adv header, csum-safe +* @skb: the received packet with @skb->data pointing to the batman-adv header +* +* Supports the following packet types, all of which carry the TTL at offset 2: +* +* - batadv_ogm_packet +* - batadv_ogm2_packet +* - batadv_icmp_header +* - batadv_icmp_packet +* - batadv_icmp_tp_packet +* - batadv_icmp_packet_rr +* - batadv_unicast_packet +* - batadv_frag_packet +* - batadv_bcast_packet +* - batadv_mcast_packet +* - batadv_coded_packet +* - batadv_unicast_tvlv_packet +* +* Return: true if the packet may be forwarded (ttl decremented), +* false if it must be dropped (ttl would expire) +*/ +static bool batadv_skb_decrement_ttl (struct sk_buff *skb) +{ +static const size_t ttl_offset =2 ; +u8 *ttl_pos; + +BUILD_BUG_ON (offsetof(struct batadv_ogm_packet , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_ogm2_packet , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_icmp_header , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_icmp_packet , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_icmp_tp_packet , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_icmp_packet_rr , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_unicast_packet , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_frag_packet , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_bcast_packet , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_mcast_packet , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_coded_packet , ttl) != ttl_offset); +BUILD_BUG_ON (offsetof(struct batadv_unicast_tvlv_packet , ttl) != ttl_offset); + + ttl_pos = skb->data + ttl_offset; + +/* would expire on this hop -> drop, leave header + csum untouched */ +if (*ttl_pos <2 ) +return false; + +skb_postpull_rcsum (skb, ttl_pos,1 ); + (*ttl_pos)--; +skb_postpush_rcsum (skb, ttl_pos,1 ); + +return true; +} +/** * batadv_recv_my_icmp_packet() - receive an icmp packet locally * @bat_priv: the bat priv with all the mesh interface information
@@ -1197,7 +1251,7 @@ int batadv_recv_bcast_packet(struct sk_buff *skb, bcast_packet = (struct batadv_bcast_packet *)skb->data; -if (bcast_packet->ttl-- <2 ) +if (!batadv_skb_decrement_ttl (skb)) goto free_skb; orig_node =batadv_orig_hash_find (bat_priv, bcast_packet->orig);
@@ -1304,7 +1358,7 @@ int batadv_recv_mcast_packet(struct sk_buff *skb, goto free_skb; mcast_packet = (struct batadv_mcast_packet *)skb->data; -if (mcast_packet->ttl-- <2 ) +if (!batadv_skb_decrement_ttl (skb)) goto free_skb; tvlv_buff = (unsigned char *)(skb->data + hdr_size);
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 4/15 batman-adv: frag: ensure fragment is writable before modifying TTL
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
Before batman-adv is allowed to write to an skb, it either has to have its own copy of the skb or use skb_cow() to ensure that the data part is not shared. But batadv_frag_skb_fwd() modifies the TTL even when it is shared.
Adding a skb_cow() right before this operation avoids this and can at the same time prepare it for the modifications required to forward the fragment.
--- net/batman-adv/fragmentation.c | 15 ++++++++++++++- net/batman-adv/fragmentation.h | 3 ++- net/batman-adv/routing.c | 3 +-- 3 files changed, 17 insertions(+), 4 deletions(-)
net/batman-adv/fragmentation.c +14 -1
@@ -386,6 +386,8 @@ bool batadv_frag_skb_buffer(struct sk_buff **skb,* @skb: skb to forward * @recv_if: interface that the skb is received on * @orig_node_src: originator that the skb is received from +* @rx_result: set to NET_RX_SUCCESS when the fragment was forwarded and +* NET_RX_DROP when it was dropped; only valid when true is returned * * Look up the next-hop of the fragments payload and check if the merged packet * will exceed the MTU towards the next-hop. If so, the fragment is forwarded
@@ -395,7 +397,8 @@ bool batadv_frag_skb_buffer(struct sk_buff **skb,*/ bool batadv_frag_skb_fwd (struct sk_buff *skb,struct batadv_hard_iface *recv_if, -struct batadv_orig_node *orig_node_src) +struct batadv_orig_node *orig_node_src, +int *rx_result) {struct batadv_priv *bat_priv =netdev_priv (recv_if->mesh_iface);struct batadv_neigh_node *neigh_node =NULL ;
@@ -414,12 +417,22 @@ bool batadv_frag_skb_fwd(struct sk_buff *skb,*/ total_size =ntohs (packet->total_size);if (total_size > neigh_node->if_incoming->net_dev->mtu) { +if (skb_cow (skb,ETH_HLEN ) <0 ) { +kfree_skb (skb); + *rx_result =NET_RX_DROP ; + ret = true; + goto out; + } + + packet = (struct batadv_frag_packet *)skb->data; +batadv_inc_counter (bat_priv,BATADV_CNT_FRAG_FWD );batadv_add_counter (bat_priv,BATADV_CNT_FRAG_FWD_BYTES , skb->len +ETH_HLEN ); packet->ttl--;batadv_send_unicast_skb (skb, neigh_node); + *rx_result =NET_RX_SUCCESS ; ret = true; }
net/batman-adv/fragmentation.h +2 -1
@@ -19,7 +19,8 @@ void batadv_frag_purge_orig(struct batadv_orig_node *orig, bool (*check_cb)(struct batadv_frag_table_entry *));bool batadv_frag_skb_fwd (struct sk_buff *skb,struct batadv_hard_iface *recv_if, -struct batadv_orig_node *orig_node_src); +struct batadv_orig_node *orig_node_src, +int *rx_result);bool batadv_frag_skb_buffer (struct sk_buff **skb,struct batadv_orig_node *orig_node); int batadv_frag_send_packet(struct sk_buff *skb,
net/batman-adv/routing.c +1 -2
@@ -1168,10 +1168,9 @@ int batadv_recv_frag_packet(struct sk_buff *skb,/* Route the fragment if it is not for us and too big to be merged. */ if (!batadv_is_my_mac (bat_priv, frag_packet->dest) && -batadv_frag_skb_fwd (skb, recv_if, orig_node_src)) { +batadv_frag_skb_fwd (skb, recv_if, orig_node_src, &ret)) {/* skb was consumed */ skb =NULL ; - ret =NET_RX_SUCCESS ; goto put_orig_node; }
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 5/15 batman-adv: frag: avoid underflow of TTL
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
Packets with a TTL are using it to limit the amount of time this packet can be forwarded. But for batadv_frag_packet, the TTL was always only reduced but it was never evaluated. It could even underflow without any effect.
Check the TTL in batadv_frag_skb_fwd() before attempting to prepare it for forwarding. This keeps it in sync with the not fragmented unicast packet.
--- net/batman-adv/fragmentation.c | 7 +++++++ 1 file changed, 7 insertions(+)
net/batman-adv/fragmentation.c +7 -0
@@ -417,6 +417,13 @@ bool batadv_frag_skb_fwd(struct sk_buff *skb,*/ total_size =ntohs (packet->total_size);if (total_size > neigh_node->if_incoming->net_dev->mtu) { +if (packet->ttl <2 ) { +kfree_skb (skb); + *rx_result =NET_RX_DROP ; + ret = true; + goto out; + } +if (skb_cow (skb,ETH_HLEN ) <0 ) {kfree_skb (skb); *rx_result =NET_RX_DROP ;
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 6/15 batman-adv: v: prevent OGM aggregation on disabled hardif
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
When an interface gets disabled, the worker is correctly disabled by batadv_hardif_disable_interface() -> ... -> batadv_v_ogm_iface_disable(). In this process, the skb aggr_list is also freed.
But batadv_v_ogm_send_meshif() can still queue new skbs (via batadv_v_ogm_queue_on_if()) to the aggr_list. This will only stop after all cores can no longer find the RCU protected list of hard interfaces. These queued skbs will never be freed or consumed by batadv_v_ogm_aggr_work.
The batadv_v_ogm_iface_disable() function must block batadv_v_ogm_queue_on_if() to avoid leak of skbs.
--- net/batman-adv/bat_v.c | 1 + net/batman-adv/bat_v_ogm.c | 12 ++++++++++++ net/batman-adv/types.h | 6 ++++++ 3 files changed, 19 insertions(+)
net/batman-adv/bat_v.c +1 -0
@@ -817,6 +817,7 @@ void batadv_v_hardif_init(struct batadv_hard_iface *hard_iface) hard_iface->bat_v.aggr_len =0 ;skb_queue_head_init (&hard_iface->bat_v.aggr_list); + hard_iface->bat_v.aggr_list_enabled = false;INIT_DELAYED_WORK (&hard_iface->bat_v.aggr_wq, batadv_v_ogm_aggr_work);/* make sure it doesn't run until interface gets enabled */
net/batman-adv/bat_v_ogm.c +12 -0
@@ -254,11 +254,18 @@ static void batadv_v_ogm_queue_on_if(struct batadv_priv *bat_priv, }spin_lock_bh (&hard_iface->bat_v.aggr_list.lock); +if (!hard_iface->bat_v.aggr_list_enabled) { +kfree_skb (skb); + goto unlock; + } +if (!batadv_v_ogm_queue_left (skb, hard_iface))batadv_v_ogm_aggr_send (bat_priv, hard_iface); hard_iface->bat_v.aggr_len +=batadv_v_ogm_len (skb);__skb_queue_tail (&hard_iface->bat_v.aggr_list, skb); + +unlock:spin_unlock_bh (&hard_iface->bat_v.aggr_list.lock); }
@@ -415,6 +422,10 @@ int batadv_v_ogm_iface_enable(struct batadv_hard_iface *hard_iface) {struct batadv_priv *bat_priv =netdev_priv (hard_iface->mesh_iface); +spin_lock_bh (&hard_iface->bat_v.aggr_list.lock); + hard_iface->bat_v.aggr_list_enabled = true; +spin_unlock_bh (&hard_iface->bat_v.aggr_list.lock); +enable_delayed_work (&hard_iface->bat_v.aggr_wq);batadv_v_ogm_start_queue_timer (hard_iface);
@@ -432,6 +443,7 @@ void batadv_v_ogm_iface_disable(struct batadv_hard_iface *hard_iface)disable_delayed_work_sync (&hard_iface->bat_v.aggr_wq);spin_lock_bh (&hard_iface->bat_v.aggr_list.lock); + hard_iface->bat_v.aggr_list_enabled = false;batadv_v_ogm_aggr_list_free (hard_iface);spin_unlock_bh (&hard_iface->bat_v.aggr_list.lock); }
net/batman-adv/types.h +6 -0
@@ -145,6 +145,12 @@ struct batadv_hard_iface_bat_v {/** @aggr_list: queue for to be aggregated OGM packets */ struct sk_buff_head aggr_list; +/** +* @aggr_list_enabled: aggr_list is active and new skbs can be +* enqueued. Protected by aggr_list.lock after initialization +*/ + bool aggr_list_enabled:1; +/** @aggr_len: size of the OGM aggregate (excluding ethernet header) */ unsigned int aggr_len;
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 7/15 batman-adv: tp_meter: restrict number of unacked list entries
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
When the unacked_list is unbound, an attacker could send messages with small lengths and appropriated seqno + gaps to force the receiver to allocate more and more unacked_list entries. And the end either causing an out-of-memory situation or increase the management overhead for the (large) list that significant portions of CPU cycles are wasted in searching through the list.
When limiting the list to a specific number, it is important to still correctly add a new entry to the list. But if the list became larger than the limit, the last entry of the list (with the highest seqno) must be dropped to still allow the earlier seqnos to finish and therefore to continue the process. Otherwise, the process might get stuck with too high seqnos which are not handled by batadv_tp_ack_unordered().
--- net/batman-adv/tp_meter.c | 23 ++++++++++++++++++++++- net/batman-adv/types.h | 3 +++ 2 files changed, 25 insertions(+), 1 deletion(-)
net/batman-adv/tp_meter.c +22 -1
@@ -87,6 +87,11 @@#define BATADV_TP_PLEN (BATADV_TP_PACKET_LEN - ETH_HLEN - \ sizeof(struct batadv_unicast_packet)) +/** +* BATADV_TP_MAX_UNACKED - maximum number of packets a receiver didn't yet ack +*/ +#define BATADV_TP_MAX_UNACKED 100 +static u8 batadv_tp_prerandom[4096 ]__read_mostly ;/**
@@ -1303,6 +1308,7 @@ static void batadv_tp_receiver_shutdown(struct timer_list *t)list_for_each_entry_safe (un, safe, &tp_vars->common.unacked_list, list) {list_del (&un->list);kfree (un); + tp_vars->common.unacked_count--; }spin_unlock_bh (&tp_vars->common.unacked_lock);
@@ -1416,6 +1422,7 @@ static bool batadv_tp_handle_out_of_order(struct batadv_tp_receiver *tp_vars,/* if the list is empty immediately attach this new object */ if (list_empty (&tp_vars->common.unacked_list)) {list_add (&new->list, &tp_vars->common.unacked_list); + tp_vars->common.unacked_count++; goto out; }
@@ -1446,12 +1453,24 @@ static bool batadv_tp_handle_out_of_order(struct batadv_tp_receiver *tp_vars,*/ list_add (&new->list, &un->list); added = true; + tp_vars->common.unacked_count++;break ; }/* received packet with smallest seqno out of order; add it to front */ -if (!added) +if (!added) {list_add (&new->list, &tp_vars->common.unacked_list); + tp_vars->common.unacked_count++; + } + +/* remove the last (biggest) unacked seqno when list is too large */ +if (tp_vars->common.unacked_count >BATADV_TP_MAX_UNACKED ) { + un =list_last_entry (&tp_vars->common.unacked_list, + struct batadv_tp_unacked, list); +list_del (&un->list); +kfree (un); + tp_vars->common.unacked_count--; + } out:spin_unlock_bh (&tp_vars->common.unacked_lock);
@@ -1488,6 +1507,7 @@ static void batadv_tp_ack_unordered(struct batadv_tp_receiver *tp_vars)list_del (&un->list);kfree (un); + tp_vars->common.unacked_count--; }spin_unlock_bh (&tp_vars->common.unacked_lock); }
@@ -1537,6 +1557,7 @@ batadv_tp_init_recv(struct batadv_priv *bat_priv,spin_lock_init (&tp_vars->common.unacked_lock);INIT_LIST_HEAD (&tp_vars->common.unacked_list); + tp_vars->common.unacked_count =0 ;kref_get (&tp_vars->common.refcount);timer_setup (&tp_vars->common.timer, batadv_tp_receiver_shutdown,0 );
net/batman-adv/types.h +3 -0
@@ -1366,6 +1366,9 @@ struct batadv_tp_vars_common {/** @unacked_lock: protect unacked_list */ spinlock_t unacked_lock; +/** @unacked_count: number of unacked entries */ +size_t unacked_count; +/** @refcount: number of context where the object is used */ struct kref refcount;
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 8/15 batman-adv: tp_meter: annotate last_recv_time access with READ/WRITE_ONCE
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
The last_recv_time field for batadv_tp_receiver tracks the jiffies value of the most recent activity and is used to detect timeouts. These accesses are not consistently protected by a lock, so READ_ONCE/WRITE_ONCE must be used to prevent data races caused by compiler optimizations.
--- net/batman-adv/tp_meter.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
net/batman-adv/tp_meter.c +4 -4
@@ -1290,7 +1290,7 @@ static void batadv_tp_receiver_shutdown(struct timer_list *t) bat_priv = tp_vars->common.bat_priv;/* if there is recent activity rearm the timer */ -if (!batadv_has_timed_out (tp_vars->last_recv_time, +if (!batadv_has_timed_out (READ_ONCE (tp_vars->last_recv_time),BATADV_TP_RECV_TIMEOUT )) {/* reset the receiver shutdown timer */ batadv_tp_reset_receiver_timer (tp_vars);
@@ -1532,7 +1532,7 @@ batadv_tp_init_recv(struct batadv_priv *bat_priv, tp_vars =batadv_tp_list_find_receiver_session (bat_priv, icmp->orig, icmp->session);if (tp_vars) { - tp_vars->last_recv_time = jiffies; +WRITE_ONCE (tp_vars->last_recv_time, jiffies); goto out_unlock; }
@@ -1562,7 +1562,7 @@ batadv_tp_init_recv(struct batadv_priv *bat_priv,kref_get (&tp_vars->common.refcount);timer_setup (&tp_vars->common.timer, batadv_tp_receiver_shutdown,0 ); - tp_vars->last_recv_time = jiffies; +WRITE_ONCE (tp_vars->last_recv_time, jiffies);kref_get (&tp_vars->common.refcount);hlist_add_head_rcu (&tp_vars->common.list, &bat_priv->tp_receiver_list);
@@ -1613,7 +1613,7 @@ static void batadv_tp_recv_msg(struct batadv_priv *bat_priv, goto out; } - tp_vars->last_recv_time = jiffies; +WRITE_ONCE (tp_vars->last_recv_time, jiffies); }/* if the packet is a duplicate, it may be the case that an ACK has been
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 9/15 batman-adv: tp_meter: prevent parallel modifications of last_recv
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
When last_recv is updated to store the last receive sequence number, it is assuming that nothing is modifying in parallel while:
* check for outdated packets is done
* out of order check is performed (and packets are stored in out-of-order queue)
* the out-of-order queue was searched for closed gaps
* sequence number for next ack is calculated
Nothing of that was actually protected. It could therefore happen that the last_recv was updated multiple times in parallel and the final sequence number was calculated with deltas which had no connection to the sequence number they were added to.
Lock this whole region with the same lock which was already used to protect the unacked (out-of-order) list.
--- net/batman-adv/tp_meter.c | 22 +++++++++++++--------- net/batman-adv/types.h | 2 +- 2 files changed, 14 insertions(+), 10 deletions(-)
net/batman-adv/tp_meter.c +13 -9
@@ -1402,6 +1402,7 @@ static int batadv_tp_send_ack(struct batadv_priv *bat_priv, const u8 *dst,*/ static bool batadv_tp_handle_out_of_order (struct batadv_tp_receiver *tp_vars,const struct sk_buff *skb) + __must_hold(&tp_vars->common.unacked_lock) {const struct batadv_icmp_tp_packet *icmp;struct batadv_tp_unacked *un, *new;
@@ -1418,12 +1419,11 @@ static bool batadv_tp_handle_out_of_order(struct batadv_tp_receiver *tp_vars, payload_len = skb->len -sizeof (struct batadv_unicast_packet ); new->len = payload_len; -spin_lock_bh (&tp_vars->common.unacked_lock);/* if the list is empty immediately attach this new object */ if (list_empty (&tp_vars->common.unacked_list)) {list_add (&new->list, &tp_vars->common.unacked_list); tp_vars->common.unacked_count++; - goto out; +return true; }/* otherwise loop over the list and either drop the packet because this
@@ -1472,9 +1472,6 @@ static bool batadv_tp_handle_out_of_order(struct batadv_tp_receiver *tp_vars, tp_vars->common.unacked_count--; } -out: -spin_unlock_bh (&tp_vars->common.unacked_lock); -return true; }
@@ -1484,6 +1481,7 @@ static bool batadv_tp_handle_out_of_order(struct batadv_tp_receiver *tp_vars,* @tp_vars: the private data of the current TP meter session */ static void batadv_tp_ack_unordered (struct batadv_tp_receiver *tp_vars) + __must_hold(&tp_vars->common.unacked_lock) {struct batadv_tp_unacked *un, *safe;u32 to_ack;
@@ -1491,7 +1489,6 @@ static void batadv_tp_ack_unordered(struct batadv_tp_receiver *tp_vars)/* go through the unacked packet list and possibly ACK them as * well */ -spin_lock_bh (&tp_vars->common.unacked_lock);list_for_each_entry_safe (un, safe, &tp_vars->common.unacked_list, list) {/* the list is ordered, therefore it is possible to stop as soon * there is a gap between the last acked seqno and the seqno of
@@ -1509,7 +1506,6 @@ static void batadv_tp_ack_unordered(struct batadv_tp_receiver *tp_vars)kfree (un); tp_vars->common.unacked_count--; } -spin_unlock_bh (&tp_vars->common.unacked_lock); }/**
@@ -1588,6 +1584,7 @@ static void batadv_tp_recv_msg(struct batadv_priv *bat_priv,const struct batadv_icmp_tp_packet *icmp;struct batadv_tp_receiver *tp_vars;size_t packet_size; +u32 to_ack;u32 seqno; icmp = (struct batadv_icmp_tp_packet *)skb->data;
@@ -1616,6 +1613,8 @@ static void batadv_tp_recv_msg(struct batadv_priv *bat_priv,WRITE_ONCE (tp_vars->last_recv_time, jiffies); } +spin_lock_bh (&tp_vars->common.unacked_lock); +/* if the packet is a duplicate, it may be the case that an ACK has been * lost. Resend the ACK */
@@ -1627,8 +1626,10 @@ static void batadv_tp_recv_msg(struct batadv_priv *bat_priv,/* exit immediately (and do not send any ACK) if the packet has * not been enqueued correctly */ -if (!batadv_tp_handle_out_of_order (tp_vars, skb)) +if (!batadv_tp_handle_out_of_order (tp_vars, skb)) { +spin_unlock_bh (&tp_vars->common.unacked_lock); goto out; + }/* send a duplicate ACK */ goto send_ack;
@@ -1642,11 +1643,14 @@ static void batadv_tp_recv_msg(struct batadv_priv *bat_priv,batadv_tp_ack_unordered (tp_vars); send_ack: + to_ack = tp_vars->last_recv; +spin_unlock_bh (&tp_vars->common.unacked_lock); +/* send the ACK. If the received packet was out of order, the ACK that * is going to be sent is a duplicate (the sender will count them and * possibly enter Fast Retransmit as soon as it has reached 3) */ -batadv_tp_send_ack (bat_priv, icmp->orig, tp_vars->last_recv, +batadv_tp_send_ack (bat_priv, icmp->orig, to_ack, icmp->timestamp, icmp->session, icmp->uid); out:batadv_tp_receiver_put (tp_vars);
net/batman-adv/types.h +1 -1
@@ -1363,7 +1363,7 @@ struct batadv_tp_vars_common {/** @unacked_list: list of unacked packets (meta-info only) */ struct list_head unacked_list; -/** @unacked_lock: protect unacked_list */ +/** @unacked_lock: protect unacked_list + &batadv_tp_receiver.last_recv */ spinlock_t unacked_lock;/** @unacked_count: number of unacked entries */
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 10/15 batman-adv: tp_meter: handle overlapping packets
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
If the size of the packets would change during the transmission, it could happen that some retries of packets are overlapping. In this case, precise comparisons of sequence numbers by the receiver would be wrong. It is then necessary to check if the start sequence number to the end sequence number ("seqno + length") would contain a new range.
If this is the case then this is enough to accept this packet. In all other cases, the packet still has to be dropped (and not acked).
--- net/batman-adv/tp_meter.c | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-)
net/batman-adv/tp_meter.c +11 -14
@@ -1392,7 +1392,8 @@ static int batadv_tp_send_ack(struct batadv_priv *bat_priv, const u8 *dst,/** * batadv_tp_handle_out_of_order() - store an out of order packet * @tp_vars: the private data of the current TP meter session -* @skb: the buffer containing the received packet +* @seqno: sequence number of new received packet +* @payload_len: length of the received packet * * Store the out of order packet in the unacked list for late processing. This * packets are kept in this list so that they can be ACKed at once as soon as
@@ -1401,22 +1402,17 @@ static int batadv_tp_send_ack(struct batadv_priv *bat_priv, const u8 *dst,* Return: true if the packed has been successfully processed, false otherwise */ static bool batadv_tp_handle_out_of_order (struct batadv_tp_receiver *tp_vars, -const struct sk_buff *skb) +u32 seqno,u32 payload_len) __must_hold(&tp_vars->common.unacked_lock) { -const struct batadv_icmp_tp_packet *icmp;struct batadv_tp_unacked *un, *new; -u32 payload_len;bool added = false; new =kmalloc_obj (*new,GFP_ATOMIC );if (unlikely (!new))return false; - icmp = (struct batadv_icmp_tp_packet *)skb->data; - - new->seqno =ntohl (icmp->seqno); - payload_len = skb->len -sizeof (struct batadv_unicast_packet ); + new->seqno = seqno; new->len = payload_len;/* if the list is empty immediately attach this new object */
@@ -1583,7 +1579,7 @@ static void batadv_tp_recv_msg(struct batadv_priv *bat_priv, {const struct batadv_icmp_tp_packet *icmp;struct batadv_tp_receiver *tp_vars; -size_t packet_size; +u32 payload_len;u32 to_ack;u32 seqno;
@@ -1618,15 +1614,17 @@ static void batadv_tp_recv_msg(struct batadv_priv *bat_priv,/* if the packet is a duplicate, it may be the case that an ACK has been * lost. Resend the ACK */ -if (batadv_seq_before (seqno, tp_vars->last_recv)) + payload_len = skb->len -sizeof (struct batadv_unicast_packet ); + to_ack = seqno + payload_len; +if (batadv_seq_before (to_ack, tp_vars->last_recv)) goto send_ack;/* if the packet is out of order enqueue it */ -if (ntohl (icmp->seqno) != tp_vars->last_recv) { +if (batadv_seq_before (tp_vars->last_recv, seqno)) {/* exit immediately (and do not send any ACK) if the packet has * not been enqueued correctly */ -if (!batadv_tp_handle_out_of_order (tp_vars, skb)) { +if (!batadv_tp_handle_out_of_order (tp_vars, seqno, payload_len)) {spin_unlock_bh (&tp_vars->common.unacked_lock); goto out; }
@@ -1636,8 +1634,7 @@ static void batadv_tp_recv_msg(struct batadv_priv *bat_priv, }/* if everything was fine count the ACKed bytes */ - packet_size = skb->len -sizeof (struct batadv_unicast_packet ); - tp_vars->last_recv += packet_size; + tp_vars->last_recv = to_ack;/* check if this ordered message filled a gap.... */ batadv_tp_ack_unordered (tp_vars);
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 11/15 batman-adv: tt: don't merge change entries with different VIDs
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
batadv_tt_local_event() merges/cancels events for the same client which would conflict or be duplicates. The matching of the queued events only compares the MAC address - the VLAN ID stored in each event is ignored.
If a MAC would now appear on multiple VID, the two ADD change events (for VID 1 and VID 2) would be merged to a single vid event. The remote can therefore not calculate the correct TT table and desync. A full translation table exchange is required to recover from this state.
A check of VID is therefore necessary to avoid such wrong merges/cancels.
--- net/batman-adv/translation-table.c | 3 +++ 1 file changed, 3 insertions(+)
net/batman-adv/translation-table.c +3 -0
@@ -447,6 +447,9 @@ static void batadv_tt_local_event(struct batadv_priv *bat_priv,if (!batadv_compare_eth (entry->change.addr, common->addr))continue ; +if (entry->change.vid != tt_change_node->change.vid) +continue ; + del_op_entry = entry->change.flags &BATADV_TT_CLIENT_DEL ;if (del_op_requested != del_op_entry) {/* DEL+ADD in the same orig interval have no effect and
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 12/15 batman-adv: tt: track roam count per VID
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
batadv_tt_check_roam_count() is supposed to track roaming of a TT entry. But TT entries are for a MAC + VID. The VID was completely missed and thus leads to incorrect detection of ROAM counts when a client MAC exists in multiple VLANs.
--- net/batman-adv/translation-table.c | 9 +++++++-- net/batman-adv/types.h | 3 +++ 2 files changed, 10 insertions(+), 2 deletions(-)
net/batman-adv/translation-table.c +7 -2
@@ -3450,6 +3450,7 @@ static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)* batadv_tt_check_roam_count() - check if a client has roamed too frequently * @bat_priv: the bat priv with all the mesh interface information * @client: mac address of the roaming client +* @vid: VLAN identifier * * This function checks whether the client already reached the * maximum number of possible roaming phases. In this case the ROAMING_ADV
@@ -3457,7 +3458,7 @@ static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)* * Return: true if the ROAMING_ADV can be sent, false otherwise */ -static bool batadv_tt_check_roam_count (struct batadv_priv *bat_priv,u8 *client) +static bool batadv_tt_check_roam_count (struct batadv_priv *bat_priv,u8 *client,u16 vid) {struct batadv_tt_roam_node *tt_roam_node;bool ret = false;
@@ -3470,6 +3471,9 @@ static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)if (!batadv_compare_eth (tt_roam_node->addr, client))continue ; +if (tt_roam_node->vid != vid) +continue ; +if (batadv_has_timed_out (tt_roam_node->first_time,BATADV_ROAMING_MAX_TIME ))continue ;
@@ -3491,6 +3495,7 @@ static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)atomic_set (&tt_roam_node->counter,BATADV_ROAMING_MAX_COUNT -1 );ether_addr_copy (tt_roam_node->addr, client); + tt_roam_node->vid = vid;list_add (&tt_roam_node->list, &bat_priv->tt.roam_list); ret = true;
@@ -3527,7 +3532,7 @@ static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,/* before going on we have to check whether the client has * already roamed to us too many times */ -if (!batadv_tt_check_roam_count (bat_priv, client)) +if (!batadv_tt_check_roam_count (bat_priv, client, vid)) goto out; batadv_dbg(BATADV_DBG_TT, bat_priv,
net/batman-adv/types.h +3 -0
@@ -1961,6 +1961,9 @@ struct batadv_tt_roam_node {/** @addr: mac address of the client in the roaming phase */ u8 addr[ETH_ALEN ]; +/** @vid: VLAN identifier */ +u16 vid; +/** * @counter: number of allowed roaming events per client within a single * OGM interval (changes are committed with each OGM)
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 13/15 batman-adv: dat: prevent false sharing between VLANs
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
The local hash of DAT entries is supposed to be VLAN (VID) aware. But the adding to the hash and the search in the hash were not checking the VID information of the hash entries. The entries would therefore only be correctly separated when batadv_hash_dat() didn't select the same buckets for different VIDs.
--- net/batman-adv/distributed-arp-table.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
net/batman-adv/distributed-arp-table.c +9 -3
@@ -215,10 +215,13 @@ static void batadv_dat_purge(struct work_struct *work)*/ static bool batadv_compare_dat (const struct hlist_node *node,const void *data2) { - const void *data1 = container_of(node, struct batadv_dat_entry, - hash_entry); +const struct batadv_dat_entry *entry1; +const struct batadv_dat_entry *entry2; -return memcmp (data1, data2,sizeof (__be32)) ==0 ; + entry1 = container_of(node, struct batadv_dat_entry, hash_entry); + entry2 = data2; + +return entry1->ip == entry2->ip && entry1->vid == entry2->vid; }/**
@@ -345,6 +348,9 @@ batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip,if (dat_entry->ip != ip)continue ; +if (dat_entry->vid != vid) +continue ; +if (!kref_get_unless_zero (&dat_entry->refcount))continue ;
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 14/15 batman-adv: tvlv: enforce 2-byte alignment
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
The fields of an aggregated OGM(v2) are accessed assuming (at least) 2-byte alignment, so a following OGM must start at an even offset. As the header length is even, an odd tvlv_len would misalign it and trigger unaligned accesses on strict-alignment architectures.
Such a misaligned TVLV/OGM/OGMv2 is not created by a normal participant in the mesh. Therefore, reject such malformed packets.
--- net/batman-adv/bat_iv_ogm.c | 11 ++++++++++- net/batman-adv/bat_v_ogm.c | 11 ++++++++++- net/batman-adv/routing.c | 6 ++++++ net/batman-adv/tvlv.c | 6 ++++++ 4 files changed, 32 insertions(+), 2 deletions(-)
net/batman-adv/bat_iv_ogm.c +10 -1
@@ -316,14 +316,23 @@ batadv_iv_ogm_aggr_packet(int buff_pos, int packet_len, const struct batadv_ogm_packet *ogm_packet) {int next_buff_pos =0 ; +u16 tvlv_len;/* check if there is enough space for the header */ next_buff_pos += buff_pos +sizeof (*ogm_packet);if (next_buff_pos > packet_len)return false; + tvlv_len =ntohs (ogm_packet->tvlv_len); + +/* the fields of an aggregated OGM are accessed assuming (at least) +* 2-byte alignment, so a following OGM must start at an even offset. +*/ +if (tvlv_len &1 ) +return false; +/* check if there is enough space for the optional TVLV */ - next_buff_pos +=ntohs (ogm_packet->tvlv_len); + next_buff_pos += tvlv_len;return next_buff_pos <= packet_len; }
net/batman-adv/bat_v_ogm.c +10 -1
@@ -849,14 +849,23 @@ batadv_v_ogm_aggr_packet(int buff_pos, int packet_len, const struct batadv_ogm2_packet *ogm2_packet) {int next_buff_pos =0 ; +u16 tvlv_len;/* check if there is enough space for the header */ next_buff_pos += buff_pos +sizeof (*ogm2_packet);if (next_buff_pos > packet_len)return false; + tvlv_len =ntohs (ogm2_packet->tvlv_len); + +/* the fields of an aggregated OGMv2 are accessed assuming (at least) +* 2-byte alignment, so a following OGMv2 must start at an even offset. +*/ +if (tvlv_len &1 ) +return false; +/* check if there is enough space for the optional TVLV */ - next_buff_pos +=ntohs (ogm2_packet->tvlv_len); + next_buff_pos += tvlv_len;return next_buff_pos <= packet_len; }
net/batman-adv/routing.c +6 -0
@@ -1366,6 +1366,12 @@ int batadv_recv_mcast_packet(struct sk_buff *skb,if (tvlv_buff_len > skb->len - hdr_size) goto free_skb; +/* the fields of an multicast payload are accessed assuming (at least) +* 2-byte alignment, so a following packet must start at an even offset. +*/ +if (tvlv_buff_len &1 ) + goto free_skb; + ret =batadv_tvlv_containers_process (bat_priv,BATADV_MCAST ,NULL , skb, tvlv_buff, tvlv_buff_len);if (ret >=0 ) {
net/batman-adv/tvlv.c +6 -0
@@ -477,6 +477,12 @@ int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,if (tvlv_value_cont_len > tvlv_value_len)break ; +/* the next tvlv header is accessed assuming (at least) 2-byte +* alignment, so it must start at an even offset. +*/ +if (tvlv_value_cont_len &1 ) +break ; + tvlv_handler =batadv_tvlv_handler_get (bat_priv, tvlv_hdr->type, tvlv_hdr->version);
Signature · 1 line
2.47.3
Simon Wunderlich
maintainerPATCH 15/15 batman-adv: tvlv: avoid race of cifsnotfound handler state
In reply to Simon WunderlichFrom: Sven Eckelmann <[email protected]>
TVLV handlers can have the flag BATADV_TVLV_HANDLER_OGM_CIFNOTFND set to signal that the OGM handler should be called (with NULL for data) when the specific TVLV container was not found in the OGM. This is used by:
* DAT
* GW
* Multicast (OGM + Tracker)
The state whether the handler was executed was stored in the struct batadv_tvlv_handler. But the TVLV processing is started without any lock. Multiple parallel contexts processing TVLVs would therefore overwrite each others BATADV_TVLV_HANDLER_OGM_CALLED flag in the shared batadv_tvlv_handler.
Drop the shared BATADV_TVLV_HANDLER_OGM_CALLED flag and instead determine, per TVLV buffer, whether a matching container was present by scanning the packet's buffer.
--- net/batman-adv/tvlv.c | 63 ++++++++++++++++++++++++++++++++++++++---- net/batman-adv/types.h | 7 ----- 2 files changed, 57 insertions(+), 13 deletions(-)
net/batman-adv/tvlv.c +57 -6
@@ -411,7 +411,6 @@ static int batadv_tvlv_call_handler(struct batadv_priv *bat_priv, tvlv_handler->ogm_handler (bat_priv, orig_node,BATADV_NO_FLAGS , tvlv_value, tvlv_value_len); - tvlv_handler->flags |=BATADV_TVLV_HANDLER_OGM_CALLED ;break ;case BATADV_UNICAST_TVLV :if (!skb)
@@ -443,6 +442,48 @@ static int batadv_tvlv_call_handler(struct batadv_priv *bat_priv,return NET_RX_SUCCESS ; } +/** +* batadv_tvlv_containers_contain() - check if a tvlv buffer holds a container +* @tvlv_value: tvlv content +* @tvlv_value_len: tvlv content length +* @type: tvlv container type to look for +* @version: tvlv container version to look for +* +* Return: true if a container of the given type and version is present in the +* tvlv buffer, false otherwise. +*/ +static bool batadv_tvlv_containers_contain (void *tvlv_value, +u16 tvlv_value_len,u8 type, +u8 version) +{ +struct batadv_tvlv_hdr *tvlv_hdr; +u16 tvlv_value_cont_len; + +while (tvlv_value_len >=sizeof (*tvlv_hdr)) { + tvlv_hdr = tvlv_value; + tvlv_value_cont_len =ntohs (tvlv_hdr->len); + tvlv_value = tvlv_hdr +1 ; + tvlv_value_len -=sizeof (*tvlv_hdr); + +if (tvlv_value_cont_len > tvlv_value_len) +break ; + +/* the next tvlv header is accessed assuming (at least) 2-byte +* alignment, so it must start at an even offset. +*/ +if (tvlv_value_cont_len &1 ) +break ; + +if (tvlv_hdr->type == type && tvlv_hdr->version == version) +return true; + + tvlv_value = (u8 *)tvlv_value + tvlv_value_cont_len; + tvlv_value_len -= tvlv_value_cont_len; + } + +return false; +} +/** * batadv_tvlv_containers_process() - parse the given tvlv buffer to call the * appropriate handlers
@@ -462,7 +503,9 @@ int batadv_tvlv_containers_process(struct batadv_priv *bat_priv, struct sk_buff *skb, void *tvlv_value, u16 tvlv_value_len) { + u16 tvlv_value_start_len = tvlv_value_len;struct batadv_tvlv_handler *tvlv_handler; +void *tvlv_value_start = tvlv_value;struct batadv_tvlv_hdr *tvlv_hdr;u16 tvlv_value_cont_len;u8 cifnotfound =BATADV_TVLV_HANDLER_OGM_CIFNOTFND ;
@@ -506,12 +549,20 @@ int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,if (!tvlv_handler->ogm_handler)continue ; -if ((tvlv_handler->flags &BATADV_TVLV_HANDLER_OGM_CIFNOTFND ) && - !(tvlv_handler->flags &BATADV_TVLV_HANDLER_OGM_CALLED )) - tvlv_handler->ogm_handler (bat_priv, orig_node, - cifnotfound,NULL ,0 ); +if (!(tvlv_handler->flags &BATADV_TVLV_HANDLER_OGM_CIFNOTFND )) +continue ; - tvlv_handler->flags &= ~BATADV_TVLV_HANDLER_OGM_CALLED ; +/* if the corresponding container was present then the handler +* was already called from the loop above +*/ +if (batadv_tvlv_containers_contain (tvlv_value_start, + tvlv_value_start_len, + tvlv_handler->type, + tvlv_handler->version)) +continue ; + + tvlv_handler->ogm_handler (bat_priv, orig_node, + cifnotfound,NULL ,0 ); }rcu_read_unlock ();
net/batman-adv/types.h +0 -7
@@ -2294,13 +2294,6 @@ enum batadv_tvlv_handler_flags {* will call this handler even if its type was not found (with no data) */ BATADV_TVLV_HANDLER_OGM_CIFNOTFND = BIT(1), - -/** -* @BATADV_TVLV_HANDLER_OGM_CALLED: interval tvlv handling flag - the -* API marks a handler as being called, so it won't be called if the -* BATADV_TVLV_HANDLER_OGM_CIFNOTFND flag was set -*/ - BATADV_TVLV_HANDLER_OGM_CALLED = BIT(2), };#endif /* _NET_BATMAN_ADV_TYPES_H_ */
Signature · 1 line
2.47.3