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