mac80211: notify mac from low level driver (iwlwifi)
[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         schedule_work(&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) STAs may only be pinned under the RTNL so that
480          *      sta_info_flush() is guaranteed to actually destroy
481          *      all STAs that are active for a given interface, this
482          *      is required for correctness because otherwise we
483          *      could notify a driver that an interface is going
484          *      away and only after that (!) notify it about a STA
485          *      on that interface going away.
486          *  (3) sta_info_debugfs_add_work() will set the status
487          *      to PINNED when it found an item that needs a new
488          *      debugfs directory created. In that case, that item
489          *      must not be freed although all *RCU* users are done
490          *      with it. Hence, we tell the caller of _unlink()
491          *      that the item is already gone (as can happen when
492          *      two tasks try to unlink/destroy at the same time)
493          *  (4) We set the pin_status to DESTROY here when we
494          *      find such an item.
495          *  (5) sta_info_debugfs_add_work() will reset the pin_status
496          *      from PINNED to NORMAL when it is done with the item,
497          *      but will check for DESTROY before resetting it in
498          *      which case it will free the item.
499          */
500         if ((*sta)->pin_status == STA_INFO_PIN_STAT_PINNED) {
501                 (*sta)->pin_status = STA_INFO_PIN_STAT_DESTROY;
502                 *sta = NULL;
503                 return;
504         }
505
506         list_del(&(*sta)->list);
507
508         if ((*sta)->flags & WLAN_STA_PS) {
509                 (*sta)->flags &= ~WLAN_STA_PS;
510                 if (sdata->bss)
511                         atomic_dec(&sdata->bss->num_sta_ps);
512                 __sta_info_clear_tim_bit(sdata->bss, *sta);
513         }
514
515         local->num_sta--;
516
517         if (local->ops->sta_notify) {
518                 if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN)
519                         sdata = sdata->u.vlan.ap;
520
521                 local->ops->sta_notify(local_to_hw(local), &sdata->vif,
522                                        STA_NOTIFY_REMOVE, (*sta)->addr);
523         }
524
525         if (ieee80211_vif_is_mesh(&sdata->vif)) {
526                 mesh_accept_plinks_update(sdata);
527 #ifdef CONFIG_MAC80211_MESH
528                 del_timer(&(*sta)->plink_timer);
529 #endif
530         }
531
532 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
533         printk(KERN_DEBUG "%s: Removed STA %s\n",
534                wiphy_name(local->hw.wiphy), print_mac(mbuf, (*sta)->addr));
535 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
536 }
537
538 void sta_info_unlink(struct sta_info **sta)
539 {
540         struct ieee80211_local *local = (*sta)->local;
541         unsigned long flags;
542
543         spin_lock_irqsave(&local->sta_lock, flags);
544         __sta_info_unlink(sta);
545         spin_unlock_irqrestore(&local->sta_lock, flags);
546 }
547
548 static inline int sta_info_buffer_expired(struct ieee80211_local *local,
549                                           struct sta_info *sta,
550                                           struct sk_buff *skb)
551 {
552         struct ieee80211_tx_packet_data *pkt_data;
553         int timeout;
554
555         if (!skb)
556                 return 0;
557
558         pkt_data = (struct ieee80211_tx_packet_data *) skb->cb;
559
560         /* Timeout: (2 * listen_interval * beacon_int * 1024 / 1000000) sec */
561         timeout = (sta->listen_interval * local->hw.conf.beacon_int * 32 /
562                    15625) * HZ;
563         if (timeout < STA_TX_BUFFER_EXPIRE)
564                 timeout = STA_TX_BUFFER_EXPIRE;
565         return time_after(jiffies, pkt_data->jiffies + timeout);
566 }
567
568
569 static void sta_info_cleanup_expire_buffered(struct ieee80211_local *local,
570                                              struct sta_info *sta)
571 {
572         unsigned long flags;
573         struct sk_buff *skb;
574         struct ieee80211_sub_if_data *sdata;
575         DECLARE_MAC_BUF(mac);
576
577         if (skb_queue_empty(&sta->ps_tx_buf))
578                 return;
579
580         for (;;) {
581                 spin_lock_irqsave(&sta->ps_tx_buf.lock, flags);
582                 skb = skb_peek(&sta->ps_tx_buf);
583                 if (sta_info_buffer_expired(local, sta, skb))
584                         skb = __skb_dequeue(&sta->ps_tx_buf);
585                 else
586                         skb = NULL;
587                 spin_unlock_irqrestore(&sta->ps_tx_buf.lock, flags);
588
589                 if (!skb)
590                         break;
591
592                 sdata = sta->sdata;
593                 local->total_ps_buffered--;
594                 printk(KERN_DEBUG "Buffered frame expired (STA "
595                        "%s)\n", print_mac(mac, sta->addr));
596                 dev_kfree_skb(skb);
597
598                 if (skb_queue_empty(&sta->ps_tx_buf))
599                         sta_info_clear_tim_bit(sta);
600         }
601 }
602
603
604 static void sta_info_cleanup(unsigned long data)
605 {
606         struct ieee80211_local *local = (struct ieee80211_local *) data;
607         struct sta_info *sta;
608
609         rcu_read_lock();
610         list_for_each_entry_rcu(sta, &local->sta_list, list)
611                 sta_info_cleanup_expire_buffered(local, sta);
612         rcu_read_unlock();
613
614         local->sta_cleanup.expires =
615                 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL);
616         add_timer(&local->sta_cleanup);
617 }
618
619 #ifdef CONFIG_MAC80211_DEBUGFS
620 static void sta_info_debugfs_add_work(struct work_struct *work)
621 {
622         struct ieee80211_local *local =
623                 container_of(work, struct ieee80211_local, sta_debugfs_add);
624         struct sta_info *sta, *tmp;
625         unsigned long flags;
626
627         /* We need to keep the RTNL across the whole pinned status. */
628         rtnl_lock();
629         while (1) {
630                 sta = NULL;
631
632                 spin_lock_irqsave(&local->sta_lock, flags);
633                 list_for_each_entry(tmp, &local->sta_list, list) {
634                         if (!tmp->debugfs.dir) {
635                                 sta = tmp;
636                                 __sta_info_pin(sta);
637                                 break;
638                         }
639                 }
640                 spin_unlock_irqrestore(&local->sta_lock, flags);
641
642                 if (!sta)
643                         break;
644
645                 ieee80211_sta_debugfs_add(sta);
646                 rate_control_add_sta_debugfs(sta);
647
648                 sta = __sta_info_unpin(sta);
649                 sta_info_destroy(sta);
650         }
651         rtnl_unlock();
652 }
653 #endif
654
655 void __ieee80211_run_pending_flush(struct ieee80211_local *local)
656 {
657         struct sta_info *sta;
658         unsigned long flags;
659
660         ASSERT_RTNL();
661
662         spin_lock_irqsave(&local->sta_lock, flags);
663         while (!list_empty(&local->sta_flush_list)) {
664                 sta = list_first_entry(&local->sta_flush_list,
665                                        struct sta_info, list);
666                 list_del(&sta->list);
667                 spin_unlock_irqrestore(&local->sta_lock, flags);
668                 sta_info_destroy(sta);
669                 spin_lock_irqsave(&local->sta_lock, flags);
670         }
671         spin_unlock_irqrestore(&local->sta_lock, flags);
672 }
673
674 static void ieee80211_sta_flush_work(struct work_struct *work)
675 {
676         struct ieee80211_local *local =
677                 container_of(work, struct ieee80211_local, sta_flush_work);
678
679         rtnl_lock();
680         __ieee80211_run_pending_flush(local);
681         rtnl_unlock();
682 }
683
684 void sta_info_init(struct ieee80211_local *local)
685 {
686         spin_lock_init(&local->sta_lock);
687         INIT_LIST_HEAD(&local->sta_list);
688         INIT_LIST_HEAD(&local->sta_flush_list);
689         INIT_WORK(&local->sta_flush_work, ieee80211_sta_flush_work);
690
691         setup_timer(&local->sta_cleanup, sta_info_cleanup,
692                     (unsigned long)local);
693         local->sta_cleanup.expires =
694                 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL);
695
696 #ifdef CONFIG_MAC80211_DEBUGFS
697         INIT_WORK(&local->sta_debugfs_add, sta_info_debugfs_add_work);
698 #endif
699 }
700
701 int sta_info_start(struct ieee80211_local *local)
702 {
703         add_timer(&local->sta_cleanup);
704         return 0;
705 }
706
707 void sta_info_stop(struct ieee80211_local *local)
708 {
709         del_timer(&local->sta_cleanup);
710         cancel_work_sync(&local->sta_flush_work);
711 #ifdef CONFIG_MAC80211_DEBUGFS
712         /*
713          * Make sure the debugfs adding work isn't pending after this
714          * because we're about to be destroyed. It doesn't matter
715          * whether it ran or not since we're going to flush all STAs
716          * anyway.
717          */
718         cancel_work_sync(&local->sta_debugfs_add);
719 #endif
720
721         rtnl_lock();
722         sta_info_flush(local, NULL);
723         __ieee80211_run_pending_flush(local);
724         rtnl_unlock();
725 }
726
727 /**
728  * sta_info_flush - flush matching STA entries from the STA table
729  *
730  * Returns the number of removed STA entries.
731  *
732  * @local: local interface data
733  * @sdata: matching rule for the net device (sta->dev) or %NULL to match all STAs
734  */
735 int sta_info_flush(struct ieee80211_local *local,
736                     struct ieee80211_sub_if_data *sdata)
737 {
738         struct sta_info *sta, *tmp;
739         LIST_HEAD(tmp_list);
740         int ret = 0;
741         unsigned long flags;
742
743         might_sleep();
744         ASSERT_RTNL();
745
746         spin_lock_irqsave(&local->sta_lock, flags);
747         list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
748                 if (!sdata || sdata == sta->sdata) {
749                         __sta_info_unlink(&sta);
750                         if (sta) {
751                                 list_add_tail(&sta->list, &tmp_list);
752                                 ret++;
753                         }
754                 }
755         }
756         spin_unlock_irqrestore(&local->sta_lock, flags);
757
758         list_for_each_entry_safe(sta, tmp, &tmp_list, list)
759                 sta_info_destroy(sta);
760
761         return ret;
762 }
763
764 /**
765  * sta_info_flush_delayed - flush matching STA entries from the STA table
766  *
767  * This function unlinks all stations for a given interface and queues
768  * them for freeing. Note that the workqueue function scheduled here has
769  * to run before any new keys can be added to the system to avoid set_key()
770  * callback ordering issues.
771  *
772  * @sdata: the interface
773  */
774 void sta_info_flush_delayed(struct ieee80211_sub_if_data *sdata)
775 {
776         struct ieee80211_local *local = sdata->local;
777         struct sta_info *sta, *tmp;
778         unsigned long flags;
779         bool work = false;
780
781         spin_lock_irqsave(&local->sta_lock, flags);
782         list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
783                 if (sdata == sta->sdata) {
784                         __sta_info_unlink(&sta);
785                         if (sta) {
786                                 list_add_tail(&sta->list,
787                                               &local->sta_flush_list);
788                                 work = true;
789                         }
790                 }
791         }
792         if (work)
793                 schedule_work(&local->sta_flush_work);
794         spin_unlock_irqrestore(&local->sta_lock, flags);
795 }