sta_info.c revision cccaec98a3ddbf20f22604f9ba405781c5f89f0e
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 28/** 29 * DOC: STA information lifetime rules 30 * 31 * STA info structures (&struct sta_info) are managed in a hash table 32 * for faster lookup and a list for iteration. They are managed using 33 * RCU, i.e. access to the list and hash table is protected by RCU. 34 * 35 * Upon allocating a STA info structure with sta_info_alloc(), the caller owns 36 * that structure. It must then either destroy it using sta_info_destroy() 37 * (which is pretty useless) or insert it into the hash table using 38 * sta_info_insert() which demotes the reference from ownership to a regular 39 * RCU-protected reference; if the function is called without protection by an 40 * RCU critical section the reference is instantly invalidated. Note that the 41 * caller may not do much with the STA info before inserting it, in particular, 42 * it may not start any mesh peer link management or add encryption keys. 43 * 44 * When the insertion fails (sta_info_insert()) returns non-zero), the 45 * structure will have been freed by sta_info_insert()! 46 * 47 * Because there are debugfs entries for each station, and adding those 48 * must be able to sleep, it is also possible to "pin" a station entry, 49 * that means it can be removed from the hash table but not be freed. 50 * See the comment in __sta_info_unlink() for more information, this is 51 * an internal capability only. 52 * 53 * In order to remove a STA info structure, the caller needs to first 54 * unlink it (sta_info_unlink()) from the list and hash tables and 55 * then destroy it; sta_info_destroy() will wait for an RCU grace period 56 * to elapse before actually freeing it. Due to the pinning and the 57 * possibility of multiple callers trying to remove the same STA info at 58 * the same time, sta_info_unlink() can clear the STA info pointer it is 59 * passed to indicate that the STA info is owned by somebody else now. 60 * 61 * If sta_info_unlink() did not clear the pointer then the caller owns 62 * the STA info structure now and is responsible of destroying it with 63 * a call to sta_info_destroy(). 64 * 65 * In all other cases, there is no concept of ownership on a STA entry, 66 * each structure is owned by the global hash table/list until it is 67 * removed. All users of the structure need to be RCU protected so that 68 * the structure won't be freed before they are done using it. 69 */ 70 71/* Caller must hold local->sta_lock */ 72static int sta_info_hash_del(struct ieee80211_local *local, 73 struct sta_info *sta) 74{ 75 struct sta_info *s; 76 77 s = local->sta_hash[STA_HASH(sta->sta.addr)]; 78 if (!s) 79 return -ENOENT; 80 if (s == sta) { 81 rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)], 82 s->hnext); 83 return 0; 84 } 85 86 while (s->hnext && s->hnext != sta) 87 s = s->hnext; 88 if (s->hnext) { 89 rcu_assign_pointer(s->hnext, sta->hnext); 90 return 0; 91 } 92 93 return -ENOENT; 94} 95 96/* protected by RCU */ 97struct sta_info *sta_info_get(struct ieee80211_local *local, const u8 *addr) 98{ 99 struct sta_info *sta; 100 101 sta = rcu_dereference(local->sta_hash[STA_HASH(addr)]); 102 while (sta) { 103 if (memcmp(sta->sta.addr, addr, ETH_ALEN) == 0) 104 break; 105 sta = rcu_dereference(sta->hnext); 106 } 107 return sta; 108} 109 110struct sta_info *sta_info_get_by_idx(struct ieee80211_local *local, int idx, 111 struct net_device *dev) 112{ 113 struct sta_info *sta; 114 int i = 0; 115 116 list_for_each_entry_rcu(sta, &local->sta_list, list) { 117 if (dev && dev != sta->sdata->dev) 118 continue; 119 if (i < idx) { 120 ++i; 121 continue; 122 } 123 return sta; 124 } 125 126 return NULL; 127} 128 129/** 130 * __sta_info_free - internal STA free helper 131 * 132 * @local: pointer to the global information 133 * @sta: STA info to free 134 * 135 * This function must undo everything done by sta_info_alloc() 136 * that may happen before sta_info_insert(). 137 */ 138static void __sta_info_free(struct ieee80211_local *local, 139 struct sta_info *sta) 140{ 141 rate_control_free_sta(sta); 142 rate_control_put(sta->rate_ctrl); 143 144#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 145 printk(KERN_DEBUG "%s: Destroyed STA %pM\n", 146 wiphy_name(local->hw.wiphy), sta->sta.addr); 147#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 148 149 kfree(sta); 150} 151 152void sta_info_destroy(struct sta_info *sta) 153{ 154 struct ieee80211_local *local; 155 struct sk_buff *skb; 156 int i; 157 158 might_sleep(); 159 160 if (!sta) 161 return; 162 163 local = sta->local; 164 165 rate_control_remove_sta_debugfs(sta); 166 ieee80211_sta_debugfs_remove(sta); 167 168#ifdef CONFIG_MAC80211_MESH 169 if (ieee80211_vif_is_mesh(&sta->sdata->vif)) 170 mesh_plink_deactivate(sta); 171#endif 172 173 /* 174 * We have only unlinked the key, and actually destroying it 175 * may mean it is removed from hardware which requires that 176 * the key->sta pointer is still valid, so flush the key todo 177 * list here. 178 * 179 * ieee80211_key_todo() will synchronize_rcu() so after this 180 * nothing can reference this sta struct any more. 181 */ 182 ieee80211_key_todo(); 183 184#ifdef CONFIG_MAC80211_MESH 185 if (ieee80211_vif_is_mesh(&sta->sdata->vif)) 186 del_timer_sync(&sta->plink_timer); 187#endif 188 189 while ((skb = skb_dequeue(&sta->ps_tx_buf)) != NULL) { 190 local->total_ps_buffered--; 191 dev_kfree_skb_any(skb); 192 } 193 194 while ((skb = skb_dequeue(&sta->tx_filtered)) != NULL) 195 dev_kfree_skb_any(skb); 196 197 for (i = 0; i < STA_TID_NUM; i++) { 198 struct tid_ampdu_rx *tid_rx; 199 struct tid_ampdu_tx *tid_tx; 200 201 spin_lock_bh(&sta->lock); 202 tid_rx = sta->ampdu_mlme.tid_rx[i]; 203 /* Make sure timer won't free the tid_rx struct, see below */ 204 if (tid_rx) 205 tid_rx->shutdown = true; 206 207 spin_unlock_bh(&sta->lock); 208 209 /* 210 * Outside spinlock - shutdown is true now so that the timer 211 * won't free tid_rx, we have to do that now. Can't let the 212 * timer do it because we have to sync the timer outside the 213 * lock that it takes itself. 214 */ 215 if (tid_rx) { 216 del_timer_sync(&tid_rx->session_timer); 217 kfree(tid_rx); 218 } 219 220 /* 221 * No need to do such complications for TX agg sessions, the 222 * path leading to freeing the tid_tx struct goes via a call 223 * from the driver, and thus needs to look up the sta struct 224 * again, which cannot be found when we get here. Hence, we 225 * just need to delete the timer and free the aggregation 226 * info; we won't be telling the peer about it then but that 227 * doesn't matter if we're not talking to it again anyway. 228 */ 229 tid_tx = sta->ampdu_mlme.tid_tx[i]; 230 if (tid_tx) { 231 del_timer_sync(&tid_tx->addba_resp_timer); 232 /* 233 * STA removed while aggregation session being 234 * started? Bit odd, but purge frames anyway. 235 */ 236 skb_queue_purge(&tid_tx->pending); 237 kfree(tid_tx); 238 } 239 } 240 241 __sta_info_free(local, sta); 242} 243 244 245/* Caller must hold local->sta_lock */ 246static void sta_info_hash_add(struct ieee80211_local *local, 247 struct sta_info *sta) 248{ 249 sta->hnext = local->sta_hash[STA_HASH(sta->sta.addr)]; 250 rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)], sta); 251} 252 253struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata, 254 u8 *addr, gfp_t gfp) 255{ 256 struct ieee80211_local *local = sdata->local; 257 struct sta_info *sta; 258 int i; 259 260 sta = kzalloc(sizeof(*sta) + local->hw.sta_data_size, gfp); 261 if (!sta) 262 return NULL; 263 264 spin_lock_init(&sta->lock); 265 spin_lock_init(&sta->flaglock); 266 267 memcpy(sta->sta.addr, addr, ETH_ALEN); 268 sta->local = local; 269 sta->sdata = sdata; 270 271 sta->rate_ctrl = rate_control_get(local->rate_ctrl); 272 sta->rate_ctrl_priv = rate_control_alloc_sta(sta->rate_ctrl, 273 &sta->sta, gfp); 274 if (!sta->rate_ctrl_priv) { 275 rate_control_put(sta->rate_ctrl); 276 kfree(sta); 277 return NULL; 278 } 279 280 for (i = 0; i < STA_TID_NUM; i++) { 281 /* timer_to_tid must be initialized with identity mapping to 282 * enable session_timer's data differentiation. refer to 283 * sta_rx_agg_session_timer_expired for useage */ 284 sta->timer_to_tid[i] = i; 285 /* rx */ 286 sta->ampdu_mlme.tid_state_rx[i] = HT_AGG_STATE_IDLE; 287 sta->ampdu_mlme.tid_rx[i] = NULL; 288 /* tx */ 289 sta->ampdu_mlme.tid_state_tx[i] = HT_AGG_STATE_IDLE; 290 sta->ampdu_mlme.tid_tx[i] = NULL; 291 sta->ampdu_mlme.addba_req_num[i] = 0; 292 } 293 skb_queue_head_init(&sta->ps_tx_buf); 294 skb_queue_head_init(&sta->tx_filtered); 295 296 for (i = 0; i < NUM_RX_DATA_QUEUES; i++) 297 sta->last_seq_ctrl[i] = cpu_to_le16(USHORT_MAX); 298 299#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 300 printk(KERN_DEBUG "%s: Allocated STA %pM\n", 301 wiphy_name(local->hw.wiphy), sta->sta.addr); 302#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 303 304#ifdef CONFIG_MAC80211_MESH 305 sta->plink_state = PLINK_LISTEN; 306 init_timer(&sta->plink_timer); 307#endif 308 309 return sta; 310} 311 312int sta_info_insert(struct sta_info *sta) 313{ 314 struct ieee80211_local *local = sta->local; 315 struct ieee80211_sub_if_data *sdata = sta->sdata; 316 unsigned long flags; 317 int err = 0; 318 319 /* 320 * Can't be a WARN_ON because it can be triggered through a race: 321 * something inserts a STA (on one CPU) without holding the RTNL 322 * and another CPU turns off the net device. 323 */ 324 if (unlikely(!netif_running(sdata->dev))) { 325 err = -ENETDOWN; 326 goto out_free; 327 } 328 329 if (WARN_ON(compare_ether_addr(sta->sta.addr, sdata->dev->dev_addr) == 0 || 330 is_multicast_ether_addr(sta->sta.addr))) { 331 err = -EINVAL; 332 goto out_free; 333 } 334 335 spin_lock_irqsave(&local->sta_lock, flags); 336 /* check if STA exists already */ 337 if (sta_info_get(local, sta->sta.addr)) { 338 spin_unlock_irqrestore(&local->sta_lock, flags); 339 err = -EEXIST; 340 goto out_free; 341 } 342 list_add(&sta->list, &local->sta_list); 343 local->num_sta++; 344 sta_info_hash_add(local, sta); 345 346 /* notify driver */ 347 if (local->ops->sta_notify) { 348 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 349 sdata = container_of(sdata->bss, 350 struct ieee80211_sub_if_data, 351 u.ap); 352 353 drv_sta_notify(local, &sdata->vif, STA_NOTIFY_ADD, &sta->sta); 354 } 355 356#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 357 printk(KERN_DEBUG "%s: Inserted STA %pM\n", 358 wiphy_name(local->hw.wiphy), sta->sta.addr); 359#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 360 361 spin_unlock_irqrestore(&local->sta_lock, flags); 362 363#ifdef CONFIG_MAC80211_DEBUGFS 364 /* 365 * Debugfs entry adding might sleep, so schedule process 366 * context task for adding entry for STAs that do not yet 367 * have one. 368 * NOTE: due to auto-freeing semantics this may only be done 369 * if the insertion is successful! 370 */ 371 schedule_work(&local->sta_debugfs_add); 372#endif 373 374 if (ieee80211_vif_is_mesh(&sdata->vif)) 375 mesh_accept_plinks_update(sdata); 376 377 return 0; 378 out_free: 379 BUG_ON(!err); 380 __sta_info_free(local, sta); 381 return err; 382} 383 384static inline void __bss_tim_set(struct ieee80211_if_ap *bss, u16 aid) 385{ 386 /* 387 * This format has been mandated by the IEEE specifications, 388 * so this line may not be changed to use the __set_bit() format. 389 */ 390 bss->tim[aid / 8] |= (1 << (aid % 8)); 391} 392 393static inline void __bss_tim_clear(struct ieee80211_if_ap *bss, u16 aid) 394{ 395 /* 396 * This format has been mandated by the IEEE specifications, 397 * so this line may not be changed to use the __clear_bit() format. 398 */ 399 bss->tim[aid / 8] &= ~(1 << (aid % 8)); 400} 401 402static void __sta_info_set_tim_bit(struct ieee80211_if_ap *bss, 403 struct sta_info *sta) 404{ 405 BUG_ON(!bss); 406 407 __bss_tim_set(bss, sta->sta.aid); 408 409 if (sta->local->ops->set_tim) { 410 sta->local->tim_in_locked_section = true; 411 drv_set_tim(sta->local, &sta->sta, true); 412 sta->local->tim_in_locked_section = false; 413 } 414} 415 416void sta_info_set_tim_bit(struct sta_info *sta) 417{ 418 unsigned long flags; 419 420 BUG_ON(!sta->sdata->bss); 421 422 spin_lock_irqsave(&sta->local->sta_lock, flags); 423 __sta_info_set_tim_bit(sta->sdata->bss, sta); 424 spin_unlock_irqrestore(&sta->local->sta_lock, flags); 425} 426 427static void __sta_info_clear_tim_bit(struct ieee80211_if_ap *bss, 428 struct sta_info *sta) 429{ 430 BUG_ON(!bss); 431 432 __bss_tim_clear(bss, sta->sta.aid); 433 434 if (sta->local->ops->set_tim) { 435 sta->local->tim_in_locked_section = true; 436 drv_set_tim(sta->local, &sta->sta, false); 437 sta->local->tim_in_locked_section = false; 438 } 439} 440 441void sta_info_clear_tim_bit(struct sta_info *sta) 442{ 443 unsigned long flags; 444 445 BUG_ON(!sta->sdata->bss); 446 447 spin_lock_irqsave(&sta->local->sta_lock, flags); 448 __sta_info_clear_tim_bit(sta->sdata->bss, sta); 449 spin_unlock_irqrestore(&sta->local->sta_lock, flags); 450} 451 452static void __sta_info_unlink(struct sta_info **sta) 453{ 454 struct ieee80211_local *local = (*sta)->local; 455 struct ieee80211_sub_if_data *sdata = (*sta)->sdata; 456 /* 457 * pull caller's reference if we're already gone. 458 */ 459 if (sta_info_hash_del(local, *sta)) { 460 *sta = NULL; 461 return; 462 } 463 464 if ((*sta)->key) { 465 ieee80211_key_free((*sta)->key); 466 WARN_ON((*sta)->key); 467 } 468 469 list_del(&(*sta)->list); 470 471 if (test_and_clear_sta_flags(*sta, WLAN_STA_PS)) { 472 BUG_ON(!sdata->bss); 473 474 atomic_dec(&sdata->bss->num_sta_ps); 475 __sta_info_clear_tim_bit(sdata->bss, *sta); 476 } 477 478 local->num_sta--; 479 480 if (local->ops->sta_notify) { 481 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 482 sdata = container_of(sdata->bss, 483 struct ieee80211_sub_if_data, 484 u.ap); 485 486 drv_sta_notify(local, &sdata->vif, STA_NOTIFY_REMOVE, 487 &(*sta)->sta); 488 } 489 490 if (ieee80211_vif_is_mesh(&sdata->vif)) { 491 mesh_accept_plinks_update(sdata); 492#ifdef CONFIG_MAC80211_MESH 493 del_timer(&(*sta)->plink_timer); 494#endif 495 } 496 497#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 498 printk(KERN_DEBUG "%s: Removed STA %pM\n", 499 wiphy_name(local->hw.wiphy), (*sta)->sta.addr); 500#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 501 502 /* 503 * Finally, pull caller's reference if the STA is pinned by the 504 * task that is adding the debugfs entries. In that case, we 505 * leave the STA "to be freed". 506 * 507 * The rules are not trivial, but not too complex either: 508 * (1) pin_status is only modified under the sta_lock 509 * (2) STAs may only be pinned under the RTNL so that 510 * sta_info_flush() is guaranteed to actually destroy 511 * all STAs that are active for a given interface, this 512 * is required for correctness because otherwise we 513 * could notify a driver that an interface is going 514 * away and only after that (!) notify it about a STA 515 * on that interface going away. 516 * (3) sta_info_debugfs_add_work() will set the status 517 * to PINNED when it found an item that needs a new 518 * debugfs directory created. In that case, that item 519 * must not be freed although all *RCU* users are done 520 * with it. Hence, we tell the caller of _unlink() 521 * that the item is already gone (as can happen when 522 * two tasks try to unlink/destroy at the same time) 523 * (4) We set the pin_status to DESTROY here when we 524 * find such an item. 525 * (5) sta_info_debugfs_add_work() will reset the pin_status 526 * from PINNED to NORMAL when it is done with the item, 527 * but will check for DESTROY before resetting it in 528 * which case it will free the item. 529 */ 530 if ((*sta)->pin_status == STA_INFO_PIN_STAT_PINNED) { 531 (*sta)->pin_status = STA_INFO_PIN_STAT_DESTROY; 532 *sta = NULL; 533 return; 534 } 535} 536 537void sta_info_unlink(struct sta_info **sta) 538{ 539 struct ieee80211_local *local = (*sta)->local; 540 unsigned long flags; 541 542 spin_lock_irqsave(&local->sta_lock, flags); 543 __sta_info_unlink(sta); 544 spin_unlock_irqrestore(&local->sta_lock, flags); 545} 546 547static int sta_info_buffer_expired(struct sta_info *sta, 548 struct sk_buff *skb) 549{ 550 struct ieee80211_tx_info *info; 551 int timeout; 552 553 if (!skb) 554 return 0; 555 556 info = IEEE80211_SKB_CB(skb); 557 558 /* Timeout: (2 * listen_interval * beacon_int * 1024 / 1000000) sec */ 559 timeout = (sta->listen_interval * 560 sta->sdata->vif.bss_conf.beacon_int * 561 32 / 15625) * HZ; 562 if (timeout < STA_TX_BUFFER_EXPIRE) 563 timeout = STA_TX_BUFFER_EXPIRE; 564 return time_after(jiffies, info->control.jiffies + timeout); 565} 566 567 568static void sta_info_cleanup_expire_buffered(struct ieee80211_local *local, 569 struct sta_info *sta) 570{ 571 unsigned long flags; 572 struct sk_buff *skb; 573 struct ieee80211_sub_if_data *sdata; 574 575 if (skb_queue_empty(&sta->ps_tx_buf)) 576 return; 577 578 for (;;) { 579 spin_lock_irqsave(&sta->ps_tx_buf.lock, flags); 580 skb = skb_peek(&sta->ps_tx_buf); 581 if (sta_info_buffer_expired(sta, skb)) 582 skb = __skb_dequeue(&sta->ps_tx_buf); 583 else 584 skb = NULL; 585 spin_unlock_irqrestore(&sta->ps_tx_buf.lock, flags); 586 587 if (!skb) 588 break; 589 590 sdata = sta->sdata; 591 local->total_ps_buffered--; 592#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG 593 printk(KERN_DEBUG "Buffered frame expired (STA %pM)\n", 594 sta->sta.addr); 595#endif 596 dev_kfree_skb(skb); 597 598 if (skb_queue_empty(&sta->ps_tx_buf)) 599 sta_info_clear_tim_bit(sta); 600 } 601} 602 603 604static void sta_info_cleanup(unsigned long data) 605{ 606 struct ieee80211_local *local = (struct ieee80211_local *) data; 607 struct sta_info *sta; 608 609 rcu_read_lock(); 610 list_for_each_entry_rcu(sta, &local->sta_list, list) 611 sta_info_cleanup_expire_buffered(local, sta); 612 rcu_read_unlock(); 613 614 local->sta_cleanup.expires = 615 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL); 616 add_timer(&local->sta_cleanup); 617} 618 619#ifdef CONFIG_MAC80211_DEBUGFS 620/* 621 * See comment in __sta_info_unlink, 622 * caller must hold local->sta_lock. 623 */ 624static void __sta_info_pin(struct sta_info *sta) 625{ 626 WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_NORMAL); 627 sta->pin_status = STA_INFO_PIN_STAT_PINNED; 628} 629 630/* 631 * See comment in __sta_info_unlink, returns sta if it 632 * needs to be destroyed. 633 */ 634static struct sta_info *__sta_info_unpin(struct sta_info *sta) 635{ 636 struct sta_info *ret = NULL; 637 unsigned long flags; 638 639 spin_lock_irqsave(&sta->local->sta_lock, flags); 640 WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_DESTROY && 641 sta->pin_status != STA_INFO_PIN_STAT_PINNED); 642 if (sta->pin_status == STA_INFO_PIN_STAT_DESTROY) 643 ret = sta; 644 sta->pin_status = STA_INFO_PIN_STAT_NORMAL; 645 spin_unlock_irqrestore(&sta->local->sta_lock, flags); 646 647 return ret; 648} 649 650static void sta_info_debugfs_add_work(struct work_struct *work) 651{ 652 struct ieee80211_local *local = 653 container_of(work, struct ieee80211_local, sta_debugfs_add); 654 struct sta_info *sta, *tmp; 655 unsigned long flags; 656 657 /* We need to keep the RTNL across the whole pinned status. */ 658 rtnl_lock(); 659 while (1) { 660 sta = NULL; 661 662 spin_lock_irqsave(&local->sta_lock, flags); 663 list_for_each_entry(tmp, &local->sta_list, list) { 664 /* 665 * debugfs.add_has_run will be set by 666 * ieee80211_sta_debugfs_add regardless 667 * of what else it does. 668 */ 669 if (!tmp->debugfs.add_has_run) { 670 sta = tmp; 671 __sta_info_pin(sta); 672 break; 673 } 674 } 675 spin_unlock_irqrestore(&local->sta_lock, flags); 676 677 if (!sta) 678 break; 679 680 ieee80211_sta_debugfs_add(sta); 681 rate_control_add_sta_debugfs(sta); 682 683 sta = __sta_info_unpin(sta); 684 sta_info_destroy(sta); 685 } 686 rtnl_unlock(); 687} 688#endif 689 690void sta_info_init(struct ieee80211_local *local) 691{ 692 spin_lock_init(&local->sta_lock); 693 INIT_LIST_HEAD(&local->sta_list); 694 695 setup_timer(&local->sta_cleanup, sta_info_cleanup, 696 (unsigned long)local); 697 local->sta_cleanup.expires = 698 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL); 699 700#ifdef CONFIG_MAC80211_DEBUGFS 701 INIT_WORK(&local->sta_debugfs_add, sta_info_debugfs_add_work); 702#endif 703} 704 705int sta_info_start(struct ieee80211_local *local) 706{ 707 add_timer(&local->sta_cleanup); 708 return 0; 709} 710 711void sta_info_stop(struct ieee80211_local *local) 712{ 713 del_timer(&local->sta_cleanup); 714#ifdef CONFIG_MAC80211_DEBUGFS 715 /* 716 * Make sure the debugfs adding work isn't pending after this 717 * because we're about to be destroyed. It doesn't matter 718 * whether it ran or not since we're going to flush all STAs 719 * anyway. 720 */ 721 cancel_work_sync(&local->sta_debugfs_add); 722#endif 723 724 sta_info_flush(local, NULL); 725} 726 727/** 728 * sta_info_flush - flush matching STA entries from the STA table 729 * 730 * Returns the number of removed STA entries. 731 * 732 * @local: local interface data 733 * @sdata: matching rule for the net device (sta->dev) or %NULL to match all STAs 734 */ 735int sta_info_flush(struct ieee80211_local *local, 736 struct ieee80211_sub_if_data *sdata) 737{ 738 struct sta_info *sta, *tmp; 739 LIST_HEAD(tmp_list); 740 int ret = 0; 741 unsigned long flags; 742 743 might_sleep(); 744 745 spin_lock_irqsave(&local->sta_lock, flags); 746 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) { 747 if (!sdata || sdata == sta->sdata) { 748 __sta_info_unlink(&sta); 749 if (sta) { 750 list_add_tail(&sta->list, &tmp_list); 751 ret++; 752 } 753 } 754 } 755 spin_unlock_irqrestore(&local->sta_lock, flags); 756 757 list_for_each_entry_safe(sta, tmp, &tmp_list, list) 758 sta_info_destroy(sta); 759 760 return ret; 761} 762 763void ieee80211_sta_expire(struct ieee80211_sub_if_data *sdata, 764 unsigned long exp_time) 765{ 766 struct ieee80211_local *local = sdata->local; 767 struct sta_info *sta, *tmp; 768 LIST_HEAD(tmp_list); 769 unsigned long flags; 770 771 spin_lock_irqsave(&local->sta_lock, flags); 772 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) 773 if (time_after(jiffies, sta->last_rx + exp_time)) { 774#ifdef CONFIG_MAC80211_IBSS_DEBUG 775 printk(KERN_DEBUG "%s: expiring inactive STA %pM\n", 776 sdata->dev->name, sta->sta.addr); 777#endif 778 __sta_info_unlink(&sta); 779 if (sta) 780 list_add(&sta->list, &tmp_list); 781 } 782 spin_unlock_irqrestore(&local->sta_lock, flags); 783 784 list_for_each_entry_safe(sta, tmp, &tmp_list, list) 785 sta_info_destroy(sta); 786} 787 788struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_hw *hw, 789 const u8 *addr) 790{ 791 struct sta_info *sta = sta_info_get(hw_to_local(hw), addr); 792 793 if (!sta) 794 return NULL; 795 return &sta->sta; 796} 797EXPORT_SYMBOL(ieee80211_find_sta); 798