core.c 28.7 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
	/*
	 * due to a locking dependency this has to be outside of the
	 * cfg80211_mutex lock
	 */
	res = rfkill_register(rdev->rfkill);
641 642 643 644 645 646 647 648 649 650
	if (res) {
		device_del(&rdev->wiphy.dev);

		mutex_lock(&cfg80211_mutex);
		debugfs_remove_recursive(rdev->wiphy.debugfsdir);
		list_del_rcu(&rdev->list);
		wiphy_regulatory_deregister(wiphy);
		mutex_unlock(&cfg80211_mutex);
		return res;
	}
651

652 653 654
	rtnl_lock();
	rdev->wiphy.registered = true;
	rtnl_unlock();
655
	return 0;
656 657 658
}
EXPORT_SYMBOL(wiphy_register);

Johannes Berg's avatar
Johannes Berg committed
659 660
void wiphy_rfkill_start_polling(struct wiphy *wiphy)
{
661
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg's avatar
Johannes Berg committed
662

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

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

674
	rfkill_pause_polling(rdev->rfkill);
Johannes Berg's avatar
Johannes Berg committed
675 676 677
}
EXPORT_SYMBOL(wiphy_rfkill_stop_polling);

678 679
void wiphy_unregister(struct wiphy *wiphy)
{
680
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
681

682 683 684 685
	rtnl_lock();
	rdev->wiphy.registered = false;
	rtnl_unlock();

686
	rfkill_unregister(rdev->rfkill);
Johannes Berg's avatar
Johannes Berg committed
687

688
	/* protect the device list */
689
	mutex_lock(&cfg80211_mutex);
690

691 692 693 694 695
	wait_event(rdev->dev_wait, ({
		int __count;
		mutex_lock(&rdev->devlist_mtx);
		__count = rdev->opencount;
		mutex_unlock(&rdev->devlist_mtx);
696
		__count == 0; }));
697 698

	mutex_lock(&rdev->devlist_mtx);
699
	BUG_ON(!list_empty(&rdev->wdev_list));
700 701 702 703 704 705
	mutex_unlock(&rdev->devlist_mtx);

	/*
	 * First remove the hardware from everywhere, this makes
	 * it impossible to find from userspace.
	 */
706
	debugfs_remove_recursive(rdev->wiphy.debugfsdir);
707 708
	list_del_rcu(&rdev->list);
	synchronize_rcu();
709 710

	/*
711
	 * Try to grab rdev->mtx. If a command is still in progress,
712 713 714 715
	 * 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
716 717 718
	 * 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.
719
	 */
Johannes Berg's avatar
Johannes Berg committed
720
	cfg80211_lock_rdev(rdev);
721
	/* nothing */
Johannes Berg's avatar
Johannes Berg committed
722
	cfg80211_unlock_rdev(rdev);
723

724 725 726 727 728
	/*
	 * 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);
729

730
	cfg80211_rdev_list_generation++;
731
	device_del(&rdev->wiphy.dev);
732

733
	mutex_unlock(&cfg80211_mutex);
Johannes Berg's avatar
Johannes Berg committed
734

735
	flush_work(&rdev->scan_done_wk);
Johannes Berg's avatar
Johannes Berg committed
736 737
	cancel_work_sync(&rdev->conn_work);
	flush_work(&rdev->event_work);
738
	cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
739 740

	if (rdev->wowlan && rdev->ops->set_wakeup)
741
		rdev_set_wakeup(rdev, false);
742
	cfg80211_rdev_free_wowlan(rdev);
743 744 745
}
EXPORT_SYMBOL(wiphy_unregister);

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

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

Johannes Berg's avatar
Johannes Berg committed
769 770
void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
{
771
	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg's avatar
Johannes Berg committed
772

773 774
	if (rfkill_set_hw_state(rdev->rfkill, blocked))
		schedule_work(&rdev->rfkill_sync);
Johannes Berg's avatar
Johannes Berg committed
775 776 777
}
EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);

778 779 780 781 782 783 784 785
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);

786
	mutex_lock(&rdev->sched_scan_mtx);
787

Johannes Berg's avatar
Johannes Berg committed
788
	if (WARN_ON(rdev->scan_req && rdev->scan_req->wdev == wdev)) {
789
		rdev->scan_req->aborted = true;
790
		___cfg80211_scan_done(rdev, true);
791 792
	}

793 794 795 796 797
	if (WARN_ON(rdev->sched_scan_req &&
		    rdev->sched_scan_req->dev == wdev->netdev)) {
		__cfg80211_stop_sched_scan(rdev, false);
	}

798
	mutex_unlock(&rdev->sched_scan_mtx);
799 800 801 802 803 804 805 806 807

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

	dev_put(wdev->netdev);
}

808 809 810 811 812 813 814 815 816 817
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);
818
	mutex_lock(&rdev->sched_scan_mtx);
819 820 821 822 823
	list_del_rcu(&wdev->list);
	rdev->devlist_generation++;

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

835 836 837 838
static struct device_type wiphy_type = {
	.name	= "wlan",
};

839 840 841
void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
			       enum nl80211_iftype iftype, int num)
{
842
	ASSERT_RTNL();
843 844 845 846 847 848

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

849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
void cfg80211_leave(struct cfg80211_registered_device *rdev,
		   struct wireless_dev *wdev)
{
	struct net_device *dev = wdev->netdev;

	switch (wdev->iftype) {
	case NL80211_IFTYPE_ADHOC:
		cfg80211_leave_ibss(rdev, dev, true);
		break;
	case NL80211_IFTYPE_P2P_CLIENT:
	case NL80211_IFTYPE_STATION:
		mutex_lock(&rdev->sched_scan_mtx);
		__cfg80211_stop_sched_scan(rdev, false);
		mutex_unlock(&rdev->sched_scan_mtx);

		wdev_lock(wdev);
#ifdef CONFIG_CFG80211_WEXT
		kfree(wdev->wext.ie);
		wdev->wext.ie = NULL;
		wdev->wext.ie_len = 0;
		wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
#endif
		__cfg80211_disconnect(rdev, dev,
				      WLAN_REASON_DEAUTH_LEAVING, true);
		wdev_unlock(wdev);
		break;
	case NL80211_IFTYPE_MESH_POINT:
		cfg80211_leave_mesh(rdev, dev);
		break;
	case NL80211_IFTYPE_AP:
		cfg80211_stop_ap(rdev, dev);
		break;
	default:
		break;
	}

	wdev->beacon_interval = 0;
}

888
static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
889 890 891 892
					 unsigned long state,
					 void *ndev)
{
	struct net_device *dev = ndev;
893
	struct wireless_dev *wdev = dev->ieee80211_ptr;
894
	struct cfg80211_registered_device *rdev;
895
	int ret;
896

897
	if (!wdev)
Johannes Berg's avatar
Johannes Berg committed
898
		return NOTIFY_DONE;
899

900
	rdev = wiphy_to_dev(wdev->wiphy);
901

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

904
	switch (state) {
905 906 907
	case NETDEV_POST_INIT:
		SET_NETDEV_DEVTYPE(dev, &wiphy_type);
		break;
908
	case NETDEV_REGISTER:
Johannes Berg's avatar
Johannes Berg committed
909 910 911 912 913
		/*
		 * 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
914
		mutex_init(&wdev->mtx);
915
		INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
Johannes Berg's avatar
Johannes Berg committed
916 917
		INIT_LIST_HEAD(&wdev->event_list);
		spin_lock_init(&wdev->event_lock);
918 919
		INIT_LIST_HEAD(&wdev->mgmt_registrations);
		spin_lock_init(&wdev->mgmt_registrations_lock);
920

921
		mutex_lock(&rdev->devlist_mtx);
922 923
		wdev->identifier = ++rdev->wdev_id;
		list_add_rcu(&wdev->list, &rdev->wdev_list);
924
		rdev->devlist_generation++;
925 926 927
		/* can only change netns with wiphy */
		dev->features |= NETIF_F_NETNS_LOCAL;

928 929
		if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
				      "phy80211")) {
930
			pr_err("failed to add phy80211 symlink to netdev!\n");
931
		}
932
		wdev->netdev = dev;
933
		wdev->sme_state = CFG80211_SME_IDLE;
Johannes Berg's avatar
Johannes Berg committed
934
		mutex_unlock(&rdev->devlist_mtx);
Johannes Berg's avatar
Johannes Berg committed
935
#ifdef CONFIG_CFG80211_WEXT
936 937
		wdev->wext.default_key = -1;
		wdev->wext.default_mgmt_key = -1;
938
		wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
Kalle Valo's avatar
Kalle Valo committed
939 940
#endif

941
		if (wdev->wiphy