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