 @@ -1,14 +1,14 @@
-/*	$NetBSD: altq_cdnr.c,v 1.22.6.1 2023/11/11 13:16:30 thorpej Exp $	*/
+/*	$NetBSD: altq_cdnr.c,v 1.22.6.1.2.1 2023/11/15 02:19:00 thorpej Exp $	*/
 /*	$KAME: altq_cdnr.c,v 1.15 2005/04/13 03:44:24 suz Exp $	*/
 /*
  * Copyright (C) 1999-2002
  *	Sony Computer Science Laboratories Inc.  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
 @@ -18,27 +18,27 @@
  * 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 SONY CSL 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: altq_cdnr.c,v 1.22.6.1 2023/11/11 13:16:30 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: altq_cdnr.c,v 1.22.6.1.2.1 2023/11/15 02:19:00 thorpej Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_altq.h"
 #include "opt_inet.h"
 #endif
 #include <sys/param.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 @@ -128,31 +128,36 @@ altqdev_decl(cdnr);
 /*
  * top level input function called from ip_input.
  * should be called before converting header fields to host-byte-order.
  */
 int
 altq_cdnr_input(struct mbuf *m, int af)
+{
 	struct ifnet		*ifp;
 	struct ip		*ip;
 	struct top_cdnr		*top;
 	struct tc_action	*tca;
 	struct cdnr_block	*cb;
 	struct cdnr_pktinfo	pktinfo;
 	bool			is_cnding = false;
 	ifp = m_get_rcvif_NOMPSAFE(m);
-	if (!ALTQ_IS_CNDTNING(&ifp->if_snd))
+	mutex_enter(ifp->if_snd.ifq_lock);
 	is_cnding = ALTQ_IS_CNDTNING(&ifp->if_snd);
 	mutex_exit(ifp->if_snd.ifq_lock);
 	if (!is_cnding) {
 		/* traffic conditioner is not enabled on this interface */
 		return (1);
+	}
 	top = ifp->if_snd.ifq_altq->altq_cdnr;
 	ip = mtod(m, struct ip *);
 #ifdef INET6
 	if (af == AF_INET6) {
 		u_int32_t flowlabel;
 		flowlabel = ((struct ip6_hdr *)ip)->ip6_flow;
 		pktinfo.pkt_dscp = (ntohl(flowlabel) >> 20) & DSCP_MASK;
 	} else
 #endif
 		pktinfo.pkt_dscp = ip->ip_tos & DSCP_MASK;
 @@ -418,50 +423,59 @@ top_create(struct ifaltq *ifq)
 	LIST_INSERT_HEAD(&tcb_list, top, tc_next);
 	ifq->altq_cdnr = top;
 	return (top);
+}
 static int
 top_destroy(struct top_cdnr *top)
+{
 	struct cdnr_block *cb;
 	mutex_enter(top->tc_ifq->altq_ifq->ifq_lock);
 	if (ALTQ_IS_CNDTNING(top->tc_ifq))
 		ALTQ_CLEAR_CNDTNING(top->tc_ifq);
 	top->tc_ifq->altq_cdnr = NULL;
 	mutex_exit(top->tc_ifq->altq_ifq->ifq_lock);
 	/*
 	 * destroy all the conditioner elements belonging to this interface
 	 */
 	while ((cb = LIST_FIRST(&top->tc_elements)) != NULL) {
 		while (cb != NULL && cb->cb_ref > 0)
 			cb = LIST_NEXT(cb, cb_next);
 		if (cb != NULL)
 			generic_element_destroy(cb);
+	}
 	LIST_REMOVE(top, tc_next);
 	cdnr_cbdestroy(top);
 	/* if there is no active conditioner, remove the input hook */
 	if (altq_input != NULL) {
-		LIST_FOREACH(top, &tcb_list, tc_next)
+		bool is_cnding = false;
 		LIST_FOREACH(top, &tcb_list, tc_next) {
 			mutex_enter(top->tc_ifq->altq_ifq->ifq_lock);
 			if (ALTQ_IS_CNDTNING(top->tc_ifq))
 				is_cnding = true;
 			mutex_exit(top->tc_ifq->altq_ifq->ifq_lock);
 			if (is_cnding)
 				break;
 		if (top == NULL)
 		if (!is_cnding)
 			altq_input = NULL;
+	}
 	return (0);
+}
 /*
  * simple tc elements without input function (e.g., dropper and makers).
  */
 static struct cdnr_block *
 element_create(struct top_cdnr *top, struct tc_action *action)
+{
 	struct cdnr_block *cb;
 @@ -1210,39 +1224,50 @@ cdnrioctl(dev_t dev, ioctlcmd_t cmd, voi
 		break;
 	case CDNR_ENABLE:
 	case CDNR_DISABLE:
 		ifacep = (struct cdnr_interface *)addr;
 		if ((top = tcb_lookup(ifacep->cdnr_ifname)) == NULL) {
 			error = EBADF;
 			break;
+		}
 		switch (cmd) {
 		case CDNR_ENABLE:
 			mutex_enter(top->tc_ifq->altq_ifq->ifq_lock);
 			ALTQ_SET_CNDTNING(top->tc_ifq);
 			mutex_exit(top->tc_ifq->altq_ifq->ifq_lock);
 			if (altq_input == NULL)
 				altq_input = altq_cdnr_input;
 			break;
-		case CDNR_DISABLE:
+		case CDNR_DISABLE: {
 			bool is_cnding = false;
 			mutex_enter(top->tc_ifq->altq_ifq->ifq_lock);
 			ALTQ_CLEAR_CNDTNING(top->tc_ifq);
-			LIST_FOREACH(top, &tcb_list, tc_next)
+			mutex_exit(top->tc_ifq->altq_ifq->ifq_lock);
 			LIST_FOREACH(top, &tcb_list, tc_next) {
 				mutex_enter(top->tc_ifq->altq_ifq->ifq_lock);
 				if (ALTQ_IS_CNDTNING(top->tc_ifq))
 					is_cnding = true;
 				mutex_exit(top->tc_ifq->altq_ifq->ifq_lock);
 				if (is_cnding)
 					break;
 			if (top == NULL)
 			if (!is_cnding)
 				altq_input = NULL;
 			break;
+		    }
+		}
 		break;
 	case CDNR_ADD_ELEM:
 		error = cdnrcmd_add_element((struct cdnr_add_element *)addr);
 		break;
 	case CDNR_DEL_ELEM:
 		error = cdnrcmd_delete_element((struct cdnr_delete_element *)addr);
 		break;
 	case CDNR_ADD_TBM:
 		error = cdnrcmd_add_tbm((struct cdnr_add_tbmeter *)addr);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: altq_subr.c,v 1.33.46.1 2023/11/11 13:16:30 thorpej Exp $	*/
+/*	$NetBSD: altq_subr.c,v 1.33.46.1.2.1 2023/11/15 02:19:00 thorpej Exp $	*/
 /*	$KAME: altq_subr.c,v 1.24 2005/04/13 03:44:25 suz Exp $	*/
 /*
  * Copyright (C) 1997-2003
  *	Sony Computer Science Laboratories Inc.  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
 @@ -18,34 +18,36 @@
  * 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 SONY CSL 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: altq_subr.c,v 1.33.46.1 2023/11/11 13:16:30 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: altq_subr.c,v 1.33.46.1.2.1 2023/11/15 02:19:00 thorpej Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_altq.h"
 #include "opt_inet.h"
 #include "pf.h"
 #endif
 #define	__IFQ_PRIVATE
 #include <sys/param.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/errno.h>
 #include <sys/syslog.h>
 #include <sys/sysctl.h>
 #include <sys/queue.h>
 @@ -130,156 +132,205 @@ altq_alloc(struct ifqueue *ifq, struct i
+	}
 	if (ifp != NULL) {
 		ifq->ifq_altq->altq_ifp = ifp;
+	}
+}
 /*
  * Free the ifaltq structure associated with an ifqueue.
  */
 void
 altq_free(struct ifqueue *ifq)
+{
 	if (ifq->ifq_altq != NULL) {
 		/*
 		 * No need to pre-flight these calls; both can handle
 		 * the not-enabled / not-attached scenarios.
 		 */
 		altq_disable(ifq->ifq_altq);
 		altq_detach(ifq->ifq_altq);
 		ifq->ifq_altq->altq_ifp = NULL;
 		kmem_free(ifq->ifq_altq, sizeof(*ifq->ifq_altq));
 		ifq->ifq_altq = NULL;
+	}
+}
 /*
  * Mark's a device's send queue as being ready for (as in
  * "knowledgeable about") ALTQ processing.
  */
 void
 altq_set_ready(struct ifqueue *ifq)
+{
 	altq_alloc(ifq, NULL);
-	ifq->ifq_altq->altq_flags = ALTQF_READY;
+	ifq->ifq_altq->altq_flags |= ALTQF_READY;
+}
 /* look up the queue state by the interface name and the queueing type. */
 void *
 altq_lookup(char *name, int type)
+{
 	struct ifnet *ifp;
 	if ((ifp = ifunit(name)) != NULL) {
 		struct ifaltq *altq = ifp->if_snd.ifq_altq;
 		if (type != ALTQT_NONE && altq->altq_type == type)
 			return (altq->altq_disc);
+	}
 	return NULL;
+}
 int
-altq_attach(struct ifaltq *ifq, int type, void *discipline,
+altq_attach(struct ifaltq *altq, int type, void *discipline,
     int (*enqueue)(struct ifaltq *, struct mbuf *),
     struct mbuf *(*dequeue)(struct ifaltq *, int),
     int (*request)(struct ifaltq *, int, void *),
     void *clfier, void *(*classify)(void *, struct mbuf *, int))
+{
-	if (!ALTQ_IS_READY(ifq))
+	struct ifqueue *ifq = altq->altq_ifq;
-		return ENXIO;
+	int error = 0;
 	mutex_enter(ifq->ifq_lock);
 	if (!ALTQ_IS_READY(ifq)) {
 		error = ENXIO;
 		goto out;
+	}
 #ifdef ALTQ3_COMPAT
 	/*
 	 * pfaltq can override the existing discipline, but altq3 cannot.
 	 * check these if clfier is not NULL (which implies altq3).
 	 */
 	if (clfier != NULL) {
-		if (ALTQ_IS_ENABLED(ifq))
+		if (ALTQ_IS_ENABLED(ifq)) {
-			return EBUSY;
+			error = EBUSY;
-		if (ALTQ_IS_ATTACHED(ifq))
+			goto out;
 			return EEXIST;
 		if (ALTQ_IS_ATTACHED(ifq)) {
 			error = EEXIST;
 			goto out;
+		}
+	}
 #endif
-	ifq->altq_type     = type;
+	altq->altq_type     = type;
-	ifq->altq_disc     = discipline;
+	altq->altq_disc     = discipline;
-	ifq->altq_enqueue  = enqueue;
+	altq->altq_enqueue  = enqueue;
-	ifq->altq_dequeue  = dequeue;
+	altq->altq_dequeue  = dequeue;
-	ifq->altq_request  = request;
+	altq->altq_request  = request;
-	ifq->altq_clfier   = clfier;
+	altq->altq_clfier   = clfier;
-	ifq->altq_classify = classify;
+	altq->altq_classify = classify;
-	ifq->altq_flags &= (ALTQF_CANTCHANGE|ALTQF_ENABLED);
+	altq->altq_flags   &= (ALTQF_CANTCHANGE|ALTQF_ENABLED);
 #ifdef ALTQ3_COMPAT
 #ifdef ALTQ_KLD
 	altq_module_incref(type);
 #endif
 #endif
-	return 0;
+ out:
 	mutex_exit(ifq->ifq_lock);
 	return error;
+}
 int
-altq_detach(struct ifaltq *ifq)
+altq_detach(struct ifaltq *altq)
+{
-	if (!ALTQ_IS_READY(ifq))
+	struct ifqueue *ifq = altq->altq_ifq;
-		return ENXIO;
+	int error = 0;
 	if (ALTQ_IS_ENABLED(ifq))
-		return EBUSY;
+	mutex_enter(ifq->ifq_lock);
 	if (!ALTQ_IS_ATTACHED(ifq))
-		return (0);
+	if (!ALTQ_IS_READY(ifq)) {
 		error = ENXIO;
 		goto out;
+	}
 	if (ALTQ_IS_ENABLED(ifq)) {
 		error = EBUSY;
 		goto out;
+	}
 	if (!ALTQ_IS_ATTACHED(ifq)) {
 		goto out;
+	}
 #ifdef ALTQ3_COMPAT
 #ifdef ALTQ_KLD
 	altq_module_declref(ifq->altq_type);
 #endif
 #endif
-	ifq->altq_type     = ALTQT_NONE;
+	altq->altq_type     = ALTQT_NONE;
-	ifq->altq_disc     = NULL;
+	altq->altq_disc     = NULL;
-	ifq->altq_enqueue  = NULL;
+	altq->altq_enqueue  = NULL;
-	ifq->altq_dequeue  = NULL;
+	altq->altq_dequeue  = NULL;
-	ifq->altq_request  = NULL;
+	altq->altq_request  = NULL;
-	ifq->altq_clfier   = NULL;
+	altq->altq_clfier   = NULL;
-	ifq->altq_classify = NULL;
+	altq->altq_classify = NULL;
-	ifq->altq_flags &= ALTQF_CANTCHANGE;
+	altq->altq_flags   &= ALTQF_CANTCHANGE;
-	return 0;
+ out:
 	mutex_exit(ifq->ifq_lock);
 	return error;
+}
 int
-altq_enable(struct ifaltq *ifq)
+altq_enable(struct ifaltq *altq)
+{
-	int s;
+	struct ifqueue *ifq = altq->altq_ifq;
 	struct mbuf *m = NULL;
 	int error = 0;
-	if (!ALTQ_IS_READY(ifq))
+	mutex_enter(ifq->ifq_lock);
 		return ENXIO;
 	if (ALTQ_IS_ENABLED(ifq))
 		return 0;
-	s = splnet();
+	if (!ALTQ_IS_READY(ifq)) {
-	IFQ_PURGE(ifq->altq_ifq);
+		error = ENXIO;
-	ASSERT(ALTQ_GET_LEN(ifq) == 0);
+		goto out;
 	ifq->altq_flags |= ALTQF_ENABLED;
-	if (ifq->altq_clfier != NULL)
+	if (ALTQ_IS_ENABLED(ifq)) {
-		ifq->altq_flags |= ALTQF_CLASSIFY;
+		goto out;
 	splx(s);
-	return 0;
+	m = ifq_purge_locked(ifq);
 	ASSERT(ALTQ_GET_LEN(altq) == 0);
 	altq->altq_flags |= ALTQF_ENABLED;
 	if (altq->altq_clfier != NULL)
 		altq->altq_flags |= ALTQF_CLASSIFY;
  out:
 	mutex_exit(ifq->ifq_lock);
 	if (m != NULL) {
 		ifq_purge_free(m);
+	}
 	return error;
+}
 int
-altq_disable(struct ifaltq *ifq)
+altq_disable(struct ifaltq *altq)
+{
-	int s;
+	struct ifqueue *ifq = altq->altq_ifq;
 	struct mbuf *m = NULL;
-	if (!ALTQ_IS_ENABLED(ifq))
+	mutex_enter(ifq->ifq_lock);
 		return 0;
-	s = splnet();
+	if (!ALTQ_IS_ENABLED(ifq)) {
-	IFQ_PURGE(ifq->altq_ifq);
+		goto out;
 	ASSERT(ALTQ_GET_LEN(ifq) == 0);
 	ifq->altq_flags &= ~(ALTQF_ENABLED|ALTQF_CLASSIFY);
-	splx(s);
+	m = ifq_purge_locked(ifq);
 	ASSERT(ALTQ_GET_LEN(altq) == 0);
 	altq->altq_flags &= ~(ALTQF_ENABLED|ALTQF_CLASSIFY);
  out:
  	mutex_exit(ifq->ifq_lock);
 	if (m != NULL) {
 		ifq_purge_free(m);
+	}
 	return 0;
+}
 #ifdef ALTQ_DEBUG
 void
 altq_assert(const char *file, int line, const char *failedexpr)
+{
 	(void)printf("altq assertion \"%s\" failed: file \"%s\", line %d\n",
 		     failedexpr, file, line);
 	panic("altq assertion");
 	/* NOTREACHED */
+}
 #endif

 @@ -1,14 +1,14 @@
-/*	$NetBSD: if.c,v 1.529.2.1.2.2 2023/11/15 02:08:33 thorpej Exp $	*/
+/*	$NetBSD: if.c,v 1.529.2.1.2.3 2023/11/15 02:19:00 thorpej Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2001, 2008, 2023 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by William Studenmund and Jason R. Thorpe.
+ *
  * 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.
 @@ -80,37 +80,39 @@
  * 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.c	8.5 (Berkeley) 1/9/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if.c,v 1.529.2.1.2.2 2023/11/15 02:08:33 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if.c,v 1.529.2.1.2.3 2023/11/15 02:19:00 thorpej Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_inet.h"
 #include "opt_ipsec.h"
 #include "opt_atalk.h"
 #include "opt_wlan.h"
 #include "opt_net_mpsafe.h"
 #include "opt_mrouting.h"
 #endif
 #define	__IFQ_PRIVATE
 #include <sys/param.h>
 #include <sys/mbuf.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/condvar.h>
 #include <sys/proc.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/domain.h>
 #include <sys/protosw.h>
 #include <sys/kernel.h>
 #include <sys/ioctl.h>
 #include <sys/sysctl.h>
 @@ -1377,30 +1379,26 @@ if_detach(struct ifnet *ifp)
 		kmem_free(isd, sizeof(*isd));
 		ifp->if_slowtimo_data = NULL; /* paraonia */
 		ifp->if_slowtimo = NULL;      /* paranoia */
+	}
 	if_deferred_start_destroy(ifp);
 	/*
 	 * Do an if_down() to give protocols a chance to do something.
 	 */
 	if_down_deactivated(ifp);
 #ifdef ALTQ
 	if (ALTQ_IS_ENABLED(&ifp->if_snd))
 		altq_disable(ifp->if_snd.ifq_altq);
 	if (ALTQ_IS_ATTACHED(&ifp->if_snd))
 		altq_detach(ifp->if_snd.ifq_altq);
 	altq_free(&ifp->if_snd);
 #endif
 #if NCARP > 0
 	/* Remove the interface from any carp group it is a part of.  */
 	if (ifp->if_carp != NULL && ifp->if_type != IFT_CARP)
 		carp_ifdetach(ifp);
 #endif
 	/*
 	 * Ensure that all packets on protocol input pktqueues have been
 	 * processed, or, at least, removed from the queues.
+	 *
 @@ -4332,59 +4330,75 @@ ifq_purge_slow(struct ifqueue * const if
 		ifq->ifq_len = 0;
+	}
 	KERNEL_UNLOCK_ONE(NULL);
 	return m;
+}
 #endif /* ALTQ */
 /*
  * ifq_purge --
+ *
  *	Purge all of the packets from the specified interface queue.
  */
-void
+struct mbuf *
-ifq_purge(struct ifqueue * const ifq)
+ifq_purge_locked(struct ifqueue * const ifq)
+{
-	struct mbuf *m, *nextm;
+	struct mbuf *m;
 	mutex_enter(ifq->ifq_lock);
 #ifdef ALTQ
 	if (__predict_false(ALTQ_IS_ENABLED(ifq)))
 		m = ifq_purge_slow(ifq);
 	else
 #endif /* ALTQ */
+	{
 		m = ifq->ifq_head;
 		ifq->ifq_head = ifq->ifq_tail = NULL;
 		ifq->ifq_len = 0;
+	}
 	if (ifq->ifq_staged != NULL) {
 		ifq->ifq_staged->m_nextpkt = m;
 		m = ifq->ifq_staged;
 		ifq->ifq_staged = NULL;
+	}
-	mutex_exit(ifq->ifq_lock);
+	return m;
+}
 void
 ifq_purge_free(struct mbuf *m)
+{
 	struct mbuf *nextm;
 	for (; m != NULL; m = nextm) {
 		nextm = m->m_nextpkt;
 		m->m_nextpkt = NULL;
 		m_freem(m);
+	}
+}
 void
 ifq_purge(struct ifqueue * const ifq)
+{
 	struct mbuf *m;
 	mutex_enter(ifq->ifq_lock);
 	m = ifq_purge_locked(ifq);
 	mutex_exit(ifq->ifq_lock);
 	ifq_purge_free(m);
+}
 /*
  * ifq_classify_packet --
+ *
  *	Decorate a packet with classificaiton information per the
  *	queue's queueing discipline.
+ *
  *	XXX This should be a private function.  It's unfortunate that
  *	XXX it's called from where it's called.
  */
 void
 ifq_classify_packet(struct ifqueue * const ifq, struct mbuf * const m,
 		    sa_family_t af)
+{

 @@ -1,14 +1,14 @@
-/*	$NetBSD: if.h,v 1.305.2.1.2.2 2023/11/15 02:08:34 thorpej Exp $	*/
+/*	$NetBSD: if.h,v 1.305.2.1.2.3 2023/11/15 02:19:00 thorpej Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2001, 2023 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by William Studenmund and Jason R. Thorpe.
+ *
  * 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.
 @@ -1260,26 +1260,31 @@ void		ifq_set_maxlen(struct ifqueue *, u
 unsigned int	ifq_maxlen(struct ifqueue *);
 uint64_t	ifq_drops(struct ifqueue *);
 struct mbuf *	ifq_get(struct ifqueue *);
 struct mbuf *	ifq_stage(struct ifqueue *);
 int		ifq_put(struct ifqueue *, struct mbuf *);
 void		ifq_restage(struct ifqueue *, struct mbuf *, struct mbuf *);
 void		ifq_commit(struct ifqueue *, struct mbuf *);
 void		ifq_abort(struct ifqueue *, struct mbuf *);
 bool		ifq_continue(struct ifqueue *);
 void		ifq_purge(struct ifqueue *);
 void		ifq_classify_packet(struct ifqueue *, struct mbuf *,
 				    sa_family_t);
 #ifdef __IFQ_PRIVATE
 struct mbuf *	ifq_purge_locked(struct ifqueue *);
 void		ifq_purge_free(struct mbuf *);
 #endif /* __IFQ_PRIVATE */
 int if_tunnel_check_nesting(struct ifnet *, struct mbuf *, int);
 percpu_t *if_tunnel_alloc_ro_percpu(void);
 void if_tunnel_free_ro_percpu(percpu_t *);
 void if_tunnel_ro_percpu_rtcache_free(percpu_t *);
 struct tunnel_ro {
 	struct route *tr_ro;
 	kmutex_t *tr_lock;
 };
 static inline void
 if_tunnel_get_ro(percpu_t *ro_percpu, struct route **ro, kmutex_t **lock)
+{