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. 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 */
73 static 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 */
98 static 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
112 struct sta_info *sta_info_get(struct ieee80211_local *local, u8 *addr)
113 {
114         return __sta_info_find(local, addr);
115 }
116 EXPORT_SYMBOL(sta_info_get);
117
118 struct 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  */
145 static 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
161 void 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 */
229 static 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
236 struct 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
295 int 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
367 static 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
376 static 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
385 static 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
397 void 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
406 static 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
418 void 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  */
431 static 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  */
441 static 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
457 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
531 void 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
541 static 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
562 static 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
597 static 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
613 static 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
647 void __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
666 static 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
676 void 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
693 int sta_info_start(struct ieee80211_local *local)
694 {
695         add_timer(&local->sta_cleanup);
696         return 0;
697 }
698
699 void 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  */
718 int 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  */
757 void 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 }