2 * Copyright (c) 2008, 2009 open80211s Ltd.
3 * Author: Luis Carlos Cobo <luisca@cozybit.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
10 #include <linux/kernel.h>
11 #include <linux/random.h>
12 #include "ieee80211_i.h"
16 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
17 #define mpl_dbg(fmt, args...) printk(KERN_DEBUG fmt, ##args)
19 #define mpl_dbg(fmt, args...) do { (void)(0); } while (0)
22 #define PLINK_GET_LLID(p) (p + 4)
23 #define PLINK_GET_PLID(p) (p + 6)
25 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
26 jiffies + HZ * t / 1000))
28 /* Peer link cancel reasons, all subject to ANA approval */
29 #define MESH_LINK_CANCELLED 2
30 #define MESH_MAX_NEIGHBORS 3
31 #define MESH_CAPABILITY_POLICY_VIOLATION 4
32 #define MESH_CLOSE_RCVD 5
33 #define MESH_MAX_RETRIES 6
34 #define MESH_CONFIRM_TIMEOUT 7
35 #define MESH_SECURITY_ROLE_NEGOTIATION_DIFFERS 8
36 #define MESH_SECURITY_AUTHENTICATION_IMPOSSIBLE 9
37 #define MESH_SECURITY_FAILED_VERIFICATION 10
39 #define dot11MeshMaxRetries(s) (s->u.mesh.mshcfg.dot11MeshMaxRetries)
40 #define dot11MeshRetryTimeout(s) (s->u.mesh.mshcfg.dot11MeshRetryTimeout)
41 #define dot11MeshConfirmTimeout(s) (s->u.mesh.mshcfg.dot11MeshConfirmTimeout)
42 #define dot11MeshHoldingTimeout(s) (s->u.mesh.mshcfg.dot11MeshHoldingTimeout)
43 #define dot11MeshMaxPeerLinks(s) (s->u.mesh.mshcfg.dot11MeshMaxPeerLinks)
45 enum plink_frame_type
{
64 void mesh_plink_inc_estab_count(struct ieee80211_sub_if_data
*sdata
)
66 atomic_inc(&sdata
->u
.mesh
.mshstats
.estab_plinks
);
67 mesh_accept_plinks_update(sdata
);
71 void mesh_plink_dec_estab_count(struct ieee80211_sub_if_data
*sdata
)
73 atomic_dec(&sdata
->u
.mesh
.mshstats
.estab_plinks
);
74 mesh_accept_plinks_update(sdata
);
78 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
80 * @sta: mesh peer link to restart
82 * Locking: this function must be called holding sta->lock
84 static inline void mesh_plink_fsm_restart(struct sta_info
*sta
)
86 sta
->plink_state
= PLINK_LISTEN
;
87 sta
->llid
= sta
->plid
= sta
->reason
= 0;
88 sta
->plink_retries
= 0;
92 * NOTE: This is just an alias for sta_info_alloc(), see notes
93 * on it in the lifecycle management section!
95 static struct sta_info
*mesh_plink_alloc(struct ieee80211_sub_if_data
*sdata
,
96 u8
*hw_addr
, u32 rates
)
98 struct ieee80211_local
*local
= sdata
->local
;
101 if (local
->num_sta
>= MESH_MAX_PLINKS
)
104 sta
= sta_info_alloc(sdata
, hw_addr
, GFP_KERNEL
);
108 sta
->flags
= WLAN_STA_AUTHORIZED
| WLAN_STA_AUTH
;
109 sta
->sta
.supp_rates
[local
->hw
.conf
.channel
->band
] = rates
;
110 rate_control_rate_init(sta
);
116 * __mesh_plink_deactivate - deactivate mesh peer link
118 * @sta: mesh peer link to deactivate
120 * All mesh paths with this peer as next hop will be flushed
122 * Locking: the caller must hold sta->lock
124 static bool __mesh_plink_deactivate(struct sta_info
*sta
)
126 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
127 bool deactivated
= false;
129 if (sta
->plink_state
== PLINK_ESTAB
) {
130 mesh_plink_dec_estab_count(sdata
);
133 sta
->plink_state
= PLINK_BLOCKED
;
134 mesh_path_flush_by_nexthop(sta
);
140 * mesh_plink_deactivate - deactivate mesh peer link
142 * @sta: mesh peer link to deactivate
144 * All mesh paths with this peer as next hop will be flushed
146 void mesh_plink_deactivate(struct sta_info
*sta
)
148 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
151 spin_lock_bh(&sta
->lock
);
152 deactivated
= __mesh_plink_deactivate(sta
);
153 spin_unlock_bh(&sta
->lock
);
156 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_BEACON
);
159 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data
*sdata
,
160 enum plink_frame_type action
, u8
*da
, __le16 llid
, __le16 plid
,
162 struct ieee80211_local
*local
= sdata
->local
;
163 struct sk_buff
*skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ 400 +
164 sdata
->u
.mesh
.ie_len
);
165 struct ieee80211_mgmt
*mgmt
;
166 bool include_plid
= false;
167 static const u8 meshpeeringproto
[] = { 0x00, 0x0F, 0xAC, 0x2A };
173 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
174 /* 25 is the size of the common mgmt part (24) plus the size of the
175 * common action part (1)
177 mgmt
= (struct ieee80211_mgmt
*)
178 skb_put(skb
, 25 + sizeof(mgmt
->u
.action
.u
.plink_action
));
179 memset(mgmt
, 0, 25 + sizeof(mgmt
->u
.action
.u
.plink_action
));
180 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
181 IEEE80211_STYPE_ACTION
);
182 memcpy(mgmt
->da
, da
, ETH_ALEN
);
183 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
184 /* BSSID is left zeroed, wildcard value */
185 mgmt
->u
.action
.category
= WLAN_CATEGORY_MESH_PLINK
;
186 mgmt
->u
.action
.u
.plink_action
.action_code
= action
;
188 if (action
== PLINK_CLOSE
)
189 mgmt
->u
.action
.u
.plink_action
.aux
= reason
;
191 mgmt
->u
.action
.u
.plink_action
.aux
= cpu_to_le16(0x0);
192 if (action
== PLINK_CONFIRM
) {
193 pos
= skb_put(skb
, 4);
194 /* two-byte status code followed by two-byte AID */
196 memcpy(pos
+ 2, &plid
, 2);
198 mesh_mgmt_ies_add(skb
, sdata
);
201 /* Add Peer Link Management element */
221 pos
= skb_put(skb
, 2 + ie_len
);
222 *pos
++ = WLAN_EID_PEER_LINK
;
224 memcpy(pos
, meshpeeringproto
, sizeof(meshpeeringproto
));
226 memcpy(pos
, &llid
, 2);
229 memcpy(pos
, &plid
, 2);
231 if (action
== PLINK_CLOSE
) {
233 memcpy(pos
, &reason
, 2);
236 ieee80211_tx_skb(sdata
, skb
);
240 void mesh_neighbour_update(u8
*hw_addr
, u32 rates
,
241 struct ieee80211_sub_if_data
*sdata
,
242 struct ieee802_11_elems
*elems
)
244 struct ieee80211_local
*local
= sdata
->local
;
245 struct sta_info
*sta
;
249 sta
= sta_info_get(sdata
, hw_addr
);
252 /* Userspace handles peer allocation when security is enabled
254 if (sdata
->u
.mesh
.is_secure
)
255 cfg80211_notify_new_peer_candidate(sdata
->dev
, hw_addr
,
256 elems
->ie_start
, elems
->total_len
,
259 sta
= mesh_plink_alloc(sdata
, hw_addr
, rates
);
262 if (sta_info_insert_rcu(sta
)) {
268 sta
->last_rx
= jiffies
;
269 sta
->sta
.supp_rates
[local
->hw
.conf
.channel
->band
] = rates
;
270 if (mesh_peer_accepts_plinks(elems
) &&
271 sta
->plink_state
== PLINK_LISTEN
&&
272 sdata
->u
.mesh
.accepting_plinks
&&
273 sdata
->u
.mesh
.mshcfg
.auto_open_plinks
)
274 mesh_plink_open(sta
);
279 static void mesh_plink_timer(unsigned long data
)
281 struct sta_info
*sta
;
282 __le16 llid
, plid
, reason
;
283 struct ieee80211_sub_if_data
*sdata
;
286 * This STA is valid because sta_info_destroy() will
287 * del_timer_sync() this timer after having made sure
288 * it cannot be readded (by deleting the plink.)
290 sta
= (struct sta_info
*) data
;
292 if (sta
->sdata
->local
->quiescing
) {
293 sta
->plink_timer_was_running
= true;
297 spin_lock_bh(&sta
->lock
);
298 if (sta
->ignore_plink_timer
) {
299 sta
->ignore_plink_timer
= false;
300 spin_unlock_bh(&sta
->lock
);
303 mpl_dbg("Mesh plink timer for %pM fired on state %d\n",
304 sta
->sta
.addr
, sta
->plink_state
);
310 switch (sta
->plink_state
) {
314 if (sta
->plink_retries
< dot11MeshMaxRetries(sdata
)) {
316 mpl_dbg("Mesh plink for %pM (retry, timeout): %d %d\n",
317 sta
->sta
.addr
, sta
->plink_retries
,
319 get_random_bytes(&rand
, sizeof(u32
));
320 sta
->plink_timeout
= sta
->plink_timeout
+
321 rand
% sta
->plink_timeout
;
322 ++sta
->plink_retries
;
323 mod_plink_timer(sta
, sta
->plink_timeout
);
324 spin_unlock_bh(&sta
->lock
);
325 mesh_plink_frame_tx(sdata
, PLINK_OPEN
, sta
->sta
.addr
, llid
,
329 reason
= cpu_to_le16(MESH_MAX_RETRIES
);
330 /* fall through on else */
334 reason
= cpu_to_le16(MESH_CONFIRM_TIMEOUT
);
335 sta
->plink_state
= PLINK_HOLDING
;
336 mod_plink_timer(sta
, dot11MeshHoldingTimeout(sdata
));
337 spin_unlock_bh(&sta
->lock
);
338 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->sta
.addr
, llid
, plid
,
343 del_timer(&sta
->plink_timer
);
344 mesh_plink_fsm_restart(sta
);
345 spin_unlock_bh(&sta
->lock
);
348 spin_unlock_bh(&sta
->lock
);
354 void mesh_plink_quiesce(struct sta_info
*sta
)
356 if (del_timer_sync(&sta
->plink_timer
))
357 sta
->plink_timer_was_running
= true;
360 void mesh_plink_restart(struct sta_info
*sta
)
362 if (sta
->plink_timer_was_running
) {
363 add_timer(&sta
->plink_timer
);
364 sta
->plink_timer_was_running
= false;
369 static inline void mesh_plink_timer_set(struct sta_info
*sta
, int timeout
)
371 sta
->plink_timer
.expires
= jiffies
+ (HZ
* timeout
/ 1000);
372 sta
->plink_timer
.data
= (unsigned long) sta
;
373 sta
->plink_timer
.function
= mesh_plink_timer
;
374 sta
->plink_timeout
= timeout
;
375 add_timer(&sta
->plink_timer
);
378 int mesh_plink_open(struct sta_info
*sta
)
381 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
383 if (!test_sta_flags(sta
, WLAN_STA_AUTH
))
386 spin_lock_bh(&sta
->lock
);
387 get_random_bytes(&llid
, 2);
389 if (sta
->plink_state
!= PLINK_LISTEN
) {
390 spin_unlock_bh(&sta
->lock
);
393 sta
->plink_state
= PLINK_OPN_SNT
;
394 mesh_plink_timer_set(sta
, dot11MeshRetryTimeout(sdata
));
395 spin_unlock_bh(&sta
->lock
);
396 mpl_dbg("Mesh plink: starting establishment with %pM\n",
399 return mesh_plink_frame_tx(sdata
, PLINK_OPEN
,
400 sta
->sta
.addr
, llid
, 0, 0);
403 void mesh_plink_block(struct sta_info
*sta
)
405 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
408 spin_lock_bh(&sta
->lock
);
409 deactivated
= __mesh_plink_deactivate(sta
);
410 sta
->plink_state
= PLINK_BLOCKED
;
411 spin_unlock_bh(&sta
->lock
);
414 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_BEACON
);
418 void mesh_rx_plink_frame(struct ieee80211_sub_if_data
*sdata
, struct ieee80211_mgmt
*mgmt
,
419 size_t len
, struct ieee80211_rx_status
*rx_status
)
421 struct ieee80211_local
*local
= sdata
->local
;
422 struct ieee802_11_elems elems
;
423 struct sta_info
*sta
;
424 enum plink_event event
;
425 enum plink_frame_type ftype
;
427 bool deactivated
, matches_local
= true;
430 __le16 plid
, llid
, reason
;
431 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
432 static const char *mplstates
[] = {
433 [PLINK_LISTEN
] = "LISTEN",
434 [PLINK_OPN_SNT
] = "OPN-SNT",
435 [PLINK_OPN_RCVD
] = "OPN-RCVD",
436 [PLINK_CNF_RCVD
] = "CNF_RCVD",
437 [PLINK_ESTAB
] = "ESTAB",
438 [PLINK_HOLDING
] = "HOLDING",
439 [PLINK_BLOCKED
] = "BLOCKED"
443 /* need action_code, aux */
444 if (len
< IEEE80211_MIN_ACTION_SIZE
+ 3)
447 if (is_multicast_ether_addr(mgmt
->da
)) {
448 mpl_dbg("Mesh plink: ignore frame from multicast address");
452 baseaddr
= mgmt
->u
.action
.u
.plink_action
.variable
;
453 baselen
= (u8
*) mgmt
->u
.action
.u
.plink_action
.variable
- (u8
*) mgmt
;
454 if (mgmt
->u
.action
.u
.plink_action
.action_code
== PLINK_CONFIRM
) {
458 ieee802_11_parse_elems(baseaddr
, len
- baselen
, &elems
);
459 if (!elems
.peer_link
) {
460 mpl_dbg("Mesh plink: missing necessary peer link ie\n");
463 if (elems
.rsn_len
&& !sdata
->u
.mesh
.is_secure
) {
464 mpl_dbg("Mesh plink: can't establish link with secure peer\n");
468 ftype
= mgmt
->u
.action
.u
.plink_action
.action_code
;
469 ie_len
= elems
.peer_link_len
;
470 if ((ftype
== PLINK_OPEN
&& ie_len
!= 6) ||
471 (ftype
== PLINK_CONFIRM
&& ie_len
!= 8) ||
472 (ftype
== PLINK_CLOSE
&& ie_len
!= 8 && ie_len
!= 10)) {
473 mpl_dbg("Mesh plink: incorrect plink ie length %d %d\n",
478 if (ftype
!= PLINK_CLOSE
&& (!elems
.mesh_id
|| !elems
.mesh_config
)) {
479 mpl_dbg("Mesh plink: missing necessary ie\n");
482 /* Note the lines below are correct, the llid in the frame is the plid
483 * from the point of view of this host.
485 memcpy(&plid
, PLINK_GET_LLID(elems
.peer_link
), 2);
486 if (ftype
== PLINK_CONFIRM
|| (ftype
== PLINK_CLOSE
&& ie_len
== 10))
487 memcpy(&llid
, PLINK_GET_PLID(elems
.peer_link
), 2);
491 sta
= sta_info_get(sdata
, mgmt
->sa
);
492 if (!sta
&& ftype
!= PLINK_OPEN
) {
493 mpl_dbg("Mesh plink: cls or cnf from unknown peer\n");
498 if (sta
&& !test_sta_flags(sta
, WLAN_STA_AUTH
)) {
499 mpl_dbg("Mesh plink: Action frame from non-authed peer\n");
504 if (sta
&& sta
->plink_state
== PLINK_BLOCKED
) {
509 /* Now we will figure out the appropriate event... */
510 event
= PLINK_UNDEFINED
;
511 if (ftype
!= PLINK_CLOSE
&& (!mesh_matches_local(&elems
, sdata
))) {
512 matches_local
= false;
526 if (!sta
&& !matches_local
) {
528 reason
= cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION
);
530 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, mgmt
->sa
, llid
,
534 /* ftype == PLINK_OPEN */
539 if (!mesh_plink_free_count(sdata
)) {
540 mpl_dbg("Mesh plink error: no more free plinks\n");
544 rates
= ieee80211_sta_get_rates(local
, &elems
, rx_status
->band
);
545 sta
= mesh_plink_alloc(sdata
, mgmt
->sa
, rates
);
547 mpl_dbg("Mesh plink error: plink table full\n");
550 if (sta_info_insert_rcu(sta
)) {
555 spin_lock_bh(&sta
->lock
);
556 } else if (matches_local
) {
557 spin_lock_bh(&sta
->lock
);
560 if (!mesh_plink_free_count(sdata
) ||
561 (sta
->plid
&& sta
->plid
!= plid
))
567 if (!mesh_plink_free_count(sdata
) ||
568 (sta
->llid
!= llid
|| sta
->plid
!= plid
))
574 if (sta
->plink_state
== PLINK_ESTAB
)
575 /* Do not check for llid or plid. This does not
576 * follow the standard but since multiple plinks
577 * per sta are not supported, it is necessary in
578 * order to avoid a livelock when MP A sees an
579 * establish peer link to MP B but MP B does not
580 * see it. This can be caused by a timeout in
581 * B's peer link establishment or B beign
585 else if (sta
->plid
!= plid
)
587 else if (ie_len
== 7 && sta
->llid
!= llid
)
593 mpl_dbg("Mesh plink: unknown frame subtype\n");
594 spin_unlock_bh(&sta
->lock
);
599 spin_lock_bh(&sta
->lock
);
602 mpl_dbg("Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
603 mgmt
->sa
, mplstates
[sta
->plink_state
],
604 le16_to_cpu(sta
->llid
), le16_to_cpu(sta
->plid
),
607 switch (sta
->plink_state
) {
608 /* spin_unlock as soon as state is updated at each case */
612 mesh_plink_fsm_restart(sta
);
613 spin_unlock_bh(&sta
->lock
);
616 sta
->plink_state
= PLINK_OPN_RCVD
;
618 get_random_bytes(&llid
, 2);
620 mesh_plink_timer_set(sta
, dot11MeshRetryTimeout(sdata
));
621 spin_unlock_bh(&sta
->lock
);
622 mesh_plink_frame_tx(sdata
, PLINK_OPEN
, sta
->sta
.addr
, llid
,
624 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->sta
.addr
,
628 spin_unlock_bh(&sta
->lock
);
637 reason
= cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION
);
640 reason
= cpu_to_le16(MESH_CLOSE_RCVD
);
641 sta
->reason
= reason
;
642 sta
->plink_state
= PLINK_HOLDING
;
643 if (!mod_plink_timer(sta
,
644 dot11MeshHoldingTimeout(sdata
)))
645 sta
->ignore_plink_timer
= true;
648 spin_unlock_bh(&sta
->lock
);
649 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->sta
.addr
, llid
,
653 /* retry timer is left untouched */
654 sta
->plink_state
= PLINK_OPN_RCVD
;
657 spin_unlock_bh(&sta
->lock
);
658 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->sta
.addr
, llid
,
662 sta
->plink_state
= PLINK_CNF_RCVD
;
663 if (!mod_plink_timer(sta
,
664 dot11MeshConfirmTimeout(sdata
)))
665 sta
->ignore_plink_timer
= true;
667 spin_unlock_bh(&sta
->lock
);
670 spin_unlock_bh(&sta
->lock
);
679 reason
= cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION
);
682 reason
= cpu_to_le16(MESH_CLOSE_RCVD
);
683 sta
->reason
= reason
;
684 sta
->plink_state
= PLINK_HOLDING
;
685 if (!mod_plink_timer(sta
,
686 dot11MeshHoldingTimeout(sdata
)))
687 sta
->ignore_plink_timer
= true;
690 spin_unlock_bh(&sta
->lock
);
691 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->sta
.addr
, llid
,
696 spin_unlock_bh(&sta
->lock
);
697 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->sta
.addr
, llid
,
701 del_timer(&sta
->plink_timer
);
702 sta
->plink_state
= PLINK_ESTAB
;
703 spin_unlock_bh(&sta
->lock
);
704 mesh_plink_inc_estab_count(sdata
);
705 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_BEACON
);
706 mpl_dbg("Mesh plink with %pM ESTABLISHED\n",
710 spin_unlock_bh(&sta
->lock
);
719 reason
= cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION
);
722 reason
= cpu_to_le16(MESH_CLOSE_RCVD
);
723 sta
->reason
= reason
;
724 sta
->plink_state
= PLINK_HOLDING
;
725 if (!mod_plink_timer(sta
,
726 dot11MeshHoldingTimeout(sdata
)))
727 sta
->ignore_plink_timer
= true;
730 spin_unlock_bh(&sta
->lock
);
731 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->sta
.addr
, llid
,
735 del_timer(&sta
->plink_timer
);
736 sta
->plink_state
= PLINK_ESTAB
;
737 spin_unlock_bh(&sta
->lock
);
738 mesh_plink_inc_estab_count(sdata
);
739 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_BEACON
);
740 mpl_dbg("Mesh plink with %pM ESTABLISHED\n",
742 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->sta
.addr
, llid
,
746 spin_unlock_bh(&sta
->lock
);
754 reason
= cpu_to_le16(MESH_CLOSE_RCVD
);
755 sta
->reason
= reason
;
756 deactivated
= __mesh_plink_deactivate(sta
);
757 sta
->plink_state
= PLINK_HOLDING
;
759 mod_plink_timer(sta
, dot11MeshHoldingTimeout(sdata
));
760 spin_unlock_bh(&sta
->lock
);
762 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_BEACON
);
763 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->sta
.addr
, llid
,
768 spin_unlock_bh(&sta
->lock
);
769 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->sta
.addr
, llid
,
773 spin_unlock_bh(&sta
->lock
);
780 if (del_timer(&sta
->plink_timer
))
781 sta
->ignore_plink_timer
= 1;
782 mesh_plink_fsm_restart(sta
);
783 spin_unlock_bh(&sta
->lock
);
790 reason
= sta
->reason
;
791 spin_unlock_bh(&sta
->lock
);
792 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->sta
.addr
,
796 spin_unlock_bh(&sta
->lock
);
800 /* should not get here, PLINK_BLOCKED is dealt with at the
801 * beginning of the function
803 spin_unlock_bh(&sta
->lock
);