cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

iface.c (60972B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * Interface handling
      4 *
      5 * Copyright 2002-2005, Instant802 Networks, Inc.
      6 * Copyright 2005-2006, Devicescape Software, Inc.
      7 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
      8 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
      9 * Copyright 2013-2014  Intel Mobile Communications GmbH
     10 * Copyright (c) 2016        Intel Deutschland GmbH
     11 * Copyright (C) 2018-2021 Intel Corporation
     12 */
     13#include <linux/slab.h>
     14#include <linux/kernel.h>
     15#include <linux/if_arp.h>
     16#include <linux/netdevice.h>
     17#include <linux/rtnetlink.h>
     18#include <linux/kcov.h>
     19#include <net/mac80211.h>
     20#include <net/ieee80211_radiotap.h>
     21#include "ieee80211_i.h"
     22#include "sta_info.h"
     23#include "debugfs_netdev.h"
     24#include "mesh.h"
     25#include "led.h"
     26#include "driver-ops.h"
     27#include "wme.h"
     28#include "rate.h"
     29
     30/**
     31 * DOC: Interface list locking
     32 *
     33 * The interface list in each struct ieee80211_local is protected
     34 * three-fold:
     35 *
     36 * (1) modifications may only be done under the RTNL
     37 * (2) modifications and readers are protected against each other by
     38 *     the iflist_mtx.
     39 * (3) modifications are done in an RCU manner so atomic readers
     40 *     can traverse the list in RCU-safe blocks.
     41 *
     42 * As a consequence, reads (traversals) of the list can be protected
     43 * by either the RTNL, the iflist_mtx or RCU.
     44 */
     45
     46static void ieee80211_iface_work(struct work_struct *work);
     47
     48bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
     49{
     50	struct ieee80211_chanctx_conf *chanctx_conf;
     51	int power;
     52
     53	rcu_read_lock();
     54	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
     55	if (!chanctx_conf) {
     56		rcu_read_unlock();
     57		return false;
     58	}
     59
     60	power = ieee80211_chandef_max_power(&chanctx_conf->def);
     61	rcu_read_unlock();
     62
     63	if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL)
     64		power = min(power, sdata->user_power_level);
     65
     66	if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL)
     67		power = min(power, sdata->ap_power_level);
     68
     69	if (power != sdata->vif.bss_conf.txpower) {
     70		sdata->vif.bss_conf.txpower = power;
     71		ieee80211_hw_config(sdata->local, 0);
     72		return true;
     73	}
     74
     75	return false;
     76}
     77
     78void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata,
     79			      bool update_bss)
     80{
     81	if (__ieee80211_recalc_txpower(sdata) ||
     82	    (update_bss && ieee80211_sdata_running(sdata)))
     83		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);
     84}
     85
     86static u32 __ieee80211_idle_off(struct ieee80211_local *local)
     87{
     88	if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
     89		return 0;
     90
     91	local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
     92	return IEEE80211_CONF_CHANGE_IDLE;
     93}
     94
     95static u32 __ieee80211_idle_on(struct ieee80211_local *local)
     96{
     97	if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
     98		return 0;
     99
    100	ieee80211_flush_queues(local, NULL, false);
    101
    102	local->hw.conf.flags |= IEEE80211_CONF_IDLE;
    103	return IEEE80211_CONF_CHANGE_IDLE;
    104}
    105
    106static u32 __ieee80211_recalc_idle(struct ieee80211_local *local,
    107				   bool force_active)
    108{
    109	bool working, scanning, active;
    110	unsigned int led_trig_start = 0, led_trig_stop = 0;
    111
    112	lockdep_assert_held(&local->mtx);
    113
    114	active = force_active ||
    115		 !list_empty(&local->chanctx_list) ||
    116		 local->monitors;
    117
    118	working = !local->ops->remain_on_channel &&
    119		  !list_empty(&local->roc_list);
    120
    121	scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
    122		   test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
    123
    124	if (working || scanning)
    125		led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
    126	else
    127		led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
    128
    129	if (active)
    130		led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
    131	else
    132		led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
    133
    134	ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);
    135
    136	if (working || scanning || active)
    137		return __ieee80211_idle_off(local);
    138	return __ieee80211_idle_on(local);
    139}
    140
    141u32 ieee80211_idle_off(struct ieee80211_local *local)
    142{
    143	return __ieee80211_recalc_idle(local, true);
    144}
    145
    146void ieee80211_recalc_idle(struct ieee80211_local *local)
    147{
    148	u32 change = __ieee80211_recalc_idle(local, false);
    149	if (change)
    150		ieee80211_hw_config(local, change);
    151}
    152
    153static int ieee80211_verify_mac(struct ieee80211_sub_if_data *sdata, u8 *addr,
    154				bool check_dup)
    155{
    156	struct ieee80211_local *local = sdata->local;
    157	struct ieee80211_sub_if_data *iter;
    158	u64 new, mask, tmp;
    159	u8 *m;
    160	int ret = 0;
    161
    162	if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
    163		return 0;
    164
    165	m = addr;
    166	new =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
    167		((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
    168		((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
    169
    170	m = local->hw.wiphy->addr_mask;
    171	mask =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
    172		((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
    173		((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
    174
    175	if (!check_dup)
    176		return ret;
    177
    178	mutex_lock(&local->iflist_mtx);
    179	list_for_each_entry(iter, &local->interfaces, list) {
    180		if (iter == sdata)
    181			continue;
    182
    183		if (iter->vif.type == NL80211_IFTYPE_MONITOR &&
    184		    !(iter->u.mntr.flags & MONITOR_FLAG_ACTIVE))
    185			continue;
    186
    187		m = iter->vif.addr;
    188		tmp =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
    189			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
    190			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
    191
    192		if ((new & ~mask) != (tmp & ~mask)) {
    193			ret = -EINVAL;
    194			break;
    195		}
    196	}
    197	mutex_unlock(&local->iflist_mtx);
    198
    199	return ret;
    200}
    201
    202static int ieee80211_change_mac(struct net_device *dev, void *addr)
    203{
    204	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
    205	struct sockaddr *sa = addr;
    206	bool check_dup = true;
    207	int ret;
    208
    209	if (ieee80211_sdata_running(sdata))
    210		return -EBUSY;
    211
    212	if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
    213	    !(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
    214		check_dup = false;
    215
    216	ret = ieee80211_verify_mac(sdata, sa->sa_data, check_dup);
    217	if (ret)
    218		return ret;
    219
    220	ret = eth_mac_addr(dev, sa);
    221
    222	if (ret == 0)
    223		memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
    224
    225	return ret;
    226}
    227
    228static inline int identical_mac_addr_allowed(int type1, int type2)
    229{
    230	return type1 == NL80211_IFTYPE_MONITOR ||
    231		type2 == NL80211_IFTYPE_MONITOR ||
    232		type1 == NL80211_IFTYPE_P2P_DEVICE ||
    233		type2 == NL80211_IFTYPE_P2P_DEVICE ||
    234		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
    235		(type1 == NL80211_IFTYPE_AP_VLAN &&
    236			(type2 == NL80211_IFTYPE_AP ||
    237			 type2 == NL80211_IFTYPE_AP_VLAN));
    238}
    239
    240static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
    241					    enum nl80211_iftype iftype)
    242{
    243	struct ieee80211_local *local = sdata->local;
    244	struct ieee80211_sub_if_data *nsdata;
    245	int ret;
    246
    247	ASSERT_RTNL();
    248
    249	/* we hold the RTNL here so can safely walk the list */
    250	list_for_each_entry(nsdata, &local->interfaces, list) {
    251		if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
    252			/*
    253			 * Only OCB and monitor mode may coexist
    254			 */
    255			if ((sdata->vif.type == NL80211_IFTYPE_OCB &&
    256			     nsdata->vif.type != NL80211_IFTYPE_MONITOR) ||
    257			    (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
    258			     nsdata->vif.type == NL80211_IFTYPE_OCB))
    259				return -EBUSY;
    260
    261			/*
    262			 * Allow only a single IBSS interface to be up at any
    263			 * time. This is restricted because beacon distribution
    264			 * cannot work properly if both are in the same IBSS.
    265			 *
    266			 * To remove this restriction we'd have to disallow them
    267			 * from setting the same SSID on different IBSS interfaces
    268			 * belonging to the same hardware. Then, however, we're
    269			 * faced with having to adopt two different TSF timers...
    270			 */
    271			if (iftype == NL80211_IFTYPE_ADHOC &&
    272			    nsdata->vif.type == NL80211_IFTYPE_ADHOC)
    273				return -EBUSY;
    274			/*
    275			 * will not add another interface while any channel
    276			 * switch is active.
    277			 */
    278			if (nsdata->vif.csa_active)
    279				return -EBUSY;
    280
    281			/*
    282			 * The remaining checks are only performed for interfaces
    283			 * with the same MAC address.
    284			 */
    285			if (!ether_addr_equal(sdata->vif.addr,
    286					      nsdata->vif.addr))
    287				continue;
    288
    289			/*
    290			 * check whether it may have the same address
    291			 */
    292			if (!identical_mac_addr_allowed(iftype,
    293							nsdata->vif.type))
    294				return -ENOTUNIQ;
    295
    296			/*
    297			 * can only add VLANs to enabled APs
    298			 */
    299			if (iftype == NL80211_IFTYPE_AP_VLAN &&
    300			    nsdata->vif.type == NL80211_IFTYPE_AP)
    301				sdata->bss = &nsdata->u.ap;
    302		}
    303	}
    304
    305	mutex_lock(&local->chanctx_mtx);
    306	ret = ieee80211_check_combinations(sdata, NULL, 0, 0);
    307	mutex_unlock(&local->chanctx_mtx);
    308	return ret;
    309}
    310
    311static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata,
    312				  enum nl80211_iftype iftype)
    313{
    314	int n_queues = sdata->local->hw.queues;
    315	int i;
    316
    317	if (iftype == NL80211_IFTYPE_NAN)
    318		return 0;
    319
    320	if (iftype != NL80211_IFTYPE_P2P_DEVICE) {
    321		for (i = 0; i < IEEE80211_NUM_ACS; i++) {
    322			if (WARN_ON_ONCE(sdata->vif.hw_queue[i] ==
    323					 IEEE80211_INVAL_HW_QUEUE))
    324				return -EINVAL;
    325			if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >=
    326					 n_queues))
    327				return -EINVAL;
    328		}
    329	}
    330
    331	if ((iftype != NL80211_IFTYPE_AP &&
    332	     iftype != NL80211_IFTYPE_P2P_GO &&
    333	     iftype != NL80211_IFTYPE_MESH_POINT) ||
    334	    !ieee80211_hw_check(&sdata->local->hw, QUEUE_CONTROL)) {
    335		sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
    336		return 0;
    337	}
    338
    339	if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE))
    340		return -EINVAL;
    341
    342	if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues))
    343		return -EINVAL;
    344
    345	return 0;
    346}
    347
    348static int ieee80211_open(struct net_device *dev)
    349{
    350	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
    351	int err;
    352
    353	/* fail early if user set an invalid address */
    354	if (!is_valid_ether_addr(dev->dev_addr))
    355		return -EADDRNOTAVAIL;
    356
    357	err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
    358	if (err)
    359		return err;
    360
    361	wiphy_lock(sdata->local->hw.wiphy);
    362	err = ieee80211_do_open(&sdata->wdev, true);
    363	wiphy_unlock(sdata->local->hw.wiphy);
    364
    365	return err;
    366}
    367
    368static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata, bool going_down)
    369{
    370	struct ieee80211_local *local = sdata->local;
    371	unsigned long flags;
    372	struct sk_buff *skb, *tmp;
    373	u32 hw_reconf_flags = 0;
    374	int i, flushed;
    375	struct ps_data *ps;
    376	struct cfg80211_chan_def chandef;
    377	bool cancel_scan;
    378	struct cfg80211_nan_func *func;
    379
    380	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
    381
    382	cancel_scan = rcu_access_pointer(local->scan_sdata) == sdata;
    383	if (cancel_scan)
    384		ieee80211_scan_cancel(local);
    385
    386	/*
    387	 * Stop TX on this interface first.
    388	 */
    389	if (sdata->dev)
    390		netif_tx_stop_all_queues(sdata->dev);
    391
    392	ieee80211_roc_purge(local, sdata);
    393
    394	switch (sdata->vif.type) {
    395	case NL80211_IFTYPE_STATION:
    396		ieee80211_mgd_stop(sdata);
    397		break;
    398	case NL80211_IFTYPE_ADHOC:
    399		ieee80211_ibss_stop(sdata);
    400		break;
    401	case NL80211_IFTYPE_MONITOR:
    402		if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES)
    403			break;
    404		list_del_rcu(&sdata->u.mntr.list);
    405		break;
    406	default:
    407		break;
    408	}
    409
    410	/*
    411	 * Remove all stations associated with this interface.
    412	 *
    413	 * This must be done before calling ops->remove_interface()
    414	 * because otherwise we can later invoke ops->sta_notify()
    415	 * whenever the STAs are removed, and that invalidates driver
    416	 * assumptions about always getting a vif pointer that is valid
    417	 * (because if we remove a STA after ops->remove_interface()
    418	 * the driver will have removed the vif info already!)
    419	 *
    420	 * For AP_VLANs stations may exist since there's nothing else that
    421	 * would have removed them, but in other modes there shouldn't
    422	 * be any stations.
    423	 */
    424	flushed = sta_info_flush(sdata);
    425	WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_AP_VLAN && flushed > 0);
    426
    427	/* don't count this interface for allmulti while it is down */
    428	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
    429		atomic_dec(&local->iff_allmultis);
    430
    431	if (sdata->vif.type == NL80211_IFTYPE_AP) {
    432		local->fif_pspoll--;
    433		local->fif_probe_req--;
    434	} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
    435		local->fif_probe_req--;
    436	}
    437
    438	if (sdata->dev) {
    439		netif_addr_lock_bh(sdata->dev);
    440		spin_lock_bh(&local->filter_lock);
    441		__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
    442				 sdata->dev->addr_len);
    443		spin_unlock_bh(&local->filter_lock);
    444		netif_addr_unlock_bh(sdata->dev);
    445	}
    446
    447	del_timer_sync(&local->dynamic_ps_timer);
    448	cancel_work_sync(&local->dynamic_ps_enable_work);
    449
    450	cancel_work_sync(&sdata->recalc_smps);
    451	sdata_lock(sdata);
    452	mutex_lock(&local->mtx);
    453	sdata->vif.csa_active = false;
    454	if (sdata->vif.type == NL80211_IFTYPE_STATION)
    455		sdata->u.mgd.csa_waiting_bcn = false;
    456	if (sdata->csa_block_tx) {
    457		ieee80211_wake_vif_queues(local, sdata,
    458					  IEEE80211_QUEUE_STOP_REASON_CSA);
    459		sdata->csa_block_tx = false;
    460	}
    461	mutex_unlock(&local->mtx);
    462	sdata_unlock(sdata);
    463
    464	cancel_work_sync(&sdata->csa_finalize_work);
    465	cancel_work_sync(&sdata->color_change_finalize_work);
    466
    467	cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
    468
    469	if (sdata->wdev.cac_started) {
    470		chandef = sdata->vif.bss_conf.chandef;
    471		WARN_ON(local->suspended);
    472		mutex_lock(&local->mtx);
    473		ieee80211_vif_release_channel(sdata);
    474		mutex_unlock(&local->mtx);
    475		cfg80211_cac_event(sdata->dev, &chandef,
    476				   NL80211_RADAR_CAC_ABORTED,
    477				   GFP_KERNEL);
    478	}
    479
    480	if (sdata->vif.type == NL80211_IFTYPE_AP) {
    481		WARN_ON(!list_empty(&sdata->u.ap.vlans));
    482	} else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
    483		/* remove all packets in parent bc_buf pointing to this dev */
    484		ps = &sdata->bss->ps;
    485
    486		spin_lock_irqsave(&ps->bc_buf.lock, flags);
    487		skb_queue_walk_safe(&ps->bc_buf, skb, tmp) {
    488			if (skb->dev == sdata->dev) {
    489				__skb_unlink(skb, &ps->bc_buf);
    490				local->total_ps_buffered--;
    491				ieee80211_free_txskb(&local->hw, skb);
    492			}
    493		}
    494		spin_unlock_irqrestore(&ps->bc_buf.lock, flags);
    495	}
    496
    497	if (going_down)
    498		local->open_count--;
    499
    500	switch (sdata->vif.type) {
    501	case NL80211_IFTYPE_AP_VLAN:
    502		mutex_lock(&local->mtx);
    503		list_del(&sdata->u.vlan.list);
    504		mutex_unlock(&local->mtx);
    505		RCU_INIT_POINTER(sdata->vif.chanctx_conf, NULL);
    506		/* see comment in the default case below */
    507		ieee80211_free_keys(sdata, true);
    508		/* no need to tell driver */
    509		break;
    510	case NL80211_IFTYPE_MONITOR:
    511		if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) {
    512			local->cooked_mntrs--;
    513			break;
    514		}
    515
    516		local->monitors--;
    517		if (local->monitors == 0) {
    518			local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
    519			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
    520		}
    521
    522		ieee80211_adjust_monitor_flags(sdata, -1);
    523		break;
    524	case NL80211_IFTYPE_NAN:
    525		/* clean all the functions */
    526		spin_lock_bh(&sdata->u.nan.func_lock);
    527
    528		idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, i) {
    529			idr_remove(&sdata->u.nan.function_inst_ids, i);
    530			cfg80211_free_nan_func(func);
    531		}
    532		idr_destroy(&sdata->u.nan.function_inst_ids);
    533
    534		spin_unlock_bh(&sdata->u.nan.func_lock);
    535		break;
    536	case NL80211_IFTYPE_P2P_DEVICE:
    537		/* relies on synchronize_rcu() below */
    538		RCU_INIT_POINTER(local->p2p_sdata, NULL);
    539		fallthrough;
    540	default:
    541		cancel_work_sync(&sdata->work);
    542		/*
    543		 * When we get here, the interface is marked down.
    544		 * Free the remaining keys, if there are any
    545		 * (which can happen in AP mode if userspace sets
    546		 * keys before the interface is operating)
    547		 *
    548		 * Force the key freeing to always synchronize_net()
    549		 * to wait for the RX path in case it is using this
    550		 * interface enqueuing frames at this very time on
    551		 * another CPU.
    552		 */
    553		ieee80211_free_keys(sdata, true);
    554		skb_queue_purge(&sdata->skb_queue);
    555		skb_queue_purge(&sdata->status_queue);
    556	}
    557
    558	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
    559	for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
    560		skb_queue_walk_safe(&local->pending[i], skb, tmp) {
    561			struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
    562			if (info->control.vif == &sdata->vif) {
    563				__skb_unlink(skb, &local->pending[i]);
    564				ieee80211_free_txskb(&local->hw, skb);
    565			}
    566		}
    567	}
    568	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
    569
    570	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
    571		ieee80211_txq_remove_vlan(local, sdata);
    572
    573	sdata->bss = NULL;
    574
    575	if (local->open_count == 0)
    576		ieee80211_clear_tx_pending(local);
    577
    578	sdata->vif.bss_conf.beacon_int = 0;
    579
    580	/*
    581	 * If the interface goes down while suspended, presumably because
    582	 * the device was unplugged and that happens before our resume,
    583	 * then the driver is already unconfigured and the remainder of
    584	 * this function isn't needed.
    585	 * XXX: what about WoWLAN? If the device has software state, e.g.
    586	 *	memory allocated, it might expect teardown commands from
    587	 *	mac80211 here?
    588	 */
    589	if (local->suspended) {
    590		WARN_ON(local->wowlan);
    591		WARN_ON(rcu_access_pointer(local->monitor_sdata));
    592		return;
    593	}
    594
    595	switch (sdata->vif.type) {
    596	case NL80211_IFTYPE_AP_VLAN:
    597		break;
    598	case NL80211_IFTYPE_MONITOR:
    599		if (local->monitors == 0)
    600			ieee80211_del_virtual_monitor(local);
    601
    602		mutex_lock(&local->mtx);
    603		ieee80211_recalc_idle(local);
    604		mutex_unlock(&local->mtx);
    605
    606		if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
    607			break;
    608
    609		fallthrough;
    610	default:
    611		if (going_down)
    612			drv_remove_interface(local, sdata);
    613	}
    614
    615	ieee80211_recalc_ps(local);
    616
    617	if (cancel_scan)
    618		flush_delayed_work(&local->scan_work);
    619
    620	if (local->open_count == 0) {
    621		ieee80211_stop_device(local);
    622
    623		/* no reconfiguring after stop! */
    624		return;
    625	}
    626
    627	/* do after stop to avoid reconfiguring when we stop anyway */
    628	ieee80211_configure_filter(local);
    629	ieee80211_hw_config(local, hw_reconf_flags);
    630
    631	if (local->monitors == local->open_count)
    632		ieee80211_add_virtual_monitor(local);
    633}
    634
    635static void ieee80211_stop_mbssid(struct ieee80211_sub_if_data *sdata)
    636{
    637	struct ieee80211_sub_if_data *tx_sdata, *non_tx_sdata, *tmp_sdata;
    638	struct ieee80211_vif *tx_vif = sdata->vif.mbssid_tx_vif;
    639
    640	if (!tx_vif)
    641		return;
    642
    643	tx_sdata = vif_to_sdata(tx_vif);
    644	sdata->vif.mbssid_tx_vif = NULL;
    645
    646	list_for_each_entry_safe(non_tx_sdata, tmp_sdata,
    647				 &tx_sdata->local->interfaces, list) {
    648		if (non_tx_sdata != sdata && non_tx_sdata != tx_sdata &&
    649		    non_tx_sdata->vif.mbssid_tx_vif == tx_vif &&
    650		    ieee80211_sdata_running(non_tx_sdata)) {
    651			non_tx_sdata->vif.mbssid_tx_vif = NULL;
    652			dev_close(non_tx_sdata->wdev.netdev);
    653		}
    654	}
    655
    656	if (sdata != tx_sdata && ieee80211_sdata_running(tx_sdata)) {
    657		tx_sdata->vif.mbssid_tx_vif = NULL;
    658		dev_close(tx_sdata->wdev.netdev);
    659	}
    660}
    661
    662static int ieee80211_stop(struct net_device *dev)
    663{
    664	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
    665
    666	/* close dependent VLAN and MBSSID interfaces before locking wiphy */
    667	if (sdata->vif.type == NL80211_IFTYPE_AP) {
    668		struct ieee80211_sub_if_data *vlan, *tmpsdata;
    669
    670		list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
    671					 u.vlan.list)
    672			dev_close(vlan->dev);
    673
    674		ieee80211_stop_mbssid(sdata);
    675	}
    676
    677	wiphy_lock(sdata->local->hw.wiphy);
    678	ieee80211_do_stop(sdata, true);
    679	wiphy_unlock(sdata->local->hw.wiphy);
    680
    681	return 0;
    682}
    683
    684static void ieee80211_set_multicast_list(struct net_device *dev)
    685{
    686	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
    687	struct ieee80211_local *local = sdata->local;
    688	int allmulti, sdata_allmulti;
    689
    690	allmulti = !!(dev->flags & IFF_ALLMULTI);
    691	sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
    692
    693	if (allmulti != sdata_allmulti) {
    694		if (dev->flags & IFF_ALLMULTI)
    695			atomic_inc(&local->iff_allmultis);
    696		else
    697			atomic_dec(&local->iff_allmultis);
    698		sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
    699	}
    700
    701	spin_lock_bh(&local->filter_lock);
    702	__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
    703	spin_unlock_bh(&local->filter_lock);
    704	ieee80211_queue_work(&local->hw, &local->reconfig_filter);
    705}
    706
    707/*
    708 * Called when the netdev is removed or, by the code below, before
    709 * the interface type changes.
    710 */
    711static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
    712{
    713	/* free extra data */
    714	ieee80211_free_keys(sdata, false);
    715
    716	ieee80211_debugfs_remove_netdev(sdata);
    717
    718	ieee80211_destroy_frag_cache(&sdata->frags);
    719
    720	if (ieee80211_vif_is_mesh(&sdata->vif))
    721		ieee80211_mesh_teardown_sdata(sdata);
    722}
    723
    724static void ieee80211_uninit(struct net_device *dev)
    725{
    726	ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
    727}
    728
    729static u16 ieee80211_netdev_select_queue(struct net_device *dev,
    730					 struct sk_buff *skb,
    731					 struct net_device *sb_dev)
    732{
    733	return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
    734}
    735
    736static void
    737ieee80211_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
    738{
    739	dev_fetch_sw_netstats(stats, dev->tstats);
    740}
    741
    742static const struct net_device_ops ieee80211_dataif_ops = {
    743	.ndo_open		= ieee80211_open,
    744	.ndo_stop		= ieee80211_stop,
    745	.ndo_uninit		= ieee80211_uninit,
    746	.ndo_start_xmit		= ieee80211_subif_start_xmit,
    747	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
    748	.ndo_set_mac_address 	= ieee80211_change_mac,
    749	.ndo_select_queue	= ieee80211_netdev_select_queue,
    750	.ndo_get_stats64	= ieee80211_get_stats64,
    751};
    752
    753static u16 ieee80211_monitor_select_queue(struct net_device *dev,
    754					  struct sk_buff *skb,
    755					  struct net_device *sb_dev)
    756{
    757	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
    758	struct ieee80211_local *local = sdata->local;
    759	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
    760	struct ieee80211_hdr *hdr;
    761	int len_rthdr;
    762
    763	if (local->hw.queues < IEEE80211_NUM_ACS)
    764		return 0;
    765
    766	/* reset flags and info before parsing radiotap header */
    767	memset(info, 0, sizeof(*info));
    768
    769	if (!ieee80211_parse_tx_radiotap(skb, dev))
    770		return 0; /* doesn't matter, frame will be dropped */
    771
    772	len_rthdr = ieee80211_get_radiotap_len(skb->data);
    773	hdr = (struct ieee80211_hdr *)(skb->data + len_rthdr);
    774	if (skb->len < len_rthdr + 2 ||
    775	    skb->len < len_rthdr + ieee80211_hdrlen(hdr->frame_control))
    776		return 0; /* doesn't matter, frame will be dropped */
    777
    778	return ieee80211_select_queue_80211(sdata, skb, hdr);
    779}
    780
    781static const struct net_device_ops ieee80211_monitorif_ops = {
    782	.ndo_open		= ieee80211_open,
    783	.ndo_stop		= ieee80211_stop,
    784	.ndo_uninit		= ieee80211_uninit,
    785	.ndo_start_xmit		= ieee80211_monitor_start_xmit,
    786	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
    787	.ndo_set_mac_address 	= ieee80211_change_mac,
    788	.ndo_select_queue	= ieee80211_monitor_select_queue,
    789	.ndo_get_stats64	= ieee80211_get_stats64,
    790};
    791
    792static int ieee80211_netdev_fill_forward_path(struct net_device_path_ctx *ctx,
    793					      struct net_device_path *path)
    794{
    795	struct ieee80211_sub_if_data *sdata;
    796	struct ieee80211_local *local;
    797	struct sta_info *sta;
    798	int ret = -ENOENT;
    799
    800	sdata = IEEE80211_DEV_TO_SUB_IF(ctx->dev);
    801	local = sdata->local;
    802
    803	if (!local->ops->net_fill_forward_path)
    804		return -EOPNOTSUPP;
    805
    806	rcu_read_lock();
    807	switch (sdata->vif.type) {
    808	case NL80211_IFTYPE_AP_VLAN:
    809		sta = rcu_dereference(sdata->u.vlan.sta);
    810		if (sta)
    811			break;
    812		if (sdata->wdev.use_4addr)
    813			goto out;
    814		if (is_multicast_ether_addr(ctx->daddr))
    815			goto out;
    816		sta = sta_info_get_bss(sdata, ctx->daddr);
    817		break;
    818	case NL80211_IFTYPE_AP:
    819		if (is_multicast_ether_addr(ctx->daddr))
    820			goto out;
    821		sta = sta_info_get(sdata, ctx->daddr);
    822		break;
    823	case NL80211_IFTYPE_STATION:
    824		if (sdata->wdev.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) {
    825			sta = sta_info_get(sdata, ctx->daddr);
    826			if (sta && test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
    827				if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH))
    828					goto out;
    829
    830				break;
    831			}
    832		}
    833
    834		sta = sta_info_get(sdata, sdata->u.mgd.bssid);
    835		break;
    836	default:
    837		goto out;
    838	}
    839
    840	if (!sta)
    841		goto out;
    842
    843	ret = drv_net_fill_forward_path(local, sdata, &sta->sta, ctx, path);
    844out:
    845	rcu_read_unlock();
    846
    847	return ret;
    848}
    849
    850static const struct net_device_ops ieee80211_dataif_8023_ops = {
    851	.ndo_open		= ieee80211_open,
    852	.ndo_stop		= ieee80211_stop,
    853	.ndo_uninit		= ieee80211_uninit,
    854	.ndo_start_xmit		= ieee80211_subif_start_xmit_8023,
    855	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
    856	.ndo_set_mac_address	= ieee80211_change_mac,
    857	.ndo_select_queue	= ieee80211_netdev_select_queue,
    858	.ndo_get_stats64	= ieee80211_get_stats64,
    859	.ndo_fill_forward_path	= ieee80211_netdev_fill_forward_path,
    860};
    861
    862static bool ieee80211_iftype_supports_hdr_offload(enum nl80211_iftype iftype)
    863{
    864	switch (iftype) {
    865	/* P2P GO and client are mapped to AP/STATION types */
    866	case NL80211_IFTYPE_AP:
    867	case NL80211_IFTYPE_STATION:
    868		return true;
    869	default:
    870		return false;
    871	}
    872}
    873
    874static bool ieee80211_set_sdata_offload_flags(struct ieee80211_sub_if_data *sdata)
    875{
    876	struct ieee80211_local *local = sdata->local;
    877	u32 flags;
    878
    879	flags = sdata->vif.offload_flags;
    880
    881	if (ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD) &&
    882	    ieee80211_iftype_supports_hdr_offload(sdata->vif.type)) {
    883		flags |= IEEE80211_OFFLOAD_ENCAP_ENABLED;
    884
    885		if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_FRAG) &&
    886		    local->hw.wiphy->frag_threshold != (u32)-1)
    887			flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
    888
    889		if (local->monitors)
    890			flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
    891	} else {
    892		flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
    893	}
    894
    895	if (ieee80211_hw_check(&local->hw, SUPPORTS_RX_DECAP_OFFLOAD) &&
    896	    ieee80211_iftype_supports_hdr_offload(sdata->vif.type)) {
    897		flags |= IEEE80211_OFFLOAD_DECAP_ENABLED;
    898
    899		if (local->monitors &&
    900		    !ieee80211_hw_check(&local->hw, SUPPORTS_CONC_MON_RX_DECAP))
    901			flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
    902	} else {
    903		flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
    904	}
    905
    906	if (sdata->vif.offload_flags == flags)
    907		return false;
    908
    909	sdata->vif.offload_flags = flags;
    910	ieee80211_check_fast_rx_iface(sdata);
    911	return true;
    912}
    913
    914static void ieee80211_set_vif_encap_ops(struct ieee80211_sub_if_data *sdata)
    915{
    916	struct ieee80211_local *local = sdata->local;
    917	struct ieee80211_sub_if_data *bss = sdata;
    918	bool enabled;
    919
    920	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
    921		if (!sdata->bss)
    922			return;
    923
    924		bss = container_of(sdata->bss, struct ieee80211_sub_if_data, u.ap);
    925	}
    926
    927	if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD) ||
    928	    !ieee80211_iftype_supports_hdr_offload(bss->vif.type))
    929		return;
    930
    931	enabled = bss->vif.offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED;
    932	if (sdata->wdev.use_4addr &&
    933	    !(bss->vif.offload_flags & IEEE80211_OFFLOAD_ENCAP_4ADDR))
    934		enabled = false;
    935
    936	sdata->dev->netdev_ops = enabled ? &ieee80211_dataif_8023_ops :
    937					   &ieee80211_dataif_ops;
    938}
    939
    940static void ieee80211_recalc_sdata_offload(struct ieee80211_sub_if_data *sdata)
    941{
    942	struct ieee80211_local *local = sdata->local;
    943	struct ieee80211_sub_if_data *vsdata;
    944
    945	if (ieee80211_set_sdata_offload_flags(sdata)) {
    946		drv_update_vif_offload(local, sdata);
    947		ieee80211_set_vif_encap_ops(sdata);
    948	}
    949
    950	list_for_each_entry(vsdata, &local->interfaces, list) {
    951		if (vsdata->vif.type != NL80211_IFTYPE_AP_VLAN ||
    952		    vsdata->bss != &sdata->u.ap)
    953			continue;
    954
    955		ieee80211_set_vif_encap_ops(vsdata);
    956	}
    957}
    958
    959void ieee80211_recalc_offload(struct ieee80211_local *local)
    960{
    961	struct ieee80211_sub_if_data *sdata;
    962
    963	if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD))
    964		return;
    965
    966	mutex_lock(&local->iflist_mtx);
    967
    968	list_for_each_entry(sdata, &local->interfaces, list) {
    969		if (!ieee80211_sdata_running(sdata))
    970			continue;
    971
    972		ieee80211_recalc_sdata_offload(sdata);
    973	}
    974
    975	mutex_unlock(&local->iflist_mtx);
    976}
    977
    978void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
    979				    const int offset)
    980{
    981	struct ieee80211_local *local = sdata->local;
    982	u32 flags = sdata->u.mntr.flags;
    983
    984#define ADJUST(_f, _s)	do {					\
    985	if (flags & MONITOR_FLAG_##_f)				\
    986		local->fif_##_s += offset;			\
    987	} while (0)
    988
    989	ADJUST(FCSFAIL, fcsfail);
    990	ADJUST(PLCPFAIL, plcpfail);
    991	ADJUST(CONTROL, control);
    992	ADJUST(CONTROL, pspoll);
    993	ADJUST(OTHER_BSS, other_bss);
    994
    995#undef ADJUST
    996}
    997
    998static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata)
    999{
   1000	struct ieee80211_local *local = sdata->local;
   1001	int i;
   1002
   1003	for (i = 0; i < IEEE80211_NUM_ACS; i++) {
   1004		if (ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
   1005			sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;
   1006		else if (local->hw.queues >= IEEE80211_NUM_ACS)
   1007			sdata->vif.hw_queue[i] = i;
   1008		else
   1009			sdata->vif.hw_queue[i] = 0;
   1010	}
   1011	sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
   1012}
   1013
   1014int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
   1015{
   1016	struct ieee80211_sub_if_data *sdata;
   1017	int ret;
   1018
   1019	if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
   1020		return 0;
   1021
   1022	ASSERT_RTNL();
   1023	lockdep_assert_wiphy(local->hw.wiphy);
   1024
   1025	if (local->monitor_sdata)
   1026		return 0;
   1027
   1028	sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
   1029	if (!sdata)
   1030		return -ENOMEM;
   1031
   1032	/* set up data */
   1033	sdata->local = local;
   1034	sdata->vif.type = NL80211_IFTYPE_MONITOR;
   1035	snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
   1036		 wiphy_name(local->hw.wiphy));
   1037	sdata->wdev.iftype = NL80211_IFTYPE_MONITOR;
   1038
   1039	sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
   1040
   1041	ieee80211_set_default_queues(sdata);
   1042
   1043	ret = drv_add_interface(local, sdata);
   1044	if (WARN_ON(ret)) {
   1045		/* ok .. stupid driver, it asked for this! */
   1046		kfree(sdata);
   1047		return ret;
   1048	}
   1049
   1050	set_bit(SDATA_STATE_RUNNING, &sdata->state);
   1051
   1052	ret = ieee80211_check_queues(sdata, NL80211_IFTYPE_MONITOR);
   1053	if (ret) {
   1054		kfree(sdata);
   1055		return ret;
   1056	}
   1057
   1058	mutex_lock(&local->iflist_mtx);
   1059	rcu_assign_pointer(local->monitor_sdata, sdata);
   1060	mutex_unlock(&local->iflist_mtx);
   1061
   1062	mutex_lock(&local->mtx);
   1063	ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef,
   1064					IEEE80211_CHANCTX_EXCLUSIVE);
   1065	mutex_unlock(&local->mtx);
   1066	if (ret) {
   1067		mutex_lock(&local->iflist_mtx);
   1068		RCU_INIT_POINTER(local->monitor_sdata, NULL);
   1069		mutex_unlock(&local->iflist_mtx);
   1070		synchronize_net();
   1071		drv_remove_interface(local, sdata);
   1072		kfree(sdata);
   1073		return ret;
   1074	}
   1075
   1076	skb_queue_head_init(&sdata->skb_queue);
   1077	skb_queue_head_init(&sdata->status_queue);
   1078	INIT_WORK(&sdata->work, ieee80211_iface_work);
   1079
   1080	return 0;
   1081}
   1082
   1083void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
   1084{
   1085	struct ieee80211_sub_if_data *sdata;
   1086
   1087	if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
   1088		return;
   1089
   1090	ASSERT_RTNL();
   1091	lockdep_assert_wiphy(local->hw.wiphy);
   1092
   1093	mutex_lock(&local->iflist_mtx);
   1094
   1095	sdata = rcu_dereference_protected(local->monitor_sdata,
   1096					  lockdep_is_held(&local->iflist_mtx));
   1097	if (!sdata) {
   1098		mutex_unlock(&local->iflist_mtx);
   1099		return;
   1100	}
   1101
   1102	RCU_INIT_POINTER(local->monitor_sdata, NULL);
   1103	mutex_unlock(&local->iflist_mtx);
   1104
   1105	synchronize_net();
   1106
   1107	mutex_lock(&local->mtx);
   1108	ieee80211_vif_release_channel(sdata);
   1109	mutex_unlock(&local->mtx);
   1110
   1111	drv_remove_interface(local, sdata);
   1112
   1113	kfree(sdata);
   1114}
   1115
   1116/*
   1117 * NOTE: Be very careful when changing this function, it must NOT return
   1118 * an error on interface type changes that have been pre-checked, so most
   1119 * checks should be in ieee80211_check_concurrent_iface.
   1120 */
   1121int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)
   1122{
   1123	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
   1124	struct net_device *dev = wdev->netdev;
   1125	struct ieee80211_local *local = sdata->local;
   1126	u32 changed = 0;
   1127	int res;
   1128	u32 hw_reconf_flags = 0;
   1129
   1130	switch (sdata->vif.type) {
   1131	case NL80211_IFTYPE_AP_VLAN: {
   1132		struct ieee80211_sub_if_data *master;
   1133
   1134		if (!sdata->bss)
   1135			return -ENOLINK;
   1136
   1137		mutex_lock(&local->mtx);
   1138		list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
   1139		mutex_unlock(&local->mtx);
   1140
   1141		master = container_of(sdata->bss,
   1142				      struct ieee80211_sub_if_data, u.ap);
   1143		sdata->control_port_protocol =
   1144			master->control_port_protocol;
   1145		sdata->control_port_no_encrypt =
   1146			master->control_port_no_encrypt;
   1147		sdata->control_port_over_nl80211 =
   1148			master->control_port_over_nl80211;
   1149		sdata->control_port_no_preauth =
   1150			master->control_port_no_preauth;
   1151		sdata->vif.cab_queue = master->vif.cab_queue;
   1152		memcpy(sdata->vif.hw_queue, master->vif.hw_queue,
   1153		       sizeof(sdata->vif.hw_queue));
   1154		sdata->vif.bss_conf.chandef = master->vif.bss_conf.chandef;
   1155
   1156		mutex_lock(&local->key_mtx);
   1157		sdata->crypto_tx_tailroom_needed_cnt +=
   1158			master->crypto_tx_tailroom_needed_cnt;
   1159		mutex_unlock(&local->key_mtx);
   1160
   1161		break;
   1162		}
   1163	case NL80211_IFTYPE_AP:
   1164		sdata->bss = &sdata->u.ap;
   1165		break;
   1166	case NL80211_IFTYPE_MESH_POINT:
   1167	case NL80211_IFTYPE_STATION:
   1168	case NL80211_IFTYPE_MONITOR:
   1169	case NL80211_IFTYPE_ADHOC:
   1170	case NL80211_IFTYPE_P2P_DEVICE:
   1171	case NL80211_IFTYPE_OCB:
   1172	case NL80211_IFTYPE_NAN:
   1173		/* no special treatment */
   1174		break;
   1175	case NL80211_IFTYPE_UNSPECIFIED:
   1176	case NUM_NL80211_IFTYPES:
   1177	case NL80211_IFTYPE_P2P_CLIENT:
   1178	case NL80211_IFTYPE_P2P_GO:
   1179	case NL80211_IFTYPE_WDS:
   1180		/* cannot happen */
   1181		WARN_ON(1);
   1182		break;
   1183	}
   1184
   1185	if (local->open_count == 0) {
   1186		res = drv_start(local);
   1187		if (res)
   1188			goto err_del_bss;
   1189		/* we're brought up, everything changes */
   1190		hw_reconf_flags = ~0;
   1191		ieee80211_led_radio(local, true);
   1192		ieee80211_mod_tpt_led_trig(local,
   1193					   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
   1194	}
   1195
   1196	/*
   1197	 * Copy the hopefully now-present MAC address to
   1198	 * this interface, if it has the special null one.
   1199	 */
   1200	if (dev && is_zero_ether_addr(dev->dev_addr)) {
   1201		eth_hw_addr_set(dev, local->hw.wiphy->perm_addr);
   1202		memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
   1203
   1204		if (!is_valid_ether_addr(dev->dev_addr)) {
   1205			res = -EADDRNOTAVAIL;
   1206			goto err_stop;
   1207		}
   1208	}
   1209
   1210	switch (sdata->vif.type) {
   1211	case NL80211_IFTYPE_AP_VLAN:
   1212		/* no need to tell driver, but set carrier and chanctx */
   1213		if (rtnl_dereference(sdata->bss->beacon)) {
   1214			ieee80211_vif_vlan_copy_chanctx(sdata);
   1215			netif_carrier_on(dev);
   1216			ieee80211_set_vif_encap_ops(sdata);
   1217		} else {
   1218			netif_carrier_off(dev);
   1219		}
   1220		break;
   1221	case NL80211_IFTYPE_MONITOR:
   1222		if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) {
   1223			local->cooked_mntrs++;
   1224			break;
   1225		}
   1226
   1227		if (sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE) {
   1228			res = drv_add_interface(local, sdata);
   1229			if (res)
   1230				goto err_stop;
   1231		} else if (local->monitors == 0 && local->open_count == 0) {
   1232			res = ieee80211_add_virtual_monitor(local);
   1233			if (res)
   1234				goto err_stop;
   1235		}
   1236
   1237		/* must be before the call to ieee80211_configure_filter */
   1238		local->monitors++;
   1239		if (local->monitors == 1) {
   1240			local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
   1241			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
   1242		}
   1243
   1244		ieee80211_adjust_monitor_flags(sdata, 1);
   1245		ieee80211_configure_filter(local);
   1246		ieee80211_recalc_offload(local);
   1247		mutex_lock(&local->mtx);
   1248		ieee80211_recalc_idle(local);
   1249		mutex_unlock(&local->mtx);
   1250
   1251		netif_carrier_on(dev);
   1252		break;
   1253	default:
   1254		if (coming_up) {
   1255			ieee80211_del_virtual_monitor(local);
   1256			ieee80211_set_sdata_offload_flags(sdata);
   1257
   1258			res = drv_add_interface(local, sdata);
   1259			if (res)
   1260				goto err_stop;
   1261
   1262			ieee80211_set_vif_encap_ops(sdata);
   1263			res = ieee80211_check_queues(sdata,
   1264				ieee80211_vif_type_p2p(&sdata->vif));
   1265			if (res)
   1266				goto err_del_interface;
   1267		}
   1268
   1269		if (sdata->vif.type == NL80211_IFTYPE_AP) {
   1270			local->fif_pspoll++;
   1271			local->fif_probe_req++;
   1272
   1273			ieee80211_configure_filter(local);
   1274		} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
   1275			local->fif_probe_req++;
   1276		}
   1277
   1278		if (sdata->vif.probe_req_reg)
   1279			drv_config_iface_filter(local, sdata,
   1280						FIF_PROBE_REQ,
   1281						FIF_PROBE_REQ);
   1282
   1283		if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
   1284		    sdata->vif.type != NL80211_IFTYPE_NAN)
   1285			changed |= ieee80211_reset_erp_info(sdata);
   1286		ieee80211_bss_info_change_notify(sdata, changed);
   1287
   1288		switch (sdata->vif.type) {
   1289		case NL80211_IFTYPE_STATION:
   1290		case NL80211_IFTYPE_ADHOC:
   1291		case NL80211_IFTYPE_AP:
   1292		case NL80211_IFTYPE_MESH_POINT:
   1293		case NL80211_IFTYPE_OCB:
   1294			netif_carrier_off(dev);
   1295			break;
   1296		case NL80211_IFTYPE_P2P_DEVICE:
   1297		case NL80211_IFTYPE_NAN:
   1298			break;
   1299		default:
   1300			/* not reached */
   1301			WARN_ON(1);
   1302		}
   1303
   1304		/*
   1305		 * Set default queue parameters so drivers don't
   1306		 * need to initialise the hardware if the hardware
   1307		 * doesn't start up with sane defaults.
   1308		 * Enable QoS for anything but station interfaces.
   1309		 */
   1310		ieee80211_set_wmm_default(sdata, true,
   1311			sdata->vif.type != NL80211_IFTYPE_STATION);
   1312	}
   1313
   1314	set_bit(SDATA_STATE_RUNNING, &sdata->state);
   1315
   1316	switch (sdata->vif.type) {
   1317	case NL80211_IFTYPE_P2P_DEVICE:
   1318		rcu_assign_pointer(local->p2p_sdata, sdata);
   1319		break;
   1320	case NL80211_IFTYPE_MONITOR:
   1321		if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES)
   1322			break;
   1323		list_add_tail_rcu(&sdata->u.mntr.list, &local->mon_list);
   1324		break;
   1325	default:
   1326		break;
   1327	}
   1328
   1329	/*
   1330	 * set_multicast_list will be invoked by the networking core
   1331	 * which will check whether any increments here were done in
   1332	 * error and sync them down to the hardware as filter flags.
   1333	 */
   1334	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
   1335		atomic_inc(&local->iff_allmultis);
   1336
   1337	if (coming_up)
   1338		local->open_count++;
   1339
   1340	if (hw_reconf_flags)
   1341		ieee80211_hw_config(local, hw_reconf_flags);
   1342
   1343	ieee80211_recalc_ps(local);
   1344
   1345	if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
   1346	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
   1347	    local->ops->wake_tx_queue) {
   1348		/* XXX: for AP_VLAN, actually track AP queues */
   1349		if (dev)
   1350			netif_tx_start_all_queues(dev);
   1351	} else if (dev) {
   1352		unsigned long flags;
   1353		int n_acs = IEEE80211_NUM_ACS;
   1354		int ac;
   1355
   1356		if (local->hw.queues < IEEE80211_NUM_ACS)
   1357			n_acs = 1;
   1358
   1359		spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
   1360		if (sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE ||
   1361		    (local->queue_stop_reasons[sdata->vif.cab_queue] == 0 &&
   1362		     skb_queue_empty(&local->pending[sdata->vif.cab_queue]))) {
   1363			for (ac = 0; ac < n_acs; ac++) {
   1364				int ac_queue = sdata->vif.hw_queue[ac];
   1365
   1366				if (local->queue_stop_reasons[ac_queue] == 0 &&
   1367				    skb_queue_empty(&local->pending[ac_queue]))
   1368					netif_start_subqueue(dev, ac);
   1369			}
   1370		}
   1371		spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
   1372	}
   1373
   1374	return 0;
   1375 err_del_interface:
   1376	drv_remove_interface(local, sdata);
   1377 err_stop:
   1378	if (!local->open_count)
   1379		drv_stop(local);
   1380 err_del_bss:
   1381	sdata->bss = NULL;
   1382	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
   1383		mutex_lock(&local->mtx);
   1384		list_del(&sdata->u.vlan.list);
   1385		mutex_unlock(&local->mtx);
   1386	}
   1387	/* might already be clear but that doesn't matter */
   1388	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
   1389	return res;
   1390}
   1391
   1392static void ieee80211_if_free(struct net_device *dev)
   1393{
   1394	free_percpu(dev->tstats);
   1395}
   1396
   1397static void ieee80211_if_setup(struct net_device *dev)
   1398{
   1399	ether_setup(dev);
   1400	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
   1401	dev->netdev_ops = &ieee80211_dataif_ops;
   1402	dev->needs_free_netdev = true;
   1403	dev->priv_destructor = ieee80211_if_free;
   1404}
   1405
   1406static void ieee80211_if_setup_no_queue(struct net_device *dev)
   1407{
   1408	ieee80211_if_setup(dev);
   1409	dev->priv_flags |= IFF_NO_QUEUE;
   1410}
   1411
   1412static void ieee80211_iface_process_skb(struct ieee80211_local *local,
   1413					struct ieee80211_sub_if_data *sdata,
   1414					struct sk_buff *skb)
   1415{
   1416	struct ieee80211_mgmt *mgmt = (void *)skb->data;
   1417
   1418	if (ieee80211_is_action(mgmt->frame_control) &&
   1419	    mgmt->u.action.category == WLAN_CATEGORY_BACK) {
   1420		struct sta_info *sta;
   1421		int len = skb->len;
   1422
   1423		mutex_lock(&local->sta_mtx);
   1424		sta = sta_info_get_bss(sdata, mgmt->sa);
   1425		if (sta) {
   1426			switch (mgmt->u.action.u.addba_req.action_code) {
   1427			case WLAN_ACTION_ADDBA_REQ:
   1428				ieee80211_process_addba_request(local, sta,
   1429								mgmt, len);
   1430				break;
   1431			case WLAN_ACTION_ADDBA_RESP:
   1432				ieee80211_process_addba_resp(local, sta,
   1433							     mgmt, len);
   1434				break;
   1435			case WLAN_ACTION_DELBA:
   1436				ieee80211_process_delba(sdata, sta,
   1437							mgmt, len);
   1438				break;
   1439			default:
   1440				WARN_ON(1);
   1441				break;
   1442			}
   1443		}
   1444		mutex_unlock(&local->sta_mtx);
   1445	} else if (ieee80211_is_action(mgmt->frame_control) &&
   1446		   mgmt->u.action.category == WLAN_CATEGORY_VHT) {
   1447		switch (mgmt->u.action.u.vht_group_notif.action_code) {
   1448		case WLAN_VHT_ACTION_OPMODE_NOTIF: {
   1449			struct ieee80211_rx_status *status;
   1450			enum nl80211_band band;
   1451			struct sta_info *sta;
   1452			u8 opmode;
   1453
   1454			status = IEEE80211_SKB_RXCB(skb);
   1455			band = status->band;
   1456			opmode = mgmt->u.action.u.vht_opmode_notif.operating_mode;
   1457
   1458			mutex_lock(&local->sta_mtx);
   1459			sta = sta_info_get_bss(sdata, mgmt->sa);
   1460
   1461			if (sta)
   1462				ieee80211_vht_handle_opmode(sdata, sta, opmode,
   1463							    band);
   1464
   1465			mutex_unlock(&local->sta_mtx);
   1466			break;
   1467		}
   1468		case WLAN_VHT_ACTION_GROUPID_MGMT:
   1469			ieee80211_process_mu_groups(sdata, mgmt);
   1470			break;
   1471		default:
   1472			WARN_ON(1);
   1473			break;
   1474		}
   1475	} else if (ieee80211_is_action(mgmt->frame_control) &&
   1476		   mgmt->u.action.category == WLAN_CATEGORY_S1G) {
   1477		switch (mgmt->u.action.u.s1g.action_code) {
   1478		case WLAN_S1G_TWT_TEARDOWN:
   1479		case WLAN_S1G_TWT_SETUP:
   1480			ieee80211_s1g_rx_twt_action(sdata, skb);
   1481			break;
   1482		default:
   1483			break;
   1484		}
   1485	} else if (ieee80211_is_ext(mgmt->frame_control)) {
   1486		if (sdata->vif.type == NL80211_IFTYPE_STATION)
   1487			ieee80211_sta_rx_queued_ext(sdata, skb);
   1488		else
   1489			WARN_ON(1);
   1490	} else if (ieee80211_is_data_qos(mgmt->frame_control)) {
   1491		struct ieee80211_hdr *hdr = (void *)mgmt;
   1492		struct sta_info *sta;
   1493
   1494		/*
   1495		 * So the frame isn't mgmt, but frame_control
   1496		 * is at the right place anyway, of course, so
   1497		 * the if statement is correct.
   1498		 *
   1499		 * Warn if we have other data frame types here,
   1500		 * they must not get here.
   1501		 */
   1502		WARN_ON(hdr->frame_control &
   1503				cpu_to_le16(IEEE80211_STYPE_NULLFUNC));
   1504		WARN_ON(!(hdr->seq_ctrl &
   1505				cpu_to_le16(IEEE80211_SCTL_FRAG)));
   1506		/*
   1507		 * This was a fragment of a frame, received while
   1508		 * a block-ack session was active. That cannot be
   1509		 * right, so terminate the session.
   1510		 */
   1511		mutex_lock(&local->sta_mtx);
   1512		sta = sta_info_get_bss(sdata, mgmt->sa);
   1513		if (sta) {
   1514			u16 tid = ieee80211_get_tid(hdr);
   1515
   1516			__ieee80211_stop_rx_ba_session(
   1517				sta, tid, WLAN_BACK_RECIPIENT,
   1518				WLAN_REASON_QSTA_REQUIRE_SETUP,
   1519				true);
   1520		}
   1521		mutex_unlock(&local->sta_mtx);
   1522	} else switch (sdata->vif.type) {
   1523	case NL80211_IFTYPE_STATION:
   1524		ieee80211_sta_rx_queued_mgmt(sdata, skb);
   1525		break;
   1526	case NL80211_IFTYPE_ADHOC:
   1527		ieee80211_ibss_rx_queued_mgmt(sdata, skb);
   1528		break;
   1529	case NL80211_IFTYPE_MESH_POINT:
   1530		if (!ieee80211_vif_is_mesh(&sdata->vif))
   1531			break;
   1532		ieee80211_mesh_rx_queued_mgmt(sdata, skb);
   1533		break;
   1534	default:
   1535		WARN(1, "frame for unexpected interface type");
   1536		break;
   1537	}
   1538}
   1539
   1540static void ieee80211_iface_process_status(struct ieee80211_sub_if_data *sdata,
   1541					   struct sk_buff *skb)
   1542{
   1543	struct ieee80211_mgmt *mgmt = (void *)skb->data;
   1544
   1545	if (ieee80211_is_action(mgmt->frame_control) &&
   1546	    mgmt->u.action.category == WLAN_CATEGORY_S1G) {
   1547		switch (mgmt->u.action.u.s1g.action_code) {
   1548		case WLAN_S1G_TWT_TEARDOWN:
   1549		case WLAN_S1G_TWT_SETUP:
   1550			ieee80211_s1g_status_twt_action(sdata, skb);
   1551			break;
   1552		default:
   1553			break;
   1554		}
   1555	}
   1556}
   1557
   1558static void ieee80211_iface_work(struct work_struct *work)
   1559{
   1560	struct ieee80211_sub_if_data *sdata =
   1561		container_of(work, struct ieee80211_sub_if_data, work);
   1562	struct ieee80211_local *local = sdata->local;
   1563	struct sk_buff *skb;
   1564
   1565	if (!ieee80211_sdata_running(sdata))
   1566		return;
   1567
   1568	if (test_bit(SCAN_SW_SCANNING, &local->scanning))
   1569		return;
   1570
   1571	if (!ieee80211_can_run_worker(local))
   1572		return;
   1573
   1574	/* first process frames */
   1575	while ((skb = skb_dequeue(&sdata->skb_queue))) {
   1576		kcov_remote_start_common(skb_get_kcov_handle(skb));
   1577
   1578		if (skb->protocol == cpu_to_be16(ETH_P_TDLS))
   1579			ieee80211_process_tdls_channel_switch(sdata, skb);
   1580		else
   1581			ieee80211_iface_process_skb(local, sdata, skb);
   1582
   1583		kfree_skb(skb);
   1584		kcov_remote_stop();
   1585	}
   1586
   1587	/* process status queue */
   1588	while ((skb = skb_dequeue(&sdata->status_queue))) {
   1589		kcov_remote_start_common(skb_get_kcov_handle(skb));
   1590
   1591		ieee80211_iface_process_status(sdata, skb);
   1592		kfree_skb(skb);
   1593
   1594		kcov_remote_stop();
   1595	}
   1596
   1597	/* then other type-dependent work */
   1598	switch (sdata->vif.type) {
   1599	case NL80211_IFTYPE_STATION:
   1600		ieee80211_sta_work(sdata);
   1601		break;
   1602	case NL80211_IFTYPE_ADHOC:
   1603		ieee80211_ibss_work(sdata);
   1604		break;
   1605	case NL80211_IFTYPE_MESH_POINT:
   1606		if (!ieee80211_vif_is_mesh(&sdata->vif))
   1607			break;
   1608		ieee80211_mesh_work(sdata);
   1609		break;
   1610	case NL80211_IFTYPE_OCB:
   1611		ieee80211_ocb_work(sdata);
   1612		break;
   1613	default:
   1614		break;
   1615	}
   1616}
   1617
   1618static void ieee80211_recalc_smps_work(struct work_struct *work)
   1619{
   1620	struct ieee80211_sub_if_data *sdata =
   1621		container_of(work, struct ieee80211_sub_if_data, recalc_smps);
   1622
   1623	ieee80211_recalc_smps(sdata);
   1624}
   1625
   1626/*
   1627 * Helper function to initialise an interface to a specific type.
   1628 */
   1629static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
   1630				  enum nl80211_iftype type)
   1631{
   1632	static const u8 bssid_wildcard[ETH_ALEN] = {0xff, 0xff, 0xff,
   1633						    0xff, 0xff, 0xff};
   1634
   1635	/* clear type-dependent union */
   1636	memset(&sdata->u, 0, sizeof(sdata->u));
   1637
   1638	/* and set some type-dependent values */
   1639	sdata->vif.type = type;
   1640	sdata->vif.p2p = false;
   1641	sdata->wdev.iftype = type;
   1642
   1643	sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
   1644	sdata->control_port_no_encrypt = false;
   1645	sdata->control_port_over_nl80211 = false;
   1646	sdata->control_port_no_preauth = false;
   1647	sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
   1648	sdata->vif.bss_conf.idle = true;
   1649	sdata->vif.bss_conf.txpower = INT_MIN; /* unset */
   1650
   1651	sdata->noack_map = 0;
   1652
   1653	/* only monitor/p2p-device differ */
   1654	if (sdata->dev) {
   1655		sdata->dev->netdev_ops = &ieee80211_dataif_ops;
   1656		sdata->dev->type = ARPHRD_ETHER;
   1657	}
   1658
   1659	skb_queue_head_init(&sdata->skb_queue);
   1660	skb_queue_head_init(&sdata->status_queue);
   1661	INIT_WORK(&sdata->work, ieee80211_iface_work);
   1662	INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);
   1663	INIT_WORK(&sdata->csa_finalize_work, ieee80211_csa_finalize_work);
   1664	INIT_WORK(&sdata->color_change_finalize_work, ieee80211_color_change_finalize_work);
   1665	INIT_LIST_HEAD(&sdata->assigned_chanctx_list);
   1666	INIT_LIST_HEAD(&sdata->reserved_chanctx_list);
   1667
   1668	switch (type) {
   1669	case NL80211_IFTYPE_P2P_GO:
   1670		type = NL80211_IFTYPE_AP;
   1671		sdata->vif.type = type;
   1672		sdata->vif.p2p = true;
   1673		fallthrough;
   1674	case NL80211_IFTYPE_AP:
   1675		skb_queue_head_init(&sdata->u.ap.ps.bc_buf);
   1676		INIT_LIST_HEAD(&sdata->u.ap.vlans);
   1677		sdata->vif.bss_conf.bssid = sdata->vif.addr;
   1678		break;
   1679	case NL80211_IFTYPE_P2P_CLIENT:
   1680		type = NL80211_IFTYPE_STATION;
   1681		sdata->vif.type = type;
   1682		sdata->vif.p2p = true;
   1683		fallthrough;
   1684	case NL80211_IFTYPE_STATION:
   1685		sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid;
   1686		ieee80211_sta_setup_sdata(sdata);
   1687		break;
   1688	case NL80211_IFTYPE_OCB:
   1689		sdata->vif.bss_conf.bssid = bssid_wildcard;
   1690		ieee80211_ocb_setup_sdata(sdata);
   1691		break;
   1692	case NL80211_IFTYPE_ADHOC:
   1693		sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
   1694		ieee80211_ibss_setup_sdata(sdata);
   1695		break;
   1696	case NL80211_IFTYPE_MESH_POINT:
   1697		if (ieee80211_vif_is_mesh(&sdata->vif))
   1698			ieee80211_mesh_init_sdata(sdata);
   1699		break;
   1700	case NL80211_IFTYPE_MONITOR:
   1701		sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
   1702		sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
   1703		sdata->u.mntr.flags = MONITOR_FLAG_CONTROL |
   1704				      MONITOR_FLAG_OTHER_BSS;
   1705		break;
   1706	case NL80211_IFTYPE_NAN:
   1707		idr_init(&sdata->u.nan.function_inst_ids);
   1708		spin_lock_init(&sdata->u.nan.func_lock);
   1709		sdata->vif.bss_conf.bssid = sdata->vif.addr;
   1710		break;
   1711	case NL80211_IFTYPE_AP_VLAN:
   1712	case NL80211_IFTYPE_P2P_DEVICE:
   1713		sdata->vif.bss_conf.bssid = sdata->vif.addr;
   1714		break;
   1715	case NL80211_IFTYPE_UNSPECIFIED:
   1716	case NL80211_IFTYPE_WDS:
   1717	case NUM_NL80211_IFTYPES:
   1718		WARN_ON(1);
   1719		break;
   1720	}
   1721
   1722	ieee80211_debugfs_add_netdev(sdata);
   1723}
   1724
   1725static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,
   1726					   enum nl80211_iftype type)
   1727{
   1728	struct ieee80211_local *local = sdata->local;
   1729	int ret, err;
   1730	enum nl80211_iftype internal_type = type;
   1731	bool p2p = false;
   1732
   1733	ASSERT_RTNL();
   1734
   1735	if (!local->ops->change_interface)
   1736		return -EBUSY;
   1737
   1738	switch (sdata->vif.type) {
   1739	case NL80211_IFTYPE_AP:
   1740		if (!list_empty(&sdata->u.ap.vlans))
   1741			return -EBUSY;
   1742		break;
   1743	case NL80211_IFTYPE_STATION:
   1744	case NL80211_IFTYPE_ADHOC:
   1745	case NL80211_IFTYPE_OCB:
   1746		/*
   1747		 * Could maybe also all others here?
   1748		 * Just not sure how that interacts
   1749		 * with the RX/config path e.g. for
   1750		 * mesh.
   1751		 */
   1752		break;
   1753	default:
   1754		return -EBUSY;
   1755	}
   1756
   1757	switch (type) {
   1758	case NL80211_IFTYPE_AP:
   1759	case NL80211_IFTYPE_STATION:
   1760	case NL80211_IFTYPE_ADHOC:
   1761	case NL80211_IFTYPE_OCB:
   1762		/*
   1763		 * Could probably support everything
   1764		 * but here.
   1765		 */
   1766		break;
   1767	case NL80211_IFTYPE_P2P_CLIENT:
   1768		p2p = true;
   1769		internal_type = NL80211_IFTYPE_STATION;
   1770		break;
   1771	case NL80211_IFTYPE_P2P_GO:
   1772		p2p = true;
   1773		internal_type = NL80211_IFTYPE_AP;
   1774		break;
   1775	default:
   1776		return -EBUSY;
   1777	}
   1778
   1779	ret = ieee80211_check_concurrent_iface(sdata, internal_type);
   1780	if (ret)
   1781		return ret;
   1782
   1783	ieee80211_stop_vif_queues(local, sdata,
   1784				  IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE);
   1785	synchronize_net();
   1786
   1787	ieee80211_do_stop(sdata, false);
   1788
   1789	ieee80211_teardown_sdata(sdata);
   1790
   1791	ieee80211_set_sdata_offload_flags(sdata);
   1792	ret = drv_change_interface(local, sdata, internal_type, p2p);
   1793	if (ret)
   1794		type = ieee80211_vif_type_p2p(&sdata->vif);
   1795
   1796	/*
   1797	 * Ignore return value here, there's not much we can do since
   1798	 * the driver changed the interface type internally already.
   1799	 * The warnings will hopefully make driver authors fix it :-)
   1800	 */
   1801	ieee80211_check_queues(sdata, type);
   1802
   1803	ieee80211_setup_sdata(sdata, type);
   1804	ieee80211_set_vif_encap_ops(sdata);
   1805
   1806	err = ieee80211_do_open(&sdata->wdev, false);
   1807	WARN(err, "type change: do_open returned %d", err);
   1808
   1809	ieee80211_wake_vif_queues(local, sdata,
   1810				  IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE);
   1811	return ret;
   1812}
   1813
   1814int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
   1815			     enum nl80211_iftype type)
   1816{
   1817	int ret;
   1818
   1819	ASSERT_RTNL();
   1820
   1821	if (type == ieee80211_vif_type_p2p(&sdata->vif))
   1822		return 0;
   1823
   1824	if (ieee80211_sdata_running(sdata)) {
   1825		ret = ieee80211_runtime_change_iftype(sdata, type);
   1826		if (ret)
   1827			return ret;
   1828	} else {
   1829		/* Purge and reset type-dependent state. */
   1830		ieee80211_teardown_sdata(sdata);
   1831		ieee80211_setup_sdata(sdata, type);
   1832	}
   1833
   1834	/* reset some values that shouldn't be kept across type changes */
   1835	if (type == NL80211_IFTYPE_STATION)
   1836		sdata->u.mgd.use_4addr = false;
   1837
   1838	return 0;
   1839}
   1840
   1841static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
   1842				       u8 *perm_addr, enum nl80211_iftype type)
   1843{
   1844	struct ieee80211_sub_if_data *sdata;
   1845	u64 mask, start, addr, val, inc;
   1846	u8 *m;
   1847	u8 tmp_addr[ETH_ALEN];
   1848	int i;
   1849
   1850	/* default ... something at least */
   1851	memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
   1852
   1853	if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
   1854	    local->hw.wiphy->n_addresses <= 1)
   1855		return;
   1856
   1857	mutex_lock(&local->iflist_mtx);
   1858
   1859	switch (type) {
   1860	case NL80211_IFTYPE_MONITOR:
   1861		/* doesn't matter */
   1862		break;
   1863	case NL80211_IFTYPE_AP_VLAN:
   1864		/* match up with an AP interface */
   1865		list_for_each_entry(sdata, &local->interfaces, list) {
   1866			if (sdata->vif.type != NL80211_IFTYPE_AP)
   1867				continue;
   1868			memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
   1869			break;
   1870		}
   1871		/* keep default if no AP interface present */
   1872		break;
   1873	case NL80211_IFTYPE_P2P_CLIENT:
   1874	case NL80211_IFTYPE_P2P_GO:
   1875		if (ieee80211_hw_check(&local->hw, P2P_DEV_ADDR_FOR_INTF)) {
   1876			list_for_each_entry(sdata, &local->interfaces, list) {
   1877				if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
   1878					continue;
   1879				if (!ieee80211_sdata_running(sdata))
   1880					continue;
   1881				memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
   1882				goto out_unlock;
   1883			}
   1884		}
   1885		fallthrough;
   1886	default:
   1887		/* assign a new address if possible -- try n_addresses first */
   1888		for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
   1889			bool used = false;
   1890
   1891			list_for_each_entry(sdata, &local->interfaces, list) {
   1892				if (ether_addr_equal(local->hw.wiphy->addresses[i].addr,
   1893						     sdata->vif.addr)) {
   1894					used = true;
   1895					break;
   1896				}
   1897			}
   1898
   1899			if (!used) {
   1900				memcpy(perm_addr,
   1901				       local->hw.wiphy->addresses[i].addr,
   1902				       ETH_ALEN);
   1903				break;
   1904			}
   1905		}
   1906
   1907		/* try mask if available */
   1908		if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
   1909			break;
   1910
   1911		m = local->hw.wiphy->addr_mask;
   1912		mask =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
   1913			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
   1914			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
   1915
   1916		if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
   1917			/* not a contiguous mask ... not handled now! */
   1918			pr_info("not contiguous\n");
   1919			break;
   1920		}
   1921
   1922		/*
   1923		 * Pick address of existing interface in case user changed
   1924		 * MAC address manually, default to perm_addr.
   1925		 */
   1926		m = local->hw.wiphy->perm_addr;
   1927		list_for_each_entry(sdata, &local->interfaces, list) {
   1928			if (sdata->vif.type == NL80211_IFTYPE_MONITOR)
   1929				continue;
   1930			m = sdata->vif.addr;
   1931			break;
   1932		}
   1933		start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
   1934			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
   1935			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
   1936
   1937		inc = 1ULL<<__ffs64(mask);
   1938		val = (start & mask);
   1939		addr = (start & ~mask) | (val & mask);
   1940		do {
   1941			bool used = false;
   1942
   1943			tmp_addr[5] = addr >> 0*8;
   1944			tmp_addr[4] = addr >> 1*8;
   1945			tmp_addr[3] = addr >> 2*8;
   1946			tmp_addr[2] = addr >> 3*8;
   1947			tmp_addr[1] = addr >> 4*8;
   1948			tmp_addr[0] = addr >> 5*8;
   1949
   1950			val += inc;
   1951
   1952			list_for_each_entry(sdata, &local->interfaces, list) {
   1953				if (ether_addr_equal(tmp_addr, sdata->vif.addr)) {
   1954					used = true;
   1955					break;
   1956				}
   1957			}
   1958
   1959			if (!used) {
   1960				memcpy(perm_addr, tmp_addr, ETH_ALEN);
   1961				break;
   1962			}
   1963			addr = (start & ~mask) | (val & mask);
   1964		} while (addr != start);
   1965
   1966		break;
   1967	}
   1968
   1969 out_unlock:
   1970	mutex_unlock(&local->iflist_mtx);
   1971}
   1972
   1973int ieee80211_if_add(struct ieee80211_local *local, const char *name,
   1974		     unsigned char name_assign_type,
   1975		     struct wireless_dev **new_wdev, enum nl80211_iftype type,
   1976		     struct vif_params *params)
   1977{
   1978	struct net_device *ndev = NULL;
   1979	struct ieee80211_sub_if_data *sdata = NULL;
   1980	struct txq_info *txqi;
   1981	void (*if_setup)(struct net_device *dev);
   1982	int ret, i;
   1983	int txqs = 1;
   1984
   1985	ASSERT_RTNL();
   1986
   1987	if (type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN) {
   1988		struct wireless_dev *wdev;
   1989
   1990		sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size,
   1991				GFP_KERNEL);
   1992		if (!sdata)
   1993			return -ENOMEM;
   1994		wdev = &sdata->wdev;
   1995
   1996		sdata->dev = NULL;
   1997		strlcpy(sdata->name, name, IFNAMSIZ);
   1998		ieee80211_assign_perm_addr(local, wdev->address, type);
   1999		memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);
   2000	} else {
   2001		int size = ALIGN(sizeof(*sdata) + local->hw.vif_data_size,
   2002				 sizeof(void *));
   2003		int txq_size = 0;
   2004
   2005		if (local->ops->wake_tx_queue &&
   2006		    type != NL80211_IFTYPE_AP_VLAN &&
   2007		    (type != NL80211_IFTYPE_MONITOR ||
   2008		     (params->flags & MONITOR_FLAG_ACTIVE)))
   2009			txq_size += sizeof(struct txq_info) +
   2010				    local->hw.txq_data_size;
   2011
   2012		if (local->ops->wake_tx_queue) {
   2013			if_setup = ieee80211_if_setup_no_queue;
   2014		} else {
   2015			if_setup = ieee80211_if_setup;
   2016			if (local->hw.queues >= IEEE80211_NUM_ACS)
   2017				txqs = IEEE80211_NUM_ACS;
   2018		}
   2019
   2020		ndev = alloc_netdev_mqs(size + txq_size,
   2021					name, name_assign_type,
   2022					if_setup, txqs, 1);
   2023		if (!ndev)
   2024			return -ENOMEM;
   2025
   2026		if (!local->ops->wake_tx_queue && local->hw.wiphy->tx_queue_len)
   2027			ndev->tx_queue_len = local->hw.wiphy->tx_queue_len;
   2028
   2029		dev_net_set(ndev, wiphy_net(local->hw.wiphy));
   2030
   2031		ndev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
   2032		if (!ndev->tstats) {
   2033			free_netdev(ndev);
   2034			return -ENOMEM;
   2035		}
   2036
   2037		ndev->needed_headroom = local->tx_headroom +
   2038					4*6 /* four MAC addresses */
   2039					+ 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
   2040					+ 6 /* mesh */
   2041					+ 8 /* rfc1042/bridge tunnel */
   2042					- ETH_HLEN /* ethernet hard_header_len */
   2043					+ IEEE80211_ENCRYPT_HEADROOM;
   2044		ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
   2045
   2046		ret = dev_alloc_name(ndev, ndev->name);
   2047		if (ret < 0) {
   2048			ieee80211_if_free(ndev);
   2049			free_netdev(ndev);
   2050			return ret;
   2051		}
   2052
   2053		ieee80211_assign_perm_addr(local, ndev->perm_addr, type);
   2054		if (is_valid_ether_addr(params->macaddr))
   2055			eth_hw_addr_set(ndev, params->macaddr);
   2056		else
   2057			eth_hw_addr_set(ndev, ndev->perm_addr);
   2058		SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
   2059
   2060		/* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */
   2061		sdata = netdev_priv(ndev);
   2062		ndev->ieee80211_ptr = &sdata->wdev;
   2063		memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
   2064		memcpy(sdata->name, ndev->name, IFNAMSIZ);
   2065
   2066		if (txq_size) {
   2067			txqi = netdev_priv(ndev) + size;
   2068			ieee80211_txq_init(sdata, NULL, txqi, 0);
   2069		}
   2070
   2071		sdata->dev = ndev;
   2072	}
   2073
   2074	/* initialise type-independent data */
   2075	sdata->wdev.wiphy = local->hw.wiphy;
   2076	sdata->local = local;
   2077
   2078	ieee80211_init_frag_cache(&sdata->frags);
   2079
   2080	INIT_LIST_HEAD(&sdata->key_list);
   2081
   2082	INIT_DELAYED_WORK(&sdata->dfs_cac_timer_work,
   2083			  ieee80211_dfs_cac_timer_work);
   2084	INIT_DELAYED_WORK(&sdata->dec_tailroom_needed_wk,
   2085			  ieee80211_delayed_tailroom_dec);
   2086
   2087	for (i = 0; i < NUM_NL80211_BANDS; i++) {
   2088		struct ieee80211_supported_band *sband;
   2089		sband = local->hw.wiphy->bands[i];
   2090		sdata->rc_rateidx_mask[i] =
   2091			sband ? (1 << sband->n_bitrates) - 1 : 0;
   2092		if (sband) {
   2093			__le16 cap;
   2094			u16 *vht_rate_mask;
   2095
   2096			memcpy(sdata->rc_rateidx_mcs_mask[i],
   2097			       sband->ht_cap.mcs.rx_mask,
   2098			       sizeof(sdata->rc_rateidx_mcs_mask[i]));
   2099
   2100			cap = sband->vht_cap.vht_mcs.rx_mcs_map;
   2101			vht_rate_mask = sdata->rc_rateidx_vht_mcs_mask[i];
   2102			ieee80211_get_vht_mask_from_cap(cap, vht_rate_mask);
   2103		} else {
   2104			memset(sdata->rc_rateidx_mcs_mask[i], 0,
   2105			       sizeof(sdata->rc_rateidx_mcs_mask[i]));
   2106			memset(sdata->rc_rateidx_vht_mcs_mask[i], 0,
   2107			       sizeof(sdata->rc_rateidx_vht_mcs_mask[i]));
   2108		}
   2109	}
   2110
   2111	for (i = 0; i < IEEE80211_NUM_ACS; i++)
   2112		init_airtime_info(&sdata->airtime[i], &local->airtime[i]);
   2113
   2114	ieee80211_set_default_queues(sdata);
   2115
   2116	sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
   2117	sdata->user_power_level = local->user_power_level;
   2118
   2119	sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
   2120
   2121	/* setup type-dependent data */
   2122	ieee80211_setup_sdata(sdata, type);
   2123
   2124	if (ndev) {
   2125		ndev->ieee80211_ptr->use_4addr = params->use_4addr;
   2126		if (type == NL80211_IFTYPE_STATION)
   2127			sdata->u.mgd.use_4addr = params->use_4addr;
   2128
   2129		ndev->features |= local->hw.netdev_features;
   2130		ndev->hw_features |= ndev->features &
   2131					MAC80211_SUPPORTED_FEATURES_TX;
   2132
   2133		netdev_set_default_ethtool_ops(ndev, &ieee80211_ethtool_ops);
   2134
   2135		/* MTU range is normally 256 - 2304, where the upper limit is
   2136		 * the maximum MSDU size. Monitor interfaces send and receive
   2137		 * MPDU and A-MSDU frames which may be much larger so we do
   2138		 * not impose an upper limit in that case.
   2139		 */
   2140		ndev->min_mtu = 256;
   2141		if (type == NL80211_IFTYPE_MONITOR)
   2142			ndev->max_mtu = 0;
   2143		else
   2144			ndev->max_mtu = local->hw.max_mtu;
   2145
   2146		ret = cfg80211_register_netdevice(ndev);
   2147		if (ret) {
   2148			free_netdev(ndev);
   2149			return ret;
   2150		}
   2151	}
   2152
   2153	mutex_lock(&local->iflist_mtx);
   2154	list_add_tail_rcu(&sdata->list, &local->interfaces);
   2155	mutex_unlock(&local->iflist_mtx);
   2156
   2157	if (new_wdev)
   2158		*new_wdev = &sdata->wdev;
   2159
   2160	return 0;
   2161}
   2162
   2163void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
   2164{
   2165	ASSERT_RTNL();
   2166
   2167	mutex_lock(&sdata->local->iflist_mtx);
   2168	list_del_rcu(&sdata->list);
   2169	mutex_unlock(&sdata->local->iflist_mtx);
   2170
   2171	if (sdata->vif.txq)
   2172		ieee80211_txq_purge(sdata->local, to_txq_info(sdata->vif.txq));
   2173
   2174	synchronize_rcu();
   2175
   2176	cfg80211_unregister_wdev(&sdata->wdev);
   2177
   2178	if (!sdata->dev) {
   2179		ieee80211_teardown_sdata(sdata);
   2180		kfree(sdata);
   2181	}
   2182}
   2183
   2184void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata)
   2185{
   2186	if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state)))
   2187		return;
   2188	ieee80211_do_stop(sdata, true);
   2189}
   2190
   2191void ieee80211_remove_interfaces(struct ieee80211_local *local)
   2192{
   2193	struct ieee80211_sub_if_data *sdata, *tmp;
   2194	LIST_HEAD(unreg_list);
   2195	LIST_HEAD(wdev_list);
   2196
   2197	ASSERT_RTNL();
   2198
   2199	/* Before destroying the interfaces, make sure they're all stopped so
   2200	 * that the hardware is stopped. Otherwise, the driver might still be
   2201	 * iterating the interfaces during the shutdown, e.g. from a worker
   2202	 * or from RX processing or similar, and if it does so (using atomic
   2203	 * iteration) while we're manipulating the list, the iteration will
   2204	 * crash.
   2205	 *
   2206	 * After this, the hardware should be stopped and the driver should
   2207	 * have stopped all of its activities, so that we can do RCU-unaware
   2208	 * manipulations of the interface list below.
   2209	 */
   2210	cfg80211_shutdown_all_interfaces(local->hw.wiphy);
   2211
   2212	WARN(local->open_count, "%s: open count remains %d\n",
   2213	     wiphy_name(local->hw.wiphy), local->open_count);
   2214
   2215	ieee80211_txq_teardown_flows(local);
   2216
   2217	mutex_lock(&local->iflist_mtx);
   2218	list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
   2219		list_del(&sdata->list);
   2220
   2221		if (sdata->dev)
   2222			unregister_netdevice_queue(sdata->dev, &unreg_list);
   2223		else
   2224			list_add(&sdata->list, &wdev_list);
   2225	}
   2226	mutex_unlock(&local->iflist_mtx);
   2227
   2228	unregister_netdevice_many(&unreg_list);
   2229
   2230	wiphy_lock(local->hw.wiphy);
   2231	list_for_each_entry_safe(sdata, tmp, &wdev_list, list) {
   2232		list_del(&sdata->list);
   2233		cfg80211_unregister_wdev(&sdata->wdev);
   2234		kfree(sdata);
   2235	}
   2236	wiphy_unlock(local->hw.wiphy);
   2237}
   2238
   2239static int netdev_notify(struct notifier_block *nb,
   2240			 unsigned long state, void *ptr)
   2241{
   2242	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
   2243	struct ieee80211_sub_if_data *sdata;
   2244
   2245	if (state != NETDEV_CHANGENAME)
   2246		return NOTIFY_DONE;
   2247
   2248	if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
   2249		return NOTIFY_DONE;
   2250
   2251	if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
   2252		return NOTIFY_DONE;
   2253
   2254	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
   2255	memcpy(sdata->name, dev->name, IFNAMSIZ);
   2256	ieee80211_debugfs_rename_netdev(sdata);
   2257
   2258	return NOTIFY_OK;
   2259}
   2260
   2261static struct notifier_block mac80211_netdev_notifier = {
   2262	.notifier_call = netdev_notify,
   2263};
   2264
   2265int ieee80211_iface_init(void)
   2266{
   2267	return register_netdevice_notifier(&mac80211_netdev_notifier);
   2268}
   2269
   2270void ieee80211_iface_exit(void)
   2271{
   2272	unregister_netdevice_notifier(&mac80211_netdev_notifier);
   2273}
   2274
   2275void ieee80211_vif_inc_num_mcast(struct ieee80211_sub_if_data *sdata)
   2276{
   2277	if (sdata->vif.type == NL80211_IFTYPE_AP)
   2278		atomic_inc(&sdata->u.ap.num_mcast_sta);
   2279	else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
   2280		atomic_inc(&sdata->u.vlan.num_mcast_sta);
   2281}
   2282
   2283void ieee80211_vif_dec_num_mcast(struct ieee80211_sub_if_data *sdata)
   2284{
   2285	if (sdata->vif.type == NL80211_IFTYPE_AP)
   2286		atomic_dec(&sdata->u.ap.num_mcast_sta);
   2287	else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
   2288		atomic_dec(&sdata->u.vlan.num_mcast_sta);
   2289}