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 31MODULE_AUTHOR("Johannes Berg"); 32MODULE_LICENSE("GPL"); 33MODULE_DESCRIPTION("wireless configuration support"); 34 35/* RCU-protected (and cfg80211_mutex for writers) */ 36LIST_HEAD(cfg80211_rdev_list); 37int cfg80211_rdev_list_generation; 38 39DEFINE_MUTEX(cfg80211_mutex); 40 41/* for debugfs */ 42static struct dentry *ieee80211_debugfs_dir; 43 44/* for the cleanup, scan and event works */ 45struct workqueue_struct *cfg80211_wq; 46 47/* requires cfg80211_mutex to be held! */ 48struct 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 67int 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! */ 77struct 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! */ 93struct 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 136struct cfg80211_registered_device * 137cfg80211_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 155struct cfg80211_registered_device * 156cfg80211_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 */ 177int 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 227int 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 258 wiphy_net_set(&rdev->wiphy, net); 259 260 return err; 261} 262 263static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data) 264{ 265 struct cfg80211_registered_device *rdev = data; 266 267 rdev->ops->rfkill_poll(&rdev->wiphy); 268} 269 270static int cfg80211_rfkill_set_block(void *data, bool blocked) 271{ 272 struct cfg80211_registered_device *rdev = data; 273 struct wireless_dev *wdev; 274 275 if (!blocked) 276 return 0; 277 278 rtnl_lock(); 279 mutex_lock(&rdev->devlist_mtx); 280 281 list_for_each_entry(wdev, &rdev->netdev_list, list) 282 dev_close(wdev->netdev); 283 284 mutex_unlock(&rdev->devlist_mtx); 285 rtnl_unlock(); 286 287 return 0; 288} 289 290static void cfg80211_rfkill_sync_work(struct work_struct *work) 291{ 292 struct cfg80211_registered_device *rdev; 293 294 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync); 295 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill)); 296} 297 298static void cfg80211_event_work(struct work_struct *work) 299{ 300 struct cfg80211_registered_device *rdev; 301 302 rdev = container_of(work, struct cfg80211_registered_device, 303 event_work); 304 305 rtnl_lock(); 306 cfg80211_lock_rdev(rdev); 307 308 cfg80211_process_rdev_events(rdev); 309 cfg80211_unlock_rdev(rdev); 310 rtnl_unlock(); 311} 312 313/* exported functions */ 314 315struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv) 316{ 317 static int wiphy_counter; 318 319 struct cfg80211_registered_device *rdev; 320 int alloc_size; 321 322 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key)); 323 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc)); 324 WARN_ON(ops->connect && !ops->disconnect); 325 WARN_ON(ops->join_ibss && !ops->leave_ibss); 326 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf); 327 WARN_ON(ops->add_station && !ops->del_station); 328 WARN_ON(ops->add_mpath && !ops->del_mpath); 329 330 alloc_size = sizeof(*rdev) + sizeof_priv; 331 332 rdev = kzalloc(alloc_size, GFP_KERNEL); 333 if (!rdev) 334 return NULL; 335 336 rdev->ops = ops; 337 338 mutex_lock(&cfg80211_mutex); 339 340 rdev->wiphy_idx = wiphy_counter++; 341 342 if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) { 343 wiphy_counter--; 344 mutex_unlock(&cfg80211_mutex); 345 /* ugh, wrapped! */ 346 kfree(rdev); 347 return NULL; 348 } 349 350 mutex_unlock(&cfg80211_mutex); 351 352 /* give it a proper name */ 353 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx); 354 355 mutex_init(&rdev->mtx); 356 mutex_init(&rdev->devlist_mtx); 357 INIT_LIST_HEAD(&rdev->netdev_list); 358 spin_lock_init(&rdev->bss_lock); 359 INIT_LIST_HEAD(&rdev->bss_list); 360 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done); 361 362#ifdef CONFIG_CFG80211_WEXT 363 rdev->wiphy.wext = &cfg80211_wext_handler; 364#endif 365 366 device_initialize(&rdev->wiphy.dev); 367 rdev->wiphy.dev.class = &ieee80211_class; 368 rdev->wiphy.dev.platform_data = rdev; 369 370#ifdef CONFIG_CFG80211_DEFAULT_PS 371 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; 372#endif 373 374 wiphy_net_set(&rdev->wiphy, &init_net); 375 376 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block; 377 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev), 378 &rdev->wiphy.dev, RFKILL_TYPE_WLAN, 379 &rdev->rfkill_ops, rdev); 380 381 if (!rdev->rfkill) { 382 kfree(rdev); 383 return NULL; 384 } 385 386 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work); 387 INIT_WORK(&rdev->conn_work, cfg80211_conn_work); 388 INIT_WORK(&rdev->event_work, cfg80211_event_work); 389 390 init_waitqueue_head(&rdev->dev_wait); 391 392 /* 393 * Initialize wiphy parameters to IEEE 802.11 MIB default values. 394 * Fragmentation and RTS threshold are disabled by default with the 395 * special -1 value. 396 */ 397 rdev->wiphy.retry_short = 7; 398 rdev->wiphy.retry_long = 4; 399 rdev->wiphy.frag_threshold = (u32) -1; 400 rdev->wiphy.rts_threshold = (u32) -1; 401 rdev->wiphy.coverage_class = 0; 402 403 return &rdev->wiphy; 404} 405EXPORT_SYMBOL(wiphy_new); 406 407int wiphy_register(struct wiphy *wiphy) 408{ 409 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 410 int res; 411 enum ieee80211_band band; 412 struct ieee80211_supported_band *sband; 413 bool have_band = false; 414 int i; 415 u16 ifmodes = wiphy->interface_modes; 416 417 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses)) 418 return -EINVAL; 419 420 if (WARN_ON(wiphy->addresses && 421 !is_zero_ether_addr(wiphy->perm_addr) && 422 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr, 423 ETH_ALEN))) 424 return -EINVAL; 425 426 if (wiphy->addresses) 427 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN); 428 429 /* sanity check ifmodes */ 430 WARN_ON(!ifmodes); 431 ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1; 432 if (WARN_ON(ifmodes != wiphy->interface_modes)) 433 wiphy->interface_modes = ifmodes; 434 435 /* sanity check supported bands/channels */ 436 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 437 sband = wiphy->bands[band]; 438 if (!sband) 439 continue; 440 441 sband->band = band; 442 443 if (WARN_ON(!sband->n_channels || !sband->n_bitrates)) 444 return -EINVAL; 445 446 /* 447 * Since we use a u32 for rate bitmaps in 448 * ieee80211_get_response_rate, we cannot 449 * have more than 32 legacy rates. 450 */ 451 if (WARN_ON(sband->n_bitrates > 32)) 452 return -EINVAL; 453 454 for (i = 0; i < sband->n_channels; i++) { 455 sband->channels[i].orig_flags = 456 sband->channels[i].flags; 457 sband->channels[i].orig_mag = 458 sband->channels[i].max_antenna_gain; 459 sband->channels[i].orig_mpwr = 460 sband->channels[i].max_power; 461 sband->channels[i].band = band; 462 } 463 464 have_band = true; 465 } 466 467 if (!have_band) { 468 WARN_ON(1); 469 return -EINVAL; 470 } 471 472 /* check and set up bitrates */ 473 ieee80211_set_bitrate_flags(wiphy); 474 475 mutex_lock(&cfg80211_mutex); 476 477 res = device_add(&rdev->wiphy.dev); 478 if (res) { 479 mutex_unlock(&cfg80211_mutex); 480 return res; 481 } 482 483 /* set up regulatory info */ 484 wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE); 485 486 list_add_rcu(&rdev->list, &cfg80211_rdev_list); 487 cfg80211_rdev_list_generation++; 488 489 /* add to debugfs */ 490 rdev->wiphy.debugfsdir = 491 debugfs_create_dir(wiphy_name(&rdev->wiphy), 492 ieee80211_debugfs_dir); 493 if (IS_ERR(rdev->wiphy.debugfsdir)) 494 rdev->wiphy.debugfsdir = NULL; 495 496 if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) { 497 struct regulatory_request request; 498 499 request.wiphy_idx = get_wiphy_idx(wiphy); 500 request.initiator = NL80211_REGDOM_SET_BY_DRIVER; 501 request.alpha2[0] = '9'; 502 request.alpha2[1] = '9'; 503 504 nl80211_send_reg_change_event(&request); 505 } 506 507 cfg80211_debugfs_rdev_add(rdev); 508 mutex_unlock(&cfg80211_mutex); 509 510 /* 511 * due to a locking dependency this has to be outside of the 512 * cfg80211_mutex lock 513 */ 514 res = rfkill_register(rdev->rfkill); 515 if (res) 516 goto out_rm_dev; 517 518 return 0; 519 520out_rm_dev: 521 device_del(&rdev->wiphy.dev); 522 return res; 523} 524EXPORT_SYMBOL(wiphy_register); 525 526void wiphy_rfkill_start_polling(struct wiphy *wiphy) 527{ 528 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 529 530 if (!rdev->ops->rfkill_poll) 531 return; 532 rdev->rfkill_ops.poll = cfg80211_rfkill_poll; 533 rfkill_resume_polling(rdev->rfkill); 534} 535EXPORT_SYMBOL(wiphy_rfkill_start_polling); 536 537void wiphy_rfkill_stop_polling(struct wiphy *wiphy) 538{ 539 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 540 541 rfkill_pause_polling(rdev->rfkill); 542} 543EXPORT_SYMBOL(wiphy_rfkill_stop_polling); 544 545void wiphy_unregister(struct wiphy *wiphy) 546{ 547 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 548 549 rfkill_unregister(rdev->rfkill); 550 551 /* protect the device list */ 552 mutex_lock(&cfg80211_mutex); 553 554 wait_event(rdev->dev_wait, ({ 555 int __count; 556 mutex_lock(&rdev->devlist_mtx); 557 __count = rdev->opencount; 558 mutex_unlock(&rdev->devlist_mtx); 559 __count == 0;})); 560 561 mutex_lock(&rdev->devlist_mtx); 562 BUG_ON(!list_empty(&rdev->netdev_list)); 563 mutex_unlock(&rdev->devlist_mtx); 564 565 /* 566 * First remove the hardware from everywhere, this makes 567 * it impossible to find from userspace. 568 */ 569 debugfs_remove_recursive(rdev->wiphy.debugfsdir); 570 list_del_rcu(&rdev->list); 571 synchronize_rcu(); 572 573 /* 574 * Try to grab rdev->mtx. If a command is still in progress, 575 * hopefully the driver will refuse it since it's tearing 576 * down the device already. We wait for this command to complete 577 * before unlinking the item from the list. 578 * Note: as codified by the BUG_ON above we cannot get here if 579 * a virtual interface is still present. Hence, we can only get 580 * to lock contention here if userspace issues a command that 581 * identified the hardware by wiphy index. 582 */ 583 cfg80211_lock_rdev(rdev); 584 /* nothing */ 585 cfg80211_unlock_rdev(rdev); 586 587 /* If this device got a regulatory hint tell core its 588 * free to listen now to a new shiny device regulatory hint */ 589 reg_device_remove(wiphy); 590 591 cfg80211_rdev_list_generation++; 592 device_del(&rdev->wiphy.dev); 593 594 mutex_unlock(&cfg80211_mutex); 595 596 flush_work(&rdev->scan_done_wk); 597 cancel_work_sync(&rdev->conn_work); 598 flush_work(&rdev->event_work); 599} 600EXPORT_SYMBOL(wiphy_unregister); 601 602void cfg80211_dev_free(struct cfg80211_registered_device *rdev) 603{ 604 struct cfg80211_internal_bss *scan, *tmp; 605 rfkill_destroy(rdev->rfkill); 606 mutex_destroy(&rdev->mtx); 607 mutex_destroy(&rdev->devlist_mtx); 608 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list) 609 cfg80211_put_bss(&scan->pub); 610 kfree(rdev); 611} 612 613void wiphy_free(struct wiphy *wiphy) 614{ 615 put_device(&wiphy->dev); 616} 617EXPORT_SYMBOL(wiphy_free); 618 619void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked) 620{ 621 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy); 622 623 if (rfkill_set_hw_state(rdev->rfkill, blocked)) 624 schedule_work(&rdev->rfkill_sync); 625} 626EXPORT_SYMBOL(wiphy_rfkill_set_hw_state); 627 628static void wdev_cleanup_work(struct work_struct *work) 629{ 630 struct wireless_dev *wdev; 631 struct cfg80211_registered_device *rdev; 632 633 wdev = container_of(work, struct wireless_dev, cleanup_work); 634 rdev = wiphy_to_dev(wdev->wiphy); 635 636 cfg80211_lock_rdev(rdev); 637 638 if (WARN_ON(rdev->scan_req && rdev->scan_req->dev == wdev->netdev)) { 639 rdev->scan_req->aborted = true; 640 ___cfg80211_scan_done(rdev, true); 641 } 642 643 cfg80211_unlock_rdev(rdev); 644 645 mutex_lock(&rdev->devlist_mtx); 646 rdev->opencount--; 647 mutex_unlock(&rdev->devlist_mtx); 648 wake_up(&rdev->dev_wait); 649 650 dev_put(wdev->netdev); 651} 652 653static struct device_type wiphy_type = { 654 .name = "wlan", 655}; 656 657static int cfg80211_netdev_notifier_call(struct notifier_block * nb, 658 unsigned long state, 659 void *ndev) 660{ 661 struct net_device *dev = ndev; 662 struct wireless_dev *wdev = dev->ieee80211_ptr; 663 struct cfg80211_registered_device *rdev; 664 665 if (!wdev) 666 return NOTIFY_DONE; 667 668 rdev = wiphy_to_dev(wdev->wiphy); 669 670 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED); 671 672 switch (state) { 673 case NETDEV_POST_INIT: 674 SET_NETDEV_DEVTYPE(dev, &wiphy_type); 675 break; 676 case NETDEV_REGISTER: 677 /* 678 * NB: cannot take rdev->mtx here because this may be 679 * called within code protected by it when interfaces 680 * are added with nl80211. 681 */ 682 mutex_init(&wdev->mtx); 683 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work); 684 INIT_LIST_HEAD(&wdev->event_list); 685 spin_lock_init(&wdev->event_lock); 686 INIT_LIST_HEAD(&wdev->action_registrations); 687 spin_lock_init(&wdev->action_registrations_lock); 688 689 mutex_lock(&rdev->devlist_mtx); 690 list_add_rcu(&wdev->list, &rdev->netdev_list); 691 rdev->devlist_generation++; 692 /* can only change netns with wiphy */ 693 dev->features |= NETIF_F_NETNS_LOCAL; 694 695 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj, 696 "phy80211")) { 697 printk(KERN_ERR "wireless: failed to add phy80211 " 698 "symlink to netdev!\n"); 699 } 700 wdev->netdev = dev; 701 wdev->sme_state = CFG80211_SME_IDLE; 702 mutex_unlock(&rdev->devlist_mtx); 703#ifdef CONFIG_CFG80211_WEXT 704 wdev->wext.default_key = -1; 705 wdev->wext.default_mgmt_key = -1; 706 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC; 707#endif 708 709 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT) 710 wdev->ps = true; 711 else 712 wdev->ps = false; 713 /* allow mac80211 to determine the timeout */ 714 wdev->ps_timeout = -1; 715 if (rdev->ops->set_power_mgmt) 716 if (rdev->ops->set_power_mgmt(wdev->wiphy, dev, 717 wdev->ps, 718 wdev->ps_timeout)) { 719 /* assume this means it's off */ 720 wdev->ps = false; 721 } 722 723 if (!dev->ethtool_ops) 724 dev->ethtool_ops = &cfg80211_ethtool_ops; 725 726 if ((wdev->iftype == NL80211_IFTYPE_STATION || 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_STATION: 736 wdev_lock(wdev); 737#ifdef CONFIG_CFG80211_WEXT 738 kfree(wdev->wext.ie); 739 wdev->wext.ie = NULL; 740 wdev->wext.ie_len = 0; 741 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC; 742#endif 743 __cfg80211_disconnect(rdev, dev, 744 WLAN_REASON_DEAUTH_LEAVING, true); 745 cfg80211_mlme_down(rdev, dev); 746 wdev_unlock(wdev); 747 break; 748 default: 749 break; 750 } 751 break; 752 case NETDEV_DOWN: 753 dev_hold(dev); 754 queue_work(cfg80211_wq, &wdev->cleanup_work); 755 break; 756 case NETDEV_UP: 757 /* 758 * If we have a really quick DOWN/UP succession we may 759 * have this work still pending ... cancel it and see 760 * if it was pending, in which case we need to account 761 * for some of the work it would have done. 762 */ 763 if (cancel_work_sync(&wdev->cleanup_work)) { 764 mutex_lock(&rdev->devlist_mtx); 765 rdev->opencount--; 766 mutex_unlock(&rdev->devlist_mtx); 767 dev_put(dev); 768 } 769 cfg80211_lock_rdev(rdev); 770 mutex_lock(&rdev->devlist_mtx); 771#ifdef CONFIG_CFG80211_WEXT 772 wdev_lock(wdev); 773 switch (wdev->iftype) { 774 case NL80211_IFTYPE_ADHOC: 775 cfg80211_ibss_wext_join(rdev, wdev); 776 break; 777 case NL80211_IFTYPE_STATION: 778 cfg80211_mgd_wext_connect(rdev, wdev); 779 break; 780 default: 781 break; 782 } 783 wdev_unlock(wdev); 784#endif 785 rdev->opencount++; 786 mutex_unlock(&rdev->devlist_mtx); 787 cfg80211_unlock_rdev(rdev); 788 break; 789 case NETDEV_UNREGISTER: 790 /* 791 * NB: cannot take rdev->mtx here because this may be 792 * called within code protected by it when interfaces 793 * are removed with nl80211. 794 */ 795 mutex_lock(&rdev->devlist_mtx); 796 /* 797 * It is possible to get NETDEV_UNREGISTER 798 * multiple times. To detect that, check 799 * that the interface is still on the list 800 * of registered interfaces, and only then 801 * remove and clean it up. 802 */ 803 if (!list_empty(&wdev->list)) { 804 sysfs_remove_link(&dev->dev.kobj, "phy80211"); 805 list_del_rcu(&wdev->list); 806 rdev->devlist_generation++; 807 cfg80211_mlme_purge_actions(wdev); 808#ifdef CONFIG_CFG80211_WEXT 809 kfree(wdev->wext.keys); 810#endif 811 } 812 mutex_unlock(&rdev->devlist_mtx); 813 /* 814 * synchronise (so that we won't find this netdev 815 * from other code any more) and then clear the list 816 * head so that the above code can safely check for 817 * !list_empty() to avoid double-cleanup. 818 */ 819 synchronize_rcu(); 820 INIT_LIST_HEAD(&wdev->list); 821 break; 822 case NETDEV_PRE_UP: 823 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype))) 824 return notifier_from_errno(-EOPNOTSUPP); 825 if (rfkill_blocked(rdev->rfkill)) 826 return notifier_from_errno(-ERFKILL); 827 break; 828 } 829 830 return NOTIFY_DONE; 831} 832 833static struct notifier_block cfg80211_netdev_notifier = { 834 .notifier_call = cfg80211_netdev_notifier_call, 835}; 836 837static void __net_exit cfg80211_pernet_exit(struct net *net) 838{ 839 struct cfg80211_registered_device *rdev; 840 841 rtnl_lock(); 842 mutex_lock(&cfg80211_mutex); 843 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 844 if (net_eq(wiphy_net(&rdev->wiphy), net)) 845 WARN_ON(cfg80211_switch_netns(rdev, &init_net)); 846 } 847 mutex_unlock(&cfg80211_mutex); 848 rtnl_unlock(); 849} 850 851static struct pernet_operations cfg80211_pernet_ops = { 852 .exit = cfg80211_pernet_exit, 853}; 854 855static int __init cfg80211_init(void) 856{ 857 int err; 858 859 err = register_pernet_device(&cfg80211_pernet_ops); 860 if (err) 861 goto out_fail_pernet; 862 863 err = wiphy_sysfs_init(); 864 if (err) 865 goto out_fail_sysfs; 866 867 err = register_netdevice_notifier(&cfg80211_netdev_notifier); 868 if (err) 869 goto out_fail_notifier; 870 871 err = nl80211_init(); 872 if (err) 873 goto out_fail_nl80211; 874 875 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL); 876 877 err = regulatory_init(); 878 if (err) 879 goto out_fail_reg; 880 881 cfg80211_wq = create_singlethread_workqueue("cfg80211"); 882 if (!cfg80211_wq) 883 goto out_fail_wq; 884 885 return 0; 886 887out_fail_wq: 888 regulatory_exit(); 889out_fail_reg: 890 debugfs_remove(ieee80211_debugfs_dir); 891out_fail_nl80211: 892 unregister_netdevice_notifier(&cfg80211_netdev_notifier); 893out_fail_notifier: 894 wiphy_sysfs_exit(); 895out_fail_sysfs: 896 unregister_pernet_device(&cfg80211_pernet_ops); 897out_fail_pernet: 898 return err; 899} 900subsys_initcall(cfg80211_init); 901 902static void __exit cfg80211_exit(void) 903{ 904 debugfs_remove(ieee80211_debugfs_dir); 905 nl80211_exit(); 906 unregister_netdevice_notifier(&cfg80211_netdev_notifier); 907 wiphy_sysfs_exit(); 908 regulatory_exit(); 909 unregister_pernet_device(&cfg80211_pernet_ops); 910 destroy_workqueue(cfg80211_wq); 911} 912module_exit(cfg80211_exit); 913 914static int ___wiphy_printk(const char *level, const struct wiphy *wiphy, 915 struct va_format *vaf) 916{ 917 if (!wiphy) 918 return printk("%s(NULL wiphy *): %pV", level, vaf); 919 920 return printk("%s%s: %pV", level, wiphy_name(wiphy), vaf); 921} 922 923int __wiphy_printk(const char *level, const struct wiphy *wiphy, 924 const char *fmt, ...) 925{ 926 struct va_format vaf; 927 va_list args; 928 int r; 929 930 va_start(args, fmt); 931 932 vaf.fmt = fmt; 933 vaf.va = &args; 934 935 r = ___wiphy_printk(level, wiphy, &vaf); 936 va_end(args); 937 938 return r; 939} 940EXPORT_SYMBOL(__wiphy_printk); 941 942#define define_wiphy_printk_level(func, kern_level) \ 943int func(const struct wiphy *wiphy, const char *fmt, ...) \ 944{ \ 945 struct va_format vaf; \ 946 va_list args; \ 947 int r; \ 948 \ 949 va_start(args, fmt); \ 950 \ 951 vaf.fmt = fmt; \ 952 vaf.va = &args; \ 953 \ 954 r = ___wiphy_printk(kern_level, wiphy, &vaf); \ 955 va_end(args); \ 956 \ 957 return r; \ 958} \ 959EXPORT_SYMBOL(func); 960 961define_wiphy_printk_level(wiphy_debug, KERN_DEBUG); 962