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