iface.c 46.7 KB
Newer Older
1
/*
2
 * Interface handling
3
 *
4
5
6
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005-2006, Devicescape Software, Inc.
 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
7
 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
8
9
10
11
12
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
13
#include <linux/slab.h>
14
15
16
17
18
#include <linux/kernel.h>
#include <linux/if_arp.h>
#include <linux/netdevice.h>
#include <linux/rtnetlink.h>
#include <net/mac80211.h>
19
#include <net/ieee80211_radiotap.h>
20
21
#include "ieee80211_i.h"
#include "sta_info.h"
22
#include "debugfs_netdev.h"
23
#include "mesh.h"
24
#include "led.h"
25
#include "driver-ops.h"
26
#include "wme.h"
Bill Jordan's avatar
Bill Jordan committed
27
#include "rate.h"
28

29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
 * DOC: Interface list locking
 *
 * The interface list in each struct ieee80211_local is protected
 * three-fold:
 *
 * (1) modifications may only be done under the RTNL
 * (2) modifications and readers are protected against each other by
 *     the iflist_mtx.
 * (3) modifications are done in an RCU manner so atomic readers
 *     can traverse the list in RCU-safe blocks.
 *
 * As a consequence, reads (traversals) of the list can be protected
 * by either the RTNL, the iflist_mtx or RCU.
 */

45
46
47
48
49
50
51
52
53
54
55
56
bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_chanctx_conf *chanctx_conf;
	int power;

	rcu_read_lock();
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (!chanctx_conf) {
		rcu_read_unlock();
		return false;
	}

57
	power = ieee80211_chandef_max_power(&chanctx_conf->def);
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
	rcu_read_unlock();

	if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL)
		power = min(power, sdata->user_power_level);

	if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL)
		power = min(power, sdata->ap_power_level);

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

	return false;
}

void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
{
	if (__ieee80211_recalc_txpower(sdata))
		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);
}
80

81
static u32 __ieee80211_idle_off(struct ieee80211_local *local)
82
83
84
85
86
87
88
89
{
	if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
		return 0;

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

90
static u32 __ieee80211_idle_on(struct ieee80211_local *local)
91
92
93
94
{
	if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
		return 0;

95
	ieee80211_flush_queues(local, NULL);
96
97
98
99
100

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

101
102
static u32 __ieee80211_recalc_idle(struct ieee80211_local *local,
				   bool force_active)
103
{
104
	bool working, scanning, active;
105
106
107
108
	unsigned int led_trig_start = 0, led_trig_stop = 0;

	lockdep_assert_held(&local->mtx);

109
110
111
	active = force_active ||
		 !list_empty(&local->chanctx_list) ||
		 local->monitors;
112

113
114
	working = !local->ops->remain_on_channel &&
		  !list_empty(&local->roc_list);
115

116
117
	scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
		   test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning);
118
119
120
121
122
123

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

124
	if (active)
125
126
127
128
129
130
		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);

131
	if (working || scanning || active)
132
133
134
135
136
137
138
139
140
141
142
143
		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);
144
145
	if (change)
		ieee80211_hw_config(local, change);
146
147
}

148
149
static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
{
Chaitanya's avatar
Chaitanya committed
150
	if (new_mtu < 256 || new_mtu > IEEE80211_MAX_DATA_LEN)
151
152
153
154
155
156
		return -EINVAL;

	dev->mtu = new_mtu;
	return 0;
}

John W. Linville's avatar
John W. Linville committed
157
static int ieee80211_verify_mac(struct ieee80211_sub_if_data *sdata, u8 *addr,
158
				bool check_dup)
159
{
160
161
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_sub_if_data *iter;
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
	u64 new, mask, tmp;
	u8 *m;
	int ret = 0;

	if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
		return 0;

	m = addr;
	new =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
		((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
		((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

	m = local->hw.wiphy->addr_mask;
	mask =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
		((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
		((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

179
180
	if (!check_dup)
		return ret;
181
182

	mutex_lock(&local->iflist_mtx);
183
184
	list_for_each_entry(iter, &local->interfaces, list) {
		if (iter == sdata)
185
186
			continue;

John W. Linville's avatar
John W. Linville committed
187
188
		if (iter->vif.type == NL80211_IFTYPE_MONITOR &&
		    !(iter->u.mntr_flags & MONITOR_FLAG_ACTIVE))
189
190
			continue;

191
		m = iter->vif.addr;
192
193
194
195
196
197
198
199
200
201
202
203
204
205
		tmp =	((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
			((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
			((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);

		if ((new & ~mask) != (tmp & ~mask)) {
			ret = -EINVAL;
			break;
		}
	}
	mutex_unlock(&local->iflist_mtx);

	return ret;
}

206
207
208
static int ieee80211_change_mac(struct net_device *dev, void *addr)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
209
	struct sockaddr *sa = addr;
210
	bool check_dup = true;
211
212
	int ret;

213
	if (ieee80211_sdata_running(sdata))
214
215
		return -EBUSY;

216
217
218
219
	if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
	    !(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))
		check_dup = false;

John W. Linville's avatar
John W. Linville committed
220
	ret = ieee80211_verify_mac(sdata, sa->sa_data, check_dup);
221
222
223
	if (ret)
		return ret;

224
	ret = eth_mac_addr(dev, sa);
225
226

	if (ret == 0)
227
		memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
228
229
230
231

	return ret;
}

232
233
234
235
static inline int identical_mac_addr_allowed(int type1, int type2)
{
	return type1 == NL80211_IFTYPE_MONITOR ||
		type2 == NL80211_IFTYPE_MONITOR ||
236
237
		type1 == NL80211_IFTYPE_P2P_DEVICE ||
		type2 == NL80211_IFTYPE_P2P_DEVICE ||
238
239
240
241
242
243
244
245
246
247
		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||
		(type1 == NL80211_IFTYPE_WDS &&
			(type2 == NL80211_IFTYPE_WDS ||
			 type2 == NL80211_IFTYPE_AP)) ||
		(type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
		(type1 == NL80211_IFTYPE_AP_VLAN &&
			(type2 == NL80211_IFTYPE_AP ||
			 type2 == NL80211_IFTYPE_AP_VLAN));
}

248
249
static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
					    enum nl80211_iftype iftype)
250
{
251
	struct ieee80211_local *local = sdata->local;
252
	struct ieee80211_sub_if_data *nsdata;
253
	int ret;
254

255
	ASSERT_RTNL();
256
257
258

	/* we hold the RTNL here so can safely walk the list */
	list_for_each_entry(nsdata, &local->interfaces, list) {
259
		if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
260
261
262
263
264
265
266
267
268
269
			/*
			 * 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...
			 */
270
			if (iftype == NL80211_IFTYPE_ADHOC &&
271
272
			    nsdata->vif.type == NL80211_IFTYPE_ADHOC)
				return -EBUSY;
273
274
275
276
277
278
			/*
			 * will not add another interface while any channel
			 * switch is active.
			 */
			if (nsdata->vif.csa_active)
				return -EBUSY;
279
280
281
282
283

			/*
			 * The remaining checks are only performed for interfaces
			 * with the same MAC address.
			 */
284
285
			if (!ether_addr_equal(sdata->vif.addr,
					      nsdata->vif.addr))
286
287
288
289
290
				continue;

			/*
			 * check whether it may have the same address
			 */
291
			if (!identical_mac_addr_allowed(iftype,
292
293
294
295
296
297
							nsdata->vif.type))
				return -ENOTUNIQ;

			/*
			 * can only add VLANs to enabled APs
			 */
298
			if (iftype == NL80211_IFTYPE_AP_VLAN &&
299
300
301
302
303
			    nsdata->vif.type == NL80211_IFTYPE_AP)
				sdata->bss = &nsdata->u.ap;
		}
	}

304
305
306
307
	mutex_lock(&local->chanctx_mtx);
	ret = ieee80211_check_combinations(sdata, NULL, 0, 0);
	mutex_unlock(&local->chanctx_mtx);
	return ret;
308
309
}

310
311
static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata,
				  enum nl80211_iftype iftype)
312
313
314
315
{
	int n_queues = sdata->local->hw.queues;
	int i;

316
	if (iftype != NL80211_IFTYPE_P2P_DEVICE) {
317
318
319
320
321
322
323
324
		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;
		}
325
326
	}

327
328
329
	if ((iftype != NL80211_IFTYPE_AP &&
	     iftype != NL80211_IFTYPE_P2P_GO &&
	     iftype != NL80211_IFTYPE_MESH_POINT) ||
330
	    !(sdata->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)) {
331
332
333
334
335
336
337
338
339
340
341
342
343
		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;
}

344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
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;

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

	ADJUST(FCSFAIL, fcsfail);
	ADJUST(PLCPFAIL, plcpfail);
	ADJUST(CONTROL, control);
	ADJUST(CONTROL, pspoll);
	ADJUST(OTHER_BSS, other_bss);

#undef ADJUST
}

364
365
366
367
368
369
370
371
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 (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
			sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;
372
		else if (local->hw.queues >= IEEE80211_NUM_ACS)
373
			sdata->vif.hw_queue[i] = i;
374
375
		else
			sdata->vif.hw_queue[i] = 0;
376
377
378
379
	}
	sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
}

380
int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
381
382
{
	struct ieee80211_sub_if_data *sdata;
383
	int ret;
384
385
386
387

	if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
		return 0;

388
	ASSERT_RTNL();
389

390
	if (local->monitor_sdata)
391
		return 0;
392
393

	sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
394
395
	if (!sdata)
		return -ENOMEM;
396
397
398
399
400
401
402

	/* set up data */
	sdata->local = local;
	sdata->vif.type = NL80211_IFTYPE_MONITOR;
	snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
		 wiphy_name(local->hw.wiphy));

403
404
	sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;

405
406
	ieee80211_set_default_queues(sdata);

407
408
409
410
	ret = drv_add_interface(local, sdata);
	if (WARN_ON(ret)) {
		/* ok .. stupid driver, it asked for this! */
		kfree(sdata);
411
		return ret;
412
413
	}

414
	ret = ieee80211_check_queues(sdata, NL80211_IFTYPE_MONITOR);
415
416
	if (ret) {
		kfree(sdata);
417
		return ret;
418
419
	}

420
421
422
423
	mutex_lock(&local->iflist_mtx);
	rcu_assign_pointer(local->monitor_sdata, sdata);
	mutex_unlock(&local->iflist_mtx);

424
	mutex_lock(&local->mtx);
425
	ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef,
Johannes Berg's avatar
Johannes Berg committed
426
					IEEE80211_CHANCTX_EXCLUSIVE);
427
	mutex_unlock(&local->mtx);
Johannes Berg's avatar
Johannes Berg committed
428
	if (ret) {
429
		mutex_lock(&local->iflist_mtx);
Monam Agarwal's avatar
Monam Agarwal committed
430
		RCU_INIT_POINTER(local->monitor_sdata, NULL);
431
432
		mutex_unlock(&local->iflist_mtx);
		synchronize_net();
Johannes Berg's avatar
Johannes Berg committed
433
434
		drv_remove_interface(local, sdata);
		kfree(sdata);
435
		return ret;
Johannes Berg's avatar
Johannes Berg committed
436
437
	}

438
	return 0;
439
440
}

441
void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
442
443
444
445
446
447
{
	struct ieee80211_sub_if_data *sdata;

	if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
		return;

448
449
	ASSERT_RTNL();

450
	mutex_lock(&local->iflist_mtx);
451

452
453
	sdata = rcu_dereference_protected(local->monitor_sdata,
					  lockdep_is_held(&local->iflist_mtx));
454
455
456
457
	if (!sdata) {
		mutex_unlock(&local->iflist_mtx);
		return;
	}
458

Monam Agarwal's avatar
Monam Agarwal committed
459
	RCU_INIT_POINTER(local->monitor_sdata, NULL);
460
461
	mutex_unlock(&local->iflist_mtx);

462
463
	synchronize_net();

464
	mutex_lock(&local->mtx);
Johannes Berg's avatar
Johannes Berg committed
465
	ieee80211_vif_release_channel(sdata);
466
	mutex_unlock(&local->mtx);
Johannes Berg's avatar
Johannes Berg committed
467

468
469
470
471
472
	drv_remove_interface(local, sdata);

	kfree(sdata);
}

473
474
475
476
477
/*
 * 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.
 */
478
int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)
479
{
480
481
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
	struct net_device *dev = wdev->netdev;
482
483
484
485
486
487
	struct ieee80211_local *local = sdata->local;
	struct sta_info *sta;
	u32 changed = 0;
	int res;
	u32 hw_reconf_flags = 0;

488
489
490
491
492
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_WDS:
		if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
			return -ENOLINK;
		break;
493
494
495
	case NL80211_IFTYPE_AP_VLAN: {
		struct ieee80211_sub_if_data *master;

496
497
		if (!sdata->bss)
			return -ENOLINK;
498

499
		mutex_lock(&local->mtx);
500
		list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
501
		mutex_unlock(&local->mtx);
502
503
504
505
506
507
508

		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;
509
510
511
		sdata->vif.cab_queue = master->vif.cab_queue;
		memcpy(sdata->vif.hw_queue, master->vif.hw_queue,
		       sizeof(sdata->vif.hw_queue));
512
		break;
513
		}
514
515
516
517
518
519
520
	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:
521
	case NL80211_IFTYPE_P2P_DEVICE:
522
523
524
		/* no special treatment */
		break;
	case NL80211_IFTYPE_UNSPECIFIED:
525
	case NUM_NL80211_IFTYPES:
526
527
	case NL80211_IFTYPE_P2P_CLIENT:
	case NL80211_IFTYPE_P2P_GO:
528
529
530
531
532
533
		/* cannot happen */
		WARN_ON(1);
		break;
	}

	if (local->open_count == 0) {
534
		res = drv_start(local);
535
536
		if (res)
			goto err_del_bss;
537
538
		/* we're brought up, everything changes */
		hw_reconf_flags = ~0;
Johannes Berg's avatar
Johannes Berg committed
539
		ieee80211_led_radio(local, true);
540
541
		ieee80211_mod_tpt_led_trig(local,
					   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
542
543
544
	}

	/*
545
546
	 * Copy the hopefully now-present MAC address to
	 * this interface, if it has the special null one.
547
	 */
548
	if (dev && is_zero_ether_addr(dev->dev_addr)) {
549
550
551
552
553
554
		memcpy(dev->dev_addr,
		       local->hw.wiphy->perm_addr,
		       ETH_ALEN);
		memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);

		if (!is_valid_ether_addr(dev->dev_addr)) {
555
556
			res = -EADDRNOTAVAIL;
			goto err_stop;
557
		}
558
559
560
561
	}

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP_VLAN:
562
563
564
		/* no need to tell driver, but set carrier and chanctx */
		if (rtnl_dereference(sdata->bss->beacon)) {
			ieee80211_vif_vlan_copy_chanctx(sdata);
565
			netif_carrier_on(dev);
566
		} else {
567
			netif_carrier_off(dev);
568
		}
569
570
571
572
573
574
575
		break;
	case NL80211_IFTYPE_MONITOR:
		if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
			local->cooked_mntrs++;
			break;
		}

576
577
578
579
580
		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) {
581
582
583
584
585
			res = ieee80211_add_virtual_monitor(local);
			if (res)
				goto err_stop;
		}

586
587
		/* must be before the call to ieee80211_configure_filter */
		local->monitors++;
588
		if (local->monitors == 1) {
589
590
			local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
591
		}
592

593
		ieee80211_adjust_monitor_flags(sdata, 1);
594
		ieee80211_configure_filter(local);
595
596
597
		mutex_lock(&local->mtx);
		ieee80211_recalc_idle(local);
		mutex_unlock(&local->mtx);
598
599

		netif_carrier_on(dev);
600
601
		break;
	default:
602
		if (coming_up) {
603
604
			ieee80211_del_virtual_monitor(local);

605
			res = drv_add_interface(local, sdata);
606
607
			if (res)
				goto err_stop;
608
609
			res = ieee80211_check_queues(sdata,
				ieee80211_vif_type_p2p(&sdata->vif));
610
611
			if (res)
				goto err_del_interface;
612
		}
613

614
		if (sdata->vif.type == NL80211_IFTYPE_AP) {
615
			local->fif_pspoll++;
616
			local->fif_probe_req++;
617
618

			ieee80211_configure_filter(local);
619
620
		} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
			local->fif_probe_req++;
621
		}
622

623
624
		if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
			changed |= ieee80211_reset_erp_info(sdata);
625
626
		ieee80211_bss_info_change_notify(sdata, changed);

627
628
629
630
631
		switch (sdata->vif.type) {
		case NL80211_IFTYPE_STATION:
		case NL80211_IFTYPE_ADHOC:
		case NL80211_IFTYPE_AP:
		case NL80211_IFTYPE_MESH_POINT:
632
			netif_carrier_off(dev);
633
			break;
634
		case NL80211_IFTYPE_WDS:
635
		case NL80211_IFTYPE_P2P_DEVICE:
636
			break;
637
		default:
638
639
			/* not reached */
			WARN_ON(1);
640
		}
641
642
643
644
645
646

		/*
		 * set default queue parameters so drivers don't
		 * need to initialise the hardware if the hardware
		 * doesn't start up with sane defaults
		 */
647
		ieee80211_set_wmm_default(sdata, true);
648
649
	}

650
651
	set_bit(SDATA_STATE_RUNNING, &sdata->state);

652
653
654
655
656
657
658
659
660
	if (sdata->vif.type == NL80211_IFTYPE_WDS) {
		/* Create STA entry for the WDS peer */
		sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
				     GFP_KERNEL);
		if (!sta) {
			res = -ENOMEM;
			goto err_del_interface;
		}

661
662
663
		sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
		sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
		sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
664
665
666
667
668
669

		res = sta_info_insert(sta);
		if (res) {
			/* STA has been freed */
			goto err_del_interface;
		}
Bill Jordan's avatar
Bill Jordan committed
670
671

		rate_control_rate_init(sta);
672
		netif_carrier_on(dev);
673
674
	} else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {
		rcu_assign_pointer(local->p2p_sdata, sdata);
675
676
677
678
679
680
681
682
683
684
685
686
687
	}

	/*
	 * 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);

	if (sdata->flags & IEEE80211_SDATA_PROMISC)
		atomic_inc(&local->iff_promiscs);

688
689
690
	if (coming_up)
		local->open_count++;

691
	if (hw_reconf_flags)
692
		ieee80211_hw_config(local, hw_reconf_flags);
693

694
	ieee80211_recalc_ps(local, -1);
695

696
697
698
699
700
	if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
		/* XXX: for AP_VLAN, actually track AP queues */
		netif_tx_start_all_queues(dev);
	} else if (dev) {
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
		unsigned long flags;
		int n_acs = IEEE80211_NUM_ACS;
		int ac;

		if (local->hw.queues < IEEE80211_NUM_ACS)
			n_acs = 1;

		spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
		if (sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE ||
		    (local->queue_stop_reasons[sdata->vif.cab_queue] == 0 &&
		     skb_queue_empty(&local->pending[sdata->vif.cab_queue]))) {
			for (ac = 0; ac < n_acs; ac++) {
				int ac_queue = sdata->vif.hw_queue[ac];

				if (local->queue_stop_reasons[ac_queue] == 0 &&
				    skb_queue_empty(&local->pending[ac_queue]))
					netif_start_subqueue(dev, ac);
			}
		}
		spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
	}
722
723
724

	return 0;
 err_del_interface:
725
	drv_remove_interface(local, sdata);
726
 err_stop:
727
728
	if (!local->open_count)
		drv_stop(local);
729
730
 err_del_bss:
	sdata->bss = NULL;
731
732
	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
		mutex_lock(&local->mtx);
733
		list_del(&sdata->u.vlan.list);
734
735
		mutex_unlock(&local->mtx);
	}
736
	/* might already be clear but that doesn't matter */
737
	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
738
739
740
	return res;
}

741
static int ieee80211_open(struct net_device *dev)
742
743
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
744
745
746
	int err;

	/* fail early if user set an invalid address */
747
	if (!is_valid_ether_addr(dev->dev_addr))
748
749
750
751
752
753
		return -EADDRNOTAVAIL;

	err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
	if (err)
		return err;

754
	return ieee80211_do_open(&sdata->wdev, true);
755
756
757
758
759
}

static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
			      bool going_down)
{
760
	struct ieee80211_local *local = sdata->local;
761
762
	unsigned long flags;
	struct sk_buff *skb, *tmp;
763
	u32 hw_reconf_flags = 0;
764
	int i, flushed;
765
	struct ps_data *ps;
766
	struct cfg80211_chan_def chandef;
767

768
769
	clear_bit(SDATA_STATE_RUNNING, &sdata->state);

770
	if (rcu_access_pointer(local->scan_sdata) == sdata)
771
772
		ieee80211_scan_cancel(local);

773
774
775
	/*
	 * Stop TX on this interface first.
	 */
776
777
	if (sdata->dev)
		netif_tx_stop_all_queues(sdata->dev);
778

779
	ieee80211_roc_purge(local, sdata);
780

781
782
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_STATION:
783
		ieee80211_mgd_stop(sdata);
784
785
		break;
	case NL80211_IFTYPE_ADHOC:
786
		ieee80211_ibss_stop(sdata);
787
788
789
790
791
792
793
		break;
	case NL80211_IFTYPE_AP:
		cancel_work_sync(&sdata->u.ap.request_smps_work);
		break;
	default:
		break;
	}
794

795
796
797
798
799
800
801
802
803
804
	/*
	 * 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!)
	 *
805
806
807
	 * This is relevant only in WDS mode, in all other modes we've
	 * already removed all stations when disconnecting or similar,
	 * so warn otherwise.
808
	 */
809
	flushed = sta_info_flush(sdata);
810
811
	WARN_ON_ONCE((sdata->vif.type != NL80211_IFTYPE_WDS && flushed > 0) ||
		     (sdata->vif.type == NL80211_IFTYPE_WDS && flushed != 1));
812

813
	/* don't count this interface for promisc/allmulti while it is down */
814
815
816
817
818
819
	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
		atomic_dec(&local->iff_allmultis);

	if (sdata->flags & IEEE80211_SDATA_PROMISC)
		atomic_dec(&local->iff_promiscs);

820
	if (sdata->vif.type == NL80211_IFTYPE_AP) {
821
		local->fif_pspoll--;
822
823
824
825
		local->fif_probe_req--;
	} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
		local->fif_probe_req--;
	}
826

827
828
829
830
831
832
833
834
	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);
	}
835

836
837
	del_timer_sync(&local->dynamic_ps_timer);
	cancel_work_sync(&local->dynamic_ps_enable_work);
838

839
	cancel_work_sync(&sdata->recalc_smps);
840
	sdata_lock(sdata);
841
	sdata->vif.csa_active = false;
842
	sdata_unlock(sdata);
843
	cancel_work_sync(&sdata->csa_finalize_work);
844

845
846
847
	cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);

	if (sdata->wdev.cac_started) {
848
		chandef = sdata->vif.bss_conf.chandef;
849
		WARN_ON(local->suspended);
850
		mutex_lock(&local->mtx);
851
		ieee80211_vif_release_channel(sdata);
852
		mutex_unlock(&local->mtx);
853
854
		cfg80211_cac_event(sdata->dev, &chandef,
				   NL80211_RADAR_CAC_ABORTED,
855
856
857
				   GFP_KERNEL);
	}

858
859
	/* APs need special treatment */
	if (sdata->vif.type == NL80211_IFTYPE_AP) {
860
		struct ieee80211_sub_if_data *vlan, *tmpsdata;
861
862

		/* down all dependent devices, that is VLANs */
863
		list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
864
865
866
					 u.vlan.list)
			dev_close(vlan->dev);
		WARN_ON(!list_empty(&sdata->u.ap.vlans));
867
868
869
870
871
872
873
874
875
876
877
878
879
	} else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
		/* remove all packets in parent bc_buf pointing to this dev */
		ps = &sdata->bss->ps;

		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);
880
881
	}

882
883
	if (going_down)
		local->open_count--;
884
885
886

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP_VLAN:
887
		mutex_lock(&local->mtx);
888
		list_del(&sdata->u.vlan.list);
889
		mutex_unlock(&local->mtx);
Monam Agarwal's avatar
Monam Agarwal committed
890
		RCU_INIT_POINTER(sdata->vif.chanctx_conf, NULL);
891
892
893
894
895
896
897
898
899
		/* no need to tell driver */
		break;
	case NL80211_IFTYPE_MONITOR:
		if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
			local->cooked_mntrs--;
			break;
		}

		local->monitors--;
900
		if (local->monitors == 0) {
901
902
			local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
903
		}
904

905
		ieee80211_adjust_monitor_flags(sdata, -1);
906
		break;
907
908
	case NL80211_IFTYPE_P2P_DEVICE:
		/* relies on synchronize_rcu() below */
Monam Agarwal's avatar
Monam Agarwal committed
909
		RCU_INIT_POINTER(local->p2p_sdata, NULL);
910
		/* fall through */
911
	default:
912
		cancel_work_sync(&sdata->work);
Johannes Berg's avatar
Johannes Berg committed
913
914
		/*
		 * When we get here, the interface is marked down.
915
916
		 * Free the remaining keys, if there are any
		 * (shouldn't be, except maybe in WDS mode?)
917
		 *
918
919
920
		 * 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
921
		 * another CPU.
Johannes Berg's avatar
Johannes Berg committed
922
		 */
923
		ieee80211_free_keys(sdata, true);
924

925
926
927
		/* fall through */
	case NL80211_IFTYPE_AP:
		skb_queue_purge(&sdata->skb_queue);
928
929
930
931
	}

	sdata->bss = NULL;

932
933
934
935
936
937
	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]);
938
				ieee80211_free_txskb(&local->hw, skb);
939
940
941
942
			}
		}
	}
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
943

944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
	if (local->open_count == 0)
		ieee80211_clear_tx_pending(local);

	/*
	 * If the interface goes down while suspended, presumably because
	 * the device was unplugged and that happens before our resume,
	 * then the driver is already unconfigured and the remainder of
	 * this function isn't needed.
	 * XXX: what about WoWLAN? If the device has software state, e.g.
	 *	memory allocated, it might expect teardown commands from
	 *	mac80211 here?
	 */
	if (local->suspended) {
		WARN_ON(local->wowlan);
		WARN_ON(rtnl_dereference(local->monitor_sdata));
		return;
	}

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP_VLAN:
		break;
	case NL80211_IFTYPE_MONITOR:
		if (local->monitors == 0)
			ieee80211_del_virtual_monitor(local);

		mutex_lock(&local->mtx);
		ieee80211_recalc_idle(local);
		mutex_unlock(&local->mtx);
972
973
974
975
976

		if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))
			break;

		/* fall through */
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
	default:
		if (going_down)
			drv_remove_interface(local, sdata);
	}

	ieee80211_recalc_ps(local, -1);

	if (local->open_count == 0) {
		ieee80211_stop_device(local);

		/* no reconfiguring after stop! */
		return;
	}

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

	if (local->monitors == local->open_count)
996
		ieee80211_add_virtual_monitor(local);
997
998
999
1000
1001
1002
1003
}

static int ieee80211_stop(struct net_device *dev)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	ieee80211_do_stop(sdata, true);
1004

1005
1006
1007
1008
1009
1010
	return 0;
}

static void ieee80211_set_multicast_list(struct net_device *dev)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1011
	struct ieee80211_local *local = sdata->local;
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
	int allmulti, promisc, sdata_allmulti, sdata_promisc;

	allmulti = !!(dev->flags & IFF_ALLMULTI);
	promisc = !!(dev->flags & IFF_PROMISC);
	sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
	sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);

	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;
	}

	if (promisc != sdata_promisc) {
		if (dev->flags & IFF_PROMISC)
			atomic_inc(&local->iff_promiscs);
		else
			atomic_dec(&local->iff_promiscs);
		sdata->flags ^= IEEE80211_SDATA_PROMISC;
	}
Johannes Berg's avatar
Johannes Berg committed
1034
	spin_lock_bh(&local->filter_lock);
1035
	__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
Johannes Berg's avatar
Johannes Berg committed
1036
	spin_unlock_bh(&local->filter_lock);
1037
	ieee80211_queue_work(&local->hw, &local->reconfig_filter);
1038
1039
}

1040
1041
1042
1043
/*
 * Called when the netdev is removed or, by the code below, before
 * the interface type changes.
 */
1044
static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
1045
1046
1047
{
	int i;

1048
	/* free extra data */
1049
	ieee80211_free_keys(sdata, false);
1050

1051
1052
	ieee80211_debugfs_remove_netdev(sdata);

1053
	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
1054
1055
		__skb_queue_purge(&sdata->fragments[i].skb_list);
	sdata->fragment_next = 0;
1056

1057
1058
	if (ieee80211_vif_is_mesh(&sdata->vif))
		mesh_rmc_free(sdata);
1059
1060
}

1061
1062
1063
1064
1065
static void ieee80211_uninit(struct net_device *dev)
{
	ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
}

1066
static u16 ieee80211_netdev_select_queue(struct net_device *dev,
1067
					 struct sk_buff *skb,
1068
1069
					 void *accel_priv,
					 select_queue_fallback_t fallback)
1070
1071
1072
1073
{
	return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
}

1074
1075
1076
static const struct net_device_ops ieee80211_dataif_ops = {
	.ndo_open		= ieee80211_open,
	.ndo_stop		= ieee80211_stop,
1077
	.ndo_uninit		= ieee80211_uninit,
1078
	.ndo_start_xmit		= ieee80211_subif_start_xmit,
1079
	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
1080
	.ndo_change_mtu 	= ieee80211_change_mtu,
1081
	.ndo_set_mac_address 	= ieee80211_change_mac,
1082
	.ndo_select_queue	= ieee80211_netdev_select_queue,
1083
1084
};

1085
static u16 ieee80211_monitor_select_queue(struct net_device *dev,
1086
					  struct sk_buff *skb,
1087
1088
					  void *accel_priv,
					  select_queue_fallback_t fallback)
1089
1090
1091
1092
1093
1094
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_hdr *hdr;
	struct ieee80211_radiotap_header *rtap = (void *)skb->data;

1095
	if (local->hw.queues < IEEE80211_NUM_ACS)
1096
1097
1098
		return 0;

	if (skb->len < 4 ||
Johannes Berg's avatar
Johannes Berg committed
1099
	    skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
1100
1101
		return 0; /* doesn't matter, frame will be dropped */

Johannes Berg's avatar
Johannes Berg committed
1102
	hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
1103

1104
	return ieee80211_select_queue_80211(sdata, skb, hdr);
1105
1106
}

1107
1108