1 /* 2 * Interface handling 3 * 4 * Copyright 2002-2005, Instant802 Networks, Inc. 5 * Copyright 2005-2006, Devicescape Software, Inc. 6 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz> 7 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net> 8 * Copyright 2013-2014 Intel Mobile Communications GmbH 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 */ 14 #include <linux/slab.h> 15 #include <linux/kernel.h> 16 #include <linux/if_arp.h> 17 #include <linux/netdevice.h> 18 #include <linux/rtnetlink.h> 19 #include <net/mac80211.h> 20 #include <net/ieee80211_radiotap.h> 21 #include "ieee80211_i.h" 22 #include "sta_info.h" 23 #include "debugfs_netdev.h" 24 #include "mesh.h" 25 #include "led.h" 26 #include "driver-ops.h" 27 #include "wme.h" 28 #include "rate.h" 29 30 /** 31 * DOC: Interface list locking 32 * 33 * The interface list in each struct ieee80211_local is protected 34 * three-fold: 35 * 36 * (1) modifications may only be done under the RTNL 37 * (2) modifications and readers are protected against each other by 38 * the iflist_mtx. 39 * (3) modifications are done in an RCU manner so atomic readers 40 * can traverse the list in RCU-safe blocks. 41 * 42 * As a consequence, reads (traversals) of the list can be protected 43 * by either the RTNL, the iflist_mtx or RCU. 44 */ 45 46 static void ieee80211_iface_work(struct work_struct *work); 47 48 bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata) 49 { 50 struct ieee80211_chanctx_conf *chanctx_conf; 51 int power; 52 53 rcu_read_lock(); 54 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 55 if (!chanctx_conf) { 56 rcu_read_unlock(); 57 return false; 58 } 59 60 power = ieee80211_chandef_max_power(&chanctx_conf->def); 61 rcu_read_unlock(); 62 63 if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL) 64 power = min(power, sdata->user_power_level); 65 66 if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL) 67 power = min(power, sdata->ap_power_level); 68 69 if (power != sdata->vif.bss_conf.txpower) { 70 sdata->vif.bss_conf.txpower = power; 71 ieee80211_hw_config(sdata->local, 0); 72 return true; 73 } 74 75 return false; 76 } 77 78 void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata, 79 bool update_bss) 80 { 81 if (__ieee80211_recalc_txpower(sdata) || 82 (update_bss && ieee80211_sdata_running(sdata))) 83 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER); 84 } 85 86 static u32 __ieee80211_idle_off(struct ieee80211_local *local) 87 { 88 if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE)) 89 return 0; 90 91 local->hw.conf.flags &= ~IEEE80211_CONF_IDLE; 92 return IEEE80211_CONF_CHANGE_IDLE; 93 } 94 95 static u32 __ieee80211_idle_on(struct ieee80211_local *local) 96 { 97 if (local->hw.conf.flags & IEEE80211_CONF_IDLE) 98 return 0; 99 100 ieee80211_flush_queues(local, NULL, false); 101 102 local->hw.conf.flags |= IEEE80211_CONF_IDLE; 103 return IEEE80211_CONF_CHANGE_IDLE; 104 } 105 106 static u32 __ieee80211_recalc_idle(struct ieee80211_local *local, 107 bool force_active) 108 { 109 bool working, scanning, active; 110 unsigned int led_trig_start = 0, led_trig_stop = 0; 111 112 lockdep_assert_held(&local->mtx); 113 114 active = force_active || 115 !list_empty(&local->chanctx_list) || 116 local->monitors; 117 118 working = !local->ops->remain_on_channel && 119 !list_empty(&local->roc_list); 120 121 scanning = test_bit(SCAN_SW_SCANNING, &local->scanning) || 122 test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning); 123 124 if (working || scanning) 125 led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK; 126 else 127 led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK; 128 129 if (active) 130 led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED; 131 else 132 led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED; 133 134 ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop); 135 136 if (working || scanning || active) 137 return __ieee80211_idle_off(local); 138 return __ieee80211_idle_on(local); 139 } 140 141 u32 ieee80211_idle_off(struct ieee80211_local *local) 142 { 143 return __ieee80211_recalc_idle(local, true); 144 } 145 146 void ieee80211_recalc_idle(struct ieee80211_local *local) 147 { 148 u32 change = __ieee80211_recalc_idle(local, false); 149 if (change) 150 ieee80211_hw_config(local, change); 151 } 152 153 static int ieee80211_change_mtu(struct net_device *dev, int new_mtu) 154 { 155 if (new_mtu < 256 || new_mtu > IEEE80211_MAX_DATA_LEN) 156 return -EINVAL; 157 158 dev->mtu = new_mtu; 159 return 0; 160 } 161 162 static int ieee80211_verify_mac(struct ieee80211_sub_if_data *sdata, u8 *addr, 163 bool check_dup) 164 { 165 struct ieee80211_local *local = sdata->local; 166 struct ieee80211_sub_if_data *iter; 167 u64 new, mask, tmp; 168 u8 *m; 169 int ret = 0; 170 171 if (is_zero_ether_addr(local->hw.wiphy->addr_mask)) 172 return 0; 173 174 m = addr; 175 new = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) | 176 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) | 177 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8); 178 179 m = local->hw.wiphy->addr_mask; 180 mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) | 181 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) | 182 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8); 183 184 if (!check_dup) 185 return ret; 186 187 mutex_lock(&local->iflist_mtx); 188 list_for_each_entry(iter, &local->interfaces, list) { 189 if (iter == sdata) 190 continue; 191 192 if (iter->vif.type == NL80211_IFTYPE_MONITOR && 193 !(iter->u.mntr.flags & MONITOR_FLAG_ACTIVE)) 194 continue; 195 196 m = iter->vif.addr; 197 tmp = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) | 198 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) | 199 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8); 200 201 if ((new & ~mask) != (tmp & ~mask)) { 202 ret = -EINVAL; 203 break; 204 } 205 } 206 mutex_unlock(&local->iflist_mtx); 207 208 return ret; 209 } 210 211 static int ieee80211_change_mac(struct net_device *dev, void *addr) 212 { 213 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 214 struct sockaddr *sa = addr; 215 bool check_dup = true; 216 int ret; 217 218 if (ieee80211_sdata_running(sdata)) 219 return -EBUSY; 220 221 if (sdata->vif.type == NL80211_IFTYPE_MONITOR && 222 !(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE)) 223 check_dup = false; 224 225 ret = ieee80211_verify_mac(sdata, sa->sa_data, check_dup); 226 if (ret) 227 return ret; 228 229 ret = eth_mac_addr(dev, sa); 230 231 if (ret == 0) 232 memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN); 233 234 return ret; 235 } 236 237 static inline int identical_mac_addr_allowed(int type1, int type2) 238 { 239 return type1 == NL80211_IFTYPE_MONITOR || 240 type2 == NL80211_IFTYPE_MONITOR || 241 type1 == NL80211_IFTYPE_P2P_DEVICE || 242 type2 == NL80211_IFTYPE_P2P_DEVICE || 243 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) || 244 (type1 == NL80211_IFTYPE_WDS && 245 (type2 == NL80211_IFTYPE_WDS || 246 type2 == NL80211_IFTYPE_AP)) || 247 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) || 248 (type1 == NL80211_IFTYPE_AP_VLAN && 249 (type2 == NL80211_IFTYPE_AP || 250 type2 == NL80211_IFTYPE_AP_VLAN)); 251 } 252 253 static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata, 254 enum nl80211_iftype iftype) 255 { 256 struct ieee80211_local *local = sdata->local; 257 struct ieee80211_sub_if_data *nsdata; 258 int ret; 259 260 ASSERT_RTNL(); 261 262 /* we hold the RTNL here so can safely walk the list */ 263 list_for_each_entry(nsdata, &local->interfaces, list) { 264 if (nsdata != sdata && ieee80211_sdata_running(nsdata)) { 265 /* 266 * Only OCB and monitor mode may coexist 267 */ 268 if ((sdata->vif.type == NL80211_IFTYPE_OCB && 269 nsdata->vif.type != NL80211_IFTYPE_MONITOR) || 270 (sdata->vif.type != NL80211_IFTYPE_MONITOR && 271 nsdata->vif.type == NL80211_IFTYPE_OCB)) 272 return -EBUSY; 273 274 /* 275 * Allow only a single IBSS interface to be up at any 276 * time. This is restricted because beacon distribution 277 * cannot work properly if both are in the same IBSS. 278 * 279 * To remove this restriction we'd have to disallow them 280 * from setting the same SSID on different IBSS interfaces 281 * belonging to the same hardware. Then, however, we're 282 * faced with having to adopt two different TSF timers... 283 */ 284 if (iftype == NL80211_IFTYPE_ADHOC && 285 nsdata->vif.type == NL80211_IFTYPE_ADHOC) 286 return -EBUSY; 287 /* 288 * will not add another interface while any channel 289 * switch is active. 290 */ 291 if (nsdata->vif.csa_active) 292 return -EBUSY; 293 294 /* 295 * The remaining checks are only performed for interfaces 296 * with the same MAC address. 297 */ 298 if (!ether_addr_equal(sdata->vif.addr, 299 nsdata->vif.addr)) 300 continue; 301 302 /* 303 * check whether it may have the same address 304 */ 305 if (!identical_mac_addr_allowed(iftype, 306 nsdata->vif.type)) 307 return -ENOTUNIQ; 308 309 /* 310 * can only add VLANs to enabled APs 311 */ 312 if (iftype == NL80211_IFTYPE_AP_VLAN && 313 nsdata->vif.type == NL80211_IFTYPE_AP) 314 sdata->bss = &nsdata->u.ap; 315 } 316 } 317 318 mutex_lock(&local->chanctx_mtx); 319 ret = ieee80211_check_combinations(sdata, NULL, 0, 0); 320 mutex_unlock(&local->chanctx_mtx); 321 return ret; 322 } 323 324 static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata, 325 enum nl80211_iftype iftype) 326 { 327 int n_queues = sdata->local->hw.queues; 328 int i; 329 330 if (iftype == NL80211_IFTYPE_NAN) 331 return 0; 332 333 if (iftype != NL80211_IFTYPE_P2P_DEVICE) { 334 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 335 if (WARN_ON_ONCE(sdata->vif.hw_queue[i] == 336 IEEE80211_INVAL_HW_QUEUE)) 337 return -EINVAL; 338 if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >= 339 n_queues)) 340 return -EINVAL; 341 } 342 } 343 344 if ((iftype != NL80211_IFTYPE_AP && 345 iftype != NL80211_IFTYPE_P2P_GO && 346 iftype != NL80211_IFTYPE_MESH_POINT) || 347 !ieee80211_hw_check(&sdata->local->hw, QUEUE_CONTROL)) { 348 sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE; 349 return 0; 350 } 351 352 if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE)) 353 return -EINVAL; 354 355 if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues)) 356 return -EINVAL; 357 358 return 0; 359 } 360 361 void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata, 362 const int offset) 363 { 364 struct ieee80211_local *local = sdata->local; 365 u32 flags = sdata->u.mntr.flags; 366 367 #define ADJUST(_f, _s) do { \ 368 if (flags & MONITOR_FLAG_##_f) \ 369 local->fif_##_s += offset; \ 370 } while (0) 371 372 ADJUST(FCSFAIL, fcsfail); 373 ADJUST(PLCPFAIL, plcpfail); 374 ADJUST(CONTROL, control); 375 ADJUST(CONTROL, pspoll); 376 ADJUST(OTHER_BSS, other_bss); 377 378 #undef ADJUST 379 } 380 381 static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata) 382 { 383 struct ieee80211_local *local = sdata->local; 384 int i; 385 386 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 387 if (ieee80211_hw_check(&local->hw, QUEUE_CONTROL)) 388 sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE; 389 else if (local->hw.queues >= IEEE80211_NUM_ACS) 390 sdata->vif.hw_queue[i] = i; 391 else 392 sdata->vif.hw_queue[i] = 0; 393 } 394 sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE; 395 } 396 397 int ieee80211_add_virtual_monitor(struct ieee80211_local *local) 398 { 399 struct ieee80211_sub_if_data *sdata; 400 int ret; 401 402 if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF)) 403 return 0; 404 405 ASSERT_RTNL(); 406 407 if (local->monitor_sdata) 408 return 0; 409 410 sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL); 411 if (!sdata) 412 return -ENOMEM; 413 414 /* set up data */ 415 sdata->local = local; 416 sdata->vif.type = NL80211_IFTYPE_MONITOR; 417 snprintf(sdata->name, IFNAMSIZ, "%s-monitor", 418 wiphy_name(local->hw.wiphy)); 419 sdata->wdev.iftype = NL80211_IFTYPE_MONITOR; 420 421 sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM; 422 423 ieee80211_set_default_queues(sdata); 424 425 ret = drv_add_interface(local, sdata); 426 if (WARN_ON(ret)) { 427 /* ok .. stupid driver, it asked for this! */ 428 kfree(sdata); 429 return ret; 430 } 431 432 ret = ieee80211_check_queues(sdata, NL80211_IFTYPE_MONITOR); 433 if (ret) { 434 kfree(sdata); 435 return ret; 436 } 437 438 mutex_lock(&local->iflist_mtx); 439 rcu_assign_pointer(local->monitor_sdata, sdata); 440 mutex_unlock(&local->iflist_mtx); 441 442 mutex_lock(&local->mtx); 443 ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef, 444 IEEE80211_CHANCTX_EXCLUSIVE); 445 mutex_unlock(&local->mtx); 446 if (ret) { 447 mutex_lock(&local->iflist_mtx); 448 RCU_INIT_POINTER(local->monitor_sdata, NULL); 449 mutex_unlock(&local->iflist_mtx); 450 synchronize_net(); 451 drv_remove_interface(local, sdata); 452 kfree(sdata); 453 return ret; 454 } 455 456 skb_queue_head_init(&sdata->skb_queue); 457 INIT_WORK(&sdata->work, ieee80211_iface_work); 458 459 return 0; 460 } 461 462 void ieee80211_del_virtual_monitor(struct ieee80211_local *local) 463 { 464 struct ieee80211_sub_if_data *sdata; 465 466 if (!ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF)) 467 return; 468 469 ASSERT_RTNL(); 470 471 mutex_lock(&local->iflist_mtx); 472 473 sdata = rcu_dereference_protected(local->monitor_sdata, 474 lockdep_is_held(&local->iflist_mtx)); 475 if (!sdata) { 476 mutex_unlock(&local->iflist_mtx); 477 return; 478 } 479 480 RCU_INIT_POINTER(local->monitor_sdata, NULL); 481 mutex_unlock(&local->iflist_mtx); 482 483 synchronize_net(); 484 485 mutex_lock(&local->mtx); 486 ieee80211_vif_release_channel(sdata); 487 mutex_unlock(&local->mtx); 488 489 drv_remove_interface(local, sdata); 490 491 kfree(sdata); 492 } 493 494 /* 495 * NOTE: Be very careful when changing this function, it must NOT return 496 * an error on interface type changes that have been pre-checked, so most 497 * checks should be in ieee80211_check_concurrent_iface. 498 */ 499 int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up) 500 { 501 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev); 502 struct net_device *dev = wdev->netdev; 503 struct ieee80211_local *local = sdata->local; 504 struct sta_info *sta; 505 u32 changed = 0; 506 int res; 507 u32 hw_reconf_flags = 0; 508 509 switch (sdata->vif.type) { 510 case NL80211_IFTYPE_WDS: 511 if (!is_valid_ether_addr(sdata->u.wds.remote_addr)) 512 return -ENOLINK; 513 break; 514 case NL80211_IFTYPE_AP_VLAN: { 515 struct ieee80211_sub_if_data *master; 516 517 if (!sdata->bss) 518 return -ENOLINK; 519 520 mutex_lock(&local->mtx); 521 list_add(&sdata->u.vlan.list, &sdata->bss->vlans); 522 mutex_unlock(&local->mtx); 523 524 master = container_of(sdata->bss, 525 struct ieee80211_sub_if_data, u.ap); 526 sdata->control_port_protocol = 527 master->control_port_protocol; 528 sdata->control_port_no_encrypt = 529 master->control_port_no_encrypt; 530 sdata->vif.cab_queue = master->vif.cab_queue; 531 memcpy(sdata->vif.hw_queue, master->vif.hw_queue, 532 sizeof(sdata->vif.hw_queue)); 533 sdata->vif.bss_conf.chandef = master->vif.bss_conf.chandef; 534 535 mutex_lock(&local->key_mtx); 536 sdata->crypto_tx_tailroom_needed_cnt += 537 master->crypto_tx_tailroom_needed_cnt; 538 mutex_unlock(&local->key_mtx); 539 540 break; 541 } 542 case NL80211_IFTYPE_AP: 543 sdata->bss = &sdata->u.ap; 544 break; 545 case NL80211_IFTYPE_MESH_POINT: 546 case NL80211_IFTYPE_STATION: 547 case NL80211_IFTYPE_MONITOR: 548 case NL80211_IFTYPE_ADHOC: 549 case NL80211_IFTYPE_P2P_DEVICE: 550 case NL80211_IFTYPE_OCB: 551 case NL80211_IFTYPE_NAN: 552 /* no special treatment */ 553 break; 554 case NL80211_IFTYPE_UNSPECIFIED: 555 case NUM_NL80211_IFTYPES: 556 case NL80211_IFTYPE_P2P_CLIENT: 557 case NL80211_IFTYPE_P2P_GO: 558 /* cannot happen */ 559 WARN_ON(1); 560 break; 561 } 562 563 if (local->open_count == 0) { 564 res = drv_start(local); 565 if (res) 566 goto err_del_bss; 567 /* we're brought up, everything changes */ 568 hw_reconf_flags = ~0; 569 ieee80211_led_radio(local, true); 570 ieee80211_mod_tpt_led_trig(local, 571 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0); 572 } 573 574 /* 575 * Copy the hopefully now-present MAC address to 576 * this interface, if it has the special null one. 577 */ 578 if (dev && is_zero_ether_addr(dev->dev_addr)) { 579 memcpy(dev->dev_addr, 580 local->hw.wiphy->perm_addr, 581 ETH_ALEN); 582 memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN); 583 584 if (!is_valid_ether_addr(dev->dev_addr)) { 585 res = -EADDRNOTAVAIL; 586 goto err_stop; 587 } 588 } 589 590 switch (sdata->vif.type) { 591 case NL80211_IFTYPE_AP_VLAN: 592 /* no need to tell driver, but set carrier and chanctx */ 593 if (rtnl_dereference(sdata->bss->beacon)) { 594 ieee80211_vif_vlan_copy_chanctx(sdata); 595 netif_carrier_on(dev); 596 } else { 597 netif_carrier_off(dev); 598 } 599 break; 600 case NL80211_IFTYPE_MONITOR: 601 if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) { 602 local->cooked_mntrs++; 603 break; 604 } 605 606 if (sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE) { 607 res = drv_add_interface(local, sdata); 608 if (res) 609 goto err_stop; 610 } else if (local->monitors == 0 && local->open_count == 0) { 611 res = ieee80211_add_virtual_monitor(local); 612 if (res) 613 goto err_stop; 614 } 615 616 /* must be before the call to ieee80211_configure_filter */ 617 local->monitors++; 618 if (local->monitors == 1) { 619 local->hw.conf.flags |= IEEE80211_CONF_MONITOR; 620 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR; 621 } 622 623 ieee80211_adjust_monitor_flags(sdata, 1); 624 ieee80211_configure_filter(local); 625 mutex_lock(&local->mtx); 626 ieee80211_recalc_idle(local); 627 mutex_unlock(&local->mtx); 628 629 netif_carrier_on(dev); 630 break; 631 default: 632 if (coming_up) { 633 ieee80211_del_virtual_monitor(local); 634 635 res = drv_add_interface(local, sdata); 636 if (res) 637 goto err_stop; 638 res = ieee80211_check_queues(sdata, 639 ieee80211_vif_type_p2p(&sdata->vif)); 640 if (res) 641 goto err_del_interface; 642 } 643 644 if (sdata->vif.type == NL80211_IFTYPE_AP) { 645 local->fif_pspoll++; 646 local->fif_probe_req++; 647 648 ieee80211_configure_filter(local); 649 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { 650 local->fif_probe_req++; 651 } 652 653 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE && 654 sdata->vif.type != NL80211_IFTYPE_NAN) 655 changed |= ieee80211_reset_erp_info(sdata); 656 ieee80211_bss_info_change_notify(sdata, changed); 657 658 switch (sdata->vif.type) { 659 case NL80211_IFTYPE_STATION: 660 case NL80211_IFTYPE_ADHOC: 661 case NL80211_IFTYPE_AP: 662 case NL80211_IFTYPE_MESH_POINT: 663 case NL80211_IFTYPE_OCB: 664 netif_carrier_off(dev); 665 break; 666 case NL80211_IFTYPE_WDS: 667 case NL80211_IFTYPE_P2P_DEVICE: 668 case NL80211_IFTYPE_NAN: 669 break; 670 default: 671 /* not reached */ 672 WARN_ON(1); 673 } 674 675 /* 676 * Set default queue parameters so drivers don't 677 * need to initialise the hardware if the hardware 678 * doesn't start up with sane defaults. 679 * Enable QoS for anything but station interfaces. 680 */ 681 ieee80211_set_wmm_default(sdata, true, 682 sdata->vif.type != NL80211_IFTYPE_STATION); 683 } 684 685 set_bit(SDATA_STATE_RUNNING, &sdata->state); 686 687 if (sdata->vif.type == NL80211_IFTYPE_WDS) { 688 /* Create STA entry for the WDS peer */ 689 sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr, 690 GFP_KERNEL); 691 if (!sta) { 692 res = -ENOMEM; 693 goto err_del_interface; 694 } 695 696 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH); 697 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC); 698 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED); 699 700 res = sta_info_insert(sta); 701 if (res) { 702 /* STA has been freed */ 703 goto err_del_interface; 704 } 705 706 rate_control_rate_init(sta); 707 netif_carrier_on(dev); 708 } else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) { 709 rcu_assign_pointer(local->p2p_sdata, sdata); 710 } 711 712 /* 713 * set_multicast_list will be invoked by the networking core 714 * which will check whether any increments here were done in 715 * error and sync them down to the hardware as filter flags. 716 */ 717 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 718 atomic_inc(&local->iff_allmultis); 719 720 if (coming_up) 721 local->open_count++; 722 723 if (hw_reconf_flags) 724 ieee80211_hw_config(local, hw_reconf_flags); 725 726 ieee80211_recalc_ps(local); 727 728 if (sdata->vif.type == NL80211_IFTYPE_MONITOR || 729 sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 730 /* XXX: for AP_VLAN, actually track AP queues */ 731 netif_tx_start_all_queues(dev); 732 } else if (dev) { 733 unsigned long flags; 734 int n_acs = IEEE80211_NUM_ACS; 735 int ac; 736 737 if (local->hw.queues < IEEE80211_NUM_ACS) 738 n_acs = 1; 739 740 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 741 if (sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE || 742 (local->queue_stop_reasons[sdata->vif.cab_queue] == 0 && 743 skb_queue_empty(&local->pending[sdata->vif.cab_queue]))) { 744 for (ac = 0; ac < n_acs; ac++) { 745 int ac_queue = sdata->vif.hw_queue[ac]; 746 747 if (local->queue_stop_reasons[ac_queue] == 0 && 748 skb_queue_empty(&local->pending[ac_queue])) 749 netif_start_subqueue(dev, ac); 750 } 751 } 752 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 753 } 754 755 return 0; 756 err_del_interface: 757 drv_remove_interface(local, sdata); 758 err_stop: 759 if (!local->open_count) 760 drv_stop(local); 761 err_del_bss: 762 sdata->bss = NULL; 763 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 764 mutex_lock(&local->mtx); 765 list_del(&sdata->u.vlan.list); 766 mutex_unlock(&local->mtx); 767 } 768 /* might already be clear but that doesn't matter */ 769 clear_bit(SDATA_STATE_RUNNING, &sdata->state); 770 return res; 771 } 772 773 static int ieee80211_open(struct net_device *dev) 774 { 775 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 776 int err; 777 778 /* fail early if user set an invalid address */ 779 if (!is_valid_ether_addr(dev->dev_addr)) 780 return -EADDRNOTAVAIL; 781 782 err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type); 783 if (err) 784 return err; 785 786 return ieee80211_do_open(&sdata->wdev, true); 787 } 788 789 static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata, 790 bool going_down) 791 { 792 struct ieee80211_local *local = sdata->local; 793 struct fq *fq = &local->fq; 794 unsigned long flags; 795 struct sk_buff *skb, *tmp; 796 u32 hw_reconf_flags = 0; 797 int i, flushed; 798 struct ps_data *ps; 799 struct cfg80211_chan_def chandef; 800 bool cancel_scan; 801 struct cfg80211_nan_func *func; 802 803 clear_bit(SDATA_STATE_RUNNING, &sdata->state); 804 805 cancel_scan = rcu_access_pointer(local->scan_sdata) == sdata; 806 if (cancel_scan) 807 ieee80211_scan_cancel(local); 808 809 /* 810 * Stop TX on this interface first. 811 */ 812 if (sdata->dev) 813 netif_tx_stop_all_queues(sdata->dev); 814 815 ieee80211_roc_purge(local, sdata); 816 817 switch (sdata->vif.type) { 818 case NL80211_IFTYPE_STATION: 819 ieee80211_mgd_stop(sdata); 820 break; 821 case NL80211_IFTYPE_ADHOC: 822 ieee80211_ibss_stop(sdata); 823 break; 824 case NL80211_IFTYPE_AP: 825 cancel_work_sync(&sdata->u.ap.request_smps_work); 826 break; 827 default: 828 break; 829 } 830 831 /* 832 * Remove all stations associated with this interface. 833 * 834 * This must be done before calling ops->remove_interface() 835 * because otherwise we can later invoke ops->sta_notify() 836 * whenever the STAs are removed, and that invalidates driver 837 * assumptions about always getting a vif pointer that is valid 838 * (because if we remove a STA after ops->remove_interface() 839 * the driver will have removed the vif info already!) 840 * 841 * In WDS mode a station must exist here and be flushed, for 842 * AP_VLANs stations may exist since there's nothing else that 843 * would have removed them, but in other modes there shouldn't 844 * be any stations. 845 */ 846 flushed = sta_info_flush(sdata); 847 WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_AP_VLAN && 848 ((sdata->vif.type != NL80211_IFTYPE_WDS && flushed > 0) || 849 (sdata->vif.type == NL80211_IFTYPE_WDS && flushed != 1))); 850 851 /* don't count this interface for allmulti while it is down */ 852 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 853 atomic_dec(&local->iff_allmultis); 854 855 if (sdata->vif.type == NL80211_IFTYPE_AP) { 856 local->fif_pspoll--; 857 local->fif_probe_req--; 858 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { 859 local->fif_probe_req--; 860 } 861 862 if (sdata->dev) { 863 netif_addr_lock_bh(sdata->dev); 864 spin_lock_bh(&local->filter_lock); 865 __hw_addr_unsync(&local->mc_list, &sdata->dev->mc, 866 sdata->dev->addr_len); 867 spin_unlock_bh(&local->filter_lock); 868 netif_addr_unlock_bh(sdata->dev); 869 } 870 871 del_timer_sync(&local->dynamic_ps_timer); 872 cancel_work_sync(&local->dynamic_ps_enable_work); 873 874 cancel_work_sync(&sdata->recalc_smps); 875 sdata_lock(sdata); 876 mutex_lock(&local->mtx); 877 sdata->vif.csa_active = false; 878 if (sdata->vif.type == NL80211_IFTYPE_STATION) 879 sdata->u.mgd.csa_waiting_bcn = false; 880 if (sdata->csa_block_tx) { 881 ieee80211_wake_vif_queues(local, sdata, 882 IEEE80211_QUEUE_STOP_REASON_CSA); 883 sdata->csa_block_tx = false; 884 } 885 mutex_unlock(&local->mtx); 886 sdata_unlock(sdata); 887 888 cancel_work_sync(&sdata->csa_finalize_work); 889 890 cancel_delayed_work_sync(&sdata->dfs_cac_timer_work); 891 892 if (sdata->wdev.cac_started) { 893 chandef = sdata->vif.bss_conf.chandef; 894 WARN_ON(local->suspended); 895 mutex_lock(&local->mtx); 896 ieee80211_vif_release_channel(sdata); 897 mutex_unlock(&local->mtx); 898 cfg80211_cac_event(sdata->dev, &chandef, 899 NL80211_RADAR_CAC_ABORTED, 900 GFP_KERNEL); 901 } 902 903 /* APs need special treatment */ 904 if (sdata->vif.type == NL80211_IFTYPE_AP) { 905 struct ieee80211_sub_if_data *vlan, *tmpsdata; 906 907 /* down all dependent devices, that is VLANs */ 908 list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans, 909 u.vlan.list) 910 dev_close(vlan->dev); 911 WARN_ON(!list_empty(&sdata->u.ap.vlans)); 912 } else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 913 /* remove all packets in parent bc_buf pointing to this dev */ 914 ps = &sdata->bss->ps; 915 916 spin_lock_irqsave(&ps->bc_buf.lock, flags); 917 skb_queue_walk_safe(&ps->bc_buf, skb, tmp) { 918 if (skb->dev == sdata->dev) { 919 __skb_unlink(skb, &ps->bc_buf); 920 local->total_ps_buffered--; 921 ieee80211_free_txskb(&local->hw, skb); 922 } 923 } 924 spin_unlock_irqrestore(&ps->bc_buf.lock, flags); 925 } 926 927 if (going_down) 928 local->open_count--; 929 930 switch (sdata->vif.type) { 931 case NL80211_IFTYPE_AP_VLAN: 932 mutex_lock(&local->mtx); 933 list_del(&sdata->u.vlan.list); 934 mutex_unlock(&local->mtx); 935 RCU_INIT_POINTER(sdata->vif.chanctx_conf, NULL); 936 /* see comment in the default case below */ 937 ieee80211_free_keys(sdata, true); 938 /* no need to tell driver */ 939 break; 940 case NL80211_IFTYPE_MONITOR: 941 if (sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) { 942 local->cooked_mntrs--; 943 break; 944 } 945 946 local->monitors--; 947 if (local->monitors == 0) { 948 local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR; 949 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR; 950 } 951 952 ieee80211_adjust_monitor_flags(sdata, -1); 953 break; 954 case NL80211_IFTYPE_NAN: 955 /* clean all the functions */ 956 spin_lock_bh(&sdata->u.nan.func_lock); 957 958 idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, i) { 959 idr_remove(&sdata->u.nan.function_inst_ids, i); 960 cfg80211_free_nan_func(func); 961 } 962 idr_destroy(&sdata->u.nan.function_inst_ids); 963 964 spin_unlock_bh(&sdata->u.nan.func_lock); 965 break; 966 case NL80211_IFTYPE_P2P_DEVICE: 967 /* relies on synchronize_rcu() below */ 968 RCU_INIT_POINTER(local->p2p_sdata, NULL); 969 /* fall through */ 970 default: 971 cancel_work_sync(&sdata->work); 972 /* 973 * When we get here, the interface is marked down. 974 * Free the remaining keys, if there are any 975 * (which can happen in AP mode if userspace sets 976 * keys before the interface is operating, and maybe 977 * also in WDS mode) 978 * 979 * Force the key freeing to always synchronize_net() 980 * to wait for the RX path in case it is using this 981 * interface enqueuing frames at this very time on 982 * another CPU. 983 */ 984 ieee80211_free_keys(sdata, true); 985 skb_queue_purge(&sdata->skb_queue); 986 } 987 988 sdata->bss = NULL; 989 990 spin_lock_irqsave(&local->queue_stop_reason_lock, flags); 991 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) { 992 skb_queue_walk_safe(&local->pending[i], skb, tmp) { 993 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 994 if (info->control.vif == &sdata->vif) { 995 __skb_unlink(skb, &local->pending[i]); 996 ieee80211_free_txskb(&local->hw, skb); 997 } 998 } 999 } 1000 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags); 1001 1002 if (sdata->vif.txq) { 1003 struct txq_info *txqi = to_txq_info(sdata->vif.txq); 1004 1005 spin_lock_bh(&fq->lock); 1006 ieee80211_txq_purge(local, txqi); 1007 spin_unlock_bh(&fq->lock); 1008 } 1009 1010 if (local->open_count == 0) 1011 ieee80211_clear_tx_pending(local); 1012 1013 /* 1014 * If the interface goes down while suspended, presumably because 1015 * the device was unplugged and that happens before our resume, 1016 * then the driver is already unconfigured and the remainder of 1017 * this function isn't needed. 1018 * XXX: what about WoWLAN? If the device has software state, e.g. 1019 * memory allocated, it might expect teardown commands from 1020 * mac80211 here? 1021 */ 1022 if (local->suspended) { 1023 WARN_ON(local->wowlan); 1024 WARN_ON(rtnl_dereference(local->monitor_sdata)); 1025 return; 1026 } 1027 1028 switch (sdata->vif.type) { 1029 case NL80211_IFTYPE_AP_VLAN: 1030 break; 1031 case NL80211_IFTYPE_MONITOR: 1032 if (local->monitors == 0) 1033 ieee80211_del_virtual_monitor(local); 1034 1035 mutex_lock(&local->mtx); 1036 ieee80211_recalc_idle(local); 1037 mutex_unlock(&local->mtx); 1038 1039 if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE)) 1040 break; 1041 1042 /* fall through */ 1043 default: 1044 if (going_down) 1045 drv_remove_interface(local, sdata); 1046 } 1047 1048 ieee80211_recalc_ps(local); 1049 1050 if (cancel_scan) 1051 flush_delayed_work(&local->scan_work); 1052 1053 if (local->open_count == 0) { 1054 ieee80211_stop_device(local); 1055 1056 /* no reconfiguring after stop! */ 1057 return; 1058 } 1059 1060 /* do after stop to avoid reconfiguring when we stop anyway */ 1061 ieee80211_configure_filter(local); 1062 ieee80211_hw_config(local, hw_reconf_flags); 1063 1064 if (local->monitors == local->open_count) 1065 ieee80211_add_virtual_monitor(local); 1066 } 1067 1068 static int ieee80211_stop(struct net_device *dev) 1069 { 1070 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1071 1072 ieee80211_do_stop(sdata, true); 1073 1074 return 0; 1075 } 1076 1077 static void ieee80211_set_multicast_list(struct net_device *dev) 1078 { 1079 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1080 struct ieee80211_local *local = sdata->local; 1081 int allmulti, sdata_allmulti; 1082 1083 allmulti = !!(dev->flags & IFF_ALLMULTI); 1084 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI); 1085 1086 if (allmulti != sdata_allmulti) { 1087 if (dev->flags & IFF_ALLMULTI) 1088 atomic_inc(&local->iff_allmultis); 1089 else 1090 atomic_dec(&local->iff_allmultis); 1091 sdata->flags ^= IEEE80211_SDATA_ALLMULTI; 1092 } 1093 1094 spin_lock_bh(&local->filter_lock); 1095 __hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len); 1096 spin_unlock_bh(&local->filter_lock); 1097 ieee80211_queue_work(&local->hw, &local->reconfig_filter); 1098 } 1099 1100 /* 1101 * Called when the netdev is removed or, by the code below, before 1102 * the interface type changes. 1103 */ 1104 static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata) 1105 { 1106 int i; 1107 1108 /* free extra data */ 1109 ieee80211_free_keys(sdata, false); 1110 1111 ieee80211_debugfs_remove_netdev(sdata); 1112 1113 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 1114 __skb_queue_purge(&sdata->fragments[i].skb_list); 1115 sdata->fragment_next = 0; 1116 1117 if (ieee80211_vif_is_mesh(&sdata->vif)) 1118 ieee80211_mesh_teardown_sdata(sdata); 1119 } 1120 1121 static void ieee80211_uninit(struct net_device *dev) 1122 { 1123 ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev)); 1124 } 1125 1126 static u16 ieee80211_netdev_select_queue(struct net_device *dev, 1127 struct sk_buff *skb, 1128 void *accel_priv, 1129 select_queue_fallback_t fallback) 1130 { 1131 return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb); 1132 } 1133 1134 static struct rtnl_link_stats64 * 1135 ieee80211_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats) 1136 { 1137 int i; 1138 1139 for_each_possible_cpu(i) { 1140 const struct pcpu_sw_netstats *tstats; 1141 u64 rx_packets, rx_bytes, tx_packets, tx_bytes; 1142 unsigned int start; 1143 1144 tstats = per_cpu_ptr(dev->tstats, i); 1145 1146 do { 1147 start = u64_stats_fetch_begin_irq(&tstats->syncp); 1148 rx_packets = tstats->rx_packets; 1149 tx_packets = tstats->tx_packets; 1150 rx_bytes = tstats->rx_bytes; 1151 tx_bytes = tstats->tx_bytes; 1152 } while (u64_stats_fetch_retry_irq(&tstats->syncp, start)); 1153 1154 stats->rx_packets += rx_packets; 1155 stats->tx_packets += tx_packets; 1156 stats->rx_bytes += rx_bytes; 1157 stats->tx_bytes += tx_bytes; 1158 } 1159 1160 return stats; 1161 } 1162 1163 static const struct net_device_ops ieee80211_dataif_ops = { 1164 .ndo_open = ieee80211_open, 1165 .ndo_stop = ieee80211_stop, 1166 .ndo_uninit = ieee80211_uninit, 1167 .ndo_start_xmit = ieee80211_subif_start_xmit, 1168 .ndo_set_rx_mode = ieee80211_set_multicast_list, 1169 .ndo_change_mtu = ieee80211_change_mtu, 1170 .ndo_set_mac_address = ieee80211_change_mac, 1171 .ndo_select_queue = ieee80211_netdev_select_queue, 1172 .ndo_get_stats64 = ieee80211_get_stats64, 1173 }; 1174 1175 static u16 ieee80211_monitor_select_queue(struct net_device *dev, 1176 struct sk_buff *skb, 1177 void *accel_priv, 1178 select_queue_fallback_t fallback) 1179 { 1180 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1181 struct ieee80211_local *local = sdata->local; 1182 struct ieee80211_hdr *hdr; 1183 struct ieee80211_radiotap_header *rtap = (void *)skb->data; 1184 1185 if (local->hw.queues < IEEE80211_NUM_ACS) 1186 return 0; 1187 1188 if (skb->len < 4 || 1189 skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */) 1190 return 0; /* doesn't matter, frame will be dropped */ 1191 1192 hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len)); 1193 1194 return ieee80211_select_queue_80211(sdata, skb, hdr); 1195 } 1196 1197 static const struct net_device_ops ieee80211_monitorif_ops = { 1198 .ndo_open = ieee80211_open, 1199 .ndo_stop = ieee80211_stop, 1200 .ndo_uninit = ieee80211_uninit, 1201 .ndo_start_xmit = ieee80211_monitor_start_xmit, 1202 .ndo_set_rx_mode = ieee80211_set_multicast_list, 1203 .ndo_change_mtu = ieee80211_change_mtu, 1204 .ndo_set_mac_address = ieee80211_change_mac, 1205 .ndo_select_queue = ieee80211_monitor_select_queue, 1206 .ndo_get_stats64 = ieee80211_get_stats64, 1207 }; 1208 1209 static void ieee80211_if_free(struct net_device *dev) 1210 { 1211 free_percpu(dev->tstats); 1212 free_netdev(dev); 1213 } 1214 1215 static void ieee80211_if_setup(struct net_device *dev) 1216 { 1217 ether_setup(dev); 1218 dev->priv_flags &= ~IFF_TX_SKB_SHARING; 1219 dev->netdev_ops = &ieee80211_dataif_ops; 1220 dev->destructor = ieee80211_if_free; 1221 } 1222 1223 static void ieee80211_if_setup_no_queue(struct net_device *dev) 1224 { 1225 ieee80211_if_setup(dev); 1226 dev->priv_flags |= IFF_NO_QUEUE; 1227 } 1228 1229 static void ieee80211_iface_work(struct work_struct *work) 1230 { 1231 struct ieee80211_sub_if_data *sdata = 1232 container_of(work, struct ieee80211_sub_if_data, work); 1233 struct ieee80211_local *local = sdata->local; 1234 struct sk_buff *skb; 1235 struct sta_info *sta; 1236 struct ieee80211_ra_tid *ra_tid; 1237 struct ieee80211_rx_agg *rx_agg; 1238 1239 if (!ieee80211_sdata_running(sdata)) 1240 return; 1241 1242 if (test_bit(SCAN_SW_SCANNING, &local->scanning)) 1243 return; 1244 1245 if (!ieee80211_can_run_worker(local)) 1246 return; 1247 1248 /* first process frames */ 1249 while ((skb = skb_dequeue(&sdata->skb_queue))) { 1250 struct ieee80211_mgmt *mgmt = (void *)skb->data; 1251 1252 if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) { 1253 ra_tid = (void *)&skb->cb; 1254 ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra, 1255 ra_tid->tid); 1256 } else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) { 1257 ra_tid = (void *)&skb->cb; 1258 ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra, 1259 ra_tid->tid); 1260 } else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_RX_AGG_START) { 1261 rx_agg = (void *)&skb->cb; 1262 mutex_lock(&local->sta_mtx); 1263 sta = sta_info_get_bss(sdata, rx_agg->addr); 1264 if (sta) 1265 __ieee80211_start_rx_ba_session(sta, 1266 0, 0, 0, 1, rx_agg->tid, 1267 IEEE80211_MAX_AMPDU_BUF, 1268 false, true); 1269 mutex_unlock(&local->sta_mtx); 1270 } else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_RX_AGG_STOP) { 1271 rx_agg = (void *)&skb->cb; 1272 mutex_lock(&local->sta_mtx); 1273 sta = sta_info_get_bss(sdata, rx_agg->addr); 1274 if (sta) 1275 __ieee80211_stop_rx_ba_session(sta, 1276 rx_agg->tid, 1277 WLAN_BACK_RECIPIENT, 0, 1278 false); 1279 mutex_unlock(&local->sta_mtx); 1280 } else if (ieee80211_is_action(mgmt->frame_control) && 1281 mgmt->u.action.category == WLAN_CATEGORY_BACK) { 1282 int len = skb->len; 1283 1284 mutex_lock(&local->sta_mtx); 1285 sta = sta_info_get_bss(sdata, mgmt->sa); 1286 if (sta) { 1287 switch (mgmt->u.action.u.addba_req.action_code) { 1288 case WLAN_ACTION_ADDBA_REQ: 1289 ieee80211_process_addba_request( 1290 local, sta, mgmt, len); 1291 break; 1292 case WLAN_ACTION_ADDBA_RESP: 1293 ieee80211_process_addba_resp(local, sta, 1294 mgmt, len); 1295 break; 1296 case WLAN_ACTION_DELBA: 1297 ieee80211_process_delba(sdata, sta, 1298 mgmt, len); 1299 break; 1300 default: 1301 WARN_ON(1); 1302 break; 1303 } 1304 } 1305 mutex_unlock(&local->sta_mtx); 1306 } else if (ieee80211_is_action(mgmt->frame_control) && 1307 mgmt->u.action.category == WLAN_CATEGORY_VHT) { 1308 switch (mgmt->u.action.u.vht_group_notif.action_code) { 1309 case WLAN_VHT_ACTION_GROUPID_MGMT: 1310 ieee80211_process_mu_groups(sdata, mgmt); 1311 break; 1312 default: 1313 WARN_ON(1); 1314 break; 1315 } 1316 } else if (ieee80211_is_data_qos(mgmt->frame_control)) { 1317 struct ieee80211_hdr *hdr = (void *)mgmt; 1318 /* 1319 * So the frame isn't mgmt, but frame_control 1320 * is at the right place anyway, of course, so 1321 * the if statement is correct. 1322 * 1323 * Warn if we have other data frame types here, 1324 * they must not get here. 1325 */ 1326 WARN_ON(hdr->frame_control & 1327 cpu_to_le16(IEEE80211_STYPE_NULLFUNC)); 1328 WARN_ON(!(hdr->seq_ctrl & 1329 cpu_to_le16(IEEE80211_SCTL_FRAG))); 1330 /* 1331 * This was a fragment of a frame, received while 1332 * a block-ack session was active. That cannot be 1333 * right, so terminate the session. 1334 */ 1335 mutex_lock(&local->sta_mtx); 1336 sta = sta_info_get_bss(sdata, mgmt->sa); 1337 if (sta) { 1338 u16 tid = *ieee80211_get_qos_ctl(hdr) & 1339 IEEE80211_QOS_CTL_TID_MASK; 1340 1341 __ieee80211_stop_rx_ba_session( 1342 sta, tid, WLAN_BACK_RECIPIENT, 1343 WLAN_REASON_QSTA_REQUIRE_SETUP, 1344 true); 1345 } 1346 mutex_unlock(&local->sta_mtx); 1347 } else switch (sdata->vif.type) { 1348 case NL80211_IFTYPE_STATION: 1349 ieee80211_sta_rx_queued_mgmt(sdata, skb); 1350 break; 1351 case NL80211_IFTYPE_ADHOC: 1352 ieee80211_ibss_rx_queued_mgmt(sdata, skb); 1353 break; 1354 case NL80211_IFTYPE_MESH_POINT: 1355 if (!ieee80211_vif_is_mesh(&sdata->vif)) 1356 break; 1357 ieee80211_mesh_rx_queued_mgmt(sdata, skb); 1358 break; 1359 default: 1360 WARN(1, "frame for unexpected interface type"); 1361 break; 1362 } 1363 1364 kfree_skb(skb); 1365 } 1366 1367 /* then other type-dependent work */ 1368 switch (sdata->vif.type) { 1369 case NL80211_IFTYPE_STATION: 1370 ieee80211_sta_work(sdata); 1371 break; 1372 case NL80211_IFTYPE_ADHOC: 1373 ieee80211_ibss_work(sdata); 1374 break; 1375 case NL80211_IFTYPE_MESH_POINT: 1376 if (!ieee80211_vif_is_mesh(&sdata->vif)) 1377 break; 1378 ieee80211_mesh_work(sdata); 1379 break; 1380 case NL80211_IFTYPE_OCB: 1381 ieee80211_ocb_work(sdata); 1382 break; 1383 default: 1384 break; 1385 } 1386 } 1387 1388 static void ieee80211_recalc_smps_work(struct work_struct *work) 1389 { 1390 struct ieee80211_sub_if_data *sdata = 1391 container_of(work, struct ieee80211_sub_if_data, recalc_smps); 1392 1393 ieee80211_recalc_smps(sdata); 1394 } 1395 1396 /* 1397 * Helper function to initialise an interface to a specific type. 1398 */ 1399 static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata, 1400 enum nl80211_iftype type) 1401 { 1402 static const u8 bssid_wildcard[ETH_ALEN] = {0xff, 0xff, 0xff, 1403 0xff, 0xff, 0xff}; 1404 1405 /* clear type-dependent union */ 1406 memset(&sdata->u, 0, sizeof(sdata->u)); 1407 1408 /* and set some type-dependent values */ 1409 sdata->vif.type = type; 1410 sdata->vif.p2p = false; 1411 sdata->wdev.iftype = type; 1412 1413 sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE); 1414 sdata->control_port_no_encrypt = false; 1415 sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM; 1416 sdata->vif.bss_conf.idle = true; 1417 1418 sdata->noack_map = 0; 1419 1420 /* only monitor/p2p-device differ */ 1421 if (sdata->dev) { 1422 sdata->dev->netdev_ops = &ieee80211_dataif_ops; 1423 sdata->dev->type = ARPHRD_ETHER; 1424 } 1425 1426 skb_queue_head_init(&sdata->skb_queue); 1427 INIT_WORK(&sdata->work, ieee80211_iface_work); 1428 INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work); 1429 INIT_WORK(&sdata->csa_finalize_work, ieee80211_csa_finalize_work); 1430 INIT_LIST_HEAD(&sdata->assigned_chanctx_list); 1431 INIT_LIST_HEAD(&sdata->reserved_chanctx_list); 1432 1433 switch (type) { 1434 case NL80211_IFTYPE_P2P_GO: 1435 type = NL80211_IFTYPE_AP; 1436 sdata->vif.type = type; 1437 sdata->vif.p2p = true; 1438 /* fall through */ 1439 case NL80211_IFTYPE_AP: 1440 skb_queue_head_init(&sdata->u.ap.ps.bc_buf); 1441 INIT_LIST_HEAD(&sdata->u.ap.vlans); 1442 INIT_WORK(&sdata->u.ap.request_smps_work, 1443 ieee80211_request_smps_ap_work); 1444 sdata->vif.bss_conf.bssid = sdata->vif.addr; 1445 sdata->u.ap.req_smps = IEEE80211_SMPS_OFF; 1446 break; 1447 case NL80211_IFTYPE_P2P_CLIENT: 1448 type = NL80211_IFTYPE_STATION; 1449 sdata->vif.type = type; 1450 sdata->vif.p2p = true; 1451 /* fall through */ 1452 case NL80211_IFTYPE_STATION: 1453 sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid; 1454 ieee80211_sta_setup_sdata(sdata); 1455 break; 1456 case NL80211_IFTYPE_OCB: 1457 sdata->vif.bss_conf.bssid = bssid_wildcard; 1458 ieee80211_ocb_setup_sdata(sdata); 1459 break; 1460 case NL80211_IFTYPE_ADHOC: 1461 sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid; 1462 ieee80211_ibss_setup_sdata(sdata); 1463 break; 1464 case NL80211_IFTYPE_MESH_POINT: 1465 if (ieee80211_vif_is_mesh(&sdata->vif)) 1466 ieee80211_mesh_init_sdata(sdata); 1467 break; 1468 case NL80211_IFTYPE_MONITOR: 1469 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP; 1470 sdata->dev->netdev_ops = &ieee80211_monitorif_ops; 1471 sdata->u.mntr.flags = MONITOR_FLAG_CONTROL | 1472 MONITOR_FLAG_OTHER_BSS; 1473 break; 1474 case NL80211_IFTYPE_WDS: 1475 sdata->vif.bss_conf.bssid = NULL; 1476 break; 1477 case NL80211_IFTYPE_NAN: 1478 idr_init(&sdata->u.nan.function_inst_ids); 1479 spin_lock_init(&sdata->u.nan.func_lock); 1480 sdata->vif.bss_conf.bssid = sdata->vif.addr; 1481 break; 1482 case NL80211_IFTYPE_AP_VLAN: 1483 case NL80211_IFTYPE_P2P_DEVICE: 1484 sdata->vif.bss_conf.bssid = sdata->vif.addr; 1485 break; 1486 case NL80211_IFTYPE_UNSPECIFIED: 1487 case NUM_NL80211_IFTYPES: 1488 BUG(); 1489 break; 1490 } 1491 1492 ieee80211_debugfs_add_netdev(sdata); 1493 } 1494 1495 static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata, 1496 enum nl80211_iftype type) 1497 { 1498 struct ieee80211_local *local = sdata->local; 1499 int ret, err; 1500 enum nl80211_iftype internal_type = type; 1501 bool p2p = false; 1502 1503 ASSERT_RTNL(); 1504 1505 if (!local->ops->change_interface) 1506 return -EBUSY; 1507 1508 switch (sdata->vif.type) { 1509 case NL80211_IFTYPE_AP: 1510 case NL80211_IFTYPE_STATION: 1511 case NL80211_IFTYPE_ADHOC: 1512 case NL80211_IFTYPE_OCB: 1513 /* 1514 * Could maybe also all others here? 1515 * Just not sure how that interacts 1516 * with the RX/config path e.g. for 1517 * mesh. 1518 */ 1519 break; 1520 default: 1521 return -EBUSY; 1522 } 1523 1524 switch (type) { 1525 case NL80211_IFTYPE_AP: 1526 case NL80211_IFTYPE_STATION: 1527 case NL80211_IFTYPE_ADHOC: 1528 case NL80211_IFTYPE_OCB: 1529 /* 1530 * Could probably support everything 1531 * but WDS here (WDS do_open can fail 1532 * under memory pressure, which this 1533 * code isn't prepared to handle). 1534 */ 1535 break; 1536 case NL80211_IFTYPE_P2P_CLIENT: 1537 p2p = true; 1538 internal_type = NL80211_IFTYPE_STATION; 1539 break; 1540 case NL80211_IFTYPE_P2P_GO: 1541 p2p = true; 1542 internal_type = NL80211_IFTYPE_AP; 1543 break; 1544 default: 1545 return -EBUSY; 1546 } 1547 1548 ret = ieee80211_check_concurrent_iface(sdata, internal_type); 1549 if (ret) 1550 return ret; 1551 1552 ieee80211_do_stop(sdata, false); 1553 1554 ieee80211_teardown_sdata(sdata); 1555 1556 ret = drv_change_interface(local, sdata, internal_type, p2p); 1557 if (ret) 1558 type = ieee80211_vif_type_p2p(&sdata->vif); 1559 1560 /* 1561 * Ignore return value here, there's not much we can do since 1562 * the driver changed the interface type internally already. 1563 * The warnings will hopefully make driver authors fix it :-) 1564 */ 1565 ieee80211_check_queues(sdata, type); 1566 1567 ieee80211_setup_sdata(sdata, type); 1568 1569 err = ieee80211_do_open(&sdata->wdev, false); 1570 WARN(err, "type change: do_open returned %d", err); 1571 1572 return ret; 1573 } 1574 1575 int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata, 1576 enum nl80211_iftype type) 1577 { 1578 int ret; 1579 1580 ASSERT_RTNL(); 1581 1582 if (type == ieee80211_vif_type_p2p(&sdata->vif)) 1583 return 0; 1584 1585 if (ieee80211_sdata_running(sdata)) { 1586 ret = ieee80211_runtime_change_iftype(sdata, type); 1587 if (ret) 1588 return ret; 1589 } else { 1590 /* Purge and reset type-dependent state. */ 1591 ieee80211_teardown_sdata(sdata); 1592 ieee80211_setup_sdata(sdata, type); 1593 } 1594 1595 /* reset some values that shouldn't be kept across type changes */ 1596 if (type == NL80211_IFTYPE_STATION) 1597 sdata->u.mgd.use_4addr = false; 1598 1599 return 0; 1600 } 1601 1602 static void ieee80211_assign_perm_addr(struct ieee80211_local *local, 1603 u8 *perm_addr, enum nl80211_iftype type) 1604 { 1605 struct ieee80211_sub_if_data *sdata; 1606 u64 mask, start, addr, val, inc; 1607 u8 *m; 1608 u8 tmp_addr[ETH_ALEN]; 1609 int i; 1610 1611 /* default ... something at least */ 1612 memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN); 1613 1614 if (is_zero_ether_addr(local->hw.wiphy->addr_mask) && 1615 local->hw.wiphy->n_addresses <= 1) 1616 return; 1617 1618 mutex_lock(&local->iflist_mtx); 1619 1620 switch (type) { 1621 case NL80211_IFTYPE_MONITOR: 1622 /* doesn't matter */ 1623 break; 1624 case NL80211_IFTYPE_WDS: 1625 case NL80211_IFTYPE_AP_VLAN: 1626 /* match up with an AP interface */ 1627 list_for_each_entry(sdata, &local->interfaces, list) { 1628 if (sdata->vif.type != NL80211_IFTYPE_AP) 1629 continue; 1630 memcpy(perm_addr, sdata->vif.addr, ETH_ALEN); 1631 break; 1632 } 1633 /* keep default if no AP interface present */ 1634 break; 1635 case NL80211_IFTYPE_P2P_CLIENT: 1636 case NL80211_IFTYPE_P2P_GO: 1637 if (ieee80211_hw_check(&local->hw, P2P_DEV_ADDR_FOR_INTF)) { 1638 list_for_each_entry(sdata, &local->interfaces, list) { 1639 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) 1640 continue; 1641 if (!ieee80211_sdata_running(sdata)) 1642 continue; 1643 memcpy(perm_addr, sdata->vif.addr, ETH_ALEN); 1644 goto out_unlock; 1645 } 1646 } 1647 /* otherwise fall through */ 1648 default: 1649 /* assign a new address if possible -- try n_addresses first */ 1650 for (i = 0; i < local->hw.wiphy->n_addresses; i++) { 1651 bool used = false; 1652 1653 list_for_each_entry(sdata, &local->interfaces, list) { 1654 if (ether_addr_equal(local->hw.wiphy->addresses[i].addr, 1655 sdata->vif.addr)) { 1656 used = true; 1657 break; 1658 } 1659 } 1660 1661 if (!used) { 1662 memcpy(perm_addr, 1663 local->hw.wiphy->addresses[i].addr, 1664 ETH_ALEN); 1665 break; 1666 } 1667 } 1668 1669 /* try mask if available */ 1670 if (is_zero_ether_addr(local->hw.wiphy->addr_mask)) 1671 break; 1672 1673 m = local->hw.wiphy->addr_mask; 1674 mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) | 1675 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) | 1676 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8); 1677 1678 if (__ffs64(mask) + hweight64(mask) != fls64(mask)) { 1679 /* not a contiguous mask ... not handled now! */ 1680 pr_info("not contiguous\n"); 1681 break; 1682 } 1683 1684 /* 1685 * Pick address of existing interface in case user changed 1686 * MAC address manually, default to perm_addr. 1687 */ 1688 m = local->hw.wiphy->perm_addr; 1689 list_for_each_entry(sdata, &local->interfaces, list) { 1690 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) 1691 continue; 1692 m = sdata->vif.addr; 1693 break; 1694 } 1695 start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) | 1696 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) | 1697 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8); 1698 1699 inc = 1ULL<<__ffs64(mask); 1700 val = (start & mask); 1701 addr = (start & ~mask) | (val & mask); 1702 do { 1703 bool used = false; 1704 1705 tmp_addr[5] = addr >> 0*8; 1706 tmp_addr[4] = addr >> 1*8; 1707 tmp_addr[3] = addr >> 2*8; 1708 tmp_addr[2] = addr >> 3*8; 1709 tmp_addr[1] = addr >> 4*8; 1710 tmp_addr[0] = addr >> 5*8; 1711 1712 val += inc; 1713 1714 list_for_each_entry(sdata, &local->interfaces, list) { 1715 if (ether_addr_equal(tmp_addr, sdata->vif.addr)) { 1716 used = true; 1717 break; 1718 } 1719 } 1720 1721 if (!used) { 1722 memcpy(perm_addr, tmp_addr, ETH_ALEN); 1723 break; 1724 } 1725 addr = (start & ~mask) | (val & mask); 1726 } while (addr != start); 1727 1728 break; 1729 } 1730 1731 out_unlock: 1732 mutex_unlock(&local->iflist_mtx); 1733 } 1734 1735 int ieee80211_if_add(struct ieee80211_local *local, const char *name, 1736 unsigned char name_assign_type, 1737 struct wireless_dev **new_wdev, enum nl80211_iftype type, 1738 struct vif_params *params) 1739 { 1740 struct net_device *ndev = NULL; 1741 struct ieee80211_sub_if_data *sdata = NULL; 1742 struct txq_info *txqi; 1743 void (*if_setup)(struct net_device *dev); 1744 int ret, i; 1745 int txqs = 1; 1746 1747 ASSERT_RTNL(); 1748 1749 if (type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN) { 1750 struct wireless_dev *wdev; 1751 1752 sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, 1753 GFP_KERNEL); 1754 if (!sdata) 1755 return -ENOMEM; 1756 wdev = &sdata->wdev; 1757 1758 sdata->dev = NULL; 1759 strlcpy(sdata->name, name, IFNAMSIZ); 1760 ieee80211_assign_perm_addr(local, wdev->address, type); 1761 memcpy(sdata->vif.addr, wdev->address, ETH_ALEN); 1762 } else { 1763 int size = ALIGN(sizeof(*sdata) + local->hw.vif_data_size, 1764 sizeof(void *)); 1765 int txq_size = 0; 1766 1767 if (local->ops->wake_tx_queue) 1768 txq_size += sizeof(struct txq_info) + 1769 local->hw.txq_data_size; 1770 1771 if (local->ops->wake_tx_queue) 1772 if_setup = ieee80211_if_setup_no_queue; 1773 else 1774 if_setup = ieee80211_if_setup; 1775 1776 if (local->hw.queues >= IEEE80211_NUM_ACS) 1777 txqs = IEEE80211_NUM_ACS; 1778 1779 ndev = alloc_netdev_mqs(size + txq_size, 1780 name, name_assign_type, 1781 if_setup, txqs, 1); 1782 if (!ndev) 1783 return -ENOMEM; 1784 dev_net_set(ndev, wiphy_net(local->hw.wiphy)); 1785 1786 ndev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 1787 if (!ndev->tstats) { 1788 free_netdev(ndev); 1789 return -ENOMEM; 1790 } 1791 1792 ndev->needed_headroom = local->tx_headroom + 1793 4*6 /* four MAC addresses */ 1794 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */ 1795 + 6 /* mesh */ 1796 + 8 /* rfc1042/bridge tunnel */ 1797 - ETH_HLEN /* ethernet hard_header_len */ 1798 + IEEE80211_ENCRYPT_HEADROOM; 1799 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM; 1800 1801 ret = dev_alloc_name(ndev, ndev->name); 1802 if (ret < 0) { 1803 ieee80211_if_free(ndev); 1804 return ret; 1805 } 1806 1807 ieee80211_assign_perm_addr(local, ndev->perm_addr, type); 1808 if (params && is_valid_ether_addr(params->macaddr)) 1809 memcpy(ndev->dev_addr, params->macaddr, ETH_ALEN); 1810 else 1811 memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN); 1812 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy)); 1813 1814 /* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */ 1815 sdata = netdev_priv(ndev); 1816 ndev->ieee80211_ptr = &sdata->wdev; 1817 memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN); 1818 memcpy(sdata->name, ndev->name, IFNAMSIZ); 1819 1820 if (txq_size) { 1821 txqi = netdev_priv(ndev) + size; 1822 ieee80211_txq_init(sdata, NULL, txqi, 0); 1823 } 1824 1825 sdata->dev = ndev; 1826 } 1827 1828 /* initialise type-independent data */ 1829 sdata->wdev.wiphy = local->hw.wiphy; 1830 sdata->local = local; 1831 1832 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 1833 skb_queue_head_init(&sdata->fragments[i].skb_list); 1834 1835 INIT_LIST_HEAD(&sdata->key_list); 1836 1837 INIT_DELAYED_WORK(&sdata->dfs_cac_timer_work, 1838 ieee80211_dfs_cac_timer_work); 1839 INIT_DELAYED_WORK(&sdata->dec_tailroom_needed_wk, 1840 ieee80211_delayed_tailroom_dec); 1841 1842 for (i = 0; i < NUM_NL80211_BANDS; i++) { 1843 struct ieee80211_supported_band *sband; 1844 sband = local->hw.wiphy->bands[i]; 1845 sdata->rc_rateidx_mask[i] = 1846 sband ? (1 << sband->n_bitrates) - 1 : 0; 1847 if (sband) { 1848 __le16 cap; 1849 u16 *vht_rate_mask; 1850 1851 memcpy(sdata->rc_rateidx_mcs_mask[i], 1852 sband->ht_cap.mcs.rx_mask, 1853 sizeof(sdata->rc_rateidx_mcs_mask[i])); 1854 1855 cap = sband->vht_cap.vht_mcs.rx_mcs_map; 1856 vht_rate_mask = sdata->rc_rateidx_vht_mcs_mask[i]; 1857 ieee80211_get_vht_mask_from_cap(cap, vht_rate_mask); 1858 } else { 1859 memset(sdata->rc_rateidx_mcs_mask[i], 0, 1860 sizeof(sdata->rc_rateidx_mcs_mask[i])); 1861 memset(sdata->rc_rateidx_vht_mcs_mask[i], 0, 1862 sizeof(sdata->rc_rateidx_vht_mcs_mask[i])); 1863 } 1864 } 1865 1866 ieee80211_set_default_queues(sdata); 1867 1868 sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL; 1869 sdata->user_power_level = local->user_power_level; 1870 1871 sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM; 1872 1873 /* setup type-dependent data */ 1874 ieee80211_setup_sdata(sdata, type); 1875 1876 if (ndev) { 1877 if (params) { 1878 ndev->ieee80211_ptr->use_4addr = params->use_4addr; 1879 if (type == NL80211_IFTYPE_STATION) 1880 sdata->u.mgd.use_4addr = params->use_4addr; 1881 } 1882 1883 ndev->features |= local->hw.netdev_features; 1884 1885 netdev_set_default_ethtool_ops(ndev, &ieee80211_ethtool_ops); 1886 1887 ret = register_netdevice(ndev); 1888 if (ret) { 1889 ieee80211_if_free(ndev); 1890 return ret; 1891 } 1892 } 1893 1894 mutex_lock(&local->iflist_mtx); 1895 list_add_tail_rcu(&sdata->list, &local->interfaces); 1896 mutex_unlock(&local->iflist_mtx); 1897 1898 if (new_wdev) 1899 *new_wdev = &sdata->wdev; 1900 1901 return 0; 1902 } 1903 1904 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata) 1905 { 1906 ASSERT_RTNL(); 1907 1908 mutex_lock(&sdata->local->iflist_mtx); 1909 list_del_rcu(&sdata->list); 1910 mutex_unlock(&sdata->local->iflist_mtx); 1911 1912 synchronize_rcu(); 1913 1914 if (sdata->dev) { 1915 unregister_netdevice(sdata->dev); 1916 } else { 1917 cfg80211_unregister_wdev(&sdata->wdev); 1918 ieee80211_teardown_sdata(sdata); 1919 kfree(sdata); 1920 } 1921 } 1922 1923 void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata) 1924 { 1925 if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state))) 1926 return; 1927 ieee80211_do_stop(sdata, true); 1928 } 1929 1930 void ieee80211_remove_interfaces(struct ieee80211_local *local) 1931 { 1932 struct ieee80211_sub_if_data *sdata, *tmp; 1933 LIST_HEAD(unreg_list); 1934 LIST_HEAD(wdev_list); 1935 1936 ASSERT_RTNL(); 1937 1938 /* Before destroying the interfaces, make sure they're all stopped so 1939 * that the hardware is stopped. Otherwise, the driver might still be 1940 * iterating the interfaces during the shutdown, e.g. from a worker 1941 * or from RX processing or similar, and if it does so (using atomic 1942 * iteration) while we're manipulating the list, the iteration will 1943 * crash. 1944 * 1945 * After this, the hardware should be stopped and the driver should 1946 * have stopped all of its activities, so that we can do RCU-unaware 1947 * manipulations of the interface list below. 1948 */ 1949 cfg80211_shutdown_all_interfaces(local->hw.wiphy); 1950 1951 WARN(local->open_count, "%s: open count remains %d\n", 1952 wiphy_name(local->hw.wiphy), local->open_count); 1953 1954 mutex_lock(&local->iflist_mtx); 1955 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) { 1956 list_del(&sdata->list); 1957 1958 if (sdata->dev) 1959 unregister_netdevice_queue(sdata->dev, &unreg_list); 1960 else 1961 list_add(&sdata->list, &wdev_list); 1962 } 1963 mutex_unlock(&local->iflist_mtx); 1964 unregister_netdevice_many(&unreg_list); 1965 1966 list_for_each_entry_safe(sdata, tmp, &wdev_list, list) { 1967 list_del(&sdata->list); 1968 cfg80211_unregister_wdev(&sdata->wdev); 1969 kfree(sdata); 1970 } 1971 } 1972 1973 static int netdev_notify(struct notifier_block *nb, 1974 unsigned long state, void *ptr) 1975 { 1976 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1977 struct ieee80211_sub_if_data *sdata; 1978 1979 if (state != NETDEV_CHANGENAME) 1980 return NOTIFY_DONE; 1981 1982 if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy) 1983 return NOTIFY_DONE; 1984 1985 if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid) 1986 return NOTIFY_DONE; 1987 1988 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1989 memcpy(sdata->name, dev->name, IFNAMSIZ); 1990 ieee80211_debugfs_rename_netdev(sdata); 1991 1992 return NOTIFY_OK; 1993 } 1994 1995 static struct notifier_block mac80211_netdev_notifier = { 1996 .notifier_call = netdev_notify, 1997 }; 1998 1999 int ieee80211_iface_init(void) 2000 { 2001 return register_netdevice_notifier(&mac80211_netdev_notifier); 2002 } 2003 2004 void ieee80211_iface_exit(void) 2005 { 2006 unregister_netdevice_notifier(&mac80211_netdev_notifier); 2007 } 2008