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