Changeset 2357
- Timestamp:
- 05/21/07 17:53:39 (2 years ago)
- Files:
-
- trunk/ath/if_ath.c (modified) (23 diffs)
- trunk/ath_rate/minstrel/minstrel.c (modified) (11 diffs)
- trunk/ath_rate/sample/sample.c (modified) (2 diffs)
- trunk/net80211/ieee80211_debug.h (copied) (copied from branches/madwifi-ng-refcount/net80211/ieee80211_debug.h)
- trunk/net80211/ieee80211_input.c (modified) (27 diffs)
- trunk/net80211/ieee80211_linux.c (modified) (2 diffs)
- trunk/net80211/ieee80211_linux.h (modified) (9 diffs)
- trunk/net80211/ieee80211_node.c (modified) (55 diffs)
- trunk/net80211/ieee80211_node.h (modified) (12 diffs)
- trunk/net80211/ieee80211_output.c (modified) (11 diffs)
- trunk/net80211/ieee80211_power.c (modified) (3 diffs)
- trunk/net80211/ieee80211_proto.c (modified) (1 diff)
- trunk/net80211/ieee80211_scan.h (modified) (1 diff)
- trunk/net80211/ieee80211_scan_sta.c (modified) (1 diff)
- trunk/net80211/ieee80211_var.h (modified) (21 diffs)
- trunk/net80211/ieee80211_wireless.c (modified) (10 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/ath/if_ath.c
r2344 r2357 162 162 static void ath_desc_free(struct ath_softc *); 163 163 static void ath_desc_swap(struct ath_desc *); 164 static struct ieee80211_node *ath_node_alloc(struct ieee80211_node_table *, 165 struct ieee80211vap *); 164 static struct ieee80211_node *ath_node_alloc(struct ieee80211vap *); 166 165 static void ath_node_cleanup(struct ieee80211_node *); 167 166 static void ath_node_free(struct ieee80211_node *); … … 2442 2441 continue; 2443 2442 bad: 2444 ieee80211_ free_node(ni);2443 ieee80211_unref_node(&ni); 2445 2444 if (bf_ff->bf_skb != NULL) { 2446 2445 dev_kfree_skb(bf_ff->bf_skb); … … 2582 2581 ATH_FF_MAGIC_PUT(skb); 2583 2582 2583 #if 0 2584 2584 /* decrement extra node reference made when an_tx_ffbuf[] was set */ 2585 //ieee80211_free_node(ni); /* XXX where was it set ? */ 2585 ieee80211_unref_node(&ni); /* XXX where was it set ? */ 2586 #endif 2586 2587 2587 2588 DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF, … … 2642 2643 DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF, 2643 2644 "%s: ff stageq flush failure\n", __func__); 2644 ieee80211_ free_node(ni);2645 ieee80211_unref_node(&ni); 2645 2646 if (bf_ff->bf_skb) { 2646 2647 dev_kfree_skb(bf_ff->bf_skb); … … 2764 2765 2765 2766 if (ni != NULL) 2766 ieee80211_ free_node(ni);2767 ieee80211_unref_node(&ni); 2767 2768 2768 2769 STAILQ_INSERT_TAIL(&sc->sc_txbuf, tbf, bf_list); … … 2846 2847 bad: 2847 2848 if (ni != NULL) 2848 ieee80211_ free_node(ni);2849 ieee80211_unref_node(&ni); 2849 2850 if (bf != NULL) { 2850 2851 bf->bf_skb = NULL; … … 3235 3236 ni = sc->sc_keyixmap[keyix]; 3236 3237 if (ni != NULL) { 3237 ieee80211_ free_node(ni);3238 ieee80211_unref_node(&ni); 3238 3239 sc->sc_keyixmap[keyix] = NULL; 3239 3240 } … … 3246 3247 ni = sc->sc_keyixmap[keyix + 32]; 3247 3248 if (ni != NULL) { /* as above... */ 3248 ieee80211_ free_node(ni);3249 ieee80211_unref_node(&ni); 3249 3250 sc->sc_keyixmap[keyix + 32] = NULL; 3250 3251 } … … 3259 3260 ni = sc->sc_keyixmap[keyix + rxkeyoff]; 3260 3261 if (ni != NULL) { /* as above... */ 3261 ieee80211_ free_node(ni);3262 ieee80211_unref_node(&ni); 3262 3263 sc->sc_keyixmap[keyix + rxkeyoff] = NULL; 3263 3264 } … … 3815 3816 bf->bf_skb = NULL; 3816 3817 } 3817 if (bf->bf_node != NULL) { 3818 ieee80211_free_node(bf->bf_node); 3819 bf->bf_node = NULL; 3820 } 3818 if (bf->bf_node != NULL) 3819 ieee80211_unref_node(&bf->bf_node); 3821 3820 3822 3821 /* … … 4360 4359 bf->bf_skb = NULL; 4361 4360 } 4362 if (bf->bf_node != NULL) { 4363 ieee80211_free_node(bf->bf_node); 4364 bf->bf_node = NULL; 4365 } 4361 if (bf->bf_node != NULL) 4362 ieee80211_unref_node(&bf->bf_node); 4366 4363 STAILQ_INSERT_TAIL(&sc->sc_bbuf, bf, bf_list); 4367 4364 } … … 4382 4379 bf->bf_skb = NULL; 4383 4380 } 4384 if (bf->bf_node != NULL) { 4385 ieee80211_free_node(bf->bf_node); 4386 bf->bf_node = NULL; 4387 } 4381 if (bf->bf_node != NULL) 4382 ieee80211_unref_node(&bf->bf_node); 4388 4383 } 4389 4384 } … … 4671 4666 * Reclaim node reference. 4672 4667 */ 4673 ieee80211_ free_node(ni);4668 ieee80211_unref_node(&ni); 4674 4669 } 4675 4670 } … … 4730 4725 4731 4726 static struct ieee80211_node * 4732 ath_node_alloc(struct ieee80211 _node_table *nt,struct ieee80211vap *vap)4733 { 4734 struct ath_softc *sc = nt->nt_ic->ic_dev->priv;4727 ath_node_alloc(struct ieee80211vap *vap) 4728 { 4729 struct ath_softc *sc = vap->iv_ic->ic_dev->priv; 4735 4730 const size_t space = sizeof(struct ath_node) + sc->sc_rc->arc_space; 4736 4731 struct ath_node *an; 4737 4732 4738 4733 an = kmalloc(space, GFP_ATOMIC); 4739 if (an == NULL) 4734 if (an != NULL) { 4735 memset(an, 0, space); 4736 an->an_decomp_index = INVALID_DECOMP_INDEX; 4737 an->an_avgrssi = ATH_RSSI_DUMMY_MARKER; 4738 an->an_halstats.ns_avgbrssi = ATH_RSSI_DUMMY_MARKER; 4739 an->an_halstats.ns_avgrssi = ATH_RSSI_DUMMY_MARKER; 4740 an->an_halstats.ns_avgtxrssi = ATH_RSSI_DUMMY_MARKER; 4741 /* 4742 * ath_rate_node_init needs a vap pointer in node 4743 * to decide which mgt rate to use 4744 */ 4745 an->an_node.ni_vap = vap; 4746 sc->sc_rc->ops->node_init(sc, an); 4747 4748 /* U-APSD init */ 4749 STAILQ_INIT(&an->an_uapsd_q); 4750 an->an_uapsd_qdepth = 0; 4751 STAILQ_INIT(&an->an_uapsd_overflowq); 4752 an->an_uapsd_overflowqdepth = 0; 4753 ATH_NODE_UAPSD_LOCK_INIT(an); 4754 4755 DPRINTF(sc, ATH_DEBUG_NODE, "%s: an %p\n", __func__, an); 4756 return &an->an_node; 4757 } else { 4740 4758 return NULL; 4741 memset(an, 0, space); 4742 an->an_decomp_index = INVALID_DECOMP_INDEX; 4743 an->an_avgrssi = ATH_RSSI_DUMMY_MARKER; 4744 an->an_halstats.ns_avgbrssi = ATH_RSSI_DUMMY_MARKER; 4745 an->an_halstats.ns_avgrssi = ATH_RSSI_DUMMY_MARKER; 4746 an->an_halstats.ns_avgtxrssi = ATH_RSSI_DUMMY_MARKER; 4747 /* 4748 * ath_rate_node_init needs a VAP pointer in node 4749 * to decide which mgt rate to use 4750 */ 4751 an->an_node.ni_vap = vap; 4752 sc->sc_rc->ops->node_init(sc, an); 4753 4754 /* U-APSD init */ 4755 STAILQ_INIT(&an->an_uapsd_q); 4756 an->an_uapsd_qdepth = 0; 4757 STAILQ_INIT(&an->an_uapsd_overflowq); 4758 an->an_uapsd_overflowqdepth = 0; 4759 ATH_NODE_UAPSD_LOCK_INIT(an); 4760 4761 DPRINTF(sc, ATH_DEBUG_NODE, "%s: an %p\n", __func__, an); 4762 return &an->an_node; 4759 } 4763 4760 } 4764 4761 … … 4770 4767 struct ath_node *an = ATH_NODE(ni); 4771 4768 struct ath_buf *bf; 4769 struct ieee80211_cb *cb = NULL; 4772 4770 4773 4771 /* … … 4784 4782 bf = STAILQ_FIRST(&an->an_uapsd_q); 4785 4783 STAILQ_REMOVE_HEAD(&an->an_uapsd_q, bf_list); 4784 4785 cb = (struct ieee80211_cb *) bf->bf_skb->cb; 4786 ieee80211_unref_node(&cb->ni); 4787 dev_kfree_skb_any(bf->bf_skb); 4788 4786 4789 bf->bf_desc->ds_link = 0; 4787 4788 dev_kfree_skb_any(bf->bf_skb);4789 4790 bf->bf_skb = NULL; 4790 4791 bf->bf_node = NULL; 4792 4791 4793 ATH_TXBUF_LOCK_IRQ(sc); 4792 4794 STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list); 4793 4795 ATH_TXBUF_UNLOCK_IRQ(sc); 4794 ieee80211_free_node(ni);4795 4796 4796 4797 an->an_uapsd_qdepth--; … … 4800 4801 bf = STAILQ_FIRST(&an->an_uapsd_overflowq); 4801 4802 STAILQ_REMOVE_HEAD(&an->an_uapsd_overflowq, bf_list); 4802 bf->bf_desc->ds_link = 0; 4803 4803 4804 cb = (struct ieee80211_cb *) bf->bf_skb->cb; 4805 ieee80211_unref_node(&cb->ni); 4804 4806 dev_kfree_skb_any(bf->bf_skb); 4807 4805 4808 bf->bf_skb = NULL; 4806 4809 bf->bf_node = NULL; 4810 bf->bf_desc->ds_link = 0; 4811 4807 4812 ATH_TXBUF_LOCK_IRQ(sc); 4808 4813 STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list); 4809 4814 ATH_TXBUF_UNLOCK_IRQ(sc); 4810 ieee80211_free_node(ni);4811 4815 4812 4816 an->an_uapsd_overflowqdepth--; 4813 4817 } 4818 4819 /* Clean up node-specific rate things - this currently appears to always be a no-op */ 4820 sc->sc_rc->ops->node_cleanup(sc, ATH_NODE(ni)); 4814 4821 4815 4822 ATH_NODE_UAPSD_LOCK_IRQ(an); … … 4823 4830 struct ath_softc *sc = ni->ni_ic->ic_dev->priv; 4824 4831 4825 sc->sc_rc->ops->node_cleanup(sc, ATH_NODE(ni));4826 4832 sc->sc_node_free(ni); 4827 4833 #ifdef ATH_SUPERG_XR … … 5704 5710 type = ieee80211_input(ni, skb, 5705 5711 ds->ds_rxstat.rs_rssi, ds->ds_rxstat.rs_tstamp); 5706 ieee80211_ free_node(ni);5712 ieee80211_unref_node(&ni); 5707 5713 } else { 5708 5714 /* … … 5729 5735 sc->sc_keyixmap[keyix] == NULL) 5730 5736 sc->sc_keyixmap[keyix] = ieee80211_ref_node(ni); 5731 ieee80211_ free_node(ni);5737 ieee80211_unref_node(&ni); 5732 5738 } else 5733 5739 type = ieee80211_input_all(ic, skb, … … 6530 6536 dev_kfree_skb(lastbuf->bf_skb); 6531 6537 lastbuf->bf_skb = NULL; 6532 ieee80211_free_node(lastbuf->bf_node); 6533 lastbuf->bf_node = NULL; 6538 ieee80211_unref_node(&lastbuf->bf_node); 6534 6539 ATH_TXBUF_LOCK_IRQ(sc); 6535 6540 STAILQ_INSERT_TAIL(&sc->sc_txbuf, lastbuf, bf_list); … … 7280 7285 * node was timed out due to inactivity. 7281 7286 */ 7282 ieee80211_ free_node(ni);7287 ieee80211_unref_node(&ni); 7283 7288 } 7284 7289 … … 7525 7530 #endif /* ATH_SUPERG_FF */ 7526 7531 if (bf->bf_node) 7527 ieee80211_ free_node(bf->bf_node);7532 ieee80211_unref_node(&bf->bf_node); 7528 7533 7529 7534 bf->bf_skb = NULL; trunk/ath_rate/minstrel/minstrel.c
r2349 r2357 343 343 344 344 /* Don't look for slowest rate (i.e. slowest 345 * base rate) We must presume that the slowest345 * base rate). We must presume that the slowest 346 346 * rate works fine, or else other management 347 347 * frames will also be failing - therefore the … … 350 350 * link in the first place. */ 351 351 ndx = sn->rs_sampleTable[sn->rs_sampleIndex][sn->rs_sampleColumn]; 352 if (ndx >= sn->num_rates) 353 ndx = 1; 352 354 353 sn->rs_sampleIndex++; 355 354 if (sn->rs_sampleIndex > (sn->num_rates - 2)) { 356 355 sn->rs_sampleIndex = 0; 356 357 357 sn->rs_sampleColumn++; 358 if (sn->rs_sampleColumn == MINSTREL_COLUMNS)358 if (sn->rs_sampleColumn >= MINSTREL_COLUMNS) 359 359 sn->rs_sampleColumn = 0; 360 360 } … … 479 479 480 480 if (!mrr) { 481 if ( ndx >= 0 && ndx < sn->num_rates) {481 if ((0 <= ndx) && (ndx < sn->num_rates)) { 482 482 sn->rs_rateattempts[ndx]++; /* only one rate was used */ 483 483 } … … 540 540 ath_fill_sample_table(struct minstrel_node *sn) 541 541 { 542 unsigned int num_sample_rates = sn->num_rates; 543 unsigned int i, column_index; 544 int newIndex; 545 u_int8_t random_bytes[12]; 546 547 for(column_index = 0; column_index < MINSTREL_COLUMNS; column_index++) { 548 for (i = 0; i <= IEEE80211_RATE_MAXSIZE; i++) 549 sn->rs_sampleTable[i][column_index] = 0; 550 551 for (i = 0; i < num_sample_rates; i++) { 552 get_random_bytes(random_bytes, 8); 553 newIndex = (i + (int)(random_bytes[i & 7])) % num_sample_rates; 554 if (newIndex < 0) 555 newIndex = 2; 556 557 while (sn->rs_sampleTable[newIndex][column_index] != 0) { 558 newIndex = ((int)(newIndex + 1)) % num_sample_rates; 559 if (newIndex < 0) 560 newIndex = 2; 561 } 562 563 sn->rs_sampleTable[newIndex][column_index] = i + 1; 564 } 565 } 542 unsigned int num_sample_rates = (sn->num_rates - 1); 543 /* newIndex varies as 0 .. (num_rates - 2) 544 * The highest index rate is the slowest and is ignored */ 545 unsigned int i, column_index, newIndex; 546 u_int8_t random_bytes[8]; 547 548 /* This should be unnecessary if we are assuming storage is provided 549 * as zeroed */ 550 memset(sn->rs_sampleTable, 0, sizeof(sn->rs_sampleTable)); 566 551 567 552 sn->rs_sampleColumn = 0; 568 553 sn->rs_sampleIndex = 0; 569 554 570 /* Seed value to random number geenrator, which determines when we 571 * send a sample packet at some non-optimal rate */ 555 /* Seed value to random number generator, which determines when we 556 * send a sample packet at some non-optimal rate 557 * FIXME: randomise? */ 572 558 sn->random_n = 1; 573 559 sn->a = 1664525; 574 560 sn->b = 1013904223; 561 562 if (sn->num_rates > 1) { 563 for(column_index = 0; column_index < MINSTREL_COLUMNS; column_index++) { 564 for (i = 0; i < num_sample_rates; i++) { 565 get_random_bytes(random_bytes, 8); 566 newIndex = (i + random_bytes[i & 7]) % num_sample_rates; 567 568 while (sn->rs_sampleTable[newIndex][column_index] != 0) 569 newIndex = (newIndex + 1) % num_sample_rates; 570 571 sn->rs_sampleTable[newIndex][column_index] = i + 1; 572 } 573 } 574 } 575 575 576 #if 0 576 577 char rates[200]; … … 579 580 p = rates + sprintf(rates, "rates :: %d ", column_index); 580 581 for (i = 0; i < num_sample_rates; i++) 581 p += sprintf(p, "%2d ", (int)sn->rs_sampleTable[i][column_index]) 582 ; 582 p += sprintf(p, "%2u ", sn->rs_sampleTable[i][column_index]); 583 583 DPRINTF(sc, "%s\n", rates); 584 584 }; … … 641 641 642 642 ni->ni_txrate = 0; 643 sn->num_rates = ni->ni_rates.rs_nrates;644 643 645 644 if (sn->num_rates <= 0) { … … 660 659 * rate set is checked when the station associates. */ 661 660 /* NB: the rate set is assumed sorted */ 662 for (; srate >= 0&& (ni->ni_rates.rs_rates[srate] & IEEE80211_RATE_VAL) != vap->iv_fixed_rate; srate--);661 for (; (srate >= 0) && (ni->ni_rates.rs_rates[srate] & IEEE80211_RATE_VAL) != vap->iv_fixed_rate; srate--); 663 662 664 663 KASSERT(srate >= 0, … … 670 669 dev_info, __func__, ether_sprintf(ni->ni_macaddr), 671 670 sn->rates[srate].rate / 2, 672 (sn->rates[srate].rate % 0x1) ? ".5" : " ");671 (sn->rates[srate].rate % 2) ? ".5 " : " "); 673 672 return; 674 673 } … … 692 691 for (retry_index = 2; retry_index < ATH_TXMAXTRY; retry_index++) { 693 692 tx_time = calc_usecs_unicast_packet(sc, 1200, sn->rates[x].rix, 0, retry_index); 694 if (tx_time > ath_segment_size)693 if (tx_time > ath_segment_size) 695 694 break; 696 695 sn->retry_count[x] = retry_index; … … 918 917 struct ath_softc *sc = vap->iv_ic->ic_dev->priv;; 919 918 919 IEEE80211_NODE_TABLE_LOCK_IRQ(nt); 920 920 TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 921 921 /* Assume each node needs 1500 bytes */ … … 966 966 p += sprintf(p, "Total packet count:: ideal %d lookaround %d\n\n", odst->packet_count, odst->sample_count); 967 967 } 968 IEEE80211_NODE_TABLE_UNLOCK_IRQ(nt); 968 969 969 970 return (p - buf); trunk/ath_rate/sample/sample.c
r2261 r2357 947 947 unsigned int size_bin; 948 948 949 IEEE80211_NODE_TABLE_LOCK_IRQ(nt); 949 950 TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 950 951 /* Assume each node needs 500 bytes */ … … 997 998 printk("\n"); 998 999 } 1000 IEEE80211_NODE_TABLE_UNLOCK_IRQ(nt); 999 1001 1000 1002 return (p - buf); trunk/net80211/ieee80211_input.c
r2350 r2357 490 490 ni_wds = ieee80211_find_wds_node(nt, wh->i_addr3); 491 491 if (ni_wds) { 492 ieee80211_ free_node(ni_wds); /* Decr ref count */492 ieee80211_unref_node(&ni_wds); /* Decr ref count */ 493 493 IEEE80211_DISCARD(vap, IEEE80211_MSG_INPUT, 494 494 wh, NULL, "%s", … … 544 544 * If not, add one. 545 545 */ 546 /* XXX: Useless node mgmt API; make better */ 546 547 if (dir == IEEE80211_FC1_DIR_DSTODS) { 547 548 struct ieee80211_node_table *nt; 548 549 struct ieee80211_frame_addr4 *wh4; 549 550 struct ieee80211_node *ni_wds; 551 550 552 if (!(vap->iv_flags_ext & IEEE80211_FEXT_WDS)) { 551 553 IEEE80211_DISCARD(vap, IEEE80211_MSG_INPUT, … … 570 572 ieee80211_add_wds_addr(nt, ni, wh4->i_addr4, 0); 571 573 else 572 ieee80211_ free_node(ni_wds); /* Decrref count */574 ieee80211_unref_node(&ni_wds); /* Decr. ref count */ 573 575 } 574 576 … … 937 939 ni = ieee80211_ref_node(vap->iv_bss); 938 940 type = ieee80211_input(ni, skb1, rssi, rstamp); 939 ieee80211_ free_node(ni);941 ieee80211_unref_node(&ni); 940 942 } 941 943 if (skb != NULL) /* no vaps, reclaim skb */ … … 987 989 988 990 /* 989 * Use this lock to make sure ni->ni_rxfrag is990 * not freed by the timer process while we use it.991 * XXX bogus992 */993 IEEE80211_NODE_LOCK_IRQ(ni->ni_table);994 995 /*996 991 * Update the time stamp. As a side effect, it 997 992 * also makes sure that the timer will not change 998 993 * ni->ni_rxfrag for at least 1 second, or in 999 994 * other words, for the remaining of this function. 995 * XXX HUGE HORRIFIC HACK 1000 996 */ 1001 997 ni->ni_rxfragstamp = jiffies; 1002 1003 IEEE80211_NODE_UNLOCK_IRQ(ni->ni_table);1004 998 1005 999 /* … … 1131 1125 } 1132 1126 /* XXX statistic? */ 1133 ieee80211_ free_node(ni1);1127 ieee80211_unref_node(&ni1); 1134 1128 } 1135 1129 } … … 1266 1260 { 1267 1261 struct ieee80211vap *vap = ni->ni_vap; 1262 unsigned int tmpnode = 0; 1268 1263 1269 1264 if (ni->ni_authmode == IEEE80211_AUTH_SHARED) { … … 1273 1268 vap->iv_stats.is_rx_bad_auth++; /* XXX maybe a unique error? */ 1274 1269 if (vap->iv_opmode == IEEE80211_M_HOSTAP) { 1275 /* XXX hack to workaround calling convention */1276 1277 /* XXX To send the frame to the requesting STA, we have to1278 * create a node for the station that we're going to reject.1279 * The node will be freed automatically */1280 1270 if (ni == vap->iv_bss) { 1281 ni = ieee80211_dup_bss(vap, wh->i_addr2 );1271 ni = ieee80211_dup_bss(vap, wh->i_addr2, 0); 1282 1272 if (ni == NULL) 1283 1273 return; … … 1286 1276 "%s: %p<%s> refcnt %d\n", __func__, ni, ether_sprintf(ni->ni_macaddr), 1287 1277 ieee80211_node_refcnt(ni)); 1278 tmpnode = 1; 1288 1279 } 1289 1280 IEEE80211_SEND_MGMT(ni, IEEE80211_FC0_SUBTYPE_AUTH, 1290 1281 (seq + 1) | (IEEE80211_STATUS_ALG << 16)); 1282 1283 if (tmpnode) 1284 ieee80211_unref_node(&ni); 1291 1285 return; 1292 1286 } … … 1316 1310 /* always accept open authentication requests */ 1317 1311 if (ni == vap->iv_bss) { 1318 ni = ieee80211_dup_bss(vap, wh->i_addr2 );1312 ni = ieee80211_dup_bss(vap, wh->i_addr2, 0); 1319 1313 if (ni == NULL) 1320 1314 return; … … 1323 1317 "%s: %p<%s> refcnt %d\n", __func__, ni, ether_sprintf(ni->ni_macaddr), 1324 1318 ieee80211_node_refcnt(ni)); 1325 1326 } else if ((ni->ni_flags & IEEE80211_NODE_AREF) == 0) 1327 (void) ieee80211_ref_node(ni); 1328 /* 1329 * Mark the node as referenced to reflect that it's 1330 * reference count has been bumped to ensure it remains 1331 * after the transaction completes. 1332 */ 1333 ni->ni_flags |= IEEE80211_NODE_AREF; 1334 1319 tmpnode = 1; 1320 } 1321 1335 1322 IEEE80211_SEND_MGMT(ni, IEEE80211_FC0_SUBTYPE_AUTH, seq + 1); 1336 1323 IEEE80211_NOTE(vap, IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH, … … 1342 1329 if (ni->ni_authmode != IEEE80211_AUTH_8021X) 1343 1330 ieee80211_node_authorize(ni); 1331 if (tmpnode) 1332 ieee80211_unref_node(&ni); 1344 1333 break; 1345 1334 … … 1380 1369 1381 1370 if (ni == vap->iv_bss) { 1382 ni = ieee80211_ tmp_node(vap, mac);1371 ni = ieee80211_dup_bss(vap, mac, 1); 1383 1372 if (ni == NULL) { 1384 1373 /* XXX msg */ … … 1390 1379 IEEE80211_SEND_MGMT(ni, subtype, arg); 1391 1380 if (istmp) 1392 ieee80211_ free_node(ni);1381 ieee80211_unref_node(&ni); 1393 1382 } 1394 1383 … … 1416 1405 struct ieee80211vap *vap = ni->ni_vap; 1417 1406 u_int8_t *challenge; 1418 int allocbs , estatus;1407 int allocbs = 0, estatus = 0; 1419 1408 1420 1409 /* … … 1426 1415 * for sanity/consistency. 1427 1416 */ 1428 estatus = 0; /* NB: silence compiler */1429 1417 if ((vap->iv_flags & IEEE80211_F_PRIVACY) == 0) { 1430 1418 IEEE80211_DISCARD_MAC(vap, IEEE80211_MSG_AUTH, … … 1506 1494 case IEEE80211_AUTH_SHARED_REQUEST: 1507 1495 if (ni == vap->iv_bss) { 1508 ni = ieee80211_dup_bss(vap, wh->i_addr2 );1496 ni = ieee80211_dup_bss(vap, wh->i_addr2, 0); 1509 1497 if (ni == NULL) { 1510 1498 /* NB: no way to return an error */ … … 1517 1505 1518 1506 allocbs = 1; 1519 } else { 1520 if ((ni->ni_flags & IEEE80211_NODE_AREF) == 0) 1521 (void) ieee80211_ref_node(ni); 1522 allocbs = 0; 1523 } 1524 /* 1525 * Mark the node as referenced to reflect that it's 1526 * reference count has been bumped to ensure it remains 1527 * after the transaction completes. 1528 */ 1529 ni->ni_flags |= IEEE80211_NODE_AREF; 1507 } 1508 1530 1509 ni->ni_rssi = rssi; 1531 1510 ni->ni_rstamp = rstamp; … … 1621 1600 return; 1622 1601 bad: 1623 /* 1624 * Send an error response; but only when operating as an AP. 1625 */ 1602 /* Send an error response; but only when operating as an AP. */ 1626 1603 if (vap->iv_opmode == IEEE80211_M_HOSTAP) { 1627 1604 /* XXX hack to workaround calling convention */ … … 1629 1606 IEEE80211_FC0_SUBTYPE_AUTH, 1630 1607 (seq + 1) | (estatus<<16)); 1608 ieee80211_node_leave(ni); 1631 1609 } else if (vap->iv_opmode == IEEE80211_M_STA) { 1632 1610 /* … … 2092 2070 if (len > 2) 2093 2071 rsn_parm->rsn_caps = LE_READ_2(frm); 2094 /* XXX PMKID */2072 /* XXX PMKID */ 2095 2073 2096 2074 return 0; … … 2601 2579 u_int8_t *ssid, *rates, *xrates, *wpa, *rsn, *wme, *ath; 2602 2580 u_int8_t rate; 2603 int reassoc, resp, allocbs ;2581 int reassoc, resp, allocbs = 0; 2604 2582 u_int8_t qosinfo; 2605 2583 … … 3009 2987 wh->i_addr2); 3010 2988 } else { 3011 ni = ieee80211_ tmp_node(vap, wh->i_addr2);2989 ni = ieee80211_dup_bss(vap, wh->i_addr2, 1); 3012 2990 } 3013 2991 if (ni == NULL) 3014 2992 return; 3015 2993 allocbs = 1; 3016 } else3017 allocbs = 0; 2994 } 2995 3018 2996 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_INPUT, wh->i_addr2, 3019 2997 "%s", "recv probe req"); … … 3038 3016 * response, reclaim immediately 3039 3017 */ 3040 ieee80211_ free_node(ni);3018 ieee80211_unref_node(&ni); 3041 3019 } else if (ath != NULL) 3042 3020 ieee80211_saveath(ni, ath); … … 3068 3046 else { 3069 3047 ieee80211_node_leave(ni); 3048 /* This would be a stupid place to add a node to the table 3049 * XR stuff needs work anyway 3050 */ 3070 3051 ieee80211_node_reset(ni, vap->iv_xrvap); 3071 3052 } … … 3080 3061 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_AUTH, wh->i_addr2, 3081 3062 "recv auth frame with algorithm %d seq %d", algo, seq); 3082 /* 3083 * Consult the ACL policy module if setup. 3084 */ 3063 /* Consult the ACL policy module if setup. */ 3085 3064 if (vap->iv_acl != NULL && 3086 3065 !vap->iv_acl->iac_check(vap, wh->i_addr2)) { … … 3115 3094 ieee80211_send_error(ni, wh->i_addr2, 3116 3095 IEEE80211_FC0_SUBTYPE_AUTH, 3117 (seq +1) | (IEEE80211_STATUS_ALG << 16));3096 (seq + 1) | (IEEE80211_STATUS_ALG << 16)); 3118 3097 } 3119 3098 return; trunk/net80211/ieee80211_linux.c
r2344 r2357 359 359 struct ieee80211_node_table *nt = (struct ieee80211_node_table *) &vap->iv_ic->ic_sta; 360 360 361 //IEEE80211_NODE_LOCK(nt);361 IEEE80211_NODE_TABLE_LOCK_IRQ(nt); 362 362 TAILQ_FOREACH(ni, &nt->nt_node, ni_list) { 363 363 /* Assume each node needs 500 bytes */ … … 377 377 } 378 378 } 379 //IEEE80211_NODE_UNLOCK(nt);379 IEEE80211_NODE_TABLE_UNLOCK_IRQ(nt); 380 380 return (p - buf); 381 381 } trunk/net80211/ieee80211_linux.h
r2300 r2357 64 64 #define IEEE80211_RESCHEDULE schedule 65 65 66 /* Locking */ 67 /* NB: beware, spin_is_locked() is not usefully defined for !(DEBUG || SMP) 68 * because spinlocks do not exist in this configuration. Instead IRQs 69 * or pre-emption are simply disabled, as this is all that is needed. 70 */ 71 66 72 /* 67 73 * Beacon handler locking definitions. … … 86 92 #define IEEE80211_UNLOCK(_ic) spin_unlock(&(_ic)->ic_comlock) 87 93 88 /* NB: beware, spin_is_locked() is unusable for !SMP */ 89 #if defined(CONFIG_SMP) 94 #if (defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)) && defined(spin_is_locked) 90 95 #define IEEE80211_LOCK_ASSERT(_ic) \ 91 96 KASSERT(spin_is_locked(&(_ic)->ic_comlock),("ieee80211com not locked!")) … … 93 98 #define IEEE80211_LOCK_ASSERT(_ic) 94 99 #endif 100 95 101 96 102 #define IEEE80211_VAPS_LOCK_INIT(_ic, _name) \ …
