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/kernel.h> 14 #include <linux/if_arp.h> 15 #include <linux/netdevice.h> 16 #include <linux/rtnetlink.h> 17 #include <net/mac80211.h> 18 #include "ieee80211_i.h" 19 #include "sta_info.h" 20 #include "debugfs_netdev.h" 21 #include "mesh.h" 22 #include "led.h" 23 24 /** 25 * DOC: Interface list locking 26 * 27 * The interface list in each struct ieee80211_local is protected 28 * three-fold: 29 * 30 * (1) modifications may only be done under the RTNL 31 * (2) modifications and readers are protected against each other by 32 * the iflist_mtx. 33 * (3) modifications are done in an RCU manner so atomic readers 34 * can traverse the list in RCU-safe blocks. 35 * 36 * As a consequence, reads (traversals) of the list can be protected 37 * by either the RTNL, the iflist_mtx or RCU. 38 */ 39 40 41 static int ieee80211_change_mtu(struct net_device *dev, int new_mtu) 42 { 43 int meshhdrlen; 44 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 45 46 meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0; 47 48 /* FIX: what would be proper limits for MTU? 49 * This interface uses 802.3 frames. */ 50 if (new_mtu < 256 || 51 new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) { 52 return -EINVAL; 53 } 54 55 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 56 printk(KERN_DEBUG "%s: setting MTU %d\n", dev->name, new_mtu); 57 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 58 dev->mtu = new_mtu; 59 return 0; 60 } 61 62 static inline int identical_mac_addr_allowed(int type1, int type2) 63 { 64 return type1 == NL80211_IFTYPE_MONITOR || 65 type2 == NL80211_IFTYPE_MONITOR || 66 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) || 67 (type1 == NL80211_IFTYPE_WDS && 68 (type2 == NL80211_IFTYPE_WDS || 69 type2 == NL80211_IFTYPE_AP)) || 70 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) || 71 (type1 == NL80211_IFTYPE_AP_VLAN && 72 (type2 == NL80211_IFTYPE_AP || 73 type2 == NL80211_IFTYPE_AP_VLAN)); 74 } 75 76 static int ieee80211_open(struct net_device *dev) 77 { 78 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 79 struct ieee80211_sub_if_data *nsdata; 80 struct ieee80211_local *local = sdata->local; 81 struct sta_info *sta; 82 struct ieee80211_if_init_conf conf; 83 u32 changed = 0; 84 int res; 85 u32 hw_reconf_flags = 0; 86 u8 null_addr[ETH_ALEN] = {0}; 87 88 /* fail early if user set an invalid address */ 89 if (compare_ether_addr(dev->dev_addr, null_addr) && 90 !is_valid_ether_addr(dev->dev_addr)) 91 return -EADDRNOTAVAIL; 92 93 /* we hold the RTNL here so can safely walk the list */ 94 list_for_each_entry(nsdata, &local->interfaces, list) { 95 struct net_device *ndev = nsdata->dev; 96 97 if (ndev != dev && netif_running(ndev)) { 98 /* 99 * Allow only a single IBSS interface to be up at any 100 * time. This is restricted because beacon distribution 101 * cannot work properly if both are in the same IBSS. 102 * 103 * To remove this restriction we'd have to disallow them 104 * from setting the same SSID on different IBSS interfaces 105 * belonging to the same hardware. Then, however, we're 106 * faced with having to adopt two different TSF timers... 107 */ 108 if (sdata->vif.type == NL80211_IFTYPE_ADHOC && 109 nsdata->vif.type == NL80211_IFTYPE_ADHOC) 110 return -EBUSY; 111 112 /* 113 * The remaining checks are only performed for interfaces 114 * with the same MAC address. 115 */ 116 if (compare_ether_addr(dev->dev_addr, ndev->dev_addr)) 117 continue; 118 119 /* 120 * check whether it may have the same address 121 */ 122 if (!identical_mac_addr_allowed(sdata->vif.type, 123 nsdata->vif.type)) 124 return -ENOTUNIQ; 125 126 /* 127 * can only add VLANs to enabled APs 128 */ 129 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN && 130 nsdata->vif.type == NL80211_IFTYPE_AP) 131 sdata->bss = &nsdata->u.ap; 132 } 133 } 134 135 switch (sdata->vif.type) { 136 case NL80211_IFTYPE_WDS: 137 if (!is_valid_ether_addr(sdata->u.wds.remote_addr)) 138 return -ENOLINK; 139 break; 140 case NL80211_IFTYPE_AP_VLAN: 141 if (!sdata->bss) 142 return -ENOLINK; 143 list_add(&sdata->u.vlan.list, &sdata->bss->vlans); 144 break; 145 case NL80211_IFTYPE_AP: 146 sdata->bss = &sdata->u.ap; 147 break; 148 case NL80211_IFTYPE_MESH_POINT: 149 if (!ieee80211_vif_is_mesh(&sdata->vif)) 150 break; 151 /* mesh ifaces must set allmulti to forward mcast traffic */ 152 atomic_inc(&local->iff_allmultis); 153 break; 154 case NL80211_IFTYPE_STATION: 155 case NL80211_IFTYPE_MONITOR: 156 case NL80211_IFTYPE_ADHOC: 157 /* no special treatment */ 158 break; 159 case NL80211_IFTYPE_UNSPECIFIED: 160 case __NL80211_IFTYPE_AFTER_LAST: 161 /* cannot happen */ 162 WARN_ON(1); 163 break; 164 } 165 166 if (local->open_count == 0) { 167 res = 0; 168 if (local->ops->start) 169 res = local->ops->start(local_to_hw(local)); 170 if (res) 171 goto err_del_bss; 172 /* we're brought up, everything changes */ 173 hw_reconf_flags = ~0; 174 ieee80211_led_radio(local, local->hw.conf.radio_enabled); 175 } 176 177 /* 178 * Check all interfaces and copy the hopefully now-present 179 * MAC address to those that have the special null one. 180 */ 181 list_for_each_entry(nsdata, &local->interfaces, list) { 182 struct net_device *ndev = nsdata->dev; 183 184 /* 185 * No need to check netif_running since we do not allow 186 * it to start up with this invalid address. 187 */ 188 if (compare_ether_addr(null_addr, ndev->dev_addr) == 0) 189 memcpy(ndev->dev_addr, 190 local->hw.wiphy->perm_addr, 191 ETH_ALEN); 192 } 193 194 if (compare_ether_addr(null_addr, local->mdev->dev_addr) == 0) 195 memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, 196 ETH_ALEN); 197 198 /* 199 * Validate the MAC address for this device. 200 */ 201 if (!is_valid_ether_addr(dev->dev_addr)) { 202 if (!local->open_count && local->ops->stop) 203 local->ops->stop(local_to_hw(local)); 204 return -EADDRNOTAVAIL; 205 } 206 207 switch (sdata->vif.type) { 208 case NL80211_IFTYPE_AP_VLAN: 209 /* no need to tell driver */ 210 break; 211 case NL80211_IFTYPE_MONITOR: 212 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) { 213 local->cooked_mntrs++; 214 break; 215 } 216 217 /* must be before the call to ieee80211_configure_filter */ 218 local->monitors++; 219 if (local->monitors == 1) { 220 local->hw.conf.flags |= IEEE80211_CONF_RADIOTAP; 221 hw_reconf_flags |= IEEE80211_CONF_CHANGE_RADIOTAP; 222 } 223 224 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL) 225 local->fif_fcsfail++; 226 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL) 227 local->fif_plcpfail++; 228 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) 229 local->fif_control++; 230 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS) 231 local->fif_other_bss++; 232 233 netif_addr_lock_bh(local->mdev); 234 ieee80211_configure_filter(local); 235 netif_addr_unlock_bh(local->mdev); 236 break; 237 case NL80211_IFTYPE_STATION: 238 case NL80211_IFTYPE_ADHOC: 239 if (sdata->vif.type == NL80211_IFTYPE_STATION) 240 sdata->u.mgd.flags &= ~IEEE80211_STA_PREV_BSSID_SET; 241 else 242 sdata->u.ibss.flags &= ~IEEE80211_IBSS_PREV_BSSID_SET; 243 /* fall through */ 244 default: 245 conf.vif = &sdata->vif; 246 conf.type = sdata->vif.type; 247 conf.mac_addr = dev->dev_addr; 248 res = local->ops->add_interface(local_to_hw(local), &conf); 249 if (res) 250 goto err_stop; 251 252 if (ieee80211_vif_is_mesh(&sdata->vif)) { 253 local->fif_other_bss++; 254 netif_addr_lock_bh(local->mdev); 255 ieee80211_configure_filter(local); 256 netif_addr_unlock_bh(local->mdev); 257 258 ieee80211_start_mesh(sdata); 259 } 260 changed |= ieee80211_reset_erp_info(sdata); 261 ieee80211_bss_info_change_notify(sdata, changed); 262 ieee80211_enable_keys(sdata); 263 264 if (sdata->vif.type == NL80211_IFTYPE_STATION) 265 netif_carrier_off(dev); 266 else 267 netif_carrier_on(dev); 268 } 269 270 if (sdata->vif.type == NL80211_IFTYPE_WDS) { 271 /* Create STA entry for the WDS peer */ 272 sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr, 273 GFP_KERNEL); 274 if (!sta) { 275 res = -ENOMEM; 276 goto err_del_interface; 277 } 278 279 /* no locking required since STA is not live yet */ 280 sta->flags |= WLAN_STA_AUTHORIZED; 281 282 res = sta_info_insert(sta); 283 if (res) { 284 /* STA has been freed */ 285 goto err_del_interface; 286 } 287 } 288 289 if (local->open_count == 0) { 290 res = dev_open(local->mdev); 291 WARN_ON(res); 292 if (res) 293 goto err_del_interface; 294 tasklet_enable(&local->tx_pending_tasklet); 295 tasklet_enable(&local->tasklet); 296 } 297 298 /* 299 * set_multicast_list will be invoked by the networking core 300 * which will check whether any increments here were done in 301 * error and sync them down to the hardware as filter flags. 302 */ 303 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 304 atomic_inc(&local->iff_allmultis); 305 306 if (sdata->flags & IEEE80211_SDATA_PROMISC) 307 atomic_inc(&local->iff_promiscs); 308 309 local->open_count++; 310 if (hw_reconf_flags) { 311 ieee80211_hw_config(local, hw_reconf_flags); 312 /* 313 * set default queue parameters so drivers don't 314 * need to initialise the hardware if the hardware 315 * doesn't start up with sane defaults 316 */ 317 ieee80211_set_wmm_default(sdata); 318 } 319 320 /* 321 * ieee80211_sta_work is disabled while network interface 322 * is down. Therefore, some configuration changes may not 323 * yet be effective. Trigger execution of ieee80211_sta_work 324 * to fix this. 325 */ 326 if (sdata->vif.type == NL80211_IFTYPE_STATION) 327 queue_work(local->hw.workqueue, &sdata->u.mgd.work); 328 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) 329 queue_work(local->hw.workqueue, &sdata->u.ibss.work); 330 331 netif_tx_start_all_queues(dev); 332 333 return 0; 334 err_del_interface: 335 local->ops->remove_interface(local_to_hw(local), &conf); 336 err_stop: 337 if (!local->open_count && local->ops->stop) 338 local->ops->stop(local_to_hw(local)); 339 err_del_bss: 340 sdata->bss = NULL; 341 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 342 list_del(&sdata->u.vlan.list); 343 return res; 344 } 345 346 static int ieee80211_stop(struct net_device *dev) 347 { 348 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 349 struct ieee80211_local *local = sdata->local; 350 struct ieee80211_if_init_conf conf; 351 struct sta_info *sta; 352 u32 hw_reconf_flags = 0; 353 354 /* 355 * Stop TX on this interface first. 356 */ 357 netif_tx_stop_all_queues(dev); 358 359 /* 360 * Now delete all active aggregation sessions. 361 */ 362 rcu_read_lock(); 363 364 list_for_each_entry_rcu(sta, &local->sta_list, list) { 365 if (sta->sdata == sdata) 366 ieee80211_sta_tear_down_BA_sessions(sta); 367 } 368 369 rcu_read_unlock(); 370 371 /* 372 * Announce that we are leaving the network, in case we are a 373 * station interface type. This must be done before removing 374 * all stations associated with sta_info_flush, otherwise STA 375 * information will be gone and no announce being done. 376 */ 377 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 378 if (sdata->u.mgd.state != IEEE80211_STA_MLME_DISABLED) 379 ieee80211_sta_deauthenticate(sdata, 380 WLAN_REASON_DEAUTH_LEAVING); 381 } 382 383 /* 384 * Remove all stations associated with this interface. 385 * 386 * This must be done before calling ops->remove_interface() 387 * because otherwise we can later invoke ops->sta_notify() 388 * whenever the STAs are removed, and that invalidates driver 389 * assumptions about always getting a vif pointer that is valid 390 * (because if we remove a STA after ops->remove_interface() 391 * the driver will have removed the vif info already!) 392 * 393 * We could relax this and only unlink the stations from the 394 * hash table and list but keep them on a per-sdata list that 395 * will be inserted back again when the interface is brought 396 * up again, but I don't currently see a use case for that, 397 * except with WDS which gets a STA entry created when it is 398 * brought up. 399 */ 400 sta_info_flush(local, sdata); 401 402 /* 403 * Don't count this interface for promisc/allmulti while it 404 * is down. dev_mc_unsync() will invoke set_multicast_list 405 * on the master interface which will sync these down to the 406 * hardware as filter flags. 407 */ 408 if (sdata->flags & IEEE80211_SDATA_ALLMULTI) 409 atomic_dec(&local->iff_allmultis); 410 411 if (sdata->flags & IEEE80211_SDATA_PROMISC) 412 atomic_dec(&local->iff_promiscs); 413 414 dev_mc_unsync(local->mdev, dev); 415 del_timer_sync(&local->dynamic_ps_timer); 416 cancel_work_sync(&local->dynamic_ps_enable_work); 417 418 /* APs need special treatment */ 419 if (sdata->vif.type == NL80211_IFTYPE_AP) { 420 struct ieee80211_sub_if_data *vlan, *tmp; 421 struct beacon_data *old_beacon = sdata->u.ap.beacon; 422 423 /* remove beacon */ 424 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 425 synchronize_rcu(); 426 kfree(old_beacon); 427 428 /* down all dependent devices, that is VLANs */ 429 list_for_each_entry_safe(vlan, tmp, &sdata->u.ap.vlans, 430 u.vlan.list) 431 dev_close(vlan->dev); 432 WARN_ON(!list_empty(&sdata->u.ap.vlans)); 433 } 434 435 local->open_count--; 436 437 switch (sdata->vif.type) { 438 case NL80211_IFTYPE_AP_VLAN: 439 list_del(&sdata->u.vlan.list); 440 /* no need to tell driver */ 441 break; 442 case NL80211_IFTYPE_MONITOR: 443 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) { 444 local->cooked_mntrs--; 445 break; 446 } 447 448 local->monitors--; 449 if (local->monitors == 0) { 450 local->hw.conf.flags &= ~IEEE80211_CONF_RADIOTAP; 451 hw_reconf_flags |= IEEE80211_CONF_CHANGE_RADIOTAP; 452 } 453 454 if (sdata->u.mntr_flags & MONITOR_FLAG_FCSFAIL) 455 local->fif_fcsfail--; 456 if (sdata->u.mntr_flags & MONITOR_FLAG_PLCPFAIL) 457 local->fif_plcpfail--; 458 if (sdata->u.mntr_flags & MONITOR_FLAG_CONTROL) 459 local->fif_control--; 460 if (sdata->u.mntr_flags & MONITOR_FLAG_OTHER_BSS) 461 local->fif_other_bss--; 462 463 netif_addr_lock_bh(local->mdev); 464 ieee80211_configure_filter(local); 465 netif_addr_unlock_bh(local->mdev); 466 break; 467 case NL80211_IFTYPE_STATION: 468 memset(sdata->u.mgd.bssid, 0, ETH_ALEN); 469 del_timer_sync(&sdata->u.mgd.chswitch_timer); 470 del_timer_sync(&sdata->u.mgd.timer); 471 /* 472 * If the timer fired while we waited for it, it will have 473 * requeued the work. Now the work will be running again 474 * but will not rearm the timer again because it checks 475 * whether the interface is running, which, at this point, 476 * it no longer is. 477 */ 478 cancel_work_sync(&sdata->u.mgd.work); 479 cancel_work_sync(&sdata->u.mgd.chswitch_work); 480 481 cancel_work_sync(&sdata->u.mgd.beacon_loss_work); 482 483 /* 484 * When we get here, the interface is marked down. 485 * Call synchronize_rcu() to wait for the RX path 486 * should it be using the interface and enqueuing 487 * frames at this very time on another CPU. 488 */ 489 synchronize_rcu(); 490 skb_queue_purge(&sdata->u.mgd.skb_queue); 491 492 sdata->u.mgd.flags &= ~(IEEE80211_STA_PRIVACY_INVOKED | 493 IEEE80211_STA_TKIP_WEP_USED); 494 kfree(sdata->u.mgd.extra_ie); 495 sdata->u.mgd.extra_ie = NULL; 496 sdata->u.mgd.extra_ie_len = 0; 497 /* fall through */ 498 case NL80211_IFTYPE_ADHOC: 499 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { 500 memset(sdata->u.ibss.bssid, 0, ETH_ALEN); 501 del_timer_sync(&sdata->u.ibss.timer); 502 cancel_work_sync(&sdata->u.ibss.work); 503 synchronize_rcu(); 504 skb_queue_purge(&sdata->u.ibss.skb_queue); 505 } 506 /* fall through */ 507 case NL80211_IFTYPE_MESH_POINT: 508 if (ieee80211_vif_is_mesh(&sdata->vif)) { 509 /* other_bss and allmulti are always set on mesh 510 * ifaces */ 511 local->fif_other_bss--; 512 atomic_dec(&local->iff_allmultis); 513 514 netif_addr_lock_bh(local->mdev); 515 ieee80211_configure_filter(local); 516 netif_addr_unlock_bh(local->mdev); 517 518 ieee80211_stop_mesh(sdata); 519 } 520 /* fall through */ 521 default: 522 if (local->scan_sdata == sdata) { 523 if (!local->ops->hw_scan) 524 cancel_delayed_work_sync(&local->scan_work); 525 /* 526 * The software scan can no longer run now, so we can 527 * clear out the scan_sdata reference. However, the 528 * hardware scan may still be running. The complete 529 * function must be prepared to handle a NULL value. 530 */ 531 local->scan_sdata = NULL; 532 /* 533 * The memory barrier guarantees that another CPU 534 * that is hardware-scanning will now see the fact 535 * that this interface is gone. 536 */ 537 smp_mb(); 538 /* 539 * If software scanning, complete the scan but since 540 * the scan_sdata is NULL already don't send out a 541 * scan event to userspace -- the scan is incomplete. 542 */ 543 if (local->sw_scanning) 544 ieee80211_scan_completed(&local->hw, true); 545 } 546 547 conf.vif = &sdata->vif; 548 conf.type = sdata->vif.type; 549 conf.mac_addr = dev->dev_addr; 550 /* disable all keys for as long as this netdev is down */ 551 ieee80211_disable_keys(sdata); 552 local->ops->remove_interface(local_to_hw(local), &conf); 553 } 554 555 sdata->bss = NULL; 556 557 if (local->open_count == 0) { 558 if (netif_running(local->mdev)) 559 dev_close(local->mdev); 560 561 if (local->ops->stop) 562 local->ops->stop(local_to_hw(local)); 563 564 ieee80211_led_radio(local, 0); 565 566 flush_workqueue(local->hw.workqueue); 567 568 tasklet_disable(&local->tx_pending_tasklet); 569 tasklet_disable(&local->tasklet); 570 571 /* no reconfiguring after stop! */ 572 hw_reconf_flags = 0; 573 } 574 575 /* do after stop to avoid reconfiguring when we stop anyway */ 576 if (hw_reconf_flags) 577 ieee80211_hw_config(local, hw_reconf_flags); 578 579 return 0; 580 } 581 582 static void ieee80211_set_multicast_list(struct net_device *dev) 583 { 584 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 585 struct ieee80211_local *local = sdata->local; 586 int allmulti, promisc, sdata_allmulti, sdata_promisc; 587 588 allmulti = !!(dev->flags & IFF_ALLMULTI); 589 promisc = !!(dev->flags & IFF_PROMISC); 590 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI); 591 sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC); 592 593 if (allmulti != sdata_allmulti) { 594 if (dev->flags & IFF_ALLMULTI) 595 atomic_inc(&local->iff_allmultis); 596 else 597 atomic_dec(&local->iff_allmultis); 598 sdata->flags ^= IEEE80211_SDATA_ALLMULTI; 599 } 600 601 if (promisc != sdata_promisc) { 602 if (dev->flags & IFF_PROMISC) 603 atomic_inc(&local->iff_promiscs); 604 else 605 atomic_dec(&local->iff_promiscs); 606 sdata->flags ^= IEEE80211_SDATA_PROMISC; 607 } 608 609 dev_mc_sync(local->mdev, dev); 610 } 611 612 /* 613 * Called when the netdev is removed or, by the code below, before 614 * the interface type changes. 615 */ 616 static void ieee80211_teardown_sdata(struct net_device *dev) 617 { 618 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 619 struct ieee80211_local *local = sdata->local; 620 struct beacon_data *beacon; 621 struct sk_buff *skb; 622 int flushed; 623 int i; 624 625 /* free extra data */ 626 ieee80211_free_keys(sdata); 627 628 ieee80211_debugfs_remove_netdev(sdata); 629 630 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 631 __skb_queue_purge(&sdata->fragments[i].skb_list); 632 sdata->fragment_next = 0; 633 634 switch (sdata->vif.type) { 635 case NL80211_IFTYPE_AP: 636 beacon = sdata->u.ap.beacon; 637 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 638 synchronize_rcu(); 639 kfree(beacon); 640 641 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) { 642 local->total_ps_buffered--; 643 dev_kfree_skb(skb); 644 } 645 646 break; 647 case NL80211_IFTYPE_MESH_POINT: 648 if (ieee80211_vif_is_mesh(&sdata->vif)) 649 mesh_rmc_free(sdata); 650 break; 651 case NL80211_IFTYPE_ADHOC: 652 kfree_skb(sdata->u.ibss.probe_resp); 653 break; 654 case NL80211_IFTYPE_STATION: 655 kfree(sdata->u.mgd.extra_ie); 656 kfree(sdata->u.mgd.assocreq_ies); 657 kfree(sdata->u.mgd.assocresp_ies); 658 kfree(sdata->u.mgd.sme_auth_ie); 659 break; 660 case NL80211_IFTYPE_WDS: 661 case NL80211_IFTYPE_AP_VLAN: 662 case NL80211_IFTYPE_MONITOR: 663 break; 664 case NL80211_IFTYPE_UNSPECIFIED: 665 case __NL80211_IFTYPE_AFTER_LAST: 666 BUG(); 667 break; 668 } 669 670 flushed = sta_info_flush(local, sdata); 671 WARN_ON(flushed); 672 } 673 674 static const struct net_device_ops ieee80211_dataif_ops = { 675 .ndo_open = ieee80211_open, 676 .ndo_stop = ieee80211_stop, 677 .ndo_uninit = ieee80211_teardown_sdata, 678 .ndo_start_xmit = ieee80211_subif_start_xmit, 679 .ndo_set_multicast_list = ieee80211_set_multicast_list, 680 .ndo_change_mtu = ieee80211_change_mtu, 681 .ndo_set_mac_address = eth_mac_addr, 682 }; 683 684 static const struct net_device_ops ieee80211_monitorif_ops = { 685 .ndo_open = ieee80211_open, 686 .ndo_stop = ieee80211_stop, 687 .ndo_uninit = ieee80211_teardown_sdata, 688 .ndo_start_xmit = ieee80211_monitor_start_xmit, 689 .ndo_set_multicast_list = ieee80211_set_multicast_list, 690 .ndo_change_mtu = ieee80211_change_mtu, 691 .ndo_set_mac_address = eth_mac_addr, 692 }; 693 694 static void ieee80211_if_setup(struct net_device *dev) 695 { 696 ether_setup(dev); 697 dev->netdev_ops = &ieee80211_dataif_ops; 698 dev->wireless_handlers = &ieee80211_iw_handler_def; 699 dev->destructor = free_netdev; 700 } 701 702 /* 703 * Helper function to initialise an interface to a specific type. 704 */ 705 static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata, 706 enum nl80211_iftype type) 707 { 708 /* clear type-dependent union */ 709 memset(&sdata->u, 0, sizeof(sdata->u)); 710 711 /* and set some type-dependent values */ 712 sdata->vif.type = type; 713 sdata->dev->netdev_ops = &ieee80211_dataif_ops; 714 sdata->wdev.iftype = type; 715 716 /* only monitor differs */ 717 sdata->dev->type = ARPHRD_ETHER; 718 719 switch (type) { 720 case NL80211_IFTYPE_AP: 721 skb_queue_head_init(&sdata->u.ap.ps_bc_buf); 722 INIT_LIST_HEAD(&sdata->u.ap.vlans); 723 break; 724 case NL80211_IFTYPE_STATION: 725 ieee80211_sta_setup_sdata(sdata); 726 break; 727 case NL80211_IFTYPE_ADHOC: 728 ieee80211_ibss_setup_sdata(sdata); 729 break; 730 case NL80211_IFTYPE_MESH_POINT: 731 if (ieee80211_vif_is_mesh(&sdata->vif)) 732 ieee80211_mesh_init_sdata(sdata); 733 break; 734 case NL80211_IFTYPE_MONITOR: 735 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP; 736 sdata->dev->netdev_ops = &ieee80211_monitorif_ops; 737 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL | 738 MONITOR_FLAG_OTHER_BSS; 739 break; 740 case NL80211_IFTYPE_WDS: 741 case NL80211_IFTYPE_AP_VLAN: 742 break; 743 case NL80211_IFTYPE_UNSPECIFIED: 744 case __NL80211_IFTYPE_AFTER_LAST: 745 BUG(); 746 break; 747 } 748 749 ieee80211_debugfs_add_netdev(sdata); 750 } 751 752 int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata, 753 enum nl80211_iftype type) 754 { 755 ASSERT_RTNL(); 756 757 if (type == sdata->vif.type) 758 return 0; 759 760 /* Setting ad-hoc mode on non-IBSS channel is not supported. */ 761 if (sdata->local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS && 762 type == NL80211_IFTYPE_ADHOC) 763 return -EOPNOTSUPP; 764 765 /* 766 * We could, here, on changes between IBSS/STA/MESH modes, 767 * invoke an MLME function instead that disassociates etc. 768 * and goes into the requested mode. 769 */ 770 771 if (netif_running(sdata->dev)) 772 return -EBUSY; 773 774 /* Purge and reset type-dependent state. */ 775 ieee80211_teardown_sdata(sdata->dev); 776 ieee80211_setup_sdata(sdata, type); 777 778 /* reset some values that shouldn't be kept across type changes */ 779 sdata->vif.bss_conf.basic_rates = 780 ieee80211_mandatory_rates(sdata->local, 781 sdata->local->hw.conf.channel->band); 782 sdata->drop_unencrypted = 0; 783 784 return 0; 785 } 786 787 int ieee80211_if_add(struct ieee80211_local *local, const char *name, 788 struct net_device **new_dev, enum nl80211_iftype type, 789 struct vif_params *params) 790 { 791 struct net_device *ndev; 792 struct ieee80211_sub_if_data *sdata = NULL; 793 int ret, i; 794 795 ASSERT_RTNL(); 796 797 ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size, 798 name, ieee80211_if_setup); 799 if (!ndev) 800 return -ENOMEM; 801 802 ndev->needed_headroom = local->tx_headroom + 803 4*6 /* four MAC addresses */ 804 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */ 805 + 6 /* mesh */ 806 + 8 /* rfc1042/bridge tunnel */ 807 - ETH_HLEN /* ethernet hard_header_len */ 808 + IEEE80211_ENCRYPT_HEADROOM; 809 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM; 810 811 ret = dev_alloc_name(ndev, ndev->name); 812 if (ret < 0) 813 goto fail; 814 815 memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN); 816 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy)); 817 ndev->features |= NETIF_F_NETNS_LOCAL; 818 819 /* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */ 820 sdata = netdev_priv(ndev); 821 ndev->ieee80211_ptr = &sdata->wdev; 822 823 /* initialise type-independent data */ 824 sdata->wdev.wiphy = local->hw.wiphy; 825 sdata->local = local; 826 sdata->dev = ndev; 827 828 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 829 skb_queue_head_init(&sdata->fragments[i].skb_list); 830 831 INIT_LIST_HEAD(&sdata->key_list); 832 833 sdata->force_unicast_rateidx = -1; 834 sdata->max_ratectrl_rateidx = -1; 835 836 /* setup type-dependent data */ 837 ieee80211_setup_sdata(sdata, type); 838 839 ret = register_netdevice(ndev); 840 if (ret) 841 goto fail; 842 843 if (ieee80211_vif_is_mesh(&sdata->vif) && 844 params && params->mesh_id_len) 845 ieee80211_sdata_set_mesh_id(sdata, 846 params->mesh_id_len, 847 params->mesh_id); 848 849 mutex_lock(&local->iflist_mtx); 850 list_add_tail_rcu(&sdata->list, &local->interfaces); 851 mutex_unlock(&local->iflist_mtx); 852 853 if (new_dev) 854 *new_dev = ndev; 855 856 return 0; 857 858 fail: 859 free_netdev(ndev); 860 return ret; 861 } 862 863 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata) 864 { 865 ASSERT_RTNL(); 866 867 mutex_lock(&sdata->local->iflist_mtx); 868 list_del_rcu(&sdata->list); 869 mutex_unlock(&sdata->local->iflist_mtx); 870 871 synchronize_rcu(); 872 unregister_netdevice(sdata->dev); 873 } 874 875 /* 876 * Remove all interfaces, may only be called at hardware unregistration 877 * time because it doesn't do RCU-safe list removals. 878 */ 879 void ieee80211_remove_interfaces(struct ieee80211_local *local) 880 { 881 struct ieee80211_sub_if_data *sdata, *tmp; 882 883 ASSERT_RTNL(); 884 885 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) { 886 /* 887 * we cannot hold the iflist_mtx across unregister_netdevice, 888 * but we only need to hold it for list modifications to lock 889 * out readers since we're under the RTNL here as all other 890 * writers. 891 */ 892 mutex_lock(&local->iflist_mtx); 893 list_del(&sdata->list); 894 mutex_unlock(&local->iflist_mtx); 895 896 unregister_netdevice(sdata->dev); 897 } 898 } 899