 @@ -1,14 +1,14 @@
-/*	$NetBSD: if_ethersubr.c,v 1.242.6.4 2018/03/08 14:37:58 martin Exp $	*/
+/*	$NetBSD: if_ethersubr.c,v 1.242.6.5 2018/03/13 15:40:25 martin Exp $	*/
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -51,27 +51,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)if_ethersubr.c	8.2 (Berkeley) 4/4/96
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_ethersubr.c,v 1.242.6.4 2018/03/08 14:37:58 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_ethersubr.c,v 1.242.6.5 2018/03/13 15:40:25 martin Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #include "opt_atalk.h"
 #include "opt_mbuftrace.h"
 #include "opt_mpls.h"
 #include "opt_gateway.h"
 #include "opt_pppoe.h"
 #include "opt_net_mpsafe.h"
 #endif
 #include "vlan.h"
 #include "pppoe.h"
 @@ -182,27 +182,27 @@ static	int ether_output(struct ifnet *,
 /*
  * Ethernet output routine.
  * Encapsulate a packet of type family for the local net.
  * Assumes that ifp is actually pointer to ethercom structure.
  */
 static int
 ether_output(struct ifnet * const ifp0, struct mbuf * const m0,
 	const struct sockaddr * const dst,
 	const struct rtentry *rt)
+{
 	uint16_t etype = 0;
 	int error = 0, hdrcmplt = 0;
- 	uint8_t esrc[6], edst[6];
+	uint8_t esrc[6], edst[6];
 	struct mbuf *m = m0;
 	struct mbuf *mcopy = NULL;
 	struct ether_header *eh;
 	struct ifnet *ifp = ifp0;
 #ifdef INET
 	struct arphdr *ah;
 #endif /* INET */
 #ifdef NETATALK
 	struct at_ifaddr *aa;
 #endif /* NETATALK */
 #ifdef MBUFTRACE
 	m_claimm(m, ifp->if_mowner);
 @@ -291,27 +291,27 @@ ether_output(struct ifnet * const ifp0,
 		else if (m->m_flags & M_MCAST) {
 			ETHER_MAP_IPV6_MULTICAST(&satocsin6(dst)->sin6_addr,
 			    edst);
 		} else {
 			error = nd6_resolve(ifp, rt, m, dst, edst,
 			    sizeof(edst));
 			if (error != 0)
 				return error == EWOULDBLOCK ? 0 : error;
+		}
 		etype = htons(ETHERTYPE_IPV6);
 		break;
 #endif
 #ifdef NETATALK
-    case AF_APPLETALK: {
+	case AF_APPLETALK: {
 		struct ifaddr *ifa;
 		int s;
 		KERNEL_LOCK(1, NULL);
 		if (!aarpresolve(ifp, m, (const struct sockaddr_at *)dst, edst)) {
 #ifdef NETATALKDEBUG
 			printf("aarpresolv failed\n");
 #endif /* NETATALKDEBUG */
 			KERNEL_UNLOCK_ONE(NULL);
 			return (0);
+		}
 		/*
 		 * ifaddr is the first thing in at_ifaddr
 @@ -337,37 +337,37 @@ ether_output(struct ifnet * const ifp0,
 			M_PREPEND(m, sizeof(struct llc), M_DONTWAIT);
 			llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
 			llc.llc_control = LLC_UI;
 			memcpy(llc.llc_snap_org_code, at_org_code,
 			    sizeof(llc.llc_snap_org_code));
 			llc.llc_snap_ether_type = htons(ETHERTYPE_ATALK);
 			memcpy(mtod(m, void *), &llc, sizeof(struct llc));
 		} else {
 			etype = htons(ETHERTYPE_ATALK);
+		}
 		pserialize_read_exit(s);
 		KERNEL_UNLOCK_ONE(NULL);
 		break;
+	}
 #endif /* NETATALK */
 	case pseudo_AF_HDRCMPLT:
 		hdrcmplt = 1;
 		memcpy(esrc,
 		    ((const struct ether_header *)dst->sa_data)->ether_shost,
 		    sizeof(esrc));
 		/* FALLTHROUGH */
 	case AF_UNSPEC:
- 		memcpy(edst,
+		memcpy(edst,
 		    ((const struct ether_header *)dst->sa_data)->ether_dhost,
 		    sizeof(edst));
 		/* AF_UNSPEC doesn't swap the byte order of the ether_type. */
 		etype = ((const struct ether_header *)dst->sa_data)->ether_type;
 		break;
 	default:
 		printf("%s: can't handle af%d\n", ifp->if_xname,
 			dst->sa_family);
 		senderr(EAFNOSUPPORT);
+	}
 #ifdef MPLS
 @@ -391,27 +391,27 @@ ether_output(struct ifnet * const ifp0,
 	 */
 	if (etype == 0)
 		etype = htons(m->m_pkthdr.len);
 	/*
 	 * Add local net header.  If no space in first mbuf,
 	 * allocate another.
 	 */
 	M_PREPEND(m, sizeof (struct ether_header), M_DONTWAIT);
 	if (m == 0)
 		senderr(ENOBUFS);
 	eh = mtod(m, struct ether_header *);
 	/* Note: etype is already in network byte order. */
 	(void)memcpy(&eh->ether_type, &etype, sizeof(eh->ether_type));
- 	memcpy(eh->ether_dhost, edst, sizeof(edst));
+	memcpy(eh->ether_dhost, edst, sizeof(edst));
 	if (hdrcmplt)
 		memcpy(eh->ether_shost, esrc, sizeof(eh->ether_shost));
 	else
 	 	memcpy(eh->ether_shost, CLLADDR(ifp->if_sadl),
 		    sizeof(eh->ether_shost));
 #if NCARP > 0
 	if (ifp0 != ifp && ifp0->if_type == IFT_CARP) {
 	 	memcpy(eh->ether_shost, CLLADDR(ifp0->if_sadl),
 		    sizeof(eh->ether_shost));
+	}
 #endif /* NCARP > 0 */
 @@ -528,27 +528,27 @@ altq_etherclassify(struct ifaltq *ifq, s
 	hdr = mtod(m, void *);
 	if (ALTQ_NEEDS_CLASSIFY(ifq))
 		m->m_pkthdr.pattr_class =
 		    (*ifq->altq_classify)(ifq->altq_clfier, m, af);
 	m->m_pkthdr.pattr_af = af;
 	m->m_pkthdr.pattr_hdr = hdr;
 	m->m_data -= hlen;
 	m->m_len += hlen;
 	return;
- bad:
+bad:
 	m->m_pkthdr.pattr_class = NULL;
 	m->m_pkthdr.pattr_hdr = NULL;
 	m->m_pkthdr.pattr_af = AF_UNSPEC;
+}
 #endif /* ALTQ */
 /*
  * Process a received Ethernet packet;
  * the packet is in the mbuf chain m with
  * the ether header.
  */
 void
 ether_input(struct ifnet *ifp, struct mbuf *m)
 @@ -569,27 +569,27 @@ ether_input(struct ifnet *ifp, struct mb
 	if ((ifp->if_flags & IFF_UP) == 0) {
 		m_freem(m);
 		return;
+	}
 #ifdef MBUFTRACE
 	m_claimm(m, &ec->ec_rx_mowner);
 #endif
 	eh = mtod(m, struct ether_header *);
 	etype = ntohs(eh->ether_type);
 	ehlen = sizeof(*eh);
-	if(__predict_false(earlypkts < 100 || !rnd_initial_entropy)) {
+	if (__predict_false(earlypkts < 100 || !rnd_initial_entropy)) {
 		rnd_add_data(NULL, eh, ehlen, 0);
 		earlypkts++;
+	}
 	/*
 	 * Determine if the packet is within its size limits.
 	 */
 	if (etype != ETHERTYPE_MPLS && m->m_pkthdr.len >
 	    ETHER_MAX_FRAME(ifp, etype, m->m_flags & M_HASFCS)) {
 		mutex_enter(&bigpktpps_lock);
 		if (ppsratecheck(&bigpktppslim_last, &bigpktpps_count,
 			    bigpktppslim)) {
 			printf("%s: discarding oversize frame (len=%d)\n",
 @@ -630,26 +630,27 @@ ether_input(struct ifnet *ifp, struct mb
 #if NCARP > 0
 	if (__predict_false(ifp->if_carp && ifp->if_type != IFT_CARP)) {
 		/*
 		 * clear M_PROMISC, in case the packets comes from a
 		 * vlan
 		 */
 		m->m_flags &= ~M_PROMISC;
 		if (carp_input(m, (uint8_t *)&eh->ether_shost,
 		    (uint8_t *)&eh->ether_dhost, eh->ether_type) == 0)
 			return;
+	}
 #endif /* NCARP > 0 */
 	if ((m->m_flags & (M_BCAST | M_MCAST | M_PROMISC)) == 0 &&
 	    (ifp->if_flags & IFF_PROMISC) != 0 &&
 	    memcmp(CLLADDR(ifp->if_sadl), eh->ether_dhost,
 		   ETHER_ADDR_LEN) != 0) {
 		m->m_flags |= M_PROMISC;
+	}
 	if ((m->m_flags & M_PROMISC) == 0) {
 		if (pfil_run_hooks(ifp->if_pfil, &m, ifp, PFIL_IN) != 0)
 			return;
 		if (m == NULL)
 			return;
 @@ -685,27 +686,27 @@ ether_input(struct ifnet *ifp, struct mb
 		return;
+	}
 	/*
 	 * Handle protocols that expect to have the Ethernet header
 	 * (and possibly FCS) intact.
 	 */
 	switch (etype) {
 	case ETHERTYPE_VLAN: {
 		struct ether_vlan_header *evl = (void *)eh;
 		/*
 		 * If there is a tag of 0, then the VLAN header was probably
 		 * just being used to store the priority.  Extract the ether
 		 * type, and if IP or IPV6, let them deal with it.
 		 */
 		if (m->m_len <= sizeof(*evl)
 		    && EVL_VLANOFTAG(evl->evl_tag) == 0) {
 			etype = ntohs(evl->evl_proto);
 			ehlen = sizeof(*evl);
 			if ((m->m_flags & M_PROMISC) == 0
 			    && (etype == ETHERTYPE_IP
 				|| etype == ETHERTYPE_IPV6))
 				break;
+		}
 #if NVLAN > 0
 		/*
 		 * vlan_input() will either recursively call ether_input()
 @@ -794,27 +795,27 @@ ether_input(struct ifnet *ifp, struct mb
 			inq = &arpintrq;
 			break;
 		case ETHERTYPE_REVARP:
 			revarpinput(m);	/* XXX queue? */
 			return;
 #endif
 #ifdef INET6
 		case ETHERTYPE_IPV6:
 			if (__predict_false(!in6_present)) {
 				m_freem(m);
 				return;
+			}
 #ifdef GATEWAY
 			if (ip6flow_fastforward(&m))
 				return;
 #endif
 			pktq = ip6_pktq;
 			break;
 #endif
 #ifdef NETATALK
 		case ETHERTYPE_ATALK:
 			isr = NETISR_ATALK;
 			inq = &atintrq1;
 			break;
 		case ETHERTYPE_AARP:
 			/* probably this should be done with a NETISR as well */
 @@ -868,30 +869,30 @@ ether_input(struct ifnet *ifp, struct mb
 				    return;
+				}
 			default:
 				goto dropanyway;
+			}
 			break;
 #endif
 		dropanyway:
 		default:
 			m_freem(m);
 			return;
+		}
-#else /* ISO || LLC || NETATALK*/
+#else /* LLC || NETATALK */
 		m_freem(m);
 		return;
-#endif /* ISO || LLC || NETATALK*/
+#endif /* LLC || NETATALK */
+	}
 	if (__predict_true(pktq)) {
 #ifdef NET_MPSAFE
 		const u_int h = curcpu()->ci_index;
 #else
 		const uint32_t h = pktq_rps_hash(m);
 #endif
 		if (__predict_false(!pktq_enqueue(pktq, m, h))) {
 			m_freem(m);
+		}
 		return;
+	}
 @@ -987,43 +988,41 @@ ether_ifdetach(struct ifnet *ifp)
 	/*
 	 * Prevent further calls to ioctl (for example turning off
 	 * promiscuous mode from the bridge code), which eventually can
 	 * call if_init() which can cause panics because the interface
 	 * is in the process of being detached. Return device not configured
 	 * instead.
 	 */
 	ifp->if_ioctl = (int (*)(struct ifnet *, u_long, void *))enxio;
 #if NBRIDGE > 0
 	if (ifp->if_bridge)
 		bridge_ifdetach(ifp);
 #endif
 	bpf_detach(ifp);
 #if NVLAN > 0
 	if (ec->ec_nvlans)
 		vlan_ifdetach(ifp);
 #endif
 	ETHER_LOCK(ec);
 	while ((enm = LIST_FIRST(&ec->ec_multiaddrs)) != NULL) {
 		LIST_REMOVE(enm, enm_list);
-		kmem_intr_free(enm, sizeof(*enm));
+		kmem_free(enm, sizeof(*enm));
 		ec->ec_multicnt--;
+	}
 	ETHER_UNLOCK(ec);
-	mutex_destroy(ec->ec_lock);
+	mutex_obj_free(ec->ec_lock);
 	ifp->if_mowner = NULL;
 	MOWNER_DETACH(&ec->ec_rx_mowner);
 	MOWNER_DETACH(&ec->ec_tx_mowner);
+}
 #if 0
 /*
  * This is for reference.  We have a table-driven version
  * of the little-endian crc32 generator, which is faster
  * than the double-loop.
  */
 uint32_t
 @@ -1103,57 +1102,59 @@ const uint8_t ether_ipmulticast_max[ETHE
 #ifdef INET6
 const uint8_t ether_ip6multicast_min[ETHER_ADDR_LEN] =
     { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 };
 const uint8_t ether_ip6multicast_max[ETHER_ADDR_LEN] =
     { 0x33, 0x33, 0xff, 0xff, 0xff, 0xff };
 #endif
 /*
  * ether_aton implementation, not using a static buffer.
  */
 int
 ether_aton_r(u_char *dest, size_t len, const char *str)
+{
-        const u_char *cp = (const void *)str;
+	const u_char *cp = (const void *)str;
 	u_char *ep;
 #define atox(c)	(((c) <= '9') ? ((c) - '0') : ((toupper(c) - 'A') + 10))
 	if (len < ETHER_ADDR_LEN)
 		return ENOSPC;
 	ep = dest + ETHER_ADDR_LEN;
 	while (*cp) {
-                if (!isxdigit(*cp))
+		if (!isxdigit(*cp))
-                        return EINVAL;
+			return EINVAL;
 		*dest = atox(*cp);
 		cp++;
-                if (isxdigit(*cp)) {
+		if (isxdigit(*cp)) {
-                        *dest = (*dest << 4) | atox(*cp);
+			*dest = (*dest << 4) | atox(*cp);
 			dest++;
 			cp++;
                 } else
-			dest++;
+		dest++;
 		if (dest == ep)
-			return *cp == '\0' ? 0 : ENAMETOOLONG;
+			return (*cp == '\0') ? 0 : ENAMETOOLONG;
 		switch (*cp) {
 		case ':':
 		case '-':
 		case '.':
 			cp++;
 			break;
+		}
+	}
 	return ENOBUFS;
+}
 /*
  * Convert a sockaddr into an Ethernet address or range of Ethernet
  * addresses.
  */
 int
 ether_multiaddr(const struct sockaddr *sa, uint8_t addrlo[ETHER_ADDR_LEN],
     uint8_t addrhi[ETHER_ADDR_LEN])
+{
 #ifdef INET
 	const struct sockaddr_in *sin;
 @@ -1171,28 +1172,27 @@ ether_multiaddr(const struct sockaddr *s
 #ifdef INET
 	case AF_INET:
 		sin = satocsin(sa);
 		if (sin->sin_addr.s_addr == INADDR_ANY) {
 			/*
 			 * An IP address of INADDR_ANY means listen to
 			 * or stop listening to all of the Ethernet
 			 * multicast addresses used for IP.
 			 * (This is for the sake of IP multicast routers.)
 			 */
 			memcpy(addrlo, ether_ipmulticast_min, ETHER_ADDR_LEN);
 			memcpy(addrhi, ether_ipmulticast_max, ETHER_ADDR_LEN);
 		} else {
 		else {
 			ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
 			memcpy(addrhi, addrlo, ETHER_ADDR_LEN);
+		}
 		break;
 #endif
 #ifdef INET6
 	case AF_INET6:
 		sin6 = satocsin6(sa);
 		if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
 			/*
 			 * An IP6 address of 0 means listen to or stop
 			 * listening to all of the Ethernet multicast
 			 * address used for IP6.
 @@ -1216,120 +1216,123 @@ ether_multiaddr(const struct sockaddr *s
 /*
  * Add an Ethernet multicast address or range of addresses to the list for a
  * given interface.
  */
 int
 ether_addmulti(const struct sockaddr *sa, struct ethercom *ec)
+{
 	struct ether_multi *enm, *_enm;
 	u_char addrlo[ETHER_ADDR_LEN];
 	u_char addrhi[ETHER_ADDR_LEN];
 	int error = 0;
 	/* Allocate out of lock */
-	/* XXX still can be called in softint */
+	enm = kmem_alloc(sizeof(*enm), KM_SLEEP);
 	enm = kmem_intr_alloc(sizeof(*enm), KM_SLEEP);
 	if (enm == NULL)
 		return ENOBUFS;
 	ETHER_LOCK(ec);
 	error = ether_multiaddr(sa, addrlo, addrhi);
 	if (error != 0)
 		goto out;
 	/*
 	 * Verify that we have valid Ethernet multicast addresses.
 	 */
 	if (!ETHER_IS_MULTICAST(addrlo) || !ETHER_IS_MULTICAST(addrhi)) {
 		error = EINVAL;
 		goto out;
+	}
 	/*
 	 * See if the address range is already in the list.
 	 */
 	ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, _enm);
 	if (_enm != NULL) {
 		/*
 		 * Found it; just increment the reference count.
 		 */
 		++_enm->enm_refcount;
 		error = 0;
 		goto out;
+	}
 	/*
 	 * Link a new multicast record into the interface's multicast list.
 	 */
-	memcpy(enm->enm_addrlo, addrlo, 6);
+	memcpy(enm->enm_addrlo, addrlo, ETHER_ADDR_LEN);
-	memcpy(enm->enm_addrhi, addrhi, 6);
+	memcpy(enm->enm_addrhi, addrhi, ETHER_ADDR_LEN);
 	enm->enm_refcount = 1;
 	LIST_INSERT_HEAD(&ec->ec_multiaddrs, enm, enm_list);
 	ec->ec_multicnt++;
 	/*
 	 * Return ENETRESET to inform the driver that the list has changed
 	 * and its reception filter should be adjusted accordingly.
 	 */
 	error = ENETRESET;
 	enm = NULL;
 out:
 	ETHER_UNLOCK(ec);
 	if (enm != NULL)
-		kmem_intr_free(enm, sizeof(*enm));
+		kmem_free(enm, sizeof(*enm));
 	return error;
+}
 /*
  * Delete a multicast address record.
  */
 int
 ether_delmulti(const struct sockaddr *sa, struct ethercom *ec)
+{
 	struct ether_multi *enm;
 	u_char addrlo[ETHER_ADDR_LEN];
 	u_char addrhi[ETHER_ADDR_LEN];
 	int error;
 	ETHER_LOCK(ec);
 	error = ether_multiaddr(sa, addrlo, addrhi);
 	if (error != 0)
 		goto error;
 	/*
-	 * Look ur the address in our list.
+	 * Look up the address in our list.
 	 */
 	ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, enm);
 	if (enm == NULL) {
 		error = ENXIO;
 		goto error;
+	}
 	if (--enm->enm_refcount != 0) {
 		/*
 		 * Still some claims to this record.
 		 */
 		error = 0;
 		goto error;
+	}
 	/*
 	 * No remaining claims to this record; unlink and free it.
 	 */
 	LIST_REMOVE(enm, enm_list);
 	ec->ec_multicnt--;
 	ETHER_UNLOCK(ec);
 	kmem_free(enm, sizeof(*enm));
 	kmem_intr_free(enm, sizeof(*enm));
 	/*
 	 * Return ENETRESET to inform the driver that the list has changed
 	 * and its reception filter should be adjusted accordingly.
 	 */
 	return ENETRESET;
 error:
 	ETHER_UNLOCK(ec);
 	return error;
+}
 void
 ether_set_ifflags_cb(struct ethercom *ec, ether_cb_t cb)
+{
 	ec->ec_ifflags_cb = cb;
+}
 /*
  * Common ioctls for Ethernet interfaces.  Note, we must be
 @@ -1350,27 +1353,27 @@ ether_ioctl(struct ifnet *ifp, u_long cm
 	case SIOCINITIFADDR:
+	    {
 		struct ifaddr *ifa = (struct ifaddr *)data;
 		if (ifa->ifa_addr->sa_family != AF_LINK
 		    && (ifp->if_flags & (IFF_UP | IFF_RUNNING)) !=
 		       (IFF_UP | IFF_RUNNING)) {
 			ifp->if_flags |= IFF_UP;
 			if ((error = (*ifp->if_init)(ifp)) != 0)
 				return error;
+		}
 #ifdef INET
 		if (ifa->ifa_addr->sa_family == AF_INET)
 			arp_ifinit(ifp, ifa);
-#endif /* INET */
+#endif
 		return 0;
+	    }
 	case SIOCSIFMTU:
+	    {
 		int maxmtu;
 		if (ec->ec_capabilities & ETHERCAP_JUMBO_MTU)
 			maxmtu = ETHERMTU_JUMBO;
 		else
 			maxmtu = ETHERMTU;
 		if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > maxmtu)
 @@ -1492,27 +1495,27 @@ ether_disable_vlan_mtu(struct ifnet *ifp
 	/* We still have VLAN's, defer for later */
 	if (ec->ec_nvlans != 0)
 		return 0;
 	/* Parent does not support VLAB's, nothing to do. */
 	if ((ec->ec_capenable & ETHERCAP_VLAN_MTU) == 0)
 		return -1;
 	/*
 	 * Disable Tx/Rx of VLAN-sized frames.
 	 */
 	ec->ec_capenable &= ~ETHERCAP_VLAN_MTU;
 	/* Interface is down, defer for later */
 	if ((ifp->if_flags & IFF_UP) == 0)
 		return 0;
 	if ((error = if_flags_set(ifp, ifp->if_flags)) == 0)
 		return 0;
 	ec->ec_capenable |= ETHERCAP_VLAN_MTU;
 	return error;
+}
 static int
 ether_multicast_sysctl(SYSCTLFN_ARGS)
 @@ -1542,36 +1545,43 @@ ether_multicast_sysctl(SYSCTLFN_ARGS)
 		*oldlenp = 0;
 		goto out;
+	}
 	ec = (struct ethercom *)ifp;
 	if (oldp == NULL) {
 		if_put(ifp, &psref);
 		*oldlenp = ec->ec_multicnt * sizeof(*addrs);
 		goto out;
+	}
 	/*
 	 * ec->ec_lock is a spin mutex so we cannot call sysctl_copyout, which
-	 * is sleepable, with holding it. Copy data to a local buffer first
+	 * is sleepable, while holding it. Copy data to a local buffer first
-	 * with holding it and then call sysctl_copyout without holding it.
+	 * with the lock taken and then call sysctl_copyout without holding it.
 	 */
 retry:
 	multicnt = ec->ec_multicnt;
 	addrs = kmem_alloc(sizeof(*addrs) * multicnt, KM_SLEEP);
 	if (multicnt == 0) {
 		if_put(ifp, &psref);
 		*oldlenp = 0;
 		goto out;
+	}
 	addrs = kmem_zalloc(sizeof(*addrs) * multicnt, KM_SLEEP);
 	ETHER_LOCK(ec);
-	if (multicnt < ec->ec_multicnt) {
+	if (multicnt != ec->ec_multicnt) {
-		/* The number of multicast addresses have increased */
+		/* The number of multicast addresses has changed */
 		ETHER_UNLOCK(ec);
 		kmem_free(addrs, sizeof(*addrs) * multicnt);
 		goto retry;
+	}
 	i = 0;
 	LIST_FOREACH(enm, &ec->ec_multiaddrs, enm_list) {
 		struct ether_multi_sysctl *addr = &addrs[i];
 		addr->enm_refcount = enm->enm_refcount;
 		memcpy(addr->enm_addrlo, enm->enm_addrlo, ETHER_ADDR_LEN);
 		memcpy(addr->enm_addrhi, enm->enm_addrhi, ETHER_ADDR_LEN);
 		i++;
+	}