mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 11:49:32 +00:00
![Johannes Berg](/assets/img/avatar_default.png)
Currently, _everything_ in cfg80211 holds the RTNL, and if you have a slow USB device (or a few) you can get some bad lock contention on that. Fix that by re-adding a mutex to each wiphy/rdev as we had at some point, so we have locking for the wireless_dev lists and all the other things in there, and also so that drivers still don't have to worry too much about it (they still won't get parallel calls for a single device). Then, we can restrict the RTNL to a few cases where we add or remove interfaces and really need the added protection. Some of the global list management still also uses the RTNL, since we need to have it anyway for netdev management, but we only hold the RTNL for very short periods of time here. Link: https://lore.kernel.org/r/20210122161942.81df9f5e047a.I4a8e1a60b18863ea8c5e6d3a0faeafb2d45b2f40@changeid Tested-by: Marek Szyprowski <m.szyprowski@samsung.com> [marvell driver issues] Signed-off-by: Johannes Berg <johannes.berg@intel.com>
543 lines
12 KiB
C
543 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Some IBSS support code for cfg80211.
|
|
*
|
|
* Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
|
|
* Copyright (C) 2020-2021 Intel Corporation
|
|
*/
|
|
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/if_arp.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/export.h>
|
|
#include <net/cfg80211.h>
|
|
#include "wext-compat.h"
|
|
#include "nl80211.h"
|
|
#include "rdev-ops.h"
|
|
|
|
|
|
void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
|
|
struct ieee80211_channel *channel)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
struct cfg80211_bss *bss;
|
|
#ifdef CONFIG_CFG80211_WEXT
|
|
union iwreq_data wrqu;
|
|
#endif
|
|
|
|
if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
|
|
return;
|
|
|
|
if (!wdev->ssid_len)
|
|
return;
|
|
|
|
bss = cfg80211_get_bss(wdev->wiphy, channel, bssid, NULL, 0,
|
|
IEEE80211_BSS_TYPE_IBSS, IEEE80211_PRIVACY_ANY);
|
|
|
|
if (WARN_ON(!bss))
|
|
return;
|
|
|
|
if (wdev->current_bss) {
|
|
cfg80211_unhold_bss(wdev->current_bss);
|
|
cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
|
|
}
|
|
|
|
cfg80211_hold_bss(bss_from_pub(bss));
|
|
wdev->current_bss = bss_from_pub(bss);
|
|
|
|
if (!(wdev->wiphy->flags & WIPHY_FLAG_HAS_STATIC_WEP))
|
|
cfg80211_upload_connect_keys(wdev);
|
|
|
|
nl80211_send_ibss_bssid(wiphy_to_rdev(wdev->wiphy), dev, bssid,
|
|
GFP_KERNEL);
|
|
#ifdef CONFIG_CFG80211_WEXT
|
|
memset(&wrqu, 0, sizeof(wrqu));
|
|
memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
|
|
wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
|
|
#endif
|
|
}
|
|
|
|
void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
|
|
struct ieee80211_channel *channel, gfp_t gfp)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
|
|
struct cfg80211_event *ev;
|
|
unsigned long flags;
|
|
|
|
trace_cfg80211_ibss_joined(dev, bssid, channel);
|
|
|
|
if (WARN_ON(!channel))
|
|
return;
|
|
|
|
ev = kzalloc(sizeof(*ev), gfp);
|
|
if (!ev)
|
|
return;
|
|
|
|
ev->type = EVENT_IBSS_JOINED;
|
|
memcpy(ev->ij.bssid, bssid, ETH_ALEN);
|
|
ev->ij.channel = channel;
|
|
|
|
spin_lock_irqsave(&wdev->event_lock, flags);
|
|
list_add_tail(&ev->list, &wdev->event_list);
|
|
spin_unlock_irqrestore(&wdev->event_lock, flags);
|
|
queue_work(cfg80211_wq, &rdev->event_work);
|
|
}
|
|
EXPORT_SYMBOL(cfg80211_ibss_joined);
|
|
|
|
int __cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
|
|
struct net_device *dev,
|
|
struct cfg80211_ibss_params *params,
|
|
struct cfg80211_cached_keys *connkeys)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
int err;
|
|
|
|
lockdep_assert_held(&rdev->wiphy.mtx);
|
|
ASSERT_WDEV_LOCK(wdev);
|
|
|
|
if (wdev->ssid_len)
|
|
return -EALREADY;
|
|
|
|
if (!params->basic_rates) {
|
|
/*
|
|
* If no rates were explicitly configured,
|
|
* use the mandatory rate set for 11b or
|
|
* 11a for maximum compatibility.
|
|
*/
|
|
struct ieee80211_supported_band *sband;
|
|
enum nl80211_band band;
|
|
u32 flag;
|
|
int j;
|
|
|
|
band = params->chandef.chan->band;
|
|
if (band == NL80211_BAND_5GHZ ||
|
|
band == NL80211_BAND_6GHZ)
|
|
flag = IEEE80211_RATE_MANDATORY_A;
|
|
else
|
|
flag = IEEE80211_RATE_MANDATORY_B;
|
|
|
|
sband = rdev->wiphy.bands[band];
|
|
for (j = 0; j < sband->n_bitrates; j++) {
|
|
if (sband->bitrates[j].flags & flag)
|
|
params->basic_rates |= BIT(j);
|
|
}
|
|
}
|
|
|
|
if (WARN_ON(connkeys && connkeys->def < 0))
|
|
return -EINVAL;
|
|
|
|
if (WARN_ON(wdev->connect_keys))
|
|
kfree_sensitive(wdev->connect_keys);
|
|
wdev->connect_keys = connkeys;
|
|
|
|
wdev->ibss_fixed = params->channel_fixed;
|
|
wdev->ibss_dfs_possible = params->userspace_handles_dfs;
|
|
wdev->chandef = params->chandef;
|
|
if (connkeys) {
|
|
params->wep_keys = connkeys->params;
|
|
params->wep_tx_key = connkeys->def;
|
|
}
|
|
|
|
#ifdef CONFIG_CFG80211_WEXT
|
|
wdev->wext.ibss.chandef = params->chandef;
|
|
#endif
|
|
err = rdev_join_ibss(rdev, dev, params);
|
|
if (err) {
|
|
wdev->connect_keys = NULL;
|
|
return err;
|
|
}
|
|
|
|
memcpy(wdev->ssid, params->ssid, params->ssid_len);
|
|
wdev->ssid_len = params->ssid_len;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __cfg80211_clear_ibss(struct net_device *dev, bool nowext)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
|
|
int i;
|
|
|
|
ASSERT_WDEV_LOCK(wdev);
|
|
|
|
kfree_sensitive(wdev->connect_keys);
|
|
wdev->connect_keys = NULL;
|
|
|
|
rdev_set_qos_map(rdev, dev, NULL);
|
|
|
|
/*
|
|
* Delete all the keys ... pairwise keys can't really
|
|
* exist any more anyway, but default keys might.
|
|
*/
|
|
if (rdev->ops->del_key)
|
|
for (i = 0; i < 6; i++)
|
|
rdev_del_key(rdev, dev, i, false, NULL);
|
|
|
|
if (wdev->current_bss) {
|
|
cfg80211_unhold_bss(wdev->current_bss);
|
|
cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
|
|
}
|
|
|
|
wdev->current_bss = NULL;
|
|
wdev->ssid_len = 0;
|
|
memset(&wdev->chandef, 0, sizeof(wdev->chandef));
|
|
#ifdef CONFIG_CFG80211_WEXT
|
|
if (!nowext)
|
|
wdev->wext.ibss.ssid_len = 0;
|
|
#endif
|
|
cfg80211_sched_dfs_chan_update(rdev);
|
|
}
|
|
|
|
void cfg80211_clear_ibss(struct net_device *dev, bool nowext)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
|
|
wdev_lock(wdev);
|
|
__cfg80211_clear_ibss(dev, nowext);
|
|
wdev_unlock(wdev);
|
|
}
|
|
|
|
int __cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
|
|
struct net_device *dev, bool nowext)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
int err;
|
|
|
|
ASSERT_WDEV_LOCK(wdev);
|
|
|
|
if (!wdev->ssid_len)
|
|
return -ENOLINK;
|
|
|
|
err = rdev_leave_ibss(rdev, dev);
|
|
|
|
if (err)
|
|
return err;
|
|
|
|
wdev->conn_owner_nlportid = 0;
|
|
__cfg80211_clear_ibss(dev, nowext);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
|
|
struct net_device *dev, bool nowext)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
int err;
|
|
|
|
wdev_lock(wdev);
|
|
err = __cfg80211_leave_ibss(rdev, dev, nowext);
|
|
wdev_unlock(wdev);
|
|
|
|
return err;
|
|
}
|
|
|
|
#ifdef CONFIG_CFG80211_WEXT
|
|
int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
|
|
struct wireless_dev *wdev)
|
|
{
|
|
struct cfg80211_cached_keys *ck = NULL;
|
|
enum nl80211_band band;
|
|
int i, err;
|
|
|
|
ASSERT_WDEV_LOCK(wdev);
|
|
|
|
if (!wdev->wext.ibss.beacon_interval)
|
|
wdev->wext.ibss.beacon_interval = 100;
|
|
|
|
/* try to find an IBSS channel if none requested ... */
|
|
if (!wdev->wext.ibss.chandef.chan) {
|
|
struct ieee80211_channel *new_chan = NULL;
|
|
|
|
for (band = 0; band < NUM_NL80211_BANDS; band++) {
|
|
struct ieee80211_supported_band *sband;
|
|
struct ieee80211_channel *chan;
|
|
|
|
sband = rdev->wiphy.bands[band];
|
|
if (!sband)
|
|
continue;
|
|
|
|
for (i = 0; i < sband->n_channels; i++) {
|
|
chan = &sband->channels[i];
|
|
if (chan->flags & IEEE80211_CHAN_NO_IR)
|
|
continue;
|
|
if (chan->flags & IEEE80211_CHAN_DISABLED)
|
|
continue;
|
|
new_chan = chan;
|
|
break;
|
|
}
|
|
|
|
if (new_chan)
|
|
break;
|
|
}
|
|
|
|
if (!new_chan)
|
|
return -EINVAL;
|
|
|
|
cfg80211_chandef_create(&wdev->wext.ibss.chandef, new_chan,
|
|
NL80211_CHAN_NO_HT);
|
|
}
|
|
|
|
/* don't join -- SSID is not there */
|
|
if (!wdev->wext.ibss.ssid_len)
|
|
return 0;
|
|
|
|
if (!netif_running(wdev->netdev))
|
|
return 0;
|
|
|
|
if (wdev->wext.keys)
|
|
wdev->wext.keys->def = wdev->wext.default_key;
|
|
|
|
wdev->wext.ibss.privacy = wdev->wext.default_key != -1;
|
|
|
|
if (wdev->wext.keys && wdev->wext.keys->def != -1) {
|
|
ck = kmemdup(wdev->wext.keys, sizeof(*ck), GFP_KERNEL);
|
|
if (!ck)
|
|
return -ENOMEM;
|
|
for (i = 0; i < CFG80211_MAX_WEP_KEYS; i++)
|
|
ck->params[i].key = ck->data[i];
|
|
}
|
|
err = __cfg80211_join_ibss(rdev, wdev->netdev,
|
|
&wdev->wext.ibss, ck);
|
|
if (err)
|
|
kfree(ck);
|
|
|
|
return err;
|
|
}
|
|
|
|
int cfg80211_ibss_wext_siwfreq(struct net_device *dev,
|
|
struct iw_request_info *info,
|
|
struct iw_freq *wextfreq, char *extra)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
|
|
struct ieee80211_channel *chan = NULL;
|
|
int err, freq;
|
|
|
|
/* call only for ibss! */
|
|
if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
|
|
return -EINVAL;
|
|
|
|
if (!rdev->ops->join_ibss)
|
|
return -EOPNOTSUPP;
|
|
|
|
freq = cfg80211_wext_freq(wextfreq);
|
|
if (freq < 0)
|
|
return freq;
|
|
|
|
if (freq) {
|
|
chan = ieee80211_get_channel(wdev->wiphy, freq);
|
|
if (!chan)
|
|
return -EINVAL;
|
|
if (chan->flags & IEEE80211_CHAN_NO_IR ||
|
|
chan->flags & IEEE80211_CHAN_DISABLED)
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (wdev->wext.ibss.chandef.chan == chan)
|
|
return 0;
|
|
|
|
wdev_lock(wdev);
|
|
err = 0;
|
|
if (wdev->ssid_len)
|
|
err = __cfg80211_leave_ibss(rdev, dev, true);
|
|
wdev_unlock(wdev);
|
|
|
|
if (err)
|
|
return err;
|
|
|
|
if (chan) {
|
|
cfg80211_chandef_create(&wdev->wext.ibss.chandef, chan,
|
|
NL80211_CHAN_NO_HT);
|
|
wdev->wext.ibss.channel_fixed = true;
|
|
} else {
|
|
/* cfg80211_ibss_wext_join will pick one if needed */
|
|
wdev->wext.ibss.channel_fixed = false;
|
|
}
|
|
|
|
wdev_lock(wdev);
|
|
err = cfg80211_ibss_wext_join(rdev, wdev);
|
|
wdev_unlock(wdev);
|
|
|
|
return err;
|
|
}
|
|
|
|
int cfg80211_ibss_wext_giwfreq(struct net_device *dev,
|
|
struct iw_request_info *info,
|
|
struct iw_freq *freq, char *extra)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
struct ieee80211_channel *chan = NULL;
|
|
|
|
/* call only for ibss! */
|
|
if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
|
|
return -EINVAL;
|
|
|
|
wdev_lock(wdev);
|
|
if (wdev->current_bss)
|
|
chan = wdev->current_bss->pub.channel;
|
|
else if (wdev->wext.ibss.chandef.chan)
|
|
chan = wdev->wext.ibss.chandef.chan;
|
|
wdev_unlock(wdev);
|
|
|
|
if (chan) {
|
|
freq->m = chan->center_freq;
|
|
freq->e = 6;
|
|
return 0;
|
|
}
|
|
|
|
/* no channel if not joining */
|
|
return -EINVAL;
|
|
}
|
|
|
|
int cfg80211_ibss_wext_siwessid(struct net_device *dev,
|
|
struct iw_request_info *info,
|
|
struct iw_point *data, char *ssid)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
|
|
size_t len = data->length;
|
|
int err;
|
|
|
|
/* call only for ibss! */
|
|
if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
|
|
return -EINVAL;
|
|
|
|
if (!rdev->ops->join_ibss)
|
|
return -EOPNOTSUPP;
|
|
|
|
wdev_lock(wdev);
|
|
err = 0;
|
|
if (wdev->ssid_len)
|
|
err = __cfg80211_leave_ibss(rdev, dev, true);
|
|
wdev_unlock(wdev);
|
|
|
|
if (err)
|
|
return err;
|
|
|
|
/* iwconfig uses nul termination in SSID.. */
|
|
if (len > 0 && ssid[len - 1] == '\0')
|
|
len--;
|
|
|
|
memcpy(wdev->ssid, ssid, len);
|
|
wdev->wext.ibss.ssid = wdev->ssid;
|
|
wdev->wext.ibss.ssid_len = len;
|
|
|
|
wdev_lock(wdev);
|
|
err = cfg80211_ibss_wext_join(rdev, wdev);
|
|
wdev_unlock(wdev);
|
|
|
|
return err;
|
|
}
|
|
|
|
int cfg80211_ibss_wext_giwessid(struct net_device *dev,
|
|
struct iw_request_info *info,
|
|
struct iw_point *data, char *ssid)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
|
|
/* call only for ibss! */
|
|
if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
|
|
return -EINVAL;
|
|
|
|
data->flags = 0;
|
|
|
|
wdev_lock(wdev);
|
|
if (wdev->ssid_len) {
|
|
data->flags = 1;
|
|
data->length = wdev->ssid_len;
|
|
memcpy(ssid, wdev->ssid, data->length);
|
|
} else if (wdev->wext.ibss.ssid && wdev->wext.ibss.ssid_len) {
|
|
data->flags = 1;
|
|
data->length = wdev->wext.ibss.ssid_len;
|
|
memcpy(ssid, wdev->wext.ibss.ssid, data->length);
|
|
}
|
|
wdev_unlock(wdev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int cfg80211_ibss_wext_siwap(struct net_device *dev,
|
|
struct iw_request_info *info,
|
|
struct sockaddr *ap_addr, char *extra)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
|
|
u8 *bssid = ap_addr->sa_data;
|
|
int err;
|
|
|
|
/* call only for ibss! */
|
|
if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
|
|
return -EINVAL;
|
|
|
|
if (!rdev->ops->join_ibss)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (ap_addr->sa_family != ARPHRD_ETHER)
|
|
return -EINVAL;
|
|
|
|
/* automatic mode */
|
|
if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))
|
|
bssid = NULL;
|
|
|
|
if (bssid && !is_valid_ether_addr(bssid))
|
|
return -EINVAL;
|
|
|
|
/* both automatic */
|
|
if (!bssid && !wdev->wext.ibss.bssid)
|
|
return 0;
|
|
|
|
/* fixed already - and no change */
|
|
if (wdev->wext.ibss.bssid && bssid &&
|
|
ether_addr_equal(bssid, wdev->wext.ibss.bssid))
|
|
return 0;
|
|
|
|
wdev_lock(wdev);
|
|
err = 0;
|
|
if (wdev->ssid_len)
|
|
err = __cfg80211_leave_ibss(rdev, dev, true);
|
|
wdev_unlock(wdev);
|
|
|
|
if (err)
|
|
return err;
|
|
|
|
if (bssid) {
|
|
memcpy(wdev->wext.bssid, bssid, ETH_ALEN);
|
|
wdev->wext.ibss.bssid = wdev->wext.bssid;
|
|
} else
|
|
wdev->wext.ibss.bssid = NULL;
|
|
|
|
wdev_lock(wdev);
|
|
err = cfg80211_ibss_wext_join(rdev, wdev);
|
|
wdev_unlock(wdev);
|
|
|
|
return err;
|
|
}
|
|
|
|
int cfg80211_ibss_wext_giwap(struct net_device *dev,
|
|
struct iw_request_info *info,
|
|
struct sockaddr *ap_addr, char *extra)
|
|
{
|
|
struct wireless_dev *wdev = dev->ieee80211_ptr;
|
|
|
|
/* call only for ibss! */
|
|
if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))
|
|
return -EINVAL;
|
|
|
|
ap_addr->sa_family = ARPHRD_ETHER;
|
|
|
|
wdev_lock(wdev);
|
|
if (wdev->current_bss)
|
|
memcpy(ap_addr->sa_data, wdev->current_bss->pub.bssid, ETH_ALEN);
|
|
else if (wdev->wext.ibss.bssid)
|
|
memcpy(ap_addr->sa_data, wdev->wext.ibss.bssid, ETH_ALEN);
|
|
else
|
|
eth_zero_addr(ap_addr->sa_data);
|
|
|
|
wdev_unlock(wdev);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|