iface.c 39.8 KB
Newer Older
1
/*
2
3
 * Interface handling (except master interface)
 *
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
45
/**
 * 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.
 */


46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
{
	int meshhdrlen;
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0;

	/* FIX: what would be proper limits for MTU?
	 * This interface uses 802.3 frames. */
	if (new_mtu < 256 ||
	    new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) {
		return -EINVAL;
	}

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
	printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu);
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
	dev->mtu = new_mtu;
	return 0;
}

67
68
69
static int ieee80211_change_mac(struct net_device *dev, void *addr)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
70
	struct sockaddr *sa = addr;
71
72
	int ret;

73
	if (ieee80211_sdata_running(sdata))
74
75
		return -EBUSY;

76
	ret = eth_mac_addr(dev, sa);
77
78

	if (ret == 0)
79
		memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
80
81
82
83

	return ret;
}

84
85
86
87
88
89
90
91
92
93
94
95
96
97
static inline int identical_mac_addr_allowed(int type1, int type2)
{
	return type1 == NL80211_IFTYPE_MONITOR ||
		type2 == NL80211_IFTYPE_MONITOR ||
		(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));
}

98
99
static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
					    enum nl80211_iftype iftype)
100
{
101
	struct ieee80211_local *local = sdata->local;
102
103
	struct ieee80211_sub_if_data *nsdata;
	struct net_device *dev = sdata->dev;
104

105
	ASSERT_RTNL();
106
107
108
109
110

	/* we hold the RTNL here so can safely walk the list */
	list_for_each_entry(nsdata, &local->interfaces, list) {
		struct net_device *ndev = nsdata->dev;

111
		if (ndev != dev && ieee80211_sdata_running(nsdata)) {
112
113
114
115
116
117
118
119
120
121
			/*
			 * 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...
			 */
122
			if (iftype == NL80211_IFTYPE_ADHOC &&
123
124
125
126
127
128
129
130
131
132
133
134
135
			    nsdata->vif.type == NL80211_IFTYPE_ADHOC)
				return -EBUSY;

			/*
			 * The remaining checks are only performed for interfaces
			 * with the same MAC address.
			 */
			if (compare_ether_addr(dev->dev_addr, ndev->dev_addr))
				continue;

			/*
			 * check whether it may have the same address
			 */
136
			if (!identical_mac_addr_allowed(iftype,
137
138
139
140
141
142
							nsdata->vif.type))
				return -ENOTUNIQ;

			/*
			 * can only add VLANs to enabled APs
			 */
143
			if (iftype == NL80211_IFTYPE_AP_VLAN &&
144
145
146
147
148
			    nsdata->vif.type == NL80211_IFTYPE_AP)
				sdata->bss = &nsdata->u.ap;
		}
	}

149
150
151
	return 0;
}

152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata)
{
	int n_queues = sdata->local->hw.queues;
	int i;

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

	if (sdata->vif.type != NL80211_IFTYPE_AP) {
		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;
}

180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
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
}

200
201
202
203
204
205
206
207
208
209
210
211
212
213
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;
		else
			sdata->vif.hw_queue[i] = i;
	}
	sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
}

214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
static int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
{
	struct ieee80211_sub_if_data *sdata;
	int ret;

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

	if (local->monitor_sdata)
		return 0;

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

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

235
236
	ieee80211_set_default_queues(sdata);

237
238
239
240
241
242
243
	ret = drv_add_interface(local, sdata);
	if (WARN_ON(ret)) {
		/* ok .. stupid driver, it asked for this! */
		kfree(sdata);
		return ret;
	}

244
245
246
247
248
249
	ret = ieee80211_check_queues(sdata);
	if (ret) {
		kfree(sdata);
		return ret;
	}

250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
	rcu_assign_pointer(local->monitor_sdata, sdata);

	return 0;
}

static void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
{
	struct ieee80211_sub_if_data *sdata;

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

	sdata = rtnl_dereference(local->monitor_sdata);

	if (!sdata)
		return;

	rcu_assign_pointer(local->monitor_sdata, NULL);
	synchronize_net();

	drv_remove_interface(local, sdata);

	kfree(sdata);
}

275
276
277
278
279
280
/*
 * 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.
 */
static int ieee80211_do_open(struct net_device *dev, bool coming_up)
281
282
283
284
285
286
287
288
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	struct sta_info *sta;
	u32 changed = 0;
	int res;
	u32 hw_reconf_flags = 0;

289
290
291
292
293
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_WDS:
		if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
			return -ENOLINK;
		break;
294
295
296
	case NL80211_IFTYPE_AP_VLAN: {
		struct ieee80211_sub_if_data *master;

297
298
		if (!sdata->bss)
			return -ENOLINK;
299

300
		list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
301
302
303
304
305
306
307

		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;
308
		break;
309
		}
310
311
312
313
314
315
316
317
318
319
	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:
		/* no special treatment */
		break;
	case NL80211_IFTYPE_UNSPECIFIED:
320
	case NUM_NL80211_IFTYPES:
321
322
	case NL80211_IFTYPE_P2P_CLIENT:
	case NL80211_IFTYPE_P2P_GO:
323
324
325
326
327
328
		/* cannot happen */
		WARN_ON(1);
		break;
	}

	if (local->open_count == 0) {
329
		res = drv_start(local);
330
331
		if (res)
			goto err_del_bss;
332
333
		if (local->ops->napi_poll)
			napi_enable(&local->napi);
334
335
		/* we're brought up, everything changes */
		hw_reconf_flags = ~0;
Johannes Berg's avatar
Johannes Berg committed
336
		ieee80211_led_radio(local, true);
337
338
		ieee80211_mod_tpt_led_trig(local,
					   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
339
340
341
	}

	/*
342
343
	 * Copy the hopefully now-present MAC address to
	 * this interface, if it has the special null one.
344
	 */
345
346
347
348
349
350
351
	if (is_zero_ether_addr(dev->dev_addr)) {
		memcpy(dev->dev_addr,
		       local->hw.wiphy->perm_addr,
		       ETH_ALEN);
		memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);

		if (!is_valid_ether_addr(dev->dev_addr)) {
352
353
			res = -EADDRNOTAVAIL;
			goto err_stop;
354
		}
355
356
357
358
	}

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP_VLAN:
359
360
361
362
363
		/* no need to tell driver, but set carrier */
		if (rtnl_dereference(sdata->bss->beacon))
			netif_carrier_on(dev);
		else
			netif_carrier_off(dev);
364
365
366
367
368
369
370
		break;
	case NL80211_IFTYPE_MONITOR:
		if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
			local->cooked_mntrs++;
			break;
		}

371
372
373
374
375
376
		if (local->monitors == 0 && local->open_count == 0) {
			res = ieee80211_add_virtual_monitor(local);
			if (res)
				goto err_stop;
		}

377
378
		/* must be before the call to ieee80211_configure_filter */
		local->monitors++;
379
		if (local->monitors == 1) {
380
381
			local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
382
		}
383

384
		ieee80211_adjust_monitor_flags(sdata, 1);
385
		ieee80211_configure_filter(local);
386
387

		netif_carrier_on(dev);
388
389
		break;
	default:
390
		if (coming_up) {
391
392
			ieee80211_del_virtual_monitor(local);

393
			res = drv_add_interface(local, sdata);
394
395
			if (res)
				goto err_stop;
396
397
398
			res = ieee80211_check_queues(sdata);
			if (res)
				goto err_del_interface;
399
		}
400

401
		if (sdata->vif.type == NL80211_IFTYPE_AP) {
402
			local->fif_pspoll++;
403
			local->fif_probe_req++;
404
405

			ieee80211_configure_filter(local);
406
407
		} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
			local->fif_probe_req++;
408
		}
409

410
411
412
		changed |= ieee80211_reset_erp_info(sdata);
		ieee80211_bss_info_change_notify(sdata, changed);

413
		if (sdata->vif.type == NL80211_IFTYPE_STATION ||
414
415
		    sdata->vif.type == NL80211_IFTYPE_ADHOC ||
		    sdata->vif.type == NL80211_IFTYPE_AP)
416
417
418
			netif_carrier_off(dev);
		else
			netif_carrier_on(dev);
419
420
421
422
423
424

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

428
429
	set_bit(SDATA_STATE_RUNNING, &sdata->state);

430
431
432
433
434
435
436
437
438
	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;
		}

439
440
441
		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);
442
443
444
445
446
447

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

		rate_control_rate_init(sta);
450
451
452
453
454
455
456
457
458
459
460
461
462
	}

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

463
	mutex_lock(&local->mtx);
464
	hw_reconf_flags |= __ieee80211_recalc_idle(local);
465
	mutex_unlock(&local->mtx);
466

467
468
469
	if (coming_up)
		local->open_count++;

470
	if (hw_reconf_flags)
471
		ieee80211_hw_config(local, hw_reconf_flags);
472

473
	ieee80211_recalc_ps(local, -1);
474

475
	netif_tx_start_all_queues(dev);
476
477
478

	return 0;
 err_del_interface:
479
	drv_remove_interface(local, sdata);
480
 err_stop:
481
482
	if (!local->open_count)
		drv_stop(local);
483
484
485
486
 err_del_bss:
	sdata->bss = NULL;
	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
		list_del(&sdata->u.vlan.list);
487
	/* might already be clear but that doesn't matter */
488
	clear_bit(SDATA_STATE_RUNNING, &sdata->state);
489
490
491
	return res;
}

492
static int ieee80211_open(struct net_device *dev)
493
494
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
495
496
497
	int err;

	/* fail early if user set an invalid address */
498
	if (!is_valid_ether_addr(dev->dev_addr))
499
500
501
502
503
504
505
506
507
508
509
510
		return -EADDRNOTAVAIL;

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

	return ieee80211_do_open(dev, true);
}

static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
			      bool going_down)
{
511
	struct ieee80211_local *local = sdata->local;
512
513
	unsigned long flags;
	struct sk_buff *skb, *tmp;
514
	u32 hw_reconf_flags = 0;
515
	int i;
516
	enum nl80211_channel_type orig_ct;
517

518
519
	clear_bit(SDATA_STATE_RUNNING, &sdata->state);

520
521
522
	if (local->scan_sdata == sdata)
		ieee80211_scan_cancel(local);

523
524
525
	/*
	 * Stop TX on this interface first.
	 */
526
	netif_tx_stop_all_queues(sdata->dev);
527

528
529
530
531
532
	/*
	 * Purge work for this interface.
	 */
	ieee80211_work_purge(sdata);

533
534
535
536
537
538
539
540
541
542
	/*
	 * 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!)
	 *
543
544
545
	 * This is relevant only in AP, WDS and mesh modes, since in
	 * all other modes we've already removed all stations when
	 * disconnecting etc.
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
	 */
	sta_info_flush(local, sdata);

	/*
	 * Don't count this interface for promisc/allmulti while it
	 * is down. dev_mc_unsync() will invoke set_multicast_list
	 * on the master interface which will sync these down to the
	 * hardware as filter flags.
	 */
	if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
		atomic_dec(&local->iff_allmultis);

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

561
	if (sdata->vif.type == NL80211_IFTYPE_AP) {
562
		local->fif_pspoll--;
563
564
565
566
		local->fif_probe_req--;
	} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
		local->fif_probe_req--;
	}
567

568
	netif_addr_lock_bh(sdata->dev);
Johannes Berg's avatar
Johannes Berg committed
569
	spin_lock_bh(&local->filter_lock);
570
571
	__hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
			 sdata->dev->addr_len);
Johannes Berg's avatar
Johannes Berg committed
572
	spin_unlock_bh(&local->filter_lock);
573
	netif_addr_unlock_bh(sdata->dev);
Johannes Berg's avatar
Johannes Berg committed
574

575
576
	ieee80211_configure_filter(local);

577
578
	del_timer_sync(&local->dynamic_ps_timer);
	cancel_work_sync(&local->dynamic_ps_enable_work);
579
580
581

	/* APs need special treatment */
	if (sdata->vif.type == NL80211_IFTYPE_AP) {
582
		struct ieee80211_sub_if_data *vlan, *tmpsdata;
583
584
		struct beacon_data *old_beacon =
			rtnl_dereference(sdata->u.ap.beacon);
585
586
		struct sk_buff *old_probe_resp =
			rtnl_dereference(sdata->u.ap.probe_resp);
587

588
589
590
591
		/* sdata_running will return false, so this will disable */
		ieee80211_bss_info_change_notify(sdata,
						 BSS_CHANGED_BEACON_ENABLED);

592
		/* remove beacon and probe response */
593
		RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
594
		RCU_INIT_POINTER(sdata->u.ap.probe_resp, NULL);
595
596
		synchronize_rcu();
		kfree(old_beacon);
597
		kfree_skb(old_probe_resp);
598
599

		/* down all dependent devices, that is VLANs */
600
		list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
601
602
603
					 u.vlan.list)
			dev_close(vlan->dev);
		WARN_ON(!list_empty(&sdata->u.ap.vlans));
604
605
606
607

		/* free all potentially still buffered bcast frames */
		local->total_ps_buffered -= skb_queue_len(&sdata->u.ap.ps_bc_buf);
		skb_queue_purge(&sdata->u.ap.ps_bc_buf);
608
609
	}

610
611
	if (going_down)
		local->open_count--;
612
613
614
615
616
617
618
619
620
621
622
623
624

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP_VLAN:
		list_del(&sdata->u.vlan.list);
		/* 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--;
625
		if (local->monitors == 0) {
626
627
			local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
			hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
628
			ieee80211_del_virtual_monitor(local);
629
		}
630

631
		ieee80211_adjust_monitor_flags(sdata, -1);
632
633
634
		ieee80211_configure_filter(local);
		break;
	default:
635
		flush_work(&sdata->work);
Johannes Berg's avatar
Johannes Berg committed
636
637
638
639
640
641
642
643
644
		/*
		 * When we get here, the interface is marked down.
		 * Call synchronize_rcu() to wait for the RX path
		 * should it be using the interface and enqueuing
		 * frames at this very time on another CPU.
		 */
		synchronize_rcu();
		skb_queue_purge(&sdata->skb_queue);

645
		/*
646
647
		 * Disable beaconing here for mesh only, AP and IBSS
		 * are already taken care of.
648
		 */
649
		if (sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
650
651
652
			ieee80211_bss_info_change_notify(sdata,
				BSS_CHANGED_BEACON_ENABLED);

653
654
655
656
		/*
		 * Free all remaining keys, there shouldn't be any,
		 * except maybe group keys in AP more or WDS?
		 */
Johannes Berg's avatar
Johannes Berg committed
657
		ieee80211_free_keys(sdata);
658

659
		if (going_down)
660
			drv_remove_interface(local, sdata);
661
662
663
664
	}

	sdata->bss = NULL;

665
	mutex_lock(&local->mtx);
666
	hw_reconf_flags |= __ieee80211_recalc_idle(local);
667
	mutex_unlock(&local->mtx);
668
669
670

	ieee80211_recalc_ps(local, -1);

671
	if (local->open_count == 0) {
672
673
		if (local->ops->napi_poll)
			napi_disable(&local->napi);
674
		ieee80211_clear_tx_pending(local);
675
		ieee80211_stop_device(local);
676

677
678
		/* no reconfiguring after stop! */
		hw_reconf_flags = 0;
679
680
	}

681
682
683
684
685
686
	/* Re-calculate channel-type, in case there are multiple vifs
	 * on different channel types.
	 */
	orig_ct = local->_oper_channel_type;
	ieee80211_set_channel_type(local, NULL, NL80211_CHAN_NO_HT);

687
	/* do after stop to avoid reconfiguring when we stop anyway */
688
	if (hw_reconf_flags || (orig_ct != local->_oper_channel_type))
689
690
		ieee80211_hw_config(local, hw_reconf_flags);

691
692
693
694
695
696
697
698
699
700
701
	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]);
				dev_kfree_skb_irq(skb);
			}
		}
	}
	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
702
703
704

	if (local->monitors == local->open_count && local->monitors > 0)
		ieee80211_add_virtual_monitor(local);
705
706
707
708
709
710
711
}

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);
712

713
714
715
716
717
718
	return 0;
}

static void ieee80211_set_multicast_list(struct net_device *dev)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
719
	struct ieee80211_local *local = sdata->local;
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
	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
742
	spin_lock_bh(&local->filter_lock);
743
	__hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
Johannes Berg's avatar
Johannes Berg committed
744
	spin_unlock_bh(&local->filter_lock);
745
	ieee80211_queue_work(&local->hw, &local->reconfig_filter);
746
747
}

748
749
750
751
752
/*
 * Called when the netdev is removed or, by the code below, before
 * the interface type changes.
 */
static void ieee80211_teardown_sdata(struct net_device *dev)
753
{
754
755
756
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	int flushed;
757
758
	int i;

759
760
761
	/* free extra data */
	ieee80211_free_keys(sdata);

762
763
	ieee80211_debugfs_remove_netdev(sdata);

764
	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
765
766
		__skb_queue_purge(&sdata->fragments[i].skb_list);
	sdata->fragment_next = 0;
767

768
769
	if (ieee80211_vif_is_mesh(&sdata->vif))
		mesh_rmc_free(sdata);
770
771
	else if (sdata->vif.type == NL80211_IFTYPE_STATION)
		ieee80211_mgd_teardown(sdata);
772
773
774

	flushed = sta_info_flush(local, sdata);
	WARN_ON(flushed);
775
776
}

777
778
779
780
781
782
static u16 ieee80211_netdev_select_queue(struct net_device *dev,
					 struct sk_buff *skb)
{
	return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
}

783
784
785
786
787
static const struct net_device_ops ieee80211_dataif_ops = {
	.ndo_open		= ieee80211_open,
	.ndo_stop		= ieee80211_stop,
	.ndo_uninit		= ieee80211_teardown_sdata,
	.ndo_start_xmit		= ieee80211_subif_start_xmit,
788
	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
789
	.ndo_change_mtu 	= ieee80211_change_mtu,
790
	.ndo_set_mac_address 	= ieee80211_change_mac,
791
	.ndo_select_queue	= ieee80211_netdev_select_queue,
792
793
};

794
795
796
797
798
799
800
801
static u16 ieee80211_monitor_select_queue(struct net_device *dev,
					  struct sk_buff *skb)
{
	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;

802
	if (local->hw.queues < IEEE80211_NUM_ACS)
803
804
805
		return 0;

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

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

811
	return ieee80211_select_queue_80211(local, skb, hdr);
812
813
}

814
815
816
817
818
static const struct net_device_ops ieee80211_monitorif_ops = {
	.ndo_open		= ieee80211_open,
	.ndo_stop		= ieee80211_stop,
	.ndo_uninit		= ieee80211_teardown_sdata,
	.ndo_start_xmit		= ieee80211_monitor_start_xmit,
819
	.ndo_set_rx_mode	= ieee80211_set_multicast_list,
820
821
	.ndo_change_mtu 	= ieee80211_change_mtu,
	.ndo_set_mac_address 	= eth_mac_addr,
822
	.ndo_select_queue	= ieee80211_monitor_select_queue,
823
824
825
826
827
};

static void ieee80211_if_setup(struct net_device *dev)
{
	ether_setup(dev);
828
	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
829
830
831
832
	dev->netdev_ops = &ieee80211_dataif_ops;
	dev->destructor = free_netdev;
}

833
834
835
836
837
838
static void ieee80211_iface_work(struct work_struct *work)
{
	struct ieee80211_sub_if_data *sdata =
		container_of(work, struct ieee80211_sub_if_data, work);
	struct ieee80211_local *local = sdata->local;
	struct sk_buff *skb;
839
	struct sta_info *sta;
840
	struct ieee80211_ra_tid *ra_tid;
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857

	if (!ieee80211_sdata_running(sdata))
		return;

	if (local->scanning)
		return;

	/*
	 * ieee80211_queue_work() should have picked up most cases,
	 * here we'll pick the rest.
	 */
	if (WARN(local->suspended,
		 "interface work scheduled while going to suspend\n"))
		return;

	/* first process frames */
	while ((skb = skb_dequeue(&sdata->skb_queue))) {
858
859
		struct ieee80211_mgmt *mgmt = (void *)skb->data;

860
861
862
863
864
865
866
867
868
869
		if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {
			ra_tid = (void *)&skb->cb;
			ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,
						 ra_tid->tid);
		} else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {
			ra_tid = (void *)&skb->cb;
			ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,
						ra_tid->tid);
		} else if (ieee80211_is_action(mgmt->frame_control) &&
			   mgmt->u.action.category == WLAN_CATEGORY_BACK) {
870
871
			int len = skb->len;

872
			mutex_lock(&local->sta_mtx);
873
			sta = sta_info_get_bss(sdata, mgmt->sa);
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
			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;
				}
			}
893
			mutex_unlock(&local->sta_mtx);
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
		} else if (ieee80211_is_data_qos(mgmt->frame_control)) {
			struct ieee80211_hdr *hdr = (void *)mgmt;
			/*
			 * 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.
			 */
913
			mutex_lock(&local->sta_mtx);
914
			sta = sta_info_get_bss(sdata, mgmt->sa);
915
916
917
918
919
920
			if (sta) {
				u16 tid = *ieee80211_get_qos_ctl(hdr) &
						IEEE80211_QOS_CTL_TID_MASK;

				__ieee80211_stop_rx_ba_session(
					sta, tid, WLAN_BACK_RECIPIENT,
921
922
					WLAN_REASON_QSTA_REQUIRE_SETUP,
					true);
923
			}
924
			mutex_unlock(&local->sta_mtx);
925
		} else switch (sdata->vif.type) {
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
		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;
		}
941
942

		kfree_skb(skb);
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
	}

	/* 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;
	default:
		break;
	}
}


964
965
966
967
/*
 * Helper function to initialise an interface to a specific type.
 */
static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
968
				  enum nl80211_iftype type)
969
{
970
971
972
973
974
	/* clear type-dependent union */
	memset(&sdata->u, 0, sizeof(sdata->u));

	/* and set some type-dependent values */
	sdata->vif.type = type;
975
	sdata->vif.p2p = false;
976
	sdata->dev->netdev_ops = &ieee80211_dataif_ops;
Johannes Berg's avatar
Johannes Berg committed
977
	sdata->wdev.iftype = type;
978

979
980
981
	sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
	sdata->control_port_no_encrypt = false;

982
983
	sdata->noack_map = 0;

984
985
986
	/* only monitor differs */
	sdata->dev->type = ARPHRD_ETHER;

Johannes Berg's avatar
Johannes Berg committed
987
	skb_queue_head_init(&sdata->skb_queue);
988
	INIT_WORK(&sdata->work, ieee80211_iface_work);
Johannes Berg's avatar
Johannes Berg committed
989

990
	switch (type) {
991
992
993
994
995
	case NL80211_IFTYPE_P2P_GO:
		type = NL80211_IFTYPE_AP;
		sdata->vif.type = type;
		sdata->vif.p2p = true;
		/* fall through */
996
	case NL80211_IFTYPE_AP:
997
998
999
		skb_queue_head_init(&sdata->u.ap.ps_bc_buf);
		INIT_LIST_HEAD(&sdata->u.ap.vlans);
		break;
1000
	case NL80211_IFTYPE_P2P_CLIENT: