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 wiphy_idx, taken = -1, result, digits; 182 183 assert_cfg80211_lock(); 184 185 /* prohibit calling the thing phy%d when %d is not its number */ 186 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken); 187 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) { 188 /* count number of places needed to print wiphy_idx */ 189 digits = 1; 190 while (wiphy_idx /= 10) 191 digits++; 192 /* 193 * deny the name if it is phy<idx> where <idx> is printed 194 * without leading zeroes. taken == strlen(newname) here 195 */ 196 if (taken == strlen(PHY_NAME) + digits) 197 return -EINVAL; 198 } 199 200 201 /* Ignore nop renames */ 202 if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0) 203 return 0; 204 205 /* Ensure another device does not already have this name. */ 206 list_for_each_entry(rdev2, &cfg80211_rdev_list, list) 207 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0) 208 return -EINVAL; 209 210 result = device_rename(&rdev->wiphy.dev, newname); 211 if (result) 212 return result; 213 214 if (rdev->wiphy.debugfsdir && 215 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent, 216 rdev->wiphy.debugfsdir, 217 rdev->wiphy.debugfsdir->d_parent, 218 newname)) 219 printk(KERN_ERR "cfg80211: failed to rename debugfs dir to %s!\n", 220 newname); 221 222 nl80211_notify_dev_rename(rdev); 223 224 return 0; 225 } 226 227 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev, 228 struct net *net) 229 { 230 struct wireless_dev *wdev; 231 int err = 0; 232 233 if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK)) 234 return -EOPNOTSUPP; 235 236 list_for_each_entry(wdev, &rdev->netdev_list, list) { 237 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL; 238 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d"); 239 if (err) 240 break; 241 wdev->netdev->features |= NETIF_F_NETNS_LOCAL; 242 } 243 244 if (err) { 245 /* failed -- clean up to old netns */ 246 net = wiphy_net(&rdev->wiphy); 247 248 list_for_each_entry_continue_reverse(wdev, &rdev->netdev_list, 249 list) { 250 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL; 251 err = dev_change_net_namespace(wdev->netdev, net, 252 "wlan%d"); 253 WARN_ON(err); 254 wdev->netdev->features |= NETIF_F_NETNS_LOCAL; 255 } 256 257 return err; 258 } 259 260 wiphy_net_set(&rdev->wiphy, net); 261 262 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev)); 263 WARN_ON(err); 264 265 return 0; 266 } 267 268 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data) 269 { 270 struct cfg80211_registered_device *rdev = data; 271 272 rdev->ops->rfkill_poll(&rdev->wiphy); 273 } 274 275 static int cfg80211_rfkill_set_block(void *data, bool blocked) 276 { 277 struct cfg80211_registered_device *rdev = data; 278 struct wireless_dev *wdev; 279 280 if (!blocked) 281 return 0; 282 283 rtnl_lock(); 284 mutex_lock(&rdev->devlist_mtx); 285 286 list_for_each_entry(wdev, &rdev->netdev_list, list) 287 dev_close(wdev->netdev); 288 289 mutex_unlock(&rdev->devlist_mtx); 290 rtnl_unlock(); 291 292 return 0; 293 } 294 295 static void cfg80211_rfkill_sync_work(struct work_struct *work) 296 { 297 struct cfg80211_registered_device *rdev; 298 299 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync); 300 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill)); 301 } 302 303 static void cfg80211_event_work(struct work_struct *work) 304 { 305 struct cfg80211_registered_device *rdev; 306 307 rdev = container_of(work, struct cfg80211_registered_device, 308 event_work); 309 310 rtnl_lock(); 311 cfg80211_lock_rdev(rdev); 312 313 cfg80211_process_rdev_events(rdev); 314 cfg80211_unlock_rdev(rdev); 315 rtnl_unlock(); 316 } 317 318 /* exported functions */ 319 320 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv) 321 { 322 static int wiphy_counter; 323 324 struct cfg80211_registered_device *rdev; 325 int alloc_size; 326 327 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key)); 328 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc)); 329 WARN_ON(ops->connect && !ops->disconnect); 330 WARN_ON(ops->join_ibss && !ops->leave_ibss); 331 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf); 332 WARN_ON(ops->add_station && !ops->del_station); 333 WARN_ON(ops->add_mpath && !ops->del_mpath); 334 335 alloc_size = sizeof(*rdev) + sizeof_priv; 336 337 rdev = kzalloc(alloc_size, GFP_KERNEL); 338 if (!rdev) 339 return NULL; 340 341 rdev->ops = ops; 342 343 mutex_lock(&cfg80211_mutex); 344 345 rdev->wiphy_idx = wiphy_counter++; 346 347 if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) { 348 wiphy_counter--; 349 mutex_unlock(&cfg80211_mutex); 350 /* ugh, wrapped! */ 351 kfree(rdev); 352 return NULL; 353 } 354 355 mutex_unlock(&cfg80211_mutex); 356 357 /* give it a proper name */ 358 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx); 359 360 mutex_init(&rdev->mtx); 361 mutex_init(&rdev->devlist_mtx); 362 INIT_LIST_HEAD(&rdev->netdev_list); 363 spin_lock_init(&rdev->bss_lock); 364 INIT_LIST_HEAD(&rdev->bss_list); 365 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done); 366 367 #ifdef CONFIG_CFG80211_WEXT 368 rdev->wiphy.wext = &cfg80211_wext_handler; 369 #endif 370 371 device_initialize(&rdev->wiphy.dev); 372 rdev->wiphy.dev.class = &ieee80211_class; 373 rdev->wiphy.dev.platform_data = rdev; 374 375 #ifdef CONFIG_CFG80211_DEFAULT_PS 376 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; 377 #endif 378 379 wiphy_net_set(&rdev->wiphy, &init_net); 380 381 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block; 382 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev), 383 &rdev->wiphy.dev, RFKILL_TYPE_WLAN, 384 &rdev->rfkill_ops, rdev); 385 386 if (!rdev->rfkill) { 387 kfree(rdev); 388 return NULL; 389 } 390 391 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work); 392 INIT_WORK(&rdev->conn_work, cfg80211_conn_work); 393 INIT_WORK(&rdev->event_work, cfg80211_event_work); 394 395 init_waitqueue_head(&rdev->dev_wait); 396 397 /* 398 * Initialize wiphy parameters to IEEE 802.11 MIB default values. 399 * Fragmentation and RTS threshold are disabled by default with the 400 * special -1 value. 401 */ 402 rdev->wiphy.retry_short = 7; 403 rdev->wiphy.retry_long = 4; 404 rdev->wiphy.frag_threshold = (u32) -1; 405 rdev->wiphy.rts_threshold = (u32) -1; 406 rdev->wiphy.coverage_class = 0; 407 408 return &rdev->wiphy; 409 } 410 EXPORT_SYMBOL(wiphy_new); 411 412 int wiphy_register(struct wiphy *wiphy) 413 { 414 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 415 int res; 416 enum ieee80211_band band; 417 struct ieee80211_supported_band *sband; 418 bool have_band = false; 419 int i; 420 u16 ifmodes = wiphy->interface_modes; 421 422 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses)) 423 return -EINVAL; 424 425 if (WARN_ON(wiphy->addresses && 426 !is_zero_ether_addr(wiphy->perm_addr) && 427 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr, 428 ETH_ALEN))) 429 return -EINVAL; 430 431 if (wiphy->addresses) 432 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN); 433 434 /* sanity check ifmodes */ 435 WARN_ON(!ifmodes); 436 ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1; 437 if (WARN_ON(ifmodes != wiphy->interface_modes)) 438 wiphy->interface_modes = ifmodes; 439 440 /* sanity check supported bands/channels */ 441 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 442 sband = wiphy->bands[band]; 443 if (!sband) 444 continue; 445 446 sband->band = band; 447 448 if (WARN_ON(!sband->n_channels || !sband->n_bitrates)) 449 return -EINVAL; 450 451 /* 452 * Since we use a u32 for rate bitmaps in 453 * ieee80211_get_response_rate, we cannot 454 * have more than 32 legacy rates. 455 */ 456 if (WARN_ON(sband->n_bitrates > 32)) 457 return -EINVAL; 458 459 for (i = 0; i < sband->n_channels; i++) { 460 sband->channels[i].orig_flags = 461 sband->channels[i].flags; 462 sband->channels[i].orig_mag = 463 sband->channels[i].max_antenna_gain; 464 sband->channels[i].orig_mpwr = 465 sband->channels[i].max_power; 466 sband->channels[i].band = band; 467 } 468 469 have_band = true; 470 } 471 472 if (!have_band) { 473 WARN_ON(1); 474 return -EINVAL; 475 } 476 477 /* check and set up bitrates */ 478 ieee80211_set_bitrate_flags(wiphy); 479 480 mutex_lock(&cfg80211_mutex); 481 482 res = device_add(&rdev->wiphy.dev); 483 if (res) { 484 mutex_unlock(&cfg80211_mutex); 485 return res; 486 } 487 488 /* set up regulatory info */ 489 wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE); 490 491 list_add_rcu(&rdev->list, &cfg80211_rdev_list); 492 cfg80211_rdev_list_generation++; 493 494 /* add to debugfs */ 495 rdev->wiphy.debugfsdir = 496 debugfs_create_dir(wiphy_name(&rdev->wiphy), 497 ieee80211_debugfs_dir); 498 if (IS_ERR(rdev->wiphy.debugfsdir)) 499 rdev->wiphy.debugfsdir = NULL; 500 501 if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) { 502 struct regulatory_request request; 503 504 request.wiphy_idx = get_wiphy_idx(wiphy); 505 request.initiator = NL80211_REGDOM_SET_BY_DRIVER; 506 request.alpha2[0] = '9'; 507 request.alpha2[1] = '9'; 508 509 nl80211_send_reg_change_event(&request); 510 } 511 512 cfg80211_debugfs_rdev_add(rdev); 513 mutex_unlock(&cfg80211_mutex); 514 515 /* 516 * due to a locking dependency this has to be outside of the 517 * cfg80211_mutex lock 518 */ 519 res = rfkill_register(rdev->rfkill); 520 if (res) 521 goto out_rm_dev; 522 523 return 0; 524 525 out_rm_dev: 526 device_del(&rdev->wiphy.dev); 527 return res; 528 } 529 EXPORT_SYMBOL(wiphy_register); 530 531 void wiphy_rfkill_start_polling(struct wiphy *wiphy) 532 { 533 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 534 535 if (!rdev->ops->rfkill_poll) 536 return; 537 rdev->rfkill_ops.poll = cfg80211_rfkill_poll; 538 rfkill_resume_polling(rdev->rfkill); 539 } 540 EXPORT_SYMBOL(wiphy_rfkill_start_polling); 541 542 void wiphy_rfkill_stop_polling(struct wiphy *wiphy) 543 { 544 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 545 546 rfkill_pause_polling(rdev->rfkill); 547 } 548 EXPORT_SYMBOL(wiphy_rfkill_stop_polling); 549 550 void wiphy_unregister(struct wiphy *wiphy) 551 { 552 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 553 554 rfkill_unregister(rdev->rfkill); 555 556 /* protect the device list */ 557 mutex_lock(&cfg80211_mutex); 558 559 wait_event(rdev->dev_wait, ({ 560 int __count; 561 mutex_lock(&rdev->devlist_mtx); 562 __count = rdev->opencount; 563 mutex_unlock(&rdev->devlist_mtx); 564 __count == 0;})); 565 566 mutex_lock(&rdev->devlist_mtx); 567 BUG_ON(!list_empty(&rdev->netdev_list)); 568 mutex_unlock(&rdev->devlist_mtx); 569 570 /* 571 * First remove the hardware from everywhere, this makes 572 * it impossible to find from userspace. 573 */ 574 debugfs_remove_recursive(rdev->wiphy.debugfsdir); 575 list_del_rcu(&rdev->list); 576 synchronize_rcu(); 577 578 /* 579 * Try to grab rdev->mtx. If a command is still in progress, 580 * hopefully the driver will refuse it since it's tearing 581 * down the device already. We wait for this command to complete 582 * before unlinking the item from the list. 583 * Note: as codified by the BUG_ON above we cannot get here if 584 * a virtual interface is still present. Hence, we can only get 585 * to lock contention here if userspace issues a command that 586 * identified the hardware by wiphy index. 587 */ 588 cfg80211_lock_rdev(rdev); 589 /* nothing */ 590 cfg80211_unlock_rdev(rdev); 591 592 /* If this device got a regulatory hint tell core its 593 * free to listen now to a new shiny device regulatory hint */ 594 reg_device_remove(wiphy); 595 596 cfg80211_rdev_list_generation++; 597 device_del(&rdev->wiphy.dev); 598 599 mutex_unlock(&cfg80211_mutex); 600 601 flush_work(&rdev->scan_done_wk); 602 cancel_work_sync(&rdev->conn_work); 603 flush_work(&rdev->event_work); 604 } 605 EXPORT_SYMBOL(wiphy_unregister); 606 607 void cfg80211_dev_free(struct cfg80211_registered_device *rdev) 608 { 609 struct cfg80211_internal_bss *scan, *tmp; 610 rfkill_destroy(rdev->rfkill); 611 mutex_destroy(&rdev->mtx); 612 mutex_destroy(&rdev->devlist_mtx); 613 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list) 614 cfg80211_put_bss(&scan->pub); 615 kfree(rdev); 616 } 617 618 void wiphy_free(struct wiphy *wiphy) 619 { 620 put_device(&wiphy->dev); 621 } 622 EXPORT_SYMBOL(wiphy_free); 623 624 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked) 625 { 626 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 627 628 if (rfkill_set_hw_state(rdev->rfkill, blocked)) 629 schedule_work(&rdev->rfkill_sync); 630 } 631 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state); 632 633 static void wdev_cleanup_work(struct work_struct *work) 634 { 635 struct wireless_dev *wdev; 636 struct cfg80211_registered_device *rdev; 637 638 wdev = container_of(work, struct wireless_dev, cleanup_work); 639 rdev = wiphy_to_dev(wdev->wiphy); 640 641 cfg80211_lock_rdev(rdev); 642 643 if (WARN_ON(rdev->scan_req && rdev->scan_req->dev == wdev->netdev)) { 644 rdev->scan_req->aborted = true; 645 ___cfg80211_scan_done(rdev, true); 646 } 647 648 cfg80211_unlock_rdev(rdev); 649 650 mutex_lock(&rdev->devlist_mtx); 651 rdev->opencount--; 652 mutex_unlock(&rdev->devlist_mtx); 653 wake_up(&rdev->dev_wait); 654 655 dev_put(wdev->netdev); 656 } 657 658 static struct device_type wiphy_type = { 659 .name = "wlan", 660 }; 661 662 static int cfg80211_netdev_notifier_call(struct notifier_block * nb, 663 unsigned long state, 664 void *ndev) 665 { 666 struct net_device *dev = ndev; 667 struct wireless_dev *wdev = dev->ieee80211_ptr; 668 struct cfg80211_registered_device *rdev; 669 670 if (!wdev) 671 return NOTIFY_DONE; 672 673 rdev = wiphy_to_dev(wdev->wiphy); 674 675 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED); 676 677 switch (state) { 678 case NETDEV_POST_INIT: 679 SET_NETDEV_DEVTYPE(dev, &wiphy_type); 680 break; 681 case NETDEV_REGISTER: 682 /* 683 * NB: cannot take rdev->mtx here because this may be 684 * called within code protected by it when interfaces 685 * are added with nl80211. 686 */ 687 mutex_init(&wdev->mtx); 688 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work); 689 INIT_LIST_HEAD(&wdev->event_list); 690 spin_lock_init(&wdev->event_lock); 691 INIT_LIST_HEAD(&wdev->mgmt_registrations); 692 spin_lock_init(&wdev->mgmt_registrations_lock); 693 694 mutex_lock(&rdev->devlist_mtx); 695 list_add_rcu(&wdev->list, &rdev->netdev_list); 696 rdev->devlist_generation++; 697 /* can only change netns with wiphy */ 698 dev->features |= NETIF_F_NETNS_LOCAL; 699 700 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj, 701 "phy80211")) { 702 printk(KERN_ERR "wireless: failed to add phy80211 " 703 "symlink to netdev!\n"); 704 } 705 wdev->netdev = dev; 706 wdev->sme_state = CFG80211_SME_IDLE; 707 mutex_unlock(&rdev->devlist_mtx); 708 #ifdef CONFIG_CFG80211_WEXT 709 wdev->wext.default_key = -1; 710 wdev->wext.default_mgmt_key = -1; 711 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC; 712 #endif 713 714 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT) 715 wdev->ps = true; 716 else 717 wdev->ps = false; 718 /* allow mac80211 to determine the timeout */ 719 wdev->ps_timeout = -1; 720 if (rdev->ops->set_power_mgmt) 721 if (rdev->ops->set_power_mgmt(wdev->wiphy, dev, 722 wdev->ps, 723 wdev->ps_timeout)) { 724 /* assume this means it's off */ 725 wdev->ps = false; 726 } 727 728 if (!dev->ethtool_ops) 729 dev->ethtool_ops = &cfg80211_ethtool_ops; 730 731 if ((wdev->iftype == NL80211_IFTYPE_STATION || 732 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT || 733 wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr) 734 dev->priv_flags |= IFF_DONT_BRIDGE; 735 break; 736 case NETDEV_GOING_DOWN: 737 switch (wdev->iftype) { 738 case NL80211_IFTYPE_ADHOC: 739 cfg80211_leave_ibss(rdev, dev, true); 740 break; 741 case NL80211_IFTYPE_P2P_CLIENT: 742 case NL80211_IFTYPE_STATION: 743 wdev_lock(wdev); 744 #ifdef CONFIG_CFG80211_WEXT 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 queue_work(cfg80211_wq, &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 cfg80211_lock_rdev(rdev); 777 mutex_lock(&rdev->devlist_mtx); 778 #ifdef CONFIG_CFG80211_WEXT 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 #endif 792 rdev->opencount++; 793 mutex_unlock(&rdev->devlist_mtx); 794 cfg80211_unlock_rdev(rdev); 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_rcu(&wdev->list); 813 rdev->devlist_generation++; 814 cfg80211_mlme_purge_registrations(wdev); 815 #ifdef CONFIG_CFG80211_WEXT 816 kfree(wdev->wext.keys); 817 #endif 818 } 819 mutex_unlock(&rdev->devlist_mtx); 820 /* 821 * synchronise (so that we won't find this netdev 822 * from other code any more) and then clear the list 823 * head so that the above code can safely check for 824 * !list_empty() to avoid double-cleanup. 825 */ 826 synchronize_rcu(); 827 INIT_LIST_HEAD(&wdev->list); 828 break; 829 case NETDEV_PRE_UP: 830 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype))) 831 return notifier_from_errno(-EOPNOTSUPP); 832 if (rfkill_blocked(rdev->rfkill)) 833 return notifier_from_errno(-ERFKILL); 834 break; 835 } 836 837 return NOTIFY_DONE; 838 } 839 840 static struct notifier_block cfg80211_netdev_notifier = { 841 .notifier_call = cfg80211_netdev_notifier_call, 842 }; 843 844 static void __net_exit cfg80211_pernet_exit(struct net *net) 845 { 846 struct cfg80211_registered_device *rdev; 847 848 rtnl_lock(); 849 mutex_lock(&cfg80211_mutex); 850 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 851 if (net_eq(wiphy_net(&rdev->wiphy), net)) 852 WARN_ON(cfg80211_switch_netns(rdev, &init_net)); 853 } 854 mutex_unlock(&cfg80211_mutex); 855 rtnl_unlock(); 856 } 857 858 static struct pernet_operations cfg80211_pernet_ops = { 859 .exit = cfg80211_pernet_exit, 860 }; 861 862 static int __init cfg80211_init(void) 863 { 864 int err; 865 866 err = register_pernet_device(&cfg80211_pernet_ops); 867 if (err) 868 goto out_fail_pernet; 869 870 err = wiphy_sysfs_init(); 871 if (err) 872 goto out_fail_sysfs; 873 874 err = register_netdevice_notifier(&cfg80211_netdev_notifier); 875 if (err) 876 goto out_fail_notifier; 877 878 err = nl80211_init(); 879 if (err) 880 goto out_fail_nl80211; 881 882 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL); 883 884 err = regulatory_init(); 885 if (err) 886 goto out_fail_reg; 887 888 cfg80211_wq = create_singlethread_workqueue("cfg80211"); 889 if (!cfg80211_wq) 890 goto out_fail_wq; 891 892 return 0; 893 894 out_fail_wq: 895 regulatory_exit(); 896 out_fail_reg: 897 debugfs_remove(ieee80211_debugfs_dir); 898 out_fail_nl80211: 899 unregister_netdevice_notifier(&cfg80211_netdev_notifier); 900 out_fail_notifier: 901 wiphy_sysfs_exit(); 902 out_fail_sysfs: 903 unregister_pernet_device(&cfg80211_pernet_ops); 904 out_fail_pernet: 905 return err; 906 } 907 subsys_initcall(cfg80211_init); 908 909 static void __exit cfg80211_exit(void) 910 { 911 debugfs_remove(ieee80211_debugfs_dir); 912 nl80211_exit(); 913 unregister_netdevice_notifier(&cfg80211_netdev_notifier); 914 wiphy_sysfs_exit(); 915 regulatory_exit(); 916 unregister_pernet_device(&cfg80211_pernet_ops); 917 destroy_workqueue(cfg80211_wq); 918 } 919 module_exit(cfg80211_exit); 920