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