Merge tag 'mac80211-for-davem-2018-09-03' of git://git.kernel.org/pub/scm/linux/kerne...
[muen/linux.git] / net / mac80211 / tx.c
1 /*
2  * Copyright 2002-2005, Instant802 Networks, Inc.
3  * Copyright 2005-2006, Devicescape Software, Inc.
4  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
5  * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
6  * Copyright 2013-2014  Intel Mobile Communications GmbH
7  * Copyright (C) 2018 Intel Corporation
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  *
13  *
14  * Transmit and frame generation functions.
15  */
16
17 #include <linux/kernel.h>
18 #include <linux/slab.h>
19 #include <linux/skbuff.h>
20 #include <linux/if_vlan.h>
21 #include <linux/etherdevice.h>
22 #include <linux/bitmap.h>
23 #include <linux/rcupdate.h>
24 #include <linux/export.h>
25 #include <net/net_namespace.h>
26 #include <net/ieee80211_radiotap.h>
27 #include <net/cfg80211.h>
28 #include <net/mac80211.h>
29 #include <net/codel.h>
30 #include <net/codel_impl.h>
31 #include <asm/unaligned.h>
32 #include <net/fq_impl.h>
33
34 #include "ieee80211_i.h"
35 #include "driver-ops.h"
36 #include "led.h"
37 #include "mesh.h"
38 #include "wep.h"
39 #include "wpa.h"
40 #include "wme.h"
41 #include "rate.h"
42
43 /* misc utils */
44
45 static inline void ieee80211_tx_stats(struct net_device *dev, u32 len)
46 {
47         struct pcpu_sw_netstats *tstats = this_cpu_ptr(dev->tstats);
48
49         u64_stats_update_begin(&tstats->syncp);
50         tstats->tx_packets++;
51         tstats->tx_bytes += len;
52         u64_stats_update_end(&tstats->syncp);
53 }
54
55 static __le16 ieee80211_duration(struct ieee80211_tx_data *tx,
56                                  struct sk_buff *skb, int group_addr,
57                                  int next_frag_len)
58 {
59         int rate, mrate, erp, dur, i, shift = 0;
60         struct ieee80211_rate *txrate;
61         struct ieee80211_local *local = tx->local;
62         struct ieee80211_supported_band *sband;
63         struct ieee80211_hdr *hdr;
64         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
65         struct ieee80211_chanctx_conf *chanctx_conf;
66         u32 rate_flags = 0;
67
68         /* assume HW handles this */
69         if (tx->rate.flags & (IEEE80211_TX_RC_MCS | IEEE80211_TX_RC_VHT_MCS))
70                 return 0;
71
72         rcu_read_lock();
73         chanctx_conf = rcu_dereference(tx->sdata->vif.chanctx_conf);
74         if (chanctx_conf) {
75                 shift = ieee80211_chandef_get_shift(&chanctx_conf->def);
76                 rate_flags = ieee80211_chandef_rate_flags(&chanctx_conf->def);
77         }
78         rcu_read_unlock();
79
80         /* uh huh? */
81         if (WARN_ON_ONCE(tx->rate.idx < 0))
82                 return 0;
83
84         sband = local->hw.wiphy->bands[info->band];
85         txrate = &sband->bitrates[tx->rate.idx];
86
87         erp = txrate->flags & IEEE80211_RATE_ERP_G;
88
89         /*
90          * data and mgmt (except PS Poll):
91          * - during CFP: 32768
92          * - during contention period:
93          *   if addr1 is group address: 0
94          *   if more fragments = 0 and addr1 is individual address: time to
95          *      transmit one ACK plus SIFS
96          *   if more fragments = 1 and addr1 is individual address: time to
97          *      transmit next fragment plus 2 x ACK plus 3 x SIFS
98          *
99          * IEEE 802.11, 9.6:
100          * - control response frame (CTS or ACK) shall be transmitted using the
101          *   same rate as the immediately previous frame in the frame exchange
102          *   sequence, if this rate belongs to the PHY mandatory rates, or else
103          *   at the highest possible rate belonging to the PHY rates in the
104          *   BSSBasicRateSet
105          */
106         hdr = (struct ieee80211_hdr *)skb->data;
107         if (ieee80211_is_ctl(hdr->frame_control)) {
108                 /* TODO: These control frames are not currently sent by
109                  * mac80211, but should they be implemented, this function
110                  * needs to be updated to support duration field calculation.
111                  *
112                  * RTS: time needed to transmit pending data/mgmt frame plus
113                  *    one CTS frame plus one ACK frame plus 3 x SIFS
114                  * CTS: duration of immediately previous RTS minus time
115                  *    required to transmit CTS and its SIFS
116                  * ACK: 0 if immediately previous directed data/mgmt had
117                  *    more=0, with more=1 duration in ACK frame is duration
118                  *    from previous frame minus time needed to transmit ACK
119                  *    and its SIFS
120                  * PS Poll: BIT(15) | BIT(14) | aid
121                  */
122                 return 0;
123         }
124
125         /* data/mgmt */
126         if (0 /* FIX: data/mgmt during CFP */)
127                 return cpu_to_le16(32768);
128
129         if (group_addr) /* Group address as the destination - no ACK */
130                 return 0;
131
132         /* Individual destination address:
133          * IEEE 802.11, Ch. 9.6 (after IEEE 802.11g changes)
134          * CTS and ACK frames shall be transmitted using the highest rate in
135          * basic rate set that is less than or equal to the rate of the
136          * immediately previous frame and that is using the same modulation
137          * (CCK or OFDM). If no basic rate set matches with these requirements,
138          * the highest mandatory rate of the PHY that is less than or equal to
139          * the rate of the previous frame is used.
140          * Mandatory rates for IEEE 802.11g PHY: 1, 2, 5.5, 11, 6, 12, 24 Mbps
141          */
142         rate = -1;
143         /* use lowest available if everything fails */
144         mrate = sband->bitrates[0].bitrate;
145         for (i = 0; i < sband->n_bitrates; i++) {
146                 struct ieee80211_rate *r = &sband->bitrates[i];
147
148                 if (r->bitrate > txrate->bitrate)
149                         break;
150
151                 if ((rate_flags & r->flags) != rate_flags)
152                         continue;
153
154                 if (tx->sdata->vif.bss_conf.basic_rates & BIT(i))
155                         rate = DIV_ROUND_UP(r->bitrate, 1 << shift);
156
157                 switch (sband->band) {
158                 case NL80211_BAND_2GHZ: {
159                         u32 flag;
160                         if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
161                                 flag = IEEE80211_RATE_MANDATORY_G;
162                         else
163                                 flag = IEEE80211_RATE_MANDATORY_B;
164                         if (r->flags & flag)
165                                 mrate = r->bitrate;
166                         break;
167                 }
168                 case NL80211_BAND_5GHZ:
169                         if (r->flags & IEEE80211_RATE_MANDATORY_A)
170                                 mrate = r->bitrate;
171                         break;
172                 case NL80211_BAND_60GHZ:
173                         /* TODO, for now fall through */
174                 case NUM_NL80211_BANDS:
175                         WARN_ON(1);
176                         break;
177                 }
178         }
179         if (rate == -1) {
180                 /* No matching basic rate found; use highest suitable mandatory
181                  * PHY rate */
182                 rate = DIV_ROUND_UP(mrate, 1 << shift);
183         }
184
185         /* Don't calculate ACKs for QoS Frames with NoAck Policy set */
186         if (ieee80211_is_data_qos(hdr->frame_control) &&
187             *(ieee80211_get_qos_ctl(hdr)) & IEEE80211_QOS_CTL_ACK_POLICY_NOACK)
188                 dur = 0;
189         else
190                 /* Time needed to transmit ACK
191                  * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
192                  * to closest integer */
193                 dur = ieee80211_frame_duration(sband->band, 10, rate, erp,
194                                 tx->sdata->vif.bss_conf.use_short_preamble,
195                                 shift);
196
197         if (next_frag_len) {
198                 /* Frame is fragmented: duration increases with time needed to
199                  * transmit next fragment plus ACK and 2 x SIFS. */
200                 dur *= 2; /* ACK + SIFS */
201                 /* next fragment */
202                 dur += ieee80211_frame_duration(sband->band, next_frag_len,
203                                 txrate->bitrate, erp,
204                                 tx->sdata->vif.bss_conf.use_short_preamble,
205                                 shift);
206         }
207
208         return cpu_to_le16(dur);
209 }
210
211 /* tx handlers */
212 static ieee80211_tx_result debug_noinline
213 ieee80211_tx_h_dynamic_ps(struct ieee80211_tx_data *tx)
214 {
215         struct ieee80211_local *local = tx->local;
216         struct ieee80211_if_managed *ifmgd;
217
218         /* driver doesn't support power save */
219         if (!ieee80211_hw_check(&local->hw, SUPPORTS_PS))
220                 return TX_CONTINUE;
221
222         /* hardware does dynamic power save */
223         if (ieee80211_hw_check(&local->hw, SUPPORTS_DYNAMIC_PS))
224                 return TX_CONTINUE;
225
226         /* dynamic power save disabled */
227         if (local->hw.conf.dynamic_ps_timeout <= 0)
228                 return TX_CONTINUE;
229
230         /* we are scanning, don't enable power save */
231         if (local->scanning)
232                 return TX_CONTINUE;
233
234         if (!local->ps_sdata)
235                 return TX_CONTINUE;
236
237         /* No point if we're going to suspend */
238         if (local->quiescing)
239                 return TX_CONTINUE;
240
241         /* dynamic ps is supported only in managed mode */
242         if (tx->sdata->vif.type != NL80211_IFTYPE_STATION)
243                 return TX_CONTINUE;
244
245         ifmgd = &tx->sdata->u.mgd;
246
247         /*
248          * Don't wakeup from power save if u-apsd is enabled, voip ac has
249          * u-apsd enabled and the frame is in voip class. This effectively
250          * means that even if all access categories have u-apsd enabled, in
251          * practise u-apsd is only used with the voip ac. This is a
252          * workaround for the case when received voip class packets do not
253          * have correct qos tag for some reason, due the network or the
254          * peer application.
255          *
256          * Note: ifmgd->uapsd_queues access is racy here. If the value is
257          * changed via debugfs, user needs to reassociate manually to have
258          * everything in sync.
259          */
260         if ((ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED) &&
261             (ifmgd->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) &&
262             skb_get_queue_mapping(tx->skb) == IEEE80211_AC_VO)
263                 return TX_CONTINUE;
264
265         if (local->hw.conf.flags & IEEE80211_CONF_PS) {
266                 ieee80211_stop_queues_by_reason(&local->hw,
267                                                 IEEE80211_MAX_QUEUE_MAP,
268                                                 IEEE80211_QUEUE_STOP_REASON_PS,
269                                                 false);
270                 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
271                 ieee80211_queue_work(&local->hw,
272                                      &local->dynamic_ps_disable_work);
273         }
274
275         /* Don't restart the timer if we're not disassociated */
276         if (!ifmgd->associated)
277                 return TX_CONTINUE;
278
279         mod_timer(&local->dynamic_ps_timer, jiffies +
280                   msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
281
282         return TX_CONTINUE;
283 }
284
285 static ieee80211_tx_result debug_noinline
286 ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx)
287 {
288
289         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
290         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
291         bool assoc = false;
292
293         if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED))
294                 return TX_CONTINUE;
295
296         if (unlikely(test_bit(SCAN_SW_SCANNING, &tx->local->scanning)) &&
297             test_bit(SDATA_STATE_OFFCHANNEL, &tx->sdata->state) &&
298             !ieee80211_is_probe_req(hdr->frame_control) &&
299             !ieee80211_is_nullfunc(hdr->frame_control))
300                 /*
301                  * When software scanning only nullfunc frames (to notify
302                  * the sleep state to the AP) and probe requests (for the
303                  * active scan) are allowed, all other frames should not be
304                  * sent and we should not get here, but if we do
305                  * nonetheless, drop them to avoid sending them
306                  * off-channel. See the link below and
307                  * ieee80211_start_scan() for more.
308                  *
309                  * http://article.gmane.org/gmane.linux.kernel.wireless.general/30089
310                  */
311                 return TX_DROP;
312
313         if (tx->sdata->vif.type == NL80211_IFTYPE_OCB)
314                 return TX_CONTINUE;
315
316         if (tx->sdata->vif.type == NL80211_IFTYPE_WDS)
317                 return TX_CONTINUE;
318
319         if (tx->flags & IEEE80211_TX_PS_BUFFERED)
320                 return TX_CONTINUE;
321
322         if (tx->sta)
323                 assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC);
324
325         if (likely(tx->flags & IEEE80211_TX_UNICAST)) {
326                 if (unlikely(!assoc &&
327                              ieee80211_is_data(hdr->frame_control))) {
328 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
329                         sdata_info(tx->sdata,
330                                    "dropped data frame to not associated station %pM\n",
331                                    hdr->addr1);
332 #endif
333                         I802_DEBUG_INC(tx->local->tx_handlers_drop_not_assoc);
334                         return TX_DROP;
335                 }
336         } else if (unlikely(ieee80211_is_data(hdr->frame_control) &&
337                             ieee80211_vif_get_num_mcast_if(tx->sdata) == 0)) {
338                 /*
339                  * No associated STAs - no need to send multicast
340                  * frames.
341                  */
342                 return TX_DROP;
343         }
344
345         return TX_CONTINUE;
346 }
347
348 /* This function is called whenever the AP is about to exceed the maximum limit
349  * of buffered frames for power saving STAs. This situation should not really
350  * happen often during normal operation, so dropping the oldest buffered packet
351  * from each queue should be OK to make some room for new frames. */
352 static void purge_old_ps_buffers(struct ieee80211_local *local)
353 {
354         int total = 0, purged = 0;
355         struct sk_buff *skb;
356         struct ieee80211_sub_if_data *sdata;
357         struct sta_info *sta;
358
359         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
360                 struct ps_data *ps;
361
362                 if (sdata->vif.type == NL80211_IFTYPE_AP)
363                         ps = &sdata->u.ap.ps;
364                 else if (ieee80211_vif_is_mesh(&sdata->vif))
365                         ps = &sdata->u.mesh.ps;
366                 else
367                         continue;
368
369                 skb = skb_dequeue(&ps->bc_buf);
370                 if (skb) {
371                         purged++;
372                         ieee80211_free_txskb(&local->hw, skb);
373                 }
374                 total += skb_queue_len(&ps->bc_buf);
375         }
376
377         /*
378          * Drop one frame from each station from the lowest-priority
379          * AC that has frames at all.
380          */
381         list_for_each_entry_rcu(sta, &local->sta_list, list) {
382                 int ac;
383
384                 for (ac = IEEE80211_AC_BK; ac >= IEEE80211_AC_VO; ac--) {
385                         skb = skb_dequeue(&sta->ps_tx_buf[ac]);
386                         total += skb_queue_len(&sta->ps_tx_buf[ac]);
387                         if (skb) {
388                                 purged++;
389                                 ieee80211_free_txskb(&local->hw, skb);
390                                 break;
391                         }
392                 }
393         }
394
395         local->total_ps_buffered = total;
396         ps_dbg_hw(&local->hw, "PS buffers full - purged %d frames\n", purged);
397 }
398
399 static ieee80211_tx_result
400 ieee80211_tx_h_multicast_ps_buf(struct ieee80211_tx_data *tx)
401 {
402         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
403         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
404         struct ps_data *ps;
405
406         /*
407          * broadcast/multicast frame
408          *
409          * If any of the associated/peer stations is in power save mode,
410          * the frame is buffered to be sent after DTIM beacon frame.
411          * This is done either by the hardware or us.
412          */
413
414         /* powersaving STAs currently only in AP/VLAN/mesh mode */
415         if (tx->sdata->vif.type == NL80211_IFTYPE_AP ||
416             tx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
417                 if (!tx->sdata->bss)
418                         return TX_CONTINUE;
419
420                 ps = &tx->sdata->bss->ps;
421         } else if (ieee80211_vif_is_mesh(&tx->sdata->vif)) {
422                 ps = &tx->sdata->u.mesh.ps;
423         } else {
424                 return TX_CONTINUE;
425         }
426
427
428         /* no buffering for ordered frames */
429         if (ieee80211_has_order(hdr->frame_control))
430                 return TX_CONTINUE;
431
432         if (ieee80211_is_probe_req(hdr->frame_control))
433                 return TX_CONTINUE;
434
435         if (ieee80211_hw_check(&tx->local->hw, QUEUE_CONTROL))
436                 info->hw_queue = tx->sdata->vif.cab_queue;
437
438         /* no stations in PS mode */
439         if (!atomic_read(&ps->num_sta_ps))
440                 return TX_CONTINUE;
441
442         info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM;
443
444         /* device releases frame after DTIM beacon */
445         if (!ieee80211_hw_check(&tx->local->hw, HOST_BROADCAST_PS_BUFFERING))
446                 return TX_CONTINUE;
447
448         /* buffered in mac80211 */
449         if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
450                 purge_old_ps_buffers(tx->local);
451
452         if (skb_queue_len(&ps->bc_buf) >= AP_MAX_BC_BUFFER) {
453                 ps_dbg(tx->sdata,
454                        "BC TX buffer full - dropping the oldest frame\n");
455                 ieee80211_free_txskb(&tx->local->hw, skb_dequeue(&ps->bc_buf));
456         } else
457                 tx->local->total_ps_buffered++;
458
459         skb_queue_tail(&ps->bc_buf, tx->skb);
460
461         return TX_QUEUED;
462 }
463
464 static int ieee80211_use_mfp(__le16 fc, struct sta_info *sta,
465                              struct sk_buff *skb)
466 {
467         if (!ieee80211_is_mgmt(fc))
468                 return 0;
469
470         if (sta == NULL || !test_sta_flag(sta, WLAN_STA_MFP))
471                 return 0;
472
473         if (!ieee80211_is_robust_mgmt_frame(skb))
474                 return 0;
475
476         return 1;
477 }
478
479 static ieee80211_tx_result
480 ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
481 {
482         struct sta_info *sta = tx->sta;
483         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
484         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
485         struct ieee80211_local *local = tx->local;
486
487         if (unlikely(!sta))
488                 return TX_CONTINUE;
489
490         if (unlikely((test_sta_flag(sta, WLAN_STA_PS_STA) ||
491                       test_sta_flag(sta, WLAN_STA_PS_DRIVER) ||
492                       test_sta_flag(sta, WLAN_STA_PS_DELIVER)) &&
493                      !(info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER))) {
494                 int ac = skb_get_queue_mapping(tx->skb);
495
496                 if (ieee80211_is_mgmt(hdr->frame_control) &&
497                     !ieee80211_is_bufferable_mmpdu(hdr->frame_control)) {
498                         info->flags |= IEEE80211_TX_CTL_NO_PS_BUFFER;
499                         return TX_CONTINUE;
500                 }
501
502                 ps_dbg(sta->sdata, "STA %pM aid %d: PS buffer for AC %d\n",
503                        sta->sta.addr, sta->sta.aid, ac);
504                 if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
505                         purge_old_ps_buffers(tx->local);
506
507                 /* sync with ieee80211_sta_ps_deliver_wakeup */
508                 spin_lock(&sta->ps_lock);
509                 /*
510                  * STA woke up the meantime and all the frames on ps_tx_buf have
511                  * been queued to pending queue. No reordering can happen, go
512                  * ahead and Tx the packet.
513                  */
514                 if (!test_sta_flag(sta, WLAN_STA_PS_STA) &&
515                     !test_sta_flag(sta, WLAN_STA_PS_DRIVER) &&
516                     !test_sta_flag(sta, WLAN_STA_PS_DELIVER)) {
517                         spin_unlock(&sta->ps_lock);
518                         return TX_CONTINUE;
519                 }
520
521                 if (skb_queue_len(&sta->ps_tx_buf[ac]) >= STA_MAX_TX_BUFFER) {
522                         struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf[ac]);
523                         ps_dbg(tx->sdata,
524                                "STA %pM TX buffer for AC %d full - dropping oldest frame\n",
525                                sta->sta.addr, ac);
526                         ieee80211_free_txskb(&local->hw, old);
527                 } else
528                         tx->local->total_ps_buffered++;
529
530                 info->control.jiffies = jiffies;
531                 info->control.vif = &tx->sdata->vif;
532                 info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
533                 info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS;
534                 skb_queue_tail(&sta->ps_tx_buf[ac], tx->skb);
535                 spin_unlock(&sta->ps_lock);
536
537                 if (!timer_pending(&local->sta_cleanup))
538                         mod_timer(&local->sta_cleanup,
539                                   round_jiffies(jiffies +
540                                                 STA_INFO_CLEANUP_INTERVAL));
541
542                 /*
543                  * We queued up some frames, so the TIM bit might
544                  * need to be set, recalculate it.
545                  */
546                 sta_info_recalc_tim(sta);
547
548                 return TX_QUEUED;
549         } else if (unlikely(test_sta_flag(sta, WLAN_STA_PS_STA))) {
550                 ps_dbg(tx->sdata,
551                        "STA %pM in PS mode, but polling/in SP -> send frame\n",
552                        sta->sta.addr);
553         }
554
555         return TX_CONTINUE;
556 }
557
558 static ieee80211_tx_result debug_noinline
559 ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx)
560 {
561         if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED))
562                 return TX_CONTINUE;
563
564         if (tx->flags & IEEE80211_TX_UNICAST)
565                 return ieee80211_tx_h_unicast_ps_buf(tx);
566         else
567                 return ieee80211_tx_h_multicast_ps_buf(tx);
568 }
569
570 static ieee80211_tx_result debug_noinline
571 ieee80211_tx_h_check_control_port_protocol(struct ieee80211_tx_data *tx)
572 {
573         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
574
575         if (unlikely(tx->sdata->control_port_protocol == tx->skb->protocol)) {
576                 if (tx->sdata->control_port_no_encrypt)
577                         info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
578                 info->control.flags |= IEEE80211_TX_CTRL_PORT_CTRL_PROTO;
579                 info->flags |= IEEE80211_TX_CTL_USE_MINRATE;
580         }
581
582         return TX_CONTINUE;
583 }
584
585 static ieee80211_tx_result debug_noinline
586 ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
587 {
588         struct ieee80211_key *key;
589         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
590         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
591
592         if (unlikely(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT))
593                 tx->key = NULL;
594         else if (tx->sta &&
595                  (key = rcu_dereference(tx->sta->ptk[tx->sta->ptk_idx])))
596                 tx->key = key;
597         else if (ieee80211_is_group_privacy_action(tx->skb) &&
598                 (key = rcu_dereference(tx->sdata->default_multicast_key)))
599                 tx->key = key;
600         else if (ieee80211_is_mgmt(hdr->frame_control) &&
601                  is_multicast_ether_addr(hdr->addr1) &&
602                  ieee80211_is_robust_mgmt_frame(tx->skb) &&
603                  (key = rcu_dereference(tx->sdata->default_mgmt_key)))
604                 tx->key = key;
605         else if (is_multicast_ether_addr(hdr->addr1) &&
606                  (key = rcu_dereference(tx->sdata->default_multicast_key)))
607                 tx->key = key;
608         else if (!is_multicast_ether_addr(hdr->addr1) &&
609                  (key = rcu_dereference(tx->sdata->default_unicast_key)))
610                 tx->key = key;
611         else
612                 tx->key = NULL;
613
614         if (tx->key) {
615                 bool skip_hw = false;
616
617                 /* TODO: add threshold stuff again */
618
619                 switch (tx->key->conf.cipher) {
620                 case WLAN_CIPHER_SUITE_WEP40:
621                 case WLAN_CIPHER_SUITE_WEP104:
622                 case WLAN_CIPHER_SUITE_TKIP:
623                         if (!ieee80211_is_data_present(hdr->frame_control))
624                                 tx->key = NULL;
625                         break;
626                 case WLAN_CIPHER_SUITE_CCMP:
627                 case WLAN_CIPHER_SUITE_CCMP_256:
628                 case WLAN_CIPHER_SUITE_GCMP:
629                 case WLAN_CIPHER_SUITE_GCMP_256:
630                         if (!ieee80211_is_data_present(hdr->frame_control) &&
631                             !ieee80211_use_mfp(hdr->frame_control, tx->sta,
632                                                tx->skb) &&
633                             !ieee80211_is_group_privacy_action(tx->skb))
634                                 tx->key = NULL;
635                         else
636                                 skip_hw = (tx->key->conf.flags &
637                                            IEEE80211_KEY_FLAG_SW_MGMT_TX) &&
638                                         ieee80211_is_mgmt(hdr->frame_control);
639                         break;
640                 case WLAN_CIPHER_SUITE_AES_CMAC:
641                 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
642                 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
643                 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
644                         if (!ieee80211_is_mgmt(hdr->frame_control))
645                                 tx->key = NULL;
646                         break;
647                 }
648
649                 if (unlikely(tx->key && tx->key->flags & KEY_FLAG_TAINTED &&
650                              !ieee80211_is_deauth(hdr->frame_control)))
651                         return TX_DROP;
652
653                 if (!skip_hw && tx->key &&
654                     tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
655                         info->control.hw_key = &tx->key->conf;
656         }
657
658         return TX_CONTINUE;
659 }
660
661 static ieee80211_tx_result debug_noinline
662 ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
663 {
664         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
665         struct ieee80211_hdr *hdr = (void *)tx->skb->data;
666         struct ieee80211_supported_band *sband;
667         u32 len;
668         struct ieee80211_tx_rate_control txrc;
669         struct ieee80211_sta_rates *ratetbl = NULL;
670         bool assoc = false;
671
672         memset(&txrc, 0, sizeof(txrc));
673
674         sband = tx->local->hw.wiphy->bands[info->band];
675
676         len = min_t(u32, tx->skb->len + FCS_LEN,
677                          tx->local->hw.wiphy->frag_threshold);
678
679         /* set up the tx rate control struct we give the RC algo */
680         txrc.hw = &tx->local->hw;
681         txrc.sband = sband;
682         txrc.bss_conf = &tx->sdata->vif.bss_conf;
683         txrc.skb = tx->skb;
684         txrc.reported_rate.idx = -1;
685         txrc.rate_idx_mask = tx->sdata->rc_rateidx_mask[info->band];
686
687         if (tx->sdata->rc_has_mcs_mask[info->band])
688                 txrc.rate_idx_mcs_mask =
689                         tx->sdata->rc_rateidx_mcs_mask[info->band];
690
691         txrc.bss = (tx->sdata->vif.type == NL80211_IFTYPE_AP ||
692                     tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
693                     tx->sdata->vif.type == NL80211_IFTYPE_ADHOC ||
694                     tx->sdata->vif.type == NL80211_IFTYPE_OCB);
695
696         /* set up RTS protection if desired */
697         if (len > tx->local->hw.wiphy->rts_threshold) {
698                 txrc.rts = true;
699         }
700
701         info->control.use_rts = txrc.rts;
702         info->control.use_cts_prot = tx->sdata->vif.bss_conf.use_cts_prot;
703
704         /*
705          * Use short preamble if the BSS can handle it, but not for
706          * management frames unless we know the receiver can handle
707          * that -- the management frame might be to a station that
708          * just wants a probe response.
709          */
710         if (tx->sdata->vif.bss_conf.use_short_preamble &&
711             (ieee80211_is_data(hdr->frame_control) ||
712              (tx->sta && test_sta_flag(tx->sta, WLAN_STA_SHORT_PREAMBLE))))
713                 txrc.short_preamble = true;
714
715         info->control.short_preamble = txrc.short_preamble;
716
717         /* don't ask rate control when rate already injected via radiotap */
718         if (info->control.flags & IEEE80211_TX_CTRL_RATE_INJECT)
719                 return TX_CONTINUE;
720
721         if (tx->sta)
722                 assoc = test_sta_flag(tx->sta, WLAN_STA_ASSOC);
723
724         /*
725          * Lets not bother rate control if we're associated and cannot
726          * talk to the sta. This should not happen.
727          */
728         if (WARN(test_bit(SCAN_SW_SCANNING, &tx->local->scanning) && assoc &&
729                  !rate_usable_index_exists(sband, &tx->sta->sta),
730                  "%s: Dropped data frame as no usable bitrate found while "
731                  "scanning and associated. Target station: "
732                  "%pM on %d GHz band\n",
733                  tx->sdata->name, hdr->addr1,
734                  info->band ? 5 : 2))
735                 return TX_DROP;
736
737         /*
738          * If we're associated with the sta at this point we know we can at
739          * least send the frame at the lowest bit rate.
740          */
741         rate_control_get_rate(tx->sdata, tx->sta, &txrc);
742
743         if (tx->sta && !info->control.skip_table)
744                 ratetbl = rcu_dereference(tx->sta->sta.rates);
745
746         if (unlikely(info->control.rates[0].idx < 0)) {
747                 if (ratetbl) {
748                         struct ieee80211_tx_rate rate = {
749                                 .idx = ratetbl->rate[0].idx,
750                                 .flags = ratetbl->rate[0].flags,
751                                 .count = ratetbl->rate[0].count
752                         };
753
754                         if (ratetbl->rate[0].idx < 0)
755                                 return TX_DROP;
756
757                         tx->rate = rate;
758                 } else {
759                         return TX_DROP;
760                 }
761         } else {
762                 tx->rate = info->control.rates[0];
763         }
764
765         if (txrc.reported_rate.idx < 0) {
766                 txrc.reported_rate = tx->rate;
767                 if (tx->sta && ieee80211_is_data(hdr->frame_control))
768                         tx->sta->tx_stats.last_rate = txrc.reported_rate;
769         } else if (tx->sta)
770                 tx->sta->tx_stats.last_rate = txrc.reported_rate;
771
772         if (ratetbl)
773                 return TX_CONTINUE;
774
775         if (unlikely(!info->control.rates[0].count))
776                 info->control.rates[0].count = 1;
777
778         if (WARN_ON_ONCE((info->control.rates[0].count > 1) &&
779                          (info->flags & IEEE80211_TX_CTL_NO_ACK)))
780                 info->control.rates[0].count = 1;
781
782         return TX_CONTINUE;
783 }
784
785 static __le16 ieee80211_tx_next_seq(struct sta_info *sta, int tid)
786 {
787         u16 *seq = &sta->tid_seq[tid];
788         __le16 ret = cpu_to_le16(*seq);
789
790         /* Increase the sequence number. */
791         *seq = (*seq + 0x10) & IEEE80211_SCTL_SEQ;
792
793         return ret;
794 }
795
796 static ieee80211_tx_result debug_noinline
797 ieee80211_tx_h_sequence(struct ieee80211_tx_data *tx)
798 {
799         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
800         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
801         int tid;
802
803         /*
804          * Packet injection may want to control the sequence
805          * number, if we have no matching interface then we
806          * neither assign one ourselves nor ask the driver to.
807          */
808         if (unlikely(info->control.vif->type == NL80211_IFTYPE_MONITOR))
809                 return TX_CONTINUE;
810
811         if (unlikely(ieee80211_is_ctl(hdr->frame_control)))
812                 return TX_CONTINUE;
813
814         if (ieee80211_hdrlen(hdr->frame_control) < 24)
815                 return TX_CONTINUE;
816
817         if (ieee80211_is_qos_nullfunc(hdr->frame_control))
818                 return TX_CONTINUE;
819
820         /*
821          * Anything but QoS data that has a sequence number field
822          * (is long enough) gets a sequence number from the global
823          * counter.  QoS data frames with a multicast destination
824          * also use the global counter (802.11-2012 9.3.2.10).
825          */
826         if (!ieee80211_is_data_qos(hdr->frame_control) ||
827             is_multicast_ether_addr(hdr->addr1)) {
828                 if (tx->flags & IEEE80211_TX_NO_SEQNO)
829                         return TX_CONTINUE;
830                 /* driver should assign sequence number */
831                 info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
832                 /* for pure STA mode without beacons, we can do it */
833                 hdr->seq_ctrl = cpu_to_le16(tx->sdata->sequence_number);
834                 tx->sdata->sequence_number += 0x10;
835                 if (tx->sta)
836                         tx->sta->tx_stats.msdu[IEEE80211_NUM_TIDS]++;
837                 return TX_CONTINUE;
838         }
839
840         /*
841          * This should be true for injected/management frames only, for
842          * management frames we have set the IEEE80211_TX_CTL_ASSIGN_SEQ
843          * above since they are not QoS-data frames.
844          */
845         if (!tx->sta)
846                 return TX_CONTINUE;
847
848         /* include per-STA, per-TID sequence counter */
849         tid = ieee80211_get_tid(hdr);
850         tx->sta->tx_stats.msdu[tid]++;
851
852         hdr->seq_ctrl = ieee80211_tx_next_seq(tx->sta, tid);
853
854         return TX_CONTINUE;
855 }
856
857 static int ieee80211_fragment(struct ieee80211_tx_data *tx,
858                               struct sk_buff *skb, int hdrlen,
859                               int frag_threshold)
860 {
861         struct ieee80211_local *local = tx->local;
862         struct ieee80211_tx_info *info;
863         struct sk_buff *tmp;
864         int per_fragm = frag_threshold - hdrlen - FCS_LEN;
865         int pos = hdrlen + per_fragm;
866         int rem = skb->len - hdrlen - per_fragm;
867
868         if (WARN_ON(rem < 0))
869                 return -EINVAL;
870
871         /* first fragment was already added to queue by caller */
872
873         while (rem) {
874                 int fraglen = per_fragm;
875
876                 if (fraglen > rem)
877                         fraglen = rem;
878                 rem -= fraglen;
879                 tmp = dev_alloc_skb(local->tx_headroom +
880                                     frag_threshold +
881                                     tx->sdata->encrypt_headroom +
882                                     IEEE80211_ENCRYPT_TAILROOM);
883                 if (!tmp)
884                         return -ENOMEM;
885
886                 __skb_queue_tail(&tx->skbs, tmp);
887
888                 skb_reserve(tmp,
889                             local->tx_headroom + tx->sdata->encrypt_headroom);
890
891                 /* copy control information */
892                 memcpy(tmp->cb, skb->cb, sizeof(tmp->cb));
893
894                 info = IEEE80211_SKB_CB(tmp);
895                 info->flags &= ~(IEEE80211_TX_CTL_CLEAR_PS_FILT |
896                                  IEEE80211_TX_CTL_FIRST_FRAGMENT);
897
898                 if (rem)
899                         info->flags |= IEEE80211_TX_CTL_MORE_FRAMES;
900
901                 skb_copy_queue_mapping(tmp, skb);
902                 tmp->priority = skb->priority;
903                 tmp->dev = skb->dev;
904
905                 /* copy header and data */
906                 skb_put_data(tmp, skb->data, hdrlen);
907                 skb_put_data(tmp, skb->data + pos, fraglen);
908
909                 pos += fraglen;
910         }
911
912         /* adjust first fragment's length */
913         skb_trim(skb, hdrlen + per_fragm);
914         return 0;
915 }
916
917 static ieee80211_tx_result debug_noinline
918 ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx)
919 {
920         struct sk_buff *skb = tx->skb;
921         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
922         struct ieee80211_hdr *hdr = (void *)skb->data;
923         int frag_threshold = tx->local->hw.wiphy->frag_threshold;
924         int hdrlen;
925         int fragnum;
926
927         /* no matter what happens, tx->skb moves to tx->skbs */
928         __skb_queue_tail(&tx->skbs, skb);
929         tx->skb = NULL;
930
931         if (info->flags & IEEE80211_TX_CTL_DONTFRAG)
932                 return TX_CONTINUE;
933
934         if (ieee80211_hw_check(&tx->local->hw, SUPPORTS_TX_FRAG))
935                 return TX_CONTINUE;
936
937         /*
938          * Warn when submitting a fragmented A-MPDU frame and drop it.
939          * This scenario is handled in ieee80211_tx_prepare but extra
940          * caution taken here as fragmented ampdu may cause Tx stop.
941          */
942         if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU))
943                 return TX_DROP;
944
945         hdrlen = ieee80211_hdrlen(hdr->frame_control);
946
947         /* internal error, why isn't DONTFRAG set? */
948         if (WARN_ON(skb->len + FCS_LEN <= frag_threshold))
949                 return TX_DROP;
950
951         /*
952          * Now fragment the frame. This will allocate all the fragments and
953          * chain them (using skb as the first fragment) to skb->next.
954          * During transmission, we will remove the successfully transmitted
955          * fragments from this list. When the low-level driver rejects one
956          * of the fragments then we will simply pretend to accept the skb
957          * but store it away as pending.
958          */
959         if (ieee80211_fragment(tx, skb, hdrlen, frag_threshold))
960                 return TX_DROP;
961
962         /* update duration/seq/flags of fragments */
963         fragnum = 0;
964
965         skb_queue_walk(&tx->skbs, skb) {
966                 const __le16 morefrags = cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
967
968                 hdr = (void *)skb->data;
969                 info = IEEE80211_SKB_CB(skb);
970
971                 if (!skb_queue_is_last(&tx->skbs, skb)) {
972                         hdr->frame_control |= morefrags;
973                         /*
974                          * No multi-rate retries for fragmented frames, that
975                          * would completely throw off the NAV at other STAs.
976                          */
977                         info->control.rates[1].idx = -1;
978                         info->control.rates[2].idx = -1;
979                         info->control.rates[3].idx = -1;
980                         BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 4);
981                         info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
982                 } else {
983                         hdr->frame_control &= ~morefrags;
984                 }
985                 hdr->seq_ctrl |= cpu_to_le16(fragnum & IEEE80211_SCTL_FRAG);
986                 fragnum++;
987         }
988
989         return TX_CONTINUE;
990 }
991
992 static ieee80211_tx_result debug_noinline
993 ieee80211_tx_h_stats(struct ieee80211_tx_data *tx)
994 {
995         struct sk_buff *skb;
996         int ac = -1;
997
998         if (!tx->sta)
999                 return TX_CONTINUE;
1000
1001         skb_queue_walk(&tx->skbs, skb) {
1002                 ac = skb_get_queue_mapping(skb);
1003                 tx->sta->tx_stats.bytes[ac] += skb->len;
1004         }
1005         if (ac >= 0)
1006                 tx->sta->tx_stats.packets[ac]++;
1007
1008         return TX_CONTINUE;
1009 }
1010
1011 static ieee80211_tx_result debug_noinline
1012 ieee80211_tx_h_encrypt(struct ieee80211_tx_data *tx)
1013 {
1014         if (!tx->key)
1015                 return TX_CONTINUE;
1016
1017         switch (tx->key->conf.cipher) {
1018         case WLAN_CIPHER_SUITE_WEP40:
1019         case WLAN_CIPHER_SUITE_WEP104:
1020                 return ieee80211_crypto_wep_encrypt(tx);
1021         case WLAN_CIPHER_SUITE_TKIP:
1022                 return ieee80211_crypto_tkip_encrypt(tx);
1023         case WLAN_CIPHER_SUITE_CCMP:
1024                 return ieee80211_crypto_ccmp_encrypt(
1025                         tx, IEEE80211_CCMP_MIC_LEN);
1026         case WLAN_CIPHER_SUITE_CCMP_256:
1027                 return ieee80211_crypto_ccmp_encrypt(
1028                         tx, IEEE80211_CCMP_256_MIC_LEN);
1029         case WLAN_CIPHER_SUITE_AES_CMAC:
1030                 return ieee80211_crypto_aes_cmac_encrypt(tx);
1031         case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1032                 return ieee80211_crypto_aes_cmac_256_encrypt(tx);
1033         case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1034         case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1035                 return ieee80211_crypto_aes_gmac_encrypt(tx);
1036         case WLAN_CIPHER_SUITE_GCMP:
1037         case WLAN_CIPHER_SUITE_GCMP_256:
1038                 return ieee80211_crypto_gcmp_encrypt(tx);
1039         default:
1040                 return ieee80211_crypto_hw_encrypt(tx);
1041         }
1042
1043         return TX_DROP;
1044 }
1045
1046 static ieee80211_tx_result debug_noinline
1047 ieee80211_tx_h_calculate_duration(struct ieee80211_tx_data *tx)
1048 {
1049         struct sk_buff *skb;
1050         struct ieee80211_hdr *hdr;
1051         int next_len;
1052         bool group_addr;
1053
1054         skb_queue_walk(&tx->skbs, skb) {
1055                 hdr = (void *) skb->data;
1056                 if (unlikely(ieee80211_is_pspoll(hdr->frame_control)))
1057                         break; /* must not overwrite AID */
1058                 if (!skb_queue_is_last(&tx->skbs, skb)) {
1059                         struct sk_buff *next = skb_queue_next(&tx->skbs, skb);
1060                         next_len = next->len;
1061                 } else
1062                         next_len = 0;
1063                 group_addr = is_multicast_ether_addr(hdr->addr1);
1064
1065                 hdr->duration_id =
1066                         ieee80211_duration(tx, skb, group_addr, next_len);
1067         }
1068
1069         return TX_CONTINUE;
1070 }
1071
1072 /* actual transmit path */
1073
1074 static bool ieee80211_tx_prep_agg(struct ieee80211_tx_data *tx,
1075                                   struct sk_buff *skb,
1076                                   struct ieee80211_tx_info *info,
1077                                   struct tid_ampdu_tx *tid_tx,
1078                                   int tid)
1079 {
1080         bool queued = false;
1081         bool reset_agg_timer = false;
1082         struct sk_buff *purge_skb = NULL;
1083
1084         if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) {
1085                 info->flags |= IEEE80211_TX_CTL_AMPDU;
1086                 reset_agg_timer = true;
1087         } else if (test_bit(HT_AGG_STATE_WANT_START, &tid_tx->state)) {
1088                 /*
1089                  * nothing -- this aggregation session is being started
1090                  * but that might still fail with the driver
1091                  */
1092         } else if (!tx->sta->sta.txq[tid]) {
1093                 spin_lock(&tx->sta->lock);
1094                 /*
1095                  * Need to re-check now, because we may get here
1096                  *
1097                  *  1) in the window during which the setup is actually
1098                  *     already done, but not marked yet because not all
1099                  *     packets are spliced over to the driver pending
1100                  *     queue yet -- if this happened we acquire the lock
1101                  *     either before or after the splice happens, but
1102                  *     need to recheck which of these cases happened.
1103                  *
1104                  *  2) during session teardown, if the OPERATIONAL bit
1105                  *     was cleared due to the teardown but the pointer
1106                  *     hasn't been assigned NULL yet (or we loaded it
1107                  *     before it was assigned) -- in this case it may
1108                  *     now be NULL which means we should just let the
1109                  *     packet pass through because splicing the frames
1110                  *     back is already done.
1111                  */
1112                 tid_tx = rcu_dereference_protected_tid_tx(tx->sta, tid);
1113
1114                 if (!tid_tx) {
1115                         /* do nothing, let packet pass through */
1116                 } else if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) {
1117                         info->flags |= IEEE80211_TX_CTL_AMPDU;
1118                         reset_agg_timer = true;
1119                 } else {
1120                         queued = true;
1121                         if (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER) {
1122                                 clear_sta_flag(tx->sta, WLAN_STA_SP);
1123                                 ps_dbg(tx->sta->sdata,
1124                                        "STA %pM aid %d: SP frame queued, close the SP w/o telling the peer\n",
1125                                        tx->sta->sta.addr, tx->sta->sta.aid);
1126                         }
1127                         info->control.vif = &tx->sdata->vif;
1128                         info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
1129                         info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS;
1130                         __skb_queue_tail(&tid_tx->pending, skb);
1131                         if (skb_queue_len(&tid_tx->pending) > STA_MAX_TX_BUFFER)
1132                                 purge_skb = __skb_dequeue(&tid_tx->pending);
1133                 }
1134                 spin_unlock(&tx->sta->lock);
1135
1136                 if (purge_skb)
1137                         ieee80211_free_txskb(&tx->local->hw, purge_skb);
1138         }
1139
1140         /* reset session timer */
1141         if (reset_agg_timer)
1142                 tid_tx->last_tx = jiffies;
1143
1144         return queued;
1145 }
1146
1147 /*
1148  * initialises @tx
1149  * pass %NULL for the station if unknown, a valid pointer if known
1150  * or an ERR_PTR() if the station is known not to exist
1151  */
1152 static ieee80211_tx_result
1153 ieee80211_tx_prepare(struct ieee80211_sub_if_data *sdata,
1154                      struct ieee80211_tx_data *tx,
1155                      struct sta_info *sta, struct sk_buff *skb)
1156 {
1157         struct ieee80211_local *local = sdata->local;
1158         struct ieee80211_hdr *hdr;
1159         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1160         int tid;
1161
1162         memset(tx, 0, sizeof(*tx));
1163         tx->skb = skb;
1164         tx->local = local;
1165         tx->sdata = sdata;
1166         __skb_queue_head_init(&tx->skbs);
1167
1168         /*
1169          * If this flag is set to true anywhere, and we get here,
1170          * we are doing the needed processing, so remove the flag
1171          * now.
1172          */
1173         info->flags &= ~IEEE80211_TX_INTFL_NEED_TXPROCESSING;
1174
1175         hdr = (struct ieee80211_hdr *) skb->data;
1176
1177         if (likely(sta)) {
1178                 if (!IS_ERR(sta))
1179                         tx->sta = sta;
1180         } else {
1181                 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
1182                         tx->sta = rcu_dereference(sdata->u.vlan.sta);
1183                         if (!tx->sta && sdata->wdev.use_4addr)
1184                                 return TX_DROP;
1185                 } else if (info->flags & (IEEE80211_TX_INTFL_NL80211_FRAME_TX |
1186                                           IEEE80211_TX_CTL_INJECTED) ||
1187                            tx->sdata->control_port_protocol == tx->skb->protocol) {
1188                         tx->sta = sta_info_get_bss(sdata, hdr->addr1);
1189                 }
1190                 if (!tx->sta && !is_multicast_ether_addr(hdr->addr1))
1191                         tx->sta = sta_info_get(sdata, hdr->addr1);
1192         }
1193
1194         if (tx->sta && ieee80211_is_data_qos(hdr->frame_control) &&
1195             !ieee80211_is_qos_nullfunc(hdr->frame_control) &&
1196             ieee80211_hw_check(&local->hw, AMPDU_AGGREGATION) &&
1197             !ieee80211_hw_check(&local->hw, TX_AMPDU_SETUP_IN_HW)) {
1198                 struct tid_ampdu_tx *tid_tx;
1199
1200                 tid = ieee80211_get_tid(hdr);
1201
1202                 tid_tx = rcu_dereference(tx->sta->ampdu_mlme.tid_tx[tid]);
1203                 if (tid_tx) {
1204                         bool queued;
1205
1206                         queued = ieee80211_tx_prep_agg(tx, skb, info,
1207                                                        tid_tx, tid);
1208
1209                         if (unlikely(queued))
1210                                 return TX_QUEUED;
1211                 }
1212         }
1213
1214         if (is_multicast_ether_addr(hdr->addr1)) {
1215                 tx->flags &= ~IEEE80211_TX_UNICAST;
1216                 info->flags |= IEEE80211_TX_CTL_NO_ACK;
1217         } else
1218                 tx->flags |= IEEE80211_TX_UNICAST;
1219
1220         if (!(info->flags & IEEE80211_TX_CTL_DONTFRAG)) {
1221                 if (!(tx->flags & IEEE80211_TX_UNICAST) ||
1222                     skb->len + FCS_LEN <= local->hw.wiphy->frag_threshold ||
1223                     info->flags & IEEE80211_TX_CTL_AMPDU)
1224                         info->flags |= IEEE80211_TX_CTL_DONTFRAG;
1225         }
1226
1227         if (!tx->sta)
1228                 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
1229         else if (test_and_clear_sta_flag(tx->sta, WLAN_STA_CLEAR_PS_FILT)) {
1230                 info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
1231                 ieee80211_check_fast_xmit(tx->sta);
1232         }
1233
1234         info->flags |= IEEE80211_TX_CTL_FIRST_FRAGMENT;
1235
1236         return TX_CONTINUE;
1237 }
1238
1239 static struct txq_info *ieee80211_get_txq(struct ieee80211_local *local,
1240                                           struct ieee80211_vif *vif,
1241                                           struct sta_info *sta,
1242                                           struct sk_buff *skb)
1243 {
1244         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1245         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1246         struct ieee80211_txq *txq = NULL;
1247
1248         if ((info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM) ||
1249             (info->control.flags & IEEE80211_TX_CTRL_PS_RESPONSE))
1250                 return NULL;
1251
1252         if (!ieee80211_is_data_present(hdr->frame_control))
1253                 return NULL;
1254
1255         if (sta) {
1256                 u8 tid = skb->priority & IEEE80211_QOS_CTL_TID_MASK;
1257
1258                 if (!sta->uploaded)
1259                         return NULL;
1260
1261                 txq = sta->sta.txq[tid];
1262         } else if (vif) {
1263                 txq = vif->txq;
1264         }
1265
1266         if (!txq)
1267                 return NULL;
1268
1269         return to_txq_info(txq);
1270 }
1271
1272 static void ieee80211_set_skb_enqueue_time(struct sk_buff *skb)
1273 {
1274         IEEE80211_SKB_CB(skb)->control.enqueue_time = codel_get_time();
1275 }
1276
1277 static u32 codel_skb_len_func(const struct sk_buff *skb)
1278 {
1279         return skb->len;
1280 }
1281
1282 static codel_time_t codel_skb_time_func(const struct sk_buff *skb)
1283 {
1284         const struct ieee80211_tx_info *info;
1285
1286         info = (const struct ieee80211_tx_info *)skb->cb;
1287         return info->control.enqueue_time;
1288 }
1289
1290 static struct sk_buff *codel_dequeue_func(struct codel_vars *cvars,
1291                                           void *ctx)
1292 {
1293         struct ieee80211_local *local;
1294         struct txq_info *txqi;
1295         struct fq *fq;
1296         struct fq_flow *flow;
1297
1298         txqi = ctx;
1299         local = vif_to_sdata(txqi->txq.vif)->local;
1300         fq = &local->fq;
1301
1302         if (cvars == &txqi->def_cvars)
1303                 flow = &txqi->def_flow;
1304         else
1305                 flow = &fq->flows[cvars - local->cvars];
1306
1307         return fq_flow_dequeue(fq, flow);
1308 }
1309
1310 static void codel_drop_func(struct sk_buff *skb,
1311                             void *ctx)
1312 {
1313         struct ieee80211_local *local;
1314         struct ieee80211_hw *hw;
1315         struct txq_info *txqi;
1316
1317         txqi = ctx;
1318         local = vif_to_sdata(txqi->txq.vif)->local;
1319         hw = &local->hw;
1320
1321         ieee80211_free_txskb(hw, skb);
1322 }
1323
1324 static struct sk_buff *fq_tin_dequeue_func(struct fq *fq,
1325                                            struct fq_tin *tin,
1326                                            struct fq_flow *flow)
1327 {
1328         struct ieee80211_local *local;
1329         struct txq_info *txqi;
1330         struct codel_vars *cvars;
1331         struct codel_params *cparams;
1332         struct codel_stats *cstats;
1333
1334         local = container_of(fq, struct ieee80211_local, fq);
1335         txqi = container_of(tin, struct txq_info, tin);
1336         cstats = &txqi->cstats;
1337
1338         if (txqi->txq.sta) {
1339                 struct sta_info *sta = container_of(txqi->txq.sta,
1340                                                     struct sta_info, sta);
1341                 cparams = &sta->cparams;
1342         } else {
1343                 cparams = &local->cparams;
1344         }
1345
1346         if (flow == &txqi->def_flow)
1347                 cvars = &txqi->def_cvars;
1348         else
1349                 cvars = &local->cvars[flow - fq->flows];
1350
1351         return codel_dequeue(txqi,
1352                              &flow->backlog,
1353                              cparams,
1354                              cvars,
1355                              cstats,
1356                              codel_skb_len_func,
1357                              codel_skb_time_func,
1358                              codel_drop_func,
1359                              codel_dequeue_func);
1360 }
1361
1362 static void fq_skb_free_func(struct fq *fq,
1363                              struct fq_tin *tin,
1364                              struct fq_flow *flow,
1365                              struct sk_buff *skb)
1366 {
1367         struct ieee80211_local *local;
1368
1369         local = container_of(fq, struct ieee80211_local, fq);
1370         ieee80211_free_txskb(&local->hw, skb);
1371 }
1372
1373 static struct fq_flow *fq_flow_get_default_func(struct fq *fq,
1374                                                 struct fq_tin *tin,
1375                                                 int idx,
1376                                                 struct sk_buff *skb)
1377 {
1378         struct txq_info *txqi;
1379
1380         txqi = container_of(tin, struct txq_info, tin);
1381         return &txqi->def_flow;
1382 }
1383
1384 static void ieee80211_txq_enqueue(struct ieee80211_local *local,
1385                                   struct txq_info *txqi,
1386                                   struct sk_buff *skb)
1387 {
1388         struct fq *fq = &local->fq;
1389         struct fq_tin *tin = &txqi->tin;
1390
1391         ieee80211_set_skb_enqueue_time(skb);
1392         fq_tin_enqueue(fq, tin, skb,
1393                        fq_skb_free_func,
1394                        fq_flow_get_default_func);
1395 }
1396
1397 static bool fq_vlan_filter_func(struct fq *fq, struct fq_tin *tin,
1398                                 struct fq_flow *flow, struct sk_buff *skb,
1399                                 void *data)
1400 {
1401         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1402
1403         return info->control.vif == data;
1404 }
1405
1406 void ieee80211_txq_remove_vlan(struct ieee80211_local *local,
1407                                struct ieee80211_sub_if_data *sdata)
1408 {
1409         struct fq *fq = &local->fq;
1410         struct txq_info *txqi;
1411         struct fq_tin *tin;
1412         struct ieee80211_sub_if_data *ap;
1413
1414         if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_AP_VLAN))
1415                 return;
1416
1417         ap = container_of(sdata->bss, struct ieee80211_sub_if_data, u.ap);
1418
1419         if (!ap->vif.txq)
1420                 return;
1421
1422         txqi = to_txq_info(ap->vif.txq);
1423         tin = &txqi->tin;
1424
1425         spin_lock_bh(&fq->lock);
1426         fq_tin_filter(fq, tin, fq_vlan_filter_func, &sdata->vif,
1427                       fq_skb_free_func);
1428         spin_unlock_bh(&fq->lock);
1429 }
1430
1431 void ieee80211_txq_init(struct ieee80211_sub_if_data *sdata,
1432                         struct sta_info *sta,
1433                         struct txq_info *txqi, int tid)
1434 {
1435         fq_tin_init(&txqi->tin);
1436         fq_flow_init(&txqi->def_flow);
1437         codel_vars_init(&txqi->def_cvars);
1438         codel_stats_init(&txqi->cstats);
1439         __skb_queue_head_init(&txqi->frags);
1440
1441         txqi->txq.vif = &sdata->vif;
1442
1443         if (sta) {
1444                 txqi->txq.sta = &sta->sta;
1445                 sta->sta.txq[tid] = &txqi->txq;
1446                 txqi->txq.tid = tid;
1447                 txqi->txq.ac = ieee80211_ac_from_tid(tid);
1448         } else {
1449                 sdata->vif.txq = &txqi->txq;
1450                 txqi->txq.tid = 0;
1451                 txqi->txq.ac = IEEE80211_AC_BE;
1452         }
1453 }
1454
1455 void ieee80211_txq_purge(struct ieee80211_local *local,
1456                          struct txq_info *txqi)
1457 {
1458         struct fq *fq = &local->fq;
1459         struct fq_tin *tin = &txqi->tin;
1460
1461         fq_tin_reset(fq, tin, fq_skb_free_func);
1462         ieee80211_purge_tx_queue(&local->hw, &txqi->frags);
1463 }
1464
1465 void ieee80211_txq_set_params(struct ieee80211_local *local)
1466 {
1467         if (local->hw.wiphy->txq_limit)
1468                 local->fq.limit = local->hw.wiphy->txq_limit;
1469         else
1470                 local->hw.wiphy->txq_limit = local->fq.limit;
1471
1472         if (local->hw.wiphy->txq_memory_limit)
1473                 local->fq.memory_limit = local->hw.wiphy->txq_memory_limit;
1474         else
1475                 local->hw.wiphy->txq_memory_limit = local->fq.memory_limit;
1476
1477         if (local->hw.wiphy->txq_quantum)
1478                 local->fq.quantum = local->hw.wiphy->txq_quantum;
1479         else
1480                 local->hw.wiphy->txq_quantum = local->fq.quantum;
1481 }
1482
1483 int ieee80211_txq_setup_flows(struct ieee80211_local *local)
1484 {
1485         struct fq *fq = &local->fq;
1486         int ret;
1487         int i;
1488         bool supp_vht = false;
1489         enum nl80211_band band;
1490
1491         if (!local->ops->wake_tx_queue)
1492                 return 0;
1493
1494         ret = fq_init(fq, 4096);
1495         if (ret)
1496                 return ret;
1497
1498         /*
1499          * If the hardware doesn't support VHT, it is safe to limit the maximum
1500          * queue size. 4 Mbytes is 64 max-size aggregates in 802.11n.
1501          */
1502         for (band = 0; band < NUM_NL80211_BANDS; band++) {
1503                 struct ieee80211_supported_band *sband;
1504
1505                 sband = local->hw.wiphy->bands[band];
1506                 if (!sband)
1507                         continue;
1508
1509                 supp_vht = supp_vht || sband->vht_cap.vht_supported;
1510         }
1511
1512         if (!supp_vht)
1513                 fq->memory_limit = 4 << 20; /* 4 Mbytes */
1514
1515         codel_params_init(&local->cparams);
1516         local->cparams.interval = MS2TIME(100);
1517         local->cparams.target = MS2TIME(20);
1518         local->cparams.ecn = true;
1519
1520         local->cvars = kcalloc(fq->flows_cnt, sizeof(local->cvars[0]),
1521                                GFP_KERNEL);
1522         if (!local->cvars) {
1523                 spin_lock_bh(&fq->lock);
1524                 fq_reset(fq, fq_skb_free_func);
1525                 spin_unlock_bh(&fq->lock);
1526                 return -ENOMEM;
1527         }
1528
1529         for (i = 0; i < fq->flows_cnt; i++)
1530                 codel_vars_init(&local->cvars[i]);
1531
1532         ieee80211_txq_set_params(local);
1533
1534         return 0;
1535 }
1536
1537 void ieee80211_txq_teardown_flows(struct ieee80211_local *local)
1538 {
1539         struct fq *fq = &local->fq;
1540
1541         if (!local->ops->wake_tx_queue)
1542                 return;
1543
1544         kfree(local->cvars);
1545         local->cvars = NULL;
1546
1547         spin_lock_bh(&fq->lock);
1548         fq_reset(fq, fq_skb_free_func);
1549         spin_unlock_bh(&fq->lock);
1550 }
1551
1552 static bool ieee80211_queue_skb(struct ieee80211_local *local,
1553                                 struct ieee80211_sub_if_data *sdata,
1554                                 struct sta_info *sta,
1555                                 struct sk_buff *skb)
1556 {
1557         struct fq *fq = &local->fq;
1558         struct ieee80211_vif *vif;
1559         struct txq_info *txqi;
1560
1561         if (!local->ops->wake_tx_queue ||
1562             sdata->vif.type == NL80211_IFTYPE_MONITOR)
1563                 return false;
1564
1565         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
1566                 sdata = container_of(sdata->bss,
1567                                      struct ieee80211_sub_if_data, u.ap);
1568
1569         vif = &sdata->vif;
1570         txqi = ieee80211_get_txq(local, vif, sta, skb);
1571
1572         if (!txqi)
1573                 return false;
1574
1575         spin_lock_bh(&fq->lock);
1576         ieee80211_txq_enqueue(local, txqi, skb);
1577         spin_unlock_bh(&fq->lock);
1578
1579         drv_wake_tx_queue(local, txqi);
1580
1581         return true;
1582 }
1583
1584 static bool ieee80211_tx_frags(struct ieee80211_local *local,
1585                                struct ieee80211_vif *vif,
1586                                struct ieee80211_sta *sta,
1587                                struct sk_buff_head *skbs,
1588                                bool txpending)
1589 {
1590         struct ieee80211_tx_control control = {};
1591         struct sk_buff *skb, *tmp;
1592         unsigned long flags;
1593
1594         skb_queue_walk_safe(skbs, skb, tmp) {
1595                 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1596                 int q = info->hw_queue;
1597
1598 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1599                 if (WARN_ON_ONCE(q >= local->hw.queues)) {
1600                         __skb_unlink(skb, skbs);
1601                         ieee80211_free_txskb(&local->hw, skb);
1602                         continue;
1603                 }
1604 #endif
1605
1606                 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
1607                 if (local->queue_stop_reasons[q] ||
1608                     (!txpending && !skb_queue_empty(&local->pending[q]))) {
1609                         if (unlikely(info->flags &
1610                                      IEEE80211_TX_INTFL_OFFCHAN_TX_OK)) {
1611                                 if (local->queue_stop_reasons[q] &
1612                                     ~BIT(IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL)) {
1613                                         /*
1614                                          * Drop off-channel frames if queues
1615                                          * are stopped for any reason other
1616                                          * than off-channel operation. Never
1617                                          * queue them.
1618                                          */
1619                                         spin_unlock_irqrestore(
1620                                                 &local->queue_stop_reason_lock,
1621                                                 flags);
1622                                         ieee80211_purge_tx_queue(&local->hw,
1623                                                                  skbs);
1624                                         return true;
1625                                 }
1626                         } else {
1627
1628                                 /*
1629                                  * Since queue is stopped, queue up frames for
1630                                  * later transmission from the tx-pending
1631                                  * tasklet when the queue is woken again.
1632                                  */
1633                                 if (txpending)
1634                                         skb_queue_splice_init(skbs,
1635                                                               &local->pending[q]);
1636                                 else
1637                                         skb_queue_splice_tail_init(skbs,
1638                                                                    &local->pending[q]);
1639
1640                                 spin_unlock_irqrestore(&local->queue_stop_reason_lock,
1641                                                        flags);
1642                                 return false;
1643                         }
1644                 }
1645                 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
1646
1647                 info->control.vif = vif;
1648                 control.sta = sta;
1649
1650                 __skb_unlink(skb, skbs);
1651                 drv_tx(local, &control, skb);
1652         }
1653
1654         return true;
1655 }
1656
1657 /*
1658  * Returns false if the frame couldn't be transmitted but was queued instead.
1659  */
1660 static bool __ieee80211_tx(struct ieee80211_local *local,
1661                            struct sk_buff_head *skbs, int led_len,
1662                            struct sta_info *sta, bool txpending)
1663 {
1664         struct ieee80211_tx_info *info;
1665         struct ieee80211_sub_if_data *sdata;
1666         struct ieee80211_vif *vif;
1667         struct ieee80211_sta *pubsta;
1668         struct sk_buff *skb;
1669         bool result = true;
1670         __le16 fc;
1671
1672         if (WARN_ON(skb_queue_empty(skbs)))
1673                 return true;
1674
1675         skb = skb_peek(skbs);
1676         fc = ((struct ieee80211_hdr *)skb->data)->frame_control;
1677         info = IEEE80211_SKB_CB(skb);
1678         sdata = vif_to_sdata(info->control.vif);
1679         if (sta && !sta->uploaded)
1680                 sta = NULL;
1681
1682         if (sta)
1683                 pubsta = &sta->sta;
1684         else
1685                 pubsta = NULL;
1686
1687         switch (sdata->vif.type) {
1688         case NL80211_IFTYPE_MONITOR:
1689                 if (sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE) {
1690                         vif = &sdata->vif;
1691                         break;
1692                 }
1693                 sdata = rcu_dereference(local->monitor_sdata);
1694                 if (sdata) {
1695                         vif = &sdata->vif;
1696                         info->hw_queue =
1697                                 vif->hw_queue[skb_get_queue_mapping(skb)];
1698                 } else if (ieee80211_hw_check(&local->hw, QUEUE_CONTROL)) {
1699                         ieee80211_purge_tx_queue(&local->hw, skbs);
1700                         return true;
1701                 } else
1702                         vif = NULL;
1703                 break;
1704         case NL80211_IFTYPE_AP_VLAN:
1705                 sdata = container_of(sdata->bss,
1706                                      struct ieee80211_sub_if_data, u.ap);
1707                 /* fall through */
1708         default:
1709                 vif = &sdata->vif;
1710                 break;
1711         }
1712
1713         result = ieee80211_tx_frags(local, vif, pubsta, skbs,
1714                                     txpending);
1715
1716         ieee80211_tpt_led_trig_tx(local, fc, led_len);
1717
1718         WARN_ON_ONCE(!skb_queue_empty(skbs));
1719
1720         return result;
1721 }
1722
1723 /*
1724  * Invoke TX handlers, return 0 on success and non-zero if the
1725  * frame was dropped or queued.
1726  *
1727  * The handlers are split into an early and late part. The latter is everything
1728  * that can be sensitive to reordering, and will be deferred to after packets
1729  * are dequeued from the intermediate queues (when they are enabled).
1730  */
1731 static int invoke_tx_handlers_early(struct ieee80211_tx_data *tx)
1732 {
1733         ieee80211_tx_result res = TX_DROP;
1734
1735 #define CALL_TXH(txh) \
1736         do {                            \
1737                 res = txh(tx);          \
1738                 if (res != TX_CONTINUE) \
1739                         goto txh_done;  \
1740         } while (0)
1741
1742         CALL_TXH(ieee80211_tx_h_dynamic_ps);
1743         CALL_TXH(ieee80211_tx_h_check_assoc);
1744         CALL_TXH(ieee80211_tx_h_ps_buf);
1745         CALL_TXH(ieee80211_tx_h_check_control_port_protocol);
1746         CALL_TXH(ieee80211_tx_h_select_key);
1747         if (!ieee80211_hw_check(&tx->local->hw, HAS_RATE_CONTROL))
1748                 CALL_TXH(ieee80211_tx_h_rate_ctrl);
1749
1750  txh_done:
1751         if (unlikely(res == TX_DROP)) {
1752                 I802_DEBUG_INC(tx->local->tx_handlers_drop);
1753                 if (tx->skb)
1754                         ieee80211_free_txskb(&tx->local->hw, tx->skb);
1755                 else
1756                         ieee80211_purge_tx_queue(&tx->local->hw, &tx->skbs);
1757                 return -1;
1758         } else if (unlikely(res == TX_QUEUED)) {
1759                 I802_DEBUG_INC(tx->local->tx_handlers_queued);
1760                 return -1;
1761         }
1762
1763         return 0;
1764 }
1765
1766 /*
1767  * Late handlers can be called while the sta lock is held. Handlers that can
1768  * cause packets to be generated will cause deadlock!
1769  */
1770 static int invoke_tx_handlers_late(struct ieee80211_tx_data *tx)
1771 {
1772         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
1773         ieee80211_tx_result res = TX_CONTINUE;
1774
1775         if (unlikely(info->flags & IEEE80211_TX_INTFL_RETRANSMISSION)) {
1776                 __skb_queue_tail(&tx->skbs, tx->skb);
1777                 tx->skb = NULL;
1778                 goto txh_done;
1779         }
1780
1781         CALL_TXH(ieee80211_tx_h_michael_mic_add);
1782         CALL_TXH(ieee80211_tx_h_sequence);
1783         CALL_TXH(ieee80211_tx_h_fragment);
1784         /* handlers after fragment must be aware of tx info fragmentation! */
1785         CALL_TXH(ieee80211_tx_h_stats);
1786         CALL_TXH(ieee80211_tx_h_encrypt);
1787         if (!ieee80211_hw_check(&tx->local->hw, HAS_RATE_CONTROL))
1788                 CALL_TXH(ieee80211_tx_h_calculate_duration);
1789 #undef CALL_TXH
1790
1791  txh_done:
1792         if (unlikely(res == TX_DROP)) {
1793                 I802_DEBUG_INC(tx->local->tx_handlers_drop);
1794                 if (tx->skb)
1795                         ieee80211_free_txskb(&tx->local->hw, tx->skb);
1796                 else
1797                         ieee80211_purge_tx_queue(&tx->local->hw, &tx->skbs);
1798                 return -1;
1799         } else if (unlikely(res == TX_QUEUED)) {
1800                 I802_DEBUG_INC(tx->local->tx_handlers_queued);
1801                 return -1;
1802         }
1803
1804         return 0;
1805 }
1806
1807 static int invoke_tx_handlers(struct ieee80211_tx_data *tx)
1808 {
1809         int r = invoke_tx_handlers_early(tx);
1810
1811         if (r)
1812                 return r;
1813         return invoke_tx_handlers_late(tx);
1814 }
1815
1816 bool ieee80211_tx_prepare_skb(struct ieee80211_hw *hw,
1817                               struct ieee80211_vif *vif, struct sk_buff *skb,
1818                               int band, struct ieee80211_sta **sta)
1819 {
1820         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1821         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1822         struct ieee80211_tx_data tx;
1823         struct sk_buff *skb2;
1824
1825         if (ieee80211_tx_prepare(sdata, &tx, NULL, skb) == TX_DROP)
1826                 return false;
1827
1828         info->band = band;
1829         info->control.vif = vif;
1830         info->hw_queue = vif->hw_queue[skb_get_queue_mapping(skb)];
1831
1832         if (invoke_tx_handlers(&tx))
1833                 return false;
1834
1835         if (sta) {
1836                 if (tx.sta)
1837                         *sta = &tx.sta->sta;
1838                 else
1839                         *sta = NULL;
1840         }
1841
1842         /* this function isn't suitable for fragmented data frames */
1843         skb2 = __skb_dequeue(&tx.skbs);
1844         if (WARN_ON(skb2 != skb || !skb_queue_empty(&tx.skbs))) {
1845                 ieee80211_free_txskb(hw, skb2);
1846                 ieee80211_purge_tx_queue(hw, &tx.skbs);
1847                 return false;
1848         }
1849
1850         return true;
1851 }
1852 EXPORT_SYMBOL(ieee80211_tx_prepare_skb);
1853
1854 /*
1855  * Returns false if the frame couldn't be transmitted but was queued instead.
1856  */
1857 static bool ieee80211_tx(struct ieee80211_sub_if_data *sdata,
1858                          struct sta_info *sta, struct sk_buff *skb,
1859                          bool txpending, u32 txdata_flags)
1860 {
1861         struct ieee80211_local *local = sdata->local;
1862         struct ieee80211_tx_data tx;
1863         ieee80211_tx_result res_prepare;
1864         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1865         bool result = true;
1866         int led_len;
1867
1868         if (unlikely(skb->len < 10)) {
1869                 dev_kfree_skb(skb);
1870                 return true;
1871         }
1872
1873         /* initialises tx */
1874         led_len = skb->len;
1875         res_prepare = ieee80211_tx_prepare(sdata, &tx, sta, skb);
1876
1877         tx.flags |= txdata_flags;
1878
1879         if (unlikely(res_prepare == TX_DROP)) {
1880                 ieee80211_free_txskb(&local->hw, skb);
1881                 return true;
1882         } else if (unlikely(res_prepare == TX_QUEUED)) {
1883                 return true;
1884         }
1885
1886         /* set up hw_queue value early */
1887         if (!(info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) ||
1888             !ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
1889                 info->hw_queue =
1890                         sdata->vif.hw_queue[skb_get_queue_mapping(skb)];
1891
1892         if (invoke_tx_handlers_early(&tx))
1893                 return false;
1894
1895         if (ieee80211_queue_skb(local, sdata, tx.sta, tx.skb))
1896                 return true;
1897
1898         if (!invoke_tx_handlers_late(&tx))
1899                 result = __ieee80211_tx(local, &tx.skbs, led_len,
1900                                         tx.sta, txpending);
1901
1902         return result;
1903 }
1904
1905 /* device xmit handlers */
1906
1907 static int ieee80211_skb_resize(struct ieee80211_sub_if_data *sdata,
1908                                 struct sk_buff *skb,
1909                                 int head_need, bool may_encrypt)
1910 {
1911         struct ieee80211_local *local = sdata->local;
1912         int tail_need = 0;
1913
1914         if (may_encrypt && sdata->crypto_tx_tailroom_needed_cnt) {
1915                 tail_need = IEEE80211_ENCRYPT_TAILROOM;
1916                 tail_need -= skb_tailroom(skb);
1917                 tail_need = max_t(int, tail_need, 0);
1918         }
1919
1920         if (skb_cloned(skb) &&
1921             (!ieee80211_hw_check(&local->hw, SUPPORTS_CLONED_SKBS) ||
1922              !skb_clone_writable(skb, ETH_HLEN) ||
1923              (may_encrypt && sdata->crypto_tx_tailroom_needed_cnt)))
1924                 I802_DEBUG_INC(local->tx_expand_skb_head_cloned);
1925         else if (head_need || tail_need)
1926                 I802_DEBUG_INC(local->tx_expand_skb_head);
1927         else
1928                 return 0;
1929
1930         if (pskb_expand_head(skb, head_need, tail_need, GFP_ATOMIC)) {
1931                 wiphy_debug(local->hw.wiphy,
1932                             "failed to reallocate TX buffer\n");
1933                 return -ENOMEM;
1934         }
1935
1936         return 0;
1937 }
1938
1939 void ieee80211_xmit(struct ieee80211_sub_if_data *sdata,
1940                     struct sta_info *sta, struct sk_buff *skb,
1941                     u32 txdata_flags)
1942 {
1943         struct ieee80211_local *local = sdata->local;
1944         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1945         struct ieee80211_hdr *hdr;
1946         int headroom;
1947         bool may_encrypt;
1948
1949         may_encrypt = !(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT);
1950
1951         headroom = local->tx_headroom;
1952         if (may_encrypt)
1953                 headroom += sdata->encrypt_headroom;
1954         headroom -= skb_headroom(skb);
1955         headroom = max_t(int, 0, headroom);
1956
1957         if (ieee80211_skb_resize(sdata, skb, headroom, may_encrypt)) {
1958                 ieee80211_free_txskb(&local->hw, skb);
1959                 return;
1960         }
1961
1962         hdr = (struct ieee80211_hdr *) skb->data;
1963         info->control.vif = &sdata->vif;
1964
1965         if (ieee80211_vif_is_mesh(&sdata->vif)) {
1966                 if (ieee80211_is_data(hdr->frame_control) &&
1967                     is_unicast_ether_addr(hdr->addr1)) {
1968                         if (mesh_nexthop_resolve(sdata, skb))
1969                                 return; /* skb queued: don't free */
1970                 } else {
1971                         ieee80211_mps_set_frame_flags(sdata, NULL, hdr);
1972                 }
1973         }
1974
1975         ieee80211_set_qos_hdr(sdata, skb);
1976         ieee80211_tx(sdata, sta, skb, false, txdata_flags);
1977 }
1978
1979 static bool ieee80211_parse_tx_radiotap(struct ieee80211_local *local,
1980                                         struct sk_buff *skb)
1981 {
1982         struct ieee80211_radiotap_iterator iterator;
1983         struct ieee80211_radiotap_header *rthdr =
1984                 (struct ieee80211_radiotap_header *) skb->data;
1985         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1986         struct ieee80211_supported_band *sband =
1987                 local->hw.wiphy->bands[info->band];
1988         int ret = ieee80211_radiotap_iterator_init(&iterator, rthdr, skb->len,
1989                                                    NULL);
1990         u16 txflags;
1991         u16 rate = 0;
1992         bool rate_found = false;
1993         u8 rate_retries = 0;
1994         u16 rate_flags = 0;
1995         u8 mcs_known, mcs_flags, mcs_bw;
1996         u16 vht_known;
1997         u8 vht_mcs = 0, vht_nss = 0;
1998         int i;
1999
2000         info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
2001                        IEEE80211_TX_CTL_DONTFRAG;
2002
2003         /*
2004          * for every radiotap entry that is present
2005          * (ieee80211_radiotap_iterator_next returns -ENOENT when no more
2006          * entries present, or -EINVAL on error)
2007          */
2008
2009         while (!ret) {
2010                 ret = ieee80211_radiotap_iterator_next(&iterator);
2011
2012                 if (ret)
2013                         continue;
2014
2015                 /* see if this argument is something we can use */
2016                 switch (iterator.this_arg_index) {
2017                 /*
2018                  * You must take care when dereferencing iterator.this_arg
2019                  * for multibyte types... the pointer is not aligned.  Use
2020                  * get_unaligned((type *)iterator.this_arg) to dereference
2021                  * iterator.this_arg for type "type" safely on all arches.
2022                 */
2023                 case IEEE80211_RADIOTAP_FLAGS:
2024                         if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) {
2025                                 /*
2026                                  * this indicates that the skb we have been
2027                                  * handed has the 32-bit FCS CRC at the end...
2028                                  * we should react to that by snipping it off
2029                                  * because it will be recomputed and added
2030                                  * on transmission
2031                                  */
2032                                 if (skb->len < (iterator._max_length + FCS_LEN))
2033                                         return false;
2034
2035                                 skb_trim(skb, skb->len - FCS_LEN);
2036                         }
2037                         if (*iterator.this_arg & IEEE80211_RADIOTAP_F_WEP)
2038                                 info->flags &= ~IEEE80211_TX_INTFL_DONT_ENCRYPT;
2039                         if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FRAG)
2040                                 info->flags &= ~IEEE80211_TX_CTL_DONTFRAG;
2041                         break;
2042
2043                 case IEEE80211_RADIOTAP_TX_FLAGS:
2044                         txflags = get_unaligned_le16(iterator.this_arg);
2045                         if (txflags & IEEE80211_RADIOTAP_F_TX_NOACK)
2046                                 info->flags |= IEEE80211_TX_CTL_NO_ACK;
2047                         break;
2048
2049                 case IEEE80211_RADIOTAP_RATE:
2050                         rate = *iterator.this_arg;
2051                         rate_flags = 0;
2052                         rate_found = true;
2053                         break;
2054
2055                 case IEEE80211_RADIOTAP_DATA_RETRIES:
2056                         rate_retries = *iterator.this_arg;
2057                         break;
2058
2059                 case IEEE80211_RADIOTAP_MCS:
2060                         mcs_known = iterator.this_arg[0];
2061                         mcs_flags = iterator.this_arg[1];
2062                         if (!(mcs_known & IEEE80211_RADIOTAP_MCS_HAVE_MCS))
2063                                 break;
2064
2065                         rate_found = true;
2066                         rate = iterator.this_arg[2];
2067                         rate_flags = IEEE80211_TX_RC_MCS;
2068
2069                         if (mcs_known & IEEE80211_RADIOTAP_MCS_HAVE_GI &&
2070                             mcs_flags & IEEE80211_RADIOTAP_MCS_SGI)
2071                                 rate_flags |= IEEE80211_TX_RC_SHORT_GI;
2072
2073                         mcs_bw = mcs_flags & IEEE80211_RADIOTAP_MCS_BW_MASK;
2074                         if (mcs_known & IEEE80211_RADIOTAP_MCS_HAVE_BW &&
2075                             mcs_bw == IEEE80211_RADIOTAP_MCS_BW_40)
2076                                 rate_flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
2077                         break;
2078
2079                 case IEEE80211_RADIOTAP_VHT:
2080                         vht_known = get_unaligned_le16(iterator.this_arg);
2081                         rate_found = true;
2082
2083                         rate_flags = IEEE80211_TX_RC_VHT_MCS;
2084                         if ((vht_known & IEEE80211_RADIOTAP_VHT_KNOWN_GI) &&
2085                             (iterator.this_arg[2] &
2086                              IEEE80211_RADIOTAP_VHT_FLAG_SGI))
2087                                 rate_flags |= IEEE80211_TX_RC_SHORT_GI;
2088                         if (vht_known &
2089                             IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH) {
2090                                 if (iterator.this_arg[3] == 1)
2091                                         rate_flags |=
2092                                                 IEEE80211_TX_RC_40_MHZ_WIDTH;
2093                                 else if (iterator.this_arg[3] == 4)
2094                                         rate_flags |=
2095                                                 IEEE80211_TX_RC_80_MHZ_WIDTH;
2096                                 else if (iterator.this_arg[3] == 11)
2097                                         rate_flags |=
2098                                                 IEEE80211_TX_RC_160_MHZ_WIDTH;
2099                         }
2100
2101                         vht_mcs = iterator.this_arg[4] >> 4;
2102                         vht_nss = iterator.this_arg[4] & 0xF;
2103                         break;
2104
2105                 /*
2106                  * Please update the file
2107                  * Documentation/networking/mac80211-injection.txt
2108                  * when parsing new fields here.
2109                  */
2110
2111                 default:
2112                         break;
2113                 }
2114         }
2115
2116         if (ret != -ENOENT) /* ie, if we didn't simply run out of fields */
2117                 return false;
2118
2119         if (rate_found) {
2120                 info->control.flags |= IEEE80211_TX_CTRL_RATE_INJECT;
2121
2122                 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
2123                         info->control.rates[i].idx = -1;
2124                         info->control.rates[i].flags = 0;
2125                         info->control.rates[i].count = 0;
2126                 }
2127
2128                 if (rate_flags & IEEE80211_TX_RC_MCS) {
2129                         info->control.rates[0].idx = rate;
2130                 } else if (rate_flags & IEEE80211_TX_RC_VHT_MCS) {
2131                         ieee80211_rate_set_vht(info->control.rates, vht_mcs,
2132                                                vht_nss);
2133                 } else {
2134                         for (i = 0; i < sband->n_bitrates; i++) {
2135                                 if (rate * 5 != sband->bitrates[i].bitrate)
2136                                         continue;
2137
2138                                 info->control.rates[0].idx = i;
2139                                 break;
2140                         }
2141                 }
2142
2143                 if (info->control.rates[0].idx < 0)
2144                         info->control.flags &= ~IEEE80211_TX_CTRL_RATE_INJECT;
2145
2146                 info->control.rates[0].flags = rate_flags;
2147                 info->control.rates[0].count = min_t(u8, rate_retries + 1,
2148                                                      local->hw.max_rate_tries);
2149         }
2150
2151         /*
2152          * remove the radiotap header
2153          * iterator->_max_length was sanity-checked against
2154          * skb->len by iterator init
2155          */
2156         skb_pull(skb, iterator._max_length);
2157
2158         return true;
2159 }
2160
2161 netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb,
2162                                          struct net_device *dev)
2163 {
2164         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2165         struct ieee80211_chanctx_conf *chanctx_conf;
2166         struct ieee80211_radiotap_header *prthdr =
2167                 (struct ieee80211_radiotap_header *)skb->data;
2168         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2169         struct ieee80211_hdr *hdr;
2170         struct ieee80211_sub_if_data *tmp_sdata, *sdata;
2171         struct cfg80211_chan_def *chandef;
2172         u16 len_rthdr;
2173         int hdrlen;
2174
2175         /* check for not even having the fixed radiotap header part */
2176         if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
2177                 goto fail; /* too short to be possibly valid */
2178
2179         /* is it a header version we can trust to find length from? */
2180         if (unlikely(prthdr->it_version))
2181                 goto fail; /* only version 0 is supported */
2182
2183         /* then there must be a radiotap header with a length we can use */
2184         len_rthdr = ieee80211_get_radiotap_len(skb->data);
2185
2186         /* does the skb contain enough to deliver on the alleged length? */
2187         if (unlikely(skb->len < len_rthdr))
2188                 goto fail; /* skb too short for claimed rt header extent */
2189
2190         /*
2191          * fix up the pointers accounting for the radiotap
2192          * header still being in there.  We are being given
2193          * a precooked IEEE80211 header so no need for
2194          * normal processing
2195          */
2196         skb_set_mac_header(skb, len_rthdr);
2197         /*
2198          * these are just fixed to the end of the rt area since we
2199          * don't have any better information and at this point, nobody cares
2200          */
2201         skb_set_network_header(skb, len_rthdr);
2202         skb_set_transport_header(skb, len_rthdr);
2203
2204         if (skb->len < len_rthdr + 2)
2205                 goto fail;
2206
2207         hdr = (struct ieee80211_hdr *)(skb->data + len_rthdr);
2208         hdrlen = ieee80211_hdrlen(hdr->frame_control);
2209
2210         if (skb->len < len_rthdr + hdrlen)
2211                 goto fail;
2212
2213         /*
2214          * Initialize skb->protocol if the injected frame is a data frame
2215          * carrying a rfc1042 header
2216          */
2217         if (ieee80211_is_data(hdr->frame_control) &&
2218             skb->len >= len_rthdr + hdrlen + sizeof(rfc1042_header) + 2) {
2219                 u8 *payload = (u8 *)hdr + hdrlen;
2220
2221                 if (ether_addr_equal(payload, rfc1042_header))
2222                         skb->protocol = cpu_to_be16((payload[6] << 8) |
2223                                                     payload[7]);
2224         }
2225
2226         memset(info, 0, sizeof(*info));
2227
2228         info->flags = IEEE80211_TX_CTL_REQ_TX_STATUS |
2229                       IEEE80211_TX_CTL_INJECTED;
2230
2231         rcu_read_lock();
2232
2233         /*
2234          * We process outgoing injected frames that have a local address
2235          * we handle as though they are non-injected frames.
2236          * This code here isn't entirely correct, the local MAC address
2237          * isn't always enough to find the interface to use; for proper
2238          * VLAN/WDS support we will need a different mechanism (which
2239          * likely isn't going to be monitor interfaces).
2240          */
2241         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2242
2243         list_for_each_entry_rcu(tmp_sdata, &local->interfaces, list) {
2244                 if (!ieee80211_sdata_running(tmp_sdata))
2245                         continue;
2246                 if (tmp_sdata->vif.type == NL80211_IFTYPE_MONITOR ||
2247                     tmp_sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
2248                     tmp_sdata->vif.type == NL80211_IFTYPE_WDS)
2249                         continue;
2250                 if (ether_addr_equal(tmp_sdata->vif.addr, hdr->addr2)) {
2251                         sdata = tmp_sdata;
2252                         break;
2253                 }
2254         }
2255
2256         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2257         if (!chanctx_conf) {
2258                 tmp_sdata = rcu_dereference(local->monitor_sdata);
2259                 if (tmp_sdata)
2260                         chanctx_conf =
2261                                 rcu_dereference(tmp_sdata->vif.chanctx_conf);
2262         }
2263
2264         if (chanctx_conf)
2265                 chandef = &chanctx_conf->def;
2266         else if (!local->use_chanctx)
2267                 chandef = &local->_oper_chandef;
2268         else
2269                 goto fail_rcu;
2270
2271         /*
2272          * Frame injection is not allowed if beaconing is not allowed
2273          * or if we need radar detection. Beaconing is usually not allowed when
2274          * the mode or operation (Adhoc, AP, Mesh) does not support DFS.
2275          * Passive scan is also used in world regulatory domains where
2276          * your country is not known and as such it should be treated as
2277          * NO TX unless the channel is explicitly allowed in which case
2278          * your current regulatory domain would not have the passive scan
2279          * flag.
2280          *
2281          * Since AP mode uses monitor interfaces to inject/TX management
2282          * frames we can make AP mode the exception to this rule once it
2283          * supports radar detection as its implementation can deal with
2284          * radar detection by itself. We can do that later by adding a
2285          * monitor flag interfaces used for AP support.
2286          */
2287         if (!cfg80211_reg_can_beacon(local->hw.wiphy, chandef,
2288                                      sdata->vif.type))
2289                 goto fail_rcu;
2290
2291         info->band = chandef->chan->band;
2292
2293         /* process and remove the injection radiotap header */
2294         if (!ieee80211_parse_tx_radiotap(local, skb))
2295                 goto fail_rcu;
2296
2297         ieee80211_xmit(sdata, NULL, skb, 0);
2298         rcu_read_unlock();
2299
2300         return NETDEV_TX_OK;
2301
2302 fail_rcu:
2303         rcu_read_unlock();
2304 fail:
2305         dev_kfree_skb(skb);
2306         return NETDEV_TX_OK; /* meaning, we dealt with the skb */
2307 }
2308
2309 static inline bool ieee80211_is_tdls_setup(struct sk_buff *skb)
2310 {
2311         u16 ethertype = (skb->data[12] << 8) | skb->data[13];
2312
2313         return ethertype == ETH_P_TDLS &&
2314                skb->len > 14 &&
2315                skb->data[14] == WLAN_TDLS_SNAP_RFTYPE;
2316 }
2317
2318 static int ieee80211_lookup_ra_sta(struct ieee80211_sub_if_data *sdata,
2319                                    struct sk_buff *skb,
2320                                    struct sta_info **sta_out)
2321 {
2322         struct sta_info *sta;
2323
2324         switch (sdata->vif.type) {
2325         case NL80211_IFTYPE_AP_VLAN:
2326                 sta = rcu_dereference(sdata->u.vlan.sta);
2327                 if (sta) {
2328                         *sta_out = sta;
2329                         return 0;
2330                 } else if (sdata->wdev.use_4addr) {
2331                         return -ENOLINK;
2332                 }
2333                 /* fall through */
2334         case NL80211_IFTYPE_AP:
2335         case NL80211_IFTYPE_OCB:
2336         case NL80211_IFTYPE_ADHOC:
2337                 if (is_multicast_ether_addr(skb->data)) {
2338                         *sta_out = ERR_PTR(-ENOENT);
2339                         return 0;
2340                 }
2341                 sta = sta_info_get_bss(sdata, skb->data);
2342                 break;
2343         case NL80211_IFTYPE_WDS:
2344                 sta = sta_info_get(sdata, sdata->u.wds.remote_addr);
2345                 break;
2346 #ifdef CONFIG_MAC80211_MESH
2347         case NL80211_IFTYPE_MESH_POINT:
2348                 /* determined much later */
2349                 *sta_out = NULL;
2350                 return 0;
2351 #endif
2352         case NL80211_IFTYPE_STATION:
2353                 if (sdata->wdev.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) {
2354                         sta = sta_info_get(sdata, skb->data);
2355                         if (sta && test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
2356                                 if (test_sta_flag(sta,
2357                                                   WLAN_STA_TDLS_PEER_AUTH)) {
2358                                         *sta_out = sta;
2359                                         return 0;
2360                                 }
2361
2362                                 /*
2363                                  * TDLS link during setup - throw out frames to
2364                                  * peer. Allow TDLS-setup frames to unauthorized
2365                                  * peers for the special case of a link teardown
2366                                  * after a TDLS sta is removed due to being
2367                                  * unreachable.
2368                                  */
2369                                 if (!ieee80211_is_tdls_setup(skb))
2370                                         return -EINVAL;
2371                         }
2372
2373                 }
2374
2375                 sta = sta_info_get(sdata, sdata->u.mgd.bssid);
2376                 if (!sta)
2377                         return -ENOLINK;
2378                 break;
2379         default:
2380                 return -EINVAL;
2381         }
2382
2383         *sta_out = sta ?: ERR_PTR(-ENOENT);
2384         return 0;
2385 }
2386
2387 /**
2388  * ieee80211_build_hdr - build 802.11 header in the given frame
2389  * @sdata: virtual interface to build the header for
2390  * @skb: the skb to build the header in
2391  * @info_flags: skb flags to set
2392  *
2393  * This function takes the skb with 802.3 header and reformats the header to
2394  * the appropriate IEEE 802.11 header based on which interface the packet is
2395  * being transmitted on.
2396  *
2397  * Note that this function also takes care of the TX status request and
2398  * potential unsharing of the SKB - this needs to be interleaved with the
2399  * header building.
2400  *
2401  * The function requires the read-side RCU lock held
2402  *
2403  * Returns: the (possibly reallocated) skb or an ERR_PTR() code
2404  */
2405 static struct sk_buff *ieee80211_build_hdr(struct ieee80211_sub_if_data *sdata,
2406                                            struct sk_buff *skb, u32 info_flags,
2407                                            struct sta_info *sta)
2408 {
2409         struct ieee80211_local *local = sdata->local;
2410         struct ieee80211_tx_info *info;
2411         int head_need;
2412         u16 ethertype, hdrlen,  meshhdrlen = 0;
2413         __le16 fc;
2414         struct ieee80211_hdr hdr;
2415         struct ieee80211s_hdr mesh_hdr __maybe_unused;
2416         struct mesh_path __maybe_unused *mppath = NULL, *mpath = NULL;
2417         const u8 *encaps_data;
2418         int encaps_len, skip_header_bytes;
2419         bool wme_sta = false, authorized = false;
2420         bool tdls_peer;
2421         bool multicast;
2422         u16 info_id = 0;
2423         struct ieee80211_chanctx_conf *chanctx_conf;
2424         struct ieee80211_sub_if_data *ap_sdata;
2425         enum nl80211_band band;
2426         int ret;
2427
2428         if (IS_ERR(sta))
2429                 sta = NULL;
2430
2431         /* convert Ethernet header to proper 802.11 header (based on
2432          * operation mode) */
2433         ethertype = (skb->data[12] << 8) | skb->data[13];
2434         fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
2435
2436         switch (sdata->vif.type) {
2437         case NL80211_IFTYPE_AP_VLAN:
2438                 if (sdata->wdev.use_4addr) {
2439                         fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
2440                         /* RA TA DA SA */
2441                         memcpy(hdr.addr1, sta->sta.addr, ETH_ALEN);
2442                         memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
2443                         memcpy(hdr.addr3, skb->data, ETH_ALEN);
2444                         memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
2445                         hdrlen = 30;
2446                         authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED);
2447                         wme_sta = sta->sta.wme;
2448                 }
2449                 ap_sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
2450                                         u.ap);
2451                 chanctx_conf = rcu_dereference(ap_sdata->vif.chanctx_conf);
2452                 if (!chanctx_conf) {
2453                         ret = -ENOTCONN;
2454                         goto free;
2455                 }
2456                 band = chanctx_conf->def.chan->band;
2457                 if (sdata->wdev.use_4addr)
2458                         break;
2459                 /* fall through */
2460         case NL80211_IFTYPE_AP:
2461                 if (sdata->vif.type == NL80211_IFTYPE_AP)
2462                         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2463                 if (!chanctx_conf) {
2464                         ret = -ENOTCONN;
2465                         goto free;
2466                 }
2467                 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
2468                 /* DA BSSID SA */
2469                 memcpy(hdr.addr1, skb->data, ETH_ALEN);
2470                 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
2471                 memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN);
2472                 hdrlen = 24;
2473                 band = chanctx_conf->def.chan->band;
2474                 break;
2475         case NL80211_IFTYPE_WDS:
2476                 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
2477                 /* RA TA DA SA */
2478                 memcpy(hdr.addr1, sdata->u.wds.remote_addr, ETH_ALEN);
2479                 memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
2480                 memcpy(hdr.addr3, skb->data, ETH_ALEN);
2481                 memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
2482                 hdrlen = 30;
2483                 /*
2484                  * This is the exception! WDS style interfaces are prohibited
2485                  * when channel contexts are in used so this must be valid
2486                  */
2487                 band = local->hw.conf.chandef.chan->band;
2488                 break;
2489 #ifdef CONFIG_MAC80211_MESH
2490         case NL80211_IFTYPE_MESH_POINT:
2491                 if (!is_multicast_ether_addr(skb->data)) {
2492                         struct sta_info *next_hop;
2493                         bool mpp_lookup = true;
2494
2495                         mpath = mesh_path_lookup(sdata, skb->data);
2496                         if (mpath) {
2497                                 mpp_lookup = false;
2498                                 next_hop = rcu_dereference(mpath->next_hop);
2499                                 if (!next_hop ||
2500                                     !(mpath->flags & (MESH_PATH_ACTIVE |
2501                                                       MESH_PATH_RESOLVING)))
2502                                         mpp_lookup = true;
2503                         }
2504
2505                         if (mpp_lookup) {
2506                                 mppath = mpp_path_lookup(sdata, skb->data);
2507                                 if (mppath)
2508                                         mppath->exp_time = jiffies;
2509                         }
2510
2511                         if (mppath && mpath)
2512                                 mesh_path_del(sdata, mpath->dst);
2513                 }
2514
2515                 /*
2516                  * Use address extension if it is a packet from
2517                  * another interface or if we know the destination
2518                  * is being proxied by a portal (i.e. portal address
2519                  * differs from proxied address)
2520                  */
2521                 if (ether_addr_equal(sdata->vif.addr, skb->data + ETH_ALEN) &&
2522                     !(mppath && !ether_addr_equal(mppath->mpp, skb->data))) {
2523                         hdrlen = ieee80211_fill_mesh_addresses(&hdr, &fc,
2524                                         skb->data, skb->data + ETH_ALEN);
2525                         meshhdrlen = ieee80211_new_mesh_header(sdata, &mesh_hdr,
2526                                                                NULL, NULL);
2527                 } else {
2528                         /* DS -> MBSS (802.11-2012 13.11.3.3).
2529                          * For unicast with unknown forwarding information,
2530                          * destination might be in the MBSS or if that fails
2531                          * forwarded to another mesh gate. In either case
2532                          * resolution will be handled in ieee80211_xmit(), so
2533                          * leave the original DA. This also works for mcast */
2534                         const u8 *mesh_da = skb->data;
2535
2536                         if (mppath)
2537                                 mesh_da = mppath->mpp;
2538                         else if (mpath)
2539                                 mesh_da = mpath->dst;
2540
2541                         hdrlen = ieee80211_fill_mesh_addresses(&hdr, &fc,
2542                                         mesh_da, sdata->vif.addr);
2543                         if (is_multicast_ether_addr(mesh_da))
2544                                 /* DA TA mSA AE:SA */
2545                                 meshhdrlen = ieee80211_new_mesh_header(
2546                                                 sdata, &mesh_hdr,
2547                                                 skb->data + ETH_ALEN, NULL);
2548                         else
2549                                 /* RA TA mDA mSA AE:DA SA */
2550                                 meshhdrlen = ieee80211_new_mesh_header(
2551                                                 sdata, &mesh_hdr, skb->data,
2552                                                 skb->data + ETH_ALEN);
2553
2554                 }
2555                 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2556                 if (!chanctx_conf) {
2557                         ret = -ENOTCONN;
2558                         goto free;
2559                 }
2560                 band = chanctx_conf->def.chan->band;
2561                 break;
2562 #endif
2563         case NL80211_IFTYPE_STATION:
2564                 /* we already did checks when looking up the RA STA */
2565                 tdls_peer = test_sta_flag(sta, WLAN_STA_TDLS_PEER);
2566
2567                 if (tdls_peer) {
2568                         /* DA SA BSSID */
2569                         memcpy(hdr.addr1, skb->data, ETH_ALEN);
2570                         memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
2571                         memcpy(hdr.addr3, sdata->u.mgd.bssid, ETH_ALEN);
2572                         hdrlen = 24;
2573                 }  else if (sdata->u.mgd.use_4addr &&
2574                             cpu_to_be16(ethertype) != sdata->control_port_protocol) {
2575                         fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS |
2576                                           IEEE80211_FCTL_TODS);
2577                         /* RA TA DA SA */
2578                         memcpy(hdr.addr1, sdata->u.mgd.bssid, ETH_ALEN);
2579                         memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
2580                         memcpy(hdr.addr3, skb->data, ETH_ALEN);
2581                         memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
2582                         hdrlen = 30;
2583                 } else {
2584                         fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
2585                         /* BSSID SA DA */
2586                         memcpy(hdr.addr1, sdata->u.mgd.bssid, ETH_ALEN);
2587                         memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
2588                         memcpy(hdr.addr3, skb->data, ETH_ALEN);
2589                         hdrlen = 24;
2590                 }
2591                 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2592                 if (!chanctx_conf) {
2593                         ret = -ENOTCONN;
2594                         goto free;
2595                 }
2596                 band = chanctx_conf->def.chan->band;
2597                 break;
2598         case NL80211_IFTYPE_OCB:
2599                 /* DA SA BSSID */
2600                 memcpy(hdr.addr1, skb->data, ETH_ALEN);
2601                 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
2602                 eth_broadcast_addr(hdr.addr3);
2603                 hdrlen = 24;
2604                 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2605                 if (!chanctx_conf) {
2606                         ret = -ENOTCONN;
2607                         goto free;
2608                 }
2609                 band = chanctx_conf->def.chan->band;
2610                 break;
2611         case NL80211_IFTYPE_ADHOC:
2612                 /* DA SA BSSID */
2613                 memcpy(hdr.addr1, skb->data, ETH_ALEN);
2614                 memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
2615                 memcpy(hdr.addr3, sdata->u.ibss.bssid, ETH_ALEN);
2616                 hdrlen = 24;
2617                 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2618                 if (!chanctx_conf) {
2619                         ret = -ENOTCONN;
2620                         goto free;
2621                 }
2622                 band = chanctx_conf->def.chan->band;
2623                 break;
2624         default:
2625                 ret = -EINVAL;
2626                 goto free;
2627         }
2628
2629         multicast = is_multicast_ether_addr(hdr.addr1);
2630
2631         /* sta is always NULL for mesh */
2632         if (sta) {
2633                 authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED);
2634                 wme_sta = sta->sta.wme;
2635         } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
2636                 /* For mesh, the use of the QoS header is mandatory */
2637                 wme_sta = true;
2638         }
2639
2640         /* receiver does QoS (which also means we do) use it */
2641         if (wme_sta) {
2642                 fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
2643                 hdrlen += 2;
2644         }
2645
2646         /*
2647          * Drop unicast frames to unauthorised stations unless they are
2648          * EAPOL frames from the local station.
2649          */
2650         if (unlikely(!ieee80211_vif_is_mesh(&sdata->vif) &&
2651                      (sdata->vif.type != NL80211_IFTYPE_OCB) &&
2652                      !multicast && !authorized &&
2653                      (cpu_to_be16(ethertype) != sdata->control_port_protocol ||
2654                       !ether_addr_equal(sdata->vif.addr, skb->data + ETH_ALEN)))) {
2655 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2656                 net_info_ratelimited("%s: dropped frame to %pM (unauthorized port)\n",
2657                                     sdata->name, hdr.addr1);
2658 #endif
2659
2660                 I802_DEBUG_INC(local->tx_handlers_drop_unauth_port);
2661
2662                 ret = -EPERM;
2663                 goto free;
2664         }
2665
2666         if (unlikely(!multicast && skb->sk &&
2667                      skb_shinfo(skb)->tx_flags & SKBTX_WIFI_STATUS)) {
2668                 struct sk_buff *ack_skb = skb_clone_sk(skb);
2669
2670                 if (ack_skb) {
2671                         unsigned long flags;
2672                         int id;
2673
2674                         spin_lock_irqsave(&local->ack_status_lock, flags);
2675                         id = idr_alloc(&local->ack_status_frames, ack_skb,
2676                                        1, 0x10000, GFP_ATOMIC);
2677                         spin_unlock_irqrestore(&local->ack_status_lock, flags);
2678
2679                         if (id >= 0) {
2680                                 info_id = id;
2681                                 info_flags |= IEEE80211_TX_CTL_REQ_TX_STATUS;
2682                         } else {
2683                                 kfree_skb(ack_skb);
2684                         }
2685                 }
2686         }
2687
2688         /*
2689          * If the skb is shared we need to obtain our own copy.
2690          */
2691         if (skb_shared(skb)) {
2692                 struct sk_buff *tmp_skb = skb;
2693
2694                 /* can't happen -- skb is a clone if info_id != 0 */
2695                 WARN_ON(info_id);
2696
2697                 skb = skb_clone(skb, GFP_ATOMIC);
2698                 kfree_skb(tmp_skb);
2699
2700                 if (!skb) {
2701                         ret = -ENOMEM;
2702                         goto free;
2703                 }
2704         }
2705
2706         hdr.frame_control = fc;
2707         hdr.duration_id = 0;
2708         hdr.seq_ctrl = 0;
2709
2710         skip_header_bytes = ETH_HLEN;
2711         if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) {
2712                 encaps_data = bridge_tunnel_header;
2713                 encaps_len = sizeof(bridge_tunnel_header);
2714                 skip_header_bytes -= 2;
2715         } else if (ethertype >= ETH_P_802_3_MIN) {
2716                 encaps_data = rfc1042_header;
2717                 encaps_len = sizeof(rfc1042_header);
2718                 skip_header_bytes -= 2;
2719         } else {
2720                 encaps_data = NULL;
2721                 encaps_len = 0;
2722         }
2723
2724         skb_pull(skb, skip_header_bytes);
2725         head_need = hdrlen + encaps_len + meshhdrlen - skb_headroom(skb);
2726
2727         /*
2728          * So we need to modify the skb header and hence need a copy of
2729          * that. The head_need variable above doesn't, so far, include
2730          * the needed header space that we don't need right away. If we
2731          * can, then we don't reallocate right now but only after the
2732          * frame arrives at the master device (if it does...)
2733          *
2734          * If we cannot, however, then we will reallocate to include all
2735          * the ever needed space. Also, if we need to reallocate it anyway,
2736          * make it big enough for everything we may ever need.
2737          */
2738
2739         if (head_need > 0 || skb_cloned(skb)) {
2740                 head_need += sdata->encrypt_headroom;
2741                 head_need += local->tx_headroom;
2742                 head_need = max_t(int, 0, head_need);
2743                 if (ieee80211_skb_resize(sdata, skb, head_need, true)) {
2744                         ieee80211_free_txskb(&local->hw, skb);
2745                         skb = NULL;
2746                         return ERR_PTR(-ENOMEM);
2747                 }
2748         }
2749
2750         if (encaps_data)
2751                 memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len);
2752
2753 #ifdef CONFIG_MAC80211_MESH
2754         if (meshhdrlen > 0)
2755                 memcpy(skb_push(skb, meshhdrlen), &mesh_hdr, meshhdrlen);
2756 #endif
2757
2758         if (ieee80211_is_data_qos(fc)) {
2759                 __le16 *qos_control;
2760
2761                 qos_control = skb_push(skb, 2);
2762                 memcpy(skb_push(skb, hdrlen - 2), &hdr, hdrlen - 2);
2763                 /*
2764                  * Maybe we could actually set some fields here, for now just
2765                  * initialise to zero to indicate no special operation.
2766                  */
2767                 *qos_control = 0;
2768         } else
2769                 memcpy(skb_push(skb, hdrlen), &hdr, hdrlen);
2770
2771         skb_reset_mac_header(skb);
2772
2773         info = IEEE80211_SKB_CB(skb);
2774         memset(info, 0, sizeof(*info));
2775
2776         info->flags = info_flags;
2777         info->ack_frame_id = info_id;
2778         info->band = band;
2779
2780         return skb;
2781  free:
2782         kfree_skb(skb);
2783         return ERR_PTR(ret);
2784 }
2785
2786 /*
2787  * fast-xmit overview
2788  *
2789  * The core idea of this fast-xmit is to remove per-packet checks by checking
2790  * them out of band. ieee80211_check_fast_xmit() implements the out-of-band
2791  * checks that are needed to get the sta->fast_tx pointer assigned, after which
2792  * much less work can be done per packet. For example, fragmentation must be
2793  * disabled or the fast_tx pointer will not be set. All the conditions are seen
2794  * in the code here.
2795  *
2796  * Once assigned, the fast_tx data structure also caches the per-packet 802.11
2797  * header and other data to aid packet processing in ieee80211_xmit_fast().
2798  *
2799  * The most difficult part of this is that when any of these assumptions
2800  * change, an external trigger (i.e. a call to ieee80211_clear_fast_xmit(),
2801  * ieee80211_check_fast_xmit() or friends) is required to reset the data,
2802  * since the per-packet code no longer checks the conditions. This is reflected
2803  * by the calls to these functions throughout the rest of the code, and must be
2804  * maintained if any of the TX path checks change.
2805  */
2806
2807 void ieee80211_check_fast_xmit(struct sta_info *sta)
2808 {
2809         struct ieee80211_fast_tx build = {}, *fast_tx = NULL, *old;
2810         struct ieee80211_local *local = sta->local;
2811         struct ieee80211_sub_if_data *sdata = sta->sdata;
2812         struct ieee80211_hdr *hdr = (void *)build.hdr;
2813         struct ieee80211_chanctx_conf *chanctx_conf;
2814         __le16 fc;
2815
2816         if (!ieee80211_hw_check(&local->hw, SUPPORT_FAST_XMIT))
2817                 return;
2818
2819         /* Locking here protects both the pointer itself, and against concurrent
2820          * invocations winning data access races to, e.g., the key pointer that
2821          * is used.
2822          * Without it, the invocation of this function right after the key
2823          * pointer changes wouldn't be sufficient, as another CPU could access
2824          * the pointer, then stall, and then do the cache update after the CPU
2825          * that invalidated the key.
2826          * With the locking, such scenarios cannot happen as the check for the
2827          * key and the fast-tx assignment are done atomically, so the CPU that
2828          * modifies the key will either wait or other one will see the key
2829          * cleared/changed already.
2830          */
2831         spin_lock_bh(&sta->lock);
2832         if (ieee80211_hw_check(&local->hw, SUPPORTS_PS) &&
2833             !ieee80211_hw_check(&local->hw, SUPPORTS_DYNAMIC_PS) &&
2834             sdata->vif.type == NL80211_IFTYPE_STATION)
2835                 goto out;
2836
2837         if (!test_sta_flag(sta, WLAN_STA_AUTHORIZED))
2838                 goto out;
2839
2840         if (test_sta_flag(sta, WLAN_STA_PS_STA) ||
2841             test_sta_flag(sta, WLAN_STA_PS_DRIVER) ||
2842             test_sta_flag(sta, WLAN_STA_PS_DELIVER) ||
2843             test_sta_flag(sta, WLAN_STA_CLEAR_PS_FILT))
2844                 goto out;
2845
2846         if (sdata->noack_map)
2847                 goto out;
2848
2849         /* fast-xmit doesn't handle fragmentation at all */
2850         if (local->hw.wiphy->frag_threshold != (u32)-1 &&
2851             !ieee80211_hw_check(&local->hw, SUPPORTS_TX_FRAG))
2852                 goto out;
2853
2854         rcu_read_lock();
2855         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2856         if (!chanctx_conf) {
2857                 rcu_read_unlock();
2858                 goto out;
2859         }
2860         build.band = chanctx_conf->def.chan->band;
2861         rcu_read_unlock();
2862
2863         fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
2864
2865         switch (sdata->vif.type) {
2866         case NL80211_IFTYPE_ADHOC:
2867                 /* DA SA BSSID */
2868                 build.da_offs = offsetof(struct ieee80211_hdr, addr1);
2869                 build.sa_offs = offsetof(struct ieee80211_hdr, addr2);
2870                 memcpy(hdr->addr3, sdata->u.ibss.bssid, ETH_ALEN);
2871                 build.hdr_len = 24;
2872                 break;
2873         case NL80211_IFTYPE_STATION:
2874                 if (test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
2875                         /* DA SA BSSID */
2876                         build.da_offs = offsetof(struct ieee80211_hdr, addr1);
2877                         build.sa_offs = offsetof(struct ieee80211_hdr, addr2);
2878                         memcpy(hdr->addr3, sdata->u.mgd.bssid, ETH_ALEN);
2879                         build.hdr_len = 24;
2880                         break;
2881                 }
2882
2883                 if (sdata->u.mgd.use_4addr) {
2884                         /* non-regular ethertype cannot use the fastpath */
2885                         fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS |
2886                                           IEEE80211_FCTL_TODS);
2887                         /* RA TA DA SA */
2888                         memcpy(hdr->addr1, sdata->u.mgd.bssid, ETH_ALEN);
2889                         memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
2890                         build.da_offs = offsetof(struct ieee80211_hdr, addr3);
2891                         build.sa_offs = offsetof(struct ieee80211_hdr, addr4);
2892                         build.hdr_len = 30;
2893                         break;
2894                 }
2895                 fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
2896                 /* BSSID SA DA */
2897                 memcpy(hdr->addr1, sdata->u.mgd.bssid, ETH_ALEN);
2898                 build.da_offs = offsetof(struct ieee80211_hdr, addr3);
2899                 build.sa_offs = offsetof(struct ieee80211_hdr, addr2);
2900                 build.hdr_len = 24;
2901                 break;
2902         case NL80211_IFTYPE_AP_VLAN:
2903                 if (sdata->wdev.use_4addr) {
2904                         fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS |
2905                                           IEEE80211_FCTL_TODS);
2906                         /* RA TA DA SA */
2907                         memcpy(hdr->addr1, sta->sta.addr, ETH_ALEN);
2908                         memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
2909                         build.da_offs = offsetof(struct ieee80211_hdr, addr3);
2910                         build.sa_offs = offsetof(struct ieee80211_hdr, addr4);
2911                         build.hdr_len = 30;
2912                         break;
2913                 }
2914                 /* fall through */
2915         case NL80211_IFTYPE_AP:
2916                 fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
2917                 /* DA BSSID SA */
2918                 build.da_offs = offsetof(struct ieee80211_hdr, addr1);
2919                 memcpy(hdr->addr2, sdata->vif.addr, ETH_ALEN);
2920                 build.sa_offs = offsetof(struct ieee80211_hdr, addr3);
2921                 build.hdr_len = 24;
2922                 break;
2923         default:
2924                 /* not handled on fast-xmit */
2925                 goto out;
2926         }
2927
2928         if (sta->sta.wme) {
2929                 build.hdr_len += 2;
2930                 fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
2931         }
2932
2933         /* We store the key here so there's no point in using rcu_dereference()
2934          * but that's fine because the code that changes the pointers will call
2935          * this function after doing so. For a single CPU that would be enough,
2936          * for multiple see the comment above.
2937          */
2938         build.key = rcu_access_pointer(sta->ptk[sta->ptk_idx]);
2939         if (!build.key)
2940                 build.key = rcu_access_pointer(sdata->default_unicast_key);
2941         if (build.key) {
2942                 bool gen_iv, iv_spc, mmic;
2943
2944                 gen_iv = build.key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV;
2945                 iv_spc = build.key->conf.flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE;
2946                 mmic = build.key->conf.flags &
2947                         (IEEE80211_KEY_FLAG_GENERATE_MMIC |
2948                          IEEE80211_KEY_FLAG_PUT_MIC_SPACE);
2949
2950                 /* don't handle software crypto */
2951                 if (!(build.key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
2952                         goto out;
2953
2954                 switch (build.key->conf.cipher) {
2955                 case WLAN_CIPHER_SUITE_CCMP:
2956                 case WLAN_CIPHER_SUITE_CCMP_256:
2957                         /* add fixed key ID */
2958                         if (gen_iv) {
2959                                 (build.hdr + build.hdr_len)[3] =
2960                                         0x20 | (build.key->conf.keyidx << 6);
2961                                 build.pn_offs = build.hdr_len;
2962                         }
2963                         if (gen_iv || iv_spc)
2964                                 build.hdr_len += IEEE80211_CCMP_HDR_LEN;
2965                         break;
2966                 case WLAN_CIPHER_SUITE_GCMP:
2967                 case WLAN_CIPHER_SUITE_GCMP_256:
2968                         /* add fixed key ID */
2969                         if (gen_iv) {
2970                                 (build.hdr + build.hdr_len)[3] =
2971                                         0x20 | (build.key->conf.keyidx << 6);
2972                                 build.pn_offs = build.hdr_len;
2973                         }
2974                         if (gen_iv || iv_spc)
2975                                 build.hdr_len += IEEE80211_GCMP_HDR_LEN;
2976                         break;
2977                 case WLAN_CIPHER_SUITE_TKIP:
2978                         /* cannot handle MMIC or IV generation in xmit-fast */
2979                         if (mmic || gen_iv)
2980                                 goto out;
2981                         if (iv_spc)
2982                                 build.hdr_len += IEEE80211_TKIP_IV_LEN;
2983                         break;
2984                 case WLAN_CIPHER_SUITE_WEP40:
2985                 case WLAN_CIPHER_SUITE_WEP104:
2986                         /* cannot handle IV generation in fast-xmit */
2987                         if (gen_iv)
2988                                 goto out;
2989                         if (iv_spc)
2990                                 build.hdr_len += IEEE80211_WEP_IV_LEN;
2991                         break;
2992                 case WLAN_CIPHER_SUITE_AES_CMAC:
2993                 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
2994                 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
2995                 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
2996                         WARN(1,
2997                              "management cipher suite 0x%x enabled for data\n",
2998                              build.key->conf.cipher);
2999                         goto out;
3000                 default:
3001                         /* we don't know how to generate IVs for this at all */
3002                         if (WARN_ON(gen_iv))
3003                                 goto out;
3004                         /* pure hardware keys are OK, of course */
3005                         if (!(build.key->flags & KEY_FLAG_CIPHER_SCHEME))
3006                                 break;
3007                         /* cipher scheme might require space allocation */
3008                         if (iv_spc &&
3009                             build.key->conf.iv_len > IEEE80211_FAST_XMIT_MAX_IV)
3010                                 goto out;
3011                         if (iv_spc)
3012                                 build.hdr_len += build.key->conf.iv_len;
3013                 }
3014
3015                 fc |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
3016         }
3017
3018         hdr->frame_control = fc;
3019
3020         memcpy(build.hdr + build.hdr_len,
3021                rfc1042_header,  sizeof(rfc1042_header));
3022         build.hdr_len += sizeof(rfc1042_header);
3023
3024         fast_tx = kmemdup(&build, sizeof(build), GFP_ATOMIC);
3025         /* if the kmemdup fails, continue w/o fast_tx */
3026         if (!fast_tx)
3027                 goto out;
3028
3029  out:
3030         /* we might have raced against another call to this function */
3031         old = rcu_dereference_protected(sta->fast_tx,
3032                                         lockdep_is_held(&sta->lock));
3033         rcu_assign_pointer(sta->fast_tx, fast_tx);
3034         if (old)
3035                 kfree_rcu(old, rcu_head);
3036         spin_unlock_bh(&sta->lock);
3037 }
3038
3039 void ieee80211_check_fast_xmit_all(struct ieee80211_local *local)
3040 {
3041         struct sta_info *sta;
3042
3043         rcu_read_lock();
3044         list_for_each_entry_rcu(sta, &local->sta_list, list)
3045                 ieee80211_check_fast_xmit(sta);
3046         rcu_read_unlock();
3047 }
3048
3049 void ieee80211_check_fast_xmit_iface(struct ieee80211_sub_if_data *sdata)
3050 {
3051         struct ieee80211_local *local = sdata->local;
3052         struct sta_info *sta;
3053
3054         rcu_read_lock();
3055
3056         list_for_each_entry_rcu(sta, &local->sta_list, list) {
3057                 if (sdata != sta->sdata &&
3058                     (!sta->sdata->bss || sta->sdata->bss != sdata->bss))
3059                         continue;
3060                 ieee80211_check_fast_xmit(sta);
3061         }
3062
3063         rcu_read_unlock();
3064 }
3065
3066 void ieee80211_clear_fast_xmit(struct sta_info *sta)
3067 {
3068         struct ieee80211_fast_tx *fast_tx;
3069
3070         spin_lock_bh(&sta->lock);
3071         fast_tx = rcu_dereference_protected(sta->fast_tx,
3072                                             lockdep_is_held(&sta->lock));
3073         RCU_INIT_POINTER(sta->fast_tx, NULL);
3074         spin_unlock_bh(&sta->lock);
3075
3076         if (fast_tx)
3077                 kfree_rcu(fast_tx, rcu_head);
3078 }
3079
3080 static bool ieee80211_amsdu_realloc_pad(struct ieee80211_local *local,
3081                                         struct sk_buff *skb, int headroom)
3082 {
3083         if (skb_headroom(skb) < headroom) {
3084                 I802_DEBUG_INC(local->tx_expand_skb_head);
3085
3086                 if (pskb_expand_head(skb, headroom, 0, GFP_ATOMIC)) {
3087                         wiphy_debug(local->hw.wiphy,
3088                                     "failed to reallocate TX buffer\n");
3089                         return false;
3090                 }
3091         }
3092
3093         return true;
3094 }
3095
3096 static bool ieee80211_amsdu_prepare_head(struct ieee80211_sub_if_data *sdata,
3097                                          struct ieee80211_fast_tx *fast_tx,
3098                                          struct sk_buff *skb)
3099 {
3100         struct ieee80211_local *local = sdata->local;
3101         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3102         struct ieee80211_hdr *hdr;
3103         struct ethhdr *amsdu_hdr;
3104         int hdr_len = fast_tx->hdr_len - sizeof(rfc1042_header);
3105         int subframe_len = skb->len - hdr_len;
3106         void *data;
3107         u8 *qc, *h_80211_src, *h_80211_dst;
3108         const u8 *bssid;
3109
3110         if (info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE)
3111                 return false;
3112
3113         if (info->control.flags & IEEE80211_TX_CTRL_AMSDU)
3114                 return true;
3115
3116         if (!ieee80211_amsdu_realloc_pad(local, skb, sizeof(*amsdu_hdr)))
3117                 return false;
3118
3119         data = skb_push(skb, sizeof(*amsdu_hdr));
3120         memmove(data, data + sizeof(*amsdu_hdr), hdr_len);
3121         hdr = data;
3122         amsdu_hdr = data + hdr_len;
3123         /* h_80211_src/dst is addr* field within hdr */
3124         h_80211_src = data + fast_tx->sa_offs;
3125         h_80211_dst = data + fast_tx->da_offs;
3126
3127         amsdu_hdr->h_proto = cpu_to_be16(subframe_len);
3128         ether_addr_copy(amsdu_hdr->h_source, h_80211_src);
3129         ether_addr_copy(amsdu_hdr->h_dest, h_80211_dst);
3130
3131         /* according to IEEE 802.11-2012 8.3.2 table 8-19, the outer SA/DA
3132          * fields needs to be changed to BSSID for A-MSDU frames depending
3133          * on FromDS/ToDS values.
3134          */
3135         switch (sdata->vif.type) {
3136         case NL80211_IFTYPE_STATION:
3137                 bssid = sdata->u.mgd.bssid;
3138                 break;
3139         case NL80211_IFTYPE_AP:
3140         case NL80211_IFTYPE_AP_VLAN:
3141                 bssid = sdata->vif.addr;
3142                 break;
3143         default:
3144                 bssid = NULL;
3145         }
3146
3147         if (bssid && ieee80211_has_fromds(hdr->frame_control))
3148                 ether_addr_copy(h_80211_src, bssid);
3149
3150         if (bssid && ieee80211_has_tods(hdr->frame_control))
3151                 ether_addr_copy(h_80211_dst, bssid);
3152
3153         qc = ieee80211_get_qos_ctl(hdr);
3154         *qc |= IEEE80211_QOS_CTL_A_MSDU_PRESENT;
3155
3156         info->control.flags |= IEEE80211_TX_CTRL_AMSDU;
3157
3158         return true;
3159 }
3160
3161 static bool ieee80211_amsdu_aggregate(struct ieee80211_sub_if_data *sdata,
3162                                       struct sta_info *sta,
3163                                       struct ieee80211_fast_tx *fast_tx,
3164                                       struct sk_buff *skb)
3165 {
3166         struct ieee80211_local *local = sdata->local;
3167         struct fq *fq = &local->fq;
3168         struct fq_tin *tin;
3169         struct fq_flow *flow;
3170         u8 tid = skb->priority & IEEE80211_QOS_CTL_TAG1D_MASK;
3171         struct ieee80211_txq *txq = sta->sta.txq[tid];
3172         struct txq_info *txqi;
3173         struct sk_buff **frag_tail, *head;
3174         int subframe_len = skb->len - ETH_ALEN;
3175         u8 max_subframes = sta->sta.max_amsdu_subframes;
3176         int max_frags = local->hw.max_tx_fragments;
3177         int max_amsdu_len = sta->sta.max_amsdu_len;
3178         __be16 len;
3179         void *data;
3180         bool ret = false;
3181         unsigned int orig_len;
3182         int n = 2, nfrags, pad = 0;
3183         u16 hdrlen;
3184
3185         if (!ieee80211_hw_check(&local->hw, TX_AMSDU))
3186                 return false;
3187
3188         if (!txq)
3189                 return false;
3190
3191         txqi = to_txq_info(txq);
3192         if (test_bit(IEEE80211_TXQ_NO_AMSDU, &txqi->flags))
3193                 return false;
3194
3195         if (sta->sta.max_rc_amsdu_len)
3196                 max_amsdu_len = min_t(int, max_amsdu_len,
3197                                       sta->sta.max_rc_amsdu_len);
3198
3199         spin_lock_bh(&fq->lock);
3200
3201         /* TODO: Ideally aggregation should be done on dequeue to remain
3202          * responsive to environment changes.
3203          */
3204
3205         tin = &txqi->tin;
3206         flow = fq_flow_classify(fq, tin, skb, fq_flow_get_default_func);
3207         head = skb_peek_tail(&flow->queue);
3208         if (!head)
3209                 goto out;
3210
3211         orig_len = head->len;
3212
3213         if (skb->len + head->len > max_amsdu_len)
3214                 goto out;
3215
3216         nfrags = 1 + skb_shinfo(skb)->nr_frags;
3217         nfrags += 1 + skb_shinfo(head)->nr_frags;
3218         frag_tail = &skb_shinfo(head)->frag_list;
3219         while (*frag_tail) {
3220                 nfrags += 1 + skb_shinfo(*frag_tail)->nr_frags;
3221                 frag_tail = &(*frag_tail)->next;
3222                 n++;
3223         }
3224
3225         if (max_subframes && n > max_subframes)
3226                 goto out;
3227
3228         if (max_frags && nfrags > max_frags)
3229                 goto out;
3230
3231         if (!ieee80211_amsdu_prepare_head(sdata, fast_tx, head))
3232                 goto out;
3233
3234         /*
3235          * Pad out the previous subframe to a multiple of 4 by adding the
3236          * padding to the next one, that's being added. Note that head->len
3237          * is the length of the full A-MSDU, but that works since each time
3238          * we add a new subframe we pad out the previous one to a multiple
3239          * of 4 and thus it no longer matters in the next round.
3240          */
3241         hdrlen = fast_tx->hdr_len - sizeof(rfc1042_header);
3242         if ((head->len - hdrlen) & 3)
3243                 pad = 4 - ((head->len - hdrlen) & 3);
3244
3245         if (!ieee80211_amsdu_realloc_pad(local, skb, sizeof(rfc1042_header) +
3246                                                      2 + pad))
3247                 goto out_recalc;
3248
3249         ret = true;
3250         data = skb_push(skb, ETH_ALEN + 2);
3251         memmove(data, data + ETH_ALEN + 2, 2 * ETH_ALEN);
3252
3253         data += 2 * ETH_ALEN;
3254         len = cpu_to_be16(subframe_len);
3255         memcpy(data, &len, 2);
3256         memcpy(data + 2, rfc1042_header, sizeof(rfc1042_header));
3257
3258         memset(skb_push(skb, pad), 0, pad);
3259
3260         head->len += skb->len;
3261         head->data_len += skb->len;
3262         *frag_tail = skb;
3263
3264 out_recalc:
3265         if (head->len != orig_len) {
3266                 flow->backlog += head->len - orig_len;
3267                 tin->backlog_bytes += head->len - orig_len;
3268
3269                 fq_recalc_backlog(fq, tin, flow);
3270         }
3271 out:
3272         spin_unlock_bh(&fq->lock);
3273
3274         return ret;
3275 }
3276
3277 /*
3278  * Can be called while the sta lock is held. Anything that can cause packets to
3279  * be generated will cause deadlock!
3280  */
3281 static void ieee80211_xmit_fast_finish(struct ieee80211_sub_if_data *sdata,
3282                                        struct sta_info *sta, u8 pn_offs,
3283                                        struct ieee80211_key *key,
3284                                        struct sk_buff *skb)
3285 {
3286         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3287         struct ieee80211_hdr *hdr = (void *)skb->data;
3288         u8 tid = IEEE80211_NUM_TIDS;
3289
3290         if (key)
3291                 info->control.hw_key = &key->conf;
3292
3293         ieee80211_tx_stats(skb->dev, skb->len);