2019-06-04 08:11:33 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2007-05-05 18:45:53 +00:00
|
|
|
/*
|
2013-03-26 20:54:24 +00:00
|
|
|
* Interface handling
|
2008-09-10 22:01:59 +00:00
|
|
|
*
|
2007-05-05 18:45:53 +00:00
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
|
|
* Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
|
2008-07-09 12:40:35 +00:00
|
|
|
* Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
|
2014-09-03 12:24:57 +00:00
|
|
|
* Copyright 2013-2014 Intel Mobile Communications GmbH
|
2016-10-20 06:52:50 +00:00
|
|
|
* Copyright (c) 2016 Intel Deutschland GmbH
|
2023-06-04 09:11:26 +00:00
|
|
|
* Copyright (C) 2018-2023 Intel Corporation
|
2007-05-05 18:45:53 +00: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 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2007-05-05 18:45:53 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
2021-02-18 17:31:24 +00:00
|
|
|
#include <linux/kcov.h>
|
2007-05-05 18:45:53 +00:00
|
|
|
#include <net/mac80211.h>
|
2010-01-05 17:00:58 +00:00
|
|
|
#include <net/ieee80211_radiotap.h>
|
2007-05-05 18:45:53 +00:00
|
|
|
#include "ieee80211_i.h"
|
|
|
|
#include "sta_info.h"
|
2007-05-05 18:46:38 +00:00
|
|
|
#include "debugfs_netdev.h"
|
2008-02-23 14:17:11 +00:00
|
|
|
#include "mesh.h"
|
2008-09-10 22:01:59 +00:00
|
|
|
#include "led.h"
|
2009-04-23 16:52:52 +00:00
|
|
|
#include "driver-ops.h"
|
2010-01-05 17:00:58 +00:00
|
|
|
#include "wme.h"
|
2010-10-01 15:20:41 +00:00
|
|
|
#include "rate.h"
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2009-01-23 21:54:03 +00:00
|
|
|
/**
|
|
|
|
* DOC: Interface list locking
|
|
|
|
*
|
|
|
|
* The interface list in each struct ieee80211_local is protected
|
|
|
|
* three-fold:
|
|
|
|
*
|
2023-08-28 12:00:06 +00:00
|
|
|
* (1) modifications may only be done under the RTNL *and* wiphy mutex
|
|
|
|
* *and* iflist_mtx
|
|
|
|
* (2) modifications are done in an RCU manner so atomic readers
|
2009-01-23 21:54:03 +00:00
|
|
|
* can traverse the list in RCU-safe blocks.
|
|
|
|
*
|
|
|
|
* As a consequence, reads (traversals) of the list can be protected
|
2023-08-28 12:00:06 +00:00
|
|
|
* by either the RTNL, the wiphy mutex, the iflist_mtx or RCU.
|
2009-01-23 21:54:03 +00:00
|
|
|
*/
|
|
|
|
|
2023-06-06 12:49:26 +00:00
|
|
|
static void ieee80211_iface_work(struct wiphy *wiphy, struct wiphy_work *work);
|
2016-08-29 20:25:16 +00:00
|
|
|
|
2012-10-24 08:59:25 +00:00
|
|
|
bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_chanctx_conf *chanctx_conf;
|
|
|
|
int power;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
wifi: mac80211: move some future per-link data to bss_conf
To add MLD, reuse the bss_conf structure later for per-link
information, so move some things into it that are per link.
Most transformations were done with the following spatch:
@@
expression sdata;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-sdata->vif.var
+sdata->vif.bss_conf.var
@@
struct ieee80211_vif *vif;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-vif->var
+vif->bss_conf.var
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-05-10 11:26:44 +00:00
|
|
|
chanctx_conf = rcu_dereference(sdata->vif.bss_conf.chanctx_conf);
|
2012-10-24 08:59:25 +00:00
|
|
|
if (!chanctx_conf) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-07-08 14:55:55 +00:00
|
|
|
power = ieee80211_chandef_max_power(&chanctx_conf->def);
|
2012-10-24 08:59:25 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
if (sdata->deflink.user_power_level != IEEE80211_UNSET_POWER_LEVEL)
|
|
|
|
power = min(power, sdata->deflink.user_power_level);
|
2012-10-24 08:59:25 +00:00
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
if (sdata->deflink.ap_power_level != IEEE80211_UNSET_POWER_LEVEL)
|
|
|
|
power = min(power, sdata->deflink.ap_power_level);
|
2012-10-24 08:59:25 +00:00
|
|
|
|
|
|
|
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 11:55:08 +00:00
|
|
|
void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata,
|
|
|
|
bool update_bss)
|
2012-10-24 08:59:25 +00:00
|
|
|
{
|
2015-11-17 08:24:39 +00:00
|
|
|
if (__ieee80211_recalc_txpower(sdata) ||
|
|
|
|
(update_bss && ieee80211_sdata_running(sdata)))
|
2022-06-17 20:36:37 +00:00
|
|
|
ieee80211_link_info_change_notify(sdata, &sdata->deflink,
|
2022-05-24 08:55:56 +00:00
|
|
|
BSS_CHANGED_TXPOWER);
|
2012-10-24 08:59:25 +00:00
|
|
|
}
|
2009-01-23 21:54:03 +00:00
|
|
|
|
2013-04-08 09:52:34 +00:00
|
|
|
static u32 __ieee80211_idle_off(struct ieee80211_local *local)
|
2012-06-21 20:30:52 +00: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 09:52:34 +00:00
|
|
|
static u32 __ieee80211_idle_on(struct ieee80211_local *local)
|
2012-06-21 20:30:52 +00:00
|
|
|
{
|
|
|
|
if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
|
|
|
|
return 0;
|
|
|
|
|
2015-01-07 13:42:39 +00:00
|
|
|
ieee80211_flush_queues(local, NULL, false);
|
2012-06-21 20:30:52 +00:00
|
|
|
|
|
|
|
local->hw.conf.flags |= IEEE80211_CONF_IDLE;
|
|
|
|
return IEEE80211_CONF_CHANGE_IDLE;
|
|
|
|
}
|
|
|
|
|
2013-04-08 09:52:34 +00:00
|
|
|
static u32 __ieee80211_recalc_idle(struct ieee80211_local *local,
|
|
|
|
bool force_active)
|
2012-06-21 20:30:52 +00:00
|
|
|
{
|
2014-02-12 10:29:32 +00:00
|
|
|
bool working, scanning, active;
|
2012-06-21 20:30:52 +00:00
|
|
|
unsigned int led_trig_start = 0, led_trig_stop = 0;
|
|
|
|
|
2023-08-28 12:00:05 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
2012-06-21 20:30:52 +00:00
|
|
|
|
2013-04-08 09:52:34 +00:00
|
|
|
active = force_active ||
|
|
|
|
!list_empty(&local->chanctx_list) ||
|
|
|
|
local->monitors;
|
2012-06-21 20:30:52 +00:00
|
|
|
|
2014-02-12 10:29:32 +00:00
|
|
|
working = !local->ops->remain_on_channel &&
|
|
|
|
!list_empty(&local->roc_list);
|
2012-06-21 20:30:52 +00:00
|
|
|
|
2013-02-06 22:57:57 +00:00
|
|
|
scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
|
|
|
|
test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
|
2012-06-21 20:30:52 +00:00
|
|
|
|
|
|
|
if (working || scanning)
|
|
|
|
led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
|
|
|
|
else
|
|
|
|
led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
|
|
|
|
|
2013-02-06 23:14:51 +00:00
|
|
|
if (active)
|
2012-06-21 20:30:52 +00: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-06 23:14:51 +00:00
|
|
|
if (working || scanning || active)
|
2013-04-08 09:52:34 +00: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-06 23:14:51 +00:00
|
|
|
if (change)
|
|
|
|
ieee80211_hw_config(local, change);
|
2012-06-21 20:30:52 +00:00
|
|
|
}
|
|
|
|
|
2013-06-11 18:48:32 +00:00
|
|
|
static int ieee80211_verify_mac(struct ieee80211_sub_if_data *sdata, u8 *addr,
|
2013-05-28 11:01:53 +00:00
|
|
|
bool check_dup)
|
2012-11-27 17:23:06 +00:00
|
|
|
{
|
2013-05-27 08:43:09 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_sub_if_data *iter;
|
2012-11-27 17:23:06 +00:00
|
|
|
u64 new, mask, tmp;
|
|
|
|
u8 *m;
|
|
|
|
int ret = 0;
|
|
|
|
|
2023-08-28 12:00:06 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
|
|
|
|
2012-11-27 17:23:06 +00:00
|
|
|
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 11:01:53 +00:00
|
|
|
if (!check_dup)
|
|
|
|
return ret;
|
2012-11-27 17:23:06 +00:00
|
|
|
|
2013-05-27 08:43:09 +00:00
|
|
|
list_for_each_entry(iter, &local->interfaces, list) {
|
|
|
|
if (iter == sdata)
|
2012-11-27 17:23:06 +00:00
|
|
|
continue;
|
|
|
|
|
2013-06-11 18:48:32 +00:00
|
|
|
if (iter->vif.type == NL80211_IFTYPE_MONITOR &&
|
2016-08-29 20:25:15 +00:00
|
|
|
!(iter->u.mntr.flags & MONITOR_FLAG_ACTIVE))
|
2012-11-27 17:23:06 +00:00
|
|
|
continue;
|
|
|
|
|
2013-05-27 08:43:09 +00:00
|
|
|
m = iter->vif.addr;
|
2012-11-27 17:23:06 +00: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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-08-26 17:00:32 +00:00
|
|
|
static int ieee80211_can_powered_addr_change(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_roc_work *roc;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_sub_if_data *scan_sdata;
|
|
|
|
int ret = 0;
|
|
|
|
|
2023-08-28 12:00:05 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
|
|
|
|
2022-08-26 17:00:32 +00:00
|
|
|
/* To be the most flexible here we want to only limit changing the
|
|
|
|
* address if the specific interface is doing offchannel work or
|
|
|
|
* scanning.
|
|
|
|
*/
|
|
|
|
if (netif_carrier_ok(sdata->dev))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
/* First check no ROC work is happening on this iface */
|
|
|
|
list_for_each_entry(roc, &local->roc_list, list) {
|
|
|
|
if (roc->sdata != sdata)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (roc->started) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* And if this iface is scanning */
|
|
|
|
if (local->scanning) {
|
|
|
|
scan_sdata = rcu_dereference_protected(local->scan_sdata,
|
2023-08-28 12:00:05 +00:00
|
|
|
lockdep_is_held(&local->hw.wiphy->mtx));
|
2022-08-26 17:00:32 +00:00
|
|
|
if (sdata == scan_sdata)
|
|
|
|
ret = -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
/* More interface types could be added here but changing the
|
|
|
|
* address while powered makes the most sense in client modes.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
default:
|
2022-09-12 15:07:16 +00:00
|
|
|
ret = -EOPNOTSUPP;
|
2022-08-26 17:00:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unlock:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2023-08-28 12:00:00 +00:00
|
|
|
static int _ieee80211_change_mac(struct ieee80211_sub_if_data *sdata,
|
|
|
|
void *addr)
|
2009-11-25 16:46:19 +00:00
|
|
|
{
|
2022-08-26 17:00:32 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2009-12-30 13:54:03 +00:00
|
|
|
struct sockaddr *sa = addr;
|
2013-05-28 11:01:53 +00:00
|
|
|
bool check_dup = true;
|
2022-08-26 17:00:32 +00:00
|
|
|
bool live = false;
|
2009-11-25 16:46:19 +00:00
|
|
|
int ret;
|
|
|
|
|
2022-08-26 17:00:32 +00:00
|
|
|
if (ieee80211_sdata_running(sdata)) {
|
|
|
|
ret = ieee80211_can_powered_addr_change(sdata);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
live = true;
|
|
|
|
}
|
2009-11-25 16:46:19 +00:00
|
|
|
|
2013-05-28 11:01:53 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
|
2016-08-29 20:25:15 +00:00
|
|
|
!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
|
2013-05-28 11:01:53 +00:00
|
|
|
check_dup = false;
|
|
|
|
|
2013-06-11 18:48:32 +00:00
|
|
|
ret = ieee80211_verify_mac(sdata, sa->sa_data, check_dup);
|
2012-11-27 17:23:06 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2022-08-26 17:00:32 +00:00
|
|
|
if (live)
|
|
|
|
drv_remove_interface(local, sdata);
|
2023-08-28 12:00:00 +00:00
|
|
|
ret = eth_mac_addr(sdata->dev, sa);
|
2009-11-25 16:46:19 +00:00
|
|
|
|
2022-05-31 21:20:08 +00:00
|
|
|
if (ret == 0) {
|
2009-12-30 13:54:03 +00:00
|
|
|
memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
|
2022-05-31 21:20:08 +00:00
|
|
|
ether_addr_copy(sdata->vif.bss_conf.addr, sdata->vif.addr);
|
|
|
|
}
|
2009-11-25 16:46:19 +00:00
|
|
|
|
2022-08-26 17:00:32 +00:00
|
|
|
/* Regardless of eth_mac_addr() return we still want to add the
|
|
|
|
* interface back. This should not fail...
|
|
|
|
*/
|
|
|
|
if (live)
|
|
|
|
WARN_ON(drv_add_interface(local, sdata));
|
|
|
|
|
2009-11-25 16:46:19 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2023-08-28 12:00:00 +00:00
|
|
|
static int ieee80211_change_mac(struct net_device *dev, void *addr)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int ret;
|
|
|
|
|
2023-10-12 10:34:47 +00:00
|
|
|
/*
|
|
|
|
* This happens during unregistration if there's a bond device
|
|
|
|
* active (maybe other cases?) and we must get removed from it.
|
|
|
|
* But we really don't care anymore if it's not registered now.
|
|
|
|
*/
|
|
|
|
if (!dev->ieee80211_ptr->registered)
|
|
|
|
return 0;
|
|
|
|
|
2023-08-28 12:00:00 +00:00
|
|
|
wiphy_lock(local->hw.wiphy);
|
|
|
|
ret = _ieee80211_change_mac(sdata, addr);
|
|
|
|
wiphy_unlock(local->hw.wiphy);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-09-10 22:01:59 +00:00
|
|
|
static inline int identical_mac_addr_allowed(int type1, int type2)
|
|
|
|
{
|
|
|
|
return type1 == NL80211_IFTYPE_MONITOR ||
|
|
|
|
type2 == NL80211_IFTYPE_MONITOR ||
|
2012-06-18 18:07:15 +00:00
|
|
|
type1 == NL80211_IFTYPE_P2P_DEVICE ||
|
|
|
|
type2 == NL80211_IFTYPE_P2P_DEVICE ||
|
2008-09-10 22:01:59 +00: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 10:35:57 +00:00
|
|
|
static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum nl80211_iftype iftype)
|
2008-09-10 22:01:59 +00:00
|
|
|
{
|
2008-09-26 11:34:54 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2010-08-27 10:35:57 +00:00
|
|
|
struct ieee80211_sub_if_data *nsdata;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2010-08-27 10:35:57 +00:00
|
|
|
ASSERT_RTNL();
|
2023-08-28 12:00:03 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
2008-09-10 22:01:59 +00:00
|
|
|
|
|
|
|
/* we hold the RTNL here so can safely walk the list */
|
|
|
|
list_for_each_entry(nsdata, &local->interfaces, list) {
|
2012-06-19 13:54:05 +00:00
|
|
|
if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
|
2014-11-03 09:33:19 +00: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-10 22:01:59 +00: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 10:35:57 +00:00
|
|
|
if (iftype == NL80211_IFTYPE_ADHOC &&
|
2008-09-10 22:01:59 +00:00
|
|
|
nsdata->vif.type == NL80211_IFTYPE_ADHOC)
|
|
|
|
return -EBUSY;
|
2013-07-11 14:09:06 +00:00
|
|
|
/*
|
|
|
|
* will not add another interface while any channel
|
|
|
|
* switch is active.
|
|
|
|
*/
|
wifi: mac80211: move some future per-link data to bss_conf
To add MLD, reuse the bss_conf structure later for per-link
information, so move some things into it that are per link.
Most transformations were done with the following spatch:
@@
expression sdata;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-sdata->vif.var
+sdata->vif.bss_conf.var
@@
struct ieee80211_vif *vif;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-vif->var
+vif->bss_conf.var
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-05-10 11:26:44 +00:00
|
|
|
if (nsdata->vif.bss_conf.csa_active)
|
2013-07-11 14:09:06 +00:00
|
|
|
return -EBUSY;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The remaining checks are only performed for interfaces
|
|
|
|
* with the same MAC address.
|
|
|
|
*/
|
2012-06-19 13:54:05 +00:00
|
|
|
if (!ether_addr_equal(sdata->vif.addr,
|
|
|
|
nsdata->vif.addr))
|
2008-09-10 22:01:59 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check whether it may have the same address
|
|
|
|
*/
|
2010-08-27 10:35:57 +00:00
|
|
|
if (!identical_mac_addr_allowed(iftype,
|
2008-09-10 22:01:59 +00:00
|
|
|
nsdata->vif.type))
|
|
|
|
return -ENOTUNIQ;
|
|
|
|
|
2022-09-02 14:12:59 +00:00
|
|
|
/* No support for VLAN with MLO yet */
|
|
|
|
if (iftype == NL80211_IFTYPE_AP_VLAN &&
|
2022-12-14 13:03:26 +00:00
|
|
|
sdata->wdev.use_4addr &&
|
|
|
|
nsdata->vif.type == NL80211_IFTYPE_AP &&
|
|
|
|
nsdata->vif.valid_links)
|
2022-09-02 14:12:59 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2008-09-10 22:01:59 +00:00
|
|
|
/*
|
|
|
|
* can only add VLANs to enabled APs
|
|
|
|
*/
|
2010-08-27 10:35:57 +00:00
|
|
|
if (iftype == NL80211_IFTYPE_AP_VLAN &&
|
2008-09-10 22:01:59 +00:00
|
|
|
nsdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
sdata->bss = &nsdata->u.ap;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-08-28 12:00:03 +00:00
|
|
|
return ieee80211_check_combinations(sdata, NULL, 0, 0);
|
2010-08-27 10:35:57 +00:00
|
|
|
}
|
|
|
|
|
2013-08-26 07:30:32 +00:00
|
|
|
static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum nl80211_iftype iftype)
|
2012-04-03 14:28:50 +00:00
|
|
|
{
|
|
|
|
int n_queues = sdata->local->hw.queues;
|
|
|
|
int i;
|
|
|
|
|
2016-09-20 14:31:14 +00:00
|
|
|
if (iftype == NL80211_IFTYPE_NAN)
|
|
|
|
return 0;
|
|
|
|
|
2013-08-26 07:30:32 +00:00
|
|
|
if (iftype != NL80211_IFTYPE_P2P_DEVICE) {
|
2012-08-21 09:43:35 +00: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 14:28:50 +00:00
|
|
|
}
|
|
|
|
|
2013-08-26 07:30:32 +00:00
|
|
|
if ((iftype != NL80211_IFTYPE_AP &&
|
|
|
|
iftype != NL80211_IFTYPE_P2P_GO &&
|
|
|
|
iftype != NL80211_IFTYPE_MESH_POINT) ||
|
2015-06-02 19:39:54 +00:00
|
|
|
!ieee80211_hw_check(&sdata->local->hw, QUEUE_CONTROL)) {
|
2012-04-03 14:28:50 +00: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 12:37:02 +00:00
|
|
|
static int ieee80211_open(struct net_device *dev)
|
2020-09-08 12:36:53 +00:00
|
|
|
{
|
2020-09-08 12:37:02 +00: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;
|
|
|
|
|
2023-08-28 11:59:58 +00:00
|
|
|
wiphy_lock(sdata->local->hw.wiphy);
|
2020-09-08 12:37:02 +00:00
|
|
|
err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
|
|
|
|
if (err)
|
2023-08-28 11:59:58 +00:00
|
|
|
goto out;
|
2020-09-08 12:37:02 +00:00
|
|
|
|
2021-01-22 15:19:43 +00:00
|
|
|
err = ieee80211_do_open(&sdata->wdev, true);
|
2023-08-28 11:59:58 +00:00
|
|
|
out:
|
2021-01-22 15:19:43 +00:00
|
|
|
wiphy_unlock(sdata->local->hw.wiphy);
|
|
|
|
|
|
|
|
return err;
|
2020-09-08 12:36:53 +00:00
|
|
|
}
|
|
|
|
|
2021-01-22 15:19:43 +00:00
|
|
|
static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata, bool going_down)
|
2020-09-08 12:36:53 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2020-09-08 12:37:02 +00: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 12:36:53 +00:00
|
|
|
|
2023-08-28 12:00:05 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
clear_bit(SDATA_STATE_RUNNING, &sdata->state);
|
2022-07-17 12:21:52 +00:00
|
|
|
synchronize_rcu(); /* flush _ieee80211_wake_txqs() */
|
2020-09-08 12:36:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
cancel_scan = rcu_access_pointer(local->scan_sdata) == sdata;
|
|
|
|
if (cancel_scan)
|
|
|
|
ieee80211_scan_cancel(local);
|
2020-09-08 12:36:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_roc_purge(local, sdata);
|
2020-09-08 12:36:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 12:36:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 09:57:46 +00:00
|
|
|
* For AP_VLANs stations may exist since there's nothing else that
|
2020-09-08 12:37:02 +00:00
|
|
|
* would have removed them, but in other modes there shouldn't
|
|
|
|
* be any stations.
|
|
|
|
*/
|
|
|
|
flushed = sta_info_flush(sdata);
|
2020-11-09 09:57:46 +00:00
|
|
|
WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_AP_VLAN && flushed > 0);
|
2020-09-08 12:36:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 12:36:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 12:36:53 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00: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 12:36:53 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
del_timer_sync(&local->dynamic_ps_timer);
|
2023-08-28 11:59:44 +00:00
|
|
|
wiphy_work_cancel(local->hw.wiphy, &local->dynamic_ps_enable_work);
|
2020-09-08 12:36:53 +00:00
|
|
|
|
2023-06-08 13:36:08 +00:00
|
|
|
WARN(ieee80211_vif_is_mld(&sdata->vif),
|
2022-05-31 21:20:08 +00:00
|
|
|
"destroying interface with valid links 0x%04x\n",
|
|
|
|
sdata->vif.valid_links);
|
|
|
|
|
wifi: mac80211: move some future per-link data to bss_conf
To add MLD, reuse the bss_conf structure later for per-link
information, so move some things into it that are per link.
Most transformations were done with the following spatch:
@@
expression sdata;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-sdata->vif.var
+sdata->vif.bss_conf.var
@@
struct ieee80211_vif *vif;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-vif->var
+vif->bss_conf.var
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-05-10 11:26:44 +00:00
|
|
|
sdata->vif.bss_conf.csa_active = false;
|
2020-09-08 12:37:02 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION)
|
2022-05-16 13:00:15 +00:00
|
|
|
sdata->deflink.u.mgd.csa_waiting_bcn = false;
|
|
|
|
if (sdata->deflink.csa_block_tx) {
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_wake_vif_queues(local, sdata,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_CSA);
|
2022-05-16 13:00:15 +00:00
|
|
|
sdata->deflink.csa_block_tx = false;
|
2020-09-08 12:36:53 +00:00
|
|
|
}
|
|
|
|
|
2023-08-28 11:59:50 +00:00
|
|
|
wiphy_work_cancel(local->hw.wiphy, &sdata->deflink.csa_finalize_work);
|
2023-08-28 11:59:51 +00:00
|
|
|
wiphy_work_cancel(local->hw.wiphy,
|
|
|
|
&sdata->deflink.color_change_finalize_work);
|
2023-08-28 11:59:37 +00:00
|
|
|
wiphy_delayed_work_cancel(local->hw.wiphy,
|
|
|
|
&sdata->deflink.dfs_cac_timer_work);
|
2010-10-02 11:17:07 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (sdata->wdev.cac_started) {
|
|
|
|
chandef = sdata->vif.bss_conf.chandef;
|
|
|
|
WARN_ON(local->suspended);
|
2022-06-17 20:36:37 +00:00
|
|
|
ieee80211_link_release_channel(&sdata->deflink);
|
2020-09-08 12:37:02 +00:00
|
|
|
cfg80211_cac_event(sdata->dev, &chandef,
|
|
|
|
NL80211_RADAR_CAC_ABORTED,
|
|
|
|
GFP_KERNEL);
|
|
|
|
}
|
2010-10-02 11:17:07 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 14:28:50 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 14:28:50 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (going_down)
|
|
|
|
local->open_count--;
|
2012-04-03 12:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
list_del(&sdata->u.vlan.list);
|
wifi: mac80211: move some future per-link data to bss_conf
To add MLD, reuse the bss_conf structure later for per-link
information, so move some things into it that are per link.
Most transformations were done with the following spatch:
@@
expression sdata;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-sdata->vif.var
+sdata->vif.bss_conf.var
@@
struct ieee80211_vif *vif;
identifier var = { chanctx_conf, mu_mimo_owner, csa_active, color_change_active, color_change_color };
@@
-vif->var
+vif->bss_conf.var
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-05-10 11:26:44 +00:00
|
|
|
RCU_INIT_POINTER(sdata->vif.bss_conf.chanctx_conf, NULL);
|
2020-09-08 12:37:02 +00:00
|
|
|
/* 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 14:38:09 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
local->monitors--;
|
|
|
|
if (local->monitors == 0) {
|
|
|
|
local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
|
|
|
|
hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
|
|
|
|
}
|
2012-04-03 12:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 12:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 14:28:50 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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:
|
2023-06-06 12:49:26 +00:00
|
|
|
wiphy_work_cancel(sdata->local->hw.wiphy, &sdata->work);
|
2020-09-08 12:37:02 +00:00
|
|
|
/*
|
|
|
|
* 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 09:57:46 +00:00
|
|
|
* keys before the interface is operating)
|
2020-09-08 12:37:02 +00: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);
|
2021-08-23 18:02:39 +00:00
|
|
|
skb_queue_purge(&sdata->status_queue);
|
2012-04-03 12:35:57 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00: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 14:28:50 +00:00
|
|
|
}
|
2020-09-08 12:37:02 +00:00
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
2012-04-03 14:28:50 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
|
|
|
ieee80211_txq_remove_vlan(local, sdata);
|
2014-01-29 12:28:02 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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);
|
2021-11-12 12:51:44 +00:00
|
|
|
WARN_ON(rcu_access_pointer(local->monitor_sdata));
|
2020-09-08 12:37:02 +00:00
|
|
|
return;
|
2012-07-26 15:24:39 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00: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-29 20:25:16 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_recalc_idle(local);
|
2012-04-03 12:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
|
|
|
|
break;
|
2012-04-03 12:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
fallthrough;
|
|
|
|
default:
|
|
|
|
if (going_down)
|
|
|
|
drv_remove_interface(local, sdata);
|
|
|
|
}
|
2012-04-03 12:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_recalc_ps(local);
|
2013-03-20 21:25:17 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (cancel_scan)
|
2023-08-28 11:59:39 +00:00
|
|
|
wiphy_delayed_work_flush(local->hw.wiphy, &local->scan_work);
|
2012-04-03 12:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (local->open_count == 0) {
|
|
|
|
ieee80211_stop_device(local);
|
|
|
|
|
|
|
|
/* no reconfiguring after stop! */
|
2013-03-20 21:25:17 +00:00
|
|
|
return;
|
|
|
|
}
|
2012-04-03 12:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
/* do after stop to avoid reconfiguring when we stop anyway */
|
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
ieee80211_hw_config(local, hw_reconf_flags);
|
2013-03-20 21:25:17 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (local->monitors == local->open_count)
|
|
|
|
ieee80211_add_virtual_monitor(local);
|
|
|
|
}
|
2012-04-03 12:35:57 +00:00
|
|
|
|
2021-09-16 02:54:35 +00:00
|
|
|
static void ieee80211_stop_mbssid(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *tx_sdata, *non_tx_sdata, *tmp_sdata;
|
|
|
|
struct ieee80211_vif *tx_vif = sdata->vif.mbssid_tx_vif;
|
|
|
|
|
|
|
|
if (!tx_vif)
|
|
|
|
return;
|
|
|
|
|
|
|
|
tx_sdata = vif_to_sdata(tx_vif);
|
|
|
|
sdata->vif.mbssid_tx_vif = NULL;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(non_tx_sdata, tmp_sdata,
|
|
|
|
&tx_sdata->local->interfaces, list) {
|
|
|
|
if (non_tx_sdata != sdata && non_tx_sdata != tx_sdata &&
|
|
|
|
non_tx_sdata->vif.mbssid_tx_vif == tx_vif &&
|
|
|
|
ieee80211_sdata_running(non_tx_sdata)) {
|
|
|
|
non_tx_sdata->vif.mbssid_tx_vif = NULL;
|
|
|
|
dev_close(non_tx_sdata->wdev.netdev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sdata != tx_sdata && ieee80211_sdata_running(tx_sdata)) {
|
|
|
|
tx_sdata->vif.mbssid_tx_vif = NULL;
|
|
|
|
dev_close(tx_sdata->wdev.netdev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
static int ieee80211_stop(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2012-07-26 15:24:39 +00:00
|
|
|
|
2021-09-16 02:54:35 +00:00
|
|
|
/* close dependent VLAN and MBSSID interfaces before locking wiphy */
|
2021-05-17 14:03:23 +00:00
|
|
|
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-09-16 02:54:35 +00:00
|
|
|
|
|
|
|
ieee80211_stop_mbssid(sdata);
|
2021-05-17 14:03:23 +00:00
|
|
|
}
|
|
|
|
|
2021-01-22 15:19:43 +00:00
|
|
|
wiphy_lock(sdata->local->hw.wiphy);
|
2023-08-28 11:59:43 +00:00
|
|
|
wiphy_work_cancel(sdata->local->hw.wiphy, &sdata->activate_links_work);
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_do_stop(sdata, true);
|
2021-01-22 15:19:43 +00:00
|
|
|
wiphy_unlock(sdata->local->hw.wiphy);
|
2012-04-03 12:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
return 0;
|
2012-04-03 12:35:57 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
static void ieee80211_set_multicast_list(struct net_device *dev)
|
2010-08-27 10:35:57 +00:00
|
|
|
{
|
2020-09-08 12:37:02 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2010-08-27 10:35:57 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2020-09-08 12:37:02 +00:00
|
|
|
int allmulti, sdata_allmulti;
|
2010-08-27 10:35:57 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
allmulti = !!(dev->flags & IFF_ALLMULTI);
|
|
|
|
sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
|
2011-11-04 10:18:11 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 10:18:11 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
spin_lock_bh(&local->filter_lock);
|
|
|
|
__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
|
|
|
|
spin_unlock_bh(&local->filter_lock);
|
2023-08-28 11:59:49 +00:00
|
|
|
wiphy_work_queue(local->hw.wiphy, &local->reconfig_filter);
|
2020-09-08 12:37:02 +00:00
|
|
|
}
|
2011-11-04 10:18:11 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 09:16:48 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_debugfs_remove_netdev(sdata);
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2021-05-11 18:02:47 +00:00
|
|
|
ieee80211_destroy_frag_cache(&sdata->frags);
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif))
|
|
|
|
ieee80211_mesh_teardown_sdata(sdata);
|
2022-06-24 08:57:41 +00:00
|
|
|
|
|
|
|
ieee80211_vif_clear_links(sdata);
|
|
|
|
ieee80211_link_stop(&sdata->deflink);
|
2020-09-08 12:37:02 +00:00
|
|
|
}
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
static void ieee80211_uninit(struct net_device *dev)
|
|
|
|
{
|
|
|
|
ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
|
|
|
|
}
|
2012-07-12 17:28:31 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
static void
|
|
|
|
ieee80211_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
|
|
|
|
{
|
2020-10-12 08:18:19 +00:00
|
|
|
dev_fetch_sw_netstats(stats, dev->tstats);
|
2020-09-08 12:37:02 +00:00
|
|
|
}
|
2009-08-04 12:48:51 +00:00
|
|
|
|
2023-03-21 09:12:48 +00:00
|
|
|
static int ieee80211_netdev_setup_tc(struct net_device *dev,
|
|
|
|
enum tc_setup_type type, void *type_data)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
|
|
|
|
return drv_net_setup_tc(local, sdata, dev, type, type_data);
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00: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_get_stats64 = ieee80211_get_stats64,
|
2023-03-21 09:12:48 +00:00
|
|
|
.ndo_setup_tc = ieee80211_netdev_setup_tc,
|
2020-09-08 12:37:02 +00:00
|
|
|
};
|
2009-08-04 12:48:51 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 09:18:31 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
return 0;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
/* reset flags and info before parsing radiotap header */
|
|
|
|
memset(info, 0, sizeof(*info));
|
2011-10-16 08:57:31 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (!ieee80211_parse_tx_radiotap(skb, dev))
|
|
|
|
return 0; /* doesn't matter, frame will be dropped */
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 13:13:13 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
return ieee80211_select_queue_80211(sdata, skb, hdr);
|
|
|
|
}
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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-10 22:01:59 +00:00
|
|
|
|
2021-11-12 11:22:23 +00:00
|
|
|
static int ieee80211_netdev_fill_forward_path(struct net_device_path_ctx *ctx,
|
|
|
|
struct net_device_path *path)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct ieee80211_local *local;
|
|
|
|
struct sta_info *sta;
|
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(ctx->dev);
|
|
|
|
local = sdata->local;
|
|
|
|
|
|
|
|
if (!local->ops->net_fill_forward_path)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
sta = rcu_dereference(sdata->u.vlan.sta);
|
|
|
|
if (sta)
|
|
|
|
break;
|
|
|
|
if (sdata->wdev.use_4addr)
|
|
|
|
goto out;
|
|
|
|
if (is_multicast_ether_addr(ctx->daddr))
|
|
|
|
goto out;
|
|
|
|
sta = sta_info_get_bss(sdata, ctx->daddr);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
if (is_multicast_ether_addr(ctx->daddr))
|
|
|
|
goto out;
|
|
|
|
sta = sta_info_get(sdata, ctx->daddr);
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
if (sdata->wdev.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) {
|
|
|
|
sta = sta_info_get(sdata, ctx->daddr);
|
|
|
|
if (sta && test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
|
|
|
|
if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
sta = sta_info_get(sdata, sdata->deflink.u.mgd.bssid);
|
2021-11-12 11:22:23 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!sta)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = drv_net_fill_forward_path(local, sdata, &sta->sta, ctx, path);
|
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00: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_get_stats64 = ieee80211_get_stats64,
|
2021-11-12 11:22:23 +00:00
|
|
|
.ndo_fill_forward_path = ieee80211_netdev_fill_forward_path,
|
2023-03-21 09:12:48 +00:00
|
|
|
.ndo_setup_tc = ieee80211_netdev_setup_tc,
|
2020-09-08 12:37:02 +00:00
|
|
|
};
|
2010-10-01 15:20:41 +00:00
|
|
|
|
2020-12-18 18:47:18 +00:00
|
|
|
static bool ieee80211_iftype_supports_hdr_offload(enum nl80211_iftype iftype)
|
2020-09-08 12:37:02 +00: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 11:28:18 +00:00
|
|
|
default:
|
2020-09-08 12:37:02 +00:00
|
|
|
return false;
|
2008-09-10 22:01:59 +00:00
|
|
|
}
|
2020-09-08 12:37:02 +00:00
|
|
|
}
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 11:17:24 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
flags = sdata->vif.offload_flags;
|
2013-03-26 21:23:20 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD) &&
|
2020-12-18 18:47:18 +00:00
|
|
|
ieee80211_iftype_supports_hdr_offload(sdata->vif.type)) {
|
2020-09-08 12:37:02 +00:00
|
|
|
flags |= IEEE80211_OFFLOAD_ENCAP_ENABLED;
|
2013-03-26 21:23:20 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_FRAG) &&
|
|
|
|
local->hw.wiphy->frag_threshold != (u32)-1)
|
|
|
|
flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
|
2013-03-26 21:23:20 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (local->monitors)
|
|
|
|
flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
|
|
|
|
} else {
|
|
|
|
flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
|
2013-03-26 21:23:20 +00:00
|
|
|
}
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-12-18 18:47:18 +00: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 01:35:16 +00:00
|
|
|
if (local->monitors &&
|
|
|
|
!ieee80211_hw_check(&local->hw, SUPPORTS_CONC_MON_RX_DECAP))
|
2020-12-18 18:47:18 +00:00
|
|
|
flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
|
|
|
|
} else {
|
|
|
|
flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (sdata->vif.offload_flags == flags)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
sdata->vif.offload_flags = flags;
|
2020-12-18 18:47:18 +00:00
|
|
|
ieee80211_check_fast_rx_iface(sdata);
|
2020-09-08 12:37:02 +00:00
|
|
|
return true;
|
2008-09-10 22:01:59 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
static void ieee80211_set_vif_encap_ops(struct ieee80211_sub_if_data *sdata)
|
2008-09-10 22:01:59 +00:00
|
|
|
{
|
2020-09-08 12:37:02 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_sub_if_data *bss = sdata;
|
|
|
|
bool enabled;
|
2010-08-27 10:35:58 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
|
|
|
|
if (!sdata->bss)
|
|
|
|
return;
|
2010-08-27 10:35:58 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
bss = container_of(sdata->bss, struct ieee80211_sub_if_data, u.ap);
|
|
|
|
}
|
2010-08-27 10:35:58 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD) ||
|
2020-12-18 18:47:18 +00:00
|
|
|
!ieee80211_iftype_supports_hdr_offload(bss->vif.type))
|
2020-09-08 12:37:02 +00:00
|
|
|
return;
|
2010-08-27 10:35:58 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
sdata->dev->netdev_ops = enabled ? &ieee80211_dataif_8023_ops :
|
|
|
|
&ieee80211_dataif_ops;
|
|
|
|
}
|
2011-05-14 04:13:28 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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-04 23:59:28 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (ieee80211_set_sdata_offload_flags(sdata)) {
|
|
|
|
drv_update_vif_offload(local, sdata);
|
|
|
|
ieee80211_set_vif_encap_ops(sdata);
|
|
|
|
}
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 12:15:35 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_set_vif_encap_ops(vsdata);
|
2014-01-23 12:28:16 +00:00
|
|
|
}
|
2020-09-08 12:37:02 +00:00
|
|
|
}
|
2013-08-28 11:41:31 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
void ieee80211_recalc_offload(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD))
|
|
|
|
return;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2023-08-28 12:00:06 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
2009-08-04 12:48:51 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
if (!ieee80211_sdata_running(sdata))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ieee80211_recalc_sdata_offload(sdata);
|
2012-06-18 18:07:15 +00:00
|
|
|
}
|
2020-09-08 12:37:02 +00:00
|
|
|
}
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 13:10:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
#define ADJUST(_f, _s) do { \
|
|
|
|
if (flags & MONITOR_FLAG_##_f) \
|
|
|
|
local->fif_##_s += offset; \
|
|
|
|
} while (0)
|
2012-09-11 12:34:12 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ADJUST(FCSFAIL, fcsfail);
|
|
|
|
ADJUST(PLCPFAIL, plcpfail);
|
|
|
|
ADJUST(CONTROL, control);
|
|
|
|
ADJUST(CONTROL, pspoll);
|
|
|
|
ADJUST(OTHER_BSS, other_bss);
|
2013-02-08 17:16:20 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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-08 17:16:20 +00:00
|
|
|
}
|
2020-09-08 12:37:02 +00:00
|
|
|
sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
|
|
|
|
}
|
2013-02-08 17:16:20 +00:00
|
|
|
|
2022-05-30 11:09:28 +00:00
|
|
|
static void ieee80211_sdata_init(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
sdata->local = local;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize the default link, so we can use link_id 0 for non-MLD,
|
|
|
|
* and that continues to work for non-MLD-aware drivers that use just
|
|
|
|
* vif.bss_conf instead of vif.link_conf.
|
|
|
|
*
|
|
|
|
* Note that we never change this, so if link ID 0 isn't used in an
|
|
|
|
* MLD connection, we get a separate allocation for it.
|
|
|
|
*/
|
2022-05-31 21:20:08 +00:00
|
|
|
ieee80211_link_init(sdata, -1, &sdata->deflink, &sdata->vif.bss_conf);
|
2022-05-30 11:09:28 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
int ret;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
|
|
|
|
return 0;
|
2013-02-13 15:49:15 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ASSERT_RTNL();
|
2021-11-12 12:51:44 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (local->monitor_sdata)
|
|
|
|
return 0;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
|
|
|
|
if (!sdata)
|
|
|
|
return -ENOMEM;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
/* set up data */
|
|
|
|
sdata->vif.type = NL80211_IFTYPE_MONITOR;
|
|
|
|
snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
|
|
|
|
wiphy_name(local->hw.wiphy));
|
|
|
|
sdata->wdev.iftype = NL80211_IFTYPE_MONITOR;
|
2023-08-28 12:00:07 +00:00
|
|
|
sdata->wdev.wiphy = local->hw.wiphy;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2022-05-30 11:09:28 +00:00
|
|
|
ieee80211_sdata_init(local, sdata);
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_set_default_queues(sdata);
|
2016-09-20 14:31:20 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 15:30:53 +00:00
|
|
|
set_bit(SDATA_STATE_RUNNING, &sdata->state);
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ret = ieee80211_check_queues(sdata, NL80211_IFTYPE_MONITOR);
|
|
|
|
if (ret) {
|
|
|
|
kfree(sdata);
|
|
|
|
return ret;
|
2008-09-10 22:01:59 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
|
|
|
rcu_assign_pointer(local->monitor_sdata, sdata);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
|
2022-06-17 20:36:37 +00:00
|
|
|
ret = ieee80211_link_use_channel(&sdata->deflink, &local->monitor_chandef,
|
2022-05-30 16:35:23 +00:00
|
|
|
IEEE80211_CHANCTX_EXCLUSIVE);
|
2020-09-08 12:37:02 +00:00
|
|
|
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-13 22:33:34 +00:00
|
|
|
}
|
2012-07-12 17:28:31 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
skb_queue_head_init(&sdata->skb_queue);
|
2021-08-23 18:02:39 +00:00
|
|
|
skb_queue_head_init(&sdata->status_queue);
|
2023-06-06 12:49:26 +00:00
|
|
|
wiphy_work_init(&sdata->work, ieee80211_iface_work);
|
2017-06-22 10:20:30 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2015-03-27 20:30:37 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2013-03-27 22:24:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
|
|
|
|
return;
|
2018-10-23 20:36:52 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ASSERT_RTNL();
|
2021-11-12 12:51:44 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
2020-09-08 12:37:02 +00:00
|
|
|
|
|
|
|
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-27 22:24:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
RCU_INIT_POINTER(local->monitor_sdata, NULL);
|
|
|
|
mutex_unlock(&local->iflist_mtx);
|
|
|
|
|
|
|
|
synchronize_net();
|
|
|
|
|
2022-06-17 20:36:37 +00:00
|
|
|
ieee80211_link_release_channel(&sdata->deflink);
|
2020-09-08 12:37:02 +00:00
|
|
|
|
|
|
|
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;
|
2023-06-04 09:11:26 +00:00
|
|
|
u64 changed = 0;
|
2020-09-08 12:37:02 +00:00
|
|
|
int res;
|
|
|
|
u32 hw_reconf_flags = 0;
|
|
|
|
|
2023-08-28 12:00:02 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
|
|
|
|
2013-03-27 22:24:53 +00:00
|
|
|
switch (sdata->vif.type) {
|
2020-09-08 12:37:02 +00:00
|
|
|
case NL80211_IFTYPE_AP_VLAN: {
|
|
|
|
struct ieee80211_sub_if_data *master;
|
|
|
|
|
|
|
|
if (!sdata->bss)
|
|
|
|
return -ENOLINK;
|
2013-03-27 22:24:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
|
2013-05-28 11:01:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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-27 22:24:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
sdata->crypto_tx_tailroom_needed_cnt +=
|
|
|
|
master->crypto_tx_tailroom_needed_cnt;
|
2013-03-27 22:24:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 09:57:46 +00:00
|
|
|
case NL80211_IFTYPE_WDS:
|
2020-09-08 12:37:02 +00:00
|
|
|
/* cannot happen */
|
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
|
|
|
}
|
2014-10-21 18:56:42 +00:00
|
|
|
|
2013-03-27 22:24:53 +00:00
|
|
|
if (local->open_count == 0) {
|
2023-06-04 09:11:28 +00:00
|
|
|
/* here we can consider everything in good order (again) */
|
|
|
|
local->reconfig_failure = false;
|
|
|
|
|
2020-09-08 12:37:02 +00: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-27 22:24:53 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00: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)) {
|
2021-10-19 16:28:15 +00:00
|
|
|
eth_hw_addr_set(dev, local->hw.wiphy->perm_addr);
|
2020-09-08 12:37:02 +00:00
|
|
|
memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
|
2010-08-27 10:35:58 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (!is_valid_ether_addr(dev->dev_addr)) {
|
|
|
|
res = -EADDRNOTAVAIL;
|
|
|
|
goto err_stop;
|
|
|
|
}
|
|
|
|
}
|
2010-08-27 10:35:58 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
/* no need to tell driver, but set carrier and chanctx */
|
2022-05-16 13:00:15 +00:00
|
|
|
if (sdata->bss->active) {
|
2022-06-17 20:36:37 +00:00
|
|
|
ieee80211_link_vlan_copy_chanctx(&sdata->deflink);
|
2020-09-08 12:37:02 +00:00
|
|
|
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-13 22:33:34 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_adjust_monitor_flags(sdata, 1);
|
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
ieee80211_recalc_offload(local);
|
|
|
|
ieee80211_recalc_idle(local);
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
netif_carrier_on(dev);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (coming_up) {
|
|
|
|
ieee80211_del_virtual_monitor(local);
|
|
|
|
ieee80211_set_sdata_offload_flags(sdata);
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
res = drv_add_interface(local, sdata);
|
|
|
|
if (res)
|
|
|
|
goto err_stop;
|
2008-09-10 22:01:59 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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-05 18:45:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP) {
|
|
|
|
local->fif_pspoll++;
|
|
|
|
local->fif_probe_req++;
|
2008-07-09 12:40:35 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
|
|
|
|
local->fif_probe_req++;
|
|
|
|
}
|
2008-09-09 14:33:15 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (sdata->vif.probe_req_reg)
|
|
|
|
drv_config_iface_filter(local, sdata,
|
|
|
|
FIF_PROBE_REQ,
|
|
|
|
FIF_PROBE_REQ);
|
2007-08-28 21:01:55 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_NAN)
|
|
|
|
changed |= ieee80211_reset_erp_info(sdata);
|
2022-06-17 20:36:37 +00:00
|
|
|
ieee80211_link_info_change_notify(sdata, &sdata->deflink,
|
|
|
|
changed);
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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-18 18:07:15 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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.
|
|
|
|
*/
|
2022-06-24 13:40:11 +00:00
|
|
|
ieee80211_set_wmm_default(&sdata->deflink, true,
|
2020-09-08 12:37:02 +00:00
|
|
|
sdata->vif.type != NL80211_IFTYPE_STATION);
|
|
|
|
}
|
2010-01-05 17:00:58 +00:00
|
|
|
|
2020-09-08 12:37:02 +00: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 15:10:38 +00:00
|
|
|
}
|
|
|
|
|
2020-09-08 12:37:02 +00: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 12:35:22 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (coming_up)
|
|
|
|
local->open_count++;
|
2010-01-05 17:00:58 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
if (hw_reconf_flags)
|
|
|
|
ieee80211_hw_config(local, hw_reconf_flags);
|
2010-01-05 17:00:58 +00:00
|
|
|
|
2020-09-08 12:37:02 +00:00
|
|
|
ieee80211_recalc_ps(local);
|
2020-07-23 10:01:53 +00:00
|
|
|
|
2022-09-20 15:55:41 +00:00
|
|
|
set_bit(SDATA_STATE_RUNNING, &sdata->state);
|
|
|
|
|
2020-09-08 12:37:02 +00: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;
|
2023-08-28 12:00:05 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
2020-09-08 12:37:02 +00:00
|
|
|
list_del(&sdata->u.vlan.list);
|
|
|
|
/* might already be clear but that doesn't matter */
|
|
|
|
clear_bit(SDATA_STATE_RUNNING, &sdata->state);
|
|
|
|
return res;
|
|
|
|
}
|
2019-11-25 10:04:37 +00:00
|
|
|
|
2015-04-22 15:10:38 +00:00
|
|
|
static void ieee80211_if_free(struct net_device *dev)
|
|
|
|
{
|
|
|
|
free_percpu(dev->tstats);
|
|
|
|
}
|
|
|
|
|
2009-01-30 12:35:22 +00:00
|
|
|
static void ieee80211_if_setup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
ether_setup(dev);
|
2011-07-26 06:05:38 +00:00
|
|
|
dev->priv_flags &= ~IFF_TX_SKB_SHARING;
|
2022-10-09 16:30:40 +00:00
|
|
|
dev->priv_flags |= IFF_NO_QUEUE;
|
2009-01-30 12:35:22 +00: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-08 16:52:56 +00:00
|
|
|
dev->needs_free_netdev = true;
|
|
|
|
dev->priv_destructor = ieee80211_if_free;
|
2009-01-30 12:35:22 +00:00
|
|
|
}
|
|
|
|
|
2021-05-17 21:07:55 +00: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;
|
|
|
|
|
2023-08-28 12:00:01 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
|
|
|
|
2021-05-17 21:07:55 +00:00
|
|
|
if (ieee80211_is_action(mgmt->frame_control) &&
|
|
|
|
mgmt->u.action.category == WLAN_CATEGORY_BACK) {
|
|
|
|
struct sta_info *sta;
|
|
|
|
int len = skb->len;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} 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;
|
|
|
|
|
|
|
|
sta = sta_info_get_bss(sdata, mgmt->sa);
|
|
|
|
|
|
|
|
if (sta)
|
2022-06-15 07:20:45 +00:00
|
|
|
ieee80211_vht_handle_opmode(sdata,
|
|
|
|
&sta->deflink,
|
2022-05-30 21:22:19 +00:00
|
|
|
opmode, band);
|
2021-05-17 21:07:55 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case WLAN_VHT_ACTION_GROUPID_MGMT:
|
2022-06-17 20:36:37 +00:00
|
|
|
ieee80211_process_mu_groups(sdata, &sdata->deflink,
|
|
|
|
mgmt);
|
2021-05-17 21:07:55 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
|
|
|
}
|
2021-08-23 18:02:39 +00:00
|
|
|
} else if (ieee80211_is_action(mgmt->frame_control) &&
|
|
|
|
mgmt->u.action.category == WLAN_CATEGORY_S1G) {
|
|
|
|
switch (mgmt->u.action.u.s1g.action_code) {
|
|
|
|
case WLAN_S1G_TWT_TEARDOWN:
|
|
|
|
case WLAN_S1G_TWT_SETUP:
|
|
|
|
ieee80211_s1g_rx_twt_action(sdata, skb);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2021-05-17 21:07:55 +00:00
|
|
|
} 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.
|
|
|
|
*/
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
} 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-23 18:02:39 +00:00
|
|
|
static void ieee80211_iface_process_status(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_S1G) {
|
|
|
|
switch (mgmt->u.action.u.s1g.action_code) {
|
|
|
|
case WLAN_S1G_TWT_TEARDOWN:
|
|
|
|
case WLAN_S1G_TWT_SETUP:
|
|
|
|
ieee80211_s1g_status_twt_action(sdata, skb);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-06-06 12:49:26 +00:00
|
|
|
static void ieee80211_iface_work(struct wiphy *wiphy, struct wiphy_work *work)
|
2010-06-10 08:21:32 +00:00
|
|
|
{
|
|
|
|
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-15 19:04:01 +00:00
|
|
|
if (test_bit(SCAN_SW_SCANNING, &local->scanning))
|
2010-06-10 08:21:32 +00:00
|
|
|
return;
|
|
|
|
|
2015-01-22 21:32:46 +00:00
|
|
|
if (!ieee80211_can_run_worker(local))
|
2010-06-10 08:21:32 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* first process frames */
|
|
|
|
while ((skb = skb_dequeue(&sdata->skb_queue))) {
|
2020-10-29 17:36:20 +00:00
|
|
|
kcov_remote_start_common(skb_get_kcov_handle(skb));
|
2010-06-10 08:21:35 +00:00
|
|
|
|
2021-05-17 21:07:56 +00: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 08:21:33 +00:00
|
|
|
|
|
|
|
kfree_skb(skb);
|
2020-10-29 17:36:20 +00:00
|
|
|
kcov_remote_stop();
|
2010-06-10 08:21:32 +00:00
|
|
|
}
|
|
|
|
|
2021-08-23 18:02:39 +00:00
|
|
|
/* process status queue */
|
|
|
|
while ((skb = skb_dequeue(&sdata->status_queue))) {
|
|
|
|
kcov_remote_start_common(skb_get_kcov_handle(skb));
|
|
|
|
|
|
|
|
ieee80211_iface_process_status(sdata, skb);
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
|
|
|
kcov_remote_stop();
|
|
|
|
}
|
|
|
|
|
2010-06-10 08:21:32 +00: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 09:33:19 +00:00
|
|
|
case NL80211_IFTYPE_OCB:
|
|
|
|
ieee80211_ocb_work(sdata);
|
|
|
|
break;
|
2010-06-10 08:21:32 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-08-28 11:59:43 +00:00
|
|
|
static void ieee80211_activate_links_work(struct wiphy *wiphy,
|
|
|
|
struct wiphy_work *work)
|
2022-09-02 14:12:56 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata =
|
|
|
|
container_of(work, struct ieee80211_sub_if_data,
|
|
|
|
activate_links_work);
|
|
|
|
|
|
|
|
ieee80211_set_active_links(&sdata->vif, sdata->desired_active_links);
|
|
|
|
}
|
|
|
|
|
2008-07-09 12:40:35 +00:00
|
|
|
/*
|
|
|
|
* Helper function to initialise an interface to a specific type.
|
|
|
|
*/
|
|
|
|
static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
|
2008-09-10 22:01:58 +00:00
|
|
|
enum nl80211_iftype type)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
2014-11-03 09:33:19 +00:00
|
|
|
static const u8 bssid_wildcard[ETH_ALEN] = {0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff};
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
/* clear type-dependent unions */
|
2008-07-09 12:40:35 +00:00
|
|
|
memset(&sdata->u, 0, sizeof(sdata->u));
|
2022-05-16 13:00:15 +00:00
|
|
|
memset(&sdata->deflink.u, 0, sizeof(sdata->deflink.u));
|
2008-07-09 12:40:35 +00:00
|
|
|
|
|
|
|
/* and set some type-dependent values */
|
|
|
|
sdata->vif.type = type;
|
2010-09-16 12:58:23 +00:00
|
|
|
sdata->vif.p2p = false;
|
2008-09-16 12:55:09 +00:00
|
|
|
sdata->wdev.iftype = type;
|
2008-07-09 12:40:35 +00:00
|
|
|
|
2010-08-27 11:26:54 +00:00
|
|
|
sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
|
|
|
|
sdata->control_port_no_encrypt = false;
|
2020-03-12 09:10:54 +00:00
|
|
|
sdata->control_port_over_nl80211 = false;
|
|
|
|
sdata->control_port_no_preauth = false;
|
wifi: mac80211: move interface config to new struct
We'll use bss_conf for per-link configuration later, so
move out all the non-link-specific data out into a new
struct ieee80211_vif_cfg used in the vif.
Some adjustments were done with the following spatch:
@@
expression sdata;
struct ieee80211_vif *vifp;
identifier var = { assoc, ibss_joined, aid, arp_addr_list, arp_addr_cnt, ssid, ssid_len, s1g, ibss_creator };
@@
(
-sdata->vif.bss_conf.var
+sdata->vif.cfg.var
|
-vifp->bss_conf.var
+vifp->cfg.var
)
@bss_conf@
struct ieee80211_bss_conf *bss_conf;
identifier var = { assoc, ibss_joined, aid, arp_addr_list, arp_addr_cnt, ssid, ssid_len, s1g, ibss_creator };
@@
-bss_conf->var
+vif_cfg->var
(though more manual fixups were needed, e.g. replacing
"vif_cfg->" by "vif->cfg." in many files.)
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-05-10 15:05:04 +00:00
|
|
|
sdata->vif.cfg.idle = true;
|
2019-12-17 18:30:57 +00:00
|
|
|
sdata->vif.bss_conf.txpower = INT_MIN; /* unset */
|
2010-08-27 11:26:54 +00:00
|
|
|
|
2011-11-18 13:20:44 +00:00
|
|
|
sdata->noack_map = 0;
|
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
/* only monitor/p2p-device differ */
|
|
|
|
if (sdata->dev) {
|
|
|
|
sdata->dev->netdev_ops = &ieee80211_dataif_ops;
|
|
|
|
sdata->dev->type = ARPHRD_ETHER;
|
|
|
|
}
|
2008-07-09 12:40:35 +00:00
|
|
|
|
2010-06-10 08:21:30 +00:00
|
|
|
skb_queue_head_init(&sdata->skb_queue);
|
2021-08-23 18:02:39 +00:00
|
|
|
skb_queue_head_init(&sdata->status_queue);
|
2023-06-06 12:49:26 +00:00
|
|
|
wiphy_work_init(&sdata->work, ieee80211_iface_work);
|
2023-08-28 11:59:43 +00:00
|
|
|
wiphy_work_init(&sdata->activate_links_work,
|
|
|
|
ieee80211_activate_links_work);
|
2010-06-10 08:21:30 +00:00
|
|
|
|
2008-07-09 12:40:35 +00:00
|
|
|
switch (type) {
|
2010-09-16 12:58:23 +00:00
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
|
|
|
type = NL80211_IFTYPE_AP;
|
|
|
|
sdata->vif.type = type;
|
|
|
|
sdata->vif.p2p = true;
|
2020-07-07 20:45:48 +00:00
|
|
|
fallthrough;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_AP:
|
2012-10-10 19:39:50 +00:00
|
|
|
skb_queue_head_init(&sdata->u.ap.ps.bc_buf);
|
2008-07-09 12:40:35 +00:00
|
|
|
INIT_LIST_HEAD(&sdata->u.ap.vlans);
|
2012-12-14 13:34:25 +00:00
|
|
|
sdata->vif.bss_conf.bssid = sdata->vif.addr;
|
2008-07-09 12:40:35 +00:00
|
|
|
break;
|
2010-09-16 12:58:23 +00:00
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
type = NL80211_IFTYPE_STATION;
|
|
|
|
sdata->vif.type = type;
|
|
|
|
sdata->vif.p2p = true;
|
2020-07-07 20:45:48 +00:00
|
|
|
fallthrough;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_STATION:
|
2022-05-16 13:00:15 +00:00
|
|
|
sdata->vif.bss_conf.bssid = sdata->deflink.u.mgd.bssid;
|
2008-09-10 22:01:52 +00:00
|
|
|
ieee80211_sta_setup_sdata(sdata);
|
2008-09-10 22:01:49 +00:00
|
|
|
break;
|
2014-11-03 09:33:18 +00:00
|
|
|
case NL80211_IFTYPE_OCB:
|
2014-11-03 09:33:19 +00:00
|
|
|
sdata->vif.bss_conf.bssid = bssid_wildcard;
|
|
|
|
ieee80211_ocb_setup_sdata(sdata);
|
2014-11-03 09:33:18 +00:00
|
|
|
break;
|
2009-02-15 11:44:28 +00:00
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2012-12-14 13:34:25 +00:00
|
|
|
sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
|
2009-02-15 11:44:28 +00:00
|
|
|
ieee80211_ibss_setup_sdata(sdata);
|
|
|
|
break;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
2008-07-09 12:40:35 +00:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif))
|
|
|
|
ieee80211_mesh_init_sdata(sdata);
|
|
|
|
break;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_MONITOR:
|
2008-07-09 12:40:35 +00:00
|
|
|
sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
|
2009-01-30 12:35:22 +00:00
|
|
|
sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
|
2016-08-29 20:25:15 +00:00
|
|
|
sdata->u.mntr.flags = MONITOR_FLAG_CONTROL |
|
2008-07-09 12:40:35 +00:00
|
|
|
MONITOR_FLAG_OTHER_BSS;
|
|
|
|
break;
|
2016-09-20 14:31:20 +00: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-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2012-06-15 22:19:54 +00:00
|
|
|
case NL80211_IFTYPE_P2P_DEVICE:
|
2012-12-14 13:34:25 +00:00
|
|
|
sdata->vif.bss_conf.bssid = sdata->vif.addr;
|
2012-06-18 18:07:15 +00:00
|
|
|
break;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_UNSPECIFIED:
|
2020-11-09 09:57:46 +00:00
|
|
|
case NL80211_IFTYPE_WDS:
|
2010-08-12 13:38:38 +00:00
|
|
|
case NUM_NL80211_IFTYPES:
|
2017-10-29 09:51:10 +00:00
|
|
|
WARN_ON(1);
|
2008-07-09 12:40:35 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-06-24 08:57:41 +00:00
|
|
|
/* need to do this after the switch so vif.type is correct */
|
|
|
|
ieee80211_link_setup(&sdata->deflink);
|
|
|
|
|
2023-09-28 14:35:26 +00:00
|
|
|
ieee80211_debugfs_add_netdev(sdata, false);
|
2008-07-09 12:40:35 +00:00
|
|
|
}
|
|
|
|
|
2010-08-27 10:35:58 +00: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 12:58:23 +00:00
|
|
|
enum nl80211_iftype internal_type = type;
|
|
|
|
bool p2p = false;
|
2010-08-27 10:35:58 +00:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if (!local->ops->change_interface)
|
|
|
|
return -EBUSY;
|
|
|
|
|
2022-05-31 21:20:08 +00:00
|
|
|
/* for now, don't support changing while links exist */
|
2023-06-08 13:36:08 +00:00
|
|
|
if (ieee80211_vif_is_mld(&sdata->vif))
|
2022-05-31 21:20:08 +00:00
|
|
|
return -EBUSY;
|
|
|
|
|
2010-08-27 10:35:58 +00:00
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_AP:
|
2021-05-17 14:03:23 +00:00
|
|
|
if (!list_empty(&sdata->u.ap.vlans))
|
|
|
|
return -EBUSY;
|
|
|
|
break;
|
2010-08-27 10:35:58 +00:00
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2014-11-03 09:33:19 +00:00
|
|
|
case NL80211_IFTYPE_OCB:
|
2010-08-27 10:35:58 +00: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 09:33:19 +00:00
|
|
|
case NL80211_IFTYPE_OCB:
|
2010-08-27 10:35:58 +00:00
|
|
|
/*
|
|
|
|
* Could probably support everything
|
2020-11-09 09:57:46 +00:00
|
|
|
* but here.
|
2010-08-27 10:35:58 +00:00
|
|
|
*/
|
|
|
|
break;
|
2010-09-16 12:58:23 +00: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 10:35:58 +00:00
|
|
|
default:
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2010-09-16 12:58:23 +00:00
|
|
|
ret = ieee80211_check_concurrent_iface(sdata, internal_type);
|
2010-08-27 10:35:58 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2021-01-22 16:11:16 +00:00
|
|
|
ieee80211_stop_vif_queues(local, sdata,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE);
|
2022-11-02 08:47:47 +00:00
|
|
|
/* do_stop will synchronize_rcu() first thing */
|
2010-08-27 10:35:58 +00:00
|
|
|
ieee80211_do_stop(sdata, false);
|
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
ieee80211_teardown_sdata(sdata);
|
2010-08-27 10:35:58 +00:00
|
|
|
|
2020-09-08 12:36:53 +00:00
|
|
|
ieee80211_set_sdata_offload_flags(sdata);
|
2010-09-16 12:58:23 +00:00
|
|
|
ret = drv_change_interface(local, sdata, internal_type, p2p);
|
2010-08-27 10:35:58 +00:00
|
|
|
if (ret)
|
2013-08-26 07:30:32 +00:00
|
|
|
type = ieee80211_vif_type_p2p(&sdata->vif);
|
2010-08-27 10:35:58 +00:00
|
|
|
|
2012-04-03 14:28:50 +00: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 07:30:32 +00:00
|
|
|
ieee80211_check_queues(sdata, type);
|
2012-04-03 14:28:50 +00:00
|
|
|
|
2010-08-27 10:35:58 +00:00
|
|
|
ieee80211_setup_sdata(sdata, type);
|
2020-09-08 12:36:53 +00:00
|
|
|
ieee80211_set_vif_encap_ops(sdata);
|
2010-08-27 10:35:58 +00:00
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
err = ieee80211_do_open(&sdata->wdev, false);
|
2010-08-27 10:35:58 +00:00
|
|
|
WARN(err, "type change: do_open returned %d", err);
|
|
|
|
|
2021-01-22 16:11:16 +00:00
|
|
|
ieee80211_wake_vif_queues(local, sdata,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE);
|
2010-08-27 10:35:58 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-09 12:40:36 +00:00
|
|
|
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
|
2008-09-10 22:01:58 +00:00
|
|
|
enum nl80211_iftype type)
|
2008-07-09 12:40:35 +00:00
|
|
|
{
|
2010-08-27 10:35:58 +00:00
|
|
|
int ret;
|
|
|
|
|
2008-07-09 12:40:36 +00:00
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2010-09-16 12:58:23 +00:00
|
|
|
if (type == ieee80211_vif_type_p2p(&sdata->vif))
|
2008-07-09 12:40:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-08-27 10:35:58 +00: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-18 18:07:15 +00:00
|
|
|
ieee80211_teardown_sdata(sdata);
|
2010-08-27 10:35:58 +00:00
|
|
|
ieee80211_setup_sdata(sdata, type);
|
|
|
|
}
|
2008-07-09 12:40:35 +00:00
|
|
|
|
|
|
|
/* reset some values that shouldn't be kept across type changes */
|
2009-11-19 10:55:19 +00:00
|
|
|
if (type == NL80211_IFTYPE_STATION)
|
|
|
|
sdata->u.mgd.use_4addr = false;
|
2008-07-09 12:40:36 +00:00
|
|
|
|
|
|
|
return 0;
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
2010-02-25 14:13:11 +00:00
|
|
|
static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
|
2012-06-18 18:07:15 +00:00
|
|
|
u8 *perm_addr, enum nl80211_iftype type)
|
2010-02-25 14:13:11 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
u64 mask, start, addr, val, inc;
|
|
|
|
u8 *m;
|
|
|
|
u8 tmp_addr[ETH_ALEN];
|
|
|
|
int i;
|
|
|
|
|
2023-08-28 12:00:06 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
|
|
|
|
2010-02-25 14:13:11 +00:00
|
|
|
/* default ... something at least */
|
2012-06-18 18:07:15 +00:00
|
|
|
memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
|
2010-02-25 14:13:11 +00:00
|
|
|
|
|
|
|
if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
|
|
|
|
local->hw.wiphy->n_addresses <= 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
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-18 18:07:15 +00:00
|
|
|
memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
|
2010-02-25 14:13:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* keep default if no AP interface present */
|
|
|
|
break;
|
2012-06-19 15:19:44 +00:00
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
2015-06-02 19:39:54 +00:00
|
|
|
if (ieee80211_hw_check(&local->hw, P2P_DEV_ADDR_FOR_INTF)) {
|
2012-06-19 15:19:44 +00: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);
|
2023-08-28 12:00:06 +00:00
|
|
|
return;
|
2012-06-19 15:19:44 +00:00
|
|
|
}
|
|
|
|
}
|
2020-07-07 20:45:48 +00:00
|
|
|
fallthrough;
|
2010-02-25 14:13:11 +00: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 11:40:56 +00:00
|
|
|
if (ether_addr_equal(local->hw.wiphy->addresses[i].addr,
|
|
|
|
sdata->vif.addr)) {
|
2010-02-25 14:13:11 +00:00
|
|
|
used = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!used) {
|
2012-06-18 18:07:15 +00:00
|
|
|
memcpy(perm_addr,
|
2010-02-25 14:13:11 +00: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 09:29:50 +00:00
|
|
|
pr_info("not contiguous\n");
|
2010-02-25 14:13:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-05-27 08:43:09 +00:00
|
|
|
/*
|
|
|
|
* Pick address of existing interface in case user changed
|
|
|
|
* MAC address manually, default to perm_addr.
|
|
|
|
*/
|
2010-02-25 14:13:11 +00:00
|
|
|
m = local->hw.wiphy->perm_addr;
|
2013-05-27 08:43:09 +00: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 14:13:11 +00: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 11:40:56 +00:00
|
|
|
if (ether_addr_equal(tmp_addr, sdata->vif.addr)) {
|
2010-02-25 14:13:11 +00:00
|
|
|
used = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!used) {
|
2012-06-18 18:07:15 +00:00
|
|
|
memcpy(perm_addr, tmp_addr, ETH_ALEN);
|
2010-02-25 14:13:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
addr = (start & ~mask) | (val & mask);
|
|
|
|
} while (addr != start);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 12:40:34 +00:00
|
|
|
int ieee80211_if_add(struct ieee80211_local *local, const char *name,
|
2015-03-18 10:13:39 +00:00
|
|
|
unsigned char name_assign_type,
|
2012-06-15 22:00:26 +00:00
|
|
|
struct wireless_dev **new_wdev, enum nl80211_iftype type,
|
2008-02-23 14:17:11 +00:00
|
|
|
struct vif_params *params)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
2012-06-18 18:07:15 +00:00
|
|
|
struct net_device *ndev = NULL;
|
2007-05-05 18:45:53 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata = NULL;
|
2015-03-27 20:30:37 +00:00
|
|
|
struct txq_info *txqi;
|
2008-07-09 12:40:35 +00:00
|
|
|
int ret, i;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
2023-08-28 12:00:06 +00:00
|
|
|
lockdep_assert_wiphy(local->hw.wiphy);
|
2008-07-09 12:40:35 +00:00
|
|
|
|
2016-09-20 14:31:14 +00:00
|
|
|
if (type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN) {
|
2012-06-18 18:07:15 +00: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;
|
2022-08-18 21:02:23 +00:00
|
|
|
strscpy(sdata->name, name, IFNAMSIZ);
|
2012-06-18 18:07:15 +00:00
|
|
|
ieee80211_assign_perm_addr(local, wdev->address, type);
|
|
|
|
memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);
|
2022-05-31 21:20:08 +00:00
|
|
|
ether_addr_copy(sdata->vif.bss_conf.addr, sdata->vif.addr);
|
2012-06-18 18:07:15 +00:00
|
|
|
} else {
|
2015-03-27 20:30:37 +00:00
|
|
|
int size = ALIGN(sizeof(*sdata) + local->hw.vif_data_size,
|
|
|
|
sizeof(void *));
|
|
|
|
int txq_size = 0;
|
|
|
|
|
2022-10-09 16:30:40 +00:00
|
|
|
if (type != NL80211_IFTYPE_AP_VLAN &&
|
2018-09-22 16:35:31 +00:00
|
|
|
(type != NL80211_IFTYPE_MONITOR ||
|
|
|
|
(params->flags & MONITOR_FLAG_ACTIVE)))
|
2015-03-27 20:30:37 +00:00
|
|
|
txq_size += sizeof(struct txq_info) +
|
|
|
|
local->hw.txq_data_size;
|
|
|
|
|
|
|
|
ndev = alloc_netdev_mqs(size + txq_size,
|
2015-03-18 10:13:39 +00:00
|
|
|
name, name_assign_type,
|
2022-10-09 16:30:40 +00:00
|
|
|
ieee80211_if_setup, 1, 1);
|
2012-06-18 18:07:15 +00:00
|
|
|
if (!ndev)
|
|
|
|
return -ENOMEM;
|
2020-02-11 12:26:04 +00:00
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
dev_net_set(ndev, wiphy_net(local->hw.wiphy));
|
|
|
|
|
2015-04-22 15:10:38 +00:00
|
|
|
ndev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
|
|
|
|
if (!ndev->tstats) {
|
|
|
|
free_netdev(ndev);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2012-06-18 18:07:15 +00: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 11:47:08 +00:00
|
|
|
ieee80211_if_free(ndev);
|
2017-06-09 19:33:09 +00:00
|
|
|
free_netdev(ndev);
|
2012-06-18 18:07:15 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_assign_perm_addr(local, ndev->perm_addr, type);
|
2018-12-15 09:03:11 +00:00
|
|
|
if (is_valid_ether_addr(params->macaddr))
|
2021-10-19 16:28:15 +00:00
|
|
|
eth_hw_addr_set(ndev, params->macaddr);
|
2014-10-22 19:23:06 +00:00
|
|
|
else
|
2021-10-19 16:28:15 +00:00
|
|
|
eth_hw_addr_set(ndev, ndev->perm_addr);
|
2012-06-18 18:07:15 +00: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);
|
2022-05-31 21:20:08 +00:00
|
|
|
ether_addr_copy(sdata->vif.bss_conf.addr, sdata->vif.addr);
|
2012-06-18 18:07:15 +00:00
|
|
|
memcpy(sdata->name, ndev->name, IFNAMSIZ);
|
|
|
|
|
2015-03-27 20:30:37 +00:00
|
|
|
if (txq_size) {
|
|
|
|
txqi = netdev_priv(ndev) + size;
|
2016-05-19 08:37:49 +00:00
|
|
|
ieee80211_txq_init(sdata, NULL, txqi, 0);
|
2015-03-27 20:30:37 +00:00
|
|
|
}
|
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
sdata->dev = ndev;
|
|
|
|
}
|
2008-07-09 12:40:35 +00:00
|
|
|
|
|
|
|
/* initialise type-independent data */
|
2007-05-05 18:45:53 +00:00
|
|
|
sdata->wdev.wiphy = local->hw.wiphy;
|
2022-05-30 11:09:28 +00:00
|
|
|
|
|
|
|
ieee80211_sdata_init(local, sdata);
|
2008-07-09 12:40:35 +00:00
|
|
|
|
2021-05-11 18:02:47 +00:00
|
|
|
ieee80211_init_frag_cache(&sdata->frags);
|
2008-07-09 12:40:35 +00:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&sdata->key_list);
|
|
|
|
|
2023-08-28 11:59:47 +00:00
|
|
|
wiphy_delayed_work_init(&sdata->dec_tailroom_needed_wk,
|
|
|
|
ieee80211_delayed_tailroom_dec);
|
2012-12-13 21:54:58 +00:00
|
|
|
|
2016-04-12 13:56:15 +00:00
|
|
|
for (i = 0; i < NUM_NL80211_BANDS; i++) {
|
2010-01-06 11:09:08 +00: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-06 21:47:33 +00:00
|
|
|
if (sband) {
|
|
|
|
__le16 cap;
|
|
|
|
u16 *vht_rate_mask;
|
|
|
|
|
2012-01-28 16:25:33 +00:00
|
|
|
memcpy(sdata->rc_rateidx_mcs_mask[i],
|
|
|
|
sband->ht_cap.mcs.rx_mask,
|
|
|
|
sizeof(sdata->rc_rateidx_mcs_mask[i]));
|
2015-08-06 21:47:33 +00: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-28 16:25:33 +00:00
|
|
|
memset(sdata->rc_rateidx_mcs_mask[i], 0,
|
|
|
|
sizeof(sdata->rc_rateidx_mcs_mask[i]));
|
2015-08-06 21:47:33 +00:00
|
|
|
memset(sdata->rc_rateidx_vht_mcs_mask[i], 0,
|
|
|
|
sizeof(sdata->rc_rateidx_vht_mcs_mask[i]));
|
|
|
|
}
|
2010-01-06 11:09:08 +00:00
|
|
|
}
|
2008-07-09 12:40:35 +00:00
|
|
|
|
2012-04-03 14:28:50 +00:00
|
|
|
ieee80211_set_default_queues(sdata);
|
|
|
|
|
2022-05-16 13:00:15 +00:00
|
|
|
sdata->deflink.ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
|
|
|
|
sdata->deflink.user_power_level = local->user_power_level;
|
2012-10-24 08:59:25 +00:00
|
|
|
|
2008-07-09 12:40:35 +00:00
|
|
|
/* setup type-dependent data */
|
|
|
|
ieee80211_setup_sdata(sdata, type);
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
if (ndev) {
|
2018-12-15 09:03:11 +00: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 10:55:19 +00:00
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
ndev->features |= local->hw.netdev_features;
|
2022-08-26 17:00:32 +00:00
|
|
|
ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
|
2020-01-31 11:12:46 +00:00
|
|
|
ndev->hw_features |= ndev->features &
|
|
|
|
MAC80211_SUPPORTED_FEATURES_TX;
|
2022-10-10 09:43:38 +00:00
|
|
|
sdata->vif.netdev_features = local->hw.netdev_features;
|
2012-05-10 13:18:26 +00:00
|
|
|
|
2014-06-04 15:31:56 +00:00
|
|
|
netdev_set_default_ethtool_ops(ndev, &ieee80211_ethtool_ops);
|
|
|
|
|
2021-06-28 12:32:46 +00: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-20 17:55:18 +00:00
|
|
|
ndev->min_mtu = 256;
|
2021-06-28 12:32:46 +00:00
|
|
|
if (type == NL80211_IFTYPE_MONITOR)
|
|
|
|
ndev->max_mtu = 0;
|
|
|
|
else
|
|
|
|
ndev->max_mtu = local->hw.max_mtu;
|
2016-10-20 17:55:18 +00:00
|
|
|
|
2021-01-22 15:19:42 +00:00
|
|
|
ret = cfg80211_register_netdevice(ndev);
|
2012-06-18 18:07:15 +00: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-08 16:52:56 +00:00
|
|
|
free_netdev(ndev);
|
2012-06-18 18:07:15 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2009-01-23 21:54:03 +00:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
2007-09-18 21:29:21 +00:00
|
|
|
list_add_tail_rcu(&sdata->list, &local->interfaces);
|
2009-01-23 21:54:03 +00:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2007-09-18 21:29:21 +00:00
|
|
|
|
2012-06-15 22:00:26 +00:00
|
|
|
if (new_wdev)
|
|
|
|
*new_wdev = &sdata->wdev;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-03 00:04:37 +00:00
|
|
|
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
|
|
|
ASSERT_RTNL();
|
2023-08-28 12:00:06 +00:00
|
|
|
lockdep_assert_wiphy(sdata->local->hw.wiphy);
|
2007-08-28 21:01:55 +00:00
|
|
|
|
2009-01-23 21:54:03 +00:00
|
|
|
mutex_lock(&sdata->local->iflist_mtx);
|
2008-07-09 12:40:35 +00:00
|
|
|
list_del_rcu(&sdata->list);
|
2009-01-23 21:54:03 +00:00
|
|
|
mutex_unlock(&sdata->local->iflist_mtx);
|
|
|
|
|
2019-04-16 07:24:40 +00:00
|
|
|
if (sdata->vif.txq)
|
|
|
|
ieee80211_txq_purge(sdata->local, to_txq_info(sdata->vif.txq));
|
|
|
|
|
2008-07-09 12:40:35 +00:00
|
|
|
synchronize_rcu();
|
2012-06-18 18:07:15 +00:00
|
|
|
|
2021-01-22 15:19:42 +00:00
|
|
|
cfg80211_unregister_wdev(&sdata->wdev);
|
|
|
|
|
|
|
|
if (!sdata->dev) {
|
2015-11-17 08:24:40 +00:00
|
|
|
ieee80211_teardown_sdata(sdata);
|
2012-06-18 18:07:15 +00: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-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
2008-07-09 12:40:35 +00:00
|
|
|
void ieee80211_remove_interfaces(struct ieee80211_local *local)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
2008-07-09 12:40:35 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata, *tmp;
|
2009-11-05 10:06:40 +00:00
|
|
|
LIST_HEAD(unreg_list);
|
2007-05-05 18:45:53 +00: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 12:41:50 +00: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-23 23:06:09 +00: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 12:41:50 +00:00
|
|
|
cfg80211_shutdown_all_interfaces(local->hw.wiphy);
|
|
|
|
|
2023-08-28 11:59:59 +00:00
|
|
|
wiphy_lock(local->hw.wiphy);
|
|
|
|
|
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 12:41:50 +00:00
|
|
|
WARN(local->open_count, "%s: open count remains %d\n",
|
|
|
|
wiphy_name(local->hw.wiphy), local->open_count);
|
2013-05-23 23:06:09 +00:00
|
|
|
|
2009-11-05 10:06:40 +00:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
2023-06-06 12:49:27 +00:00
|
|
|
list_splice_init(&local->interfaces, &unreg_list);
|
2009-11-05 10:06:40 +00:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2021-01-22 15:19:43 +00:00
|
|
|
|
2023-06-06 12:49:27 +00:00
|
|
|
list_for_each_entry_safe(sdata, tmp, &unreg_list, list) {
|
|
|
|
bool netdev = sdata->dev;
|
|
|
|
|
2023-08-28 11:59:41 +00:00
|
|
|
/*
|
|
|
|
* Remove IP addresses explicitly, since the notifier will
|
|
|
|
* skip the callbacks if wdev->registered is false, since
|
|
|
|
* we can't acquire the wiphy_lock() again there if already
|
|
|
|
* inside this locked section.
|
|
|
|
*/
|
|
|
|
sdata->vif.cfg.arp_addr_cnt = 0;
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION &&
|
|
|
|
sdata->u.mgd.associated)
|
|
|
|
ieee80211_vif_cfg_change_notify(sdata,
|
|
|
|
BSS_CHANGED_ARP_FILTER);
|
|
|
|
|
2012-06-18 18:07:15 +00:00
|
|
|
list_del(&sdata->list);
|
|
|
|
cfg80211_unregister_wdev(&sdata->wdev);
|
2023-06-06 12:49:27 +00:00
|
|
|
|
|
|
|
if (!netdev)
|
|
|
|
kfree(sdata);
|
2012-06-18 18:07:15 +00:00
|
|
|
}
|
2021-01-22 15:19:43 +00:00
|
|
|
wiphy_unlock(local->hw.wiphy);
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
2009-04-29 10:26:17 +00:00
|
|
|
|
2009-11-25 16:46:19 +00:00
|
|
|
static int netdev_notify(struct notifier_block *nb,
|
2013-05-28 01:30:21 +00:00
|
|
|
unsigned long state, void *ptr)
|
2009-11-25 16:46:19 +00:00
|
|
|
{
|
2013-05-28 01:30:21 +00:00
|
|
|
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
|
2009-11-25 16:46:19 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
|
|
|
if (state != NETDEV_CHANGENAME)
|
2014-04-21 04:53:05 +00:00
|
|
|
return NOTIFY_DONE;
|
2009-11-25 16:46:19 +00:00
|
|
|
|
|
|
|
if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
|
2014-04-21 04:53:05 +00:00
|
|
|
return NOTIFY_DONE;
|
2009-11-25 16:46:19 +00:00
|
|
|
|
|
|
|
if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
|
2014-04-21 04:53:05 +00:00
|
|
|
return NOTIFY_DONE;
|
2009-11-25 16:46:19 +00:00
|
|
|
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2010-02-12 09:45:05 +00:00
|
|
|
memcpy(sdata->name, dev->name, IFNAMSIZ);
|
2009-11-25 16:46:19 +00:00
|
|
|
ieee80211_debugfs_rename_netdev(sdata);
|
2014-04-21 04:53:05 +00:00
|
|
|
|
|
|
|
return NOTIFY_OK;
|
2009-11-25 16:46:19 +00: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-10 17:12:21 +00: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);
|
|
|
|
}
|