2 * This is the linux wireless configuration interface.
4 * Copyright 2006-2009 Johannes Berg <johannes@sipsolutions.net>
8 #include <linux/module.h>
10 #include <linux/list.h>
11 #include <linux/nl80211.h>
12 #include <linux/debugfs.h>
13 #include <linux/notifier.h>
14 #include <linux/device.h>
15 #include <linux/etherdevice.h>
16 #include <linux/rtnetlink.h>
17 #include <linux/sched.h>
18 #include <net/genetlink.h>
19 #include <net/cfg80211.h>
24 #include "wext-compat.h"
27 /* name for sysfs, %d is appended */
28 #define PHY_NAME "phy"
30 MODULE_AUTHOR("Johannes Berg");
31 MODULE_LICENSE("GPL");
32 MODULE_DESCRIPTION("wireless configuration support");
34 /* RCU might be appropriate here since we usually
35 * only read the list, and that can happen quite
36 * often because we need to do it for each command */
37 LIST_HEAD(cfg80211_rdev_list
);
38 int cfg80211_rdev_list_generation
;
41 * This is used to protect the cfg80211_rdev_list
43 DEFINE_MUTEX(cfg80211_mutex
);
46 static struct dentry
*ieee80211_debugfs_dir
;
48 /* for the cleanup, scan and event works */
49 struct workqueue_struct
*cfg80211_wq
;
51 /* requires cfg80211_mutex to be held! */
52 struct cfg80211_registered_device
*cfg80211_rdev_by_wiphy_idx(int wiphy_idx
)
54 struct cfg80211_registered_device
*result
= NULL
, *rdev
;
56 if (!wiphy_idx_valid(wiphy_idx
))
59 assert_cfg80211_lock();
61 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
62 if (rdev
->wiphy_idx
== wiphy_idx
) {
71 int get_wiphy_idx(struct wiphy
*wiphy
)
73 struct cfg80211_registered_device
*rdev
;
75 return WIPHY_IDX_STALE
;
76 rdev
= wiphy_to_dev(wiphy
);
77 return rdev
->wiphy_idx
;
80 /* requires cfg80211_rdev_mutex to be held! */
81 struct wiphy
*wiphy_idx_to_wiphy(int wiphy_idx
)
83 struct cfg80211_registered_device
*rdev
;
85 if (!wiphy_idx_valid(wiphy_idx
))
88 assert_cfg80211_lock();
90 rdev
= cfg80211_rdev_by_wiphy_idx(wiphy_idx
);
96 /* requires cfg80211_mutex to be held! */
97 struct cfg80211_registered_device
*
98 __cfg80211_rdev_from_info(struct genl_info
*info
)
101 struct cfg80211_registered_device
*bywiphyidx
= NULL
, *byifidx
= NULL
;
102 struct net_device
*dev
;
105 assert_cfg80211_lock();
107 if (info
->attrs
[NL80211_ATTR_WIPHY
]) {
108 bywiphyidx
= cfg80211_rdev_by_wiphy_idx(
109 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY
]));
113 if (info
->attrs
[NL80211_ATTR_IFINDEX
]) {
114 ifindex
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFINDEX
]);
115 dev
= dev_get_by_index(genl_info_net(info
), ifindex
);
117 if (dev
->ieee80211_ptr
)
119 wiphy_to_dev(dev
->ieee80211_ptr
->wiphy
);
125 if (bywiphyidx
&& byifidx
) {
126 if (bywiphyidx
!= byifidx
)
127 return ERR_PTR(-EINVAL
);
129 return bywiphyidx
; /* == byifidx */
140 struct cfg80211_registered_device
*
141 cfg80211_get_dev_from_info(struct genl_info
*info
)
143 struct cfg80211_registered_device
*rdev
;
145 mutex_lock(&cfg80211_mutex
);
146 rdev
= __cfg80211_rdev_from_info(info
);
148 /* if it is not an error we grab the lock on
149 * it to assure it won't be going away while
150 * we operate on it */
152 mutex_lock(&rdev
->mtx
);
154 mutex_unlock(&cfg80211_mutex
);
159 struct cfg80211_registered_device
*
160 cfg80211_get_dev_from_ifindex(struct net
*net
, int ifindex
)
162 struct cfg80211_registered_device
*rdev
= ERR_PTR(-ENODEV
);
163 struct net_device
*dev
;
165 mutex_lock(&cfg80211_mutex
);
166 dev
= dev_get_by_index(net
, ifindex
);
169 if (dev
->ieee80211_ptr
) {
170 rdev
= wiphy_to_dev(dev
->ieee80211_ptr
->wiphy
);
171 mutex_lock(&rdev
->mtx
);
173 rdev
= ERR_PTR(-ENODEV
);
176 mutex_unlock(&cfg80211_mutex
);
180 /* requires cfg80211_mutex to be held */
181 int cfg80211_dev_rename(struct cfg80211_registered_device
*rdev
,
184 struct cfg80211_registered_device
*rdev2
;
185 int wiphy_idx
, taken
= -1, result
, digits
;
187 assert_cfg80211_lock();
189 /* prohibit calling the thing phy%d when %d is not its number */
190 sscanf(newname
, PHY_NAME
"%d%n", &wiphy_idx
, &taken
);
191 if (taken
== strlen(newname
) && wiphy_idx
!= rdev
->wiphy_idx
) {
192 /* count number of places needed to print wiphy_idx */
194 while (wiphy_idx
/= 10)
197 * deny the name if it is phy<idx> where <idx> is printed
198 * without leading zeroes. taken == strlen(newname) here
200 if (taken
== strlen(PHY_NAME
) + digits
)
205 /* Ignore nop renames */
206 if (strcmp(newname
, dev_name(&rdev
->wiphy
.dev
)) == 0)
209 /* Ensure another device does not already have this name. */
210 list_for_each_entry(rdev2
, &cfg80211_rdev_list
, list
)
211 if (strcmp(newname
, dev_name(&rdev2
->wiphy
.dev
)) == 0)
214 result
= device_rename(&rdev
->wiphy
.dev
, newname
);
218 if (rdev
->wiphy
.debugfsdir
&&
219 !debugfs_rename(rdev
->wiphy
.debugfsdir
->d_parent
,
220 rdev
->wiphy
.debugfsdir
,
221 rdev
->wiphy
.debugfsdir
->d_parent
,
223 printk(KERN_ERR
"cfg80211: failed to rename debugfs dir to %s!\n",
226 nl80211_notify_dev_rename(rdev
);
231 int cfg80211_switch_netns(struct cfg80211_registered_device
*rdev
,
234 struct wireless_dev
*wdev
;
237 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
))
240 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
) {
241 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
242 err
= dev_change_net_namespace(wdev
->netdev
, net
, "wlan%d");
245 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
249 /* failed -- clean up to old netns */
250 net
= wiphy_net(&rdev
->wiphy
);
252 list_for_each_entry_continue_reverse(wdev
, &rdev
->netdev_list
,
254 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
255 err
= dev_change_net_namespace(wdev
->netdev
, net
,
258 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
262 wiphy_net_set(&rdev
->wiphy
, net
);
267 static void cfg80211_rfkill_poll(struct rfkill
*rfkill
, void *data
)
269 struct cfg80211_registered_device
*rdev
= data
;
271 rdev
->ops
->rfkill_poll(&rdev
->wiphy
);
274 static int cfg80211_rfkill_set_block(void *data
, bool blocked
)
276 struct cfg80211_registered_device
*rdev
= data
;
277 struct wireless_dev
*wdev
;
283 mutex_lock(&rdev
->devlist_mtx
);
285 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
)
286 dev_close(wdev
->netdev
);
288 mutex_unlock(&rdev
->devlist_mtx
);
294 static void cfg80211_rfkill_sync_work(struct work_struct
*work
)
296 struct cfg80211_registered_device
*rdev
;
298 rdev
= container_of(work
, struct cfg80211_registered_device
, rfkill_sync
);
299 cfg80211_rfkill_set_block(rdev
, rfkill_blocked(rdev
->rfkill
));
302 static void cfg80211_event_work(struct work_struct
*work
)
304 struct cfg80211_registered_device
*rdev
;
306 rdev
= container_of(work
, struct cfg80211_registered_device
,
310 cfg80211_lock_rdev(rdev
);
312 cfg80211_process_rdev_events(rdev
);
313 cfg80211_unlock_rdev(rdev
);
317 /* exported functions */
319 struct wiphy
*wiphy_new(const struct cfg80211_ops
*ops
, int sizeof_priv
)
321 static int wiphy_counter
;
323 struct cfg80211_registered_device
*rdev
;
326 WARN_ON(ops
->add_key
&& (!ops
->del_key
|| !ops
->set_default_key
));
327 WARN_ON(ops
->auth
&& (!ops
->assoc
|| !ops
->deauth
|| !ops
->disassoc
));
328 WARN_ON(ops
->connect
&& !ops
->disconnect
);
329 WARN_ON(ops
->join_ibss
&& !ops
->leave_ibss
);
330 WARN_ON(ops
->add_virtual_intf
&& !ops
->del_virtual_intf
);
331 WARN_ON(ops
->add_station
&& !ops
->del_station
);
332 WARN_ON(ops
->add_mpath
&& !ops
->del_mpath
);
334 alloc_size
= sizeof(*rdev
) + sizeof_priv
;
336 rdev
= kzalloc(alloc_size
, GFP_KERNEL
);
342 mutex_lock(&cfg80211_mutex
);
344 rdev
->wiphy_idx
= wiphy_counter
++;
346 if (unlikely(!wiphy_idx_valid(rdev
->wiphy_idx
))) {
348 mutex_unlock(&cfg80211_mutex
);
354 mutex_unlock(&cfg80211_mutex
);
356 /* give it a proper name */
357 dev_set_name(&rdev
->wiphy
.dev
, PHY_NAME
"%d", rdev
->wiphy_idx
);
359 mutex_init(&rdev
->mtx
);
360 mutex_init(&rdev
->devlist_mtx
);
361 INIT_LIST_HEAD(&rdev
->netdev_list
);
362 spin_lock_init(&rdev
->bss_lock
);
363 INIT_LIST_HEAD(&rdev
->bss_list
);
364 INIT_WORK(&rdev
->scan_done_wk
, __cfg80211_scan_done
);
366 #ifdef CONFIG_CFG80211_WEXT
367 rdev
->wiphy
.wext
= &cfg80211_wext_handler
;
370 device_initialize(&rdev
->wiphy
.dev
);
371 rdev
->wiphy
.dev
.class = &ieee80211_class
;
372 rdev
->wiphy
.dev
.platform_data
= rdev
;
374 #ifdef CONFIG_CFG80211_DEFAULT_PS
375 rdev
->wiphy
.flags
|= WIPHY_FLAG_PS_ON_BY_DEFAULT
;
378 wiphy_net_set(&rdev
->wiphy
, &init_net
);
380 rdev
->rfkill_ops
.set_block
= cfg80211_rfkill_set_block
;
381 rdev
->rfkill
= rfkill_alloc(dev_name(&rdev
->wiphy
.dev
),
382 &rdev
->wiphy
.dev
, RFKILL_TYPE_WLAN
,
383 &rdev
->rfkill_ops
, rdev
);
390 INIT_WORK(&rdev
->rfkill_sync
, cfg80211_rfkill_sync_work
);
391 INIT_WORK(&rdev
->conn_work
, cfg80211_conn_work
);
392 INIT_WORK(&rdev
->event_work
, cfg80211_event_work
);
394 init_waitqueue_head(&rdev
->dev_wait
);
397 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
398 * Fragmentation and RTS threshold are disabled by default with the
401 rdev
->wiphy
.retry_short
= 7;
402 rdev
->wiphy
.retry_long
= 4;
403 rdev
->wiphy
.frag_threshold
= (u32
) -1;
404 rdev
->wiphy
.rts_threshold
= (u32
) -1;
405 rdev
->wiphy
.coverage_class
= 0;
409 EXPORT_SYMBOL(wiphy_new
);
411 int wiphy_register(struct wiphy
*wiphy
)
413 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
415 enum ieee80211_band band
;
416 struct ieee80211_supported_band
*sband
;
417 bool have_band
= false;
419 u16 ifmodes
= wiphy
->interface_modes
;
421 /* sanity check ifmodes */
423 ifmodes
&= ((1 << __NL80211_IFTYPE_AFTER_LAST
) - 1) & ~1;
424 if (WARN_ON(ifmodes
!= wiphy
->interface_modes
))
425 wiphy
->interface_modes
= ifmodes
;
427 /* sanity check supported bands/channels */
428 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
429 sband
= wiphy
->bands
[band
];
435 if (WARN_ON(!sband
->n_channels
|| !sband
->n_bitrates
))
439 * Since we use a u32 for rate bitmaps in
440 * ieee80211_get_response_rate, we cannot
441 * have more than 32 legacy rates.
443 if (WARN_ON(sband
->n_bitrates
> 32))
446 for (i
= 0; i
< sband
->n_channels
; i
++) {
447 sband
->channels
[i
].orig_flags
=
448 sband
->channels
[i
].flags
;
449 sband
->channels
[i
].orig_mag
=
450 sband
->channels
[i
].max_antenna_gain
;
451 sband
->channels
[i
].orig_mpwr
=
452 sband
->channels
[i
].max_power
;
453 sband
->channels
[i
].band
= band
;
464 /* check and set up bitrates */
465 ieee80211_set_bitrate_flags(wiphy
);
467 res
= device_add(&rdev
->wiphy
.dev
);
471 res
= rfkill_register(rdev
->rfkill
);
475 mutex_lock(&cfg80211_mutex
);
477 /* set up regulatory info */
478 wiphy_update_regulatory(wiphy
, NL80211_REGDOM_SET_BY_CORE
);
480 list_add(&rdev
->list
, &cfg80211_rdev_list
);
481 cfg80211_rdev_list_generation
++;
483 mutex_unlock(&cfg80211_mutex
);
486 rdev
->wiphy
.debugfsdir
=
487 debugfs_create_dir(wiphy_name(&rdev
->wiphy
),
488 ieee80211_debugfs_dir
);
489 if (IS_ERR(rdev
->wiphy
.debugfsdir
))
490 rdev
->wiphy
.debugfsdir
= NULL
;
492 if (wiphy
->flags
& WIPHY_FLAG_CUSTOM_REGULATORY
) {
493 struct regulatory_request request
;
495 request
.wiphy_idx
= get_wiphy_idx(wiphy
);
496 request
.initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
497 request
.alpha2
[0] = '9';
498 request
.alpha2
[1] = '9';
500 nl80211_send_reg_change_event(&request
);
503 cfg80211_debugfs_rdev_add(rdev
);
508 device_del(&rdev
->wiphy
.dev
);
511 EXPORT_SYMBOL(wiphy_register
);
513 void wiphy_rfkill_start_polling(struct wiphy
*wiphy
)
515 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
517 if (!rdev
->ops
->rfkill_poll
)
519 rdev
->rfkill_ops
.poll
= cfg80211_rfkill_poll
;
520 rfkill_resume_polling(rdev
->rfkill
);
522 EXPORT_SYMBOL(wiphy_rfkill_start_polling
);
524 void wiphy_rfkill_stop_polling(struct wiphy
*wiphy
)
526 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
528 rfkill_pause_polling(rdev
->rfkill
);
530 EXPORT_SYMBOL(wiphy_rfkill_stop_polling
);
532 void wiphy_unregister(struct wiphy
*wiphy
)
534 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
536 rfkill_unregister(rdev
->rfkill
);
538 /* protect the device list */
539 mutex_lock(&cfg80211_mutex
);
541 wait_event(rdev
->dev_wait
, ({
543 mutex_lock(&rdev
->devlist_mtx
);
544 __count
= rdev
->opencount
;
545 mutex_unlock(&rdev
->devlist_mtx
);
548 mutex_lock(&rdev
->devlist_mtx
);
549 BUG_ON(!list_empty(&rdev
->netdev_list
));
550 mutex_unlock(&rdev
->devlist_mtx
);
553 * First remove the hardware from everywhere, this makes
554 * it impossible to find from userspace.
556 debugfs_remove_recursive(rdev
->wiphy
.debugfsdir
);
557 list_del(&rdev
->list
);
560 * Try to grab rdev->mtx. If a command is still in progress,
561 * hopefully the driver will refuse it since it's tearing
562 * down the device already. We wait for this command to complete
563 * before unlinking the item from the list.
564 * Note: as codified by the BUG_ON above we cannot get here if
565 * a virtual interface is still present. Hence, we can only get
566 * to lock contention here if userspace issues a command that
567 * identified the hardware by wiphy index.
569 cfg80211_lock_rdev(rdev
);
571 cfg80211_unlock_rdev(rdev
);
573 /* If this device got a regulatory hint tell core its
574 * free to listen now to a new shiny device regulatory hint */
575 reg_device_remove(wiphy
);
577 cfg80211_rdev_list_generation
++;
578 device_del(&rdev
->wiphy
.dev
);
580 mutex_unlock(&cfg80211_mutex
);
582 flush_work(&rdev
->scan_done_wk
);
583 cancel_work_sync(&rdev
->conn_work
);
584 flush_work(&rdev
->event_work
);
586 EXPORT_SYMBOL(wiphy_unregister
);
588 void cfg80211_dev_free(struct cfg80211_registered_device
*rdev
)
590 struct cfg80211_internal_bss
*scan
, *tmp
;
591 rfkill_destroy(rdev
->rfkill
);
592 mutex_destroy(&rdev
->mtx
);
593 mutex_destroy(&rdev
->devlist_mtx
);
594 list_for_each_entry_safe(scan
, tmp
, &rdev
->bss_list
, list
)
595 cfg80211_put_bss(&scan
->pub
);
599 void wiphy_free(struct wiphy
*wiphy
)
601 put_device(&wiphy
->dev
);
603 EXPORT_SYMBOL(wiphy_free
);
605 void wiphy_rfkill_set_hw_state(struct wiphy
*wiphy
, bool blocked
)
607 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
609 if (rfkill_set_hw_state(rdev
->rfkill
, blocked
))
610 schedule_work(&rdev
->rfkill_sync
);
612 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state
);
614 static void wdev_cleanup_work(struct work_struct
*work
)
616 struct wireless_dev
*wdev
;
617 struct cfg80211_registered_device
*rdev
;
619 wdev
= container_of(work
, struct wireless_dev
, cleanup_work
);
620 rdev
= wiphy_to_dev(wdev
->wiphy
);
622 cfg80211_lock_rdev(rdev
);
624 if (WARN_ON(rdev
->scan_req
&& rdev
->scan_req
->dev
== wdev
->netdev
)) {
625 rdev
->scan_req
->aborted
= true;
626 ___cfg80211_scan_done(rdev
, true);
629 cfg80211_unlock_rdev(rdev
);
631 mutex_lock(&rdev
->devlist_mtx
);
633 mutex_unlock(&rdev
->devlist_mtx
);
634 wake_up(&rdev
->dev_wait
);
636 dev_put(wdev
->netdev
);
639 static struct device_type wiphy_type
= {
643 static int cfg80211_netdev_notifier_call(struct notifier_block
* nb
,
647 struct net_device
*dev
= ndev
;
648 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
649 struct cfg80211_registered_device
*rdev
;
654 rdev
= wiphy_to_dev(wdev
->wiphy
);
656 WARN_ON(wdev
->iftype
== NL80211_IFTYPE_UNSPECIFIED
);
659 case NETDEV_POST_INIT
:
660 SET_NETDEV_DEVTYPE(dev
, &wiphy_type
);
662 case NETDEV_REGISTER
:
664 * NB: cannot take rdev->mtx here because this may be
665 * called within code protected by it when interfaces
666 * are added with nl80211.
668 mutex_init(&wdev
->mtx
);
669 INIT_WORK(&wdev
->cleanup_work
, wdev_cleanup_work
);
670 INIT_LIST_HEAD(&wdev
->event_list
);
671 spin_lock_init(&wdev
->event_lock
);
672 mutex_lock(&rdev
->devlist_mtx
);
673 list_add(&wdev
->list
, &rdev
->netdev_list
);
674 rdev
->devlist_generation
++;
675 /* can only change netns with wiphy */
676 dev
->features
|= NETIF_F_NETNS_LOCAL
;
678 if (sysfs_create_link(&dev
->dev
.kobj
, &rdev
->wiphy
.dev
.kobj
,
680 printk(KERN_ERR
"wireless: failed to add phy80211 "
681 "symlink to netdev!\n");
684 wdev
->sme_state
= CFG80211_SME_IDLE
;
685 mutex_unlock(&rdev
->devlist_mtx
);
686 #ifdef CONFIG_CFG80211_WEXT
687 wdev
->wext
.default_key
= -1;
688 wdev
->wext
.default_mgmt_key
= -1;
689 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
690 if (wdev
->wiphy
->flags
& WIPHY_FLAG_PS_ON_BY_DEFAULT
)
691 wdev
->wext
.ps
= true;
693 wdev
->wext
.ps
= false;
694 wdev
->wext
.ps_timeout
= 100;
695 if (rdev
->ops
->set_power_mgmt
)
696 if (rdev
->ops
->set_power_mgmt(wdev
->wiphy
, dev
,
698 wdev
->wext
.ps_timeout
)) {
699 /* assume this means it's off */
700 wdev
->wext
.ps
= false;
703 if (!dev
->ethtool_ops
)
704 dev
->ethtool_ops
= &cfg80211_ethtool_ops
;
706 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
707 wdev
->iftype
== NL80211_IFTYPE_ADHOC
) && !wdev
->use_4addr
)
708 dev
->priv_flags
|= IFF_DONT_BRIDGE
;
710 case NETDEV_GOING_DOWN
:
711 switch (wdev
->iftype
) {
712 case NL80211_IFTYPE_ADHOC
:
713 cfg80211_leave_ibss(rdev
, dev
, true);
715 case NL80211_IFTYPE_STATION
:
717 #ifdef CONFIG_CFG80211_WEXT
718 kfree(wdev
->wext
.ie
);
719 wdev
->wext
.ie
= NULL
;
720 wdev
->wext
.ie_len
= 0;
721 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
723 __cfg80211_disconnect(rdev
, dev
,
724 WLAN_REASON_DEAUTH_LEAVING
, true);
725 cfg80211_mlme_down(rdev
, dev
);
734 queue_work(cfg80211_wq
, &wdev
->cleanup_work
);
738 * If we have a really quick DOWN/UP succession we may
739 * have this work still pending ... cancel it and see
740 * if it was pending, in which case we need to account
741 * for some of the work it would have done.
743 if (cancel_work_sync(&wdev
->cleanup_work
)) {
744 mutex_lock(&rdev
->devlist_mtx
);
746 mutex_unlock(&rdev
->devlist_mtx
);
749 cfg80211_lock_rdev(rdev
);
750 mutex_lock(&rdev
->devlist_mtx
);
751 #ifdef CONFIG_CFG80211_WEXT
753 switch (wdev
->iftype
) {
754 case NL80211_IFTYPE_ADHOC
:
755 cfg80211_ibss_wext_join(rdev
, wdev
);
757 case NL80211_IFTYPE_STATION
:
758 cfg80211_mgd_wext_connect(rdev
, wdev
);
766 mutex_unlock(&rdev
->devlist_mtx
);
767 cfg80211_unlock_rdev(rdev
);
769 case NETDEV_UNREGISTER
:
771 * NB: cannot take rdev->mtx here because this may be
772 * called within code protected by it when interfaces
773 * are removed with nl80211.
775 mutex_lock(&rdev
->devlist_mtx
);
777 * It is possible to get NETDEV_UNREGISTER
778 * multiple times. To detect that, check
779 * that the interface is still on the list
780 * of registered interfaces, and only then
781 * remove and clean it up.
783 if (!list_empty(&wdev
->list
)) {
784 sysfs_remove_link(&dev
->dev
.kobj
, "phy80211");
785 list_del_init(&wdev
->list
);
786 rdev
->devlist_generation
++;
787 #ifdef CONFIG_CFG80211_WEXT
788 kfree(wdev
->wext
.keys
);
791 mutex_unlock(&rdev
->devlist_mtx
);
794 if (!(wdev
->wiphy
->interface_modes
& BIT(wdev
->iftype
)))
795 return notifier_from_errno(-EOPNOTSUPP
);
796 if (rfkill_blocked(rdev
->rfkill
))
797 return notifier_from_errno(-ERFKILL
);
804 static struct notifier_block cfg80211_netdev_notifier
= {
805 .notifier_call
= cfg80211_netdev_notifier_call
,
808 static void __net_exit
cfg80211_pernet_exit(struct net
*net
)
810 struct cfg80211_registered_device
*rdev
;
813 mutex_lock(&cfg80211_mutex
);
814 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
815 if (net_eq(wiphy_net(&rdev
->wiphy
), net
))
816 WARN_ON(cfg80211_switch_netns(rdev
, &init_net
));
818 mutex_unlock(&cfg80211_mutex
);
822 static struct pernet_operations cfg80211_pernet_ops
= {
823 .exit
= cfg80211_pernet_exit
,
826 static int __init
cfg80211_init(void)
830 err
= register_pernet_device(&cfg80211_pernet_ops
);
832 goto out_fail_pernet
;
834 err
= wiphy_sysfs_init();
838 err
= register_netdevice_notifier(&cfg80211_netdev_notifier
);
840 goto out_fail_notifier
;
842 err
= nl80211_init();
844 goto out_fail_nl80211
;
846 ieee80211_debugfs_dir
= debugfs_create_dir("ieee80211", NULL
);
848 err
= regulatory_init();
852 cfg80211_wq
= create_singlethread_workqueue("cfg80211");
861 debugfs_remove(ieee80211_debugfs_dir
);
863 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
867 unregister_pernet_device(&cfg80211_pernet_ops
);
871 subsys_initcall(cfg80211_init
);
873 static void cfg80211_exit(void)
875 debugfs_remove(ieee80211_debugfs_dir
);
877 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
880 unregister_pernet_device(&cfg80211_pernet_ops
);
881 destroy_workqueue(cfg80211_wq
);
883 module_exit(cfg80211_exit
);