1
2
3
4
5
6
7
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 "driver-ops.h"
23#include "rate.h"
24#include "sta_info.h"
25#include "debugfs_sta.h"
26#include "mesh.h"
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81static int sta_info_hash_del(struct ieee80211_local *local,
82 struct sta_info *sta)
83{
84 struct sta_info *s;
85
86 s = local->sta_hash[STA_HASH(sta->sta.addr)];
87 if (!s)
88 return -ENOENT;
89 if (s == sta) {
90 rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)],
91 s->hnext);
92 return 0;
93 }
94
95 while (s->hnext && s->hnext != sta)
96 s = s->hnext;
97 if (s->hnext) {
98 rcu_assign_pointer(s->hnext, sta->hnext);
99 return 0;
100 }
101
102 return -ENOENT;
103}
104
105
106struct sta_info *sta_info_get(struct ieee80211_local *local, const u8 *addr)
107{
108 struct sta_info *sta;
109
110 sta = rcu_dereference(local->sta_hash[STA_HASH(addr)]);
111 while (sta) {
112 if (memcmp(sta->sta.addr, addr, ETH_ALEN) == 0)
113 break;
114 sta = rcu_dereference(sta->hnext);
115 }
116 return sta;
117}
118
119struct sta_info *sta_info_get_by_idx(struct ieee80211_local *local, int idx,
120 struct net_device *dev)
121{
122 struct sta_info *sta;
123 int i = 0;
124
125 list_for_each_entry_rcu(sta, &local->sta_list, list) {
126 if (dev && dev != sta->sdata->dev)
127 continue;
128 if (i < idx) {
129 ++i;
130 continue;
131 }
132 return sta;
133 }
134
135 return NULL;
136}
137
138
139
140
141
142
143
144
145
146
147static void __sta_info_free(struct ieee80211_local *local,
148 struct sta_info *sta)
149{
150 rate_control_free_sta(sta);
151 rate_control_put(sta->rate_ctrl);
152
153#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
154 printk(KERN_DEBUG "%s: Destroyed STA %pM\n",
155 wiphy_name(local->hw.wiphy), sta->sta.addr);
156#endif
157
158 kfree(sta);
159}
160
161void sta_info_destroy(struct sta_info *sta)
162{
163 struct ieee80211_local *local;
164 struct sk_buff *skb;
165 int i;
166
167 might_sleep();
168
169 if (!sta)
170 return;
171
172 local = sta->local;
173
174 rate_control_remove_sta_debugfs(sta);
175 ieee80211_sta_debugfs_remove(sta);
176
177#ifdef CONFIG_MAC80211_MESH
178 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
179 mesh_plink_deactivate(sta);
180#endif
181
182
183
184
185
186
187
188
189
190
191 ieee80211_key_todo();
192
193#ifdef CONFIG_MAC80211_MESH
194 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
195 del_timer_sync(&sta->plink_timer);
196#endif
197
198 while ((skb = skb_dequeue(&sta->ps_tx_buf)) != NULL) {
199 local->total_ps_buffered--;
200 dev_kfree_skb_any(skb);
201 }
202
203 while ((skb = skb_dequeue(&sta->tx_filtered)) != NULL)
204 dev_kfree_skb_any(skb);
205
206 for (i = 0; i < STA_TID_NUM; i++) {
207 struct tid_ampdu_rx *tid_rx;
208 struct tid_ampdu_tx *tid_tx;
209
210 spin_lock_bh(&sta->lock);
211 tid_rx = sta->ampdu_mlme.tid_rx[i];
212
213 if (tid_rx)
214 tid_rx->shutdown = true;
215
216 spin_unlock_bh(&sta->lock);
217
218
219
220
221
222
223
224 if (tid_rx) {
225 del_timer_sync(&tid_rx->session_timer);
226 kfree(tid_rx);
227 }
228
229
230
231
232
233
234
235
236
237
238 tid_tx = sta->ampdu_mlme.tid_tx[i];
239 if (tid_tx) {
240 del_timer_sync(&tid_tx->addba_resp_timer);
241
242
243
244
245 skb_queue_purge(&tid_tx->pending);
246 kfree(tid_tx);
247 }
248 }
249
250 __sta_info_free(local, sta);
251}
252
253
254
255static void sta_info_hash_add(struct ieee80211_local *local,
256 struct sta_info *sta)
257{
258 sta->hnext = local->sta_hash[STA_HASH(sta->sta.addr)];
259 rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)], sta);
260}
261
262struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
263 u8 *addr, gfp_t gfp)
264{
265 struct ieee80211_local *local = sdata->local;
266 struct sta_info *sta;
267 int i;
268
269 sta = kzalloc(sizeof(*sta) + local->hw.sta_data_size, gfp);
270 if (!sta)
271 return NULL;
272
273 spin_lock_init(&sta->lock);
274 spin_lock_init(&sta->flaglock);
275
276 memcpy(sta->sta.addr, addr, ETH_ALEN);
277 sta->local = local;
278 sta->sdata = sdata;
279
280 sta->rate_ctrl = rate_control_get(local->rate_ctrl);
281 sta->rate_ctrl_priv = rate_control_alloc_sta(sta->rate_ctrl,
282 &sta->sta, gfp);
283 if (!sta->rate_ctrl_priv) {
284 rate_control_put(sta->rate_ctrl);
285 kfree(sta);
286 return NULL;
287 }
288
289 for (i = 0; i < STA_TID_NUM; i++) {
290
291
292
293 sta->timer_to_tid[i] = i;
294
295 sta->ampdu_mlme.tid_state_rx[i] = HT_AGG_STATE_IDLE;
296 sta->ampdu_mlme.tid_rx[i] = NULL;
297
298 sta->ampdu_mlme.tid_state_tx[i] = HT_AGG_STATE_IDLE;
299 sta->ampdu_mlme.tid_tx[i] = NULL;
300 sta->ampdu_mlme.addba_req_num[i] = 0;
301 }
302 skb_queue_head_init(&sta->ps_tx_buf);
303 skb_queue_head_init(&sta->tx_filtered);
304
305 for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
306 sta->last_seq_ctrl[i] = cpu_to_le16(USHORT_MAX);
307
308#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
309 printk(KERN_DEBUG "%s: Allocated STA %pM\n",
310 wiphy_name(local->hw.wiphy), sta->sta.addr);
311#endif
312
313#ifdef CONFIG_MAC80211_MESH
314 sta->plink_state = PLINK_LISTEN;
315 init_timer(&sta->plink_timer);
316#endif
317
318 return sta;
319}
320
321int sta_info_insert(struct sta_info *sta)
322{
323 struct ieee80211_local *local = sta->local;
324 struct ieee80211_sub_if_data *sdata = sta->sdata;
325 unsigned long flags;
326 int err = 0;
327
328
329
330
331
332
333 if (unlikely(!netif_running(sdata->dev))) {
334 err = -ENETDOWN;
335 goto out_free;
336 }
337
338 if (WARN_ON(compare_ether_addr(sta->sta.addr, sdata->dev->dev_addr) == 0 ||
339 is_multicast_ether_addr(sta->sta.addr))) {
340 err = -EINVAL;
341 goto out_free;
342 }
343
344 spin_lock_irqsave(&local->sta_lock, flags);
345
346 if (sta_info_get(local, sta->sta.addr)) {
347 spin_unlock_irqrestore(&local->sta_lock, flags);
348 err = -EEXIST;
349 goto out_free;
350 }
351 list_add(&sta->list, &local->sta_list);
352 local->sta_generation++;
353 local->num_sta++;
354 sta_info_hash_add(local, sta);
355
356
357 if (local->ops->sta_notify) {
358 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
359 sdata = container_of(sdata->bss,
360 struct ieee80211_sub_if_data,
361 u.ap);
362
363 drv_sta_notify(local, &sdata->vif, STA_NOTIFY_ADD, &sta->sta);
364 sdata = sta->sdata;
365 }
366
367#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
368 printk(KERN_DEBUG "%s: Inserted STA %pM\n",
369 wiphy_name(local->hw.wiphy), sta->sta.addr);
370#endif
371
372 spin_unlock_irqrestore(&local->sta_lock, flags);
373
374#ifdef CONFIG_MAC80211_DEBUGFS
375
376
377
378
379
380
381
382 schedule_work(&local->sta_debugfs_add);
383#endif
384
385 if (ieee80211_vif_is_mesh(&sdata->vif))
386 mesh_accept_plinks_update(sdata);
387
388 return 0;
389 out_free:
390 BUG_ON(!err);
391 __sta_info_free(local, sta);
392 return err;
393}
394
395static inline void __bss_tim_set(struct ieee80211_if_ap *bss, u16 aid)
396{
397
398
399
400
401 bss->tim[aid / 8] |= (1 << (aid % 8));
402}
403
404static inline void __bss_tim_clear(struct ieee80211_if_ap *bss, u16 aid)
405{
406
407
408
409
410 bss->tim[aid / 8] &= ~(1 << (aid % 8));
411}
412
413static void __sta_info_set_tim_bit(struct ieee80211_if_ap *bss,
414 struct sta_info *sta)
415{
416 BUG_ON(!bss);
417
418 __bss_tim_set(bss, sta->sta.aid);
419
420 if (sta->local->ops->set_tim) {
421 sta->local->tim_in_locked_section = true;
422 drv_set_tim(sta->local, &sta->sta, true);
423 sta->local->tim_in_locked_section = false;
424 }
425}
426
427void sta_info_set_tim_bit(struct sta_info *sta)
428{
429 unsigned long flags;
430
431 BUG_ON(!sta->sdata->bss);
432
433 spin_lock_irqsave(&sta->local->sta_lock, flags);
434 __sta_info_set_tim_bit(sta->sdata->bss, sta);
435 spin_unlock_irqrestore(&sta->local->sta_lock, flags);
436}
437
438static void __sta_info_clear_tim_bit(struct ieee80211_if_ap *bss,
439 struct sta_info *sta)
440{
441 BUG_ON(!bss);
442
443 __bss_tim_clear(bss, sta->sta.aid);
444
445 if (sta->local->ops->set_tim) {
446 sta->local->tim_in_locked_section = true;
447 drv_set_tim(sta->local, &sta->sta, false);
448 sta->local->tim_in_locked_section = false;
449 }
450}
451
452void sta_info_clear_tim_bit(struct sta_info *sta)
453{
454 unsigned long flags;
455
456 BUG_ON(!sta->sdata->bss);
457
458 spin_lock_irqsave(&sta->local->sta_lock, flags);
459 __sta_info_clear_tim_bit(sta->sdata->bss, sta);
460 spin_unlock_irqrestore(&sta->local->sta_lock, flags);
461}
462
463static void __sta_info_unlink(struct sta_info **sta)
464{
465 struct ieee80211_local *local = (*sta)->local;
466 struct ieee80211_sub_if_data *sdata = (*sta)->sdata;
467
468
469
470 if (sta_info_hash_del(local, *sta)) {
471 *sta = NULL;
472 return;
473 }
474
475 if ((*sta)->key) {
476 ieee80211_key_free((*sta)->key);
477 WARN_ON((*sta)->key);
478 }
479
480 list_del(&(*sta)->list);
481
482 if (test_and_clear_sta_flags(*sta, WLAN_STA_PS)) {
483 BUG_ON(!sdata->bss);
484
485 atomic_dec(&sdata->bss->num_sta_ps);
486 __sta_info_clear_tim_bit(sdata->bss, *sta);
487 }
488
489 local->num_sta--;
490 local->sta_generation++;
491
492 if (local->ops->sta_notify) {
493 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
494 sdata = container_of(sdata->bss,
495 struct ieee80211_sub_if_data,
496 u.ap);
497
498 drv_sta_notify(local, &sdata->vif, STA_NOTIFY_REMOVE,
499 &(*sta)->sta);
500 sdata = (*sta)->sdata;
501 }
502
503 if (ieee80211_vif_is_mesh(&sdata->vif)) {
504 mesh_accept_plinks_update(sdata);
505#ifdef CONFIG_MAC80211_MESH
506 del_timer(&(*sta)->plink_timer);
507#endif
508 }
509
510#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
511 printk(KERN_DEBUG "%s: Removed STA %pM\n",
512 wiphy_name(local->hw.wiphy), (*sta)->sta.addr);
513#endif
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543 if ((*sta)->pin_status == STA_INFO_PIN_STAT_PINNED) {
544 (*sta)->pin_status = STA_INFO_PIN_STAT_DESTROY;
545 *sta = NULL;
546 return;
547 }
548}
549
550void sta_info_unlink(struct sta_info **sta)
551{
552 struct ieee80211_local *local = (*sta)->local;
553 unsigned long flags;
554
555 spin_lock_irqsave(&local->sta_lock, flags);
556 __sta_info_unlink(sta);
557 spin_unlock_irqrestore(&local->sta_lock, flags);
558}
559
560static int sta_info_buffer_expired(struct sta_info *sta,
561 struct sk_buff *skb)
562{
563 struct ieee80211_tx_info *info;
564 int timeout;
565
566 if (!skb)
567 return 0;
568
569 info = IEEE80211_SKB_CB(skb);
570
571
572 timeout = (sta->listen_interval *
573 sta->sdata->vif.bss_conf.beacon_int *
574 32 / 15625) * HZ;
575 if (timeout < STA_TX_BUFFER_EXPIRE)
576 timeout = STA_TX_BUFFER_EXPIRE;
577 return time_after(jiffies, info->control.jiffies + timeout);
578}
579
580
581static void sta_info_cleanup_expire_buffered(struct ieee80211_local *local,
582 struct sta_info *sta)
583{
584 unsigned long flags;
585 struct sk_buff *skb;
586 struct ieee80211_sub_if_data *sdata;
587
588 if (skb_queue_empty(&sta->ps_tx_buf))
589 return;
590
591 for (;;) {
592 spin_lock_irqsave(&sta->ps_tx_buf.lock, flags);
593 skb = skb_peek(&sta->ps_tx_buf);
594 if (sta_info_buffer_expired(sta, skb))
595 skb = __skb_dequeue(&sta->ps_tx_buf);
596 else
597 skb = NULL;
598 spin_unlock_irqrestore(&sta->ps_tx_buf.lock, flags);
599
600 if (!skb)
601 break;
602
603 sdata = sta->sdata;
604 local->total_ps_buffered--;
605#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
606 printk(KERN_DEBUG "Buffered frame expired (STA %pM)\n",
607 sta->sta.addr);
608#endif
609 dev_kfree_skb(skb);
610
611 if (skb_queue_empty(&sta->ps_tx_buf))
612 sta_info_clear_tim_bit(sta);
613 }
614}
615
616
617static void sta_info_cleanup(unsigned long data)
618{
619 struct ieee80211_local *local = (struct ieee80211_local *) data;
620 struct sta_info *sta;
621
622 rcu_read_lock();
623 list_for_each_entry_rcu(sta, &local->sta_list, list)
624 sta_info_cleanup_expire_buffered(local, sta);
625 rcu_read_unlock();
626
627 if (local->quiescing)
628 return;
629
630 local->sta_cleanup.expires =
631 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL);
632 add_timer(&local->sta_cleanup);
633}
634
635#ifdef CONFIG_MAC80211_DEBUGFS
636
637
638
639
640static void __sta_info_pin(struct sta_info *sta)
641{
642 WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_NORMAL);
643 sta->pin_status = STA_INFO_PIN_STAT_PINNED;
644}
645
646
647
648
649
650static struct sta_info *__sta_info_unpin(struct sta_info *sta)
651{
652 struct sta_info *ret = NULL;
653 unsigned long flags;
654
655 spin_lock_irqsave(&sta->local->sta_lock, flags);
656 WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_DESTROY &&
657 sta->pin_status != STA_INFO_PIN_STAT_PINNED);
658 if (sta->pin_status == STA_INFO_PIN_STAT_DESTROY)
659 ret = sta;
660 sta->pin_status = STA_INFO_PIN_STAT_NORMAL;
661 spin_unlock_irqrestore(&sta->local->sta_lock, flags);
662
663 return ret;
664}
665
666static void sta_info_debugfs_add_work(struct work_struct *work)
667{
668 struct ieee80211_local *local =
669 container_of(work, struct ieee80211_local, sta_debugfs_add);
670 struct sta_info *sta, *tmp;
671 unsigned long flags;
672
673
674 rtnl_lock();
675 while (1) {
676 sta = NULL;
677
678 spin_lock_irqsave(&local->sta_lock, flags);
679 list_for_each_entry(tmp, &local->sta_list, list) {
680
681
682
683
684
685 if (!tmp->debugfs.add_has_run) {
686 sta = tmp;
687 __sta_info_pin(sta);
688 break;
689 }
690 }
691 spin_unlock_irqrestore(&local->sta_lock, flags);
692
693 if (!sta)
694 break;
695
696 ieee80211_sta_debugfs_add(sta);
697 rate_control_add_sta_debugfs(sta);
698
699 sta = __sta_info_unpin(sta);
700 sta_info_destroy(sta);
701 }
702 rtnl_unlock();
703}
704#endif
705
706void sta_info_init(struct ieee80211_local *local)
707{
708 spin_lock_init(&local->sta_lock);
709 INIT_LIST_HEAD(&local->sta_list);
710
711 setup_timer(&local->sta_cleanup, sta_info_cleanup,
712 (unsigned long)local);
713 local->sta_cleanup.expires =
714 round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL);
715
716#ifdef CONFIG_MAC80211_DEBUGFS
717 INIT_WORK(&local->sta_debugfs_add, sta_info_debugfs_add_work);
718#endif
719}
720
721int sta_info_start(struct ieee80211_local *local)
722{
723 add_timer(&local->sta_cleanup);
724 return 0;
725}
726
727void sta_info_stop(struct ieee80211_local *local)
728{
729 del_timer(&local->sta_cleanup);
730#ifdef CONFIG_MAC80211_DEBUGFS
731
732
733
734
735
736
737 cancel_work_sync(&local->sta_debugfs_add);
738#endif
739
740 sta_info_flush(local, NULL);
741}
742
743
744
745
746
747
748
749
750
751int sta_info_flush(struct ieee80211_local *local,
752 struct ieee80211_sub_if_data *sdata)
753{
754 struct sta_info *sta, *tmp;
755 LIST_HEAD(tmp_list);
756 int ret = 0;
757 unsigned long flags;
758
759 might_sleep();
760
761 spin_lock_irqsave(&local->sta_lock, flags);
762 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
763 if (!sdata || sdata == sta->sdata) {
764 __sta_info_unlink(&sta);
765 if (sta) {
766 list_add_tail(&sta->list, &tmp_list);
767 ret++;
768 }
769 }
770 }
771 spin_unlock_irqrestore(&local->sta_lock, flags);
772
773 list_for_each_entry_safe(sta, tmp, &tmp_list, list)
774 sta_info_destroy(sta);
775
776 return ret;
777}
778
779void ieee80211_sta_expire(struct ieee80211_sub_if_data *sdata,
780 unsigned long exp_time)
781{
782 struct ieee80211_local *local = sdata->local;
783 struct sta_info *sta, *tmp;
784 LIST_HEAD(tmp_list);
785 unsigned long flags;
786
787 spin_lock_irqsave(&local->sta_lock, flags);
788 list_for_each_entry_safe(sta, tmp, &local->sta_list, list)
789 if (time_after(jiffies, sta->last_rx + exp_time)) {
790#ifdef CONFIG_MAC80211_IBSS_DEBUG
791 printk(KERN_DEBUG "%s: expiring inactive STA %pM\n",
792 sdata->dev->name, sta->sta.addr);
793#endif
794 __sta_info_unlink(&sta);
795 if (sta)
796 list_add(&sta->list, &tmp_list);
797 }
798 spin_unlock_irqrestore(&local->sta_lock, flags);
799
800 list_for_each_entry_safe(sta, tmp, &tmp_list, list)
801 sta_info_destroy(sta);
802}
803
804struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_hw *hw,
805 const u8 *addr)
806{
807 struct sta_info *sta = sta_info_get(hw_to_local(hw), addr);
808
809 if (!sta)
810 return NULL;
811 return &sta->sta;
812}
813EXPORT_SYMBOL(ieee80211_find_sta);
814