sta_info.c revision 7852e36186d2a1983c215836d7e3d7b8927c930d
1/* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 */ 9 10#include <linux/module.h> 11#include <linux/init.h> 12#include <linux/netdevice.h> 13#include <linux/types.h> 14#include <linux/slab.h> 15#include <linux/skbuff.h> 16#include <linux/if_arp.h> 17#include <linux/timer.h> 18#include <linux/rtnetlink.h> 19 20#include <net/mac80211.h> 21#include "ieee80211_i.h" 22#include "driver-ops.h" 23#include "rate.h" 24#include "sta_info.h" 25#include "debugfs_sta.h" 26#include "mesh.h" 27#include "wme.h" 28 29/** 30 * DOC: STA information lifetime rules 31 * 32 * STA info structures (&struct sta_info) are managed in a hash table 33 * for faster lookup and a list for iteration. They are managed using 34 * RCU, i.e. access to the list and hash table is protected by RCU. 35 * 36 * Upon allocating a STA info structure with sta_info_alloc(), the caller 37 * owns that structure. It must then insert it into the hash table using 38 * either sta_info_insert() or sta_info_insert_rcu(); only in the latter 39 * case (which acquires an rcu read section but must not be called from 40 * within one) will the pointer still be valid after the call. Note that 41 * the caller may not do much with the STA info before inserting it, in 42 * particular, it may not start any mesh peer link management or add 43 * encryption keys. 44 * 45 * When the insertion fails (sta_info_insert()) returns non-zero), the 46 * structure will have been freed by sta_info_insert()! 47 * 48 * Station entries are added by mac80211 when you establish a link with a 49 * peer. This means different things for the different type of interfaces 50 * we support. For a regular station this mean we add the AP sta when we 51 * receive an association response from the AP. For IBSS this occurs when 52 * get to know about a peer on the same IBSS. For WDS we add the sta for 53 * the peer immediately upon device open. When using AP mode we add stations 54 * for each respective station upon request from userspace through nl80211. 55 * 56 * In order to remove a STA info structure, various sta_info_destroy_*() 57 * calls are available. 58 * 59 * There is no concept of ownership on a STA entry, each structure is 60 * owned by the global hash table/list until it is removed. All users of 61 * the structure need to be RCU protected so that the structure won't be 62 * freed before they are done using it. 63 */ 64 65/* Caller must hold local->sta_mtx */ 66static int sta_info_hash_del(struct ieee80211_local *local, 67 struct sta_info *sta) 68{ 69 struct sta_info *s; 70 71 s = rcu_dereference_protected(local->sta_hash[STA_HASH(sta->sta.addr)], 72 lockdep_is_held(&local->sta_mtx)); 73 if (!s) 74 return -ENOENT; 75 if (s == sta) { 76 rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)], 77 s->hnext); 78 return 0; 79 } 80 81 while (rcu_access_pointer(s->hnext) && 82 rcu_access_pointer(s->hnext) != sta) 83 s = rcu_dereference_protected(s->hnext, 84 lockdep_is_held(&local->sta_mtx)); 85 if (rcu_access_pointer(s->hnext)) { 86 rcu_assign_pointer(s->hnext, sta->hnext); 87 return 0; 88 } 89 90 return -ENOENT; 91} 92 93/* protected by RCU */ 94struct sta_info *sta_info_get(struct ieee80211_sub_if_data *sdata, 95 const u8 *addr) 96{ 97 struct ieee80211_local *local = sdata->local; 98 struct sta_info *sta; 99 100 sta = rcu_dereference_check(local->sta_hash[STA_HASH(addr)], 101 lockdep_is_held(&local->sta_mtx)); 102 while (sta) { 103 if (sta->sdata == sdata && 104 memcmp(sta->sta.addr, addr, ETH_ALEN) == 0) 105 break; 106 sta = rcu_dereference_check(sta->hnext, 107 lockdep_is_held(&local->sta_mtx)); 108 } 109 return sta; 110} 111 112/* 113 * Get sta info either from the specified interface 114 * or from one of its vlans 115 */ 116struct sta_info *sta_info_get_bss(struct ieee80211_sub_if_data *sdata, 117 const u8 *addr) 118{ 119 struct ieee80211_local *local = sdata->local; 120 struct sta_info *sta; 121 122 sta = rcu_dereference_check(local->sta_hash[STA_HASH(addr)], 123 lockdep_is_held(&local->sta_mtx)); 124 while (sta) { 125 if ((sta->sdata == sdata || 126 (sta->sdata->bss && sta->sdata->bss == sdata->bss)) && 127 memcmp(sta->sta.addr, addr, ETH_ALEN) == 0) 128 break; 129 sta = rcu_dereference_check(sta->hnext, 130 lockdep_is_held(&local->sta_mtx)); 131 } 132 return sta; 133} 134 135struct sta_info *sta_info_get_by_idx(struct ieee80211_sub_if_data *sdata, 136 int idx) 137{ 138 struct ieee80211_local *local = sdata->local; 139 struct sta_info *sta; 140 int i = 0; 141 142 list_for_each_entry_rcu(sta, &local->sta_list, list) { 143 if (sdata != sta->sdata) 144 continue; 145 if (i < idx) { 146 ++i; 147 continue; 148 } 149 return sta; 150 } 151 152 return NULL; 153} 154 155/** 156 * sta_info_free - free STA 157 * 158 * @local: pointer to the global information 159 * @sta: STA info to free 160 * 161 * This function must undo everything done by sta_info_alloc() 162 * that may happen before sta_info_insert(). It may only be 163 * called when sta_info_insert() has not been attempted (and 164 * if that fails, the station is freed anyway.) 165 */ 166void sta_info_free(struct ieee80211_local *local, struct sta_info *sta) 167{ 168 if (sta->rate_ctrl) 169 rate_control_free_sta(sta); 170 171#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 172 wiphy_debug(local->hw.wiphy, "Destroyed STA %pM\n", sta->sta.addr); 173#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 174 175 kfree(sta); 176} 177 178/* Caller must hold local->sta_mtx */ 179static void sta_info_hash_add(struct ieee80211_local *local, 180 struct sta_info *sta) 181{ 182 lockdep_assert_held(&local->sta_mtx); 183 sta->hnext = local->sta_hash[STA_HASH(sta->sta.addr)]; 184 rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)], sta); 185} 186 187static void sta_unblock(struct work_struct *wk) 188{ 189 struct sta_info *sta; 190 191 sta = container_of(wk, struct sta_info, drv_unblock_wk); 192 193 if (sta->dead) 194 return; 195 196 if (!test_sta_flag(sta, WLAN_STA_PS_STA)) { 197 local_bh_disable(); 198 ieee80211_sta_ps_deliver_wakeup(sta); 199 local_bh_enable(); 200 } else if (test_and_clear_sta_flag(sta, WLAN_STA_PSPOLL)) { 201 clear_sta_flag(sta, WLAN_STA_PS_DRIVER); 202 203 local_bh_disable(); 204 ieee80211_sta_ps_deliver_poll_response(sta); 205 local_bh_enable(); 206 } else if (test_and_clear_sta_flag(sta, WLAN_STA_UAPSD)) { 207 clear_sta_flag(sta, WLAN_STA_PS_DRIVER); 208 209 local_bh_disable(); 210 ieee80211_sta_ps_deliver_uapsd(sta); 211 local_bh_enable(); 212 } else 213 clear_sta_flag(sta, WLAN_STA_PS_DRIVER); 214} 215 216static int sta_prepare_rate_control(struct ieee80211_local *local, 217 struct sta_info *sta, gfp_t gfp) 218{ 219 if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) 220 return 0; 221 222 sta->rate_ctrl = local->rate_ctrl; 223 sta->rate_ctrl_priv = rate_control_alloc_sta(sta->rate_ctrl, 224 &sta->sta, gfp); 225 if (!sta->rate_ctrl_priv) 226 return -ENOMEM; 227 228 return 0; 229} 230 231struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata, 232 const u8 *addr, gfp_t gfp) 233{ 234 struct ieee80211_local *local = sdata->local; 235 struct sta_info *sta; 236 struct timespec uptime; 237 int i; 238 239 sta = kzalloc(sizeof(*sta) + local->hw.sta_data_size, gfp); 240 if (!sta) 241 return NULL; 242 243 spin_lock_init(&sta->lock); 244 INIT_WORK(&sta->drv_unblock_wk, sta_unblock); 245 INIT_WORK(&sta->ampdu_mlme.work, ieee80211_ba_session_work); 246 mutex_init(&sta->ampdu_mlme.mtx); 247 248 memcpy(sta->sta.addr, addr, ETH_ALEN); 249 sta->local = local; 250 sta->sdata = sdata; 251 sta->last_rx = jiffies; 252 253 sta->sta_state = IEEE80211_STA_NONE; 254 255 do_posix_clock_monotonic_gettime(&uptime); 256 sta->last_connected = uptime.tv_sec; 257 ewma_init(&sta->avg_signal, 1024, 8); 258 259 if (sta_prepare_rate_control(local, sta, gfp)) { 260 kfree(sta); 261 return NULL; 262 } 263 264 for (i = 0; i < STA_TID_NUM; i++) { 265 /* 266 * timer_to_tid must be initialized with identity mapping 267 * to enable session_timer's data differentiation. See 268 * sta_rx_agg_session_timer_expired for usage. 269 */ 270 sta->timer_to_tid[i] = i; 271 } 272 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 273 skb_queue_head_init(&sta->ps_tx_buf[i]); 274 skb_queue_head_init(&sta->tx_filtered[i]); 275 } 276 277 for (i = 0; i < NUM_RX_DATA_QUEUES; i++) 278 sta->last_seq_ctrl[i] = cpu_to_le16(USHRT_MAX); 279 280#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 281 wiphy_debug(local->hw.wiphy, "Allocated STA %pM\n", sta->sta.addr); 282#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 283 284#ifdef CONFIG_MAC80211_MESH 285 sta->plink_state = NL80211_PLINK_LISTEN; 286 init_timer(&sta->plink_timer); 287#endif 288 289 return sta; 290} 291 292static int sta_info_insert_check(struct sta_info *sta) 293{ 294 struct ieee80211_sub_if_data *sdata = sta->sdata; 295 296 /* 297 * Can't be a WARN_ON because it can be triggered through a race: 298 * something inserts a STA (on one CPU) without holding the RTNL 299 * and another CPU turns off the net device. 300 */ 301 if (unlikely(!ieee80211_sdata_running(sdata))) 302 return -ENETDOWN; 303 304 if (WARN_ON(compare_ether_addr(sta->sta.addr, sdata->vif.addr) == 0 || 305 is_multicast_ether_addr(sta->sta.addr))) 306 return -EINVAL; 307 308 return 0; 309} 310 311static int sta_info_insert_drv_state(struct ieee80211_local *local, 312 struct ieee80211_sub_if_data *sdata, 313 struct sta_info *sta) 314{ 315 enum ieee80211_sta_state state; 316 int err = 0; 317 318 for (state = IEEE80211_STA_NOTEXIST; state < sta->sta_state; state++) { 319 err = drv_sta_state(local, sdata, sta, state, state + 1); 320 if (err) 321 break; 322 } 323 324 if (!err) { 325 /* 326 * Drivers using legacy sta_add/sta_remove callbacks only 327 * get uploaded set to true after sta_add is called. 328 */ 329 if (!local->ops->sta_add) 330 sta->uploaded = true; 331 return 0; 332 } 333 334 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { 335 printk(KERN_DEBUG 336 "%s: failed to move IBSS STA %pM to state %d (%d) - keeping it anyway.\n", 337 sdata->name, sta->sta.addr, state + 1, err); 338 err = 0; 339 } 340 341 /* unwind on error */ 342 for (; state > IEEE80211_STA_NOTEXIST; state--) 343 WARN_ON(drv_sta_state(local, sdata, sta, state, state - 1)); 344 345 return err; 346} 347 348/* 349 * should be called with sta_mtx locked 350 * this function replaces the mutex lock 351 * with a RCU lock 352 */ 353static int sta_info_insert_finish(struct sta_info *sta) __acquires(RCU) 354{ 355 struct ieee80211_local *local = sta->local; 356 struct ieee80211_sub_if_data *sdata = sta->sdata; 357 struct station_info sinfo; 358 int err = 0; 359 360 lockdep_assert_held(&local->sta_mtx); 361 362 /* check if STA exists already */ 363 if (sta_info_get_bss(sdata, sta->sta.addr)) { 364 err = -EEXIST; 365 goto out_err; 366 } 367 368 /* notify driver */ 369 err = sta_info_insert_drv_state(local, sdata, sta); 370 if (err) 371 goto out_err; 372 373 local->num_sta++; 374 local->sta_generation++; 375 smp_mb(); 376 377 /* make the station visible */ 378 sta_info_hash_add(local, sta); 379 380 list_add(&sta->list, &local->sta_list); 381 382 set_sta_flag(sta, WLAN_STA_INSERTED); 383 384 ieee80211_sta_debugfs_add(sta); 385 rate_control_add_sta_debugfs(sta); 386 387 memset(&sinfo, 0, sizeof(sinfo)); 388 sinfo.filled = 0; 389 sinfo.generation = local->sta_generation; 390 cfg80211_new_sta(sdata->dev, sta->sta.addr, &sinfo, GFP_KERNEL); 391 392#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 393 wiphy_debug(local->hw.wiphy, "Inserted STA %pM\n", sta->sta.addr); 394#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 395 396 /* move reference to rcu-protected */ 397 rcu_read_lock(); 398 mutex_unlock(&local->sta_mtx); 399 400 if (ieee80211_vif_is_mesh(&sdata->vif)) 401 mesh_accept_plinks_update(sdata); 402 403 return 0; 404 out_err: 405 mutex_unlock(&local->sta_mtx); 406 rcu_read_lock(); 407 return err; 408} 409 410int sta_info_insert_rcu(struct sta_info *sta) __acquires(RCU) 411{ 412 struct ieee80211_local *local = sta->local; 413 int err = 0; 414 415 might_sleep(); 416 417 err = sta_info_insert_check(sta); 418 if (err) { 419 rcu_read_lock(); 420 goto out_free; 421 } 422 423 mutex_lock(&local->sta_mtx); 424 425 err = sta_info_insert_finish(sta); 426 if (err) 427 goto out_free; 428 429 return 0; 430 out_free: 431 BUG_ON(!err); 432 sta_info_free(local, sta); 433 return err; 434} 435 436int sta_info_insert(struct sta_info *sta) 437{ 438 int err = sta_info_insert_rcu(sta); 439 440 rcu_read_unlock(); 441 442 return err; 443} 444 445static inline void __bss_tim_set(struct ieee80211_if_ap *bss, u16 aid) 446{ 447 /* 448 * This format has been mandated by the IEEE specifications, 449 * so this line may not be changed to use the __set_bit() format. 450 */ 451 bss->tim[aid / 8] |= (1 << (aid % 8)); 452} 453 454static inline void __bss_tim_clear(struct ieee80211_if_ap *bss, u16 aid) 455{ 456 /* 457 * This format has been mandated by the IEEE specifications, 458 * so this line may not be changed to use the __clear_bit() format. 459 */ 460 bss->tim[aid / 8] &= ~(1 << (aid % 8)); 461} 462 463static unsigned long ieee80211_tids_for_ac(int ac) 464{ 465 /* If we ever support TIDs > 7, this obviously needs to be adjusted */ 466 switch (ac) { 467 case IEEE80211_AC_VO: 468 return BIT(6) | BIT(7); 469 case IEEE80211_AC_VI: 470 return BIT(4) | BIT(5); 471 case IEEE80211_AC_BE: 472 return BIT(0) | BIT(3); 473 case IEEE80211_AC_BK: 474 return BIT(1) | BIT(2); 475 default: 476 WARN_ON(1); 477 return 0; 478 } 479} 480 481void sta_info_recalc_tim(struct sta_info *sta) 482{ 483 struct ieee80211_local *local = sta->local; 484 struct ieee80211_if_ap *bss = sta->sdata->bss; 485 unsigned long flags; 486 bool indicate_tim = false; 487 u8 ignore_for_tim = sta->sta.uapsd_queues; 488 int ac; 489 490 if (WARN_ON_ONCE(!sta->sdata->bss)) 491 return; 492 493 /* No need to do anything if the driver does all */ 494 if (local->hw.flags & IEEE80211_HW_AP_LINK_PS) 495 return; 496 497 if (sta->dead) 498 goto done; 499 500 /* 501 * If all ACs are delivery-enabled then we should build 502 * the TIM bit for all ACs anyway; if only some are then 503 * we ignore those and build the TIM bit using only the 504 * non-enabled ones. 505 */ 506 if (ignore_for_tim == BIT(IEEE80211_NUM_ACS) - 1) 507 ignore_for_tim = 0; 508 509 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 510 unsigned long tids; 511 512 if (ignore_for_tim & BIT(ac)) 513 continue; 514 515 indicate_tim |= !skb_queue_empty(&sta->tx_filtered[ac]) || 516 !skb_queue_empty(&sta->ps_tx_buf[ac]); 517 if (indicate_tim) 518 break; 519 520 tids = ieee80211_tids_for_ac(ac); 521 522 indicate_tim |= 523 sta->driver_buffered_tids & tids; 524 } 525 526 done: 527 spin_lock_irqsave(&local->tim_lock, flags); 528 529 if (indicate_tim) 530 __bss_tim_set(bss, sta->sta.aid); 531 else 532 __bss_tim_clear(bss, sta->sta.aid); 533 534 if (local->ops->set_tim) { 535 local->tim_in_locked_section = true; 536 drv_set_tim(local, &sta->sta, indicate_tim); 537 local->tim_in_locked_section = false; 538 } 539 540 spin_unlock_irqrestore(&local->tim_lock, flags); 541} 542 543static bool sta_info_buffer_expired(struct sta_info *sta, struct sk_buff *skb) 544{ 545 struct ieee80211_tx_info *info; 546 int timeout; 547 548 if (!skb) 549 return false; 550 551 info = IEEE80211_SKB_CB(skb); 552 553 /* Timeout: (2 * listen_interval * beacon_int * 1024 / 1000000) sec */ 554 timeout = (sta->listen_interval * 555 sta->sdata->vif.bss_conf.beacon_int * 556 32 / 15625) * HZ; 557 if (timeout < STA_TX_BUFFER_EXPIRE) 558 timeout = STA_TX_BUFFER_EXPIRE; 559 return time_after(jiffies, info->control.jiffies + timeout); 560} 561 562 563static bool sta_info_cleanup_expire_buffered_ac(struct ieee80211_local *local, 564 struct sta_info *sta, int ac) 565{ 566 unsigned long flags; 567 struct sk_buff *skb; 568 569 /* 570 * First check for frames that should expire on the filtered 571 * queue. Frames here were rejected by the driver and are on 572 * a separate queue to avoid reordering with normal PS-buffered 573 * frames. They also aren't accounted for right now in the 574 * total_ps_buffered counter. 575 */ 576 for (;;) { 577 spin_lock_irqsave(&sta->tx_filtered[ac].lock, flags); 578 skb = skb_peek(&sta->tx_filtered[ac]); 579 if (sta_info_buffer_expired(sta, skb)) 580 skb = __skb_dequeue(&sta->tx_filtered[ac]); 581 else 582 skb = NULL; 583 spin_unlock_irqrestore(&sta->tx_filtered[ac].lock, flags); 584 585 /* 586 * Frames are queued in order, so if this one 587 * hasn't expired yet we can stop testing. If 588 * we actually reached the end of the queue we 589 * also need to stop, of course. 590 */ 591 if (!skb) 592 break; 593 dev_kfree_skb(skb); 594 } 595 596 /* 597 * Now also check the normal PS-buffered queue, this will 598 * only find something if the filtered queue was emptied 599 * since the filtered frames are all before the normal PS 600 * buffered frames. 601 */ 602 for (;;) { 603 spin_lock_irqsave(&sta->ps_tx_buf[ac].lock, flags); 604 skb = skb_peek(&sta->ps_tx_buf[ac]); 605 if (sta_info_buffer_expired(sta, skb)) 606 skb = __skb_dequeue(&sta->ps_tx_buf[ac]); 607 else 608 skb = NULL; 609 spin_unlock_irqrestore(&sta->ps_tx_buf[ac].lock, flags); 610 611 /* 612 * frames are queued in order, so if this one 613 * hasn't expired yet (or we reached the end of 614 * the queue) we can stop testing 615 */ 616 if (!skb) 617 break; 618 619 local->total_ps_buffered--; 620#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG 621 printk(KERN_DEBUG "Buffered frame expired (STA %pM)\n", 622 sta->sta.addr); 623#endif 624 dev_kfree_skb(skb); 625 } 626 627 /* 628 * Finally, recalculate the TIM bit for this station -- it might 629 * now be clear because the station was too slow to retrieve its 630 * frames. 631 */ 632 sta_info_recalc_tim(sta); 633 634 /* 635 * Return whether there are any frames still buffered, this is 636 * used to check whether the cleanup timer still needs to run, 637 * if there are no frames we don't need to rearm the timer. 638 */ 639 return !(skb_queue_empty(&sta->ps_tx_buf[ac]) && 640 skb_queue_empty(&sta->tx_filtered[ac])); 641} 642 643static bool sta_info_cleanup_expire_buffered(struct ieee80211_local *local, 644 struct sta_info *sta) 645{ 646 bool have_buffered = false; 647 int ac; 648 649 /* This is only necessary for stations on BSS interfaces */ 650 if (!sta->sdata->bss) 651 return false; 652 653 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) 654 have_buffered |= 655 sta_info_cleanup_expire_buffered_ac(local, sta, ac); 656 657 return have_buffered; 658} 659 660int __must_check __sta_info_destroy(struct sta_info *sta) 661{ 662 struct ieee80211_local *local; 663 struct ieee80211_sub_if_data *sdata; 664 int ret, i, ac; 665 struct tid_ampdu_tx *tid_tx; 666 667 might_sleep(); 668 669 if (!sta) 670 return -ENOENT; 671 672 local = sta->local; 673 sdata = sta->sdata; 674 675 lockdep_assert_held(&local->sta_mtx); 676 677 /* 678 * Before removing the station from the driver and 679 * rate control, it might still start new aggregation 680 * sessions -- block that to make sure the tear-down 681 * will be sufficient. 682 */ 683 set_sta_flag(sta, WLAN_STA_BLOCK_BA); 684 ieee80211_sta_tear_down_BA_sessions(sta, true); 685 686 ret = sta_info_hash_del(local, sta); 687 if (ret) 688 return ret; 689 690 list_del(&sta->list); 691 692 mutex_lock(&local->key_mtx); 693 for (i = 0; i < NUM_DEFAULT_KEYS; i++) 694 __ieee80211_key_free(key_mtx_dereference(local, sta->gtk[i])); 695 if (sta->ptk) 696 __ieee80211_key_free(key_mtx_dereference(local, sta->ptk)); 697 mutex_unlock(&local->key_mtx); 698 699 sta->dead = true; 700 701 local->num_sta--; 702 local->sta_generation++; 703 704 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 705 RCU_INIT_POINTER(sdata->u.vlan.sta, NULL); 706 707 while (sta->sta_state > IEEE80211_STA_NONE) { 708 ret = sta_info_move_state(sta, sta->sta_state - 1); 709 if (ret) { 710 WARN_ON_ONCE(1); 711 break; 712 } 713 } 714 715 if (sta->uploaded) { 716 ret = drv_sta_state(local, sdata, sta, IEEE80211_STA_NONE, 717 IEEE80211_STA_NOTEXIST); 718 WARN_ON_ONCE(ret != 0); 719 } 720 721 /* 722 * At this point, after we wait for an RCU grace period, 723 * neither mac80211 nor the driver can reference this 724 * sta struct any more except by still existing timers 725 * associated with this station that we clean up below. 726 */ 727 synchronize_rcu(); 728 729 if (test_sta_flag(sta, WLAN_STA_PS_STA)) { 730 BUG_ON(!sdata->bss); 731 732 clear_sta_flag(sta, WLAN_STA_PS_STA); 733 734 atomic_dec(&sdata->bss->num_sta_ps); 735 sta_info_recalc_tim(sta); 736 } 737 738 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 739 local->total_ps_buffered -= skb_queue_len(&sta->ps_tx_buf[ac]); 740 __skb_queue_purge(&sta->ps_tx_buf[ac]); 741 __skb_queue_purge(&sta->tx_filtered[ac]); 742 } 743 744#ifdef CONFIG_MAC80211_MESH 745 if (ieee80211_vif_is_mesh(&sdata->vif)) 746 mesh_accept_plinks_update(sdata); 747#endif 748 749#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 750 wiphy_debug(local->hw.wiphy, "Removed STA %pM\n", sta->sta.addr); 751#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 752 cancel_work_sync(&sta->drv_unblock_wk); 753 754 cfg80211_del_sta(sdata->dev, sta->sta.addr, GFP_KERNEL); 755 756 rate_control_remove_sta_debugfs(sta); 757 ieee80211_sta_debugfs_remove(sta); 758 759#ifdef CONFIG_MAC80211_MESH 760 if (ieee80211_vif_is_mesh(&sta->sdata->vif)) { 761 mesh_plink_deactivate(sta); 762 del_timer_sync(&sta->plink_timer); 763 } 764#endif 765 766 /* 767 * Destroy aggregation state here. It would be nice to wait for the 768 * driver to finish aggregation stop and then clean up, but for now 769 * drivers have to handle aggregation stop being requested, followed 770 * directly by station destruction. 771 */ 772 for (i = 0; i < STA_TID_NUM; i++) { 773 tid_tx = rcu_dereference_raw(sta->ampdu_mlme.tid_tx[i]); 774 if (!tid_tx) 775 continue; 776 __skb_queue_purge(&tid_tx->pending); 777 kfree(tid_tx); 778 } 779 780 sta_info_free(local, sta); 781 782 return 0; 783} 784 785int sta_info_destroy_addr(struct ieee80211_sub_if_data *sdata, const u8 *addr) 786{ 787 struct sta_info *sta; 788 int ret; 789 790 mutex_lock(&sdata->local->sta_mtx); 791 sta = sta_info_get(sdata, addr); 792 ret = __sta_info_destroy(sta); 793 mutex_unlock(&sdata->local->sta_mtx); 794 795 return ret; 796} 797 798int sta_info_destroy_addr_bss(struct ieee80211_sub_if_data *sdata, 799 const u8 *addr) 800{ 801 struct sta_info *sta; 802 int ret; 803 804 mutex_lock(&sdata->local->sta_mtx); 805 sta = sta_info_get_bss(sdata, addr); 806 ret = __sta_info_destroy(sta); 807 mutex_unlock(&sdata->local->sta_mtx); 808 809 return ret; 810} 811 812static void sta_info_cleanup(unsigned long data) 813{ 814 struct ieee80211_local *local = (struct ieee80211_local *) data; 815 struct sta_info *sta; 816 bool timer_needed = false; 817 818 rcu_read_lock(); 819 list_for_each_entry_rcu(sta, &local->sta_list, list) 820 if (sta_info_cleanup_expire_buffered(local, sta)) 821 timer_needed = true; 822 rcu_read_unlock(); 823 824 if (local->quiescing) 825 return; 826 827 if (!timer_needed) 828 return; 829 830 mod_timer(&local->sta_cleanup, 831 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL)); 832} 833 834void sta_info_init(struct ieee80211_local *local) 835{ 836 spin_lock_init(&local->tim_lock); 837 mutex_init(&local->sta_mtx); 838 INIT_LIST_HEAD(&local->sta_list); 839 840 setup_timer(&local->sta_cleanup, sta_info_cleanup, 841 (unsigned long)local); 842} 843 844void sta_info_stop(struct ieee80211_local *local) 845{ 846 del_timer(&local->sta_cleanup); 847 sta_info_flush(local, NULL); 848} 849 850/** 851 * sta_info_flush - flush matching STA entries from the STA table 852 * 853 * Returns the number of removed STA entries. 854 * 855 * @local: local interface data 856 * @sdata: matching rule for the net device (sta->dev) or %NULL to match all STAs 857 */ 858int sta_info_flush(struct ieee80211_local *local, 859 struct ieee80211_sub_if_data *sdata) 860{ 861 struct sta_info *sta, *tmp; 862 int ret = 0; 863 864 might_sleep(); 865 866 mutex_lock(&local->sta_mtx); 867 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) { 868 if (!sdata || sdata == sta->sdata) 869 WARN_ON(__sta_info_destroy(sta)); 870 } 871 mutex_unlock(&local->sta_mtx); 872 873 return ret; 874} 875 876void ieee80211_sta_expire(struct ieee80211_sub_if_data *sdata, 877 unsigned long exp_time) 878{ 879 struct ieee80211_local *local = sdata->local; 880 struct sta_info *sta, *tmp; 881 882 mutex_lock(&local->sta_mtx); 883 884 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) { 885 if (sdata != sta->sdata) 886 continue; 887 888 if (time_after(jiffies, sta->last_rx + exp_time)) { 889#ifdef CONFIG_MAC80211_IBSS_DEBUG 890 printk(KERN_DEBUG "%s: expiring inactive STA %pM\n", 891 sdata->name, sta->sta.addr); 892#endif 893 WARN_ON(__sta_info_destroy(sta)); 894 } 895 } 896 897 mutex_unlock(&local->sta_mtx); 898} 899 900struct ieee80211_sta *ieee80211_find_sta_by_ifaddr(struct ieee80211_hw *hw, 901 const u8 *addr, 902 const u8 *localaddr) 903{ 904 struct sta_info *sta, *nxt; 905 906 /* 907 * Just return a random station if localaddr is NULL 908 * ... first in list. 909 */ 910 for_each_sta_info(hw_to_local(hw), addr, sta, nxt) { 911 if (localaddr && 912 compare_ether_addr(sta->sdata->vif.addr, localaddr) != 0) 913 continue; 914 if (!sta->uploaded) 915 return NULL; 916 return &sta->sta; 917 } 918 919 return NULL; 920} 921EXPORT_SYMBOL_GPL(ieee80211_find_sta_by_ifaddr); 922 923struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_vif *vif, 924 const u8 *addr) 925{ 926 struct sta_info *sta; 927 928 if (!vif) 929 return NULL; 930 931 sta = sta_info_get_bss(vif_to_sdata(vif), addr); 932 if (!sta) 933 return NULL; 934 935 if (!sta->uploaded) 936 return NULL; 937 938 return &sta->sta; 939} 940EXPORT_SYMBOL(ieee80211_find_sta); 941 942static void clear_sta_ps_flags(void *_sta) 943{ 944 struct sta_info *sta = _sta; 945 struct ieee80211_sub_if_data *sdata = sta->sdata; 946 947 clear_sta_flag(sta, WLAN_STA_PS_DRIVER); 948 if (test_and_clear_sta_flag(sta, WLAN_STA_PS_STA)) 949 atomic_dec(&sdata->bss->num_sta_ps); 950} 951 952/* powersave support code */ 953void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta) 954{ 955 struct ieee80211_sub_if_data *sdata = sta->sdata; 956 struct ieee80211_local *local = sdata->local; 957 struct sk_buff_head pending; 958 int filtered = 0, buffered = 0, ac; 959 960 clear_sta_flag(sta, WLAN_STA_SP); 961 962 BUILD_BUG_ON(BITS_TO_LONGS(STA_TID_NUM) > 1); 963 sta->driver_buffered_tids = 0; 964 965 if (!(local->hw.flags & IEEE80211_HW_AP_LINK_PS)) 966 drv_sta_notify(local, sdata, STA_NOTIFY_AWAKE, &sta->sta); 967 968 skb_queue_head_init(&pending); 969 970 /* Send all buffered frames to the station */ 971 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 972 int count = skb_queue_len(&pending), tmp; 973 974 skb_queue_splice_tail_init(&sta->tx_filtered[ac], &pending); 975 tmp = skb_queue_len(&pending); 976 filtered += tmp - count; 977 count = tmp; 978 979 skb_queue_splice_tail_init(&sta->ps_tx_buf[ac], &pending); 980 tmp = skb_queue_len(&pending); 981 buffered += tmp - count; 982 } 983 984 ieee80211_add_pending_skbs_fn(local, &pending, clear_sta_ps_flags, sta); 985 986 local->total_ps_buffered -= buffered; 987 988 sta_info_recalc_tim(sta); 989 990#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG 991 printk(KERN_DEBUG "%s: STA %pM aid %d sending %d filtered/%d PS frames " 992 "since STA not sleeping anymore\n", sdata->name, 993 sta->sta.addr, sta->sta.aid, filtered, buffered); 994#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */ 995} 996 997static void ieee80211_send_null_response(struct ieee80211_sub_if_data *sdata, 998 struct sta_info *sta, int tid, 999 enum ieee80211_frame_release_type reason) 1000{ 1001 struct ieee80211_local *local = sdata->local; 1002 struct ieee80211_qos_hdr *nullfunc; 1003 struct sk_buff *skb; 1004 int size = sizeof(*nullfunc); 1005 __le16 fc; 1006 bool qos = test_sta_flag(sta, WLAN_STA_WME); 1007 struct ieee80211_tx_info *info; 1008 1009 if (qos) { 1010 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | 1011 IEEE80211_STYPE_QOS_NULLFUNC | 1012 IEEE80211_FCTL_FROMDS); 1013 } else { 1014 size -= 2; 1015 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | 1016 IEEE80211_STYPE_NULLFUNC | 1017 IEEE80211_FCTL_FROMDS); 1018 } 1019 1020 skb = dev_alloc_skb(local->hw.extra_tx_headroom + size); 1021 if (!skb) 1022 return; 1023 1024 skb_reserve(skb, local->hw.extra_tx_headroom); 1025 1026 nullfunc = (void *) skb_put(skb, size); 1027 nullfunc->frame_control = fc; 1028 nullfunc->duration_id = 0; 1029 memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN); 1030 memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN); 1031 memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN); 1032 1033 skb->priority = tid; 1034 skb_set_queue_mapping(skb, ieee802_1d_to_ac[tid]); 1035 if (qos) { 1036 nullfunc->qos_ctrl = cpu_to_le16(tid); 1037 1038 if (reason == IEEE80211_FRAME_RELEASE_UAPSD) 1039 nullfunc->qos_ctrl |= 1040 cpu_to_le16(IEEE80211_QOS_CTL_EOSP); 1041 } 1042 1043 info = IEEE80211_SKB_CB(skb); 1044 1045 /* 1046 * Tell TX path to send this frame even though the 1047 * STA may still remain is PS mode after this frame 1048 * exchange. Also set EOSP to indicate this packet 1049 * ends the poll/service period. 1050 */ 1051 info->flags |= IEEE80211_TX_CTL_POLL_RESPONSE | 1052 IEEE80211_TX_STATUS_EOSP | 1053 IEEE80211_TX_CTL_REQ_TX_STATUS; 1054 1055 drv_allow_buffered_frames(local, sta, BIT(tid), 1, reason, false); 1056 1057 ieee80211_xmit(sdata, skb); 1058} 1059 1060static void 1061ieee80211_sta_ps_deliver_response(struct sta_info *sta, 1062 int n_frames, u8 ignored_acs, 1063 enum ieee80211_frame_release_type reason) 1064{ 1065 struct ieee80211_sub_if_data *sdata = sta->sdata; 1066 struct ieee80211_local *local = sdata->local; 1067 bool found = false; 1068 bool more_data = false; 1069 int ac; 1070 unsigned long driver_release_tids = 0; 1071 struct sk_buff_head frames; 1072 1073 /* Service or PS-Poll period starts */ 1074 set_sta_flag(sta, WLAN_STA_SP); 1075 1076 __skb_queue_head_init(&frames); 1077 1078 /* 1079 * Get response frame(s) and more data bit for it. 1080 */ 1081 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { 1082 unsigned long tids; 1083 1084 if (ignored_acs & BIT(ac)) 1085 continue; 1086 1087 tids = ieee80211_tids_for_ac(ac); 1088 1089 if (!found) { 1090 driver_release_tids = sta->driver_buffered_tids & tids; 1091 if (driver_release_tids) { 1092 found = true; 1093 } else { 1094 struct sk_buff *skb; 1095 1096 while (n_frames > 0) { 1097 skb = skb_dequeue(&sta->tx_filtered[ac]); 1098 if (!skb) { 1099 skb = skb_dequeue( 1100 &sta->ps_tx_buf[ac]); 1101 if (skb) 1102 local->total_ps_buffered--; 1103 } 1104 if (!skb) 1105 break; 1106 n_frames--; 1107 found = true; 1108 __skb_queue_tail(&frames, skb); 1109 } 1110 } 1111 1112 /* 1113 * If the driver has data on more than one TID then 1114 * certainly there's more data if we release just a 1115 * single frame now (from a single TID). 1116 */ 1117 if (reason == IEEE80211_FRAME_RELEASE_PSPOLL && 1118 hweight16(driver_release_tids) > 1) { 1119 more_data = true; 1120 driver_release_tids = 1121 BIT(ffs(driver_release_tids) - 1); 1122 break; 1123 } 1124 } 1125 1126 if (!skb_queue_empty(&sta->tx_filtered[ac]) || 1127 !skb_queue_empty(&sta->ps_tx_buf[ac])) { 1128 more_data = true; 1129 break; 1130 } 1131 } 1132 1133 if (!found) { 1134 int tid; 1135 1136 /* 1137 * For PS-Poll, this can only happen due to a race condition 1138 * when we set the TIM bit and the station notices it, but 1139 * before it can poll for the frame we expire it. 1140 * 1141 * For uAPSD, this is said in the standard (11.2.1.5 h): 1142 * At each unscheduled SP for a non-AP STA, the AP shall 1143 * attempt to transmit at least one MSDU or MMPDU, but no 1144 * more than the value specified in the Max SP Length field 1145 * in the QoS Capability element from delivery-enabled ACs, 1146 * that are destined for the non-AP STA. 1147 * 1148 * Since we have no other MSDU/MMPDU, transmit a QoS null frame. 1149 */ 1150 1151 /* This will evaluate to 1, 3, 5 or 7. */ 1152 tid = 7 - ((ffs(~ignored_acs) - 1) << 1); 1153 1154 ieee80211_send_null_response(sdata, sta, tid, reason); 1155 return; 1156 } 1157 1158 if (!driver_release_tids) { 1159 struct sk_buff_head pending; 1160 struct sk_buff *skb; 1161 int num = 0; 1162 u16 tids = 0; 1163 1164 skb_queue_head_init(&pending); 1165 1166 while ((skb = __skb_dequeue(&frames))) { 1167 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1168 struct ieee80211_hdr *hdr = (void *) skb->data; 1169 u8 *qoshdr = NULL; 1170 1171 num++; 1172 1173 /* 1174 * Tell TX path to send this frame even though the 1175 * STA may still remain is PS mode after this frame 1176 * exchange. 1177 */ 1178 info->flags |= IEEE80211_TX_CTL_POLL_RESPONSE; 1179 1180 /* 1181 * Use MoreData flag to indicate whether there are 1182 * more buffered frames for this STA 1183 */ 1184 if (more_data || !skb_queue_empty(&frames)) 1185 hdr->frame_control |= 1186 cpu_to_le16(IEEE80211_FCTL_MOREDATA); 1187 else 1188 hdr->frame_control &= 1189 cpu_to_le16(~IEEE80211_FCTL_MOREDATA); 1190 1191 if (ieee80211_is_data_qos(hdr->frame_control) || 1192 ieee80211_is_qos_nullfunc(hdr->frame_control)) 1193 qoshdr = ieee80211_get_qos_ctl(hdr); 1194 1195 /* set EOSP for the frame */ 1196 if (reason == IEEE80211_FRAME_RELEASE_UAPSD && 1197 qoshdr && skb_queue_empty(&frames)) 1198 *qoshdr |= IEEE80211_QOS_CTL_EOSP; 1199 1200 info->flags |= IEEE80211_TX_STATUS_EOSP | 1201 IEEE80211_TX_CTL_REQ_TX_STATUS; 1202 1203 if (qoshdr) 1204 tids |= BIT(*qoshdr & IEEE80211_QOS_CTL_TID_MASK); 1205 else 1206 tids |= BIT(0); 1207 1208 __skb_queue_tail(&pending, skb); 1209 } 1210 1211 drv_allow_buffered_frames(local, sta, tids, num, 1212 reason, more_data); 1213 1214 ieee80211_add_pending_skbs(local, &pending); 1215 1216 sta_info_recalc_tim(sta); 1217 } else { 1218 /* 1219 * We need to release a frame that is buffered somewhere in the 1220 * driver ... it'll have to handle that. 1221 * Note that, as per the comment above, it'll also have to see 1222 * if there is more than just one frame on the specific TID that 1223 * we're releasing from, and it needs to set the more-data bit 1224 * accordingly if we tell it that there's no more data. If we do 1225 * tell it there's more data, then of course the more-data bit 1226 * needs to be set anyway. 1227 */ 1228 drv_release_buffered_frames(local, sta, driver_release_tids, 1229 n_frames, reason, more_data); 1230 1231 /* 1232 * Note that we don't recalculate the TIM bit here as it would 1233 * most likely have no effect at all unless the driver told us 1234 * that the TID became empty before returning here from the 1235 * release function. 1236 * Either way, however, when the driver tells us that the TID 1237 * became empty we'll do the TIM recalculation. 1238 */ 1239 } 1240} 1241 1242void ieee80211_sta_ps_deliver_poll_response(struct sta_info *sta) 1243{ 1244 u8 ignore_for_response = sta->sta.uapsd_queues; 1245 1246 /* 1247 * If all ACs are delivery-enabled then we should reply 1248 * from any of them, if only some are enabled we reply 1249 * only from the non-enabled ones. 1250 */ 1251 if (ignore_for_response == BIT(IEEE80211_NUM_ACS) - 1) 1252 ignore_for_response = 0; 1253 1254 ieee80211_sta_ps_deliver_response(sta, 1, ignore_for_response, 1255 IEEE80211_FRAME_RELEASE_PSPOLL); 1256} 1257 1258void ieee80211_sta_ps_deliver_uapsd(struct sta_info *sta) 1259{ 1260 int n_frames = sta->sta.max_sp; 1261 u8 delivery_enabled = sta->sta.uapsd_queues; 1262 1263 /* 1264 * If we ever grow support for TSPEC this might happen if 1265 * the TSPEC update from hostapd comes in between a trigger 1266 * frame setting WLAN_STA_UAPSD in the RX path and this 1267 * actually getting called. 1268 */ 1269 if (!delivery_enabled) 1270 return; 1271 1272 switch (sta->sta.max_sp) { 1273 case 1: 1274 n_frames = 2; 1275 break; 1276 case 2: 1277 n_frames = 4; 1278 break; 1279 case 3: 1280 n_frames = 6; 1281 break; 1282 case 0: 1283 /* XXX: what is a good value? */ 1284 n_frames = 8; 1285 break; 1286 } 1287 1288 ieee80211_sta_ps_deliver_response(sta, n_frames, ~delivery_enabled, 1289 IEEE80211_FRAME_RELEASE_UAPSD); 1290} 1291 1292void ieee80211_sta_block_awake(struct ieee80211_hw *hw, 1293 struct ieee80211_sta *pubsta, bool block) 1294{ 1295 struct sta_info *sta = container_of(pubsta, struct sta_info, sta); 1296 1297 trace_api_sta_block_awake(sta->local, pubsta, block); 1298 1299 if (block) 1300 set_sta_flag(sta, WLAN_STA_PS_DRIVER); 1301 else if (test_sta_flag(sta, WLAN_STA_PS_DRIVER)) 1302 ieee80211_queue_work(hw, &sta->drv_unblock_wk); 1303} 1304EXPORT_SYMBOL(ieee80211_sta_block_awake); 1305 1306void ieee80211_sta_eosp_irqsafe(struct ieee80211_sta *pubsta) 1307{ 1308 struct sta_info *sta = container_of(pubsta, struct sta_info, sta); 1309 struct ieee80211_local *local = sta->local; 1310 struct sk_buff *skb; 1311 struct skb_eosp_msg_data *data; 1312 1313 trace_api_eosp(local, pubsta); 1314 1315 skb = alloc_skb(0, GFP_ATOMIC); 1316 if (!skb) { 1317 /* too bad ... but race is better than loss */ 1318 clear_sta_flag(sta, WLAN_STA_SP); 1319 return; 1320 } 1321 1322 data = (void *)skb->cb; 1323 memcpy(data->sta, pubsta->addr, ETH_ALEN); 1324 memcpy(data->iface, sta->sdata->vif.addr, ETH_ALEN); 1325 skb->pkt_type = IEEE80211_EOSP_MSG; 1326 skb_queue_tail(&local->skb_queue, skb); 1327 tasklet_schedule(&local->tasklet); 1328} 1329EXPORT_SYMBOL(ieee80211_sta_eosp_irqsafe); 1330 1331void ieee80211_sta_set_buffered(struct ieee80211_sta *pubsta, 1332 u8 tid, bool buffered) 1333{ 1334 struct sta_info *sta = container_of(pubsta, struct sta_info, sta); 1335 1336 if (WARN_ON(tid >= STA_TID_NUM)) 1337 return; 1338 1339 if (buffered) 1340 set_bit(tid, &sta->driver_buffered_tids); 1341 else 1342 clear_bit(tid, &sta->driver_buffered_tids); 1343 1344 sta_info_recalc_tim(sta); 1345} 1346EXPORT_SYMBOL(ieee80211_sta_set_buffered); 1347 1348int sta_info_move_state(struct sta_info *sta, 1349 enum ieee80211_sta_state new_state) 1350{ 1351 might_sleep(); 1352 1353 if (sta->sta_state == new_state) 1354 return 0; 1355 1356 /* check allowed transitions first */ 1357 1358 switch (new_state) { 1359 case IEEE80211_STA_NONE: 1360 if (sta->sta_state != IEEE80211_STA_AUTH) 1361 return -EINVAL; 1362 break; 1363 case IEEE80211_STA_AUTH: 1364 if (sta->sta_state != IEEE80211_STA_NONE && 1365 sta->sta_state != IEEE80211_STA_ASSOC) 1366 return -EINVAL; 1367 break; 1368 case IEEE80211_STA_ASSOC: 1369 if (sta->sta_state != IEEE80211_STA_AUTH && 1370 sta->sta_state != IEEE80211_STA_AUTHORIZED) 1371 return -EINVAL; 1372 break; 1373 case IEEE80211_STA_AUTHORIZED: 1374 if (sta->sta_state != IEEE80211_STA_ASSOC) 1375 return -EINVAL; 1376 break; 1377 default: 1378 WARN(1, "invalid state %d", new_state); 1379 return -EINVAL; 1380 } 1381 1382 printk(KERN_DEBUG "%s: moving STA %pM to state %d\n", 1383 sta->sdata->name, sta->sta.addr, new_state); 1384 1385 /* 1386 * notify the driver before the actual changes so it can 1387 * fail the transition 1388 */ 1389 if (test_sta_flag(sta, WLAN_STA_INSERTED)) { 1390 int err = drv_sta_state(sta->local, sta->sdata, sta, 1391 sta->sta_state, new_state); 1392 if (err) 1393 return err; 1394 } 1395 1396 /* reflect the change in all state variables */ 1397 1398 switch (new_state) { 1399 case IEEE80211_STA_NONE: 1400 if (sta->sta_state == IEEE80211_STA_AUTH) 1401 clear_bit(WLAN_STA_AUTH, &sta->_flags); 1402 break; 1403 case IEEE80211_STA_AUTH: 1404 if (sta->sta_state == IEEE80211_STA_NONE) 1405 set_bit(WLAN_STA_AUTH, &sta->_flags); 1406 else if (sta->sta_state == IEEE80211_STA_ASSOC) 1407 clear_bit(WLAN_STA_ASSOC, &sta->_flags); 1408 break; 1409 case IEEE80211_STA_ASSOC: 1410 if (sta->sta_state == IEEE80211_STA_AUTH) { 1411 set_bit(WLAN_STA_ASSOC, &sta->_flags); 1412 } else if (sta->sta_state == IEEE80211_STA_AUTHORIZED) { 1413 if (sta->sdata->vif.type == NL80211_IFTYPE_AP) 1414 atomic_dec(&sta->sdata->u.ap.num_sta_authorized); 1415 clear_bit(WLAN_STA_AUTHORIZED, &sta->_flags); 1416 } 1417 break; 1418 case IEEE80211_STA_AUTHORIZED: 1419 if (sta->sta_state == IEEE80211_STA_ASSOC) { 1420 if (sta->sdata->vif.type == NL80211_IFTYPE_AP) 1421 atomic_inc(&sta->sdata->u.ap.num_sta_authorized); 1422 set_bit(WLAN_STA_AUTHORIZED, &sta->_flags); 1423 } 1424 break; 1425 default: 1426 break; 1427 } 1428 1429 sta->sta_state = new_state; 1430 1431 return 0; 1432} 1433