~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/mac80211/status.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  * Copyright 2002-2005, Instant802 Networks, Inc.
  4  * Copyright 2005-2006, Devicescape Software, Inc.
  5  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
  6  * Copyright 2008-2010  Johannes Berg <johannes@sipsolutions.net>
  7  * Copyright 2013-2014  Intel Mobile Communications GmbH
  8  */
  9 
 10 #include <linux/export.h>
 11 #include <linux/etherdevice.h>
 12 #include <net/mac80211.h>
 13 #include <asm/unaligned.h>
 14 #include "ieee80211_i.h"
 15 #include "rate.h"
 16 #include "mesh.h"
 17 #include "led.h"
 18 #include "wme.h"
 19 
 20 
 21 void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
 22                                  struct sk_buff *skb)
 23 {
 24         struct ieee80211_local *local = hw_to_local(hw);
 25         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 26         int tmp;
 27 
 28         skb->pkt_type = IEEE80211_TX_STATUS_MSG;
 29         skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ?
 30                        &local->skb_queue : &local->skb_queue_unreliable, skb);
 31         tmp = skb_queue_len(&local->skb_queue) +
 32                 skb_queue_len(&local->skb_queue_unreliable);
 33         while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT &&
 34                (skb = skb_dequeue(&local->skb_queue_unreliable))) {
 35                 ieee80211_free_txskb(hw, skb);
 36                 tmp--;
 37                 I802_DEBUG_INC(local->tx_status_drop);
 38         }
 39         tasklet_schedule(&local->tasklet);
 40 }
 41 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
 42 
 43 static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
 44                                             struct sta_info *sta,
 45                                             struct sk_buff *skb)
 46 {
 47         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 48         struct ieee80211_hdr *hdr = (void *)skb->data;
 49         int ac;
 50 
 51         if (info->flags & (IEEE80211_TX_CTL_NO_PS_BUFFER |
 52                            IEEE80211_TX_CTL_AMPDU)) {
 53                 ieee80211_free_txskb(&local->hw, skb);
 54                 return;
 55         }
 56 
 57         /*
 58          * This skb 'survived' a round-trip through the driver, and
 59          * hopefully the driver didn't mangle it too badly. However,
 60          * we can definitely not rely on the control information
 61          * being correct. Clear it so we don't get junk there, and
 62          * indicate that it needs new processing, but must not be
 63          * modified/encrypted again.
 64          */
 65         memset(&info->control, 0, sizeof(info->control));
 66 
 67         info->control.jiffies = jiffies;
 68         info->control.vif = &sta->sdata->vif;
 69         info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING |
 70                        IEEE80211_TX_INTFL_RETRANSMISSION;
 71         info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS;
 72 
 73         sta->status_stats.filtered++;
 74 
 75         /*
 76          * Clear more-data bit on filtered frames, it might be set
 77          * but later frames might time out so it might have to be
 78          * clear again ... It's all rather unlikely (this frame
 79          * should time out first, right?) but let's not confuse
 80          * peers unnecessarily.
 81          */
 82         if (hdr->frame_control & cpu_to_le16(IEEE80211_FCTL_MOREDATA))
 83                 hdr->frame_control &= ~cpu_to_le16(IEEE80211_FCTL_MOREDATA);
 84 
 85         if (ieee80211_is_data_qos(hdr->frame_control)) {
 86                 u8 *p = ieee80211_get_qos_ctl(hdr);
 87                 int tid = *p & IEEE80211_QOS_CTL_TID_MASK;
 88 
 89                 /*
 90                  * Clear EOSP if set, this could happen e.g.
 91                  * if an absence period (us being a P2P GO)
 92                  * shortens the SP.
 93                  */
 94                 if (*p & IEEE80211_QOS_CTL_EOSP)
 95                         *p &= ~IEEE80211_QOS_CTL_EOSP;
 96                 ac = ieee80211_ac_from_tid(tid);
 97         } else {
 98                 ac = IEEE80211_AC_BE;
 99         }
100 
101         /*
102          * Clear the TX filter mask for this STA when sending the next
103          * packet. If the STA went to power save mode, this will happen
104          * when it wakes up for the next time.
105          */
106         set_sta_flag(sta, WLAN_STA_CLEAR_PS_FILT);
107         ieee80211_clear_fast_xmit(sta);
108 
109         /*
110          * This code races in the following way:
111          *
112          *  (1) STA sends frame indicating it will go to sleep and does so
113          *  (2) hardware/firmware adds STA to filter list, passes frame up
114          *  (3) hardware/firmware processes TX fifo and suppresses a frame
115          *  (4) we get TX status before having processed the frame and
116          *      knowing that the STA has gone to sleep.
117          *
118          * This is actually quite unlikely even when both those events are
119          * processed from interrupts coming in quickly after one another or
120          * even at the same time because we queue both TX status events and
121          * RX frames to be processed by a tasklet and process them in the
122          * same order that they were received or TX status last. Hence, there
123          * is no race as long as the frame RX is processed before the next TX
124          * status, which drivers can ensure, see below.
125          *
126          * Note that this can only happen if the hardware or firmware can
127          * actually add STAs to the filter list, if this is done by the
128          * driver in response to set_tim() (which will only reduce the race
129          * this whole filtering tries to solve, not completely solve it)
130          * this situation cannot happen.
131          *
132          * To completely solve this race drivers need to make sure that they
133          *  (a) don't mix the irq-safe/not irq-safe TX status/RX processing
134          *      functions and
135          *  (b) always process RX events before TX status events if ordering
136          *      can be unknown, for example with different interrupt status
137          *      bits.
138          *  (c) if PS mode transitions are manual (i.e. the flag
139          *      %IEEE80211_HW_AP_LINK_PS is set), always process PS state
140          *      changes before calling TX status events if ordering can be
141          *      unknown.
142          */
143         if (test_sta_flag(sta, WLAN_STA_PS_STA) &&
144             skb_queue_len(&sta->tx_filtered[ac]) < STA_MAX_TX_BUFFER) {
145                 skb_queue_tail(&sta->tx_filtered[ac], skb);
146                 sta_info_recalc_tim(sta);
147 
148                 if (!timer_pending(&local->sta_cleanup))
149                         mod_timer(&local->sta_cleanup,
150                                   round_jiffies(jiffies +
151                                                 STA_INFO_CLEANUP_INTERVAL));
152                 return;
153         }
154 
155         if (!test_sta_flag(sta, WLAN_STA_PS_STA) &&
156             !(info->flags & IEEE80211_TX_INTFL_RETRIED)) {
157                 /* Software retry the packet once */
158                 info->flags |= IEEE80211_TX_INTFL_RETRIED;
159                 ieee80211_add_pending_skb(local, skb);
160                 return;
161         }
162 
163         ps_dbg_ratelimited(sta->sdata,
164                            "dropped TX filtered frame, queue_len=%d PS=%d @%lu\n",
165                            skb_queue_len(&sta->tx_filtered[ac]),
166                            !!test_sta_flag(sta, WLAN_STA_PS_STA), jiffies);
167         ieee80211_free_txskb(&local->hw, skb);
168 }
169 
170 static void ieee80211_check_pending_bar(struct sta_info *sta, u8 *addr, u8 tid)
171 {
172         struct tid_ampdu_tx *tid_tx;
173 
174         tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
175         if (!tid_tx || !tid_tx->bar_pending)
176                 return;
177 
178         tid_tx->bar_pending = false;
179         ieee80211_send_bar(&sta->sdata->vif, addr, tid, tid_tx->failed_bar_ssn);
180 }
181 
182 static void ieee80211_frame_acked(struct sta_info *sta, struct sk_buff *skb)
183 {
184         struct ieee80211_mgmt *mgmt = (void *) skb->data;
185         struct ieee80211_local *local = sta->local;
186         struct ieee80211_sub_if_data *sdata = sta->sdata;
187         struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
188 
189         if (ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
190                 sta->status_stats.last_ack = jiffies;
191                 if (txinfo->status.is_valid_ack_signal) {
192                         sta->status_stats.last_ack_signal =
193                                          (s8)txinfo->status.ack_signal;
194                         sta->status_stats.ack_signal_filled = true;
195                         ewma_avg_signal_add(&sta->status_stats.avg_ack_signal,
196                                             -txinfo->status.ack_signal);
197                 }
198         }
199 
200         if (ieee80211_is_data_qos(mgmt->frame_control)) {
201                 struct ieee80211_hdr *hdr = (void *) skb->data;
202                 u8 *qc = ieee80211_get_qos_ctl(hdr);
203                 u16 tid = qc[0] & 0xf;
204 
205                 ieee80211_check_pending_bar(sta, hdr->addr1, tid);
206         }
207 
208         if (ieee80211_is_action(mgmt->frame_control) &&
209             !ieee80211_has_protected(mgmt->frame_control) &&
210             mgmt->u.action.category == WLAN_CATEGORY_HT &&
211             mgmt->u.action.u.ht_smps.action == WLAN_HT_ACTION_SMPS &&
212             ieee80211_sdata_running(sdata)) {
213                 enum ieee80211_smps_mode smps_mode;
214 
215                 switch (mgmt->u.action.u.ht_smps.smps_control) {
216                 case WLAN_HT_SMPS_CONTROL_DYNAMIC:
217                         smps_mode = IEEE80211_SMPS_DYNAMIC;
218                         break;
219                 case WLAN_HT_SMPS_CONTROL_STATIC:
220                         smps_mode = IEEE80211_SMPS_STATIC;
221                         break;
222                 case WLAN_HT_SMPS_CONTROL_DISABLED:
223                 default: /* shouldn't happen since we don't send that */
224                         smps_mode = IEEE80211_SMPS_OFF;
225                         break;
226                 }
227 
228                 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
229                         /*
230                          * This update looks racy, but isn't -- if we come
231                          * here we've definitely got a station that we're
232                          * talking to, and on a managed interface that can
233                          * only be the AP. And the only other place updating
234                          * this variable in managed mode is before association.
235                          */
236                         sdata->smps_mode = smps_mode;
237                         ieee80211_queue_work(&local->hw, &sdata->recalc_smps);
238                 } else if (sdata->vif.type == NL80211_IFTYPE_AP ||
239                            sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
240                         sta->known_smps_mode = smps_mode;
241                 }
242         }
243 }
244 
245 static void ieee80211_set_bar_pending(struct sta_info *sta, u8 tid, u16 ssn)
246 {
247         struct tid_ampdu_tx *tid_tx;
248 
249         tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
250         if (!tid_tx)
251                 return;
252 
253         tid_tx->failed_bar_ssn = ssn;
254         tid_tx->bar_pending = true;
255 }
256 
257 static int ieee80211_tx_radiotap_len(struct ieee80211_tx_info *info)
258 {
259         int len = sizeof(struct ieee80211_radiotap_header);
260 
261         /* IEEE80211_RADIOTAP_RATE rate */
262         if (info->status.rates[0].idx >= 0 &&
263             !(info->status.rates[0].flags & (IEEE80211_TX_RC_MCS |
264                                              IEEE80211_TX_RC_VHT_MCS)))
265                 len += 2;
266 
267         /* IEEE80211_RADIOTAP_TX_FLAGS */
268         len += 2;
269 
270         /* IEEE80211_RADIOTAP_DATA_RETRIES */
271         len += 1;
272 
273         /* IEEE80211_RADIOTAP_MCS
274          * IEEE80211_RADIOTAP_VHT */
275         if (info->status.rates[0].idx >= 0) {
276                 if (info->status.rates[0].flags & IEEE80211_TX_RC_MCS)
277                         len += 3;
278                 else if (info->status.rates[0].flags & IEEE80211_TX_RC_VHT_MCS)
279                         len = ALIGN(len, 2) + 12;
280         }
281 
282         return len;
283 }
284 
285 static void
286 ieee80211_add_tx_radiotap_header(struct ieee80211_local *local,
287                                  struct ieee80211_supported_band *sband,
288                                  struct sk_buff *skb, int retry_count,
289                                  int rtap_len, int shift)
290 {
291         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
292         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
293         struct ieee80211_radiotap_header *rthdr;
294         unsigned char *pos;
295         u16 txflags;
296 
297         rthdr = skb_push(skb, rtap_len);
298 
299         memset(rthdr, 0, rtap_len);
300         rthdr->it_len = cpu_to_le16(rtap_len);
301         rthdr->it_present =
302                 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
303                             (1 << IEEE80211_RADIOTAP_DATA_RETRIES));
304         pos = (unsigned char *)(rthdr + 1);
305 
306         /*
307          * XXX: Once radiotap gets the bitmap reset thing the vendor
308          *      extensions proposal contains, we can actually report
309          *      the whole set of tries we did.
310          */
311 
312         /* IEEE80211_RADIOTAP_RATE */
313         if (info->status.rates[0].idx >= 0 &&
314             !(info->status.rates[0].flags & (IEEE80211_TX_RC_MCS |
315                                              IEEE80211_TX_RC_VHT_MCS))) {
316                 u16 rate;
317 
318                 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
319                 rate = sband->bitrates[info->status.rates[0].idx].bitrate;
320                 *pos = DIV_ROUND_UP(rate, 5 * (1 << shift));
321                 /* padding for tx flags */
322                 pos += 2;
323         }
324 
325         /* IEEE80211_RADIOTAP_TX_FLAGS */
326         txflags = 0;
327         if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
328             !is_multicast_ether_addr(hdr->addr1))
329                 txflags |= IEEE80211_RADIOTAP_F_TX_FAIL;
330 
331         if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
332                 txflags |= IEEE80211_RADIOTAP_F_TX_CTS;
333         if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
334                 txflags |= IEEE80211_RADIOTAP_F_TX_RTS;
335 
336         put_unaligned_le16(txflags, pos);
337         pos += 2;
338 
339         /* IEEE80211_RADIOTAP_DATA_RETRIES */
340         /* for now report the total retry_count */
341         *pos = retry_count;
342         pos++;
343 
344         if (info->status.rates[0].idx < 0)
345                 return;
346 
347         /* IEEE80211_RADIOTAP_MCS
348          * IEEE80211_RADIOTAP_VHT */
349         if (info->status.rates[0].flags & IEEE80211_TX_RC_MCS) {
350                 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_MCS);
351                 pos[0] = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
352                          IEEE80211_RADIOTAP_MCS_HAVE_GI |
353                          IEEE80211_RADIOTAP_MCS_HAVE_BW;
354                 if (info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
355                         pos[1] |= IEEE80211_RADIOTAP_MCS_SGI;
356                 if (info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
357                         pos[1] |= IEEE80211_RADIOTAP_MCS_BW_40;
358                 if (info->status.rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD)
359                         pos[1] |= IEEE80211_RADIOTAP_MCS_FMT_GF;
360                 pos[2] = info->status.rates[0].idx;
361                 pos += 3;
362         } else if (info->status.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
363                 u16 known = local->hw.radiotap_vht_details &
364                         (IEEE80211_RADIOTAP_VHT_KNOWN_GI |
365                          IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH);
366 
367                 rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_VHT);
368 
369                 /* required alignment from rthdr */
370                 pos = (u8 *)rthdr + ALIGN(pos - (u8 *)rthdr, 2);
371 
372                 /* u16 known - IEEE80211_RADIOTAP_VHT_KNOWN_* */
373                 put_unaligned_le16(known, pos);
374                 pos += 2;
375 
376                 /* u8 flags - IEEE80211_RADIOTAP_VHT_FLAG_* */
377                 if (info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
378                         *pos |= IEEE80211_RADIOTAP_VHT_FLAG_SGI;
379                 pos++;
380 
381                 /* u8 bandwidth */
382                 if (info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
383                         *pos = 1;
384                 else if (info->status.rates[0].flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
385                         *pos = 4;
386                 else if (info->status.rates[0].flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
387                         *pos = 11;
388                 else /* IEEE80211_TX_RC_{20_MHZ_WIDTH,FIXME:DUP_DATA} */
389                         *pos = 0;
390                 pos++;
391 
392                 /* u8 mcs_nss[4] */
393                 *pos = (ieee80211_rate_get_vht_mcs(&info->status.rates[0]) << 4) |
394                         ieee80211_rate_get_vht_nss(&info->status.rates[0]);
395                 pos += 4;
396 
397                 /* u8 coding */
398                 pos++;
399                 /* u8 group_id */
400                 pos++;
401                 /* u16 partial_aid */
402                 pos += 2;
403         }
404 }
405 
406 /*
407  * Handles the tx for TDLS teardown frames.
408  * If the frame wasn't ACKed by the peer - it will be re-sent through the AP
409  */
410 static void ieee80211_tdls_td_tx_handle(struct ieee80211_local *local,
411                                         struct ieee80211_sub_if_data *sdata,
412                                         struct sk_buff *skb, u32 flags)
413 {
414         struct sk_buff *teardown_skb;
415         struct sk_buff *orig_teardown_skb;
416         bool is_teardown = false;
417 
418         /* Get the teardown data we need and free the lock */
419         spin_lock(&sdata->u.mgd.teardown_lock);
420         teardown_skb = sdata->u.mgd.teardown_skb;
421         orig_teardown_skb = sdata->u.mgd.orig_teardown_skb;
422         if ((skb == orig_teardown_skb) && teardown_skb) {
423                 sdata->u.mgd.teardown_skb = NULL;
424                 sdata->u.mgd.orig_teardown_skb = NULL;
425                 is_teardown = true;
426         }
427         spin_unlock(&sdata->u.mgd.teardown_lock);
428 
429         if (is_teardown) {
430                 /* This mechanism relies on being able to get ACKs */
431                 WARN_ON(!ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS));
432 
433                 /* Check if peer has ACKed */
434                 if (flags & IEEE80211_TX_STAT_ACK) {
435                         dev_kfree_skb_any(teardown_skb);
436                 } else {
437                         tdls_dbg(sdata,
438                                  "TDLS Resending teardown through AP\n");
439 
440                         ieee80211_subif_start_xmit(teardown_skb, skb->dev);
441                 }
442         }
443 }
444 
445 static struct ieee80211_sub_if_data *
446 ieee80211_sdata_from_skb(struct ieee80211_local *local, struct sk_buff *skb)
447 {
448         struct ieee80211_sub_if_data *sdata;
449 
450         if (skb->dev) {
451                 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
452                         if (!sdata->dev)
453                                 continue;
454 
455                         if (skb->dev == sdata->dev)
456                                 return sdata;
457                 }
458 
459                 return NULL;
460         }
461 
462         return rcu_dereference(local->p2p_sdata);
463 }
464 
465 static void ieee80211_report_ack_skb(struct ieee80211_local *local,
466                                      struct ieee80211_tx_info *info,
467                                      bool acked, bool dropped)
468 {
469         struct sk_buff *skb;
470         unsigned long flags;
471 
472         spin_lock_irqsave(&local->ack_status_lock, flags);
473         skb = idr_remove(&local->ack_status_frames, info->ack_frame_id);
474         spin_unlock_irqrestore(&local->ack_status_lock, flags);
475 
476         if (!skb)
477                 return;
478 
479         if (info->flags & IEEE80211_TX_INTFL_NL80211_FRAME_TX) {
480                 u64 cookie = IEEE80211_SKB_CB(skb)->ack.cookie;
481                 struct ieee80211_sub_if_data *sdata;
482                 struct ieee80211_hdr *hdr = (void *)skb->data;
483 
484                 rcu_read_lock();
485                 sdata = ieee80211_sdata_from_skb(local, skb);
486                 if (sdata) {
487                         if (ieee80211_is_nullfunc(hdr->frame_control) ||
488                             ieee80211_is_qos_nullfunc(hdr->frame_control))
489                                 cfg80211_probe_status(sdata->dev, hdr->addr1,
490                                                       cookie, acked,
491                                                       info->status.ack_signal,
492                                                       info->status.is_valid_ack_signal,
493                                                       GFP_ATOMIC);
494                         else
495                                 cfg80211_mgmt_tx_status(&sdata->wdev, cookie,
496                                                         skb->data, skb->len,
497                                                         acked, GFP_ATOMIC);
498                 }
499                 rcu_read_unlock();
500 
501                 dev_kfree_skb_any(skb);
502         } else if (dropped) {
503                 dev_kfree_skb_any(skb);
504         } else {
505                 /* consumes skb */
506                 skb_complete_wifi_ack(skb, acked);
507         }
508 }
509 
510 static void ieee80211_report_used_skb(struct ieee80211_local *local,
511                                       struct sk_buff *skb, bool dropped)
512 {
513         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
514         struct ieee80211_hdr *hdr = (void *)skb->data;
515         bool acked = info->flags & IEEE80211_TX_STAT_ACK;
516 
517         if (dropped)
518                 acked = false;
519 
520         if (info->flags & IEEE80211_TX_INTFL_MLME_CONN_TX) {
521                 struct ieee80211_sub_if_data *sdata;
522 
523                 rcu_read_lock();
524 
525                 sdata = ieee80211_sdata_from_skb(local, skb);
526 
527                 if (!sdata) {
528                         skb->dev = NULL;
529                 } else {
530                         unsigned int hdr_size =
531                                 ieee80211_hdrlen(hdr->frame_control);
532 
533                         /* Check to see if packet is a TDLS teardown packet */
534                         if (ieee80211_is_data(hdr->frame_control) &&
535                             (ieee80211_get_tdls_action(skb, hdr_size) ==
536                              WLAN_TDLS_TEARDOWN))
537                                 ieee80211_tdls_td_tx_handle(local, sdata, skb,
538                                                             info->flags);
539                         else
540                                 ieee80211_mgd_conn_tx_status(sdata,
541                                                              hdr->frame_control,
542                                                              acked);
543                 }
544 
545                 rcu_read_unlock();
546         } else if (info->ack_frame_id) {
547                 ieee80211_report_ack_skb(local, info, acked, dropped);
548         }
549 
550         if (!dropped && skb->destructor) {
551                 skb->wifi_acked_valid = 1;
552                 skb->wifi_acked = acked;
553         }
554 
555         ieee80211_led_tx(local);
556 
557         if (skb_has_frag_list(skb)) {
558                 kfree_skb_list(skb_shinfo(skb)->frag_list);
559                 skb_shinfo(skb)->frag_list = NULL;
560         }
561 }
562 
563 /*
564  * Use a static threshold for now, best value to be determined
565  * by testing ...
566  * Should it depend on:
567  *  - on # of retransmissions
568  *  - current throughput (higher value for higher tpt)?
569  */
570 #define STA_LOST_PKT_THRESHOLD  50
571 #define STA_LOST_TDLS_PKT_THRESHOLD     10
572 #define STA_LOST_TDLS_PKT_TIME          (10*HZ) /* 10secs since last ACK */
573 
574 static void ieee80211_lost_packet(struct sta_info *sta,
575                                   struct ieee80211_tx_info *info)
576 {
577         /* If driver relies on its own algorithm for station kickout, skip
578          * mac80211 packet loss mechanism.
579          */
580         if (ieee80211_hw_check(&sta->local->hw, REPORTS_LOW_ACK))
581                 return;
582 
583         /* This packet was aggregated but doesn't carry status info */
584         if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
585             !(info->flags & IEEE80211_TX_STAT_AMPDU))
586                 return;
587 
588         sta->status_stats.lost_packets++;
589         if (!sta->sta.tdls &&
590             sta->status_stats.lost_packets < STA_LOST_PKT_THRESHOLD)
591                 return;
592 
593         /*
594          * If we're in TDLS mode, make sure that all STA_LOST_TDLS_PKT_THRESHOLD
595          * of the last packets were lost, and that no ACK was received in the
596          * last STA_LOST_TDLS_PKT_TIME ms, before triggering the CQM packet-loss
597          * mechanism.
598          */
599         if (sta->sta.tdls &&
600             (sta->status_stats.lost_packets < STA_LOST_TDLS_PKT_THRESHOLD ||
601              time_before(jiffies,
602                          sta->status_stats.last_tdls_pkt_time +
603                          STA_LOST_TDLS_PKT_TIME)))
604                 return;
605 
606         cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
607                                     sta->status_stats.lost_packets, GFP_ATOMIC);
608         sta->status_stats.lost_packets = 0;
609 }
610 
611 static int ieee80211_tx_get_rates(struct ieee80211_hw *hw,
612                                   struct ieee80211_tx_info *info,
613                                   int *retry_count)
614 {
615         int rates_idx = -1;
616         int count = -1;
617         int i;
618 
619         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
620                 if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
621                     !(info->flags & IEEE80211_TX_STAT_AMPDU)) {
622                         /* just the first aggr frame carry status info */
623                         info->status.rates[i].idx = -1;
624                         info->status.rates[i].count = 0;
625                         break;
626                 } else if (info->status.rates[i].idx < 0) {
627                         break;
628                 } else if (i >= hw->max_report_rates) {
629                         /* the HW cannot have attempted that rate */
630                         info->status.rates[i].idx = -1;
631                         info->status.rates[i].count = 0;
632                         break;
633                 }
634 
635                 count += info->status.rates[i].count;
636         }
637         rates_idx = i - 1;
638 
639         if (count < 0)
640                 count = 0;
641 
642         *retry_count = count;
643         return rates_idx;
644 }
645 
646 void ieee80211_tx_monitor(struct ieee80211_local *local, struct sk_buff *skb,
647                           struct ieee80211_supported_band *sband,
648                           int retry_count, int shift, bool send_to_cooked)
649 {
650         struct sk_buff *skb2;
651         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
652         struct ieee80211_sub_if_data *sdata;
653         struct net_device *prev_dev = NULL;
654         int rtap_len;
655 
656         /* send frame to monitor interfaces now */
657         rtap_len = ieee80211_tx_radiotap_len(info);
658         if (WARN_ON_ONCE(skb_headroom(skb) < rtap_len)) {
659                 pr_err("ieee80211_tx_status: headroom too small\n");
660                 dev_kfree_skb(skb);
661                 return;
662         }
663         ieee80211_add_tx_radiotap_header(local, sband, skb, retry_count,
664                                          rtap_len, shift);
665 
666         /* XXX: is this sufficient for BPF? */
667         skb_reset_mac_header(skb);
668         skb->ip_summed = CHECKSUM_UNNECESSARY;
669         skb->pkt_type = PACKET_OTHERHOST;
670         skb->protocol = htons(ETH_P_802_2);
671         memset(skb->cb, 0, sizeof(skb->cb));
672 
673         rcu_read_lock();
674         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
675                 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
676                         if (!ieee80211_sdata_running(sdata))
677                                 continue;
678 
679                         if ((sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) &&
680                             !send_to_cooked)
681                                 continue;
682 
683                         if (prev_dev) {
684                                 skb2 = skb_clone(skb, GFP_ATOMIC);
685                                 if (skb2) {
686                                         skb2->dev = prev_dev;
687                                         netif_rx(skb2);
688                                 }
689                         }
690 
691                         prev_dev = sdata->dev;
692                 }
693         }
694         if (prev_dev) {
695                 skb->dev = prev_dev;
696                 netif_rx(skb);
697                 skb = NULL;
698         }
699         rcu_read_unlock();
700         dev_kfree_skb(skb);
701 }
702 
703 static void __ieee80211_tx_status(struct ieee80211_hw *hw,
704                                   struct ieee80211_tx_status *status)
705 {
706         struct sk_buff *skb = status->skb;
707         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
708         struct ieee80211_local *local = hw_to_local(hw);
709         struct ieee80211_tx_info *info = status->info;
710         struct sta_info *sta;
711         __le16 fc;
712         struct ieee80211_supported_band *sband;
713         int retry_count;
714         int rates_idx;
715         bool send_to_cooked;
716         bool acked;
717         struct ieee80211_bar *bar;
718         int shift = 0;
719         int tid = IEEE80211_NUM_TIDS;
720 
721         rates_idx = ieee80211_tx_get_rates(hw, info, &retry_count);
722 
723         sband = local->hw.wiphy->bands[info->band];
724         fc = hdr->frame_control;
725 
726         if (status->sta) {
727                 sta = container_of(status->sta, struct sta_info, sta);
728                 shift = ieee80211_vif_get_shift(&sta->sdata->vif);
729 
730                 if (info->flags & IEEE80211_TX_STATUS_EOSP)
731                         clear_sta_flag(sta, WLAN_STA_SP);
732 
733                 acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
734 
735                 /* mesh Peer Service Period support */
736                 if (ieee80211_vif_is_mesh(&sta->sdata->vif) &&
737                     ieee80211_is_data_qos(fc))
738                         ieee80211_mpsp_trigger_process(
739                                 ieee80211_get_qos_ctl(hdr), sta, true, acked);
740 
741                 if (!acked && test_sta_flag(sta, WLAN_STA_PS_STA)) {
742                         /*
743                          * The STA is in power save mode, so assume
744                          * that this TX packet failed because of that.
745                          */
746                         ieee80211_handle_filtered_frame(local, sta, skb);
747                         return;
748                 }
749 
750                 if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL) &&
751                     (ieee80211_is_data(hdr->frame_control)) &&
752                     (rates_idx != -1))
753                         sta->tx_stats.last_rate =
754                                 info->status.rates[rates_idx];
755 
756                 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
757                     (ieee80211_is_data_qos(fc))) {
758                         u16 ssn;
759                         u8 *qc;
760 
761                         qc = ieee80211_get_qos_ctl(hdr);
762                         tid = qc[0] & 0xf;
763                         ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
764                                                 & IEEE80211_SCTL_SEQ);
765                         ieee80211_send_bar(&sta->sdata->vif, hdr->addr1,
766                                            tid, ssn);
767                 } else if (ieee80211_is_data_qos(fc)) {
768                         u8 *qc = ieee80211_get_qos_ctl(hdr);
769 
770                         tid = qc[0] & 0xf;
771                 }
772 
773                 if (!acked && ieee80211_is_back_req(fc)) {
774                         u16 control;
775 
776                         /*
777                          * BAR failed, store the last SSN and retry sending
778                          * the BAR when the next unicast transmission on the
779                          * same TID succeeds.
780                          */
781                         bar = (struct ieee80211_bar *) skb->data;
782                         control = le16_to_cpu(bar->control);
783                         if (!(control & IEEE80211_BAR_CTRL_MULTI_TID)) {
784                                 u16 ssn = le16_to_cpu(bar->start_seq_num);
785 
786                                 tid = (control &
787                                        IEEE80211_BAR_CTRL_TID_INFO_MASK) >>
788                                       IEEE80211_BAR_CTRL_TID_INFO_SHIFT;
789 
790                                 ieee80211_set_bar_pending(sta, tid, ssn);
791                         }
792                 }
793 
794                 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
795                         ieee80211_handle_filtered_frame(local, sta, skb);
796                         return;
797                 } else {
798                         if (!acked)
799                                 sta->status_stats.retry_failed++;
800                         sta->status_stats.retry_count += retry_count;
801 
802                         if (ieee80211_is_data_present(fc)) {
803                                 if (!acked)
804                                         sta->status_stats.msdu_failed[tid]++;
805 
806                                 sta->status_stats.msdu_retries[tid] +=
807                                         retry_count;
808                         }
809                 }
810 
811                 rate_control_tx_status(local, sband, status);
812                 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
813                         ieee80211s_update_metric(local, sta, status);
814 
815                 if (!(info->flags & IEEE80211_TX_CTL_INJECTED) && acked)
816                         ieee80211_frame_acked(sta, skb);
817 
818                 if ((sta->sdata->vif.type == NL80211_IFTYPE_STATION) &&
819                     ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS))
820                         ieee80211_sta_tx_notify(sta->sdata, (void *) skb->data,
821                                                 acked, info->status.tx_time);
822 
823                 if (info->status.tx_time &&
824                     wiphy_ext_feature_isset(local->hw.wiphy,
825                                             NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
826                         ieee80211_sta_register_airtime(&sta->sta, tid,
827                                                        info->status.tx_time, 0);
828 
829                 if (ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
830                         if (info->flags & IEEE80211_TX_STAT_ACK) {
831                                 if (sta->status_stats.lost_packets)
832                                         sta->status_stats.lost_packets = 0;
833 
834                                 /* Track when last TDLS packet was ACKed */
835                                 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH))
836                                         sta->status_stats.last_tdls_pkt_time =
837                                                 jiffies;
838                         } else {
839                                 ieee80211_lost_packet(sta, info);
840                         }
841                 }
842         }
843 
844         /* SNMP counters
845          * Fragments are passed to low-level drivers as separate skbs, so these
846          * are actually fragments, not frames. Update frame counters only for
847          * the first fragment of the frame. */
848         if ((info->flags & IEEE80211_TX_STAT_ACK) ||
849             (info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED)) {
850                 if (ieee80211_is_first_frag(hdr->seq_ctrl)) {
851                         I802_DEBUG_INC(local->dot11TransmittedFrameCount);
852                         if (is_multicast_ether_addr(ieee80211_get_DA(hdr)))
853                                 I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
854                         if (retry_count > 0)
855                                 I802_DEBUG_INC(local->dot11RetryCount);
856                         if (retry_count > 1)
857                                 I802_DEBUG_INC(local->dot11MultipleRetryCount);
858                 }
859 
860                 /* This counter shall be incremented for an acknowledged MPDU
861                  * with an individual address in the address 1 field or an MPDU
862                  * with a multicast address in the address 1 field of type Data
863                  * or Management. */
864                 if (!is_multicast_ether_addr(hdr->addr1) ||
865                     ieee80211_is_data(fc) ||
866                     ieee80211_is_mgmt(fc))
867                         I802_DEBUG_INC(local->dot11TransmittedFragmentCount);
868         } else {
869                 if (ieee80211_is_first_frag(hdr->seq_ctrl))
870                         I802_DEBUG_INC(local->dot11FailedCount);
871         }
872 
873         if (ieee80211_is_nullfunc(fc) && ieee80211_has_pm(fc) &&
874             ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS) &&
875             !(info->flags & IEEE80211_TX_CTL_INJECTED) &&
876             local->ps_sdata && !(local->scanning)) {
877                 if (info->flags & IEEE80211_TX_STAT_ACK) {
878                         local->ps_sdata->u.mgd.flags |=
879                                         IEEE80211_STA_NULLFUNC_ACKED;
880                 } else
881                         mod_timer(&local->dynamic_ps_timer, jiffies +
882                                         msecs_to_jiffies(10));
883         }
884 
885         ieee80211_report_used_skb(local, skb, false);
886 
887         /* this was a transmitted frame, but now we want to reuse it */
888         skb_orphan(skb);
889 
890         /* Need to make a copy before skb->cb gets cleared */
891         send_to_cooked = !!(info->flags & IEEE80211_TX_CTL_INJECTED) ||
892                          !(ieee80211_is_data(fc));
893 
894         /*
895          * This is a bit racy but we can avoid a lot of work
896          * with this test...
897          */
898         if (!local->monitors && (!send_to_cooked || !local->cooked_mntrs)) {
899                 dev_kfree_skb(skb);
900                 return;
901         }
902 
903         /* send to monitor interfaces */
904         ieee80211_tx_monitor(local, skb, sband, retry_count, shift, send_to_cooked);
905 }
906 
907 void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
908 {
909         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
910         struct ieee80211_local *local = hw_to_local(hw);
911         struct ieee80211_tx_status status = {
912                 .skb = skb,
913                 .info = IEEE80211_SKB_CB(skb),
914         };
915         struct rhlist_head *tmp;
916         struct sta_info *sta;
917 
918         rcu_read_lock();
919 
920         for_each_sta_info(local, hdr->addr1, sta, tmp) {
921                 /* skip wrong virtual interface */
922                 if (!ether_addr_equal(hdr->addr2, sta->sdata->vif.addr))
923                         continue;
924 
925                 status.sta = &sta->sta;
926                 break;
927         }
928 
929         __ieee80211_tx_status(hw, &status);
930         rcu_read_unlock();
931 }
932 EXPORT_SYMBOL(ieee80211_tx_status);
933 
934 void ieee80211_tx_status_ext(struct ieee80211_hw *hw,
935                              struct ieee80211_tx_status *status)
936 {
937         struct ieee80211_local *local = hw_to_local(hw);
938         struct ieee80211_tx_info *info = status->info;
939         struct ieee80211_sta *pubsta = status->sta;
940         struct ieee80211_supported_band *sband;
941         int retry_count;
942         bool acked, noack_success;
943 
944         if (status->skb)
945                 return __ieee80211_tx_status(hw, status);
946 
947         if (!status->sta)
948                 return;
949 
950         ieee80211_tx_get_rates(hw, info, &retry_count);
951 
952         sband = hw->wiphy->bands[info->band];
953 
954         acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
955         noack_success = !!(info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED);
956 
957         if (pubsta) {
958                 struct sta_info *sta;
959 
960                 sta = container_of(pubsta, struct sta_info, sta);
961 
962                 if (!acked)
963                         sta->status_stats.retry_failed++;
964                 sta->status_stats.retry_count += retry_count;
965 
966                 if (acked) {
967                         sta->status_stats.last_ack = jiffies;
968 
969                         if (sta->status_stats.lost_packets)
970                                 sta->status_stats.lost_packets = 0;
971 
972                         /* Track when last TDLS packet was ACKed */
973                         if (test_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH))
974                                 sta->status_stats.last_tdls_pkt_time = jiffies;
975                 } else if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
976                         return;
977                 } else {
978                         ieee80211_lost_packet(sta, info);
979                 }
980 
981                 rate_control_tx_status(local, sband, status);
982                 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
983                         ieee80211s_update_metric(local, sta, status);
984         }
985 
986         if (acked || noack_success) {
987                 I802_DEBUG_INC(local->dot11TransmittedFrameCount);
988                 if (!pubsta)
989                         I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
990                 if (retry_count > 0)
991                         I802_DEBUG_INC(local->dot11RetryCount);
992                 if (retry_count > 1)
993                         I802_DEBUG_INC(local->dot11MultipleRetryCount);
994         } else {
995                 I802_DEBUG_INC(local->dot11FailedCount);
996         }
997 }
998 EXPORT_SYMBOL(ieee80211_tx_status_ext);
999 
1000 void ieee80211_tx_rate_update(struct ieee80211_hw *hw,
1001                               struct ieee80211_sta *pubsta,
1002                               struct ieee80211_tx_info *info)
1003 {
1004         struct ieee80211_local *local = hw_to_local(hw);
1005         struct ieee80211_supported_band *sband = hw->wiphy->bands[info->band];
1006         struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1007         struct ieee80211_tx_status status = {
1008                 .info = info,
1009                 .sta = pubsta,
1010         };
1011 
1012         rate_control_tx_status(local, sband, &status);
1013 
1014         if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL))
1015                 sta->tx_stats.last_rate = info->status.rates[0];
1016 }
1017 EXPORT_SYMBOL(ieee80211_tx_rate_update);
1018 
1019 void ieee80211_report_low_ack(struct ieee80211_sta *pubsta, u32 num_packets)
1020 {
1021         struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
1022         cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
1023                                     num_packets, GFP_ATOMIC);
1024 }
1025 EXPORT_SYMBOL(ieee80211_report_low_ack);
1026 
1027 void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb)
1028 {
1029         struct ieee80211_local *local = hw_to_local(hw);
1030 
1031         ieee80211_report_used_skb(local, skb, true);
1032         dev_kfree_skb_any(skb);
1033 }
1034 EXPORT_SYMBOL(ieee80211_free_txskb);
1035 
1036 void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
1037                               struct sk_buff_head *skbs)
1038 {
1039         struct sk_buff *skb;
1040 
1041         while ((skb = __skb_dequeue(skbs)))
1042                 ieee80211_free_txskb(hw, skb);
1043 }
1044 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp