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