1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * This is the linux wireless configuration interface.
4  *
5  * Copyright 2006-2010		Johannes Berg <johannes@sipsolutions.net>
6  * Copyright 2013-2014  Intel Mobile Communications GmbH
7  * Copyright 2015-2017	Intel Deutschland GmbH
8  * Copyright (C) 2018-2022 Intel Corporation
9  */
10 
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 
13 #include <linux/if.h>
14 #include <linux/module.h>
15 #include <linux/err.h>
16 #include <linux/list.h>
17 #include <linux/slab.h>
18 #include <linux/nl80211.h>
19 #include <linux/debugfs.h>
20 #include <linux/notifier.h>
21 #include <linux/device.h>
22 #include <linux/etherdevice.h>
23 #include <linux/rtnetlink.h>
24 #include <linux/sched.h>
25 #include <net/genetlink.h>
26 #include <net/cfg80211.h>
27 #include "nl80211.h"
28 #include "core.h"
29 #include "sysfs.h"
30 #include "debugfs.h"
31 #include "wext-compat.h"
32 #include "rdev-ops.h"
33 
34 /* name for sysfs, %d is appended */
35 #define PHY_NAME "phy"
36 
37 MODULE_AUTHOR("Johannes Berg");
38 MODULE_LICENSE("GPL");
39 MODULE_DESCRIPTION("wireless configuration support");
40 MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME);
41 
42 /* RCU-protected (and RTNL for writers) */
43 LIST_HEAD(cfg80211_rdev_list);
44 int cfg80211_rdev_list_generation;
45 
46 /* for debugfs */
47 static struct dentry *ieee80211_debugfs_dir;
48 
49 /* for the cleanup, scan and event works */
50 struct workqueue_struct *cfg80211_wq;
51 
52 static bool cfg80211_disable_40mhz_24ghz;
53 module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
54 MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
55 		 "Disable 40MHz support in the 2.4GHz band");
56 
cfg80211_rdev_by_wiphy_idx(int wiphy_idx)57 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
58 {
59 	struct cfg80211_registered_device *result = NULL, *rdev;
60 
61 	ASSERT_RTNL();
62 
63 	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
64 		if (rdev->wiphy_idx == wiphy_idx) {
65 			result = rdev;
66 			break;
67 		}
68 	}
69 
70 	return result;
71 }
72 
get_wiphy_idx(struct wiphy * wiphy)73 int get_wiphy_idx(struct wiphy *wiphy)
74 {
75 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
76 
77 	return rdev->wiphy_idx;
78 }
79 
wiphy_idx_to_wiphy(int wiphy_idx)80 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
81 {
82 	struct cfg80211_registered_device *rdev;
83 
84 	ASSERT_RTNL();
85 
86 	rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
87 	if (!rdev)
88 		return NULL;
89 	return &rdev->wiphy;
90 }
91 
cfg80211_dev_check_name(struct cfg80211_registered_device * rdev,const char * newname)92 static int cfg80211_dev_check_name(struct cfg80211_registered_device *rdev,
93 				   const char *newname)
94 {
95 	struct cfg80211_registered_device *rdev2;
96 	int wiphy_idx, taken = -1, digits;
97 
98 	ASSERT_RTNL();
99 
100 	if (strlen(newname) > NL80211_WIPHY_NAME_MAXLEN)
101 		return -EINVAL;
102 
103 	/* prohibit calling the thing phy%d when %d is not its number */
104 	sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
105 	if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
106 		/* count number of places needed to print wiphy_idx */
107 		digits = 1;
108 		while (wiphy_idx /= 10)
109 			digits++;
110 		/*
111 		 * deny the name if it is phy<idx> where <idx> is printed
112 		 * without leading zeroes. taken == strlen(newname) here
113 		 */
114 		if (taken == strlen(PHY_NAME) + digits)
115 			return -EINVAL;
116 	}
117 
118 	/* Ensure another device does not already have this name. */
119 	list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
120 		if (strcmp(newname, wiphy_name(&rdev2->wiphy)) == 0)
121 			return -EINVAL;
122 
123 	return 0;
124 }
125 
cfg80211_dev_rename(struct cfg80211_registered_device * rdev,char * newname)126 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
127 			char *newname)
128 {
129 	int result;
130 
131 	ASSERT_RTNL();
132 	lockdep_assert_wiphy(&rdev->wiphy);
133 
134 	/* Ignore nop renames */
135 	if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
136 		return 0;
137 
138 	result = cfg80211_dev_check_name(rdev, newname);
139 	if (result < 0)
140 		return result;
141 
142 	result = device_rename(&rdev->wiphy.dev, newname);
143 	if (result)
144 		return result;
145 
146 	if (!IS_ERR_OR_NULL(rdev->wiphy.debugfsdir))
147 		debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
148 			       rdev->wiphy.debugfsdir,
149 			       rdev->wiphy.debugfsdir->d_parent, newname);
150 
151 	nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
152 
153 	return 0;
154 }
155 
cfg80211_switch_netns(struct cfg80211_registered_device * rdev,struct net * net)156 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
157 			  struct net *net)
158 {
159 	struct wireless_dev *wdev;
160 	int err = 0;
161 
162 	if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
163 		return -EOPNOTSUPP;
164 
165 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
166 		if (!wdev->netdev)
167 			continue;
168 		wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
169 		err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
170 		if (err)
171 			break;
172 		wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
173 	}
174 
175 	if (err) {
176 		/* failed -- clean up to old netns */
177 		net = wiphy_net(&rdev->wiphy);
178 
179 		list_for_each_entry_continue_reverse(wdev,
180 						     &rdev->wiphy.wdev_list,
181 						     list) {
182 			if (!wdev->netdev)
183 				continue;
184 			wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
185 			err = dev_change_net_namespace(wdev->netdev, net,
186 							"wlan%d");
187 			WARN_ON(err);
188 			wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
189 		}
190 
191 		return err;
192 	}
193 
194 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
195 		if (!wdev->netdev)
196 			continue;
197 		nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
198 	}
199 
200 	wiphy_lock(&rdev->wiphy);
201 	nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
202 
203 	wiphy_net_set(&rdev->wiphy, net);
204 
205 	err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
206 	WARN_ON(err);
207 
208 	nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
209 	wiphy_unlock(&rdev->wiphy);
210 
211 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
212 		if (!wdev->netdev)
213 			continue;
214 		nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
215 	}
216 
217 	return 0;
218 }
219 
cfg80211_rfkill_poll(struct rfkill * rfkill,void * data)220 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
221 {
222 	struct cfg80211_registered_device *rdev = data;
223 
224 	wiphy_lock(&rdev->wiphy);
225 	rdev_rfkill_poll(rdev);
226 	wiphy_unlock(&rdev->wiphy);
227 }
228 
cfg80211_stop_p2p_device(struct cfg80211_registered_device * rdev,struct wireless_dev * wdev)229 void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
230 			      struct wireless_dev *wdev)
231 {
232 	lockdep_assert_held(&rdev->wiphy.mtx);
233 
234 	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
235 		return;
236 
237 	if (!wdev_running(wdev))
238 		return;
239 
240 	rdev_stop_p2p_device(rdev, wdev);
241 	wdev->is_running = false;
242 
243 	rdev->opencount--;
244 
245 	if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
246 		if (WARN_ON(!rdev->scan_req->notified &&
247 			    (!rdev->int_scan_req ||
248 			     !rdev->int_scan_req->notified)))
249 			rdev->scan_req->info.aborted = true;
250 		___cfg80211_scan_done(rdev, false);
251 	}
252 }
253 
cfg80211_stop_nan(struct cfg80211_registered_device * rdev,struct wireless_dev * wdev)254 void cfg80211_stop_nan(struct cfg80211_registered_device *rdev,
255 		       struct wireless_dev *wdev)
256 {
257 	lockdep_assert_held(&rdev->wiphy.mtx);
258 
259 	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_NAN))
260 		return;
261 
262 	if (!wdev_running(wdev))
263 		return;
264 
265 	rdev_stop_nan(rdev, wdev);
266 	wdev->is_running = false;
267 
268 	rdev->opencount--;
269 }
270 
cfg80211_shutdown_all_interfaces(struct wiphy * wiphy)271 void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy)
272 {
273 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
274 	struct wireless_dev *wdev;
275 
276 	ASSERT_RTNL();
277 
278 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
279 		if (wdev->netdev) {
280 			dev_close(wdev->netdev);
281 			continue;
282 		}
283 
284 		/* otherwise, check iftype */
285 
286 		wiphy_lock(wiphy);
287 
288 		switch (wdev->iftype) {
289 		case NL80211_IFTYPE_P2P_DEVICE:
290 			cfg80211_stop_p2p_device(rdev, wdev);
291 			break;
292 		case NL80211_IFTYPE_NAN:
293 			cfg80211_stop_nan(rdev, wdev);
294 			break;
295 		default:
296 			break;
297 		}
298 
299 		wiphy_unlock(wiphy);
300 	}
301 }
302 EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces);
303 
cfg80211_rfkill_set_block(void * data,bool blocked)304 static int cfg80211_rfkill_set_block(void *data, bool blocked)
305 {
306 	struct cfg80211_registered_device *rdev = data;
307 
308 	if (!blocked)
309 		return 0;
310 
311 	rtnl_lock();
312 	cfg80211_shutdown_all_interfaces(&rdev->wiphy);
313 	rtnl_unlock();
314 
315 	return 0;
316 }
317 
cfg80211_rfkill_block_work(struct work_struct * work)318 static void cfg80211_rfkill_block_work(struct work_struct *work)
319 {
320 	struct cfg80211_registered_device *rdev;
321 
322 	rdev = container_of(work, struct cfg80211_registered_device,
323 			    rfkill_block);
324 	cfg80211_rfkill_set_block(rdev, true);
325 }
326 
cfg80211_event_work(struct work_struct * work)327 static void cfg80211_event_work(struct work_struct *work)
328 {
329 	struct cfg80211_registered_device *rdev;
330 
331 	rdev = container_of(work, struct cfg80211_registered_device,
332 			    event_work);
333 
334 	wiphy_lock(&rdev->wiphy);
335 	cfg80211_process_rdev_events(rdev);
336 	wiphy_unlock(&rdev->wiphy);
337 }
338 
cfg80211_destroy_ifaces(struct cfg80211_registered_device * rdev)339 void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev)
340 {
341 	struct wireless_dev *wdev, *tmp;
342 
343 	ASSERT_RTNL();
344 
345 	list_for_each_entry_safe(wdev, tmp, &rdev->wiphy.wdev_list, list) {
346 		if (wdev->nl_owner_dead) {
347 			if (wdev->netdev)
348 				dev_close(wdev->netdev);
349 
350 			wiphy_lock(&rdev->wiphy);
351 			cfg80211_leave(rdev, wdev);
352 			cfg80211_remove_virtual_intf(rdev, wdev);
353 			wiphy_unlock(&rdev->wiphy);
354 		}
355 	}
356 }
357 
cfg80211_destroy_iface_wk(struct work_struct * work)358 static void cfg80211_destroy_iface_wk(struct work_struct *work)
359 {
360 	struct cfg80211_registered_device *rdev;
361 
362 	rdev = container_of(work, struct cfg80211_registered_device,
363 			    destroy_work);
364 
365 	rtnl_lock();
366 	cfg80211_destroy_ifaces(rdev);
367 	rtnl_unlock();
368 }
369 
cfg80211_sched_scan_stop_wk(struct wiphy * wiphy,struct wiphy_work * work)370 static void cfg80211_sched_scan_stop_wk(struct wiphy *wiphy,
371 					struct wiphy_work *work)
372 {
373 	struct cfg80211_registered_device *rdev;
374 	struct cfg80211_sched_scan_request *req, *tmp;
375 
376 	rdev = container_of(work, struct cfg80211_registered_device,
377 			   sched_scan_stop_wk);
378 
379 	list_for_each_entry_safe(req, tmp, &rdev->sched_scan_req_list, list) {
380 		if (req->nl_owner_dead)
381 			cfg80211_stop_sched_scan_req(rdev, req, false);
382 	}
383 }
384 
cfg80211_propagate_radar_detect_wk(struct work_struct * work)385 static void cfg80211_propagate_radar_detect_wk(struct work_struct *work)
386 {
387 	struct cfg80211_registered_device *rdev;
388 
389 	rdev = container_of(work, struct cfg80211_registered_device,
390 			    propagate_radar_detect_wk);
391 
392 	rtnl_lock();
393 
394 	regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->radar_chandef,
395 				       NL80211_DFS_UNAVAILABLE,
396 				       NL80211_RADAR_DETECTED);
397 
398 	rtnl_unlock();
399 }
400 
cfg80211_propagate_cac_done_wk(struct work_struct * work)401 static void cfg80211_propagate_cac_done_wk(struct work_struct *work)
402 {
403 	struct cfg80211_registered_device *rdev;
404 
405 	rdev = container_of(work, struct cfg80211_registered_device,
406 			    propagate_cac_done_wk);
407 
408 	rtnl_lock();
409 
410 	regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->cac_done_chandef,
411 				       NL80211_DFS_AVAILABLE,
412 				       NL80211_RADAR_CAC_FINISHED);
413 
414 	rtnl_unlock();
415 }
416 
cfg80211_wiphy_work(struct work_struct * work)417 static void cfg80211_wiphy_work(struct work_struct *work)
418 {
419 	struct cfg80211_registered_device *rdev;
420 	struct wiphy_work *wk;
421 
422 	rdev = container_of(work, struct cfg80211_registered_device, wiphy_work);
423 
424 	wiphy_lock(&rdev->wiphy);
425 	if (rdev->suspended)
426 		goto out;
427 
428 	spin_lock_irq(&rdev->wiphy_work_lock);
429 	wk = list_first_entry_or_null(&rdev->wiphy_work_list,
430 				      struct wiphy_work, entry);
431 	if (wk) {
432 		list_del_init(&wk->entry);
433 		if (!list_empty(&rdev->wiphy_work_list))
434 			schedule_work(work);
435 		spin_unlock_irq(&rdev->wiphy_work_lock);
436 
437 		wk->func(&rdev->wiphy, wk);
438 	} else {
439 		spin_unlock_irq(&rdev->wiphy_work_lock);
440 	}
441 out:
442 	wiphy_unlock(&rdev->wiphy);
443 }
444 
445 /* exported functions */
446 
wiphy_new_nm(const struct cfg80211_ops * ops,int sizeof_priv,const char * requested_name)447 struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
448 			   const char *requested_name)
449 {
450 	static atomic_t wiphy_counter = ATOMIC_INIT(0);
451 
452 	struct cfg80211_registered_device *rdev;
453 	int alloc_size;
454 
455 	WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
456 	WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
457 	WARN_ON(ops->connect && !ops->disconnect);
458 	WARN_ON(ops->join_ibss && !ops->leave_ibss);
459 	WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
460 	WARN_ON(ops->add_station && !ops->del_station);
461 	WARN_ON(ops->add_mpath && !ops->del_mpath);
462 	WARN_ON(ops->join_mesh && !ops->leave_mesh);
463 	WARN_ON(ops->start_p2p_device && !ops->stop_p2p_device);
464 	WARN_ON(ops->start_ap && !ops->stop_ap);
465 	WARN_ON(ops->join_ocb && !ops->leave_ocb);
466 	WARN_ON(ops->suspend && !ops->resume);
467 	WARN_ON(ops->sched_scan_start && !ops->sched_scan_stop);
468 	WARN_ON(ops->remain_on_channel && !ops->cancel_remain_on_channel);
469 	WARN_ON(ops->tdls_channel_switch && !ops->tdls_cancel_channel_switch);
470 	WARN_ON(ops->add_tx_ts && !ops->del_tx_ts);
471 
472 	alloc_size = sizeof(*rdev) + sizeof_priv;
473 
474 	rdev = kzalloc(alloc_size, GFP_KERNEL);
475 	if (!rdev)
476 		return NULL;
477 
478 	rdev->ops = ops;
479 
480 	rdev->wiphy_idx = atomic_inc_return(&wiphy_counter);
481 
482 	if (unlikely(rdev->wiphy_idx < 0)) {
483 		/* ugh, wrapped! */
484 		atomic_dec(&wiphy_counter);
485 		kfree(rdev);
486 		return NULL;
487 	}
488 
489 	/* atomic_inc_return makes it start at 1, make it start at 0 */
490 	rdev->wiphy_idx--;
491 
492 	/* give it a proper name */
493 	if (requested_name && requested_name[0]) {
494 		int rv;
495 
496 		rtnl_lock();
497 		rv = cfg80211_dev_check_name(rdev, requested_name);
498 
499 		if (rv < 0) {
500 			rtnl_unlock();
501 			goto use_default_name;
502 		}
503 
504 		rv = dev_set_name(&rdev->wiphy.dev, "%s", requested_name);
505 		rtnl_unlock();
506 		if (rv)
507 			goto use_default_name;
508 	} else {
509 		int rv;
510 
511 use_default_name:
512 		/* NOTE:  This is *probably* safe w/out holding rtnl because of
513 		 * the restrictions on phy names.  Probably this call could
514 		 * fail if some other part of the kernel (re)named a device
515 		 * phyX.  But, might should add some locking and check return
516 		 * value, and use a different name if this one exists?
517 		 */
518 		rv = dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
519 		if (rv < 0) {
520 			kfree(rdev);
521 			return NULL;
522 		}
523 	}
524 
525 	mutex_init(&rdev->wiphy.mtx);
526 	INIT_LIST_HEAD(&rdev->wiphy.wdev_list);
527 	INIT_LIST_HEAD(&rdev->beacon_registrations);
528 	spin_lock_init(&rdev->beacon_registrations_lock);
529 	spin_lock_init(&rdev->bss_lock);
530 	INIT_LIST_HEAD(&rdev->bss_list);
531 	INIT_LIST_HEAD(&rdev->sched_scan_req_list);
532 	wiphy_work_init(&rdev->scan_done_wk, __cfg80211_scan_done);
533 	INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
534 			  cfg80211_dfs_channels_update_work);
535 #ifdef CONFIG_CFG80211_WEXT
536 	rdev->wiphy.wext = &cfg80211_wext_handler;
537 #endif
538 
539 	device_initialize(&rdev->wiphy.dev);
540 	rdev->wiphy.dev.class = &ieee80211_class;
541 	rdev->wiphy.dev.platform_data = rdev;
542 	device_enable_async_suspend(&rdev->wiphy.dev);
543 
544 	INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);
545 	wiphy_work_init(&rdev->sched_scan_stop_wk, cfg80211_sched_scan_stop_wk);
546 	INIT_WORK(&rdev->sched_scan_res_wk, cfg80211_sched_scan_results_wk);
547 	INIT_WORK(&rdev->propagate_radar_detect_wk,
548 		  cfg80211_propagate_radar_detect_wk);
549 	INIT_WORK(&rdev->propagate_cac_done_wk, cfg80211_propagate_cac_done_wk);
550 	INIT_WORK(&rdev->mgmt_registrations_update_wk,
551 		  cfg80211_mgmt_registrations_update_wk);
552 	spin_lock_init(&rdev->mgmt_registrations_lock);
553 
554 #ifdef CONFIG_CFG80211_DEFAULT_PS
555 	rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
556 #endif
557 
558 	wiphy_net_set(&rdev->wiphy, &init_net);
559 
560 	rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
561 	rdev->wiphy.rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
562 					  &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
563 					  &rdev->rfkill_ops, rdev);
564 
565 	if (!rdev->wiphy.rfkill) {
566 		wiphy_free(&rdev->wiphy);
567 		return NULL;
568 	}
569 
570 	INIT_WORK(&rdev->wiphy_work, cfg80211_wiphy_work);
571 	INIT_LIST_HEAD(&rdev->wiphy_work_list);
572 	spin_lock_init(&rdev->wiphy_work_lock);
573 	INIT_WORK(&rdev->rfkill_block, cfg80211_rfkill_block_work);
574 	INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
575 	INIT_WORK(&rdev->event_work, cfg80211_event_work);
576 	INIT_WORK(&rdev->background_cac_abort_wk,
577 		  cfg80211_background_cac_abort_wk);
578 	INIT_DELAYED_WORK(&rdev->background_cac_done_wk,
579 			  cfg80211_background_cac_done_wk);
580 
581 	init_waitqueue_head(&rdev->dev_wait);
582 
583 	/*
584 	 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
585 	 * Fragmentation and RTS threshold are disabled by default with the
586 	 * special -1 value.
587 	 */
588 	rdev->wiphy.retry_short = 7;
589 	rdev->wiphy.retry_long = 4;
590 	rdev->wiphy.frag_threshold = (u32) -1;
591 	rdev->wiphy.rts_threshold = (u32) -1;
592 	rdev->wiphy.coverage_class = 0;
593 
594 	rdev->wiphy.max_num_csa_counters = 1;
595 
596 	rdev->wiphy.max_sched_scan_plans = 1;
597 	rdev->wiphy.max_sched_scan_plan_interval = U32_MAX;
598 
599 	return &rdev->wiphy;
600 }
601 EXPORT_SYMBOL(wiphy_new_nm);
602 
wiphy_verify_combinations(struct wiphy * wiphy)603 static int wiphy_verify_combinations(struct wiphy *wiphy)
604 {
605 	const struct ieee80211_iface_combination *c;
606 	int i, j;
607 
608 	for (i = 0; i < wiphy->n_iface_combinations; i++) {
609 		u32 cnt = 0;
610 		u16 all_iftypes = 0;
611 
612 		c = &wiphy->iface_combinations[i];
613 
614 		/*
615 		 * Combinations with just one interface aren't real,
616 		 * however we make an exception for DFS.
617 		 */
618 		if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
619 			return -EINVAL;
620 
621 		/* Need at least one channel */
622 		if (WARN_ON(!c->num_different_channels))
623 			return -EINVAL;
624 
625 		/* DFS only works on one channel. */
626 		if (WARN_ON(c->radar_detect_widths &&
627 			    (c->num_different_channels > 1)))
628 			return -EINVAL;
629 
630 		if (WARN_ON(!c->n_limits))
631 			return -EINVAL;
632 
633 		for (j = 0; j < c->n_limits; j++) {
634 			u16 types = c->limits[j].types;
635 
636 			/* interface types shouldn't overlap */
637 			if (WARN_ON(types & all_iftypes))
638 				return -EINVAL;
639 			all_iftypes |= types;
640 
641 			if (WARN_ON(!c->limits[j].max))
642 				return -EINVAL;
643 
644 			/* Shouldn't list software iftypes in combinations! */
645 			if (WARN_ON(wiphy->software_iftypes & types))
646 				return -EINVAL;
647 
648 			/* Only a single P2P_DEVICE can be allowed */
649 			if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
650 				    c->limits[j].max > 1))
651 				return -EINVAL;
652 
653 			/* Only a single NAN can be allowed */
654 			if (WARN_ON(types & BIT(NL80211_IFTYPE_NAN) &&
655 				    c->limits[j].max > 1))
656 				return -EINVAL;
657 
658 			/*
659 			 * This isn't well-defined right now. If you have an
660 			 * IBSS interface, then its beacon interval may change
661 			 * by joining other networks, and nothing prevents it
662 			 * from doing that.
663 			 * So technically we probably shouldn't even allow AP
664 			 * and IBSS in the same interface, but it seems that
665 			 * some drivers support that, possibly only with fixed
666 			 * beacon intervals for IBSS.
667 			 */
668 			if (WARN_ON(types & BIT(NL80211_IFTYPE_ADHOC) &&
669 				    c->beacon_int_min_gcd)) {
670 				return -EINVAL;
671 			}
672 
673 			cnt += c->limits[j].max;
674 			/*
675 			 * Don't advertise an unsupported type
676 			 * in a combination.
677 			 */
678 			if (WARN_ON((wiphy->interface_modes & types) != types))
679 				return -EINVAL;
680 		}
681 
682 		if (WARN_ON(all_iftypes & BIT(NL80211_IFTYPE_WDS)))
683 			return -EINVAL;
684 
685 		/* You can't even choose that many! */
686 		if (WARN_ON(cnt < c->max_interfaces))
687 			return -EINVAL;
688 	}
689 
690 	return 0;
691 }
692 
wiphy_register(struct wiphy * wiphy)693 int wiphy_register(struct wiphy *wiphy)
694 {
695 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
696 	int res;
697 	enum nl80211_band band;
698 	struct ieee80211_supported_band *sband;
699 	bool have_band = false;
700 	int i;
701 	u16 ifmodes = wiphy->interface_modes;
702 
703 #ifdef CONFIG_PM
704 	if (WARN_ON(wiphy->wowlan &&
705 		    (wiphy->wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
706 		    !(wiphy->wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
707 		return -EINVAL;
708 	if (WARN_ON(wiphy->wowlan &&
709 		    !wiphy->wowlan->flags && !wiphy->wowlan->n_patterns &&
710 		    !wiphy->wowlan->tcp))
711 		return -EINVAL;
712 #endif
713 	if (WARN_ON((wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
714 		    (!rdev->ops->tdls_channel_switch ||
715 		     !rdev->ops->tdls_cancel_channel_switch)))
716 		return -EINVAL;
717 
718 	if (WARN_ON((wiphy->interface_modes & BIT(NL80211_IFTYPE_NAN)) &&
719 		    (!rdev->ops->start_nan || !rdev->ops->stop_nan ||
720 		     !rdev->ops->add_nan_func || !rdev->ops->del_nan_func ||
721 		     !(wiphy->nan_supported_bands & BIT(NL80211_BAND_2GHZ)))))
722 		return -EINVAL;
723 
724 	if (WARN_ON(wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS)))
725 		return -EINVAL;
726 
727 	if (WARN_ON(wiphy->pmsr_capa && !wiphy->pmsr_capa->ftm.supported))
728 		return -EINVAL;
729 
730 	if (wiphy->pmsr_capa && wiphy->pmsr_capa->ftm.supported) {
731 		if (WARN_ON(!wiphy->pmsr_capa->ftm.asap &&
732 			    !wiphy->pmsr_capa->ftm.non_asap))
733 			return -EINVAL;
734 		if (WARN_ON(!wiphy->pmsr_capa->ftm.preambles ||
735 			    !wiphy->pmsr_capa->ftm.bandwidths))
736 			return -EINVAL;
737 		if (WARN_ON(wiphy->pmsr_capa->ftm.preambles &
738 				~(BIT(NL80211_PREAMBLE_LEGACY) |
739 				  BIT(NL80211_PREAMBLE_HT) |
740 				  BIT(NL80211_PREAMBLE_VHT) |
741 				  BIT(NL80211_PREAMBLE_HE) |
742 				  BIT(NL80211_PREAMBLE_DMG))))
743 			return -EINVAL;
744 		if (WARN_ON((wiphy->pmsr_capa->ftm.trigger_based ||
745 			     wiphy->pmsr_capa->ftm.non_trigger_based) &&
746 			    !(wiphy->pmsr_capa->ftm.preambles &
747 			      BIT(NL80211_PREAMBLE_HE))))
748 			return -EINVAL;
749 		if (WARN_ON(wiphy->pmsr_capa->ftm.bandwidths &
750 				~(BIT(NL80211_CHAN_WIDTH_20_NOHT) |
751 				  BIT(NL80211_CHAN_WIDTH_20) |
752 				  BIT(NL80211_CHAN_WIDTH_40) |
753 				  BIT(NL80211_CHAN_WIDTH_80) |
754 				  BIT(NL80211_CHAN_WIDTH_80P80) |
755 				  BIT(NL80211_CHAN_WIDTH_160) |
756 				  BIT(NL80211_CHAN_WIDTH_5) |
757 				  BIT(NL80211_CHAN_WIDTH_10))))
758 			return -EINVAL;
759 	}
760 
761 	if (WARN_ON((wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) &&
762 		    (wiphy->regulatory_flags &
763 					(REGULATORY_CUSTOM_REG |
764 					 REGULATORY_STRICT_REG |
765 					 REGULATORY_COUNTRY_IE_FOLLOW_POWER |
766 					 REGULATORY_COUNTRY_IE_IGNORE))))
767 		return -EINVAL;
768 
769 	if (WARN_ON(wiphy->coalesce &&
770 		    (!wiphy->coalesce->n_rules ||
771 		     !wiphy->coalesce->n_patterns) &&
772 		    (!wiphy->coalesce->pattern_min_len ||
773 		     wiphy->coalesce->pattern_min_len >
774 			wiphy->coalesce->pattern_max_len)))
775 		return -EINVAL;
776 
777 	if (WARN_ON(wiphy->ap_sme_capa &&
778 		    !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
779 		return -EINVAL;
780 
781 	if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
782 		return -EINVAL;
783 
784 	if (WARN_ON(wiphy->addresses &&
785 		    !is_zero_ether_addr(wiphy->perm_addr) &&
786 		    memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
787 			   ETH_ALEN)))
788 		return -EINVAL;
789 
790 	if (WARN_ON(wiphy->max_acl_mac_addrs &&
791 		    (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
792 		     !rdev->ops->set_mac_acl)))
793 		return -EINVAL;
794 
795 	/* assure only valid behaviours are flagged by driver
796 	 * hence subtract 2 as bit 0 is invalid.
797 	 */
798 	if (WARN_ON(wiphy->bss_select_support &&
799 		    (wiphy->bss_select_support & ~(BIT(__NL80211_BSS_SELECT_ATTR_AFTER_LAST) - 2))))
800 		return -EINVAL;
801 
802 	if (WARN_ON(wiphy_ext_feature_isset(&rdev->wiphy,
803 					    NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X) &&
804 		    (!rdev->ops->set_pmk || !rdev->ops->del_pmk)))
805 		return -EINVAL;
806 
807 	if (WARN_ON(!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
808 		    rdev->ops->update_connect_params))
809 		return -EINVAL;
810 
811 	if (wiphy->addresses)
812 		memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
813 
814 	/* sanity check ifmodes */
815 	WARN_ON(!ifmodes);
816 	ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
817 	if (WARN_ON(ifmodes != wiphy->interface_modes))
818 		wiphy->interface_modes = ifmodes;
819 
820 	res = wiphy_verify_combinations(wiphy);
821 	if (res)
822 		return res;
823 
824 	/* sanity check supported bands/channels */
825 	for (band = 0; band < NUM_NL80211_BANDS; band++) {
826 		u16 types = 0;
827 		bool have_he = false;
828 
829 		sband = wiphy->bands[band];
830 		if (!sband)
831 			continue;
832 
833 		sband->band = band;
834 		if (WARN_ON(!sband->n_channels))
835 			return -EINVAL;
836 		/*
837 		 * on 60GHz or sub-1Ghz band, there are no legacy rates, so
838 		 * n_bitrates is 0
839 		 */
840 		if (WARN_ON((band != NL80211_BAND_60GHZ &&
841 			     band != NL80211_BAND_S1GHZ) &&
842 			    !sband->n_bitrates))
843 			return -EINVAL;
844 
845 		if (WARN_ON(band == NL80211_BAND_6GHZ &&
846 			    (sband->ht_cap.ht_supported ||
847 			     sband->vht_cap.vht_supported)))
848 			return -EINVAL;
849 
850 		/*
851 		 * Since cfg80211_disable_40mhz_24ghz is global, we can
852 		 * modify the sband's ht data even if the driver uses a
853 		 * global structure for that.
854 		 */
855 		if (cfg80211_disable_40mhz_24ghz &&
856 		    band == NL80211_BAND_2GHZ &&
857 		    sband->ht_cap.ht_supported) {
858 			sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
859 			sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
860 		}
861 
862 		/*
863 		 * Since we use a u32 for rate bitmaps in
864 		 * ieee80211_get_response_rate, we cannot
865 		 * have more than 32 legacy rates.
866 		 */
867 		if (WARN_ON(sband->n_bitrates > 32))
868 			return -EINVAL;
869 
870 		for (i = 0; i < sband->n_channels; i++) {
871 			sband->channels[i].orig_flags =
872 				sband->channels[i].flags;
873 			sband->channels[i].orig_mag = INT_MAX;
874 			sband->channels[i].orig_mpwr =
875 				sband->channels[i].max_power;
876 			sband->channels[i].band = band;
877 
878 			if (WARN_ON(sband->channels[i].freq_offset >= 1000))
879 				return -EINVAL;
880 		}
881 
882 		for (i = 0; i < sband->n_iftype_data; i++) {
883 			const struct ieee80211_sband_iftype_data *iftd;
884 			bool has_ap, has_non_ap;
885 			u32 ap_bits = BIT(NL80211_IFTYPE_AP) |
886 				      BIT(NL80211_IFTYPE_P2P_GO);
887 
888 			iftd = &sband->iftype_data[i];
889 
890 			if (WARN_ON(!iftd->types_mask))
891 				return -EINVAL;
892 			if (WARN_ON(types & iftd->types_mask))
893 				return -EINVAL;
894 
895 			/* at least one piece of information must be present */
896 			if (WARN_ON(!iftd->he_cap.has_he))
897 				return -EINVAL;
898 
899 			types |= iftd->types_mask;
900 
901 			if (i == 0)
902 				have_he = iftd->he_cap.has_he;
903 			else
904 				have_he = have_he &&
905 					  iftd->he_cap.has_he;
906 
907 			has_ap = iftd->types_mask & ap_bits;
908 			has_non_ap = iftd->types_mask & ~ap_bits;
909 
910 			/*
911 			 * For EHT 20 MHz STA, the capabilities format differs
912 			 * but to simplify, don't check 20 MHz but rather check
913 			 * only if AP and non-AP were mentioned at the same time,
914 			 * reject if so.
915 			 */
916 			if (WARN_ON(iftd->eht_cap.has_eht &&
917 				    has_ap && has_non_ap))
918 				return -EINVAL;
919 		}
920 
921 		if (WARN_ON(!have_he && band == NL80211_BAND_6GHZ))
922 			return -EINVAL;
923 
924 		have_band = true;
925 	}
926 
927 	if (!have_band) {
928 		WARN_ON(1);
929 		return -EINVAL;
930 	}
931 
932 	for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
933 		/*
934 		 * Validate we have a policy (can be explicitly set to
935 		 * VENDOR_CMD_RAW_DATA which is non-NULL) and also that
936 		 * we have at least one of doit/dumpit.
937 		 */
938 		if (WARN_ON(!rdev->wiphy.vendor_commands[i].policy))
939 			return -EINVAL;
940 		if (WARN_ON(!rdev->wiphy.vendor_commands[i].doit &&
941 			    !rdev->wiphy.vendor_commands[i].dumpit))
942 			return -EINVAL;
943 	}
944 
945 #ifdef CONFIG_PM
946 	if (WARN_ON(rdev->wiphy.wowlan && rdev->wiphy.wowlan->n_patterns &&
947 		    (!rdev->wiphy.wowlan->pattern_min_len ||
948 		     rdev->wiphy.wowlan->pattern_min_len >
949 				rdev->wiphy.wowlan->pattern_max_len)))
950 		return -EINVAL;
951 #endif
952 
953 	if (!wiphy->max_num_akm_suites)
954 		wiphy->max_num_akm_suites = NL80211_MAX_NR_AKM_SUITES;
955 	else if (wiphy->max_num_akm_suites < NL80211_MAX_NR_AKM_SUITES ||
956 		 wiphy->max_num_akm_suites > CFG80211_MAX_NUM_AKM_SUITES)
957 		return -EINVAL;
958 
959 	/* check and set up bitrates */
960 	ieee80211_set_bitrate_flags(wiphy);
961 
962 	rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
963 
964 	rtnl_lock();
965 	wiphy_lock(&rdev->wiphy);
966 	res = device_add(&rdev->wiphy.dev);
967 	if (res) {
968 		wiphy_unlock(&rdev->wiphy);
969 		rtnl_unlock();
970 		return res;
971 	}
972 
973 	list_add_rcu(&rdev->list, &cfg80211_rdev_list);
974 	cfg80211_rdev_list_generation++;
975 
976 	/* add to debugfs */
977 	rdev->wiphy.debugfsdir = debugfs_create_dir(wiphy_name(&rdev->wiphy),
978 						    ieee80211_debugfs_dir);
979 
980 	cfg80211_debugfs_rdev_add(rdev);
981 	nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
982 	wiphy_unlock(&rdev->wiphy);
983 
984 	/* set up regulatory info */
985 	wiphy_regulatory_register(wiphy);
986 
987 	if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
988 		struct regulatory_request request;
989 
990 		request.wiphy_idx = get_wiphy_idx(wiphy);
991 		request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
992 		request.alpha2[0] = '9';
993 		request.alpha2[1] = '9';
994 
995 		nl80211_send_reg_change_event(&request);
996 	}
997 
998 	/* Check that nobody globally advertises any capabilities they do not
999 	 * advertise on all possible interface types.
1000 	 */
1001 	if (wiphy->extended_capabilities_len &&
1002 	    wiphy->num_iftype_ext_capab &&
1003 	    wiphy->iftype_ext_capab) {
1004 		u8 supported_on_all, j;
1005 		const struct wiphy_iftype_ext_capab *capab;
1006 
1007 		capab = wiphy->iftype_ext_capab;
1008 		for (j = 0; j < wiphy->extended_capabilities_len; j++) {
1009 			if (capab[0].extended_capabilities_len > j)
1010 				supported_on_all =
1011 					capab[0].extended_capabilities[j];
1012 			else
1013 				supported_on_all = 0x00;
1014 			for (i = 1; i < wiphy->num_iftype_ext_capab; i++) {
1015 				if (j >= capab[i].extended_capabilities_len) {
1016 					supported_on_all = 0x00;
1017 					break;
1018 				}
1019 				supported_on_all &=
1020 					capab[i].extended_capabilities[j];
1021 			}
1022 			if (WARN_ON(wiphy->extended_capabilities[j] &
1023 				    ~supported_on_all))
1024 				break;
1025 		}
1026 	}
1027 
1028 	rdev->wiphy.registered = true;
1029 	rtnl_unlock();
1030 
1031 	res = rfkill_register(rdev->wiphy.rfkill);
1032 	if (res) {
1033 		rfkill_destroy(rdev->wiphy.rfkill);
1034 		rdev->wiphy.rfkill = NULL;
1035 		wiphy_unregister(&rdev->wiphy);
1036 		return res;
1037 	}
1038 
1039 	return 0;
1040 }
1041 EXPORT_SYMBOL(wiphy_register);
1042 
wiphy_rfkill_start_polling(struct wiphy * wiphy)1043 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
1044 {
1045 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1046 
1047 	if (!rdev->ops->rfkill_poll)
1048 		return;
1049 	rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
1050 	rfkill_resume_polling(wiphy->rfkill);
1051 }
1052 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
1053 
cfg80211_process_wiphy_works(struct cfg80211_registered_device * rdev,struct wiphy_work * end)1054 void cfg80211_process_wiphy_works(struct cfg80211_registered_device *rdev,
1055 				  struct wiphy_work *end)
1056 {
1057 	unsigned int runaway_limit = 100;
1058 	unsigned long flags;
1059 
1060 	lockdep_assert_held(&rdev->wiphy.mtx);
1061 
1062 	spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
1063 	while (!list_empty(&rdev->wiphy_work_list)) {
1064 		struct wiphy_work *wk;
1065 
1066 		wk = list_first_entry(&rdev->wiphy_work_list,
1067 				      struct wiphy_work, entry);
1068 		list_del_init(&wk->entry);
1069 		spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
1070 
1071 		wk->func(&rdev->wiphy, wk);
1072 
1073 		spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
1074 
1075 		if (wk == end)
1076 			break;
1077 
1078 		if (WARN_ON(--runaway_limit == 0))
1079 			INIT_LIST_HEAD(&rdev->wiphy_work_list);
1080 	}
1081 	spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
1082 }
1083 
wiphy_unregister(struct wiphy * wiphy)1084 void wiphy_unregister(struct wiphy *wiphy)
1085 {
1086 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1087 
1088 	wait_event(rdev->dev_wait, ({
1089 		int __count;
1090 		wiphy_lock(&rdev->wiphy);
1091 		__count = rdev->opencount;
1092 		wiphy_unlock(&rdev->wiphy);
1093 		__count == 0; }));
1094 
1095 	if (rdev->wiphy.rfkill)
1096 		rfkill_unregister(rdev->wiphy.rfkill);
1097 
1098 	rtnl_lock();
1099 	wiphy_lock(&rdev->wiphy);
1100 	nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
1101 	rdev->wiphy.registered = false;
1102 
1103 	WARN_ON(!list_empty(&rdev->wiphy.wdev_list));
1104 
1105 	/*
1106 	 * First remove the hardware from everywhere, this makes
1107 	 * it impossible to find from userspace.
1108 	 */
1109 	debugfs_remove_recursive(rdev->wiphy.debugfsdir);
1110 	list_del_rcu(&rdev->list);
1111 	synchronize_rcu();
1112 
1113 	/*
1114 	 * If this device got a regulatory hint tell core its
1115 	 * free to listen now to a new shiny device regulatory hint
1116 	 */
1117 	wiphy_regulatory_deregister(wiphy);
1118 
1119 	cfg80211_rdev_list_generation++;
1120 	device_del(&rdev->wiphy.dev);
1121 
1122 #ifdef CONFIG_PM
1123 	if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
1124 		rdev_set_wakeup(rdev, false);
1125 #endif
1126 
1127 	/* surely nothing is reachable now, clean up work */
1128 	cfg80211_process_wiphy_works(rdev, NULL);
1129 	wiphy_unlock(&rdev->wiphy);
1130 	rtnl_unlock();
1131 
1132 	/* this has nothing to do now but make sure it's gone */
1133 	cancel_work_sync(&rdev->wiphy_work);
1134 
1135 	cancel_work_sync(&rdev->conn_work);
1136 	flush_work(&rdev->event_work);
1137 	cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
1138 	cancel_delayed_work_sync(&rdev->background_cac_done_wk);
1139 	flush_work(&rdev->destroy_work);
1140 	flush_work(&rdev->propagate_radar_detect_wk);
1141 	flush_work(&rdev->propagate_cac_done_wk);
1142 	flush_work(&rdev->mgmt_registrations_update_wk);
1143 	flush_work(&rdev->background_cac_abort_wk);
1144 
1145 	cfg80211_rdev_free_wowlan(rdev);
1146 	cfg80211_rdev_free_coalesce(rdev);
1147 }
1148 EXPORT_SYMBOL(wiphy_unregister);
1149 
cfg80211_dev_free(struct cfg80211_registered_device * rdev)1150 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
1151 {
1152 	struct cfg80211_internal_bss *scan, *tmp;
1153 	struct cfg80211_beacon_registration *reg, *treg;
1154 	rfkill_destroy(rdev->wiphy.rfkill);
1155 	list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
1156 		list_del(&reg->list);
1157 		kfree(reg);
1158 	}
1159 	list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
1160 		cfg80211_put_bss(&rdev->wiphy, &scan->pub);
1161 	mutex_destroy(&rdev->wiphy.mtx);
1162 
1163 	/*
1164 	 * The 'regd' can only be non-NULL if we never finished
1165 	 * initializing the wiphy and thus never went through the
1166 	 * unregister path - e.g. in failure scenarios. Thus, it
1167 	 * cannot have been visible to anyone if non-NULL, so we
1168 	 * can just free it here.
1169 	 */
1170 	kfree(rcu_dereference_raw(rdev->wiphy.regd));
1171 
1172 	kfree(rdev);
1173 }
1174 
wiphy_free(struct wiphy * wiphy)1175 void wiphy_free(struct wiphy *wiphy)
1176 {
1177 	put_device(&wiphy->dev);
1178 }
1179 EXPORT_SYMBOL(wiphy_free);
1180 
wiphy_rfkill_set_hw_state_reason(struct wiphy * wiphy,bool blocked,enum rfkill_hard_block_reasons reason)1181 void wiphy_rfkill_set_hw_state_reason(struct wiphy *wiphy, bool blocked,
1182 				      enum rfkill_hard_block_reasons reason)
1183 {
1184 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1185 
1186 	if (rfkill_set_hw_state_reason(wiphy->rfkill, blocked, reason))
1187 		schedule_work(&rdev->rfkill_block);
1188 }
1189 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state_reason);
1190 
_cfg80211_unregister_wdev(struct wireless_dev * wdev,bool unregister_netdev)1191 static void _cfg80211_unregister_wdev(struct wireless_dev *wdev,
1192 				      bool unregister_netdev)
1193 {
1194 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
1195 	struct cfg80211_cqm_config *cqm_config;
1196 	unsigned int link_id;
1197 
1198 	ASSERT_RTNL();
1199 	lockdep_assert_held(&rdev->wiphy.mtx);
1200 
1201 	nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
1202 
1203 	wdev->registered = false;
1204 
1205 	if (wdev->netdev) {
1206 		sysfs_remove_link(&wdev->netdev->dev.kobj, "phy80211");
1207 		if (unregister_netdev)
1208 			unregister_netdevice(wdev->netdev);
1209 	}
1210 
1211 	list_del_rcu(&wdev->list);
1212 	synchronize_net();
1213 	rdev->devlist_generation++;
1214 
1215 	cfg80211_mlme_purge_registrations(wdev);
1216 
1217 	switch (wdev->iftype) {
1218 	case NL80211_IFTYPE_P2P_DEVICE:
1219 		cfg80211_stop_p2p_device(rdev, wdev);
1220 		break;
1221 	case NL80211_IFTYPE_NAN:
1222 		cfg80211_stop_nan(rdev, wdev);
1223 		break;
1224 	default:
1225 		break;
1226 	}
1227 
1228 #ifdef CONFIG_CFG80211_WEXT
1229 	kfree_sensitive(wdev->wext.keys);
1230 	wdev->wext.keys = NULL;
1231 #endif
1232 	wiphy_work_cancel(wdev->wiphy, &wdev->cqm_rssi_work);
1233 	/* deleted from the list, so can't be found from nl80211 any more */
1234 	cqm_config = rcu_access_pointer(wdev->cqm_config);
1235 	kfree_rcu(cqm_config, rcu_head);
1236 
1237 	/*
1238 	 * Ensure that all events have been processed and
1239 	 * freed.
1240 	 */
1241 	cfg80211_process_wdev_events(wdev);
1242 
1243 	if (wdev->iftype == NL80211_IFTYPE_STATION ||
1244 	    wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) {
1245 		for (link_id = 0; link_id < ARRAY_SIZE(wdev->links); link_id++) {
1246 			struct cfg80211_internal_bss *curbss;
1247 
1248 			curbss = wdev->links[link_id].client.current_bss;
1249 
1250 			if (WARN_ON(curbss)) {
1251 				cfg80211_unhold_bss(curbss);
1252 				cfg80211_put_bss(wdev->wiphy, &curbss->pub);
1253 				wdev->links[link_id].client.current_bss = NULL;
1254 			}
1255 		}
1256 	}
1257 
1258 	wdev->connected = false;
1259 }
1260 
cfg80211_unregister_wdev(struct wireless_dev * wdev)1261 void cfg80211_unregister_wdev(struct wireless_dev *wdev)
1262 {
1263 	_cfg80211_unregister_wdev(wdev, true);
1264 }
1265 EXPORT_SYMBOL(cfg80211_unregister_wdev);
1266 
1267 static const struct device_type wiphy_type = {
1268 	.name	= "wlan",
1269 };
1270 
cfg80211_update_iface_num(struct cfg80211_registered_device * rdev,enum nl80211_iftype iftype,int num)1271 void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
1272 			       enum nl80211_iftype iftype, int num)
1273 {
1274 	lockdep_assert_held(&rdev->wiphy.mtx);
1275 
1276 	rdev->num_running_ifaces += num;
1277 	if (iftype == NL80211_IFTYPE_MONITOR)
1278 		rdev->num_running_monitor_ifaces += num;
1279 }
1280 
__cfg80211_leave(struct cfg80211_registered_device * rdev,struct wireless_dev * wdev)1281 void __cfg80211_leave(struct cfg80211_registered_device *rdev,
1282 		      struct wireless_dev *wdev)
1283 {
1284 	struct net_device *dev = wdev->netdev;
1285 	struct cfg80211_sched_scan_request *pos, *tmp;
1286 
1287 	lockdep_assert_held(&rdev->wiphy.mtx);
1288 	ASSERT_WDEV_LOCK(wdev);
1289 
1290 	cfg80211_pmsr_wdev_down(wdev);
1291 
1292 	cfg80211_stop_background_radar_detection(wdev);
1293 
1294 	switch (wdev->iftype) {
1295 	case NL80211_IFTYPE_ADHOC:
1296 		__cfg80211_leave_ibss(rdev, dev, true);
1297 		break;
1298 	case NL80211_IFTYPE_P2P_CLIENT:
1299 	case NL80211_IFTYPE_STATION:
1300 		list_for_each_entry_safe(pos, tmp, &rdev->sched_scan_req_list,
1301 					 list) {
1302 			if (dev == pos->dev)
1303 				cfg80211_stop_sched_scan_req(rdev, pos, false);
1304 		}
1305 
1306 #ifdef CONFIG_CFG80211_WEXT
1307 		kfree(wdev->wext.ie);
1308 		wdev->wext.ie = NULL;
1309 		wdev->wext.ie_len = 0;
1310 		wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1311 #endif
1312 		cfg80211_disconnect(rdev, dev,
1313 				    WLAN_REASON_DEAUTH_LEAVING, true);
1314 		break;
1315 	case NL80211_IFTYPE_MESH_POINT:
1316 		__cfg80211_leave_mesh(rdev, dev);
1317 		break;
1318 	case NL80211_IFTYPE_AP:
1319 	case NL80211_IFTYPE_P2P_GO:
1320 		__cfg80211_stop_ap(rdev, dev, -1, true);
1321 		break;
1322 	case NL80211_IFTYPE_OCB:
1323 		__cfg80211_leave_ocb(rdev, dev);
1324 		break;
1325 	case NL80211_IFTYPE_P2P_DEVICE:
1326 	case NL80211_IFTYPE_NAN:
1327 		/* cannot happen, has no netdev */
1328 		break;
1329 	case NL80211_IFTYPE_AP_VLAN:
1330 	case NL80211_IFTYPE_MONITOR:
1331 		/* nothing to do */
1332 		break;
1333 	case NL80211_IFTYPE_UNSPECIFIED:
1334 	case NL80211_IFTYPE_WDS:
1335 	case NUM_NL80211_IFTYPES:
1336 		/* invalid */
1337 		break;
1338 	}
1339 }
1340 
cfg80211_leave(struct cfg80211_registered_device * rdev,struct wireless_dev * wdev)1341 void cfg80211_leave(struct cfg80211_registered_device *rdev,
1342 		    struct wireless_dev *wdev)
1343 {
1344 	wdev_lock(wdev);
1345 	__cfg80211_leave(rdev, wdev);
1346 	wdev_unlock(wdev);
1347 }
1348 
cfg80211_stop_iface(struct wiphy * wiphy,struct wireless_dev * wdev,gfp_t gfp)1349 void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
1350 			 gfp_t gfp)
1351 {
1352 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1353 	struct cfg80211_event *ev;
1354 	unsigned long flags;
1355 
1356 	trace_cfg80211_stop_iface(wiphy, wdev);
1357 
1358 	ev = kzalloc(sizeof(*ev), gfp);
1359 	if (!ev)
1360 		return;
1361 
1362 	ev->type = EVENT_STOPPED;
1363 
1364 	spin_lock_irqsave(&wdev->event_lock, flags);
1365 	list_add_tail(&ev->list, &wdev->event_list);
1366 	spin_unlock_irqrestore(&wdev->event_lock, flags);
1367 	queue_work(cfg80211_wq, &rdev->event_work);
1368 }
1369 EXPORT_SYMBOL(cfg80211_stop_iface);
1370 
cfg80211_init_wdev(struct wireless_dev * wdev)1371 void cfg80211_init_wdev(struct wireless_dev *wdev)
1372 {
1373 	mutex_init(&wdev->mtx);
1374 	INIT_LIST_HEAD(&wdev->event_list);
1375 	spin_lock_init(&wdev->event_lock);
1376 	INIT_LIST_HEAD(&wdev->mgmt_registrations);
1377 	INIT_LIST_HEAD(&wdev->pmsr_list);
1378 	spin_lock_init(&wdev->pmsr_lock);
1379 	INIT_WORK(&wdev->pmsr_free_wk, cfg80211_pmsr_free_wk);
1380 
1381 #ifdef CONFIG_CFG80211_WEXT
1382 	wdev->wext.default_key = -1;
1383 	wdev->wext.default_mgmt_key = -1;
1384 	wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1385 #endif
1386 
1387 	wiphy_work_init(&wdev->cqm_rssi_work, cfg80211_cqm_rssi_notify_work);
1388 
1389 	if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
1390 		wdev->ps = true;
1391 	else
1392 		wdev->ps = false;
1393 	/* allow mac80211 to determine the timeout */
1394 	wdev->ps_timeout = -1;
1395 
1396 	if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1397 	     wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
1398 	     wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
1399 		wdev->netdev->priv_flags |= IFF_DONT_BRIDGE;
1400 
1401 	INIT_WORK(&wdev->disconnect_wk, cfg80211_autodisconnect_wk);
1402 }
1403 
cfg80211_register_wdev(struct cfg80211_registered_device * rdev,struct wireless_dev * wdev)1404 void cfg80211_register_wdev(struct cfg80211_registered_device *rdev,
1405 			    struct wireless_dev *wdev)
1406 {
1407 	ASSERT_RTNL();
1408 	lockdep_assert_held(&rdev->wiphy.mtx);
1409 
1410 	/*
1411 	 * We get here also when the interface changes network namespaces,
1412 	 * as it's registered into the new one, but we don't want it to
1413 	 * change ID in that case. Checking if the ID is already assigned
1414 	 * works, because 0 isn't considered a valid ID and the memory is
1415 	 * 0-initialized.
1416 	 */
1417 	if (!wdev->identifier)
1418 		wdev->identifier = ++rdev->wdev_id;
1419 	list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
1420 	rdev->devlist_generation++;
1421 	wdev->registered = true;
1422 
1423 	if (wdev->netdev &&
1424 	    sysfs_create_link(&wdev->netdev->dev.kobj, &rdev->wiphy.dev.kobj,
1425 			      "phy80211"))
1426 		pr_err("failed to add phy80211 symlink to netdev!\n");
1427 
1428 	nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
1429 }
1430 
cfg80211_register_netdevice(struct net_device * dev)1431 int cfg80211_register_netdevice(struct net_device *dev)
1432 {
1433 	struct wireless_dev *wdev = dev->ieee80211_ptr;
1434 	struct cfg80211_registered_device *rdev;
1435 	int ret;
1436 
1437 	ASSERT_RTNL();
1438 
1439 	if (WARN_ON(!wdev))
1440 		return -EINVAL;
1441 
1442 	rdev = wiphy_to_rdev(wdev->wiphy);
1443 
1444 	lockdep_assert_held(&rdev->wiphy.mtx);
1445 
1446 	/* we'll take care of this */
1447 	wdev->registered = true;
1448 	wdev->registering = true;
1449 	ret = register_netdevice(dev);
1450 	if (ret)
1451 		goto out;
1452 
1453 	cfg80211_register_wdev(rdev, wdev);
1454 	ret = 0;
1455 out:
1456 	wdev->registering = false;
1457 	if (ret)
1458 		wdev->registered = false;
1459 	return ret;
1460 }
1461 EXPORT_SYMBOL(cfg80211_register_netdevice);
1462 
cfg80211_netdev_notifier_call(struct notifier_block * nb,unsigned long state,void * ptr)1463 static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
1464 					 unsigned long state, void *ptr)
1465 {
1466 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1467 	struct wireless_dev *wdev = dev->ieee80211_ptr;
1468 	struct cfg80211_registered_device *rdev;
1469 	struct cfg80211_sched_scan_request *pos, *tmp;
1470 
1471 	if (!wdev)
1472 		return NOTIFY_DONE;
1473 
1474 	rdev = wiphy_to_rdev(wdev->wiphy);
1475 
1476 	WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
1477 
1478 	switch (state) {
1479 	case NETDEV_POST_INIT:
1480 		SET_NETDEV_DEVTYPE(dev, &wiphy_type);
1481 		wdev->netdev = dev;
1482 		/* can only change netns with wiphy */
1483 		dev->features |= NETIF_F_NETNS_LOCAL;
1484 
1485 		cfg80211_init_wdev(wdev);
1486 		break;
1487 	case NETDEV_REGISTER:
1488 		if (!wdev->registered) {
1489 			wiphy_lock(&rdev->wiphy);
1490 			cfg80211_register_wdev(rdev, wdev);
1491 			wiphy_unlock(&rdev->wiphy);
1492 		}
1493 		break;
1494 	case NETDEV_UNREGISTER:
1495 		/*
1496 		 * It is possible to get NETDEV_UNREGISTER multiple times,
1497 		 * so check wdev->registered.
1498 		 */
1499 		if (wdev->registered && !wdev->registering) {
1500 			wiphy_lock(&rdev->wiphy);
1501 			_cfg80211_unregister_wdev(wdev, false);
1502 			wiphy_unlock(&rdev->wiphy);
1503 		}
1504 		break;
1505 	case NETDEV_GOING_DOWN:
1506 		wiphy_lock(&rdev->wiphy);
1507 		cfg80211_leave(rdev, wdev);
1508 		cfg80211_remove_links(wdev);
1509 		wiphy_unlock(&rdev->wiphy);
1510 		/* since we just did cfg80211_leave() nothing to do there */
1511 		cancel_work_sync(&wdev->disconnect_wk);
1512 		cancel_work_sync(&wdev->pmsr_free_wk);
1513 		break;
1514 	case NETDEV_DOWN:
1515 		wiphy_lock(&rdev->wiphy);
1516 		cfg80211_update_iface_num(rdev, wdev->iftype, -1);
1517 		if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1518 			if (WARN_ON(!rdev->scan_req->notified &&
1519 				    (!rdev->int_scan_req ||
1520 				     !rdev->int_scan_req->notified)))
1521 				rdev->scan_req->info.aborted = true;
1522 			___cfg80211_scan_done(rdev, false);
1523 		}
1524 
1525 		list_for_each_entry_safe(pos, tmp,
1526 					 &rdev->sched_scan_req_list, list) {
1527 			if (WARN_ON(pos->dev == wdev->netdev))
1528 				cfg80211_stop_sched_scan_req(rdev, pos, false);
1529 		}
1530 
1531 		rdev->opencount--;
1532 		wiphy_unlock(&rdev->wiphy);
1533 		wake_up(&rdev->dev_wait);
1534 		break;
1535 	case NETDEV_UP:
1536 		wiphy_lock(&rdev->wiphy);
1537 		cfg80211_update_iface_num(rdev, wdev->iftype, 1);
1538 		wdev_lock(wdev);
1539 		switch (wdev->iftype) {
1540 #ifdef CONFIG_CFG80211_WEXT
1541 		case NL80211_IFTYPE_ADHOC:
1542 			cfg80211_ibss_wext_join(rdev, wdev);
1543 			break;
1544 		case NL80211_IFTYPE_STATION:
1545 			cfg80211_mgd_wext_connect(rdev, wdev);
1546 			break;
1547 #endif
1548 #ifdef CONFIG_MAC80211_MESH
1549 		case NL80211_IFTYPE_MESH_POINT:
1550 			{
1551 				/* backward compat code... */
1552 				struct mesh_setup setup;
1553 				memcpy(&setup, &default_mesh_setup,
1554 						sizeof(setup));
1555 				 /* back compat only needed for mesh_id */
1556 				setup.mesh_id = wdev->u.mesh.id;
1557 				setup.mesh_id_len = wdev->u.mesh.id_up_len;
1558 				if (wdev->u.mesh.id_up_len)
1559 					__cfg80211_join_mesh(rdev, dev,
1560 							&setup,
1561 							&default_mesh_config);
1562 				break;
1563 			}
1564 #endif
1565 		default:
1566 			break;
1567 		}
1568 		wdev_unlock(wdev);
1569 		rdev->opencount++;
1570 
1571 		/*
1572 		 * Configure power management to the driver here so that its
1573 		 * correctly set also after interface type changes etc.
1574 		 */
1575 		if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1576 		     wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
1577 		    rdev->ops->set_power_mgmt &&
1578 		    rdev_set_power_mgmt(rdev, dev, wdev->ps,
1579 					wdev->ps_timeout)) {
1580 			/* assume this means it's off */
1581 			wdev->ps = false;
1582 		}
1583 		wiphy_unlock(&rdev->wiphy);
1584 		break;
1585 	case NETDEV_PRE_UP:
1586 		if (!cfg80211_iftype_allowed(wdev->wiphy, wdev->iftype,
1587 					     wdev->use_4addr, 0))
1588 			return notifier_from_errno(-EOPNOTSUPP);
1589 
1590 		if (rfkill_blocked(rdev->wiphy.rfkill))
1591 			return notifier_from_errno(-ERFKILL);
1592 		break;
1593 	default:
1594 		return NOTIFY_DONE;
1595 	}
1596 
1597 	wireless_nlevent_flush();
1598 
1599 	return NOTIFY_OK;
1600 }
1601 
1602 static struct notifier_block cfg80211_netdev_notifier = {
1603 	.notifier_call = cfg80211_netdev_notifier_call,
1604 };
1605 
cfg80211_pernet_exit(struct net * net)1606 static void __net_exit cfg80211_pernet_exit(struct net *net)
1607 {
1608 	struct cfg80211_registered_device *rdev;
1609 
1610 	rtnl_lock();
1611 	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1612 		if (net_eq(wiphy_net(&rdev->wiphy), net))
1613 			WARN_ON(cfg80211_switch_netns(rdev, &init_net));
1614 	}
1615 	rtnl_unlock();
1616 }
1617 
1618 static struct pernet_operations cfg80211_pernet_ops = {
1619 	.exit = cfg80211_pernet_exit,
1620 };
1621 
wiphy_work_queue(struct wiphy * wiphy,struct wiphy_work * work)1622 void wiphy_work_queue(struct wiphy *wiphy, struct wiphy_work *work)
1623 {
1624 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1625 	unsigned long flags;
1626 
1627 	spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
1628 	if (list_empty(&work->entry))
1629 		list_add_tail(&work->entry, &rdev->wiphy_work_list);
1630 	spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
1631 
1632 	queue_work(system_unbound_wq, &rdev->wiphy_work);
1633 }
1634 EXPORT_SYMBOL_GPL(wiphy_work_queue);
1635 
wiphy_work_cancel(struct wiphy * wiphy,struct wiphy_work * work)1636 void wiphy_work_cancel(struct wiphy *wiphy, struct wiphy_work *work)
1637 {
1638 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1639 	unsigned long flags;
1640 
1641 	lockdep_assert_held(&wiphy->mtx);
1642 
1643 	spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
1644 	if (!list_empty(&work->entry))
1645 		list_del_init(&work->entry);
1646 	spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
1647 }
1648 EXPORT_SYMBOL_GPL(wiphy_work_cancel);
1649 
wiphy_work_flush(struct wiphy * wiphy,struct wiphy_work * work)1650 void wiphy_work_flush(struct wiphy *wiphy, struct wiphy_work *work)
1651 {
1652 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1653 	unsigned long flags;
1654 	bool run;
1655 
1656 	spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
1657 	run = !work || !list_empty(&work->entry);
1658 	spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
1659 
1660 	if (run)
1661 		cfg80211_process_wiphy_works(rdev, work);
1662 }
1663 EXPORT_SYMBOL_GPL(wiphy_work_flush);
1664 
wiphy_delayed_work_timer(struct timer_list * t)1665 void wiphy_delayed_work_timer(struct timer_list *t)
1666 {
1667 	struct wiphy_delayed_work *dwork = from_timer(dwork, t, timer);
1668 
1669 	wiphy_work_queue(dwork->wiphy, &dwork->work);
1670 }
1671 EXPORT_SYMBOL(wiphy_delayed_work_timer);
1672 
wiphy_delayed_work_queue(struct wiphy * wiphy,struct wiphy_delayed_work * dwork,unsigned long delay)1673 void wiphy_delayed_work_queue(struct wiphy *wiphy,
1674 			      struct wiphy_delayed_work *dwork,
1675 			      unsigned long delay)
1676 {
1677 	if (!delay) {
1678 		del_timer(&dwork->timer);
1679 		wiphy_work_queue(wiphy, &dwork->work);
1680 		return;
1681 	}
1682 
1683 	dwork->wiphy = wiphy;
1684 	mod_timer(&dwork->timer, jiffies + delay);
1685 }
1686 EXPORT_SYMBOL_GPL(wiphy_delayed_work_queue);
1687 
wiphy_delayed_work_cancel(struct wiphy * wiphy,struct wiphy_delayed_work * dwork)1688 void wiphy_delayed_work_cancel(struct wiphy *wiphy,
1689 			       struct wiphy_delayed_work *dwork)
1690 {
1691 	lockdep_assert_held(&wiphy->mtx);
1692 
1693 	del_timer_sync(&dwork->timer);
1694 	wiphy_work_cancel(wiphy, &dwork->work);
1695 }
1696 EXPORT_SYMBOL_GPL(wiphy_delayed_work_cancel);
1697 
wiphy_delayed_work_flush(struct wiphy * wiphy,struct wiphy_delayed_work * dwork)1698 void wiphy_delayed_work_flush(struct wiphy *wiphy,
1699 			      struct wiphy_delayed_work *dwork)
1700 {
1701 	lockdep_assert_held(&wiphy->mtx);
1702 
1703 	del_timer_sync(&dwork->timer);
1704 	wiphy_work_flush(wiphy, &dwork->work);
1705 }
1706 EXPORT_SYMBOL_GPL(wiphy_delayed_work_flush);
1707 
cfg80211_init(void)1708 static int __init cfg80211_init(void)
1709 {
1710 	int err;
1711 
1712 	err = register_pernet_device(&cfg80211_pernet_ops);
1713 	if (err)
1714 		goto out_fail_pernet;
1715 
1716 	err = wiphy_sysfs_init();
1717 	if (err)
1718 		goto out_fail_sysfs;
1719 
1720 	err = register_netdevice_notifier(&cfg80211_netdev_notifier);
1721 	if (err)
1722 		goto out_fail_notifier;
1723 
1724 	err = nl80211_init();
1725 	if (err)
1726 		goto out_fail_nl80211;
1727 
1728 	ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
1729 
1730 	err = regulatory_init();
1731 	if (err)
1732 		goto out_fail_reg;
1733 
1734 	cfg80211_wq = alloc_ordered_workqueue("cfg80211", WQ_MEM_RECLAIM);
1735 	if (!cfg80211_wq) {
1736 		err = -ENOMEM;
1737 		goto out_fail_wq;
1738 	}
1739 
1740 	return 0;
1741 
1742 out_fail_wq:
1743 	regulatory_exit();
1744 out_fail_reg:
1745 	debugfs_remove(ieee80211_debugfs_dir);
1746 	nl80211_exit();
1747 out_fail_nl80211:
1748 	unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1749 out_fail_notifier:
1750 	wiphy_sysfs_exit();
1751 out_fail_sysfs:
1752 	unregister_pernet_device(&cfg80211_pernet_ops);
1753 out_fail_pernet:
1754 	return err;
1755 }
1756 fs_initcall(cfg80211_init);
1757 
cfg80211_exit(void)1758 static void __exit cfg80211_exit(void)
1759 {
1760 	debugfs_remove(ieee80211_debugfs_dir);
1761 	nl80211_exit();
1762 	unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1763 	wiphy_sysfs_exit();
1764 	regulatory_exit();
1765 	unregister_pernet_device(&cfg80211_pernet_ops);
1766 	destroy_workqueue(cfg80211_wq);
1767 }
1768 module_exit(cfg80211_exit);
1769