Ticket #1329: madwifi-locks.diff

File madwifi-locks.diff, 9.1 kB (added by mentor, 5 years ago)

Version 1

  • net80211/ieee80211_node.c

    old new  
    14171417                 * the table. 
    14181418                 */ 
    14191419                if (ni->ni_table != NULL) { 
    1420                         IEEE80211_NODE_LOCK(nt); 
     1420                        IEEE80211_NODE_LOCK_IRQ(nt); 
    14211421                        _ieee80211_free_node(ni); 
    1422                         IEEE80211_NODE_UNLOCK(nt); 
     1422                        IEEE80211_NODE_UNLOCK_IRQ(nt); 
    14231423                } else 
    14241424                        _ieee80211_free_node(ni); 
    14251425        } 
     
    16611661        IEEE80211_SCAN_LOCK_IRQ(nt); 
    16621662        gen = ++nt->nt_scangen; 
    16631663restart: 
    1664         IEEE80211_NODE_LOCK(nt); 
     1664        IEEE80211_NODE_LOCK_IRQ(nt); 
    16651665        TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 
    16661666                if (dev != NULL && ni->ni_vap->iv_dev != dev)  
    16671667                        continue;  /* skip node not for this vap */ 
    16681668                if (ni->ni_scangen != gen) { 
    16691669                        ni->ni_scangen = gen; 
    16701670                        (void) ieee80211_ref_node(ni); 
    1671                         IEEE80211_NODE_UNLOCK(nt); 
     1671                        IEEE80211_NODE_UNLOCK_IRQ_EARLY(nt); 
    16721672                        (*f)(arg, ni); 
    16731673                        ieee80211_free_node(ni); 
    16741674                        goto restart; 
    16751675                } 
    16761676        } 
    1677         IEEE80211_NODE_UNLOCK(nt); 
     1677        IEEE80211_NODE_UNLOCK_IRQ(nt); 
    16781678 
    16791679        IEEE80211_SCAN_UNLOCK_IRQ(nt); 
    16801680} 
  • net80211/ieee80211_beacon.c

    old new  
    286286        int len_changed = 0; 
    287287        u_int16_t capinfo; 
    288288 
    289         IEEE80211_LOCK(ic); 
     289        IEEE80211_LOCK_IRQ(ic); 
    290290 
    291291        if ((ic->ic_flags & IEEE80211_F_DOTH) && 
    292292            (vap->iv_flags & IEEE80211_F_CHANSWITCH) && 
     
    307307                if (c == NULL) { 
    308308                        IEEE80211_DPRINTF(vap, IEEE80211_MSG_DOTH, 
    309309                                "%s: find channel failure\n", __func__); 
    310                         IEEE80211_UNLOCK(ic); 
     310                        IEEE80211_UNLOCK_IRQ_EARLY(ic); 
    311311                        return 0; 
    312312                } 
    313313                ic->ic_bsschan = c; 
     
    547547                vap->iv_flags_ext &= ~IEEE80211_FEXT_APPIE_UPDATE; 
    548548        } 
    549549 
    550         IEEE80211_UNLOCK(ic); 
     550        IEEE80211_UNLOCK_IRQ(ic); 
    551551 
    552552        return len_changed; 
    553553} 
  • net80211/ieee80211_input.c

    old new  
    36753675        } 
    36763676 
    36773677        /* Okay, take the first queued packet and put it out... */ 
    3678         IEEE80211_NODE_SAVEQ_LOCK(ni); 
     3678        IEEE80211_NODE_SAVEQ_LOCK_BH(ni); 
    36793679        IEEE80211_NODE_SAVEQ_DEQUEUE(ni, skb, qlen); 
    3680         IEEE80211_NODE_SAVEQ_UNLOCK(ni); 
     3680        IEEE80211_NODE_SAVEQ_UNLOCK_BH(ni); 
    36813681        if (skb == NULL) { 
    36823682                IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_POWER, wh->i_addr2, 
    36833683                        "%s", "recv ps-poll, but queue empty"); 
  • net80211/ieee80211_power.c

    old new  
    112112        struct sk_buff *skb; 
    113113        int qlen; 
    114114 
    115         IEEE80211_NODE_SAVEQ_LOCK(ni); 
     115        IEEE80211_NODE_SAVEQ_LOCK_BH(ni); 
    116116        qlen = skb_queue_len(&ni->ni_savedq); 
    117117        while ((skb = __skb_dequeue(&ni->ni_savedq)) != NULL) { 
    118118                ieee80211_free_node(ni); 
    119119                dev_kfree_skb_any(skb); 
    120120        } 
    121         IEEE80211_NODE_SAVEQ_UNLOCK(ni); 
     121        IEEE80211_NODE_SAVEQ_UNLOCK_BH(ni); 
    122122 
    123123        return qlen; 
    124124} 
     
    145145#endif 
    146146                struct sk_buff *skb; 
    147147 
    148                 IEEE80211_NODE_SAVEQ_LOCK(ni); 
     148                IEEE80211_NODE_SAVEQ_LOCK_BH(ni); 
    149149                while ((skb = skb_peek(&ni->ni_savedq)) != NULL && 
    150150                     M_AGE_GET(skb) < IEEE80211_INACT_WAIT) { 
    151151                        IEEE80211_NOTE(vap, IEEE80211_MSG_POWER, ni, 
     
    157157                } 
    158158                if (skb != NULL) 
    159159                        M_AGE_SUB(skb, IEEE80211_INACT_WAIT); 
    160                 IEEE80211_NODE_SAVEQ_UNLOCK(ni); 
     160                IEEE80211_NODE_SAVEQ_UNLOCK_BH(ni); 
    161161 
    162162                IEEE80211_NOTE(vap, IEEE80211_MSG_POWER, ni, 
    163163                        "discard %u frames for age", discard); 
     
    183183        KASSERT(aid < vap->iv_max_aid, 
    184184                ("bogus aid %u, max %u", aid, vap->iv_max_aid)); 
    185185 
    186         IEEE80211_LOCK(ni->ni_ic); 
     186        IEEE80211_LOCK_IRQ(ni->ni_ic); 
    187187        if (set != (isset(vap->iv_tim_bitmap, aid) != 0)) { 
    188188                if (set) { 
    189189                        setbit(vap->iv_tim_bitmap, aid); 
     
    194194                } 
    195195                vap->iv_flags |= IEEE80211_F_TIMUPDATE; 
    196196        } 
    197         IEEE80211_UNLOCK(ni->ni_ic); 
     197        IEEE80211_UNLOCK_IRQ(ni->ni_ic); 
    198198} 
    199199 
    200200/* 
     
    295295                struct sk_buff *skb; 
    296296                int qlen; 
    297297 
    298                 IEEE80211_NODE_SAVEQ_LOCK(ni); 
     298                IEEE80211_NODE_SAVEQ_LOCK_BH(ni); 
    299299                IEEE80211_NODE_SAVEQ_DEQUEUE(ni, skb, qlen); 
    300                 IEEE80211_NODE_SAVEQ_UNLOCK(ni); 
     300                IEEE80211_NODE_SAVEQ_UNLOCK_BH(ni); 
    301301                if (skb == NULL) 
    302302                        break; 
    303303                /*  
     
    359359                        for (;;) { 
    360360                                struct sk_buff *skb; 
    361361 
    362                                 IEEE80211_NODE_SAVEQ_LOCK(ni); 
     362                                IEEE80211_NODE_SAVEQ_LOCK_BH(ni); 
    363363                                skb = __skb_dequeue(&ni->ni_savedq); 
    364                                 IEEE80211_NODE_SAVEQ_UNLOCK(ni); 
     364                                IEEE80211_NODE_SAVEQ_UNLOCK_BH(ni); 
    365365                                if (skb == NULL) 
    366366                                        break; 
    367367                                ieee80211_parent_queue_xmit(skb); 
  • net80211/ieee80211_proto.c

    old new  
    633633{ 
    634634        struct ieee80211com *ic = vap->iv_ic; 
    635635 
    636         IEEE80211_LOCK(ic); 
     636        IEEE80211_LOCK_IRQ(ic); 
    637637        ieee80211_wme_initparams_locked(vap); 
    638         IEEE80211_UNLOCK(ic); 
     638        IEEE80211_UNLOCK_IRQ(ic); 
    639639} 
    640640 
    641641void 
     
    918918        struct ieee80211com *ic = vap->iv_ic; 
    919919 
    920920        if (ic->ic_caps & IEEE80211_C_WME) { 
    921                 IEEE80211_LOCK(ic); 
     921                IEEE80211_LOCK_IRQ(ic); 
    922922                ieee80211_wme_updateparams_locked(vap); 
    923                 IEEE80211_UNLOCK(ic); 
     923                IEEE80211_UNLOCK_IRQ(ic); 
    924924        } 
    925925} 
    926926 
  • net80211/ieee80211_linux.h

    old new  
    8080} while (0) 
    8181#define IEEE80211_UNLOCK_IRQ_EARLY(_ic)                                 \ 
    8282        spin_unlock_irqrestore(&(_ic)->ic_comlock, __ilockflags); 
    83 #define IEEE80211_LOCK_BH(_ic)  spin_lock_bh(&(_ic)->ic_comlock) 
    84 #define IEEE80211_UNLOCK_BH(_ic) spin_unlock_bh(&(_ic)->ic_comlock) 
    85 #define IEEE80211_LOCK(_ic)     spin_lock(&(_ic)->ic_comlock) 
    86 #define IEEE80211_UNLOCK(_ic)   spin_unlock(&(_ic)->ic_comlock) 
    8783 
    8884/* NB: beware, spin_is_locked() is unusable for !SMP */ 
    8985#if defined(CONFIG_SMP) 
     
    9692#define IEEE80211_VAPS_LOCK_INIT(_ic, _name)            \ 
    9793        spin_lock_init(&(_ic)->ic_vapslock) 
    9894#define IEEE80211_VAPS_LOCK_DESTROY(_ic) 
    99 #define IEEE80211_VAPS_LOCK(_ic)        spin_lock(&(_ic)->ic_vapslock); 
    100 #define IEEE80211_VAPS_UNLOCK(_ic)      spin_unlock(&(_ic)->ic_vapslock); 
    10195#define IEEE80211_VAPS_LOCK_BH(_ic)     spin_lock_bh(&(_ic)->ic_vapslock); 
    10296#define IEEE80211_VAPS_UNLOCK_BH(_ic)   spin_unlock_bh(&(_ic)->ic_vapslock); 
    103 #define IEEE80211_VAPS_LOCK_IRQ(_ic)    do {    \ 
    104         int _vaps_lockflags;                    \ 
    105         spin_lock_irqsave(&(_ic)->ic_vapslock, _vaps_lockflags); 
    106 #define IEEE80211_VAPS_UNLOCK_IRQ(_ic)  \ 
    107         spin_unlock_irqrestore(&(_ic)->ic_vapslock, _vaps_lockflags); \ 
    108 } while (0) 
    109 #define IEEE80211_VAPS_UNLOCK_IRQ_EARLY(_ic)    spin_unlock_irqrestore(&(_ic)->ic_vapslock, _vaps_lockflags) 
    11097 
    111  
    11298/* NB: beware, spin_is_locked() is unusable for !SMP */ 
    11399#if defined(CONFIG_SMP) 
    114100#define IEEE80211_VAPS_LOCK_ASSERT(_ic) \ 
     
    124110typedef spinlock_t ieee80211_node_lock_t; 
    125111#define IEEE80211_NODE_LOCK_INIT(_nt, _name)    spin_lock_init(&(_nt)->nt_nodelock) 
    126112#define IEEE80211_NODE_LOCK_DESTROY(_nt) 
    127 #define IEEE80211_NODE_LOCK(_nt)        spin_lock(&(_nt)->nt_nodelock) 
    128 #define IEEE80211_NODE_UNLOCK(_nt)      spin_unlock(&(_nt)->nt_nodelock) 
    129 #define IEEE80211_NODE_LOCK_BH(_nt)     spin_lock_bh(&(_nt)->nt_nodelock) 
    130 #define IEEE80211_NODE_UNLOCK_BH(_nt)   spin_unlock_bh(&(_nt)->nt_nodelock) 
    131113#define IEEE80211_NODE_LOCK_IRQ(_nt)    do {    \ 
    132114        unsigned long __node_lockflags;         \ 
    133115        spin_lock_irqsave(&(_nt)->nt_nodelock, __node_lockflags); 
     
    152134typedef spinlock_t ieee80211_scan_lock_t; 
    153135#define IEEE80211_SCAN_LOCK_INIT(_nt, _name) spin_lock_init(&(_nt)->nt_scanlock) 
    154136#define IEEE80211_SCAN_LOCK_DESTROY(_nt) 
    155 #define IEEE80211_SCAN_LOCK_BH(_nt)     spin_lock_bh(&(_nt)->nt_scanlock) 
    156 #define IEEE80211_SCAN_UNLOCK_BH(_nt)   spin_unlock_bh(&(_nt)->nt_scanlock) 
    157137#define IEEE80211_SCAN_LOCK_IRQ(_nt)    do {    \ 
    158138        unsigned long __scan_lockflags;         \ 
    159139        spin_lock_irqsave(&(_nt)->nt_scanlock, __scan_lockflags); 
     
    179159#define ACL_LOCK_DESTROY(_as) 
    180160#define ACL_LOCK(_as)                   spin_lock(&(_as)->as_lock) 
    181161#define ACL_UNLOCK(_as)                 spin_unlock(&(_as)->as_lock) 
    182 #define ACL_LOCK_BH(_as)                spin_lock_bh(&(_as)->as_lock) 
    183 #define ACL_UNLOCK_BH(_as)              spin_unlock_bh(&(_as)->as_lock) 
    184162 
    185163/* NB: beware, spin_is_locked() is unusable for !SMP */ 
    186164#if defined(CONFIG_SMP) 
     
    203181        skb_queue_head_init(&(_ni)->ni_savedq);                 \ 
    204182} while (0) 
    205183#define IEEE80211_NODE_SAVEQ_DESTROY(_ni) 
    206 #define IEEE80211_NODE_SAVEQ_QLEN(_ni)  skb_queue_len(&(_ni)->ni_savedq) 
    207 #define IEEE80211_NODE_SAVEQ_LOCK(_ni)                          \ 
    208         spin_lock(&(_ni)->ni_savedq.lock) 
    209 #define IEEE80211_NODE_SAVEQ_UNLOCK(_ni)                        \ 
    210         spin_unlock(&(_ni)->ni_savedq.lock) 
    211 #define IEEE80211_NODE_SAVEQ_LOCK_IRQ(_ni) do {                 \ 
    212         unsigned long __sqlockflags;                            \ 
    213         spin_lock_irqsave(&(_ni)->ni_savedq.lock, __sqlockflags); 
    214 #define IEEE80211_NODE_SAVEQ_UNLOCK_IRQ(_ni)                    \ 
    215         spin_unlock_irqrestore(&(_ni)->ni_savedq.lock, __sqlockflags);\ 
    216 } while (0) 
     184#define IEEE80211_NODE_SAVEQ_QLEN(_ni)          skb_queue_len(&(_ni)->ni_savedq) 
     185#define IEEE80211_NODE_SAVEQ_LOCK_BH(_ni)       spin_lock_bh(&(_ni)->ni_savedq); 
     186#define IEEE80211_NODE_SAVEQ_UNLOCK_BH(_ni)     spin_unlock_bh(&(_ni)->ni_savedq); 
    217187 
    218188/* caller MUST lock IEEE80211_NODE_SAVEQ */ 
    219189#define IEEE80211_NODE_SAVEQ_DEQUEUE(_ni, _skb, _qlen) do {     \