2019-06-04 16:11:33 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2007-05-06 02:45:53 +08:00
|
|
|
/*
|
2013-03-27 04:54:24 +08:00
|
|
|
* Interface handling
|
2008-09-11 06:01:59 +08:00
|
|
|
*
|
2007-05-06 02:45:53 +08:00
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
|
|
* Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
|
2008-07-09 20:40:35 +08:00
|
|
|
* Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
|
2014-09-03 20:24:57 +08:00
|
|
|
* Copyright 2013-2014 Intel Mobile Communications GmbH
|
2016-10-20 14:52:50 +08:00
|
|
|
* Copyright (c) 2016 Intel Deutschland GmbH
|
2021-05-12 02:02:47 +08:00
|
|
|
* Copyright (C) 2018-2021 Intel Corporation
|
2007-05-06 02:45:53 +08:00
|
|
|
*/
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2007-05-06 02:45:53 +08:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
2021-02-19 01:31:24 +08:00
|
|
|
#include <linux/kcov.h>
|
2007-05-06 02:45:53 +08:00
|
|
|
#include <net/mac80211.h>
|
2010-01-06 01:00:58 +08:00
|
|
|
#include <net/ieee80211_radiotap.h>
|
2007-05-06 02:45:53 +08:00
|
|
|
#include "ieee80211_i.h"
|
|
|
|
#include "sta_info.h"
|
2007-05-06 02:46:38 +08:00
|
|
|
#include "debugfs_netdev.h"
|
2008-02-23 22:17:11 +08:00
|
|
|
#include "mesh.h"
|
2008-09-11 06:01:59 +08:00
|
|
|
#include "led.h"
|
2009-04-24 00:52:52 +08:00
|
|
|
#include "driver-ops.h"
|
2010-01-06 01:00:58 +08:00
|
|
|
#include "wme.h"
|
2010-10-01 23:20:41 +08:00
|
|
|
#include "rate.h"
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2009-01-24 05:54:03 +08:00
|
|
|
/**
|
|
|
|
* DOC: Interface list locking
|
|
|
|
*
|
|
|
|
* The interface list in each struct ieee80211_local is protected
|
|
|
|
* three-fold:
|
|
|
|
*
|
|
|
|
* (1) modifications may only be done under the RTNL
|
|
|
|
* (2) modifications and readers are protected against each other by
|
|
|
|
* the iflist_mtx.
|
|
|
|
* (3) modifications are done in an RCU manner so atomic readers
|
|
|
|
* can traverse the list in RCU-safe blocks.
|
|
|
|
*
|
|
|
|
* As a consequence, reads (traversals) of the list can be protected
|
|
|
|
* by either the RTNL, the iflist_mtx or RCU.
|
|
|
|
*/
|
|
|
|
|
2016-08-30 04:25:16 +08:00
|
|
|
static void ieee80211_iface_work(struct work_struct *work);
|
|
|
|
|
2012-10-24 16:59:25 +08:00
|
|
|
bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
int power;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
|
|
|
|
if (!chanctx_conf) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-07-08 22:55:55 +08:00
|
|
|
power = ieee80211_chandef_max_power(&chanctx_conf->def);
|
2012-10-24 16:59:25 +08:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL)
|
|
|
|
power = min(power, sdata->user_power_level);
|
|
|
|
|
|
|
|
if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL)
|
|
|
|
power = min(power, sdata->ap_power_level);
|
|
|
|
|
|
|
|
if (power != sdata->vif.bss_conf.txpower) {
|
|
|
|
sdata->vif.bss_conf.txpower = power;
|
|
|
|
ieee80211_hw_config(sdata->local, 0);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-01-14 19:55:08 +08:00
|
|
|
void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool update_bss)
|
2012-10-24 16:59:25 +08:00
|
|
|
{
|
2015-11-17 16:24:39 +08:00
|
|
|
if (__ieee80211_recalc_txpower(sdata) ||
|
|
|
|
(update_bss && ieee80211_sdata_running(sdata)))
|
2012-10-24 16:59:25 +08:00
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);
|
|
|
|
}
|
2009-01-24 05:54:03 +08:00
|
|
|
|
2013-04-08 17:52:34 +08:00
|
|
|
static u32 __ieee80211_idle_off(struct ieee80211_local *local)
|
2012-06-22 04:30:52 +08:00
|
|
|
{
|
|
|
|
if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
|
|
|
|
return IEEE80211_CONF_CHANGE_IDLE;
|
|
|
|
}
|
|
|
|
|
2013-04-08 17:52:34 +08:00
|
|
|
static u32 __ieee80211_idle_on(struct ieee80211_local *local)
|
2012-06-22 04:30:52 +08:00
|
|
|
{
|
|
|
|
if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
|
|
|
|
return 0;
|
|
|
|
|
2015-01-07 21:42:39 +08:00
|
|
|
ieee80211_flush_queues(local, NULL, false);
|
2012-06-22 04:30:52 +08:00
|
|
|
|
|
|
|
local->hw.conf.flags |= IEEE80211_CONF_IDLE;
|
|
|
|
return IEEE80211_CONF_CHANGE_IDLE;
|
|
|
|
}
|
|
|
|
|
2013-04-08 17:52:34 +08:00
|
|
|
static u32 __ieee80211_recalc_idle(struct ieee80211_local *local,
|
|
|
|
bool force_active)
|
2012-06-22 04:30:52 +08:00
|
|
|
{
|
2014-02-12 18:29:32 +08:00
|
|
|
bool working, scanning, active;
|
2012-06-22 04:30:52 +08:00
|
|
|
unsigned int led_trig_start = 0, led_trig_stop = 0;
|
|
|
|
|
|
|
|
lockdep_assert_held(&local->mtx);
|
|
|
|
|
2013-04-08 17:52:34 +08:00
|
|
|
active = force_active ||
|
|
|
|
!list_empty(&local->chanctx_list) ||
|
|
|
|
local->monitors;
|
2012-06-22 04:30:52 +08:00
|
|
|
|
2014-02-12 18:29:32 +08:00
|
|
|
working = !local->ops->remain_on_channel &&
|
|
|
|
!list_empty(&local->roc_list);
|
2012-06-22 04:30:52 +08:00
|
|
|
|
2013-02-07 06:57:57 +08:00
|
|
|
scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
|
|
|
|
test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
|
2012-06-22 04:30:52 +08:00
|
|
|
|
|
|
|
if (working || scanning)
|
|
|
|
led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
|
|
|
|
else
|
|
|
|
led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
|
|
|
|
|
2013-02-07 07:14:51 +08:00
|
|
|
if (active)
|
2012-06-22 04:30:52 +08:00
|
|
|
led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
|
|
|
|
else
|
|
|
|
led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
|
|
|
|
|
|
|
|
ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);
|
|
|
|
|
2013-02-07 07:14:51 +08:00
|
|
|
if (working || scanning || active)
|
2013-04-08 17:52:34 +08:00
|
|
|
return __ieee80211_idle_off(local);
|
|
|
|
return __ieee80211_idle_on(local);
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 ieee80211_idle_off(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
return __ieee80211_recalc_idle(local, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_recalc_idle(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
u32 change = __ieee80211_recalc_idle(local, false);
|
2013-02-07 07:14:51 +08:00
|
|
|
if (change)
|
|
|
|
ieee80211_hw_config(local, change);
|
2012-06-22 04:30:52 +08:00
|
|
|
}
|
|
|
|
|
2013-06-12 02:48:32 +08:00
|
|
|
static int ieee80211_verify_mac(struct ieee80211_sub_if_data *sdata, u8 *addr,
|
2013-05-28 19:01:53 +08:00
|
|
|
bool check_dup)
|
2012-11-28 01:23:06 +08:00
|
|
|
{
|
2013-05-27 16:43:09 +08:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_sub_if_data *iter;
|
2012-11-28 01:23:06 +08:00
|
|
|
u64 new, mask, tmp;
|
|
|
|
u8 *m;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
m = addr;
|
|
|
|
new = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
|
|
|
|
((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
|
|
|
|
((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
|
|
|
|
|
|
|
|
m = local->hw.wiphy->addr_mask;
|
|
|
|
mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
|
|
|
|
((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
|
|
|
|
((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
|
|
|
|
|
2013-05-28 19:01:53 +08:00
|
|
|
if (!check_dup)
|
|
|
|
return ret;
|
2012-11-28 01:23:06 +08:00
|
|
|
|
|
|
|
mutex_lock(&local->iflist_mtx);
|
2013-05-27 16:43:09 +08:00
|
|
|
list_for_each_entry(iter, &local->interfaces, list) {
|
|
|
|
if (iter == sdata)
|
2012-11-28 01:23:06 +08:00
|
|
|
continue;
|
|
|
|
|
2013-06-12 02:48:32 +08:00
|
|
|
if (iter->vif.type == NL80211_IFTYPE_MONITOR &&
|
2016-08-30 04:25:15 +08:00
|
|
|
!(iter->u.mntr.flags & MONITOR_FLAG_ACTIVE))
|
2012-11-28 01:23:06 +08:00
|
|
|
continue;
|
|
|
|
|
2013-05-27 16:43:09 +08:00
|
|
|
m = iter->vif.addr;
|
2012-11-28 01:23:06 +08:00
|
|
|
tmp = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
|
|
|
|
((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
|
|
|
|
((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
|
|
|
|
|
|
|
|
if ((new & ~mask) != (tmp & ~mask)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-11-26 00:46:19 +08:00
|
|
|
static int ieee80211_change_mac(struct net_device *dev, void *addr)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2009-12-30 21:54:03 +08:00
|
|
|
struct sockaddr *sa = addr;
|
2013-05-28 19:01:53 +08:00
|
|
|
bool check_dup = true;
|
2009-11-26 00:46:19 +08:00
|
|
|
int ret;
|
|
|
|
|
2009-12-23 20:15:31 +08:00
|
|
|
if (ieee80211_sdata_running(sdata))
|
2009-11-26 00:46:19 +08:00
|
|
|
return -EBUSY;
|
|
|
|
|
2013-05-28 19:01:53 +08:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
|
2016-08-30 04:25:15 +08:00
|
|
|
!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
|
2013-05-28 19:01:53 +08:00
|
|
|
check_dup = false;
|
|
|
|
|
2013-06-12 02:48:32 +08:00
|
|
|
ret = ieee80211_verify_mac(sdata, sa->sa_data, check_dup);
|
2012-11-28 01:23:06 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2009-12-30 21:54:03 +08:00
|
|
|
ret = eth_mac_addr(dev, sa);
|
2009-11-26 00:46:19 +08:00
|
|
|
|
|
|
|
if (ret == 0)
|
2009-12-30 21:54:03 +08:00
|
|
|
memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
|
2009-11-26 00:46:19 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-09-11 06:01:59 +08:00
|
|
|
static inline int identical_mac_addr_allowed(int type1, int type2)
|
|
|
|
{
|
|
|
|
return type1 == NL80211_IFTYPE_MONITOR ||
|
|
|
|
type2 == NL80211_IFTYPE_MONITOR ||
|
2012-06-19 02:07:15 +08:00
|
|
|
type1 == NL80211_IFTYPE_P2P_DEVICE ||
|
|
|
|
type2 == NL80211_IFTYPE_P2P_DEVICE ||
|
2008-09-11 06:01:59 +08:00
|
|
|
(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
|
|
|
|
(type1 == NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
(type2 == NL80211_IFTYPE_AP ||
|
|
|
|
type2 == NL80211_IFTYPE_AP_VLAN));
|
|
|
|
}
|
|
|
|
|
2010-08-27 18:35:57 +08:00
|
|
|
static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum nl80211_iftype iftype)
|
2008-09-11 06:01:59 +08:00
|
|
|
{
|
2008-09-26 19:34:54 +08:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2010-08-27 18:35:57 +08:00
|
|
|
struct ieee80211_sub_if_data *nsdata;
|
2014-02-27 17:07:21 +08:00
|
|
|
int ret;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2010-08-27 18:35:57 +08:00
|
|
|
ASSERT_RTNL();
|
2008-09-11 06:01:59 +08:00
|
|
|
|
|
|
|
/* we hold the RTNL here so can safely walk the list */
|
|
|
|
list_for_each_entry(nsdata, &local->interfaces, list) {
|
2012-06-19 21:54:05 +08:00
|
|
|
if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
|
2014-11-03 17:33:19 +08:00
|
|
|
/*
|
|
|
|
* Only OCB and monitor mode may coexist
|
|
|
|
*/
|
|
|
|
if ((sdata->vif.type == NL80211_IFTYPE_OCB &&
|
|
|
|
nsdata->vif.type != NL80211_IFTYPE_MONITOR) ||
|
|
|
|
(sdata->vif.type != NL80211_IFTYPE_MONITOR &&
|
|
|
|
nsdata->vif.type == NL80211_IFTYPE_OCB))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2008-09-11 06:01:59 +08:00
|
|
|
/*
|
|
|
|
* Allow only a single IBSS interface to be up at any
|
|
|
|
* time. This is restricted because beacon distribution
|
|
|
|
* cannot work properly if both are in the same IBSS.
|
|
|
|
*
|
|
|
|
* To remove this restriction we'd have to disallow them
|
|
|
|
* from setting the same SSID on different IBSS interfaces
|
|
|
|
* belonging to the same hardware. Then, however, we're
|
|
|
|
* faced with having to adopt two different TSF timers...
|
|
|
|
*/
|
2010-08-27 18:35:57 +08:00
|
|
|
if (iftype == NL80211_IFTYPE_ADHOC &&
|
2008-09-11 06:01:59 +08:00
|
|
|
nsdata->vif.type == NL80211_IFTYPE_ADHOC)
|
|
|
|
return -EBUSY;
|
2013-07-11 22:09:06 +08:00
|
|
|
/*
|
|
|
|
* will not add another interface while any channel
|
|
|
|
* switch is active.
|
|
|
|
*/
|
|
|
|
if (nsdata->vif.csa_active)
|
|
|
|
return -EBUSY;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The remaining checks are only performed for interfaces
|
|
|
|
* with the same MAC address.
|
|
|
|
*/
|
2012-06-19 21:54:05 +08:00
|
|
|
if (!ether_addr_equal(sdata->vif.addr,
|
|
|
|
nsdata->vif.addr))
|
2008-09-11 06:01:59 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check whether it may have the same address
|
|
|
|
*/
|
2010-08-27 18:35:57 +08:00
|
|
|
if (!identical_mac_addr_allowed(iftype,
|
2008-09-11 06:01:59 +08:00
|
|
|
nsdata->vif.type))
|
|
|
|
return -ENOTUNIQ;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* can only add VLANs to enabled APs
|
|
|
|
*/
|
2010-08-27 18:35:57 +08:00
|
|
|
if (iftype == NL80211_IFTYPE_AP_VLAN &&
|
2008-09-11 06:01:59 +08:00
|
|
|
nsdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
sdata->bss = &nsdata->u.ap;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-27 17:07:21 +08:00
|
|
|
mutex_lock(&local->chanctx_mtx);
|
|
|
|
ret = ieee80211_check_combinations(sdata, NULL, 0, 0);
|
|
|
|
mutex_unlock(&local->chanctx_mtx);
|
|
|
|
return ret;
|
2010-08-27 18:35:57 +08:00
|
|
|
}
|
|
|
|
|
2013-08-26 15:30:32 +08:00
|
|
|
static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum nl80211_iftype iftype)
|
2012-04-03 22:28:50 +08:00
|
|
|
{
|
|
|
|
int n_queues = sdata->local->hw.queues;
|
|
|
|
int i;
|
|
|
|
|
2016-09-20 22:31:14 +08:00
|
|
|
if (iftype == NL80211_IFTYPE_NAN)
|
|
|
|
return 0;
|
|
|
|
|
2013-08-26 15:30:32 +08:00
|
|
|
if (iftype != NL80211_IFTYPE_P2P_DEVICE) {
|
2012-08-21 17:43:35 +08:00
|
|
|
for (i = 0; i < IEEE80211_NUM_ACS; i++) {
|
|
|
|
if (WARN_ON_ONCE(sdata->vif.hw_queue[i] ==
|
|
|
|
IEEE80211_INVAL_HW_QUEUE))
|
|
|
|
return -EINVAL;
|
|
|
|
if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >=
|
|
|
|
n_queues))
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2012-04-03 22:28:50 +08:00
|
|
|
}
|
|
|
|
|
2013-08-26 15:30:32 +08:00
|
|
|
if ((iftype != NL80211_IFTYPE_AP &&
|
|
|
|
iftype != NL80211_IFTYPE_P2P_GO &&
|
|
|
|
iftype != NL80211_IFTYPE_MESH_POINT) ||
|
2015-06-03 03:39:54 +08:00
|
|
|
!ieee80211_hw_check(&sdata->local->hw, QUEUE_CONTROL)) {
|
2012-04-03 22:28:50 +08:00
|
|
|
sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static int ieee80211_open(struct net_device *dev)
|
2020-09-08 20:36:53 +08:00
|
|
|
{
|
2020-09-08 20:37:02 +08:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* fail early if user set an invalid address */
|
|
|
|
if (!is_valid_ether_addr(dev->dev_addr))
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
|
|
|
err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2021-01-22 23:19:43 +08:00
|
|
|
wiphy_lock(sdata->local->hw.wiphy);
|
|
|
|
err = ieee80211_do_open(&sdata->wdev, true);
|
|
|
|
wiphy_unlock(sdata->local->hw.wiphy);
|
|
|
|
|
|
|
|
return err;
|
2020-09-08 20:36:53 +08:00
|
|
|
}
|
|
|
|
|
2021-01-22 23:19:43 +08:00
|
|
|
static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata, bool going_down)
|
2020-09-08 20:36:53 +08:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2020-09-08 20:37:02 +08:00
|
|
|
unsigned long flags;
|
|
|
|
struct sk_buff *skb, *tmp;
|
|
|
|
u32 hw_reconf_flags = 0;
|
|
|
|
int i, flushed;
|
|
|
|
struct ps_data *ps;
|
|
|
|
struct cfg80211_chan_def chandef;
|
|
|
|
bool cancel_scan;
|
|
|
|
struct cfg80211_nan_func *func;
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
clear_bit(SDATA_STATE_RUNNING, &sdata->state);
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
cancel_scan = rcu_access_pointer(local->scan_sdata) == sdata;
|
|
|
|
if (cancel_scan)
|
|
|
|
ieee80211_scan_cancel(local);
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/*
|
|
|
|
* Stop TX on this interface first.
|
|
|
|
*/
|
|
|
|
if (sdata->dev)
|
|
|
|
netif_tx_stop_all_queues(sdata->dev);
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_roc_purge(local, sdata);
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
ieee80211_mgd_stop(sdata);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
ieee80211_ibss_stop(sdata);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES)
|
|
|
|
break;
|
|
|
|
list_del_rcu(&sdata->u.mntr.list);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/*
|
|
|
|
* Remove all stations associated with this interface.
|
|
|
|
*
|
|
|
|
* This must be done before calling ops->remove_interface()
|
|
|
|
* because otherwise we can later invoke ops->sta_notify()
|
|
|
|
* whenever the STAs are removed, and that invalidates driver
|
|
|
|
* assumptions about always getting a vif pointer that is valid
|
|
|
|
* (because if we remove a STA after ops->remove_interface()
|
|
|
|
* the driver will have removed the vif info already!)
|
|
|
|
*
|
2020-11-09 17:57:46 +08:00
|
|
|
* For AP_VLANs stations may exist since there's nothing else that
|
2020-09-08 20:37:02 +08:00
|
|
|
* would have removed them, but in other modes there shouldn't
|
|
|
|
* be any stations.
|
|
|
|
*/
|
|
|
|
flushed = sta_info_flush(sdata);
|
2020-11-09 17:57:46 +08:00
|
|
|
WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_AP_VLAN && flushed > 0);
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/* don't count this interface for allmulti while it is down */
|
|
|
|
if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
|
|
|
|
atomic_dec(&local->iff_allmultis);
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP) {
|
|
|
|
local->fif_pspoll--;
|
|
|
|
local->fif_probe_req--;
|
|
|
|
} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
|
|
|
|
local->fif_probe_req--;
|
2020-09-08 20:36:53 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->dev) {
|
|
|
|
netif_addr_lock_bh(sdata->dev);
|
|
|
|
spin_lock_bh(&local->filter_lock);
|
|
|
|
__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
|
|
|
|
sdata->dev->addr_len);
|
|
|
|
spin_unlock_bh(&local->filter_lock);
|
|
|
|
netif_addr_unlock_bh(sdata->dev);
|
2020-09-08 20:36:53 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
del_timer_sync(&local->dynamic_ps_timer);
|
|
|
|
cancel_work_sync(&local->dynamic_ps_enable_work);
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
cancel_work_sync(&sdata->recalc_smps);
|
|
|
|
sdata_lock(sdata);
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
sdata->vif.csa_active = false;
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION)
|
|
|
|
sdata->u.mgd.csa_waiting_bcn = false;
|
|
|
|
if (sdata->csa_block_tx) {
|
|
|
|
ieee80211_wake_vif_queues(local, sdata,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_CSA);
|
|
|
|
sdata->csa_block_tx = false;
|
2020-09-08 20:36:53 +08:00
|
|
|
}
|
2020-09-08 20:37:02 +08:00
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
sdata_unlock(sdata);
|
2020-09-08 20:36:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
cancel_work_sync(&sdata->csa_finalize_work);
|
2010-10-02 19:17:07 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
|
2010-10-02 19:17:07 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->wdev.cac_started) {
|
|
|
|
chandef = sdata->vif.bss_conf.chandef;
|
|
|
|
WARN_ON(local->suspended);
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ieee80211_vif_release_channel(sdata);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
cfg80211_cac_event(sdata->dev, &chandef,
|
|
|
|
NL80211_RADAR_CAC_ABORTED,
|
|
|
|
GFP_KERNEL);
|
|
|
|
}
|
2010-10-02 19:17:07 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP) {
|
|
|
|
WARN_ON(!list_empty(&sdata->u.ap.vlans));
|
|
|
|
} else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
|
|
|
|
/* remove all packets in parent bc_buf pointing to this dev */
|
|
|
|
ps = &sdata->bss->ps;
|
2012-04-03 22:28:50 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
spin_lock_irqsave(&ps->bc_buf.lock, flags);
|
|
|
|
skb_queue_walk_safe(&ps->bc_buf, skb, tmp) {
|
|
|
|
if (skb->dev == sdata->dev) {
|
|
|
|
__skb_unlink(skb, &ps->bc_buf);
|
|
|
|
local->total_ps_buffered--;
|
|
|
|
ieee80211_free_txskb(&local->hw, skb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&ps->bc_buf.lock, flags);
|
2012-04-03 22:28:50 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (going_down)
|
|
|
|
local->open_count--;
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
list_del(&sdata->u.vlan.list);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
RCU_INIT_POINTER(sdata->vif.chanctx_conf, NULL);
|
|
|
|
/* see comment in the default case below */
|
|
|
|
ieee80211_free_keys(sdata, true);
|
|
|
|
/* no need to tell driver */
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) {
|
|
|
|
local->cooked_mntrs--;
|
|
|
|
break;
|
|
|
|
}
|
2012-07-11 22:38:09 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
local->monitors--;
|
|
|
|
if (local->monitors == 0) {
|
|
|
|
local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
|
|
|
|
hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
|
|
|
|
}
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_adjust_monitor_flags(sdata, -1);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_NAN:
|
|
|
|
/* clean all the functions */
|
|
|
|
spin_lock_bh(&sdata->u.nan.func_lock);
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, i) {
|
|
|
|
idr_remove(&sdata->u.nan.function_inst_ids, i);
|
|
|
|
cfg80211_free_nan_func(func);
|
|
|
|
}
|
|
|
|
idr_destroy(&sdata->u.nan.function_inst_ids);
|
2012-04-03 22:28:50 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
spin_unlock_bh(&sdata->u.nan.func_lock);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_P2P_DEVICE:
|
|
|
|
/* relies on synchronize_rcu() below */
|
|
|
|
RCU_INIT_POINTER(local->p2p_sdata, NULL);
|
|
|
|
fallthrough;
|
|
|
|
default:
|
|
|
|
cancel_work_sync(&sdata->work);
|
|
|
|
/*
|
|
|
|
* When we get here, the interface is marked down.
|
|
|
|
* Free the remaining keys, if there are any
|
|
|
|
* (which can happen in AP mode if userspace sets
|
2020-11-09 17:57:46 +08:00
|
|
|
* keys before the interface is operating)
|
2020-09-08 20:37:02 +08:00
|
|
|
*
|
|
|
|
* Force the key freeing to always synchronize_net()
|
|
|
|
* to wait for the RX path in case it is using this
|
|
|
|
* interface enqueuing frames at this very time on
|
|
|
|
* another CPU.
|
|
|
|
*/
|
|
|
|
ieee80211_free_keys(sdata, true);
|
|
|
|
skb_queue_purge(&sdata->skb_queue);
|
2012-04-03 20:35:57 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
|
|
|
|
skb_queue_walk_safe(&local->pending[i], skb, tmp) {
|
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
if (info->control.vif == &sdata->vif) {
|
|
|
|
__skb_unlink(skb, &local->pending[i]);
|
|
|
|
ieee80211_free_txskb(&local->hw, skb);
|
|
|
|
}
|
|
|
|
}
|
2012-04-03 22:28:50 +08:00
|
|
|
}
|
2020-09-08 20:37:02 +08:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
2012-04-03 22:28:50 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
|
|
|
ieee80211_txq_remove_vlan(local, sdata);
|
2014-01-29 20:28:02 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
sdata->bss = NULL;
|
|
|
|
|
|
|
|
if (local->open_count == 0)
|
|
|
|
ieee80211_clear_tx_pending(local);
|
|
|
|
|
|
|
|
sdata->vif.bss_conf.beacon_int = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the interface goes down while suspended, presumably because
|
|
|
|
* the device was unplugged and that happens before our resume,
|
|
|
|
* then the driver is already unconfigured and the remainder of
|
|
|
|
* this function isn't needed.
|
|
|
|
* XXX: what about WoWLAN? If the device has software state, e.g.
|
|
|
|
* memory allocated, it might expect teardown commands from
|
|
|
|
* mac80211 here?
|
|
|
|
*/
|
|
|
|
if (local->suspended) {
|
|
|
|
WARN_ON(local->wowlan);
|
|
|
|
WARN_ON(rtnl_dereference(local->monitor_sdata));
|
|
|
|
return;
|
2012-07-26 23:24:39 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
if (local->monitors == 0)
|
|
|
|
ieee80211_del_virtual_monitor(local);
|
2016-08-30 04:25:16 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
mutex_unlock(&local->mtx);
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
|
|
|
|
break;
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
fallthrough;
|
|
|
|
default:
|
|
|
|
if (going_down)
|
|
|
|
drv_remove_interface(local, sdata);
|
|
|
|
}
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_recalc_ps(local);
|
2013-03-21 05:25:17 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (cancel_scan)
|
|
|
|
flush_delayed_work(&local->scan_work);
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (local->open_count == 0) {
|
|
|
|
ieee80211_stop_device(local);
|
|
|
|
|
|
|
|
/* no reconfiguring after stop! */
|
2013-03-21 05:25:17 +08:00
|
|
|
return;
|
|
|
|
}
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/* do after stop to avoid reconfiguring when we stop anyway */
|
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
ieee80211_hw_config(local, hw_reconf_flags);
|
2013-03-21 05:25:17 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (local->monitors == local->open_count)
|
|
|
|
ieee80211_add_virtual_monitor(local);
|
|
|
|
}
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static int ieee80211_stop(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2012-07-26 23:24:39 +08:00
|
|
|
|
2021-05-17 22:03:23 +08:00
|
|
|
/* close all dependent VLAN interfaces before locking wiphy */
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP) {
|
|
|
|
struct ieee80211_sub_if_data *vlan, *tmpsdata;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
|
|
|
|
u.vlan.list)
|
|
|
|
dev_close(vlan->dev);
|
|
|
|
}
|
|
|
|
|
2021-01-22 23:19:43 +08:00
|
|
|
wiphy_lock(sdata->local->hw.wiphy);
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_do_stop(sdata, true);
|
2021-01-22 23:19:43 +08:00
|
|
|
wiphy_unlock(sdata->local->hw.wiphy);
|
2012-04-03 20:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
return 0;
|
2012-04-03 20:35:57 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static void ieee80211_set_multicast_list(struct net_device *dev)
|
2010-08-27 18:35:57 +08:00
|
|
|
{
|
2020-09-08 20:37:02 +08:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2010-08-27 18:35:57 +08:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2020-09-08 20:37:02 +08:00
|
|
|
int allmulti, sdata_allmulti;
|
2010-08-27 18:35:57 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
allmulti = !!(dev->flags & IFF_ALLMULTI);
|
|
|
|
sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
|
2011-11-04 18:18:11 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (allmulti != sdata_allmulti) {
|
|
|
|
if (dev->flags & IFF_ALLMULTI)
|
|
|
|
atomic_inc(&local->iff_allmultis);
|
|
|
|
else
|
|
|
|
atomic_dec(&local->iff_allmultis);
|
|
|
|
sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
|
|
|
|
}
|
2011-11-04 18:18:11 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
spin_lock_bh(&local->filter_lock);
|
|
|
|
__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
|
|
|
|
spin_unlock_bh(&local->filter_lock);
|
|
|
|
ieee80211_queue_work(&local->hw, &local->reconfig_filter);
|
|
|
|
}
|
2011-11-04 18:18:11 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/*
|
|
|
|
* Called when the netdev is removed or, by the code below, before
|
|
|
|
* the interface type changes.
|
|
|
|
*/
|
|
|
|
static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
/* free extra data */
|
|
|
|
ieee80211_free_keys(sdata, false);
|
2015-05-13 17:16:48 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_debugfs_remove_netdev(sdata);
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2021-05-12 02:02:47 +08:00
|
|
|
ieee80211_destroy_frag_cache(&sdata->frags);
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif))
|
|
|
|
ieee80211_mesh_teardown_sdata(sdata);
|
|
|
|
}
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static void ieee80211_uninit(struct net_device *dev)
|
|
|
|
{
|
|
|
|
ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
|
|
|
|
}
|
2012-07-13 01:28:31 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static u16 ieee80211_netdev_select_queue(struct net_device *dev,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
struct net_device *sb_dev)
|
|
|
|
{
|
|
|
|
return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
|
|
|
|
}
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static void
|
|
|
|
ieee80211_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
|
|
|
|
{
|
2020-10-12 16:18:19 +08:00
|
|
|
dev_fetch_sw_netstats(stats, dev->tstats);
|
2020-09-08 20:37:02 +08:00
|
|
|
}
|
2009-08-04 20:48:51 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static const struct net_device_ops ieee80211_dataif_ops = {
|
|
|
|
.ndo_open = ieee80211_open,
|
|
|
|
.ndo_stop = ieee80211_stop,
|
|
|
|
.ndo_uninit = ieee80211_uninit,
|
|
|
|
.ndo_start_xmit = ieee80211_subif_start_xmit,
|
|
|
|
.ndo_set_rx_mode = ieee80211_set_multicast_list,
|
|
|
|
.ndo_set_mac_address = ieee80211_change_mac,
|
|
|
|
.ndo_select_queue = ieee80211_netdev_select_queue,
|
|
|
|
.ndo_get_stats64 = ieee80211_get_stats64,
|
|
|
|
};
|
2009-08-04 20:48:51 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static u16 ieee80211_monitor_select_queue(struct net_device *dev,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
struct net_device *sb_dev)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
struct ieee80211_hdr *hdr;
|
|
|
|
int len_rthdr;
|
2020-04-17 17:18:31 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
return 0;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/* reset flags and info before parsing radiotap header */
|
|
|
|
memset(info, 0, sizeof(*info));
|
2011-10-16 16:57:31 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (!ieee80211_parse_tx_radiotap(skb, dev))
|
|
|
|
return 0; /* doesn't matter, frame will be dropped */
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
len_rthdr = ieee80211_get_radiotap_len(skb->data);
|
|
|
|
hdr = (struct ieee80211_hdr *)(skb->data + len_rthdr);
|
|
|
|
if (skb->len < len_rthdr + 2 ||
|
|
|
|
skb->len < len_rthdr + ieee80211_hdrlen(hdr->frame_control))
|
|
|
|
return 0; /* doesn't matter, frame will be dropped */
|
2010-09-15 21:13:13 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
return ieee80211_select_queue_80211(sdata, skb, hdr);
|
|
|
|
}
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static const struct net_device_ops ieee80211_monitorif_ops = {
|
|
|
|
.ndo_open = ieee80211_open,
|
|
|
|
.ndo_stop = ieee80211_stop,
|
|
|
|
.ndo_uninit = ieee80211_uninit,
|
|
|
|
.ndo_start_xmit = ieee80211_monitor_start_xmit,
|
|
|
|
.ndo_set_rx_mode = ieee80211_set_multicast_list,
|
|
|
|
.ndo_set_mac_address = ieee80211_change_mac,
|
|
|
|
.ndo_select_queue = ieee80211_monitor_select_queue,
|
|
|
|
.ndo_get_stats64 = ieee80211_get_stats64,
|
|
|
|
};
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static const struct net_device_ops ieee80211_dataif_8023_ops = {
|
|
|
|
.ndo_open = ieee80211_open,
|
|
|
|
.ndo_stop = ieee80211_stop,
|
|
|
|
.ndo_uninit = ieee80211_uninit,
|
|
|
|
.ndo_start_xmit = ieee80211_subif_start_xmit_8023,
|
|
|
|
.ndo_set_rx_mode = ieee80211_set_multicast_list,
|
|
|
|
.ndo_set_mac_address = ieee80211_change_mac,
|
|
|
|
.ndo_select_queue = ieee80211_netdev_select_queue,
|
|
|
|
.ndo_get_stats64 = ieee80211_get_stats64,
|
|
|
|
};
|
2010-10-01 23:20:41 +08:00
|
|
|
|
2020-12-19 02:47:18 +08:00
|
|
|
static bool ieee80211_iftype_supports_hdr_offload(enum nl80211_iftype iftype)
|
2020-09-08 20:37:02 +08:00
|
|
|
{
|
|
|
|
switch (iftype) {
|
|
|
|
/* P2P GO and client are mapped to AP/STATION types */
|
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
return true;
|
2017-04-13 19:28:18 +08:00
|
|
|
default:
|
2020-09-08 20:37:02 +08:00
|
|
|
return false;
|
2008-09-11 06:01:59 +08:00
|
|
|
}
|
2020-09-08 20:37:02 +08:00
|
|
|
}
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static bool ieee80211_set_sdata_offload_flags(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
u32 flags;
|
2009-04-16 19:17:24 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
flags = sdata->vif.offload_flags;
|
2013-03-27 05:23:20 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD) &&
|
2020-12-19 02:47:18 +08:00
|
|
|
ieee80211_iftype_supports_hdr_offload(sdata->vif.type)) {
|
2020-09-08 20:37:02 +08:00
|
|
|
flags |= IEEE80211_OFFLOAD_ENCAP_ENABLED;
|
2013-03-27 05:23:20 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_FRAG) &&
|
|
|
|
local->hw.wiphy->frag_threshold != (u32)-1)
|
|
|
|
flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
|
2013-03-27 05:23:20 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (local->monitors)
|
|
|
|
flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
|
|
|
|
} else {
|
|
|
|
flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
|
2013-03-27 05:23:20 +08:00
|
|
|
}
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-12-19 02:47:18 +08:00
|
|
|
if (ieee80211_hw_check(&local->hw, SUPPORTS_RX_DECAP_OFFLOAD) &&
|
|
|
|
ieee80211_iftype_supports_hdr_offload(sdata->vif.type)) {
|
|
|
|
flags |= IEEE80211_OFFLOAD_DECAP_ENABLED;
|
|
|
|
|
2021-03-30 09:35:16 +08:00
|
|
|
if (local->monitors &&
|
|
|
|
!ieee80211_hw_check(&local->hw, SUPPORTS_CONC_MON_RX_DECAP))
|
2020-12-19 02:47:18 +08:00
|
|
|
flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
|
|
|
|
} else {
|
|
|
|
flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
|
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->vif.offload_flags == flags)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
sdata->vif.offload_flags = flags;
|
2020-12-19 02:47:18 +08:00
|
|
|
ieee80211_check_fast_rx_iface(sdata);
|
2020-09-08 20:37:02 +08:00
|
|
|
return true;
|
2008-09-11 06:01:59 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static void ieee80211_set_vif_encap_ops(struct ieee80211_sub_if_data *sdata)
|
2008-09-11 06:01:59 +08:00
|
|
|
{
|
2020-09-08 20:37:02 +08:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_sub_if_data *bss = sdata;
|
|
|
|
bool enabled;
|
2010-08-27 18:35:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
|
|
|
|
if (!sdata->bss)
|
|
|
|
return;
|
2010-08-27 18:35:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
bss = container_of(sdata->bss, struct ieee80211_sub_if_data, u.ap);
|
|
|
|
}
|
2010-08-27 18:35:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD) ||
|
2020-12-19 02:47:18 +08:00
|
|
|
!ieee80211_iftype_supports_hdr_offload(bss->vif.type))
|
2020-09-08 20:37:02 +08:00
|
|
|
return;
|
2010-08-27 18:35:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
enabled = bss->vif.offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED;
|
|
|
|
if (sdata->wdev.use_4addr &&
|
|
|
|
!(bss->vif.offload_flags & IEEE80211_OFFLOAD_ENCAP_4ADDR))
|
|
|
|
enabled = false;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
sdata->dev->netdev_ops = enabled ? &ieee80211_dataif_8023_ops :
|
|
|
|
&ieee80211_dataif_ops;
|
|
|
|
}
|
2011-05-14 12:13:28 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
static void ieee80211_recalc_sdata_offload(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_sub_if_data *vsdata;
|
2010-11-05 07:59:28 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (ieee80211_set_sdata_offload_flags(sdata)) {
|
|
|
|
drv_update_vif_offload(local, sdata);
|
|
|
|
ieee80211_set_vif_encap_ops(sdata);
|
|
|
|
}
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
list_for_each_entry(vsdata, &local->interfaces, list) {
|
|
|
|
if (vsdata->vif.type != NL80211_IFTYPE_AP_VLAN ||
|
|
|
|
vsdata->bss != &sdata->u.ap)
|
|
|
|
continue;
|
2009-12-23 20:15:35 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_set_vif_encap_ops(vsdata);
|
2014-01-23 20:28:16 +08:00
|
|
|
}
|
2020-09-08 20:37:02 +08:00
|
|
|
}
|
2013-08-28 19:41:31 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
void ieee80211_recalc_offload(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD))
|
|
|
|
return;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
2009-08-04 20:48:51 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (!ieee80211_sdata_running(sdata))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ieee80211_recalc_sdata_offload(sdata);
|
2012-06-19 02:07:15 +08:00
|
|
|
}
|
2009-08-17 22:16:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
}
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const int offset)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
u32 flags = sdata->u.mntr.flags;
|
2014-04-09 21:10:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
#define ADJUST(_f, _s) do { \
|
|
|
|
if (flags & MONITOR_FLAG_##_f) \
|
|
|
|
local->fif_##_s += offset; \
|
|
|
|
} while (0)
|
2012-09-11 20:34:12 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ADJUST(FCSFAIL, fcsfail);
|
|
|
|
ADJUST(PLCPFAIL, plcpfail);
|
|
|
|
ADJUST(CONTROL, control);
|
|
|
|
ADJUST(CONTROL, pspoll);
|
|
|
|
ADJUST(OTHER_BSS, other_bss);
|
2013-02-09 01:16:20 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
#undef ADJUST
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < IEEE80211_NUM_ACS; i++) {
|
|
|
|
if (ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
|
|
|
|
sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;
|
|
|
|
else if (local->hw.queues >= IEEE80211_NUM_ACS)
|
|
|
|
sdata->vif.hw_queue[i] = i;
|
|
|
|
else
|
|
|
|
sdata->vif.hw_queue[i] = 0;
|
2013-02-09 01:16:20 +08:00
|
|
|
}
|
2020-09-08 20:37:02 +08:00
|
|
|
sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
|
|
|
|
}
|
2013-02-09 01:16:20 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
int ret;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
|
|
|
|
return 0;
|
2013-02-13 23:49:15 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ASSERT_RTNL();
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (local->monitor_sdata)
|
|
|
|
return 0;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
|
|
|
|
if (!sdata)
|
|
|
|
return -ENOMEM;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/* set up data */
|
|
|
|
sdata->local = local;
|
|
|
|
sdata->vif.type = NL80211_IFTYPE_MONITOR;
|
|
|
|
snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
|
|
|
|
wiphy_name(local->hw.wiphy));
|
|
|
|
sdata->wdev.iftype = NL80211_IFTYPE_MONITOR;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
|
2016-09-20 22:31:20 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_set_default_queues(sdata);
|
2016-09-20 22:31:20 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ret = drv_add_interface(local, sdata);
|
|
|
|
if (WARN_ON(ret)) {
|
|
|
|
/* ok .. stupid driver, it asked for this! */
|
|
|
|
kfree(sdata);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-11-29 23:30:53 +08:00
|
|
|
set_bit(SDATA_STATE_RUNNING, &sdata->state);
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ret = ieee80211_check_queues(sdata, NL80211_IFTYPE_MONITOR);
|
|
|
|
if (ret) {
|
|
|
|
kfree(sdata);
|
|
|
|
return ret;
|
2008-09-11 06:01:59 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
rcu_assign_pointer(local->monitor_sdata, sdata);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef,
|
|
|
|
IEEE80211_CHANCTX_EXCLUSIVE);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
if (ret) {
|
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
RCU_INIT_POINTER(local->monitor_sdata, NULL);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
synchronize_net();
|
|
|
|
drv_remove_interface(local, sdata);
|
|
|
|
kfree(sdata);
|
|
|
|
return ret;
|
2009-07-14 06:33:34 +08:00
|
|
|
}
|
2012-07-13 01:28:31 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
skb_queue_head_init(&sdata->skb_queue);
|
|
|
|
INIT_WORK(&sdata->work, ieee80211_iface_work);
|
2017-06-22 18:20:30 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2015-03-28 04:30:37 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2013-03-28 06:24:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
|
|
|
|
return;
|
2018-10-24 04:36:52 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
|
|
|
|
sdata = rcu_dereference_protected(local->monitor_sdata,
|
|
|
|
lockdep_is_held(&local->iflist_mtx));
|
|
|
|
if (!sdata) {
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2013-03-28 06:24:53 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
RCU_INIT_POINTER(local->monitor_sdata, NULL);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
|
|
|
|
synchronize_net();
|
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ieee80211_vif_release_channel(sdata);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
|
|
|
drv_remove_interface(local, sdata);
|
|
|
|
|
|
|
|
kfree(sdata);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NOTE: Be very careful when changing this function, it must NOT return
|
|
|
|
* an error on interface type changes that have been pre-checked, so most
|
|
|
|
* checks should be in ieee80211_check_concurrent_iface.
|
|
|
|
*/
|
|
|
|
int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
|
|
|
|
struct net_device *dev = wdev->netdev;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
u32 changed = 0;
|
|
|
|
int res;
|
|
|
|
u32 hw_reconf_flags = 0;
|
|
|
|
|
2013-03-28 06:24:53 +08:00
|
|
|
switch (sdata->vif.type) {
|
2020-09-08 20:37:02 +08:00
|
|
|
case NL80211_IFTYPE_AP_VLAN: {
|
|
|
|
struct ieee80211_sub_if_data *master;
|
|
|
|
|
|
|
|
if (!sdata->bss)
|
|
|
|
return -ENOLINK;
|
2013-03-28 06:24:53 +08:00
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
2020-09-08 20:37:02 +08:00
|
|
|
list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
|
2013-03-28 06:24:53 +08:00
|
|
|
mutex_unlock(&local->mtx);
|
2013-05-28 19:01:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
master = container_of(sdata->bss,
|
|
|
|
struct ieee80211_sub_if_data, u.ap);
|
|
|
|
sdata->control_port_protocol =
|
|
|
|
master->control_port_protocol;
|
|
|
|
sdata->control_port_no_encrypt =
|
|
|
|
master->control_port_no_encrypt;
|
|
|
|
sdata->control_port_over_nl80211 =
|
|
|
|
master->control_port_over_nl80211;
|
|
|
|
sdata->control_port_no_preauth =
|
|
|
|
master->control_port_no_preauth;
|
|
|
|
sdata->vif.cab_queue = master->vif.cab_queue;
|
|
|
|
memcpy(sdata->vif.hw_queue, master->vif.hw_queue,
|
|
|
|
sizeof(sdata->vif.hw_queue));
|
|
|
|
sdata->vif.bss_conf.chandef = master->vif.bss_conf.chandef;
|
2013-03-28 06:24:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
mutex_lock(&local->key_mtx);
|
|
|
|
sdata->crypto_tx_tailroom_needed_cnt +=
|
|
|
|
master->crypto_tx_tailroom_needed_cnt;
|
|
|
|
mutex_unlock(&local->key_mtx);
|
2013-03-28 06:24:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
sdata->bss = &sdata->u.ap;
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
case NL80211_IFTYPE_P2P_DEVICE:
|
|
|
|
case NL80211_IFTYPE_OCB:
|
|
|
|
case NL80211_IFTYPE_NAN:
|
|
|
|
/* no special treatment */
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_UNSPECIFIED:
|
|
|
|
case NUM_NL80211_IFTYPES:
|
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
2020-11-09 17:57:46 +08:00
|
|
|
case NL80211_IFTYPE_WDS:
|
2020-09-08 20:37:02 +08:00
|
|
|
/* cannot happen */
|
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
|
|
|
}
|
2014-10-22 02:56:42 +08:00
|
|
|
|
2013-03-28 06:24:53 +08:00
|
|
|
if (local->open_count == 0) {
|
2020-09-08 20:37:02 +08:00
|
|
|
res = drv_start(local);
|
|
|
|
if (res)
|
|
|
|
goto err_del_bss;
|
|
|
|
/* we're brought up, everything changes */
|
|
|
|
hw_reconf_flags = ~0;
|
|
|
|
ieee80211_led_radio(local, true);
|
|
|
|
ieee80211_mod_tpt_led_trig(local,
|
|
|
|
IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
|
2013-03-28 06:24:53 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/*
|
|
|
|
* Copy the hopefully now-present MAC address to
|
|
|
|
* this interface, if it has the special null one.
|
|
|
|
*/
|
|
|
|
if (dev && is_zero_ether_addr(dev->dev_addr)) {
|
|
|
|
memcpy(dev->dev_addr,
|
|
|
|
local->hw.wiphy->perm_addr,
|
|
|
|
ETH_ALEN);
|
|
|
|
memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
|
2010-08-27 18:35:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (!is_valid_ether_addr(dev->dev_addr)) {
|
|
|
|
res = -EADDRNOTAVAIL;
|
|
|
|
goto err_stop;
|
|
|
|
}
|
|
|
|
}
|
2010-08-27 18:35:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
/* no need to tell driver, but set carrier and chanctx */
|
|
|
|
if (rtnl_dereference(sdata->bss->beacon)) {
|
|
|
|
ieee80211_vif_vlan_copy_chanctx(sdata);
|
|
|
|
netif_carrier_on(dev);
|
|
|
|
ieee80211_set_vif_encap_ops(sdata);
|
|
|
|
} else {
|
|
|
|
netif_carrier_off(dev);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) {
|
|
|
|
local->cooked_mntrs++;
|
|
|
|
break;
|
|
|
|
}
|
2009-07-14 06:33:34 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE) {
|
|
|
|
res = drv_add_interface(local, sdata);
|
|
|
|
if (res)
|
|
|
|
goto err_stop;
|
|
|
|
} else if (local->monitors == 0 && local->open_count == 0) {
|
|
|
|
res = ieee80211_add_virtual_monitor(local);
|
|
|
|
if (res)
|
|
|
|
goto err_stop;
|
|
|
|
}
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/* must be before the call to ieee80211_configure_filter */
|
|
|
|
local->monitors++;
|
|
|
|
if (local->monitors == 1) {
|
|
|
|
local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
|
|
|
|
hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
|
|
|
|
}
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_adjust_monitor_flags(sdata, 1);
|
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
ieee80211_recalc_offload(local);
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
mutex_unlock(&local->mtx);
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
netif_carrier_on(dev);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (coming_up) {
|
|
|
|
ieee80211_del_virtual_monitor(local);
|
|
|
|
ieee80211_set_sdata_offload_flags(sdata);
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
res = drv_add_interface(local, sdata);
|
|
|
|
if (res)
|
|
|
|
goto err_stop;
|
2008-09-11 06:01:59 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_set_vif_encap_ops(sdata);
|
|
|
|
res = ieee80211_check_queues(sdata,
|
|
|
|
ieee80211_vif_type_p2p(&sdata->vif));
|
|
|
|
if (res)
|
|
|
|
goto err_del_interface;
|
|
|
|
}
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP) {
|
|
|
|
local->fif_pspoll++;
|
|
|
|
local->fif_probe_req++;
|
2008-07-09 20:40:35 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
|
|
|
|
local->fif_probe_req++;
|
|
|
|
}
|
2008-09-09 22:33:15 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->vif.probe_req_reg)
|
|
|
|
drv_config_iface_filter(local, sdata,
|
|
|
|
FIF_PROBE_REQ,
|
|
|
|
FIF_PROBE_REQ);
|
2007-08-29 05:01:55 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_NAN)
|
|
|
|
changed |= ieee80211_reset_erp_info(sdata);
|
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
|
|
|
case NL80211_IFTYPE_OCB:
|
|
|
|
netif_carrier_off(dev);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_P2P_DEVICE:
|
|
|
|
case NL80211_IFTYPE_NAN:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* not reached */
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
2012-06-19 02:07:15 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/*
|
|
|
|
* Set default queue parameters so drivers don't
|
|
|
|
* need to initialise the hardware if the hardware
|
|
|
|
* doesn't start up with sane defaults.
|
|
|
|
* Enable QoS for anything but station interfaces.
|
|
|
|
*/
|
|
|
|
ieee80211_set_wmm_default(sdata, true,
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_STATION);
|
|
|
|
}
|
2010-01-06 01:00:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
set_bit(SDATA_STATE_RUNNING, &sdata->state);
|
2015-04-22 23:10:38 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_P2P_DEVICE:
|
|
|
|
rcu_assign_pointer(local->p2p_sdata, sdata);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES)
|
|
|
|
break;
|
|
|
|
list_add_tail_rcu(&sdata->u.mntr.list, &local->mon_list);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2015-04-22 23:10:38 +08:00
|
|
|
}
|
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
/*
|
|
|
|
* set_multicast_list will be invoked by the networking core
|
|
|
|
* which will check whether any increments here were done in
|
|
|
|
* error and sync them down to the hardware as filter flags.
|
|
|
|
*/
|
|
|
|
if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
|
|
|
|
atomic_inc(&local->iff_allmultis);
|
2009-01-30 20:35:22 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (coming_up)
|
|
|
|
local->open_count++;
|
2010-01-06 01:00:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (hw_reconf_flags)
|
|
|
|
ieee80211_hw_config(local, hw_reconf_flags);
|
2010-01-06 01:00:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
ieee80211_recalc_ps(local);
|
2020-07-23 18:01:53 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
|
|
|
|
local->ops->wake_tx_queue) {
|
|
|
|
/* XXX: for AP_VLAN, actually track AP queues */
|
|
|
|
if (dev)
|
|
|
|
netif_tx_start_all_queues(dev);
|
|
|
|
} else if (dev) {
|
|
|
|
unsigned long flags;
|
|
|
|
int n_acs = IEEE80211_NUM_ACS;
|
|
|
|
int ac;
|
2010-01-06 01:00:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
n_acs = 1;
|
2010-01-06 01:00:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
if (sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE ||
|
|
|
|
(local->queue_stop_reasons[sdata->vif.cab_queue] == 0 &&
|
|
|
|
skb_queue_empty(&local->pending[sdata->vif.cab_queue]))) {
|
|
|
|
for (ac = 0; ac < n_acs; ac++) {
|
|
|
|
int ac_queue = sdata->vif.hw_queue[ac];
|
2010-01-06 01:00:58 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
if (local->queue_stop_reasons[ac_queue] == 0 &&
|
|
|
|
skb_queue_empty(&local->pending[ac_queue]))
|
|
|
|
netif_start_subqueue(dev, ac);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
2009-01-30 20:35:22 +08:00
|
|
|
|
2020-09-08 20:37:02 +08:00
|
|
|
return 0;
|
|
|
|
err_del_interface:
|
|
|
|
drv_remove_interface(local, sdata);
|
|
|
|
err_stop:
|
|
|
|
if (!local->open_count)
|
|
|
|
drv_stop(local);
|
|
|
|
err_del_bss:
|
|
|
|
sdata->bss = NULL;
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
list_del(&sdata->u.vlan.list);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
}
|
|
|
|
/* might already be clear but that doesn't matter */
|
|
|
|
clear_bit(SDATA_STATE_RUNNING, &sdata->state);
|
|
|
|
return res;
|
|
|
|
}
|
2019-11-25 18:04:37 +08:00
|
|
|
|
2015-04-22 23:10:38 +08:00
|
|
|
static void ieee80211_if_free(struct net_device *dev)
|
|
|
|
{
|
|
|
|
free_percpu(dev->tstats);
|
|
|
|
}
|
|
|
|
|
2009-01-30 20:35:22 +08:00
|
|
|
static void ieee80211_if_setup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
ether_setup(dev);
|
2011-07-26 14:05:38 +08:00
|
|
|
dev->priv_flags &= ~IFF_TX_SKB_SHARING;
|
2009-01-30 20:35:22 +08:00
|
|
|
dev->netdev_ops = &ieee80211_dataif_ops;
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-09 00:52:56 +08:00
|
|
|
dev->needs_free_netdev = true;
|
|
|
|
dev->priv_destructor = ieee80211_if_free;
|
2009-01-30 20:35:22 +08:00
|
|
|
}
|
|
|
|
|
2016-05-19 16:37:48 +08:00
|
|
|
static void ieee80211_if_setup_no_queue(struct net_device *dev)
|
|
|
|
{
|
|
|
|
ieee80211_if_setup(dev);
|
|
|
|
dev->priv_flags |= IFF_NO_QUEUE;
|
|
|
|
}
|
|
|
|
|
2021-05-18 05:07:55 +08:00
|
|
|
static void ieee80211_iface_process_skb(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_mgmt *mgmt = (void *)skb->data;
|
|
|
|
|
|
|
|
if (ieee80211_is_action(mgmt->frame_control) &&
|
|
|
|
mgmt->u.action.category == WLAN_CATEGORY_BACK) {
|
|
|
|
struct sta_info *sta;
|
|
|
|
int len = skb->len;
|
|
|
|
|
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
sta = sta_info_get_bss(sdata, mgmt->sa);
|
|
|
|
if (sta) {
|
|
|
|
switch (mgmt->u.action.u.addba_req.action_code) {
|
|
|
|
case WLAN_ACTION_ADDBA_REQ:
|
|
|
|
ieee80211_process_addba_request(local, sta,
|
|
|
|
mgmt, len);
|
|
|
|
break;
|
|
|
|
case WLAN_ACTION_ADDBA_RESP:
|
|
|
|
ieee80211_process_addba_resp(local, sta,
|
|
|
|
mgmt, len);
|
|
|
|
break;
|
|
|
|
case WLAN_ACTION_DELBA:
|
|
|
|
ieee80211_process_delba(sdata, sta,
|
|
|
|
mgmt, len);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
|
|
|
} else if (ieee80211_is_action(mgmt->frame_control) &&
|
|
|
|
mgmt->u.action.category == WLAN_CATEGORY_VHT) {
|
|
|
|
switch (mgmt->u.action.u.vht_group_notif.action_code) {
|
|
|
|
case WLAN_VHT_ACTION_OPMODE_NOTIF: {
|
|
|
|
struct ieee80211_rx_status *status;
|
|
|
|
enum nl80211_band band;
|
|
|
|
struct sta_info *sta;
|
|
|
|
u8 opmode;
|
|
|
|
|
|
|
|
status = IEEE80211_SKB_RXCB(skb);
|
|
|
|
band = status->band;
|
|
|
|
opmode = mgmt->u.action.u.vht_opmode_notif.operating_mode;
|
|
|
|
|
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
sta = sta_info_get_bss(sdata, mgmt->sa);
|
|
|
|
|
|
|
|
if (sta)
|
|
|
|
ieee80211_vht_handle_opmode(sdata, sta, opmode,
|
|
|
|
band);
|
|
|
|
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case WLAN_VHT_ACTION_GROUPID_MGMT:
|
|
|
|
ieee80211_process_mu_groups(sdata, mgmt);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (ieee80211_is_ext(mgmt->frame_control)) {
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION)
|
|
|
|
ieee80211_sta_rx_queued_ext(sdata, skb);
|
|
|
|
else
|
|
|
|
WARN_ON(1);
|
|
|
|
} else if (ieee80211_is_data_qos(mgmt->frame_control)) {
|
|
|
|
struct ieee80211_hdr *hdr = (void *)mgmt;
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* So the frame isn't mgmt, but frame_control
|
|
|
|
* is at the right place anyway, of course, so
|
|
|
|
* the if statement is correct.
|
|
|
|
*
|
|
|
|
* Warn if we have other data frame types here,
|
|
|
|
* they must not get here.
|
|
|
|
*/
|
|
|
|
WARN_ON(hdr->frame_control &
|
|
|
|
cpu_to_le16(IEEE80211_STYPE_NULLFUNC));
|
|
|
|
WARN_ON(!(hdr->seq_ctrl &
|
|
|
|
cpu_to_le16(IEEE80211_SCTL_FRAG)));
|
|
|
|
/*
|
|
|
|
* This was a fragment of a frame, received while
|
|
|
|
* a block-ack session was active. That cannot be
|
|
|
|
* right, so terminate the session.
|
|
|
|
*/
|
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
sta = sta_info_get_bss(sdata, mgmt->sa);
|
|
|
|
if (sta) {
|
|
|
|
u16 tid = ieee80211_get_tid(hdr);
|
|
|
|
|
|
|
|
__ieee80211_stop_rx_ba_session(
|
|
|
|
sta, tid, WLAN_BACK_RECIPIENT,
|
|
|
|
WLAN_REASON_QSTA_REQUIRE_SETUP,
|
|
|
|
true);
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
|
|
|
} else switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
ieee80211_sta_rx_queued_mgmt(sdata, skb);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
ieee80211_ibss_rx_queued_mgmt(sdata, skb);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
|
|
|
if (!ieee80211_vif_is_mesh(&sdata->vif))
|
|
|
|
break;
|
|
|
|
ieee80211_mesh_rx_queued_mgmt(sdata, skb);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN(1, "frame for unexpected interface type");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-10 16:21:32 +08:00
|
|
|
static void ieee80211_iface_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
container_of(work, struct ieee80211_sub_if_data, work);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
if (!ieee80211_sdata_running(sdata))
|
|
|
|
return;
|
|
|
|
|
2015-08-16 03:04:01 +08:00
|
|
|
if (test_bit(SCAN_SW_SCANNING, &local->scanning))
|
2010-06-10 16:21:32 +08:00
|
|
|
return;
|
|
|
|
|
2015-01-23 05:32:46 +08:00
|
|
|
if (!ieee80211_can_run_worker(local))
|
2010-06-10 16:21:32 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* first process frames */
|
|
|
|
while ((skb = skb_dequeue(&sdata->skb_queue))) {
|
2020-10-30 01:36:20 +08:00
|
|
|
kcov_remote_start_common(skb_get_kcov_handle(skb));
|
2010-06-10 16:21:35 +08:00
|
|
|
|
2021-05-18 05:07:56 +08:00
|
|
|
if (skb->protocol == cpu_to_be16(ETH_P_TDLS))
|
|
|
|
ieee80211_process_tdls_channel_switch(sdata, skb);
|
|
|
|
else
|
|
|
|
ieee80211_iface_process_skb(local, sdata, skb);
|
2010-06-10 16:21:33 +08:00
|
|
|
|
|
|
|
kfree_skb(skb);
|
2020-10-30 01:36:20 +08:00
|
|
|
kcov_remote_stop();
|
2010-06-10 16:21:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* then other type-dependent work */
|
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
ieee80211_sta_work(sdata);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
ieee80211_ibss_work(sdata);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
|
|
|
if (!ieee80211_vif_is_mesh(&sdata->vif))
|
|
|
|
break;
|
|
|
|
ieee80211_mesh_work(sdata);
|
|
|
|
break;
|
2014-11-03 17:33:19 +08:00
|
|
|
case NL80211_IFTYPE_OCB:
|
|
|
|
ieee80211_ocb_work(sdata);
|
|
|
|
break;
|
2010-06-10 16:21:32 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-11 20:34:12 +08:00
|
|
|
static void ieee80211_recalc_smps_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
container_of(work, struct ieee80211_sub_if_data, recalc_smps);
|
|
|
|
|
|
|
|
ieee80211_recalc_smps(sdata);
|
|
|
|
}
|
2010-06-10 16:21:32 +08:00
|
|
|
|
2008-07-09 20:40:35 +08:00
|
|
|
/*
|
|
|
|
* Helper function to initialise an interface to a specific type.
|
|
|
|
*/
|
|
|
|
static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
|
2008-09-11 06:01:58 +08:00
|
|
|
enum nl80211_iftype type)
|
2007-05-06 02:45:53 +08:00
|
|
|
{
|
2014-11-03 17:33:19 +08:00
|
|
|
static const u8 bssid_wildcard[ETH_ALEN] = {0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff};
|
|
|
|
|
2008-07-09 20:40:35 +08:00
|
|
|
/* clear type-dependent union */
|
|
|
|
memset(&sdata->u, 0, sizeof(sdata->u));
|
|
|
|
|
|
|
|
/* and set some type-dependent values */
|
|
|
|
sdata->vif.type = type;
|
2010-09-16 20:58:23 +08:00
|
|
|
sdata->vif.p2p = false;
|
2008-09-16 20:55:09 +08:00
|
|
|
sdata->wdev.iftype = type;
|
2008-07-09 20:40:35 +08:00
|
|
|
|
2010-08-27 19:26:54 +08:00
|
|
|
sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
|
|
|
|
sdata->control_port_no_encrypt = false;
|
2020-03-12 17:10:54 +08:00
|
|
|
sdata->control_port_over_nl80211 = false;
|
|
|
|
sdata->control_port_no_preauth = false;
|
2013-03-24 20:23:27 +08:00
|
|
|
sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
|
2014-05-22 17:17:47 +08:00
|
|
|
sdata->vif.bss_conf.idle = true;
|
2019-12-18 02:30:57 +08:00
|
|
|
sdata->vif.bss_conf.txpower = INT_MIN; /* unset */
|
2010-08-27 19:26:54 +08:00
|
|
|
|
2011-11-18 21:20:44 +08:00
|
|
|
sdata->noack_map = 0;
|
|
|
|
|
2012-06-19 02:07:15 +08:00
|
|
|
/* only monitor/p2p-device differ */
|
|
|
|
if (sdata->dev) {
|
|
|
|
sdata->dev->netdev_ops = &ieee80211_dataif_ops;
|
|
|
|
sdata->dev->type = ARPHRD_ETHER;
|
|
|
|
}
|
2008-07-09 20:40:35 +08:00
|
|
|
|
2010-06-10 16:21:30 +08:00
|
|
|
skb_queue_head_init(&sdata->skb_queue);
|
2010-06-10 16:21:32 +08:00
|
|
|
INIT_WORK(&sdata->work, ieee80211_iface_work);
|
2012-09-11 20:34:12 +08:00
|
|
|
INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);
|
2013-07-11 22:09:06 +08:00
|
|
|
INIT_WORK(&sdata->csa_finalize_work, ieee80211_csa_finalize_work);
|
2014-04-09 21:29:26 +08:00
|
|
|
INIT_LIST_HEAD(&sdata->assigned_chanctx_list);
|
2014-04-09 21:29:27 +08:00
|
|
|
INIT_LIST_HEAD(&sdata->reserved_chanctx_list);
|
2010-06-10 16:21:30 +08:00
|
|
|
|
2008-07-09 20:40:35 +08:00
|
|
|
switch (type) {
|
2010-09-16 20:58:23 +08:00
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
|
|
|
type = NL80211_IFTYPE_AP;
|
|
|
|
sdata->vif.type = type;
|
|
|
|
sdata->vif.p2p = true;
|
2020-07-08 04:45:48 +08:00
|
|
|
fallthrough;
|
2008-09-11 06:01:58 +08:00
|
|
|
case NL80211_IFTYPE_AP:
|
2012-10-11 03:39:50 +08:00
|
|
|
skb_queue_head_init(&sdata->u.ap.ps.bc_buf);
|
2008-07-09 20:40:35 +08:00
|
|
|
INIT_LIST_HEAD(&sdata->u.ap.vlans);
|
2012-12-14 21:34:25 +08:00
|
|
|
sdata->vif.bss_conf.bssid = sdata->vif.addr;
|
2008-07-09 20:40:35 +08:00
|
|
|
break;
|
2010-09-16 20:58:23 +08:00
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
type = NL80211_IFTYPE_STATION;
|
|
|
|
sdata->vif.type = type;
|
|
|
|
sdata->vif.p2p = true;
|
2020-07-08 04:45:48 +08:00
|
|
|
fallthrough;
|
2008-09-11 06:01:58 +08:00
|
|
|
case NL80211_IFTYPE_STATION:
|
2012-12-14 21:34:25 +08:00
|
|
|
sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid;
|
2008-09-11 06:01:52 +08:00
|
|
|
ieee80211_sta_setup_sdata(sdata);
|
2008-09-11 06:01:49 +08:00
|
|
|
break;
|
2014-11-03 17:33:18 +08:00
|
|
|
case NL80211_IFTYPE_OCB:
|
2014-11-03 17:33:19 +08:00
|
|
|
sdata->vif.bss_conf.bssid = bssid_wildcard;
|
|
|
|
ieee80211_ocb_setup_sdata(sdata);
|
2014-11-03 17:33:18 +08:00
|
|
|
break;
|
2009-02-15 19:44:28 +08:00
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2012-12-14 21:34:25 +08:00
|
|
|
sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
|
2009-02-15 19:44:28 +08:00
|
|
|
ieee80211_ibss_setup_sdata(sdata);
|
|
|
|
break;
|
2008-09-11 06:01:58 +08:00
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
2008-07-09 20:40:35 +08:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif))
|
|
|
|
ieee80211_mesh_init_sdata(sdata);
|
|
|
|
break;
|
2008-09-11 06:01:58 +08:00
|
|
|
case NL80211_IFTYPE_MONITOR:
|
2008-07-09 20:40:35 +08:00
|
|
|
sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
|
2009-01-30 20:35:22 +08:00
|
|
|
sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
|
2016-08-30 04:25:15 +08:00
|
|
|
sdata->u.mntr.flags = MONITOR_FLAG_CONTROL |
|
2008-07-09 20:40:35 +08:00
|
|
|
MONITOR_FLAG_OTHER_BSS;
|
|
|
|
break;
|
2016-09-20 22:31:20 +08:00
|
|
|
case NL80211_IFTYPE_NAN:
|
|
|
|
idr_init(&sdata->u.nan.function_inst_ids);
|
|
|
|
spin_lock_init(&sdata->u.nan.func_lock);
|
|
|
|
sdata->vif.bss_conf.bssid = sdata->vif.addr;
|
|
|
|
break;
|
2008-09-11 06:01:58 +08:00
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2012-06-16 06:19:54 +08:00
|
|
|
case NL80211_IFTYPE_P2P_DEVICE:
|
2012-12-14 21:34:25 +08:00
|
|
|
sdata->vif.bss_conf.bssid = sdata->vif.addr;
|
2012-06-19 02:07:15 +08:00
|
|
|
break;
|
2008-09-11 06:01:58 +08:00
|
|
|
case NL80211_IFTYPE_UNSPECIFIED:
|
2020-11-09 17:57:46 +08:00
|
|
|
case NL80211_IFTYPE_WDS:
|
2010-08-12 21:38:38 +08:00
|
|
|
case NUM_NL80211_IFTYPES:
|
2017-10-29 17:51:10 +08:00
|
|
|
WARN_ON(1);
|
2008-07-09 20:40:35 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_debugfs_add_netdev(sdata);
|
|
|
|
}
|
|
|
|
|
2010-08-27 18:35:58 +08:00
|
|
|
static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum nl80211_iftype type)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int ret, err;
|
2010-09-16 20:58:23 +08:00
|
|
|
enum nl80211_iftype internal_type = type;
|
|
|
|
bool p2p = false;
|
2010-08-27 18:35:58 +08:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if (!local->ops->change_interface)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_AP:
|
2021-05-17 22:03:23 +08:00
|
|
|
if (!list_empty(&sdata->u.ap.vlans))
|
|
|
|
return -EBUSY;
|
|
|
|
break;
|
2010-08-27 18:35:58 +08:00
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2014-11-03 17:33:19 +08:00
|
|
|
case NL80211_IFTYPE_OCB:
|
2010-08-27 18:35:58 +08:00
|
|
|
/*
|
|
|
|
* Could maybe also all others here?
|
|
|
|
* Just not sure how that interacts
|
|
|
|
* with the RX/config path e.g. for
|
|
|
|
* mesh.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2014-11-03 17:33:19 +08:00
|
|
|
case NL80211_IFTYPE_OCB:
|
2010-08-27 18:35:58 +08:00
|
|
|
/*
|
|
|
|
* Could probably support everything
|
2020-11-09 17:57:46 +08:00
|
|
|
* but here.
|
2010-08-27 18:35:58 +08:00
|
|
|
*/
|
|
|
|
break;
|
2010-09-16 20:58:23 +08:00
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
p2p = true;
|
|
|
|
internal_type = NL80211_IFTYPE_STATION;
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
|
|
|
p2p = true;
|
|
|
|
internal_type = NL80211_IFTYPE_AP;
|
|
|
|
break;
|
2010-08-27 18:35:58 +08:00
|
|
|
default:
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2010-09-16 20:58:23 +08:00
|
|
|
ret = ieee80211_check_concurrent_iface(sdata, internal_type);
|
2010-08-27 18:35:58 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2021-01-23 00:11:16 +08:00
|
|
|
ieee80211_stop_vif_queues(local, sdata,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE);
|
|
|
|
synchronize_net();
|
|
|
|
|
2010-08-27 18:35:58 +08:00
|
|
|
ieee80211_do_stop(sdata, false);
|
|
|
|
|
2012-06-19 02:07:15 +08:00
|
|
|
ieee80211_teardown_sdata(sdata);
|
2010-08-27 18:35:58 +08:00
|
|
|
|
2020-09-08 20:36:53 +08:00
|
|
|
ieee80211_set_sdata_offload_flags(sdata);
|
2010-09-16 20:58:23 +08:00
|
|
|
ret = drv_change_interface(local, sdata, internal_type, p2p);
|
2010-08-27 18:35:58 +08:00
|
|
|
if (ret)
|
2013-08-26 15:30:32 +08:00
|
|
|
type = ieee80211_vif_type_p2p(&sdata->vif);
|
2010-08-27 18:35:58 +08:00
|
|
|
|
2012-04-03 22:28:50 +08:00
|
|
|
/*
|
|
|
|
* Ignore return value here, there's not much we can do since
|
|
|
|
* the driver changed the interface type internally already.
|
|
|
|
* The warnings will hopefully make driver authors fix it :-)
|
|
|
|
*/
|
2013-08-26 15:30:32 +08:00
|
|
|
ieee80211_check_queues(sdata, type);
|
2012-04-03 22:28:50 +08:00
|
|
|
|
2010-08-27 18:35:58 +08:00
|
|
|
ieee80211_setup_sdata(sdata, type);
|
2020-09-08 20:36:53 +08:00
|
|
|
ieee80211_set_vif_encap_ops(sdata);
|
2010-08-27 18:35:58 +08:00
|
|
|
|
2012-06-19 02:07:15 +08:00
|
|
|
err = ieee80211_do_open(&sdata->wdev, false);
|
2010-08-27 18:35:58 +08:00
|
|
|
WARN(err, "type change: do_open returned %d", err);
|
|
|
|
|
2021-01-23 00:11:16 +08:00
|
|
|
ieee80211_wake_vif_queues(local, sdata,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE);
|
2010-08-27 18:35:58 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-09 20:40:36 +08:00
|
|
|
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
|
2008-09-11 06:01:58 +08:00
|
|
|
enum nl80211_iftype type)
|
2008-07-09 20:40:35 +08:00
|
|
|
{
|
2010-08-27 18:35:58 +08:00
|
|
|
int ret;
|
|
|
|
|
2008-07-09 20:40:36 +08:00
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2010-09-16 20:58:23 +08:00
|
|
|
if (type == ieee80211_vif_type_p2p(&sdata->vif))
|
2008-07-09 20:40:36 +08:00
|
|
|
return 0;
|
|
|
|
|
2010-08-27 18:35:58 +08:00
|
|
|
if (ieee80211_sdata_running(sdata)) {
|
|
|
|
ret = ieee80211_runtime_change_iftype(sdata, type);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
/* Purge and reset type-dependent state. */
|
2012-06-19 02:07:15 +08:00
|
|
|
ieee80211_teardown_sdata(sdata);
|
2010-08-27 18:35:58 +08:00
|
|
|
ieee80211_setup_sdata(sdata, type);
|
|
|
|
}
|
2008-07-09 20:40:35 +08:00
|
|
|
|
|
|
|
/* reset some values that shouldn't be kept across type changes */
|
2009-11-19 18:55:19 +08:00
|
|
|
if (type == NL80211_IFTYPE_STATION)
|
|
|
|
sdata->u.mgd.use_4addr = false;
|
2008-07-09 20:40:36 +08:00
|
|
|
|
|
|
|
return 0;
|
2007-05-06 02:45:53 +08:00
|
|
|
}
|
|
|
|
|
2010-02-25 22:13:11 +08:00
|
|
|
static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
|
2012-06-19 02:07:15 +08:00
|
|
|
u8 *perm_addr, enum nl80211_iftype type)
|
2010-02-25 22:13:11 +08:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
u64 mask, start, addr, val, inc;
|
|
|
|
u8 *m;
|
|
|
|
u8 tmp_addr[ETH_ALEN];
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* default ... something at least */
|
2012-06-19 02:07:15 +08:00
|
|
|
memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
|
2010-02-25 22:13:11 +08:00
|
|
|
|
|
|
|
if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
|
|
|
|
local->hw.wiphy->n_addresses <= 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
/* doesn't matter */
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
/* match up with an AP interface */
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_AP)
|
|
|
|
continue;
|
2012-06-19 02:07:15 +08:00
|
|
|
memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
|
2010-02-25 22:13:11 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* keep default if no AP interface present */
|
|
|
|
break;
|
2012-06-19 23:19:44 +08:00
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
2015-06-03 03:39:54 +08:00
|
|
|
if (ieee80211_hw_check(&local->hw, P2P_DEV_ADDR_FOR_INTF)) {
|
2012-06-19 23:19:44 +08:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
|
|
|
|
continue;
|
|
|
|
if (!ieee80211_sdata_running(sdata))
|
|
|
|
continue;
|
|
|
|
memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
}
|
2020-07-08 04:45:48 +08:00
|
|
|
fallthrough;
|
2010-02-25 22:13:11 +08:00
|
|
|
default:
|
|
|
|
/* assign a new address if possible -- try n_addresses first */
|
|
|
|
for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
|
|
|
|
bool used = false;
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
2013-12-26 19:40:56 +08:00
|
|
|
if (ether_addr_equal(local->hw.wiphy->addresses[i].addr,
|
|
|
|
sdata->vif.addr)) {
|
2010-02-25 22:13:11 +08:00
|
|
|
used = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!used) {
|
2012-06-19 02:07:15 +08:00
|
|
|
memcpy(perm_addr,
|
2010-02-25 22:13:11 +08:00
|
|
|
local->hw.wiphy->addresses[i].addr,
|
|
|
|
ETH_ALEN);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* try mask if available */
|
|
|
|
if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
|
|
|
|
break;
|
|
|
|
|
|
|
|
m = local->hw.wiphy->addr_mask;
|
|
|
|
mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
|
|
|
|
((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
|
|
|
|
((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
|
|
|
|
|
|
|
|
if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
|
|
|
|
/* not a contiguous mask ... not handled now! */
|
2012-06-22 17:29:50 +08:00
|
|
|
pr_info("not contiguous\n");
|
2010-02-25 22:13:11 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-05-27 16:43:09 +08:00
|
|
|
/*
|
|
|
|
* Pick address of existing interface in case user changed
|
|
|
|
* MAC address manually, default to perm_addr.
|
|
|
|
*/
|
2010-02-25 22:13:11 +08:00
|
|
|
m = local->hw.wiphy->perm_addr;
|
2013-05-27 16:43:09 +08:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_MONITOR)
|
|
|
|
continue;
|
|
|
|
m = sdata->vif.addr;
|
|
|
|
break;
|
|
|
|
}
|
2010-02-25 22:13:11 +08:00
|
|
|
start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
|
|
|
|
((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
|
|
|
|
((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
|
|
|
|
|
|
|
|
inc = 1ULL<<__ffs64(mask);
|
|
|
|
val = (start & mask);
|
|
|
|
addr = (start & ~mask) | (val & mask);
|
|
|
|
do {
|
|
|
|
bool used = false;
|
|
|
|
|
|
|
|
tmp_addr[5] = addr >> 0*8;
|
|
|
|
tmp_addr[4] = addr >> 1*8;
|
|
|
|
tmp_addr[3] = addr >> 2*8;
|
|
|
|
tmp_addr[2] = addr >> 3*8;
|
|
|
|
tmp_addr[1] = addr >> 4*8;
|
|
|
|
tmp_addr[0] = addr >> 5*8;
|
|
|
|
|
|
|
|
val += inc;
|
|
|
|
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
2013-12-26 19:40:56 +08:00
|
|
|
if (ether_addr_equal(tmp_addr, sdata->vif.addr)) {
|
2010-02-25 22:13:11 +08:00
|
|
|
used = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!used) {
|
2012-06-19 02:07:15 +08:00
|
|
|
memcpy(perm_addr, tmp_addr, ETH_ALEN);
|
2010-02-25 22:13:11 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
addr = (start & ~mask) | (val & mask);
|
|
|
|
} while (addr != start);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-06-19 23:19:44 +08:00
|
|
|
out_unlock:
|
2010-02-25 22:13:11 +08:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
}
|
|
|
|
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 20:40:34 +08:00
|
|
|
int ieee80211_if_add(struct ieee80211_local *local, const char *name,
|
2015-03-18 18:13:39 +08:00
|
|
|
unsigned char name_assign_type,
|
2012-06-16 06:00:26 +08:00
|
|
|
struct wireless_dev **new_wdev, enum nl80211_iftype type,
|
2008-02-23 22:17:11 +08:00
|
|
|
struct vif_params *params)
|
2007-05-06 02:45:53 +08:00
|
|
|
{
|
2012-06-19 02:07:15 +08:00
|
|
|
struct net_device *ndev = NULL;
|
2007-05-06 02:45:53 +08:00
|
|
|
struct ieee80211_sub_if_data *sdata = NULL;
|
2015-03-28 04:30:37 +08:00
|
|
|
struct txq_info *txqi;
|
2016-05-19 16:37:48 +08:00
|
|
|
void (*if_setup)(struct net_device *dev);
|
2008-07-09 20:40:35 +08:00
|
|
|
int ret, i;
|
2012-03-28 17:04:26 +08:00
|
|
|
int txqs = 1;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
2008-07-09 20:40:35 +08:00
|
|
|
|
2016-09-20 22:31:14 +08:00
|
|
|
if (type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN) {
|
2012-06-19 02:07:15 +08:00
|
|
|
struct wireless_dev *wdev;
|
|
|
|
|
|
|
|
sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!sdata)
|
|
|
|
return -ENOMEM;
|
|
|
|
wdev = &sdata->wdev;
|
|
|
|
|
|
|
|
sdata->dev = NULL;
|
|
|
|
strlcpy(sdata->name, name, IFNAMSIZ);
|
|
|
|
ieee80211_assign_perm_addr(local, wdev->address, type);
|
|
|
|
memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);
|
|
|
|
} else {
|
2015-03-28 04:30:37 +08:00
|
|
|
int size = ALIGN(sizeof(*sdata) + local->hw.vif_data_size,
|
|
|
|
sizeof(void *));
|
|
|
|
int txq_size = 0;
|
|
|
|
|
2017-06-22 18:20:29 +08:00
|
|
|
if (local->ops->wake_tx_queue &&
|
|
|
|
type != NL80211_IFTYPE_AP_VLAN &&
|
2018-09-23 00:35:31 +08:00
|
|
|
(type != NL80211_IFTYPE_MONITOR ||
|
|
|
|
(params->flags & MONITOR_FLAG_ACTIVE)))
|
2015-03-28 04:30:37 +08:00
|
|
|
txq_size += sizeof(struct txq_info) +
|
|
|
|
local->hw.txq_data_size;
|
|
|
|
|
2019-04-08 20:39:11 +08:00
|
|
|
if (local->ops->wake_tx_queue) {
|
2016-05-19 16:37:48 +08:00
|
|
|
if_setup = ieee80211_if_setup_no_queue;
|
2019-04-08 20:39:11 +08:00
|
|
|
} else {
|
2016-05-19 16:37:48 +08:00
|
|
|
if_setup = ieee80211_if_setup;
|
2019-04-08 20:39:11 +08:00
|
|
|
if (local->hw.queues >= IEEE80211_NUM_ACS)
|
|
|
|
txqs = IEEE80211_NUM_ACS;
|
|
|
|
}
|
2012-06-19 02:07:15 +08:00
|
|
|
|
2015-03-28 04:30:37 +08:00
|
|
|
ndev = alloc_netdev_mqs(size + txq_size,
|
2015-03-18 18:13:39 +08:00
|
|
|
name, name_assign_type,
|
2016-05-19 16:37:48 +08:00
|
|
|
if_setup, txqs, 1);
|
2012-06-19 02:07:15 +08:00
|
|
|
if (!ndev)
|
|
|
|
return -ENOMEM;
|
2020-02-11 20:26:04 +08:00
|
|
|
|
|
|
|
if (!local->ops->wake_tx_queue && local->hw.wiphy->tx_queue_len)
|
|
|
|
ndev->tx_queue_len = local->hw.wiphy->tx_queue_len;
|
|
|
|
|
2012-06-19 02:07:15 +08:00
|
|
|
dev_net_set(ndev, wiphy_net(local->hw.wiphy));
|
|
|
|
|
2015-04-22 23:10:38 +08:00
|
|
|
ndev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
|
|
|
|
if (!ndev->tstats) {
|
|
|
|
free_netdev(ndev);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2012-06-19 02:07:15 +08:00
|
|
|
ndev->needed_headroom = local->tx_headroom +
|
|
|
|
4*6 /* four MAC addresses */
|
|
|
|
+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
|
|
|
|
+ 6 /* mesh */
|
|
|
|
+ 8 /* rfc1042/bridge tunnel */
|
|
|
|
- ETH_HLEN /* ethernet hard_header_len */
|
|
|
|
+ IEEE80211_ENCRYPT_HEADROOM;
|
|
|
|
ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
|
|
|
|
|
|
|
|
ret = dev_alloc_name(ndev, ndev->name);
|
|
|
|
if (ret < 0) {
|
2016-04-26 19:47:08 +08:00
|
|
|
ieee80211_if_free(ndev);
|
2017-06-10 03:33:09 +08:00
|
|
|
free_netdev(ndev);
|
2012-06-19 02:07:15 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_assign_perm_addr(local, ndev->perm_addr, type);
|
2018-12-15 17:03:11 +08:00
|
|
|
if (is_valid_ether_addr(params->macaddr))
|
2014-10-23 03:23:06 +08:00
|
|
|
memcpy(ndev->dev_addr, params->macaddr, ETH_ALEN);
|
|
|
|
else
|
|
|
|
memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);
|
2012-06-19 02:07:15 +08:00
|
|
|
SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
|
|
|
|
|
|
|
|
/* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */
|
|
|
|
sdata = netdev_priv(ndev);
|
|
|
|
ndev->ieee80211_ptr = &sdata->wdev;
|
|
|
|
memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
|
|
|
|
memcpy(sdata->name, ndev->name, IFNAMSIZ);
|
|
|
|
|
2015-03-28 04:30:37 +08:00
|
|
|
if (txq_size) {
|
|
|
|
txqi = netdev_priv(ndev) + size;
|
2016-05-19 16:37:49 +08:00
|
|
|
ieee80211_txq_init(sdata, NULL, txqi, 0);
|
2015-03-28 04:30:37 +08:00
|
|
|
}
|
|
|
|
|
2012-06-19 02:07:15 +08:00
|
|
|
sdata->dev = ndev;
|
|
|
|
}
|
2008-07-09 20:40:35 +08:00
|
|
|
|
|
|
|
/* initialise type-independent data */
|
2007-05-06 02:45:53 +08:00
|
|
|
sdata->wdev.wiphy = local->hw.wiphy;
|
|
|
|
sdata->local = local;
|
2008-07-09 20:40:35 +08:00
|
|
|
|
2021-05-12 02:02:47 +08:00
|
|
|
ieee80211_init_frag_cache(&sdata->frags);
|
2008-07-09 20:40:35 +08:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&sdata->key_list);
|
|
|
|
|
2013-02-09 01:16:20 +08:00
|
|
|
INIT_DELAYED_WORK(&sdata->dfs_cac_timer_work,
|
|
|
|
ieee80211_dfs_cac_timer_work);
|
mac80211: defer tailroom counter manipulation when roaming
During roaming, the crypto_tx_tailroom_needed_cnt counter
will often take values 2,1,0,1,2 because first keys are
removed and then new keys are added. This is inefficient
because during the 0->1 transition, synchronize_net must
be called to avoid packet races, although typically no
packets would be flowing during that time.
To avoid that, defer the decrement (2->1, 1->0) when keys
are removed (by half a second). This means the counter
will really have the values 2,2,2,3,4 ... 2, thus never
reaching 0 and having to do the 0->1 transition.
Note that this patch entirely disregards the drivers for
which this optimisation was done to start with, for them
the key removal itself will be expensive because it has
to synchronize_net() after the counter is incremented to
remove the key from HW crypto. For them the sequence will
look like this: 0,1,0,1,0,1,0,1,0 (*) which is clearly a
lot more inefficient. This could be addressed separately,
during key removal the 0->1->0 sequence isn't necessary.
(*) it starts at 0 because HW crypto is on, then goes to
1 when HW crypto is disabled for a key, then back to
0 because the key is deleted; this happens for both
keys in the example. When new keys are added, it goes
to 1 first because they're added in software; when a
key is moved to hardware it goes back to 0
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2013-02-23 07:59:03 +08:00
|
|
|
INIT_DELAYED_WORK(&sdata->dec_tailroom_needed_wk,
|
|
|
|
ieee80211_delayed_tailroom_dec);
|
2012-12-14 05:54:58 +08:00
|
|
|
|
2016-04-12 21:56:15 +08:00
|
|
|
for (i = 0; i < NUM_NL80211_BANDS; i++) {
|
2010-01-06 19:09:08 +08:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
sband = local->hw.wiphy->bands[i];
|
|
|
|
sdata->rc_rateidx_mask[i] =
|
|
|
|
sband ? (1 << sband->n_bitrates) - 1 : 0;
|
2015-08-07 05:47:33 +08:00
|
|
|
if (sband) {
|
|
|
|
__le16 cap;
|
|
|
|
u16 *vht_rate_mask;
|
|
|
|
|
2012-01-29 00:25:33 +08:00
|
|
|
memcpy(sdata->rc_rateidx_mcs_mask[i],
|
|
|
|
sband->ht_cap.mcs.rx_mask,
|
|
|
|
sizeof(sdata->rc_rateidx_mcs_mask[i]));
|
2015-08-07 05:47:33 +08:00
|
|
|
|
|
|
|
cap = sband->vht_cap.vht_mcs.rx_mcs_map;
|
|
|
|
vht_rate_mask = sdata->rc_rateidx_vht_mcs_mask[i];
|
|
|
|
ieee80211_get_vht_mask_from_cap(cap, vht_rate_mask);
|
|
|
|
} else {
|
2012-01-29 00:25:33 +08:00
|
|
|
memset(sdata->rc_rateidx_mcs_mask[i], 0,
|
|
|
|
sizeof(sdata->rc_rateidx_mcs_mask[i]));
|
2015-08-07 05:47:33 +08:00
|
|
|
memset(sdata->rc_rateidx_vht_mcs_mask[i], 0,
|
|
|
|
sizeof(sdata->rc_rateidx_vht_mcs_mask[i]));
|
|
|
|
}
|
2010-01-06 19:09:08 +08:00
|
|
|
}
|
2008-07-09 20:40:35 +08:00
|
|
|
|
2021-06-23 21:47:55 +08:00
|
|
|
for (i = 0; i < IEEE80211_NUM_ACS; i++)
|
|
|
|
init_airtime_info(&sdata->airtime[i], &local->airtime[i]);
|
|
|
|
|
2012-04-03 22:28:50 +08:00
|
|
|
ieee80211_set_default_queues(sdata);
|
|
|
|
|
2012-10-24 16:59:25 +08:00
|
|
|
sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
|
|
|
|
sdata->user_power_level = local->user_power_level;
|
|
|
|
|
2013-03-24 20:23:27 +08:00
|
|
|
sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
|
|
|
|
|
2008-07-09 20:40:35 +08:00
|
|
|
/* setup type-dependent data */
|
|
|
|
ieee80211_setup_sdata(sdata, type);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2012-06-19 02:07:15 +08:00
|
|
|
if (ndev) {
|
2018-12-15 17:03:11 +08:00
|
|
|
ndev->ieee80211_ptr->use_4addr = params->use_4addr;
|
|
|
|
if (type == NL80211_IFTYPE_STATION)
|
|
|
|
sdata->u.mgd.use_4addr = params->use_4addr;
|
2009-11-19 18:55:19 +08:00
|
|
|
|
2012-06-19 02:07:15 +08:00
|
|
|
ndev->features |= local->hw.netdev_features;
|
2020-01-31 19:12:46 +08:00
|
|
|
ndev->hw_features |= ndev->features &
|
|
|
|
MAC80211_SUPPORTED_FEATURES_TX;
|
2012-05-10 21:18:26 +08:00
|
|
|
|
2014-06-04 23:31:56 +08:00
|
|
|
netdev_set_default_ethtool_ops(ndev, &ieee80211_ethtool_ops);
|
|
|
|
|
2021-06-28 20:32:46 +08:00
|
|
|
/* MTU range is normally 256 - 2304, where the upper limit is
|
|
|
|
* the maximum MSDU size. Monitor interfaces send and receive
|
|
|
|
* MPDU and A-MSDU frames which may be much larger so we do
|
|
|
|
* not impose an upper limit in that case.
|
|
|
|
*/
|
2016-10-21 01:55:18 +08:00
|
|
|
ndev->min_mtu = 256;
|
2021-06-28 20:32:46 +08:00
|
|
|
if (type == NL80211_IFTYPE_MONITOR)
|
|
|
|
ndev->max_mtu = 0;
|
|
|
|
else
|
|
|
|
ndev->max_mtu = local->hw.max_mtu;
|
2016-10-21 01:55:18 +08:00
|
|
|
|
2021-01-22 23:19:42 +08:00
|
|
|
ret = cfg80211_register_netdevice(ndev);
|
2012-06-19 02:07:15 +08:00
|
|
|
if (ret) {
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-09 00:52:56 +08:00
|
|
|
free_netdev(ndev);
|
2012-06-19 02:07:15 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2007-05-06 02:45:53 +08:00
|
|
|
|
2009-01-24 05:54:03 +08:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
2007-09-19 05:29:21 +08:00
|
|
|
list_add_tail_rcu(&sdata->list, &local->interfaces);
|
2009-01-24 05:54:03 +08:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2007-09-19 05:29:21 +08:00
|
|
|
|
2012-06-16 06:00:26 +08:00
|
|
|
if (new_wdev)
|
|
|
|
*new_wdev = &sdata->wdev;
|
2007-05-06 02:45:53 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-03 08:04:37 +08:00
|
|
|
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
|
2007-05-06 02:45:53 +08:00
|
|
|
{
|
|
|
|
ASSERT_RTNL();
|
2007-08-29 05:01:55 +08:00
|
|
|
|
2009-01-24 05:54:03 +08:00
|
|
|
mutex_lock(&sdata->local->iflist_mtx);
|
2008-07-09 20:40:35 +08:00
|
|
|
list_del_rcu(&sdata->list);
|
2009-01-24 05:54:03 +08:00
|
|
|
mutex_unlock(&sdata->local->iflist_mtx);
|
|
|
|
|
2019-04-16 15:24:40 +08:00
|
|
|
if (sdata->vif.txq)
|
|
|
|
ieee80211_txq_purge(sdata->local, to_txq_info(sdata->vif.txq));
|
|
|
|
|
2008-07-09 20:40:35 +08:00
|
|
|
synchronize_rcu();
|
2012-06-19 02:07:15 +08:00
|
|
|
|
2021-01-22 23:19:42 +08:00
|
|
|
cfg80211_unregister_wdev(&sdata->wdev);
|
|
|
|
|
|
|
|
if (!sdata->dev) {
|
2015-11-17 16:24:40 +08:00
|
|
|
ieee80211_teardown_sdata(sdata);
|
2012-06-19 02:07:15 +08:00
|
|
|
kfree(sdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state)))
|
|
|
|
return;
|
|
|
|
ieee80211_do_stop(sdata, true);
|
2007-05-06 02:45:53 +08:00
|
|
|
}
|
|
|
|
|
2008-07-09 20:40:35 +08:00
|
|
|
void ieee80211_remove_interfaces(struct ieee80211_local *local)
|
2007-05-06 02:45:53 +08:00
|
|
|
{
|
2008-07-09 20:40:35 +08:00
|
|
|
struct ieee80211_sub_if_data *sdata, *tmp;
|
2009-11-05 18:06:40 +08:00
|
|
|
LIST_HEAD(unreg_list);
|
2012-06-19 02:07:15 +08:00
|
|
|
LIST_HEAD(wdev_list);
|
2007-05-06 02:45:53 +08:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
mac80211: shut down interfaces before destroying interface list
If the hardware is unregistered while interfaces are up, mac80211 will
unregister all interfaces, which in turns causes mac80211 to be called
again to remove them all from the driver and eventually shut down the
hardware.
During this shutdown, however, it's currently already unsafe to iterate
the list of interfaces atomically, as the list is manipulated in an
unsafe manner. This puts an undue burden on the driver - it must stop
all its activities before calling ieee80211_unregister_hw(), while in
the normal stop path it can do all cleanup in the stop method. If, for
example, it's using the iteration during RX for some reason, it would
have to stop RX before unregistering to avoid crashes.
Fix this problem by closing all interfaces before unregistering them.
This will cause the driver stop to have completed before we manipulate
the interface list, and after the driver is stopped *and* has called
ieee80211_unregister_hw() it really musn't be iterating any more as
the memory will be freed as well.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2015-07-08 20:41:50 +08:00
|
|
|
/* Before destroying the interfaces, make sure they're all stopped so
|
|
|
|
* that the hardware is stopped. Otherwise, the driver might still be
|
|
|
|
* iterating the interfaces during the shutdown, e.g. from a worker
|
|
|
|
* or from RX processing or similar, and if it does so (using atomic
|
|
|
|
* iteration) while we're manipulating the list, the iteration will
|
|
|
|
* crash.
|
|
|
|
*
|
|
|
|
* After this, the hardware should be stopped and the driver should
|
|
|
|
* have stopped all of its activities, so that we can do RCU-unaware
|
|
|
|
* manipulations of the interface list below.
|
2013-05-24 07:06:09 +08:00
|
|
|
*/
|
mac80211: shut down interfaces before destroying interface list
If the hardware is unregistered while interfaces are up, mac80211 will
unregister all interfaces, which in turns causes mac80211 to be called
again to remove them all from the driver and eventually shut down the
hardware.
During this shutdown, however, it's currently already unsafe to iterate
the list of interfaces atomically, as the list is manipulated in an
unsafe manner. This puts an undue burden on the driver - it must stop
all its activities before calling ieee80211_unregister_hw(), while in
the normal stop path it can do all cleanup in the stop method. If, for
example, it's using the iteration during RX for some reason, it would
have to stop RX before unregistering to avoid crashes.
Fix this problem by closing all interfaces before unregistering them.
This will cause the driver stop to have completed before we manipulate
the interface list, and after the driver is stopped *and* has called
ieee80211_unregister_hw() it really musn't be iterating any more as
the memory will be freed as well.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2015-07-08 20:41:50 +08:00
|
|
|
cfg80211_shutdown_all_interfaces(local->hw.wiphy);
|
|
|
|
|
|
|
|
WARN(local->open_count, "%s: open count remains %d\n",
|
|
|
|
wiphy_name(local->hw.wiphy), local->open_count);
|
2013-05-24 07:06:09 +08:00
|
|
|
|
2018-12-15 17:03:10 +08:00
|
|
|
ieee80211_txq_teardown_flows(local);
|
|
|
|
|
2009-11-05 18:06:40 +08:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
2008-07-09 20:40:35 +08:00
|
|
|
list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
|
|
|
|
list_del(&sdata->list);
|
2009-01-24 05:54:03 +08:00
|
|
|
|
2012-06-19 02:07:15 +08:00
|
|
|
if (sdata->dev)
|
|
|
|
unregister_netdevice_queue(sdata->dev, &unreg_list);
|
|
|
|
else
|
|
|
|
list_add(&sdata->list, &wdev_list);
|
2007-05-06 02:45:53 +08:00
|
|
|
}
|
2009-11-05 18:06:40 +08:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2021-01-22 23:19:43 +08:00
|
|
|
|
2009-11-05 18:06:40 +08:00
|
|
|
unregister_netdevice_many(&unreg_list);
|
2012-06-19 02:07:15 +08:00
|
|
|
|
2021-01-22 23:19:43 +08:00
|
|
|
wiphy_lock(local->hw.wiphy);
|
2012-06-19 02:07:15 +08:00
|
|
|
list_for_each_entry_safe(sdata, tmp, &wdev_list, list) {
|
|
|
|
list_del(&sdata->list);
|
|
|
|
cfg80211_unregister_wdev(&sdata->wdev);
|
|
|
|
kfree(sdata);
|
|
|
|
}
|
2021-01-22 23:19:43 +08:00
|
|
|
wiphy_unlock(local->hw.wiphy);
|
2007-05-06 02:45:53 +08:00
|
|
|
}
|
2009-04-29 18:26:17 +08:00
|
|
|
|
2009-11-26 00:46:19 +08:00
|
|
|
static int netdev_notify(struct notifier_block *nb,
|
2013-05-28 09:30:21 +08:00
|
|
|
unsigned long state, void *ptr)
|
2009-11-26 00:46:19 +08:00
|
|
|
{
|
2013-05-28 09:30:21 +08:00
|
|
|
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
|
2009-11-26 00:46:19 +08:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
|
|
|
if (state != NETDEV_CHANGENAME)
|
2014-04-21 12:53:05 +08:00
|
|
|
return NOTIFY_DONE;
|
2009-11-26 00:46:19 +08:00
|
|
|
|
|
|
|
if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
|
2014-04-21 12:53:05 +08:00
|
|
|
return NOTIFY_DONE;
|
2009-11-26 00:46:19 +08:00
|
|
|
|
|
|
|
if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
|
2014-04-21 12:53:05 +08:00
|
|
|
return NOTIFY_DONE;
|
2009-11-26 00:46:19 +08:00
|
|
|
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2010-02-12 17:45:05 +08:00
|
|
|
memcpy(sdata->name, dev->name, IFNAMSIZ);
|
2009-11-26 00:46:19 +08:00
|
|
|
ieee80211_debugfs_rename_netdev(sdata);
|
2014-04-21 12:53:05 +08:00
|
|
|
|
|
|
|
return NOTIFY_OK;
|
2009-11-26 00:46:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block mac80211_netdev_notifier = {
|
|
|
|
.notifier_call = netdev_notify,
|
|
|
|
};
|
|
|
|
|
|
|
|
int ieee80211_iface_init(void)
|
|
|
|
{
|
|
|
|
return register_netdevice_notifier(&mac80211_netdev_notifier);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_iface_exit(void)
|
|
|
|
{
|
|
|
|
unregister_netdevice_notifier(&mac80211_netdev_notifier);
|
|
|
|
}
|
2016-10-11 01:12:21 +08:00
|
|
|
|
|
|
|
void ieee80211_vif_inc_num_mcast(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
atomic_inc(&sdata->u.ap.num_mcast_sta);
|
|
|
|
else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
|
|
|
atomic_inc(&sdata->u.vlan.num_mcast_sta);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_vif_dec_num_mcast(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
atomic_dec(&sdata->u.ap.num_mcast_sta);
|
|
|
|
else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
|
|
|
atomic_dec(&sdata->u.vlan.num_mcast_sta);
|
|
|
|
}
|