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