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