2 * This is the linux wireless configuration interface.
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
8 #include <linux/module.h>
10 #include <linux/list.h>
11 #include <linux/slab.h>
12 #include <linux/nl80211.h>
13 #include <linux/debugfs.h>
14 #include <linux/notifier.h>
15 #include <linux/device.h>
16 #include <linux/etherdevice.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/sched.h>
19 #include <net/genetlink.h>
20 #include <net/cfg80211.h>
25 #include "wext-compat.h"
28 /* name for sysfs, %d is appended */
29 #define PHY_NAME "phy"
31 MODULE_AUTHOR("Johannes Berg");
32 MODULE_LICENSE("GPL");
33 MODULE_DESCRIPTION("wireless configuration support");
35 /* RCU-protected (and cfg80211_mutex for writers) */
36 LIST_HEAD(cfg80211_rdev_list
);
37 int cfg80211_rdev_list_generation
;
39 DEFINE_MUTEX(cfg80211_mutex
);
42 static struct dentry
*ieee80211_debugfs_dir
;
44 /* for the cleanup, scan and event works */
45 struct workqueue_struct
*cfg80211_wq
;
47 /* requires cfg80211_mutex to be held! */
48 struct cfg80211_registered_device
*cfg80211_rdev_by_wiphy_idx(int wiphy_idx
)
50 struct cfg80211_registered_device
*result
= NULL
, *rdev
;
52 if (!wiphy_idx_valid(wiphy_idx
))
55 assert_cfg80211_lock();
57 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
58 if (rdev
->wiphy_idx
== wiphy_idx
) {
67 int get_wiphy_idx(struct wiphy
*wiphy
)
69 struct cfg80211_registered_device
*rdev
;
71 return WIPHY_IDX_STALE
;
72 rdev
= wiphy_to_dev(wiphy
);
73 return rdev
->wiphy_idx
;
76 /* requires cfg80211_rdev_mutex to be held! */
77 struct wiphy
*wiphy_idx_to_wiphy(int wiphy_idx
)
79 struct cfg80211_registered_device
*rdev
;
81 if (!wiphy_idx_valid(wiphy_idx
))
84 assert_cfg80211_lock();
86 rdev
= cfg80211_rdev_by_wiphy_idx(wiphy_idx
);
92 /* requires cfg80211_mutex to be held! */
93 struct cfg80211_registered_device
*
94 __cfg80211_rdev_from_info(struct genl_info
*info
)
97 struct cfg80211_registered_device
*bywiphyidx
= NULL
, *byifidx
= NULL
;
98 struct net_device
*dev
;
101 assert_cfg80211_lock();
103 if (info
->attrs
[NL80211_ATTR_WIPHY
]) {
104 bywiphyidx
= cfg80211_rdev_by_wiphy_idx(
105 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY
]));
109 if (info
->attrs
[NL80211_ATTR_IFINDEX
]) {
110 ifindex
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFINDEX
]);
111 dev
= dev_get_by_index(genl_info_net(info
), ifindex
);
113 if (dev
->ieee80211_ptr
)
115 wiphy_to_dev(dev
->ieee80211_ptr
->wiphy
);
121 if (bywiphyidx
&& byifidx
) {
122 if (bywiphyidx
!= byifidx
)
123 return ERR_PTR(-EINVAL
);
125 return bywiphyidx
; /* == byifidx */
136 struct cfg80211_registered_device
*
137 cfg80211_get_dev_from_info(struct genl_info
*info
)
139 struct cfg80211_registered_device
*rdev
;
141 mutex_lock(&cfg80211_mutex
);
142 rdev
= __cfg80211_rdev_from_info(info
);
144 /* if it is not an error we grab the lock on
145 * it to assure it won't be going away while
146 * we operate on it */
148 mutex_lock(&rdev
->mtx
);
150 mutex_unlock(&cfg80211_mutex
);
155 struct cfg80211_registered_device
*
156 cfg80211_get_dev_from_ifindex(struct net
*net
, int ifindex
)
158 struct cfg80211_registered_device
*rdev
= ERR_PTR(-ENODEV
);
159 struct net_device
*dev
;
161 mutex_lock(&cfg80211_mutex
);
162 dev
= dev_get_by_index(net
, ifindex
);
165 if (dev
->ieee80211_ptr
) {
166 rdev
= wiphy_to_dev(dev
->ieee80211_ptr
->wiphy
);
167 mutex_lock(&rdev
->mtx
);
169 rdev
= ERR_PTR(-ENODEV
);
172 mutex_unlock(&cfg80211_mutex
);
176 /* requires cfg80211_mutex to be held */
177 int cfg80211_dev_rename(struct cfg80211_registered_device
*rdev
,
180 struct cfg80211_registered_device
*rdev2
;
181 int wiphy_idx
, taken
= -1, result
, digits
;
183 assert_cfg80211_lock();
185 /* prohibit calling the thing phy%d when %d is not its number */
186 sscanf(newname
, PHY_NAME
"%d%n", &wiphy_idx
, &taken
);
187 if (taken
== strlen(newname
) && wiphy_idx
!= rdev
->wiphy_idx
) {
188 /* count number of places needed to print wiphy_idx */
190 while (wiphy_idx
/= 10)
193 * deny the name if it is phy<idx> where <idx> is printed
194 * without leading zeroes. taken == strlen(newname) here
196 if (taken
== strlen(PHY_NAME
) + digits
)
201 /* Ignore nop renames */
202 if (strcmp(newname
, dev_name(&rdev
->wiphy
.dev
)) == 0)
205 /* Ensure another device does not already have this name. */
206 list_for_each_entry(rdev2
, &cfg80211_rdev_list
, list
)
207 if (strcmp(newname
, dev_name(&rdev2
->wiphy
.dev
)) == 0)
210 result
= device_rename(&rdev
->wiphy
.dev
, newname
);
214 if (rdev
->wiphy
.debugfsdir
&&
215 !debugfs_rename(rdev
->wiphy
.debugfsdir
->d_parent
,
216 rdev
->wiphy
.debugfsdir
,
217 rdev
->wiphy
.debugfsdir
->d_parent
,
219 printk(KERN_ERR
"cfg80211: failed to rename debugfs dir to %s!\n",
222 nl80211_notify_dev_rename(rdev
);
227 int cfg80211_switch_netns(struct cfg80211_registered_device
*rdev
,
230 struct wireless_dev
*wdev
;
233 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
))
236 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
) {
237 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
238 err
= dev_change_net_namespace(wdev
->netdev
, net
, "wlan%d");
241 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
245 /* failed -- clean up to old netns */
246 net
= wiphy_net(&rdev
->wiphy
);
248 list_for_each_entry_continue_reverse(wdev
, &rdev
->netdev_list
,
250 wdev
->netdev
->features
&= ~NETIF_F_NETNS_LOCAL
;
251 err
= dev_change_net_namespace(wdev
->netdev
, net
,
254 wdev
->netdev
->features
|= NETIF_F_NETNS_LOCAL
;
260 wiphy_net_set(&rdev
->wiphy
, net
);
262 err
= device_rename(&rdev
->wiphy
.dev
, dev_name(&rdev
->wiphy
.dev
));
268 static void cfg80211_rfkill_poll(struct rfkill
*rfkill
, void *data
)
270 struct cfg80211_registered_device
*rdev
= data
;
272 rdev
->ops
->rfkill_poll(&rdev
->wiphy
);
275 static int cfg80211_rfkill_set_block(void *data
, bool blocked
)
277 struct cfg80211_registered_device
*rdev
= data
;
278 struct wireless_dev
*wdev
;
284 mutex_lock(&rdev
->devlist_mtx
);
286 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
)
287 dev_close(wdev
->netdev
);
289 mutex_unlock(&rdev
->devlist_mtx
);
295 static void cfg80211_rfkill_sync_work(struct work_struct
*work
)
297 struct cfg80211_registered_device
*rdev
;
299 rdev
= container_of(work
, struct cfg80211_registered_device
, rfkill_sync
);
300 cfg80211_rfkill_set_block(rdev
, rfkill_blocked(rdev
->rfkill
));
303 static void cfg80211_event_work(struct work_struct
*work
)
305 struct cfg80211_registered_device
*rdev
;
307 rdev
= container_of(work
, struct cfg80211_registered_device
,
311 cfg80211_lock_rdev(rdev
);
313 cfg80211_process_rdev_events(rdev
);
314 cfg80211_unlock_rdev(rdev
);
318 /* exported functions */
320 struct wiphy
*wiphy_new(const struct cfg80211_ops
*ops
, int sizeof_priv
)
322 static int wiphy_counter
;
324 struct cfg80211_registered_device
*rdev
;
327 WARN_ON(ops
->add_key
&& (!ops
->del_key
|| !ops
->set_default_key
));
328 WARN_ON(ops
->auth
&& (!ops
->assoc
|| !ops
->deauth
|| !ops
->disassoc
));
329 WARN_ON(ops
->connect
&& !ops
->disconnect
);
330 WARN_ON(ops
->join_ibss
&& !ops
->leave_ibss
);
331 WARN_ON(ops
->add_virtual_intf
&& !ops
->del_virtual_intf
);
332 WARN_ON(ops
->add_station
&& !ops
->del_station
);
333 WARN_ON(ops
->add_mpath
&& !ops
->del_mpath
);
335 alloc_size
= sizeof(*rdev
) + sizeof_priv
;
337 rdev
= kzalloc(alloc_size
, GFP_KERNEL
);
343 mutex_lock(&cfg80211_mutex
);
345 rdev
->wiphy_idx
= wiphy_counter
++;
347 if (unlikely(!wiphy_idx_valid(rdev
->wiphy_idx
))) {
349 mutex_unlock(&cfg80211_mutex
);
355 mutex_unlock(&cfg80211_mutex
);
357 /* give it a proper name */
358 dev_set_name(&rdev
->wiphy
.dev
, PHY_NAME
"%d", rdev
->wiphy_idx
);
360 mutex_init(&rdev
->mtx
);
361 mutex_init(&rdev
->devlist_mtx
);
362 INIT_LIST_HEAD(&rdev
->netdev_list
);
363 spin_lock_init(&rdev
->bss_lock
);
364 INIT_LIST_HEAD(&rdev
->bss_list
);
365 INIT_WORK(&rdev
->scan_done_wk
, __cfg80211_scan_done
);
367 #ifdef CONFIG_CFG80211_WEXT
368 rdev
->wiphy
.wext
= &cfg80211_wext_handler
;
371 device_initialize(&rdev
->wiphy
.dev
);
372 rdev
->wiphy
.dev
.class = &ieee80211_class
;
373 rdev
->wiphy
.dev
.platform_data
= rdev
;
375 #ifdef CONFIG_CFG80211_DEFAULT_PS
376 rdev
->wiphy
.flags
|= WIPHY_FLAG_PS_ON_BY_DEFAULT
;
379 wiphy_net_set(&rdev
->wiphy
, &init_net
);
381 rdev
->rfkill_ops
.set_block
= cfg80211_rfkill_set_block
;
382 rdev
->rfkill
= rfkill_alloc(dev_name(&rdev
->wiphy
.dev
),
383 &rdev
->wiphy
.dev
, RFKILL_TYPE_WLAN
,
384 &rdev
->rfkill_ops
, rdev
);
391 INIT_WORK(&rdev
->rfkill_sync
, cfg80211_rfkill_sync_work
);
392 INIT_WORK(&rdev
->conn_work
, cfg80211_conn_work
);
393 INIT_WORK(&rdev
->event_work
, cfg80211_event_work
);
395 init_waitqueue_head(&rdev
->dev_wait
);
398 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
399 * Fragmentation and RTS threshold are disabled by default with the
402 rdev
->wiphy
.retry_short
= 7;
403 rdev
->wiphy
.retry_long
= 4;
404 rdev
->wiphy
.frag_threshold
= (u32
) -1;
405 rdev
->wiphy
.rts_threshold
= (u32
) -1;
406 rdev
->wiphy
.coverage_class
= 0;
410 EXPORT_SYMBOL(wiphy_new
);
412 int wiphy_register(struct wiphy
*wiphy
)
414 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
416 enum ieee80211_band band
;
417 struct ieee80211_supported_band
*sband
;
418 bool have_band
= false;
420 u16 ifmodes
= wiphy
->interface_modes
;
422 if (WARN_ON(wiphy
->addresses
&& !wiphy
->n_addresses
))
425 if (WARN_ON(wiphy
->addresses
&&
426 !is_zero_ether_addr(wiphy
->perm_addr
) &&
427 memcmp(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
,
431 if (wiphy
->addresses
)
432 memcpy(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
, ETH_ALEN
);
434 /* sanity check ifmodes */
436 ifmodes
&= ((1 << NUM_NL80211_IFTYPES
) - 1) & ~1;
437 if (WARN_ON(ifmodes
!= wiphy
->interface_modes
))
438 wiphy
->interface_modes
= ifmodes
;
440 /* sanity check supported bands/channels */
441 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
442 sband
= wiphy
->bands
[band
];
448 if (WARN_ON(!sband
->n_channels
|| !sband
->n_bitrates
))
452 * Since we use a u32 for rate bitmaps in
453 * ieee80211_get_response_rate, we cannot
454 * have more than 32 legacy rates.
456 if (WARN_ON(sband
->n_bitrates
> 32))
459 for (i
= 0; i
< sband
->n_channels
; i
++) {
460 sband
->channels
[i
].orig_flags
=
461 sband
->channels
[i
].flags
;
462 sband
->channels
[i
].orig_mag
=
463 sband
->channels
[i
].max_antenna_gain
;
464 sband
->channels
[i
].orig_mpwr
=
465 sband
->channels
[i
].max_power
;
466 sband
->channels
[i
].band
= band
;
477 /* check and set up bitrates */
478 ieee80211_set_bitrate_flags(wiphy
);
480 mutex_lock(&cfg80211_mutex
);
482 res
= device_add(&rdev
->wiphy
.dev
);
486 res
= rfkill_register(rdev
->rfkill
);
490 /* set up regulatory info */
491 wiphy_update_regulatory(wiphy
, NL80211_REGDOM_SET_BY_CORE
);
493 list_add_rcu(&rdev
->list
, &cfg80211_rdev_list
);
494 cfg80211_rdev_list_generation
++;
497 rdev
->wiphy
.debugfsdir
=
498 debugfs_create_dir(wiphy_name(&rdev
->wiphy
),
499 ieee80211_debugfs_dir
);
500 if (IS_ERR(rdev
->wiphy
.debugfsdir
))
501 rdev
->wiphy
.debugfsdir
= NULL
;
503 if (wiphy
->flags
& WIPHY_FLAG_CUSTOM_REGULATORY
) {
504 struct regulatory_request request
;
506 request
.wiphy_idx
= get_wiphy_idx(wiphy
);
507 request
.initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
508 request
.alpha2
[0] = '9';
509 request
.alpha2
[1] = '9';
511 nl80211_send_reg_change_event(&request
);
514 cfg80211_debugfs_rdev_add(rdev
);
515 mutex_unlock(&cfg80211_mutex
);
520 device_del(&rdev
->wiphy
.dev
);
523 mutex_unlock(&cfg80211_mutex
);
526 EXPORT_SYMBOL(wiphy_register
);
528 void wiphy_rfkill_start_polling(struct wiphy
*wiphy
)
530 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
532 if (!rdev
->ops
->rfkill_poll
)
534 rdev
->rfkill_ops
.poll
= cfg80211_rfkill_poll
;
535 rfkill_resume_polling(rdev
->rfkill
);
537 EXPORT_SYMBOL(wiphy_rfkill_start_polling
);
539 void wiphy_rfkill_stop_polling(struct wiphy
*wiphy
)
541 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
543 rfkill_pause_polling(rdev
->rfkill
);
545 EXPORT_SYMBOL(wiphy_rfkill_stop_polling
);
547 void wiphy_unregister(struct wiphy
*wiphy
)
549 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
551 rfkill_unregister(rdev
->rfkill
);
553 /* protect the device list */
554 mutex_lock(&cfg80211_mutex
);
556 wait_event(rdev
->dev_wait
, ({
558 mutex_lock(&rdev
->devlist_mtx
);
559 __count
= rdev
->opencount
;
560 mutex_unlock(&rdev
->devlist_mtx
);
563 mutex_lock(&rdev
->devlist_mtx
);
564 BUG_ON(!list_empty(&rdev
->netdev_list
));
565 mutex_unlock(&rdev
->devlist_mtx
);
568 * First remove the hardware from everywhere, this makes
569 * it impossible to find from userspace.
571 debugfs_remove_recursive(rdev
->wiphy
.debugfsdir
);
572 list_del_rcu(&rdev
->list
);
576 * Try to grab rdev->mtx. If a command is still in progress,
577 * hopefully the driver will refuse it since it's tearing
578 * down the device already. We wait for this command to complete
579 * before unlinking the item from the list.
580 * Note: as codified by the BUG_ON above we cannot get here if
581 * a virtual interface is still present. Hence, we can only get
582 * to lock contention here if userspace issues a command that
583 * identified the hardware by wiphy index.
585 cfg80211_lock_rdev(rdev
);
587 cfg80211_unlock_rdev(rdev
);
589 /* If this device got a regulatory hint tell core its
590 * free to listen now to a new shiny device regulatory hint */
591 reg_device_remove(wiphy
);
593 cfg80211_rdev_list_generation
++;
594 device_del(&rdev
->wiphy
.dev
);
596 mutex_unlock(&cfg80211_mutex
);
598 flush_work(&rdev
->scan_done_wk
);
599 cancel_work_sync(&rdev
->conn_work
);
600 flush_work(&rdev
->event_work
);
602 EXPORT_SYMBOL(wiphy_unregister
);
604 void cfg80211_dev_free(struct cfg80211_registered_device
*rdev
)
606 struct cfg80211_internal_bss
*scan
, *tmp
;
607 rfkill_destroy(rdev
->rfkill
);
608 mutex_destroy(&rdev
->mtx
);
609 mutex_destroy(&rdev
->devlist_mtx
);
610 list_for_each_entry_safe(scan
, tmp
, &rdev
->bss_list
, list
)
611 cfg80211_put_bss(&scan
->pub
);
615 void wiphy_free(struct wiphy
*wiphy
)
617 put_device(&wiphy
->dev
);
619 EXPORT_SYMBOL(wiphy_free
);
621 void wiphy_rfkill_set_hw_state(struct wiphy
*wiphy
, bool blocked
)
623 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
625 if (rfkill_set_hw_state(rdev
->rfkill
, blocked
))
626 schedule_work(&rdev
->rfkill_sync
);
628 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state
);
630 static void wdev_cleanup_work(struct work_struct
*work
)
632 struct wireless_dev
*wdev
;
633 struct cfg80211_registered_device
*rdev
;
635 wdev
= container_of(work
, struct wireless_dev
, cleanup_work
);
636 rdev
= wiphy_to_dev(wdev
->wiphy
);
638 cfg80211_lock_rdev(rdev
);
640 if (WARN_ON(rdev
->scan_req
&& rdev
->scan_req
->dev
== wdev
->netdev
)) {
641 rdev
->scan_req
->aborted
= true;
642 ___cfg80211_scan_done(rdev
, true);
645 cfg80211_unlock_rdev(rdev
);
647 mutex_lock(&rdev
->devlist_mtx
);
649 mutex_unlock(&rdev
->devlist_mtx
);
650 wake_up(&rdev
->dev_wait
);
652 dev_put(wdev
->netdev
);
655 static struct device_type wiphy_type
= {
659 static int cfg80211_netdev_notifier_call(struct notifier_block
* nb
,
663 struct net_device
*dev
= ndev
;
664 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
665 struct cfg80211_registered_device
*rdev
;
670 rdev
= wiphy_to_dev(wdev
->wiphy
);
672 WARN_ON(wdev
->iftype
== NL80211_IFTYPE_UNSPECIFIED
);
675 case NETDEV_POST_INIT
:
676 SET_NETDEV_DEVTYPE(dev
, &wiphy_type
);
678 case NETDEV_REGISTER
:
680 * NB: cannot take rdev->mtx here because this may be
681 * called within code protected by it when interfaces
682 * are added with nl80211.
684 mutex_init(&wdev
->mtx
);
685 INIT_WORK(&wdev
->cleanup_work
, wdev_cleanup_work
);
686 INIT_LIST_HEAD(&wdev
->event_list
);
687 spin_lock_init(&wdev
->event_lock
);
688 INIT_LIST_HEAD(&wdev
->mgmt_registrations
);
689 spin_lock_init(&wdev
->mgmt_registrations_lock
);
691 mutex_lock(&rdev
->devlist_mtx
);
692 list_add_rcu(&wdev
->list
, &rdev
->netdev_list
);
693 rdev
->devlist_generation
++;
694 /* can only change netns with wiphy */
695 dev
->features
|= NETIF_F_NETNS_LOCAL
;
697 if (sysfs_create_link(&dev
->dev
.kobj
, &rdev
->wiphy
.dev
.kobj
,
699 printk(KERN_ERR
"wireless: failed to add phy80211 "
700 "symlink to netdev!\n");
703 wdev
->sme_state
= CFG80211_SME_IDLE
;
704 mutex_unlock(&rdev
->devlist_mtx
);
705 #ifdef CONFIG_CFG80211_WEXT
706 wdev
->wext
.default_key
= -1;
707 wdev
->wext
.default_mgmt_key
= -1;
708 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
711 if (wdev
->wiphy
->flags
& WIPHY_FLAG_PS_ON_BY_DEFAULT
)
715 /* allow mac80211 to determine the timeout */
716 wdev
->ps_timeout
= -1;
717 if (rdev
->ops
->set_power_mgmt
)
718 if (rdev
->ops
->set_power_mgmt(wdev
->wiphy
, dev
,
721 /* assume this means it's off */
725 if (!dev
->ethtool_ops
)
726 dev
->ethtool_ops
= &cfg80211_ethtool_ops
;
728 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
729 wdev
->iftype
== NL80211_IFTYPE_ADHOC
) && !wdev
->use_4addr
)
730 dev
->priv_flags
|= IFF_DONT_BRIDGE
;
732 case NETDEV_GOING_DOWN
:
733 switch (wdev
->iftype
) {
734 case NL80211_IFTYPE_ADHOC
:
735 cfg80211_leave_ibss(rdev
, dev
, true);
737 case NL80211_IFTYPE_STATION
:
739 #ifdef CONFIG_CFG80211_WEXT
740 kfree(wdev
->wext
.ie
);
741 wdev
->wext
.ie
= NULL
;
742 wdev
->wext
.ie_len
= 0;
743 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
745 __cfg80211_disconnect(rdev
, dev
,
746 WLAN_REASON_DEAUTH_LEAVING
, true);
747 cfg80211_mlme_down(rdev
, dev
);
756 queue_work(cfg80211_wq
, &wdev
->cleanup_work
);
760 * If we have a really quick DOWN/UP succession we may
761 * have this work still pending ... cancel it and see
762 * if it was pending, in which case we need to account
763 * for some of the work it would have done.
765 if (cancel_work_sync(&wdev
->cleanup_work
)) {
766 mutex_lock(&rdev
->devlist_mtx
);
768 mutex_unlock(&rdev
->devlist_mtx
);
771 cfg80211_lock_rdev(rdev
);
772 mutex_lock(&rdev
->devlist_mtx
);
773 #ifdef CONFIG_CFG80211_WEXT
775 switch (wdev
->iftype
) {
776 case NL80211_IFTYPE_ADHOC
:
777 cfg80211_ibss_wext_join(rdev
, wdev
);
779 case NL80211_IFTYPE_STATION
:
780 cfg80211_mgd_wext_connect(rdev
, wdev
);
788 mutex_unlock(&rdev
->devlist_mtx
);
789 cfg80211_unlock_rdev(rdev
);
791 case NETDEV_UNREGISTER
:
793 * NB: cannot take rdev->mtx here because this may be
794 * called within code protected by it when interfaces
795 * are removed with nl80211.
797 mutex_lock(&rdev
->devlist_mtx
);
799 * It is possible to get NETDEV_UNREGISTER
800 * multiple times. To detect that, check
801 * that the interface is still on the list
802 * of registered interfaces, and only then
803 * remove and clean it up.
805 if (!list_empty(&wdev
->list
)) {
806 sysfs_remove_link(&dev
->dev
.kobj
, "phy80211");
807 list_del_rcu(&wdev
->list
);
808 rdev
->devlist_generation
++;
809 cfg80211_mlme_purge_registrations(wdev
);
810 #ifdef CONFIG_CFG80211_WEXT
811 kfree(wdev
->wext
.keys
);
814 mutex_unlock(&rdev
->devlist_mtx
);
816 * synchronise (so that we won't find this netdev
817 * from other code any more) and then clear the list
818 * head so that the above code can safely check for
819 * !list_empty() to avoid double-cleanup.
822 INIT_LIST_HEAD(&wdev
->list
);
825 if (!(wdev
->wiphy
->interface_modes
& BIT(wdev
->iftype
)))
826 return notifier_from_errno(-EOPNOTSUPP
);
827 if (rfkill_blocked(rdev
->rfkill
))
828 return notifier_from_errno(-ERFKILL
);
835 static struct notifier_block cfg80211_netdev_notifier
= {
836 .notifier_call
= cfg80211_netdev_notifier_call
,
839 static void __net_exit
cfg80211_pernet_exit(struct net
*net
)
841 struct cfg80211_registered_device
*rdev
;
844 mutex_lock(&cfg80211_mutex
);
845 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
846 if (net_eq(wiphy_net(&rdev
->wiphy
), net
))
847 WARN_ON(cfg80211_switch_netns(rdev
, &init_net
));
849 mutex_unlock(&cfg80211_mutex
);
853 static struct pernet_operations cfg80211_pernet_ops
= {
854 .exit
= cfg80211_pernet_exit
,
857 static int __init
cfg80211_init(void)
861 err
= register_pernet_device(&cfg80211_pernet_ops
);
863 goto out_fail_pernet
;
865 err
= wiphy_sysfs_init();
869 err
= register_netdevice_notifier(&cfg80211_netdev_notifier
);
871 goto out_fail_notifier
;
873 err
= nl80211_init();
875 goto out_fail_nl80211
;
877 ieee80211_debugfs_dir
= debugfs_create_dir("ieee80211", NULL
);
879 err
= regulatory_init();
883 cfg80211_wq
= create_singlethread_workqueue("cfg80211");
892 debugfs_remove(ieee80211_debugfs_dir
);
894 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
898 unregister_pernet_device(&cfg80211_pernet_ops
);
902 subsys_initcall(cfg80211_init
);
904 static void __exit
cfg80211_exit(void)
906 debugfs_remove(ieee80211_debugfs_dir
);
908 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
911 unregister_pernet_device(&cfg80211_pernet_ops
);
912 destroy_workqueue(cfg80211_wq
);
914 module_exit(cfg80211_exit
);
916 static int ___wiphy_printk(const char *level
, const struct wiphy
*wiphy
,
917 struct va_format
*vaf
)
920 return printk("%s(NULL wiphy *): %pV", level
, vaf
);
922 return printk("%s%s: %pV", level
, wiphy_name(wiphy
), vaf
);
925 int __wiphy_printk(const char *level
, const struct wiphy
*wiphy
,
926 const char *fmt
, ...)
928 struct va_format vaf
;
937 r
= ___wiphy_printk(level
, wiphy
, &vaf
);
942 EXPORT_SYMBOL(__wiphy_printk
);
944 #define define_wiphy_printk_level(func, kern_level) \
945 int func(const struct wiphy *wiphy, const char *fmt, ...) \
947 struct va_format vaf; \
951 va_start(args, fmt); \
956 r = ___wiphy_printk(kern_level, wiphy, &vaf); \
963 define_wiphy_printk_level(wiphy_debug
, KERN_DEBUG
);