core.c 28.4 KB
Newer Older
1
2
3
/*
 * This is the linux wireless configuration interface.
 *
4
 * Copyright 2006-2010		Johannes Berg <johannes@sipsolutions.net>
5
6
 */

7
8
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

9
10
11
12
#include <linux/if.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/list.h>
13
#include <linux/slab.h>
14
15
16
17
#include <linux/nl80211.h>
#include <linux/debugfs.h>
#include <linux/notifier.h>
#include <linux/device.h>
18
#include <linux/etherdevice.h>
Johannes Berg's avatar
Johannes Berg committed
19
#include <linux/rtnetlink.h>
20
#include <linux/sched.h>
21
22
#include <net/genetlink.h>
#include <net/cfg80211.h>
23
#include "nl80211.h"
24
25
#include "core.h"
#include "sysfs.h"
26
#include "debugfs.h"
27
#include "wext-compat.h"
28
#include "ethtool.h"
29
#include "rdev-ops.h"
30
31
32
33
34
35
36
37

/* name for sysfs, %d is appended */
#define PHY_NAME "phy"

MODULE_AUTHOR("Johannes Berg");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("wireless configuration support");

38
/* RCU-protected (and cfg80211_mutex for writers) */
39
LIST_HEAD(cfg80211_rdev_list);
40
int cfg80211_rdev_list_generation;
41
42

DEFINE_MUTEX(cfg80211_mutex);
43
44
45
46

/* for debugfs */
static struct dentry *ieee80211_debugfs_dir;

47
48
49
/* for the cleanup, scan and event works */
struct workqueue_struct *cfg80211_wq;

50
51
52
53
54
static bool cfg80211_disable_40mhz_24ghz;
module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
		 "Disable 40MHz support in the 2.4GHz band");

55
/* requires cfg80211_mutex to be held! */
56
struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
57
{
58
	struct cfg80211_registered_device *result = NULL, *rdev;
59

60
61
	assert_cfg80211_lock();

62
63
64
	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
		if (rdev->wiphy_idx == wiphy_idx) {
			result = rdev;
65
66
67
68
69
70
71
			break;
		}
	}

	return result;
}

72
73
int get_wiphy_idx(struct wiphy *wiphy)
{
74
75
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);

76
	return rdev->wiphy_idx;
77
78
}

79
/* requires cfg80211_rdev_mutex to be held! */
80
81
struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
{
82
	struct cfg80211_registered_device *rdev;
83
84
85

	assert_cfg80211_lock();

86
87
	rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
	if (!rdev)
88
		return NULL;
89
	return &rdev->wiphy;
90
91
}

92
struct cfg80211_registered_device *
93
cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
94
{
95
	struct cfg80211_registered_device *rdev = ERR_PTR(-ENODEV);
96
97
	struct net_device *dev;

98
	mutex_lock(&cfg80211_mutex);
99
	dev = dev_get_by_index(net, ifindex);
100
101
102
	if (!dev)
		goto out;
	if (dev->ieee80211_ptr) {
103
104
		rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
		mutex_lock(&rdev->mtx);
105
	} else
106
		rdev = ERR_PTR(-ENODEV);
107
108
	dev_put(dev);
 out:
109
	mutex_unlock(&cfg80211_mutex);
110
	return rdev;
111
112
}

113
/* requires cfg80211_mutex to be held */
114
115
116
int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
			char *newname)
{
117
	struct cfg80211_registered_device *rdev2;
118
	int wiphy_idx, taken = -1, result, digits;
119

120
	assert_cfg80211_lock();
121

122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
	/* prohibit calling the thing phy%d when %d is not its number */
	sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
	if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
		/* count number of places needed to print wiphy_idx */
		digits = 1;
		while (wiphy_idx /= 10)
			digits++;
		/*
		 * deny the name if it is phy<idx> where <idx> is printed
		 * without leading zeroes. taken == strlen(newname) here
		 */
		if (taken == strlen(PHY_NAME) + digits)
			return -EINVAL;
	}


138
139
	/* Ignore nop renames */
	if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
140
		return 0;
141
142

	/* Ensure another device does not already have this name. */
143
144
	list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
		if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0)
145
			return -EINVAL;
146
147
148

	result = device_rename(&rdev->wiphy.dev, newname);
	if (result)
149
		return result;
150

151
152
	if (rdev->wiphy.debugfsdir &&
	    !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
153
154
155
			    rdev->wiphy.debugfsdir,
			    rdev->wiphy.debugfsdir->d_parent,
			    newname))
156
		pr_err("failed to rename debugfs dir to %s!\n", newname);
157

158
	nl80211_notify_dev_rename(rdev);
159

160
	return 0;
161
162
}

163
164
165
166
167
168
int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
			  struct net *net)
{
	struct wireless_dev *wdev;
	int err = 0;

169
	if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
170
171
		return -EOPNOTSUPP;

172
	list_for_each_entry(wdev, &rdev->wdev_list, list) {
173
174
		if (!wdev->netdev)
			continue;
175
176
177
178
179
180
181
182
183
184
185
		wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
		err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
		if (err)
			break;
		wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
	}

	if (err) {
		/* failed -- clean up to old netns */
		net = wiphy_net(&rdev->wiphy);

186
		list_for_each_entry_continue_reverse(wdev, &rdev->wdev_list,
187
						     list) {
188
189
			if (!wdev->netdev)
				continue;
190
191
192
193
194
195
			wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
			err = dev_change_net_namespace(wdev->netdev, net,
							"wlan%d");
			WARN_ON(err);
			wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
		}
196
197

		return err;
198
199
200
201
	}

	wiphy_net_set(&rdev->wiphy, net);

202
203
204
205
	err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
	WARN_ON(err);

	return 0;
206
207
}

Johannes Berg's avatar
Johannes Berg committed
208
209
static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
{
210
	struct cfg80211_registered_device *rdev = data;
Johannes Berg's avatar
Johannes Berg committed
211

212
	rdev_rfkill_poll(rdev);
Johannes Berg's avatar
Johannes Berg committed
213
214
}

215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
			      struct wireless_dev *wdev)
{
	lockdep_assert_held(&rdev->devlist_mtx);
	lockdep_assert_held(&rdev->sched_scan_mtx);

	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
		return;

	if (!wdev->p2p_started)
		return;

	rdev_stop_p2p_device(rdev, wdev);
	wdev->p2p_started = false;

	rdev->opencount--;

	if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
		bool busy = work_busy(&rdev->scan_done_wk);

		/*
		 * If the work isn't pending or running (in which case it would
		 * be waiting for the lock we hold) the driver didn't properly
		 * cancel the scan when the interface was removed. In this case
		 * warn and leak the scan request object to not crash later.
		 */
		WARN_ON(!busy);

		rdev->scan_req->aborted = true;
		___cfg80211_scan_done(rdev, !busy);
	}
}

Johannes Berg's avatar
Johannes Berg committed
248
249
static int cfg80211_rfkill_set_block(void *data, bool blocked)
{
250
	struct cfg80211_registered_device *rdev = data;
Johannes Berg's avatar
Johannes Berg committed
251
252
253
254
255
256
	struct wireless_dev *wdev;

	if (!blocked)
		return 0;

	rtnl_lock();
257
258

	/* read-only iteration need not hold the devlist_mtx */
Johannes Berg's avatar
Johannes Berg committed
259

260
261
	list_for_each_entry(wdev, &rdev->wdev_list, list) {
		if (wdev->netdev) {
262
			dev_close(wdev->netdev);
263
264
265
266
267
			continue;
		}
		/* otherwise, check iftype */
		switch (wdev->iftype) {
		case NL80211_IFTYPE_P2P_DEVICE:
268
269
270
271
272
273
			/* but this requires it */
			mutex_lock(&rdev->devlist_mtx);
			mutex_lock(&rdev->sched_scan_mtx);
			cfg80211_stop_p2p_device(rdev, wdev);
			mutex_unlock(&rdev->sched_scan_mtx);
			mutex_unlock(&rdev->devlist_mtx);
274
275
276
277
278
			break;
		default:
			break;
		}
	}
Johannes Berg's avatar
Johannes Berg committed
279
280
281
282
283
284
285
286

	rtnl_unlock();

	return 0;
}

static void cfg80211_rfkill_sync_work(struct work_struct *work)
{
287
	struct cfg80211_registered_device *rdev;
Johannes Berg's avatar
Johannes Berg committed
288

289
290
	rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
	cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
Johannes Berg's avatar
Johannes Berg committed
291
292
}

Johannes Berg's avatar
Johannes Berg committed
293
294
295
296
297
298
299
300
301
302
static void cfg80211_event_work(struct work_struct *work)
{
	struct cfg80211_registered_device *rdev;

	rdev = container_of(work, struct cfg80211_registered_device,
			    event_work);

	rtnl_lock();
	cfg80211_lock_rdev(rdev);

303
	cfg80211_process_rdev_events(rdev);
Johannes Berg's avatar
Johannes Berg committed
304
305
306
307
	cfg80211_unlock_rdev(rdev);
	rtnl_unlock();
}

308
309
/* exported functions */

310
struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
311
{
312
	static int wiphy_counter;
313
314

	struct cfg80211_registered_device *rdev;
315
316
	int alloc_size;

317
318
319
320
321
322
323
	WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
	WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
	WARN_ON(ops->connect && !ops->disconnect);
	WARN_ON(ops->join_ibss && !ops->leave_ibss);
	WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
	WARN_ON(ops->add_station && !ops->del_station);
	WARN_ON(ops->add_mpath && !ops->del_mpath);
324
	WARN_ON(ops->join_mesh && !ops->leave_mesh);
325

326
	alloc_size = sizeof(*rdev) + sizeof_priv;
327

328
329
	rdev = kzalloc(alloc_size, GFP_KERNEL);
	if (!rdev)
330
331
		return NULL;

332
	rdev->ops = ops;
333

334
	mutex_lock(&cfg80211_mutex);
335

336
	rdev->wiphy_idx = wiphy_counter++;
337

338
	if (unlikely(rdev->wiphy_idx < 0)) {
339
		wiphy_counter--;
340
		mutex_unlock(&cfg80211_mutex);
341
		/* ugh, wrapped! */
342
		kfree(rdev);
343
344
345
		return NULL;
	}

346
	mutex_unlock(&cfg80211_mutex);
347

348
349
350
	/* give it a proper name */
	dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);

351
352
	mutex_init(&rdev->mtx);
	mutex_init(&rdev->devlist_mtx);
353
	mutex_init(&rdev->sched_scan_mtx);
354
	INIT_LIST_HEAD(&rdev->wdev_list);
355
356
	INIT_LIST_HEAD(&rdev->beacon_registrations);
	spin_lock_init(&rdev->beacon_registrations_lock);
357
358
359
	spin_lock_init(&rdev->bss_lock);
	INIT_LIST_HEAD(&rdev->bss_list);
	INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
360
	INIT_WORK(&rdev->sched_scan_results_wk, __cfg80211_sched_scan_results);
361
362
	INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
			  cfg80211_dfs_channels_update_work);
Johannes Berg's avatar
Johannes Berg committed
363
364
365
366
#ifdef CONFIG_CFG80211_WEXT
	rdev->wiphy.wext = &cfg80211_wext_handler;
#endif

367
368
369
370
	device_initialize(&rdev->wiphy.dev);
	rdev->wiphy.dev.class = &ieee80211_class;
	rdev->wiphy.dev.platform_data = rdev;

371
372
373
#ifdef CONFIG_CFG80211_DEFAULT_PS
	rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
#endif
374

375
376
	wiphy_net_set(&rdev->wiphy, &init_net);

377
378
379
380
381
382
383
	rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
	rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
				   &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
				   &rdev->rfkill_ops, rdev);

	if (!rdev->rfkill) {
		kfree(rdev);
Johannes Berg's avatar
Johannes Berg committed
384
385
386
		return NULL;
	}

387
388
389
	INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
	INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
	INIT_WORK(&rdev->event_work, cfg80211_event_work);
Johannes Berg's avatar
Johannes Berg committed
390

391
392
	init_waitqueue_head(&rdev->dev_wait);

393
394
395
396
397
	/*
	 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
	 * Fragmentation and RTS threshold are disabled by default with the
	 * special -1 value.
	 */
398
399
400
401
	rdev->wiphy.retry_short = 7;
	rdev->wiphy.retry_long = 4;
	rdev->wiphy.frag_threshold = (u32) -1;
	rdev->wiphy.rts_threshold = (u32) -1;
402
	rdev->wiphy.coverage_class = 0;
403

404
	rdev->wiphy.features = NL80211_FEATURE_SCAN_FLUSH;
405

406
	return &rdev->wiphy;
407
408
409
}
EXPORT_SYMBOL(wiphy_new);

410
411
412
413
414
415
416
417
418
419
420
static int wiphy_verify_combinations(struct wiphy *wiphy)
{
	const struct ieee80211_iface_combination *c;
	int i, j;

	for (i = 0; i < wiphy->n_iface_combinations; i++) {
		u32 cnt = 0;
		u16 all_iftypes = 0;

		c = &wiphy->iface_combinations[i];

421
422
423
424
425
		/*
		 * Combinations with just one interface aren't real,
		 * however we make an exception for DFS.
		 */
		if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
426
427
428
429
430
431
			return -EINVAL;

		/* Need at least one channel */
		if (WARN_ON(!c->num_different_channels))
			return -EINVAL;

432
433
434
435
436
437
438
439
		/*
		 * Put a sane limit on maximum number of different
		 * channels to simplify channel accounting code.
		 */
		if (WARN_ON(c->num_different_channels >
				CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
			return -EINVAL;

440
441
442
443
444
		/* DFS only works on one channel. */
		if (WARN_ON(c->radar_detect_widths &&
			    (c->num_different_channels > 1)))
			return -EINVAL;

445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
		if (WARN_ON(!c->n_limits))
			return -EINVAL;

		for (j = 0; j < c->n_limits; j++) {
			u16 types = c->limits[j].types;

			/*
			 * interface types shouldn't overlap, this is
			 * used in cfg80211_can_change_interface()
			 */
			if (WARN_ON(types & all_iftypes))
				return -EINVAL;
			all_iftypes |= types;

			if (WARN_ON(!c->limits[j].max))
				return -EINVAL;

			/* Shouldn't list software iftypes in combinations! */
			if (WARN_ON(wiphy->software_iftypes & types))
				return -EINVAL;

466
467
468
469
470
			/* Only a single P2P_DEVICE can be allowed */
			if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
				    c->limits[j].max > 1))
				return -EINVAL;

471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
			cnt += c->limits[j].max;
			/*
			 * Don't advertise an unsupported type
			 * in a combination.
			 */
			if (WARN_ON((wiphy->interface_modes & types) != types))
				return -EINVAL;
		}

		/* You can't even choose that many! */
		if (WARN_ON(cnt < c->max_interfaces))
			return -EINVAL;
	}

	return 0;
}

488
489
int wiphy_register(struct wiphy *wiphy)
{
490
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
491
	int res;
492
493
494
495
	enum ieee80211_band band;
	struct ieee80211_supported_band *sband;
	bool have_band = false;
	int i;
496
497
	u16 ifmodes = wiphy->interface_modes;

498
#ifdef CONFIG_PM
499
500
501
	if (WARN_ON((wiphy->wowlan.flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
		    !(wiphy->wowlan.flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
		return -EINVAL;
502
#endif
503

504
505
506
507
	if (WARN_ON(wiphy->ap_sme_capa &&
		    !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
		return -EINVAL;

508
509
510
511
512
513
514
515
516
	if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
		return -EINVAL;

	if (WARN_ON(wiphy->addresses &&
		    !is_zero_ether_addr(wiphy->perm_addr) &&
		    memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
			   ETH_ALEN)))
		return -EINVAL;

517
518
519
520
521
	if (WARN_ON(wiphy->max_acl_mac_addrs &&
		    (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
		     !rdev->ops->set_mac_acl)))
		return -EINVAL;

522
523
524
	if (wiphy->addresses)
		memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);

525
526
	/* sanity check ifmodes */
	WARN_ON(!ifmodes);
527
	ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
528
529
	if (WARN_ON(ifmodes != wiphy->interface_modes))
		wiphy->interface_modes = ifmodes;
530

531
532
533
534
	res = wiphy_verify_combinations(wiphy);
	if (res)
		return res;

535
536
537
538
539
540
541
	/* sanity check supported bands/channels */
	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
		sband = wiphy->bands[band];
		if (!sband)
			continue;

		sband->band = band;
542
543
544
545
546
547
548
549
		if (WARN_ON(!sband->n_channels))
			return -EINVAL;
		/*
		 * on 60gHz band, there are no legacy rates, so
		 * n_bitrates is 0
		 */
		if (WARN_ON(band != IEEE80211_BAND_60GHZ &&
			    !sband->n_bitrates))
550
551
			return -EINVAL;

552
553
554
555
556
557
558
559
560
561
562
563
		/*
		 * Since cfg80211_disable_40mhz_24ghz is global, we can
		 * modify the sband's ht data even if the driver uses a
		 * global structure for that.
		 */
		if (cfg80211_disable_40mhz_24ghz &&
		    band == IEEE80211_BAND_2GHZ &&
		    sband->ht_cap.ht_supported) {
			sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
			sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
		}

564
565
566
567
568
569
		/*
		 * Since we use a u32 for rate bitmaps in
		 * ieee80211_get_response_rate, we cannot
		 * have more than 32 legacy rates.
		 */
		if (WARN_ON(sband->n_bitrates > 32))
570
571
572
573
574
			return -EINVAL;

		for (i = 0; i < sband->n_channels; i++) {
			sband->channels[i].orig_flags =
				sband->channels[i].flags;
575
			sband->channels[i].orig_mag = INT_MAX;
576
577
578
579
580
581
582
583
584
585
586
587
588
			sband->channels[i].orig_mpwr =
				sband->channels[i].max_power;
			sband->channels[i].band = band;
		}

		have_band = true;
	}

	if (!have_band) {
		WARN_ON(1);
		return -EINVAL;
	}

589
#ifdef CONFIG_PM
590
591
592
593
594
595
	if (rdev->wiphy.wowlan.n_patterns) {
		if (WARN_ON(!rdev->wiphy.wowlan.pattern_min_len ||
			    rdev->wiphy.wowlan.pattern_min_len >
			    rdev->wiphy.wowlan.pattern_max_len))
			return -EINVAL;
	}
596
#endif
597

598
599
600
	/* check and set up bitrates */
	ieee80211_set_bitrate_flags(wiphy);

601
602
	mutex_lock(&cfg80211_mutex);

603
	res = device_add(&rdev->wiphy.dev);
604
605
606
607
	if (res) {
		mutex_unlock(&cfg80211_mutex);
		return res;
	}
Johannes Berg's avatar
Johannes Berg committed
608

609
	/* set up regulatory info */
610
	wiphy_regulatory_register(wiphy);
611

612
	list_add_rcu(&rdev->list, &cfg80211_rdev_list);
613
	cfg80211_rdev_list_generation++;
614
615

	/* add to debugfs */
616
617
	rdev->wiphy.debugfsdir =
		debugfs_create_dir(wiphy_name(&rdev->wiphy),
618
				   ieee80211_debugfs_dir);
619
620
	if (IS_ERR(rdev->wiphy.debugfsdir))
		rdev->wiphy.debugfsdir = NULL;
621

622
	if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
623
624
625
626
627
628
629
630
631
632
		struct regulatory_request request;

		request.wiphy_idx = get_wiphy_idx(wiphy);
		request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
		request.alpha2[0] = '9';
		request.alpha2[1] = '9';

		nl80211_send_reg_change_event(&request);
	}

633
	cfg80211_debugfs_rdev_add(rdev);
634
	mutex_unlock(&cfg80211_mutex);
635

636
637
638
639
640
641
642
643
	/*
	 * due to a locking dependency this has to be outside of the
	 * cfg80211_mutex lock
	 */
	res = rfkill_register(rdev->rfkill);
	if (res)
		goto out_rm_dev;

644
645
646
	rtnl_lock();
	rdev->wiphy.registered = true;
	rtnl_unlock();
647
	return 0;
Johannes Berg's avatar
Johannes Berg committed
648

649
out_rm_dev:
650
	device_del(&rdev->wiphy.dev);
651
652
653
654
	return res;
}
EXPORT_SYMBOL(wiphy_register);

Johannes Berg's avatar
Johannes Berg committed
655
656
void wiphy_rfkill_start_polling(struct wiphy *wiphy)
{
657
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg's avatar
Johannes Berg committed
658

659
	if (!rdev->ops->rfkill_poll)
Johannes Berg's avatar
Johannes Berg committed
660
		return;
661
662
	rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
	rfkill_resume_polling(rdev->rfkill);
Johannes Berg's avatar
Johannes Berg committed
663
664
665
666
667
}
EXPORT_SYMBOL(wiphy_rfkill_start_polling);

void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
{
668
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg's avatar
Johannes Berg committed
669

670
	rfkill_pause_polling(rdev->rfkill);
Johannes Berg's avatar
Johannes Berg committed
671
672
673
}
EXPORT_SYMBOL(wiphy_rfkill_stop_polling);

674
675
void wiphy_unregister(struct wiphy *wiphy)
{
676
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
677

678
679
680
681
	rtnl_lock();
	rdev->wiphy.registered = false;
	rtnl_unlock();

682
	rfkill_unregister(rdev->rfkill);
Johannes Berg's avatar
Johannes Berg committed
683

684
	/* protect the device list */
685
	mutex_lock(&cfg80211_mutex);
686

687
688
689
690
691
	wait_event(rdev->dev_wait, ({
		int __count;
		mutex_lock(&rdev->devlist_mtx);
		__count = rdev->opencount;
		mutex_unlock(&rdev->devlist_mtx);
692
		__count == 0; }));
693
694

	mutex_lock(&rdev->devlist_mtx);
695
	BUG_ON(!list_empty(&rdev->wdev_list));
696
697
698
699
700
701
	mutex_unlock(&rdev->devlist_mtx);

	/*
	 * First remove the hardware from everywhere, this makes
	 * it impossible to find from userspace.
	 */
702
	debugfs_remove_recursive(rdev->wiphy.debugfsdir);
703
704
	list_del_rcu(&rdev->list);
	synchronize_rcu();
705
706

	/*
707
	 * Try to grab rdev->mtx. If a command is still in progress,
708
709
710
711
	 * hopefully the driver will refuse it since it's tearing
	 * down the device already. We wait for this command to complete
	 * before unlinking the item from the list.
	 * Note: as codified by the BUG_ON above we cannot get here if
712
713
714
	 * a virtual interface is still present. Hence, we can only get
	 * to lock contention here if userspace issues a command that
	 * identified the hardware by wiphy index.
715
	 */
Johannes Berg's avatar
Johannes Berg committed
716
	cfg80211_lock_rdev(rdev);
717
	/* nothing */
Johannes Berg's avatar
Johannes Berg committed
718
	cfg80211_unlock_rdev(rdev);
719

720
721
722
723
724
	/*
	 * If this device got a regulatory hint tell core its
	 * free to listen now to a new shiny device regulatory hint
	 */
	wiphy_regulatory_deregister(wiphy);
725

726
	cfg80211_rdev_list_generation++;
727
	device_del(&rdev->wiphy.dev);
728

729
	mutex_unlock(&cfg80211_mutex);
Johannes Berg's avatar
Johannes Berg committed
730

731
	flush_work(&rdev->scan_done_wk);
Johannes Berg's avatar
Johannes Berg committed
732
733
	cancel_work_sync(&rdev->conn_work);
	flush_work(&rdev->event_work);
734
	cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
735
736

	if (rdev->wowlan && rdev->ops->set_wakeup)
737
		rdev_set_wakeup(rdev, false);
738
	cfg80211_rdev_free_wowlan(rdev);
739
740
741
}
EXPORT_SYMBOL(wiphy_unregister);

742
void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
743
{
744
	struct cfg80211_internal_bss *scan, *tmp;
745
	struct cfg80211_beacon_registration *reg, *treg;
746
747
748
	rfkill_destroy(rdev->rfkill);
	mutex_destroy(&rdev->mtx);
	mutex_destroy(&rdev->devlist_mtx);
749
	mutex_destroy(&rdev->sched_scan_mtx);
750
751
752
753
	list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
		list_del(&reg->list);
		kfree(reg);
	}
754
	list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
755
		cfg80211_put_bss(&rdev->wiphy, &scan->pub);
756
	kfree(rdev);
757
758
759
760
761
762
763
764
}

void wiphy_free(struct wiphy *wiphy)
{
	put_device(&wiphy->dev);
}
EXPORT_SYMBOL(wiphy_free);

Johannes Berg's avatar
Johannes Berg committed
765
766
void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
{
767
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg's avatar
Johannes Berg committed
768

769
770
	if (rfkill_set_hw_state(rdev->rfkill, blocked))
		schedule_work(&rdev->rfkill_sync);
Johannes Berg's avatar
Johannes Berg committed
771
772
773
}
EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);

774
775
776
777
778
779
780
781
static void wdev_cleanup_work(struct work_struct *work)
{
	struct wireless_dev *wdev;
	struct cfg80211_registered_device *rdev;

	wdev = container_of(work, struct wireless_dev, cleanup_work);
	rdev = wiphy_to_dev(wdev->wiphy);

782
	mutex_lock(&rdev->sched_scan_mtx);
783

Johannes Berg's avatar
Johannes Berg committed
784
	if (WARN_ON(rdev->scan_req && rdev->scan_req->wdev == wdev)) {
785
		rdev->scan_req->aborted = true;
786
		___cfg80211_scan_done(rdev, true);
787
788
	}

789
790
791
792
793
	if (WARN_ON(rdev->sched_scan_req &&
		    rdev->sched_scan_req->dev == wdev->netdev)) {
		__cfg80211_stop_sched_scan(rdev, false);
	}

794
	mutex_unlock(&rdev->sched_scan_mtx);
795
796
797
798
799
800
801
802
803

	mutex_lock(&rdev->devlist_mtx);
	rdev->opencount--;
	mutex_unlock(&rdev->devlist_mtx);
	wake_up(&rdev->dev_wait);

	dev_put(wdev->netdev);
}

804
805
806
807
808
809
810
811
812
813
void cfg80211_unregister_wdev(struct wireless_dev *wdev)
{
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);

	ASSERT_RTNL();

	if (WARN_ON(wdev->netdev))
		return;

	mutex_lock(&rdev->devlist_mtx);
814
	mutex_lock(&rdev->sched_scan_mtx);
815
816
817
818
819
	list_del_rcu(&wdev->list);
	rdev->devlist_generation++;

	switch (wdev->iftype) {
	case NL80211_IFTYPE_P2P_DEVICE:
820
		cfg80211_stop_p2p_device(rdev, wdev);
821
822
823
824
825
		break;
	default:
		WARN_ON_ONCE(1);
		break;
	}
826
	mutex_unlock(&rdev->sched_scan_mtx);
827
828
829
830
	mutex_unlock(&rdev->devlist_mtx);
}
EXPORT_SYMBOL(cfg80211_unregister_wdev);

831
832
833
834
static struct device_type wiphy_type = {
	.name	= "wlan",
};

835
836
837
void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
			       enum nl80211_iftype iftype, int num)
{
838
	ASSERT_RTNL();
839
840
841
842
843
844

	rdev->num_running_ifaces += num;
	if (iftype == NL80211_IFTYPE_MONITOR)
		rdev->num_running_monitor_ifaces += num;
}

845
static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
846
847
848
849
					 unsigned long state,
					 void *ndev)
{
	struct net_device *dev = ndev;
850
	struct wireless_dev *wdev = dev->ieee80211_ptr;
851
	struct cfg80211_registered_device *rdev;
852
	int ret;
853

854
	if (!wdev)
Johannes Berg's avatar
Johannes Berg committed
855
		return NOTIFY_DONE;
856

857
	rdev = wiphy_to_dev(wdev->wiphy);
858

859
	WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
Johannes Berg's avatar
Johannes Berg committed
860

861
	switch (state) {
862
863
864
	case NETDEV_POST_INIT:
		SET_NETDEV_DEVTYPE(dev, &wiphy_type);
		break;
865
	case NETDEV_REGISTER:
Johannes Berg's avatar
Johannes Berg committed
866
867
868
869
870
		/*
		 * NB: cannot take rdev->mtx here because this may be
		 * called within code protected by it when interfaces
		 * are added with nl80211.
		 */
Johannes Berg's avatar
Johannes Berg committed
871
		mutex_init(&wdev->mtx);
872
		INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
Johannes Berg's avatar
Johannes Berg committed
873
874
		INIT_LIST_HEAD(&wdev->event_list);
		spin_lock_init(&wdev->event_lock);
875
876
		INIT_LIST_HEAD(&wdev->mgmt_registrations);
		spin_lock_init(&wdev->mgmt_registrations_lock);
877

878
		mutex_lock(&rdev->devlist_mtx);
879
880
		wdev->identifier = ++rdev->wdev_id;
		list_add_rcu(&wdev->list, &rdev->wdev_list);
881
		rdev->devlist_generation++;
882
883
884
		/* can only change netns with wiphy */
		dev->features |= NETIF_F_NETNS_LOCAL;

885
886
		if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
				      "phy80211")) {
887
			pr_err("failed to add phy80211 symlink to netdev!\n");
888
		}
889
		wdev->netdev = dev;
890
		wdev->sme_state = CFG80211_SME_IDLE;
Johannes Berg's avatar
Johannes Berg committed
891
		mutex_unlock(&rdev->devlist_mtx);
Johannes Berg's avatar
Johannes Berg committed
892
#ifdef CONFIG_CFG80211_WEXT
893
894
		wdev->wext.default_key = -1;
		wdev->wext.default_mgmt_key = -1;
895
		wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
Kalle Valo's avatar
Kalle Valo committed
896
897
#endif

898
		if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
Kalle Valo's avatar
Kalle Valo committed
899
			wdev->ps = true;
900
		else
Kalle Valo's avatar
Kalle Valo committed
901
			wdev->ps = false;
902
903
		/* allow mac80211 to determine the timeout */
		wdev->ps_timeout = -1;
Kalle Valo's avatar
Kalle Valo committed
904

905
906
		if (!dev->ethtool_ops)
			dev->ethtool_ops = &cfg80211_ethtool_ops;
907
908

		if ((wdev->iftype == NL80211_IFTYPE_STATION ||
909
		     wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
910
911
		     wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
			dev->priv_flags |= IFF_DONT_BRIDGE;
912
		break;
Johannes Berg's avatar
Johannes Berg committed
913
	case NETDEV_GOING_DOWN:
914
915
916
917
		switch (wdev->iftype) {
		case NL80211_IFTYPE_ADHOC:
			cfg80211_leave_ibss(rdev, dev, true);
			break;
918
		case NL80211_IFTYPE_P2P_CLIENT:
919
		case NL80211_IFTYPE_STATION:
920
			mutex_lock(&rdev->sched_scan_mtx);
921
			__cfg80211_stop_sched_scan(rdev, false);
922
			mutex_unlock(&rdev->sched_scan_mtx);
923

Johannes Berg's avatar
Johannes Berg committed
924
			wdev_lock(wdev);
Johannes Berg's avatar
Johannes Berg committed
925
#ifdef CONFIG_CFG80211_WEXT
926
927
928
			kfree(wdev->wext.ie);
			wdev->wext.ie = NULL;
			wdev->wext.ie_len = 0;
Johannes Berg's avatar
Johannes Berg committed
929
			wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
930
#endif
Johannes Berg's avatar
Johannes Berg committed
931
932
			__cfg80211_disconnect(rdev, dev,
					      WLAN_REASON_DEAUTH_LEAVING, true);
Johannes Berg's avatar
Johannes Berg committed
933
			cfg80211_mlme_down(rdev, dev);
Johannes Berg's avatar
Johannes Berg committed
934
			wdev_unlock(wdev);
935
			break;
936
937
938
		case NL80211_IFTYPE_MESH_POINT:
			cfg80211_leave_mesh(rdev, dev);
			break;
939
940
941
		case NL80211_IFTYPE_AP:
			cfg80211_stop_ap(rdev, dev);
			break;
942
943
944
		default:
			break;
		}
945
		wdev->beacon_interval = 0;
946
947
		break;
	case NETDEV_DOWN:
948
		cfg80211_update_iface_num(rdev, wdev->iftype, -1);
949
		dev_hold(dev);
950
		queue_work(cfg80211_wq, &wdev->cleanup_work);
Johannes Berg's avatar
Johannes Berg committed
951
952
		break;
	case NETDEV_UP:
953
954
955
956
957
958
959
960
961
962
963
964
		/*
		 * If we have a really quick DOWN/UP succession we may
		 * have this work still pending ... cancel it and see
		 * if it was pending, in which case we need to account
		 * for some of the work it would have done.
		 */
		if (cancel_work_sync(&wdev->cleanup_work)) {
			mutex_lock(&rdev->devlist_mtx);
			rdev->opencount--;
			mutex_unlock(&rdev->devlist_mtx);
			dev_put(dev);
		}
965
		cfg80211_update_iface_num(rdev, wdev->iftype, 1);
Johannes Berg's avatar
Johannes Berg committed
966
		cfg80211_lock_rdev(rdev);
967
		mutex_lock(&rdev->devlist_mtx);
968
		mutex_lock(&rdev->sched_scan_mtx);
Johannes Berg's avatar
Johannes Berg committed
969
		wdev_lock(wdev);
970
		switch (wdev->iftype) {