 @@ -1,1887 +1,1900 @@
-/*	$NetBSD: if_ethersubr.c,v 1.322 2022/11/15 09:14:28 roy Exp $	*/
+/*	$NetBSD: if_ethersubr.c,v 1.323 2022/11/15 10:47:39 roy 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.
  * 3. Neither the name of the project nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT 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.
  */
 /*
  * Copyright (c) 1982, 1989, 1993
  *	The Regents of the University of California.  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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * 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.322 2022/11/15 09:14:28 roy Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_ethersubr.c,v 1.323 2022/11/15 10:47:39 roy 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"
 #include "bridge.h"
 #include "arp.h"
 #include "agr.h"
 #include <sys/sysctl.h>
 #include <sys/mbuf.h>
 #include <sys/mutex.h>
 #include <sys/ioctl.h>
 #include <sys/errno.h>
 #include <sys/device.h>
 #include <sys/entropy.h>
 #include <sys/rndsource.h>
 #include <sys/cpu.h>
 #include <sys/kmem.h>
 #include <sys/hook.h>
 #include <net/if.h>
 #include <net/route.h>
 #include <net/if_llc.h>
 #include <net/if_dl.h>
 #include <net/if_types.h>
 #include <net/pktqueue.h>
 #include <net/if_media.h>
 #include <dev/mii/mii.h>
 #include <dev/mii/miivar.h>
 #if NARP == 0
 /*
  * XXX there should really be a way to issue this warning from within config(8)
  */
 #error You have included NETATALK or a pseudo-device in your configuration that depends on the presence of ethernet interfaces, but have no such interfaces configured. Check if you really need pseudo-device bridge, pppoe, vlan or options NETATALK.
 #endif
 #include <net/bpf.h>
 #include <net/if_ether.h>
 #include <net/if_vlanvar.h>
 #if NPPPOE > 0
 #include <net/if_pppoe.h>
 #endif
 #if NAGR > 0
 #include <net/ether_slowprotocols.h>
 #include <net/agr/ieee8023ad.h>
 #include <net/agr/if_agrvar.h>
 #endif
 #if NBRIDGE > 0
 #include <net/if_bridgevar.h>
 #endif
 #include <netinet/in.h>
 #ifdef INET
 #include <netinet/in_var.h>
 #endif
 #include <netinet/if_inarp.h>
 #ifdef INET6
 #ifndef INET
 #include <netinet/in.h>
 #endif
 #include <netinet6/in6_var.h>
 #include <netinet6/nd6.h>
 #endif
 #include "carp.h"
 #if NCARP > 0
 #include <netinet/ip_carp.h>
 #endif
 #ifdef NETATALK
 #include <netatalk/at.h>
 #include <netatalk/at_var.h>
 #include <netatalk/at_extern.h>
 #define llc_snap_org_code llc_un.type_snap.org_code
 #define llc_snap_ether_type llc_un.type_snap.ether_type
 extern u_char	at_org_code[3];
 extern u_char	aarp_org_code[3];
 #endif /* NETATALK */
 #ifdef MPLS
 #include <netmpls/mpls.h>
 #include <netmpls/mpls_var.h>
 #endif
 CTASSERT(sizeof(struct ether_addr) == 6);
 CTASSERT(sizeof(struct ether_header) == 14);
 #ifdef DIAGNOSTIC
 static struct timeval bigpktppslim_last;
 static int bigpktppslim = 2;	/* XXX */
 static int bigpktpps_count;
 static kmutex_t bigpktpps_lock __cacheline_aligned;
 #endif
 const uint8_t etherbroadcastaddr[ETHER_ADDR_LEN] =
     { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 const uint8_t ethermulticastaddr_slowprotocols[ETHER_ADDR_LEN] =
     { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x02 };
 #define senderr(e) { error = (e); goto bad;}
 static pktq_rps_hash_func_t ether_pktq_rps_hash_p;
 static int ether_output(struct ifnet *, struct mbuf *,
     const struct sockaddr *, const struct rtentry *);
 /*
  * 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)
+{
 	uint8_t esrc[ETHER_ADDR_LEN], edst[ETHER_ADDR_LEN];
 	uint16_t etype = 0;
 	int error = 0, hdrcmplt = 0;
 	struct mbuf *m = m0;
 	struct mbuf *mcopy = NULL;
 	struct ether_header *eh;
 	struct ifnet *ifp = ifp0;
 #ifdef INET
 	struct arphdr *ah;
 #endif
 #ifdef NETATALK
 	struct at_ifaddr *aa;
 #endif
 #ifdef MBUFTRACE
 	m_claimm(m, ifp->if_mowner);
 #endif
 #if NCARP > 0
 	if (ifp->if_type == IFT_CARP) {
 		struct ifaddr *ifa;
 		int s = pserialize_read_enter();
 		/* loop back if this is going to the carp interface */
 		if (dst != NULL && ifp0->if_link_state == LINK_STATE_UP &&
 		    (ifa = ifa_ifwithaddr(dst)) != NULL) {
 			if (ifa->ifa_ifp == ifp0) {
 				pserialize_read_exit(s);
 				return looutput(ifp0, m, dst, rt);
+			}
+		}
 		pserialize_read_exit(s);
 		ifp = ifp->if_carpdev;
 		/* ac = (struct arpcom *)ifp; */
 		if ((ifp0->if_flags & (IFF_UP | IFF_RUNNING)) !=
 		    (IFF_UP | IFF_RUNNING))
 			senderr(ENETDOWN);
+	}
 #endif
 	if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) != (IFF_UP | IFF_RUNNING))
 		senderr(ENETDOWN);
 	switch (dst->sa_family) {
 #ifdef INET
 	case AF_INET:
 		if (m->m_flags & M_BCAST) {
 			memcpy(edst, etherbroadcastaddr, sizeof(edst));
 		} else if (m->m_flags & M_MCAST) {
 			ETHER_MAP_IP_MULTICAST(&satocsin(dst)->sin_addr, edst);
 		} else {
 			error = arpresolve(ifp0, rt, m, dst, edst, sizeof(edst));
 			if (error)
 				return (error == EWOULDBLOCK) ? 0 : error;
+		}
 		/* If broadcasting on a simplex interface, loopback a copy */
 		if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
 			mcopy = m_copypacket(m, M_DONTWAIT);
 		etype = htons(ETHERTYPE_IP);
 		break;
 	case AF_ARP:
 		ah = mtod(m, struct arphdr *);
 		if (m->m_flags & M_BCAST) {
 			memcpy(edst, etherbroadcastaddr, sizeof(edst));
 		} else {
 			void *tha = ar_tha(ah);
 			if (tha == NULL) {
 				/* fake with ARPHRD_IEEE1394 */
 				m_freem(m);
 				return 0;
+			}
 			memcpy(edst, tha, sizeof(edst));
+		}
 		ah->ar_hrd = htons(ARPHRD_ETHER);
 		switch (ntohs(ah->ar_op)) {
 		case ARPOP_REVREQUEST:
 		case ARPOP_REVREPLY:
 			etype = htons(ETHERTYPE_REVARP);
 			break;
 		case ARPOP_REQUEST:
 		case ARPOP_REPLY:
 		default:
 			etype = htons(ETHERTYPE_ARP);
+		}
 		break;
 #endif
 #ifdef INET6
 	case AF_INET6:
 		if (m->m_flags & M_BCAST) {
 			memcpy(edst, etherbroadcastaddr, sizeof(edst));
 		} else if (m->m_flags & M_MCAST) {
 			ETHER_MAP_IPV6_MULTICAST(&satocsin6(dst)->sin6_addr,
 			    edst);
 		} else {
 			error = nd6_resolve(ifp0, rt, m, dst, edst,
 			    sizeof(edst));
 			if (error)
 				return (error == EWOULDBLOCK) ? 0 : error;
+		}
 		etype = htons(ETHERTYPE_IPV6);
 		break;
 #endif
 #ifdef NETATALK
 	case AF_APPLETALK: {
 		struct ifaddr *ifa;
 		int s;
 		KERNEL_LOCK(1, NULL);
 		if (!aarpresolve(ifp, m, (const struct sockaddr_at *)dst, edst)) {
 			KERNEL_UNLOCK_ONE(NULL);
 			return 0;
+		}
 		/*
 		 * ifaddr is the first thing in at_ifaddr
 		 */
 		s = pserialize_read_enter();
 		ifa = at_ifawithnet((const struct sockaddr_at *)dst, ifp);
 		if (ifa == NULL) {
 			pserialize_read_exit(s);
 			KERNEL_UNLOCK_ONE(NULL);
 			senderr(EADDRNOTAVAIL);
+		}
 		aa = (struct at_ifaddr *)ifa;
 		/*
 		 * In the phase 2 case, we need to prepend an mbuf for the
 		 * llc header.
 		 */
 		if (aa->aa_flags & AFA_PHASE2) {
 			struct llc llc;
 			M_PREPEND(m, sizeof(struct llc), M_DONTWAIT);
 			if (m == NULL) {
 				pserialize_read_exit(s);
 				KERNEL_UNLOCK_ONE(NULL);
 				senderr(ENOBUFS);
+			}
 			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,
 		    ((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
+	{
 		struct m_tag *mtag;
 		mtag = m_tag_find(m, PACKET_TAG_MPLS);
 		if (mtag != NULL) {
 			/* Having the tag itself indicates it's MPLS */
 			etype = htons(ETHERTYPE_MPLS);
 			m_tag_delete(m, mtag);
+		}
+	}
 #endif
 	if (mcopy)
 		(void)looutput(ifp, mcopy, dst, rt);
 	KASSERT((m->m_flags & M_PKTHDR) != 0);
 	/*
 	 * If no ether type is set, this must be a 802.2 formatted packet.
 	 */
 	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 == NULL)
 		senderr(ENOBUFS);
 	eh = mtod(m, struct ether_header *);
 	/* Note: etype is already in network byte order. */
 	memcpy(&eh->ether_type, &etype, sizeof(eh->ether_type));
 	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
 	if ((error = pfil_run_hooks(ifp->if_pfil, &m, ifp, PFIL_OUT)) != 0)
 		return error;
 	if (m == NULL)
 		return 0;
 #if NBRIDGE > 0
 	/*
 	 * Bridges require special output handling.
 	 */
 	if (ifp->if_bridge)
 		return bridge_output(ifp, m, NULL, NULL);
 #endif
 #if NCARP > 0
 	if (ifp != ifp0)
 		if_statadd(ifp0, if_obytes, m->m_pkthdr.len + ETHER_HDR_LEN);
 #endif
 #ifdef ALTQ
 	KERNEL_LOCK(1, NULL);
 	/*
 	 * If ALTQ is enabled on the parent interface, do
 	 * classification; the queueing discipline might not
 	 * require classification, but might require the
 	 * address family/header pointer in the pktattr.
 	 */
 	if (ALTQ_IS_ENABLED(&ifp->if_snd))
 		altq_etherclassify(&ifp->if_snd, m);
 	KERNEL_UNLOCK_ONE(NULL);
 #endif
 	return ifq_enqueue(ifp, m);
 bad:
 	if_statinc(ifp, if_oerrors);
 	if (m)
 		m_freem(m);
 	return error;
+}
 #ifdef ALTQ
 /*
  * This routine is a slight hack to allow a packet to be classified
  * if the Ethernet headers are present.  It will go away when ALTQ's
  * classification engine understands link headers.
+ *
  * XXX: We may need to do m_pullups here. First to ensure struct ether_header
  * is indeed contiguous, then to read the LLC and so on.
  */
 void
 altq_etherclassify(struct ifaltq *ifq, struct mbuf *m)
+{
 	struct ether_header *eh;
 	struct mbuf *mtop = m;
 	uint16_t ether_type;
 	int hlen, af, hdrsize;
 	void *hdr;
 	KASSERT((mtop->m_flags & M_PKTHDR) != 0);
 	hlen = ETHER_HDR_LEN;
 	eh = mtod(m, struct ether_header *);
 	ether_type = htons(eh->ether_type);
 	if (ether_type < ETHERMTU) {
 		/* LLC/SNAP */
 		struct llc *llc = (struct llc *)(eh + 1);
 		hlen += 8;
 		if (m->m_len < hlen ||
 		    llc->llc_dsap != LLC_SNAP_LSAP ||
 		    llc->llc_ssap != LLC_SNAP_LSAP ||
 		    llc->llc_control != LLC_UI) {
 			/* Not SNAP. */
 			goto bad;
+		}
 		ether_type = htons(llc->llc_un.type_snap.ether_type);
+	}
 	switch (ether_type) {
 	case ETHERTYPE_IP:
 		af = AF_INET;
 		hdrsize = 20;		/* sizeof(struct ip) */
 		break;
 	case ETHERTYPE_IPV6:
 		af = AF_INET6;
 		hdrsize = 40;		/* sizeof(struct ip6_hdr) */
 		break;
 	default:
 		af = AF_UNSPEC;
 		hdrsize = 0;
 		break;
+	}
 	while (m->m_len <= hlen) {
 		hlen -= m->m_len;
 		m = m->m_next;
 		if (m == NULL)
 			goto bad;
+	}
 	if (m->m_len < (hlen + hdrsize)) {
 		/*
 		 * protocol header not in a single mbuf.
 		 * We can't cope with this situation right
 		 * now (but it shouldn't ever happen, really, anyhow).
 		 */
 #ifdef DEBUG
 		printf("altq_etherclassify: headers span multiple mbufs: "
 		    "%d < %d\n", m->m_len, (hlen + hdrsize));
 #endif
 		goto bad;
+	}
 	m->m_data += hlen;
 	m->m_len -= hlen;
 	hdr = mtod(m, void *);
 	if (ALTQ_NEEDS_CLASSIFY(ifq)) {
 		mtop->m_pkthdr.pattr_class =
 		    (*ifq->altq_classify)(ifq->altq_clfier, m, af);
+	}
 	mtop->m_pkthdr.pattr_af = af;
 	mtop->m_pkthdr.pattr_hdr = hdr;
 	m->m_data -= hlen;
 	m->m_len += hlen;
 	return;
 bad:
 	mtop->m_pkthdr.pattr_class = NULL;
 	mtop->m_pkthdr.pattr_hdr = NULL;
 	mtop->m_pkthdr.pattr_af = AF_UNSPEC;
+}
 #endif /* ALTQ */
 #if defined (LLC) || defined (NETATALK)
 static void
 ether_input_llc(struct ifnet *ifp, struct mbuf *m, struct ether_header *eh)
+{
 	pktqueue_t *pktq = NULL;
 	struct llc *l;
 	if (m->m_len < sizeof(*eh) + sizeof(struct llc))
 		goto error;
 	l = (struct llc *)(eh+1);
 	switch (l->llc_dsap) {
 #ifdef NETATALK
 	case LLC_SNAP_LSAP:
 		switch (l->llc_control) {
 		case LLC_UI:
 			if (l->llc_ssap != LLC_SNAP_LSAP)
 				goto error;
 			if (memcmp(&(l->llc_snap_org_code)[0],
 			    at_org_code, sizeof(at_org_code)) == 0 &&
 			    ntohs(l->llc_snap_ether_type) ==
 			    ETHERTYPE_ATALK) {
 				pktq = at_pktq2;
 				m_adj(m, sizeof(struct ether_header)
 				    + sizeof(struct llc));
 				break;
+			}
 			if (memcmp(&(l->llc_snap_org_code)[0],
 			    aarp_org_code,
 			    sizeof(aarp_org_code)) == 0 &&
 			    ntohs(l->llc_snap_ether_type) ==
 			    ETHERTYPE_AARP) {
 				m_adj(m, sizeof(struct ether_header)
 				    + sizeof(struct llc));
 				aarpinput(ifp, m); /* XXX queue? */
 				return;
+			}
 		default:
 			goto error;
+		}
 		break;
 #endif
 	default:
 		goto noproto;
+	}
 	KASSERT(pktq != NULL);
 	if (__predict_false(!pktq_enqueue(pktq, m, 0))) {
 		m_freem(m);
+	}
 	return;
 noproto:
 	m_freem(m);
 	if_statinc(ifp, if_noproto);
 	return;
 error:
 	m_freem(m);
 	if_statinc(ifp, if_ierrors);
 	return;
+}
 #endif /* defined (LLC) || defined (NETATALK) */
 /*
  * 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)
+{
 #if NVLAN > 0 || defined(MBUFTRACE)
 	struct ethercom *ec = (struct ethercom *) ifp;
 #endif
 	pktqueue_t *pktq = NULL;
 	uint16_t etype;
 	struct ether_header *eh;
 	size_t ehlen;
 	static int earlypkts;
 	/* No RPS for not-IP. */
 	pktq_rps_hash_func_t rps_hash = NULL;
 	KASSERT(!cpu_intr_p());
 	KASSERT((m->m_flags & M_PKTHDR) != 0);
 	if ((ifp->if_flags & IFF_UP) == 0)
 		goto drop;
 #ifdef MBUFTRACE
 	m_claimm(m, &ec->ec_rx_mowner);
 #endif
 	if (__predict_false(m->m_len < sizeof(*eh))) {
 		if ((m = m_pullup(m, sizeof(*eh))) == NULL) {
 			if_statinc(ifp, if_ierrors);
 			return;
+		}
+	}
 	eh = mtod(m, struct ether_header *);
 	etype = ntohs(eh->ether_type);
 	ehlen = sizeof(*eh);
 	if (__predict_false(earlypkts < 100 ||
 		entropy_epoch() == (unsigned)-1)) {
 		rnd_add_data(NULL, eh, ehlen, 0);
 		earlypkts++;
+	}
 	/*
 	 * Determine if the packet is within its size limits. For MPLS the
 	 * header length is variable, so we skip the check.
 	 */
 	if (etype != ETHERTYPE_MPLS && m->m_pkthdr.len >
 	    ETHER_MAX_FRAME(ifp, etype, m->m_flags & M_HASFCS)) {
 #ifdef DIAGNOSTIC
 		mutex_enter(&bigpktpps_lock);
 		if (ppsratecheck(&bigpktppslim_last, &bigpktpps_count,
 		    bigpktppslim)) {
 			printf("%s: discarding oversize frame (len=%d)\n",
 			    ifp->if_xname, m->m_pkthdr.len);
+		}
 		mutex_exit(&bigpktpps_lock);
 #endif
 		goto error;
+	}
 	if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
 		/*
 		 * If this is not a simplex interface, drop the packet
 		 * if it came from us.
 		 */
 		if ((ifp->if_flags & IFF_SIMPLEX) == 0 &&
 		    memcmp(CLLADDR(ifp->if_sadl), eh->ether_shost,
 		    ETHER_ADDR_LEN) == 0) {
 			goto drop;
+		}
 		if (memcmp(etherbroadcastaddr,
 		    eh->ether_dhost, ETHER_ADDR_LEN) == 0)
 			m->m_flags |= M_BCAST;
 		else
 			m->m_flags |= M_MCAST;
 		if_statinc(ifp, if_imcasts);
+	}
 	/* If the CRC is still on the packet, trim it off. */
 	if (m->m_flags & M_HASFCS) {
 		m_adj(m, -ETHER_CRC_LEN);
 		m->m_flags &= ~M_HASFCS;
+	}
 	if_statadd(ifp, if_ibytes, m->m_pkthdr.len);
 	if (!vlan_has_tag(m) && etype == ETHERTYPE_VLAN) {
 		m = ether_strip_vlantag(m);
 		if (m == NULL) {
 			if_statinc(ifp, if_ierrors);
 			return;
+		}
 		eh = mtod(m, struct ether_header *);
 		etype = ntohs(eh->ether_type);
 		ehlen = sizeof(*eh);
+	}
 	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;
 		eh = mtod(m, struct ether_header *);
 		etype = ntohs(eh->ether_type);
+	}
 	/*
 	 * Processing a logical interfaces that are able
 	 * to configure vlan(4).
 	*/
 #if NAGR > 0
 	if (ifp->if_lagg != NULL &&
 	    __predict_true(etype != ETHERTYPE_SLOWPROTOCOLS)) {
 		m->m_flags &= ~M_PROMISC;
 		agr_input(ifp, m);
 		return;
+	}
 #endif
 	/*
 	 * VLAN processing.
+	 *
 	 * VLAN provides service delimiting so the frames are
 	 * processed before other handlings. If a VLAN interface
 	 * does not exist to take those frames, they're returned
 	 * to ether_input().
 	 */
 	if (vlan_has_tag(m)) {
 		if (EVL_VLANOFTAG(vlan_get_tag(m)) == 0) {
 			if (etype == ETHERTYPE_VLAN ||
 			     etype == ETHERTYPE_QINQ)
 				goto drop;
 			/* XXX we should actually use the prio value? */
 			m->m_flags &= ~M_VLANTAG;
 		} else {
 #if NVLAN > 0
 			if (ec->ec_nvlans > 0) {
 				m = vlan_input(ifp, m);
 				/* vlan_input() called ether_input() recursively */
 				if (m == NULL)
 					return;
+			}
 #endif
 			/* drop VLAN frames not for this port. */
 			goto noproto;
+		}
+	}
 #if NCARP > 0
 	if (__predict_false(ifp->if_carp && ifp->if_type != IFT_CARP)) {
 		/*
 		 * Clear M_PROMISC, in case the packet 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
 	/*
 	 * Handle protocols that expect to have the Ethernet header
 	 * (and possibly FCS) intact.
 	 */
 	switch (etype) {
 #if NPPPOE > 0
 	case ETHERTYPE_PPPOEDISC:
 		pppoedisc_input(ifp, m);
 		return;
 	case ETHERTYPE_PPPOE:
 		pppoe_input(ifp, m);
 		return;
 #endif
 	case ETHERTYPE_SLOWPROTOCOLS: {
 		uint8_t subtype;
 		if (m->m_pkthdr.len < sizeof(*eh) + sizeof(subtype))
 			goto error;
 		m_copydata(m, sizeof(*eh), sizeof(subtype), &subtype);
 		switch (subtype) {
 #if NAGR > 0
 		case SLOWPROTOCOLS_SUBTYPE_LACP:
 			if (ifp->if_lagg != NULL) {
 				ieee8023ad_lacp_input(ifp, m);
 				return;
+			}
 			break;
 		case SLOWPROTOCOLS_SUBTYPE_MARKER:
 			if (ifp->if_lagg != NULL) {
 				ieee8023ad_marker_input(ifp, m);
 				return;
+			}
 			break;
 #endif
 		default:
 			if (subtype == 0 || subtype > 10) {
 				/* illegal value */
 				goto error;
+			}
 			/* unknown subtype */
 			break;
+		}
+	}
 	/* FALLTHROUGH */
 	default:
 		if (m->m_flags & M_PROMISC)
 			goto drop;
+	}
 	/* If the CRC is still on the packet, trim it off. */
 	if (m->m_flags & M_HASFCS) {
 		m_adj(m, -ETHER_CRC_LEN);
 		m->m_flags &= ~M_HASFCS;
+	}
 	/* etype represents the size of the payload in this case */
 	if (etype <= ETHERMTU + sizeof(struct ether_header)) {
 		KASSERT(ehlen == sizeof(*eh));
 #if defined (LLC) || defined (NETATALK)
 		ether_input_llc(ifp, m, eh);
 		return;
 #else
 		/* ethertype of 0-1500 is regarded as noproto */
 		goto noproto;
 #endif
+	}
 	/* For ARP packets, store the source address so that
 	 * ARP DAD probes can be validated. */
 	if (etype == ETHERTYPE_ARP) {
 		struct m_tag *mtag;
 		mtag = m_tag_get(PACKET_TAG_ETHERNET_SRC, ETHER_ADDR_LEN,
 		    M_NOWAIT);
 		if (mtag != NULL) {
 			memcpy(mtag + 1, &eh->ether_shost, ETHER_ADDR_LEN);
 			m_tag_prepend(m, mtag);
+		}
+	}
 	/* Strip off the Ethernet header. */
 	m_adj(m, ehlen);
 	switch (etype) {
 #ifdef INET
 	case ETHERTYPE_IP:
 #ifdef GATEWAY
 		if (ipflow_fastforward(m))
 			return;
 #endif
 		pktq = ip_pktq;
 		rps_hash = atomic_load_relaxed(&ether_pktq_rps_hash_p);
 		break;
 	case ETHERTYPE_ARP:
 		pktq = arp_pktq;
 		break;
 	case ETHERTYPE_REVARP:
 		revarpinput(m);	/* XXX queue? */
 		return;
 #endif
 #ifdef INET6
 	case ETHERTYPE_IPV6:
 		if (__predict_false(!in6_present))
 			goto noproto;
 #ifdef GATEWAY
 		if (ip6flow_fastforward(&m))
 			return;
 #endif
 		pktq = ip6_pktq;
 		rps_hash = atomic_load_relaxed(&ether_pktq_rps_hash_p);
 		break;
 #endif
 #ifdef NETATALK
 	case ETHERTYPE_ATALK:
 		pktq = at_pktq1;
 		break;
 	case ETHERTYPE_AARP:
 		aarpinput(ifp, m); /* XXX queue? */
 		return;
 #endif
 #ifdef MPLS
 	case ETHERTYPE_MPLS:
 		pktq = mpls_pktq;
 		break;
 #endif
 	default:
 		goto noproto;
+	}
 	KASSERT(pktq != NULL);
 	const uint32_t h = rps_hash ? pktq_rps_hash(&rps_hash, m) : 0;
 	if (__predict_false(!pktq_enqueue(pktq, m, h))) {
 		m_freem(m);
+	}
 	return;
 drop:
 	m_freem(m);
 	if_statinc(ifp, if_iqdrops);
 	return;
 noproto:
 	m_freem(m);
 	if_statinc(ifp, if_noproto);
 	return;
 error:
 	m_freem(m);
 	if_statinc(ifp, if_ierrors);
 	return;
+}
 static void
 ether_bpf_mtap(struct bpf_if *bp, struct mbuf *m, u_int direction)
+{
 	struct ether_vlan_header evl;
 	struct m_hdr mh, md;
 	KASSERT(bp != NULL);
 	if (!vlan_has_tag(m)) {
 		bpf_mtap3(bp, m, direction);
 		return;
+	}
 	memcpy(&evl, mtod(m, char *), ETHER_HDR_LEN);
 	evl.evl_proto = evl.evl_encap_proto;
 	evl.evl_encap_proto = htons(ETHERTYPE_VLAN);
 	evl.evl_tag = htons(vlan_get_tag(m));
 	md.mh_flags = 0;
 	md.mh_data = m->m_data + ETHER_HDR_LEN;
 	md.mh_len = m->m_len - ETHER_HDR_LEN;
 	md.mh_next = m->m_next;
 	mh.mh_flags = 0;
 	mh.mh_data = (char *)&evl;
 	mh.mh_len = sizeof(evl);
 	mh.mh_next = (struct mbuf *)&md;
 	bpf_mtap3(bp, (struct mbuf *)&mh, direction);
+}
 /*
  * Convert Ethernet address to printable (loggable) representation.
  */
 char *
 ether_sprintf(const u_char *ap)
+{
 	static char etherbuf[3 * ETHER_ADDR_LEN];
 	return ether_snprintf(etherbuf, sizeof(etherbuf), ap);
+}
 char *
 ether_snprintf(char *buf, size_t len, const u_char *ap)
+{
 	char *cp = buf;
 	size_t i;
 	for (i = 0; i < len / 3; i++) {
 		*cp++ = hexdigits[*ap >> 4];
 		*cp++ = hexdigits[*ap++ & 0xf];
 		*cp++ = ':';
+	}
 	*--cp = '\0';
 	return buf;
+}
 /*
  * Perform common duties while attaching to interface list
  */
 void
 ether_ifattach(struct ifnet *ifp, const uint8_t *lla)
+{
 	struct ethercom *ec = (struct ethercom *)ifp;
 	char xnamebuf[HOOKNAMSIZ];
 	ifp->if_type = IFT_ETHER;
 	ifp->if_hdrlen = ETHER_HDR_LEN;
 	ifp->if_dlt = DLT_EN10MB;
 	ifp->if_mtu = ETHERMTU;
 	ifp->if_output = ether_output;
 	ifp->_if_input = ether_input;
 	ifp->if_bpf_mtap = ether_bpf_mtap;
 	if (ifp->if_baudrate == 0)
 		ifp->if_baudrate = IF_Mbps(10);		/* just a default */
 	if (lla != NULL)
 		if_set_sadl(ifp, lla, ETHER_ADDR_LEN, !ETHER_IS_LOCAL(lla));
 	LIST_INIT(&ec->ec_multiaddrs);
 	SIMPLEQ_INIT(&ec->ec_vids);
 	ec->ec_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NET);
 	ec->ec_flags = 0;
 	ifp->if_broadcastaddr = etherbroadcastaddr;
 	bpf_attach(ifp, DLT_EN10MB, sizeof(struct ether_header));
 	snprintf(xnamebuf, sizeof(xnamebuf),
 	    "%s-ether_ifdetachhooks", ifp->if_xname);
 	ec->ec_ifdetach_hooks = simplehook_create(IPL_NET, xnamebuf);
 #ifdef MBUFTRACE
 	mowner_init_owner(&ec->ec_tx_mowner, ifp->if_xname, "tx");
 	mowner_init_owner(&ec->ec_rx_mowner, ifp->if_xname, "rx");
 	MOWNER_ATTACH(&ec->ec_tx_mowner);
 	MOWNER_ATTACH(&ec->ec_rx_mowner);
 	ifp->if_mowner = &ec->ec_tx_mowner;
 #endif
+}
 void
 ether_ifdetach(struct ifnet *ifp)
+{
 	struct ethercom *ec = (void *) ifp;
 	struct ether_multi *enm;
 	IFNET_ASSERT_UNLOCKED(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 = __FPTRCAST(int (*)(struct ifnet *, u_long, void *),
 	    enxio);
 	simplehook_dohooks(ec->ec_ifdetach_hooks);
 	KASSERT(!simplehook_has_hooks(ec->ec_ifdetach_hooks));
 	simplehook_destroy(ec->ec_ifdetach_hooks);
 	bpf_detach(ifp);
 	ETHER_LOCK(ec);
 	KASSERT(ec->ec_nvlans == 0);
 	while ((enm = LIST_FIRST(&ec->ec_multiaddrs)) != NULL) {
 		LIST_REMOVE(enm, enm_list);
 		kmem_free(enm, sizeof(*enm));
 		ec->ec_multicnt--;
+	}
 	ETHER_UNLOCK(ec);
 	mutex_obj_free(ec->ec_lock);
 	ec->ec_lock = NULL;
 	ifp->if_mowner = NULL;
 	MOWNER_DETACH(&ec->ec_rx_mowner);
 	MOWNER_DETACH(&ec->ec_tx_mowner);
+}
 void *
 ether_ifdetachhook_establish(struct ifnet *ifp,
     void (*fn)(void *), void *arg)
+{
 	struct ethercom *ec;
 	khook_t *hk;
 	if (ifp->if_type != IFT_ETHER)
 		return NULL;
 	ec = (struct ethercom *)ifp;
 	hk = simplehook_establish(ec->ec_ifdetach_hooks,
 	    fn, arg);
 	return (void *)hk;
+}
 void
 ether_ifdetachhook_disestablish(struct ifnet *ifp,
     void *vhook, kmutex_t *lock)
+{
 	struct ethercom *ec;
 	if (vhook == NULL)
 		return;
 	ec = (struct ethercom *)ifp;
 	simplehook_disestablish(ec->ec_ifdetach_hooks, vhook, lock);
+}
 #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
 ether_crc32_le(const uint8_t *buf, size_t len)
+{
 	uint32_t c, crc, carry;
 	size_t i, j;
 	crc = 0xffffffffU;	/* initial value */
 	for (i = 0; i < len; i++) {
 		c = buf[i];
 		for (j = 0; j < 8; j++) {
 			carry = ((crc & 0x01) ? 1 : 0) ^ (c & 0x01);
 			crc >>= 1;
 			c >>= 1;
 			if (carry)
 				crc = (crc ^ ETHER_CRC_POLY_LE);
+		}
+	}
 	return (crc);
+}
 #else
 uint32_t
 ether_crc32_le(const uint8_t *buf, size_t len)
+{
 	static const uint32_t crctab[] = {
 x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
 x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
 xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
 x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
 	};
 	uint32_t crc;
 	size_t i;
 	crc = 0xffffffffU;	/* initial value */
 	for (i = 0; i < len; i++) {
 		crc ^= buf[i];
 		crc = (crc >> 4) ^ crctab[crc & 0xf];
 		crc = (crc >> 4) ^ crctab[crc & 0xf];
+	}
 	return (crc);
+}
 #endif
 uint32_t
 ether_crc32_be(const uint8_t *buf, size_t len)
+{
 	uint32_t c, crc, carry;
 	size_t i, j;
 	crc = 0xffffffffU;	/* initial value */
 	for (i = 0; i < len; i++) {
 		c = buf[i];
 		for (j = 0; j < 8; j++) {
 			carry = ((crc & 0x80000000U) ? 1 : 0) ^ (c & 0x01);
 			crc <<= 1;
 			c >>= 1;
 			if (carry)
 				crc = (crc ^ ETHER_CRC_POLY_BE) | carry;
+		}
+	}
 	return (crc);
+}
 #ifdef INET
 const uint8_t ether_ipmulticast_min[ETHER_ADDR_LEN] =
     { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
 const uint8_t ether_ipmulticast_max[ETHER_ADDR_LEN] =
     { 0x01, 0x00, 0x5e, 0x7f, 0xff, 0xff };
 #endif
 #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;
 	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))
 			return EINVAL;
 		*dest = atox(*cp);
 		cp++;
 		if (isxdigit(*cp)) {
 			*dest = (*dest << 4) | atox(*cp);
 			cp++;
+		}
 		dest++;
 		if (dest == ep)
 			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;
 #endif
 #ifdef INET6
 	const struct sockaddr_in6 *sin6;
 #endif
 	switch (sa->sa_family) {
 	case AF_UNSPEC:
 		memcpy(addrlo, sa->sa_data, ETHER_ADDR_LEN);
 		memcpy(addrhi, addrlo, ETHER_ADDR_LEN);
 		break;
 #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 {
 			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.
 			 * (This is used for multicast routers.)
 			 */
 			memcpy(addrlo, ether_ip6multicast_min, ETHER_ADDR_LEN);
 			memcpy(addrhi, ether_ip6multicast_max, ETHER_ADDR_LEN);
 		} else {
 			ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, addrlo);
 			memcpy(addrhi, addrlo, ETHER_ADDR_LEN);
+		}
 		break;
 #endif
 	default:
 		return EAFNOSUPPORT;
+	}
 	return 0;
+}
 /*
  * 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 */
 	enm = kmem_alloc(sizeof(*enm), KM_SLEEP);
 	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.
 	 */
 	_enm = ether_lookup_multi(addrlo, addrhi, ec);
 	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, ETHER_ADDR_LEN);
 	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_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 up the address in our list.
 	 */
 	enm = ether_lookup_multi(addrlo, addrhi, ec);
 	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));
 	/*
 	 * 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;
+}
 void
 ether_set_vlan_cb(struct ethercom *ec, ether_vlancb_t cb)
+{
 	ec->ec_vlan_cb = cb;
+}
 static int
 ether_ioctl_reinit(struct ethercom *ec)
+{
 	struct ifnet *ifp = &ec->ec_if;
 	int error;
 	KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
 	switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
 	case IFF_RUNNING:
 		/*
 		 * If interface is marked down and it is running,
 		 * then stop and disable it.
 		 */
 		if_stop(ifp, 1);
 		break;
 	case IFF_UP:
 		/*
 		 * If interface is marked up and it is stopped, then
 		 * start it.
 		 */
 		return if_init(ifp);
 	case IFF_UP | IFF_RUNNING:
 		error = 0;
 		if (ec->ec_ifflags_cb != NULL) {
 			error = (*ec->ec_ifflags_cb)(ec);
 			if (error == ENETRESET) {
 				/*
 				 * Reset the interface to pick up
 				 * changes in any other flags that
 				 * affect the hardware state.
 				 */
 				return if_init(ifp);
+			}
 		} else
 			error = if_init(ifp);
 		return error;
 	case 0:
 		break;
+	}
 	return 0;
+}
 /*
  * Common ioctls for Ethernet interfaces.  Note, we must be
  * called at splnet().
  */
 int
 ether_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	struct ethercom *ec = (void *)ifp;
 	struct eccapreq *eccr;
 	struct ifreq *ifr = (struct ifreq *)data;
 	struct if_laddrreq *iflr = data;
 	const struct sockaddr_dl *sdl;
 	static const uint8_t zero[ETHER_ADDR_LEN];
 	int error;
 	switch (cmd) {
 	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 = if_init(ifp)) != 0)
 				return error;
+		}
 #ifdef INET
 		if (ifa->ifa_addr->sa_family == AF_INET)
 			arp_ifinit(ifp, ifa);
 #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)
 			return EINVAL;
 		else if ((error = ifioctl_common(ifp, cmd, data)) != ENETRESET)
 			return error;
 		else if (ifp->if_flags & IFF_UP) {
 			/* Make sure the device notices the MTU change. */
 			return if_init(ifp);
 		} else
 			return 0;
+	    }
 	case SIOCSIFFLAGS:
 		if ((error = ifioctl_common(ifp, cmd, data)) != 0)
 			return error;
 		return ether_ioctl_reinit(ec);
 	case SIOCGIFFLAGS:
 		error = ifioctl_common(ifp, cmd, data);
 		if (error == 0) {
 			/* Set IFF_ALLMULTI for backcompat */
 			ifr->ifr_flags |= (ec->ec_flags & ETHER_F_ALLMULTI) ?
 			    IFF_ALLMULTI : 0;
+		}
 		return error;
 	case SIOCGETHERCAP:
 		eccr = (struct eccapreq *)data;
 		eccr->eccr_capabilities = ec->ec_capabilities;
 		eccr->eccr_capenable = ec->ec_capenable;
 		return 0;
 	case SIOCSETHERCAP:
 		eccr = (struct eccapreq *)data;
 		if ((eccr->eccr_capenable & ~ec->ec_capabilities) != 0)
 			return EINVAL;
 		if (eccr->eccr_capenable == ec->ec_capenable)
 			return 0;
 #if 0 /* notyet */
 		ec->ec_capenable = (ec->ec_capenable & ETHERCAP_CANTCHANGE)
 		    | (eccr->eccr_capenable & ~ETHERCAP_CANTCHANGE);
 #else
 		ec->ec_capenable = eccr->eccr_capenable;
 #endif
 		return ether_ioctl_reinit(ec);
 	case SIOCADDMULTI:
 		return ether_addmulti(ifreq_getaddr(cmd, ifr), ec);
 	case SIOCDELMULTI:
 		return ether_delmulti(ifreq_getaddr(cmd, ifr), ec);
 	case SIOCSIFMEDIA:
 	case SIOCGIFMEDIA:
 		if (ec->ec_mii != NULL)
 			return ifmedia_ioctl(ifp, ifr, &ec->ec_mii->mii_media,
 			    cmd);
 		else if (ec->ec_ifmedia != NULL)
 			return ifmedia_ioctl(ifp, ifr, ec->ec_ifmedia, cmd);
 		else
 			return ENOTTY;
 		break;
 	case SIOCALIFADDR:
 		sdl = satocsdl(sstocsa(&iflr->addr));
 		if (sdl->sdl_family != AF_LINK)
+			;
 		else if (ETHER_IS_MULTICAST(CLLADDR(sdl)))
 			return EINVAL;
 		else if (memcmp(zero, CLLADDR(sdl), sizeof(zero)) == 0)
 			return EINVAL;
 		/*FALLTHROUGH*/
 	default:
 		return ifioctl_common(ifp, cmd, data);
+	}
 	return 0;
+}
 /*
  * Enable/disable passing VLAN packets if the parent interface supports it.
  * Return:
  * 	 0: Ok
  *	-1: Parent interface does not support vlans
  *	>0: Error
  */
 int
 ether_enable_vlan_mtu(struct ifnet *ifp)
+{
 	int error;
 	struct ethercom *ec = (void *)ifp;
 	/* Parent does not support VLAN's */
 	if ((ec->ec_capabilities & ETHERCAP_VLAN_MTU) == 0)
 		return -1;
 	/*
 	 * Parent supports the VLAN_MTU capability,
 	 * i.e. can Tx/Rx larger than ETHER_MAX_LEN frames;
 	 * enable it.
 	 */
 	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;
+}
 int
 ether_disable_vlan_mtu(struct ifnet *ifp)
+{
 	int error;
 	struct ethercom *ec = (void *)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;
+}
 /*
  * Add and delete VLAN TAG
  */
 int
 ether_add_vlantag(struct ifnet *ifp, uint16_t vtag, bool *vlanmtu_status)
+{
 	struct ethercom *ec = (void *)ifp;
 	struct vlanid_list *vidp;
 	bool vlanmtu_enabled;
 	uint16_t vid = EVL_VLANOFTAG(vtag);
 	int error;
 	vlanmtu_enabled = false;
 	/* Add a vid to the list */
 	vidp = kmem_alloc(sizeof(*vidp), KM_SLEEP);
 	vidp->vid = vid;
 	ETHER_LOCK(ec);
 	ec->ec_nvlans++;
 	SIMPLEQ_INSERT_TAIL(&ec->ec_vids, vidp, vid_list);
 	ETHER_UNLOCK(ec);
 	if (ec->ec_nvlans == 1) {
 		IFNET_LOCK(ifp);
 		error = ether_enable_vlan_mtu(ifp);
 		IFNET_UNLOCK(ifp);
 		if (error == 0) {
 			vlanmtu_enabled = true;
 		} else if (error != -1) {
 			goto fail;
+		}
+	}
 	if (ec->ec_vlan_cb != NULL) {
 		error = (*ec->ec_vlan_cb)(ec, vid, true);
 		if (error != 0)
 			goto fail;
+	}
 	if (vlanmtu_status != NULL)
 		*vlanmtu_status = vlanmtu_enabled;
 	return 0;
 fail:
 	ETHER_LOCK(ec);
 	ec->ec_nvlans--;
 	SIMPLEQ_REMOVE(&ec->ec_vids, vidp, vlanid_list, vid_list);
 	ETHER_UNLOCK(ec);
 	if (vlanmtu_enabled) {
 		IFNET_LOCK(ifp);
 		(void)ether_disable_vlan_mtu(ifp);
 		IFNET_UNLOCK(ifp);
+	}
 	kmem_free(vidp, sizeof(*vidp));
 	return error;
+}
 int
 ether_del_vlantag(struct ifnet *ifp, uint16_t vtag)
+{
 	struct ethercom *ec = (void *)ifp;
 	struct vlanid_list *vidp;
 	uint16_t vid = EVL_VLANOFTAG(vtag);
 	ETHER_LOCK(ec);
 	SIMPLEQ_FOREACH(vidp, &ec->ec_vids, vid_list) {
 		if (vidp->vid == vid) {
 			SIMPLEQ_REMOVE(&ec->ec_vids, vidp,
 			    vlanid_list, vid_list);
 			ec->ec_nvlans--;
 			break;
+		}
+	}
 	ETHER_UNLOCK(ec);
 	if (vidp == NULL)
 		return ENOENT;
 	if (ec->ec_vlan_cb != NULL) {
 		(void)(*ec->ec_vlan_cb)(ec, vidp->vid, false);
+	}
 	if (ec->ec_nvlans == 0) {
 		IFNET_LOCK(ifp);
 		(void)ether_disable_vlan_mtu(ifp);
 		IFNET_UNLOCK(ifp);
+	}
 	kmem_free(vidp, sizeof(*vidp));
 	return 0;
+}
 int
 ether_inject_vlantag(struct mbuf **mp, uint16_t etype, uint16_t tag)
+{
 	static const size_t min_data_len =
 	    ETHER_MIN_LEN - ETHER_CRC_LEN + ETHER_VLAN_ENCAP_LEN;
 	/* Used to pad ethernet frames with < ETHER_MIN_LEN bytes */
 	static const char vlan_zero_pad_buff[ETHER_MIN_LEN] = { 0 };
 	struct ether_vlan_header *evl;
 	struct mbuf *m = *mp;
 	int error;
 	error = 0;
 	M_PREPEND(m, ETHER_VLAN_ENCAP_LEN, M_DONTWAIT);
 	if (m == NULL) {
 		error = ENOBUFS;
 		goto out;
+	}
 	if (m->m_len < sizeof(*evl)) {
 		m = m_pullup(m, sizeof(*evl));
 		if (m == NULL) {
 			error = ENOBUFS;
 			goto out;
+		}
+	}
 	/*
 	 * Transform the Ethernet header into an
 	 * Ethernet header with 802.1Q encapsulation.
 	 */
 	memmove(mtod(m, void *),
 	    mtod(m, char *) + ETHER_VLAN_ENCAP_LEN,
 	    sizeof(struct ether_header));
 	evl = mtod(m, struct ether_vlan_header *);
 	evl->evl_proto = evl->evl_encap_proto;
 	evl->evl_encap_proto = htons(etype);
 	evl->evl_tag = htons(tag);
 	/*
 	 * To cater for VLAN-aware layer 2 ethernet
 	 * switches which may need to strip the tag
 	 * before forwarding the packet, make sure
 	 * the packet+tag is at least 68 bytes long.
 	 * This is necessary because our parent will
 	 * only pad to 64 bytes (ETHER_MIN_LEN) and
 	 * some switches will not pad by themselves
 	 * after deleting a tag.
 	 */
 	if (m->m_pkthdr.len < min_data_len) {
 		m_copyback(m, m->m_pkthdr.len,
 		    min_data_len - m->m_pkthdr.len,
 		    vlan_zero_pad_buff);
+	}
 	m->m_flags &= ~M_VLANTAG;
 out:
 	*mp = m;
 	return error;
+}
 struct mbuf *
 ether_strip_vlantag(struct mbuf *m)
+{
 	struct ether_vlan_header *evl;
 	if (m->m_len < sizeof(*evl) &&
 	    (m = m_pullup(m, sizeof(*evl))) == NULL) {
 		return NULL;
+	}
 	if (m_makewritable(&m, 0, sizeof(*evl), M_DONTWAIT)) {
 		m_freem(m);
 		return NULL;
+	}
 	evl = mtod(m, struct ether_vlan_header *);
 	KASSERT(ntohs(evl->evl_encap_proto) == ETHERTYPE_VLAN);
 	vlan_set_tag(m, ntohs(evl->evl_tag));
 	/*
 	 * Restore the original ethertype.  We'll remove
 	 * the encapsulation after we've found the vlan
 	 * interface corresponding to the tag.
 	 */
 	evl->evl_encap_proto = evl->evl_proto;
 	/*
 	 * Remove the encapsulation header and append tag.
 	 * The original header has already been fixed up above.
 	 */
 	vlan_set_tag(m, ntohs(evl->evl_tag));
 	memmove((char *)evl + ETHER_VLAN_ENCAP_LEN, evl,
 	    offsetof(struct ether_vlan_header, evl_encap_proto));
 	m_adj(m, ETHER_VLAN_ENCAP_LEN);
 	return m;
+}
 static int
 ether_multicast_sysctl(SYSCTLFN_ARGS)
+{
 	struct ether_multi *enm;
 	struct ifnet *ifp;
 	struct ethercom *ec;
 	int error = 0;
 	size_t written;
 	struct psref psref;
 	int bound;
 	unsigned int multicnt;
 	struct ether_multi_sysctl *addrs;
 	int i;

 @@ -1,1953 +1,1961 @@
-/*	$NetBSD: if_arp.c,v 1.310 2022/11/15 09:15:43 roy Exp $	*/
+/*	$NetBSD: if_arp.c,v 1.311 2022/11/15 10:47:39 roy Exp $	*/
 /*
  * Copyright (c) 1998, 2000, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Public Access Networks Corporation ("Panix").  It was developed under
  * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION 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.
  */
 /*
  * Copyright (c) 1982, 1986, 1988, 1993
  *	The Regents of the University of California.  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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * 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_ether.c	8.2 (Berkeley) 9/26/94
  */
 /*
  * Ethernet address resolution protocol.
  * TODO:
  *	add "inuse/lock" bit (or ref. count) along with valid bit
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_arp.c,v 1.310 2022/11/15 09:15:43 roy Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_arp.c,v 1.311 2022/11/15 10:47:39 roy Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_ddb.h"
 #include "opt_inet.h"
 #include "opt_net_mpsafe.h"
 #endif
 #ifdef INET
 #include "arp.h"
 #include "bridge.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/kmem.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/timetc.h>
 #include <sys/kernel.h>
 #include <sys/errno.h>
 #include <sys/ioctl.h>
 #include <sys/syslog.h>
 #include <sys/proc.h>
 #include <sys/protosw.h>
 #include <sys/domain.h>
 #include <sys/sysctl.h>
 #include <sys/socketvar.h>
 #include <sys/percpu.h>
 #include <sys/cprng.h>
 #include <sys/kmem.h>
 #include <net/ethertypes.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <net/if_types.h>
 #include <net/if_ether.h>
 #include <net/if_llatbl.h>
 #include <net/nd.h>
 #include <net/route.h>
 #include <net/net_stats.h>
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/in_var.h>
 #include <netinet/ip.h>
 #include <netinet/if_inarp.h>
 #include "arcnet.h"
 #if NARCNET > 0
 #include <net/if_arc.h>
 #endif
 #include "carp.h"
 #if NCARP > 0
 #include <netinet/ip_carp.h>
 #endif
 /*
  * ARP trailer negotiation.  Trailer protocol is not IP specific,
  * but ARP request/response use IP addresses.
  */
 #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL
 /* timers */
 static int arp_reachable = REACHABLE_TIME;
 static int arp_retrans = RETRANS_TIMER;
 static int arp_perform_nud = 1;
 static bool arp_nud_enabled(struct ifnet *);
 static unsigned int arp_llinfo_reachable(struct ifnet *);
 static unsigned int arp_llinfo_retrans(struct ifnet *);
 static union l3addr *arp_llinfo_holdsrc(struct llentry *, union l3addr *);
 static void arp_llinfo_output(struct ifnet *, const union l3addr *,
     const union l3addr *, const uint8_t *, const union l3addr *);
 static void arp_llinfo_missed(struct ifnet *, const union l3addr *,
     int16_t, struct mbuf *);
 static void arp_free(struct llentry *, int);
 static struct nd_domain arp_nd_domain = {
 	.nd_family = AF_INET,
 	.nd_delay = 5,		/* delay first probe time 5 second */
 	.nd_mmaxtries = 3,	/* maximum broadcast query */
 	.nd_umaxtries = 3,	/* maximum unicast query */
 	.nd_retransmultiple = BACKOFF_MULTIPLE,
 	.nd_maxretrans = MAX_RETRANS_TIMER,
 	.nd_maxnudhint = 0,	/* max # of subsequent upper layer hints */
 	.nd_maxqueuelen = 1,	/* max # of packets in unresolved ND entries */
 	.nd_nud_enabled = arp_nud_enabled,
 	.nd_reachable = arp_llinfo_reachable,
 	.nd_retrans = arp_llinfo_retrans,
 	.nd_holdsrc = arp_llinfo_holdsrc,
 	.nd_output = arp_llinfo_output,
 	.nd_missed = arp_llinfo_missed,
 	.nd_free = arp_free,
 };
 int ip_dad_count = PROBE_NUM;
 #ifdef ARP_DEBUG
 int arp_debug = 1;
 #else
 int arp_debug = 0;
 #endif
 static void arp_init(void);
 static void arp_dad_init(void);
 static void arprequest(struct ifnet *,
     const struct in_addr *, const struct in_addr *,
     const uint8_t *, const uint8_t *);
 static void arpannounce1(struct ifaddr *);
 static struct sockaddr *arp_setgate(struct rtentry *, struct sockaddr *,
     const struct sockaddr *);
 static struct llentry *arpcreate(struct ifnet *,
     const struct in_addr *, const struct sockaddr *, int);
 static void in_arpinput(struct mbuf *);
 static void in_revarpinput(struct mbuf *);
 static void revarprequest(struct ifnet *);
 static void arp_drainstub(void);
 struct dadq;
 static void arp_dad_timer(struct dadq *);
 static void arp_dad_start(struct ifaddr *);
 static void arp_dad_stop(struct ifaddr *);
 static void arp_dad_duplicated(struct ifaddr *, const struct sockaddr_dl *);
 #define	ARP_MAXQLEN	50
 pktqueue_t *		arp_pktq		__read_mostly;
 static int useloopback = 1;	/* use loopback interface for local traffic */
 static percpu_t *arpstat_percpu;
 #define	ARP_STAT_GETREF()	_NET_STAT_GETREF(arpstat_percpu)
 #define	ARP_STAT_PUTREF()	_NET_STAT_PUTREF(arpstat_percpu)
 #define	ARP_STATINC(x)		_NET_STATINC(arpstat_percpu, x)
 #define	ARP_STATADD(x, v)	_NET_STATADD(arpstat_percpu, x, v)
 /* revarp state */
 static struct in_addr myip, srv_ip;
 static int myip_initialized = 0;
 static int revarp_in_progress = 0;
 static struct ifnet *myip_ifp = NULL;
 static int arp_drainwanted;
 static int log_movements = 0;
 static int log_permanent_modify = 1;
 static int log_wrong_iface = 1;
 DOMAIN_DEFINE(arpdomain);	/* forward declare and add to link set */
 static void
 arp_fasttimo(void)
+{
 	if (arp_drainwanted) {
 		arp_drain();
 		arp_drainwanted = 0;
+	}
+}
 static const struct protosw arpsw[] = {
+	{
 		.pr_type = 0,
 		.pr_domain = &arpdomain,
 		.pr_protocol = 0,
 		.pr_flags = 0,
 		.pr_input = 0,
 		.pr_ctlinput = 0,
 		.pr_ctloutput = 0,
 		.pr_usrreqs = 0,
 		.pr_init = arp_init,
 		.pr_fasttimo = arp_fasttimo,
 		.pr_slowtimo = 0,
 		.pr_drain = arp_drainstub,
+	}
 };
 struct domain arpdomain = {
 	.dom_family = PF_ARP,
 	.dom_name = "arp",
 	.dom_protosw = arpsw,
 	.dom_protoswNPROTOSW = &arpsw[__arraycount(arpsw)],
 #ifdef MBUFTRACE
 	.dom_mowner = MOWNER_INIT("internet", "arp"),
 #endif
 };
 static void sysctl_net_inet_arp_setup(struct sysctllog **);
 void
 arp_init(void)
+{
 	arp_pktq = pktq_create(ARP_MAXQLEN, arpintr, NULL);
 	KASSERT(arp_pktq != NULL);
 	sysctl_net_inet_arp_setup(NULL);
 	arpstat_percpu = percpu_alloc(sizeof(uint64_t) * ARP_NSTATS);
 #ifdef MBUFTRACE
 	MOWNER_ATTACH(&arpdomain.dom_mowner);
 #endif
 	nd_attach_domain(&arp_nd_domain);
 	arp_dad_init();
+}
 static void
 arp_drainstub(void)
+{
 	arp_drainwanted = 1;
+}
 /*
  * ARP protocol drain routine.  Called when memory is in short supply.
  * Called at splvm();  don't acquire softnet_lock as can be called from
  * hardware interrupt handlers.
  */
 void
 arp_drain(void)
+{
 	lltable_drain(AF_INET);
+}
 /*
  * We set the gateway for RTF_CLONING routes to a "prototype"
  * link-layer sockaddr whose interface type (if_type) and interface
  * index (if_index) fields are prepared.
  */
 static struct sockaddr *
 arp_setgate(struct rtentry *rt, struct sockaddr *gate,
     const struct sockaddr *netmask)
+{
 	const struct ifnet *ifp = rt->rt_ifp;
 	uint8_t namelen = strlen(ifp->if_xname);
 	uint8_t addrlen = ifp->if_addrlen;
 	/*
 	 * XXX: If this is a manually added route to interface
 	 * such as older version of routed or gated might provide,
 	 * restore cloning bit.
 	 */
 	if ((rt->rt_flags & RTF_HOST) == 0 && netmask != NULL &&
 	    satocsin(netmask)->sin_addr.s_addr != 0xffffffff)
 		rt->rt_flags |= RTF_CONNECTED;
 	if ((rt->rt_flags & (RTF_CONNECTED | RTF_LOCAL))) {
 		union {
 			struct sockaddr sa;
 			struct sockaddr_storage ss;
 			struct sockaddr_dl sdl;
 		} u;
 		/*
 		 * Case 1: This route should come from a route to iface.
 		 */
 		sockaddr_dl_init(&u.sdl, sizeof(u.ss),
 		    ifp->if_index, ifp->if_type, NULL, namelen, NULL, addrlen);
 		rt_setgate(rt, &u.sa);
 		gate = rt->rt_gateway;
+	}
 	return gate;
+}
 /*
  * Parallel to llc_rtrequest.
  */
 void
 arp_rtrequest(int req, struct rtentry *rt, const struct rt_addrinfo *info)
+{
 	struct sockaddr *gate = rt->rt_gateway;
 	struct in_ifaddr *ia;
 	struct ifaddr *ifa;
 	struct ifnet *ifp = rt->rt_ifp;
 	int bound;
 	int s;
 	if (req == RTM_LLINFO_UPD) {
 		if ((ifa = info->rti_ifa) != NULL)
 			arpannounce1(ifa);
 		return;
+	}
 	if ((rt->rt_flags & RTF_GATEWAY) != 0) {
 		if (req != RTM_ADD)
 			return;
 		/*
 		 * linklayers with particular link MTU limitation.
 		 */
 		switch(ifp->if_type) {
 #if NARCNET > 0
 		case IFT_ARCNET:
+		    {
 			int arcipifmtu;
 			if (ifp->if_flags & IFF_LINK0)
 				arcipifmtu = arc_ipmtu;
 			else
 				arcipifmtu = ARCMTU;
 			if (ifp->if_mtu > arcipifmtu)
 				rt->rt_rmx.rmx_mtu = arcipifmtu;
 			break;
+		    }
 #endif
+		}
 		return;
+	}
 	switch (req) {
 	case RTM_SETGATE:
 		gate = arp_setgate(rt, gate, info->rti_info[RTAX_NETMASK]);
 		break;
 	case RTM_ADD:
 		gate = arp_setgate(rt, gate, info->rti_info[RTAX_NETMASK]);
 		if (gate == NULL) {
 			log(LOG_ERR, "%s: arp_setgate failed\n", __func__);
 			break;
+		}
 		if ((rt->rt_flags & RTF_CONNECTED) ||
 		    (rt->rt_flags & RTF_LOCAL)) {
 			/*
 			 * linklayers with particular link MTU limitation.
 			 */
 			switch (ifp->if_type) {
 #if NARCNET > 0
 			case IFT_ARCNET:
+			    {
 				int arcipifmtu;
 				if (ifp->if_flags & IFF_LINK0)
 					arcipifmtu = arc_ipmtu;
 				else
 					arcipifmtu = ARCMTU;
 				if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0 &&
 				    (rt->rt_rmx.rmx_mtu > arcipifmtu ||
 				     (rt->rt_rmx.rmx_mtu == 0 &&
 				      ifp->if_mtu > arcipifmtu)))
 					rt->rt_rmx.rmx_mtu = arcipifmtu;
 				break;
+			    }
 #endif
+			}
 			if (rt->rt_flags & RTF_CONNECTED)
 				break;
+		}
 		bound = curlwp_bind();
 		/* Announce a new entry if requested. */
 		if (rt->rt_flags & RTF_ANNOUNCE) {
 			struct psref psref;
 			ia = in_get_ia_on_iface_psref(
 			    satocsin(rt_getkey(rt))->sin_addr, ifp, &psref);
 			if (ia != NULL) {
 				arpannounce(ifp, &ia->ia_ifa,
 				    CLLADDR(satocsdl(gate)));
 				ia4_release(ia, &psref);
+			}
+		}
 		if (gate->sa_family != AF_LINK ||
 		    gate->sa_len < sockaddr_dl_measure(0, ifp->if_addrlen)) {
 			log(LOG_DEBUG, "%s: bad gateway value\n", __func__);
 			goto out;
+		}
 		satosdl(gate)->sdl_type = ifp->if_type;
 		satosdl(gate)->sdl_index = ifp->if_index;
 		/*
 		 * If the route is for a broadcast address mark it as such.
 		 * This way we can avoid an expensive call to in_broadcast()
 		 * in ip_output() most of the time (because the route passed
 		 * to ip_output() is almost always a host route).
 		 */
 		if (rt->rt_flags & RTF_HOST &&
 		    !(rt->rt_flags & RTF_BROADCAST) &&
 		    in_broadcast(satocsin(rt_getkey(rt))->sin_addr, rt->rt_ifp))
 			rt->rt_flags |= RTF_BROADCAST;
 		/* There is little point in resolving the broadcast address */
 		if (rt->rt_flags & RTF_BROADCAST)
 			goto out;
 		/*
 		 * When called from rt_ifa_addlocal, we cannot depend on that
 		 * the address (rt_getkey(rt)) exits in the address list of the
 		 * interface. So check RTF_LOCAL instead.
 		 */
 		if (rt->rt_flags & RTF_LOCAL) {
 			if (useloopback) {
 				rt->rt_ifp = lo0ifp;
 				rt->rt_rmx.rmx_mtu = 0;
+			}
 			goto out;
+		}
 		s = pserialize_read_enter();
 		ia = in_get_ia_on_iface(satocsin(rt_getkey(rt))->sin_addr, ifp);
 		if (ia == NULL) {
 			pserialize_read_exit(s);
 			goto out;
+		}
 		if (useloopback) {
 			rt->rt_ifp = lo0ifp;
 			rt->rt_rmx.rmx_mtu = 0;
+		}
 		rt->rt_flags |= RTF_LOCAL;
 		if (ISSET(info->rti_flags, RTF_DONTCHANGEIFA)) {
 			pserialize_read_exit(s);
 			goto out;
+		}
 		/*
 		 * make sure to set rt->rt_ifa to the interface
 		 * address we are using, otherwise we will have trouble
 		 * with source address selection.
 		 */
 		ifa = &ia->ia_ifa;
 		if (ifa != rt->rt_ifa)
 			/* Assume it doesn't sleep */
 			rt_replace_ifa(rt, ifa);
 		pserialize_read_exit(s);
 	out:
 		curlwp_bindx(bound);
 		break;
+	}
+}
 /*
  * Broadcast an ARP request. Caller specifies:
  *	- arp header source ip address
  *	- arp header target ip address
  *	- arp header source ethernet address
  */
 static void
 arprequest(struct ifnet *ifp,
     const struct in_addr *sip, const struct in_addr *tip,
     const uint8_t *saddr, const uint8_t *taddr)
+{
 	struct mbuf *m;
 	struct arphdr *ah;
 	struct sockaddr sa;
 	uint64_t *arps;
 	KASSERT(sip != NULL);
 	KASSERT(tip != NULL);
 	KASSERT(saddr != NULL);
 	if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
 		return;
 	MCLAIM(m, &arpdomain.dom_mowner);
 	switch (ifp->if_type) {
 	case IFT_IEEE1394:
 		m->m_len = sizeof(*ah) + 2 * sizeof(struct in_addr) +
 		    ifp->if_addrlen;
 		break;
 	default:
 		m->m_len = sizeof(*ah) + 2 * sizeof(struct in_addr) +
 * ifp->if_addrlen;
 		break;
+	}
 	m->m_pkthdr.len = m->m_len;
 	m_align(m, m->m_len);
 	ah = mtod(m, struct arphdr *);
 	memset(ah, 0, m->m_len);
 	switch (ifp->if_type) {
 	case IFT_IEEE1394:	/* RFC2734 */
 		/* fill it now for ar_tpa computation */
 		ah->ar_hrd = htons(ARPHRD_IEEE1394);
 		break;
 	default:
 		/* ifp->if_output will fill ar_hrd */
 		break;
+	}
 	ah->ar_pro = htons(ETHERTYPE_IP);
 	ah->ar_hln = ifp->if_addrlen;		/* hardware address length */
 	ah->ar_pln = sizeof(struct in_addr);	/* protocol address length */
 	ah->ar_op = htons(ARPOP_REQUEST);
 	memcpy(ar_sha(ah), saddr, ah->ar_hln);
 	if (taddr == NULL)
 		m->m_flags |= M_BCAST;
 	else
 		memcpy(ar_tha(ah), taddr, ah->ar_hln);
 	memcpy(ar_spa(ah), sip, ah->ar_pln);
 	memcpy(ar_tpa(ah), tip, ah->ar_pln);
 	sa.sa_family = AF_ARP;
 	sa.sa_len = 2;
 	arps = ARP_STAT_GETREF();
 	arps[ARP_STAT_SNDTOTAL]++;
 	arps[ARP_STAT_SENDREQUEST]++;
 	ARP_STAT_PUTREF();
 	if_output_lock(ifp, ifp, m, &sa, NULL);
+}
 void
 arpannounce(struct ifnet *ifp, struct ifaddr *ifa, const uint8_t *enaddr)
+{
 	struct in_ifaddr *ia = ifatoia(ifa);
 	struct in_addr *ip = &IA_SIN(ifa)->sin_addr;
 	if (ia->ia4_flags & (IN_IFF_NOTREADY | IN_IFF_DETACHED)) {
 		ARPLOG(LOG_DEBUG, "%s not ready\n", ARPLOGADDR(ip));
 		return;
+	}
 	arprequest(ifp, ip, ip, enaddr, NULL);
+}
 static void
 arpannounce1(struct ifaddr *ifa)
+{
 	arpannounce(ifa->ifa_ifp, ifa, CLLADDR(ifa->ifa_ifp->if_sadl));
+}
 /*
  * Resolve an IP address into an ethernet address.  If success, desten is
  * filled in. If there is no entry in arptab, set one up and broadcast a
  * request for the IP address. Hold onto this mbuf and resend it once the
  * address is finally resolved.
+ *
  * A return value of 0 indicates that desten has been filled in and the packet
  * should be sent normally; a return value of EWOULDBLOCK indicates that the
  * packet has been held pending resolution. Any other value indicates an
  * error.
  */
 int
 arpresolve(struct ifnet *ifp, const struct rtentry *rt, struct mbuf *m,
     const struct sockaddr *dst, void *desten, size_t destlen)
+{
 	struct llentry *la;
 	const char *create_lookup;
 	int error;
 #if NCARP > 0
 	if (rt != NULL && rt->rt_ifp->if_type == IFT_CARP)
 		ifp = rt->rt_ifp;
 #endif
 	KASSERT(m != NULL);
 	la = arplookup(ifp, NULL, dst, 0);
 	if (la == NULL)
 		goto notfound;
 	if (la->la_flags & LLE_VALID && la->ln_state == ND_LLINFO_REACHABLE) {
 		KASSERT(destlen >= ifp->if_addrlen);
 		memcpy(desten, &la->ll_addr, ifp->if_addrlen);
 		LLE_RUNLOCK(la);
 		return 0;
+	}
 notfound:
 	if (ifp->if_flags & IFF_NOARP) {
 		if (la != NULL)
 			LLE_RUNLOCK(la);
 		error = ENOTSUP;
 		goto bad;
+	}
 	if (la == NULL) {
 		struct rtentry *_rt;
 		create_lookup = "create";
 		_rt = rtalloc1(dst, 0);
 		IF_AFDATA_WLOCK(ifp);
 		la = lla_create(LLTABLE(ifp), LLE_EXCLUSIVE, dst, _rt);
 		IF_AFDATA_WUNLOCK(ifp);
 		if (_rt != NULL)
 			rt_unref(_rt);
 		if (la == NULL)
 			ARP_STATINC(ARP_STAT_ALLOCFAIL);
 		else
 			la->ln_state = ND_LLINFO_NOSTATE;
 	} else if (LLE_TRY_UPGRADE(la) == 0) {
 		create_lookup = "lookup";
 		LLE_RUNLOCK(la);
 		IF_AFDATA_RLOCK(ifp);
 		la = lla_lookup(LLTABLE(ifp), LLE_EXCLUSIVE, dst);
 		IF_AFDATA_RUNLOCK(ifp);
+	}
 	error = EINVAL;
 	if (la == NULL) {
 		log(LOG_DEBUG,
 		    "%s: failed to %s llentry for %s on %s\n",
 		    __func__, create_lookup, inet_ntoa(satocsin(dst)->sin_addr),
 		    ifp->if_xname);
 		goto bad;
+	}
 	error = nd_resolve(la, rt, m, desten, destlen);
 	return error;
 bad:
 	m_freem(m);
 	return error;
+}
 /*
  * Common length and type checks are done here,
  * then the protocol-specific routine is called.
  */
 void
 arpintr(void *arg __unused)
+{
 	struct mbuf *m;
 	struct arphdr *ar;
 	int s;
 	int arplen;
 	struct ifnet *rcvif;
 	bool badhrd;
 	SOFTNET_KERNEL_LOCK_UNLESS_NET_MPSAFE();
 	while ((m = pktq_dequeue(arp_pktq)) != NULL) {
 		if ((m->m_flags & M_PKTHDR) == 0)
 			panic("arpintr");
 		MCLAIM(m, &arpdomain.dom_mowner);
 		ARP_STATINC(ARP_STAT_RCVTOTAL);
 		if (__predict_false(m->m_len < sizeof(*ar))) {
 			if ((m = m_pullup(m, sizeof(*ar))) == NULL)
 				goto badlen;
+		}
 		ar = mtod(m, struct arphdr *);
 		KASSERT(ACCESSIBLE_POINTER(ar, struct arphdr));
 		rcvif = m_get_rcvif(m, &s);
 		if (__predict_false(rcvif == NULL)) {
 			ARP_STATINC(ARP_STAT_RCVNOINT);
 			goto free;
+		}
 		/*
 		 * We don't want non-IEEE1394 ARP packets on IEEE1394
 		 * interfaces, and vice versa. Our life depends on that.
 		 */
 		if (ntohs(ar->ar_hrd) == ARPHRD_IEEE1394)
 			badhrd = rcvif->if_type != IFT_IEEE1394;
 		else
 			badhrd = rcvif->if_type == IFT_IEEE1394;
 		m_put_rcvif(rcvif, &s);
 		if (badhrd) {
 			ARP_STATINC(ARP_STAT_RCVBADPROTO);
 			goto free;
+		}
 		arplen = sizeof(*ar) + 2 * ar->ar_hln + 2 * ar->ar_pln;
 		if (__predict_false(m->m_len < arplen)) {
 			if ((m = m_pullup(m, arplen)) == NULL)
 				goto badlen;
 			ar = mtod(m, struct arphdr *);
 			KASSERT(ACCESSIBLE_POINTER(ar, struct arphdr));
+		}
 		switch (ntohs(ar->ar_pro)) {
 		case ETHERTYPE_IP:
 		case ETHERTYPE_IPTRAILERS:
 			in_arpinput(m);
 			continue;
 		default:
 			ARP_STATINC(ARP_STAT_RCVBADPROTO);
 			goto free;
+		}
 badlen:
 		ARP_STATINC(ARP_STAT_RCVBADLEN);
 free:
 		m_freem(m);
+	}
 	SOFTNET_KERNEL_UNLOCK_UNLESS_NET_MPSAFE();
 	return; /* XXX gcc */
+}
 /*
  * ARP for Internet protocols on 10 Mb/s Ethernet. Algorithm is that given in
  * RFC 826. In addition, a sanity check is performed on the sender protocol
  * address, to catch impersonators.
+ *
  * We no longer handle negotiations for use of trailer protocol: formerly, ARP
  * replied for protocol type ETHERTYPE_TRAIL sent along with IP replies if we
  * wanted trailers sent to us, and also sent them in response to IP replies.
  * This allowed either end to announce the desire to receive trailer packets.
+ *
  * We no longer reply to requests for ETHERTYPE_TRAIL protocol either, but
  * formerly didn't normally send requests.
  */
 static void
 in_arpinput(struct mbuf *m)
+{
 	struct arphdr *ah;
 	struct ifnet *ifp, *rcvif = NULL;
 	struct llentry *la = NULL;
 	struct in_ifaddr *ia = NULL;
 #if NBRIDGE > 0
 	struct in_ifaddr *bridge_ia = NULL;
 #endif
 #if NCARP > 0
 	uint32_t count = 0, index = 0;
 #endif
 	struct sockaddr sa;
 	struct in_addr isaddr, itaddr, myaddr;
 	int op, rt_cmd, new_state = 0;
 	void *tha;
 	uint64_t *arps;
 	struct psref psref, psref_ia;
 	int s;
 	char ipbuf[INET_ADDRSTRLEN];
 	bool find_source, do_dad;
 	if (__predict_false(m_makewritable(&m, 0, m->m_pkthdr.len, M_DONTWAIT)))
 		goto out;
 	ah = mtod(m, struct arphdr *);
 	op = ntohs(ah->ar_op);
 	if (ah->ar_pln != sizeof(struct in_addr))
 		goto out;
 	ifp = if_get_bylla(ar_sha(ah), ah->ar_hln, &psref);
 	if (ifp) {
 		/* it's from me, ignore it. */
 		if_put(ifp, &psref);
 		ARP_STATINC(ARP_STAT_RCVLOCALSHA);
 		goto out;
+	}
 	rcvif = ifp = m_get_rcvif_psref(m, &psref);
 	if (__predict_false(rcvif == NULL))
 		goto out;
 	if (rcvif->if_flags & IFF_NOARP)
 		goto out;
 	memcpy(&isaddr, ar_spa(ah), sizeof(isaddr));
 	memcpy(&itaddr, ar_tpa(ah), sizeof(itaddr));
 	if (m->m_flags & (M_BCAST|M_MCAST))
 		ARP_STATINC(ARP_STAT_RCVMCAST);
 	/*
 	 * Search for a matching interface address
 	 * or any address on the interface to use
 	 * as a dummy address in the rest of this function.
+	 *
 	 * First try and find the source address for early
 	 * duplicate address detection.
 	 */
 	if (in_nullhost(isaddr)) {
 		if (in_nullhost(itaddr)) /* very bogus ARP */
 			goto out;
 		find_source = false;
 		myaddr = itaddr;
 	} else {
 		find_source = true;
 		myaddr = isaddr;
+	}
 	s = pserialize_read_enter();
 again:
 	IN_ADDRHASH_READER_FOREACH(ia, myaddr.s_addr) {
 		if (!in_hosteq(ia->ia_addr.sin_addr, myaddr))
 			continue;
 #if NCARP > 0
 		if (ia->ia_ifp->if_type == IFT_CARP &&
 		    ((ia->ia_ifp->if_flags & (IFF_UP|IFF_RUNNING)) ==
 		    (IFF_UP|IFF_RUNNING))) {
 			index++;
 			/* XXX: ar_hln? */
 			if (ia->ia_ifp == rcvif && (ah->ar_hln >= 6) &&
 			    carp_iamatch(ia, ar_sha(ah),
 			    &count, index)) {
 				break;
+			}
 		} else
 #endif
 		if (ia->ia_ifp == rcvif)
 			break;
 #if NBRIDGE > 0
 		/*
 		 * If the interface we received the packet on
 		 * is part of a bridge, check to see if we need
 		 * to "bridge" the packet to ourselves at this
 		 * layer.  Note we still prefer a perfect match,
 		 * but allow this weaker match if necessary.
 		 */
 		if (rcvif->if_bridge != NULL &&
 		    rcvif->if_bridge == ia->ia_ifp->if_bridge)
 			bridge_ia = ia;
 #endif
+	}
 #if NBRIDGE > 0
 	if (ia == NULL && bridge_ia != NULL) {
 		ia = bridge_ia;
 		m_put_rcvif_psref(rcvif, &psref);
 		rcvif = NULL;
 		/* FIXME */
 		ifp = bridge_ia->ia_ifp;
+	}
 #endif
 	/* If we failed to find the source address then find
 	 * the target address. */
 	if (ia == NULL && find_source && !in_nullhost(itaddr)) {
 		find_source = false;
 		myaddr = itaddr;
 		goto again;
+	}
 	if (ia != NULL)
 		ia4_acquire(ia, &psref_ia);
 	pserialize_read_exit(s);
 	if (ah->ar_hln != ifp->if_addrlen) {
 		ARP_STATINC(ARP_STAT_RCVBADLEN);
 		log(LOG_WARNING,
 		    "arp from %s: addr len: new %d, i/f %d (ignored)\n",
 		    IN_PRINT(ipbuf, &isaddr), ah->ar_hln, ifp->if_addrlen);
 		goto out;
+	}
 	/* Only do DaD if we have a matching address. */
 	do_dad = (ia != NULL);
 	if (ia == NULL) {
 		ia = in_get_ia_on_iface_psref(isaddr, rcvif, &psref_ia);
 		if (ia == NULL) {
 			ia = in_get_ia_from_ifp_psref(ifp, &psref_ia);
 			if (ia == NULL) {
 				ARP_STATINC(ARP_STAT_RCVNOINT);
 				goto out;
+			}
+		}
+	}
 	myaddr = ia->ia_addr.sin_addr;
 	/* XXX checks for bridge case? */
 	if (!memcmp(ar_sha(ah), ifp->if_broadcastaddr, ifp->if_addrlen)) {
 		ARP_STATINC(ARP_STAT_RCVBCASTSHA);
 		log(LOG_ERR,
 		    "%s: arp: link address is broadcast for IP address %s!\n",
 		    ifp->if_xname, IN_PRINT(ipbuf, &isaddr));
 		goto out;
+	}
 	/*
 	 * If the source IP address is zero, this is an RFC 5227 ARP probe
 	 */
 	if (in_nullhost(isaddr))
 		ARP_STATINC(ARP_STAT_RCVZEROSPA);
 	else if (in_hosteq(isaddr, myaddr))
 		ARP_STATINC(ARP_STAT_RCVLOCALSPA);
 	if (in_nullhost(itaddr))
 		ARP_STATINC(ARP_STAT_RCVZEROTPA);
 	/*
 	 * DAD check, RFC 5227.
 	 * ARP sender hardware address must match the interface
 	 * address of the interface sending the packet.
 	 * Collision on sender address is always a duplicate.
 	 * Collision on target address is only a duplicate
 	 * IF the sender address is the null host (ie a DAD probe)
 	 * AND the message was broadcast
 	 * AND our address is either tentative or duplicated
 	 * If it was unicast then it's a valid Unicast Poll from RFC 1122.
 	 */
 	if (do_dad &&
 	    (in_hosteq(isaddr, myaddr) ||
 	    (in_nullhost(isaddr) && in_hosteq(itaddr, myaddr) &&
 	     m->m_flags & M_BCAST &&
 	     ia->ia4_flags & (IN_IFF_TENTATIVE | IN_IFF_DUPLICATED))))
+	{
-		struct sockaddr_dl sdl, *sdlp;
+		struct m_tag *mtag;
-		sdlp = sockaddr_dl_init(&sdl, sizeof(sdl),
+		mtag = m_tag_find(m, PACKET_TAG_ETHERNET_SRC);
-		    ifp->if_index, ifp->if_type,
+		if (mtag == NULL || (ah->ar_hln == ETHER_ADDR_LEN &&
-		    NULL, 0, ar_sha(ah), ah->ar_hln);
+		    memcmp(mtag + 1, ar_sha(ah), ah->ar_hln) == 0)) {
-		arp_dad_duplicated((struct ifaddr *)ia, sdlp);
+			struct sockaddr_dl sdl, *sdlp;
 		goto out;
 			sdlp = sockaddr_dl_init(&sdl, sizeof(sdl),
 			    ifp->if_index, ifp->if_type,
 			    NULL, 0, ar_sha(ah), ah->ar_hln);
 			arp_dad_duplicated((struct ifaddr *)ia, sdlp);
 			goto out;
+		}
+	}
 	/*
 	 * If the target IP address is zero, ignore the packet.
 	 * This prevents the code below from trying to answer
 	 * when we are using IP address zero (booting).
 	 */
 	if (in_nullhost(itaddr))
 		goto out;
 	if (in_nullhost(isaddr))
 		goto reply;
 	if (in_hosteq(itaddr, myaddr))
 		la = arpcreate(ifp, &isaddr, NULL, 1);
 	else
 		la = arplookup(ifp, &isaddr, NULL, 1);
 	if (la == NULL)
 		goto reply;
 	if ((la->la_flags & LLE_VALID) &&
 	    memcmp(ar_sha(ah), &la->ll_addr, ifp->if_addrlen))
+	{
 		char llabuf[LLA_ADDRSTRLEN], *llastr;
 		llastr = lla_snprintf(llabuf, sizeof(llabuf),
 		    ar_sha(ah), ah->ar_hln);
 		if (la->la_flags & LLE_STATIC) {
 			ARP_STATINC(ARP_STAT_RCVOVERPERM);
 			if (!log_permanent_modify)
 				goto out;
 			log(LOG_INFO,
 			    "%s tried to overwrite permanent arp info"
 			    " for %s\n", llastr, IN_PRINT(ipbuf, &isaddr));
 			goto out;
 		} else if (la->lle_tbl->llt_ifp != ifp) {
 			/* XXX should not happen? */
 			ARP_STATINC(ARP_STAT_RCVOVERINT);
 			if (!log_wrong_iface)
 				goto out;
 			log(LOG_INFO,
 			    "%s on %s tried to overwrite "
 			    "arp info for %s on %s\n",
 			    llastr,
 			    ifp->if_xname, IN_PRINT(ipbuf, &isaddr),
 			    la->lle_tbl->llt_ifp->if_xname);
 				goto out;
 		} else {
 			ARP_STATINC(ARP_STAT_RCVOVER);
 			if (log_movements)
 				log(LOG_INFO, "arp info overwritten "
 				    "for %s by %s\n",
 				    IN_PRINT(ipbuf, &isaddr), llastr);
+		}
 		rt_cmd = RTM_CHANGE;
 		new_state = ND_LLINFO_STALE;
 	} else {
 		if (op == ARPOP_REPLY && in_hosteq(itaddr, myaddr)) {
 			/* This was a solicited ARP reply. */
 			la->ln_byhint = 0;
 			new_state = ND_LLINFO_REACHABLE;
+		}
 		rt_cmd = la->la_flags & LLE_VALID ? 0 : RTM_ADD;
+	}
 	KASSERT(ifp->if_sadl->sdl_alen == ifp->if_addrlen);
 	KASSERT(sizeof(la->ll_addr) >= ifp->if_addrlen);
 	memcpy(&la->ll_addr, ar_sha(ah), ifp->if_addrlen);
 	la->la_flags |= LLE_VALID;
 	la->ln_asked = 0;
 	if (new_state != 0) {
 		la->ln_state = new_state;
 		if (new_state != ND_LLINFO_REACHABLE ||
 		    !(la->la_flags & LLE_STATIC))
+		{
 			int timer = ND_TIMER_GC;
 			if (new_state == ND_LLINFO_REACHABLE)
 				timer = ND_TIMER_REACHABLE;
 			nd_set_timer(la, timer);
+		}
+	}
 	if (rt_cmd != 0) {
 		struct sockaddr_in sin;
 		sockaddr_in_init(&sin, &la->r_l3addr.addr4, 0);
 		rt_clonedmsg(rt_cmd, NULL, sintosa(&sin), ar_sha(ah), ifp);
+	}
 	if (la->la_hold != NULL) {
 		int n = la->la_numheld;
 		struct mbuf *m_hold, *m_hold_next;
 		struct sockaddr_in sin;
 		sockaddr_in_init(&sin, &la->r_l3addr.addr4, 0);
 		m_hold = la->la_hold;
 		la->la_hold = NULL;
 		la->la_numheld = 0;
 		/*
 		 * We have to unlock here because if_output would call
 		 * arpresolve
 		 */
 		LLE_WUNLOCK(la);
 		ARP_STATADD(ARP_STAT_DFRSENT, n);
 		ARP_STATADD(ARP_STAT_DFRTOTAL, n);
 		for (; m_hold != NULL; m_hold = m_hold_next) {
 			m_hold_next = m_hold->m_nextpkt;
 			m_hold->m_nextpkt = NULL;
 			if_output_lock(ifp, ifp, m_hold, sintosa(&sin), NULL);
+		}
 	} else
 		LLE_WUNLOCK(la);
 	la = NULL;
 reply:
 	if (la != NULL) {
 		LLE_WUNLOCK(la);
 		la = NULL;
+	}
 	if (op != ARPOP_REQUEST) {
 		if (op == ARPOP_REPLY)
 			ARP_STATINC(ARP_STAT_RCVREPLY);
 		goto out;
+	}
 	ARP_STATINC(ARP_STAT_RCVREQUEST);
 	if (in_hosteq(itaddr, myaddr)) {
 		/* If our address is unusable, don't reply */
 		if (ia->ia4_flags & (IN_IFF_NOTREADY | IN_IFF_DETACHED))
 			goto out;
 		/* I am the target */
 		tha = ar_tha(ah);
 		if (tha)
 			memcpy(tha, ar_sha(ah), ah->ar_hln);
 		memcpy(ar_sha(ah), CLLADDR(ifp->if_sadl), ah->ar_hln);
 	} else {
 		/* Proxy ARP */
 		struct llentry *lle = NULL;
 		struct sockaddr_in sin;
 #if NCARP > 0
 		if (ifp->if_type == IFT_CARP) {
 			struct ifnet *_rcvif = m_get_rcvif(m, &s);
 			int iftype = 0;
 			if (__predict_true(_rcvif != NULL))
 				iftype = _rcvif->if_type;
 			m_put_rcvif(_rcvif, &s);
 			if (iftype != IFT_CARP)
 				goto out;
+		}
 #endif
 		tha = ar_tha(ah);
 		sockaddr_in_init(&sin, &itaddr, 0);
 		IF_AFDATA_RLOCK(ifp);
 		lle = lla_lookup(LLTABLE(ifp), 0, (struct sockaddr *)&sin);
 		IF_AFDATA_RUNLOCK(ifp);
 		if ((lle != NULL) && (lle->la_flags & LLE_PUB)) {
 			if (tha)
 				memcpy(tha, ar_sha(ah), ah->ar_hln);
 			memcpy(ar_sha(ah), &lle->ll_addr, ah->ar_hln);
 			LLE_RUNLOCK(lle);
 		} else {
 			if (lle != NULL)
 				LLE_RUNLOCK(lle);
 			goto out;
+		}
+	}
 	ia4_release(ia, &psref_ia);
 	/*
 	 * XXX XXX: Here we're recycling the mbuf. But the mbuf could have
 	 * other mbufs in its chain, and just overwriting m->m_pkthdr.len
 	 * would be wrong in this case (the length becomes smaller than the
 	 * real chain size).
+	 *
 	 * This can theoretically cause bugs in the lower layers (drivers,
 	 * and L2encap), in some corner cases.
 	 */
 	memcpy(ar_tpa(ah), ar_spa(ah), ah->ar_pln);
 	memcpy(ar_spa(ah), &itaddr, ah->ar_pln);
 	ah->ar_op = htons(ARPOP_REPLY);
 	ah->ar_pro = htons(ETHERTYPE_IP); /* let's be sure! */
 	switch (ifp->if_type) {
 	case IFT_IEEE1394:
 		/* ieee1394 arp reply is broadcast */
 		m->m_flags &= ~M_MCAST;
 		m->m_flags |= M_BCAST;
 		m->m_len = sizeof(*ah) + (2 * ah->ar_pln) + ah->ar_hln;
 		break;
 	default:
 		m->m_flags &= ~(M_BCAST|M_MCAST); /* never reply by broadcast */
 		m->m_len = sizeof(*ah) + (2 * ah->ar_pln) + (2 * ah->ar_hln);
 		break;
+	}
 	m->m_pkthdr.len = m->m_len;
 	sa.sa_family = AF_ARP;
 	sa.sa_len = 2;
 	arps = ARP_STAT_GETREF();
 	arps[ARP_STAT_SNDTOTAL]++;
 	arps[ARP_STAT_SNDREPLY]++;
 	ARP_STAT_PUTREF();
 	if_output_lock(ifp, ifp, m, &sa, NULL);
 	if (rcvif != NULL)
 		m_put_rcvif_psref(rcvif, &psref);
 	return;
 out:
 	if (la != NULL)
 		LLE_WUNLOCK(la);
 	if (ia != NULL)
 		ia4_release(ia, &psref_ia);
 	if (rcvif != NULL)
 		m_put_rcvif_psref(rcvif, &psref);
 	m_freem(m);
+}
 /*
  * Lookup or a new address in arptab.
  */
 struct llentry *
 arplookup(struct ifnet *ifp, const struct in_addr *addr,
     const struct sockaddr *sa, int wlock)
+{
 	struct sockaddr_in sin;
 	struct llentry *la;
 	int flags = wlock ? LLE_EXCLUSIVE : 0;
 	if (sa == NULL) {
 		KASSERT(addr != NULL);
 		sockaddr_in_init(&sin, addr, 0);
 		sa = sintocsa(&sin);
+	}
 	IF_AFDATA_RLOCK(ifp);
 	la = lla_lookup(LLTABLE(ifp), flags, sa);
 	IF_AFDATA_RUNLOCK(ifp);
 	return la;
+}
 static struct llentry *
 arpcreate(struct ifnet *ifp, const struct in_addr *addr,
     const struct sockaddr *sa, int wlock)
+{
 	struct sockaddr_in sin;
 	struct llentry *la;
 	int flags = wlock ? LLE_EXCLUSIVE : 0;
 	if (sa == NULL) {
 		KASSERT(addr != NULL);
 		sockaddr_in_init(&sin, addr, 0);
 		sa = sintocsa(&sin);
+	}
 	la = arplookup(ifp, addr, sa, wlock);
 	if (la == NULL) {
 		struct rtentry *rt;
 		rt = rtalloc1(sa, 0);
 		IF_AFDATA_WLOCK(ifp);
 		la = lla_create(LLTABLE(ifp), flags, sa, rt);
 		IF_AFDATA_WUNLOCK(ifp);
 		if (rt != NULL)
 			rt_unref(rt);
 		if (la != NULL)
 			la->ln_state = ND_LLINFO_NOSTATE;
+	}
 	return la;
+}
 int
 arpioctl(u_long cmd, void *data)
+{
 	return EOPNOTSUPP;
+}
 void
 arp_ifinit(struct ifnet *ifp, struct ifaddr *ifa)
+{
 	struct in_ifaddr *ia = (struct in_ifaddr *)ifa;
 	ifa->ifa_rtrequest = arp_rtrequest;
 	ifa->ifa_flags |= RTF_CONNECTED;
 	/* ARP will handle DAD for this address. */
 	if (in_nullhost(IA_SIN(ifa)->sin_addr)) {
 		if (ia->ia_dad_stop != NULL)	/* safety */
 			ia->ia_dad_stop(ifa);
 		ia->ia_dad_start = NULL;
 		ia->ia_dad_stop = NULL;
 		ia->ia4_flags &= ~IN_IFF_TENTATIVE;
 	} else {
 		ia->ia_dad_start = arp_dad_start;
 		ia->ia_dad_stop = arp_dad_stop;
 		if (ia->ia4_flags & IN_IFF_TRYTENTATIVE && ip_dad_enabled())
 			ia->ia4_flags |= IN_IFF_TENTATIVE;
 		else
 			arpannounce1(ifa);
+	}
+}
 static bool
 arp_nud_enabled(__unused struct ifnet *ifp)
+{
 	return arp_perform_nud != 0;
+}
 static unsigned int
 arp_llinfo_reachable(__unused struct ifnet *ifp)
+{
 	return arp_reachable;
+}
 static unsigned int
 arp_llinfo_retrans(__unused struct ifnet *ifp)
+{
 	return arp_retrans;
+}
 /*
  * Gets source address of the first packet in hold queue
  * and stores it in @src.
  * Returns pointer to @src (if hold queue is not empty) or NULL.
  */
 static union l3addr *
 arp_llinfo_holdsrc(struct llentry *ln, union l3addr *src)
+{
 	struct ip *ip;
 	if (ln == NULL || ln->ln_hold == NULL)
 		return NULL;
 	/*
 	 * assuming every packet in ln_hold has the same IP header
 	 */
 	ip = mtod(ln->ln_hold, struct ip *);
 	/* XXX pullup? */
 	if (sizeof(*ip) < ln->ln_hold->m_len)
 		src->addr4 = ip->ip_src;
 	else
 		src = NULL;
 	return src;
+}
 static void
 arp_llinfo_output(struct ifnet *ifp, __unused const union l3addr *daddr,
     const union l3addr *taddr, const uint8_t *tlladdr,
     const union l3addr *hsrc)
+{
 	struct in_addr tip = taddr->addr4, sip = zeroin_addr;
 	const uint8_t *slladdr = CLLADDR(ifp->if_sadl);
 	if (hsrc != NULL) {
 		struct in_ifaddr *ia;
 		struct psref psref;
 		ia = in_get_ia_on_iface_psref(hsrc->addr4, ifp, &psref);
 		if (ia != NULL) {
 			sip = hsrc->addr4;
 			ia4_release(ia, &psref);
+		}
+	}
 	if (sip.s_addr == INADDR_ANY) {
 		struct sockaddr_in dst;
 		struct rtentry *rt;
 		sockaddr_in_init(&dst, &tip, 0);
 		rt = rtalloc1(sintosa(&dst), 0);
 		if (rt != NULL) {
 			if (rt->rt_ifp == ifp &&
 			    rt->rt_ifa != NULL &&
 			    rt->rt_ifa->ifa_addr->sa_family == AF_INET)
 				sip = satosin(rt->rt_ifa->ifa_addr)->sin_addr;
 			rt_unref(rt);
+		}
 		if (sip.s_addr == INADDR_ANY) {
 			char ipbuf[INET_ADDRSTRLEN];
 			log(LOG_DEBUG, "source can't be "
 			    "determined: dst=%s\n",
 			    IN_PRINT(ipbuf, &tip));
 			return;
+		}
+	}
 	arprequest(ifp, &sip, &tip, slladdr, tlladdr);
+}
 static void
 arp_llinfo_missed(struct ifnet *ifp, const union l3addr *taddr,
     __unused int16_t type, struct mbuf *m)
+{
 	struct in_addr mdaddr = zeroin_addr;
 	struct sockaddr_in dsin, tsin;
 	struct sockaddr *sa;
 	if (m != NULL) {
 		struct ip *ip = mtod(m, struct ip *);
 		if (sizeof(*ip) < m->m_len)
 			mdaddr = ip->ip_src;
 		/* ip_input() will send ICMP_UNREACH_HOST, not us. */
 		m_freem(m);
+	}
 	if (mdaddr.s_addr != INADDR_ANY) {
 		sockaddr_in_init(&dsin, &mdaddr, 0);
 		sa = sintosa(&dsin);
 	} else
 		sa = NULL;
 	sockaddr_in_init(&tsin, &taddr->addr4, 0);
 	rt_clonedmsg(RTM_MISS, sa, sintosa(&tsin), NULL, ifp);
+}
 static void
 arp_free(struct llentry *ln, int gc)
+{
 	struct ifnet *ifp;
 	KASSERT(ln != NULL);
 	LLE_WLOCK_ASSERT(ln);
 	ifp = ln->lle_tbl->llt_ifp;
 	if (ln->la_flags & LLE_VALID || gc) {
 		struct sockaddr_in sin;
 		const char *lladdr;
 		sockaddr_in_init(&sin, &ln->r_l3addr.addr4, 0);
 		lladdr = ln->la_flags & LLE_VALID ?
 		    (const char *)&ln->ll_addr : NULL;
 		rt_clonedmsg(RTM_DELETE, NULL, sintosa(&sin), lladdr, ifp);
+	}
 	/*
 	 * Save to unlock. We still hold an extra reference and will not
 	 * free(9) in llentry_free() if someone else holds one as well.
 	 */
 	LLE_WUNLOCK(ln);
 	IF_AFDATA_LOCK(ifp);
 	LLE_WLOCK(ln);
 	lltable_free_entry(LLTABLE(ifp), ln);
 	IF_AFDATA_UNLOCK(ifp);
+}
 /*
  * Upper-layer reachability hint for Neighbor Unreachability Detection.
+ *
  * XXX cost-effective methods?
  */
 void
 arp_nud_hint(struct rtentry *rt)
+{
 	struct llentry *ln;
 	struct ifnet *ifp;
 	if (rt == NULL)
 		return;
 	ifp = rt->rt_ifp;
 	ln = arplookup(ifp, NULL, rt_getkey(rt), 1);
 	nd_nud_hint(ln);
+}
 TAILQ_HEAD(dadq_head, dadq);
 struct dadq {
 	TAILQ_ENTRY(dadq) dad_list;
 	struct ifaddr *dad_ifa;
 	int dad_count;		/* max ARP to send */
 	int dad_arp_tcount;	/* # of trials to send ARP */
 	int dad_arp_ocount;	/* ARP sent so far */
 	int dad_arp_announce;	/* max ARP announcements */
 	int dad_arp_acount;	/* # of announcements */
 	struct callout dad_timer_ch;
 };
 static struct dadq_head dadq;
 static int dad_maxtry = 15;     /* max # of *tries* to transmit DAD packet */
 static kmutex_t arp_dad_lock;
 static void
 arp_dad_init(void)
+{
 	TAILQ_INIT(&dadq);
 	mutex_init(&arp_dad_lock, MUTEX_DEFAULT, IPL_NONE);
+}
 static struct dadq *
 arp_dad_find(struct ifaddr *ifa)
+{
 	struct dadq *dp;
 	KASSERT(mutex_owned(&arp_dad_lock));
 	TAILQ_FOREACH(dp, &dadq, dad_list) {
 		if (dp->dad_ifa == ifa)
 			return dp;
+	}
 	return NULL;
+}
 static void
 arp_dad_starttimer(struct dadq *dp, int ticks)
+{
 	callout_reset(&dp->dad_timer_ch, ticks,
 	    (void (*)(void *))arp_dad_timer, dp);
+}
 static void
 arp_dad_stoptimer(struct dadq *dp)
+{
 	KASSERT(mutex_owned(&arp_dad_lock));
 	TAILQ_REMOVE(&dadq, dp, dad_list);
 	/* Tell the timer that dp is being destroyed. */
 	dp->dad_ifa = NULL;
 	callout_halt(&dp->dad_timer_ch, &arp_dad_lock);
+}
 static void
 arp_dad_destroytimer(struct dadq *dp)
+{
 	callout_destroy(&dp->dad_timer_ch);
 	KASSERT(dp->dad_ifa == NULL);
 	kmem_intr_free(dp, sizeof(*dp));
+}
 static void
 arp_dad_output(struct dadq *dp, struct ifaddr *ifa)
+{
 	struct in_ifaddr *ia = (struct in_ifaddr *)ifa;
 	struct ifnet *ifp = ifa->ifa_ifp;
 	struct in_addr sip;
 	dp->dad_arp_tcount++;
 	if ((ifp->if_flags & IFF_UP) == 0)
 		return;
 	if ((ifp->if_flags & IFF_RUNNING) == 0)
 		return;
 	dp->dad_arp_tcount = 0;
 	dp->dad_arp_ocount++;
 	memset(&sip, 0, sizeof(sip));
 	arprequest(ifa->ifa_ifp, &sip, &ia->ia_addr.sin_addr,
 	    CLLADDR(ifa->ifa_ifp->if_sadl), NULL);
+}
 /*
  * Start Duplicate Address Detection (DAD) for specified interface address.
  */
 static void
 arp_dad_start(struct ifaddr *ifa)
+{
 	struct in_ifaddr *ia = (struct in_ifaddr *)ifa;
 	struct dadq *dp;
 	char ipbuf[INET_ADDRSTRLEN];
 	/*
 	 * If we don't need DAD, don't do it.
 	 * - DAD is disabled
 	 */
 	if (!(ia->ia4_flags & IN_IFF_TENTATIVE)) {
 		log(LOG_DEBUG,
 		    "%s: called with non-tentative address %s(%s)\n", __func__,
 		    IN_PRINT(ipbuf, &ia->ia_addr.sin_addr),
 		    ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
 		return;
+	}
 	if (!ip_dad_enabled()) {
 		ia->ia4_flags &= ~IN_IFF_TENTATIVE;
 		rt_addrmsg(RTM_NEWADDR, ifa);
 		arpannounce1(ifa);
 		return;
+	}
 	KASSERT(ifa->ifa_ifp != NULL);
 	if (!(ifa->ifa_ifp->if_flags & IFF_UP))
 		return;
 	dp = kmem_intr_alloc(sizeof(*dp), KM_NOSLEEP);
 	mutex_enter(&arp_dad_lock);
 	if (arp_dad_find(ifa) != NULL) {
 		mutex_exit(&arp_dad_lock);
 		/* DAD already in progress */
 		if (dp != NULL)
 			kmem_intr_free(dp, sizeof(*dp));
 		return;
+	}
 	if (dp == NULL) {
 		mutex_exit(&arp_dad_lock);
 		log(LOG_ERR, "%s: memory allocation failed for %s(%s)\n",
 		    __func__, IN_PRINT(ipbuf, &ia->ia_addr.sin_addr),
 		    ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
 		return;
+	}
 	/*
 	 * Send ARP packet for DAD, ip_dad_count times.
 	 * Note that we must delay the first transmission.
 	 */
 	callout_init(&dp->dad_timer_ch, CALLOUT_MPSAFE);
 	dp->dad_ifa = ifa;
 	ifaref(ifa);	/* just for safety */
 	dp->dad_count = ip_dad_count;
 	dp->dad_arp_announce = 0; /* Will be set when starting to announce */
 	dp->dad_arp_acount = dp->dad_arp_ocount = dp->dad_arp_tcount = 0;
 	TAILQ_INSERT_TAIL(&dadq, (struct dadq *)dp, dad_list);
 	ARPLOG(LOG_DEBUG, "%s: starting DAD for %s\n", if_name(ifa->ifa_ifp),
 	    ARPLOGADDR(&ia->ia_addr.sin_addr));
 	arp_dad_starttimer(dp, cprng_fast32() % (PROBE_WAIT * hz));
 	mutex_exit(&arp_dad_lock);
+}
 /*
  * terminate DAD unconditionally.  used for address removals.
  */
 static void
 arp_dad_stop(struct ifaddr *ifa)
+{
 	struct dadq *dp;
 	mutex_enter(&arp_dad_lock);
 	dp = arp_dad_find(ifa);
 	if (dp == NULL) {
 		mutex_exit(&arp_dad_lock);
 		/* DAD wasn't started yet */
 		return;
+	}
 	arp_dad_stoptimer(dp);
 	mutex_exit(&arp_dad_lock);
 	arp_dad_destroytimer(dp);
 	ifafree(ifa);
+}
 static void
 arp_dad_timer(struct dadq *dp)
+{
 	struct ifaddr *ifa;
 	struct in_ifaddr *ia;
 	char ipbuf[INET_ADDRSTRLEN];
 	bool need_free = false;
 	KERNEL_LOCK_UNLESS_NET_MPSAFE();
 	mutex_enter(&arp_dad_lock);
 	ifa = dp->dad_ifa;
 	if (ifa == NULL) {
 		/* dp is being destroyed by someone.  Do nothing. */
 		goto done;
+	}
 	ia = (struct in_ifaddr *)ifa;
 	if (ia->ia4_flags & IN_IFF_DUPLICATED) {
 		log(LOG_ERR, "%s: called with duplicate address %s(%s)\n",
 		    __func__, IN_PRINT(ipbuf, &ia->ia_addr.sin_addr),
 		    ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
 		goto done;
+	}
 	if ((ia->ia4_flags & IN_IFF_TENTATIVE) == 0 && dp->dad_arp_acount == 0)
+	{
 		log(LOG_ERR, "%s: called with non-tentative address %s(%s)\n",
 		    __func__, IN_PRINT(ipbuf, &ia->ia_addr.sin_addr),
 		    ifa->ifa_ifp ? if_name(ifa->ifa_ifp) : "???");
 		goto done;
+	}
 	/* timeouted with IFF_{RUNNING,UP} check */
 	if (dp->dad_arp_tcount > dad_maxtry) {
 		ARPLOG(LOG_INFO, "%s: could not run DAD, driver problem?\n",
 		    if_name(ifa->ifa_ifp));
 		arp_dad_stoptimer(dp);
 		need_free = true;
 		goto done;
+	}
 	/* Need more checks? */
 	if (dp->dad_arp_ocount < dp->dad_count) {
 		int adelay;
 		/*
 		 * We have more ARP to go.  Send ARP packet for DAD.
 		 */
 		arp_dad_output(dp, ifa);
 		if (dp->dad_arp_ocount < dp->dad_count)
 			adelay = (PROBE_MIN * hz) +
 			    (cprng_fast32() %
 			    ((PROBE_MAX * hz) - (PROBE_MIN * hz)));
 		else
 			adelay = ANNOUNCE_WAIT * hz;
 		arp_dad_starttimer(dp, adelay);
 		goto done;
 	} else if (dp->dad_arp_acount == 0) {
 		/*
 		 * We are done with DAD.
 		 * No duplicate address found.
 		 */
 		ia->ia4_flags &= ~IN_IFF_TENTATIVE;
 		rt_addrmsg(RTM_NEWADDR, ifa);
 		ARPLOG(LOG_DEBUG,
 		    "%s: DAD complete for %s - no duplicates found\n",
 		    if_name(ifa->ifa_ifp), ARPLOGADDR(&ia->ia_addr.sin_addr));
 		dp->dad_arp_announce = ANNOUNCE_NUM;
 		goto announce;
 	} else if (dp->dad_arp_acount < dp->dad_arp_announce) {
 announce:
 		/*
 		 * Announce the address.
 		 */
 		arpannounce1(ifa);
 		dp->dad_arp_acount++;
 		if (dp->dad_arp_acount < dp->dad_arp_announce) {
 			arp_dad_starttimer(dp, ANNOUNCE_INTERVAL * hz);
 			goto done;
+		}
 		ARPLOG(LOG_DEBUG,
 		    "%s: ARP announcement complete for %s\n",
 		    if_name(ifa->ifa_ifp), ARPLOGADDR(&ia->ia_addr.sin_addr));
+	}
 	arp_dad_stoptimer(dp);
 	need_free = true;
 done:
 	mutex_exit(&arp_dad_lock);
 	if (need_free) {
 		arp_dad_destroytimer(dp);
 		KASSERT(ifa != NULL);
 		ifafree(ifa);
+	}
 	KERNEL_UNLOCK_UNLESS_NET_MPSAFE();
+}
 static void
 arp_dad_duplicated(struct ifaddr *ifa, const struct sockaddr_dl *from)
+{
 	struct in_ifaddr *ia = ifatoia(ifa);
 	struct ifnet *ifp = ifa->ifa_ifp;
 	char ipbuf[INET_ADDRSTRLEN], llabuf[LLA_ADDRSTRLEN];
 	const char *iastr, *llastr;
 	iastr = IN_PRINT(ipbuf, &ia->ia_addr.sin_addr);
 	if (__predict_false(from == NULL))
 		llastr = NULL;
 	else
 		llastr = lla_snprintf(llabuf, sizeof(llabuf),
 		    CLLADDR(from), from->sdl_alen);
 	if (ia->ia4_flags & (IN_IFF_TENTATIVE|IN_IFF_DUPLICATED)) {
 		log(LOG_ERR,
 		    "%s: DAD duplicate address %s from %s\n",
 		    if_name(ifp), iastr, llastr);
 	} else if (ia->ia_dad_defended == 0 ||
 		   ia->ia_dad_defended < time_uptime - DEFEND_INTERVAL) {
 		ia->ia_dad_defended = time_uptime;
 		arpannounce1(ifa);
 		log(LOG_ERR,
 		    "%s: DAD defended address %s from %s\n",
 		    if_name(ifp), iastr, llastr);
 		return;
 	} else {
 		/* If DAD is disabled, just report the duplicate. */
 		if (!ip_dad_enabled()) {
 			log(LOG_ERR,
 			    "%s: DAD ignoring duplicate address %s from %s\n",
 			    if_name(ifp), iastr, llastr);
 			return;
+		}
 		log(LOG_ERR,
 		    "%s: DAD defence failed for %s from %s\n",
 		    if_name(ifp), iastr, llastr);
+	}
 	arp_dad_stop(ifa);
 	ia->ia4_flags &= ~IN_IFF_TENTATIVE;
 	if ((ia->ia4_flags & IN_IFF_DUPLICATED) == 0) {
 		ia->ia4_flags |= IN_IFF_DUPLICATED;
 		/* Inform the routing socket of the duplicate address */
 		rt_addrmsg_src(RTM_NEWADDR, ifa, (const struct sockaddr *)from);
+	}
+}
 /*
  * Called from 10 Mb/s Ethernet interrupt handlers
  * when ether packet type ETHERTYPE_REVARP
  * is received.  Common length and type checks are done here,
  * then the protocol-specific routine is called.
  */
 void
 revarpinput(struct mbuf *m)
+{
 	struct arphdr *ar;
 	int arplen;
 	arplen = sizeof(struct arphdr);
 	if (m->m_len < arplen && (m = m_pullup(m, arplen)) == NULL)
 		return;
 	ar = mtod(m, struct arphdr *);
 	if (ntohs(ar->ar_hrd) == ARPHRD_IEEE1394) {
 		goto out;
+	}
 	arplen = sizeof(struct arphdr) + 2 * (ar->ar_hln + ar->ar_pln);
 	if (m->m_len < arplen && (m = m_pullup(m, arplen)) == NULL)
 		return;
 	ar = mtod(m, struct arphdr *);
 	switch (ntohs(ar->ar_pro)) {
 	case ETHERTYPE_IP:
 	case ETHERTYPE_IPTRAILERS:
 		in_revarpinput(m);
 		return;
 	default:
 		break;
+	}
 out:
 	m_freem(m);
+}
 /*
  * RARP for Internet protocols on 10 Mb/s Ethernet.
  * Algorithm is that given in RFC 903.
  * We are only using for bootstrap purposes to get an ip address for one of
  * our interfaces.  Thus we support no user-interface.
+ *
  * Since the contents of the RARP reply are specific to the interface that
  * sent the request, this code must ensure that they are properly associated.
+ *
  * Note: also supports ARP via RARP packets, per the RFC.
  */
 void
 in_revarpinput(struct mbuf *m)
+{
 	struct arphdr *ah;
 	void *tha;
 	int op;
 	struct ifnet *rcvif;
 	int s;
 	ah = mtod(m, struct arphdr *);
 	op = ntohs(ah->ar_op);
 	rcvif = m_get_rcvif(m, &s);
 	if (__predict_false(rcvif == NULL))
 		goto out;
 	if (rcvif->if_flags & IFF_NOARP)
 		goto out;
 	switch (rcvif->if_type) {
 	case IFT_IEEE1394:
 		/* ARP without target hardware address is not supported */
 		goto out;
 	default:
 		break;
+	}
 	switch (op) {
 	case ARPOP_REQUEST:
 	case ARPOP_REPLY:	/* per RFC */
 		m_put_rcvif(rcvif, &s);
 		in_arpinput(m);
 		return;
 	case ARPOP_REVREPLY:
 		break;
 	case ARPOP_REVREQUEST:	/* handled by rarpd(8) */
 	default:
 		goto out;
+	}
 	if (!revarp_in_progress)
 		goto out;
 	if (rcvif != myip_ifp) /* !same interface */
 		goto out;
 	if (myip_initialized)
 		goto wake;
 	tha = ar_tha(ah);
 	if (tha == NULL)
 		goto out;
 	if (ah->ar_pln != sizeof(struct in_addr))
 		goto out;
 	if (ah->ar_hln != rcvif->if_sadl->sdl_alen)
 		goto out;
 	if (memcmp(tha, CLLADDR(rcvif->if_sadl), rcvif->if_sadl->sdl_alen))
 		goto out;
 	memcpy(&srv_ip, ar_spa(ah), sizeof(srv_ip));
 	memcpy(&myip, ar_tpa(ah), sizeof(myip));
 	myip_initialized = 1;
 wake:	/* Do wakeup every time in case it was missed. */
 	wakeup((void *)&myip);
 out:
 	m_put_rcvif(rcvif, &s);
 	m_freem(m);
+}
 /*
  * Send a RARP request for the ip address of the specified interface.
  * The request should be RFC 903-compliant.
  */
 static void
 revarprequest(struct ifnet *ifp)
+{
 	struct sockaddr sa;
 	struct mbuf *m;
 	struct arphdr *ah;
 	void *tha;
 	if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
 		return;
 	MCLAIM(m, &arpdomain.dom_mowner);
 	m->m_len = sizeof(*ah) + 2*sizeof(struct in_addr) +
 *ifp->if_addrlen;
 	m->m_pkthdr.len = m->m_len;
 	m_align(m, m->m_len);
 	ah = mtod(m, struct arphdr *);
 	memset(ah, 0, m->m_len);
 	ah->ar_pro = htons(ETHERTYPE_IP);
 	ah->ar_hln = ifp->if_addrlen;		/* hardware address length */
 	ah->ar_pln = sizeof(struct in_addr);	/* protocol address length */
 	ah->ar_op = htons(ARPOP_REVREQUEST);
 	memcpy(ar_sha(ah), CLLADDR(ifp->if_sadl), ah->ar_hln);
 	tha = ar_tha(ah);
 	if (tha == NULL) {
 		m_free(m);
 		return;
+	}
 	memcpy(tha, CLLADDR(ifp->if_sadl), ah->ar_hln);
 	sa.sa_family = AF_ARP;
 	sa.sa_len = 2;
 	m->m_flags |= M_BCAST;
 	if_output_lock(ifp, ifp, m, &sa, NULL);
+}
 /*
  * RARP for the ip address of the specified interface, but also
  * save the ip address of the server that sent the answer.
  * Timeout if no response is received.
  */
 int
 revarpwhoarewe(struct ifnet *ifp, struct in_addr *serv_in,
     struct in_addr *clnt_in)
+{
 	int result, count = 20;
 	myip_initialized = 0;
 	myip_ifp = ifp;
 	revarp_in_progress = 1;
 	while (count--) {
 		revarprequest(ifp);
 		result = tsleep((void *)&myip, PSOCK, "revarp", hz/2);
 		if (result != EWOULDBLOCK)
 			break;
+	}
 	revarp_in_progress = 0;
 	if (!myip_initialized)
 		return ENETUNREACH;

 @@ -1,963 +1,964 @@
-/*	$NetBSD: mbuf.h,v 1.235 2022/11/15 09:13:43 roy Exp $	*/
+/*	$NetBSD: mbuf.h,v 1.236 2022/11/15 10:47:39 roy Exp $	*/
 /*
  * Copyright (c) 1996, 1997, 1999, 2001, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center and Matt Thomas of 3am Software Foundry.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION 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.
  */
 /*
  * Copyright (c) 1982, 1986, 1988, 1993
  *	The Regents of the University of California.  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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * 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.
+ *
  *	@(#)mbuf.h	8.5 (Berkeley) 2/19/95
  */
 #ifndef _SYS_MBUF_H_
 #define _SYS_MBUF_H_
 #ifdef _KERNEL_OPT
 #include "opt_mbuftrace.h"
 #endif
 #ifndef M_WAITOK
 #include <sys/malloc.h>
 #endif
 #include <sys/pool.h>
 #include <sys/queue.h>
 #if defined(_KERNEL)
 #include <sys/percpu_types.h>
 #include <sys/socket.h>	/* for AF_UNSPEC */
 #include <sys/psref.h>
 #endif /* defined(_KERNEL) */
 /* For offsetof() */
 #if defined(_KERNEL) || defined(_STANDALONE)
 #include <sys/systm.h>
 #else
 #include <stddef.h>
 #endif
 #include <uvm/uvm_param.h>	/* for MIN_PAGE_SIZE */
 #include <net/if.h>
 /*
  * Mbufs are of a single size, MSIZE (machine/param.h), which
  * includes overhead.  An mbuf may add a single "mbuf cluster" of size
  * MCLBYTES (also in machine/param.h), which has no additional overhead
  * and is used instead of the internal data area; this is done when
  * at least MINCLSIZE of data must be stored.
  */
 /* Packet tags structure */
 struct m_tag {
 	SLIST_ENTRY(m_tag)	m_tag_link;	/* List of packet tags */
 	uint16_t		m_tag_id;	/* Tag ID */
 	uint16_t		m_tag_len;	/* Length of data */
 };
 /* mbuf ownership structure */
 struct mowner {
 	char mo_name[16];		/* owner name (fxp0) */
 	char mo_descr[16];		/* owner description (input) */
 	LIST_ENTRY(mowner) mo_link;	/* */
 	struct percpu *mo_counters;
 };
 #define MOWNER_INIT(x, y) { .mo_name = x, .mo_descr = y }
 enum mowner_counter_index {
 	MOWNER_COUNTER_CLAIMS,		/* # of small mbuf claimed */
 	MOWNER_COUNTER_RELEASES,	/* # of small mbuf released */
 	MOWNER_COUNTER_CLUSTER_CLAIMS,	/* # of cluster mbuf claimed */
 	MOWNER_COUNTER_CLUSTER_RELEASES,/* # of cluster mbuf released */
 	MOWNER_COUNTER_EXT_CLAIMS,	/* # of M_EXT mbuf claimed */
 	MOWNER_COUNTER_EXT_RELEASES,	/* # of M_EXT mbuf released */
 	MOWNER_COUNTER_NCOUNTERS,
 };
 #if defined(_KERNEL)
 struct mowner_counter {
 	u_long mc_counter[MOWNER_COUNTER_NCOUNTERS];
 };
 #endif
 /* userland-exported version of struct mowner */
 struct mowner_user {
 	char mo_name[16];		/* owner name (fxp0) */
 	char mo_descr[16];		/* owner description (input) */
 	LIST_ENTRY(mowner) mo_link;	/* unused padding; for compatibility */
 	u_long mo_counter[MOWNER_COUNTER_NCOUNTERS]; /* counters */
 };
 /*
  * Macros for type conversion
  * mtod(m,t) -	convert mbuf pointer to data pointer of correct type
  */
 #define mtod(m, t)	((t)((m)->m_data))
 /* header at beginning of each mbuf */
 struct m_hdr {
 	struct	mbuf *mh_next;		/* next buffer in chain */
 	struct	mbuf *mh_nextpkt;	/* next chain in queue/record */
 	char	*mh_data;		/* location of data */
 	struct	mowner *mh_owner;	/* mbuf owner */
 	int	mh_len;			/* amount of data in this mbuf */
 	int	mh_flags;		/* flags; see below */
 	paddr_t	mh_paddr;		/* physical address of mbuf */
 	short	mh_type;		/* type of data in this mbuf */
 };
 /*
  * record/packet header in first mbuf of chain; valid if M_PKTHDR set
+ *
  * A note about csum_data:
+ *
  *  o For the out-bound direction, the low 16 bits indicates the offset after
  *    the L4 header where the final L4 checksum value is to be stored and the
  *    high 16 bits is the length of the L3 header (the start of the data to
  *    be checksummed).
+ *
  *  o For the in-bound direction, it is only valid if the M_CSUM_DATA flag is
  *    set. In this case, an L4 checksum has been calculated by hardware and
  *    is stored in csum_data, but it is up to software to perform final
  *    verification.
+ *
  * Note for in-bound TCP/UDP checksums: we expect the csum_data to NOT
  * be bit-wise inverted (the final step in the calculation of an IP
  * checksum) -- this is so we can accumulate the checksum for fragmented
  * packets during reassembly.
+ *
  * Size ILP32: 40
  *       LP64: 56
  */
 struct pkthdr {
 	union {
 		void		*ctx;		/* for M_GETCTX/M_SETCTX */
 		if_index_t	index;		/* rcv interface index */
 	} _rcvif;
 #define rcvif_index		_rcvif.index
 	SLIST_HEAD(packet_tags, m_tag) tags;	/* list of packet tags */
 	int		len;			/* total packet length */
 	int		csum_flags;		/* checksum flags */
 	uint32_t	csum_data;		/* checksum data */
 	u_int		segsz;			/* segment size */
 	uint16_t	ether_vtag;		/* ethernet 802.1p+q vlan tag */
 	uint16_t	pkthdr_flags;		/* flags for pkthdr, see blow */
 #define PKTHDR_FLAG_IPSEC_SKIP_PFIL	0x0001	/* skip pfil_run_hooks() after ipsec decrypt */
 	/*
 	 * Following three fields are open-coded struct altq_pktattr
 	 * to rearrange struct pkthdr fields flexibly.
 	 */
 	int	pattr_af;		/* ALTQ: address family */
 	void	*pattr_class;		/* ALTQ: sched class set by classifier */
 	void	*pattr_hdr;		/* ALTQ: saved header position in mbuf */
 };
 /* Checksumming flags (csum_flags). */
 #define M_CSUM_TCPv4		0x00000001	/* TCP header/payload */
 #define M_CSUM_UDPv4		0x00000002	/* UDP header/payload */
 #define M_CSUM_TCP_UDP_BAD	0x00000004	/* TCP/UDP checksum bad */
 #define M_CSUM_DATA		0x00000008	/* consult csum_data */
 #define M_CSUM_TCPv6		0x00000010	/* IPv6 TCP header/payload */
 #define M_CSUM_UDPv6		0x00000020	/* IPv6 UDP header/payload */
 #define M_CSUM_IPv4		0x00000040	/* IPv4 header */
 #define M_CSUM_IPv4_BAD		0x00000080	/* IPv4 header checksum bad */
 #define M_CSUM_TSOv4		0x00000100	/* TCPv4 segmentation offload */
 #define M_CSUM_TSOv6		0x00000200	/* TCPv6 segmentation offload */
 /* Checksum-assist quirks: keep separate from jump-table bits. */
 #define M_CSUM_BLANK		0x40000000	/* csum is missing */
 #define M_CSUM_NO_PSEUDOHDR	0x80000000	/* Rx csum_data does not include
 						 * the UDP/TCP pseudo-hdr, and
 						 * is not yet 1s-complemented.
 						 */
 #define M_CSUM_BITS \
     "\20\1TCPv4\2UDPv4\3TCP_UDP_BAD\4DATA\5TCPv6\6UDPv6\7IPv4\10IPv4_BAD" \
     "\11TSOv4\12TSOv6\39BLANK\40NO_PSEUDOHDR"
 /*
  * Macros for manipulating csum_data on outgoing packets. These are
  * used to pass information down from the L4/L3 to the L2.
+ *
  *   _IPHL:   Length of the IPv{4/6} header, plus the options; in other
  *            words the offset of the UDP/TCP header in the packet.
  *   _OFFSET: Offset of the checksum field in the UDP/TCP header.
  */
 #define M_CSUM_DATA_IPv4_IPHL(x)	((x) >> 16)
 #define M_CSUM_DATA_IPv4_OFFSET(x)	((x) & 0xffff)
 #define M_CSUM_DATA_IPv6_IPHL(x)	((x) >> 16)
 #define M_CSUM_DATA_IPv6_OFFSET(x)	((x) & 0xffff)
 #define M_CSUM_DATA_IPv6_SET(x, v)	(x) = ((x) & 0xffff) | ((v) << 16)
 /*
  * Max # of pages we can attach to m_ext.  This is carefully chosen
  * to be able to handle SOSEND_LOAN_CHUNK with our minimum sized page.
  */
 #ifdef MIN_PAGE_SIZE
 #define M_EXT_MAXPAGES		((65536 / MIN_PAGE_SIZE) + 1)
 #endif
 /*
  * Description of external storage mapped into mbuf, valid if M_EXT set.
  */
 struct _m_ext_storage {
 	unsigned int ext_refcnt;
 	char *ext_buf;			/* start of buffer */
 	void (*ext_free)		/* free routine if not the usual */
 		(struct mbuf *, void *, size_t, void *);
 	void *ext_arg;			/* argument for ext_free */
 	size_t ext_size;		/* size of buffer, for ext_free */
 	union {
 		/* M_EXT_CLUSTER: physical address */
 		paddr_t extun_paddr;
 #ifdef M_EXT_MAXPAGES
 		/* M_EXT_PAGES: pages */
 		struct vm_page *extun_pgs[M_EXT_MAXPAGES];
 #endif
 	} ext_un;
 #define ext_paddr	ext_un.extun_paddr
 #define ext_pgs		ext_un.extun_pgs
 };
 struct _m_ext {
 	struct mbuf *ext_ref;
 	struct _m_ext_storage ext_storage;
 };
 #define M_PADDR_INVALID		POOL_PADDR_INVALID
 /*
  * Definition of "struct mbuf".
  * Don't change this without understanding how MHLEN/MLEN are defined.
  */
 #define MBUF_DEFINE(name, mhlen, mlen)					\
 	struct name {							\
 		struct m_hdr m_hdr;					\
 		union {							\
 			struct {					\
 				struct pkthdr MH_pkthdr;		\
 				union {					\
 					struct _m_ext MH_ext;		\
 					char MH_databuf[(mhlen)];	\
 				} MH_dat;				\
 			} MH;						\
 			char M_databuf[(mlen)];				\
 		} M_dat;						\
+	}
 #define m_next		m_hdr.mh_next
 #define m_len		m_hdr.mh_len
 #define m_data		m_hdr.mh_data
 #define m_owner		m_hdr.mh_owner
 #define m_type		m_hdr.mh_type
 #define m_flags		m_hdr.mh_flags
 #define m_nextpkt	m_hdr.mh_nextpkt
 #define m_paddr		m_hdr.mh_paddr
 #define m_pkthdr	M_dat.MH.MH_pkthdr
 #define m_ext_storage	M_dat.MH.MH_dat.MH_ext.ext_storage
 #define m_ext_ref	M_dat.MH.MH_dat.MH_ext.ext_ref
 #define m_ext		m_ext_ref->m_ext_storage
 #define m_pktdat	M_dat.MH.MH_dat.MH_databuf
 #define m_dat		M_dat.M_databuf
 /*
  * Dummy mbuf structure to calculate the right values for MLEN/MHLEN, taking
  * into account inter-structure padding.
  */
 MBUF_DEFINE(_mbuf_dummy, 1, 1);
 /* normal data len */
 #define MLEN		((int)(MSIZE - offsetof(struct _mbuf_dummy, m_dat)))
 /* data len w/pkthdr */
 #define MHLEN		((int)(MSIZE - offsetof(struct _mbuf_dummy, m_pktdat)))
 #define MINCLSIZE	(MHLEN+MLEN+1)	/* smallest amount to put in cluster */
 /*
  * The *real* struct mbuf
  */
 MBUF_DEFINE(mbuf, MHLEN, MLEN);
 /* mbuf flags */
 #define M_EXT		0x00000001	/* has associated external storage */
 #define M_PKTHDR	0x00000002	/* start of record */
 #define M_EOR		0x00000004	/* end of record */
 #define M_PROTO1	0x00000008	/* protocol-specific */
 /* mbuf pkthdr flags, also in m_flags */
 #define M_AUTHIPHDR	0x00000010	/* authenticated (IPsec) */
 #define M_DECRYPTED	0x00000020	/* decrypted (IPsec) */
 #define M_LOOP		0x00000040	/* received on loopback */
 #define M_BCAST		0x00000100	/* send/received as L2 broadcast */
 #define M_MCAST		0x00000200	/* send/received as L2 multicast */
 #define M_CANFASTFWD	0x00000400	/* packet can be fast-forwarded */
 #define M_ANYCAST6	0x00000800	/* received as IPv6 anycast */
 #define M_LINK0		0x00001000	/* link layer specific flag */
 #define M_LINK1		0x00002000	/* link layer specific flag */
 #define M_LINK2		0x00004000	/* link layer specific flag */
 #define M_LINK3		0x00008000	/* link layer specific flag */
 #define M_LINK4		0x00010000	/* link layer specific flag */
 #define M_LINK5		0x00020000	/* link layer specific flag */
 #define M_LINK6		0x00040000	/* link layer specific flag */
 #define M_LINK7		0x00080000	/* link layer specific flag */
 #define M_VLANTAG	0x00100000	/* ether_vtag is valid */
 /* additional flags for M_EXT mbufs */
 #define M_EXT_FLAGS	0xff000000
 #define M_EXT_CLUSTER	0x01000000	/* ext is a cluster */
 #define M_EXT_PAGES	0x02000000	/* ext_pgs is valid */
 #define M_EXT_ROMAP	0x04000000	/* ext mapping is r-o at MMU */
 #define M_EXT_RW	0x08000000	/* ext storage is writable */
 /* for source-level compatibility */
 #define M_NOTIFICATION	M_PROTO1
 #define M_FLAGS_BITS \
     "\20\1EXT\2PKTHDR\3EOR\4PROTO1\5AUTHIPHDR\6DECRYPTED\7LOOP\10NONE" \
     "\11BCAST\12MCAST\13CANFASTFWD\14ANYCAST6\15LINK0\16LINK1\17LINK2\20LINK3" \
     "\21LINK4\22LINK5\23LINK6\24LINK7" \
     "\25VLANTAG" \
     "\31EXT_CLUSTER\32EXT_PAGES\33EXT_ROMAP\34EXT_RW"
 /* flags copied when copying m_pkthdr */
 #define M_COPYFLAGS	(M_PKTHDR|M_EOR|M_BCAST|M_MCAST|M_CANFASTFWD| \
     M_ANYCAST6|M_LINK0|M_LINK1|M_LINK2|M_AUTHIPHDR|M_DECRYPTED|M_LOOP| \
     M_VLANTAG)
 /* flag copied when shallow-copying external storage */
 #define M_EXTCOPYFLAGS	(M_EXT|M_EXT_FLAGS)
 /* mbuf types */
 #define MT_FREE		0	/* should be on free list */
 #define MT_DATA		1	/* dynamic (data) allocation */
 #define MT_HEADER	2	/* packet header */
 #define MT_SONAME	3	/* socket name */
 #define MT_SOOPTS	4	/* socket options */
 #define MT_FTABLE	5	/* fragment reassembly header */
 #define MT_CONTROL	6	/* extra-data protocol message */
 #define MT_OOBDATA	7	/* expedited data  */
 #ifdef MBUFTYPES
 const char * const mbuftypes[] = {
 	"mbfree",
 	"mbdata",
 	"mbheader",
 	"mbsoname",
 	"mbsopts",
 	"mbftable",
 	"mbcontrol",
 	"mboobdata",
 };
 #else
 extern const char * const mbuftypes[];
 #endif
 /* flags to m_get/MGET */
 #define M_DONTWAIT	M_NOWAIT
 #define M_WAIT		M_WAITOK
 #ifdef MBUFTRACE
 /* Mbuf allocation tracing. */
 void mowner_init_owner(struct mowner *, const char *, const char *);
 void mowner_init(struct mbuf *, int);
 void mowner_ref(struct mbuf *, int);
 void m_claim(struct mbuf *, struct mowner *);
 void mowner_revoke(struct mbuf *, bool, int);
 void mowner_attach(struct mowner *);
 void mowner_detach(struct mowner *);
 void m_claimm(struct mbuf *, struct mowner *);
 #else
 #define mowner_init_owner(mo, n, d)	__nothing
 #define mowner_init(m, type)		__nothing
 #define mowner_ref(m, flags)		__nothing
 #define mowner_revoke(m, all, flags)	__nothing
 #define m_claim(m, mowner)		__nothing
 #define mowner_attach(mo)		__nothing
 #define mowner_detach(mo)		__nothing
 #define m_claimm(m, mo)			__nothing
 #endif
 #define MCLAIM(m, mo)		m_claim((m), (mo))
 #define MOWNER_ATTACH(mo)	mowner_attach(mo)
 #define MOWNER_DETACH(mo)	mowner_detach(mo)
 /*
  * mbuf allocation/deallocation macros:
+ *
  *	MGET(struct mbuf *m, int how, int type)
  * allocates an mbuf and initializes it to contain internal data.
+ *
  *	MGETHDR(struct mbuf *m, int how, int type)
  * allocates an mbuf and initializes it to contain a packet header
  * and internal data.
+ *
  * If 'how' is M_WAIT, these macros (and the corresponding functions)
  * are guaranteed to return successfully.
  */
 #define MGET(m, how, type)	m = m_get((how), (type))
 #define MGETHDR(m, how, type)	m = m_gethdr((how), (type))
 #if defined(_KERNEL)
 #define MCLINITREFERENCE(m)						\
 do {									\
 	KASSERT(((m)->m_flags & M_EXT) == 0);				\
 	(m)->m_ext_ref = (m);						\
 	(m)->m_ext.ext_refcnt = 1;					\
 } while (/* CONSTCOND */ 0)
 /*
  * Macros for mbuf external storage.
+ *
  * MCLGET allocates and adds an mbuf cluster to a normal mbuf;
  * the flag M_EXT is set upon success.
+ *
  * MEXTMALLOC allocates external storage and adds it to
  * a normal mbuf; the flag M_EXT is set upon success.
+ *
  * MEXTADD adds pre-allocated external storage to
  * a normal mbuf; the flag M_EXT is set upon success.
  */
 #define MCLGET(m, how)	m_clget((m), (how))
 #define MEXTMALLOC(m, size, how)					\
 do {									\
 	(m)->m_ext_storage.ext_buf = malloc((size), 0, (how));		\
 	if ((m)->m_ext_storage.ext_buf != NULL) {			\
 		MCLINITREFERENCE(m);					\
 		(m)->m_data = (m)->m_ext.ext_buf;			\
 		(m)->m_flags = ((m)->m_flags & ~M_EXTCOPYFLAGS) |	\
 				M_EXT|M_EXT_RW;				\
 		(m)->m_ext.ext_size = (size);				\
 		(m)->m_ext.ext_free = NULL;				\
 		(m)->m_ext.ext_arg = NULL;				\
 		mowner_ref((m), M_EXT);					\
 	}								\
 } while (/* CONSTCOND */ 0)
 #define MEXTADD(m, buf, size, type, free, arg)				\
 do {									\
 	MCLINITREFERENCE(m);						\
 	(m)->m_data = (m)->m_ext.ext_buf = (char *)(buf);		\
 	(m)->m_flags = ((m)->m_flags & ~M_EXTCOPYFLAGS) | M_EXT;	\
 	(m)->m_ext.ext_size = (size);					\
 	(m)->m_ext.ext_free = (free);					\
 	(m)->m_ext.ext_arg = (arg);					\
 	mowner_ref((m), M_EXT);						\
 } while (/* CONSTCOND */ 0)
 #define M_BUFADDR(m)							\
 	(((m)->m_flags & M_EXT) ? (m)->m_ext.ext_buf :			\
 	    ((m)->m_flags & M_PKTHDR) ? (m)->m_pktdat : (m)->m_dat)
 #define M_BUFSIZE(m)							\
 	(((m)->m_flags & M_EXT) ? (m)->m_ext.ext_size :			\
 	    ((m)->m_flags & M_PKTHDR) ? MHLEN : MLEN)
 #define MRESETDATA(m)	(m)->m_data = M_BUFADDR(m)
 /*
  * Compute the offset of the beginning of the data buffer of a non-ext
  * mbuf.
  */
 #define M_BUFOFFSET(m)							\
 	(((m)->m_flags & M_PKTHDR) ?					\
 	 offsetof(struct mbuf, m_pktdat) : offsetof(struct mbuf, m_dat))
 /*
  * Determine if an mbuf's data area is read-only.  This is true
  * if external storage is read-only mapped, or not marked as R/W,
  * or referenced by more than one mbuf.
  */
 #define M_READONLY(m)							\
 	(((m)->m_flags & M_EXT) != 0 &&					\
 	  (((m)->m_flags & (M_EXT_ROMAP|M_EXT_RW)) != M_EXT_RW ||	\
 	  (m)->m_ext.ext_refcnt > 1))
 #define M_UNWRITABLE(__m, __len)					\
 	((__m)->m_len < (__len) || M_READONLY((__m)))
 /*
  * Determine if an mbuf's data area is read-only at the MMU.
  */
 #define M_ROMAP(m)							\
 	(((m)->m_flags & (M_EXT|M_EXT_ROMAP)) == (M_EXT|M_EXT_ROMAP))
 /*
  * Compute the amount of space available before the current start of
  * data in an mbuf.
  */
 #define M_LEADINGSPACE(m)						\
 	(M_READONLY((m)) ? 0 : ((m)->m_data - M_BUFADDR(m)))
 /*
  * Compute the amount of space available
  * after the end of data in an mbuf.
  */
 #define _M_TRAILINGSPACE(m)						\
 	((m)->m_flags & M_EXT ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size - \
 	 ((m)->m_data + (m)->m_len) :					\
 	 &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len))
 #define M_TRAILINGSPACE(m)						\
 	(M_READONLY((m)) ? 0 : _M_TRAILINGSPACE((m)))
 /*
  * Arrange to prepend space of size plen to mbuf m.
  * If a new mbuf must be allocated, how specifies whether to wait.
  * If how is M_DONTWAIT and allocation fails, the original mbuf chain
  * is freed and m is set to NULL.
  */
 #define M_PREPEND(m, plen, how)						\
 do {									\
 	if (M_LEADINGSPACE(m) >= (plen)) {				\
 		(m)->m_data -= (plen);					\
 		(m)->m_len += (plen);					\
 	} else								\
 		(m) = m_prepend((m), (plen), (how));			\
 	if ((m) && (m)->m_flags & M_PKTHDR)				\
 		(m)->m_pkthdr.len += (plen);				\
 } while (/* CONSTCOND */ 0)
 /* change mbuf to new type */
 #define MCHTYPE(m, t)							\
 do {									\
 	KASSERT((t) != MT_FREE);					\
 	mbstat_type_add((m)->m_type, -1);				\
 	mbstat_type_add(t, 1);						\
 	(m)->m_type = t;						\
 } while (/* CONSTCOND */ 0)
 #ifdef DIAGNOSTIC
 #define M_VERIFY_PACKET(m)	m_verify_packet(m)
 #else
 #define M_VERIFY_PACKET(m)	__nothing
 #endif
 /* The "copy all" special length. */
 #define M_COPYALL	-1
 /*
  * Allow drivers and/or protocols to store private context information.
  */
 #define M_GETCTX(m, t)		((t)(m)->m_pkthdr._rcvif.ctx)
 #define M_SETCTX(m, c)		((void)((m)->m_pkthdr._rcvif.ctx = (void *)(c)))
 #define M_CLEARCTX(m)		M_SETCTX((m), NULL)
 /*
  * M_REGION_GET ensures that the "len"-sized region of type "typ" starting
  * from "off" within "m" is located in a single mbuf, contiguously.
+ *
  * The pointer to the region will be returned to pointer variable "val".
  */
 #define M_REGION_GET(val, typ, m, off, len) \
 do {									\
 	struct mbuf *_t;						\
 	int _tmp;							\
 	if ((m)->m_len >= (off) + (len))				\
 		(val) = (typ)(mtod((m), char *) + (off));		\
 	else {								\
 		_t = m_pulldown((m), (off), (len), &_tmp);		\
 		if (_t) {						\
 			if (_t->m_len < _tmp + (len))			\
 				panic("m_pulldown malfunction");	\
 			(val) = (typ)(mtod(_t, char *) + _tmp);	\
 		} else {						\
 			(val) = (typ)NULL;				\
 			(m) = NULL;					\
 		}							\
 	}								\
 } while (/*CONSTCOND*/ 0)
 #endif /* defined(_KERNEL) */
 /*
  * Simple mbuf queueing system
+ *
  * this is basically a SIMPLEQ adapted to mbuf use (ie using
  * m_nextpkt instead of field.sqe_next).
+ *
  * m_next is ignored, so queueing chains of mbufs is possible
  */
 #define MBUFQ_HEAD(name)					\
 struct name {							\
 	struct mbuf *mq_first;					\
 	struct mbuf **mq_last;					\
+}
 #define MBUFQ_INIT(q)		do {				\
 	(q)->mq_first = NULL;					\
 	(q)->mq_last = &(q)->mq_first;				\
 } while (/*CONSTCOND*/0)
 #define MBUFQ_ENQUEUE(q, m)	do {				\
 	(m)->m_nextpkt = NULL;					\
 	*(q)->mq_last = (m);					\
 	(q)->mq_last = &(m)->m_nextpkt;				\
 } while (/*CONSTCOND*/0)
 #define MBUFQ_PREPEND(q, m)	do {				\
 	if (((m)->m_nextpkt = (q)->mq_first) == NULL)		\
 		(q)->mq_last = &(m)->m_nextpkt;			\
 	(q)->mq_first = (m);					\
 } while (/*CONSTCOND*/0)
 #define MBUFQ_DEQUEUE(q, m)	do {				\
 	if (((m) = (q)->mq_first) != NULL) {			\
 		if (((q)->mq_first = (m)->m_nextpkt) == NULL)	\
 			(q)->mq_last = &(q)->mq_first;		\
 		else						\
 			(m)->m_nextpkt = NULL;			\
 	}							\
 } while (/*CONSTCOND*/0)
 #define MBUFQ_DRAIN(q)		do {				\
 	struct mbuf *__m0;					\
 	while ((__m0 = (q)->mq_first) != NULL) {		\
 		(q)->mq_first = __m0->m_nextpkt;		\
 		m_freem(__m0);					\
 	}							\
 	(q)->mq_last = &(q)->mq_first;				\
 } while (/*CONSTCOND*/0)
 #define MBUFQ_FIRST(q)		((q)->mq_first)
 #define MBUFQ_NEXT(m)		((m)->m_nextpkt)
 #define MBUFQ_LAST(q)		(*(q)->mq_last)
 /*
  * Mbuf statistics.
  * For statistics related to mbuf and cluster allocations, see also the
  * pool headers (mb_cache and mcl_cache).
  */
 struct mbstat {
 	u_long	_m_spare;	/* formerly m_mbufs */
 	u_long	_m_spare1;	/* formerly m_clusters */
 	u_long	_m_spare2;	/* spare field */
 	u_long	_m_spare3;	/* formely m_clfree - free clusters */
 	u_long	m_drops;	/* times failed to find space */
 	u_long	m_wait;		/* times waited for space */
 	u_long	m_drain;	/* times drained protocols for space */
 	u_short	m_mtypes[256];	/* type specific mbuf allocations */
 };
 struct mbstat_cpu {
 	u_int	m_mtypes[256];	/* type specific mbuf allocations */
 };
 /*
  * Mbuf sysctl variables.
  */
 #define MBUF_MSIZE		1	/* int: mbuf base size */
 #define MBUF_MCLBYTES		2	/* int: mbuf cluster size */
 #define MBUF_NMBCLUSTERS	3	/* int: limit on the # of clusters */
 #define MBUF_MBLOWAT		4	/* int: mbuf low water mark */
 #define MBUF_MCLLOWAT		5	/* int: mbuf cluster low water mark */
 #define MBUF_STATS		6	/* struct: mbstat */
 #define MBUF_MOWNERS		7	/* struct: m_owner[] */
 #ifdef _KERNEL
 extern struct mbstat mbstat;
 extern int nmbclusters;		/* limit on the # of clusters */
 extern int mblowat;		/* mbuf low water mark */
 extern int mcllowat;		/* mbuf cluster low water mark */
 extern int max_linkhdr;		/* largest link-level header */
 extern int max_protohdr;		/* largest protocol header */
 extern int max_hdr;		/* largest link+protocol header */
 extern int max_datalen;		/* MHLEN - max_hdr */
 extern const int msize;			/* mbuf base size */
 extern const int mclbytes;		/* mbuf cluster size */
 extern pool_cache_t mb_cache;
 #ifdef MBUFTRACE
 LIST_HEAD(mownerhead, mowner);
 extern struct mownerhead mowners;
 extern struct mowner unknown_mowners[];
 extern struct mowner revoked_mowner;
 #endif
 MALLOC_DECLARE(M_MBUF);
 MALLOC_DECLARE(M_SONAME);
 struct	mbuf *m_copym(struct mbuf *, int, int, int);
 struct	mbuf *m_copypacket(struct mbuf *, int);
 struct	mbuf *m_devget(char *, int, int, struct ifnet *);
 struct	mbuf *m_dup(struct mbuf *, int, int, int);
 struct	mbuf *m_get(int, int);
 struct	mbuf *m_gethdr(int, int);
 struct	mbuf *m_prepend(struct mbuf *,int, int);
 struct	mbuf *m_pulldown(struct mbuf *, int, int, int *);
 struct	mbuf *m_pullup(struct mbuf *, int);
 struct	mbuf *m_copyup(struct mbuf *, int, int);
 struct	mbuf *m_split(struct mbuf *,int, int);
 struct	mbuf *m_getptr(struct mbuf *, int, int *);
 void	m_adj(struct mbuf *, int);
 struct	mbuf *m_defrag(struct mbuf *, int);
 int	m_apply(struct mbuf *, int, int,
     int (*)(void *, void *, unsigned int), void *);
 void	m_cat(struct mbuf *,struct mbuf *);
 void	m_clget(struct mbuf *, int);
 void	m_copyback(struct mbuf *, int, int, const void *);
 struct	mbuf *m_copyback_cow(struct mbuf *, int, int, const void *, int);
 int	m_makewritable(struct mbuf **, int, int, int);
 struct	mbuf *m_getcl(int, int, int);
 void	m_copydata(struct mbuf *, int, int, void *);
 void	m_verify_packet(struct mbuf *);
 struct	mbuf *m_free(struct mbuf *);
 void	m_freem(struct mbuf *);
 void	mbinit(void);
 void	m_remove_pkthdr(struct mbuf *);
 void	m_copy_pkthdr(struct mbuf *, struct mbuf *);
 void	m_move_pkthdr(struct mbuf *, struct mbuf *);
 void	m_align(struct mbuf *, int);
 bool	m_ensure_contig(struct mbuf **, int);
 struct mbuf *m_add(struct mbuf *, struct mbuf *);
 /* Inline routines. */
 static __inline u_int m_length(const struct mbuf *) __unused;
 /* Statistics */
 void mbstat_type_add(int, int);
 /* Packet tag routines */
 struct	m_tag *m_tag_get(int, int, int);
 void	m_tag_free(struct m_tag *);
 void	m_tag_prepend(struct mbuf *, struct m_tag *);
 void	m_tag_unlink(struct mbuf *, struct m_tag *);
 void	m_tag_delete(struct mbuf *, struct m_tag *);
 void	m_tag_delete_chain(struct mbuf *);
 struct	m_tag *m_tag_find(const struct mbuf *, int);
 struct	m_tag *m_tag_copy(struct m_tag *);
 int	m_tag_copy_chain(struct mbuf *, struct mbuf *);
 /* Packet tag types */
 #define PACKET_TAG_NONE			0  /* Nothing */
 #define PACKET_TAG_SO			4  /* sending socket pointer */
 #define PACKET_TAG_NPF			10 /* packet filter */
 #define PACKET_TAG_PF			11 /* packet filter */
 #define PACKET_TAG_ALTQ_QID		12 /* ALTQ queue id */
 #define PACKET_TAG_IPSEC_OUT_DONE	18
 #define PACKET_TAG_IPSEC_NAT_T_PORTS	25 /* two uint16_t */
 #define PACKET_TAG_INET6		26 /* IPv6 info */
 #define PACKET_TAG_TUNNEL_INFO		28 /* tunnel identification and
 					    * protocol callback, for loop
 					    * detection/recovery
 					    */
 #define PACKET_TAG_MPLS			29 /* Indicate it's for MPLS */
 #define PACKET_TAG_SRCROUTE		30 /* IPv4 source routing */
 #define PACKET_TAG_ETHERNET_SRC		31 /* Ethernet source address */
 /*
  * Return the number of bytes in the mbuf chain, m.
  */
 static __inline u_int
 m_length(const struct mbuf *m)
+{
 	const struct mbuf *m0;
 	u_int pktlen;
 	if ((m->m_flags & M_PKTHDR) != 0)
 		return m->m_pkthdr.len;
 	pktlen = 0;
 	for (m0 = m; m0 != NULL; m0 = m0->m_next)
 		pktlen += m0->m_len;
 	return pktlen;
+}
 static __inline void
 m_set_rcvif(struct mbuf *m, const struct ifnet *ifp)
+{
 	KASSERT(m->m_flags & M_PKTHDR);
 	m->m_pkthdr.rcvif_index = ifp->if_index;
+}
 static __inline void
 m_reset_rcvif(struct mbuf *m)
+{
 	KASSERT(m->m_flags & M_PKTHDR);
 	/* A caller may expect whole _rcvif union is zeroed */
 	/* m->m_pkthdr.rcvif_index = 0; */
 	m->m_pkthdr._rcvif.ctx = NULL;
+}
 static __inline void
 m_copy_rcvif(struct mbuf *m, const struct mbuf *n)
+{
 	KASSERT(m->m_flags & M_PKTHDR);
 	KASSERT(n->m_flags & M_PKTHDR);
 	m->m_pkthdr.rcvif_index = n->m_pkthdr.rcvif_index;
+}
 #define M_GET_ALIGNED_HDR(m, type, linkhdr) \
     m_get_aligned_hdr((m), __alignof(type) - 1, sizeof(type), (linkhdr))
 static __inline int
 m_get_aligned_hdr(struct mbuf **m, int mask, size_t hlen, bool linkhdr)
+{
 #ifndef __NO_STRICT_ALIGNMENT
 	if (((uintptr_t)mtod(*m, void *) & mask) != 0)
 		*m = m_copyup(*m, hlen,
 		      linkhdr ? (max_linkhdr + mask) & ~mask : 0);
 	else
 #endif
 	if (__predict_false((size_t)(*m)->m_len < hlen))
 		*m = m_pullup(*m, hlen);
 	return *m == NULL;
+}
 void m_print(const struct mbuf *, const char *, void (*)(const char *, ...)
     __printflike(1, 2));
 /* from uipc_mbufdebug.c */
 void	m_examine(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 /* parsers for m_examine() */
 void m_examine_ether(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_pppoe(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_ppp(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_arp(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_ip(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_icmp(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_ip6(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_icmp6(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_tcp(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_udp(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 void m_examine_hex(const struct mbuf *, int, const char *,
     void (*)(const char *, ...) __printflike(1, 2));
 /*
  * Get rcvif of a mbuf.
+ *
  * The caller must call m_put_rcvif after using rcvif if the returned rcvif
  * isn't NULL. If the returned rcvif is NULL, the caller doesn't need to call
  * m_put_rcvif (although calling it is safe).
+ *
  * The caller must not block or sleep while using rcvif. The API ensures a
  * returned rcvif isn't freed until m_put_rcvif is called.
  */
 static __inline struct ifnet *
 m_get_rcvif(const struct mbuf *m, int *s)
+{
 	struct ifnet *ifp;
 	KASSERT(m->m_flags & M_PKTHDR);
 	*s = pserialize_read_enter();
 	ifp = if_byindex(m->m_pkthdr.rcvif_index);
 	if (__predict_false(ifp == NULL))
 		pserialize_read_exit(*s);
 	return ifp;
+}
 static __inline void
 m_put_rcvif(struct ifnet *ifp, int *s)
+{
 	if (ifp == NULL)
 		return;
 	pserialize_read_exit(*s);
+}
 /*
  * Get rcvif of a mbuf.
+ *
  * The caller must call m_put_rcvif_psref after using rcvif. The API ensures
  * a got rcvif isn't be freed until m_put_rcvif_psref is called.
  */
 static __inline struct ifnet *
 m_get_rcvif_psref(const struct mbuf *m, struct psref *psref)
+{
 	KASSERT(m->m_flags & M_PKTHDR);
 	return if_get_byindex(m->m_pkthdr.rcvif_index, psref);
+}
 static __inline void
 m_put_rcvif_psref(struct ifnet *ifp, struct psref *psref)
+{
 	if (ifp == NULL)
 		return;
 	if_put(ifp, psref);
+}
 /*
  * Get rcvif of a mbuf.
+ *
  * This is NOT an MP-safe API and shouldn't be used at where we want MP-safe.
  */
 static __inline struct ifnet *
 m_get_rcvif_NOMPSAFE(const struct mbuf *m)
+{
 	KASSERT(m->m_flags & M_PKTHDR);
 	return if_byindex(m->m_pkthdr.rcvif_index);
+}
 #endif /* _KERNEL */
 #endif /* !_SYS_MBUF_H_ */