~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/wireless/core.c

Version: ~ [ linux-5.5 ] ~ [ linux-5.4.15 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.98 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.167 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.211 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.211 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp