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