sta_info.c 22.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/if_arp.h>
17
#include <linux/timer.h>
18
#include <linux/rtnetlink.h>
19
20
21

#include <net/mac80211.h>
#include "ieee80211_i.h"
Johannes Berg's avatar
Johannes Berg committed
22
#include "rate.h"
23
#include "sta_info.h"
24
#include "debugfs_sta.h"
25
#include "mesh.h"
26

27
28
29
30
31
32
33
/**
 * DOC: STA information lifetime rules
 *
 * STA info structures (&struct sta_info) are managed in a hash table
 * for faster lookup and a list for iteration. They are managed using
 * RCU, i.e. access to the list and hash table is protected by RCU.
 *
34
35
36
37
38
 * Upon allocating a STA info structure with sta_info_alloc(), the caller owns
 * that structure. It must then either destroy it using sta_info_destroy()
 * (which is pretty useless) or insert it into the hash table using
 * sta_info_insert() which demotes the reference from ownership to a regular
 * RCU-protected reference; if the function is called without protection by an
39
40
41
42
43
44
 * RCU critical section the reference is instantly invalidated. Note that the
 * caller may not do much with the STA info before inserting it, in particular,
 * it may not start any mesh peer link management or add encryption keys.
 *
 * When the insertion fails (sta_info_insert()) returns non-zero), the
 * structure will have been freed by sta_info_insert()!
45
46
47
48
 *
 * Because there are debugfs entries for each station, and adding those
 * must be able to sleep, it is also possible to "pin" a station entry,
 * that means it can be removed from the hash table but not be freed.
49
50
 * See the comment in __sta_info_unlink() for more information, this is
 * 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
55
56
57
58
 * then destroy it; sta_info_destroy() will wait for an RCU grace period
 * to elapse before actually freeing it. Due to the pinning and the
 * possibility of multiple callers trying to remove the same STA info at
 * the same time, sta_info_unlink() can clear the STA info pointer it is
 * passed to indicate that the STA info is owned by somebody else now.
59
 *
60
 * If sta_info_unlink() did not clear the pointer then the caller owns
61
 * the STA info structure now and is responsible of destroying it with
62
 * a call to sta_info_destroy().
63
64
65
66
67
68
 *
 * In all other cases, there is no concept of ownership on a STA entry,
 * each structure is owned by the global hash table/list until it is
 * removed. All users of the structure need to be RCU protected so that
 * the structure won't be freed before they are done using it.
 */
69
70

/* Caller must hold local->sta_lock */
71
72
static int sta_info_hash_del(struct ieee80211_local *local,
			     struct sta_info *sta)
73
74
75
{
	struct sta_info *s;

76
	s = local->sta_hash[STA_HASH(sta->sta.addr)];
77
	if (!s)
78
79
		return -ENOENT;
	if (s == sta) {
80
		rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)],
81
				   s->hnext);
82
		return 0;
83
84
	}

85
	while (s->hnext && s->hnext != sta)
86
		s = s->hnext;
87
	if (s->hnext) {
88
		rcu_assign_pointer(s->hnext, sta->hnext);
89
90
		return 0;
	}
91

92
	return -ENOENT;
93
94
}

95
/* protected by RCU */
96
struct sta_info *sta_info_get(struct ieee80211_local *local, const u8 *addr)
97
98
99
{
	struct sta_info *sta;

100
	sta = rcu_dereference(local->sta_hash[STA_HASH(addr)]);
101
	while (sta) {
102
		if (memcmp(sta->sta.addr, addr, ETH_ALEN) == 0)
103
			break;
104
		sta = rcu_dereference(sta->hnext);
105
	}
106
107
108
	return sta;
}

109
110
111
112
113
114
struct sta_info *sta_info_get_by_idx(struct ieee80211_local *local, int idx,
				     struct net_device *dev)
{
	struct sta_info *sta;
	int i = 0;

115
	list_for_each_entry_rcu(sta, &local->sta_list, list) {
116
117
		if (dev && dev != sta->sdata->dev)
			continue;
118
119
120
121
		if (i < idx) {
			++i;
			continue;
		}
122
		return sta;
123
124
125
126
	}

	return NULL;
}
127

128
129
130
/**
 * __sta_info_free - internal STA free helper
 *
131
 * @local: pointer to the global information
132
133
134
135
136
137
138
139
 * @sta: STA info to free
 *
 * This function must undo everything done by sta_info_alloc()
 * that may happen before sta_info_insert().
 */
static void __sta_info_free(struct ieee80211_local *local,
			    struct sta_info *sta)
{
140
	rate_control_free_sta(sta);
141
142
143
	rate_control_put(sta->rate_ctrl);

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
144
145
	printk(KERN_DEBUG "%s: Destroyed STA %pM\n",
	       wiphy_name(local->hw.wiphy), sta->sta.addr);
146
147
148
149
150
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */

	kfree(sta);
}

151
void sta_info_destroy(struct sta_info *sta)
152
{
153
	struct ieee80211_local *local;
154
	struct sk_buff *skb;
155
	int i;
Johannes Berg's avatar
Johannes Berg committed
156

157
158
	might_sleep();

Johannes Berg's avatar
Johannes Berg committed
159
160
	if (!sta)
		return;
161

162
	local = sta->local;
163
164
165
166
167
168
169
170
171

	rate_control_remove_sta_debugfs(sta);
	ieee80211_sta_debugfs_remove(sta);

#ifdef CONFIG_MAC80211_MESH
	if (ieee80211_vif_is_mesh(&sta->sdata->vif))
		mesh_plink_deactivate(sta);
#endif

172
173
174
175
176
177
178
179
180
181
	/*
	 * We have only unlinked the key, and actually destroying it
	 * may mean it is removed from hardware which requires that
	 * the key->sta pointer is still valid, so flush the key todo
	 * list here.
	 *
	 * ieee80211_key_todo() will synchronize_rcu() so after this
	 * nothing can reference this sta struct any more.
	 */
	ieee80211_key_todo();
182
183
184
185
186
187

#ifdef CONFIG_MAC80211_MESH
	if (ieee80211_vif_is_mesh(&sta->sdata->vif))
		del_timer_sync(&sta->plink_timer);
#endif

188
189
190
191
	while ((skb = skb_dequeue(&sta->ps_tx_buf)) != NULL) {
		local->total_ps_buffered--;
		dev_kfree_skb_any(skb);
	}
192
193

	while ((skb = skb_dequeue(&sta->tx_filtered)) != NULL)
194
		dev_kfree_skb_any(skb);
195

196
	for (i = 0; i <  STA_TID_NUM; i++) {
197
198
199
		struct tid_ampdu_rx *tid_rx;
		struct tid_ampdu_tx *tid_tx;

200
		spin_lock_bh(&sta->lock);
201
202
203
204
		tid_rx = sta->ampdu_mlme.tid_rx[i];
		/* Make sure timer won't free the tid_rx struct, see below */
		if (tid_rx)
			tid_rx->shutdown = true;
205

206
		spin_unlock_bh(&sta->lock);
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230

		/*
		 * Outside spinlock - shutdown is true now so that the timer
		 * won't free tid_rx, we have to do that now. Can't let the
		 * timer do it because we have to sync the timer outside the
		 * lock that it takes itself.
		 */
		if (tid_rx) {
			del_timer_sync(&tid_rx->session_timer);
			kfree(tid_rx);
		}

		/*
		 * No need to do such complications for TX agg sessions, the
		 * path leading to freeing the tid_tx struct goes via a call
		 * from the driver, and thus needs to look up the sta struct
		 * again, which cannot be found when we get here. Hence, we
		 * just need to delete the timer and free the aggregation
		 * info; we won't be telling the peer about it then but that
		 * doesn't matter if we're not talking to it again anyway.
		 */
		tid_tx = sta->ampdu_mlme.tid_tx[i];
		if (tid_tx) {
			del_timer_sync(&tid_tx->addba_resp_timer);
231
232
233
234
235
			/*
			 * STA removed while aggregation session being
			 * started? Bit odd, but purge frames anyway.
			 */
			skb_queue_purge(&tid_tx->pending);
236
237
			kfree(tid_tx);
		}
238
	}
239

240
	__sta_info_free(local, sta);
241
242
243
}


244
245
246
/* Caller must hold local->sta_lock */
static void sta_info_hash_add(struct ieee80211_local *local,
			      struct sta_info *sta)
247
{
248
249
	sta->hnext = local->sta_hash[STA_HASH(sta->sta.addr)];
	rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)], sta);
250
251
}

Johannes Berg's avatar
Johannes Berg committed
252
253
struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
				u8 *addr, gfp_t gfp)
254
{
255
	struct ieee80211_local *local = sdata->local;
256
	struct sta_info *sta;
257
	int i;
258

259
	sta = kzalloc(sizeof(*sta) + local->hw.sta_data_size, gfp);
260
	if (!sta)
Johannes Berg's avatar
Johannes Berg committed
261
		return NULL;
262

263
	spin_lock_init(&sta->lock);
264
	spin_lock_init(&sta->flaglock);
265

266
	memcpy(sta->sta.addr, addr, ETH_ALEN);
267
268
	sta->local = local;
	sta->sdata = sdata;
269
270

	sta->rate_ctrl = rate_control_get(local->rate_ctrl);
271
	sta->rate_ctrl_priv = rate_control_alloc_sta(sta->rate_ctrl,
272
						     &sta->sta, gfp);
273
274
275
	if (!sta->rate_ctrl_priv) {
		rate_control_put(sta->rate_ctrl);
		kfree(sta);
Johannes Berg's avatar
Johannes Berg committed
276
		return NULL;
277
278
	}

279
280
281
282
283
	for (i = 0; i < STA_TID_NUM; i++) {
		/* timer_to_tid must be initialized with identity mapping to
		 * enable session_timer's data differentiation. refer to
		 * sta_rx_agg_session_timer_expired for useage */
		sta->timer_to_tid[i] = i;
284
285
286
287
288
289
290
		/* rx */
		sta->ampdu_mlme.tid_state_rx[i] = HT_AGG_STATE_IDLE;
		sta->ampdu_mlme.tid_rx[i] = NULL;
		/* tx */
		sta->ampdu_mlme.tid_state_tx[i] = HT_AGG_STATE_IDLE;
		sta->ampdu_mlme.tid_tx[i] = NULL;
		sta->ampdu_mlme.addba_req_num[i] = 0;
291
	}
292
293
	skb_queue_head_init(&sta->ps_tx_buf);
	skb_queue_head_init(&sta->tx_filtered);
Johannes Berg's avatar
Johannes Berg committed
294
295

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
296
297
	printk(KERN_DEBUG "%s: Allocated STA %pM\n",
	       wiphy_name(local->hw.wiphy), sta->sta.addr);
Johannes Berg's avatar
Johannes Berg committed
298
299
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */

300
#ifdef CONFIG_MAC80211_MESH
301
	sta->plink_state = PLINK_LISTEN;
302
303
304
	init_timer(&sta->plink_timer);
#endif

Johannes Berg's avatar
Johannes Berg committed
305
306
307
308
309
310
311
312
	return sta;
}

int sta_info_insert(struct sta_info *sta)
{
	struct ieee80211_local *local = sta->local;
	struct ieee80211_sub_if_data *sdata = sta->sdata;
	unsigned long flags;
313
	int err = 0;
Johannes Berg's avatar
Johannes Berg committed
314

315
316
317
318
319
	/*
	 * Can't be a WARN_ON because it can be triggered through a race:
	 * something inserts a STA (on one CPU) without holding the RTNL
	 * and another CPU turns off the net device.
	 */
320
321
322
323
	if (unlikely(!netif_running(sdata->dev))) {
		err = -ENETDOWN;
		goto out_free;
	}
324

325
	if (WARN_ON(compare_ether_addr(sta->sta.addr, sdata->dev->dev_addr) == 0 ||
Johannes Berg's avatar
Johannes Berg committed
326
		    is_multicast_ether_addr(sta->sta.addr))) {
327
328
329
		err = -EINVAL;
		goto out_free;
	}
330

331
	spin_lock_irqsave(&local->sta_lock, flags);
332
	/* check if STA exists already */
333
	if (sta_info_get(local, sta->sta.addr)) {
334
		spin_unlock_irqrestore(&local->sta_lock, flags);
335
336
		err = -EEXIST;
		goto out_free;
337
	}
338
339
340
	list_add(&sta->list, &local->sta_list);
	local->num_sta++;
	sta_info_hash_add(local, sta);
341

342
343
	/* notify driver */
	if (local->ops->sta_notify) {
344
		if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
345
346
347
			sdata = container_of(sdata->bss,
					     struct ieee80211_sub_if_data,
					     u.ap);
348
349

		local->ops->sta_notify(local_to_hw(local), &sdata->vif,
350
				       STA_NOTIFY_ADD, &sta->sta);
351
	}
352

353
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
354
355
	printk(KERN_DEBUG "%s: Inserted STA %pM\n",
	       wiphy_name(local->hw.wiphy), sta->sta.addr);
356
357
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */

Johannes Berg's avatar
Johannes Berg committed
358
359
	spin_unlock_irqrestore(&local->sta_lock, flags);

360
#ifdef CONFIG_MAC80211_DEBUGFS
361
362
	/*
	 * Debugfs entry adding might sleep, so schedule process
363
	 * context task for adding entry for STAs that do not yet
364
365
366
367
	 * have one.
	 * NOTE: due to auto-freeing semantics this may only be done
	 *       if the insertion is successful!
	 */
368
	schedule_work(&local->sta_debugfs_add);
369
370
#endif

Johannes Berg's avatar
Johannes Berg committed
371
372
373
374
	if (ieee80211_vif_is_mesh(&sdata->vif))
		mesh_accept_plinks_update(sdata);

	return 0;
375
376
377
378
 out_free:
	BUG_ON(!err);
	__sta_info_free(local, sta);
	return err;
379
380
}

381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
static inline void __bss_tim_set(struct ieee80211_if_ap *bss, u16 aid)
{
	/*
	 * This format has been mandated by the IEEE specifications,
	 * so this line may not be changed to use the __set_bit() format.
	 */
	bss->tim[aid / 8] |= (1 << (aid % 8));
}

static inline void __bss_tim_clear(struct ieee80211_if_ap *bss, u16 aid)
{
	/*
	 * This format has been mandated by the IEEE specifications,
	 * so this line may not be changed to use the __clear_bit() format.
	 */
	bss->tim[aid / 8] &= ~(1 << (aid % 8));
}

static void __sta_info_set_tim_bit(struct ieee80211_if_ap *bss,
				   struct sta_info *sta)
{
402
403
	BUG_ON(!bss);

404
	__bss_tim_set(bss, sta->sta.aid);
405

406
407
	if (sta->local->ops->set_tim) {
		sta->local->tim_in_locked_section = true;
408
409
		sta->local->ops->set_tim(local_to_hw(sta->local),
					 &sta->sta, true);
410
411
		sta->local->tim_in_locked_section = false;
	}
412
413
414
415
}

void sta_info_set_tim_bit(struct sta_info *sta)
{
416
	unsigned long flags;
417

418
419
	BUG_ON(!sta->sdata->bss);

420
421
422
	spin_lock_irqsave(&sta->local->sta_lock, flags);
	__sta_info_set_tim_bit(sta->sdata->bss, sta);
	spin_unlock_irqrestore(&sta->local->sta_lock, flags);
423
424
425
426
427
}

static void __sta_info_clear_tim_bit(struct ieee80211_if_ap *bss,
				     struct sta_info *sta)
{
428
429
	BUG_ON(!bss);

430
	__bss_tim_clear(bss, sta->sta.aid);
431

432
433
	if (sta->local->ops->set_tim) {
		sta->local->tim_in_locked_section = true;
434
435
		sta->local->ops->set_tim(local_to_hw(sta->local),
					 &sta->sta, false);
436
437
		sta->local->tim_in_locked_section = false;
	}
438
439
440
441
}

void sta_info_clear_tim_bit(struct sta_info *sta)
{
442
	unsigned long flags;
443

444
445
	BUG_ON(!sta->sdata->bss);

446
447
448
	spin_lock_irqsave(&sta->local->sta_lock, flags);
	__sta_info_clear_tim_bit(sta->sdata->bss, sta);
	spin_unlock_irqrestore(&sta->local->sta_lock, flags);
449
450
}

451
static void __sta_info_unlink(struct sta_info **sta)
452
{
453
454
455
456
457
458
459
460
461
	struct ieee80211_local *local = (*sta)->local;
	struct ieee80211_sub_if_data *sdata = (*sta)->sdata;
	/*
	 * pull caller's reference if we're already gone.
	 */
	if (sta_info_hash_del(local, *sta)) {
		*sta = NULL;
		return;
	}
462

463
464
465
466
467
	if ((*sta)->key) {
		ieee80211_key_free((*sta)->key);
		WARN_ON((*sta)->key);
	}

Johannes Berg's avatar
Johannes Berg committed
468
469
	list_del(&(*sta)->list);

470
	if (test_and_clear_sta_flags(*sta, WLAN_STA_PS)) {
471
472
473
		BUG_ON(!sdata->bss);

		atomic_dec(&sdata->bss->num_sta_ps);
Johannes Berg's avatar
Johannes Berg committed
474
475
476
477
478
479
		__sta_info_clear_tim_bit(sdata->bss, *sta);
	}

	local->num_sta--;

	if (local->ops->sta_notify) {
480
		if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
481
482
483
			sdata = container_of(sdata->bss,
					     struct ieee80211_sub_if_data,
					     u.ap);
Johannes Berg's avatar
Johannes Berg committed
484
485

		local->ops->sta_notify(local_to_hw(local), &sdata->vif,
486
				       STA_NOTIFY_REMOVE, &(*sta)->sta);
Johannes Berg's avatar
Johannes Berg committed
487
488
489
490
491
492
493
494
495
496
	}

	if (ieee80211_vif_is_mesh(&sdata->vif)) {
		mesh_accept_plinks_update(sdata);
#ifdef CONFIG_MAC80211_MESH
		del_timer(&(*sta)->plink_timer);
#endif
	}

#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
497
498
	printk(KERN_DEBUG "%s: Removed STA %pM\n",
	       wiphy_name(local->hw.wiphy), (*sta)->sta.addr);
Johannes Berg's avatar
Johannes Berg committed
499
500
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */

501
	/*
Johannes Berg's avatar
Johannes Berg committed
502
	 * Finally, pull caller's reference if the STA is pinned by the
503
504
505
506
507
	 * task that is adding the debugfs entries. In that case, we
	 * leave the STA "to be freed".
	 *
	 * The rules are not trivial, but not too complex either:
	 *  (1) pin_status is only modified under the sta_lock
508
509
510
511
512
513
514
515
	 *  (2) STAs may only be pinned under the RTNL so that
	 *	sta_info_flush() is guaranteed to actually destroy
	 *	all STAs that are active for a given interface, this
	 *	is required for correctness because otherwise we
	 *	could notify a driver that an interface is going
	 *	away and only after that (!) notify it about a STA
	 *	on that interface going away.
	 *  (3) sta_info_debugfs_add_work() will set the status
516
517
518
519
520
521
	 *	to PINNED when it found an item that needs a new
	 *	debugfs directory created. In that case, that item
	 *	must not be freed although all *RCU* users are done
	 *	with it. Hence, we tell the caller of _unlink()
	 *	that the item is already gone (as can happen when
	 *	two tasks try to unlink/destroy at the same time)
522
	 *  (4) We set the pin_status to DESTROY here when we
523
	 *	find such an item.
524
	 *  (5) sta_info_debugfs_add_work() will reset the pin_status
525
526
527
528
529
530
531
532
533
	 *	from PINNED to NORMAL when it is done with the item,
	 *	but will check for DESTROY before resetting it in
	 *	which case it will free the item.
	 */
	if ((*sta)->pin_status == STA_INFO_PIN_STAT_PINNED) {
		(*sta)->pin_status = STA_INFO_PIN_STAT_DESTROY;
		*sta = NULL;
		return;
	}
534
535
}

536
537
538
539
540
541
542
543
544
void sta_info_unlink(struct sta_info **sta)
{
	struct ieee80211_local *local = (*sta)->local;
	unsigned long flags;

	spin_lock_irqsave(&local->sta_lock, flags);
	__sta_info_unlink(sta);
	spin_unlock_irqrestore(&local->sta_lock, flags);
}
545
546
547
548
549

static inline int sta_info_buffer_expired(struct ieee80211_local *local,
					  struct sta_info *sta,
					  struct sk_buff *skb)
{
550
	struct ieee80211_tx_info *info;
551
552
553
554
555
	int timeout;

	if (!skb)
		return 0;

556
	info = IEEE80211_SKB_CB(skb);
557
558
559
560
561
562

	/* Timeout: (2 * listen_interval * beacon_int * 1024 / 1000000) sec */
	timeout = (sta->listen_interval * local->hw.conf.beacon_int * 32 /
		   15625) * HZ;
	if (timeout < STA_TX_BUFFER_EXPIRE)
		timeout = STA_TX_BUFFER_EXPIRE;
563
	return time_after(jiffies, info->control.jiffies + timeout);
564
565
566
567
568
569
570
571
}


static void sta_info_cleanup_expire_buffered(struct ieee80211_local *local,
					     struct sta_info *sta)
{
	unsigned long flags;
	struct sk_buff *skb;
572
	struct ieee80211_sub_if_data *sdata;
573
574
575
576
577
578
579

	if (skb_queue_empty(&sta->ps_tx_buf))
		return;

	for (;;) {
		spin_lock_irqsave(&sta->ps_tx_buf.lock, flags);
		skb = skb_peek(&sta->ps_tx_buf);
580
		if (sta_info_buffer_expired(local, sta, skb))
581
			skb = __skb_dequeue(&sta->ps_tx_buf);
582
		else
583
584
585
			skb = NULL;
		spin_unlock_irqrestore(&sta->ps_tx_buf.lock, flags);

586
		if (!skb)
587
			break;
588

589
		sdata = sta->sdata;
590
		local->total_ps_buffered--;
591
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
592
593
		printk(KERN_DEBUG "Buffered frame expired (STA %pM)\n",
		       sta->sta.addr);
594
#endif
595
596
		dev_kfree_skb(skb);

597
598
		if (skb_queue_empty(&sta->ps_tx_buf))
			sta_info_clear_tim_bit(sta);
599
600
601
602
603
604
605
606
607
	}
}


static void sta_info_cleanup(unsigned long data)
{
	struct ieee80211_local *local = (struct ieee80211_local *) data;
	struct sta_info *sta;

608
609
	rcu_read_lock();
	list_for_each_entry_rcu(sta, &local->sta_list, list)
610
		sta_info_cleanup_expire_buffered(local, sta);
611
	rcu_read_unlock();
612

613
614
	local->sta_cleanup.expires =
		round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL);
615
616
617
	add_timer(&local->sta_cleanup);
}

618
#ifdef CONFIG_MAC80211_DEBUGFS
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
/*
 * See comment in __sta_info_unlink,
 * caller must hold local->sta_lock.
 */
static void __sta_info_pin(struct sta_info *sta)
{
	WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_NORMAL);
	sta->pin_status = STA_INFO_PIN_STAT_PINNED;
}

/*
 * See comment in __sta_info_unlink, returns sta if it
 * needs to be destroyed.
 */
static struct sta_info *__sta_info_unpin(struct sta_info *sta)
{
	struct sta_info *ret = NULL;
	unsigned long flags;

	spin_lock_irqsave(&sta->local->sta_lock, flags);
	WARN_ON(sta->pin_status != STA_INFO_PIN_STAT_DESTROY &&
		sta->pin_status != STA_INFO_PIN_STAT_PINNED);
	if (sta->pin_status == STA_INFO_PIN_STAT_DESTROY)
		ret = sta;
	sta->pin_status = STA_INFO_PIN_STAT_NORMAL;
	spin_unlock_irqrestore(&sta->local->sta_lock, flags);

	return ret;
}

649
static void sta_info_debugfs_add_work(struct work_struct *work)
650
651
652
653
{
	struct ieee80211_local *local =
		container_of(work, struct ieee80211_local, sta_debugfs_add);
	struct sta_info *sta, *tmp;
654
	unsigned long flags;
655

656
657
	/* We need to keep the RTNL across the whole pinned status. */
	rtnl_lock();
658
659
	while (1) {
		sta = NULL;
660
661

		spin_lock_irqsave(&local->sta_lock, flags);
662
		list_for_each_entry(tmp, &local->sta_list, list) {
Johannes Berg's avatar
Johannes Berg committed
663
664
665
666
667
668
			/*
			 * debugfs.add_has_run will be set by
			 * ieee80211_sta_debugfs_add regardless
			 * of what else it does.
			 */
			if (!tmp->debugfs.add_has_run) {
669
				sta = tmp;
670
				__sta_info_pin(sta);
671
672
673
				break;
			}
		}
674
		spin_unlock_irqrestore(&local->sta_lock, flags);
675
676
677
678
679
680

		if (!sta)
			break;

		ieee80211_sta_debugfs_add(sta);
		rate_control_add_sta_debugfs(sta);
681
682

		sta = __sta_info_unpin(sta);
683
		sta_info_destroy(sta);
684
	}
685
	rtnl_unlock();
686
687
688
}
#endif

689
static void __ieee80211_run_pending_flush(struct ieee80211_local *local)
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
{
	struct sta_info *sta;
	unsigned long flags;

	ASSERT_RTNL();

	spin_lock_irqsave(&local->sta_lock, flags);
	while (!list_empty(&local->sta_flush_list)) {
		sta = list_first_entry(&local->sta_flush_list,
				       struct sta_info, list);
		list_del(&sta->list);
		spin_unlock_irqrestore(&local->sta_lock, flags);
		sta_info_destroy(sta);
		spin_lock_irqsave(&local->sta_lock, flags);
	}
	spin_unlock_irqrestore(&local->sta_lock, flags);
}

static void ieee80211_sta_flush_work(struct work_struct *work)
{
	struct ieee80211_local *local =
		container_of(work, struct ieee80211_local, sta_flush_work);

	rtnl_lock();
	__ieee80211_run_pending_flush(local);
	rtnl_unlock();
}

718
719
void sta_info_init(struct ieee80211_local *local)
{
720
	spin_lock_init(&local->sta_lock);
721
	INIT_LIST_HEAD(&local->sta_list);
722
723
	INIT_LIST_HEAD(&local->sta_flush_list);
	INIT_WORK(&local->sta_flush_work, ieee80211_sta_flush_work);
724

725
726
	setup_timer(&local->sta_cleanup, sta_info_cleanup,
		    (unsigned long)local);
727
728
	local->sta_cleanup.expires =
		round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL);
729
730

#ifdef CONFIG_MAC80211_DEBUGFS
731
	INIT_WORK(&local->sta_debugfs_add, sta_info_debugfs_add_work);
732
#endif
733
734
735
736
737
738
739
740
741
742
743
}

int sta_info_start(struct ieee80211_local *local)
{
	add_timer(&local->sta_cleanup);
	return 0;
}

void sta_info_stop(struct ieee80211_local *local)
{
	del_timer(&local->sta_cleanup);
744
	cancel_work_sync(&local->sta_flush_work);
745
746
747
748
749
750
751
752
753
#ifdef CONFIG_MAC80211_DEBUGFS
	/*
	 * Make sure the debugfs adding work isn't pending after this
	 * because we're about to be destroyed. It doesn't matter
	 * whether it ran or not since we're going to flush all STAs
	 * anyway.
	 */
	cancel_work_sync(&local->sta_debugfs_add);
#endif
754
755

	rtnl_lock();
756
	sta_info_flush(local, NULL);
757
758
	__ieee80211_run_pending_flush(local);
	rtnl_unlock();
759
760
761
762
}

/**
 * sta_info_flush - flush matching STA entries from the STA table
763
764
765
 *
 * Returns the number of removed STA entries.
 *
766
 * @local: local interface data
767
 * @sdata: matching rule for the net device (sta->dev) or %NULL to match all STAs
768
 */
769
int sta_info_flush(struct ieee80211_local *local,
770
		    struct ieee80211_sub_if_data *sdata)
771
772
{
	struct sta_info *sta, *tmp;
773
	LIST_HEAD(tmp_list);
774
	int ret = 0;
775
	unsigned long flags;
776

777
	might_sleep();
778
	ASSERT_RTNL();
779

780
781
782
783
	spin_lock_irqsave(&local->sta_lock, flags);
	list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
		if (!sdata || sdata == sta->sdata) {
			__sta_info_unlink(&sta);
784
			if (sta) {
785
				list_add_tail(&sta->list, &tmp_list);
786
787
				ret++;
			}
788
		}
789
	}
790
791
792
793
	spin_unlock_irqrestore(&local->sta_lock, flags);

	list_for_each_entry_safe(sta, tmp, &tmp_list, list)
		sta_info_destroy(sta);
794
795

	return ret;
796
}
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829

/**
 * sta_info_flush_delayed - flush matching STA entries from the STA table
 *
 * This function unlinks all stations for a given interface and queues
 * them for freeing. Note that the workqueue function scheduled here has
 * to run before any new keys can be added to the system to avoid set_key()
 * callback ordering issues.
 *
 * @sdata: the interface
 */
void sta_info_flush_delayed(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	struct sta_info *sta, *tmp;
	unsigned long flags;
	bool work = false;

	spin_lock_irqsave(&local->sta_lock, flags);
	list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
		if (sdata == sta->sdata) {
			__sta_info_unlink(&sta);
			if (sta) {
				list_add_tail(&sta->list,
					      &local->sta_flush_list);
				work = true;
			}
		}
	}
	if (work)
		schedule_work(&local->sta_flush_work);
	spin_unlock_irqrestore(&local->sta_lock, flags);
}
830
831
832
833
834
835
836
837
838
839
840
841
842

void ieee80211_sta_expire(struct ieee80211_sub_if_data *sdata,
			  unsigned long exp_time)
{
	struct ieee80211_local *local = sdata->local;
	struct sta_info *sta, *tmp;
	LIST_HEAD(tmp_list);
	unsigned long flags;

	spin_lock_irqsave(&local->sta_lock, flags);
	list_for_each_entry_safe(sta, tmp, &local->sta_list, list)
		if (time_after(jiffies, sta->last_rx + exp_time)) {
#ifdef CONFIG_MAC80211_IBSS_DEBUG
843
844
			printk(KERN_DEBUG "%s: expiring inactive STA %pM\n",
			       sdata->dev->name, sta->sta.addr);
845
846
847
848
849
850
851
852
853
854
#endif
			__sta_info_unlink(&sta);
			if (sta)
				list_add(&sta->list, &tmp_list);
		}
	spin_unlock_irqrestore(&local->sta_lock, flags);

	list_for_each_entry_safe(sta, tmp, &tmp_list, list)
		sta_info_destroy(sta);
}
855
856

struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_hw *hw,
Johannes Berg's avatar
Johannes Berg committed
857
					 const u8 *addr)
858
{
859
	struct sta_info *sta = sta_info_get(hw_to_local(hw), addr);
860
861
862
863
864
865

	if (!sta)
		return NULL;
	return &sta->sta;
}
EXPORT_SYMBOL(ieee80211_find_sta);