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 "rdev-ops.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 MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME); 37 38 /* RCU-protected (and RTNL for writers) */ 39 LIST_HEAD(cfg80211_rdev_list); 40 int cfg80211_rdev_list_generation; 41 42 /* for debugfs */ 43 static struct dentry *ieee80211_debugfs_dir; 44 45 /* for the cleanup, scan and event works */ 46 struct workqueue_struct *cfg80211_wq; 47 48 static bool cfg80211_disable_40mhz_24ghz; 49 module_param(cfg80211_disable_40mhz_24ghz, bool, 0644); 50 MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz, 51 "Disable 40MHz support in the 2.4GHz band"); 52 53 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx) 54 { 55 struct cfg80211_registered_device *result = NULL, *rdev; 56 57 ASSERT_RTNL(); 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 = wiphy_to_rdev(wiphy); 72 73 return rdev->wiphy_idx; 74 } 75 76 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx) 77 { 78 struct cfg80211_registered_device *rdev; 79 80 ASSERT_RTNL(); 81 82 rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx); 83 if (!rdev) 84 return NULL; 85 return &rdev->wiphy; 86 } 87 88 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev, 89 char *newname) 90 { 91 struct cfg80211_registered_device *rdev2; 92 int wiphy_idx, taken = -1, result, digits; 93 94 ASSERT_RTNL(); 95 96 /* prohibit calling the thing phy%d when %d is not its number */ 97 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken); 98 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) { 99 /* count number of places needed to print wiphy_idx */ 100 digits = 1; 101 while (wiphy_idx /= 10) 102 digits++; 103 /* 104 * deny the name if it is phy<idx> where <idx> is printed 105 * without leading zeroes. taken == strlen(newname) here 106 */ 107 if (taken == strlen(PHY_NAME) + digits) 108 return -EINVAL; 109 } 110 111 112 /* Ignore nop renames */ 113 if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0) 114 return 0; 115 116 /* Ensure another device does not already have this name. */ 117 list_for_each_entry(rdev2, &cfg80211_rdev_list, list) 118 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0) 119 return -EINVAL; 120 121 result = device_rename(&rdev->wiphy.dev, newname); 122 if (result) 123 return result; 124 125 if (rdev->wiphy.debugfsdir && 126 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent, 127 rdev->wiphy.debugfsdir, 128 rdev->wiphy.debugfsdir->d_parent, 129 newname)) 130 pr_err("failed to rename debugfs dir to %s!\n", newname); 131 132 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY); 133 134 return 0; 135 } 136 137 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev, 138 struct net *net) 139 { 140 struct wireless_dev *wdev; 141 int err = 0; 142 143 if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK)) 144 return -EOPNOTSUPP; 145 146 list_for_each_entry(wdev, &rdev->wdev_list, list) { 147 if (!wdev->netdev) 148 continue; 149 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL; 150 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d"); 151 if (err) 152 break; 153 wdev->netdev->features |= NETIF_F_NETNS_LOCAL; 154 } 155 156 if (err) { 157 /* failed -- clean up to old netns */ 158 net = wiphy_net(&rdev->wiphy); 159 160 list_for_each_entry_continue_reverse(wdev, &rdev->wdev_list, 161 list) { 162 if (!wdev->netdev) 163 continue; 164 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL; 165 err = dev_change_net_namespace(wdev->netdev, net, 166 "wlan%d"); 167 WARN_ON(err); 168 wdev->netdev->features |= NETIF_F_NETNS_LOCAL; 169 } 170 171 return err; 172 } 173 174 wiphy_net_set(&rdev->wiphy, net); 175 176 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev)); 177 WARN_ON(err); 178 179 return 0; 180 } 181 182 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data) 183 { 184 struct cfg80211_registered_device *rdev = data; 185 186 rdev_rfkill_poll(rdev); 187 } 188 189 void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev, 190 struct wireless_dev *wdev) 191 { 192 ASSERT_RTNL(); 193 194 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)) 195 return; 196 197 if (!wdev->p2p_started) 198 return; 199 200 rdev_stop_p2p_device(rdev, wdev); 201 wdev->p2p_started = false; 202 203 rdev->opencount--; 204 205 if (rdev->scan_req && rdev->scan_req->wdev == wdev) { 206 if (WARN_ON(!rdev->scan_req->notified)) 207 rdev->scan_req->aborted = true; 208 ___cfg80211_scan_done(rdev, false); 209 } 210 } 211 212 void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy) 213 { 214 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 215 struct wireless_dev *wdev; 216 217 ASSERT_RTNL(); 218 219 list_for_each_entry(wdev, &rdev->wdev_list, list) { 220 if (wdev->netdev) { 221 dev_close(wdev->netdev); 222 continue; 223 } 224 /* otherwise, check iftype */ 225 switch (wdev->iftype) { 226 case NL80211_IFTYPE_P2P_DEVICE: 227 cfg80211_stop_p2p_device(rdev, wdev); 228 break; 229 default: 230 break; 231 } 232 } 233 } 234 EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces); 235 236 static int cfg80211_rfkill_set_block(void *data, bool blocked) 237 { 238 struct cfg80211_registered_device *rdev = data; 239 240 if (!blocked) 241 return 0; 242 243 rtnl_lock(); 244 cfg80211_shutdown_all_interfaces(&rdev->wiphy); 245 rtnl_unlock(); 246 247 return 0; 248 } 249 250 static void cfg80211_rfkill_sync_work(struct work_struct *work) 251 { 252 struct cfg80211_registered_device *rdev; 253 254 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync); 255 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill)); 256 } 257 258 static void cfg80211_event_work(struct work_struct *work) 259 { 260 struct cfg80211_registered_device *rdev; 261 262 rdev = container_of(work, struct cfg80211_registered_device, 263 event_work); 264 265 rtnl_lock(); 266 cfg80211_process_rdev_events(rdev); 267 rtnl_unlock(); 268 } 269 270 void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev) 271 { 272 struct cfg80211_iface_destroy *item; 273 274 ASSERT_RTNL(); 275 276 spin_lock_irq(&rdev->destroy_list_lock); 277 while ((item = list_first_entry_or_null(&rdev->destroy_list, 278 struct cfg80211_iface_destroy, 279 list))) { 280 struct wireless_dev *wdev, *tmp; 281 u32 nlportid = item->nlportid; 282 283 list_del(&item->list); 284 kfree(item); 285 spin_unlock_irq(&rdev->destroy_list_lock); 286 287 list_for_each_entry_safe(wdev, tmp, &rdev->wdev_list, list) { 288 if (nlportid == wdev->owner_nlportid) 289 rdev_del_virtual_intf(rdev, wdev); 290 } 291 292 spin_lock_irq(&rdev->destroy_list_lock); 293 } 294 spin_unlock_irq(&rdev->destroy_list_lock); 295 } 296 297 static void cfg80211_destroy_iface_wk(struct work_struct *work) 298 { 299 struct cfg80211_registered_device *rdev; 300 301 rdev = container_of(work, struct cfg80211_registered_device, 302 destroy_work); 303 304 rtnl_lock(); 305 cfg80211_destroy_ifaces(rdev); 306 rtnl_unlock(); 307 } 308 309 /* exported functions */ 310 311 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv) 312 { 313 static atomic_t wiphy_counter = ATOMIC_INIT(0); 314 315 struct cfg80211_registered_device *rdev; 316 int alloc_size; 317 318 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key)); 319 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc)); 320 WARN_ON(ops->connect && !ops->disconnect); 321 WARN_ON(ops->join_ibss && !ops->leave_ibss); 322 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf); 323 WARN_ON(ops->add_station && !ops->del_station); 324 WARN_ON(ops->add_mpath && !ops->del_mpath); 325 WARN_ON(ops->join_mesh && !ops->leave_mesh); 326 327 alloc_size = sizeof(*rdev) + sizeof_priv; 328 329 rdev = kzalloc(alloc_size, GFP_KERNEL); 330 if (!rdev) 331 return NULL; 332 333 rdev->ops = ops; 334 335 rdev->wiphy_idx = atomic_inc_return(&wiphy_counter); 336 337 if (unlikely(rdev->wiphy_idx < 0)) { 338 /* ugh, wrapped! */ 339 atomic_dec(&wiphy_counter); 340 kfree(rdev); 341 return NULL; 342 } 343 344 /* atomic_inc_return makes it start at 1, make it start at 0 */ 345 rdev->wiphy_idx--; 346 347 /* give it a proper name */ 348 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx); 349 350 INIT_LIST_HEAD(&rdev->wdev_list); 351 INIT_LIST_HEAD(&rdev->beacon_registrations); 352 spin_lock_init(&rdev->beacon_registrations_lock); 353 spin_lock_init(&rdev->bss_lock); 354 INIT_LIST_HEAD(&rdev->bss_list); 355 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done); 356 INIT_WORK(&rdev->sched_scan_results_wk, __cfg80211_sched_scan_results); 357 INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk, 358 cfg80211_dfs_channels_update_work); 359 #ifdef CONFIG_CFG80211_WEXT 360 rdev->wiphy.wext = &cfg80211_wext_handler; 361 #endif 362 363 device_initialize(&rdev->wiphy.dev); 364 rdev->wiphy.dev.class = &ieee80211_class; 365 rdev->wiphy.dev.platform_data = rdev; 366 367 INIT_LIST_HEAD(&rdev->destroy_list); 368 spin_lock_init(&rdev->destroy_list_lock); 369 INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk); 370 371 #ifdef CONFIG_CFG80211_DEFAULT_PS 372 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; 373 #endif 374 375 wiphy_net_set(&rdev->wiphy, &init_net); 376 377 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block; 378 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev), 379 &rdev->wiphy.dev, RFKILL_TYPE_WLAN, 380 &rdev->rfkill_ops, rdev); 381 382 if (!rdev->rfkill) { 383 kfree(rdev); 384 return NULL; 385 } 386 387 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work); 388 INIT_WORK(&rdev->conn_work, cfg80211_conn_work); 389 INIT_WORK(&rdev->event_work, cfg80211_event_work); 390 391 init_waitqueue_head(&rdev->dev_wait); 392 393 /* 394 * Initialize wiphy parameters to IEEE 802.11 MIB default values. 395 * Fragmentation and RTS threshold are disabled by default with the 396 * special -1 value. 397 */ 398 rdev->wiphy.retry_short = 7; 399 rdev->wiphy.retry_long = 4; 400 rdev->wiphy.frag_threshold = (u32) -1; 401 rdev->wiphy.rts_threshold = (u32) -1; 402 rdev->wiphy.coverage_class = 0; 403 404 rdev->wiphy.max_num_csa_counters = 1; 405 406 return &rdev->wiphy; 407 } 408 EXPORT_SYMBOL(wiphy_new); 409 410 static int wiphy_verify_combinations(struct wiphy *wiphy) 411 { 412 const struct ieee80211_iface_combination *c; 413 int i, j; 414 415 for (i = 0; i < wiphy->n_iface_combinations; i++) { 416 u32 cnt = 0; 417 u16 all_iftypes = 0; 418 419 c = &wiphy->iface_combinations[i]; 420 421 /* 422 * Combinations with just one interface aren't real, 423 * however we make an exception for DFS. 424 */ 425 if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths)) 426 return -EINVAL; 427 428 /* Need at least one channel */ 429 if (WARN_ON(!c->num_different_channels)) 430 return -EINVAL; 431 432 /* 433 * Put a sane limit on maximum number of different 434 * channels to simplify channel accounting code. 435 */ 436 if (WARN_ON(c->num_different_channels > 437 CFG80211_MAX_NUM_DIFFERENT_CHANNELS)) 438 return -EINVAL; 439 440 /* DFS only works on one channel. */ 441 if (WARN_ON(c->radar_detect_widths && 442 (c->num_different_channels > 1))) 443 return -EINVAL; 444 445 if (WARN_ON(!c->n_limits)) 446 return -EINVAL; 447 448 for (j = 0; j < c->n_limits; j++) { 449 u16 types = c->limits[j].types; 450 451 /* interface types shouldn't overlap */ 452 if (WARN_ON(types & all_iftypes)) 453 return -EINVAL; 454 all_iftypes |= types; 455 456 if (WARN_ON(!c->limits[j].max)) 457 return -EINVAL; 458 459 /* Shouldn't list software iftypes in combinations! */ 460 if (WARN_ON(wiphy->software_iftypes & types)) 461 return -EINVAL; 462 463 /* Only a single P2P_DEVICE can be allowed */ 464 if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) && 465 c->limits[j].max > 1)) 466 return -EINVAL; 467 468 cnt += c->limits[j].max; 469 /* 470 * Don't advertise an unsupported type 471 * in a combination. 472 */ 473 if (WARN_ON((wiphy->interface_modes & types) != types)) 474 return -EINVAL; 475 } 476 477 /* You can't even choose that many! */ 478 if (WARN_ON(cnt < c->max_interfaces)) 479 return -EINVAL; 480 } 481 482 return 0; 483 } 484 485 int wiphy_register(struct wiphy *wiphy) 486 { 487 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 488 int res; 489 enum ieee80211_band band; 490 struct ieee80211_supported_band *sband; 491 bool have_band = false; 492 int i; 493 u16 ifmodes = wiphy->interface_modes; 494 495 /* 496 * There are major locking problems in nl80211/mac80211 for CSA, 497 * disable for all drivers until this has been reworked. 498 */ 499 wiphy->flags &= ~WIPHY_FLAG_HAS_CHANNEL_SWITCH; 500 501 #ifdef CONFIG_PM 502 if (WARN_ON(wiphy->wowlan && 503 (wiphy->wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) && 504 !(wiphy->wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY))) 505 return -EINVAL; 506 if (WARN_ON(wiphy->wowlan && 507 !wiphy->wowlan->flags && !wiphy->wowlan->n_patterns && 508 !wiphy->wowlan->tcp)) 509 return -EINVAL; 510 #endif 511 512 if (WARN_ON(wiphy->coalesce && 513 (!wiphy->coalesce->n_rules || 514 !wiphy->coalesce->n_patterns) && 515 (!wiphy->coalesce->pattern_min_len || 516 wiphy->coalesce->pattern_min_len > 517 wiphy->coalesce->pattern_max_len))) 518 return -EINVAL; 519 520 if (WARN_ON(wiphy->ap_sme_capa && 521 !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME))) 522 return -EINVAL; 523 524 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses)) 525 return -EINVAL; 526 527 if (WARN_ON(wiphy->addresses && 528 !is_zero_ether_addr(wiphy->perm_addr) && 529 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr, 530 ETH_ALEN))) 531 return -EINVAL; 532 533 if (WARN_ON(wiphy->max_acl_mac_addrs && 534 (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) || 535 !rdev->ops->set_mac_acl))) 536 return -EINVAL; 537 538 if (wiphy->addresses) 539 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN); 540 541 /* sanity check ifmodes */ 542 WARN_ON(!ifmodes); 543 ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1; 544 if (WARN_ON(ifmodes != wiphy->interface_modes)) 545 wiphy->interface_modes = ifmodes; 546 547 res = wiphy_verify_combinations(wiphy); 548 if (res) 549 return res; 550 551 /* sanity check supported bands/channels */ 552 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 553 sband = wiphy->bands[band]; 554 if (!sband) 555 continue; 556 557 sband->band = band; 558 if (WARN_ON(!sband->n_channels)) 559 return -EINVAL; 560 /* 561 * on 60gHz band, there are no legacy rates, so 562 * n_bitrates is 0 563 */ 564 if (WARN_ON(band != IEEE80211_BAND_60GHZ && 565 !sband->n_bitrates)) 566 return -EINVAL; 567 568 /* 569 * Since cfg80211_disable_40mhz_24ghz is global, we can 570 * modify the sband's ht data even if the driver uses a 571 * global structure for that. 572 */ 573 if (cfg80211_disable_40mhz_24ghz && 574 band == IEEE80211_BAND_2GHZ && 575 sband->ht_cap.ht_supported) { 576 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; 577 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40; 578 } 579 580 /* 581 * Since we use a u32 for rate bitmaps in 582 * ieee80211_get_response_rate, we cannot 583 * have more than 32 legacy rates. 584 */ 585 if (WARN_ON(sband->n_bitrates > 32)) 586 return -EINVAL; 587 588 for (i = 0; i < sband->n_channels; i++) { 589 sband->channels[i].orig_flags = 590 sband->channels[i].flags; 591 sband->channels[i].orig_mag = INT_MAX; 592 sband->channels[i].orig_mpwr = 593 sband->channels[i].max_power; 594 sband->channels[i].band = band; 595 } 596 597 have_band = true; 598 } 599 600 if (!have_band) { 601 WARN_ON(1); 602 return -EINVAL; 603 } 604 605 #ifdef CONFIG_PM 606 if (WARN_ON(rdev->wiphy.wowlan && rdev->wiphy.wowlan->n_patterns && 607 (!rdev->wiphy.wowlan->pattern_min_len || 608 rdev->wiphy.wowlan->pattern_min_len > 609 rdev->wiphy.wowlan->pattern_max_len))) 610 return -EINVAL; 611 #endif 612 613 /* check and set up bitrates */ 614 ieee80211_set_bitrate_flags(wiphy); 615 616 rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH; 617 618 rtnl_lock(); 619 res = device_add(&rdev->wiphy.dev); 620 if (res) { 621 rtnl_unlock(); 622 return res; 623 } 624 625 /* set up regulatory info */ 626 wiphy_regulatory_register(wiphy); 627 628 list_add_rcu(&rdev->list, &cfg80211_rdev_list); 629 cfg80211_rdev_list_generation++; 630 631 /* add to debugfs */ 632 rdev->wiphy.debugfsdir = 633 debugfs_create_dir(wiphy_name(&rdev->wiphy), 634 ieee80211_debugfs_dir); 635 if (IS_ERR(rdev->wiphy.debugfsdir)) 636 rdev->wiphy.debugfsdir = NULL; 637 638 if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) { 639 struct regulatory_request request; 640 641 request.wiphy_idx = get_wiphy_idx(wiphy); 642 request.initiator = NL80211_REGDOM_SET_BY_DRIVER; 643 request.alpha2[0] = '9'; 644 request.alpha2[1] = '9'; 645 646 nl80211_send_reg_change_event(&request); 647 } 648 649 cfg80211_debugfs_rdev_add(rdev); 650 651 rdev->wiphy.registered = true; 652 rtnl_unlock(); 653 654 res = rfkill_register(rdev->rfkill); 655 if (res) { 656 rfkill_destroy(rdev->rfkill); 657 rdev->rfkill = NULL; 658 wiphy_unregister(&rdev->wiphy); 659 return res; 660 } 661 662 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY); 663 664 return 0; 665 } 666 EXPORT_SYMBOL(wiphy_register); 667 668 void wiphy_rfkill_start_polling(struct wiphy *wiphy) 669 { 670 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 671 672 if (!rdev->ops->rfkill_poll) 673 return; 674 rdev->rfkill_ops.poll = cfg80211_rfkill_poll; 675 rfkill_resume_polling(rdev->rfkill); 676 } 677 EXPORT_SYMBOL(wiphy_rfkill_start_polling); 678 679 void wiphy_rfkill_stop_polling(struct wiphy *wiphy) 680 { 681 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 682 683 rfkill_pause_polling(rdev->rfkill); 684 } 685 EXPORT_SYMBOL(wiphy_rfkill_stop_polling); 686 687 void wiphy_unregister(struct wiphy *wiphy) 688 { 689 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 690 691 wait_event(rdev->dev_wait, ({ 692 int __count; 693 rtnl_lock(); 694 __count = rdev->opencount; 695 rtnl_unlock(); 696 __count == 0; })); 697 698 if (rdev->rfkill) 699 rfkill_unregister(rdev->rfkill); 700 701 rtnl_lock(); 702 nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY); 703 rdev->wiphy.registered = false; 704 705 WARN_ON(!list_empty(&rdev->wdev_list)); 706 707 /* 708 * First remove the hardware from everywhere, this makes 709 * it impossible to find from userspace. 710 */ 711 debugfs_remove_recursive(rdev->wiphy.debugfsdir); 712 list_del_rcu(&rdev->list); 713 synchronize_rcu(); 714 715 /* 716 * If this device got a regulatory hint tell core its 717 * free to listen now to a new shiny device regulatory hint 718 */ 719 wiphy_regulatory_deregister(wiphy); 720 721 cfg80211_rdev_list_generation++; 722 device_del(&rdev->wiphy.dev); 723 724 rtnl_unlock(); 725 726 flush_work(&rdev->scan_done_wk); 727 cancel_work_sync(&rdev->conn_work); 728 flush_work(&rdev->event_work); 729 cancel_delayed_work_sync(&rdev->dfs_update_channels_wk); 730 flush_work(&rdev->destroy_work); 731 732 #ifdef CONFIG_PM 733 if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup) 734 rdev_set_wakeup(rdev, false); 735 #endif 736 cfg80211_rdev_free_wowlan(rdev); 737 cfg80211_rdev_free_coalesce(rdev); 738 } 739 EXPORT_SYMBOL(wiphy_unregister); 740 741 void cfg80211_dev_free(struct cfg80211_registered_device *rdev) 742 { 743 struct cfg80211_internal_bss *scan, *tmp; 744 struct cfg80211_beacon_registration *reg, *treg; 745 rfkill_destroy(rdev->rfkill); 746 list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) { 747 list_del(®->list); 748 kfree(reg); 749 } 750 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list) 751 cfg80211_put_bss(&rdev->wiphy, &scan->pub); 752 kfree(rdev); 753 } 754 755 void wiphy_free(struct wiphy *wiphy) 756 { 757 put_device(&wiphy->dev); 758 } 759 EXPORT_SYMBOL(wiphy_free); 760 761 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked) 762 { 763 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 764 765 if (rfkill_set_hw_state(rdev->rfkill, blocked)) 766 schedule_work(&rdev->rfkill_sync); 767 } 768 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state); 769 770 void cfg80211_unregister_wdev(struct wireless_dev *wdev) 771 { 772 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 773 774 ASSERT_RTNL(); 775 776 if (WARN_ON(wdev->netdev)) 777 return; 778 779 list_del_rcu(&wdev->list); 780 rdev->devlist_generation++; 781 782 switch (wdev->iftype) { 783 case NL80211_IFTYPE_P2P_DEVICE: 784 cfg80211_stop_p2p_device(rdev, wdev); 785 break; 786 default: 787 WARN_ON_ONCE(1); 788 break; 789 } 790 } 791 EXPORT_SYMBOL(cfg80211_unregister_wdev); 792 793 static const struct device_type wiphy_type = { 794 .name = "wlan", 795 }; 796 797 void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev, 798 enum nl80211_iftype iftype, int num) 799 { 800 ASSERT_RTNL(); 801 802 rdev->num_running_ifaces += num; 803 if (iftype == NL80211_IFTYPE_MONITOR) 804 rdev->num_running_monitor_ifaces += num; 805 } 806 807 void __cfg80211_leave(struct cfg80211_registered_device *rdev, 808 struct wireless_dev *wdev) 809 { 810 struct net_device *dev = wdev->netdev; 811 812 ASSERT_RTNL(); 813 ASSERT_WDEV_LOCK(wdev); 814 815 switch (wdev->iftype) { 816 case NL80211_IFTYPE_ADHOC: 817 __cfg80211_leave_ibss(rdev, dev, true); 818 break; 819 case NL80211_IFTYPE_P2P_CLIENT: 820 case NL80211_IFTYPE_STATION: 821 if (rdev->sched_scan_req && dev == rdev->sched_scan_req->dev) 822 __cfg80211_stop_sched_scan(rdev, false); 823 824 #ifdef CONFIG_CFG80211_WEXT 825 kfree(wdev->wext.ie); 826 wdev->wext.ie = NULL; 827 wdev->wext.ie_len = 0; 828 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC; 829 #endif 830 cfg80211_disconnect(rdev, dev, 831 WLAN_REASON_DEAUTH_LEAVING, true); 832 break; 833 case NL80211_IFTYPE_MESH_POINT: 834 __cfg80211_leave_mesh(rdev, dev); 835 break; 836 case NL80211_IFTYPE_AP: 837 case NL80211_IFTYPE_P2P_GO: 838 __cfg80211_stop_ap(rdev, dev, true); 839 break; 840 default: 841 break; 842 } 843 } 844 845 void cfg80211_leave(struct cfg80211_registered_device *rdev, 846 struct wireless_dev *wdev) 847 { 848 wdev_lock(wdev); 849 __cfg80211_leave(rdev, wdev); 850 wdev_unlock(wdev); 851 } 852 853 void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev, 854 gfp_t gfp) 855 { 856 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 857 struct cfg80211_event *ev; 858 unsigned long flags; 859 860 trace_cfg80211_stop_iface(wiphy, wdev); 861 862 ev = kzalloc(sizeof(*ev), gfp); 863 if (!ev) 864 return; 865 866 ev->type = EVENT_STOPPED; 867 868 spin_lock_irqsave(&wdev->event_lock, flags); 869 list_add_tail(&ev->list, &wdev->event_list); 870 spin_unlock_irqrestore(&wdev->event_lock, flags); 871 queue_work(cfg80211_wq, &rdev->event_work); 872 } 873 EXPORT_SYMBOL(cfg80211_stop_iface); 874 875 static int cfg80211_netdev_notifier_call(struct notifier_block *nb, 876 unsigned long state, void *ptr) 877 { 878 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 879 struct wireless_dev *wdev = dev->ieee80211_ptr; 880 struct cfg80211_registered_device *rdev; 881 882 if (!wdev) 883 return NOTIFY_DONE; 884 885 rdev = wiphy_to_rdev(wdev->wiphy); 886 887 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED); 888 889 switch (state) { 890 case NETDEV_POST_INIT: 891 SET_NETDEV_DEVTYPE(dev, &wiphy_type); 892 break; 893 case NETDEV_REGISTER: 894 /* 895 * NB: cannot take rdev->mtx here because this may be 896 * called within code protected by it when interfaces 897 * are added with nl80211. 898 */ 899 mutex_init(&wdev->mtx); 900 INIT_LIST_HEAD(&wdev->event_list); 901 spin_lock_init(&wdev->event_lock); 902 INIT_LIST_HEAD(&wdev->mgmt_registrations); 903 spin_lock_init(&wdev->mgmt_registrations_lock); 904 905 wdev->identifier = ++rdev->wdev_id; 906 list_add_rcu(&wdev->list, &rdev->wdev_list); 907 rdev->devlist_generation++; 908 /* can only change netns with wiphy */ 909 dev->features |= NETIF_F_NETNS_LOCAL; 910 911 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj, 912 "phy80211")) { 913 pr_err("failed to add phy80211 symlink to netdev!\n"); 914 } 915 wdev->netdev = dev; 916 #ifdef CONFIG_CFG80211_WEXT 917 wdev->wext.default_key = -1; 918 wdev->wext.default_mgmt_key = -1; 919 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC; 920 #endif 921 922 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT) 923 wdev->ps = true; 924 else 925 wdev->ps = false; 926 /* allow mac80211 to determine the timeout */ 927 wdev->ps_timeout = -1; 928 929 if ((wdev->iftype == NL80211_IFTYPE_STATION || 930 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT || 931 wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr) 932 dev->priv_flags |= IFF_DONT_BRIDGE; 933 break; 934 case NETDEV_GOING_DOWN: 935 cfg80211_leave(rdev, wdev); 936 break; 937 case NETDEV_DOWN: 938 cfg80211_update_iface_num(rdev, wdev->iftype, -1); 939 if (rdev->scan_req && rdev->scan_req->wdev == wdev) { 940 if (WARN_ON(!rdev->scan_req->notified)) 941 rdev->scan_req->aborted = true; 942 ___cfg80211_scan_done(rdev, false); 943 } 944 945 if (WARN_ON(rdev->sched_scan_req && 946 rdev->sched_scan_req->dev == wdev->netdev)) { 947 __cfg80211_stop_sched_scan(rdev, false); 948 } 949 950 rdev->opencount--; 951 wake_up(&rdev->dev_wait); 952 break; 953 case NETDEV_UP: 954 cfg80211_update_iface_num(rdev, wdev->iftype, 1); 955 wdev_lock(wdev); 956 switch (wdev->iftype) { 957 #ifdef CONFIG_CFG80211_WEXT 958 case NL80211_IFTYPE_ADHOC: 959 cfg80211_ibss_wext_join(rdev, wdev); 960 break; 961 case NL80211_IFTYPE_STATION: 962 cfg80211_mgd_wext_connect(rdev, wdev); 963 break; 964 #endif 965 #ifdef CONFIG_MAC80211_MESH 966 case NL80211_IFTYPE_MESH_POINT: 967 { 968 /* backward compat code... */ 969 struct mesh_setup setup; 970 memcpy(&setup, &default_mesh_setup, 971 sizeof(setup)); 972 /* back compat only needed for mesh_id */ 973 setup.mesh_id = wdev->ssid; 974 setup.mesh_id_len = wdev->mesh_id_up_len; 975 if (wdev->mesh_id_up_len) 976 __cfg80211_join_mesh(rdev, dev, 977 &setup, 978 &default_mesh_config); 979 break; 980 } 981 #endif 982 default: 983 break; 984 } 985 wdev_unlock(wdev); 986 rdev->opencount++; 987 988 /* 989 * Configure power management to the driver here so that its 990 * correctly set also after interface type changes etc. 991 */ 992 if ((wdev->iftype == NL80211_IFTYPE_STATION || 993 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) && 994 rdev->ops->set_power_mgmt) 995 if (rdev_set_power_mgmt(rdev, dev, wdev->ps, 996 wdev->ps_timeout)) { 997 /* assume this means it's off */ 998 wdev->ps = false; 999 } 1000 break; 1001 case NETDEV_UNREGISTER: 1002 /* 1003 * It is possible to get NETDEV_UNREGISTER 1004 * multiple times. To detect that, check 1005 * that the interface is still on the list 1006 * of registered interfaces, and only then 1007 * remove and clean it up. 1008 */ 1009 if (!list_empty(&wdev->list)) { 1010 sysfs_remove_link(&dev->dev.kobj, "phy80211"); 1011 list_del_rcu(&wdev->list); 1012 rdev->devlist_generation++; 1013 cfg80211_mlme_purge_registrations(wdev); 1014 #ifdef CONFIG_CFG80211_WEXT 1015 kfree(wdev->wext.keys); 1016 #endif 1017 } 1018 /* 1019 * synchronise (so that we won't find this netdev 1020 * from other code any more) and then clear the list 1021 * head so that the above code can safely check for 1022 * !list_empty() to avoid double-cleanup. 1023 */ 1024 synchronize_rcu(); 1025 INIT_LIST_HEAD(&wdev->list); 1026 /* 1027 * Ensure that all events have been processed and 1028 * freed. 1029 */ 1030 cfg80211_process_wdev_events(wdev); 1031 1032 if (WARN_ON(wdev->current_bss)) { 1033 cfg80211_unhold_bss(wdev->current_bss); 1034 cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub); 1035 wdev->current_bss = NULL; 1036 } 1037 break; 1038 case NETDEV_PRE_UP: 1039 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype))) 1040 return notifier_from_errno(-EOPNOTSUPP); 1041 if (rfkill_blocked(rdev->rfkill)) 1042 return notifier_from_errno(-ERFKILL); 1043 break; 1044 default: 1045 return NOTIFY_DONE; 1046 } 1047 1048 return NOTIFY_OK; 1049 } 1050 1051 static struct notifier_block cfg80211_netdev_notifier = { 1052 .notifier_call = cfg80211_netdev_notifier_call, 1053 }; 1054 1055 static void __net_exit cfg80211_pernet_exit(struct net *net) 1056 { 1057 struct cfg80211_registered_device *rdev; 1058 1059 rtnl_lock(); 1060 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 1061 if (net_eq(wiphy_net(&rdev->wiphy), net)) 1062 WARN_ON(cfg80211_switch_netns(rdev, &init_net)); 1063 } 1064 rtnl_unlock(); 1065 } 1066 1067 static struct pernet_operations cfg80211_pernet_ops = { 1068 .exit = cfg80211_pernet_exit, 1069 }; 1070 1071 static int __init cfg80211_init(void) 1072 { 1073 int err; 1074 1075 err = register_pernet_device(&cfg80211_pernet_ops); 1076 if (err) 1077 goto out_fail_pernet; 1078 1079 err = wiphy_sysfs_init(); 1080 if (err) 1081 goto out_fail_sysfs; 1082 1083 err = register_netdevice_notifier(&cfg80211_netdev_notifier); 1084 if (err) 1085 goto out_fail_notifier; 1086 1087 err = nl80211_init(); 1088 if (err) 1089 goto out_fail_nl80211; 1090 1091 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL); 1092 1093 err = regulatory_init(); 1094 if (err) 1095 goto out_fail_reg; 1096 1097 cfg80211_wq = create_singlethread_workqueue("cfg80211"); 1098 if (!cfg80211_wq) { 1099 err = -ENOMEM; 1100 goto out_fail_wq; 1101 } 1102 1103 return 0; 1104 1105 out_fail_wq: 1106 regulatory_exit(); 1107 out_fail_reg: 1108 debugfs_remove(ieee80211_debugfs_dir); 1109 out_fail_nl80211: 1110 unregister_netdevice_notifier(&cfg80211_netdev_notifier); 1111 out_fail_notifier: 1112 wiphy_sysfs_exit(); 1113 out_fail_sysfs: 1114 unregister_pernet_device(&cfg80211_pernet_ops); 1115 out_fail_pernet: 1116 return err; 1117 } 1118 subsys_initcall(cfg80211_init); 1119 1120 static void __exit cfg80211_exit(void) 1121 { 1122 debugfs_remove(ieee80211_debugfs_dir); 1123 nl80211_exit(); 1124 unregister_netdevice_notifier(&cfg80211_netdev_notifier); 1125 wiphy_sysfs_exit(); 1126 regulatory_exit(); 1127 unregister_pernet_device(&cfg80211_pernet_ops); 1128 destroy_workqueue(cfg80211_wq); 1129 } 1130 module_exit(cfg80211_exit); 1131