2019-06-04 08:11:33 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
2008-02-23 14:17:08 +00:00
|
|
|
/*
|
2009-11-09 23:46:58 +00:00
|
|
|
* Copyright (c) 2008, 2009 open80211s Ltd.
|
2024-02-06 12:45:55 +00:00
|
|
|
* Copyright (C) 2023-2024 Intel Corporation
|
2008-02-23 14:17:08 +00:00
|
|
|
* Authors: Luis Carlos Cobo <luisca@cozybit.com>
|
|
|
|
|
* Javier Cardona <javier@cozybit.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef IEEE80211S_H
|
|
|
|
|
#define IEEE80211S_H
|
|
|
|
|
|
2008-02-23 14:17:19 +00:00
|
|
|
#include <linux/types.h>
|
2008-02-23 14:17:08 +00:00
|
|
|
#include <linux/jhash.h>
|
2008-02-23 14:17:19 +00:00
|
|
|
#include "ieee80211_i.h"
|
2008-02-23 14:17:08 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Data structures */
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* enum mesh_path_flags - mac80211 mesh path flags
|
|
|
|
|
*
|
2009-01-19 11:50:32 +00:00
|
|
|
* @MESH_PATH_ACTIVE: the mesh path can be used for forwarding
|
|
|
|
|
* @MESH_PATH_RESOLVING: the discovery process is running for this mesh path
|
2009-11-09 23:46:55 +00:00
|
|
|
* @MESH_PATH_SN_VALID: the mesh path contains a valid destination sequence
|
2013-02-15 13:40:31 +00:00
|
|
|
* number
|
2008-02-23 14:17:08 +00:00
|
|
|
* @MESH_PATH_FIXED: the mesh path has been manually set and should not be
|
2013-02-15 13:40:31 +00:00
|
|
|
* modified
|
2008-02-23 14:17:08 +00:00
|
|
|
* @MESH_PATH_RESOLVED: the mesh path can has been resolved
|
2011-11-04 04:11:10 +00:00
|
|
|
* @MESH_PATH_REQ_QUEUED: there is an unsent path request for this destination
|
2013-02-15 13:40:31 +00:00
|
|
|
* already queued up, waiting for the discovery process to start.
|
2016-03-19 02:03:24 +00:00
|
|
|
* @MESH_PATH_DELETED: the mesh path has been deleted and should no longer
|
|
|
|
|
* be used
|
2008-02-23 14:17:08 +00:00
|
|
|
*
|
2009-01-19 11:50:32 +00:00
|
|
|
* MESH_PATH_RESOLVED is used by the mesh path timer to
|
2008-02-23 14:17:08 +00:00
|
|
|
* decide when to stop or cancel the mesh path discovery.
|
|
|
|
|
*/
|
|
|
|
|
enum mesh_path_flags {
|
|
|
|
|
MESH_PATH_ACTIVE = BIT(0),
|
|
|
|
|
MESH_PATH_RESOLVING = BIT(1),
|
2009-11-09 23:46:55 +00:00
|
|
|
MESH_PATH_SN_VALID = BIT(2),
|
2008-02-23 14:17:08 +00:00
|
|
|
MESH_PATH_FIXED = BIT(3),
|
|
|
|
|
MESH_PATH_RESOLVED = BIT(4),
|
2011-11-04 04:11:10 +00:00
|
|
|
MESH_PATH_REQ_QUEUED = BIT(5),
|
2016-03-19 02:03:24 +00:00
|
|
|
MESH_PATH_DELETED = BIT(6),
|
2008-02-23 14:17:08 +00:00
|
|
|
};
|
|
|
|
|
|
2009-08-10 19:15:52 +00:00
|
|
|
/**
|
|
|
|
|
* enum mesh_deferred_task_flags - mac80211 mesh deferred tasks
|
|
|
|
|
*
|
|
|
|
|
*
|
|
|
|
|
*
|
|
|
|
|
* @MESH_WORK_HOUSEKEEPING: run the periodic mesh housekeeping tasks
|
2009-11-09 23:46:56 +00:00
|
|
|
* @MESH_WORK_ROOT: the mesh root station needs to send a frame
|
2012-03-31 18:31:32 +00:00
|
|
|
* @MESH_WORK_DRIFT_ADJUST: time to compensate for clock drift relative to other
|
|
|
|
|
* mesh nodes
|
2013-06-13 22:54:41 +00:00
|
|
|
* @MESH_WORK_MBSS_CHANGED: rebuild beacon and notify driver of BSS changes
|
2009-08-10 19:15:52 +00:00
|
|
|
*/
|
|
|
|
|
enum mesh_deferred_task_flags {
|
|
|
|
|
MESH_WORK_HOUSEKEEPING,
|
2009-11-09 23:46:56 +00:00
|
|
|
MESH_WORK_ROOT,
|
2012-03-31 18:31:32 +00:00
|
|
|
MESH_WORK_DRIFT_ADJUST,
|
2013-06-13 22:54:41 +00:00
|
|
|
MESH_WORK_MBSS_CHANGED,
|
2009-08-10 19:15:52 +00:00
|
|
|
};
|
|
|
|
|
|
2008-02-23 14:17:08 +00:00
|
|
|
/**
|
|
|
|
|
* struct mesh_path - mac80211 mesh path structure
|
|
|
|
|
*
|
|
|
|
|
* @dst: mesh path destination mac address
|
2016-03-19 02:11:32 +00:00
|
|
|
* @mpp: mesh proxy mac address
|
|
|
|
|
* @rhash: rhashtable list pointer
|
2019-02-14 14:03:24 +00:00
|
|
|
* @walk_list: linked list containing all mesh_path objects.
|
2016-03-19 02:11:32 +00:00
|
|
|
* @gate_list: list pointer for known gates list
|
2008-08-03 00:04:37 +00:00
|
|
|
* @sdata: mesh subif
|
2008-02-23 14:17:08 +00:00
|
|
|
* @next_hop: mesh neighbor to which frames for this destination will be
|
2013-02-15 13:40:31 +00:00
|
|
|
* forwarded
|
2008-02-23 14:17:08 +00:00
|
|
|
* @timer: mesh path discovery timer
|
|
|
|
|
* @frame_queue: pending queue for frames sent to this destination while the
|
2013-02-15 13:40:31 +00:00
|
|
|
* path is unresolved
|
2016-03-19 02:11:32 +00:00
|
|
|
* @rcu: rcu head for freeing mesh path
|
2009-11-09 23:46:55 +00:00
|
|
|
* @sn: target sequence number
|
2008-02-23 14:17:08 +00:00
|
|
|
* @metric: current metric to this destination
|
|
|
|
|
* @hop_count: hops to destination
|
|
|
|
|
* @exp_time: in jiffies, when the path will expire or when it expired
|
|
|
|
|
* @discovery_timeout: timeout (lapse in jiffies) used for the last discovery
|
2013-02-15 13:40:31 +00:00
|
|
|
* retry
|
2008-02-23 14:17:08 +00:00
|
|
|
* @discovery_retries: number of discovery retries
|
|
|
|
|
* @flags: mesh path flags, as specified on &enum mesh_path_flags
|
2011-08-29 20:23:05 +00:00
|
|
|
* @state_lock: mesh path state lock used to protect changes to the
|
|
|
|
|
* mpath itself. No need to take this lock when adding or removing
|
|
|
|
|
* an mpath to a hash bucket on a path table.
|
2012-02-28 14:00:06 +00:00
|
|
|
* @rann_snd_addr: the RANN sender address
|
2012-03-23 10:48:51 +00:00
|
|
|
* @rann_metric: the aggregated path metric towards the root node
|
2012-06-13 18:06:10 +00:00
|
|
|
* @last_preq_to_root: Timestamp of last PREQ sent to root
|
2012-02-28 14:00:06 +00:00
|
|
|
* @is_root: the destination station of this path is a root node
|
2011-08-09 23:45:08 +00:00
|
|
|
* @is_gate: the destination station of this path is a mesh gate
|
2019-01-15 23:28:43 +00:00
|
|
|
* @path_change_count: the number of path changes to destination
|
2024-02-06 12:45:55 +00:00
|
|
|
* @fast_tx_check: timestamp of last fast-xmit enable attempt
|
2008-02-23 14:17:08 +00:00
|
|
|
*
|
|
|
|
|
*
|
2016-03-19 02:11:32 +00:00
|
|
|
* The dst address is unique in the mesh path table. Since the mesh_path is
|
|
|
|
|
* protected by RCU, deleting the next_hop STA must remove / substitute the
|
|
|
|
|
* mesh_path structure and wait until that is no longer reachable before
|
|
|
|
|
* destroying the STA completely.
|
2008-02-23 14:17:08 +00:00
|
|
|
*/
|
|
|
|
|
struct mesh_path {
|
|
|
|
|
u8 dst[ETH_ALEN];
|
2008-09-22 05:30:32 +00:00
|
|
|
u8 mpp[ETH_ALEN]; /* used for MPP or MAP */
|
2016-03-02 15:09:20 +00:00
|
|
|
struct rhash_head rhash;
|
2019-02-14 14:03:24 +00:00
|
|
|
struct hlist_node walk_list;
|
2016-02-29 01:03:59 +00:00
|
|
|
struct hlist_node gate_list;
|
2008-08-03 00:04:37 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2011-05-13 12:15:49 +00:00
|
|
|
struct sta_info __rcu *next_hop;
|
2008-02-23 14:17:08 +00:00
|
|
|
struct timer_list timer;
|
|
|
|
|
struct sk_buff_head frame_queue;
|
|
|
|
|
struct rcu_head rcu;
|
2009-11-09 23:46:55 +00:00
|
|
|
u32 sn;
|
2008-02-23 14:17:08 +00:00
|
|
|
u32 metric;
|
|
|
|
|
u8 hop_count;
|
|
|
|
|
unsigned long exp_time;
|
|
|
|
|
u32 discovery_timeout;
|
|
|
|
|
u8 discovery_retries;
|
|
|
|
|
enum mesh_path_flags flags;
|
|
|
|
|
spinlock_t state_lock;
|
2012-02-28 14:00:06 +00:00
|
|
|
u8 rann_snd_addr[ETH_ALEN];
|
2012-03-23 10:48:51 +00:00
|
|
|
u32 rann_metric;
|
2012-06-13 18:06:10 +00:00
|
|
|
unsigned long last_preq_to_root;
|
wifi: mac80211: mesh fast xmit support
Previously, fast xmit only worked on interface types where initially a
sta lookup is performed, and a cached header can be attached to the sta,
requiring only some fields to be updated at runtime.
This technique is not directly applicable for a mesh device type due
to the dynamic nature of the topology and protocol. There are more
addresses that need to be filled, and there is an extra header with a
dynamic length based on the addressing mode.
Change the code to cache entries contain a copy of the mesh subframe header +
bridge tunnel header, as well as an embedded struct ieee80211_fast_tx, which
contains the information for building the 802.11 header.
Add a mesh specific early fast xmit call, which looks up a cached entry and
adds only the mesh subframe header, before passing it over to the generic
fast xmit code.
To ensure the changes in network are reflected in these cached headers,
flush affected cached entries on path changes, as well as other conditions
that currently trigger a fast xmit check in other modes (key changes etc.)
This code is loosely based on a previous implementation by:
Sriram R <quic_srirrama@quicinc.com>
Cc: Sriram R <quic_srirrama@quicinc.com>
Signed-off-by: Ryder Lee <ryder.lee@mediatek.com>
Signed-off-by: Felix Fietkau <nbd@nbd.name>
Link: https://lore.kernel.org/r/20230314095956.62085-4-nbd@nbd.name
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2023-03-14 09:59:53 +00:00
|
|
|
unsigned long fast_tx_check;
|
2012-02-28 14:00:06 +00:00
|
|
|
bool is_root;
|
2011-08-09 23:45:08 +00:00
|
|
|
bool is_gate;
|
2019-01-15 23:28:43 +00:00
|
|
|
u32 path_change_count;
|
2008-02-23 14:17:08 +00:00
|
|
|
};
|
|
|
|
|
|
wifi: mac80211: mesh fast xmit support
Previously, fast xmit only worked on interface types where initially a
sta lookup is performed, and a cached header can be attached to the sta,
requiring only some fields to be updated at runtime.
This technique is not directly applicable for a mesh device type due
to the dynamic nature of the topology and protocol. There are more
addresses that need to be filled, and there is an extra header with a
dynamic length based on the addressing mode.
Change the code to cache entries contain a copy of the mesh subframe header +
bridge tunnel header, as well as an embedded struct ieee80211_fast_tx, which
contains the information for building the 802.11 header.
Add a mesh specific early fast xmit call, which looks up a cached entry and
adds only the mesh subframe header, before passing it over to the generic
fast xmit code.
To ensure the changes in network are reflected in these cached headers,
flush affected cached entries on path changes, as well as other conditions
that currently trigger a fast xmit check in other modes (key changes etc.)
This code is loosely based on a previous implementation by:
Sriram R <quic_srirrama@quicinc.com>
Cc: Sriram R <quic_srirrama@quicinc.com>
Signed-off-by: Ryder Lee <ryder.lee@mediatek.com>
Signed-off-by: Felix Fietkau <nbd@nbd.name>
Link: https://lore.kernel.org/r/20230314095956.62085-4-nbd@nbd.name
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2023-03-14 09:59:53 +00:00
|
|
|
#define MESH_FAST_TX_CACHE_MAX_SIZE 512
|
|
|
|
|
#define MESH_FAST_TX_CACHE_THRESHOLD_SIZE 384
|
|
|
|
|
#define MESH_FAST_TX_CACHE_TIMEOUT 8000 /* msecs */
|
|
|
|
|
|
2024-04-15 12:18:11 +00:00
|
|
|
/**
|
|
|
|
|
* enum ieee80211_mesh_fast_tx_type - cached mesh fast tx entry type
|
|
|
|
|
*
|
|
|
|
|
* @MESH_FAST_TX_TYPE_LOCAL: tx from the local vif address as SA
|
|
|
|
|
* @MESH_FAST_TX_TYPE_PROXIED: local tx with a different SA (e.g. bridged)
|
|
|
|
|
* @MESH_FAST_TX_TYPE_FORWARDED: forwarded from a different mesh point
|
|
|
|
|
* @NUM_MESH_FAST_TX_TYPE: number of entry types
|
|
|
|
|
*/
|
|
|
|
|
enum ieee80211_mesh_fast_tx_type {
|
|
|
|
|
MESH_FAST_TX_TYPE_LOCAL,
|
|
|
|
|
MESH_FAST_TX_TYPE_PROXIED,
|
|
|
|
|
MESH_FAST_TX_TYPE_FORWARDED,
|
|
|
|
|
|
|
|
|
|
/* must be last */
|
|
|
|
|
NUM_MESH_FAST_TX_TYPE
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct ieee80211_mesh_fast_tx_key - cached mesh fast tx entry key
|
|
|
|
|
*
|
|
|
|
|
* @addr: The Ethernet DA for this entry
|
|
|
|
|
* @type: cache entry type
|
|
|
|
|
*/
|
|
|
|
|
struct ieee80211_mesh_fast_tx_key {
|
|
|
|
|
u8 addr[ETH_ALEN] __aligned(2);
|
|
|
|
|
u16 type;
|
|
|
|
|
};
|
|
|
|
|
|
wifi: mac80211: mesh fast xmit support
Previously, fast xmit only worked on interface types where initially a
sta lookup is performed, and a cached header can be attached to the sta,
requiring only some fields to be updated at runtime.
This technique is not directly applicable for a mesh device type due
to the dynamic nature of the topology and protocol. There are more
addresses that need to be filled, and there is an extra header with a
dynamic length based on the addressing mode.
Change the code to cache entries contain a copy of the mesh subframe header +
bridge tunnel header, as well as an embedded struct ieee80211_fast_tx, which
contains the information for building the 802.11 header.
Add a mesh specific early fast xmit call, which looks up a cached entry and
adds only the mesh subframe header, before passing it over to the generic
fast xmit code.
To ensure the changes in network are reflected in these cached headers,
flush affected cached entries on path changes, as well as other conditions
that currently trigger a fast xmit check in other modes (key changes etc.)
This code is loosely based on a previous implementation by:
Sriram R <quic_srirrama@quicinc.com>
Cc: Sriram R <quic_srirrama@quicinc.com>
Signed-off-by: Ryder Lee <ryder.lee@mediatek.com>
Signed-off-by: Felix Fietkau <nbd@nbd.name>
Link: https://lore.kernel.org/r/20230314095956.62085-4-nbd@nbd.name
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2023-03-14 09:59:53 +00:00
|
|
|
/**
|
|
|
|
|
* struct ieee80211_mesh_fast_tx - cached mesh fast tx entry
|
|
|
|
|
* @rhash: rhashtable pointer
|
2024-04-15 12:18:11 +00:00
|
|
|
* @key: the lookup key for this cache entry
|
wifi: mac80211: mesh fast xmit support
Previously, fast xmit only worked on interface types where initially a
sta lookup is performed, and a cached header can be attached to the sta,
requiring only some fields to be updated at runtime.
This technique is not directly applicable for a mesh device type due
to the dynamic nature of the topology and protocol. There are more
addresses that need to be filled, and there is an extra header with a
dynamic length based on the addressing mode.
Change the code to cache entries contain a copy of the mesh subframe header +
bridge tunnel header, as well as an embedded struct ieee80211_fast_tx, which
contains the information for building the 802.11 header.
Add a mesh specific early fast xmit call, which looks up a cached entry and
adds only the mesh subframe header, before passing it over to the generic
fast xmit code.
To ensure the changes in network are reflected in these cached headers,
flush affected cached entries on path changes, as well as other conditions
that currently trigger a fast xmit check in other modes (key changes etc.)
This code is loosely based on a previous implementation by:
Sriram R <quic_srirrama@quicinc.com>
Cc: Sriram R <quic_srirrama@quicinc.com>
Signed-off-by: Ryder Lee <ryder.lee@mediatek.com>
Signed-off-by: Felix Fietkau <nbd@nbd.name>
Link: https://lore.kernel.org/r/20230314095956.62085-4-nbd@nbd.name
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2023-03-14 09:59:53 +00:00
|
|
|
* @fast_tx: base fast_tx data
|
|
|
|
|
* @hdr: cached mesh and rfc1042 headers
|
|
|
|
|
* @hdrlen: length of mesh + rfc1042
|
|
|
|
|
* @walk_list: list containing all the fast tx entries
|
|
|
|
|
* @mpath: mesh path corresponding to the Mesh DA
|
|
|
|
|
* @mppath: MPP entry corresponding to this DA
|
|
|
|
|
* @timestamp: Last used time of this entry
|
|
|
|
|
*/
|
|
|
|
|
struct ieee80211_mesh_fast_tx {
|
|
|
|
|
struct rhash_head rhash;
|
2024-04-15 12:18:11 +00:00
|
|
|
struct ieee80211_mesh_fast_tx_key key;
|
wifi: mac80211: mesh fast xmit support
Previously, fast xmit only worked on interface types where initially a
sta lookup is performed, and a cached header can be attached to the sta,
requiring only some fields to be updated at runtime.
This technique is not directly applicable for a mesh device type due
to the dynamic nature of the topology and protocol. There are more
addresses that need to be filled, and there is an extra header with a
dynamic length based on the addressing mode.
Change the code to cache entries contain a copy of the mesh subframe header +
bridge tunnel header, as well as an embedded struct ieee80211_fast_tx, which
contains the information for building the 802.11 header.
Add a mesh specific early fast xmit call, which looks up a cached entry and
adds only the mesh subframe header, before passing it over to the generic
fast xmit code.
To ensure the changes in network are reflected in these cached headers,
flush affected cached entries on path changes, as well as other conditions
that currently trigger a fast xmit check in other modes (key changes etc.)
This code is loosely based on a previous implementation by:
Sriram R <quic_srirrama@quicinc.com>
Cc: Sriram R <quic_srirrama@quicinc.com>
Signed-off-by: Ryder Lee <ryder.lee@mediatek.com>
Signed-off-by: Felix Fietkau <nbd@nbd.name>
Link: https://lore.kernel.org/r/20230314095956.62085-4-nbd@nbd.name
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2023-03-14 09:59:53 +00:00
|
|
|
|
|
|
|
|
struct ieee80211_fast_tx fast_tx;
|
|
|
|
|
u8 hdr[sizeof(struct ieee80211s_hdr) + sizeof(rfc1042_header)];
|
|
|
|
|
u16 hdrlen;
|
|
|
|
|
|
|
|
|
|
struct mesh_path *mpath, *mppath;
|
|
|
|
|
struct hlist_node walk_list;
|
|
|
|
|
unsigned long timestamp;
|
|
|
|
|
};
|
|
|
|
|
|
2008-02-23 14:17:08 +00:00
|
|
|
/* Recent multicast cache */
|
|
|
|
|
/* RMC_BUCKETS must be a power of 2, maximum 256 */
|
|
|
|
|
#define RMC_BUCKETS 256
|
|
|
|
|
#define RMC_QUEUE_MAX_LEN 4
|
|
|
|
|
#define RMC_TIMEOUT (3 * HZ)
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct rmc_entry - entry in the Recent Multicast Cache
|
|
|
|
|
*
|
|
|
|
|
* @seqnum: mesh sequence number of the frame
|
|
|
|
|
* @exp_time: expiration time of the entry, in jiffies
|
|
|
|
|
* @sa: source address of the frame
|
2016-03-19 02:11:32 +00:00
|
|
|
* @list: hashtable list pointer
|
2008-02-23 14:17:08 +00:00
|
|
|
*
|
|
|
|
|
* The Recent Multicast Cache keeps track of the latest multicast frames that
|
|
|
|
|
* have been received by a mesh interface and discards received multicast frames
|
|
|
|
|
* that are found in the cache.
|
|
|
|
|
*/
|
|
|
|
|
struct rmc_entry {
|
2016-03-19 02:11:29 +00:00
|
|
|
struct hlist_node list;
|
2008-02-23 14:17:08 +00:00
|
|
|
unsigned long exp_time;
|
2016-03-19 02:11:31 +00:00
|
|
|
u32 seqnum;
|
2008-02-23 14:17:08 +00:00
|
|
|
u8 sa[ETH_ALEN];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct mesh_rmc {
|
2016-03-19 02:11:29 +00:00
|
|
|
struct hlist_head bucket[RMC_BUCKETS];
|
2008-04-23 19:15:29 +00:00
|
|
|
u32 idx_mask;
|
2008-02-23 14:17:08 +00:00
|
|
|
};
|
|
|
|
|
|
2011-08-12 02:35:15 +00:00
|
|
|
#define IEEE80211_MESH_HOUSEKEEPING_INTERVAL (60 * HZ)
|
2008-02-23 14:17:08 +00:00
|
|
|
|
|
|
|
|
#define MESH_PATH_EXPIRE (600 * HZ)
|
|
|
|
|
|
|
|
|
|
/* Default maximum number of plinks per interface */
|
|
|
|
|
#define MESH_MAX_PLINKS 256
|
|
|
|
|
|
|
|
|
|
/* Maximum number of paths per interface */
|
|
|
|
|
#define MESH_MAX_MPATHS 1024
|
|
|
|
|
|
2012-08-10 01:15:40 +00:00
|
|
|
/* Number of frames buffered per destination for unresolved destinations */
|
|
|
|
|
#define MESH_FRAME_QUEUE_LEN 10
|
|
|
|
|
|
2008-02-23 14:17:08 +00:00
|
|
|
/* Public interfaces */
|
|
|
|
|
/* Various */
|
2009-08-10 19:15:48 +00:00
|
|
|
int ieee80211_fill_mesh_addresses(struct ieee80211_hdr *hdr, __le16 *fc,
|
2009-11-17 12:34:04 +00:00
|
|
|
const u8 *da, const u8 *sa);
|
2015-09-25 06:42:00 +00:00
|
|
|
unsigned int ieee80211_new_mesh_header(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct ieee80211s_hdr *meshhdr,
|
|
|
|
|
const char *addr4or5, const char *addr6);
|
2013-02-15 13:40:31 +00:00
|
|
|
int mesh_rmc_check(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
const u8 *addr, struct ieee80211s_hdr *mesh_hdr);
|
2012-04-19 02:23:43 +00:00
|
|
|
bool mesh_matches_local(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct ieee802_11_elems *ie);
|
2013-02-15 13:40:31 +00:00
|
|
|
int mesh_add_meshconf_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
|
|
|
|
int mesh_add_meshid_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
|
|
|
|
int mesh_add_rsn_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
|
|
|
|
int mesh_add_vendor_ies(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
|
|
|
|
int mesh_add_ht_cap_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
|
|
|
|
int mesh_add_ht_oper_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
2015-08-27 13:00:18 +00:00
|
|
|
int mesh_add_vht_cap_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
|
|
|
|
int mesh_add_vht_oper_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
2019-07-24 16:33:56 +00:00
|
|
|
int mesh_add_he_cap_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb, u8 ie_len);
|
|
|
|
|
int mesh_add_he_oper_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
2020-05-28 19:34:32 +00:00
|
|
|
int mesh_add_he_6ghz_cap_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
2023-03-27 17:07:42 +00:00
|
|
|
int mesh_add_eht_cap_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb, u8 ie_len);
|
|
|
|
|
int mesh_add_eht_oper_ie(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
2008-08-03 00:04:37 +00:00
|
|
|
void mesh_rmc_free(struct ieee80211_sub_if_data *sdata);
|
|
|
|
|
int mesh_rmc_init(struct ieee80211_sub_if_data *sdata);
|
2008-02-23 14:17:08 +00:00
|
|
|
void ieee80211s_init(void);
|
2009-08-18 00:15:55 +00:00
|
|
|
void ieee80211s_update_metric(struct ieee80211_local *local,
|
2018-09-06 08:57:48 +00:00
|
|
|
struct sta_info *sta,
|
|
|
|
|
struct ieee80211_tx_status *st);
|
2008-02-23 14:17:19 +00:00
|
|
|
void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata);
|
2016-03-26 15:27:18 +00:00
|
|
|
void ieee80211_mesh_teardown_sdata(struct ieee80211_sub_if_data *sdata);
|
2013-02-14 19:20:13 +00:00
|
|
|
int ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata);
|
2008-09-10 22:01:49 +00:00
|
|
|
void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata);
|
2009-11-09 23:46:57 +00:00
|
|
|
void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh);
|
2012-09-30 15:07:19 +00:00
|
|
|
const struct ieee80211_mesh_sync_ops *ieee80211_mesh_sync_ops_get(u8 method);
|
2013-02-14 19:20:13 +00:00
|
|
|
/* wrapper for ieee80211_bss_info_change_notify() */
|
|
|
|
|
void ieee80211_mbss_info_change_notify(struct ieee80211_sub_if_data *sdata,
|
2023-06-04 09:11:26 +00:00
|
|
|
u64 changed);
|
2008-02-23 14:17:19 +00:00
|
|
|
|
2013-01-30 17:14:08 +00:00
|
|
|
/* mesh power save */
|
2023-06-04 09:11:26 +00:00
|
|
|
u64 ieee80211_mps_local_status_update(struct ieee80211_sub_if_data *sdata);
|
|
|
|
|
u64 ieee80211_mps_set_sta_local_pm(struct sta_info *sta,
|
2013-02-13 20:14:19 +00:00
|
|
|
enum nl80211_mesh_power_mode pm);
|
2013-01-30 17:14:08 +00:00
|
|
|
void ieee80211_mps_set_frame_flags(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sta_info *sta,
|
|
|
|
|
struct ieee80211_hdr *hdr);
|
|
|
|
|
void ieee80211_mps_sta_status_update(struct sta_info *sta);
|
|
|
|
|
void ieee80211_mps_rx_h_sta_process(struct sta_info *sta,
|
|
|
|
|
struct ieee80211_hdr *hdr);
|
|
|
|
|
void ieee80211_mpsp_trigger_process(u8 *qc, struct sta_info *sta,
|
|
|
|
|
bool tx, bool acked);
|
|
|
|
|
void ieee80211_mps_frame_release(struct sta_info *sta,
|
|
|
|
|
struct ieee802_11_elems *elems);
|
|
|
|
|
|
2008-02-23 14:17:08 +00:00
|
|
|
/* Mesh paths */
|
2013-02-15 13:40:31 +00:00
|
|
|
int mesh_nexthop_lookup(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
|
|
|
|
int mesh_nexthop_resolve(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
2008-08-03 00:04:37 +00:00
|
|
|
void mesh_path_start_discovery(struct ieee80211_sub_if_data *sdata);
|
2013-02-15 13:40:31 +00:00
|
|
|
struct mesh_path *mesh_path_lookup(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
const u8 *dst);
|
|
|
|
|
struct mesh_path *mpp_path_lookup(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
const u8 *dst);
|
|
|
|
|
int mpp_path_add(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
const u8 *dst, const u8 *mpp);
|
|
|
|
|
struct mesh_path *
|
|
|
|
|
mesh_path_lookup_by_idx(struct ieee80211_sub_if_data *sdata, int idx);
|
2014-09-12 06:58:50 +00:00
|
|
|
struct mesh_path *
|
|
|
|
|
mpp_path_lookup_by_idx(struct ieee80211_sub_if_data *sdata, int idx);
|
2008-02-23 14:17:08 +00:00
|
|
|
void mesh_path_fix_nexthop(struct mesh_path *mpath, struct sta_info *next_hop);
|
2008-08-03 00:04:37 +00:00
|
|
|
void mesh_path_expire(struct ieee80211_sub_if_data *sdata);
|
|
|
|
|
void mesh_rx_path_sel_frame(struct ieee80211_sub_if_data *sdata,
|
2013-02-15 13:40:31 +00:00
|
|
|
struct ieee80211_mgmt *mgmt, size_t len);
|
2013-03-29 13:38:39 +00:00
|
|
|
struct mesh_path *
|
|
|
|
|
mesh_path_add(struct ieee80211_sub_if_data *sdata, const u8 *dst);
|
2011-08-09 23:45:08 +00:00
|
|
|
|
|
|
|
|
int mesh_path_add_gate(struct mesh_path *mpath);
|
|
|
|
|
int mesh_path_send_to_gates(struct mesh_path *mpath);
|
|
|
|
|
int mesh_gate_num(struct ieee80211_sub_if_data *sdata);
|
2019-02-07 20:16:05 +00:00
|
|
|
u32 airtime_link_metric_get(struct ieee80211_local *local,
|
|
|
|
|
struct sta_info *sta);
|
2013-02-15 13:40:31 +00:00
|
|
|
|
2008-02-23 14:17:08 +00:00
|
|
|
/* Mesh plinks */
|
2012-04-19 02:23:43 +00:00
|
|
|
void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
|
2018-10-26 14:03:50 +00:00
|
|
|
u8 *hw_addr, struct ieee802_11_elems *ie,
|
|
|
|
|
struct ieee80211_rx_status *rx_status);
|
2008-08-03 00:04:37 +00:00
|
|
|
bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie);
|
2023-06-04 09:11:26 +00:00
|
|
|
u64 mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata);
|
2017-10-05 17:39:10 +00:00
|
|
|
void mesh_plink_timer(struct timer_list *t);
|
2008-02-23 14:17:08 +00:00
|
|
|
void mesh_plink_broken(struct sta_info *sta);
|
2023-06-04 09:11:26 +00:00
|
|
|
u64 mesh_plink_deactivate(struct sta_info *sta);
|
|
|
|
|
u64 mesh_plink_open(struct sta_info *sta);
|
|
|
|
|
u64 mesh_plink_block(struct sta_info *sta);
|
2008-08-03 00:04:37 +00:00
|
|
|
void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct ieee80211_mgmt *mgmt, size_t len,
|
|
|
|
|
struct ieee80211_rx_status *rx_status);
|
2013-02-06 18:17:21 +00:00
|
|
|
void mesh_sta_cleanup(struct sta_info *sta);
|
2008-02-23 14:17:08 +00:00
|
|
|
|
|
|
|
|
/* Private interfaces */
|
|
|
|
|
/* Mesh paths */
|
2013-02-15 13:40:31 +00:00
|
|
|
int mesh_path_error_tx(struct ieee80211_sub_if_data *sdata,
|
2013-11-13 07:39:12 +00:00
|
|
|
u8 ttl, const u8 *target, u32 target_sn,
|
|
|
|
|
u16 target_rcode, const u8 *ra);
|
2008-02-23 14:17:08 +00:00
|
|
|
void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta);
|
|
|
|
|
void mesh_path_flush_pending(struct mesh_path *mpath);
|
|
|
|
|
void mesh_path_tx_pending(struct mesh_path *mpath);
|
2021-12-30 19:55:47 +00:00
|
|
|
void mesh_pathtbl_init(struct ieee80211_sub_if_data *sdata);
|
2016-02-29 01:03:56 +00:00
|
|
|
void mesh_pathtbl_unregister(struct ieee80211_sub_if_data *sdata);
|
2013-02-15 13:40:31 +00:00
|
|
|
int mesh_path_del(struct ieee80211_sub_if_data *sdata, const u8 *addr);
|
2017-10-16 23:35:49 +00:00
|
|
|
void mesh_path_timer(struct timer_list *t);
|
2008-02-23 14:17:08 +00:00
|
|
|
void mesh_path_flush_by_nexthop(struct sta_info *sta);
|
2013-02-15 13:40:31 +00:00
|
|
|
void mesh_path_discard_frame(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb);
|
2009-11-09 23:46:56 +00:00
|
|
|
void mesh_path_tx_root_frame(struct ieee80211_sub_if_data *sdata);
|
2008-02-23 14:17:08 +00:00
|
|
|
|
2011-08-12 02:35:15 +00:00
|
|
|
bool mesh_action_is_path_sel(struct ieee80211_mgmt *mgmt);
|
wifi: mac80211: mesh fast xmit support
Previously, fast xmit only worked on interface types where initially a
sta lookup is performed, and a cached header can be attached to the sta,
requiring only some fields to be updated at runtime.
This technique is not directly applicable for a mesh device type due
to the dynamic nature of the topology and protocol. There are more
addresses that need to be filled, and there is an extra header with a
dynamic length based on the addressing mode.
Change the code to cache entries contain a copy of the mesh subframe header +
bridge tunnel header, as well as an embedded struct ieee80211_fast_tx, which
contains the information for building the 802.11 header.
Add a mesh specific early fast xmit call, which looks up a cached entry and
adds only the mesh subframe header, before passing it over to the generic
fast xmit code.
To ensure the changes in network are reflected in these cached headers,
flush affected cached entries on path changes, as well as other conditions
that currently trigger a fast xmit check in other modes (key changes etc.)
This code is loosely based on a previous implementation by:
Sriram R <quic_srirrama@quicinc.com>
Cc: Sriram R <quic_srirrama@quicinc.com>
Signed-off-by: Ryder Lee <ryder.lee@mediatek.com>
Signed-off-by: Felix Fietkau <nbd@nbd.name>
Link: https://lore.kernel.org/r/20230314095956.62085-4-nbd@nbd.name
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2023-03-14 09:59:53 +00:00
|
|
|
struct ieee80211_mesh_fast_tx *
|
2024-04-15 12:18:11 +00:00
|
|
|
mesh_fast_tx_get(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct ieee80211_mesh_fast_tx_key *key);
|
wifi: mac80211: mesh fast xmit support
Previously, fast xmit only worked on interface types where initially a
sta lookup is performed, and a cached header can be attached to the sta,
requiring only some fields to be updated at runtime.
This technique is not directly applicable for a mesh device type due
to the dynamic nature of the topology and protocol. There are more
addresses that need to be filled, and there is an extra header with a
dynamic length based on the addressing mode.
Change the code to cache entries contain a copy of the mesh subframe header +
bridge tunnel header, as well as an embedded struct ieee80211_fast_tx, which
contains the information for building the 802.11 header.
Add a mesh specific early fast xmit call, which looks up a cached entry and
adds only the mesh subframe header, before passing it over to the generic
fast xmit code.
To ensure the changes in network are reflected in these cached headers,
flush affected cached entries on path changes, as well as other conditions
that currently trigger a fast xmit check in other modes (key changes etc.)
This code is loosely based on a previous implementation by:
Sriram R <quic_srirrama@quicinc.com>
Cc: Sriram R <quic_srirrama@quicinc.com>
Signed-off-by: Ryder Lee <ryder.lee@mediatek.com>
Signed-off-by: Felix Fietkau <nbd@nbd.name>
Link: https://lore.kernel.org/r/20230314095956.62085-4-nbd@nbd.name
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2023-03-14 09:59:53 +00:00
|
|
|
bool ieee80211_mesh_xmit_fast(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb, u32 ctrl_flags);
|
|
|
|
|
void mesh_fast_tx_cache(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sk_buff *skb, struct mesh_path *mpath);
|
|
|
|
|
void mesh_fast_tx_gc(struct ieee80211_sub_if_data *sdata);
|
|
|
|
|
void mesh_fast_tx_flush_addr(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
const u8 *addr);
|
|
|
|
|
void mesh_fast_tx_flush_mpath(struct mesh_path *mpath);
|
|
|
|
|
void mesh_fast_tx_flush_sta(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct sta_info *sta);
|
|
|
|
|
void mesh_path_refresh(struct ieee80211_sub_if_data *sdata,
|
|
|
|
|
struct mesh_path *mpath, const u8 *addr);
|
2009-08-07 14:17:38 +00:00
|
|
|
|
2008-02-23 14:17:19 +00:00
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
2013-01-07 15:04:49 +00:00
|
|
|
static inline
|
2023-06-04 09:11:26 +00:00
|
|
|
u64 mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata)
|
2013-01-07 15:04:49 +00:00
|
|
|
{
|
|
|
|
|
atomic_inc(&sdata->u.mesh.estab_plinks);
|
2013-05-29 21:32:36 +00:00
|
|
|
return mesh_accept_plinks_update(sdata) | BSS_CHANGED_BEACON;
|
2013-01-07 15:04:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline
|
2023-06-04 09:11:26 +00:00
|
|
|
u64 mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata)
|
2013-01-07 15:04:49 +00:00
|
|
|
{
|
|
|
|
|
atomic_dec(&sdata->u.mesh.estab_plinks);
|
2013-05-29 21:32:36 +00:00
|
|
|
return mesh_accept_plinks_update(sdata) | BSS_CHANGED_BEACON;
|
2013-01-07 15:04:49 +00:00
|
|
|
}
|
|
|
|
|
|
2008-02-23 14:17:08 +00:00
|
|
|
static inline int mesh_plink_free_count(struct ieee80211_sub_if_data *sdata)
|
|
|
|
|
{
|
2008-09-10 22:01:49 +00:00
|
|
|
return sdata->u.mesh.mshcfg.dot11MeshMaxPeerLinks -
|
2012-10-09 20:27:47 +00:00
|
|
|
atomic_read(&sdata->u.mesh.estab_plinks);
|
2008-02-23 14:17:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool mesh_plink_availables(struct ieee80211_sub_if_data *sdata)
|
|
|
|
|
{
|
2008-02-25 15:27:46 +00:00
|
|
|
return (min_t(long, mesh_plink_free_count(sdata),
|
2008-02-23 14:17:08 +00:00
|
|
|
MESH_MAX_PLINKS - sdata->local->num_sta)) > 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void mesh_path_activate(struct mesh_path *mpath)
|
|
|
|
|
{
|
|
|
|
|
mpath->flags |= MESH_PATH_ACTIVE | MESH_PATH_RESOLVED;
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-17 01:37:50 +00:00
|
|
|
static inline bool mesh_path_sel_is_hwmp(struct ieee80211_sub_if_data *sdata)
|
|
|
|
|
{
|
|
|
|
|
return sdata->u.mesh.mesh_pp_id == IEEE80211_PATH_PROTOCOL_HWMP;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-24 11:18:28 +00:00
|
|
|
void mesh_path_flush_by_iface(struct ieee80211_sub_if_data *sdata);
|
2016-12-08 01:15:51 +00:00
|
|
|
void mesh_sync_adjust_tsf(struct ieee80211_sub_if_data *sdata);
|
2013-02-15 13:40:31 +00:00
|
|
|
void ieee80211s_stop(void);
|
2008-02-23 14:17:19 +00:00
|
|
|
#else
|
2010-12-17 01:37:50 +00:00
|
|
|
static inline bool mesh_path_sel_is_hwmp(struct ieee80211_sub_if_data *sdata)
|
|
|
|
|
{ return false; }
|
2012-04-24 11:18:28 +00:00
|
|
|
static inline void mesh_path_flush_by_iface(struct ieee80211_sub_if_data *sdata)
|
|
|
|
|
{}
|
2013-02-15 13:40:31 +00:00
|
|
|
static inline void ieee80211s_stop(void) {}
|
2008-02-23 14:17:19 +00:00
|
|
|
#endif
|
|
|
|
|
|
2008-02-23 14:17:08 +00:00
|
|
|
#endif /* IEEE80211S_H */
|
