* [PATCH wireless-next 07/15] wifi: cfg80211: hide scan internals
2025-06-09 18:35 [PATCH wireless-next 00/15] wifi: cfg80211/mac80211: updates - 2025-06-09 Miri Korenblit
@ 2025-06-09 18:35 ` Miri Korenblit
0 siblings, 0 replies; 2+ messages in thread
From: Miri Korenblit @ 2025-06-09 18:35 UTC (permalink / raw)
To: linux-wireless; +Cc: Johannes Berg, Benjamin Berg
From: Johannes Berg <johannes.berg@intel.com>
Hide the internal scan fields from mac80211 and drivers, the
'notified' variable is for internal tracking, and the 'info'
is output that's passed to cfg80211_scan_done() and stored
only for delayed userspace notification.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Reviewed-by: Benjamin Berg <benjamin.berg@intel.com>
Signed-off-by: Miri Korenblit <miriam.rachel.korenblit@intel.com>
---
include/net/cfg80211.h | 6 --
net/wireless/core.c | 4 +-
net/wireless/core.h | 11 ++-
net/wireless/nl80211.c | 97 +++++++++++----------
net/wireless/rdev-ops.h | 6 +-
net/wireless/scan.c | 188 +++++++++++++++++++++-------------------
net/wireless/sme.c | 40 ++++-----
net/wireless/trace.h | 23 ++---
8 files changed, 196 insertions(+), 179 deletions(-)
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index d1848dc8ec99..07368dd9a212 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -2645,8 +2645,6 @@ struct cfg80211_scan_6ghz_params {
* @wiphy: the wiphy this was for
* @scan_start: time (in jiffies) when the scan started
* @wdev: the wireless device to scan for
- * @info: (internal) information about completed scan
- * @notified: (internal) scan request was notified as done or aborted
* @no_cck: used to send probe requests at non CCK rate in 2GHz band
* @mac_addr: MAC address used with randomisation
* @mac_addr_mask: MAC address mask used with randomisation, bits that
@@ -2677,12 +2675,8 @@ struct cfg80211_scan_request {
u8 mac_addr[ETH_ALEN] __aligned(2);
u8 mac_addr_mask[ETH_ALEN] __aligned(2);
u8 bssid[ETH_ALEN] __aligned(2);
-
- /* internal */
struct wiphy *wiphy;
unsigned long scan_start;
- struct cfg80211_scan_info info;
- bool notified;
bool no_cck;
bool scan_6ghz;
u32 n_6ghz_params;
diff --git a/net/wireless/core.c b/net/wireless/core.c
index dcce326fdb8c..c82bced6c156 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -239,7 +239,7 @@ void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
rdev->opencount--;
- if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
+ if (rdev->scan_req && rdev->scan_req->req.wdev == wdev) {
if (WARN_ON(!rdev->scan_req->notified &&
(!rdev->int_scan_req ||
!rdev->int_scan_req->notified)))
@@ -1555,7 +1555,7 @@ static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
case NETDEV_DOWN:
wiphy_lock(&rdev->wiphy);
cfg80211_update_iface_num(rdev, wdev->iftype, -1);
- if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
+ if (rdev->scan_req && rdev->scan_req->req.wdev == wdev) {
if (WARN_ON(!rdev->scan_req->notified &&
(!rdev->int_scan_req ||
!rdev->int_scan_req->notified)))
diff --git a/net/wireless/core.h b/net/wireless/core.h
index c56a35040caa..b6bd7f4d6385 100644
--- a/net/wireless/core.h
+++ b/net/wireless/core.h
@@ -21,6 +21,13 @@
#define WIPHY_IDX_INVALID -1
+struct cfg80211_scan_request_int {
+ struct cfg80211_scan_info info;
+ bool notified;
+ /* must be last - variable members */
+ struct cfg80211_scan_request req;
+};
+
struct cfg80211_registered_device {
const struct cfg80211_ops *ops;
struct list_head list;
@@ -70,8 +77,8 @@ struct cfg80211_registered_device {
struct rb_root bss_tree;
u32 bss_generation;
u32 bss_entries;
- struct cfg80211_scan_request *scan_req; /* protected by RTNL */
- struct cfg80211_scan_request *int_scan_req;
+ struct cfg80211_scan_request_int *scan_req; /* protected by RTNL */
+ struct cfg80211_scan_request_int *int_scan_req;
struct sk_buff *scan_msg;
struct list_head sched_scan_req_list;
time64_t suspend_at;
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index fd5f79266471..42774c02a18f 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -9316,12 +9316,12 @@ nl80211_check_scan_flags(struct wiphy *wiphy, struct wireless_dev *wdev,
mac_addr = req->mac_addr;
mac_addr_mask = req->mac_addr_mask;
} else {
- struct cfg80211_scan_request *req = request;
+ struct cfg80211_scan_request_int *req = request;
randomness_flag = NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
- flags = &req->flags;
- mac_addr = req->mac_addr;
- mac_addr_mask = req->mac_addr_mask;
+ flags = &req->req.flags;
+ mac_addr = req->req.mac_addr;
+ mac_addr_mask = req->req.mac_addr_mask;
}
*flags = nla_get_u32(attrs[NL80211_ATTR_SCAN_FLAGS]);
@@ -9376,7 +9376,7 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
{
struct cfg80211_registered_device *rdev = info->user_ptr[0];
struct wireless_dev *wdev = info->user_ptr[1];
- struct cfg80211_scan_request *request;
+ struct cfg80211_scan_request_int *request;
struct nlattr *scan_freqs = NULL;
bool scan_freqs_khz = false;
struct nlattr *attr;
@@ -9428,21 +9428,21 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
if (ie_len > wiphy->max_scan_ie_len)
return -EINVAL;
- size = struct_size(request, channels, n_channels);
+ size = struct_size(request, req.channels, n_channels);
ssids_offset = size;
- size = size_add(size, array_size(sizeof(*request->ssids), n_ssids));
+ size = size_add(size, array_size(sizeof(*request->req.ssids), n_ssids));
ie_offset = size;
size = size_add(size, ie_len);
request = kzalloc(size, GFP_KERNEL);
if (!request)
return -ENOMEM;
- request->n_channels = n_channels;
+ request->req.n_channels = n_channels;
if (n_ssids)
- request->ssids = (void *)request + ssids_offset;
- request->n_ssids = n_ssids;
+ request->req.ssids = (void *)request + ssids_offset;
+ request->req.n_ssids = n_ssids;
if (ie_len)
- request->ie = (void *)request + ie_offset;
+ request->req.ie = (void *)request + ie_offset;
i = 0;
if (scan_freqs) {
@@ -9465,7 +9465,7 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
!cfg80211_wdev_channel_allowed(wdev, chan))
continue;
- request->channels[i] = chan;
+ request->req.channels[i] = chan;
i++;
}
} else {
@@ -9486,7 +9486,7 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
!cfg80211_wdev_channel_allowed(wdev, chan))
continue;
- request->channels[i] = chan;
+ request->req.channels[i] = chan;
i++;
}
}
@@ -9497,10 +9497,10 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
goto out_free;
}
- request->n_channels = i;
+ request->req.n_channels = i;
- for (i = 0; i < request->n_channels; i++) {
- struct ieee80211_channel *chan = request->channels[i];
+ for (i = 0; i < request->req.n_channels; i++) {
+ struct ieee80211_channel *chan = request->req.channels[i];
/* if we can go off-channel to the target channel we're good */
if (cfg80211_off_channel_oper_allowed(wdev, chan))
@@ -9519,22 +9519,23 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
err = -EINVAL;
goto out_free;
}
- request->ssids[i].ssid_len = nla_len(attr);
- memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
+ request->req.ssids[i].ssid_len = nla_len(attr);
+ memcpy(request->req.ssids[i].ssid,
+ nla_data(attr), nla_len(attr));
i++;
}
}
if (info->attrs[NL80211_ATTR_IE]) {
- request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
- memcpy((void *)request->ie,
+ request->req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
+ memcpy((void *)request->req.ie,
nla_data(info->attrs[NL80211_ATTR_IE]),
- request->ie_len);
+ request->req.ie_len);
}
for (i = 0; i < NUM_NL80211_BANDS; i++)
if (wiphy->bands[i])
- request->rates[i] =
+ request->req.rates[i] =
(1 << wiphy->bands[i]->n_bitrates) - 1;
if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
@@ -9554,16 +9555,16 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
err = ieee80211_get_ratemask(wiphy->bands[band],
nla_data(attr),
nla_len(attr),
- &request->rates[band]);
+ &request->req.rates[band]);
if (err)
goto out_free;
}
}
if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
- request->duration =
+ request->req.duration =
nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
- request->duration_mandatory =
+ request->req.duration_mandatory =
nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
}
@@ -9572,7 +9573,7 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
if (err)
goto out_free;
- request->no_cck =
+ request->req.no_cck =
nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
/* Initial implementation used NL80211_ATTR_MAC to set the specific
@@ -9585,19 +9586,21 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
* (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
*/
if (info->attrs[NL80211_ATTR_BSSID])
- memcpy(request->bssid,
+ memcpy(request->req.bssid,
nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
- else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
+ else if (!(request->req.flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
info->attrs[NL80211_ATTR_MAC])
- memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
+ memcpy(request->req.bssid,
+ nla_data(info->attrs[NL80211_ATTR_MAC]),
ETH_ALEN);
else
- eth_broadcast_addr(request->bssid);
+ eth_broadcast_addr(request->req.bssid);
- request->tsf_report_link_id = nl80211_link_id_or_invalid(info->attrs);
- request->wdev = wdev;
- request->wiphy = &rdev->wiphy;
- request->scan_start = jiffies;
+ request->req.tsf_report_link_id =
+ nl80211_link_id_or_invalid(info->attrs);
+ request->req.wdev = wdev;
+ request->req.wiphy = &rdev->wiphy;
+ request->req.scan_start = jiffies;
rdev->scan_req = request;
err = cfg80211_scan(rdev);
@@ -17899,7 +17902,7 @@ void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
static int nl80211_add_scan_req(struct sk_buff *msg,
struct cfg80211_registered_device *rdev)
{
- struct cfg80211_scan_request *req = rdev->scan_req;
+ struct cfg80211_scan_request_int *req = rdev->scan_req;
struct nlattr *nest;
int i;
struct cfg80211_scan_info *info;
@@ -17910,19 +17913,20 @@ static int nl80211_add_scan_req(struct sk_buff *msg,
nest = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_SSIDS);
if (!nest)
goto nla_put_failure;
- for (i = 0; i < req->n_ssids; i++) {
- if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
+ for (i = 0; i < req->req.n_ssids; i++) {
+ if (nla_put(msg, i, req->req.ssids[i].ssid_len,
+ req->req.ssids[i].ssid))
goto nla_put_failure;
}
nla_nest_end(msg, nest);
- if (req->flags & NL80211_SCAN_FLAG_FREQ_KHZ) {
+ if (req->req.flags & NL80211_SCAN_FLAG_FREQ_KHZ) {
nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQ_KHZ);
if (!nest)
goto nla_put_failure;
- for (i = 0; i < req->n_channels; i++) {
+ for (i = 0; i < req->req.n_channels; i++) {
if (nla_put_u32(msg, i,
- ieee80211_channel_to_khz(req->channels[i])))
+ ieee80211_channel_to_khz(req->req.channels[i])))
goto nla_put_failure;
}
nla_nest_end(msg, nest);
@@ -17931,19 +17935,20 @@ static int nl80211_add_scan_req(struct sk_buff *msg,
NL80211_ATTR_SCAN_FREQUENCIES);
if (!nest)
goto nla_put_failure;
- for (i = 0; i < req->n_channels; i++) {
- if (nla_put_u32(msg, i, req->channels[i]->center_freq))
+ for (i = 0; i < req->req.n_channels; i++) {
+ if (nla_put_u32(msg, i,
+ req->req.channels[i]->center_freq))
goto nla_put_failure;
}
nla_nest_end(msg, nest);
}
- if (req->ie &&
- nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
+ if (req->req.ie &&
+ nla_put(msg, NL80211_ATTR_IE, req->req.ie_len, req->req.ie))
goto nla_put_failure;
- if (req->flags &&
- nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
+ if (req->req.flags &&
+ nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->req.flags))
goto nla_put_failure;
info = rdev->int_scan_req ? &rdev->int_scan_req->info :
diff --git a/net/wireless/rdev-ops.h b/net/wireless/rdev-ops.h
index 9f4783c2354c..ccca538819f7 100644
--- a/net/wireless/rdev-ops.h
+++ b/net/wireless/rdev-ops.h
@@ -456,15 +456,15 @@ rdev_set_monitor_channel(struct cfg80211_registered_device *rdev,
}
static inline int rdev_scan(struct cfg80211_registered_device *rdev,
- struct cfg80211_scan_request *request)
+ struct cfg80211_scan_request_int *request)
{
int ret;
- if (WARN_ON_ONCE(!request->n_ssids && request->ssids))
+ if (WARN_ON_ONCE(!request->req.n_ssids && request->req.ssids))
return -EINVAL;
trace_rdev_scan(&rdev->wiphy, request);
- ret = rdev->ops->scan(&rdev->wiphy, request);
+ ret = rdev->ops->scan(&rdev->wiphy, &request->req);
trace_rdev_return_int(&rdev->wiphy, ret);
return ret;
}
diff --git a/net/wireless/scan.c b/net/wireless/scan.c
index ddd3a97f6609..d12ece068c10 100644
--- a/net/wireless/scan.c
+++ b/net/wireless/scan.c
@@ -782,9 +782,9 @@ cfg80211_parse_colocated_ap(const struct cfg80211_bss_ies *ies,
}
EXPORT_SYMBOL_IF_CFG80211_KUNIT(cfg80211_parse_colocated_ap);
-static void cfg80211_scan_req_add_chan(struct cfg80211_scan_request *request,
- struct ieee80211_channel *chan,
- bool add_to_6ghz)
+static void cfg80211_scan_req_add_chan(struct cfg80211_scan_request *request,
+ struct ieee80211_channel *chan,
+ bool add_to_6ghz)
{
int i;
u32 n_channels = request->n_channels;
@@ -843,25 +843,25 @@ static int cfg80211_scan_6ghz(struct cfg80211_registered_device *rdev)
u8 i;
struct cfg80211_colocated_ap *ap;
int n_channels, count = 0, err;
- struct cfg80211_scan_request *request, *rdev_req = rdev->scan_req;
+ struct cfg80211_scan_request_int *request, *rdev_req = rdev->scan_req;
LIST_HEAD(coloc_ap_list);
bool need_scan_psc = true;
const struct ieee80211_sband_iftype_data *iftd;
size_t size, offs_ssids, offs_6ghz_params, offs_ies;
- rdev_req->scan_6ghz = true;
+ rdev_req->req.scan_6ghz = true;
if (!rdev->wiphy.bands[NL80211_BAND_6GHZ])
return -EOPNOTSUPP;
iftd = ieee80211_get_sband_iftype_data(rdev->wiphy.bands[NL80211_BAND_6GHZ],
- rdev_req->wdev->iftype);
+ rdev_req->req.wdev->iftype);
if (!iftd || !iftd->he_cap.has_he)
return -EOPNOTSUPP;
n_channels = rdev->wiphy.bands[NL80211_BAND_6GHZ]->n_channels;
- if (rdev_req->flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ) {
+ if (rdev_req->req.flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ) {
struct cfg80211_internal_bss *intbss;
spin_lock_bh(&rdev->bss_lock);
@@ -883,8 +883,8 @@ static int cfg80211_scan_6ghz(struct cfg80211_registered_device *rdev)
* This is relevant for ML probe requests when the lower
* band APs have not been discovered.
*/
- if (is_broadcast_ether_addr(rdev_req->bssid) ||
- !ether_addr_equal(rdev_req->bssid, res->bssid) ||
+ if (is_broadcast_ether_addr(rdev_req->req.bssid) ||
+ !ether_addr_equal(rdev_req->req.bssid, res->bssid) ||
res->channel->band != NL80211_BAND_6GHZ)
continue;
@@ -911,13 +911,13 @@ static int cfg80211_scan_6ghz(struct cfg80211_registered_device *rdev)
spin_unlock_bh(&rdev->bss_lock);
}
- size = struct_size(request, channels, n_channels);
+ size = struct_size(request, req.channels, n_channels);
offs_ssids = size;
- size += sizeof(*request->ssids) * rdev_req->n_ssids;
+ size += sizeof(*request->req.ssids) * rdev_req->req.n_ssids;
offs_6ghz_params = size;
- size += sizeof(*request->scan_6ghz_params) * count;
+ size += sizeof(*request->req.scan_6ghz_params) * count;
offs_ies = size;
- size += rdev_req->ie_len;
+ size += rdev_req->req.ie_len;
request = kzalloc(size, GFP_KERNEL);
if (!request) {
@@ -926,26 +926,26 @@ static int cfg80211_scan_6ghz(struct cfg80211_registered_device *rdev)
}
*request = *rdev_req;
- request->n_channels = 0;
- request->n_6ghz_params = 0;
- if (rdev_req->n_ssids) {
+ request->req.n_channels = 0;
+ request->req.n_6ghz_params = 0;
+ if (rdev_req->req.n_ssids) {
/*
* Add the ssids from the parent scan request to the new
* scan request, so the driver would be able to use them
* in its probe requests to discover hidden APs on PSC
* channels.
*/
- request->ssids = (void *)request + offs_ssids;
- memcpy(request->ssids, rdev_req->ssids,
- sizeof(*request->ssids) * request->n_ssids);
+ request->req.ssids = (void *)request + offs_ssids;
+ memcpy(request->req.ssids, rdev_req->req.ssids,
+ sizeof(*request->req.ssids) * request->req.n_ssids);
}
- request->scan_6ghz_params = (void *)request + offs_6ghz_params;
+ request->req.scan_6ghz_params = (void *)request + offs_6ghz_params;
- if (rdev_req->ie_len) {
+ if (rdev_req->req.ie_len) {
void *ie = (void *)request + offs_ies;
- memcpy(ie, rdev_req->ie, rdev_req->ie_len);
- request->ie = ie;
+ memcpy(ie, rdev_req->req.ie, rdev_req->req.ie_len);
+ request->req.ie = ie;
}
/*
@@ -953,10 +953,12 @@ static int cfg80211_scan_6ghz(struct cfg80211_registered_device *rdev)
* and at least one of the reported co-located APs with same SSID
* indicating that all APs in the same ESS are co-located
*/
- if (count && request->n_ssids == 1 && request->ssids[0].ssid_len) {
+ if (count &&
+ request->req.n_ssids == 1 &&
+ request->req.ssids[0].ssid_len) {
list_for_each_entry(ap, &coloc_ap_list, list) {
if (ap->colocated_ess &&
- cfg80211_find_ssid_match(ap, request)) {
+ cfg80211_find_ssid_match(ap, &request->req)) {
need_scan_psc = false;
break;
}
@@ -968,51 +970,52 @@ static int cfg80211_scan_6ghz(struct cfg80211_registered_device *rdev)
* regardless of the collocated APs (PSC channels or all channels
* in case that NL80211_SCAN_FLAG_COLOCATED_6GHZ is not set)
*/
- for (i = 0; i < rdev_req->n_channels; i++) {
- if (rdev_req->channels[i]->band == NL80211_BAND_6GHZ &&
+ for (i = 0; i < rdev_req->req.n_channels; i++) {
+ if (rdev_req->req.channels[i]->band == NL80211_BAND_6GHZ &&
((need_scan_psc &&
- cfg80211_channel_is_psc(rdev_req->channels[i])) ||
- !(rdev_req->flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ))) {
- cfg80211_scan_req_add_chan(request,
- rdev_req->channels[i],
+ cfg80211_channel_is_psc(rdev_req->req.channels[i])) ||
+ !(rdev_req->req.flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ))) {
+ cfg80211_scan_req_add_chan(&request->req,
+ rdev_req->req.channels[i],
false);
}
}
- if (!(rdev_req->flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ))
+ if (!(rdev_req->req.flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ))
goto skip;
list_for_each_entry(ap, &coloc_ap_list, list) {
bool found = false;
struct cfg80211_scan_6ghz_params *scan_6ghz_params =
- &request->scan_6ghz_params[request->n_6ghz_params];
+ &request->req.scan_6ghz_params[request->req.n_6ghz_params];
struct ieee80211_channel *chan =
ieee80211_get_channel(&rdev->wiphy, ap->center_freq);
if (!chan || chan->flags & IEEE80211_CHAN_DISABLED ||
- !cfg80211_wdev_channel_allowed(rdev_req->wdev, chan))
+ !cfg80211_wdev_channel_allowed(rdev_req->req.wdev, chan))
continue;
- for (i = 0; i < rdev_req->n_channels; i++) {
- if (rdev_req->channels[i] == chan)
+ for (i = 0; i < rdev_req->req.n_channels; i++) {
+ if (rdev_req->req.channels[i] == chan)
found = true;
}
if (!found)
continue;
- if (request->n_ssids > 0 &&
- !cfg80211_find_ssid_match(ap, request))
+ if (request->req.n_ssids > 0 &&
+ !cfg80211_find_ssid_match(ap, &request->req))
continue;
- if (!is_broadcast_ether_addr(request->bssid) &&
- !ether_addr_equal(request->bssid, ap->bssid))
+ if (!is_broadcast_ether_addr(request->req.bssid) &&
+ !ether_addr_equal(request->req.bssid, ap->bssid))
continue;
- if (!request->n_ssids && ap->multi_bss && !ap->transmitted_bssid)
+ if (!request->req.n_ssids && ap->multi_bss &&
+ !ap->transmitted_bssid)
continue;
- cfg80211_scan_req_add_chan(request, chan, true);
+ cfg80211_scan_req_add_chan(&request->req, chan, true);
memcpy(scan_6ghz_params->bssid, ap->bssid, ETH_ALEN);
scan_6ghz_params->short_ssid = ap->short_ssid;
scan_6ghz_params->short_ssid_valid = ap->short_ssid_valid;
@@ -1028,14 +1031,14 @@ static int cfg80211_scan_6ghz(struct cfg80211_registered_device *rdev)
if (cfg80211_channel_is_psc(chan) && !need_scan_psc)
scan_6ghz_params->psc_no_listen = true;
- request->n_6ghz_params++;
+ request->req.n_6ghz_params++;
}
skip:
cfg80211_free_coloc_ap_list(&coloc_ap_list);
- if (request->n_channels) {
- struct cfg80211_scan_request *old = rdev->int_scan_req;
+ if (request->req.n_channels) {
+ struct cfg80211_scan_request_int *old = rdev->int_scan_req;
rdev->int_scan_req = request;
@@ -1063,35 +1066,36 @@ static int cfg80211_scan_6ghz(struct cfg80211_registered_device *rdev)
int cfg80211_scan(struct cfg80211_registered_device *rdev)
{
- struct cfg80211_scan_request *request;
- struct cfg80211_scan_request *rdev_req = rdev->scan_req;
+ struct cfg80211_scan_request_int *request;
+ struct cfg80211_scan_request_int *rdev_req = rdev->scan_req;
u32 n_channels = 0, idx, i;
if (!(rdev->wiphy.flags & WIPHY_FLAG_SPLIT_SCAN_6GHZ))
return rdev_scan(rdev, rdev_req);
- for (i = 0; i < rdev_req->n_channels; i++) {
- if (rdev_req->channels[i]->band != NL80211_BAND_6GHZ)
+ for (i = 0; i < rdev_req->req.n_channels; i++) {
+ if (rdev_req->req.channels[i]->band != NL80211_BAND_6GHZ)
n_channels++;
}
if (!n_channels)
return cfg80211_scan_6ghz(rdev);
- request = kzalloc(struct_size(request, channels, n_channels),
+ request = kzalloc(struct_size(request, req.channels, n_channels),
GFP_KERNEL);
if (!request)
return -ENOMEM;
*request = *rdev_req;
- request->n_channels = n_channels;
+ request->req.n_channels = n_channels;
- for (i = idx = 0; i < rdev_req->n_channels; i++) {
- if (rdev_req->channels[i]->band != NL80211_BAND_6GHZ)
- request->channels[idx++] = rdev_req->channels[i];
+ for (i = idx = 0; i < rdev_req->req.n_channels; i++) {
+ if (rdev_req->req.channels[i]->band != NL80211_BAND_6GHZ)
+ request->req.channels[idx++] =
+ rdev_req->req.channels[i];
}
- rdev_req->scan_6ghz = false;
+ rdev_req->req.scan_6ghz = false;
rdev->int_scan_req = request;
return rdev_scan(rdev, request);
}
@@ -1099,7 +1103,7 @@ int cfg80211_scan(struct cfg80211_registered_device *rdev)
void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
bool send_message)
{
- struct cfg80211_scan_request *request, *rdev_req;
+ struct cfg80211_scan_request_int *request, *rdev_req;
struct wireless_dev *wdev;
struct sk_buff *msg;
#ifdef CONFIG_CFG80211_WEXT
@@ -1118,12 +1122,12 @@ void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
if (!rdev_req)
return;
- wdev = rdev_req->wdev;
+ wdev = rdev_req->req.wdev;
request = rdev->int_scan_req ? rdev->int_scan_req : rdev_req;
if (wdev_running(wdev) &&
(rdev->wiphy.flags & WIPHY_FLAG_SPLIT_SCAN_6GHZ) &&
- !rdev_req->scan_6ghz && !request->info.aborted &&
+ !rdev_req->req.scan_6ghz && !request->info.aborted &&
!cfg80211_scan_6ghz(rdev))
return;
@@ -1136,10 +1140,10 @@ void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
cfg80211_sme_scan_done(wdev->netdev);
if (!request->info.aborted &&
- request->flags & NL80211_SCAN_FLAG_FLUSH) {
+ request->req.flags & NL80211_SCAN_FLAG_FLUSH) {
/* flush entries from previous scans */
spin_lock_bh(&rdev->bss_lock);
- __cfg80211_bss_expire(rdev, request->scan_start);
+ __cfg80211_bss_expire(rdev, request->req.scan_start);
spin_unlock_bh(&rdev->bss_lock);
}
@@ -1175,13 +1179,16 @@ void __cfg80211_scan_done(struct wiphy *wiphy, struct wiphy_work *wk)
void cfg80211_scan_done(struct cfg80211_scan_request *request,
struct cfg80211_scan_info *info)
{
- struct cfg80211_scan_info old_info = request->info;
+ struct cfg80211_scan_request_int *intreq =
+ container_of(request, struct cfg80211_scan_request_int, req);
+ struct cfg80211_registered_device *rdev = wiphy_to_rdev(request->wiphy);
+ struct cfg80211_scan_info old_info = intreq->info;
- trace_cfg80211_scan_done(request, info);
- WARN_ON(request != wiphy_to_rdev(request->wiphy)->scan_req &&
- request != wiphy_to_rdev(request->wiphy)->int_scan_req);
+ trace_cfg80211_scan_done(intreq, info);
+ WARN_ON(intreq != rdev->scan_req &&
+ intreq != rdev->int_scan_req);
- request->info = *info;
+ intreq->info = *info;
/*
* In case the scan is split, the scan_start_tsf and tsf_bssid should
@@ -1189,14 +1196,13 @@ void cfg80211_scan_done(struct cfg80211_scan_request *request,
* be non zero.
*/
if (request->scan_6ghz && old_info.scan_start_tsf) {
- request->info.scan_start_tsf = old_info.scan_start_tsf;
- memcpy(request->info.tsf_bssid, old_info.tsf_bssid,
- sizeof(request->info.tsf_bssid));
+ intreq->info.scan_start_tsf = old_info.scan_start_tsf;
+ memcpy(intreq->info.tsf_bssid, old_info.tsf_bssid,
+ sizeof(intreq->info.tsf_bssid));
}
- request->notified = true;
- wiphy_work_queue(request->wiphy,
- &wiphy_to_rdev(request->wiphy)->scan_done_wk);
+ intreq->notified = true;
+ wiphy_work_queue(request->wiphy, &rdev->scan_done_wk);
}
EXPORT_SYMBOL(cfg80211_scan_done);
@@ -3500,7 +3506,7 @@ int cfg80211_wext_siwscan(struct net_device *dev,
struct cfg80211_registered_device *rdev;
struct wiphy *wiphy;
struct iw_scan_req *wreq = NULL;
- struct cfg80211_scan_request *creq;
+ struct cfg80211_scan_request_int *creq;
int i, err, n_channels = 0;
enum nl80211_band band;
@@ -3530,19 +3536,20 @@ int cfg80211_wext_siwscan(struct net_device *dev,
n_channels = ieee80211_get_num_supported_channels(wiphy);
}
- creq = kzalloc(struct_size(creq, channels, n_channels) +
+ creq = kzalloc(struct_size(creq, req.channels, n_channels) +
sizeof(struct cfg80211_ssid),
GFP_ATOMIC);
if (!creq)
return -ENOMEM;
- creq->wiphy = wiphy;
- creq->wdev = dev->ieee80211_ptr;
+ creq->req.wiphy = wiphy;
+ creq->req.wdev = dev->ieee80211_ptr;
/* SSIDs come after channels */
- creq->ssids = (void *)creq + struct_size(creq, channels, n_channels);
- creq->n_channels = n_channels;
- creq->n_ssids = 1;
- creq->scan_start = jiffies;
+ creq->req.ssids = (void *)creq +
+ struct_size(creq, req.channels, n_channels);
+ creq->req.n_channels = n_channels;
+ creq->req.n_ssids = 1;
+ creq->req.scan_start = jiffies;
/* translate "Scan on frequencies" request */
i = 0;
@@ -3558,7 +3565,7 @@ int cfg80211_wext_siwscan(struct net_device *dev,
/* ignore disabled channels */
chan = &wiphy->bands[band]->channels[j];
if (chan->flags & IEEE80211_CHAN_DISABLED ||
- !cfg80211_wdev_channel_allowed(creq->wdev, chan))
+ !cfg80211_wdev_channel_allowed(creq->req.wdev, chan))
continue;
/* If we have a wireless request structure and the
@@ -3581,7 +3588,8 @@ int cfg80211_wext_siwscan(struct net_device *dev,
}
wext_freq_found:
- creq->channels[i] = &wiphy->bands[band]->channels[j];
+ creq->req.channels[i] =
+ &wiphy->bands[band]->channels[j];
i++;
wext_freq_not_found: ;
}
@@ -3592,28 +3600,30 @@ int cfg80211_wext_siwscan(struct net_device *dev,
goto out;
}
- /* Set real number of channels specified in creq->channels[] */
- creq->n_channels = i;
+ /* Set real number of channels specified in creq->req.channels[] */
+ creq->req.n_channels = i;
/* translate "Scan for SSID" request */
if (wreq) {
if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
if (wreq->essid_len > IEEE80211_MAX_SSID_LEN)
return -EINVAL;
- memcpy(creq->ssids[0].ssid, wreq->essid, wreq->essid_len);
- creq->ssids[0].ssid_len = wreq->essid_len;
+ memcpy(creq->req.ssids[0].ssid, wreq->essid,
+ wreq->essid_len);
+ creq->req.ssids[0].ssid_len = wreq->essid_len;
}
if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE) {
- creq->ssids = NULL;
- creq->n_ssids = 0;
+ creq->req.ssids = NULL;
+ creq->req.n_ssids = 0;
}
}
for (i = 0; i < NUM_NL80211_BANDS; i++)
if (wiphy->bands[i])
- creq->rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
+ creq->req.rates[i] =
+ (1 << wiphy->bands[i]->n_bitrates) - 1;
- eth_broadcast_addr(creq->bssid);
+ eth_broadcast_addr(creq->req.bssid);
scoped_guard(wiphy, &rdev->wiphy) {
rdev->scan_req = creq;
diff --git a/net/wireless/sme.c b/net/wireless/sme.c
index cf998500a965..6d7a7e7f0fc2 100644
--- a/net/wireless/sme.c
+++ b/net/wireless/sme.c
@@ -5,7 +5,7 @@
* (for nl80211's connect() and wext)
*
* Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
- * Copyright (C) 2009, 2020, 2022-2024 Intel Corporation. All rights reserved.
+ * Copyright (C) 2009, 2020, 2022-2025 Intel Corporation. All rights reserved.
* Copyright 2017 Intel Deutschland GmbH
*/
@@ -64,7 +64,7 @@ static void cfg80211_sme_free(struct wireless_dev *wdev)
static int cfg80211_conn_scan(struct wireless_dev *wdev)
{
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
- struct cfg80211_scan_request *request;
+ struct cfg80211_scan_request_int *request;
int n_channels, err;
lockdep_assert_wiphy(wdev->wiphy);
@@ -77,13 +77,13 @@ static int cfg80211_conn_scan(struct wireless_dev *wdev)
else
n_channels = ieee80211_get_num_supported_channels(wdev->wiphy);
- request = kzalloc(sizeof(*request) + sizeof(request->ssids[0]) +
- sizeof(request->channels[0]) * n_channels,
+ request = kzalloc(sizeof(*request) + sizeof(request->req.ssids[0]) +
+ sizeof(request->req.channels[0]) * n_channels,
GFP_KERNEL);
if (!request)
return -ENOMEM;
- request->n_channels = n_channels;
+ request->req.n_channels = n_channels;
if (wdev->conn->params.channel) {
enum nl80211_band band = wdev->conn->params.channel->band;
struct ieee80211_supported_band *sband =
@@ -93,8 +93,8 @@ static int cfg80211_conn_scan(struct wireless_dev *wdev)
kfree(request);
return -EINVAL;
}
- request->channels[0] = wdev->conn->params.channel;
- request->rates[band] = (1 << sband->n_bitrates) - 1;
+ request->req.channels[0] = wdev->conn->params.channel;
+ request->req.rates[band] = (1 << sband->n_bitrates) - 1;
} else {
int i = 0, j;
enum nl80211_band band;
@@ -109,26 +109,26 @@ static int cfg80211_conn_scan(struct wireless_dev *wdev)
channel = &bands->channels[j];
if (channel->flags & IEEE80211_CHAN_DISABLED)
continue;
- request->channels[i++] = channel;
+ request->req.channels[i++] = channel;
}
- request->rates[band] = (1 << bands->n_bitrates) - 1;
+ request->req.rates[band] = (1 << bands->n_bitrates) - 1;
}
n_channels = i;
}
- request->n_channels = n_channels;
- request->ssids = (void *)request +
- struct_size(request, channels, n_channels);
- request->n_ssids = 1;
+ request->req.n_channels = n_channels;
+ request->req.ssids = (void *)request +
+ struct_size(request, req.channels, n_channels);
+ request->req.n_ssids = 1;
- memcpy(request->ssids[0].ssid, wdev->conn->params.ssid,
- wdev->conn->params.ssid_len);
- request->ssids[0].ssid_len = wdev->conn->params.ssid_len;
+ memcpy(request->req.ssids[0].ssid, wdev->conn->params.ssid,
+ wdev->conn->params.ssid_len);
+ request->req.ssids[0].ssid_len = wdev->conn->params.ssid_len;
- eth_broadcast_addr(request->bssid);
+ eth_broadcast_addr(request->req.bssid);
- request->wdev = wdev;
- request->wiphy = &rdev->wiphy;
- request->scan_start = jiffies;
+ request->req.wdev = wdev;
+ request->req.wiphy = &rdev->wiphy;
+ request->req.scan_start = jiffies;
rdev->scan_req = request;
diff --git a/net/wireless/trace.h b/net/wireless/trace.h
index 4ed9fada4ec0..083c35d97ed2 100644
--- a/net/wireless/trace.h
+++ b/net/wireless/trace.h
@@ -373,7 +373,8 @@ TRACE_EVENT(rdev_return_int,
);
TRACE_EVENT(rdev_scan,
- TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request),
+ TP_PROTO(struct wiphy *wiphy,
+ struct cfg80211_scan_request_int *request),
TP_ARGS(wiphy, request),
TP_STRUCT__entry(
WIPHY_ENTRY
@@ -3685,12 +3686,12 @@ TRACE_EVENT(cfg80211_tdls_oper_request,
);
TRACE_EVENT(cfg80211_scan_done,
- TP_PROTO(struct cfg80211_scan_request *request,
+ TP_PROTO(struct cfg80211_scan_request_int *request,
struct cfg80211_scan_info *info),
TP_ARGS(request, info),
TP_STRUCT__entry(
__field(u32, n_channels)
- __dynamic_array(u8, ie, request ? request->ie_len : 0)
+ __dynamic_array(u8, ie, request ? request->req.ie_len : 0)
__array(u32, rates, NUM_NL80211_BANDS)
__field(u32, wdev_id)
MAC_ENTRY(wiphy_mac)
@@ -3701,16 +3702,16 @@ TRACE_EVENT(cfg80211_scan_done,
),
TP_fast_assign(
if (request) {
- memcpy(__get_dynamic_array(ie), request->ie,
- request->ie_len);
- memcpy(__entry->rates, request->rates,
+ memcpy(__get_dynamic_array(ie), request->req.ie,
+ request->req.ie_len);
+ memcpy(__entry->rates, request->req.rates,
NUM_NL80211_BANDS);
- __entry->wdev_id = request->wdev ?
- request->wdev->identifier : 0;
- if (request->wiphy)
+ __entry->wdev_id = request->req.wdev ?
+ request->req.wdev->identifier : 0;
+ if (request->req.wiphy)
MAC_ASSIGN(wiphy_mac,
- request->wiphy->perm_addr);
- __entry->no_cck = request->no_cck;
+ request->req.wiphy->perm_addr);
+ __entry->no_cck = request->req.no_cck;
}
if (info) {
__entry->aborted = info->aborted;
--
2.34.1
^ permalink raw reply related [flat|nested] 2+ messages in thread
* Re: [PATCH wireless-next 07/15] wifi: cfg80211: hide scan internals
@ 2025-06-11 12:18 kernel test robot
0 siblings, 0 replies; 2+ messages in thread
From: kernel test robot @ 2025-06-11 12:18 UTC (permalink / raw)
To: oe-kbuild; +Cc: lkp, Dan Carpenter
BCC: lkp@intel.com
CC: oe-kbuild-all@lists.linux.dev
In-Reply-To: <20250609213231.6a62e41858e2.I004f66e9c087cc6e6ae4a24951cf470961ee9466@changeid>
References: <20250609213231.6a62e41858e2.I004f66e9c087cc6e6ae4a24951cf470961ee9466@changeid>
TO: Miri Korenblit <miriam.rachel.korenblit@intel.com>
TO: linux-wireless@vger.kernel.org
CC: Johannes Berg <johannes.berg@intel.com>
CC: Benjamin Berg <benjamin.berg@intel.com>
Hi Miri,
kernel test robot noticed the following build warnings:
[auto build test WARNING on wireless-next/main]
[also build test WARNING on wireless/main linus/master v6.16-rc1 next-20250611]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Miri-Korenblit/wifi-mac80211-avoid-weird-state-in-error-path/20250610-023727
base: https://git.kernel.org/pub/scm/linux/kernel/git/wireless/wireless-next.git main
patch link: https://lore.kernel.org/r/20250609213231.6a62e41858e2.I004f66e9c087cc6e6ae4a24951cf470961ee9466%40changeid
patch subject: [PATCH wireless-next 07/15] wifi: cfg80211: hide scan internals
:::::: branch date: 2 days ago
:::::: commit date: 2 days ago
config: i386-randconfig-141-20250611 (https://download.01.org/0day-ci/archive/20250611/202506111904.zPyJVeRF-lkp@intel.com/config)
compiler: gcc-12 (Debian 12.2.0-14) 12.2.0
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Reported-by: Dan Carpenter <error27@gmail.com>
| Closes: https://lore.kernel.org/r/202506111904.zPyJVeRF-lkp@intel.com/
New smatch warnings:
net/wireless/nl80211.c:9558 nl80211_trigger_scan() warn: potential spectre issue 'request->req.rates' [r] (local cap)
Old smatch warnings:
net/wireless/nl80211.c:277 validate_ie_attr() warn: potential spectre issue 'elem->data' [r]
net/wireless/nl80211.c:4080 nl80211_send_iface() error: we previously assumed 'rdev->ops->get_channel' could be null (see line 4003)
net/wireless/nl80211.c:5368 nl80211_parse_tx_bitrate_mask() warn: potential spectre issue 'rdev->wiphy.bands' [r] (local cap)
net/wireless/nl80211.c:5369 nl80211_parse_tx_bitrate_mask() warn: possible spectre second half. 'sband'
net/wireless/nl80211.c:5378 nl80211_parse_tx_bitrate_mask() warn: potential spectre issue 'mask->control' [w] (local cap)
net/wireless/nl80211.c:9555 nl80211_trigger_scan() warn: potential spectre issue 'wiphy->bands' [r] (local cap)
vim +9558 net/wireless/nl80211.c
2d23d0736e3a4a Roee Zamir 2017-08-06 9374
2a519311926906 Johannes Berg 2009-02-10 9375 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
2a519311926906 Johannes Berg 2009-02-10 9376 {
4c476991062a0a Johannes Berg 2010-10-04 9377 struct cfg80211_registered_device *rdev = info->user_ptr[0];
fd0142844efa85 Johannes Berg 2012-06-18 9378 struct wireless_dev *wdev = info->user_ptr[1];
655f189ad02b2c Johannes Berg 2025-06-09 9379 struct cfg80211_scan_request_int *request;
2032f3b2f94325 Thomas Pedersen 2020-04-30 9380 struct nlattr *scan_freqs = NULL;
2032f3b2f94325 Thomas Pedersen 2020-04-30 9381 bool scan_freqs_khz = false;
2a519311926906 Johannes Berg 2009-02-10 9382 struct nlattr *attr;
2a519311926906 Johannes Berg 2009-02-10 9383 struct wiphy *wiphy;
83f5e2cf79390f Johannes Berg 2009-06-17 9384 int err, tmp, n_ssids = 0, n_channels, i;
14e05beb10326e Jacob Keller 2023-02-28 9385 size_t ie_len, size;
838c7b8f1f2784 Kees Cook 2024-04-24 9386 size_t ssids_offset, ie_offset;
2a519311926906 Johannes Berg 2009-02-10 9387
79c97e97aed7f7 Johannes Berg 2009-07-07 9388 wiphy = &rdev->wiphy;
2a519311926906 Johannes Berg 2009-02-10 9389
cb3b7d87652aeb Ayala Beker 2016-09-20 9390 if (wdev->iftype == NL80211_IFTYPE_NAN)
cb3b7d87652aeb Ayala Beker 2016-09-20 9391 return -EOPNOTSUPP;
cb3b7d87652aeb Ayala Beker 2016-09-20 9392
4c476991062a0a Johannes Berg 2010-10-04 9393 if (!rdev->ops->scan)
4c476991062a0a Johannes Berg 2010-10-04 9394 return -EOPNOTSUPP;
2a519311926906 Johannes Berg 2009-02-10 9395
8328685682965c Christophe JAILLET 2020-07-12 9396 if (rdev->scan_req || rdev->scan_msg)
8328685682965c Christophe JAILLET 2020-07-12 9397 return -EBUSY;
2a519311926906 Johannes Berg 2009-02-10 9398
2032f3b2f94325 Thomas Pedersen 2020-04-30 9399 if (info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ]) {
2032f3b2f94325 Thomas Pedersen 2020-04-30 9400 if (!wiphy_ext_feature_isset(wiphy,
2032f3b2f94325 Thomas Pedersen 2020-04-30 9401 NL80211_EXT_FEATURE_SCAN_FREQ_KHZ))
2032f3b2f94325 Thomas Pedersen 2020-04-30 9402 return -EOPNOTSUPP;
2032f3b2f94325 Thomas Pedersen 2020-04-30 9403 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ];
2032f3b2f94325 Thomas Pedersen 2020-04-30 9404 scan_freqs_khz = true;
2032f3b2f94325 Thomas Pedersen 2020-04-30 9405 } else if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES])
2032f3b2f94325 Thomas Pedersen 2020-04-30 9406 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQUENCIES];
2032f3b2f94325 Thomas Pedersen 2020-04-30 9407
2032f3b2f94325 Thomas Pedersen 2020-04-30 9408 if (scan_freqs) {
2032f3b2f94325 Thomas Pedersen 2020-04-30 9409 n_channels = validate_scan_freqs(scan_freqs);
8328685682965c Christophe JAILLET 2020-07-12 9410 if (!n_channels)
8328685682965c Christophe JAILLET 2020-07-12 9411 return -EINVAL;
2a519311926906 Johannes Berg 2009-02-10 9412 } else {
bdfbec2d2d240e Ilan Peer 2014-01-09 9413 n_channels = ieee80211_get_num_supported_channels(wiphy);
2a519311926906 Johannes Berg 2009-02-10 9414 }
2a519311926906 Johannes Berg 2009-02-10 9415
2a519311926906 Johannes Berg 2009-02-10 9416 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
2a519311926906 Johannes Berg 2009-02-10 9417 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
2a519311926906 Johannes Berg 2009-02-10 9418 n_ssids++;
2a519311926906 Johannes Berg 2009-02-10 9419
8328685682965c Christophe JAILLET 2020-07-12 9420 if (n_ssids > wiphy->max_scan_ssids)
8328685682965c Christophe JAILLET 2020-07-12 9421 return -EINVAL;
2a519311926906 Johannes Berg 2009-02-10 9422
70692ad2923a37 Jouni Malinen 2009-02-16 9423 if (info->attrs[NL80211_ATTR_IE])
70692ad2923a37 Jouni Malinen 2009-02-16 9424 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
70692ad2923a37 Jouni Malinen 2009-02-16 9425 else
70692ad2923a37 Jouni Malinen 2009-02-16 9426 ie_len = 0;
70692ad2923a37 Jouni Malinen 2009-02-16 9427
8328685682965c Christophe JAILLET 2020-07-12 9428 if (ie_len > wiphy->max_scan_ie_len)
8328685682965c Christophe JAILLET 2020-07-12 9429 return -EINVAL;
18a8365992a804 Johannes Berg 2009-03-31 9430
655f189ad02b2c Johannes Berg 2025-06-09 9431 size = struct_size(request, req.channels, n_channels);
838c7b8f1f2784 Kees Cook 2024-04-24 9432 ssids_offset = size;
655f189ad02b2c Johannes Berg 2025-06-09 9433 size = size_add(size, array_size(sizeof(*request->req.ssids), n_ssids));
838c7b8f1f2784 Kees Cook 2024-04-24 9434 ie_offset = size;
14e05beb10326e Jacob Keller 2023-02-28 9435 size = size_add(size, ie_len);
14e05beb10326e Jacob Keller 2023-02-28 9436 request = kzalloc(size, GFP_KERNEL);
8328685682965c Christophe JAILLET 2020-07-12 9437 if (!request)
8328685682965c Christophe JAILLET 2020-07-12 9438 return -ENOMEM;
655f189ad02b2c Johannes Berg 2025-06-09 9439 request->req.n_channels = n_channels;
2a519311926906 Johannes Berg 2009-02-10 9440
2a519311926906 Johannes Berg 2009-02-10 9441 if (n_ssids)
655f189ad02b2c Johannes Berg 2025-06-09 9442 request->req.ssids = (void *)request + ssids_offset;
655f189ad02b2c Johannes Berg 2025-06-09 9443 request->req.n_ssids = n_ssids;
838c7b8f1f2784 Kees Cook 2024-04-24 9444 if (ie_len)
655f189ad02b2c Johannes Berg 2025-06-09 9445 request->req.ie = (void *)request + ie_offset;
2a519311926906 Johannes Berg 2009-02-10 9446
584991dccfd347 Johannes Berg 2009-11-02 9447 i = 0;
2032f3b2f94325 Thomas Pedersen 2020-04-30 9448 if (scan_freqs) {
2a519311926906 Johannes Berg 2009-02-10 9449 /* user specified, bail out if channel not found */
2032f3b2f94325 Thomas Pedersen 2020-04-30 9450 nla_for_each_nested(attr, scan_freqs, tmp) {
584991dccfd347 Johannes Berg 2009-11-02 9451 struct ieee80211_channel *chan;
2032f3b2f94325 Thomas Pedersen 2020-04-30 9452 int freq = nla_get_u32(attr);
584991dccfd347 Johannes Berg 2009-11-02 9453
2032f3b2f94325 Thomas Pedersen 2020-04-30 9454 if (!scan_freqs_khz)
2032f3b2f94325 Thomas Pedersen 2020-04-30 9455 freq = MHZ_TO_KHZ(freq);
584991dccfd347 Johannes Berg 2009-11-02 9456
2032f3b2f94325 Thomas Pedersen 2020-04-30 9457 chan = ieee80211_get_channel_khz(wiphy, freq);
584991dccfd347 Johannes Berg 2009-11-02 9458 if (!chan) {
2a519311926906 Johannes Berg 2009-02-10 9459 err = -EINVAL;
2a519311926906 Johannes Berg 2009-02-10 9460 goto out_free;
2a519311926906 Johannes Berg 2009-02-10 9461 }
584991dccfd347 Johannes Berg 2009-11-02 9462
584991dccfd347 Johannes Berg 2009-11-02 9463 /* ignore disabled channels */
3607798ad9bdef Felix Fietkau 2024-10-09 9464 if (chan->flags & IEEE80211_CHAN_DISABLED ||
3607798ad9bdef Felix Fietkau 2024-10-09 9465 !cfg80211_wdev_channel_allowed(wdev, chan))
584991dccfd347 Johannes Berg 2009-11-02 9466 continue;
584991dccfd347 Johannes Berg 2009-11-02 9467
655f189ad02b2c Johannes Berg 2025-06-09 9468 request->req.channels[i] = chan;
2a519311926906 Johannes Berg 2009-02-10 9469 i++;
2a519311926906 Johannes Berg 2009-02-10 9470 }
2a519311926906 Johannes Berg 2009-02-10 9471 } else {
57fbcce37be7c1 Johannes Berg 2016-04-12 9472 enum nl80211_band band;
34850ab25d74ab Johannes Berg 2011-07-18 9473
2a519311926906 Johannes Berg 2009-02-10 9474 /* all channels */
57fbcce37be7c1 Johannes Berg 2016-04-12 9475 for (band = 0; band < NUM_NL80211_BANDS; band++) {
2a519311926906 Johannes Berg 2009-02-10 9476 int j;
7a087e7484c9e4 Kirtika Ruchandani 2016-05-29 9477
2a519311926906 Johannes Berg 2009-02-10 9478 if (!wiphy->bands[band])
2a519311926906 Johannes Berg 2009-02-10 9479 continue;
2a519311926906 Johannes Berg 2009-02-10 9480 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
584991dccfd347 Johannes Berg 2009-11-02 9481 struct ieee80211_channel *chan;
584991dccfd347 Johannes Berg 2009-11-02 9482
584991dccfd347 Johannes Berg 2009-11-02 9483 chan = &wiphy->bands[band]->channels[j];
584991dccfd347 Johannes Berg 2009-11-02 9484
3607798ad9bdef Felix Fietkau 2024-10-09 9485 if (chan->flags & IEEE80211_CHAN_DISABLED ||
3607798ad9bdef Felix Fietkau 2024-10-09 9486 !cfg80211_wdev_channel_allowed(wdev, chan))
584991dccfd347 Johannes Berg 2009-11-02 9487 continue;
584991dccfd347 Johannes Berg 2009-11-02 9488
655f189ad02b2c Johannes Berg 2025-06-09 9489 request->req.channels[i] = chan;
2a519311926906 Johannes Berg 2009-02-10 9490 i++;
2a519311926906 Johannes Berg 2009-02-10 9491 }
2a519311926906 Johannes Berg 2009-02-10 9492 }
2a519311926906 Johannes Berg 2009-02-10 9493 }
2a519311926906 Johannes Berg 2009-02-10 9494
584991dccfd347 Johannes Berg 2009-11-02 9495 if (!i) {
584991dccfd347 Johannes Berg 2009-11-02 9496 err = -EINVAL;
584991dccfd347 Johannes Berg 2009-11-02 9497 goto out_free;
584991dccfd347 Johannes Berg 2009-11-02 9498 }
584991dccfd347 Johannes Berg 2009-11-02 9499
655f189ad02b2c Johannes Berg 2025-06-09 9500 request->req.n_channels = i;
584991dccfd347 Johannes Berg 2009-11-02 9501
655f189ad02b2c Johannes Berg 2025-06-09 9502 for (i = 0; i < request->req.n_channels; i++) {
655f189ad02b2c Johannes Berg 2025-06-09 9503 struct ieee80211_channel *chan = request->req.channels[i];
34373d12f3cbb7 Vasanthakumar Thiagarajan 2017-02-27 9504
7b0a0e3c3a8826 Johannes Berg 2022-04-14 9505 /* if we can go off-channel to the target channel we're good */
7b0a0e3c3a8826 Johannes Berg 2022-04-14 9506 if (cfg80211_off_channel_oper_allowed(wdev, chan))
7b0a0e3c3a8826 Johannes Berg 2022-04-14 9507 continue;
34373d12f3cbb7 Vasanthakumar Thiagarajan 2017-02-27 9508
7b0a0e3c3a8826 Johannes Berg 2022-04-14 9509 if (!cfg80211_wdev_on_sub_chan(wdev, chan, true)) {
34373d12f3cbb7 Vasanthakumar Thiagarajan 2017-02-27 9510 err = -EBUSY;
34373d12f3cbb7 Vasanthakumar Thiagarajan 2017-02-27 9511 goto out_free;
34373d12f3cbb7 Vasanthakumar Thiagarajan 2017-02-27 9512 }
34373d12f3cbb7 Vasanthakumar Thiagarajan 2017-02-27 9513 }
34373d12f3cbb7 Vasanthakumar Thiagarajan 2017-02-27 9514
2a519311926906 Johannes Berg 2009-02-10 9515 i = 0;
13874e4b23de83 Johannes Berg 2015-01-23 9516 if (n_ssids) {
2a519311926906 Johannes Berg 2009-02-10 9517 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
57a27e1d6a3bb9 Luciano Coelho 2011-06-07 9518 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
2a519311926906 Johannes Berg 2009-02-10 9519 err = -EINVAL;
2a519311926906 Johannes Berg 2009-02-10 9520 goto out_free;
2a519311926906 Johannes Berg 2009-02-10 9521 }
655f189ad02b2c Johannes Berg 2025-06-09 9522 request->req.ssids[i].ssid_len = nla_len(attr);
655f189ad02b2c Johannes Berg 2025-06-09 9523 memcpy(request->req.ssids[i].ssid,
655f189ad02b2c Johannes Berg 2025-06-09 9524 nla_data(attr), nla_len(attr));
2a519311926906 Johannes Berg 2009-02-10 9525 i++;
2a519311926906 Johannes Berg 2009-02-10 9526 }
2a519311926906 Johannes Berg 2009-02-10 9527 }
2a519311926906 Johannes Berg 2009-02-10 9528
70692ad2923a37 Jouni Malinen 2009-02-16 9529 if (info->attrs[NL80211_ATTR_IE]) {
655f189ad02b2c Johannes Berg 2025-06-09 9530 request->req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
655f189ad02b2c Johannes Berg 2025-06-09 9531 memcpy((void *)request->req.ie,
de95a54b1aebe5 Johannes Berg 2009-04-01 9532 nla_data(info->attrs[NL80211_ATTR_IE]),
655f189ad02b2c Johannes Berg 2025-06-09 9533 request->req.ie_len);
70692ad2923a37 Jouni Malinen 2009-02-16 9534 }
70692ad2923a37 Jouni Malinen 2009-02-16 9535
57fbcce37be7c1 Johannes Berg 2016-04-12 9536 for (i = 0; i < NUM_NL80211_BANDS; i++)
a401d2bb363d94 Johannes Berg 2011-07-20 9537 if (wiphy->bands[i])
655f189ad02b2c Johannes Berg 2025-06-09 9538 request->req.rates[i] =
a401d2bb363d94 Johannes Berg 2011-07-20 9539 (1 << wiphy->bands[i]->n_bitrates) - 1;
34850ab25d74ab Johannes Berg 2011-07-18 9540
34850ab25d74ab Johannes Berg 2011-07-18 9541 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
34850ab25d74ab Johannes Berg 2011-07-18 9542 nla_for_each_nested(attr,
34850ab25d74ab Johannes Berg 2011-07-18 9543 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
34850ab25d74ab Johannes Berg 2011-07-18 9544 tmp) {
57fbcce37be7c1 Johannes Berg 2016-04-12 9545 enum nl80211_band band = nla_type(attr);
34850ab25d74ab Johannes Berg 2011-07-18 9546
57fbcce37be7c1 Johannes Berg 2016-04-12 9547 if (band < 0 || band >= NUM_NL80211_BANDS) {
34850ab25d74ab Johannes Berg 2011-07-18 9548 err = -EINVAL;
34850ab25d74ab Johannes Berg 2011-07-18 9549 goto out_free;
34850ab25d74ab Johannes Berg 2011-07-18 9550 }
1b09cd82d8c479 Felix Fietkau 2013-11-20 9551
1b09cd82d8c479 Felix Fietkau 2013-11-20 9552 if (!wiphy->bands[band])
1b09cd82d8c479 Felix Fietkau 2013-11-20 9553 continue;
1b09cd82d8c479 Felix Fietkau 2013-11-20 9554
34850ab25d74ab Johannes Berg 2011-07-18 9555 err = ieee80211_get_ratemask(wiphy->bands[band],
34850ab25d74ab Johannes Berg 2011-07-18 9556 nla_data(attr),
34850ab25d74ab Johannes Berg 2011-07-18 9557 nla_len(attr),
655f189ad02b2c Johannes Berg 2025-06-09 @9558 &request->req.rates[band]);
34850ab25d74ab Johannes Berg 2011-07-18 9559 if (err)
34850ab25d74ab Johannes Berg 2011-07-18 9560 goto out_free;
34850ab25d74ab Johannes Berg 2011-07-18 9561 }
34850ab25d74ab Johannes Berg 2011-07-18 9562 }
34850ab25d74ab Johannes Berg 2011-07-18 9563
1d76250bd34af8 Avraham Stern 2016-07-05 9564 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
655f189ad02b2c Johannes Berg 2025-06-09 9565 request->req.duration =
1d76250bd34af8 Avraham Stern 2016-07-05 9566 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
655f189ad02b2c Johannes Berg 2025-06-09 9567 request->req.duration_mandatory =
1d76250bd34af8 Avraham Stern 2016-07-05 9568 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
1d76250bd34af8 Avraham Stern 2016-07-05 9569 }
1d76250bd34af8 Avraham Stern 2016-07-05 9570
2d23d0736e3a4a Roee Zamir 2017-08-06 9571 err = nl80211_check_scan_flags(wiphy, wdev, request, info->attrs,
2d23d0736e3a4a Roee Zamir 2017-08-06 9572 false);
ad2b26abc15746 Johannes Berg 2014-06-12 9573 if (err)
ad2b26abc15746 Johannes Berg 2014-06-12 9574 goto out_free;
ed47377154310f Sam Leffler 2012-10-11 9575
655f189ad02b2c Johannes Berg 2025-06-09 9576 request->req.no_cck =
e9f935e3e8dc0b Rajkumar Manoharan 2011-09-25 9577 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
e9f935e3e8dc0b Rajkumar Manoharan 2011-09-25 9578
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9579 /* Initial implementation used NL80211_ATTR_MAC to set the specific
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9580 * BSSID to scan for. This was problematic because that same attribute
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9581 * was already used for another purpose (local random MAC address). The
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9582 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9583 * compatibility with older userspace components, also use the
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9584 * NL80211_ATTR_MAC value here if it can be determined to be used for
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9585 * the specific BSSID use case instead of the random MAC address
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9586 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9587 */
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9588 if (info->attrs[NL80211_ATTR_BSSID])
655f189ad02b2c Johannes Berg 2025-06-09 9589 memcpy(request->req.bssid,
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9590 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
655f189ad02b2c Johannes Berg 2025-06-09 9591 else if (!(request->req.flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
2fa436b3a2a700 Vamsi Krishna 2016-12-02 9592 info->attrs[NL80211_ATTR_MAC])
655f189ad02b2c Johannes Berg 2025-06-09 9593 memcpy(request->req.bssid,
655f189ad02b2c Johannes Berg 2025-06-09 9594 nla_data(info->attrs[NL80211_ATTR_MAC]),
818965d3917774 Jouni Malinen 2016-02-26 9595 ETH_ALEN);
818965d3917774 Jouni Malinen 2016-02-26 9596 else
655f189ad02b2c Johannes Berg 2025-06-09 9597 eth_broadcast_addr(request->req.bssid);
818965d3917774 Jouni Malinen 2016-02-26 9598
655f189ad02b2c Johannes Berg 2025-06-09 9599 request->req.tsf_report_link_id =
655f189ad02b2c Johannes Berg 2025-06-09 9600 nl80211_link_id_or_invalid(info->attrs);
655f189ad02b2c Johannes Berg 2025-06-09 9601 request->req.wdev = wdev;
655f189ad02b2c Johannes Berg 2025-06-09 9602 request->req.wiphy = &rdev->wiphy;
655f189ad02b2c Johannes Berg 2025-06-09 9603 request->req.scan_start = jiffies;
2a519311926906 Johannes Berg 2009-02-10 9604
79c97e97aed7f7 Johannes Berg 2009-07-07 9605 rdev->scan_req = request;
c8cb5b854b40f2 Tova Mussai 2020-09-18 9606 err = cfg80211_scan(rdev);
2a519311926906 Johannes Berg 2009-02-10 9607
504776be46cb61 Christophe JAILLET 2020-07-12 9608 if (err)
504776be46cb61 Christophe JAILLET 2020-07-12 9609 goto out_free;
504776be46cb61 Christophe JAILLET 2020-07-12 9610
fd0142844efa85 Johannes Berg 2012-06-18 9611 nl80211_send_scan_start(rdev, wdev);
fd0142844efa85 Johannes Berg 2012-06-18 9612 dev_hold(wdev->netdev);
504776be46cb61 Christophe JAILLET 2020-07-12 9613
504776be46cb61 Christophe JAILLET 2020-07-12 9614 return 0;
504776be46cb61 Christophe JAILLET 2020-07-12 9615
2a519311926906 Johannes Berg 2009-02-10 9616 out_free:
79c97e97aed7f7 Johannes Berg 2009-07-07 9617 rdev->scan_req = NULL;
2a519311926906 Johannes Berg 2009-02-10 9618 kfree(request);
3b85875a252dbb Johannes Berg 2009-03-12 9619
2a519311926906 Johannes Berg 2009-02-10 9620 return err;
2a519311926906 Johannes Berg 2009-02-10 9621 }
2a519311926906 Johannes Berg 2009-02-10 9622
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2025-06-11 12:19 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-06-11 12:18 [PATCH wireless-next 07/15] wifi: cfg80211: hide scan internals kernel test robot
-- strict thread matches above, loose matches on Subject: below --
2025-06-09 18:35 [PATCH wireless-next 00/15] wifi: cfg80211/mac80211: updates - 2025-06-09 Miri Korenblit
2025-06-09 18:35 ` [PATCH wireless-next 07/15] wifi: cfg80211: hide scan internals Miri Korenblit
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.