sta_info.c revision dbbea6713d6096cd1c411cb453a6b71292c78b33
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() or 35 * mesh_plink_alloc(), the caller owns that structure. It must then either 36 * destroy it using sta_info_destroy() (which is pretty useless) or insert 37 * it into the hash table using sta_info_insert() which demotes the reference 38 * from ownership to a regular RCU-protected reference; if the function 39 * is called without protection by an RCU critical section the reference 40 * is instantly invalidated. 41 * 42 * Because there are debugfs entries for each station, and adding those 43 * must be able to sleep, it is also possible to "pin" a station entry, 44 * that means it can be removed from the hash table but not be freed. 45 * See the comment in __sta_info_unlink() for more information. 46 * 47 * In order to remove a STA info structure, the caller needs to first 48 * unlink it (sta_info_unlink()) from the list and hash tables and 49 * then wait for an RCU synchronisation before it can be freed. Due to 50 * the pinning and the possibility of multiple callers trying to remove 51 * the same STA info at the same time, sta_info_unlink() can clear the 52 * STA info pointer it is passed to indicate that the STA info is owned 53 * by somebody else now. 54 * 55 * If sta_info_unlink() did not clear the pointer then the caller owns 56 * the STA info structure now and is responsible of destroying it with 57 * a call to sta_info_destroy(), not before RCU synchronisation, of 58 * course. Note that sta_info_destroy() must be protected by the RTNL. 59 * 60 * In all other cases, there is no concept of ownership on a STA entry, 61 * each structure is owned by the global hash table/list until it is 62 * removed. All users of the structure need to be RCU protected so that 63 * the structure won't be freed before they are done using it. 64 */ 65 66/* Caller must hold local->sta_lock */ 67static int sta_info_hash_del(struct ieee80211_local *local, 68 struct sta_info *sta) 69{ 70 struct sta_info *s; 71 72 s = local->sta_hash[STA_HASH(sta->addr)]; 73 if (!s) 74 return -ENOENT; 75 if (s == sta) { 76 rcu_assign_pointer(local->sta_hash[STA_HASH(sta->addr)], 77 s->hnext); 78 return 0; 79 } 80 81 while (s->hnext && s->hnext != sta) 82 s = s->hnext; 83 if (s->hnext) { 84 rcu_assign_pointer(s->hnext, sta->hnext); 85 return 0; 86 } 87 88 return -ENOENT; 89} 90 91/* protected by RCU */ 92static struct sta_info *__sta_info_find(struct ieee80211_local *local, 93 u8 *addr) 94{ 95 struct sta_info *sta; 96 97 sta = rcu_dereference(local->sta_hash[STA_HASH(addr)]); 98 while (sta) { 99 if (compare_ether_addr(sta->addr, addr) == 0) 100 break; 101 sta = rcu_dereference(sta->hnext); 102 } 103 return sta; 104} 105 106struct sta_info *sta_info_get(struct ieee80211_local *local, u8 *addr) 107{ 108 return __sta_info_find(local, addr); 109} 110EXPORT_SYMBOL(sta_info_get); 111 112struct sta_info *sta_info_get_by_idx(struct ieee80211_local *local, int idx, 113 struct net_device *dev) 114{ 115 struct sta_info *sta; 116 int i = 0; 117 118 list_for_each_entry_rcu(sta, &local->sta_list, list) { 119 if (i < idx) { 120 ++i; 121 continue; 122 } else if (!dev || dev == sta->sdata->dev) { 123 return sta; 124 } 125 } 126 127 return NULL; 128} 129 130void sta_info_destroy(struct sta_info *sta) 131{ 132 struct ieee80211_local *local = sta->local; 133 struct sk_buff *skb; 134 int i; 135 DECLARE_MAC_BUF(mbuf); 136 137 if (!sta) 138 return; 139 140 ASSERT_RTNL(); 141 might_sleep(); 142 143 rate_control_remove_sta_debugfs(sta); 144 ieee80211_sta_debugfs_remove(sta); 145 146#ifdef CONFIG_MAC80211_MESH 147 if (ieee80211_vif_is_mesh(&sta->sdata->vif)) 148 mesh_plink_deactivate(sta); 149#endif 150 151 /* 152 * NOTE: This will call synchronize_rcu() internally to 153 * make sure no key references can be in use. We rely on 154 * that here for the mesh code! 155 */ 156 ieee80211_key_free(sta->key); 157 WARN_ON(sta->key); 158 159#ifdef CONFIG_MAC80211_MESH 160 if (ieee80211_vif_is_mesh(&sta->sdata->vif)) 161 del_timer_sync(&sta->plink_timer); 162#endif 163 164 while ((skb = skb_dequeue(&sta->ps_tx_buf)) != NULL) { 165 local->total_ps_buffered--; 166 dev_kfree_skb_any(skb); 167 } 168 169 while ((skb = skb_dequeue(&sta->tx_filtered)) != NULL) 170 dev_kfree_skb_any(skb); 171 172 for (i = 0; i < STA_TID_NUM; i++) { 173 del_timer_sync(&sta->ampdu_mlme.tid_rx[i].session_timer); 174 del_timer_sync(&sta->ampdu_mlme.tid_tx[i].addba_resp_timer); 175 } 176 rate_control_free_sta(sta->rate_ctrl, sta->rate_ctrl_priv); 177 rate_control_put(sta->rate_ctrl); 178 179#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 180 printk(KERN_DEBUG "%s: Destroyed STA %s\n", 181 wiphy_name(local->hw.wiphy), print_mac(mbuf, sta->addr)); 182#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 183 184 kfree(sta); 185} 186 187 188/* Caller must hold local->sta_lock */ 189static void sta_info_hash_add(struct ieee80211_local *local, 190 struct sta_info *sta) 191{ 192 sta->hnext = local->sta_hash[STA_HASH(sta->addr)]; 193 rcu_assign_pointer(local->sta_hash[STA_HASH(sta->addr)], sta); 194} 195 196struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata, 197 u8 *addr, gfp_t gfp) 198{ 199 struct ieee80211_local *local = sdata->local; 200 struct sta_info *sta; 201 int i; 202 DECLARE_MAC_BUF(mbuf); 203 204 sta = kzalloc(sizeof(*sta), gfp); 205 if (!sta) 206 return NULL; 207 208 memcpy(sta->addr, addr, ETH_ALEN); 209 sta->local = local; 210 sta->sdata = sdata; 211 212 sta->rate_ctrl = rate_control_get(local->rate_ctrl); 213 sta->rate_ctrl_priv = rate_control_alloc_sta(sta->rate_ctrl, 214 gfp); 215 if (!sta->rate_ctrl_priv) { 216 rate_control_put(sta->rate_ctrl); 217 kfree(sta); 218 return NULL; 219 } 220 221 spin_lock_init(&sta->ampdu_mlme.ampdu_rx); 222 spin_lock_init(&sta->ampdu_mlme.ampdu_tx); 223 for (i = 0; i < STA_TID_NUM; i++) { 224 /* timer_to_tid must be initialized with identity mapping to 225 * enable session_timer's data differentiation. refer to 226 * sta_rx_agg_session_timer_expired for useage */ 227 sta->timer_to_tid[i] = i; 228 /* tid to tx queue: initialize according to HW (0 is valid) */ 229 sta->tid_to_tx_q[i] = local->hw.queues; 230 /* rx timers */ 231 sta->ampdu_mlme.tid_rx[i].session_timer.function = 232 sta_rx_agg_session_timer_expired; 233 sta->ampdu_mlme.tid_rx[i].session_timer.data = 234 (unsigned long)&sta->timer_to_tid[i]; 235 init_timer(&sta->ampdu_mlme.tid_rx[i].session_timer); 236 /* tx timers */ 237 sta->ampdu_mlme.tid_tx[i].addba_resp_timer.function = 238 sta_addba_resp_timer_expired; 239 sta->ampdu_mlme.tid_tx[i].addba_resp_timer.data = 240 (unsigned long)&sta->timer_to_tid[i]; 241 init_timer(&sta->ampdu_mlme.tid_tx[i].addba_resp_timer); 242 } 243 skb_queue_head_init(&sta->ps_tx_buf); 244 skb_queue_head_init(&sta->tx_filtered); 245 246#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 247 printk(KERN_DEBUG "%s: Allocated STA %s\n", 248 wiphy_name(local->hw.wiphy), print_mac(mbuf, sta->addr)); 249#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 250 251 return sta; 252} 253 254int sta_info_insert(struct sta_info *sta) 255{ 256 struct ieee80211_local *local = sta->local; 257 struct ieee80211_sub_if_data *sdata = sta->sdata; 258 unsigned long flags; 259 DECLARE_MAC_BUF(mac); 260 261 WARN_ON(!netif_running(sdata->dev)); 262 263 spin_lock_irqsave(&local->sta_lock, flags); 264 /* check if STA exists already */ 265 if (__sta_info_find(local, sta->addr)) { 266 spin_unlock_irqrestore(&local->sta_lock, flags); 267 return -EEXIST; 268 } 269 list_add(&sta->list, &local->sta_list); 270 local->num_sta++; 271 sta_info_hash_add(local, sta); 272 273 /* notify driver */ 274 if (local->ops->sta_notify) { 275 if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN) 276 sdata = sdata->u.vlan.ap; 277 278 local->ops->sta_notify(local_to_hw(local), &sdata->vif, 279 STA_NOTIFY_ADD, sta->addr); 280 } 281 282#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 283 printk(KERN_DEBUG "%s: Inserted STA %s\n", 284 wiphy_name(local->hw.wiphy), print_mac(mac, sta->addr)); 285#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 286 287 spin_unlock_irqrestore(&local->sta_lock, flags); 288 289#ifdef CONFIG_MAC80211_DEBUGFS 290 /* debugfs entry adding might sleep, so schedule process 291 * context task for adding entry for STAs that do not yet 292 * have one. */ 293 queue_work(local->hw.workqueue, &local->sta_debugfs_add); 294#endif 295 296 if (ieee80211_vif_is_mesh(&sdata->vif)) 297 mesh_accept_plinks_update(sdata); 298 299 return 0; 300} 301 302static inline void __bss_tim_set(struct ieee80211_if_ap *bss, u16 aid) 303{ 304 /* 305 * This format has been mandated by the IEEE specifications, 306 * so this line may not be changed to use the __set_bit() format. 307 */ 308 bss->tim[aid / 8] |= (1 << (aid % 8)); 309} 310 311static inline void __bss_tim_clear(struct ieee80211_if_ap *bss, u16 aid) 312{ 313 /* 314 * This format has been mandated by the IEEE specifications, 315 * so this line may not be changed to use the __clear_bit() format. 316 */ 317 bss->tim[aid / 8] &= ~(1 << (aid % 8)); 318} 319 320static void __sta_info_set_tim_bit(struct ieee80211_if_ap *bss, 321 struct sta_info *sta) 322{ 323 if (bss) 324 __bss_tim_set(bss, sta->aid); 325 if (sta->local->ops->set_tim) { 326 sta->local->tim_in_locked_section = true; 327 sta->local->ops->set_tim(local_to_hw(sta->local), sta->aid, 1); 328 sta->local->tim_in_locked_section = false; 329 } 330} 331 332void sta_info_set_tim_bit(struct sta_info *sta) 333{ 334 unsigned long flags; 335 336 spin_lock_irqsave(&sta->local->sta_lock, flags); 337 __sta_info_set_tim_bit(sta->sdata->bss, sta); 338 spin_unlock_irqrestore(&sta->local->sta_lock, flags); 339} 340 341static void __sta_info_clear_tim_bit(struct ieee80211_if_ap *bss, 342 struct sta_info *sta) 343{ 344 if (bss) 345 __bss_tim_clear(bss, sta->aid); 346 if (sta->local->ops->set_tim) { 347 sta->local->tim_in_locked_section = true; 348 sta->local->ops->set_tim(local_to_hw(sta->local), sta->aid, 0); 349 sta->local->tim_in_locked_section = false; 350 } 351} 352 353void sta_info_clear_tim_bit(struct sta_info *sta) 354{ 355 unsigned long flags; 356 357 spin_lock_irqsave(&sta->local->sta_lock, flags); 358 __sta_info_clear_tim_bit(sta->sdata->bss, sta); 359 spin_unlock_irqrestore(&sta->local->sta_lock, flags); 360} 361 362/* 363 * See comment in __sta_info_unlink, 364 * caller must hold local->sta_lock. 365 */ 366static void __sta_info_pin(struct sta_info *sta) 367{ 368 WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_NORMAL); 369 sta->pin_status = STA_INFO_PIN_STAT_PINNED; 370} 371 372/* 373 * See comment in __sta_info_unlink, returns sta if it 374 * needs to be destroyed. 375 */ 376static struct sta_info *__sta_info_unpin(struct sta_info *sta) 377{ 378 struct sta_info *ret = NULL; 379 unsigned long flags; 380 381 spin_lock_irqsave(&sta->local->sta_lock, flags); 382 WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_DESTROY && 383 sta->pin_status != STA_INFO_PIN_STAT_PINNED); 384 if (sta->pin_status == STA_INFO_PIN_STAT_DESTROY) 385 ret = sta; 386 sta->pin_status = STA_INFO_PIN_STAT_NORMAL; 387 spin_unlock_irqrestore(&sta->local->sta_lock, flags); 388 389 return ret; 390} 391 392static void __sta_info_unlink(struct sta_info **sta) 393{ 394 struct ieee80211_local *local = (*sta)->local; 395 struct ieee80211_sub_if_data *sdata = (*sta)->sdata; 396#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 397 DECLARE_MAC_BUF(mbuf); 398#endif 399 /* 400 * pull caller's reference if we're already gone. 401 */ 402 if (sta_info_hash_del(local, *sta)) { 403 *sta = NULL; 404 return; 405 } 406 407 /* 408 * Also pull caller's reference if the STA is pinned by the 409 * task that is adding the debugfs entries. In that case, we 410 * leave the STA "to be freed". 411 * 412 * The rules are not trivial, but not too complex either: 413 * (1) pin_status is only modified under the sta_lock 414 * (2) sta_info_debugfs_add_work() will set the status 415 * to PINNED when it found an item that needs a new 416 * debugfs directory created. In that case, that item 417 * must not be freed although all *RCU* users are done 418 * with it. Hence, we tell the caller of _unlink() 419 * that the item is already gone (as can happen when 420 * two tasks try to unlink/destroy at the same time) 421 * (3) We set the pin_status to DESTROY here when we 422 * find such an item. 423 * (4) sta_info_debugfs_add_work() will reset the pin_status 424 * from PINNED to NORMAL when it is done with the item, 425 * but will check for DESTROY before resetting it in 426 * which case it will free the item. 427 */ 428 if ((*sta)->pin_status == STA_INFO_PIN_STAT_PINNED) { 429 (*sta)->pin_status = STA_INFO_PIN_STAT_DESTROY; 430 *sta = NULL; 431 return; 432 } 433 434 list_del(&(*sta)->list); 435 436 if ((*sta)->flags & WLAN_STA_PS) { 437 (*sta)->flags &= ~WLAN_STA_PS; 438 if (sdata->bss) 439 atomic_dec(&sdata->bss->num_sta_ps); 440 __sta_info_clear_tim_bit(sdata->bss, *sta); 441 } 442 443 local->num_sta--; 444 445 if (local->ops->sta_notify) { 446 if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN) 447 sdata = sdata->u.vlan.ap; 448 449 local->ops->sta_notify(local_to_hw(local), &sdata->vif, 450 STA_NOTIFY_REMOVE, (*sta)->addr); 451 } 452 453 if (ieee80211_vif_is_mesh(&sdata->vif)) { 454 mesh_accept_plinks_update(sdata); 455#ifdef CONFIG_MAC80211_MESH 456 del_timer(&(*sta)->plink_timer); 457#endif 458 } 459 460#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 461 printk(KERN_DEBUG "%s: Removed STA %s\n", 462 wiphy_name(local->hw.wiphy), print_mac(mbuf, (*sta)->addr)); 463#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 464} 465 466void sta_info_unlink(struct sta_info **sta) 467{ 468 struct ieee80211_local *local = (*sta)->local; 469 unsigned long flags; 470 471 spin_lock_irqsave(&local->sta_lock, flags); 472 __sta_info_unlink(sta); 473 spin_unlock_irqrestore(&local->sta_lock, flags); 474} 475 476static inline int sta_info_buffer_expired(struct ieee80211_local *local, 477 struct sta_info *sta, 478 struct sk_buff *skb) 479{ 480 struct ieee80211_tx_packet_data *pkt_data; 481 int timeout; 482 483 if (!skb) 484 return 0; 485 486 pkt_data = (struct ieee80211_tx_packet_data *) skb->cb; 487 488 /* Timeout: (2 * listen_interval * beacon_int * 1024 / 1000000) sec */ 489 timeout = (sta->listen_interval * local->hw.conf.beacon_int * 32 / 490 15625) * HZ; 491 if (timeout < STA_TX_BUFFER_EXPIRE) 492 timeout = STA_TX_BUFFER_EXPIRE; 493 return time_after(jiffies, pkt_data->jiffies + timeout); 494} 495 496 497static void sta_info_cleanup_expire_buffered(struct ieee80211_local *local, 498 struct sta_info *sta) 499{ 500 unsigned long flags; 501 struct sk_buff *skb; 502 struct ieee80211_sub_if_data *sdata; 503 DECLARE_MAC_BUF(mac); 504 505 if (skb_queue_empty(&sta->ps_tx_buf)) 506 return; 507 508 for (;;) { 509 spin_lock_irqsave(&sta->ps_tx_buf.lock, flags); 510 skb = skb_peek(&sta->ps_tx_buf); 511 if (sta_info_buffer_expired(local, sta, skb)) 512 skb = __skb_dequeue(&sta->ps_tx_buf); 513 else 514 skb = NULL; 515 spin_unlock_irqrestore(&sta->ps_tx_buf.lock, flags); 516 517 if (!skb) 518 break; 519 520 sdata = sta->sdata; 521 local->total_ps_buffered--; 522 printk(KERN_DEBUG "Buffered frame expired (STA " 523 "%s)\n", print_mac(mac, sta->addr)); 524 dev_kfree_skb(skb); 525 526 if (skb_queue_empty(&sta->ps_tx_buf)) 527 sta_info_clear_tim_bit(sta); 528 } 529} 530 531 532static void sta_info_cleanup(unsigned long data) 533{ 534 struct ieee80211_local *local = (struct ieee80211_local *) data; 535 struct sta_info *sta; 536 537 rcu_read_lock(); 538 list_for_each_entry_rcu(sta, &local->sta_list, list) 539 sta_info_cleanup_expire_buffered(local, sta); 540 rcu_read_unlock(); 541 542 local->sta_cleanup.expires = 543 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL); 544 add_timer(&local->sta_cleanup); 545} 546 547#ifdef CONFIG_MAC80211_DEBUGFS 548static void sta_info_debugfs_add_work(struct work_struct *work) 549{ 550 struct ieee80211_local *local = 551 container_of(work, struct ieee80211_local, sta_debugfs_add); 552 struct sta_info *sta, *tmp; 553 unsigned long flags; 554 555 while (1) { 556 sta = NULL; 557 558 spin_lock_irqsave(&local->sta_lock, flags); 559 list_for_each_entry(tmp, &local->sta_list, list) { 560 if (!tmp->debugfs.dir) { 561 sta = tmp; 562 __sta_info_pin(sta); 563 break; 564 } 565 } 566 spin_unlock_irqrestore(&local->sta_lock, flags); 567 568 if (!sta) 569 break; 570 571 ieee80211_sta_debugfs_add(sta); 572 rate_control_add_sta_debugfs(sta); 573 574 sta = __sta_info_unpin(sta); 575 576 if (sta) { 577 synchronize_rcu(); 578 sta_info_destroy(sta); 579 } 580 } 581} 582#endif 583 584void sta_info_init(struct ieee80211_local *local) 585{ 586 spin_lock_init(&local->sta_lock); 587 INIT_LIST_HEAD(&local->sta_list); 588 589 setup_timer(&local->sta_cleanup, sta_info_cleanup, 590 (unsigned long)local); 591 local->sta_cleanup.expires = 592 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL); 593 594#ifdef CONFIG_MAC80211_DEBUGFS 595 INIT_WORK(&local->sta_debugfs_add, sta_info_debugfs_add_work); 596#endif 597} 598 599int sta_info_start(struct ieee80211_local *local) 600{ 601 add_timer(&local->sta_cleanup); 602 return 0; 603} 604 605void sta_info_stop(struct ieee80211_local *local) 606{ 607 del_timer(&local->sta_cleanup); 608 sta_info_flush(local, NULL); 609} 610 611/** 612 * sta_info_flush - flush matching STA entries from the STA table 613 * 614 * Returns the number of removed STA entries. 615 * 616 * @local: local interface data 617 * @sdata: matching rule for the net device (sta->dev) or %NULL to match all STAs 618 */ 619int sta_info_flush(struct ieee80211_local *local, 620 struct ieee80211_sub_if_data *sdata) 621{ 622 struct sta_info *sta, *tmp; 623 LIST_HEAD(tmp_list); 624 int ret = 0; 625 unsigned long flags; 626 627 might_sleep(); 628 629 spin_lock_irqsave(&local->sta_lock, flags); 630 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) { 631 if (!sdata || sdata == sta->sdata) { 632 __sta_info_unlink(&sta); 633 if (sta) { 634 list_add_tail(&sta->list, &tmp_list); 635 ret++; 636 } 637 } 638 } 639 spin_unlock_irqrestore(&local->sta_lock, flags); 640 641 synchronize_rcu(); 642 643 list_for_each_entry_safe(sta, tmp, &tmp_list, list) 644 sta_info_destroy(sta); 645 646 return ret; 647} 648