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