cfg80211: clean up properly on interface type change
[linux-2.6.git] / net / wireless / core.c
1 /*
2  * This is the linux wireless configuration interface.
3  *
4  * Copyright 2006-2009          Johannes Berg <johannes@sipsolutions.net>
5  */
6
7 #include <linux/if.h>
8 #include <linux/module.h>
9 #include <linux/err.h>
10 #include <linux/list.h>
11 #include <linux/nl80211.h>
12 #include <linux/debugfs.h>
13 #include <linux/notifier.h>
14 #include <linux/device.h>
15 #include <linux/etherdevice.h>
16 #include <linux/rtnetlink.h>
17 #include <net/genetlink.h>
18 #include <net/cfg80211.h>
19 #include "nl80211.h"
20 #include "core.h"
21 #include "sysfs.h"
22 #include "debugfs.h"
23 #include "wext-compat.h"
24
25 /* name for sysfs, %d is appended */
26 #define PHY_NAME "phy"
27
28 MODULE_AUTHOR("Johannes Berg");
29 MODULE_LICENSE("GPL");
30 MODULE_DESCRIPTION("wireless configuration support");
31
32 /* RCU might be appropriate here since we usually
33  * only read the list, and that can happen quite
34  * often because we need to do it for each command */
35 LIST_HEAD(cfg80211_rdev_list);
36 int cfg80211_rdev_list_generation;
37
38 /*
39  * This is used to protect the cfg80211_rdev_list
40  */
41 DEFINE_MUTEX(cfg80211_mutex);
42
43 /* for debugfs */
44 static struct dentry *ieee80211_debugfs_dir;
45
46 /* requires cfg80211_mutex to be held! */
47 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
48 {
49         struct cfg80211_registered_device *result = NULL, *rdev;
50
51         if (!wiphy_idx_valid(wiphy_idx))
52                 return NULL;
53
54         assert_cfg80211_lock();
55
56         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
57                 if (rdev->wiphy_idx == wiphy_idx) {
58                         result = rdev;
59                         break;
60                 }
61         }
62
63         return result;
64 }
65
66 int get_wiphy_idx(struct wiphy *wiphy)
67 {
68         struct cfg80211_registered_device *rdev;
69         if (!wiphy)
70                 return WIPHY_IDX_STALE;
71         rdev = wiphy_to_dev(wiphy);
72         return rdev->wiphy_idx;
73 }
74
75 /* requires cfg80211_rdev_mutex to be held! */
76 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
77 {
78         struct cfg80211_registered_device *rdev;
79
80         if (!wiphy_idx_valid(wiphy_idx))
81                 return NULL;
82
83         assert_cfg80211_lock();
84
85         rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
86         if (!rdev)
87                 return NULL;
88         return &rdev->wiphy;
89 }
90
91 /* requires cfg80211_mutex to be held! */
92 struct cfg80211_registered_device *
93 __cfg80211_rdev_from_info(struct genl_info *info)
94 {
95         int ifindex;
96         struct cfg80211_registered_device *bywiphyidx = NULL, *byifidx = NULL;
97         struct net_device *dev;
98         int err = -EINVAL;
99
100         assert_cfg80211_lock();
101
102         if (info->attrs[NL80211_ATTR_WIPHY]) {
103                 bywiphyidx = cfg80211_rdev_by_wiphy_idx(
104                                 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY]));
105                 err = -ENODEV;
106         }
107
108         if (info->attrs[NL80211_ATTR_IFINDEX]) {
109                 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
110                 dev = dev_get_by_index(genl_info_net(info), ifindex);
111                 if (dev) {
112                         if (dev->ieee80211_ptr)
113                                 byifidx =
114                                         wiphy_to_dev(dev->ieee80211_ptr->wiphy);
115                         dev_put(dev);
116                 }
117                 err = -ENODEV;
118         }
119
120         if (bywiphyidx && byifidx) {
121                 if (bywiphyidx != byifidx)
122                         return ERR_PTR(-EINVAL);
123                 else
124                         return bywiphyidx; /* == byifidx */
125         }
126         if (bywiphyidx)
127                 return bywiphyidx;
128
129         if (byifidx)
130                 return byifidx;
131
132         return ERR_PTR(err);
133 }
134
135 struct cfg80211_registered_device *
136 cfg80211_get_dev_from_info(struct genl_info *info)
137 {
138         struct cfg80211_registered_device *rdev;
139
140         mutex_lock(&cfg80211_mutex);
141         rdev = __cfg80211_rdev_from_info(info);
142
143         /* if it is not an error we grab the lock on
144          * it to assure it won't be going away while
145          * we operate on it */
146         if (!IS_ERR(rdev))
147                 mutex_lock(&rdev->mtx);
148
149         mutex_unlock(&cfg80211_mutex);
150
151         return rdev;
152 }
153
154 struct cfg80211_registered_device *
155 cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
156 {
157         struct cfg80211_registered_device *rdev = ERR_PTR(-ENODEV);
158         struct net_device *dev;
159
160         mutex_lock(&cfg80211_mutex);
161         dev = dev_get_by_index(net, ifindex);
162         if (!dev)
163                 goto out;
164         if (dev->ieee80211_ptr) {
165                 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
166                 mutex_lock(&rdev->mtx);
167         } else
168                 rdev = ERR_PTR(-ENODEV);
169         dev_put(dev);
170  out:
171         mutex_unlock(&cfg80211_mutex);
172         return rdev;
173 }
174
175 /* requires cfg80211_mutex to be held */
176 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
177                         char *newname)
178 {
179         struct cfg80211_registered_device *rdev2;
180         int wiphy_idx, taken = -1, result, digits;
181
182         assert_cfg80211_lock();
183
184         /* prohibit calling the thing phy%d when %d is not its number */
185         sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
186         if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
187                 /* count number of places needed to print wiphy_idx */
188                 digits = 1;
189                 while (wiphy_idx /= 10)
190                         digits++;
191                 /*
192                  * deny the name if it is phy<idx> where <idx> is printed
193                  * without leading zeroes. taken == strlen(newname) here
194                  */
195                 if (taken == strlen(PHY_NAME) + digits)
196                         return -EINVAL;
197         }
198
199
200         /* Ignore nop renames */
201         if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
202                 return 0;
203
204         /* Ensure another device does not already have this name. */
205         list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
206                 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0)
207                         return -EINVAL;
208
209         result = device_rename(&rdev->wiphy.dev, newname);
210         if (result)
211                 return result;
212
213         if (rdev->wiphy.debugfsdir &&
214             !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
215                             rdev->wiphy.debugfsdir,
216                             rdev->wiphy.debugfsdir->d_parent,
217                             newname))
218                 printk(KERN_ERR "cfg80211: failed to rename debugfs dir to %s!\n",
219                        newname);
220
221         nl80211_notify_dev_rename(rdev);
222
223         return 0;
224 }
225
226 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
227                           struct net *net)
228 {
229         struct wireless_dev *wdev;
230         int err = 0;
231
232         if (!rdev->wiphy.netnsok)
233                 return -EOPNOTSUPP;
234
235         list_for_each_entry(wdev, &rdev->netdev_list, list) {
236                 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
237                 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
238                 if (err)
239                         break;
240                 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
241         }
242
243         if (err) {
244                 /* failed -- clean up to old netns */
245                 net = wiphy_net(&rdev->wiphy);
246
247                 list_for_each_entry_continue_reverse(wdev, &rdev->netdev_list,
248                                                      list) {
249                         wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
250                         err = dev_change_net_namespace(wdev->netdev, net,
251                                                         "wlan%d");
252                         WARN_ON(err);
253                         wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
254                 }
255         }
256
257         wiphy_net_set(&rdev->wiphy, net);
258
259         return err;
260 }
261
262 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
263 {
264         struct cfg80211_registered_device *rdev = data;
265
266         rdev->ops->rfkill_poll(&rdev->wiphy);
267 }
268
269 static int cfg80211_rfkill_set_block(void *data, bool blocked)
270 {
271         struct cfg80211_registered_device *rdev = data;
272         struct wireless_dev *wdev;
273
274         if (!blocked)
275                 return 0;
276
277         rtnl_lock();
278         mutex_lock(&rdev->devlist_mtx);
279
280         list_for_each_entry(wdev, &rdev->netdev_list, list)
281                 dev_close(wdev->netdev);
282
283         mutex_unlock(&rdev->devlist_mtx);
284         rtnl_unlock();
285
286         return 0;
287 }
288
289 static void cfg80211_rfkill_sync_work(struct work_struct *work)
290 {
291         struct cfg80211_registered_device *rdev;
292
293         rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
294         cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
295 }
296
297 static void cfg80211_event_work(struct work_struct *work)
298 {
299         struct cfg80211_registered_device *rdev;
300
301         rdev = container_of(work, struct cfg80211_registered_device,
302                             event_work);
303
304         rtnl_lock();
305         cfg80211_lock_rdev(rdev);
306
307         cfg80211_process_rdev_events(rdev);
308         cfg80211_unlock_rdev(rdev);
309         rtnl_unlock();
310 }
311
312 /* exported functions */
313
314 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
315 {
316         static int wiphy_counter;
317
318         struct cfg80211_registered_device *rdev;
319         int alloc_size;
320
321         WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
322         WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
323         WARN_ON(ops->connect && !ops->disconnect);
324         WARN_ON(ops->join_ibss && !ops->leave_ibss);
325         WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
326         WARN_ON(ops->add_station && !ops->del_station);
327         WARN_ON(ops->add_mpath && !ops->del_mpath);
328
329         alloc_size = sizeof(*rdev) + sizeof_priv;
330
331         rdev = kzalloc(alloc_size, GFP_KERNEL);
332         if (!rdev)
333                 return NULL;
334
335         rdev->ops = ops;
336
337         mutex_lock(&cfg80211_mutex);
338
339         rdev->wiphy_idx = wiphy_counter++;
340
341         if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) {
342                 wiphy_counter--;
343                 mutex_unlock(&cfg80211_mutex);
344                 /* ugh, wrapped! */
345                 kfree(rdev);
346                 return NULL;
347         }
348
349         mutex_unlock(&cfg80211_mutex);
350
351         /* give it a proper name */
352         dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
353
354         mutex_init(&rdev->mtx);
355         mutex_init(&rdev->devlist_mtx);
356         INIT_LIST_HEAD(&rdev->netdev_list);
357         spin_lock_init(&rdev->bss_lock);
358         INIT_LIST_HEAD(&rdev->bss_list);
359         INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
360
361         device_initialize(&rdev->wiphy.dev);
362         rdev->wiphy.dev.class = &ieee80211_class;
363         rdev->wiphy.dev.platform_data = rdev;
364
365         rdev->wiphy.ps_default = CONFIG_CFG80211_DEFAULT_PS_VALUE;
366
367         wiphy_net_set(&rdev->wiphy, &init_net);
368
369         rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
370         rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
371                                    &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
372                                    &rdev->rfkill_ops, rdev);
373
374         if (!rdev->rfkill) {
375                 kfree(rdev);
376                 return NULL;
377         }
378
379         INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
380         INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
381         INIT_WORK(&rdev->event_work, cfg80211_event_work);
382
383         init_waitqueue_head(&rdev->dev_wait);
384
385         /*
386          * Initialize wiphy parameters to IEEE 802.11 MIB default values.
387          * Fragmentation and RTS threshold are disabled by default with the
388          * special -1 value.
389          */
390         rdev->wiphy.retry_short = 7;
391         rdev->wiphy.retry_long = 4;
392         rdev->wiphy.frag_threshold = (u32) -1;
393         rdev->wiphy.rts_threshold = (u32) -1;
394
395         return &rdev->wiphy;
396 }
397 EXPORT_SYMBOL(wiphy_new);
398
399 int wiphy_register(struct wiphy *wiphy)
400 {
401         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
402         int res;
403         enum ieee80211_band band;
404         struct ieee80211_supported_band *sband;
405         bool have_band = false;
406         int i;
407         u16 ifmodes = wiphy->interface_modes;
408
409         /* sanity check ifmodes */
410         WARN_ON(!ifmodes);
411         ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1;
412         if (WARN_ON(ifmodes != wiphy->interface_modes))
413                 wiphy->interface_modes = ifmodes;
414
415         /* sanity check supported bands/channels */
416         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
417                 sband = wiphy->bands[band];
418                 if (!sband)
419                         continue;
420
421                 sband->band = band;
422
423                 if (WARN_ON(!sband->n_channels || !sband->n_bitrates))
424                         return -EINVAL;
425
426                 /*
427                  * Since we use a u32 for rate bitmaps in
428                  * ieee80211_get_response_rate, we cannot
429                  * have more than 32 legacy rates.
430                  */
431                 if (WARN_ON(sband->n_bitrates > 32))
432                         return -EINVAL;
433
434                 for (i = 0; i < sband->n_channels; i++) {
435                         sband->channels[i].orig_flags =
436                                 sband->channels[i].flags;
437                         sband->channels[i].orig_mag =
438                                 sband->channels[i].max_antenna_gain;
439                         sband->channels[i].orig_mpwr =
440                                 sband->channels[i].max_power;
441                         sband->channels[i].band = band;
442                 }
443
444                 have_band = true;
445         }
446
447         if (!have_band) {
448                 WARN_ON(1);
449                 return -EINVAL;
450         }
451
452         /* check and set up bitrates */
453         ieee80211_set_bitrate_flags(wiphy);
454
455         res = device_add(&rdev->wiphy.dev);
456         if (res)
457                 return res;
458
459         res = rfkill_register(rdev->rfkill);
460         if (res)
461                 goto out_rm_dev;
462
463         mutex_lock(&cfg80211_mutex);
464
465         /* set up regulatory info */
466         wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
467
468         list_add(&rdev->list, &cfg80211_rdev_list);
469         cfg80211_rdev_list_generation++;
470
471         mutex_unlock(&cfg80211_mutex);
472
473         /* add to debugfs */
474         rdev->wiphy.debugfsdir =
475                 debugfs_create_dir(wiphy_name(&rdev->wiphy),
476                                    ieee80211_debugfs_dir);
477         if (IS_ERR(rdev->wiphy.debugfsdir))
478                 rdev->wiphy.debugfsdir = NULL;
479
480         if (wiphy->custom_regulatory) {
481                 struct regulatory_request request;
482
483                 request.wiphy_idx = get_wiphy_idx(wiphy);
484                 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
485                 request.alpha2[0] = '9';
486                 request.alpha2[1] = '9';
487
488                 nl80211_send_reg_change_event(&request);
489         }
490
491         cfg80211_debugfs_rdev_add(rdev);
492
493         return 0;
494
495  out_rm_dev:
496         device_del(&rdev->wiphy.dev);
497         return res;
498 }
499 EXPORT_SYMBOL(wiphy_register);
500
501 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
502 {
503         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
504
505         if (!rdev->ops->rfkill_poll)
506                 return;
507         rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
508         rfkill_resume_polling(rdev->rfkill);
509 }
510 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
511
512 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
513 {
514         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
515
516         rfkill_pause_polling(rdev->rfkill);
517 }
518 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
519
520 void wiphy_unregister(struct wiphy *wiphy)
521 {
522         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
523
524         rfkill_unregister(rdev->rfkill);
525
526         /* protect the device list */
527         mutex_lock(&cfg80211_mutex);
528
529         wait_event(rdev->dev_wait, ({
530                 int __count;
531                 mutex_lock(&rdev->devlist_mtx);
532                 __count = rdev->opencount;
533                 mutex_unlock(&rdev->devlist_mtx);
534                 __count == 0;}));
535
536         mutex_lock(&rdev->devlist_mtx);
537         BUG_ON(!list_empty(&rdev->netdev_list));
538         mutex_unlock(&rdev->devlist_mtx);
539
540         /*
541          * First remove the hardware from everywhere, this makes
542          * it impossible to find from userspace.
543          */
544         cfg80211_debugfs_rdev_del(rdev);
545         list_del(&rdev->list);
546
547         /*
548          * Try to grab rdev->mtx. If a command is still in progress,
549          * hopefully the driver will refuse it since it's tearing
550          * down the device already. We wait for this command to complete
551          * before unlinking the item from the list.
552          * Note: as codified by the BUG_ON above we cannot get here if
553          * a virtual interface is still present. Hence, we can only get
554          * to lock contention here if userspace issues a command that
555          * identified the hardware by wiphy index.
556          */
557         cfg80211_lock_rdev(rdev);
558         /* nothing */
559         cfg80211_unlock_rdev(rdev);
560
561         /* If this device got a regulatory hint tell core its
562          * free to listen now to a new shiny device regulatory hint */
563         reg_device_remove(wiphy);
564
565         cfg80211_rdev_list_generation++;
566         device_del(&rdev->wiphy.dev);
567         debugfs_remove(rdev->wiphy.debugfsdir);
568
569         mutex_unlock(&cfg80211_mutex);
570
571         flush_work(&rdev->scan_done_wk);
572         cancel_work_sync(&rdev->conn_work);
573         flush_work(&rdev->event_work);
574 }
575 EXPORT_SYMBOL(wiphy_unregister);
576
577 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
578 {
579         struct cfg80211_internal_bss *scan, *tmp;
580         rfkill_destroy(rdev->rfkill);
581         mutex_destroy(&rdev->mtx);
582         mutex_destroy(&rdev->devlist_mtx);
583         list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
584                 cfg80211_put_bss(&scan->pub);
585         kfree(rdev);
586 }
587
588 void wiphy_free(struct wiphy *wiphy)
589 {
590         put_device(&wiphy->dev);
591 }
592 EXPORT_SYMBOL(wiphy_free);
593
594 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
595 {
596         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
597
598         if (rfkill_set_hw_state(rdev->rfkill, blocked))
599                 schedule_work(&rdev->rfkill_sync);
600 }
601 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
602
603 static void wdev_cleanup_work(struct work_struct *work)
604 {
605         struct wireless_dev *wdev;
606         struct cfg80211_registered_device *rdev;
607
608         wdev = container_of(work, struct wireless_dev, cleanup_work);
609         rdev = wiphy_to_dev(wdev->wiphy);
610
611         cfg80211_lock_rdev(rdev);
612
613         if (WARN_ON(rdev->scan_req && rdev->scan_req->dev == wdev->netdev)) {
614                 rdev->scan_req->aborted = true;
615                 ___cfg80211_scan_done(rdev, true);
616         }
617
618         cfg80211_unlock_rdev(rdev);
619
620         mutex_lock(&rdev->devlist_mtx);
621         rdev->opencount--;
622         mutex_unlock(&rdev->devlist_mtx);
623         wake_up(&rdev->dev_wait);
624
625         dev_put(wdev->netdev);
626 }
627
628 static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
629                                          unsigned long state,
630                                          void *ndev)
631 {
632         struct net_device *dev = ndev;
633         struct wireless_dev *wdev = dev->ieee80211_ptr;
634         struct cfg80211_registered_device *rdev;
635
636         if (!wdev)
637                 return NOTIFY_DONE;
638
639         rdev = wiphy_to_dev(wdev->wiphy);
640
641         WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
642
643         switch (state) {
644         case NETDEV_REGISTER:
645                 /*
646                  * NB: cannot take rdev->mtx here because this may be
647                  * called within code protected by it when interfaces
648                  * are added with nl80211.
649                  */
650                 mutex_init(&wdev->mtx);
651                 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
652                 INIT_LIST_HEAD(&wdev->event_list);
653                 spin_lock_init(&wdev->event_lock);
654                 mutex_lock(&rdev->devlist_mtx);
655                 list_add(&wdev->list, &rdev->netdev_list);
656                 rdev->devlist_generation++;
657                 /* can only change netns with wiphy */
658                 dev->features |= NETIF_F_NETNS_LOCAL;
659
660                 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
661                                       "phy80211")) {
662                         printk(KERN_ERR "wireless: failed to add phy80211 "
663                                 "symlink to netdev!\n");
664                 }
665                 wdev->netdev = dev;
666                 wdev->sme_state = CFG80211_SME_IDLE;
667                 mutex_unlock(&rdev->devlist_mtx);
668 #ifdef CONFIG_WIRELESS_EXT
669                 if (!dev->wireless_handlers)
670                         dev->wireless_handlers = &cfg80211_wext_handler;
671                 wdev->wext.default_key = -1;
672                 wdev->wext.default_mgmt_key = -1;
673                 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
674                 wdev->wext.ps = wdev->wiphy->ps_default;
675                 wdev->wext.ps_timeout = 100;
676                 if (rdev->ops->set_power_mgmt)
677                         if (rdev->ops->set_power_mgmt(wdev->wiphy, dev,
678                                                       wdev->wext.ps,
679                                                       wdev->wext.ps_timeout)) {
680                                 /* assume this means it's off */
681                                 wdev->wext.ps = false;
682                         }
683 #endif
684                 break;
685         case NETDEV_GOING_DOWN:
686                 switch (wdev->iftype) {
687                 case NL80211_IFTYPE_ADHOC:
688                         cfg80211_leave_ibss(rdev, dev, true);
689                         break;
690                 case NL80211_IFTYPE_STATION:
691                         wdev_lock(wdev);
692 #ifdef CONFIG_WIRELESS_EXT
693                         kfree(wdev->wext.ie);
694                         wdev->wext.ie = NULL;
695                         wdev->wext.ie_len = 0;
696                         wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
697 #endif
698                         __cfg80211_disconnect(rdev, dev,
699                                               WLAN_REASON_DEAUTH_LEAVING, true);
700                         cfg80211_mlme_down(rdev, dev);
701                         wdev_unlock(wdev);
702                         break;
703                 default:
704                         break;
705                 }
706                 break;
707         case NETDEV_DOWN:
708                 dev_hold(dev);
709                 schedule_work(&wdev->cleanup_work);
710                 break;
711         case NETDEV_UP:
712                 /*
713                  * If we have a really quick DOWN/UP succession we may
714                  * have this work still pending ... cancel it and see
715                  * if it was pending, in which case we need to account
716                  * for some of the work it would have done.
717                  */
718                 if (cancel_work_sync(&wdev->cleanup_work)) {
719                         mutex_lock(&rdev->devlist_mtx);
720                         rdev->opencount--;
721                         mutex_unlock(&rdev->devlist_mtx);
722                         dev_put(dev);
723                 }
724 #ifdef CONFIG_WIRELESS_EXT
725                 cfg80211_lock_rdev(rdev);
726                 mutex_lock(&rdev->devlist_mtx);
727                 wdev_lock(wdev);
728                 switch (wdev->iftype) {
729                 case NL80211_IFTYPE_ADHOC:
730                         cfg80211_ibss_wext_join(rdev, wdev);
731                         break;
732                 case NL80211_IFTYPE_STATION:
733                         cfg80211_mgd_wext_connect(rdev, wdev);
734                         break;
735                 default:
736                         break;
737                 }
738                 wdev_unlock(wdev);
739                 rdev->opencount++;
740                 mutex_unlock(&rdev->devlist_mtx);
741                 cfg80211_unlock_rdev(rdev);
742 #endif
743                 break;
744         case NETDEV_UNREGISTER:
745                 /*
746                  * NB: cannot take rdev->mtx here because this may be
747                  * called within code protected by it when interfaces
748                  * are removed with nl80211.
749                  */
750                 mutex_lock(&rdev->devlist_mtx);
751                 /*
752                  * It is possible to get NETDEV_UNREGISTER
753                  * multiple times. To detect that, check
754                  * that the interface is still on the list
755                  * of registered interfaces, and only then
756                  * remove and clean it up.
757                  */
758                 if (!list_empty(&wdev->list)) {
759                         sysfs_remove_link(&dev->dev.kobj, "phy80211");
760                         list_del_init(&wdev->list);
761                         rdev->devlist_generation++;
762 #ifdef CONFIG_WIRELESS_EXT
763                         kfree(wdev->wext.keys);
764 #endif
765                 }
766                 mutex_unlock(&rdev->devlist_mtx);
767                 break;
768         case NETDEV_PRE_UP:
769                 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
770                         return notifier_from_errno(-EOPNOTSUPP);
771                 if (rfkill_blocked(rdev->rfkill))
772                         return notifier_from_errno(-ERFKILL);
773                 break;
774         }
775
776         return NOTIFY_DONE;
777 }
778
779 static struct notifier_block cfg80211_netdev_notifier = {
780         .notifier_call = cfg80211_netdev_notifier_call,
781 };
782
783 static void __net_exit cfg80211_pernet_exit(struct net *net)
784 {
785         struct cfg80211_registered_device *rdev;
786
787         rtnl_lock();
788         mutex_lock(&cfg80211_mutex);
789         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
790                 if (net_eq(wiphy_net(&rdev->wiphy), net))
791                         WARN_ON(cfg80211_switch_netns(rdev, &init_net));
792         }
793         mutex_unlock(&cfg80211_mutex);
794         rtnl_unlock();
795 }
796
797 static struct pernet_operations cfg80211_pernet_ops = {
798         .exit = cfg80211_pernet_exit,
799 };
800
801 static int __init cfg80211_init(void)
802 {
803         int err;
804
805         err = register_pernet_device(&cfg80211_pernet_ops);
806         if (err)
807                 goto out_fail_pernet;
808
809         err = wiphy_sysfs_init();
810         if (err)
811                 goto out_fail_sysfs;
812
813         err = register_netdevice_notifier(&cfg80211_netdev_notifier);
814         if (err)
815                 goto out_fail_notifier;
816
817         err = nl80211_init();
818         if (err)
819                 goto out_fail_nl80211;
820
821         ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
822
823         err = regulatory_init();
824         if (err)
825                 goto out_fail_reg;
826
827         return 0;
828
829 out_fail_reg:
830         debugfs_remove(ieee80211_debugfs_dir);
831 out_fail_nl80211:
832         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
833 out_fail_notifier:
834         wiphy_sysfs_exit();
835 out_fail_sysfs:
836         unregister_pernet_device(&cfg80211_pernet_ops);
837 out_fail_pernet:
838         return err;
839 }
840 subsys_initcall(cfg80211_init);
841
842 static void cfg80211_exit(void)
843 {
844         debugfs_remove(ieee80211_debugfs_dir);
845         nl80211_exit();
846         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
847         wiphy_sysfs_exit();
848         regulatory_exit();
849         unregister_pernet_device(&cfg80211_pernet_ops);
850 }
851 module_exit(cfg80211_exit);