[apple/xnu.git] / bsd / net / altq / altq_subr.c

/*
 * Copyright (c) 2007-2011 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

/*	$OpenBSD: altq_subr.c,v 1.24 2007/12/11 00:30:14 mikeb Exp $	*/
/*	$KAME: altq_subr.c,v 1.11 2002/01/11 08:11:49 kjc 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
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY SONY CSL 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 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>

#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/errno.h>
#include <sys/syslog.h>
#include <sys/sysctl.h>
#include <sys/queue.h>
#include <sys/mcache.h>

#include <net/if.h>
#include <net/if_var.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/pfvar.h>
#include <net/altq/altq.h>
#include <net/pktsched/pktsched.h>

#include <pexpert/pexpert.h>

SYSCTL_NODE(_net, OID_AUTO, altq, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "ALTQ");

static u_int32_t altq_debug;
SYSCTL_UINT(_net_altq, OID_AUTO, debug, CTLFLAG_RW, &altq_debug, 0,
    "Enable ALTQ debugging");

/*
 * look up the queue state by the interface name and the queueing type;
 * upon success, returns with the interface send queue lock held, and
 * the caller is responsible for releasing it.
 */
void *
altq_lookup(char *name, u_int32_t type)
{
	struct ifnet *ifp;
	void *state = NULL;

	if ((ifp = ifunit(name)) != NULL) {
		IFCQ_LOCK(&ifp->if_snd);
		if (type != ALTQT_NONE &&
		    IFCQ_ALTQ(&ifp->if_snd)->altq_type == type)
			state = IFCQ_ALTQ(&ifp->if_snd)->altq_disc;
		if (state == NULL)
			IFCQ_UNLOCK(&ifp->if_snd);
	}

	if (state != NULL)
		IFCQ_LOCK_ASSERT_HELD(&ifp->if_snd);

	return (state);
}

int
altq_attach(struct ifaltq *altq, u_int32_t type, void *discipline,
    altq_enq_func enqueue, altq_deq_func dequeue,
    altq_deq_sc_func dequeue_sc, altq_req_func request)
{
	IFCQ_LOCK_ASSERT_HELD(altq->altq_ifcq);

	if (!ALTQ_IS_READY(altq))
		return (ENXIO);

	VERIFY(enqueue != NULL);
	VERIFY(!(dequeue != NULL && dequeue_sc != NULL));
	VERIFY(request != NULL);

	altq->altq_type = type;
	altq->altq_disc = discipline;
	altq->altq_enqueue = enqueue;
	altq->altq_dequeue = dequeue;
	altq->altq_dequeue_sc = dequeue_sc;
	altq->altq_request = request;
	altq->altq_flags &= (ALTQF_CANTCHANGE|ALTQF_ENABLED);

	return (0);
}

int
altq_detach(struct ifaltq *altq)
{
	IFCQ_LOCK_ASSERT_HELD(altq->altq_ifcq);

	if (!ALTQ_IS_READY(altq))
		return (ENXIO);
	if (ALTQ_IS_ENABLED(altq))
		return (EBUSY);
	if (!ALTQ_IS_ATTACHED(altq))
		return (0);

	altq->altq_type = ALTQT_NONE;
	altq->altq_disc = NULL;
	altq->altq_enqueue = NULL;
	altq->altq_dequeue = NULL;
	altq->altq_dequeue_sc = NULL;
	altq->altq_request = NULL;
	altq->altq_flags &= ALTQF_CANTCHANGE;

	return (0);
}

int
altq_enable(struct ifaltq *altq)
{
	struct ifclassq *ifq = altq->altq_ifcq;

	IFCQ_LOCK_ASSERT_HELD(ifq);

	if (!ALTQ_IS_READY(altq))
		return (ENXIO);
	if (ALTQ_IS_ENABLED(altq))
		return (0);

	altq->altq_flags |= ALTQF_ENABLED;

	return (0);
}

int
altq_disable(struct ifaltq *altq)
{
	struct ifclassq *ifq = altq->altq_ifcq;

	IFCQ_LOCK_ASSERT_HELD(ifq);

	if (!ALTQ_IS_ENABLED(altq))
		return (0);

	if_qflush(ifq->ifcq_ifp, 1);

	altq->altq_flags &= ~ALTQF_ENABLED;

	return (0);
}

/*
 * add a discipline or a queue
 */
int
altq_add(struct pf_altq *a)
{
	int error = 0;

	VERIFY(machclk_freq != 0);

	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);

	if (a->qname[0] != 0)
		return (altq_add_queue(a));

	switch (a->scheduler) {
#if PKTSCHED_CBQ
	case ALTQT_CBQ:
		error = altq_cbq_add(a);
		break;
#endif /* PKTSCHED_CBQ */
#if PKTSCHED_PRIQ
	case ALTQT_PRIQ:
		error = altq_priq_add(a);
		break;
#endif /* PKTSCHED_PRIQ */
#if PKTSCHED_HFSC
	case ALTQT_HFSC:
		error = altq_hfsc_add(a);
		break;
#endif /* PKTSCHED_HFSC */
#if PKTSCHED_FAIRQ
        case ALTQT_FAIRQ:
                error = altq_fairq_add(a);
                break;
#endif /* PKTSCHED_FAIRQ */
        case ALTQT_QFQ:
                error = altq_qfq_add(a);
                break;
	default:
		error = ENXIO;
	}

	return (error);
}

/*
 * remove a discipline or a queue
 */
int
altq_remove(struct pf_altq *a)
{
	int error = 0;

	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);

	if (a->qname[0] != 0)
		return (altq_remove_queue(a));

	switch (a->scheduler) {
#if PKTSCHED_CBQ
	case ALTQT_CBQ:
		error = altq_cbq_remove(a);
		break;
#endif /* PKTSCHED_CBQ */
#if PKTSCHED_PRIQ
	case ALTQT_PRIQ:
		error = altq_priq_remove(a);
		break;
#endif /* PKTSCHED_PRIQ */
#if PKTSCHED_HFSC
	case ALTQT_HFSC:
		error = altq_hfsc_remove(a);
		break;
#endif /* PKTSCHED_HFSC */
#if PKTSCHED_FAIRQ
        case ALTQT_FAIRQ:
                error = altq_fairq_remove(a);
                break;
#endif /* PKTSCHED_FAIRQ */
        case ALTQT_QFQ:
                error = altq_qfq_remove(a);
                break;
	default:
		error = ENXIO;
	}

	return (error);
}

/*
 * add a queue to the discipline
 */
int
altq_add_queue(struct pf_altq *a)
{
	int error = 0;

	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);

	switch (a->scheduler) {
#if PKTSCHED_CBQ
	case ALTQT_CBQ:
		error = altq_cbq_add_queue(a);
		break;
#endif /* PKTSCHED_CBQ */
#if PKTSCHED_PRIQ
	case ALTQT_PRIQ:
		error = altq_priq_add_queue(a);
		break;
#endif /* PKTSCHED_PRIQ */
#if PKTSCHED_HFSC
	case ALTQT_HFSC:
		error = altq_hfsc_add_queue(a);
		break;
#endif /* PKTSCHED_HFSC */
#if PKTSCHED_FAIRQ
        case ALTQT_FAIRQ:
                error = altq_fairq_add_queue(a);
                break;
#endif /* PKTSCHED_FAIRQ */
        case ALTQT_QFQ:
                error = altq_qfq_add_queue(a);
                break;
	default:
		error = ENXIO;
	}

	return (error);
}

/*
 * remove a queue from the discipline
 */
int
altq_remove_queue(struct pf_altq *a)
{
	int error = 0;

	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);

	switch (a->scheduler) {
#if PKTSCHED_CBQ
	case ALTQT_CBQ:
		error = altq_cbq_remove_queue(a);
		break;
#endif /* PKTSCHED_CBQ */
#if PKTSCHED_PRIQ
	case ALTQT_PRIQ:
		error = altq_priq_remove_queue(a);
		break;
#endif /* PKTSCHED_PRIQ */
#if PKTSCHED_HFSC
	case ALTQT_HFSC:
		error = altq_hfsc_remove_queue(a);
		break;
#endif /* PKTSCHED_HFSC */
#if PKTSCHED_FAIRQ
        case ALTQT_FAIRQ:
                error = altq_fairq_remove_queue(a);
                break;
#endif /* PKTSCHED_FAIRQ */
        case ALTQT_QFQ:
                error = altq_qfq_remove_queue(a);
                break;
	default:
		error = ENXIO;
	}

	return (error);
}

/*
 * get queue statistics
 */
int
altq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes)
{
	int error = 0;

	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);

	switch (a->scheduler) {
#if PKTSCHED_CBQ
	case ALTQT_CBQ:
		error = altq_cbq_getqstats(a, ubuf, nbytes);
		break;
#endif /* PKTSCHED_CBQ */
#if PKTSCHED_PRIQ
	case ALTQT_PRIQ:
		error = altq_priq_getqstats(a, ubuf, nbytes);
		break;
#endif /* PKTSCHED_PRIQ */
#if PKTSCHED_HFSC
	case ALTQT_HFSC:
		error = altq_hfsc_getqstats(a, ubuf, nbytes);
		break;
#endif /* PKTSCHED_HFSC */
#if PKTSCHED_FAIRQ
        case ALTQT_FAIRQ:
                error = altq_fairq_getqstats(a, ubuf, nbytes);
                break;
#endif /* PKTSCHED_FAIRQ */
        case ALTQT_QFQ:
                error = altq_qfq_getqstats(a, ubuf, nbytes);
                break;
	default:
		error = ENXIO;
	}

	return (error);
}

/*
 * attach a discipline to the interface.  if one already exists, it is
 * overridden.
 */
int
altq_pfattach(struct pf_altq *a)
{
	int error = 0;

	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);

	switch (a->scheduler) {
	case ALTQT_NONE:
		break;
#if PKTSCHED_CBQ
	case ALTQT_CBQ:
		error = altq_cbq_pfattach(a);
		break;
#endif /* PKTSCHED_CBQ */
#if PKTSCHED_PRIQ
	case ALTQT_PRIQ:
		error = altq_priq_pfattach(a);
		break;
#endif /* PKTSCHED_PRIQ */
#if PKTSCHED_HFSC
	case ALTQT_HFSC:
		error = altq_hfsc_pfattach(a);
		break;
#endif /* PKTSCHED_HFSC */
#if PKTSCHED_FAIRQ
	case ALTQT_FAIRQ:
		error = altq_fairq_pfattach(a);
		break;
#endif /* PKTSCHED_FAIRQ */
	case ALTQT_QFQ:
		error = altq_qfq_pfattach(a);
		break;
	default:
		error = ENXIO;
	}

	return (error);
}

/*
 * detach a discipline from the interface.
 * it is possible that the discipline was already overridden by another
 * discipline.
 */
int
altq_pfdetach(struct pf_altq *a)
{
	struct ifnet *ifp;
	int error = 0;

	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);

	if ((ifp = ifunit(a->ifname)) == NULL)
		return (EINVAL);

	/* if this discipline is no longer referenced, just return */
	IFCQ_LOCK(&ifp->if_snd);
	if (a->altq_disc == NULL ||
	    a->altq_disc != IFCQ_ALTQ(&ifp->if_snd)->altq_disc) {
		IFCQ_UNLOCK(&ifp->if_snd);
		return (0);
	}

	if (ALTQ_IS_ENABLED(IFCQ_ALTQ(&ifp->if_snd)))
		error = altq_disable(IFCQ_ALTQ(&ifp->if_snd));
	if (error == 0)
		error = altq_detach(IFCQ_ALTQ(&ifp->if_snd));
	IFCQ_UNLOCK(&ifp->if_snd);
	return (error);
}
Commit	Line	Data
316670eb A	1	/*
	2	* Copyright (c) 2007-2011 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
	29	/* $OpenBSD: altq_subr.c,v 1.24 2007/12/11 00:30:14 mikeb Exp $ */
	30	/* $KAME: altq_subr.c,v 1.11 2002/01/11 08:11:49 kjc Exp $ */
	31
	32	/*
	33	* Copyright (C) 1997-2003
	34	* Sony Computer Science Laboratories Inc. All rights reserved.
	35	*
	36	* Redistribution and use in source and binary forms, with or without
	37	* modification, are permitted provided that the following conditions
	38	* are met:
	39	* 1. Redistributions of source code must retain the above copyright
	40	* notice, this list of conditions and the following disclaimer.
	41	* 2. Redistributions in binary form must reproduce the above copyright
	42	* notice, this list of conditions and the following disclaimer in the
	43	* documentation and/or other materials provided with the distribution.
	44	*
	45	* THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
	46	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	47	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	48	* ARE DISCLAIMED. IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE
	49	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	50	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	51	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	52	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	53	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	54	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	55	* SUCH DAMAGE.
	56	*/
	57
	58	#include <sys/cdefs.h>
	59
	60	#include <sys/param.h>
	61	#include <sys/malloc.h>
	62	#include <sys/mbuf.h>
	63	#include <sys/systm.h>
	64	#include <sys/proc.h>
65	#include <sys/socket.h>
66	#include <sys/socketvar.h>
67	#include <sys/kernel.h>
68	#include <sys/errno.h>
69	#include <sys/syslog.h>
70	#include <sys/sysctl.h>
71	#include <sys/queue.h>
72	#include <sys/mcache.h>
73
74	#include <net/if.h>
75	#include <net/if_var.h>
76	#include <net/if_dl.h>
77	#include <net/if_types.h>
78	#include <net/pfvar.h>
79	#include <net/altq/altq.h>
80	#include <net/pktsched/pktsched.h>
81
82	#include <pexpert/pexpert.h>
83
84	SYSCTL_NODE(_net, OID_AUTO, altq, CTLFLAG_RW\|CTLFLAG_LOCKED, 0, "ALTQ");
85
86	static u_int32_t altq_debug;
87	SYSCTL_UINT(_net_altq, OID_AUTO, debug, CTLFLAG_RW, &altq_debug, 0,
88	"Enable ALTQ debugging");
89
90	/*
91	* look up the queue state by the interface name and the queueing type;
92	* upon success, returns with the interface send queue lock held, and
93	* the caller is responsible for releasing it.
94	*/
95	void *
96	altq_lookup(char *name, u_int32_t type)
97	{
98	struct ifnet *ifp;
99	void *state = NULL;
100
101	if ((ifp = ifunit(name)) != NULL) {
102	IFCQ_LOCK(&ifp->if_snd);
103	if (type != ALTQT_NONE &&
104	IFCQ_ALTQ(&ifp->if_snd)->altq_type == type)
105	state = IFCQ_ALTQ(&ifp->if_snd)->altq_disc;
106	if (state == NULL)
107	IFCQ_UNLOCK(&ifp->if_snd);
108	}
109
110	if (state != NULL)
111	IFCQ_LOCK_ASSERT_HELD(&ifp->if_snd);
112
113	return (state);
114	}
115
116	int
117	altq_attach(struct ifaltq altq, u_int32_t type, void discipline,
118	altq_enq_func enqueue, altq_deq_func dequeue,
119	altq_deq_sc_func dequeue_sc, altq_req_func request)
120	{
121	IFCQ_LOCK_ASSERT_HELD(altq->altq_ifcq);
122
123	if (!ALTQ_IS_READY(altq))
124	return (ENXIO);
125
126	VERIFY(enqueue != NULL);
127	VERIFY(!(dequeue != NULL && dequeue_sc != NULL));
128	VERIFY(request != NULL);
129
130	altq->altq_type = type;
131	altq->altq_disc = discipline;
132	altq->altq_enqueue = enqueue;
133	altq->altq_dequeue = dequeue;
134	altq->altq_dequeue_sc = dequeue_sc;
135	altq->altq_request = request;
136	altq->altq_flags &= (ALTQF_CANTCHANGE\|ALTQF_ENABLED);
137
138	return (0);
139	}
140
141	int
142	altq_detach(struct ifaltq *altq)
143	{
144	IFCQ_LOCK_ASSERT_HELD(altq->altq_ifcq);
145
146	if (!ALTQ_IS_READY(altq))
147	return (ENXIO);
148	if (ALTQ_IS_ENABLED(altq))
149	return (EBUSY);
150	if (!ALTQ_IS_ATTACHED(altq))
151	return (0);
152
153	altq->altq_type = ALTQT_NONE;
154	altq->altq_disc = NULL;
155	altq->altq_enqueue = NULL;
156	altq->altq_dequeue = NULL;
157	altq->altq_dequeue_sc = NULL;
158	altq->altq_request = NULL;
159	altq->altq_flags &= ALTQF_CANTCHANGE;
160
161	return (0);
162	}
163
164	int
165	altq_enable(struct ifaltq *altq)
166	{
167	struct ifclassq *ifq = altq->altq_ifcq;
168
169	IFCQ_LOCK_ASSERT_HELD(ifq);
170
171	if (!ALTQ_IS_READY(altq))
172	return (ENXIO);
173	if (ALTQ_IS_ENABLED(altq))
174	return (0);
175
176	altq->altq_flags \|= ALTQF_ENABLED;
177
178	return (0);
179	}
180
181	int
182	altq_disable(struct ifaltq *altq)
183	{
184	struct ifclassq *ifq = altq->altq_ifcq;
185
186	IFCQ_LOCK_ASSERT_HELD(ifq);
187
188	if (!ALTQ_IS_ENABLED(altq))
189	return (0);
190
191	if_qflush(ifq->ifcq_ifp, 1);
192
193	altq->altq_flags &= ~ALTQF_ENABLED;
194
195	return (0);
196	}
197
198	/*
199	* add a discipline or a queue
200	*/
201	int
202	altq_add(struct pf_altq *a)
203	{
204	int error = 0;
205
206	VERIFY(machclk_freq != 0);
207
208	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);
209
210	if (a->qname[0] != 0)
211	return (altq_add_queue(a));
212
213	switch (a->scheduler) {
214	#if PKTSCHED_CBQ
215	case ALTQT_CBQ:
216	error = altq_cbq_add(a);
217	break;
218	#endif /* PKTSCHED_CBQ */
219	#if PKTSCHED_PRIQ
220	case ALTQT_PRIQ:
221	error = altq_priq_add(a);
222	break;
223	#endif /* PKTSCHED_PRIQ */
224	#if PKTSCHED_HFSC
225	case ALTQT_HFSC:
226	error = altq_hfsc_add(a);
227	break;
228	#endif /* PKTSCHED_HFSC */
229	#if PKTSCHED_FAIRQ
230	case ALTQT_FAIRQ:
231	error = altq_fairq_add(a);
232	break;
233	#endif /* PKTSCHED_FAIRQ */
234	case ALTQT_QFQ:
235	error = altq_qfq_add(a);
236	break;
237	default:
238	error = ENXIO;
239	}
240
241	return (error);
242	}
243
244	/*
245	* remove a discipline or a queue
246	*/
247	int
248	altq_remove(struct pf_altq *a)
249	{
250	int error = 0;
251
252	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);
253
254	if (a->qname[0] != 0)
255	return (altq_remove_queue(a));
256
257	switch (a->scheduler) {
258	#if PKTSCHED_CBQ
259	case ALTQT_CBQ:
260	error = altq_cbq_remove(a);
261	break;
262	#endif /* PKTSCHED_CBQ */
263	#if PKTSCHED_PRIQ
264	case ALTQT_PRIQ:
265	error = altq_priq_remove(a);
266	break;
267	#endif /* PKTSCHED_PRIQ */
268	#if PKTSCHED_HFSC
269	case ALTQT_HFSC:
270	error = altq_hfsc_remove(a);
271	break;
272	#endif /* PKTSCHED_HFSC */
273	#if PKTSCHED_FAIRQ
274	case ALTQT_FAIRQ:
275	error = altq_fairq_remove(a);
276	break;
277	#endif /* PKTSCHED_FAIRQ */
278	case ALTQT_QFQ:
279	error = altq_qfq_remove(a);
280	break;
281	default:
282	error = ENXIO;
283	}
284
285	return (error);
286	}
287
288	/*
289	* add a queue to the discipline
290	*/
291	int
292	altq_add_queue(struct pf_altq *a)
293	{
294	int error = 0;
295
296	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);
297
298	switch (a->scheduler) {
299	#if PKTSCHED_CBQ
300	case ALTQT_CBQ:
301	error = altq_cbq_add_queue(a);
302	break;
303	#endif /* PKTSCHED_CBQ */
304	#if PKTSCHED_PRIQ
305	case ALTQT_PRIQ:
306	error = altq_priq_add_queue(a);
307	break;
308	#endif /* PKTSCHED_PRIQ */
309	#if PKTSCHED_HFSC
310	case ALTQT_HFSC:
311	error = altq_hfsc_add_queue(a);
312	break;
313	#endif /* PKTSCHED_HFSC */
314	#if PKTSCHED_FAIRQ
315	case ALTQT_FAIRQ:
316	error = altq_fairq_add_queue(a);
317	break;
318	#endif /* PKTSCHED_FAIRQ */
319	case ALTQT_QFQ:
320	error = altq_qfq_add_queue(a);
321	break;
322	default:
323	error = ENXIO;
324	}
325
326	return (error);
327	}
328
329	/*
330	* remove a queue from the discipline
331	*/
332	int
333	altq_remove_queue(struct pf_altq *a)
334	{
335	int error = 0;
336
337	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);
338
339	switch (a->scheduler) {
340	#if PKTSCHED_CBQ
341	case ALTQT_CBQ:
342	error = altq_cbq_remove_queue(a);
343	break;
344	#endif /* PKTSCHED_CBQ */
345	#if PKTSCHED_PRIQ
346	case ALTQT_PRIQ:
347	error = altq_priq_remove_queue(a);
348	break;
349	#endif /* PKTSCHED_PRIQ */
350	#if PKTSCHED_HFSC
351	case ALTQT_HFSC:
352	error = altq_hfsc_remove_queue(a);
353	break;
354	#endif /* PKTSCHED_HFSC */
355	#if PKTSCHED_FAIRQ
356	case ALTQT_FAIRQ:
357	error = altq_fairq_remove_queue(a);
358	break;
359	#endif /* PKTSCHED_FAIRQ */
360	case ALTQT_QFQ:
361	error = altq_qfq_remove_queue(a);
362	break;
363	default:
364	error = ENXIO;
365	}
366
367	return (error);
368	}
369
370	/*
371	* get queue statistics
372	*/
373	int
374	altq_getqstats(struct pf_altq a, void ubuf, int *nbytes)
375	{
376	int error = 0;
377
378	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);
379
380	switch (a->scheduler) {
381	#if PKTSCHED_CBQ
382	case ALTQT_CBQ:
383	error = altq_cbq_getqstats(a, ubuf, nbytes);
384	break;
385	#endif /* PKTSCHED_CBQ */
386	#if PKTSCHED_PRIQ
387	case ALTQT_PRIQ:
388	error = altq_priq_getqstats(a, ubuf, nbytes);
389	break;
390	#endif /* PKTSCHED_PRIQ */
391	#if PKTSCHED_HFSC
392	case ALTQT_HFSC:
393	error = altq_hfsc_getqstats(a, ubuf, nbytes);
394	break;
395	#endif /* PKTSCHED_HFSC */
396	#if PKTSCHED_FAIRQ
397	case ALTQT_FAIRQ:
398	error = altq_fairq_getqstats(a, ubuf, nbytes);
399	break;
400	#endif /* PKTSCHED_FAIRQ */
401	case ALTQT_QFQ:
402	error = altq_qfq_getqstats(a, ubuf, nbytes);
403	break;
404	default:
405	error = ENXIO;
406	}
407
408	return (error);
409	}
410
411	/*
412	* attach a discipline to the interface. if one already exists, it is
413	* overridden.
414	*/
415	int
416	altq_pfattach(struct pf_altq *a)
417	{
418	int error = 0;
419
420	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);
421
422	switch (a->scheduler) {
423	case ALTQT_NONE:
424	break;
425	#if PKTSCHED_CBQ
426	case ALTQT_CBQ:
427	error = altq_cbq_pfattach(a);
428	break;
429	#endif /* PKTSCHED_CBQ */
430	#if PKTSCHED_PRIQ
431	case ALTQT_PRIQ:
432	error = altq_priq_pfattach(a);
433	break;
434	#endif /* PKTSCHED_PRIQ */
435	#if PKTSCHED_HFSC
436	case ALTQT_HFSC:
437	error = altq_hfsc_pfattach(a);
438	break;
439	#endif /* PKTSCHED_HFSC */
440	#if PKTSCHED_FAIRQ
441	case ALTQT_FAIRQ:
442	error = altq_fairq_pfattach(a);
443	break;
444	#endif /* PKTSCHED_FAIRQ */
445	case ALTQT_QFQ:
446	error = altq_qfq_pfattach(a);
447	break;
448	default:
449	error = ENXIO;
450	}
451
452	return (error);
453	}
454
455	/*
456	* detach a discipline from the interface.
457	* it is possible that the discipline was already overridden by another
458	* discipline.
459	*/
460	int
461	altq_pfdetach(struct pf_altq *a)
462	{
463	struct ifnet *ifp;
464	int error = 0;
465
466	lck_mtx_assert(pf_lock, LCK_MTX_ASSERT_OWNED);
467
468	if ((ifp = ifunit(a->ifname)) == NULL)
469	return (EINVAL);
470
471	/* if this discipline is no longer referenced, just return */
472	IFCQ_LOCK(&ifp->if_snd);
473	if (a->altq_disc == NULL \|\|
474	a->altq_disc != IFCQ_ALTQ(&ifp->if_snd)->altq_disc) {
475	IFCQ_UNLOCK(&ifp->if_snd);
476	return (0);
477	}
478
479	if (ALTQ_IS_ENABLED(IFCQ_ALTQ(&ifp->if_snd)))
480	error = altq_disable(IFCQ_ALTQ(&ifp->if_snd));
481	if (error == 0)
482	error = altq_detach(IFCQ_ALTQ(&ifp->if_snd));
483	IFCQ_UNLOCK(&ifp->if_snd);
484	return (error);
485	}
486
487