?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / net / wireless / core.c
bloba6f3cac8c640e4cdb0eb4fb9d3c77bf3fd352576
1 /*
2 * This is the linux wireless configuration interface.
3 *
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright 2013-2014 Intel Mobile Communications GmbH
6 * Copyright 2015 Intel Deutschland GmbH
7 */
8
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11 #include <linux/if.h>
12 #include <linux/module.h>
13 #include <linux/err.h>
14 #include <linux/list.h>
15 #include <linux/slab.h>
16 #include <linux/nl80211.h>
17 #include <linux/debugfs.h>
18 #include <linux/notifier.h>
19 #include <linux/device.h>
20 #include <linux/etherdevice.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/sched.h>
23 #include <net/genetlink.h>
24 #include <net/cfg80211.h>
25 #include "nl80211.h"
26 #include "core.h"
27 #include "sysfs.h"
28 #include "debugfs.h"
29 #include "wext-compat.h"
30 #include "rdev-ops.h"
31
32 /* name for sysfs, %d is appended */
33 #define PHY_NAME "phy"
34
35 MODULE_AUTHOR("Johannes Berg");
36 MODULE_LICENSE("GPL");
37 MODULE_DESCRIPTION("wireless configuration support");
38 MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME);
39
40 /* RCU-protected (and RTNL for writers) */
41 LIST_HEAD(cfg80211_rdev_list);
42 int cfg80211_rdev_list_generation;
43
44 /* for debugfs */
45 static struct dentry *ieee80211_debugfs_dir;
46
47 /* for the cleanup, scan and event works */
48 struct workqueue_struct *cfg80211_wq;
49
50 static bool cfg80211_disable_40mhz_24ghz;
51 module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
52 MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
53 "Disable 40MHz support in the 2.4GHz band");
54
55 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
56 {
57 struct cfg80211_registered_device *result = NULL, *rdev;
58
59 ASSERT_RTNL();
60
61 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
62 if (rdev->wiphy_idx == wiphy_idx) {
63 result = rdev;
64 break;
65 }
66 }
67
68 return result;
69 }
70
71 int get_wiphy_idx(struct wiphy *wiphy)
72 {
73 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
74
75 return rdev->wiphy_idx;
76 }
77
78 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
79 {
80 struct cfg80211_registered_device *rdev;
81
82 ASSERT_RTNL();
83
84 rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
85 if (!rdev)
86 return NULL;
87 return &rdev->wiphy;
88 }
89
90 static int cfg80211_dev_check_name(struct cfg80211_registered_device *rdev,
91 const char *newname)
92 {
93 struct cfg80211_registered_device *rdev2;
94 int wiphy_idx, taken = -1, digits;
95
96 ASSERT_RTNL();
97
98 /* prohibit calling the thing phy%d when %d is not its number */
99 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
100 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
101 /* count number of places needed to print wiphy_idx */
102 digits = 1;
103 while (wiphy_idx /= 10)
104 digits++;
105 /*
106 * deny the name if it is phy<idx> where <idx> is printed
107 * without leading zeroes. taken == strlen(newname) here
108 */
109 if (taken == strlen(PHY_NAME) + digits)
110 return -EINVAL;
111 }
112
113 /* Ensure another device does not already have this name. */
114 list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
115 if (strcmp(newname, wiphy_name(&rdev2->wiphy)) == 0)
116 return -EINVAL;
117
118 return 0;
119 }
120
121 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
122 char *newname)
123 {
124 int result;
125
126 ASSERT_RTNL();
127
128 /* Ignore nop renames */
129 if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
130 return 0;
131
132 result = cfg80211_dev_check_name(rdev, newname);
133 if (result < 0)
134 return result;
135
136 result = device_rename(&rdev->wiphy.dev, newname);
137 if (result)
138 return result;
139
140 if (rdev->wiphy.debugfsdir &&
141 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
142 rdev->wiphy.debugfsdir,
143 rdev->wiphy.debugfsdir->d_parent,
144 newname))
145 pr_err("failed to rename debugfs dir to %s!\n", newname);
146
147 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
148
149 return 0;
150 }
151
152 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
153 struct net *net)
154 {
155 struct wireless_dev *wdev;
156 int err = 0;
157
158 if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
159 return -EOPNOTSUPP;
160
161 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
162 if (!wdev->netdev)
163 continue;
164 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
165 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
166 if (err)
167 break;
168 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
169 }
170
171 if (err) {
172 /* failed -- clean up to old netns */
173 net = wiphy_net(&rdev->wiphy);
174
175 list_for_each_entry_continue_reverse(wdev,
176 &rdev->wiphy.wdev_list,
177 list) {
178 if (!wdev->netdev)
179 continue;
180 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
181 err = dev_change_net_namespace(wdev->netdev, net,
182 "wlan%d");
183 WARN_ON(err);
184 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
185 }
186
187 return err;
188 }
189
190 wiphy_net_set(&rdev->wiphy, net);
191
192 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
193 WARN_ON(err);
194
195 return 0;
196 }
197
198 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
199 {
200 struct cfg80211_registered_device *rdev = data;
201
202 rdev_rfkill_poll(rdev);
203 }
204
205 void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
206 struct wireless_dev *wdev)
207 {
208 ASSERT_RTNL();
209
210 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
211 return;
212
213 if (!wdev_running(wdev))
214 return;
215
216 rdev_stop_p2p_device(rdev, wdev);
217 wdev->is_running = false;
218
219 rdev->opencount--;
220
221 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
222 if (WARN_ON(!rdev->scan_req->notified))
223 rdev->scan_req->info.aborted = true;
224 ___cfg80211_scan_done(rdev, false);
225 }
226 }
227
228 void cfg80211_stop_nan(struct cfg80211_registered_device *rdev,
229 struct wireless_dev *wdev)
230 {
231 ASSERT_RTNL();
232
233 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_NAN))
234 return;
235
236 if (!wdev_running(wdev))
237 return;
238
239 rdev_stop_nan(rdev, wdev);
240 wdev->is_running = false;
241
242 rdev->opencount--;
243 }
244
245 void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy)
246 {
247 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
248 struct wireless_dev *wdev;
249
250 ASSERT_RTNL();
251
252 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
253 if (wdev->netdev) {
254 dev_close(wdev->netdev);
255 continue;
256 }
257 /* otherwise, check iftype */
258 switch (wdev->iftype) {
259 case NL80211_IFTYPE_P2P_DEVICE:
260 cfg80211_stop_p2p_device(rdev, wdev);
261 break;
262 case NL80211_IFTYPE_NAN:
263 cfg80211_stop_nan(rdev, wdev);
264 break;
265 default:
266 break;
267 }
268 }
269 }
270 EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces);
271
272 static int cfg80211_rfkill_set_block(void *data, bool blocked)
273 {
274 struct cfg80211_registered_device *rdev = data;
275
276 if (!blocked)
277 return 0;
278
279 rtnl_lock();
280 cfg80211_shutdown_all_interfaces(&rdev->wiphy);
281 rtnl_unlock();
282
283 return 0;
284 }
285
286 static void cfg80211_rfkill_sync_work(struct work_struct *work)
287 {
288 struct cfg80211_registered_device *rdev;
289
290 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
291 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
292 }
293
294 static void cfg80211_event_work(struct work_struct *work)
295 {
296 struct cfg80211_registered_device *rdev;
297
298 rdev = container_of(work, struct cfg80211_registered_device,
299 event_work);
300
301 rtnl_lock();
302 cfg80211_process_rdev_events(rdev);
303 rtnl_unlock();
304 }
305
306 void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev)
307 {
308 struct wireless_dev *wdev, *tmp;
309
310 ASSERT_RTNL();
311
312 list_for_each_entry_safe(wdev, tmp, &rdev->wiphy.wdev_list, list) {
313 if (wdev->nl_owner_dead)
314 rdev_del_virtual_intf(rdev, wdev);
315 }
316 }
317
318 static void cfg80211_destroy_iface_wk(struct work_struct *work)
319 {
320 struct cfg80211_registered_device *rdev;
321
322 rdev = container_of(work, struct cfg80211_registered_device,
323 destroy_work);
324
325 rtnl_lock();
326 cfg80211_destroy_ifaces(rdev);
327 rtnl_unlock();
328 }
329
330 static void cfg80211_sched_scan_stop_wk(struct work_struct *work)
331 {
332 struct cfg80211_registered_device *rdev;
333 struct cfg80211_sched_scan_request *req, *tmp;
334
335 rdev = container_of(work, struct cfg80211_registered_device,
336 sched_scan_stop_wk);
337
338 rtnl_lock();
339 list_for_each_entry_safe(req, tmp, &rdev->sched_scan_req_list, list) {
340 if (req->nl_owner_dead)
341 cfg80211_stop_sched_scan_req(rdev, req, false);
342 }
343 rtnl_unlock();
344 }
345
346 static void cfg80211_propagate_radar_detect_wk(struct work_struct *work)
347 {
348 struct cfg80211_registered_device *rdev;
349
350 rdev = container_of(work, struct cfg80211_registered_device,
351 propagate_radar_detect_wk);
352
353 rtnl_lock();
354
355 regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->radar_chandef,
356 NL80211_DFS_UNAVAILABLE,
357 NL80211_RADAR_DETECTED);
358
359 rtnl_unlock();
360 }
361
362 static void cfg80211_propagate_cac_done_wk(struct work_struct *work)
363 {
364 struct cfg80211_registered_device *rdev;
365
366 rdev = container_of(work, struct cfg80211_registered_device,
367 propagate_cac_done_wk);
368
369 rtnl_lock();
370
371 regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->cac_done_chandef,
372 NL80211_DFS_AVAILABLE,
373 NL80211_RADAR_CAC_FINISHED);
374
375 rtnl_unlock();
376 }
377
378 /* exported functions */
379
380 struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
381 const char *requested_name)
382 {
383 static atomic_t wiphy_counter = ATOMIC_INIT(0);
384
385 struct cfg80211_registered_device *rdev;
386 int alloc_size;
387
388 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
389 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
390 WARN_ON(ops->connect && !ops->disconnect);
391 WARN_ON(ops->join_ibss && !ops->leave_ibss);
392 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
393 WARN_ON(ops->add_station && !ops->del_station);
394 WARN_ON(ops->add_mpath && !ops->del_mpath);
395 WARN_ON(ops->join_mesh && !ops->leave_mesh);
396 WARN_ON(ops->start_p2p_device && !ops->stop_p2p_device);
397 WARN_ON(ops->start_ap && !ops->stop_ap);
398 WARN_ON(ops->join_ocb && !ops->leave_ocb);
399 WARN_ON(ops->suspend && !ops->resume);
400 WARN_ON(ops->sched_scan_start && !ops->sched_scan_stop);
401 WARN_ON(ops->remain_on_channel && !ops->cancel_remain_on_channel);
402 WARN_ON(ops->tdls_channel_switch && !ops->tdls_cancel_channel_switch);
403 WARN_ON(ops->add_tx_ts && !ops->del_tx_ts);
404
405 alloc_size = sizeof(*rdev) + sizeof_priv;
406
407 rdev = kzalloc(alloc_size, GFP_KERNEL);
408 if (!rdev)
409 return NULL;
410
411 rdev->ops = ops;
412
413 rdev->wiphy_idx = atomic_inc_return(&wiphy_counter);
414
415 if (unlikely(rdev->wiphy_idx < 0)) {
416 /* ugh, wrapped! */
417 atomic_dec(&wiphy_counter);
418 kfree(rdev);
419 return NULL;
420 }
421
422 /* atomic_inc_return makes it start at 1, make it start at 0 */
423 rdev->wiphy_idx--;
424
425 /* give it a proper name */
426 if (requested_name && requested_name[0]) {
427 int rv;
428
429 rtnl_lock();
430 rv = cfg80211_dev_check_name(rdev, requested_name);
431
432 if (rv < 0) {
433 rtnl_unlock();
434 goto use_default_name;
435 }
436
437 rv = dev_set_name(&rdev->wiphy.dev, "%s", requested_name);
438 rtnl_unlock();
439 if (rv)
440 goto use_default_name;
441 } else {
442 int rv;
443
444 use_default_name:
445 /* NOTE: This is *probably* safe w/out holding rtnl because of
446 * the restrictions on phy names. Probably this call could
447 * fail if some other part of the kernel (re)named a device
448 * phyX. But, might should add some locking and check return
449 * value, and use a different name if this one exists?
450 */
451 rv = dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
452 if (rv < 0) {
453 kfree(rdev);
454 return NULL;
455 }
456 }
457
458 INIT_LIST_HEAD(&rdev->wiphy.wdev_list);
459 INIT_LIST_HEAD(&rdev->beacon_registrations);
460 spin_lock_init(&rdev->beacon_registrations_lock);
461 spin_lock_init(&rdev->bss_lock);
462 INIT_LIST_HEAD(&rdev->bss_list);
463 INIT_LIST_HEAD(&rdev->sched_scan_req_list);
464 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
465 INIT_LIST_HEAD(&rdev->mlme_unreg);
466 spin_lock_init(&rdev->mlme_unreg_lock);
467 INIT_WORK(&rdev->mlme_unreg_wk, cfg80211_mlme_unreg_wk);
468 INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
469 cfg80211_dfs_channels_update_work);
470 #ifdef CONFIG_CFG80211_WEXT
471 rdev->wiphy.wext = &cfg80211_wext_handler;
472 #endif
473
474 device_initialize(&rdev->wiphy.dev);
475 rdev->wiphy.dev.class = &ieee80211_class;
476 rdev->wiphy.dev.platform_data = rdev;
477 device_enable_async_suspend(&rdev->wiphy.dev);
478
479 INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);
480 INIT_WORK(&rdev->sched_scan_stop_wk, cfg80211_sched_scan_stop_wk);
481 INIT_WORK(&rdev->sched_scan_res_wk, cfg80211_sched_scan_results_wk);
482 INIT_WORK(&rdev->propagate_radar_detect_wk,
483 cfg80211_propagate_radar_detect_wk);
484 INIT_WORK(&rdev->propagate_cac_done_wk, cfg80211_propagate_cac_done_wk);
485
486 #ifdef CONFIG_CFG80211_DEFAULT_PS
487 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
488 #endif
489
490 wiphy_net_set(&rdev->wiphy, &init_net);
491
492 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
493 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
494 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
495 &rdev->rfkill_ops, rdev);
496
497 if (!rdev->rfkill) {
498 kfree(rdev);
499 return NULL;
500 }
501
502 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
503 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
504 INIT_WORK(&rdev->event_work, cfg80211_event_work);
505
506 init_waitqueue_head(&rdev->dev_wait);
507
508 /*
509 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
510 * Fragmentation and RTS threshold are disabled by default with the
511 * special -1 value.
512 */
513 rdev->wiphy.retry_short = 7;
514 rdev->wiphy.retry_long = 4;
515 rdev->wiphy.frag_threshold = (u32) -1;
516 rdev->wiphy.rts_threshold = (u32) -1;
517 rdev->wiphy.coverage_class = 0;
518
519 rdev->wiphy.max_num_csa_counters = 1;
520
521 rdev->wiphy.max_sched_scan_plans = 1;
522 rdev->wiphy.max_sched_scan_plan_interval = U32_MAX;
523
524 return &rdev->wiphy;
525 }
526 EXPORT_SYMBOL(wiphy_new_nm);
527
528 static int wiphy_verify_combinations(struct wiphy *wiphy)
529 {
530 const struct ieee80211_iface_combination *c;
531 int i, j;
532
533 for (i = 0; i < wiphy->n_iface_combinations; i++) {
534 u32 cnt = 0;
535 u16 all_iftypes = 0;
536
537 c = &wiphy->iface_combinations[i];
538
539 /*
540 * Combinations with just one interface aren't real,
541 * however we make an exception for DFS.
542 */
543 if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
544 return -EINVAL;
545
546 /* Need at least one channel */
547 if (WARN_ON(!c->num_different_channels))
548 return -EINVAL;
549
550 /*
551 * Put a sane limit on maximum number of different
552 * channels to simplify channel accounting code.
553 */
554 if (WARN_ON(c->num_different_channels >
555 CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
556 return -EINVAL;
557
558 /* DFS only works on one channel. */
559 if (WARN_ON(c->radar_detect_widths &&
560 (c->num_different_channels > 1)))
561 return -EINVAL;
562
563 if (WARN_ON(!c->n_limits))
564 return -EINVAL;
565
566 for (j = 0; j < c->n_limits; j++) {
567 u16 types = c->limits[j].types;
568
569 /* interface types shouldn't overlap */
570 if (WARN_ON(types & all_iftypes))
571 return -EINVAL;
572 all_iftypes |= types;
573
574 if (WARN_ON(!c->limits[j].max))
575 return -EINVAL;
576
577 /* Shouldn't list software iftypes in combinations! */
578 if (WARN_ON(wiphy->software_iftypes & types))
579 return -EINVAL;
580
581 /* Only a single P2P_DEVICE can be allowed */
582 if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
583 c->limits[j].max > 1))
584 return -EINVAL;
585
586 /* Only a single NAN can be allowed */
587 if (WARN_ON(types & BIT(NL80211_IFTYPE_NAN) &&
588 c->limits[j].max > 1))
589 return -EINVAL;
590
591 /*
592 * This isn't well-defined right now. If you have an
593 * IBSS interface, then its beacon interval may change
594 * by joining other networks, and nothing prevents it
595 * from doing that.
596 * So technically we probably shouldn't even allow AP
597 * and IBSS in the same interface, but it seems that
598 * some drivers support that, possibly only with fixed
599 * beacon intervals for IBSS.
600 */
601 if (WARN_ON(types & BIT(NL80211_IFTYPE_ADHOC) &&
602 c->beacon_int_min_gcd)) {
603 return -EINVAL;
604 }
605
606 cnt += c->limits[j].max;
607 /*
608 * Don't advertise an unsupported type
609 * in a combination.
610 */
611 if (WARN_ON((wiphy->interface_modes & types) != types))
612 return -EINVAL;
613 }
614
615 #ifndef CONFIG_WIRELESS_WDS
616 if (WARN_ON(all_iftypes & BIT(NL80211_IFTYPE_WDS)))
617 return -EINVAL;
618 #endif
619
620 /* You can't even choose that many! */
621 if (WARN_ON(cnt < c->max_interfaces))
622 return -EINVAL;
623 }
624
625 return 0;
626 }
627
628 int wiphy_register(struct wiphy *wiphy)
629 {
630 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
631 int res;
632 enum nl80211_band band;
633 struct ieee80211_supported_band *sband;
634 bool have_band = false;
635 int i;
636 u16 ifmodes = wiphy->interface_modes;
637
638 #ifdef CONFIG_PM
639 if (WARN_ON(wiphy->wowlan &&
640 (wiphy->wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
641 !(wiphy->wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
642 return -EINVAL;
643 if (WARN_ON(wiphy->wowlan &&
644 !wiphy->wowlan->flags && !wiphy->wowlan->n_patterns &&
645 !wiphy->wowlan->tcp))
646 return -EINVAL;
647 #endif
648 if (WARN_ON((wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
649 (!rdev->ops->tdls_channel_switch ||
650 !rdev->ops->tdls_cancel_channel_switch)))
651 return -EINVAL;
652
653 if (WARN_ON((wiphy->interface_modes & BIT(NL80211_IFTYPE_NAN)) &&
654 (!rdev->ops->start_nan || !rdev->ops->stop_nan ||
655 !rdev->ops->add_nan_func || !rdev->ops->del_nan_func ||
656 !(wiphy->nan_supported_bands & BIT(NL80211_BAND_2GHZ)))))
657 return -EINVAL;
658
659 #ifndef CONFIG_WIRELESS_WDS
660 if (WARN_ON(wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS)))
661 return -EINVAL;
662 #endif
663
664 /*
665 * if a wiphy has unsupported modes for regulatory channel enforcement,
666 * opt-out of enforcement checking
667 */
668 if (wiphy->interface_modes & ~(BIT(NL80211_IFTYPE_STATION) |
669 BIT(NL80211_IFTYPE_P2P_CLIENT) |
670 BIT(NL80211_IFTYPE_AP) |
671 BIT(NL80211_IFTYPE_P2P_GO) |
672 BIT(NL80211_IFTYPE_ADHOC) |
673 BIT(NL80211_IFTYPE_P2P_DEVICE) |
674 BIT(NL80211_IFTYPE_NAN) |
675 BIT(NL80211_IFTYPE_AP_VLAN) |
676 BIT(NL80211_IFTYPE_MONITOR)))
677 wiphy->regulatory_flags |= REGULATORY_IGNORE_STALE_KICKOFF;
678
679 if (WARN_ON((wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) &&
680 (wiphy->regulatory_flags &
681 (REGULATORY_CUSTOM_REG |
682 REGULATORY_STRICT_REG |
683 REGULATORY_COUNTRY_IE_FOLLOW_POWER |
684 REGULATORY_COUNTRY_IE_IGNORE))))
685 return -EINVAL;
686
687 if (WARN_ON(wiphy->coalesce &&
688 (!wiphy->coalesce->n_rules ||
689 !wiphy->coalesce->n_patterns) &&
690 (!wiphy->coalesce->pattern_min_len ||
691 wiphy->coalesce->pattern_min_len >
692 wiphy->coalesce->pattern_max_len)))
693 return -EINVAL;
694
695 if (WARN_ON(wiphy->ap_sme_capa &&
696 !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
697 return -EINVAL;
698
699 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
700 return -EINVAL;
701
702 if (WARN_ON(wiphy->addresses &&
703 !is_zero_ether_addr(wiphy->perm_addr) &&
704 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
705 ETH_ALEN)))
706 return -EINVAL;
707
708 if (WARN_ON(wiphy->max_acl_mac_addrs &&
709 (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
710 !rdev->ops->set_mac_acl)))
711 return -EINVAL;
712
713 /* assure only valid behaviours are flagged by driver
714 * hence subtract 2 as bit 0 is invalid.
715 */
716 if (WARN_ON(wiphy->bss_select_support &&
717 (wiphy->bss_select_support & ~(BIT(__NL80211_BSS_SELECT_ATTR_AFTER_LAST) - 2))))
718 return -EINVAL;
719
720 if (WARN_ON(wiphy_ext_feature_isset(&rdev->wiphy,
721 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X) &&
722 (!rdev->ops->set_pmk || !rdev->ops->del_pmk)))
723 return -EINVAL;
724
725 if (wiphy->addresses)
726 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
727
728 /* sanity check ifmodes */
729 WARN_ON(!ifmodes);
730 ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
731 if (WARN_ON(ifmodes != wiphy->interface_modes))
732 wiphy->interface_modes = ifmodes;
733
734 res = wiphy_verify_combinations(wiphy);
735 if (res)
736 return res;
737
738 /* sanity check supported bands/channels */
739 for (band = 0; band < NUM_NL80211_BANDS; band++) {
740 sband = wiphy->bands[band];
741 if (!sband)
742 continue;
743
744 sband->band = band;
745 if (WARN_ON(!sband->n_channels))
746 return -EINVAL;
747 /*
748 * on 60GHz band, there are no legacy rates, so
749 * n_bitrates is 0
750 */
751 if (WARN_ON(band != NL80211_BAND_60GHZ &&
752 !sband->n_bitrates))
753 return -EINVAL;
754
755 /*
756 * Since cfg80211_disable_40mhz_24ghz is global, we can
757 * modify the sband's ht data even if the driver uses a
758 * global structure for that.
759 */
760 if (cfg80211_disable_40mhz_24ghz &&
761 band == NL80211_BAND_2GHZ &&
762 sband->ht_cap.ht_supported) {
763 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
764 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
765 }
766
767 /*
768 * Since we use a u32 for rate bitmaps in
769 * ieee80211_get_response_rate, we cannot
770 * have more than 32 legacy rates.
771 */
772 if (WARN_ON(sband->n_bitrates > 32))
773 return -EINVAL;
774
775 for (i = 0; i < sband->n_channels; i++) {
776 sband->channels[i].orig_flags =
777 sband->channels[i].flags;
778 sband->channels[i].orig_mag = INT_MAX;
779 sband->channels[i].orig_mpwr =
780 sband->channels[i].max_power;
781 sband->channels[i].band = band;
782 }
783
784 have_band = true;
785 }
786
787 if (!have_band) {
788 WARN_ON(1);
789 return -EINVAL;
790 }
791
792 #ifdef CONFIG_PM
793 if (WARN_ON(rdev->wiphy.wowlan && rdev->wiphy.wowlan->n_patterns &&
794 (!rdev->wiphy.wowlan->pattern_min_len ||
795 rdev->wiphy.wowlan->pattern_min_len >
796 rdev->wiphy.wowlan->pattern_max_len)))
797 return -EINVAL;
798 #endif
799
800 /* check and set up bitrates */
801 ieee80211_set_bitrate_flags(wiphy);
802
803 rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
804
805 rtnl_lock();
806 res = device_add(&rdev->wiphy.dev);
807 if (res) {
808 rtnl_unlock();
809 return res;
810 }
811
812 /* set up regulatory info */
813 wiphy_regulatory_register(wiphy);
814
815 list_add_rcu(&rdev->list, &cfg80211_rdev_list);
816 cfg80211_rdev_list_generation++;
817
818 /* add to debugfs */
819 rdev->wiphy.debugfsdir =
820 debugfs_create_dir(wiphy_name(&rdev->wiphy),
821 ieee80211_debugfs_dir);
822 if (IS_ERR(rdev->wiphy.debugfsdir))
823 rdev->wiphy.debugfsdir = NULL;
824
825 cfg80211_debugfs_rdev_add(rdev);
826 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
827
828 if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
829 struct regulatory_request request;
830
831 request.wiphy_idx = get_wiphy_idx(wiphy);
832 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
833 request.alpha2[0] = '9';
834 request.alpha2[1] = '9';
835
836 nl80211_send_reg_change_event(&request);
837 }
838
839 /* Check that nobody globally advertises any capabilities they do not
840 * advertise on all possible interface types.
841 */
842 if (wiphy->extended_capabilities_len &&
843 wiphy->num_iftype_ext_capab &&
844 wiphy->iftype_ext_capab) {
845 u8 supported_on_all, j;
846 const struct wiphy_iftype_ext_capab *capab;
847
848 capab = wiphy->iftype_ext_capab;
849 for (j = 0; j < wiphy->extended_capabilities_len; j++) {
850 if (capab[0].extended_capabilities_len > j)
851 supported_on_all =
852 capab[0].extended_capabilities[j];
853 else
854 supported_on_all = 0x00;
855 for (i = 1; i < wiphy->num_iftype_ext_capab; i++) {
856 if (j >= capab[i].extended_capabilities_len) {
857 supported_on_all = 0x00;
858 break;
859 }
860 supported_on_all &=
861 capab[i].extended_capabilities[j];
862 }
863 if (WARN_ON(wiphy->extended_capabilities[j] &
864 ~supported_on_all))
865 break;
866 }
867 }
868
869 rdev->wiphy.registered = true;
870 rtnl_unlock();
871
872 res = rfkill_register(rdev->rfkill);
873 if (res) {
874 rfkill_destroy(rdev->rfkill);
875 rdev->rfkill = NULL;
876 wiphy_unregister(&rdev->wiphy);
877 return res;
878 }
879
880 return 0;
881 }
882 EXPORT_SYMBOL(wiphy_register);
883
884 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
885 {
886 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
887
888 if (!rdev->ops->rfkill_poll)
889 return;
890 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
891 rfkill_resume_polling(rdev->rfkill);
892 }
893 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
894
895 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
896 {
897 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
898
899 rfkill_pause_polling(rdev->rfkill);
900 }
901 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
902
903 void wiphy_unregister(struct wiphy *wiphy)
904 {
905 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
906
907 wait_event(rdev->dev_wait, ({
908 int __count;
909 rtnl_lock();
910 __count = rdev->opencount;
911 rtnl_unlock();
912 __count == 0; }));
913
914 if (rdev->rfkill)
915 rfkill_unregister(rdev->rfkill);
916
917 rtnl_lock();
918 nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
919 rdev->wiphy.registered = false;
920
921 WARN_ON(!list_empty(&rdev->wiphy.wdev_list));
922
923 /*
924 * First remove the hardware from everywhere, this makes
925 * it impossible to find from userspace.
926 */
927 debugfs_remove_recursive(rdev->wiphy.debugfsdir);
928 list_del_rcu(&rdev->list);
929 synchronize_rcu();
930
931 /*
932 * If this device got a regulatory hint tell core its
933 * free to listen now to a new shiny device regulatory hint
934 */
935 wiphy_regulatory_deregister(wiphy);
936
937 cfg80211_rdev_list_generation++;
938 device_del(&rdev->wiphy.dev);
939
940 rtnl_unlock();
941
942 flush_work(&rdev->scan_done_wk);
943 cancel_work_sync(&rdev->conn_work);
944 flush_work(&rdev->event_work);
945 cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
946 flush_work(&rdev->destroy_work);
947 flush_work(&rdev->sched_scan_stop_wk);
948 flush_work(&rdev->mlme_unreg_wk);
949 flush_work(&rdev->propagate_radar_detect_wk);
950 flush_work(&rdev->propagate_cac_done_wk);
951
952 #ifdef CONFIG_PM
953 if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
954 rdev_set_wakeup(rdev, false);
955 #endif
956 cfg80211_rdev_free_wowlan(rdev);
957 cfg80211_rdev_free_coalesce(rdev);
958 }
959 EXPORT_SYMBOL(wiphy_unregister);
960
961 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
962 {
963 struct cfg80211_internal_bss *scan, *tmp;
964 struct cfg80211_beacon_registration *reg, *treg;
965 rfkill_destroy(rdev->rfkill);
966 list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
967 list_del(&reg->list);
968 kfree(reg);
969 }
970 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
971 cfg80211_put_bss(&rdev->wiphy, &scan->pub);
972 kfree(rdev);
973 }
974
975 void wiphy_free(struct wiphy *wiphy)
976 {
977 put_device(&wiphy->dev);
978 }
979 EXPORT_SYMBOL(wiphy_free);
980
981 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
982 {
983 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
984
985 if (rfkill_set_hw_state(rdev->rfkill, blocked))
986 schedule_work(&rdev->rfkill_sync);
987 }
988 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
989
990 void cfg80211_cqm_config_free(struct wireless_dev *wdev)
991 {
992 kfree(wdev->cqm_config);
993 wdev->cqm_config = NULL;
994 }
995
996 void cfg80211_unregister_wdev(struct wireless_dev *wdev)
997 {
998 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
999
1000 ASSERT_RTNL();
1001
1002 if (WARN_ON(wdev->netdev))
1003 return;
1004
1005 nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
1006
1007 list_del_rcu(&wdev->list);
1008 rdev->devlist_generation++;
1009
1010 switch (wdev->iftype) {
1011 case NL80211_IFTYPE_P2P_DEVICE:
1012 cfg80211_mlme_purge_registrations(wdev);
1013 cfg80211_stop_p2p_device(rdev, wdev);
1014 break;
1015 case NL80211_IFTYPE_NAN:
1016 cfg80211_stop_nan(rdev, wdev);
1017 break;
1018 default:
1019 WARN_ON_ONCE(1);
1020 break;
1021 }
1022
1023 cfg80211_cqm_config_free(wdev);
1024 }
1025 EXPORT_SYMBOL(cfg80211_unregister_wdev);
1026
1027 static const struct device_type wiphy_type = {
1028 .name = "wlan",
1029 };
1030
1031 void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
1032 enum nl80211_iftype iftype, int num)
1033 {
1034 ASSERT_RTNL();
1035
1036 rdev->num_running_ifaces += num;
1037 if (iftype == NL80211_IFTYPE_MONITOR)
1038 rdev->num_running_monitor_ifaces += num;
1039 }
1040
1041 void __cfg80211_leave(struct cfg80211_registered_device *rdev,
1042 struct wireless_dev *wdev)
1043 {
1044 struct net_device *dev = wdev->netdev;
1045 struct cfg80211_sched_scan_request *pos, *tmp;
1046
1047 ASSERT_RTNL();
1048 ASSERT_WDEV_LOCK(wdev);
1049
1050 switch (wdev->iftype) {
1051 case NL80211_IFTYPE_ADHOC:
1052 __cfg80211_leave_ibss(rdev, dev, true);
1053 break;
1054 case NL80211_IFTYPE_P2P_CLIENT:
1055 case NL80211_IFTYPE_STATION:
1056 list_for_each_entry_safe(pos, tmp, &rdev->sched_scan_req_list,
1057 list) {
1058 if (dev == pos->dev)
1059 cfg80211_stop_sched_scan_req(rdev, pos, false);
1060 }
1061
1062 #ifdef CONFIG_CFG80211_WEXT
1063 kfree(wdev->wext.ie);
1064 wdev->wext.ie = NULL;
1065 wdev->wext.ie_len = 0;
1066 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1067 #endif
1068 cfg80211_disconnect(rdev, dev,
1069 WLAN_REASON_DEAUTH_LEAVING, true);
1070 break;
1071 case NL80211_IFTYPE_MESH_POINT:
1072 __cfg80211_leave_mesh(rdev, dev);
1073 break;
1074 case NL80211_IFTYPE_AP:
1075 case NL80211_IFTYPE_P2P_GO:
1076 __cfg80211_stop_ap(rdev, dev, true);
1077 break;
1078 case NL80211_IFTYPE_OCB:
1079 __cfg80211_leave_ocb(rdev, dev);
1080 break;
1081 case NL80211_IFTYPE_WDS:
1082 /* must be handled by mac80211/driver, has no APIs */
1083 break;
1084 case NL80211_IFTYPE_P2P_DEVICE:
1085 case NL80211_IFTYPE_NAN:
1086 /* cannot happen, has no netdev */
1087 break;
1088 case NL80211_IFTYPE_AP_VLAN:
1089 case NL80211_IFTYPE_MONITOR:
1090 /* nothing to do */
1091 break;
1092 case NL80211_IFTYPE_UNSPECIFIED:
1093 case NUM_NL80211_IFTYPES:
1094 /* invalid */
1095 break;
1096 }
1097 }
1098
1099 void cfg80211_leave(struct cfg80211_registered_device *rdev,
1100 struct wireless_dev *wdev)
1101 {
1102 wdev_lock(wdev);
1103 __cfg80211_leave(rdev, wdev);
1104 wdev_unlock(wdev);
1105 }
1106
1107 void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
1108 gfp_t gfp)
1109 {
1110 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1111 struct cfg80211_event *ev;
1112 unsigned long flags;
1113
1114 trace_cfg80211_stop_iface(wiphy, wdev);
1115
1116 ev = kzalloc(sizeof(*ev), gfp);
1117 if (!ev)
1118 return;
1119
1120 ev->type = EVENT_STOPPED;
1121
1122 spin_lock_irqsave(&wdev->event_lock, flags);
1123 list_add_tail(&ev->list, &wdev->event_list);
1124 spin_unlock_irqrestore(&wdev->event_lock, flags);
1125 queue_work(cfg80211_wq, &rdev->event_work);
1126 }
1127 EXPORT_SYMBOL(cfg80211_stop_iface);
1128
1129 static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
1130 unsigned long state, void *ptr)
1131 {
1132 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1133 struct wireless_dev *wdev = dev->ieee80211_ptr;
1134 struct cfg80211_registered_device *rdev;
1135 struct cfg80211_sched_scan_request *pos, *tmp;
1136
1137 if (!wdev)
1138 return NOTIFY_DONE;
1139
1140 rdev = wiphy_to_rdev(wdev->wiphy);
1141
1142 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
1143
1144 switch (state) {
1145 case NETDEV_POST_INIT:
1146 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
1147 break;
1148 case NETDEV_REGISTER:
1149 /*
1150 * NB: cannot take rdev->mtx here because this may be
1151 * called within code protected by it when interfaces
1152 * are added with nl80211.
1153 */
1154 mutex_init(&wdev->mtx);
1155 INIT_LIST_HEAD(&wdev->event_list);
1156 spin_lock_init(&wdev->event_lock);
1157 INIT_LIST_HEAD(&wdev->mgmt_registrations);
1158 spin_lock_init(&wdev->mgmt_registrations_lock);
1159
1160 /*
1161 * We get here also when the interface changes network namespaces,
1162 * as it's registered into the new one, but we don't want it to
1163 * change ID in that case. Checking if the ID is already assigned
1164 * works, because 0 isn't considered a valid ID and the memory is
1165 * 0-initialized.
1166 */
1167 if (!wdev->identifier)
1168 wdev->identifier = ++rdev->wdev_id;
1169 list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
1170 rdev->devlist_generation++;
1171 /* can only change netns with wiphy */
1172 dev->features |= NETIF_F_NETNS_LOCAL;
1173
1174 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
1175 "phy80211")) {
1176 pr_err("failed to add phy80211 symlink to netdev!\n");
1177 }
1178 wdev->netdev = dev;
1179 #ifdef CONFIG_CFG80211_WEXT
1180 wdev->wext.default_key = -1;
1181 wdev->wext.default_mgmt_key = -1;
1182 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1183 #endif
1184
1185 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
1186 wdev->ps = true;
1187 else
1188 wdev->ps = false;
1189 /* allow mac80211 to determine the timeout */
1190 wdev->ps_timeout = -1;
1191
1192 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1193 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
1194 wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
1195 dev->priv_flags |= IFF_DONT_BRIDGE;
1196
1197 INIT_WORK(&wdev->disconnect_wk, cfg80211_autodisconnect_wk);
1198
1199 nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
1200 break;
1201 case NETDEV_GOING_DOWN:
1202 cfg80211_leave(rdev, wdev);
1203 break;
1204 case NETDEV_DOWN:
1205 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
1206 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1207 if (WARN_ON(!rdev->scan_req->notified))
1208 rdev->scan_req->info.aborted = true;
1209 ___cfg80211_scan_done(rdev, false);
1210 }
1211
1212 list_for_each_entry_safe(pos, tmp,
1213 &rdev->sched_scan_req_list, list) {
1214 if (WARN_ON(pos && pos->dev == wdev->netdev))
1215 cfg80211_stop_sched_scan_req(rdev, pos, false);
1216 }
1217
1218 rdev->opencount--;
1219 wake_up(&rdev->dev_wait);
1220 break;
1221 case NETDEV_UP:
1222 cfg80211_update_iface_num(rdev, wdev->iftype, 1);
1223 wdev_lock(wdev);
1224 switch (wdev->iftype) {
1225 #ifdef CONFIG_CFG80211_WEXT
1226 case NL80211_IFTYPE_ADHOC:
1227 cfg80211_ibss_wext_join(rdev, wdev);
1228 break;
1229 case NL80211_IFTYPE_STATION:
1230 cfg80211_mgd_wext_connect(rdev, wdev);
1231 break;
1232 #endif
1233 #ifdef CONFIG_MAC80211_MESH
1234 case NL80211_IFTYPE_MESH_POINT:
1235 {
1236 /* backward compat code... */
1237 struct mesh_setup setup;
1238 memcpy(&setup, &default_mesh_setup,
1239 sizeof(setup));
1240 /* back compat only needed for mesh_id */
1241 setup.mesh_id = wdev->ssid;
1242 setup.mesh_id_len = wdev->mesh_id_up_len;
1243 if (wdev->mesh_id_up_len)
1244 __cfg80211_join_mesh(rdev, dev,
1245 &setup,
1246 &default_mesh_config);
1247 break;
1248 }
1249 #endif
1250 default:
1251 break;
1252 }
1253 wdev_unlock(wdev);
1254 rdev->opencount++;
1255
1256 /*
1257 * Configure power management to the driver here so that its
1258 * correctly set also after interface type changes etc.
1259 */
1260 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1261 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
1262 rdev->ops->set_power_mgmt &&
1263 rdev_set_power_mgmt(rdev, dev, wdev->ps,
1264 wdev->ps_timeout)) {
1265 /* assume this means it's off */
1266 wdev->ps = false;
1267 }
1268 break;
1269 case NETDEV_UNREGISTER:
1270 /*
1271 * It is possible to get NETDEV_UNREGISTER
1272 * multiple times. To detect that, check
1273 * that the interface is still on the list
1274 * of registered interfaces, and only then
1275 * remove and clean it up.
1276 */
1277 if (!list_empty(&wdev->list)) {
1278 nl80211_notify_iface(rdev, wdev,
1279 NL80211_CMD_DEL_INTERFACE);
1280 sysfs_remove_link(&dev->dev.kobj, "phy80211");
1281 list_del_rcu(&wdev->list);
1282 rdev->devlist_generation++;
1283 cfg80211_mlme_purge_registrations(wdev);
1284 #ifdef CONFIG_CFG80211_WEXT
1285 kzfree(wdev->wext.keys);
1286 #endif
1287 flush_work(&wdev->disconnect_wk);
1288 cfg80211_cqm_config_free(wdev);
1289 }
1290 /*
1291 * synchronise (so that we won't find this netdev
1292 * from other code any more) and then clear the list
1293 * head so that the above code can safely check for
1294 * !list_empty() to avoid double-cleanup.
1295 */
1296 synchronize_rcu();
1297 INIT_LIST_HEAD(&wdev->list);
1298 /*
1299 * Ensure that all events have been processed and
1300 * freed.
1301 */
1302 cfg80211_process_wdev_events(wdev);
1303
1304 if (WARN_ON(wdev->current_bss)) {
1305 cfg80211_unhold_bss(wdev->current_bss);
1306 cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
1307 wdev->current_bss = NULL;
1308 }
1309 break;
1310 case NETDEV_PRE_UP:
1311 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
1312 return notifier_from_errno(-EOPNOTSUPP);
1313 if (rfkill_blocked(rdev->rfkill))
1314 return notifier_from_errno(-ERFKILL);
1315 break;
1316 default:
1317 return NOTIFY_DONE;
1318 }
1319
1320 wireless_nlevent_flush();
1321
1322 return NOTIFY_OK;
1323 }
1324
1325 static struct notifier_block cfg80211_netdev_notifier = {
1326 .notifier_call = cfg80211_netdev_notifier_call,
1327 };
1328
1329 static void __net_exit cfg80211_pernet_exit(struct net *net)
1330 {
1331 struct cfg80211_registered_device *rdev;
1332
1333 rtnl_lock();
1334 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1335 if (net_eq(wiphy_net(&rdev->wiphy), net))
1336 WARN_ON(cfg80211_switch_netns(rdev, &init_net));
1337 }
1338 rtnl_unlock();
1339 }
1340
1341 static struct pernet_operations cfg80211_pernet_ops = {
1342 .exit = cfg80211_pernet_exit,
1343 };
1344
1345 static int __init cfg80211_init(void)
1346 {
1347 int err;
1348
1349 err = register_pernet_device(&cfg80211_pernet_ops);
1350 if (err)
1351 goto out_fail_pernet;
1352
1353 err = wiphy_sysfs_init();
1354 if (err)
1355 goto out_fail_sysfs;
1356
1357 err = register_netdevice_notifier(&cfg80211_netdev_notifier);
1358 if (err)
1359 goto out_fail_notifier;
1360
1361 err = nl80211_init();
1362 if (err)
1363 goto out_fail_nl80211;
1364
1365 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
1366
1367 err = regulatory_init();
1368 if (err)
1369 goto out_fail_reg;
1370
1371 cfg80211_wq = alloc_ordered_workqueue("cfg80211", WQ_MEM_RECLAIM);
1372 if (!cfg80211_wq) {
1373 err = -ENOMEM;
1374 goto out_fail_wq;
1375 }
1376
1377 return 0;
1378
1379 out_fail_wq:
1380 regulatory_exit();
1381 out_fail_reg:
1382 debugfs_remove(ieee80211_debugfs_dir);
1383 nl80211_exit();
1384 out_fail_nl80211:
1385 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1386 out_fail_notifier:
1387 wiphy_sysfs_exit();
1388 out_fail_sysfs:
1389 unregister_pernet_device(&cfg80211_pernet_ops);
1390 out_fail_pernet:
1391 return err;
1392 }
1393 fs_initcall(cfg80211_init);
1394
1395 static void __exit cfg80211_exit(void)
1396 {
1397 debugfs_remove(ieee80211_debugfs_dir);
1398 nl80211_exit();
1399 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1400 wiphy_sysfs_exit();
1401 regulatory_exit();
1402 unregister_pernet_device(&cfg80211_pernet_ops);
1403 destroy_workqueue(cfg80211_wq);
1404 }
1405 module_exit(cfg80211_exit);
CRIS linux kernel tree