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