iface.c 62 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2
/*
3
 * Interface handling
4
 *
5 6 7
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005-2006, Devicescape Software, Inc.
 * 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-2024 Intel Corporation
12
 */
13
#include <linux/slab.h>
14 15 16 17
#include <linux/kernel.h>
#include <linux/if_arp.h>
#include <linux/netdevice.h>
#include <linux/rtnetlink.h>
18
#include <linux/kcov.h>
19
#include <net/mac80211.h>
20
#include <net/ieee80211_radiotap.h>
21 22
#include "ieee80211_i.h"
#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 32 33 34 35
/**
 * DOC: Interface list locking
 *
 * The interface list in each struct ieee80211_local is protected
 * three-fold:
 *
36 37 38
 * (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
39 40 41
 *     can traverse the list in RCU-safe blocks.
 *
 * As a consequence, reads (traversals) of the list can be protected
42
 * by either the RTNL, the wiphy mutex, the iflist_mtx or RCU.
43 44
 */

45
static void ieee80211_iface_work(struct wiphy *wiphy, struct wiphy_work *work);
46

47 48 49 50 51 52
bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_chanctx_conf *chanctx_conf;
	int power;

	rcu_read_lock();
53
	chanctx_conf = rcu_dereference(sdata->vif.bss_conf.chanctx_conf);
54 55 56 57 58
	if (!chanctx_conf) {
		rcu_read_unlock();
		return false;
	}

59
	power = ieee80211_chandef_max_power(&chanctx_conf->def);
60 61
	rcu_read_unlock();

62 63
	if (sdata->deflink.user_power_level != IEEE80211_UNSET_POWER_LEVEL)
		power = min(power, sdata->deflink.user_power_level);
64

65 66
	if (sdata->deflink.ap_power_level != IEEE80211_UNSET_POWER_LEVEL)
		power = min(power, sdata->deflink.ap_power_level);
67 68 69 70 71 72 73 74 75 76

	if (power != sdata->vif.bss_conf.txpower) {
		sdata->vif.bss_conf.txpower = power;
		ieee80211_hw_config(sdata->local, 0);
		return true;
	}

	return false;
}

77 78
void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata,
			      bool update_bss)
79
{
80 81
	if (__ieee80211_recalc_txpower(sdata) ||
	    (update_bss && ieee80211_sdata_running(sdata)))
82
		ieee80211_link_info_change_notify(sdata, &sdata->deflink,
83
						  BSS_CHANGED_TXPOWER);
84
}
85

86
static u32 __ieee80211_idle_off(struct ieee80211_local *local)
87 88 89 90 91 92 93 94
{
	if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
		return 0;

	local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
	return IEEE80211_CONF_CHANGE_IDLE;
}

95
static u32 __ieee80211_idle_on(struct ieee80211_local *local)
96 97 98 99
{
	if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
		return 0;

100
	ieee80211_flush_queues(local, NULL, false);
101 102 103 104 105

	local->hw.conf.flags |= IEEE80211_CONF_IDLE;
	return IEEE80211_CONF_CHANGE_IDLE;
}

106 107
static u32 __ieee80211_recalc_idle(struct ieee80211_local *local,
				   bool force_active)
108
{
109
	bool working, scanning, active;
110 111
	unsigned int led_trig_start = 0, led_trig_stop = 0;

112
	lockdep_assert_wiphy(local->hw.wiphy);
113

114 115 116
	active = force_active ||
		 !list_empty(&local->chanctx_list) ||
		 local->monitors;
117

118 119
	working = !local->ops->remain_on_channel &&
		  !list_empty(&local->roc_list);
120

121 122
	scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
		   test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
123 124 125 126 127 128

	if (working || scanning)
		led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
	else
		led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;

129
	if (active)
130 131 132 133 134 135
		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);

136
	if (working || scanning || active)
137 138 139 140 141 142 143 144 145 146 147 148
		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);
149 150
	if (change)
		ieee80211_hw_config(local, change);
151 152
}

153
static int ieee80211_verify_mac(struct ieee80211_sub_if_data *sdata, u8 *addr,
154
				bool check_dup)
155
{
156 157
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_sub_if_data *iter;
158 159 160 161
	u64 new, mask, tmp;
	u8 *m;
	int ret = 0;

162 163
	lockdep_assert_wiphy(local->hw.wiphy);

164 165 166 167 168 169 170 171 172 173 174 175 176
	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);

177 178
	if (!check_dup)
		return ret;
179

180 181
	list_for_each_entry(iter, &local->interfaces, list) {
		if (iter == sdata)
182 183
			continue;

184
		if (iter->vif.type == NL80211_IFTYPE_MONITOR &&
185
		    !(iter->u.mntr.flags & MONITOR_FLAG_ACTIVE))
186 187
			continue;

188
		m = iter->vif.addr;
189 190 191 192 193 194 195 196 197 198 199 200 201
		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;
}

202 203 204 205 206 207 208
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;

209 210
	lockdep_assert_wiphy(local->hw.wiphy);

211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	/* 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,
232
						       lockdep_is_held(&local->hw.wiphy->mtx));
233 234 235 236 237 238 239 240 241 242 243 244
		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:
245
		ret = -EOPNOTSUPP;
246 247 248 249 250 251
	}

unlock:
	return ret;
}

252 253
static int _ieee80211_change_mac(struct ieee80211_sub_if_data *sdata,
				 void *addr)
254
{
255
	struct ieee80211_local *local = sdata->local;
256
	struct sockaddr *sa = addr;
257
	bool check_dup = true;
258
	bool live = false;
259 260
	int ret;

261 262 263 264 265 266 267
	if (ieee80211_sdata_running(sdata)) {
		ret = ieee80211_can_powered_addr_change(sdata);
		if (ret)
			return ret;

		live = true;
	}
268

269
	if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
270
	    !(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
271 272
		check_dup = false;

273
	ret = ieee80211_verify_mac(sdata, sa->sa_data, check_dup);
274 275 276
	if (ret)
		return ret;

277 278
	if (live)
		drv_remove_interface(local, sdata);
279
	ret = eth_mac_addr(sdata->dev, sa);
280

281
	if (ret == 0) {
282
		memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
283 284
		ether_addr_copy(sdata->vif.bss_conf.addr, sdata->vif.addr);
	}
285

286 287 288 289 290 291
	/* 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));

292 293 294
	return ret;
}

295 296 297 298 299 300
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;

301 302 303 304 305 306 307 308
	/*
	 * 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;

309 310 311 312 313 314 315
	wiphy_lock(local->hw.wiphy);
	ret = _ieee80211_change_mac(sdata, addr);
	wiphy_unlock(local->hw.wiphy);

	return ret;
}

316 317 318 319
static inline int identical_mac_addr_allowed(int type1, int type2)
{
	return type1 == NL80211_IFTYPE_MONITOR ||
		type2 == NL80211_IFTYPE_MONITOR ||
320 321
		type1 == NL80211_IFTYPE_P2P_DEVICE ||
		type2 == NL80211_IFTYPE_P2P_DEVICE ||
322 323 324 325 326 327
		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
		(type1 == NL80211_IFTYPE_AP_VLAN &&
			(type2 == NL80211_IFTYPE_AP ||
			 type2 == NL80211_IFTYPE_AP_VLAN));
}

328 329
static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
					    enum nl80211_iftype iftype)
330
{
331
	struct ieee80211_local *local = sdata->local;
332
	struct ieee80211_sub_if_data *nsdata;
333

334
	ASSERT_RTNL();
335
	lockdep_assert_wiphy(local->hw.wiphy);
336 337 338

	/* we hold the RTNL here so can safely walk the list */
	list_for_each_entry(nsdata, &local->interfaces, list) {
339
		if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
340 341 342 343 344 345 346 347 348
			/*
			 * 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;

349 350 351 352 353 354 355 356 357 358
			/*
			 * 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...
			 */
359
			if (iftype == NL80211_IFTYPE_ADHOC &&
360 361
			    nsdata->vif.type == NL80211_IFTYPE_ADHOC)
				return -EBUSY;
362 363 364 365
			/*
			 * will not add another interface while any channel
			 * switch is active.
			 */
366
			if (nsdata->vif.bss_conf.csa_active)
367
				return -EBUSY;
368 369 370 371 372

			/*
			 * The remaining checks are only performed for interfaces
			 * with the same MAC address.
			 */
373 374
			if (!ether_addr_equal(sdata->vif.addr,
					      nsdata->vif.addr))
375 376 377 378 379
				continue;

			/*
			 * check whether it may have the same address
			 */
380
			if (!identical_mac_addr_allowed(iftype,
381 382 383
							nsdata->vif.type))
				return -ENOTUNIQ;

384 385
			/* No support for VLAN with MLO yet */
			if (iftype == NL80211_IFTYPE_AP_VLAN &&
386 387 388
			    sdata->wdev.use_4addr &&
			    nsdata->vif.type == NL80211_IFTYPE_AP &&
			    nsdata->vif.valid_links)
389 390
				return -EOPNOTSUPP;

391 392 393
			/*
			 * can only add VLANs to enabled APs
			 */
394
			if (iftype == NL80211_IFTYPE_AP_VLAN &&
395 396 397 398 399
			    nsdata->vif.type == NL80211_IFTYPE_AP)
				sdata->bss = &nsdata->u.ap;
		}
	}

400
	return ieee80211_check_combinations(sdata, NULL, 0, 0);
401 402
}

403 404
static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata,
				  enum nl80211_iftype iftype)
405 406 407 408
{
	int n_queues = sdata->local->hw.queues;
	int i;

409 410 411
	if (iftype == NL80211_IFTYPE_NAN)
		return 0;

412
	if (iftype != NL80211_IFTYPE_P2P_DEVICE) {
413 414 415 416 417 418 419 420
		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;
		}
421 422
	}

423 424 425
	if ((iftype != NL80211_IFTYPE_AP &&
	     iftype != NL80211_IFTYPE_P2P_GO &&
	     iftype != NL80211_IFTYPE_MESH_POINT) ||
426
	    !ieee80211_hw_check(&sdata->local->hw, QUEUE_CONTROL)) {
427 428 429 430 431 432 433 434 435 436 437 438 439
		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;
}

440
static int ieee80211_open(struct net_device *dev)
441
{
442 443 444 445 446 447 448
	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;

449
	wiphy_lock(sdata->local->hw.wiphy);
450 451
	err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
	if (err)
452
		goto out;
453

454
	err = ieee80211_do_open(&sdata->wdev, true);
455
out:
456 457 458
	wiphy_unlock(sdata->local->hw.wiphy);

	return err;
459 460
}

461
static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata, bool going_down)
462 463
{
	struct ieee80211_local *local = sdata->local;
464 465 466 467 468 469 470 471
	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;
472

473 474
	lockdep_assert_wiphy(local->hw.wiphy);

475
	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
476
	synchronize_rcu(); /* flush _ieee80211_wake_txqs() */
477

478 479 480
	cancel_scan = rcu_access_pointer(local->scan_sdata) == sdata;
	if (cancel_scan)
		ieee80211_scan_cancel(local);
481

482
	ieee80211_roc_purge(local, sdata);
483

484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
	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;
	}
499

500 501 502 503 504 505 506 507 508 509
	/*
	 * 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!)
	 *
510
	 * For AP_VLANs stations may exist since there's nothing else that
511 512 513
	 * would have removed them, but in other modes there shouldn't
	 * be any stations.
	 */
514
	flushed = sta_info_flush(sdata, -1);
515
	WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_AP_VLAN && flushed > 0);
516

517 518 519
	/* don't count this interface for allmulti while it is down */
	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
		atomic_dec(&local->iff_allmultis);
520

521 522 523 524 525
	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--;
526 527
	}

528 529 530 531 532 533 534
	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);
535 536
	}

537
	del_timer_sync(&local->dynamic_ps_timer);
538
	wiphy_work_cancel(local->hw.wiphy, &local->dynamic_ps_enable_work);
539

540
	WARN(ieee80211_vif_is_mld(&sdata->vif),
541 542 543
	     "destroying interface with valid links 0x%04x\n",
	     sdata->vif.valid_links);

544
	sdata->vif.bss_conf.csa_active = false;
545
	if (sdata->vif.type == NL80211_IFTYPE_STATION)
546
		sdata->deflink.u.mgd.csa.waiting_bcn = false;
547
	ieee80211_vif_unblock_queues_csa(sdata);
548

549
	wiphy_work_cancel(local->hw.wiphy, &sdata->deflink.csa.finalize_work);
550 551
	wiphy_work_cancel(local->hw.wiphy,
			  &sdata->deflink.color_change_finalize_work);
552
	wiphy_delayed_work_cancel(local->hw.wiphy,
553
				  &sdata->dfs_cac_timer_work);
554

555
	if (sdata->wdev.cac_started) {
556
		chandef = sdata->vif.bss_conf.chanreq.oper;
557
		WARN_ON(local->suspended);
558
		ieee80211_link_release_channel(&sdata->deflink);
559 560 561 562
		cfg80211_cac_event(sdata->dev, &chandef,
				   NL80211_RADAR_CAC_ABORTED,
				   GFP_KERNEL);
	}
563

564 565 566 567 568
	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;
569

570 571 572 573 574 575 576 577 578
		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);
579 580
	}

581 582
	if (going_down)
		local->open_count--;
583

584 585 586
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP_VLAN:
		list_del(&sdata->u.vlan.list);
587
		RCU_INIT_POINTER(sdata->vif.bss_conf.chanctx_conf, NULL);
588 589 590 591 592 593 594 595 596
		/* 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;
		}
597

598 599 600 601 602
		local->monitors--;
		if (local->monitors == 0) {
			local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
		}
603

604 605 606 607 608
		ieee80211_adjust_monitor_flags(sdata, -1);
		break;
	case NL80211_IFTYPE_NAN:
		/* clean all the functions */
		spin_lock_bh(&sdata->u.nan.func_lock);
609

610 611 612 613 614
		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);
615

616 617 618 619 620 621 622
		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:
623
		wiphy_work_cancel(sdata->local->hw.wiphy, &sdata->work);
624 625 626 627
		/*
		 * 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
628
		 * keys before the interface is operating)
629 630 631 632 633 634 635 636
		 *
		 * 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);
637
		skb_queue_purge(&sdata->status_queue);
638 639
	}

640 641 642 643 644 645 646 647 648
	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);
			}
		}
649
	}
650
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
651

652 653
	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
		ieee80211_txq_remove_vlan(local, sdata);
654

655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
	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);
673
		WARN_ON(rcu_access_pointer(local->monitor_sdata));
674
		return;
675 676
	}

677 678 679 680 681 682
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP_VLAN:
		break;
	case NL80211_IFTYPE_MONITOR:
		if (local->monitors == 0)
			ieee80211_del_virtual_monitor(local);
683

684
		ieee80211_recalc_idle(local);
685

686 687
		if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE))
			break;
688

689 690 691 692 693
		fallthrough;
	default:
		if (going_down)
			drv_remove_interface(local, sdata);
	}
694

695
	ieee80211_recalc_ps(local);
696

697
	if (cancel_scan)
698
		wiphy_delayed_work_flush(local->hw.wiphy, &local->scan_work);
699

700 701 702 703
	if (local->open_count == 0) {
		ieee80211_stop_device(local);

		/* no reconfiguring after stop! */
704 705
		return;
	}
706

707 708 709
	/* do after stop to avoid reconfiguring when we stop anyway */
	ieee80211_configure_filter(local);
	ieee80211_hw_config(local, hw_reconf_flags);
710

711 712 713
	if (local->monitors == local->open_count)
		ieee80211_add_virtual_monitor(local);
}
714

715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
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);
	}
}

742 743 744
static int ieee80211_stop(struct net_device *dev)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
745

746
	/* close dependent VLAN and MBSSID interfaces before locking wiphy */
747 748 749 750 751 752
	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);
753 754

		ieee80211_stop_mbssid(sdata);
755 756
	}

757
	wiphy_lock(sdata->local->hw.wiphy);
758 759
	wiphy_work_cancel(sdata->local->hw.wiphy, &sdata->activate_links_work);

760
	ieee80211_do_stop(sdata, true);
761
	wiphy_unlock(sdata->local->hw.wiphy);
762

763
	return 0;
764 765
}

766
static void ieee80211_set_multicast_list(struct net_device *dev)
767
{
768
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
769
	struct ieee80211_local *local = sdata->local;
770
	int allmulti, sdata_allmulti;
771

772 773
	allmulti = !!(dev->flags & IFF_ALLMULTI);
	sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
774

775 776 777 778 779 780 781
	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;
	}
782

783 784 785
	spin_lock_bh(&local->filter_lock);
	__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
	spin_unlock_bh(&local->filter_lock);
786
	wiphy_work_queue(local->hw.wiphy, &local->reconfig_filter);
787
}
788

789 790 791 792 793 794 795 796
/*
 * 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);
797

798
	ieee80211_debugfs_remove_netdev(sdata);
799

800
	ieee80211_destroy_frag_cache(&sdata->frags);
801

802 803
	if (ieee80211_vif_is_mesh(&sdata->vif))
		ieee80211_mesh_teardown_sdata(sdata);
804 805 806

	ieee80211_vif_clear_links(sdata);
	ieee80211_link_stop(&sdata->deflink);
807
}
808

809 810 811 812
static void ieee80211_uninit(struct net_device *dev)
{
	ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
}
813

814 815 816 817 818 819 820 821 822
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);
}

823 824 825 826 827 828 829
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,
830
	.ndo_setup_tc		= ieee80211_netdev_setup_tc,
831
};
832

833 834 835 836 837 838 839 840 841
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;
842

843 844
	if (local->hw.queues < IEEE80211_NUM_ACS)
		return 0;
845

846 847
	/* reset flags and info before parsing radiotap header */
	memset(info, 0, sizeof(*info));
848

849 850
	if (!ieee80211_parse_tx_radiotap(skb, dev))
		return 0; /* doesn't matter, frame will be dropped */
851

852 853 854 855 856
	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 */
857

858 859
	return ieee80211_select_queue_80211(sdata, skb, hdr);
}
860

861 862 863 864 865 866 867 868 869
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,
};
870

871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
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;
			}
		}

913
		sta = sta_info_get(sdata, sdata->deflink.u.mgd.bssid);
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
		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;
}

929 930 931 932 933 934 935
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,
936
	.ndo_fill_forward_path	= ieee80211_netdev_fill_forward_path,
937
	.ndo_setup_tc		= ieee80211_netdev_setup_tc,
938
};
939

940
static bool ieee80211_iftype_supports_hdr_offload(enum nl80211_iftype iftype)
941 942 943 944 945 946
{
	switch (iftype) {
	/* P2P GO and client are mapped to AP/STATION types */
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_STATION:
		return true;
947
	default:
948
		return false;
949
	}
950
}
951

952 953 954 955
static bool ieee80211_set_sdata_offload_flags(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	u32 flags;
956

957
	flags = sdata->vif.offload_flags;
958

959
	if (ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD) &&
960
	    ieee80211_iftype_supports_hdr_offload(sdata->vif.type)) {
961
		flags |= IEEE80211_OFFLOAD_ENCAP_ENABLED;
962

963 964 965
		if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_FRAG) &&
		    local->hw.wiphy->frag_threshold != (u32)-1)
			flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
966

967 968 969 970
		if (local->monitors)
			flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
	} else {
		flags &= ~IEEE80211_OFFLOAD_ENCAP_ENABLED;
971
	}
972

973 974 975 976
	if (ieee80211_hw_check(&local->hw, SUPPORTS_RX_DECAP_OFFLOAD) &&
	    ieee80211_iftype_supports_hdr_offload(sdata->vif.type)) {
		flags |= IEEE80211_OFFLOAD_DECAP_ENABLED;

977 978
		if (local->monitors &&
		    !ieee80211_hw_check(&local->hw, SUPPORTS_CONC_MON_RX_DECAP))
979 980 981 982 983
			flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
	} else {
		flags &= ~IEEE80211_OFFLOAD_DECAP_ENABLED;
	}

984 985 986 987
	if (sdata->vif.offload_flags == flags)
		return false;

	sdata->vif.offload_flags = flags;
988
	ieee80211_check_fast_rx_iface(sdata);
989
	return true;
990 991
}

992
static void ieee80211_set_vif_encap_ops(struct ieee80211_sub_if_data *sdata)
993
{
994 995 996
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_sub_if_data *bss = sdata;
	bool enabled;
997

998 999 1000
	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
		if (!sdata->bss)
			return;
1001

1002 1003
		bss = container_of(sdata->bss, struct ieee80211_sub_if_data, u.ap);
	}
1004

1005
	if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD) ||
1006
	    !ieee80211_iftype_supports_hdr_offload(bss->vif.type))
1007
		return;
1008

1009 1010 1011 1012
	enabled = bss->vif.offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED;
	if (sdata->wdev.use_4addr &&
	    !(bss->vif.offload_flags & IEEE80211_OFFLOAD_ENCAP_4ADDR))
		enabled = false;
1013

1014 1015 1016
	sdata->dev->netdev_ops = enabled ? &ieee80211_dataif_8023_ops :
					   &ieee80211_dataif_ops;
}
1017

1018 1019 1020 1021
static void ieee80211_recalc_sdata_offload(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_sub_if_data *vsdata;
1022

1023 1024 1025 1026
	if (ieee80211_set_sdata_offload_flags(sdata)) {
		drv_update_vif_offload(local, sdata);
		ieee80211_set_vif_encap_ops(sdata);
	}
1027

1028 1029 1030 1031
	list_for_each_entry(vsdata, &local->interfaces, list) {
		if (vsdata->vif.type != NL80211_IFTYPE_AP_VLAN ||
		    vsdata->bss != &sdata->u.ap)
			continue;
1032

1033
		ieee80211_set_vif_encap_ops(vsdata);
1034
	}
1035
}
1036

1037 1038 1039
void ieee80211_recalc_offload(struct ieee80211_local *local)
{
	struct ieee80211_sub_if_data *sdata;
1040

1041 1042
	if (!ieee80211_hw_check(&local->hw, SUPPORTS_TX_ENCAP_OFFLOAD))
		return;
1043

1044
	lockdep_assert_wiphy(local->hw.wiphy);
1045

1046 1047 1048 1049 1050
	list_for_each_entry(sdata, &local->interfaces, list) {
		if (!ieee80211_sdata_running(sdata))
			continue;

		ieee80211_recalc_sdata_offload(sdata);
1051
	}
1052
}
1053

1054 1055 1056 1057 1058
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;
1059

1060 1061 1062 1063
#define ADJUST(_f, _s)	do {					\
	if (flags & MONITOR_FLAG_##_f)				\
		local->fif_##_s += offset;			\
	} while (0)
1064

1065 1066 1067 1068 1069
	ADJUST(FCSFAIL, fcsfail);
	ADJUST(PLCPFAIL, plcpfail);
	ADJUST(CONTROL, control);
	ADJUST(CONTROL, pspoll);
	ADJUST(OTHER_BSS, other_bss);
1070

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
#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;
1086
	}
1087 1088
	sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
}
1089

1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
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.
	 */
1103
	ieee80211_link_init(sdata, -1, &sdata->deflink, &sdata->vif.bss_conf);
1104 1105
}

1106 1107 1108 1109
int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
{
	struct ieee80211_sub_if_data *sdata;
	int ret;
1110

1111 1112
	if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
		return 0;
1113

1114
	ASSERT_RTNL();
1115
	lockdep_assert_wiphy(local->hw.wiphy);
1116

1117 1118
	if (local->monitor_sdata)
		return 0;
1119

1120 1121 1122
	sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
	if (!sdata)
		return -ENOMEM;
1123

1124 1125 1126 1127 1128
	/* 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;
1129
	sdata->wdev.wiphy = local->hw.wiphy;
1130

1131 1132
	ieee80211_sdata_init(local, sdata);

1133
	ieee80211_set_default_queues(sdata);
1134

1135 1136 1137 1138 1139 1140 1141
	ret = drv_add_interface(local, sdata);
	if (WARN_ON(ret)) {
		/* ok .. stupid driver, it asked for this! */
		kfree(sdata);
		return ret;
	}

1142 1143
	set_bit(SDATA_STATE_RUNNING, &sdata->state);

1144 1145 1146 1147
	ret = ieee80211_check_queues(sdata, NL80211_IFTYPE_MONITOR);
	if (ret) {
		kfree(sdata);
		return ret;
1148 1149
	}

1150 1151 1152 1153
	mutex_lock(&local->iflist_mtx);
	rcu_assign_pointer(local->monitor_sdata, sdata);
	mutex_unlock(&local->iflist_mtx);

1154
	ret = ieee80211_link_use_channel(&sdata->deflink, &local->monitor_chanreq,
1155
					 IEEE80211_CHANCTX_EXCLUSIVE);
1156 1157 1158 1159 1160 1161 1162 1163
	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;
1164
	}
1165

1166
	skb_queue_head_init(&sdata->skb_queue);
1167
	skb_queue_head_init(&sdata->status_queue);
1168
	wiphy_work_init(&sdata->work, ieee80211_iface_work);
1169

1170 1171
	return 0;
}
1172

1173 1174 1175
void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
{
	struct ieee80211_sub_if_data *sdata;
1176

1177 1178
	if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF))
		return;
1179

1180
	ASSERT_RTNL();
1181
	lockdep_assert_wiphy(local->hw.wiphy);
1182 1183 1184 1185 1186 1187 1188

	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);
1189 1190 1191
		return;
	}

1192 1193 1194 1195 1196
	RCU_INIT_POINTER(local->monitor_sdata, NULL);
	mutex_unlock(&local->iflist_mtx);

	synchronize_net();

1197
	ieee80211_link_release_channel(&sdata->deflink);
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213

	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;
1214
	u64 changed = 0;
1215 1216 1217
	int res;
	u32 hw_reconf_flags = 0;

1218 1219
	lockdep_assert_wiphy(local->hw.wiphy);

1220
	switch (sdata->vif.type) {
1221 1222 1223 1224 1225
	case NL80211_IFTYPE_AP_VLAN: {
		struct ieee80211_sub_if_data *master;

		if (!sdata->bss)
			return -ENOLINK;
1226

1227
		list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
1228

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
		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));
1242
		sdata->vif.bss_conf.chanreq = master->vif.bss_conf.chanreq;
1243

1244 1245
		sdata->crypto_tx_tailroom_needed_cnt +=
			master->crypto_tx_tailroom_needed_cnt;
1246

1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
		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:
1265
	case NL80211_IFTYPE_WDS:
1266 1267 1268 1269
		/* cannot happen */
		WARN_ON(1);
		break;
	}
1270

1271
	if (local->open_count == 0) {
1272 1273 1274
		/* here we can consider everything in good order (again) */
		local->reconfig_failure = false;

1275 1276 1277 1278 1279 1280
		res = drv_start(local);
		if (res)
			goto err_del_bss;
		ieee80211_led_radio(local, true);
		ieee80211_mod_tpt_led_trig(local,
					   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
1281 1282
	}

1283 1284 1285 1286 1287
	/*
	 * 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)) {
1288
		eth_hw_addr_set(dev, local->hw.wiphy->perm_addr);
1289
		memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
1290

1291 1292 1293 1294 1295
		if (!is_valid_ether_addr(dev->dev_addr)) {
			res = -EADDRNOTAVAIL;
			goto err_stop;
		}
	}
1296

1297 1298 1299
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP_VLAN:
		/* no need to tell driver, but set carrier and chanctx */
1300
		if (sdata->bss->active) {
1301
			ieee80211_link_vlan_copy_chanctx(&sdata->deflink);
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
			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;
		}
1313

1314 1315 1316 1317 1318 1319 1320 1321 1322
		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;
		}
1323

1324 1325 1326 1327 1328 1329
		/* 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;
		}
1330

1331 1332 1333 1334
		ieee80211_adjust_monitor_flags(sdata, 1);
		ieee80211_configure_filter(local);
		ieee80211_recalc_offload(local);
		ieee80211_recalc_idle(local);
1335

1336 1337 1338 1339 1340 1341
		netif_carrier_on(dev);
		break;
	default:
		if (coming_up) {
			ieee80211_del_virtual_monitor(local);
			ieee80211_set_sdata_offload_flags(sdata);
1342

1343 1344 1345
			res = drv_add_interface(local, sdata);
			if (res)
				goto err_stop;
1346

1347 1348 1349 1350 1351 1352
			ieee80211_set_vif_encap_ops(sdata);
			res = ieee80211_check_queues(sdata,
				ieee80211_vif_type_p2p(&sdata->vif));
			if (res)
				goto err_del_interface;
		}
1353

1354 1355 1356
		if (sdata->vif.type == NL80211_IFTYPE_AP) {
			local->fif_pspoll++;
			local->fif_probe_req++;
1357

1358 1359 1360 1361
			ieee80211_configure_filter(local);
		} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
			local->fif_probe_req++;
		}
1362

1363 1364 1365 1366
		if (sdata->vif.probe_req_reg)
			drv_config_iface_filter(local, sdata,
						FIF_PROBE_REQ,
						FIF_PROBE_REQ);
1367

1368 1369 1370
		if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
		    sdata->vif.type != NL80211_IFTYPE_NAN)
			changed |= ieee80211_reset_erp_info(sdata);
1371 1372
		ieee80211_link_info_change_notify(sdata, &sdata->deflink,
						  changed);
1373

1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
		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);
		}
1389

1390 1391 1392 1393 1394 1395
		/*
		 * 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.
		 */
1396
		ieee80211_set_wmm_default(&sdata->deflink, true,
1397 1398
			sdata->vif.type != NL80211_IFTYPE_STATION);
	}
1399

1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
	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;
1411 1412
	}

1413 1414 1415 1416 1417 1418 1419
	/*
	 * 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);
1420

1421 1422
	if (coming_up)
		local->open_count++;
1423

1424 1425 1426
	if (local->open_count == 1)
		ieee80211_hw_conf_init(local);
	else if (hw_reconf_flags)
1427
		ieee80211_hw_config(local, hw_reconf_flags);
1428

1429
	ieee80211_recalc_ps(local);
1430

1431 1432
	set_bit(SDATA_STATE_RUNNING, &sdata->state);

1433 1434 1435 1436 1437 1438 1439 1440
	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;
1441
	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
1442 1443 1444 1445 1446
		list_del(&sdata->u.vlan.list);
	/* might already be clear but that doesn't matter */
	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
	return res;
}
1447

1448 1449 1450
static void ieee80211_if_setup(struct net_device *dev)
{
	ether_setup(dev);
1451
	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1452
	dev->priv_flags |= IFF_NO_QUEUE;
1453
	dev->netdev_ops = &ieee80211_dataif_ops;
1454
	dev->needs_free_netdev = true;
1455 1456
}

1457 1458 1459 1460 1461 1462
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;

1463 1464
	lockdep_assert_wiphy(local->hw.wiphy);

1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
	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)
1506 1507
				ieee80211_vht_handle_opmode(sdata,
							    &sta->deflink,
1508
							    opmode, band);
1509 1510 1511 1512

			break;
		}
		case WLAN_VHT_ACTION_GROUPID_MGMT:
1513 1514
			ieee80211_process_mu_groups(sdata, &sdata->deflink,
						    mgmt);
1515 1516 1517 1518 1519
			break;
		default:
			WARN_ON(1);
			break;
		}
1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
	} 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;
		}
1530 1531 1532 1533 1534 1535 1536 1537
	} else if (ieee80211_is_action(mgmt->frame_control) &&
		   mgmt->u.action.category == WLAN_CATEGORY_PROTECTED_EHT) {
		if (sdata->vif.type == NL80211_IFTYPE_STATION) {
			switch (mgmt->u.action.u.ttlm_req.action_code) {
			case WLAN_PROTECTED_EHT_ACTION_TTLM_REQ:
				ieee80211_process_neg_ttlm_req(sdata, mgmt,
							       skb->len);
				break;
1538 1539 1540 1541
			case WLAN_PROTECTED_EHT_ACTION_TTLM_RES:
				ieee80211_process_neg_ttlm_res(sdata, mgmt,
							       skb->len);
				break;
1542 1543 1544 1545
			default:
				break;
			}
		}
1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
	} 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;
	}
}

1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
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;
		}
	}
}

1617
static void ieee80211_iface_work(struct wiphy *wiphy, struct wiphy_work *work)
1618 1619 1620 1621 1622 1623 1624 1625 1626
{
	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;

1627
	if (test_bit(SCAN_SW_SCANNING, &local->scanning))
1628 1629
		return;

1630
	if (!ieee80211_can_run_worker(local))
1631 1632 1633 1634
		return;

	/* first process frames */
	while ((skb = skb_dequeue(&sdata->skb_queue))) {
1635
		kcov_remote_start_common(skb_get_kcov_handle(skb));
1636

1637 1638 1639 1640
		if (skb->protocol == cpu_to_be16(ETH_P_TDLS))
			ieee80211_process_tdls_channel_switch(sdata, skb);
		else
			ieee80211_iface_process_skb(local, sdata, skb);
1641 1642

		kfree_skb(skb);
1643
		kcov_remote_stop();
1644 1645
	}

1646 1647 1648 1649 1650 1651 1652 1653 1654 1655
	/* 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();
	}

1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
	/* 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;
1669 1670 1671
	case NL80211_IFTYPE_OCB:
		ieee80211_ocb_work(sdata);
		break;
1672 1673 1674 1675 1676
	default:
		break;
	}
}

1677 1678
static void ieee80211_activate_links_work(struct wiphy *wiphy,
					  struct wiphy_work *work)
1679 1680 1681 1682
{
	struct ieee80211_sub_if_data *sdata =
		container_of(work, struct ieee80211_sub_if_data,
			     activate_links_work);
1683 1684 1685 1686
	struct ieee80211_local *local = wiphy_priv(wiphy);

	if (local->in_reconfig)
		return;
1687 1688

	ieee80211_set_active_links(&sdata->vif, sdata->desired_active_links);
1689
	sdata->desired_active_links = 0;
1690 1691
}

1692 1693 1694 1695
/*
 * Helper function to initialise an interface to a specific type.
 */
static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
1696
				  enum nl80211_iftype type)
1697
{
1698 1699 1700
	static const u8 bssid_wildcard[ETH_ALEN] = {0xff, 0xff, 0xff,
						    0xff, 0xff, 0xff};

1701
	/* clear type-dependent unions */
1702
	memset(&sdata->u, 0, sizeof(sdata->u));
1703
	memset(&sdata->deflink.u, 0, sizeof(sdata->deflink.u));
1704 1705 1706

	/* and set some type-dependent values */
	sdata->vif.type = type;
1707
	sdata->vif.p2p = false;
1708
	sdata->wdev.iftype = type;
1709

1710 1711
	sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
	sdata->control_port_no_encrypt = false;
1712 1713
	sdata->control_port_over_nl80211 = false;
	sdata->control_port_no_preauth = false;
1714
	sdata->vif.cfg.idle = true;
1715
	sdata->vif.bss_conf.txpower = INT_MIN; /* unset */
1716

1717 1718
	sdata->noack_map = 0;

1719 1720 1721 1722 1723
	/* only monitor/p2p-device differ */
	if (sdata->dev) {
		sdata->dev->netdev_ops = &ieee80211_dataif_ops;
		sdata->dev->type = ARPHRD_ETHER;
	}
1724

1725
	skb_queue_head_init(&sdata->skb_queue);
1726
	skb_queue_head_init(&sdata->status_queue);
1727
	wiphy_work_init(&sdata->work, ieee80211_iface_work);
1728 1729
	wiphy_work_init(&sdata->activate_links_work,
			ieee80211_activate_links_work);
1730 1731
	wiphy_delayed_work_init(&sdata->dfs_cac_timer_work,
				ieee80211_dfs_cac_timer_work);
1732

1733
	switch (type) {
1734 1735 1736 1737
	case NL80211_IFTYPE_P2P_GO:
		type = NL80211_IFTYPE_AP;
		sdata->vif.type = type;
		sdata->vif.p2p = true;
1738
		fallthrough;
1739
	case NL80211_IFTYPE_AP:
1740
		skb_queue_head_init(&sdata->u.ap.ps.bc_buf);
1741
		INIT_LIST_HEAD(&sdata->u.ap.vlans);
1742
		sdata->vif.bss_conf.bssid = sdata->vif.addr;
1743
		break;
1744 1745 1746 1747
	case NL80211_IFTYPE_P2P_CLIENT:
		type = NL80211_IFTYPE_STATION;
		sdata->vif.type = type;
		sdata->vif.p2p = true;
1748
		fallthrough;
1749
	case NL80211_IFTYPE_STATION:
1750
		sdata->vif.bss_conf.bssid = sdata->deflink.u.mgd.bssid;
1751
		ieee80211_sta_setup_sdata(sdata);
1752
		break;
1753
	case NL80211_IFTYPE_OCB:
1754 1755
		sdata->vif.bss_conf.bssid = bssid_wildcard;
		ieee80211_ocb_setup_sdata(sdata);
1756
		break;
1757
	case NL80211_IFTYPE_ADHOC:
1758
		sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
1759 1760
		ieee80211_ibss_setup_sdata(sdata);
		break;
1761
	case NL80211_IFTYPE_MESH_POINT:
1762 1763 1764
		if (ieee80211_vif_is_mesh(&sdata->vif))
			ieee80211_mesh_init_sdata(sdata);
		break;
1765
	case NL80211_IFTYPE_MONITOR:
1766
		sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
1767
		sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
1768
		sdata->u.mntr.flags = MONITOR_FLAG_CONTROL |
1769 1770
				      MONITOR_FLAG_OTHER_BSS;
		break;
1771 1772 1773 1774 1775
	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;
1776
	case NL80211_IFTYPE_AP_VLAN:
1777
	case NL80211_IFTYPE_P2P_DEVICE:
1778
		sdata->vif.bss_conf.bssid = sdata->vif.addr;
1779
		break;
1780
	case NL80211_IFTYPE_UNSPECIFIED:
1781
	case NL80211_IFTYPE_WDS:
1782
	case NUM_NL80211_IFTYPES:
1783
		WARN_ON(1);
1784 1785 1786
		break;
	}

1787 1788 1789
	/* need to do this after the switch so vif.type is correct */
	ieee80211_link_setup(&sdata->deflink);

1790
	ieee80211_debugfs_recreate_netdev(sdata, false);
1791 1792
}

1793 1794 1795 1796 1797
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;
1798 1799
	enum nl80211_iftype internal_type = type;
	bool p2p = false;
1800 1801 1802 1803 1804 1805

	ASSERT_RTNL();

	if (!local->ops->change_interface)
		return -EBUSY;

1806
	/* for now, don't support changing while links exist */
1807
	if (ieee80211_vif_is_mld(&sdata->vif))
1808 1809
		return -EBUSY;

1810 1811
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP:
1812 1813 1814
		if (!list_empty(&sdata->u.ap.vlans))
			return -EBUSY;
		break;
1815 1816
	case NL80211_IFTYPE_STATION:
	case NL80211_IFTYPE_ADHOC:
1817
	case NL80211_IFTYPE_OCB:
1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832
		/*
		 * 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:
1833
	case NL80211_IFTYPE_OCB:
1834 1835
		/*
		 * Could probably support everything
1836
		 * but here.
1837 1838
		 */
		break;
1839 1840 1841 1842 1843 1844 1845 1846
	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;
1847 1848 1849 1850
	default:
		return -EBUSY;
	}

1851
	ret = ieee80211_check_concurrent_iface(sdata, internal_type);
1852 1853 1854
	if (ret)
		return ret;

1855 1856
	ieee80211_stop_vif_queues(local, sdata,
				  IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE);
1857
	/* do_stop will synchronize_rcu() first thing */
1858 1859
	ieee80211_do_stop(sdata, false);

1860
	ieee80211_teardown_sdata(sdata);
1861

1862
	ieee80211_set_sdata_offload_flags(sdata);
1863
	ret = drv_change_interface(local, sdata, internal_type, p2p);
1864
	if (ret)
1865
		type = ieee80211_vif_type_p2p(&sdata->vif);
1866

1867 1868 1869 1870 1871
	/*
	 * 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 :-)
	 */
1872
	ieee80211_check_queues(sdata, type);
1873

1874
	ieee80211_setup_sdata(sdata, type);
1875
	ieee80211_set_vif_encap_ops(sdata);
1876

1877
	err = ieee80211_do_open(&sdata->wdev, false);
1878 1879
	WARN(err, "type change: do_open returned %d", err);

1880 1881
	ieee80211_wake_vif_queues(local, sdata,
				  IEEE80211_QUEUE_STOP_REASON_IFTYPE_CHANGE);
1882 1883 1884
	return ret;
}

1885
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
1886
			     enum nl80211_iftype type)
1887
{
1888 1889
	int ret;

1890 1891
	ASSERT_RTNL();

1892
	if (type == ieee80211_vif_type_p2p(&sdata->vif))
1893 1894
		return 0;

1895 1896 1897 1898 1899 1900
	if (ieee80211_sdata_running(sdata)) {
		ret = ieee80211_runtime_change_iftype(sdata, type);
		if (ret)
			return ret;
	} else {
		/* Purge and reset type-dependent state. */
1901
		ieee80211_teardown_sdata(sdata);
1902 1903
		ieee80211_setup_sdata(sdata, type);
	}
1904 1905

	/* reset some values that shouldn't be kept across type changes */
1906 1907
	if (type == NL80211_IFTYPE_STATION)
		sdata->u.mgd.use_4addr = false;
1908 1909

	return 0;
1910 1911
}

1912
static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
1913
				       u8 *perm_addr, enum nl80211_iftype type)
1914 1915 1916 1917 1918 1919 1920
{
	struct ieee80211_sub_if_data *sdata;
	u64 mask, start, addr, val, inc;
	u8 *m;
	u8 tmp_addr[ETH_ALEN];
	int i;

1921 1922
	lockdep_assert_wiphy(local->hw.wiphy);

1923
	/* default ... something at least */
1924
	memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938

	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;
1939
			memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
1940 1941 1942 1943
			break;
		}
		/* keep default if no AP interface present */
		break;
1944 1945
	case NL80211_IFTYPE_P2P_CLIENT:
	case NL80211_IFTYPE_P2P_GO:
1946
		if (ieee80211_hw_check(&local->hw, P2P_DEV_ADDR_FOR_INTF)) {
1947 1948 1949 1950 1951 1952
			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);
1953
				return;
1954 1955
			}
		}
1956
		fallthrough;
1957 1958 1959 1960 1961 1962
	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) {
1963 1964
				if (ether_addr_equal(local->hw.wiphy->addresses[i].addr,
						     sdata->vif.addr)) {
1965 1966 1967 1968 1969 1970
					used = true;
					break;
				}
			}

			if (!used) {
1971
				memcpy(perm_addr,
1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
				       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! */
Johannes Berg's avatar
Johannes Berg committed
1989
			pr_info("not contiguous\n");
1990 1991 1992
			break;
		}

1993 1994 1995 1996
		/*
		 * Pick address of existing interface in case user changed
		 * MAC address manually, default to perm_addr.
		 */
1997
		m = local->hw.wiphy->perm_addr;
1998 1999 2000 2001 2002 2003
		list_for_each_entry(sdata, &local->interfaces, list) {
			if (sdata->vif.type == NL80211_IFTYPE_MONITOR)
				continue;
			m = sdata->vif.addr;
			break;
		}
2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023
		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) {
2024
				if (ether_addr_equal(tmp_addr, sdata->vif.addr)) {
2025 2026 2027 2028 2029 2030
					used = true;
					break;
				}
			}

			if (!used) {
2031
				memcpy(perm_addr, tmp_addr, ETH_ALEN);
2032 2033 2034 2035 2036 2037 2038 2039 2040
				break;
			}
			addr = (start & ~mask) | (val & mask);
		} while (addr != start);

		break;
	}
}

2041
int ieee80211_if_add(struct ieee80211_local *local, const char *name,
2042
		     unsigned char name_assign_type,
2043
		     struct wireless_dev **new_wdev, enum nl80211_iftype type,
2044
		     struct vif_params *params)
2045
{
2046
	struct net_device *ndev = NULL;
2047
	struct ieee80211_sub_if_data *sdata = NULL;
2048
	struct txq_info *txqi;
2049
	int ret, i;
2050 2051

	ASSERT_RTNL();
2052
	lockdep_assert_wiphy(local->hw.wiphy);
2053

2054
	if (type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN) {
2055 2056 2057 2058 2059 2060 2061 2062 2063
		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;
2064
		strscpy(sdata->name, name, IFNAMSIZ);
2065 2066
		ieee80211_assign_perm_addr(local, wdev->address, type);
		memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);
2067
		ether_addr_copy(sdata->vif.bss_conf.addr, sdata->vif.addr);
2068
	} else {
2069 2070 2071 2072
		int size = ALIGN(sizeof(*sdata) + local->hw.vif_data_size,
				 sizeof(void *));
		int txq_size = 0;

2073
		if (type != NL80211_IFTYPE_AP_VLAN &&
2074 2075
		    (type != NL80211_IFTYPE_MONITOR ||
		     (params->flags & MONITOR_FLAG_ACTIVE)))
2076 2077 2078 2079
			txq_size += sizeof(struct txq_info) +
				    local->hw.txq_data_size;

		ndev = alloc_netdev_mqs(size + txq_size,
2080
					name, name_assign_type,
2081
					ieee80211_if_setup, 1, 1);
2082 2083
		if (!ndev)
			return -ENOMEM;
2084

2085 2086
		dev_net_set(ndev, wiphy_net(local->hw.wiphy));

2087
		ndev->pcpu_stat_type = NETDEV_PCPU_STAT_TSTATS;
2088

2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
		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) {
2100
			free_netdev(ndev);
2101 2102 2103 2104
			return ret;
		}

		ieee80211_assign_perm_addr(local, ndev->perm_addr, type);
2105
		if (is_valid_ether_addr(params->macaddr))
2106
			eth_hw_addr_set(ndev, params->macaddr);
2107
		else
2108
			eth_hw_addr_set(ndev, ndev->perm_addr);
2109 2110 2111 2112 2113 2114
		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);
2115
		ether_addr_copy(sdata->vif.bss_conf.addr, sdata->vif.addr);
2116 2117
		memcpy(sdata->name, ndev->name, IFNAMSIZ);

2118 2119
		if (txq_size) {
			txqi = netdev_priv(ndev) + size;
2120
			ieee80211_txq_init(sdata, NULL, txqi, 0);
2121 2122
		}

2123 2124
		sdata->dev = ndev;
	}
2125 2126

	/* initialise type-independent data */
2127
	sdata->wdev.wiphy = local->hw.wiphy;
2128 2129

	ieee80211_sdata_init(local, sdata);
2130

2131
	ieee80211_init_frag_cache(&sdata->frags);
2132 2133 2134

	INIT_LIST_HEAD(&sdata->key_list);

2135 2136
	wiphy_delayed_work_init(&sdata->dec_tailroom_needed_wk,
				ieee80211_delayed_tailroom_dec);
2137

2138
	for (i = 0; i < NUM_NL80211_BANDS; i++) {
2139 2140 2141 2142
		struct ieee80211_supported_band *sband;
		sband = local->hw.wiphy->bands[i];
		sdata->rc_rateidx_mask[i] =
			sband ? (1 << sband->n_bitrates) - 1 : 0;
2143 2144 2145 2146
		if (sband) {
			__le16 cap;
			u16 *vht_rate_mask;

2147 2148 2149
			memcpy(sdata->rc_rateidx_mcs_mask[i],
			       sband->ht_cap.mcs.rx_mask,
			       sizeof(sdata->rc_rateidx_mcs_mask[i]));
2150 2151 2152 2153 2154

			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 {
2155 2156
			memset(sdata->rc_rateidx_mcs_mask[i], 0,
			       sizeof(sdata->rc_rateidx_mcs_mask[i]));
2157 2158 2159
			memset(sdata->rc_rateidx_vht_mcs_mask[i], 0,
			       sizeof(sdata->rc_rateidx_vht_mcs_mask[i]));
		}
2160
	}
2161

2162 2163
	ieee80211_set_default_queues(sdata);

2164 2165
	sdata->deflink.ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
	sdata->deflink.user_power_level = local->user_power_level;
2166

2167 2168
	/* setup type-dependent data */
	ieee80211_setup_sdata(sdata, type);
2169

2170
	if (ndev) {
2171 2172 2173
		ndev->ieee80211_ptr->use_4addr = params->use_4addr;
		if (type == NL80211_IFTYPE_STATION)
			sdata->u.mgd.use_4addr = params->use_4addr;
2174

2175
		ndev->features |= local->hw.netdev_features;
2176
		ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
2177 2178
		ndev->hw_features |= ndev->features &
					MAC80211_SUPPORTED_FEATURES_TX;
2179
		sdata->vif.netdev_features = local->hw.netdev_features;
2180

2181 2182
		netdev_set_default_ethtool_ops(ndev, &ieee80211_ethtool_ops);

2183 2184 2185 2186 2187
		/* 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.
		 */
2188
		ndev->min_mtu = 256;
2189 2190 2191 2192
		if (type == NL80211_IFTYPE_MONITOR)
			ndev->max_mtu = 0;
		else
			ndev->max_mtu = local->hw.max_mtu;
2193

2194
		ret = cfg80211_register_netdevice(ndev);
2195
		if (ret) {
2196
			free_netdev(ndev);
2197 2198 2199
			return ret;
		}
	}
2200

2201
	mutex_lock(&local->iflist_mtx);
2202
	list_add_tail_rcu(&sdata->list, &local->interfaces);
2203
	mutex_unlock(&local->iflist_mtx);
2204

2205 2206
	if (new_wdev)
		*new_wdev = &sdata->wdev;
2207 2208 2209 2210

	return 0;
}

2211
void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
2212 2213
{
	ASSERT_RTNL();
2214
	lockdep_assert_wiphy(sdata->local->hw.wiphy);
2215

2216
	mutex_lock(&sdata->local->iflist_mtx);
2217
	list_del_rcu(&sdata->list);
2218 2219
	mutex_unlock(&sdata->local->iflist_mtx);

2220 2221 2222
	if (sdata->vif.txq)
		ieee80211_txq_purge(sdata->local, to_txq_info(sdata->vif.txq));

2223
	synchronize_rcu();
2224

2225 2226 2227
	cfg80211_unregister_wdev(&sdata->wdev);

	if (!sdata->dev) {
2228
		ieee80211_teardown_sdata(sdata);
2229 2230 2231 2232 2233 2234 2235 2236 2237
		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);
2238 2239
}

2240
void ieee80211_remove_interfaces(struct ieee80211_local *local)
2241
{
2242
	struct ieee80211_sub_if_data *sdata, *tmp;
2243
	LIST_HEAD(unreg_list);
2244 2245 2246

	ASSERT_RTNL();

2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
	/* 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.
2257
	 */
2258 2259
	cfg80211_shutdown_all_interfaces(local->hw.wiphy);

2260 2261
	wiphy_lock(local->hw.wiphy);

2262 2263
	WARN(local->open_count, "%s: open count remains %d\n",
	     wiphy_name(local->hw.wiphy), local->open_count);
2264

2265
	mutex_lock(&local->iflist_mtx);
2266
	list_splice_init(&local->interfaces, &unreg_list);
2267
	mutex_unlock(&local->iflist_mtx);
2268

2269 2270 2271
	list_for_each_entry_safe(sdata, tmp, &unreg_list, list) {
		bool netdev = sdata->dev;

2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283
		/*
		 * 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);

2284 2285
		list_del(&sdata->list);
		cfg80211_unregister_wdev(&sdata->wdev);
2286 2287 2288

		if (!netdev)
			kfree(sdata);
2289
	}
2290
	wiphy_unlock(local->hw.wiphy);
2291
}
2292

2293
static int netdev_notify(struct notifier_block *nb,
2294
			 unsigned long state, void *ptr)
2295
{
2296
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2297 2298 2299
	struct ieee80211_sub_if_data *sdata;

	if (state != NETDEV_CHANGENAME)
2300
		return NOTIFY_DONE;
2301 2302

	if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
2303
		return NOTIFY_DONE;
2304 2305

	if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
2306
		return NOTIFY_DONE;
2307 2308

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Berg's avatar
Johannes Berg committed
2309
	memcpy(sdata->name, dev->name, IFNAMSIZ);
2310
	ieee80211_debugfs_rename_netdev(sdata);
2311 2312

	return NOTIFY_OK;
2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327
}

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);
}
2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343

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);
}
2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366

void ieee80211_vif_block_queues_csa(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;

	if (ieee80211_hw_check(&local->hw, HANDLES_QUIET_CSA))
		return;

	ieee80211_stop_vif_queues(local, sdata,
				  IEEE80211_QUEUE_STOP_REASON_CSA);
	sdata->csa_blocked_queues = true;
}

void ieee80211_vif_unblock_queues_csa(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;

	if (sdata->csa_blocked_queues) {
		ieee80211_wake_vif_queues(local, sdata,
					  IEEE80211_QUEUE_STOP_REASON_CSA);
		sdata->csa_blocked_queues = false;
	}
}