Index: arm/xscale/ixp425/if_npe.c
===================================================================
--- arm/xscale/ixp425/if_npe.c	(revision 195044)
+++ arm/xscale/ixp425/if_npe.c	(working copy)
@@ -435,7 +435,7 @@
 		memset(clr, 0, ETHER_ADDR_LEN);
 		memset(set, 0xff, ETHER_ADDR_LEN);
 
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -445,7 +445,7 @@
 				set[i] &= mac[i];
 			}
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 
 		for (i = 0; i < ETHER_ADDR_LEN; i++) {
 			mask[i] = set[i] | ~clr[i];
Index: arm/at91/if_ate.c
===================================================================
--- arm/at91/if_ate.c	(revision 195044)
+++ arm/at91/if_ate.c	(working copy)
@@ -413,7 +413,7 @@
 	 */
 	mcaf[0] = 0;
 	mcaf[1] = 0;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -421,14 +421,14 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
 		af[index >> 3] |= 1 << (index & 7);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	/*
 	 * Write the hash to the hash register.  This card can also
 	 * accept unicast packets as well as multicast packets using this
 	 * register for easier bridging operations, but we don't take
 	 * advantage of that.  Locks here are to avoid LOR with the
-	 * IF_ADDR_LOCK, but might not be strictly necessary.
+	 * if_maddr_rlock, but might not be strictly necessary.
 	 */
 	WR4(sc, ETH_HSL, mcaf[0]);
 	WR4(sc, ETH_HSH, mcaf[1]);
Index: mips/adm5120/if_admsw.c
===================================================================
--- mips/adm5120/if_admsw.c	(revision 195044)
+++ mips/adm5120/if_admsw.c	(working copy)
@@ -1168,7 +1168,7 @@
 
 		ifp->if_flags &= ~IFF_ALLMULTI;
 
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 		{
 			if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -1176,7 +1176,7 @@
 
 			anymc |= vlan_matrix[i];
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 	}
 
 	conf = REG_READ(CPUP_CONF_REG);
Index: netgraph/ng_ether.c
===================================================================
--- netgraph/ng_ether.c	(revision 195044)
+++ netgraph/ng_ether.c	(working copy)
@@ -551,10 +551,10 @@
 			 * lose a race while we check if the membership
 			 * already exists.
 			 */
-			IF_ADDR_LOCK(priv->ifp);
+			if_maddr_rlock(priv->ifp);
 			ifma = if_findmulti(priv->ifp,
 			    (struct sockaddr *)&sa_dl);
-			IF_ADDR_UNLOCK(priv->ifp);
+			if_maddr_runlock(priv->ifp);
 			if (ifma != NULL) {
 				error = EADDRINUSE;
 			} else {
Index: pci/if_rl.c
===================================================================
--- pci/if_rl.c	(revision 195044)
+++ pci/if_rl.c	(working copy)
@@ -697,7 +697,7 @@
 	CSR_WRITE_4(sc, RL_MAR4, 0);
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -709,7 +709,7 @@
 			hashes[1] |= (1 << (h - 32));
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt)
 		rxfilt |= RL_RXCFG_RX_MULTI;
Index: dev/e1000/if_igb.c
===================================================================
--- dev/e1000/if_igb.c	(revision 195044)
+++ dev/e1000/if_igb.c	(working copy)
@@ -1886,7 +1886,7 @@
 
 	IOCTL_DEBUGOUT("igb_set_multi: begin");
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1898,7 +1898,7 @@
 		    &mta[mcnt * ETH_ADDR_LEN], ETH_ADDR_LEN);
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
 		reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
Index: dev/e1000/if_em.c
===================================================================
--- dev/e1000/if_em.c	(revision 195044)
+++ dev/e1000/if_em.c	(working copy)
@@ -2538,7 +2538,7 @@
 	if (mta == NULL)
 		panic("em_set_multi memory failure\n");
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -2550,7 +2550,7 @@
 		    &mta[mcnt * ETH_ADDR_LEN], ETH_ADDR_LEN);
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
 		reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
Index: dev/bce/if_bce.c
===================================================================
--- dev/bce/if_bce.c	(revision 195044)
+++ dev/bce/if_bce.c	(working copy)
@@ -7260,7 +7260,7 @@
 		/* Accept one or more multicast(s). */
 		DBPRINT(sc, BCE_INFO_MISC, "Enabling selective multicast mode.\n");
 
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -7268,7 +7268,7 @@
 			    ifma->ifma_addr), ETHER_ADDR_LEN) & 0xFF;
 			    hashes[(h & 0xE0) >> 5] |= 1 << (h & 0x1F);
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 
 		for (i = 0; i < NUM_MC_HASH_REGISTERS; i++)
 			REG_WR(sc, BCE_EMAC_MULTICAST_HASH0 + (i * 4), hashes[i]);
Index: dev/bm/if_bm.c
===================================================================
--- dev/bm/if_bm.c	(revision 195044)
+++ dev/bm/if_bm.c	(working copy)
@@ -1072,7 +1072,7 @@
 		/* Clear the hash table. */
 		memset(hash, 0, sizeof(hash));
 
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(inm, &ifp->if_multiaddrs, ifma_link) {
 			if (inm->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -1085,7 +1085,7 @@
 			/* Set the corresponding bit in the filter. */
 			hash[crc >> 4] |= 1 << (crc & 0xf);
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 	}
 
 	/* Write out new hash table */
Index: dev/re/if_re.c
===================================================================
--- dev/re/if_re.c	(revision 195044)
+++ dev/re/if_re.c	(working copy)
@@ -640,7 +640,7 @@
 		goto done;
 	}
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -651,7 +651,7 @@
 		else
 			hashes[1] |= (1 << (h - 32));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (hashes[0] != 0 || hashes[1] != 0) {
 		/*
Index: dev/cas/if_cas.c
===================================================================
--- dev/cas/if_cas.c	(revision 195044)
+++ dev/cas/if_cas.c	(working copy)
@@ -2531,7 +2531,7 @@
 	/* Clear the hash table. */
 	memset(hash, 0, sizeof(hash));
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(inm, &ifp->if_multiaddrs, ifma_link) {
 		if (inm->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -2544,7 +2544,7 @@
 		/* Set the corresponding bit in the filter. */
 		hash[crc >> 4] |= 1 << (15 - (crc & 15));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	v |= CAS_MAC_RX_CONF_HFILTER;
 
Index: dev/lge/if_lge.c
===================================================================
--- dev/lge/if_lge.c	(revision 195044)
+++ dev/lge/if_lge.c	(working copy)
@@ -393,7 +393,7 @@
 	CSR_WRITE_4(sc, LGE_MAR1, 0);
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -404,7 +404,7 @@
 		else
 			hashes[1] |= (1 << (h - 32));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	CSR_WRITE_4(sc, LGE_MAR0, hashes[0]);
 	CSR_WRITE_4(sc, LGE_MAR1, hashes[1]);
Index: dev/sis/if_sis.c
===================================================================
--- dev/sis/if_sis.c	(revision 195044)
+++ dev/sis/if_sis.c	(working copy)
@@ -773,7 +773,7 @@
 		CSR_WRITE_4(sc, SIS_RXFILT_DATA, 0);
 	}
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -786,7 +786,7 @@
 			bit -= 0x10;
 		SIS_SETBIT(sc, SIS_RXFILT_DATA, (1 << bit));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	CSR_WRITE_4(sc, SIS_RXFILT_CTL, filtsave);
 
@@ -825,7 +825,7 @@
 		for (i = 0; i < n; i++)
 			hashes[i] = 0;
 		i = 0;
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -834,7 +834,7 @@
 			hashes[h >> 4] |= 1 << (h & 0xf);
 			i++;
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 		if (i > n) {
 			ctl |= SIS_RXFILTCTL_ALLMULTI;
 			for (i = 0; i < n; i++)
Index: dev/cs/if_cs.c
===================================================================
--- dev/cs/if_cs.c	(revision 195044)
+++ dev/cs/if_cs.c	(working copy)
@@ -1022,7 +1022,7 @@
 			 * Set up the filter to only accept multicast
 			 * frames we're interested in.
 			 */
-			IF_ADDR_LOCK(ifp);
+			if_maddr_rlock(ifp);
 			TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 				struct sockaddr_dl *dl =
 				    (struct sockaddr_dl *)ifma->ifma_addr;
@@ -1032,7 +1032,7 @@
 				mask = (u_int16_t) (1 << (index & 0xf));
 				af[port] |= mask;
 			}
-			IF_ADDR_UNLOCK(ifp);
+			if_maddr_runlock(ifp);
 		}
 
 		cs_writereg(sc, PP_LAF + 0, af[0]);
Index: dev/sf/if_sf.c
===================================================================
--- dev/sf/if_sf.c	(revision 195044)
+++ dev/sf/if_sf.c	(working copy)
@@ -494,7 +494,7 @@
 
 	/* Now program new ones. */
 	i = 1;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH_REVERSE(ifma, &ifp->if_multiaddrs, ifmultihead,
 	    ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -514,7 +514,7 @@
 		sf_sethash(sc,
 		    LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 0);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 done:
 	csr_write_4(sc, SF_RXFILT, rxfilt);
Index: dev/if_ndis/if_ndis.c
===================================================================
--- dev/if_ndis/if_ndis.c	(revision 195044)
+++ dev/if_ndis/if_ndis.c	(working copy)
@@ -320,7 +320,7 @@
 	sc->ndis_filter |= NDIS_PACKET_TYPE_MULTICAST;
 
 	len = 0;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -328,13 +328,13 @@
 		    mclist + (ETHER_ADDR_LEN * len), ETHER_ADDR_LEN);
 		len++;
 		if (len > mclistsz) {
-			IF_ADDR_UNLOCK(ifp);
+			if_maddr_runlock(ifp);
 			sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
 			sc->ndis_filter &= ~NDIS_PACKET_TYPE_MULTICAST;
 			goto out;
 		}
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	len = len * ETHER_ADDR_LEN;
 	error = ndis_set_info(sc, OID_802_3_MULTICAST_LIST, mclist, &len);
Index: dev/sk/if_sk.c
===================================================================
--- dev/sk/if_sk.c	(revision 195044)
+++ dev/sk/if_sk.c	(working copy)
@@ -759,7 +759,7 @@
 		hashes[1] = 0xFFFFFFFF;
 	} else {
 		i = 1;
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH_REVERSE(ifma, &ifp->if_multiaddrs, ifmultihead,
 		    ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -783,7 +783,7 @@
 				hashes[1] |= (1 << (h - 32));
 			mode |= XM_MODE_RX_USE_HASH;
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 	}
 
 	SK_XM_WRITE_4(sc_if, XM_MODE, mode);
@@ -811,7 +811,7 @@
 		hashes[1] = 0xFFFFFFFF;
 	} else {
 		mode |= YU_RCR_UFLEN;
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -822,7 +822,7 @@
 			/* Set the corresponding bit in the hash table. */
 			hashes[crc >> 5] |= 1 << (crc & 0x1f);
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 		if (hashes[0] != 0 || hashes[1] != 0)
 			mode |= YU_RCR_MUFLEN;
 	}
Index: dev/sn/if_sn.c
===================================================================
--- dev/sn/if_sn.c	(revision 195044)
+++ dev/sn/if_sn.c	(working copy)
@@ -1404,10 +1404,10 @@
 
 	bzero(mcf, MCFSZ);
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 	    if (ifma->ifma_addr->sa_family != AF_LINK) {
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 		return 0;
 	    }
 	    index = ether_crc32_le(LLADDR((struct sockaddr_dl *)
@@ -1420,6 +1420,6 @@
 	    }
 	    af[index2 >> 3] |= 1 << (index2 & 7);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 	return 1;  /* use multicast filter */
 }
Index: dev/dc/if_dc.c
===================================================================
--- dev/dc/if_dc.c	(revision 195044)
+++ dev/dc/if_dc.c	(working copy)
@@ -1110,7 +1110,7 @@
 	else
 		DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1118,7 +1118,7 @@
 		    LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
 		sp[h >> 4] |= htole32(1 << (h & 0xF));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (ifp->if_flags & IFF_BROADCAST) {
 		h = dc_mchash_le(sc, ifp->if_broadcastaddr);
@@ -1185,7 +1185,7 @@
 		return;
 
 	/* Now program new ones. */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1200,7 +1200,7 @@
 		else
 			hashes[1] |= (1 << (h - 32));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	CSR_WRITE_4(sc, DC_AL_MAR0, hashes[0]);
 	CSR_WRITE_4(sc, DC_AL_MAR1, hashes[1]);
@@ -1258,7 +1258,7 @@
 		return;
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1268,7 +1268,7 @@
 		else
 			hashes[1] |= (1 << (h - 32));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_MAR0);
 	CSR_WRITE_4(sc, DC_AX_FILTDATA, hashes[0]);
@@ -1313,7 +1313,7 @@
 	else
 		DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1321,7 +1321,7 @@
 		    LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
 		sp[h >> 4] |= htole32(1 << (h & 0xF));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (ifp->if_flags & IFF_BROADCAST) {
 		h = dc_mchash_le(sc, ifp->if_broadcastaddr);
Index: dev/malo/if_malo.c
===================================================================
--- dev/malo/if_malo.c	(revision 195044)
+++ dev/malo/if_malo.c	(working copy)
@@ -1577,14 +1577,14 @@
 	    (ifp->if_flags & (IFF_ALLMULTI | IFF_PROMISC)))
 		goto all;
 	
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
 
 		if (nmc == MALO_HAL_MCAST_MAX) {
 			ifp->if_flags |= IFF_ALLMULTI;
-			IF_ADDR_UNLOCK(ifp);
+			if_maddr_runlock(ifp);
 			goto all;
 		}
 		IEEE80211_ADDR_COPY(mp,
@@ -1592,7 +1592,7 @@
 
 		mp += IEEE80211_ADDR_LEN, nmc++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	malo_hal_setmcast(sc->malo_mh, nmc, macs);
 
Index: dev/de/if_de.c
===================================================================
--- dev/de/if_de.c	(revision 195044)
+++ dev/de/if_de.c	(working copy)
@@ -3041,7 +3041,7 @@
 
     multicnt = 0;
     ifp = sc->tulip_ifp;      
-    IF_ADDR_LOCK(ifp);
+    if_maddr_rlock(ifp);
 
     /* Copy MAC address on stack to align. */
     if (ifp->if_input != NULL)
@@ -3134,7 +3134,7 @@
 	    *sp++ = TULIP_SP_MAC(eaddr[2]);
 	}
     }
-    IF_ADDR_UNLOCK(ifp);
+    if_maddr_runlock(ifp);
 }
 
 static void
Index: dev/age/if_age.c
===================================================================
--- dev/age/if_age.c	(revision 195044)
+++ dev/age/if_age.c	(working copy)
@@ -3131,7 +3131,7 @@
 	/* Program new filter. */
 	bzero(mchash, sizeof(mchash));
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &sc->age_ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -3139,7 +3139,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN);
 		mchash[crc >> 31] |= 1 << ((crc >> 26) & 0x1f);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	CSR_WRITE_4(sc, AGE_MAR0, mchash[0]);
 	CSR_WRITE_4(sc, AGE_MAR1, mchash[1]);
Index: dev/le/lance.c
===================================================================
--- dev/le/lance.c	(revision 195044)
+++ dev/le/lance.c	(working copy)
@@ -605,7 +605,7 @@
 	}
 
 	af[0] = af[1] = af[2] = af[3] = 0x0000;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -619,7 +619,7 @@
 		/* Set the corresponding bit in the filter. */
 		af[crc >> 4] |= LE_HTOLE16(1 << (crc & 0xf));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 }
 
 /*
Index: dev/mge/if_mge.c
===================================================================
--- dev/mge/if_mge.c	(revision 195044)
+++ dev/mge/if_mge.c	(working copy)
@@ -1731,7 +1731,7 @@
 		memset(smt, 0, sizeof(smt));
 		memset(omt, 0, sizeof(omt));
 
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -1745,7 +1745,7 @@
 				omt[i >> 2] |= v << ((i & 0x03) << 3);
 			}
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 	}
 
 	for (i = 0; i < MGE_MCAST_REG_NUMBER; i++) {
Index: dev/jme/if_jme.c
===================================================================
--- dev/jme/if_jme.c	(revision 195044)
+++ dev/jme/if_jme.c	(working copy)
@@ -3122,7 +3122,7 @@
 	rxcfg |= RXMAC_MULTICAST;
 	bzero(mchash, sizeof(mchash));
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &sc->jme_ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -3135,7 +3135,7 @@
 		/* Set the corresponding bit in the hash table. */
 		mchash[crc >> 5] |= 1 << (crc & 0x1f);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	CSR_WRITE_4(sc, JME_MAR0, mchash[0]);
 	CSR_WRITE_4(sc, JME_MAR1, mchash[1]);
Index: dev/txp/if_txp.c
===================================================================
--- dev/txp/if_txp.c	(revision 195044)
+++ dev/txp/if_txp.c	(working copy)
@@ -2725,7 +2725,7 @@
 
 	mchash[0] = mchash[1] = 0;
 	mcnt = 0;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -2735,7 +2735,7 @@
 		mchash[crc >> 5] |= 1 << (crc & 0x1f);
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt > 0) {
 		filter |= TXP_RXFILT_HASHMULTI;
Index: dev/ti/if_ti.c
===================================================================
--- dev/ti/if_ti.c	(revision 195044)
+++ dev/ti/if_ti.c	(working copy)
@@ -1851,7 +1851,7 @@
 	}
 
 	/* Now program new ones. */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1866,7 +1866,7 @@
 		SLIST_INSERT_HEAD(&sc->ti_mc_listhead, mc, mc_entries);
 		ti_add_mcast(sc, &mc->mc_addr);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	/* Re-enable interrupts. */
 	CSR_WRITE_4(sc, TI_MB_HOSTINTR, intrs);
Index: dev/tl/if_tl.c
===================================================================
--- dev/tl/if_tl.c	(revision 195044)
+++ dev/tl/if_tl.c	(working copy)
@@ -952,7 +952,7 @@
 		hashes[1] = 0xFFFFFFFF;
 	} else {
 		i = 1;
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH_REVERSE(ifma, &ifp->if_multiaddrs, ifmultihead, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -975,7 +975,7 @@
 			else
 				hashes[1] |= (1 << (h - 32));
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 	}
 
 	tl_dio_write32(sc, TL_HASH1, hashes[0]);
Index: dev/ed/if_ed.c
===================================================================
--- dev/ed/if_ed.c	(revision 195044)
+++ dev/ed/if_ed.c	(working copy)
@@ -1614,7 +1614,7 @@
 	mcaf[0] = 0;
 	mcaf[1] = 0;
 
-	IF_ADDR_LOCK(sc->ifp);
+	if_maddr_rlock(sc->ifp);
 	TAILQ_FOREACH(ifma, &sc->ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1622,7 +1622,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
 		af[index >> 3] |= 1 << (index & 7);
 	}
-	IF_ADDR_UNLOCK(sc->ifp);
+	if_maddr_runlock(sc->ifp);
 }
 
 int
Index: dev/tx/if_tx.c
===================================================================
--- dev/tx/if_tx.c	(revision 195044)
+++ dev/tx/if_tx.c	(working copy)
@@ -1400,7 +1400,7 @@
 	filter[2] = 0;
 	filter[3] = 0;
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1408,7 +1408,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
 		filter[h >> 4] |= 1 << (h & 0xF);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	CSR_WRITE_4(sc, MC0, filter[0]);
 	CSR_WRITE_4(sc, MC1, filter[1]);
Index: dev/bfe/if_bfe.c
===================================================================
--- dev/bfe/if_bfe.c	(revision 195044)
+++ dev/bfe/if_bfe.c	(working copy)
@@ -1111,14 +1111,14 @@
 		val |= BFE_RXCONF_ALLMULTI;
 	else {
 		val &= ~BFE_RXCONF_ALLMULTI;
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
 			bfe_cam_write(sc,
 			    LLADDR((struct sockaddr_dl *)ifma->ifma_addr), i++);
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 	}
 
 	CSR_WRITE_4(sc, BFE_RXCONF, val);
Index: dev/mxge/if_mxge.c
===================================================================
--- dev/mxge/if_mxge.c	(revision 195044)
+++ dev/mxge/if_mxge.c	(working copy)
@@ -1130,7 +1130,7 @@
 
 	/* Walk the multicast list, and add each address */
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1146,11 +1146,11 @@
 			       "MXGEFW_JOIN_MULTICAST_GROUP, error status:"
 			       "%d\t", err);
 			/* abort, leaving multicast filtering off */
-			IF_ADDR_UNLOCK(ifp);
+			if_maddr_runlock(ifp);
 			return;
 		}
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 	/* Enable multicast filtering */
 	err = mxge_send_cmd(sc, MXGEFW_DISABLE_ALLMULTI, &cmd);
 	if (err != 0) {
Index: dev/nfe/if_nfe.c
===================================================================
--- dev/nfe/if_nfe.c	(revision 195044)
+++ dev/nfe/if_nfe.c	(working copy)
@@ -2491,7 +2491,7 @@
 	bcopy(etherbroadcastaddr, addr, ETHER_ADDR_LEN);
 	bcopy(etherbroadcastaddr, mask, ETHER_ADDR_LEN);
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		u_char *addrp;
 
@@ -2505,7 +2505,7 @@
 			mask[i] &= ~mcaddr;
 		}
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	for (i = 0; i < ETHER_ADDR_LEN; i++) {
 		mask[i] |= addr[i];
Index: dev/et/if_et.c
===================================================================
--- dev/et/if_et.c	(revision 195044)
+++ dev/et/if_et.c	(working copy)
@@ -1361,7 +1361,7 @@
 	}
 
 	count = 0;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		uint32_t *hp, h;
 
@@ -1387,7 +1387,7 @@
 
 		++count;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	for (i = 0; i < 4; ++i)
 		CSR_WRITE_4(sc, ET_MULTI_HASH + (i * 4), hash[i]);
Index: dev/ex/if_ex.c
===================================================================
--- dev/ex/if_ex.c	(revision 195044)
+++ dev/ex/if_ex.c	(working copy)
@@ -870,13 +870,13 @@
 	ifp = sc->ifp;
 
 	count = 0;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(maddr, &ifp->if_multiaddrs, ifma_link) {
 		if (maddr->ifma_addr->sa_family != AF_LINK)
 			continue;
 		count++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if ((ifp->if_flags & IFF_PROMISC) || (ifp->if_flags & IFF_ALLMULTI)
 			|| count > 63) {
@@ -904,7 +904,7 @@
 		CSR_WRITE_2(sc, IO_PORT_REG, 0);
 		CSR_WRITE_2(sc, IO_PORT_REG, (count + 1) * 6);
 
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(maddr, &ifp->if_multiaddrs, ifma_link) {
 			if (maddr->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -915,7 +915,7 @@
 			CSR_WRITE_2(sc, IO_PORT_REG, *addr++);
 			CSR_WRITE_2(sc, IO_PORT_REG, *addr++);
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 
 		/* Program our MAC address as well */
 		/* XXX: Is this necessary?  The Linux driver does this
Index: dev/my/if_my.c
===================================================================
--- dev/my/if_my.c	(revision 195044)
+++ dev/my/if_my.c	(working copy)
@@ -337,7 +337,7 @@
 	CSR_WRITE_4(sc, MY_MAR1, 0);
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -349,7 +349,7 @@
 			hashes[1] |= (1 << (h - 32));
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt)
 		rxfilt |= MY_AM;
Index: dev/nve/if_nve.c
===================================================================
--- dev/nve/if_nve.c	(revision 195044)
+++ dev/nve/if_nve.c	(working copy)
@@ -1133,7 +1133,7 @@
 		return;
 	}
 	/* Setup multicast filter */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		u_char *addrp;
 
@@ -1147,7 +1147,7 @@
 			oraddr[i] |= mcaddr;
 		}
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 	for (i = 0; i < 6; i++) {
 		hwfilter.acMulticastAddress[i] = andaddr[i] & oraddr[i];
 		hwfilter.acMulticastMask[i] = andaddr[i] | (~oraddr[i]);
Index: dev/fe/if_fe.c
===================================================================
--- dev/fe/if_fe.c	(revision 195044)
+++ dev/fe/if_fe.c	(working copy)
@@ -2080,7 +2080,7 @@
 	struct ifmultiaddr *ifma;
 
 	filter = fe_filter_nothing;
-	IF_ADDR_LOCK(sc->ifp);
+	if_maddr_rlock(sc->ifp);
 	TAILQ_FOREACH(ifma, &sc->ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -2093,7 +2093,7 @@
 
 		filter.data[index >> 3] |= 1 << (index & 7);
 	}
-	IF_ADDR_UNLOCK(sc->ifp);
+	if_maddr_runlock(sc->ifp);
 	return ( filter );
 }
 
Index: dev/ste/if_ste.c
===================================================================
--- dev/ste/if_ste.c	(revision 195044)
+++ dev/ste/if_ste.c	(working copy)
@@ -594,7 +594,7 @@
 	CSR_WRITE_2(sc, STE_MAR3, 0);
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -605,7 +605,7 @@
 		else
 			hashes[1] |= (1 << (h - 32));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	CSR_WRITE_2(sc, STE_MAR0, hashes[0] & 0xFFFF);
 	CSR_WRITE_2(sc, STE_MAR1, (hashes[0] >> 16) & 0xFFFF);
Index: dev/bge/if_bge.c
===================================================================
--- dev/bge/if_bge.c	(revision 195044)
+++ dev/bge/if_bge.c	(working copy)
@@ -1186,7 +1186,7 @@
 		CSR_WRITE_4(sc, BGE_MAR0 + (i * 4), 0);
 
 	/* Now program new ones. */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1194,7 +1194,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN) & 0x7F;
 		hashes[(h & 0x60) >> 5] |= 1 << (h & 0x1F);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	for (i = 0; i < 4; i++)
 		CSR_WRITE_4(sc, BGE_MAR0 + (i * 4), hashes[i]);
Index: dev/ixgbe/ixgbe.c
===================================================================
--- dev/ixgbe/ixgbe.c	(revision 195044)
+++ dev/ixgbe/ixgbe.c	(working copy)
@@ -1883,7 +1883,7 @@
 	
 	IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl);
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1892,7 +1892,7 @@
 		    IXGBE_ETH_LENGTH_OF_ADDRESS);
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	update_ptr = mta;
 	ixgbe_update_mc_addr_list(&adapter->hw,
Index: dev/tsec/if_tsec.c
===================================================================
--- dev/tsec/if_tsec.c	(revision 195044)
+++ dev/tsec/if_tsec.c	(working copy)
@@ -1899,7 +1899,7 @@
 		return;
 	}
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 
 		if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -1910,7 +1910,7 @@
 
 		hashtable[(h >> 5)] |= 1 << (0x1F - (h & 0x1F));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	for (i = 0; i < 8; i++)
 		TSEC_WRITE(sc, TSEC_REG_GADDR(i), hashtable[i]);
Index: dev/gem/if_gem.c
===================================================================
--- dev/gem/if_gem.c	(revision 195044)
+++ dev/gem/if_gem.c	(working copy)
@@ -2201,7 +2201,7 @@
 	/* Clear the hash table. */
 	memset(hash, 0, sizeof(hash));
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(inm, &ifp->if_multiaddrs, ifma_link) {
 		if (inm->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -2214,7 +2214,7 @@
 		/* Set the corresponding bit in the filter. */
 		hash[crc >> 4] |= 1 << (15 - (crc & 15));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	v |= GEM_MAC_RX_HASH_FILTER;
 
Index: dev/nge/if_nge.c
===================================================================
--- dev/nge/if_nge.c	(revision 195044)
+++ dev/nge/if_nge.c	(working copy)
@@ -863,7 +863,7 @@
 	 * that needs to be updated, and the lower 4 bits represent
 	 * which bit within that byte needs to be set.
 	 */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -875,7 +875,7 @@
 		    NGE_FILTADDR_MCAST_LO + (index * 2));
 		NGE_SETBIT(sc, NGE_RXFILT_DATA, (1 << bit));
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 done:
 	CSR_WRITE_4(sc, NGE_RXFILT_CTL, rxfilt);
Index: dev/pcn/if_pcn.c
===================================================================
--- dev/pcn/if_pcn.c	(revision 195044)
+++ dev/pcn/if_pcn.c	(working copy)
@@ -371,7 +371,7 @@
 		pcn_csr_write(sc, PCN_CSR_MAR0 + i, 0);
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -379,7 +379,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
 		hashes[h >> 4] |= 1 << (h & 0xF);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	for (i = 0; i < 4; i++)
 		pcn_csr_write(sc, PCN_CSR_MAR0 + i, hashes[i]);
Index: dev/vge/if_vge.c
===================================================================
--- dev/vge/if_vge.c	(revision 195044)
+++ dev/vge/if_vge.c	(working copy)
@@ -569,7 +569,7 @@
 	}
 
 	/* Now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -597,7 +597,7 @@
 		CSR_WRITE_4(sc, VGE_MAR0, hashes[0]);
 		CSR_WRITE_4(sc, VGE_MAR1, hashes[1]);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	return;
 }
Index: dev/vr/if_vr.c
===================================================================
--- dev/vr/if_vr.c	(revision 195044)
+++ dev/vr/if_vr.c	(working copy)
@@ -482,7 +482,7 @@
 	/* Now program new ones. */
 	error = 0;
 	mcnt = 0;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	if ((sc->vr_quirks & VR_Q_CAM) != 0) {
 		/*
 		 * For hardwares that have CAM capability, use
@@ -523,7 +523,7 @@
 			mcnt++;
 		}
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt > 0)
 		rxfilt |= VR_RXCFG_RX_MULTI;
Index: dev/stge/if_stge.c
===================================================================
--- dev/stge/if_stge.c	(revision 195044)
+++ dev/stge/if_stge.c	(working copy)
@@ -2683,7 +2683,7 @@
 	bzero(mchash, sizeof(mchash));
 
 	count = 0;
-	IF_ADDR_LOCK(sc->sc_ifp);
+	if_maddr_rlock(sc->sc_ifp);
 	TAILQ_FOREACH(ifma, &sc->sc_ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -2697,7 +2697,7 @@
 		mchash[crc >> 5] |= 1 << (crc & 0x1f);
 		count++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	mode &= ~(RM_ReceiveMulticast | RM_ReceiveAllFrames);
 	if (count > 0)
Index: dev/wb/if_wb.c
===================================================================
--- dev/wb/if_wb.c	(revision 195044)
+++ dev/wb/if_wb.c	(working copy)
@@ -605,7 +605,7 @@
 	CSR_WRITE_4(sc, WB_MAR1, 0);
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -617,7 +617,7 @@
 			hashes[1] |= (1 << (h - 32));
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt)
 		rxfilt |= WB_NETCFG_RX_MULTI;
Index: dev/wi/if_wi.c
===================================================================
--- dev/wi/if_wi.c	(revision 195044)
+++ dev/wi/if_wi.c	(working copy)
@@ -1582,7 +1582,7 @@
 	}
 
 	n = 0;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1592,7 +1592,7 @@
 		    (LLADDR((struct sockaddr_dl *)ifma->ifma_addr)));
 		n++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 	return wi_write_rid(sc, WI_RID_MCAST_LIST, &mlist,
 	    IEEE80211_ADDR_LEN * n);
 }
Index: dev/wl/if_wl.c
===================================================================
--- dev/wl/if_wl.c	(revision 195044)
+++ dev/wl/if_wl.c	(working copy)
@@ -2116,7 +2116,7 @@
     outw(PIOP1(base), 0);				/* ac_status */
     outw(PIOP1(base), AC_MCSETUP|AC_CW_EL);		/* ac_command */
     outw(PIOR1(base), OFFSET_CU + 8);
-    IF_ADDR_LOCK(sc->ifp);
+    if_maddr_rlock(sc->ifp);
     TAILQ_FOREACH(ifma, &sc->ifp->if_multiaddrs, ifma_link) {
 	if (ifma->ifma_addr->sa_family != AF_LINK)
 	    continue;
@@ -2127,7 +2127,7 @@
         outw(PIOP1(base), addrp[4] + (addrp[5] << 8));
         ++cnt;
     }
-    IF_ADDR_UNLOCK(sc->ifp);
+    if_maddr_runlock(sc->ifp);
     outw(PIOR1(base), OFFSET_CU + 6);		/* mc-cnt */
     outw(PIOP1(base), cnt * WAVELAN_ADDR_SIZE);
     if (wlcmd(sc, "config()-mcaddress") == 0)
Index: dev/snc/dp83932.c
===================================================================
--- dev/snc/dp83932.c	(revision 195044)
+++ dev/snc/dp83932.c	(working copy)
@@ -691,7 +691,7 @@
 	ifp->if_flags &= ~IFF_ALLMULTI;
 
 	/* Loop through multicast addresses */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
                 if (ifma->ifma_addr->sa_family != AF_LINK)
                         continue;
@@ -705,7 +705,7 @@
 			 LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
 		mcount++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	NIC_PUT(sc, SNCR_CDP, LOWER(sc->v_cda));
 	NIC_PUT(sc, SNCR_CDC, MAXCAM);
Index: dev/pdq/pdq_ifsubr.c
===================================================================
--- dev/pdq/pdq_ifsubr.c	(revision 195044)
+++ dev/pdq/pdq_ifsubr.c	(working copy)
@@ -273,7 +273,7 @@
     PDQ_IFNET(sc)->if_flags &= ~IFF_ALLMULTI;
 #endif
 
-    IF_ADDR_LOCK(PDQ_IFNET(sc));
+    if_maddr_rlock(PDQ_IFNET(sc));
     for (ifma = TAILQ_FIRST(&PDQ_IFNET(sc)->if_multiaddrs); ifma && num_addrs > 0;
 	 ifma = TAILQ_NEXT(ifma, ifma_link)) {
 	    char *mcaddr;
@@ -286,7 +286,7 @@
 	    addr++;
 	    num_addrs--;
     }
-    IF_ADDR_UNLOCK(PDQ_IFNET(sc));
+    if_maddr_runlock(PDQ_IFNET(sc));
     /*
      * If not all the address fit into the CAM, turn on all-multicast mode.
      */
Index: dev/fxp/if_fxp.c
===================================================================
--- dev/fxp/if_fxp.c	(revision 195044)
+++ dev/fxp/if_fxp.c	(working copy)
@@ -2851,7 +2851,7 @@
 
 	nmcasts = 0;
 	if ((ifp->if_flags & IFF_ALLMULTI) == 0) {
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -2864,7 +2864,7 @@
 			    &sc->mcsp->mc_addr[nmcasts][0], ETHER_ADDR_LEN);
 			nmcasts++;
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 	}
 	mcsp->mc_cnt = htole16(nmcasts * ETHER_ADDR_LEN);
 	return (nmcasts);
Index: dev/nxge/if_nxge.c
===================================================================
--- dev/nxge/if_nxge.c	(revision 195044)
+++ dev/nxge/if_nxge.c	(working copy)
@@ -2238,7 +2238,7 @@
 	}
 
 	/* Updating address list */
-	IF_ADDR_LOCK(ifnetp);
+	if_maddr_rlock(ifnetp);
 	index = 0;
 	TAILQ_FOREACH(ifma, &ifnetp->if_multiaddrs, ifma_link) {
 	    if(ifma->ifma_addr->sa_family != AF_LINK) {
@@ -2247,7 +2247,7 @@
 	    lladdr = LLADDR((struct sockaddr_dl *)ifma->ifma_addr);
 	    index += 1;
 	}
-	IF_ADDR_UNLOCK(ifnetp);
+	if_maddr_runlock(ifnetp);
 
 	if((!lldev->all_multicast) && (index)) {
 	    lldev->macaddr_count = (index + 1);
@@ -2263,7 +2263,7 @@
 	}
 
 	/* Add new addresses */
-	IF_ADDR_LOCK(ifnetp);
+	if_maddr_rlock(ifnetp);
 	index = 0;
 	TAILQ_FOREACH(ifma, &ifnetp->if_multiaddrs, ifma_link) {
 	    if(ifma->ifma_addr->sa_family != AF_LINK) {
@@ -2273,7 +2273,7 @@
 	    xge_hal_device_macaddr_set(hldev, (offset + index), lladdr);
 	    index += 1;
 	}
-	IF_ADDR_UNLOCK(ifnetp);
+	if_maddr_runlock(ifnetp);
 
 _exit:
 	return;
Index: dev/hme/if_hme.c
===================================================================
--- dev/hme/if_hme.c	(revision 195044)
+++ dev/hme/if_hme.c	(working copy)
@@ -1710,7 +1710,7 @@
 	 * the word.
 	 */
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(inm, &ifp->if_multiaddrs, ifma_link) {
 		if (inm->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1723,7 +1723,7 @@
 		/* Set the corresponding bit in the filter. */
 		hash[crc >> 4] |= 1 << (crc & 0xf);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 chipit:
 	/* Now load the hash table into the chip */
Index: dev/xe/if_xe.c
===================================================================
--- dev/xe/if_xe.c	(revision 195044)
+++ dev/xe/if_xe.c	(working copy)
@@ -1390,7 +1390,7 @@
 
 	/* Iterate over multicast address list */
 	count = 0;
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(maddr, &ifp->if_multiaddrs, ifma_link) {
 		if (maddr->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1413,7 +1413,7 @@
 			/* Nowhere else to put them on CE2 */
 			break;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	DEVPRINTF(2, (scp->dev, "set_multicast: count = %u\n", count));
 
Index: dev/xl/if_xl.c
===================================================================
--- dev/xl/if_xl.c	(revision 195044)
+++ dev/xl/if_xl.c	(working copy)
@@ -724,10 +724,10 @@
 		return;
 	}
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 		mcnt++;
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt)
 		rxfilt |= XL_RXFILTER_ALLMULTI;
@@ -766,7 +766,7 @@
 		CSR_WRITE_2(sc, XL_COMMAND, XL_CMD_RX_SET_HASH|i);
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -788,7 +788,7 @@
 		    h | XL_CMD_RX_SET_HASH | XL_HASH_SET);
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt)
 		rxfilt |= XL_RXFILTER_MULTIHASH;
Index: dev/ae/if_ae.c
===================================================================
--- dev/ae/if_ae.c	(revision 195044)
+++ dev/ae/if_ae.c	(working copy)
@@ -2073,7 +2073,7 @@
 	 * Load multicast tables.
 	 */
 	bzero(mchash, sizeof(mchash));
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -2081,7 +2081,7 @@
 			ifma->ifma_addr), ETHER_ADDR_LEN);
 		mchash[crc >> 31] |= 1 << ((crc >> 26) & 0x1f);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 	AE_WRITE_4(sc, AE_REG_MHT0, mchash[0]);
 	AE_WRITE_4(sc, AE_REG_MHT1, mchash[1]);
 	AE_WRITE_4(sc, AE_MAC_REG, rxcfg);
Index: dev/ixgb/if_ixgb.c
===================================================================
--- dev/ixgb/if_ixgb.c	(revision 195044)
+++ dev/ixgb/if_ixgb.c	(working copy)
@@ -1090,7 +1090,7 @@
 
 	IOCTL_DEBUGOUT("ixgb_set_multi: begin");
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 #if __FreeBSD_version < 500000
 	LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 #else
@@ -1103,7 +1103,7 @@
 		      &mta[mcnt * IXGB_ETH_LENGTH_OF_ADDRESS], IXGB_ETH_LENGTH_OF_ADDRESS);
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt > MAX_NUM_MULTICAST_ADDRESSES) {
 		reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL);
Index: dev/usb/net/if_kue.c
===================================================================
--- dev/usb/net/if_kue.c	(revision 195044)
+++ dev/usb/net/if_kue.c	(working copy)
@@ -368,7 +368,7 @@
 
 	sc->sc_rxfilt &= ~KUE_RXFILT_ALLMULTI;
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 	{
 		if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -383,7 +383,7 @@
 		    KUE_MCFILT(sc, i), ETHER_ADDR_LEN);
 		i++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (i == KUE_MCFILTCNT(sc))
 		sc->sc_rxfilt |= KUE_RXFILT_ALLMULTI;
Index: dev/usb/net/if_rue.c
===================================================================
--- dev/usb/net/if_rue.c	(revision 195044)
+++ dev/usb/net/if_rue.c	(working copy)
@@ -494,7 +494,7 @@
 	rue_csr_write_4(sc, RUE_MAR4, 0);
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH (ifma, &ifp->if_multiaddrs, ifma_link)
 	{
 		if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -507,7 +507,7 @@
 			hashes[1] |= (1 << (h - 32));
 		mcnt++;
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	if (mcnt)
 		rxcfg |= RUE_RCR_AM;
Index: dev/usb/net/if_udav.c
===================================================================
--- dev/usb/net/if_udav.c	(revision 195044)
+++ dev/usb/net/if_udav.c	(working copy)
@@ -494,7 +494,7 @@
 	udav_csr_write(sc, UDAV_MAR, hashtbl, sizeof(hashtbl));
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 	{
 		if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -503,7 +503,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
 		hashtbl[h / 8] |= 1 << (h % 8);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	/* disable all multicast */
 	UDAV_CLRBIT(sc, UDAV_RCR, UDAV_RCR_ALL);
Index: dev/usb/net/if_aue.c
===================================================================
--- dev/usb/net/if_aue.c	(revision 195044)
+++ dev/usb/net/if_aue.c	(working copy)
@@ -551,7 +551,7 @@
 	AUE_CLRBIT(sc, AUE_CTL0, AUE_CTL0_ALLMULTI);
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -559,7 +559,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN) & ((1 << AUE_BITS) - 1);
 		hashtbl[(h >> 3)] |=  1 << (h & 0x7);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	/* write the hashtable */
 	for (i = 0; i != 8; i++)
Index: dev/usb/net/if_cue.c
===================================================================
--- dev/usb/net/if_cue.c	(revision 195044)
+++ dev/usb/net/if_cue.c	(working copy)
@@ -318,7 +318,7 @@
 	}
 
 	/* now program new ones */
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 	{
 		if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -326,7 +326,7 @@
 		h = cue_mchash(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
 		hashtbl[h >> 3] |= 1 << (h & 0x7);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	/*
 	 * Also include the broadcast address in the filter
Index: dev/usb/net/if_axe.c
===================================================================
--- dev/usb/net/if_axe.c	(revision 195044)
+++ dev/usb/net/if_axe.c	(working copy)
@@ -475,7 +475,7 @@
 	}
 	rxmode &= ~AXE_RXCMD_ALLMULTI;
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 	{
 		if (ifma->ifma_addr->sa_family != AF_LINK)
@@ -484,7 +484,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
 		hashtbl[h / 8] |= 1 << (h % 8);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	axe_cmd(sc, AXE_CMD_WRITE_MCAST, 0, 0, (void *)&hashtbl);
 	axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL);
Index: dev/usb/wlan/if_urtw.c
===================================================================
--- dev/usb/wlan/if_urtw.c	(revision 195044)
+++ dev/usb/wlan/if_urtw.c	(working copy)
@@ -1945,9 +1945,7 @@
 	 * XXX don't know how to set a device.  Lack of docs.  Just try to set
 	 * IFF_ALLMULTI flag here.
 	 */
-	IF_ADDR_LOCK(ifp);
 	ifp->if_flags |= IFF_ALLMULTI;
-	IF_ADDR_UNLOCK(ifp);
 }
 
 static usb_error_t
Index: dev/usb/wlan/if_zyd.c
===================================================================
--- dev/usb/wlan/if_zyd.c	(revision 195044)
+++ dev/usb/wlan/if_zyd.c	(working copy)
@@ -2016,7 +2016,7 @@
 		low = 0xffffffff;
 		high = 0xffffffff;
 	} else {
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -2027,7 +2027,7 @@
 			else
 				high |= 1 << (v - 32);
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 	}
 
 	/* reprogram multicast global hash table */
Index: dev/usb/wlan/if_upgt.c
===================================================================
--- dev/usb/wlan/if_upgt.c	(revision 195044)
+++ dev/usb/wlan/if_upgt.c	(working copy)
@@ -809,9 +809,7 @@
 	 * XXX don't know how to set a device.  Lack of docs.  Just try to set
 	 * IFF_ALLMULTI flag here.
 	 */
-	IF_ADDR_LOCK(ifp);
 	ifp->if_flags |= IFF_ALLMULTI;
-	IF_ADDR_UNLOCK(ifp);
 }
 
 static void
Index: dev/msk/if_msk.c
===================================================================
--- dev/msk/if_msk.c	(revision 195044)
+++ dev/msk/if_msk.c	(working copy)
@@ -601,7 +601,7 @@
 		mchash[1] = 0xffff;
 	} else {
 		mode |= GM_RXCR_UCF_ENA;
-		IF_ADDR_LOCK(ifp);
+		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
@@ -612,7 +612,7 @@
 			/* Set the corresponding bit in the hash table. */
 			mchash[crc >> 5] |= 1 << (crc & 0x1f);
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 		if (mchash[0] != 0 || mchash[1] != 0)
 			mode |= GM_RXCR_MCF_ENA;
 	}
Index: dev/ie/if_ie.c
===================================================================
--- dev/ie/if_ie.c	(revision 195044)
+++ dev/ie/if_ie.c	(working copy)
@@ -1675,7 +1675,7 @@
 	 * Step through the list of addresses.
 	 */
 	sc->mcast_count = 0;
-	IF_ADDR_LOCK(sc->ifp);
+	if_maddr_rlock(sc->ifp);
 	TAILQ_FOREACH(ifma, &sc->ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -1691,7 +1691,7 @@
 		      &(sc->mcast_addrs[sc->mcast_count]), 6);
 		sc->mcast_count++;
 	}
-	IF_ADDR_UNLOCK(sc->ifp);
+	if_maddr_runlock(sc->ifp);
 
 setflag:
 	sc->want_mcsetup = 1;
Index: dev/alc/if_alc.c
===================================================================
--- dev/alc/if_alc.c	(revision 195044)
+++ dev/alc/if_alc.c	(working copy)
@@ -3446,7 +3446,7 @@
 		goto chipit;
 	}
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &sc->alc_ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -3454,7 +3454,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN);
 		mchash[crc >> 31] |= 1 << ((crc >> 26) & 0x1f);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 chipit:
 	CSR_WRITE_4(sc, ALC_MAR0, mchash[0]);
Index: dev/ale/if_ale.c
===================================================================
--- dev/ale/if_ale.c	(revision 195044)
+++ dev/ale/if_ale.c	(working copy)
@@ -3048,7 +3048,7 @@
 	/* Program new filter. */
 	bzero(mchash, sizeof(mchash));
 
-	IF_ADDR_LOCK(ifp);
+	if_maddr_rlock(ifp);
 	TAILQ_FOREACH(ifma, &sc->ale_ifp->if_multiaddrs, ifma_link) {
 		if (ifma->ifma_addr->sa_family != AF_LINK)
 			continue;
@@ -3056,7 +3056,7 @@
 		    ifma->ifma_addr), ETHER_ADDR_LEN);
 		mchash[crc >> 31] |= 1 << ((crc >> 26) & 0x1f);
 	}
-	IF_ADDR_UNLOCK(ifp);
+	if_maddr_runlock(ifp);
 
 	CSR_WRITE_4(sc, ALE_MAR0, mchash[0]);
 	CSR_WRITE_4(sc, ALE_MAR1, mchash[1]);
Index: dev/ath/if_ath.c
===================================================================
--- dev/ath/if_ath.c	(revision 195044)
+++ dev/ath/if_ath.c	(working copy)
@@ -2408,7 +2408,7 @@
 		 * Merge multicast addresses to form the hardware filter.
 		 */
 		mfilt[0] = mfilt[1] = 0;
-		IF_ADDR_LOCK(ifp);	/* XXX need some fiddling to remove? */
+		if_maddr_rlock(ifp);	/* XXX need some fiddling to remove? */
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			caddr_t dl;
 			u_int32_t val;
@@ -2423,7 +2423,7 @@
 			pos &= 0x3f;
 			mfilt[pos / 32] |= (1 << (pos % 32));
 		}
-		IF_ADDR_UNLOCK(ifp);
+		if_maddr_runlock(ifp);
 	} else
 		mfilt[0] = mfilt[1] = ~0;
 	ath_hal_setmcastfilter(sc->sc_ah, mfilt[0], mfilt[1]);
