cfg80211: check lost scans later, fix bug
[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_process_events(struct wireless_dev *wdev)
298 {
299         struct cfg80211_event *ev;
300         unsigned long flags;
301
302         spin_lock_irqsave(&wdev->event_lock, flags);
303         while (!list_empty(&wdev->event_list)) {
304                 ev = list_first_entry(&wdev->event_list,
305                                       struct cfg80211_event, list);
306                 list_del(&ev->list);
307                 spin_unlock_irqrestore(&wdev->event_lock, flags);
308
309                 wdev_lock(wdev);
310                 switch (ev->type) {
311                 case EVENT_CONNECT_RESULT:
312                         __cfg80211_connect_result(
313                                 wdev->netdev, is_zero_ether_addr(ev->cr.bssid) ?
314                                 NULL : ev->cr.bssid,
315                                 ev->cr.req_ie, ev->cr.req_ie_len,
316                                 ev->cr.resp_ie, ev->cr.resp_ie_len,
317                                 ev->cr.status,
318                                 ev->cr.status == WLAN_STATUS_SUCCESS,
319                                 NULL);
320                         break;
321                 case EVENT_ROAMED:
322                         __cfg80211_roamed(wdev, ev->rm.bssid,
323                                           ev->rm.req_ie, ev->rm.req_ie_len,
324                                           ev->rm.resp_ie, ev->rm.resp_ie_len);
325                         break;
326                 case EVENT_DISCONNECTED:
327                         __cfg80211_disconnected(wdev->netdev,
328                                                 ev->dc.ie, ev->dc.ie_len,
329                                                 ev->dc.reason, true);
330                         break;
331                 case EVENT_IBSS_JOINED:
332                         __cfg80211_ibss_joined(wdev->netdev, ev->ij.bssid);
333                         break;
334                 }
335                 wdev_unlock(wdev);
336
337                 kfree(ev);
338
339                 spin_lock_irqsave(&wdev->event_lock, flags);
340         }
341         spin_unlock_irqrestore(&wdev->event_lock, flags);
342 }
343
344 static void cfg80211_event_work(struct work_struct *work)
345 {
346         struct cfg80211_registered_device *rdev;
347         struct wireless_dev *wdev;
348
349         rdev = container_of(work, struct cfg80211_registered_device,
350                             event_work);
351
352         rtnl_lock();
353         cfg80211_lock_rdev(rdev);
354         mutex_lock(&rdev->devlist_mtx);
355
356         list_for_each_entry(wdev, &rdev->netdev_list, list)
357                 cfg80211_process_events(wdev);
358
359         mutex_unlock(&rdev->devlist_mtx);
360         cfg80211_unlock_rdev(rdev);
361         rtnl_unlock();
362 }
363
364 /* exported functions */
365
366 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
367 {
368         static int wiphy_counter;
369
370         struct cfg80211_registered_device *rdev;
371         int alloc_size;
372
373         WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
374         WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
375         WARN_ON(ops->connect && !ops->disconnect);
376         WARN_ON(ops->join_ibss && !ops->leave_ibss);
377         WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
378         WARN_ON(ops->add_station && !ops->del_station);
379         WARN_ON(ops->add_mpath && !ops->del_mpath);
380
381         alloc_size = sizeof(*rdev) + sizeof_priv;
382
383         rdev = kzalloc(alloc_size, GFP_KERNEL);
384         if (!rdev)
385                 return NULL;
386
387         rdev->ops = ops;
388
389         mutex_lock(&cfg80211_mutex);
390
391         rdev->wiphy_idx = wiphy_counter++;
392
393         if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) {
394                 wiphy_counter--;
395                 mutex_unlock(&cfg80211_mutex);
396                 /* ugh, wrapped! */
397                 kfree(rdev);
398                 return NULL;
399         }
400
401         mutex_unlock(&cfg80211_mutex);
402
403         /* give it a proper name */
404         dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
405
406         mutex_init(&rdev->mtx);
407         mutex_init(&rdev->devlist_mtx);
408         INIT_LIST_HEAD(&rdev->netdev_list);
409         spin_lock_init(&rdev->bss_lock);
410         INIT_LIST_HEAD(&rdev->bss_list);
411         INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
412
413         device_initialize(&rdev->wiphy.dev);
414         rdev->wiphy.dev.class = &ieee80211_class;
415         rdev->wiphy.dev.platform_data = rdev;
416
417         rdev->wiphy.ps_default = CONFIG_CFG80211_DEFAULT_PS_VALUE;
418
419         wiphy_net_set(&rdev->wiphy, &init_net);
420
421         rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
422         rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
423                                    &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
424                                    &rdev->rfkill_ops, rdev);
425
426         if (!rdev->rfkill) {
427                 kfree(rdev);
428                 return NULL;
429         }
430
431         INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
432         INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
433         INIT_WORK(&rdev->event_work, cfg80211_event_work);
434
435         init_waitqueue_head(&rdev->dev_wait);
436
437         /*
438          * Initialize wiphy parameters to IEEE 802.11 MIB default values.
439          * Fragmentation and RTS threshold are disabled by default with the
440          * special -1 value.
441          */
442         rdev->wiphy.retry_short = 7;
443         rdev->wiphy.retry_long = 4;
444         rdev->wiphy.frag_threshold = (u32) -1;
445         rdev->wiphy.rts_threshold = (u32) -1;
446
447         return &rdev->wiphy;
448 }
449 EXPORT_SYMBOL(wiphy_new);
450
451 int wiphy_register(struct wiphy *wiphy)
452 {
453         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
454         int res;
455         enum ieee80211_band band;
456         struct ieee80211_supported_band *sband;
457         bool have_band = false;
458         int i;
459         u16 ifmodes = wiphy->interface_modes;
460
461         /* sanity check ifmodes */
462         WARN_ON(!ifmodes);
463         ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1;
464         if (WARN_ON(ifmodes != wiphy->interface_modes))
465                 wiphy->interface_modes = ifmodes;
466
467         /* sanity check supported bands/channels */
468         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
469                 sband = wiphy->bands[band];
470                 if (!sband)
471                         continue;
472
473                 sband->band = band;
474
475                 if (WARN_ON(!sband->n_channels || !sband->n_bitrates))
476                         return -EINVAL;
477
478                 /*
479                  * Since we use a u32 for rate bitmaps in
480                  * ieee80211_get_response_rate, we cannot
481                  * have more than 32 legacy rates.
482                  */
483                 if (WARN_ON(sband->n_bitrates > 32))
484                         return -EINVAL;
485
486                 for (i = 0; i < sband->n_channels; i++) {
487                         sband->channels[i].orig_flags =
488                                 sband->channels[i].flags;
489                         sband->channels[i].orig_mag =
490                                 sband->channels[i].max_antenna_gain;
491                         sband->channels[i].orig_mpwr =
492                                 sband->channels[i].max_power;
493                         sband->channels[i].band = band;
494                 }
495
496                 have_band = true;
497         }
498
499         if (!have_band) {
500                 WARN_ON(1);
501                 return -EINVAL;
502         }
503
504         /* check and set up bitrates */
505         ieee80211_set_bitrate_flags(wiphy);
506
507         res = device_add(&rdev->wiphy.dev);
508         if (res)
509                 return res;
510
511         res = rfkill_register(rdev->rfkill);
512         if (res)
513                 goto out_rm_dev;
514
515         mutex_lock(&cfg80211_mutex);
516
517         /* set up regulatory info */
518         wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
519
520         list_add(&rdev->list, &cfg80211_rdev_list);
521         cfg80211_rdev_list_generation++;
522
523         mutex_unlock(&cfg80211_mutex);
524
525         /* add to debugfs */
526         rdev->wiphy.debugfsdir =
527                 debugfs_create_dir(wiphy_name(&rdev->wiphy),
528                                    ieee80211_debugfs_dir);
529         if (IS_ERR(rdev->wiphy.debugfsdir))
530                 rdev->wiphy.debugfsdir = NULL;
531
532         if (wiphy->custom_regulatory) {
533                 struct regulatory_request request;
534
535                 request.wiphy_idx = get_wiphy_idx(wiphy);
536                 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
537                 request.alpha2[0] = '9';
538                 request.alpha2[1] = '9';
539
540                 nl80211_send_reg_change_event(&request);
541         }
542
543         cfg80211_debugfs_rdev_add(rdev);
544
545         return 0;
546
547  out_rm_dev:
548         device_del(&rdev->wiphy.dev);
549         return res;
550 }
551 EXPORT_SYMBOL(wiphy_register);
552
553 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
554 {
555         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
556
557         if (!rdev->ops->rfkill_poll)
558                 return;
559         rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
560         rfkill_resume_polling(rdev->rfkill);
561 }
562 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
563
564 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
565 {
566         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
567
568         rfkill_pause_polling(rdev->rfkill);
569 }
570 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
571
572 void wiphy_unregister(struct wiphy *wiphy)
573 {
574         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
575
576         rfkill_unregister(rdev->rfkill);
577
578         /* protect the device list */
579         mutex_lock(&cfg80211_mutex);
580
581         wait_event(rdev->dev_wait, ({
582                 int __count;
583                 mutex_lock(&rdev->devlist_mtx);
584                 __count = rdev->opencount;
585                 mutex_unlock(&rdev->devlist_mtx);
586                 __count == 0;}));
587
588         mutex_lock(&rdev->devlist_mtx);
589         BUG_ON(!list_empty(&rdev->netdev_list));
590         mutex_unlock(&rdev->devlist_mtx);
591
592         /*
593          * First remove the hardware from everywhere, this makes
594          * it impossible to find from userspace.
595          */
596         cfg80211_debugfs_rdev_del(rdev);
597         list_del(&rdev->list);
598
599         /*
600          * Try to grab rdev->mtx. If a command is still in progress,
601          * hopefully the driver will refuse it since it's tearing
602          * down the device already. We wait for this command to complete
603          * before unlinking the item from the list.
604          * Note: as codified by the BUG_ON above we cannot get here if
605          * a virtual interface is still present. Hence, we can only get
606          * to lock contention here if userspace issues a command that
607          * identified the hardware by wiphy index.
608          */
609         cfg80211_lock_rdev(rdev);
610         /* nothing */
611         cfg80211_unlock_rdev(rdev);
612
613         /* If this device got a regulatory hint tell core its
614          * free to listen now to a new shiny device regulatory hint */
615         reg_device_remove(wiphy);
616
617         cfg80211_rdev_list_generation++;
618         device_del(&rdev->wiphy.dev);
619         debugfs_remove(rdev->wiphy.debugfsdir);
620
621         mutex_unlock(&cfg80211_mutex);
622
623         flush_work(&rdev->scan_done_wk);
624         cancel_work_sync(&rdev->conn_work);
625         flush_work(&rdev->event_work);
626 }
627 EXPORT_SYMBOL(wiphy_unregister);
628
629 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
630 {
631         struct cfg80211_internal_bss *scan, *tmp;
632         rfkill_destroy(rdev->rfkill);
633         mutex_destroy(&rdev->mtx);
634         mutex_destroy(&rdev->devlist_mtx);
635         list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
636                 cfg80211_put_bss(&scan->pub);
637         kfree(rdev);
638 }
639
640 void wiphy_free(struct wiphy *wiphy)
641 {
642         put_device(&wiphy->dev);
643 }
644 EXPORT_SYMBOL(wiphy_free);
645
646 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
647 {
648         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
649
650         if (rfkill_set_hw_state(rdev->rfkill, blocked))
651                 schedule_work(&rdev->rfkill_sync);
652 }
653 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
654
655 static void wdev_cleanup_work(struct work_struct *work)
656 {
657         struct wireless_dev *wdev;
658         struct cfg80211_registered_device *rdev;
659
660         wdev = container_of(work, struct wireless_dev, cleanup_work);
661         rdev = wiphy_to_dev(wdev->wiphy);
662
663         cfg80211_lock_rdev(rdev);
664
665         if (WARN_ON(rdev->scan_req && rdev->scan_req->dev == wdev->netdev)) {
666                 rdev->scan_req->aborted = true;
667                 ___cfg80211_scan_done(rdev, true);
668         }
669
670         cfg80211_unlock_rdev(rdev);
671
672         mutex_lock(&rdev->devlist_mtx);
673         rdev->opencount--;
674         mutex_unlock(&rdev->devlist_mtx);
675         wake_up(&rdev->dev_wait);
676
677         dev_put(wdev->netdev);
678 }
679
680 static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
681                                          unsigned long state,
682                                          void *ndev)
683 {
684         struct net_device *dev = ndev;
685         struct wireless_dev *wdev = dev->ieee80211_ptr;
686         struct cfg80211_registered_device *rdev;
687
688         if (!wdev)
689                 return NOTIFY_DONE;
690
691         rdev = wiphy_to_dev(wdev->wiphy);
692
693         WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
694
695         switch (state) {
696         case NETDEV_REGISTER:
697                 /*
698                  * NB: cannot take rdev->mtx here because this may be
699                  * called within code protected by it when interfaces
700                  * are added with nl80211.
701                  */
702                 mutex_init(&wdev->mtx);
703                 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
704                 INIT_LIST_HEAD(&wdev->event_list);
705                 spin_lock_init(&wdev->event_lock);
706                 mutex_lock(&rdev->devlist_mtx);
707                 list_add(&wdev->list, &rdev->netdev_list);
708                 rdev->devlist_generation++;
709                 /* can only change netns with wiphy */
710                 dev->features |= NETIF_F_NETNS_LOCAL;
711
712                 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
713                                       "phy80211")) {
714                         printk(KERN_ERR "wireless: failed to add phy80211 "
715                                 "symlink to netdev!\n");
716                 }
717                 wdev->netdev = dev;
718                 wdev->sme_state = CFG80211_SME_IDLE;
719                 mutex_unlock(&rdev->devlist_mtx);
720 #ifdef CONFIG_WIRELESS_EXT
721                 if (!dev->wireless_handlers)
722                         dev->wireless_handlers = &cfg80211_wext_handler;
723                 wdev->wext.default_key = -1;
724                 wdev->wext.default_mgmt_key = -1;
725                 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
726                 wdev->wext.ps = wdev->wiphy->ps_default;
727                 wdev->wext.ps_timeout = 100;
728                 if (rdev->ops->set_power_mgmt)
729                         if (rdev->ops->set_power_mgmt(wdev->wiphy, dev,
730                                                       wdev->wext.ps,
731                                                       wdev->wext.ps_timeout)) {
732                                 /* assume this means it's off */
733                                 wdev->wext.ps = false;
734                         }
735 #endif
736                 break;
737         case NETDEV_GOING_DOWN:
738                 switch (wdev->iftype) {
739                 case NL80211_IFTYPE_ADHOC:
740                         cfg80211_leave_ibss(rdev, dev, true);
741                         break;
742                 case NL80211_IFTYPE_STATION:
743                         wdev_lock(wdev);
744 #ifdef CONFIG_WIRELESS_EXT
745                         kfree(wdev->wext.ie);
746                         wdev->wext.ie = NULL;
747                         wdev->wext.ie_len = 0;
748                         wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
749 #endif
750                         __cfg80211_disconnect(rdev, dev,
751                                               WLAN_REASON_DEAUTH_LEAVING, true);
752                         cfg80211_mlme_down(rdev, dev);
753                         wdev_unlock(wdev);
754                         break;
755                 default:
756                         break;
757                 }
758                 break;
759         case NETDEV_DOWN:
760                 dev_hold(dev);
761                 schedule_work(&wdev->cleanup_work);
762                 break;
763         case NETDEV_UP:
764                 /*
765                  * If we have a really quick DOWN/UP succession we may
766                  * have this work still pending ... cancel it and see
767                  * if it was pending, in which case we need to account
768                  * for some of the work it would have done.
769                  */
770                 if (cancel_work_sync(&wdev->cleanup_work)) {
771                         mutex_lock(&rdev->devlist_mtx);
772                         rdev->opencount--;
773                         mutex_unlock(&rdev->devlist_mtx);
774                         dev_put(dev);
775                 }
776 #ifdef CONFIG_WIRELESS_EXT
777                 cfg80211_lock_rdev(rdev);
778                 mutex_lock(&rdev->devlist_mtx);
779                 wdev_lock(wdev);
780                 switch (wdev->iftype) {
781                 case NL80211_IFTYPE_ADHOC:
782                         cfg80211_ibss_wext_join(rdev, wdev);
783                         break;
784                 case NL80211_IFTYPE_STATION:
785                         cfg80211_mgd_wext_connect(rdev, wdev);
786                         break;
787                 default:
788                         break;
789                 }
790                 wdev_unlock(wdev);
791                 rdev->opencount++;
792                 mutex_unlock(&rdev->devlist_mtx);
793                 cfg80211_unlock_rdev(rdev);
794 #endif
795                 break;
796         case NETDEV_UNREGISTER:
797                 /*
798                  * NB: cannot take rdev->mtx here because this may be
799                  * called within code protected by it when interfaces
800                  * are removed with nl80211.
801                  */
802                 mutex_lock(&rdev->devlist_mtx);
803                 /*
804                  * It is possible to get NETDEV_UNREGISTER
805                  * multiple times. To detect that, check
806                  * that the interface is still on the list
807                  * of registered interfaces, and only then
808                  * remove and clean it up.
809                  */
810                 if (!list_empty(&wdev->list)) {
811                         sysfs_remove_link(&dev->dev.kobj, "phy80211");
812                         list_del_init(&wdev->list);
813                         rdev->devlist_generation++;
814 #ifdef CONFIG_WIRELESS_EXT
815                         kfree(wdev->wext.keys);
816 #endif
817                 }
818                 mutex_unlock(&rdev->devlist_mtx);
819                 break;
820         case NETDEV_PRE_UP:
821                 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
822                         return notifier_from_errno(-EOPNOTSUPP);
823                 if (rfkill_blocked(rdev->rfkill))
824                         return notifier_from_errno(-ERFKILL);
825                 break;
826         }
827
828         return NOTIFY_DONE;
829 }
830
831 static struct notifier_block cfg80211_netdev_notifier = {
832         .notifier_call = cfg80211_netdev_notifier_call,
833 };
834
835 static void __net_exit cfg80211_pernet_exit(struct net *net)
836 {
837         struct cfg80211_registered_device *rdev;
838
839         rtnl_lock();
840         mutex_lock(&cfg80211_mutex);
841         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
842                 if (net_eq(wiphy_net(&rdev->wiphy), net))
843                         WARN_ON(cfg80211_switch_netns(rdev, &init_net));
844         }
845         mutex_unlock(&cfg80211_mutex);
846         rtnl_unlock();
847 }
848
849 static struct pernet_operations cfg80211_pernet_ops = {
850         .exit = cfg80211_pernet_exit,
851 };
852
853 static int __init cfg80211_init(void)
854 {
855         int err;
856
857         err = register_pernet_device(&cfg80211_pernet_ops);
858         if (err)
859                 goto out_fail_pernet;
860
861         err = wiphy_sysfs_init();
862         if (err)
863                 goto out_fail_sysfs;
864
865         err = register_netdevice_notifier(&cfg80211_netdev_notifier);
866         if (err)
867                 goto out_fail_notifier;
868
869         err = nl80211_init();
870         if (err)
871                 goto out_fail_nl80211;
872
873         ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
874
875         err = regulatory_init();
876         if (err)
877                 goto out_fail_reg;
878
879         return 0;
880
881 out_fail_reg:
882         debugfs_remove(ieee80211_debugfs_dir);
883 out_fail_nl80211:
884         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
885 out_fail_notifier:
886         wiphy_sysfs_exit();
887 out_fail_sysfs:
888         unregister_pernet_device(&cfg80211_pernet_ops);
889 out_fail_pernet:
890         return err;
891 }
892 subsys_initcall(cfg80211_init);
893
894 static void cfg80211_exit(void)
895 {
896         debugfs_remove(ieee80211_debugfs_dir);
897         nl80211_exit();
898         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
899         wiphy_sysfs_exit();
900         regulatory_exit();
901         unregister_pernet_device(&cfg80211_pernet_ops);
902 }
903 module_exit(cfg80211_exit);