Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / net / mac80211 / sta_info.c
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.
40  *
41  * Because there are debugfs entries for each station, and adding those
42  * must be able to sleep, it is also possible to "pin" a station entry,
43  * that means it can be removed from the hash table but not be freed.
44  * See the comment in __sta_info_unlink() for more information.
45  *
46  * In order to remove a STA info structure, the caller needs to first
47  * unlink it (sta_info_unlink()) from the list and hash tables and
48  * then wait for an RCU synchronisation before it can be freed. Due to
49  * the pinning and the possibility of multiple callers trying to remove
50  * the same STA info at the same time, sta_info_unlink() can clear the
51  * STA info pointer it is passed to indicate that the STA info is owned
52  * by somebody else now.
53  *
54  * If sta_info_unlink() did not clear the pointer then the caller owns
55  * the STA info structure now and is responsible of destroying it with
56  * a call to sta_info_destroy(), not before RCU synchronisation, of
57  * course. Note that sta_info_destroy() must be protected by the RTNL.
58  *
59  * In all other cases, there is no concept of ownership on a STA entry,
60  * each structure is owned by the global hash table/list until it is
61  * removed. All users of the structure need to be RCU protected so that
62  * the structure won't be freed before they are done using it.
63  */
64
65 /* Caller must hold local->sta_lock */
66 static int sta_info_hash_del(struct ieee80211_local *local,
67                              struct sta_info *sta)
68 {
69         struct sta_info *s;
70
71         s = local->sta_hash[STA_HASH(sta->addr)];
72         if (!s)
73                 return -ENOENT;
74         if (s == sta) {
75                 rcu_assign_pointer(local->sta_hash[STA_HASH(sta->addr)],
76                                    s->hnext);
77                 return 0;
78         }
79
80         while (s->hnext && s->hnext != sta)
81                 s = s->hnext;
82         if (s->hnext) {
83                 rcu_assign_pointer(s->hnext, sta->hnext);
84                 return 0;
85         }
86
87         return -ENOENT;
88 }
89
90 /* protected by RCU */
91 static struct sta_info *__sta_info_find(struct ieee80211_local *local,
92                                         u8 *addr)
93 {
94         struct sta_info *sta;
95
96         sta = rcu_dereference(local->sta_hash[STA_HASH(addr)]);
97         while (sta) {
98                 if (compare_ether_addr(sta->addr, addr) == 0)
99                         break;
100                 sta = rcu_dereference(sta->hnext);
101         }
102         return sta;
103 }
104
105 struct sta_info *sta_info_get(struct ieee80211_local *local, u8 *addr)
106 {
107         return __sta_info_find(local, addr);
108 }
109 EXPORT_SYMBOL(sta_info_get);
110
111 struct sta_info *sta_info_get_by_idx(struct ieee80211_local *local, int idx,
112                                      struct net_device *dev)
113 {
114         struct sta_info *sta;
115         int i = 0;
116
117         list_for_each_entry_rcu(sta, &local->sta_list, list) {
118                 if (dev && dev != sta->sdata->dev)
119                         continue;
120                 if (i < idx) {
121                         ++i;
122                         continue;
123                 }
124                 return sta;
125         }
126
127         return NULL;
128 }
129
130 void 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 */
189 static 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
196 struct 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 #ifdef CONFIG_MAC80211_MESH
252         sta->plink_state = PLINK_LISTEN;
253         spin_lock_init(&sta->plink_lock);
254         init_timer(&sta->plink_timer);
255 #endif
256
257         return sta;
258 }
259
260 int sta_info_insert(struct sta_info *sta)
261 {
262         struct ieee80211_local *local = sta->local;
263         struct ieee80211_sub_if_data *sdata = sta->sdata;
264         unsigned long flags;
265         DECLARE_MAC_BUF(mac);
266
267         /*
268          * Can't be a WARN_ON because it can be triggered through a race:
269          * something inserts a STA (on one CPU) without holding the RTNL
270          * and another CPU turns off the net device.
271          */
272         if (unlikely(!netif_running(sdata->dev)))
273                 return -ENETDOWN;
274
275         if (WARN_ON(compare_ether_addr(sta->addr, sdata->dev->dev_addr) == 0))
276                 return -EINVAL;
277
278         if (WARN_ON(is_multicast_ether_addr(sta->addr)))
279                 return -EINVAL;
280
281         spin_lock_irqsave(&local->sta_lock, flags);
282         /* check if STA exists already */
283         if (__sta_info_find(local, sta->addr)) {
284                 spin_unlock_irqrestore(&local->sta_lock, flags);
285                 return -EEXIST;
286         }
287         list_add(&sta->list, &local->sta_list);
288         local->num_sta++;
289         sta_info_hash_add(local, sta);
290
291         /* notify driver */
292         if (local->ops->sta_notify) {
293                 if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN)
294                         sdata = sdata->u.vlan.ap;
295
296                 local->ops->sta_notify(local_to_hw(local), &sdata->vif,
297                                        STA_NOTIFY_ADD, sta->addr);
298         }
299
300 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
301         printk(KERN_DEBUG "%s: Inserted STA %s\n",
302                wiphy_name(local->hw.wiphy), print_mac(mac, sta->addr));
303 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
304
305         spin_unlock_irqrestore(&local->sta_lock, flags);
306
307 #ifdef CONFIG_MAC80211_DEBUGFS
308         /* debugfs entry adding might sleep, so schedule process
309          * context task for adding entry for STAs that do not yet
310          * have one. */
311         queue_work(local->hw.workqueue, &local->sta_debugfs_add);
312 #endif
313
314         if (ieee80211_vif_is_mesh(&sdata->vif))
315                 mesh_accept_plinks_update(sdata);
316
317         return 0;
318 }
319
320 static inline void __bss_tim_set(struct ieee80211_if_ap *bss, u16 aid)
321 {
322         /*
323          * This format has been mandated by the IEEE specifications,
324          * so this line may not be changed to use the __set_bit() format.
325          */
326         bss->tim[aid / 8] |= (1 << (aid % 8));
327 }
328
329 static inline void __bss_tim_clear(struct ieee80211_if_ap *bss, u16 aid)
330 {
331         /*
332          * This format has been mandated by the IEEE specifications,
333          * so this line may not be changed to use the __clear_bit() format.
334          */
335         bss->tim[aid / 8] &= ~(1 << (aid % 8));
336 }
337
338 static void __sta_info_set_tim_bit(struct ieee80211_if_ap *bss,
339                                    struct sta_info *sta)
340 {
341         if (bss)
342                 __bss_tim_set(bss, sta->aid);
343         if (sta->local->ops->set_tim) {
344                 sta->local->tim_in_locked_section = true;
345                 sta->local->ops->set_tim(local_to_hw(sta->local), sta->aid, 1);
346                 sta->local->tim_in_locked_section = false;
347         }
348 }
349
350 void sta_info_set_tim_bit(struct sta_info *sta)
351 {
352         unsigned long flags;
353
354         spin_lock_irqsave(&sta->local->sta_lock, flags);
355         __sta_info_set_tim_bit(sta->sdata->bss, sta);
356         spin_unlock_irqrestore(&sta->local->sta_lock, flags);
357 }
358
359 static void __sta_info_clear_tim_bit(struct ieee80211_if_ap *bss,
360                                      struct sta_info *sta)
361 {
362         if (bss)
363                 __bss_tim_clear(bss, sta->aid);
364         if (sta->local->ops->set_tim) {
365                 sta->local->tim_in_locked_section = true;
366                 sta->local->ops->set_tim(local_to_hw(sta->local), sta->aid, 0);
367                 sta->local->tim_in_locked_section = false;
368         }
369 }
370
371 void sta_info_clear_tim_bit(struct sta_info *sta)
372 {
373         unsigned long flags;
374
375         spin_lock_irqsave(&sta->local->sta_lock, flags);
376         __sta_info_clear_tim_bit(sta->sdata->bss, sta);
377         spin_unlock_irqrestore(&sta->local->sta_lock, flags);
378 }
379
380 /*
381  * See comment in __sta_info_unlink,
382  * caller must hold local->sta_lock.
383  */
384 static void __sta_info_pin(struct sta_info *sta)
385 {
386         WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_NORMAL);
387         sta->pin_status = STA_INFO_PIN_STAT_PINNED;
388 }
389
390 /*
391  * See comment in __sta_info_unlink, returns sta if it
392  * needs to be destroyed.
393  */
394 static struct sta_info *__sta_info_unpin(struct sta_info *sta)
395 {
396         struct sta_info *ret = NULL;
397         unsigned long flags;
398
399         spin_lock_irqsave(&sta->local->sta_lock, flags);
400         WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_DESTROY &&
401                 sta->pin_status != STA_INFO_PIN_STAT_PINNED);
402         if (sta->pin_status == STA_INFO_PIN_STAT_DESTROY)
403                 ret = sta;
404         sta->pin_status = STA_INFO_PIN_STAT_NORMAL;
405         spin_unlock_irqrestore(&sta->local->sta_lock, flags);
406
407         return ret;
408 }
409
410 static void __sta_info_unlink(struct sta_info **sta)
411 {
412         struct ieee80211_local *local = (*sta)->local;
413         struct ieee80211_sub_if_data *sdata = (*sta)->sdata;
414 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
415         DECLARE_MAC_BUF(mbuf);
416 #endif
417         /*
418          * pull caller's reference if we're already gone.
419          */
420         if (sta_info_hash_del(local, *sta)) {
421                 *sta = NULL;
422                 return;
423         }
424
425         /*
426          * Also pull caller's reference if the STA is pinned by the
427          * task that is adding the debugfs entries. In that case, we
428          * leave the STA "to be freed".
429          *
430          * The rules are not trivial, but not too complex either:
431          *  (1) pin_status is only modified under the sta_lock
432          *  (2) sta_info_debugfs_add_work() will set the status
433          *      to PINNED when it found an item that needs a new
434          *      debugfs directory created. In that case, that item
435          *      must not be freed although all *RCU* users are done
436          *      with it. Hence, we tell the caller of _unlink()
437          *      that the item is already gone (as can happen when
438          *      two tasks try to unlink/destroy at the same time)
439          *  (3) We set the pin_status to DESTROY here when we
440          *      find such an item.
441          *  (4) sta_info_debugfs_add_work() will reset the pin_status
442          *      from PINNED to NORMAL when it is done with the item,
443          *      but will check for DESTROY before resetting it in
444          *      which case it will free the item.
445          */
446         if ((*sta)->pin_status == STA_INFO_PIN_STAT_PINNED) {
447                 (*sta)->pin_status = STA_INFO_PIN_STAT_DESTROY;
448                 *sta = NULL;
449                 return;
450         }
451
452         list_del(&(*sta)->list);
453
454         if ((*sta)->flags & WLAN_STA_PS) {
455                 (*sta)->flags &= ~WLAN_STA_PS;
456                 if (sdata->bss)
457                         atomic_dec(&sdata->bss->num_sta_ps);
458                 __sta_info_clear_tim_bit(sdata->bss, *sta);
459         }
460
461         local->num_sta--;
462
463         if (local->ops->sta_notify) {
464                 if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN)
465                         sdata = sdata->u.vlan.ap;
466
467                 local->ops->sta_notify(local_to_hw(local), &sdata->vif,
468                                        STA_NOTIFY_REMOVE, (*sta)->addr);
469         }
470
471         if (ieee80211_vif_is_mesh(&sdata->vif)) {
472                 mesh_accept_plinks_update(sdata);
473 #ifdef CONFIG_MAC80211_MESH
474                 del_timer(&(*sta)->plink_timer);
475 #endif
476         }
477
478 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
479         printk(KERN_DEBUG "%s: Removed STA %s\n",
480                wiphy_name(local->hw.wiphy), print_mac(mbuf, (*sta)->addr));
481 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
482 }
483
484 void sta_info_unlink(struct sta_info **sta)
485 {
486         struct ieee80211_local *local = (*sta)->local;
487         unsigned long flags;
488
489         spin_lock_irqsave(&local->sta_lock, flags);
490         __sta_info_unlink(sta);
491         spin_unlock_irqrestore(&local->sta_lock, flags);
492 }
493
494 static inline int sta_info_buffer_expired(struct ieee80211_local *local,
495                                           struct sta_info *sta,
496                                           struct sk_buff *skb)
497 {
498         struct ieee80211_tx_packet_data *pkt_data;
499         int timeout;
500
501         if (!skb)
502                 return 0;
503
504         pkt_data = (struct ieee80211_tx_packet_data *) skb->cb;
505
506         /* Timeout: (2 * listen_interval * beacon_int * 1024 / 1000000) sec */
507         timeout = (sta->listen_interval * local->hw.conf.beacon_int * 32 /
508                    15625) * HZ;
509         if (timeout < STA_TX_BUFFER_EXPIRE)
510                 timeout = STA_TX_BUFFER_EXPIRE;
511         return time_after(jiffies, pkt_data->jiffies + timeout);
512 }
513
514
515 static void sta_info_cleanup_expire_buffered(struct ieee80211_local *local,
516                                              struct sta_info *sta)
517 {
518         unsigned long flags;
519         struct sk_buff *skb;
520         struct ieee80211_sub_if_data *sdata;
521         DECLARE_MAC_BUF(mac);
522
523         if (skb_queue_empty(&sta->ps_tx_buf))
524                 return;
525
526         for (;;) {
527                 spin_lock_irqsave(&sta->ps_tx_buf.lock, flags);
528                 skb = skb_peek(&sta->ps_tx_buf);
529                 if (sta_info_buffer_expired(local, sta, skb))
530                         skb = __skb_dequeue(&sta->ps_tx_buf);
531                 else
532                         skb = NULL;
533                 spin_unlock_irqrestore(&sta->ps_tx_buf.lock, flags);
534
535                 if (!skb)
536                         break;
537
538                 sdata = sta->sdata;
539                 local->total_ps_buffered--;
540                 printk(KERN_DEBUG "Buffered frame expired (STA "
541                        "%s)\n", print_mac(mac, sta->addr));
542                 dev_kfree_skb(skb);
543
544                 if (skb_queue_empty(&sta->ps_tx_buf))
545                         sta_info_clear_tim_bit(sta);
546         }
547 }
548
549
550 static void sta_info_cleanup(unsigned long data)
551 {
552         struct ieee80211_local *local = (struct ieee80211_local *) data;
553         struct sta_info *sta;
554
555         rcu_read_lock();
556         list_for_each_entry_rcu(sta, &local->sta_list, list)
557                 sta_info_cleanup_expire_buffered(local, sta);
558         rcu_read_unlock();
559
560         local->sta_cleanup.expires =
561                 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL);
562         add_timer(&local->sta_cleanup);
563 }
564
565 #ifdef CONFIG_MAC80211_DEBUGFS
566 static void sta_info_debugfs_add_work(struct work_struct *work)
567 {
568         struct ieee80211_local *local =
569                 container_of(work, struct ieee80211_local, sta_debugfs_add);
570         struct sta_info *sta, *tmp;
571         unsigned long flags;
572
573         while (1) {
574                 sta = NULL;
575
576                 spin_lock_irqsave(&local->sta_lock, flags);
577                 list_for_each_entry(tmp, &local->sta_list, list) {
578                         if (!tmp->debugfs.dir) {
579                                 sta = tmp;
580                                 __sta_info_pin(sta);
581                                 break;
582                         }
583                 }
584                 spin_unlock_irqrestore(&local->sta_lock, flags);
585
586                 if (!sta)
587                         break;
588
589                 ieee80211_sta_debugfs_add(sta);
590                 rate_control_add_sta_debugfs(sta);
591
592                 sta = __sta_info_unpin(sta);
593
594                 if (sta) {
595                         synchronize_rcu();
596                         sta_info_destroy(sta);
597                 }
598         }
599 }
600 #endif
601
602 void sta_info_init(struct ieee80211_local *local)
603 {
604         spin_lock_init(&local->sta_lock);
605         INIT_LIST_HEAD(&local->sta_list);
606
607         setup_timer(&local->sta_cleanup, sta_info_cleanup,
608                     (unsigned long)local);
609         local->sta_cleanup.expires =
610                 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL);
611
612 #ifdef CONFIG_MAC80211_DEBUGFS
613         INIT_WORK(&local->sta_debugfs_add, sta_info_debugfs_add_work);
614 #endif
615 }
616
617 int sta_info_start(struct ieee80211_local *local)
618 {
619         add_timer(&local->sta_cleanup);
620         return 0;
621 }
622
623 void sta_info_stop(struct ieee80211_local *local)
624 {
625         del_timer(&local->sta_cleanup);
626         sta_info_flush(local, NULL);
627 }
628
629 /**
630  * sta_info_flush - flush matching STA entries from the STA table
631  *
632  * Returns the number of removed STA entries.
633  *
634  * @local: local interface data
635  * @sdata: matching rule for the net device (sta->dev) or %NULL to match all STAs
636  */
637 int sta_info_flush(struct ieee80211_local *local,
638                     struct ieee80211_sub_if_data *sdata)
639 {
640         struct sta_info *sta, *tmp;
641         LIST_HEAD(tmp_list);
642         int ret = 0;
643         unsigned long flags;
644
645         might_sleep();
646
647         spin_lock_irqsave(&local->sta_lock, flags);
648         list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
649                 if (!sdata || sdata == sta->sdata) {
650                         __sta_info_unlink(&sta);
651                         if (sta) {
652                                 list_add_tail(&sta->list, &tmp_list);
653                                 ret++;
654                         }
655                 }
656         }
657         spin_unlock_irqrestore(&local->sta_lock, flags);
658
659         synchronize_rcu();
660
661         list_for_each_entry_safe(sta, tmp, &tmp_list, list)
662                 sta_info_destroy(sta);
663
664         return ret;
665 }