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
;
258 wiphy_net_set(&rdev
->wiphy
, net
);
263 static void cfg80211_rfkill_poll(struct rfkill
*rfkill
, void *data
)
265 struct cfg80211_registered_device
*rdev
= data
;
267 rdev
->ops
->rfkill_poll(&rdev
->wiphy
);
270 static int cfg80211_rfkill_set_block(void *data
, bool blocked
)
272 struct cfg80211_registered_device
*rdev
= data
;
273 struct wireless_dev
*wdev
;
279 mutex_lock(&rdev
->devlist_mtx
);
281 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
)
282 dev_close(wdev
->netdev
);
284 mutex_unlock(&rdev
->devlist_mtx
);
290 static void cfg80211_rfkill_sync_work(struct work_struct
*work
)
292 struct cfg80211_registered_device
*rdev
;
294 rdev
= container_of(work
, struct cfg80211_registered_device
, rfkill_sync
);
295 cfg80211_rfkill_set_block(rdev
, rfkill_blocked(rdev
->rfkill
));
298 static void cfg80211_event_work(struct work_struct
*work
)
300 struct cfg80211_registered_device
*rdev
;
302 rdev
= container_of(work
, struct cfg80211_registered_device
,
306 cfg80211_lock_rdev(rdev
);
308 cfg80211_process_rdev_events(rdev
);
309 cfg80211_unlock_rdev(rdev
);
313 /* exported functions */
315 struct wiphy
*wiphy_new(const struct cfg80211_ops
*ops
, int sizeof_priv
)
317 static int wiphy_counter
;
319 struct cfg80211_registered_device
*rdev
;
322 WARN_ON(ops
->add_key
&& (!ops
->del_key
|| !ops
->set_default_key
));
323 WARN_ON(ops
->auth
&& (!ops
->assoc
|| !ops
->deauth
|| !ops
->disassoc
));
324 WARN_ON(ops
->connect
&& !ops
->disconnect
);
325 WARN_ON(ops
->join_ibss
&& !ops
->leave_ibss
);
326 WARN_ON(ops
->add_virtual_intf
&& !ops
->del_virtual_intf
);
327 WARN_ON(ops
->add_station
&& !ops
->del_station
);
328 WARN_ON(ops
->add_mpath
&& !ops
->del_mpath
);
330 alloc_size
= sizeof(*rdev
) + sizeof_priv
;
332 rdev
= kzalloc(alloc_size
, GFP_KERNEL
);
338 mutex_lock(&cfg80211_mutex
);
340 rdev
->wiphy_idx
= wiphy_counter
++;
342 if (unlikely(!wiphy_idx_valid(rdev
->wiphy_idx
))) {
344 mutex_unlock(&cfg80211_mutex
);
350 mutex_unlock(&cfg80211_mutex
);
352 /* give it a proper name */
353 dev_set_name(&rdev
->wiphy
.dev
, PHY_NAME
"%d", rdev
->wiphy_idx
);
355 mutex_init(&rdev
->mtx
);
356 mutex_init(&rdev
->devlist_mtx
);
357 INIT_LIST_HEAD(&rdev
->netdev_list
);
358 spin_lock_init(&rdev
->bss_lock
);
359 INIT_LIST_HEAD(&rdev
->bss_list
);
360 INIT_WORK(&rdev
->scan_done_wk
, __cfg80211_scan_done
);
362 #ifdef CONFIG_CFG80211_WEXT
363 rdev
->wiphy
.wext
= &cfg80211_wext_handler
;
366 device_initialize(&rdev
->wiphy
.dev
);
367 rdev
->wiphy
.dev
.class = &ieee80211_class
;
368 rdev
->wiphy
.dev
.platform_data
= rdev
;
370 #ifdef CONFIG_CFG80211_DEFAULT_PS
371 rdev
->wiphy
.flags
|= WIPHY_FLAG_PS_ON_BY_DEFAULT
;
374 wiphy_net_set(&rdev
->wiphy
, &init_net
);
376 rdev
->rfkill_ops
.set_block
= cfg80211_rfkill_set_block
;
377 rdev
->rfkill
= rfkill_alloc(dev_name(&rdev
->wiphy
.dev
),
378 &rdev
->wiphy
.dev
, RFKILL_TYPE_WLAN
,
379 &rdev
->rfkill_ops
, rdev
);
386 INIT_WORK(&rdev
->rfkill_sync
, cfg80211_rfkill_sync_work
);
387 INIT_WORK(&rdev
->conn_work
, cfg80211_conn_work
);
388 INIT_WORK(&rdev
->event_work
, cfg80211_event_work
);
390 init_waitqueue_head(&rdev
->dev_wait
);
393 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
394 * Fragmentation and RTS threshold are disabled by default with the
397 rdev
->wiphy
.retry_short
= 7;
398 rdev
->wiphy
.retry_long
= 4;
399 rdev
->wiphy
.frag_threshold
= (u32
) -1;
400 rdev
->wiphy
.rts_threshold
= (u32
) -1;
401 rdev
->wiphy
.coverage_class
= 0;
405 EXPORT_SYMBOL(wiphy_new
);
407 int wiphy_register(struct wiphy
*wiphy
)
409 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
411 enum ieee80211_band band
;
412 struct ieee80211_supported_band
*sband
;
413 bool have_band
= false;
415 u16 ifmodes
= wiphy
->interface_modes
;
417 if (WARN_ON(wiphy
->addresses
&& !wiphy
->n_addresses
))
420 if (WARN_ON(wiphy
->addresses
&&
421 !is_zero_ether_addr(wiphy
->perm_addr
) &&
422 memcmp(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
,
426 if (wiphy
->addresses
)
427 memcpy(wiphy
->perm_addr
, wiphy
->addresses
[0].addr
, ETH_ALEN
);
429 /* sanity check ifmodes */
431 ifmodes
&= ((1 << __NL80211_IFTYPE_AFTER_LAST
) - 1) & ~1;
432 if (WARN_ON(ifmodes
!= wiphy
->interface_modes
))
433 wiphy
->interface_modes
= ifmodes
;
435 /* sanity check supported bands/channels */
436 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
437 sband
= wiphy
->bands
[band
];
443 if (WARN_ON(!sband
->n_channels
|| !sband
->n_bitrates
))
447 * Since we use a u32 for rate bitmaps in
448 * ieee80211_get_response_rate, we cannot
449 * have more than 32 legacy rates.
451 if (WARN_ON(sband
->n_bitrates
> 32))
454 for (i
= 0; i
< sband
->n_channels
; i
++) {
455 sband
->channels
[i
].orig_flags
=
456 sband
->channels
[i
].flags
;
457 sband
->channels
[i
].orig_mag
=
458 sband
->channels
[i
].max_antenna_gain
;
459 sband
->channels
[i
].orig_mpwr
=
460 sband
->channels
[i
].max_power
;
461 sband
->channels
[i
].band
= band
;
472 /* check and set up bitrates */
473 ieee80211_set_bitrate_flags(wiphy
);
475 mutex_lock(&cfg80211_mutex
);
477 res
= device_add(&rdev
->wiphy
.dev
);
481 res
= rfkill_register(rdev
->rfkill
);
485 /* set up regulatory info */
486 wiphy_update_regulatory(wiphy
, NL80211_REGDOM_SET_BY_CORE
);
488 list_add_rcu(&rdev
->list
, &cfg80211_rdev_list
);
489 cfg80211_rdev_list_generation
++;
492 rdev
->wiphy
.debugfsdir
=
493 debugfs_create_dir(wiphy_name(&rdev
->wiphy
),
494 ieee80211_debugfs_dir
);
495 if (IS_ERR(rdev
->wiphy
.debugfsdir
))
496 rdev
->wiphy
.debugfsdir
= NULL
;
498 if (wiphy
->flags
& WIPHY_FLAG_CUSTOM_REGULATORY
) {
499 struct regulatory_request request
;
501 request
.wiphy_idx
= get_wiphy_idx(wiphy
);
502 request
.initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
503 request
.alpha2
[0] = '9';
504 request
.alpha2
[1] = '9';
506 nl80211_send_reg_change_event(&request
);
509 cfg80211_debugfs_rdev_add(rdev
);
510 mutex_unlock(&cfg80211_mutex
);
515 device_del(&rdev
->wiphy
.dev
);
518 mutex_unlock(&cfg80211_mutex
);
521 EXPORT_SYMBOL(wiphy_register
);
523 void wiphy_rfkill_start_polling(struct wiphy
*wiphy
)
525 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
527 if (!rdev
->ops
->rfkill_poll
)
529 rdev
->rfkill_ops
.poll
= cfg80211_rfkill_poll
;
530 rfkill_resume_polling(rdev
->rfkill
);
532 EXPORT_SYMBOL(wiphy_rfkill_start_polling
);
534 void wiphy_rfkill_stop_polling(struct wiphy
*wiphy
)
536 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
538 rfkill_pause_polling(rdev
->rfkill
);
540 EXPORT_SYMBOL(wiphy_rfkill_stop_polling
);
542 void wiphy_unregister(struct wiphy
*wiphy
)
544 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
546 rfkill_unregister(rdev
->rfkill
);
548 /* protect the device list */
549 mutex_lock(&cfg80211_mutex
);
551 wait_event(rdev
->dev_wait
, ({
553 mutex_lock(&rdev
->devlist_mtx
);
554 __count
= rdev
->opencount
;
555 mutex_unlock(&rdev
->devlist_mtx
);
558 mutex_lock(&rdev
->devlist_mtx
);
559 BUG_ON(!list_empty(&rdev
->netdev_list
));
560 mutex_unlock(&rdev
->devlist_mtx
);
563 * First remove the hardware from everywhere, this makes
564 * it impossible to find from userspace.
566 debugfs_remove_recursive(rdev
->wiphy
.debugfsdir
);
567 list_del_rcu(&rdev
->list
);
571 * Try to grab rdev->mtx. If a command is still in progress,
572 * hopefully the driver will refuse it since it's tearing
573 * down the device already. We wait for this command to complete
574 * before unlinking the item from the list.
575 * Note: as codified by the BUG_ON above we cannot get here if
576 * a virtual interface is still present. Hence, we can only get
577 * to lock contention here if userspace issues a command that
578 * identified the hardware by wiphy index.
580 cfg80211_lock_rdev(rdev
);
582 cfg80211_unlock_rdev(rdev
);
584 /* If this device got a regulatory hint tell core its
585 * free to listen now to a new shiny device regulatory hint */
586 reg_device_remove(wiphy
);
588 cfg80211_rdev_list_generation
++;
589 device_del(&rdev
->wiphy
.dev
);
591 mutex_unlock(&cfg80211_mutex
);
593 flush_work(&rdev
->scan_done_wk
);
594 cancel_work_sync(&rdev
->conn_work
);
595 flush_work(&rdev
->event_work
);
597 EXPORT_SYMBOL(wiphy_unregister
);
599 void cfg80211_dev_free(struct cfg80211_registered_device
*rdev
)
601 struct cfg80211_internal_bss
*scan
, *tmp
;
602 rfkill_destroy(rdev
->rfkill
);
603 mutex_destroy(&rdev
->mtx
);
604 mutex_destroy(&rdev
->devlist_mtx
);
605 list_for_each_entry_safe(scan
, tmp
, &rdev
->bss_list
, list
)
606 cfg80211_put_bss(&scan
->pub
);
610 void wiphy_free(struct wiphy
*wiphy
)
612 put_device(&wiphy
->dev
);
614 EXPORT_SYMBOL(wiphy_free
);
616 void wiphy_rfkill_set_hw_state(struct wiphy
*wiphy
, bool blocked
)
618 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
620 if (rfkill_set_hw_state(rdev
->rfkill
, blocked
))
621 schedule_work(&rdev
->rfkill_sync
);
623 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state
);
625 static void wdev_cleanup_work(struct work_struct
*work
)
627 struct wireless_dev
*wdev
;
628 struct cfg80211_registered_device
*rdev
;
630 wdev
= container_of(work
, struct wireless_dev
, cleanup_work
);
631 rdev
= wiphy_to_dev(wdev
->wiphy
);
633 cfg80211_lock_rdev(rdev
);
635 if (WARN_ON(rdev
->scan_req
&& rdev
->scan_req
->dev
== wdev
->netdev
)) {
636 rdev
->scan_req
->aborted
= true;
637 ___cfg80211_scan_done(rdev
, true);
640 cfg80211_unlock_rdev(rdev
);
642 mutex_lock(&rdev
->devlist_mtx
);
644 mutex_unlock(&rdev
->devlist_mtx
);
645 wake_up(&rdev
->dev_wait
);
647 dev_put(wdev
->netdev
);
650 static struct device_type wiphy_type
= {
654 static int cfg80211_netdev_notifier_call(struct notifier_block
* nb
,
658 struct net_device
*dev
= ndev
;
659 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
660 struct cfg80211_registered_device
*rdev
;
665 rdev
= wiphy_to_dev(wdev
->wiphy
);
667 WARN_ON(wdev
->iftype
== NL80211_IFTYPE_UNSPECIFIED
);
670 case NETDEV_POST_INIT
:
671 SET_NETDEV_DEVTYPE(dev
, &wiphy_type
);
673 case NETDEV_REGISTER
:
675 * NB: cannot take rdev->mtx here because this may be
676 * called within code protected by it when interfaces
677 * are added with nl80211.
679 mutex_init(&wdev
->mtx
);
680 INIT_WORK(&wdev
->cleanup_work
, wdev_cleanup_work
);
681 INIT_LIST_HEAD(&wdev
->event_list
);
682 spin_lock_init(&wdev
->event_lock
);
683 INIT_LIST_HEAD(&wdev
->action_registrations
);
684 spin_lock_init(&wdev
->action_registrations_lock
);
686 mutex_lock(&rdev
->devlist_mtx
);
687 list_add_rcu(&wdev
->list
, &rdev
->netdev_list
);
688 rdev
->devlist_generation
++;
689 /* can only change netns with wiphy */
690 dev
->features
|= NETIF_F_NETNS_LOCAL
;
692 if (sysfs_create_link(&dev
->dev
.kobj
, &rdev
->wiphy
.dev
.kobj
,
694 printk(KERN_ERR
"wireless: failed to add phy80211 "
695 "symlink to netdev!\n");
698 wdev
->sme_state
= CFG80211_SME_IDLE
;
699 mutex_unlock(&rdev
->devlist_mtx
);
700 #ifdef CONFIG_CFG80211_WEXT
701 wdev
->wext
.default_key
= -1;
702 wdev
->wext
.default_mgmt_key
= -1;
703 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
706 if (wdev
->wiphy
->flags
& WIPHY_FLAG_PS_ON_BY_DEFAULT
)
710 /* allow mac80211 to determine the timeout */
711 wdev
->ps_timeout
= -1;
712 if (rdev
->ops
->set_power_mgmt
)
713 if (rdev
->ops
->set_power_mgmt(wdev
->wiphy
, dev
,
716 /* assume this means it's off */
720 if (!dev
->ethtool_ops
)
721 dev
->ethtool_ops
= &cfg80211_ethtool_ops
;
723 if ((wdev
->iftype
== NL80211_IFTYPE_STATION
||
724 wdev
->iftype
== NL80211_IFTYPE_ADHOC
) && !wdev
->use_4addr
)
725 dev
->priv_flags
|= IFF_DONT_BRIDGE
;
727 case NETDEV_GOING_DOWN
:
728 switch (wdev
->iftype
) {
729 case NL80211_IFTYPE_ADHOC
:
730 cfg80211_leave_ibss(rdev
, dev
, true);
732 case NL80211_IFTYPE_STATION
:
734 #ifdef CONFIG_CFG80211_WEXT
735 kfree(wdev
->wext
.ie
);
736 wdev
->wext
.ie
= NULL
;
737 wdev
->wext
.ie_len
= 0;
738 wdev
->wext
.connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
740 __cfg80211_disconnect(rdev
, dev
,
741 WLAN_REASON_DEAUTH_LEAVING
, true);
742 cfg80211_mlme_down(rdev
, dev
);
751 queue_work(cfg80211_wq
, &wdev
->cleanup_work
);
755 * If we have a really quick DOWN/UP succession we may
756 * have this work still pending ... cancel it and see
757 * if it was pending, in which case we need to account
758 * for some of the work it would have done.
760 if (cancel_work_sync(&wdev
->cleanup_work
)) {
761 mutex_lock(&rdev
->devlist_mtx
);
763 mutex_unlock(&rdev
->devlist_mtx
);
766 cfg80211_lock_rdev(rdev
);
767 mutex_lock(&rdev
->devlist_mtx
);
768 #ifdef CONFIG_CFG80211_WEXT
770 switch (wdev
->iftype
) {
771 case NL80211_IFTYPE_ADHOC
:
772 cfg80211_ibss_wext_join(rdev
, wdev
);
774 case NL80211_IFTYPE_STATION
:
775 cfg80211_mgd_wext_connect(rdev
, wdev
);
783 mutex_unlock(&rdev
->devlist_mtx
);
784 cfg80211_unlock_rdev(rdev
);
786 case NETDEV_UNREGISTER
:
788 * NB: cannot take rdev->mtx here because this may be
789 * called within code protected by it when interfaces
790 * are removed with nl80211.
792 mutex_lock(&rdev
->devlist_mtx
);
794 * It is possible to get NETDEV_UNREGISTER
795 * multiple times. To detect that, check
796 * that the interface is still on the list
797 * of registered interfaces, and only then
798 * remove and clean it up.
800 if (!list_empty(&wdev
->list
)) {
801 sysfs_remove_link(&dev
->dev
.kobj
, "phy80211");
802 list_del_rcu(&wdev
->list
);
803 rdev
->devlist_generation
++;
804 cfg80211_mlme_purge_actions(wdev
);
805 #ifdef CONFIG_CFG80211_WEXT
806 kfree(wdev
->wext
.keys
);
809 mutex_unlock(&rdev
->devlist_mtx
);
811 * synchronise (so that we won't find this netdev
812 * from other code any more) and then clear the list
813 * head so that the above code can safely check for
814 * !list_empty() to avoid double-cleanup.
817 INIT_LIST_HEAD(&wdev
->list
);
820 if (!(wdev
->wiphy
->interface_modes
& BIT(wdev
->iftype
)))
821 return notifier_from_errno(-EOPNOTSUPP
);
822 if (rfkill_blocked(rdev
->rfkill
))
823 return notifier_from_errno(-ERFKILL
);
830 static struct notifier_block cfg80211_netdev_notifier
= {
831 .notifier_call
= cfg80211_netdev_notifier_call
,
834 static void __net_exit
cfg80211_pernet_exit(struct net
*net
)
836 struct cfg80211_registered_device
*rdev
;
839 mutex_lock(&cfg80211_mutex
);
840 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
841 if (net_eq(wiphy_net(&rdev
->wiphy
), net
))
842 WARN_ON(cfg80211_switch_netns(rdev
, &init_net
));
844 mutex_unlock(&cfg80211_mutex
);
848 static struct pernet_operations cfg80211_pernet_ops
= {
849 .exit
= cfg80211_pernet_exit
,
852 static int __init
cfg80211_init(void)
856 err
= register_pernet_device(&cfg80211_pernet_ops
);
858 goto out_fail_pernet
;
860 err
= wiphy_sysfs_init();
864 err
= register_netdevice_notifier(&cfg80211_netdev_notifier
);
866 goto out_fail_notifier
;
868 err
= nl80211_init();
870 goto out_fail_nl80211
;
872 ieee80211_debugfs_dir
= debugfs_create_dir("ieee80211", NULL
);
874 err
= regulatory_init();
878 cfg80211_wq
= create_singlethread_workqueue("cfg80211");
887 debugfs_remove(ieee80211_debugfs_dir
);
889 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
893 unregister_pernet_device(&cfg80211_pernet_ops
);
897 subsys_initcall(cfg80211_init
);
899 static void __exit
cfg80211_exit(void)
901 debugfs_remove(ieee80211_debugfs_dir
);
903 unregister_netdevice_notifier(&cfg80211_netdev_notifier
);
906 unregister_pernet_device(&cfg80211_pernet_ops
);
907 destroy_workqueue(cfg80211_wq
);
909 module_exit(cfg80211_exit
);
911 static int ___wiphy_printk(const char *level
, const struct wiphy
*wiphy
,
912 struct va_format
*vaf
)
915 return printk("%s(NULL wiphy *): %pV", level
, vaf
);
917 return printk("%s%s: %pV", level
, wiphy_name(wiphy
), vaf
);
920 int __wiphy_printk(const char *level
, const struct wiphy
*wiphy
,
921 const char *fmt
, ...)
923 struct va_format vaf
;
932 r
= ___wiphy_printk(level
, wiphy
, &vaf
);
937 EXPORT_SYMBOL(__wiphy_printk
);
939 #define define_wiphy_printk_level(func, kern_level) \
940 int func(const struct wiphy *wiphy, const char *fmt, ...) \
942 struct va_format vaf; \
946 va_start(args, fmt); \
951 r = ___wiphy_printk(kern_level, wiphy, &vaf); \
958 define_wiphy_printk_level(wiphy_debug
, KERN_DEBUG
);