1
2
3
4
5
6
7#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8
9#include <linux/if.h>
10#include <linux/module.h>
11#include <linux/err.h>
12#include <linux/list.h>
13#include <linux/slab.h>
14#include <linux/nl80211.h>
15#include <linux/debugfs.h>
16#include <linux/notifier.h>
17#include <linux/device.h>
18#include <linux/etherdevice.h>
19#include <linux/rtnetlink.h>
20#include <linux/sched.h>
21#include <net/genetlink.h>
22#include <net/cfg80211.h>
23#include "nl80211.h"
24#include "core.h"
25#include "sysfs.h"
26#include "debugfs.h"
27#include "wext-compat.h"
28#include "ethtool.h"
29#include "rdev-ops.h"
30
31
32#define PHY_NAME "phy"
33
34MODULE_AUTHOR("Johannes Berg");
35MODULE_LICENSE("GPL");
36MODULE_DESCRIPTION("wireless configuration support");
37
38
39LIST_HEAD(cfg80211_rdev_list);
40int cfg80211_rdev_list_generation;
41
42DEFINE_MUTEX(cfg80211_mutex);
43
44
45static struct dentry *ieee80211_debugfs_dir;
46
47
48struct workqueue_struct *cfg80211_wq;
49
50static bool cfg80211_disable_40mhz_24ghz;
51module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
52MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
53 "Disable 40MHz support in the 2.4GHz band");
54
55
56struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
57{
58 struct cfg80211_registered_device *result = NULL, *rdev;
59
60 assert_cfg80211_lock();
61
62 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
63 if (rdev->wiphy_idx == wiphy_idx) {
64 result = rdev;
65 break;
66 }
67 }
68
69 return result;
70}
71
72int get_wiphy_idx(struct wiphy *wiphy)
73{
74 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
75
76 return rdev->wiphy_idx;
77}
78
79
80struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
81{
82 struct cfg80211_registered_device *rdev;
83
84 assert_cfg80211_lock();
85
86 rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
87 if (!rdev)
88 return NULL;
89 return &rdev->wiphy;
90}
91
92struct cfg80211_registered_device *
93cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
94{
95 struct cfg80211_registered_device *rdev = ERR_PTR(-ENODEV);
96 struct net_device *dev;
97
98 mutex_lock(&cfg80211_mutex);
99 dev = dev_get_by_index(net, ifindex);
100 if (!dev)
101 goto out;
102 if (dev->ieee80211_ptr) {
103 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
104 mutex_lock(&rdev->mtx);
105 } else
106 rdev = ERR_PTR(-ENODEV);
107 dev_put(dev);
108 out:
109 mutex_unlock(&cfg80211_mutex);
110 return rdev;
111}
112
113
114int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
115 char *newname)
116{
117 struct cfg80211_registered_device *rdev2;
118 int wiphy_idx, taken = -1, result, digits;
119
120 assert_cfg80211_lock();
121
122
123 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
124 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
125
126 digits = 1;
127 while (wiphy_idx /= 10)
128 digits++;
129
130
131
132
133 if (taken == strlen(PHY_NAME) + digits)
134 return -EINVAL;
135 }
136
137
138
139 if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
140 return 0;
141
142
143 list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
144 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0)
145 return -EINVAL;
146
147 result = device_rename(&rdev->wiphy.dev, newname);
148 if (result)
149 return result;
150
151 if (rdev->wiphy.debugfsdir &&
152 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
153 rdev->wiphy.debugfsdir,
154 rdev->wiphy.debugfsdir->d_parent,
155 newname))
156 pr_err("failed to rename debugfs dir to %s!\n", newname);
157
158 nl80211_notify_dev_rename(rdev);
159
160 return 0;
161}
162
163int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
164 struct net *net)
165{
166 struct wireless_dev *wdev;
167 int err = 0;
168
169 if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
170 return -EOPNOTSUPP;
171
172 list_for_each_entry(wdev, &rdev->wdev_list, list) {
173 if (!wdev->netdev)
174 continue;
175 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
176 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
177 if (err)
178 break;
179 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
180 }
181
182 if (err) {
183
184 net = wiphy_net(&rdev->wiphy);
185
186 list_for_each_entry_continue_reverse(wdev, &rdev->wdev_list,
187 list) {
188 if (!wdev->netdev)
189 continue;
190 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
191 err = dev_change_net_namespace(wdev->netdev, net,
192 "wlan%d");
193 WARN_ON(err);
194 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
195 }
196
197 return err;
198 }
199
200 wiphy_net_set(&rdev->wiphy, net);
201
202 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
203 WARN_ON(err);
204
205 return 0;
206}
207
208static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
209{
210 struct cfg80211_registered_device *rdev = data;
211
212 rdev_rfkill_poll(rdev);
213}
214
215void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
216 struct wireless_dev *wdev)
217{
218 lockdep_assert_held(&rdev->devlist_mtx);
219 lockdep_assert_held(&rdev->sched_scan_mtx);
220
221 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
222 return;
223
224 if (!wdev->p2p_started)
225 return;
226
227 rdev_stop_p2p_device(rdev, wdev);
228 wdev->p2p_started = false;
229
230 rdev->opencount--;
231
232 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
233 bool busy = work_busy(&rdev->scan_done_wk);
234
235
236
237
238
239
240
241 WARN_ON(!busy);
242
243 rdev->scan_req->aborted = true;
244 ___cfg80211_scan_done(rdev, !busy);
245 }
246}
247
248static int cfg80211_rfkill_set_block(void *data, bool blocked)
249{
250 struct cfg80211_registered_device *rdev = data;
251 struct wireless_dev *wdev;
252
253 if (!blocked)
254 return 0;
255
256 rtnl_lock();
257
258
259
260 list_for_each_entry(wdev, &rdev->wdev_list, list) {
261 if (wdev->netdev) {
262 dev_close(wdev->netdev);
263 continue;
264 }
265
266 switch (wdev->iftype) {
267 case NL80211_IFTYPE_P2P_DEVICE:
268
269 mutex_lock(&rdev->devlist_mtx);
270 mutex_lock(&rdev->sched_scan_mtx);
271 cfg80211_stop_p2p_device(rdev, wdev);
272 mutex_unlock(&rdev->sched_scan_mtx);
273 mutex_unlock(&rdev->devlist_mtx);
274 break;
275 default:
276 break;
277 }
278 }
279
280 rtnl_unlock();
281
282 return 0;
283}
284
285static void cfg80211_rfkill_sync_work(struct work_struct *work)
286{
287 struct cfg80211_registered_device *rdev;
288
289 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
290 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
291}
292
293static void cfg80211_event_work(struct work_struct *work)
294{
295 struct cfg80211_registered_device *rdev;
296
297 rdev = container_of(work, struct cfg80211_registered_device,
298 event_work);
299
300 rtnl_lock();
301 cfg80211_lock_rdev(rdev);
302
303 cfg80211_process_rdev_events(rdev);
304 cfg80211_unlock_rdev(rdev);
305 rtnl_unlock();
306}
307
308
309
310struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
311{
312 static int wiphy_counter;
313
314 struct cfg80211_registered_device *rdev;
315 int alloc_size;
316
317 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
318 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
319 WARN_ON(ops->connect && !ops->disconnect);
320 WARN_ON(ops->join_ibss && !ops->leave_ibss);
321 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
322 WARN_ON(ops->add_station && !ops->del_station);
323 WARN_ON(ops->add_mpath && !ops->del_mpath);
324 WARN_ON(ops->join_mesh && !ops->leave_mesh);
325
326 alloc_size = sizeof(*rdev) + sizeof_priv;
327
328 rdev = kzalloc(alloc_size, GFP_KERNEL);
329 if (!rdev)
330 return NULL;
331
332 rdev->ops = ops;
333
334 mutex_lock(&cfg80211_mutex);
335
336 rdev->wiphy_idx = wiphy_counter++;
337
338 if (unlikely(rdev->wiphy_idx < 0)) {
339 wiphy_counter--;
340 mutex_unlock(&cfg80211_mutex);
341
342 kfree(rdev);
343 return NULL;
344 }
345
346 mutex_unlock(&cfg80211_mutex);
347
348
349 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
350
351 mutex_init(&rdev->mtx);
352 mutex_init(&rdev->devlist_mtx);
353 mutex_init(&rdev->sched_scan_mtx);
354 INIT_LIST_HEAD(&rdev->wdev_list);
355 INIT_LIST_HEAD(&rdev->beacon_registrations);
356 spin_lock_init(&rdev->beacon_registrations_lock);
357 spin_lock_init(&rdev->bss_lock);
358 INIT_LIST_HEAD(&rdev->bss_list);
359 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
360 INIT_WORK(&rdev->sched_scan_results_wk, __cfg80211_sched_scan_results);
361 INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
362 cfg80211_dfs_channels_update_work);
363#ifdef CONFIG_CFG80211_WEXT
364 rdev->wiphy.wext = &cfg80211_wext_handler;
365#endif
366
367 device_initialize(&rdev->wiphy.dev);
368 rdev->wiphy.dev.class = &ieee80211_class;
369 rdev->wiphy.dev.platform_data = rdev;
370
371#ifdef CONFIG_CFG80211_DEFAULT_PS
372 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
373#endif
374
375 wiphy_net_set(&rdev->wiphy, &init_net);
376
377 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
378 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
379 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
380 &rdev->rfkill_ops, rdev);
381
382 if (!rdev->rfkill) {
383 kfree(rdev);
384 return NULL;
385 }
386
387 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
388 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
389 INIT_WORK(&rdev->event_work, cfg80211_event_work);
390
391 init_waitqueue_head(&rdev->dev_wait);
392
393
394
395
396
397
398 rdev->wiphy.retry_short = 7;
399 rdev->wiphy.retry_long = 4;
400 rdev->wiphy.frag_threshold = (u32) -1;
401 rdev->wiphy.rts_threshold = (u32) -1;
402 rdev->wiphy.coverage_class = 0;
403
404 rdev->wiphy.features = NL80211_FEATURE_SCAN_FLUSH;
405
406 return &rdev->wiphy;
407}
408EXPORT_SYMBOL(wiphy_new);
409
410static int wiphy_verify_combinations(struct wiphy *wiphy)
411{
412 const struct ieee80211_iface_combination *c;
413 int i, j;
414
415 for (i = 0; i < wiphy->n_iface_combinations; i++) {
416 u32 cnt = 0;
417 u16 all_iftypes = 0;
418
419 c = &wiphy->iface_combinations[i];
420
421
422
423
424
425 if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
426 return -EINVAL;
427
428
429 if (WARN_ON(!c->num_different_channels))
430 return -EINVAL;
431
432
433
434
435
436 if (WARN_ON(c->num_different_channels >
437 CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
438 return -EINVAL;
439
440
441 if (WARN_ON(c->radar_detect_widths &&
442 (c->num_different_channels > 1)))
443 return -EINVAL;
444
445 if (WARN_ON(!c->n_limits))
446 return -EINVAL;
447
448 for (j = 0; j < c->n_limits; j++) {
449 u16 types = c->limits[j].types;
450
451
452
453
454
455 if (WARN_ON(types & all_iftypes))
456 return -EINVAL;
457 all_iftypes |= types;
458
459 if (WARN_ON(!c->limits[j].max))
460 return -EINVAL;
461
462
463 if (WARN_ON(wiphy->software_iftypes & types))
464 return -EINVAL;
465
466
467 if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
468 c->limits[j].max > 1))
469 return -EINVAL;
470
471 cnt += c->limits[j].max;
472
473
474
475
476 if (WARN_ON((wiphy->interface_modes & types) != types))
477 return -EINVAL;
478 }
479
480
481 if (WARN_ON(cnt < c->max_interfaces))
482 return -EINVAL;
483 }
484
485 return 0;
486}
487
488int wiphy_register(struct wiphy *wiphy)
489{
490 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
491 int res;
492 enum ieee80211_band band;
493 struct ieee80211_supported_band *sband;
494 bool have_band = false;
495 int i;
496 u16 ifmodes = wiphy->interface_modes;
497
498#ifdef CONFIG_PM
499 if (WARN_ON((wiphy->wowlan.flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
500 !(wiphy->wowlan.flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
501 return -EINVAL;
502#endif
503
504 if (WARN_ON(wiphy->ap_sme_capa &&
505 !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
506 return -EINVAL;
507
508 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
509 return -EINVAL;
510
511 if (WARN_ON(wiphy->addresses &&
512 !is_zero_ether_addr(wiphy->perm_addr) &&
513 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
514 ETH_ALEN)))
515 return -EINVAL;
516
517 if (WARN_ON(wiphy->max_acl_mac_addrs &&
518 (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
519 !rdev->ops->set_mac_acl)))
520 return -EINVAL;
521
522 if (wiphy->addresses)
523 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
524
525
526 WARN_ON(!ifmodes);
527 ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
528 if (WARN_ON(ifmodes != wiphy->interface_modes))
529 wiphy->interface_modes = ifmodes;
530
531 res = wiphy_verify_combinations(wiphy);
532 if (res)
533 return res;
534
535
536 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
537 sband = wiphy->bands[band];
538 if (!sband)
539 continue;
540
541 sband->band = band;
542 if (WARN_ON(!sband->n_channels))
543 return -EINVAL;
544
545
546
547
548 if (WARN_ON(band != IEEE80211_BAND_60GHZ &&
549 !sband->n_bitrates))
550 return -EINVAL;
551
552
553
554
555
556
557 if (cfg80211_disable_40mhz_24ghz &&
558 band == IEEE80211_BAND_2GHZ &&
559 sband->ht_cap.ht_supported) {
560 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
561 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
562 }
563
564
565
566
567
568
569 if (WARN_ON(sband->n_bitrates > 32))
570 return -EINVAL;
571
572 for (i = 0; i < sband->n_channels; i++) {
573 sband->channels[i].orig_flags =
574 sband->channels[i].flags;
575 sband->channels[i].orig_mag = INT_MAX;
576 sband->channels[i].orig_mpwr =
577 sband->channels[i].max_power;
578 sband->channels[i].band = band;
579 }
580
581 have_band = true;
582 }
583
584 if (!have_band) {
585 WARN_ON(1);
586 return -EINVAL;
587 }
588
589#ifdef CONFIG_PM
590 if (rdev->wiphy.wowlan.n_patterns) {
591 if (WARN_ON(!rdev->wiphy.wowlan.pattern_min_len ||
592 rdev->wiphy.wowlan.pattern_min_len >
593 rdev->wiphy.wowlan.pattern_max_len))
594 return -EINVAL;
595 }
596#endif
597
598
599 ieee80211_set_bitrate_flags(wiphy);
600
601 mutex_lock(&cfg80211_mutex);
602
603 res = device_add(&rdev->wiphy.dev);
604 if (res) {
605 mutex_unlock(&cfg80211_mutex);
606 return res;
607 }
608
609
610 wiphy_regulatory_register(wiphy);
611
612 list_add_rcu(&rdev->list, &cfg80211_rdev_list);
613 cfg80211_rdev_list_generation++;
614
615
616 rdev->wiphy.debugfsdir =
617 debugfs_create_dir(wiphy_name(&rdev->wiphy),
618 ieee80211_debugfs_dir);
619 if (IS_ERR(rdev->wiphy.debugfsdir))
620 rdev->wiphy.debugfsdir = NULL;
621
622 if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
623 struct regulatory_request request;
624
625 request.wiphy_idx = get_wiphy_idx(wiphy);
626 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
627 request.alpha2[0] = '9';
628 request.alpha2[1] = '9';
629
630 nl80211_send_reg_change_event(&request);
631 }
632
633 cfg80211_debugfs_rdev_add(rdev);
634 mutex_unlock(&cfg80211_mutex);
635
636
637
638
639
640 res = rfkill_register(rdev->rfkill);
641 if (res) {
642 device_del(&rdev->wiphy.dev);
643
644 mutex_lock(&cfg80211_mutex);
645 debugfs_remove_recursive(rdev->wiphy.debugfsdir);
646 list_del_rcu(&rdev->list);
647 wiphy_regulatory_deregister(wiphy);
648 mutex_unlock(&cfg80211_mutex);
649 return res;
650 }
651
652 rtnl_lock();
653 rdev->wiphy.registered = true;
654 rtnl_unlock();
655 return 0;
656}
657EXPORT_SYMBOL(wiphy_register);
658
659void wiphy_rfkill_start_polling(struct wiphy *wiphy)
660{
661 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
662
663 if (!rdev->ops->rfkill_poll)
664 return;
665 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
666 rfkill_resume_polling(rdev->rfkill);
667}
668EXPORT_SYMBOL(wiphy_rfkill_start_polling);
669
670void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
671{
672 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
673
674 rfkill_pause_polling(rdev->rfkill);
675}
676EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
677
678void wiphy_unregister(struct wiphy *wiphy)
679{
680 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
681
682 rtnl_lock();
683 rdev->wiphy.registered = false;
684 rtnl_unlock();
685
686 rfkill_unregister(rdev->rfkill);
687
688
689 mutex_lock(&cfg80211_mutex);
690
691 wait_event(rdev->dev_wait, ({
692 int __count;
693 mutex_lock(&rdev->devlist_mtx);
694 __count = rdev->opencount;
695 mutex_unlock(&rdev->devlist_mtx);
696 __count == 0; }));
697
698 mutex_lock(&rdev->devlist_mtx);
699 BUG_ON(!list_empty(&rdev->wdev_list));
700 mutex_unlock(&rdev->devlist_mtx);
701
702
703
704
705
706 debugfs_remove_recursive(rdev->wiphy.debugfsdir);
707 list_del_rcu(&rdev->list);
708 synchronize_rcu();
709
710
711
712
713
714
715
716
717
718
719
720 cfg80211_lock_rdev(rdev);
721
722 cfg80211_unlock_rdev(rdev);
723
724
725
726
727
728 wiphy_regulatory_deregister(wiphy);
729
730 cfg80211_rdev_list_generation++;
731 device_del(&rdev->wiphy.dev);
732
733 mutex_unlock(&cfg80211_mutex);
734
735 flush_work(&rdev->scan_done_wk);
736 cancel_work_sync(&rdev->conn_work);
737 flush_work(&rdev->event_work);
738 cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
739
740 if (rdev->wowlan && rdev->ops->set_wakeup)
741 rdev_set_wakeup(rdev, false);
742 cfg80211_rdev_free_wowlan(rdev);
743}
744EXPORT_SYMBOL(wiphy_unregister);
745
746void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
747{
748 struct cfg80211_internal_bss *scan, *tmp;
749 struct cfg80211_beacon_registration *reg, *treg;
750 rfkill_destroy(rdev->rfkill);
751 mutex_destroy(&rdev->mtx);
752 mutex_destroy(&rdev->devlist_mtx);
753 mutex_destroy(&rdev->sched_scan_mtx);
754 list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
755 list_del(®->list);
756 kfree(reg);
757 }
758 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
759 cfg80211_put_bss(&rdev->wiphy, &scan->pub);
760 kfree(rdev);
761}
762
763void wiphy_free(struct wiphy *wiphy)
764{
765 put_device(&wiphy->dev);
766}
767EXPORT_SYMBOL(wiphy_free);
768
769void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
770{
771 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
772
773 if (rfkill_set_hw_state(rdev->rfkill, blocked))
774 schedule_work(&rdev->rfkill_sync);
775}
776EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
777
778static void wdev_cleanup_work(struct work_struct *work)
779{
780 struct wireless_dev *wdev;
781 struct cfg80211_registered_device *rdev;
782
783 wdev = container_of(work, struct wireless_dev, cleanup_work);
784 rdev = wiphy_to_dev(wdev->wiphy);
785
786 mutex_lock(&rdev->sched_scan_mtx);
787
788 if (WARN_ON(rdev->scan_req && rdev->scan_req->wdev == wdev)) {
789 rdev->scan_req->aborted = true;
790 ___cfg80211_scan_done(rdev, true);
791 }
792
793 if (WARN_ON(rdev->sched_scan_req &&
794 rdev->sched_scan_req->dev == wdev->netdev)) {
795 __cfg80211_stop_sched_scan(rdev, false);
796 }
797
798 mutex_unlock(&rdev->sched_scan_mtx);
799
800 mutex_lock(&rdev->devlist_mtx);
801 rdev->opencount--;
802 mutex_unlock(&rdev->devlist_mtx);
803 wake_up(&rdev->dev_wait);
804
805 dev_put(wdev->netdev);
806}
807
808void cfg80211_unregister_wdev(struct wireless_dev *wdev)
809{
810 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
811
812 ASSERT_RTNL();
813
814 if (WARN_ON(wdev->netdev))
815 return;
816
817 mutex_lock(&rdev->devlist_mtx);
818 mutex_lock(&rdev->sched_scan_mtx);
819 list_del_rcu(&wdev->list);
820 rdev->devlist_generation++;
821
822 switch (wdev->iftype) {
823 case NL80211_IFTYPE_P2P_DEVICE:
824 cfg80211_stop_p2p_device(rdev, wdev);
825 break;
826 default:
827 WARN_ON_ONCE(1);
828 break;
829 }
830 mutex_unlock(&rdev->sched_scan_mtx);
831 mutex_unlock(&rdev->devlist_mtx);
832}
833EXPORT_SYMBOL(cfg80211_unregister_wdev);
834
835static struct device_type wiphy_type = {
836 .name = "wlan",
837};
838
839void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
840 enum nl80211_iftype iftype, int num)
841{
842 ASSERT_RTNL();
843
844 rdev->num_running_ifaces += num;
845 if (iftype == NL80211_IFTYPE_MONITOR)
846 rdev->num_running_monitor_ifaces += num;
847}
848
849void cfg80211_leave(struct cfg80211_registered_device *rdev,
850 struct wireless_dev *wdev)
851{
852 struct net_device *dev = wdev->netdev;
853
854 switch (wdev->iftype) {
855 case NL80211_IFTYPE_ADHOC:
856 cfg80211_leave_ibss(rdev, dev, true);
857 break;
858 case NL80211_IFTYPE_P2P_CLIENT:
859 case NL80211_IFTYPE_STATION:
860 mutex_lock(&rdev->sched_scan_mtx);
861 __cfg80211_stop_sched_scan(rdev, false);
862 mutex_unlock(&rdev->sched_scan_mtx);
863
864 wdev_lock(wdev);
865#ifdef CONFIG_CFG80211_WEXT
866 kfree(wdev->wext.ie);
867 wdev->wext.ie = NULL;
868 wdev->wext.ie_len = 0;
869 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
870#endif
871 __cfg80211_disconnect(rdev, dev,
872 WLAN_REASON_DEAUTH_LEAVING, true);
873 wdev_unlock(wdev);
874 break;
875 case NL80211_IFTYPE_MESH_POINT:
876 cfg80211_leave_mesh(rdev, dev);
877 break;
878 case NL80211_IFTYPE_AP:
879 cfg80211_stop_ap(rdev, dev);
880 break;
881 default:
882 break;
883 }
884
885 wdev->beacon_interval = 0;
886}
887
888static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
889 unsigned long state,
890 void *ndev)
891{
892 struct net_device *dev = ndev;
893 struct wireless_dev *wdev = dev->ieee80211_ptr;
894 struct cfg80211_registered_device *rdev;
895 int ret;
896
897 if (!wdev)
898 return NOTIFY_DONE;
899
900 rdev = wiphy_to_dev(wdev->wiphy);
901
902 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
903
904 switch (state) {
905 case NETDEV_POST_INIT:
906 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
907 break;
908 case NETDEV_REGISTER:
909
910
911
912
913
914 mutex_init(&wdev->mtx);
915 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
916 INIT_LIST_HEAD(&wdev->event_list);
917 spin_lock_init(&wdev->event_lock);
918 INIT_LIST_HEAD(&wdev->mgmt_registrations);
919 spin_lock_init(&wdev->mgmt_registrations_lock);
920
921 mutex_lock(&rdev->devlist_mtx);
922 wdev->identifier = ++rdev->wdev_id;
923 list_add_rcu(&wdev->list, &rdev->wdev_list);
924 rdev->devlist_generation++;
925
926 dev->features |= NETIF_F_NETNS_LOCAL;
927
928 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
929 "phy80211")) {
930 pr_err("failed to add phy80211 symlink to netdev!\n");
931 }
932 wdev->netdev = dev;
933 wdev->sme_state = CFG80211_SME_IDLE;
934 mutex_unlock(&rdev->devlist_mtx);
935#ifdef CONFIG_CFG80211_WEXT
936 wdev->wext.default_key = -1;
937 wdev->wext.default_mgmt_key = -1;
938 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
939#endif
940
941 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
942 wdev->ps = true;
943 else
944 wdev->ps = false;
945
946 wdev->ps_timeout = -1;
947
948 netdev_set_default_ethtool_ops(dev, &cfg80211_ethtool_ops);
949
950 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
951 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
952 wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
953 dev->priv_flags |= IFF_DONT_BRIDGE;
954 break;
955 case NETDEV_GOING_DOWN:
956 cfg80211_leave(rdev, wdev);
957 break;
958 case NETDEV_DOWN:
959 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
960 dev_hold(dev);
961 queue_work(cfg80211_wq, &wdev->cleanup_work);
962 break;
963 case NETDEV_UP:
964
965
966
967
968
969
970 if (cancel_work_sync(&wdev->cleanup_work)) {
971 mutex_lock(&rdev->devlist_mtx);
972 rdev->opencount--;
973 mutex_unlock(&rdev->devlist_mtx);
974 dev_put(dev);
975 }
976 cfg80211_update_iface_num(rdev, wdev->iftype, 1);
977 cfg80211_lock_rdev(rdev);
978 mutex_lock(&rdev->devlist_mtx);
979 mutex_lock(&rdev->sched_scan_mtx);
980 wdev_lock(wdev);
981 switch (wdev->iftype) {
982#ifdef CONFIG_CFG80211_WEXT
983 case NL80211_IFTYPE_ADHOC:
984 cfg80211_ibss_wext_join(rdev, wdev);
985 break;
986 case NL80211_IFTYPE_STATION:
987 cfg80211_mgd_wext_connect(rdev, wdev);
988 break;
989#endif
990#ifdef CONFIG_MAC80211_MESH
991 case NL80211_IFTYPE_MESH_POINT:
992 {
993
994 struct mesh_setup setup;
995 memcpy(&setup, &default_mesh_setup,
996 sizeof(setup));
997
998 setup.mesh_id = wdev->ssid;
999 setup.mesh_id_len = wdev->mesh_id_up_len;
1000 if (wdev->mesh_id_up_len)
1001 __cfg80211_join_mesh(rdev, dev,
1002 &setup,
1003 &default_mesh_config);
1004 break;
1005 }
1006#endif
1007 default:
1008 break;
1009 }
1010 wdev_unlock(wdev);
1011 mutex_unlock(&rdev->sched_scan_mtx);
1012 rdev->opencount++;
1013 mutex_unlock(&rdev->devlist_mtx);
1014 cfg80211_unlock_rdev(rdev);
1015
1016
1017
1018
1019
1020 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1021 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
1022 rdev->ops->set_power_mgmt)
1023 if (rdev_set_power_mgmt(rdev, dev, wdev->ps,
1024 wdev->ps_timeout)) {
1025
1026 wdev->ps = false;
1027 }
1028 break;
1029 case NETDEV_UNREGISTER:
1030
1031
1032
1033
1034
1035 mutex_lock(&rdev->devlist_mtx);
1036
1037
1038
1039
1040
1041
1042
1043 if (!list_empty(&wdev->list)) {
1044 sysfs_remove_link(&dev->dev.kobj, "phy80211");
1045 list_del_rcu(&wdev->list);
1046 rdev->devlist_generation++;
1047 cfg80211_mlme_purge_registrations(wdev);
1048#ifdef CONFIG_CFG80211_WEXT
1049 kfree(wdev->wext.keys);
1050#endif
1051 }
1052 mutex_unlock(&rdev->devlist_mtx);
1053
1054
1055
1056
1057
1058
1059 synchronize_rcu();
1060 INIT_LIST_HEAD(&wdev->list);
1061
1062
1063
1064
1065 cfg80211_process_wdev_events(wdev);
1066 break;
1067 case NETDEV_PRE_UP:
1068 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
1069 return notifier_from_errno(-EOPNOTSUPP);
1070 if (rfkill_blocked(rdev->rfkill))
1071 return notifier_from_errno(-ERFKILL);
1072 mutex_lock(&rdev->devlist_mtx);
1073 ret = cfg80211_can_add_interface(rdev, wdev->iftype);
1074 mutex_unlock(&rdev->devlist_mtx);
1075 if (ret)
1076 return notifier_from_errno(ret);
1077 break;
1078 }
1079
1080 return NOTIFY_DONE;
1081}
1082
1083static struct notifier_block cfg80211_netdev_notifier = {
1084 .notifier_call = cfg80211_netdev_notifier_call,
1085};
1086
1087static void __net_exit cfg80211_pernet_exit(struct net *net)
1088{
1089 struct cfg80211_registered_device *rdev;
1090
1091 rtnl_lock();
1092 mutex_lock(&cfg80211_mutex);
1093 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1094 if (net_eq(wiphy_net(&rdev->wiphy), net))
1095 WARN_ON(cfg80211_switch_netns(rdev, &init_net));
1096 }
1097 mutex_unlock(&cfg80211_mutex);
1098 rtnl_unlock();
1099}
1100
1101static struct pernet_operations cfg80211_pernet_ops = {
1102 .exit = cfg80211_pernet_exit,
1103};
1104
1105static int __init cfg80211_init(void)
1106{
1107 int err;
1108
1109 err = register_pernet_device(&cfg80211_pernet_ops);
1110 if (err)
1111 goto out_fail_pernet;
1112
1113 err = wiphy_sysfs_init();
1114 if (err)
1115 goto out_fail_sysfs;
1116
1117 err = register_netdevice_notifier(&cfg80211_netdev_notifier);
1118 if (err)
1119 goto out_fail_notifier;
1120
1121 err = nl80211_init();
1122 if (err)
1123 goto out_fail_nl80211;
1124
1125 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
1126
1127 err = regulatory_init();
1128 if (err)
1129 goto out_fail_reg;
1130
1131 cfg80211_wq = create_singlethread_workqueue("cfg80211");
1132 if (!cfg80211_wq) {
1133 err = -ENOMEM;
1134 goto out_fail_wq;
1135 }
1136
1137 return 0;
1138
1139out_fail_wq:
1140 regulatory_exit();
1141out_fail_reg:
1142 debugfs_remove(ieee80211_debugfs_dir);
1143out_fail_nl80211:
1144 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1145out_fail_notifier:
1146 wiphy_sysfs_exit();
1147out_fail_sysfs:
1148 unregister_pernet_device(&cfg80211_pernet_ops);
1149out_fail_pernet:
1150 return err;
1151}
1152subsys_initcall(cfg80211_init);
1153
1154static void __exit cfg80211_exit(void)
1155{
1156 debugfs_remove(ieee80211_debugfs_dir);
1157 nl80211_exit();
1158 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1159 wiphy_sysfs_exit();
1160 regulatory_exit();
1161 unregister_pernet_device(&cfg80211_pernet_ops);
1162 destroy_workqueue(cfg80211_wq);
1163}
1164module_exit(cfg80211_exit);
1165