Ticket #1096: simplify_ni_rxfrag_2.diff

File simplify_ni_rxfrag_2.diff, 7.0 kB (added by Mark Glines <mark@glines.org>, 5 years ago)

Same diff, refreshed to svn r2059. Signed-off-by: Mark Glines <mark@glines.org>

  • net80211/ieee80211_node.c

    old new  
    759759static void 
    760760node_cleanup(struct ieee80211_node *ni) 
    761761{ 
    762 #define N(a)    (sizeof(a)/sizeof(a[0])) 
    763762        struct ieee80211vap *vap = ni->ni_vap; 
    764         int i; 
    765763 
    766764        /* NB: preserve ni_table */ 
    767765        if (ni->ni_flags & IEEE80211_NODE_PWR_MGT) { 
     
    810808         * 
    811809         * XXX does this leave us open to inheriting old state? 
    812810         */ 
    813         for (i = 0; i < N(ni->ni_rxfrag); i++) 
    814                if (ni->ni_rxfrag[i] != NULL) { 
    815                        dev_kfree_skb_any(ni->ni_rxfrag[i]); 
    816                        ni->ni_rxfrag[i] = NULL; 
    817                
     811     
     812        if (ni->ni_rxfrag != NULL) { 
     813                dev_kfree_skb_any(ni->ni_rxfrag); 
     814                ni->ni_rxfrag = NULL; 
     815       
    818816        ieee80211_crypto_delkey(vap, &ni->ni_ucastkey, ni); 
    819817        ni->ni_rxkeyoff = 0; 
    820 #undef N 
    821818} 
    822819 
    823820static void 
     
    859856        struct ieee80211com *ic = nt->nt_ic; 
    860857        struct ieee80211_node *ni; 
    861858        int hash; 
    862         int i; 
    863859 
    864860        ni = ic->ic_node_alloc(nt, vap); 
    865861        if (ni == NULL) { 
     
    892888        ni->ni_table = nt; 
    893889        TAILQ_INSERT_TAIL(&nt->nt_node, ni, ni_list); 
    894890        LIST_INSERT_HEAD(&nt->nt_hash[hash], ni, ni_hash); 
    895 #define N(a)    (sizeof(a)/sizeof(a[0])) 
    896         for (i = 0; i < N(ni->ni_rxfrag); i++) 
    897                 ni->ni_rxfrag[i] = NULL; 
    898 #undef N 
     891        ni->ni_rxfrag = NULL; 
    899892        ni->ni_challenge = NULL; 
    900893        IEEE80211_NODE_UNLOCK_IRQ(nt); 
    901894 
     
    10191012{ 
    10201013        struct ieee80211com *ic = vap->iv_ic; 
    10211014        struct ieee80211_node *ni; 
    1022         int i; 
    10231015 
    10241016        ni = ic->ic_node_alloc(&ic->ic_sta,vap); 
    10251017        if (ni != NULL) { 
     
    10411033 
    10421034                ni->ni_table = NULL;            /* NB: pedantic */ 
    10431035                ni->ni_ic = ic; 
    1044 #define N(a)    (sizeof(a)/sizeof(a[0])) 
    1045                 for (i = 0; i < N(ni->ni_rxfrag); i++) 
    1046                         ni->ni_rxfrag[i] = NULL; 
    1047 #undef N 
     1036                ni->ni_rxfrag = NULL; 
    10481037                ni->ni_challenge = NULL; 
    10491038        } else { 
    10501039                /* XXX msg */ 
     
    10611050{ 
    10621051        struct ieee80211com *ic = vap->iv_ic; 
    10631052        struct ieee80211_node *ni; 
    1064         int i; 
    10651053 
    10661054        ni = ieee80211_alloc_node(&ic->ic_sta, vap, macaddr); 
    10671055        if (ni != NULL) { 
     
    10741062                IEEE80211_ADDR_COPY(ni->ni_bssid, vap->iv_bss->ni_bssid); 
    10751063                ieee80211_node_set_chan(ic, ni); 
    10761064                ni->ni_rsn = vap->iv_bss->ni_rsn; 
    1077 #define N(a)    (sizeof(a)/sizeof(a[0])) 
    1078                 for (i = 0; i < N(ni->ni_rxfrag); i++) 
    1079                         ni->ni_rxfrag[i] = NULL; 
    1080 #undef N 
     1065                ni->ni_rxfrag = NULL; 
    10811066        } 
    10821067        return ni; 
    10831068} 
     
    15621547                 * (last fragment older than 1s). 
    15631548                 * XXX doesn't belong here 
    15641549                 */ 
    1565                 if (ni->ni_rxfrag[0] != NULL && 
     1550                if (ni->ni_rxfrag != NULL && 
    15661551                    jiffies > ni->ni_rxfragstamp + HZ) { 
    1567                         dev_kfree_skb(ni->ni_rxfrag[0]); 
    1568                         ni->ni_rxfrag[0] = NULL; 
     1552                        dev_kfree_skb(ni->ni_rxfrag); 
     1553                        ni->ni_rxfrag = NULL; 
    15691554                } 
    15701555                /* 
    15711556                 * Special case ourself; we may be idle for extended periods 
  • net80211/ieee80211_node.h

    old new  
    129129        u_int16_t ni_txseqs[17];                        /* tx seq per-tid */ 
    130130        u_int16_t ni_rxseqs[17];                        /* rx seq previous per-tid*/ 
    131131        u_int32_t ni_rxfragstamp;               /* time stamp of last rx frag */ 
    132         struct sk_buff *ni_rxfrag[3];         /* rx frag reassembly */ 
     132        struct sk_buff *ni_rxfrag;            /* rx frag reassembly */ 
    133133        struct ieee80211_rsnparms ni_rsn;       /* RSN/WPA parameters */ 
    134134        struct ieee80211_key ni_ucastkey;       /* unicast key */ 
    135135        int ni_rxkeyoff;                        /* Receive key offset */ 
  • net80211/ieee80211_input.c

    old new  
    959959        fragno = le16_to_cpu(*(__le16 *)wh->i_seq) & IEEE80211_SEQ_FRAG_MASK; 
    960960 
    961961        /* Quick way out, if there's nothing to defragment */ 
    962         if (!more_frag && fragno == 0 && ni->ni_rxfrag[0] == NULL) 
     962        if (!more_frag && fragno == 0 && ni->ni_rxfrag == NULL) 
    963963                return skb; 
    964964 
    965965        /* 
     
    980980        } 
    981981 
    982982        /* 
    983          * Use this lock to make sure ni->ni_rxfrag[0] is 
     983         * Use this lock to make sure ni->ni_rxfrag is 
    984984         * not freed by the timer process while we use it. 
    985985         * XXX bogus 
    986986         */ 
     
    989989        /* 
    990990         * Update the time stamp.  As a side effect, it 
    991991         * also makes sure that the timer will not change 
    992          * ni->ni_rxfrag[0] for at least 1 second, or in 
     992         * ni->ni_rxfrag for at least 1 second, or in 
    993993         * other words, for the remaining of this function. 
    994994         */ 
    995995        ni->ni_rxfragstamp = jiffies; 
     
    10001000         * Validate that fragment is in order and 
    10011001         * related to the previous ones. 
    10021002         */ 
    1003         if (ni->ni_rxfrag[0]) { 
     1003        if (ni->ni_rxfrag) { 
    10041004                struct ieee80211_frame *lwh; 
    10051005 
    1006                 lwh = (struct ieee80211_frame *) ni->ni_rxfrag[0]->data; 
     1006                lwh = (struct ieee80211_frame *) ni->ni_rxfrag->data; 
    10071007                last_rxseq = le16_to_cpu(*(__le16 *)lwh->i_seq) >> 
    10081008                        IEEE80211_SEQ_SEQ_SHIFT; 
    10091009                last_fragno = le16_to_cpu(*(__le16 *)lwh->i_seq) & 
     
    10121012                    || fragno != last_fragno + 1 
    10131013                    || (!IEEE80211_ADDR_EQ(wh->i_addr1, lwh->i_addr1)) 
    10141014                    || (!IEEE80211_ADDR_EQ(wh->i_addr2, lwh->i_addr2)) 
    1015                     || (ni->ni_rxfrag[0]->end - ni->ni_rxfrag[0]->tail < 
     1015                    || (ni->ni_rxfrag->end - ni->ni_rxfrag->tail < 
    10161016                        skb->len)) { 
    10171017                        /* 
    10181018                         * Unrelated fragment or no space for it, 
    10191019                         * clear current fragments 
    10201020                         */ 
    1021                         dev_kfree_skb(ni->ni_rxfrag[0]); 
    1022                         ni->ni_rxfrag[0] = NULL; 
     1021                        dev_kfree_skb(ni->ni_rxfrag); 
     1022                        ni->ni_rxfrag = NULL; 
    10231023                } 
    10241024        } 
    10251025 
    10261026        /* If this is the first fragment */ 
    1027         if (ni->ni_rxfrag[0] == NULL && fragno == 0) { 
    1028                 ni->ni_rxfrag[0] = skb; 
     1027        if (ni->ni_rxfrag == NULL && fragno == 0) { 
     1028                ni->ni_rxfrag = skb; 
    10291029                /* If more frags are coming */ 
    10301030                if (more_frag) { 
    10311031                        if (skb_is_nonlinear(skb)) { 
     
    10331033                                 * We need a continous buffer to 
    10341034                                 * assemble fragments 
    10351035                                 */ 
    1036                                 ni->ni_rxfrag[0] = skb_copy(skb, GFP_ATOMIC); 
     1036                                ni->ni_rxfrag = skb_copy(skb, GFP_ATOMIC); 
    10371037                                dev_kfree_skb(skb); 
    10381038                        } 
    10391039                        /* 
     
    10431043                         */ 
    10441044                        else if (skb->end - skb->head < ni->ni_vap->iv_dev->mtu + 
    10451045                                 hdrlen) { 
    1046                                 ni->ni_rxfrag[0] = skb_copy_expand(skb, 0, 
     1046                                ni->ni_rxfrag = skb_copy_expand(skb, 0, 
    10471047                                        (ni->ni_vap->iv_dev->mtu + hdrlen) - 
    10481048                                        (skb->end - skb->head), GFP_ATOMIC); 
    10491049                                dev_kfree_skb(skb); 
    10501050                        } 
    10511051                } 
    10521052        } else { 
    1053                 if (ni->ni_rxfrag[0]) { 
     1053                if (ni->ni_rxfrag) { 
    10541054                        struct ieee80211_frame *lwh = (struct ieee80211_frame *) 
    1055                                 ni->ni_rxfrag[0]->data; 
     1055                                ni->ni_rxfrag->data; 
    10561056 
    10571057                        /* 
    10581058                         * We know we have enough space to copy, 
    10591059                         * we've verified that before 
    10601060                         */ 
    10611061                        /* Copy current fragment at end of previous one */ 
    1062                         memcpy(ni->ni_rxfrag[0]->tail, 
     1062                        memcpy(ni->ni_rxfrag->tail, 
    10631063                               skb->data + hdrlen, skb->len - hdrlen); 
    10641064                        /* Update tail and length */ 
    1065                         skb_put(ni->ni_rxfrag[0], skb->len - hdrlen); 
     1065                        skb_put(ni->ni_rxfrag, skb->len - hdrlen); 
    10661066                        /* Keep a copy of last sequence and fragno */ 
    10671067                        *(__le16 *) lwh->i_seq = *(__le16 *) wh->i_seq; 
    10681068                } 
     
    10751075                skb = NULL; 
    10761076        } else { 
    10771077                /* Last fragment received, we're done! */ 
    1078                 skb = ni->ni_rxfrag[0]
    1079                 ni->ni_rxfrag[0] = NULL; 
     1078                skb = ni->ni_rxfrag
     1079                ni->ni_rxfrag = NULL; 
    10801080        } 
    10811081        return skb; 
    10821082}