diff options
Diffstat (limited to 'net/mac80211/sta_info.c')
-rw-r--r-- | net/mac80211/sta_info.c | 977 |
1 files changed, 748 insertions, 229 deletions
diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c index 21070e9bc8d0..ce962d2c8782 100644 --- a/net/mac80211/sta_info.c +++ b/net/mac80211/sta_info.c | |||
@@ -24,6 +24,7 @@ | |||
24 | #include "sta_info.h" | 24 | #include "sta_info.h" |
25 | #include "debugfs_sta.h" | 25 | #include "debugfs_sta.h" |
26 | #include "mesh.h" | 26 | #include "mesh.h" |
27 | #include "wme.h" | ||
27 | 28 | ||
28 | /** | 29 | /** |
29 | * DOC: STA information lifetime rules | 30 | * DOC: STA information lifetime rules |
@@ -72,7 +73,7 @@ static int sta_info_hash_del(struct ieee80211_local *local, | |||
72 | if (!s) | 73 | if (!s) |
73 | return -ENOENT; | 74 | return -ENOENT; |
74 | if (s == sta) { | 75 | if (s == sta) { |
75 | rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)], | 76 | RCU_INIT_POINTER(local->sta_hash[STA_HASH(sta->sta.addr)], |
76 | s->hnext); | 77 | s->hnext); |
77 | return 0; | 78 | return 0; |
78 | } | 79 | } |
@@ -82,7 +83,7 @@ static int sta_info_hash_del(struct ieee80211_local *local, | |||
82 | s = rcu_dereference_protected(s->hnext, | 83 | s = rcu_dereference_protected(s->hnext, |
83 | lockdep_is_held(&local->sta_lock)); | 84 | lockdep_is_held(&local->sta_lock)); |
84 | if (rcu_access_pointer(s->hnext)) { | 85 | if (rcu_access_pointer(s->hnext)) { |
85 | rcu_assign_pointer(s->hnext, sta->hnext); | 86 | RCU_INIT_POINTER(s->hnext, sta->hnext); |
86 | return 0; | 87 | return 0; |
87 | } | 88 | } |
88 | 89 | ||
@@ -100,6 +101,27 @@ struct sta_info *sta_info_get(struct ieee80211_sub_if_data *sdata, | |||
100 | lockdep_is_held(&local->sta_lock) || | 101 | lockdep_is_held(&local->sta_lock) || |
101 | lockdep_is_held(&local->sta_mtx)); | 102 | lockdep_is_held(&local->sta_mtx)); |
102 | while (sta) { | 103 | while (sta) { |
104 | if (sta->sdata == sdata && !sta->dummy && | ||
105 | memcmp(sta->sta.addr, addr, ETH_ALEN) == 0) | ||
106 | break; | ||
107 | sta = rcu_dereference_check(sta->hnext, | ||
108 | lockdep_is_held(&local->sta_lock) || | ||
109 | lockdep_is_held(&local->sta_mtx)); | ||
110 | } | ||
111 | return sta; | ||
112 | } | ||
113 | |||
114 | /* get a station info entry even if it is a dummy station*/ | ||
115 | struct sta_info *sta_info_get_rx(struct ieee80211_sub_if_data *sdata, | ||
116 | const u8 *addr) | ||
117 | { | ||
118 | struct ieee80211_local *local = sdata->local; | ||
119 | struct sta_info *sta; | ||
120 | |||
121 | sta = rcu_dereference_check(local->sta_hash[STA_HASH(addr)], | ||
122 | lockdep_is_held(&local->sta_lock) || | ||
123 | lockdep_is_held(&local->sta_mtx)); | ||
124 | while (sta) { | ||
103 | if (sta->sdata == sdata && | 125 | if (sta->sdata == sdata && |
104 | memcmp(sta->sta.addr, addr, ETH_ALEN) == 0) | 126 | memcmp(sta->sta.addr, addr, ETH_ALEN) == 0) |
105 | break; | 127 | break; |
@@ -126,6 +148,32 @@ struct sta_info *sta_info_get_bss(struct ieee80211_sub_if_data *sdata, | |||
126 | while (sta) { | 148 | while (sta) { |
127 | if ((sta->sdata == sdata || | 149 | if ((sta->sdata == sdata || |
128 | (sta->sdata->bss && sta->sdata->bss == sdata->bss)) && | 150 | (sta->sdata->bss && sta->sdata->bss == sdata->bss)) && |
151 | !sta->dummy && | ||
152 | memcmp(sta->sta.addr, addr, ETH_ALEN) == 0) | ||
153 | break; | ||
154 | sta = rcu_dereference_check(sta->hnext, | ||
155 | lockdep_is_held(&local->sta_lock) || | ||
156 | lockdep_is_held(&local->sta_mtx)); | ||
157 | } | ||
158 | return sta; | ||
159 | } | ||
160 | |||
161 | /* | ||
162 | * Get sta info either from the specified interface | ||
163 | * or from one of its vlans (including dummy stations) | ||
164 | */ | ||
165 | struct sta_info *sta_info_get_bss_rx(struct ieee80211_sub_if_data *sdata, | ||
166 | const u8 *addr) | ||
167 | { | ||
168 | struct ieee80211_local *local = sdata->local; | ||
169 | struct sta_info *sta; | ||
170 | |||
171 | sta = rcu_dereference_check(local->sta_hash[STA_HASH(addr)], | ||
172 | lockdep_is_held(&local->sta_lock) || | ||
173 | lockdep_is_held(&local->sta_mtx)); | ||
174 | while (sta) { | ||
175 | if ((sta->sdata == sdata || | ||
176 | (sta->sdata->bss && sta->sdata->bss == sdata->bss)) && | ||
129 | memcmp(sta->sta.addr, addr, ETH_ALEN) == 0) | 177 | memcmp(sta->sta.addr, addr, ETH_ALEN) == 0) |
130 | break; | 178 | break; |
131 | sta = rcu_dereference_check(sta->hnext, | 179 | sta = rcu_dereference_check(sta->hnext, |
@@ -184,7 +232,7 @@ static void sta_info_hash_add(struct ieee80211_local *local, | |||
184 | struct sta_info *sta) | 232 | struct sta_info *sta) |
185 | { | 233 | { |
186 | sta->hnext = local->sta_hash[STA_HASH(sta->sta.addr)]; | 234 | sta->hnext = local->sta_hash[STA_HASH(sta->sta.addr)]; |
187 | rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)], sta); | 235 | RCU_INIT_POINTER(local->sta_hash[STA_HASH(sta->sta.addr)], sta); |
188 | } | 236 | } |
189 | 237 | ||
190 | static void sta_unblock(struct work_struct *wk) | 238 | static void sta_unblock(struct work_struct *wk) |
@@ -196,13 +244,22 @@ static void sta_unblock(struct work_struct *wk) | |||
196 | if (sta->dead) | 244 | if (sta->dead) |
197 | return; | 245 | return; |
198 | 246 | ||
199 | if (!test_sta_flags(sta, WLAN_STA_PS_STA)) | 247 | if (!test_sta_flag(sta, WLAN_STA_PS_STA)) |
200 | ieee80211_sta_ps_deliver_wakeup(sta); | 248 | ieee80211_sta_ps_deliver_wakeup(sta); |
201 | else if (test_and_clear_sta_flags(sta, WLAN_STA_PSPOLL)) { | 249 | else if (test_and_clear_sta_flag(sta, WLAN_STA_PSPOLL)) { |
202 | clear_sta_flags(sta, WLAN_STA_PS_DRIVER); | 250 | clear_sta_flag(sta, WLAN_STA_PS_DRIVER); |
251 | |||
252 | local_bh_disable(); | ||
203 | ieee80211_sta_ps_deliver_poll_response(sta); | 253 | ieee80211_sta_ps_deliver_poll_response(sta); |
254 | local_bh_enable(); | ||
255 | } else if (test_and_clear_sta_flag(sta, WLAN_STA_UAPSD)) { | ||
256 | clear_sta_flag(sta, WLAN_STA_PS_DRIVER); | ||
257 | |||
258 | local_bh_disable(); | ||
259 | ieee80211_sta_ps_deliver_uapsd(sta); | ||
260 | local_bh_enable(); | ||
204 | } else | 261 | } else |
205 | clear_sta_flags(sta, WLAN_STA_PS_DRIVER); | 262 | clear_sta_flag(sta, WLAN_STA_PS_DRIVER); |
206 | } | 263 | } |
207 | 264 | ||
208 | static int sta_prepare_rate_control(struct ieee80211_local *local, | 265 | static int sta_prepare_rate_control(struct ieee80211_local *local, |
@@ -235,7 +292,6 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata, | |||
235 | return NULL; | 292 | return NULL; |
236 | 293 | ||
237 | spin_lock_init(&sta->lock); | 294 | spin_lock_init(&sta->lock); |
238 | spin_lock_init(&sta->flaglock); | ||
239 | INIT_WORK(&sta->drv_unblock_wk, sta_unblock); | 295 | INIT_WORK(&sta->drv_unblock_wk, sta_unblock); |
240 | INIT_WORK(&sta->ampdu_mlme.work, ieee80211_ba_session_work); | 296 | INIT_WORK(&sta->ampdu_mlme.work, ieee80211_ba_session_work); |
241 | mutex_init(&sta->ampdu_mlme.mtx); | 297 | mutex_init(&sta->ampdu_mlme.mtx); |
@@ -262,8 +318,10 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata, | |||
262 | */ | 318 | */ |
263 | sta->timer_to_tid[i] = i; | 319 | sta->timer_to_tid[i] = i; |
264 | } | 320 | } |
265 | skb_queue_head_init(&sta->ps_tx_buf); | 321 | for (i = 0; i < IEEE80211_NUM_ACS; i++) { |
266 | skb_queue_head_init(&sta->tx_filtered); | 322 | skb_queue_head_init(&sta->ps_tx_buf[i]); |
323 | skb_queue_head_init(&sta->tx_filtered[i]); | ||
324 | } | ||
267 | 325 | ||
268 | for (i = 0; i < NUM_RX_DATA_QUEUES; i++) | 326 | for (i = 0; i < NUM_RX_DATA_QUEUES; i++) |
269 | sta->last_seq_ctrl[i] = cpu_to_le16(USHRT_MAX); | 327 | sta->last_seq_ctrl[i] = cpu_to_le16(USHRT_MAX); |
@@ -280,7 +338,8 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata, | |||
280 | return sta; | 338 | return sta; |
281 | } | 339 | } |
282 | 340 | ||
283 | static int sta_info_finish_insert(struct sta_info *sta, bool async) | 341 | static int sta_info_finish_insert(struct sta_info *sta, |
342 | bool async, bool dummy_reinsert) | ||
284 | { | 343 | { |
285 | struct ieee80211_local *local = sta->local; | 344 | struct ieee80211_local *local = sta->local; |
286 | struct ieee80211_sub_if_data *sdata = sta->sdata; | 345 | struct ieee80211_sub_if_data *sdata = sta->sdata; |
@@ -290,50 +349,58 @@ static int sta_info_finish_insert(struct sta_info *sta, bool async) | |||
290 | 349 | ||
291 | lockdep_assert_held(&local->sta_mtx); | 350 | lockdep_assert_held(&local->sta_mtx); |
292 | 351 | ||
293 | /* notify driver */ | 352 | if (!sta->dummy || dummy_reinsert) { |
294 | if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) | 353 | /* notify driver */ |
295 | sdata = container_of(sdata->bss, | 354 | if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) |
296 | struct ieee80211_sub_if_data, | 355 | sdata = container_of(sdata->bss, |
297 | u.ap); | 356 | struct ieee80211_sub_if_data, |
298 | err = drv_sta_add(local, sdata, &sta->sta); | 357 | u.ap); |
299 | if (err) { | 358 | err = drv_sta_add(local, sdata, &sta->sta); |
300 | if (!async) | 359 | if (err) { |
301 | return err; | 360 | if (!async) |
302 | printk(KERN_DEBUG "%s: failed to add IBSS STA %pM to driver (%d)" | 361 | return err; |
303 | " - keeping it anyway.\n", | 362 | printk(KERN_DEBUG "%s: failed to add IBSS STA %pM to " |
304 | sdata->name, sta->sta.addr, err); | 363 | "driver (%d) - keeping it anyway.\n", |
305 | } else { | 364 | sdata->name, sta->sta.addr, err); |
306 | sta->uploaded = true; | 365 | } else { |
366 | sta->uploaded = true; | ||
307 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG | 367 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG |
308 | if (async) | 368 | if (async) |
309 | wiphy_debug(local->hw.wiphy, | 369 | wiphy_debug(local->hw.wiphy, |
310 | "Finished adding IBSS STA %pM\n", | 370 | "Finished adding IBSS STA %pM\n", |
311 | sta->sta.addr); | 371 | sta->sta.addr); |
312 | #endif | 372 | #endif |
373 | } | ||
374 | |||
375 | sdata = sta->sdata; | ||
313 | } | 376 | } |
314 | 377 | ||
315 | sdata = sta->sdata; | 378 | if (!dummy_reinsert) { |
379 | if (!async) { | ||
380 | local->num_sta++; | ||
381 | local->sta_generation++; | ||
382 | smp_mb(); | ||
316 | 383 | ||
317 | if (!async) { | 384 | /* make the station visible */ |
318 | local->num_sta++; | 385 | spin_lock_irqsave(&local->sta_lock, flags); |
319 | local->sta_generation++; | 386 | sta_info_hash_add(local, sta); |
320 | smp_mb(); | 387 | spin_unlock_irqrestore(&local->sta_lock, flags); |
388 | } | ||
321 | 389 | ||
322 | /* make the station visible */ | 390 | list_add(&sta->list, &local->sta_list); |
323 | spin_lock_irqsave(&local->sta_lock, flags); | 391 | } else { |
324 | sta_info_hash_add(local, sta); | 392 | sta->dummy = false; |
325 | spin_unlock_irqrestore(&local->sta_lock, flags); | ||
326 | } | 393 | } |
327 | 394 | ||
328 | list_add(&sta->list, &local->sta_list); | 395 | if (!sta->dummy) { |
329 | 396 | ieee80211_sta_debugfs_add(sta); | |
330 | ieee80211_sta_debugfs_add(sta); | 397 | rate_control_add_sta_debugfs(sta); |
331 | rate_control_add_sta_debugfs(sta); | ||
332 | |||
333 | sinfo.filled = 0; | ||
334 | sinfo.generation = local->sta_generation; | ||
335 | cfg80211_new_sta(sdata->dev, sta->sta.addr, &sinfo, GFP_KERNEL); | ||
336 | 398 | ||
399 | memset(&sinfo, 0, sizeof(sinfo)); | ||
400 | sinfo.filled = 0; | ||
401 | sinfo.generation = local->sta_generation; | ||
402 | cfg80211_new_sta(sdata->dev, sta->sta.addr, &sinfo, GFP_KERNEL); | ||
403 | } | ||
337 | 404 | ||
338 | return 0; | 405 | return 0; |
339 | } | 406 | } |
@@ -350,7 +417,7 @@ static void sta_info_finish_pending(struct ieee80211_local *local) | |||
350 | list_del(&sta->list); | 417 | list_del(&sta->list); |
351 | spin_unlock_irqrestore(&local->sta_lock, flags); | 418 | spin_unlock_irqrestore(&local->sta_lock, flags); |
352 | 419 | ||
353 | sta_info_finish_insert(sta, true); | 420 | sta_info_finish_insert(sta, true, false); |
354 | 421 | ||
355 | spin_lock_irqsave(&local->sta_lock, flags); | 422 | spin_lock_irqsave(&local->sta_lock, flags); |
356 | } | 423 | } |
@@ -367,106 +434,117 @@ static void sta_info_finish_work(struct work_struct *work) | |||
367 | mutex_unlock(&local->sta_mtx); | 434 | mutex_unlock(&local->sta_mtx); |
368 | } | 435 | } |
369 | 436 | ||
370 | int sta_info_insert_rcu(struct sta_info *sta) __acquires(RCU) | 437 | static int sta_info_insert_check(struct sta_info *sta) |
371 | { | 438 | { |
372 | struct ieee80211_local *local = sta->local; | ||
373 | struct ieee80211_sub_if_data *sdata = sta->sdata; | 439 | struct ieee80211_sub_if_data *sdata = sta->sdata; |
374 | unsigned long flags; | ||
375 | int err = 0; | ||
376 | 440 | ||
377 | /* | 441 | /* |
378 | * Can't be a WARN_ON because it can be triggered through a race: | 442 | * Can't be a WARN_ON because it can be triggered through a race: |
379 | * something inserts a STA (on one CPU) without holding the RTNL | 443 | * something inserts a STA (on one CPU) without holding the RTNL |
380 | * and another CPU turns off the net device. | 444 | * and another CPU turns off the net device. |
381 | */ | 445 | */ |
382 | if (unlikely(!ieee80211_sdata_running(sdata))) { | 446 | if (unlikely(!ieee80211_sdata_running(sdata))) |
383 | err = -ENETDOWN; | 447 | return -ENETDOWN; |
384 | rcu_read_lock(); | ||
385 | goto out_free; | ||
386 | } | ||
387 | 448 | ||
388 | if (WARN_ON(compare_ether_addr(sta->sta.addr, sdata->vif.addr) == 0 || | 449 | if (WARN_ON(compare_ether_addr(sta->sta.addr, sdata->vif.addr) == 0 || |
389 | is_multicast_ether_addr(sta->sta.addr))) { | 450 | is_multicast_ether_addr(sta->sta.addr))) |
390 | err = -EINVAL; | 451 | return -EINVAL; |
452 | |||
453 | return 0; | ||
454 | } | ||
455 | |||
456 | static int sta_info_insert_ibss(struct sta_info *sta) __acquires(RCU) | ||
457 | { | ||
458 | struct ieee80211_local *local = sta->local; | ||
459 | struct ieee80211_sub_if_data *sdata = sta->sdata; | ||
460 | unsigned long flags; | ||
461 | |||
462 | spin_lock_irqsave(&local->sta_lock, flags); | ||
463 | /* check if STA exists already */ | ||
464 | if (sta_info_get_bss_rx(sdata, sta->sta.addr)) { | ||
465 | spin_unlock_irqrestore(&local->sta_lock, flags); | ||
391 | rcu_read_lock(); | 466 | rcu_read_lock(); |
392 | goto out_free; | 467 | return -EEXIST; |
393 | } | 468 | } |
394 | 469 | ||
395 | /* | 470 | local->num_sta++; |
396 | * In ad-hoc mode, we sometimes need to insert stations | 471 | local->sta_generation++; |
397 | * from tasklet context from the RX path. To avoid races, | 472 | smp_mb(); |
398 | * always do so in that case -- see the comment below. | 473 | sta_info_hash_add(local, sta); |
399 | */ | ||
400 | if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { | ||
401 | spin_lock_irqsave(&local->sta_lock, flags); | ||
402 | /* check if STA exists already */ | ||
403 | if (sta_info_get_bss(sdata, sta->sta.addr)) { | ||
404 | spin_unlock_irqrestore(&local->sta_lock, flags); | ||
405 | rcu_read_lock(); | ||
406 | err = -EEXIST; | ||
407 | goto out_free; | ||
408 | } | ||
409 | |||
410 | local->num_sta++; | ||
411 | local->sta_generation++; | ||
412 | smp_mb(); | ||
413 | sta_info_hash_add(local, sta); | ||
414 | 474 | ||
415 | list_add_tail(&sta->list, &local->sta_pending_list); | 475 | list_add_tail(&sta->list, &local->sta_pending_list); |
416 | 476 | ||
417 | rcu_read_lock(); | 477 | rcu_read_lock(); |
418 | spin_unlock_irqrestore(&local->sta_lock, flags); | 478 | spin_unlock_irqrestore(&local->sta_lock, flags); |
419 | 479 | ||
420 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG | 480 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG |
421 | wiphy_debug(local->hw.wiphy, "Added IBSS STA %pM\n", | 481 | wiphy_debug(local->hw.wiphy, "Added IBSS STA %pM\n", |
422 | sta->sta.addr); | 482 | sta->sta.addr); |
423 | #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ | 483 | #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ |
424 | 484 | ||
425 | ieee80211_queue_work(&local->hw, &local->sta_finish_work); | 485 | ieee80211_queue_work(&local->hw, &local->sta_finish_work); |
426 | 486 | ||
427 | return 0; | 487 | return 0; |
428 | } | 488 | } |
489 | |||
490 | /* | ||
491 | * should be called with sta_mtx locked | ||
492 | * this function replaces the mutex lock | ||
493 | * with a RCU lock | ||
494 | */ | ||
495 | static int sta_info_insert_non_ibss(struct sta_info *sta) __acquires(RCU) | ||
496 | { | ||
497 | struct ieee80211_local *local = sta->local; | ||
498 | struct ieee80211_sub_if_data *sdata = sta->sdata; | ||
499 | unsigned long flags; | ||
500 | struct sta_info *exist_sta; | ||
501 | bool dummy_reinsert = false; | ||
502 | int err = 0; | ||
503 | |||
504 | lockdep_assert_held(&local->sta_mtx); | ||
429 | 505 | ||
430 | /* | 506 | /* |
431 | * On first glance, this will look racy, because the code | 507 | * On first glance, this will look racy, because the code |
432 | * below this point, which inserts a station with sleeping, | 508 | * in this function, which inserts a station with sleeping, |
433 | * unlocks the sta_lock between checking existence in the | 509 | * unlocks the sta_lock between checking existence in the |
434 | * hash table and inserting into it. | 510 | * hash table and inserting into it. |
435 | * | 511 | * |
436 | * However, it is not racy against itself because it keeps | 512 | * However, it is not racy against itself because it keeps |
437 | * the mutex locked. It still seems to race against the | 513 | * the mutex locked. |
438 | * above code that atomically inserts the station... That, | ||
439 | * however, is not true because the above code can only | ||
440 | * be invoked for IBSS interfaces, and the below code will | ||
441 | * not be -- and the two do not race against each other as | ||
442 | * the hash table also keys off the interface. | ||
443 | */ | 514 | */ |
444 | 515 | ||
445 | might_sleep(); | ||
446 | |||
447 | mutex_lock(&local->sta_mtx); | ||
448 | |||
449 | spin_lock_irqsave(&local->sta_lock, flags); | 516 | spin_lock_irqsave(&local->sta_lock, flags); |
450 | /* check if STA exists already */ | 517 | /* |
451 | if (sta_info_get_bss(sdata, sta->sta.addr)) { | 518 | * check if STA exists already. |
452 | spin_unlock_irqrestore(&local->sta_lock, flags); | 519 | * only accept a scenario of a second call to sta_info_insert_non_ibss |
453 | mutex_unlock(&local->sta_mtx); | 520 | * with a dummy station entry that was inserted earlier |
454 | rcu_read_lock(); | 521 | * in that case - assume that the dummy station flag should |
455 | err = -EEXIST; | 522 | * be removed. |
456 | goto out_free; | 523 | */ |
524 | exist_sta = sta_info_get_bss_rx(sdata, sta->sta.addr); | ||
525 | if (exist_sta) { | ||
526 | if (exist_sta == sta && sta->dummy) { | ||
527 | dummy_reinsert = true; | ||
528 | } else { | ||
529 | spin_unlock_irqrestore(&local->sta_lock, flags); | ||
530 | mutex_unlock(&local->sta_mtx); | ||
531 | rcu_read_lock(); | ||
532 | return -EEXIST; | ||
533 | } | ||
457 | } | 534 | } |
458 | 535 | ||
459 | spin_unlock_irqrestore(&local->sta_lock, flags); | 536 | spin_unlock_irqrestore(&local->sta_lock, flags); |
460 | 537 | ||
461 | err = sta_info_finish_insert(sta, false); | 538 | err = sta_info_finish_insert(sta, false, dummy_reinsert); |
462 | if (err) { | 539 | if (err) { |
463 | mutex_unlock(&local->sta_mtx); | 540 | mutex_unlock(&local->sta_mtx); |
464 | rcu_read_lock(); | 541 | rcu_read_lock(); |
465 | goto out_free; | 542 | return err; |
466 | } | 543 | } |
467 | 544 | ||
468 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG | 545 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG |
469 | wiphy_debug(local->hw.wiphy, "Inserted STA %pM\n", sta->sta.addr); | 546 | wiphy_debug(local->hw.wiphy, "Inserted %sSTA %pM\n", |
547 | sta->dummy ? "dummy " : "", sta->sta.addr); | ||
470 | #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ | 548 | #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ |
471 | 549 | ||
472 | /* move reference to rcu-protected */ | 550 | /* move reference to rcu-protected */ |
@@ -477,6 +555,51 @@ int sta_info_insert_rcu(struct sta_info *sta) __acquires(RCU) | |||
477 | mesh_accept_plinks_update(sdata); | 555 | mesh_accept_plinks_update(sdata); |
478 | 556 | ||
479 | return 0; | 557 | return 0; |
558 | } | ||
559 | |||
560 | int sta_info_insert_rcu(struct sta_info *sta) __acquires(RCU) | ||
561 | { | ||
562 | struct ieee80211_local *local = sta->local; | ||
563 | struct ieee80211_sub_if_data *sdata = sta->sdata; | ||
564 | int err = 0; | ||
565 | |||
566 | err = sta_info_insert_check(sta); | ||
567 | if (err) { | ||
568 | rcu_read_lock(); | ||
569 | goto out_free; | ||
570 | } | ||
571 | |||
572 | /* | ||
573 | * In ad-hoc mode, we sometimes need to insert stations | ||
574 | * from tasklet context from the RX path. To avoid races, | ||
575 | * always do so in that case -- see the comment below. | ||
576 | */ | ||
577 | if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { | ||
578 | err = sta_info_insert_ibss(sta); | ||
579 | if (err) | ||
580 | goto out_free; | ||
581 | |||
582 | return 0; | ||
583 | } | ||
584 | |||
585 | /* | ||
586 | * It might seem that the function called below is in race against | ||
587 | * the function call above that atomically inserts the station... That, | ||
588 | * however, is not true because the above code can only | ||
589 | * be invoked for IBSS interfaces, and the below code will | ||
590 | * not be -- and the two do not race against each other as | ||
591 | * the hash table also keys off the interface. | ||
592 | */ | ||
593 | |||
594 | might_sleep(); | ||
595 | |||
596 | mutex_lock(&local->sta_mtx); | ||
597 | |||
598 | err = sta_info_insert_non_ibss(sta); | ||
599 | if (err) | ||
600 | goto out_free; | ||
601 | |||
602 | return 0; | ||
480 | out_free: | 603 | out_free: |
481 | BUG_ON(!err); | 604 | BUG_ON(!err); |
482 | __sta_info_free(local, sta); | 605 | __sta_info_free(local, sta); |
@@ -492,6 +615,25 @@ int sta_info_insert(struct sta_info *sta) | |||
492 | return err; | 615 | return err; |
493 | } | 616 | } |
494 | 617 | ||
618 | /* Caller must hold sta->local->sta_mtx */ | ||
619 | int sta_info_reinsert(struct sta_info *sta) | ||
620 | { | ||
621 | struct ieee80211_local *local = sta->local; | ||
622 | int err = 0; | ||
623 | |||
624 | err = sta_info_insert_check(sta); | ||
625 | if (err) { | ||
626 | mutex_unlock(&local->sta_mtx); | ||
627 | return err; | ||
628 | } | ||
629 | |||
630 | might_sleep(); | ||
631 | |||
632 | err = sta_info_insert_non_ibss(sta); | ||
633 | rcu_read_unlock(); | ||
634 | return err; | ||
635 | } | ||
636 | |||
495 | static inline void __bss_tim_set(struct ieee80211_if_ap *bss, u16 aid) | 637 | static inline void __bss_tim_set(struct ieee80211_if_ap *bss, u16 aid) |
496 | { | 638 | { |
497 | /* | 639 | /* |
@@ -510,64 +652,93 @@ static inline void __bss_tim_clear(struct ieee80211_if_ap *bss, u16 aid) | |||
510 | bss->tim[aid / 8] &= ~(1 << (aid % 8)); | 652 | bss->tim[aid / 8] &= ~(1 << (aid % 8)); |
511 | } | 653 | } |
512 | 654 | ||
513 | static void __sta_info_set_tim_bit(struct ieee80211_if_ap *bss, | 655 | static unsigned long ieee80211_tids_for_ac(int ac) |
514 | struct sta_info *sta) | ||
515 | { | 656 | { |
516 | BUG_ON(!bss); | 657 | /* If we ever support TIDs > 7, this obviously needs to be adjusted */ |
517 | 658 | switch (ac) { | |
518 | __bss_tim_set(bss, sta->sta.aid); | 659 | case IEEE80211_AC_VO: |
519 | 660 | return BIT(6) | BIT(7); | |
520 | if (sta->local->ops->set_tim) { | 661 | case IEEE80211_AC_VI: |
521 | sta->local->tim_in_locked_section = true; | 662 | return BIT(4) | BIT(5); |
522 | drv_set_tim(sta->local, &sta->sta, true); | 663 | case IEEE80211_AC_BE: |
523 | sta->local->tim_in_locked_section = false; | 664 | return BIT(0) | BIT(3); |
665 | case IEEE80211_AC_BK: | ||
666 | return BIT(1) | BIT(2); | ||
667 | default: | ||
668 | WARN_ON(1); | ||
669 | return 0; | ||
524 | } | 670 | } |
525 | } | 671 | } |
526 | 672 | ||
527 | void sta_info_set_tim_bit(struct sta_info *sta) | 673 | void sta_info_recalc_tim(struct sta_info *sta) |
528 | { | 674 | { |
675 | struct ieee80211_local *local = sta->local; | ||
676 | struct ieee80211_if_ap *bss = sta->sdata->bss; | ||
529 | unsigned long flags; | 677 | unsigned long flags; |
678 | bool indicate_tim = false; | ||
679 | u8 ignore_for_tim = sta->sta.uapsd_queues; | ||
680 | int ac; | ||
530 | 681 | ||
531 | BUG_ON(!sta->sdata->bss); | 682 | if (WARN_ON_ONCE(!sta->sdata->bss)) |
683 | return; | ||
532 | 684 | ||
533 | spin_lock_irqsave(&sta->local->sta_lock, flags); | 685 | /* No need to do anything if the driver does all */ |
534 | __sta_info_set_tim_bit(sta->sdata->bss, sta); | 686 | if (local->hw.flags & IEEE80211_HW_AP_LINK_PS) |
535 | spin_unlock_irqrestore(&sta->local->sta_lock, flags); | 687 | return; |
536 | } | ||
537 | 688 | ||
538 | static void __sta_info_clear_tim_bit(struct ieee80211_if_ap *bss, | 689 | if (sta->dead) |
539 | struct sta_info *sta) | 690 | goto done; |
540 | { | 691 | |
541 | BUG_ON(!bss); | 692 | /* |
693 | * If all ACs are delivery-enabled then we should build | ||
694 | * the TIM bit for all ACs anyway; if only some are then | ||
695 | * we ignore those and build the TIM bit using only the | ||
696 | * non-enabled ones. | ||
697 | */ | ||
698 | if (ignore_for_tim == BIT(IEEE80211_NUM_ACS) - 1) | ||
699 | ignore_for_tim = 0; | ||
700 | |||
701 | for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { | ||
702 | unsigned long tids; | ||
542 | 703 | ||
543 | __bss_tim_clear(bss, sta->sta.aid); | 704 | if (ignore_for_tim & BIT(ac)) |
705 | continue; | ||
706 | |||
707 | indicate_tim |= !skb_queue_empty(&sta->tx_filtered[ac]) || | ||
708 | !skb_queue_empty(&sta->ps_tx_buf[ac]); | ||
709 | if (indicate_tim) | ||
710 | break; | ||
544 | 711 | ||
545 | if (sta->local->ops->set_tim) { | 712 | tids = ieee80211_tids_for_ac(ac); |
546 | sta->local->tim_in_locked_section = true; | 713 | |
547 | drv_set_tim(sta->local, &sta->sta, false); | 714 | indicate_tim |= |
548 | sta->local->tim_in_locked_section = false; | 715 | sta->driver_buffered_tids & tids; |
549 | } | 716 | } |
550 | } | ||
551 | 717 | ||
552 | void sta_info_clear_tim_bit(struct sta_info *sta) | 718 | done: |
553 | { | 719 | spin_lock_irqsave(&local->sta_lock, flags); |
554 | unsigned long flags; | ||
555 | 720 | ||
556 | BUG_ON(!sta->sdata->bss); | 721 | if (indicate_tim) |
722 | __bss_tim_set(bss, sta->sta.aid); | ||
723 | else | ||
724 | __bss_tim_clear(bss, sta->sta.aid); | ||
557 | 725 | ||
558 | spin_lock_irqsave(&sta->local->sta_lock, flags); | 726 | if (local->ops->set_tim) { |
559 | __sta_info_clear_tim_bit(sta->sdata->bss, sta); | 727 | local->tim_in_locked_section = true; |
560 | spin_unlock_irqrestore(&sta->local->sta_lock, flags); | 728 | drv_set_tim(local, &sta->sta, indicate_tim); |
729 | local->tim_in_locked_section = false; | ||
730 | } | ||
731 | |||
732 | spin_unlock_irqrestore(&local->sta_lock, flags); | ||
561 | } | 733 | } |
562 | 734 | ||
563 | static int sta_info_buffer_expired(struct sta_info *sta, | 735 | static bool sta_info_buffer_expired(struct sta_info *sta, struct sk_buff *skb) |
564 | struct sk_buff *skb) | ||
565 | { | 736 | { |
566 | struct ieee80211_tx_info *info; | 737 | struct ieee80211_tx_info *info; |
567 | int timeout; | 738 | int timeout; |
568 | 739 | ||
569 | if (!skb) | 740 | if (!skb) |
570 | return 0; | 741 | return false; |
571 | 742 | ||
572 | info = IEEE80211_SKB_CB(skb); | 743 | info = IEEE80211_SKB_CB(skb); |
573 | 744 | ||
@@ -581,24 +752,59 @@ static int sta_info_buffer_expired(struct sta_info *sta, | |||
581 | } | 752 | } |
582 | 753 | ||
583 | 754 | ||
584 | static bool sta_info_cleanup_expire_buffered(struct ieee80211_local *local, | 755 | static bool sta_info_cleanup_expire_buffered_ac(struct ieee80211_local *local, |
585 | struct sta_info *sta) | 756 | struct sta_info *sta, int ac) |
586 | { | 757 | { |
587 | unsigned long flags; | 758 | unsigned long flags; |
588 | struct sk_buff *skb; | 759 | struct sk_buff *skb; |
589 | 760 | ||
590 | if (skb_queue_empty(&sta->ps_tx_buf)) | 761 | /* |
591 | return false; | 762 | * First check for frames that should expire on the filtered |
763 | * queue. Frames here were rejected by the driver and are on | ||
764 | * a separate queue to avoid reordering with normal PS-buffered | ||
765 | * frames. They also aren't accounted for right now in the | ||
766 | * total_ps_buffered counter. | ||
767 | */ | ||
768 | for (;;) { | ||
769 | spin_lock_irqsave(&sta->tx_filtered[ac].lock, flags); | ||
770 | skb = skb_peek(&sta->tx_filtered[ac]); | ||
771 | if (sta_info_buffer_expired(sta, skb)) | ||
772 | skb = __skb_dequeue(&sta->tx_filtered[ac]); | ||
773 | else | ||
774 | skb = NULL; | ||
775 | spin_unlock_irqrestore(&sta->tx_filtered[ac].lock, flags); | ||
592 | 776 | ||
777 | /* | ||
778 | * Frames are queued in order, so if this one | ||
779 | * hasn't expired yet we can stop testing. If | ||
780 | * we actually reached the end of the queue we | ||
781 | * also need to stop, of course. | ||
782 | */ | ||
783 | if (!skb) | ||
784 | break; | ||
785 | dev_kfree_skb(skb); | ||
786 | } | ||
787 | |||
788 | /* | ||
789 | * Now also check the normal PS-buffered queue, this will | ||
790 | * only find something if the filtered queue was emptied | ||
791 | * since the filtered frames are all before the normal PS | ||
792 | * buffered frames. | ||
793 | */ | ||
593 | for (;;) { | 794 | for (;;) { |
594 | spin_lock_irqsave(&sta->ps_tx_buf.lock, flags); | 795 | spin_lock_irqsave(&sta->ps_tx_buf[ac].lock, flags); |
595 | skb = skb_peek(&sta->ps_tx_buf); | 796 | skb = skb_peek(&sta->ps_tx_buf[ac]); |
596 | if (sta_info_buffer_expired(sta, skb)) | 797 | if (sta_info_buffer_expired(sta, skb)) |
597 | skb = __skb_dequeue(&sta->ps_tx_buf); | 798 | skb = __skb_dequeue(&sta->ps_tx_buf[ac]); |
598 | else | 799 | else |
599 | skb = NULL; | 800 | skb = NULL; |
600 | spin_unlock_irqrestore(&sta->ps_tx_buf.lock, flags); | 801 | spin_unlock_irqrestore(&sta->ps_tx_buf[ac].lock, flags); |
601 | 802 | ||
803 | /* | ||
804 | * frames are queued in order, so if this one | ||
805 | * hasn't expired yet (or we reached the end of | ||
806 | * the queue) we can stop testing | ||
807 | */ | ||
602 | if (!skb) | 808 | if (!skb) |
603 | break; | 809 | break; |
604 | 810 | ||
@@ -608,22 +814,47 @@ static bool sta_info_cleanup_expire_buffered(struct ieee80211_local *local, | |||
608 | sta->sta.addr); | 814 | sta->sta.addr); |
609 | #endif | 815 | #endif |
610 | dev_kfree_skb(skb); | 816 | dev_kfree_skb(skb); |
611 | |||
612 | if (skb_queue_empty(&sta->ps_tx_buf) && | ||
613 | !test_sta_flags(sta, WLAN_STA_PS_DRIVER_BUF)) | ||
614 | sta_info_clear_tim_bit(sta); | ||
615 | } | 817 | } |
616 | 818 | ||
617 | return true; | 819 | /* |
820 | * Finally, recalculate the TIM bit for this station -- it might | ||
821 | * now be clear because the station was too slow to retrieve its | ||
822 | * frames. | ||
823 | */ | ||
824 | sta_info_recalc_tim(sta); | ||
825 | |||
826 | /* | ||
827 | * Return whether there are any frames still buffered, this is | ||
828 | * used to check whether the cleanup timer still needs to run, | ||
829 | * if there are no frames we don't need to rearm the timer. | ||
830 | */ | ||
831 | return !(skb_queue_empty(&sta->ps_tx_buf[ac]) && | ||
832 | skb_queue_empty(&sta->tx_filtered[ac])); | ||
833 | } | ||
834 | |||
835 | static bool sta_info_cleanup_expire_buffered(struct ieee80211_local *local, | ||
836 | struct sta_info *sta) | ||
837 | { | ||
838 | bool have_buffered = false; | ||
839 | int ac; | ||
840 | |||
841 | /* This is only necessary for stations on BSS interfaces */ | ||
842 | if (!sta->sdata->bss) | ||
843 | return false; | ||
844 | |||
845 | for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) | ||
846 | have_buffered |= | ||
847 | sta_info_cleanup_expire_buffered_ac(local, sta, ac); | ||
848 | |||
849 | return have_buffered; | ||
618 | } | 850 | } |
619 | 851 | ||
620 | static int __must_check __sta_info_destroy(struct sta_info *sta) | 852 | static int __must_check __sta_info_destroy(struct sta_info *sta) |
621 | { | 853 | { |
622 | struct ieee80211_local *local; | 854 | struct ieee80211_local *local; |
623 | struct ieee80211_sub_if_data *sdata; | 855 | struct ieee80211_sub_if_data *sdata; |
624 | struct sk_buff *skb; | ||
625 | unsigned long flags; | 856 | unsigned long flags; |
626 | int ret, i; | 857 | int ret, i, ac; |
627 | 858 | ||
628 | might_sleep(); | 859 | might_sleep(); |
629 | 860 | ||
@@ -639,7 +870,7 @@ static int __must_check __sta_info_destroy(struct sta_info *sta) | |||
639 | * sessions -- block that to make sure the tear-down | 870 | * sessions -- block that to make sure the tear-down |
640 | * will be sufficient. | 871 | * will be sufficient. |
641 | */ | 872 | */ |
642 | set_sta_flags(sta, WLAN_STA_BLOCK_BA); | 873 | set_sta_flag(sta, WLAN_STA_BLOCK_BA); |
643 | ieee80211_sta_tear_down_BA_sessions(sta, true); | 874 | ieee80211_sta_tear_down_BA_sessions(sta, true); |
644 | 875 | ||
645 | spin_lock_irqsave(&local->sta_lock, flags); | 876 | spin_lock_irqsave(&local->sta_lock, flags); |
@@ -660,19 +891,22 @@ static int __must_check __sta_info_destroy(struct sta_info *sta) | |||
660 | 891 | ||
661 | sta->dead = true; | 892 | sta->dead = true; |
662 | 893 | ||
663 | if (test_and_clear_sta_flags(sta, | 894 | if (test_sta_flag(sta, WLAN_STA_PS_STA) || |
664 | WLAN_STA_PS_STA | WLAN_STA_PS_DRIVER)) { | 895 | test_sta_flag(sta, WLAN_STA_PS_DRIVER)) { |
665 | BUG_ON(!sdata->bss); | 896 | BUG_ON(!sdata->bss); |
666 | 897 | ||
898 | clear_sta_flag(sta, WLAN_STA_PS_STA); | ||
899 | clear_sta_flag(sta, WLAN_STA_PS_DRIVER); | ||
900 | |||
667 | atomic_dec(&sdata->bss->num_sta_ps); | 901 | atomic_dec(&sdata->bss->num_sta_ps); |
668 | sta_info_clear_tim_bit(sta); | 902 | sta_info_recalc_tim(sta); |
669 | } | 903 | } |
670 | 904 | ||
671 | local->num_sta--; | 905 | local->num_sta--; |
672 | local->sta_generation++; | 906 | local->sta_generation++; |
673 | 907 | ||
674 | if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) | 908 | if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) |
675 | rcu_assign_pointer(sdata->u.vlan.sta, NULL); | 909 | RCU_INIT_POINTER(sdata->u.vlan.sta, NULL); |
676 | 910 | ||
677 | if (sta->uploaded) { | 911 | if (sta->uploaded) { |
678 | if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) | 912 | if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) |
@@ -691,6 +925,12 @@ static int __must_check __sta_info_destroy(struct sta_info *sta) | |||
691 | */ | 925 | */ |
692 | synchronize_rcu(); | 926 | synchronize_rcu(); |
693 | 927 | ||
928 | for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { | ||
929 | local->total_ps_buffered -= skb_queue_len(&sta->ps_tx_buf[ac]); | ||
930 | __skb_queue_purge(&sta->ps_tx_buf[ac]); | ||
931 | __skb_queue_purge(&sta->tx_filtered[ac]); | ||
932 | } | ||
933 | |||
694 | #ifdef CONFIG_MAC80211_MESH | 934 | #ifdef CONFIG_MAC80211_MESH |
695 | if (ieee80211_vif_is_mesh(&sdata->vif)) | 935 | if (ieee80211_vif_is_mesh(&sdata->vif)) |
696 | mesh_accept_plinks_update(sdata); | 936 | mesh_accept_plinks_update(sdata); |
@@ -713,14 +953,6 @@ static int __must_check __sta_info_destroy(struct sta_info *sta) | |||
713 | } | 953 | } |
714 | #endif | 954 | #endif |
715 | 955 | ||
716 | while ((skb = skb_dequeue(&sta->ps_tx_buf)) != NULL) { | ||
717 | local->total_ps_buffered--; | ||
718 | dev_kfree_skb_any(skb); | ||
719 | } | ||
720 | |||
721 | while ((skb = skb_dequeue(&sta->tx_filtered)) != NULL) | ||
722 | dev_kfree_skb_any(skb); | ||
723 | |||
724 | __sta_info_free(local, sta); | 956 | __sta_info_free(local, sta); |
725 | 957 | ||
726 | return 0; | 958 | return 0; |
@@ -732,7 +964,7 @@ int sta_info_destroy_addr(struct ieee80211_sub_if_data *sdata, const u8 *addr) | |||
732 | int ret; | 964 | int ret; |
733 | 965 | ||
734 | mutex_lock(&sdata->local->sta_mtx); | 966 | mutex_lock(&sdata->local->sta_mtx); |
735 | sta = sta_info_get(sdata, addr); | 967 | sta = sta_info_get_rx(sdata, addr); |
736 | ret = __sta_info_destroy(sta); | 968 | ret = __sta_info_destroy(sta); |
737 | mutex_unlock(&sdata->local->sta_mtx); | 969 | mutex_unlock(&sdata->local->sta_mtx); |
738 | 970 | ||
@@ -746,7 +978,7 @@ int sta_info_destroy_addr_bss(struct ieee80211_sub_if_data *sdata, | |||
746 | int ret; | 978 | int ret; |
747 | 979 | ||
748 | mutex_lock(&sdata->local->sta_mtx); | 980 | mutex_lock(&sdata->local->sta_mtx); |
749 | sta = sta_info_get_bss(sdata, addr); | 981 | sta = sta_info_get_bss_rx(sdata, addr); |
750 | ret = __sta_info_destroy(sta); | 982 | ret = __sta_info_destroy(sta); |
751 | mutex_unlock(&sdata->local->sta_mtx); | 983 | mutex_unlock(&sdata->local->sta_mtx); |
752 | 984 | ||
@@ -886,7 +1118,8 @@ static void clear_sta_ps_flags(void *_sta) | |||
886 | { | 1118 | { |
887 | struct sta_info *sta = _sta; | 1119 | struct sta_info *sta = _sta; |
888 | 1120 | ||
889 | clear_sta_flags(sta, WLAN_STA_PS_DRIVER | WLAN_STA_PS_STA); | 1121 | clear_sta_flag(sta, WLAN_STA_PS_DRIVER); |
1122 | clear_sta_flag(sta, WLAN_STA_PS_STA); | ||
890 | } | 1123 | } |
891 | 1124 | ||
892 | /* powersave support code */ | 1125 | /* powersave support code */ |
@@ -894,88 +1127,341 @@ void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta) | |||
894 | { | 1127 | { |
895 | struct ieee80211_sub_if_data *sdata = sta->sdata; | 1128 | struct ieee80211_sub_if_data *sdata = sta->sdata; |
896 | struct ieee80211_local *local = sdata->local; | 1129 | struct ieee80211_local *local = sdata->local; |
897 | int sent, buffered; | 1130 | struct sk_buff_head pending; |
1131 | int filtered = 0, buffered = 0, ac; | ||
1132 | |||
1133 | clear_sta_flag(sta, WLAN_STA_SP); | ||
1134 | |||
1135 | BUILD_BUG_ON(BITS_TO_LONGS(STA_TID_NUM) > 1); | ||
1136 | sta->driver_buffered_tids = 0; | ||
898 | 1137 | ||
899 | clear_sta_flags(sta, WLAN_STA_PS_DRIVER_BUF); | ||
900 | if (!(local->hw.flags & IEEE80211_HW_AP_LINK_PS)) | 1138 | if (!(local->hw.flags & IEEE80211_HW_AP_LINK_PS)) |
901 | drv_sta_notify(local, sdata, STA_NOTIFY_AWAKE, &sta->sta); | 1139 | drv_sta_notify(local, sdata, STA_NOTIFY_AWAKE, &sta->sta); |
902 | 1140 | ||
903 | if (!skb_queue_empty(&sta->ps_tx_buf)) | 1141 | skb_queue_head_init(&pending); |
904 | sta_info_clear_tim_bit(sta); | ||
905 | 1142 | ||
906 | /* Send all buffered frames to the station */ | 1143 | /* Send all buffered frames to the station */ |
907 | sent = ieee80211_add_pending_skbs(local, &sta->tx_filtered); | 1144 | for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { |
908 | buffered = ieee80211_add_pending_skbs_fn(local, &sta->ps_tx_buf, | 1145 | int count = skb_queue_len(&pending), tmp; |
909 | clear_sta_ps_flags, sta); | 1146 | |
910 | sent += buffered; | 1147 | skb_queue_splice_tail_init(&sta->tx_filtered[ac], &pending); |
1148 | tmp = skb_queue_len(&pending); | ||
1149 | filtered += tmp - count; | ||
1150 | count = tmp; | ||
1151 | |||
1152 | skb_queue_splice_tail_init(&sta->ps_tx_buf[ac], &pending); | ||
1153 | tmp = skb_queue_len(&pending); | ||
1154 | buffered += tmp - count; | ||
1155 | } | ||
1156 | |||
1157 | ieee80211_add_pending_skbs_fn(local, &pending, clear_sta_ps_flags, sta); | ||
1158 | |||
911 | local->total_ps_buffered -= buffered; | 1159 | local->total_ps_buffered -= buffered; |
912 | 1160 | ||
1161 | sta_info_recalc_tim(sta); | ||
1162 | |||
913 | #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG | 1163 | #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG |
914 | printk(KERN_DEBUG "%s: STA %pM aid %d sending %d filtered/%d PS frames " | 1164 | printk(KERN_DEBUG "%s: STA %pM aid %d sending %d filtered/%d PS frames " |
915 | "since STA not sleeping anymore\n", sdata->name, | 1165 | "since STA not sleeping anymore\n", sdata->name, |
916 | sta->sta.addr, sta->sta.aid, sent - buffered, buffered); | 1166 | sta->sta.addr, sta->sta.aid, filtered, buffered); |
917 | #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */ | 1167 | #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */ |
918 | } | 1168 | } |
919 | 1169 | ||
920 | void ieee80211_sta_ps_deliver_poll_response(struct sta_info *sta) | 1170 | static void ieee80211_send_null_response(struct ieee80211_sub_if_data *sdata, |
1171 | struct sta_info *sta, int tid, | ||
1172 | enum ieee80211_frame_release_type reason) | ||
921 | { | 1173 | { |
922 | struct ieee80211_sub_if_data *sdata = sta->sdata; | ||
923 | struct ieee80211_local *local = sdata->local; | 1174 | struct ieee80211_local *local = sdata->local; |
1175 | struct ieee80211_qos_hdr *nullfunc; | ||
924 | struct sk_buff *skb; | 1176 | struct sk_buff *skb; |
925 | int no_pending_pkts; | 1177 | int size = sizeof(*nullfunc); |
1178 | __le16 fc; | ||
1179 | bool qos = test_sta_flag(sta, WLAN_STA_WME); | ||
1180 | struct ieee80211_tx_info *info; | ||
926 | 1181 | ||
927 | skb = skb_dequeue(&sta->tx_filtered); | 1182 | if (qos) { |
928 | if (!skb) { | 1183 | fc = cpu_to_le16(IEEE80211_FTYPE_DATA | |
929 | skb = skb_dequeue(&sta->ps_tx_buf); | 1184 | IEEE80211_STYPE_QOS_NULLFUNC | |
930 | if (skb) | 1185 | IEEE80211_FCTL_FROMDS); |
931 | local->total_ps_buffered--; | 1186 | } else { |
1187 | size -= 2; | ||
1188 | fc = cpu_to_le16(IEEE80211_FTYPE_DATA | | ||
1189 | IEEE80211_STYPE_NULLFUNC | | ||
1190 | IEEE80211_FCTL_FROMDS); | ||
1191 | } | ||
1192 | |||
1193 | skb = dev_alloc_skb(local->hw.extra_tx_headroom + size); | ||
1194 | if (!skb) | ||
1195 | return; | ||
1196 | |||
1197 | skb_reserve(skb, local->hw.extra_tx_headroom); | ||
1198 | |||
1199 | nullfunc = (void *) skb_put(skb, size); | ||
1200 | nullfunc->frame_control = fc; | ||
1201 | nullfunc->duration_id = 0; | ||
1202 | memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN); | ||
1203 | memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN); | ||
1204 | memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN); | ||
1205 | |||
1206 | skb->priority = tid; | ||
1207 | skb_set_queue_mapping(skb, ieee802_1d_to_ac[tid]); | ||
1208 | if (qos) { | ||
1209 | nullfunc->qos_ctrl = cpu_to_le16(tid); | ||
1210 | |||
1211 | if (reason == IEEE80211_FRAME_RELEASE_UAPSD) | ||
1212 | nullfunc->qos_ctrl |= | ||
1213 | cpu_to_le16(IEEE80211_QOS_CTL_EOSP); | ||
932 | } | 1214 | } |
933 | no_pending_pkts = skb_queue_empty(&sta->tx_filtered) && | ||
934 | skb_queue_empty(&sta->ps_tx_buf); | ||
935 | 1215 | ||
936 | if (skb) { | 1216 | info = IEEE80211_SKB_CB(skb); |
937 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); | 1217 | |
938 | struct ieee80211_hdr *hdr = | 1218 | /* |
939 | (struct ieee80211_hdr *) skb->data; | 1219 | * Tell TX path to send this frame even though the |
1220 | * STA may still remain is PS mode after this frame | ||
1221 | * exchange. Also set EOSP to indicate this packet | ||
1222 | * ends the poll/service period. | ||
1223 | */ | ||
1224 | info->flags |= IEEE80211_TX_CTL_POLL_RESPONSE | | ||
1225 | IEEE80211_TX_STATUS_EOSP | | ||
1226 | IEEE80211_TX_CTL_REQ_TX_STATUS; | ||
1227 | |||
1228 | drv_allow_buffered_frames(local, sta, BIT(tid), 1, reason, false); | ||
1229 | |||
1230 | ieee80211_xmit(sdata, skb); | ||
1231 | } | ||
1232 | |||
1233 | static void | ||
1234 | ieee80211_sta_ps_deliver_response(struct sta_info *sta, | ||
1235 | int n_frames, u8 ignored_acs, | ||
1236 | enum ieee80211_frame_release_type reason) | ||
1237 | { | ||
1238 | struct ieee80211_sub_if_data *sdata = sta->sdata; | ||
1239 | struct ieee80211_local *local = sdata->local; | ||
1240 | bool found = false; | ||
1241 | bool more_data = false; | ||
1242 | int ac; | ||
1243 | unsigned long driver_release_tids = 0; | ||
1244 | struct sk_buff_head frames; | ||
1245 | |||
1246 | /* Service or PS-Poll period starts */ | ||
1247 | set_sta_flag(sta, WLAN_STA_SP); | ||
1248 | |||
1249 | __skb_queue_head_init(&frames); | ||
1250 | |||
1251 | /* | ||
1252 | * Get response frame(s) and more data bit for it. | ||
1253 | */ | ||
1254 | for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { | ||
1255 | unsigned long tids; | ||
1256 | |||
1257 | if (ignored_acs & BIT(ac)) | ||
1258 | continue; | ||
1259 | |||
1260 | tids = ieee80211_tids_for_ac(ac); | ||
1261 | |||
1262 | if (!found) { | ||
1263 | driver_release_tids = sta->driver_buffered_tids & tids; | ||
1264 | if (driver_release_tids) { | ||
1265 | found = true; | ||
1266 | } else { | ||
1267 | struct sk_buff *skb; | ||
1268 | |||
1269 | while (n_frames > 0) { | ||
1270 | skb = skb_dequeue(&sta->tx_filtered[ac]); | ||
1271 | if (!skb) { | ||
1272 | skb = skb_dequeue( | ||
1273 | &sta->ps_tx_buf[ac]); | ||
1274 | if (skb) | ||
1275 | local->total_ps_buffered--; | ||
1276 | } | ||
1277 | if (!skb) | ||
1278 | break; | ||
1279 | n_frames--; | ||
1280 | found = true; | ||
1281 | __skb_queue_tail(&frames, skb); | ||
1282 | } | ||
1283 | } | ||
1284 | |||
1285 | /* | ||
1286 | * If the driver has data on more than one TID then | ||
1287 | * certainly there's more data if we release just a | ||
1288 | * single frame now (from a single TID). | ||
1289 | */ | ||
1290 | if (reason == IEEE80211_FRAME_RELEASE_PSPOLL && | ||
1291 | hweight16(driver_release_tids) > 1) { | ||
1292 | more_data = true; | ||
1293 | driver_release_tids = | ||
1294 | BIT(ffs(driver_release_tids) - 1); | ||
1295 | break; | ||
1296 | } | ||
1297 | } | ||
1298 | |||
1299 | if (!skb_queue_empty(&sta->tx_filtered[ac]) || | ||
1300 | !skb_queue_empty(&sta->ps_tx_buf[ac])) { | ||
1301 | more_data = true; | ||
1302 | break; | ||
1303 | } | ||
1304 | } | ||
1305 | |||
1306 | if (!found) { | ||
1307 | int tid; | ||
940 | 1308 | ||
941 | /* | 1309 | /* |
942 | * Tell TX path to send this frame even though the STA may | 1310 | * For PS-Poll, this can only happen due to a race condition |
943 | * still remain is PS mode after this frame exchange. | 1311 | * when we set the TIM bit and the station notices it, but |
1312 | * before it can poll for the frame we expire it. | ||
1313 | * | ||
1314 | * For uAPSD, this is said in the standard (11.2.1.5 h): | ||
1315 | * At each unscheduled SP for a non-AP STA, the AP shall | ||
1316 | * attempt to transmit at least one MSDU or MMPDU, but no | ||
1317 | * more than the value specified in the Max SP Length field | ||
1318 | * in the QoS Capability element from delivery-enabled ACs, | ||
1319 | * that are destined for the non-AP STA. | ||
1320 | * | ||
1321 | * Since we have no other MSDU/MMPDU, transmit a QoS null frame. | ||
944 | */ | 1322 | */ |
945 | info->flags |= IEEE80211_TX_CTL_PSPOLL_RESPONSE; | ||
946 | 1323 | ||
947 | #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG | 1324 | /* This will evaluate to 1, 3, 5 or 7. */ |
948 | printk(KERN_DEBUG "STA %pM aid %d: PS Poll (entries after %d)\n", | 1325 | tid = 7 - ((ffs(~ignored_acs) - 1) << 1); |
949 | sta->sta.addr, sta->sta.aid, | ||
950 | skb_queue_len(&sta->ps_tx_buf)); | ||
951 | #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */ | ||
952 | 1326 | ||
953 | /* Use MoreData flag to indicate whether there are more | 1327 | ieee80211_send_null_response(sdata, sta, tid, reason); |
954 | * buffered frames for this STA */ | 1328 | return; |
955 | if (no_pending_pkts) | 1329 | } |
956 | hdr->frame_control &= cpu_to_le16(~IEEE80211_FCTL_MOREDATA); | 1330 | |
957 | else | 1331 | if (!driver_release_tids) { |
958 | hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_MOREDATA); | 1332 | struct sk_buff_head pending; |
1333 | struct sk_buff *skb; | ||
1334 | int num = 0; | ||
1335 | u16 tids = 0; | ||
1336 | |||
1337 | skb_queue_head_init(&pending); | ||
1338 | |||
1339 | while ((skb = __skb_dequeue(&frames))) { | ||
1340 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); | ||
1341 | struct ieee80211_hdr *hdr = (void *) skb->data; | ||
1342 | u8 *qoshdr = NULL; | ||
1343 | |||
1344 | num++; | ||
1345 | |||
1346 | /* | ||
1347 | * Tell TX path to send this frame even though the | ||
1348 | * STA may still remain is PS mode after this frame | ||
1349 | * exchange. | ||
1350 | */ | ||
1351 | info->flags |= IEEE80211_TX_CTL_POLL_RESPONSE; | ||
1352 | |||
1353 | /* | ||
1354 | * Use MoreData flag to indicate whether there are | ||
1355 | * more buffered frames for this STA | ||
1356 | */ | ||
1357 | if (!more_data) | ||
1358 | hdr->frame_control &= | ||
1359 | cpu_to_le16(~IEEE80211_FCTL_MOREDATA); | ||
1360 | else | ||
1361 | hdr->frame_control |= | ||
1362 | cpu_to_le16(IEEE80211_FCTL_MOREDATA); | ||
1363 | |||
1364 | if (ieee80211_is_data_qos(hdr->frame_control) || | ||
1365 | ieee80211_is_qos_nullfunc(hdr->frame_control)) | ||
1366 | qoshdr = ieee80211_get_qos_ctl(hdr); | ||
1367 | |||
1368 | /* set EOSP for the frame */ | ||
1369 | if (reason == IEEE80211_FRAME_RELEASE_UAPSD && | ||
1370 | qoshdr && skb_queue_empty(&frames)) | ||
1371 | *qoshdr |= IEEE80211_QOS_CTL_EOSP; | ||
1372 | |||
1373 | info->flags |= IEEE80211_TX_STATUS_EOSP | | ||
1374 | IEEE80211_TX_CTL_REQ_TX_STATUS; | ||
1375 | |||
1376 | if (qoshdr) | ||
1377 | tids |= BIT(*qoshdr & IEEE80211_QOS_CTL_TID_MASK); | ||
1378 | else | ||
1379 | tids |= BIT(0); | ||
1380 | |||
1381 | __skb_queue_tail(&pending, skb); | ||
1382 | } | ||
959 | 1383 | ||
960 | ieee80211_add_pending_skb(local, skb); | 1384 | drv_allow_buffered_frames(local, sta, tids, num, |
1385 | reason, more_data); | ||
961 | 1386 | ||
962 | if (no_pending_pkts) | 1387 | ieee80211_add_pending_skbs(local, &pending); |
963 | sta_info_clear_tim_bit(sta); | 1388 | |
964 | #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG | 1389 | sta_info_recalc_tim(sta); |
965 | } else { | 1390 | } else { |
966 | /* | 1391 | /* |
967 | * FIXME: This can be the result of a race condition between | 1392 | * We need to release a frame that is buffered somewhere in the |
968 | * us expiring a frame and the station polling for it. | 1393 | * driver ... it'll have to handle that. |
969 | * Should we send it a null-func frame indicating we | 1394 | * Note that, as per the comment above, it'll also have to see |
970 | * have nothing buffered for it? | 1395 | * if there is more than just one frame on the specific TID that |
1396 | * we're releasing from, and it needs to set the more-data bit | ||
1397 | * accordingly if we tell it that there's no more data. If we do | ||
1398 | * tell it there's more data, then of course the more-data bit | ||
1399 | * needs to be set anyway. | ||
1400 | */ | ||
1401 | drv_release_buffered_frames(local, sta, driver_release_tids, | ||
1402 | n_frames, reason, more_data); | ||
1403 | |||
1404 | /* | ||
1405 | * Note that we don't recalculate the TIM bit here as it would | ||
1406 | * most likely have no effect at all unless the driver told us | ||
1407 | * that the TID became empty before returning here from the | ||
1408 | * release function. | ||
1409 | * Either way, however, when the driver tells us that the TID | ||
1410 | * became empty we'll do the TIM recalculation. | ||
971 | */ | 1411 | */ |
972 | printk(KERN_DEBUG "%s: STA %pM sent PS Poll even " | ||
973 | "though there are no buffered frames for it\n", | ||
974 | sdata->name, sta->sta.addr); | ||
975 | #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */ | ||
976 | } | 1412 | } |
977 | } | 1413 | } |
978 | 1414 | ||
1415 | void ieee80211_sta_ps_deliver_poll_response(struct sta_info *sta) | ||
1416 | { | ||
1417 | u8 ignore_for_response = sta->sta.uapsd_queues; | ||
1418 | |||
1419 | /* | ||
1420 | * If all ACs are delivery-enabled then we should reply | ||
1421 | * from any of them, if only some are enabled we reply | ||
1422 | * only from the non-enabled ones. | ||
1423 | */ | ||
1424 | if (ignore_for_response == BIT(IEEE80211_NUM_ACS) - 1) | ||
1425 | ignore_for_response = 0; | ||
1426 | |||
1427 | ieee80211_sta_ps_deliver_response(sta, 1, ignore_for_response, | ||
1428 | IEEE80211_FRAME_RELEASE_PSPOLL); | ||
1429 | } | ||
1430 | |||
1431 | void ieee80211_sta_ps_deliver_uapsd(struct sta_info *sta) | ||
1432 | { | ||
1433 | int n_frames = sta->sta.max_sp; | ||
1434 | u8 delivery_enabled = sta->sta.uapsd_queues; | ||
1435 | |||
1436 | /* | ||
1437 | * If we ever grow support for TSPEC this might happen if | ||
1438 | * the TSPEC update from hostapd comes in between a trigger | ||
1439 | * frame setting WLAN_STA_UAPSD in the RX path and this | ||
1440 | * actually getting called. | ||
1441 | */ | ||
1442 | if (!delivery_enabled) | ||
1443 | return; | ||
1444 | |||
1445 | switch (sta->sta.max_sp) { | ||
1446 | case 1: | ||
1447 | n_frames = 2; | ||
1448 | break; | ||
1449 | case 2: | ||
1450 | n_frames = 4; | ||
1451 | break; | ||
1452 | case 3: | ||
1453 | n_frames = 6; | ||
1454 | break; | ||
1455 | case 0: | ||
1456 | /* XXX: what is a good value? */ | ||
1457 | n_frames = 8; | ||
1458 | break; | ||
1459 | } | ||
1460 | |||
1461 | ieee80211_sta_ps_deliver_response(sta, n_frames, ~delivery_enabled, | ||
1462 | IEEE80211_FRAME_RELEASE_UAPSD); | ||
1463 | } | ||
1464 | |||
979 | void ieee80211_sta_block_awake(struct ieee80211_hw *hw, | 1465 | void ieee80211_sta_block_awake(struct ieee80211_hw *hw, |
980 | struct ieee80211_sta *pubsta, bool block) | 1466 | struct ieee80211_sta *pubsta, bool block) |
981 | { | 1467 | { |
@@ -984,17 +1470,50 @@ void ieee80211_sta_block_awake(struct ieee80211_hw *hw, | |||
984 | trace_api_sta_block_awake(sta->local, pubsta, block); | 1470 | trace_api_sta_block_awake(sta->local, pubsta, block); |
985 | 1471 | ||
986 | if (block) | 1472 | if (block) |
987 | set_sta_flags(sta, WLAN_STA_PS_DRIVER); | 1473 | set_sta_flag(sta, WLAN_STA_PS_DRIVER); |
988 | else if (test_sta_flags(sta, WLAN_STA_PS_DRIVER)) | 1474 | else if (test_sta_flag(sta, WLAN_STA_PS_DRIVER)) |
989 | ieee80211_queue_work(hw, &sta->drv_unblock_wk); | 1475 | ieee80211_queue_work(hw, &sta->drv_unblock_wk); |
990 | } | 1476 | } |
991 | EXPORT_SYMBOL(ieee80211_sta_block_awake); | 1477 | EXPORT_SYMBOL(ieee80211_sta_block_awake); |
992 | 1478 | ||
993 | void ieee80211_sta_set_tim(struct ieee80211_sta *pubsta) | 1479 | void ieee80211_sta_eosp_irqsafe(struct ieee80211_sta *pubsta) |
994 | { | 1480 | { |
995 | struct sta_info *sta = container_of(pubsta, struct sta_info, sta); | 1481 | struct sta_info *sta = container_of(pubsta, struct sta_info, sta); |
1482 | struct ieee80211_local *local = sta->local; | ||
1483 | struct sk_buff *skb; | ||
1484 | struct skb_eosp_msg_data *data; | ||
1485 | |||
1486 | trace_api_eosp(local, pubsta); | ||
1487 | |||
1488 | skb = alloc_skb(0, GFP_ATOMIC); | ||
1489 | if (!skb) { | ||
1490 | /* too bad ... but race is better than loss */ | ||
1491 | clear_sta_flag(sta, WLAN_STA_SP); | ||
1492 | return; | ||
1493 | } | ||
1494 | |||
1495 | data = (void *)skb->cb; | ||
1496 | memcpy(data->sta, pubsta->addr, ETH_ALEN); | ||
1497 | memcpy(data->iface, sta->sdata->vif.addr, ETH_ALEN); | ||
1498 | skb->pkt_type = IEEE80211_EOSP_MSG; | ||
1499 | skb_queue_tail(&local->skb_queue, skb); | ||
1500 | tasklet_schedule(&local->tasklet); | ||
1501 | } | ||
1502 | EXPORT_SYMBOL(ieee80211_sta_eosp_irqsafe); | ||
1503 | |||
1504 | void ieee80211_sta_set_buffered(struct ieee80211_sta *pubsta, | ||
1505 | u8 tid, bool buffered) | ||
1506 | { | ||
1507 | struct sta_info *sta = container_of(pubsta, struct sta_info, sta); | ||
1508 | |||
1509 | if (WARN_ON(tid >= STA_TID_NUM)) | ||
1510 | return; | ||
1511 | |||
1512 | if (buffered) | ||
1513 | set_bit(tid, &sta->driver_buffered_tids); | ||
1514 | else | ||
1515 | clear_bit(tid, &sta->driver_buffered_tids); | ||
996 | 1516 | ||
997 | set_sta_flags(sta, WLAN_STA_PS_DRIVER_BUF); | 1517 | sta_info_recalc_tim(sta); |
998 | sta_info_set_tim_bit(sta); | ||
999 | } | 1518 | } |
1000 | EXPORT_SYMBOL(ieee80211_sta_set_tim); | 1519 | EXPORT_SYMBOL(ieee80211_sta_set_buffered); |