xref: /netbsd/sys/altq/altq_wfq.c (revision bf9ec67e) 
1 /*	$NetBSD: altq_wfq.c,v 1.5 2001/11/15 06:37:15 lukem Exp $	*/
2 /*	$KAME: altq_wfq.c,v 1.7 2000/12/14 08:12:46 thorpej Exp $	*/
3 
4 /*
5  * Copyright (C) 1997-2000
6  *	Sony Computer Science Laboratories Inc.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 /*
30  *  March 27, 1997.  Written by Hiroshi Kyusojin of Keio University
31  *  (kyu@mt.cs.keio.ac.jp).
32  */
33 
34 #include <sys/cdefs.h>
35 __KERNEL_RCSID(0, "$NetBSD: altq_wfq.c,v 1.5 2001/11/15 06:37:15 lukem Exp $");
36 
37 #if defined(__FreeBSD__) || defined(__NetBSD__)
38 #include "opt_altq.h"
39 #if (__FreeBSD__ != 2)
40 #include "opt_inet.h"
41 #ifdef __FreeBSD__
42 #include "opt_inet6.h"
43 #endif
44 #endif
45 #endif /* __FreeBSD__ || __NetBSD__ */
46 #ifdef ALTQ_WFQ
47 
48 #include <sys/param.h>
49 #include <sys/malloc.h>
50 #include <sys/mbuf.h>
51 #include <sys/uio.h>
52 #include <sys/socket.h>
53 #include <sys/systm.h>
54 #include <sys/proc.h>
55 #include <sys/errno.h>
56 #include <sys/time.h>
57 #include <sys/kernel.h>
58 
59 #include <net/if.h>
60 #include <net/if_types.h>
61 #include <netinet/in.h>
62 
63 #include <altq/altq.h>
64 #include <altq/altq_conf.h>
65 #include <altq/altq_wfq.h>
66 
67 /*
68 #define	WFQ_DEBUG
69 */
70 
71 static int		wfq_setenable(struct wfq_interface *, int);
72 static int		wfq_ifattach(struct wfq_interface *);
73 static int		wfq_ifdetach(struct wfq_interface *);
74 static int		wfq_ifenqueue(struct ifaltq *, struct mbuf *,
75 				      struct altq_pktattr *);
76 static u_long		wfq_hash(struct flowinfo *, int);
77 static __inline u_long	wfq_hashbydstaddr(struct flowinfo *, int);
78 static __inline u_long	wfq_hashbysrcport(struct flowinfo *, int);
79 static wfq		*wfq_maxqueue(wfq_state_t *);
80 static struct mbuf	*wfq_ifdequeue(struct ifaltq *, int);
81 static int		wfq_getqid(struct wfq_getqid *);
82 static int		wfq_setweight(struct wfq_setweight *);
83 static int		wfq_getstats(struct wfq_getstats *);
84 static int		wfq_config(struct wfq_conf *);
85 static int		wfq_request __P((struct ifaltq *, int, void *));
86 static int		wfq_flush(struct ifaltq *);
87 static void		*wfq_classify(void *, struct mbuf *, int);
88 
89 /* global value : pointer to wfq queue list */
90 static wfq_state_t *wfq_list = NULL;
91 
92 static int
93 wfq_setenable(ifacep, flag)
94 	struct wfq_interface *ifacep;
95 	int flag;
96 {
97 	wfq_state_t *wfqp;
98 	int error = 0;
99 
100 	if ((wfqp = altq_lookup(ifacep->wfq_ifacename, ALTQT_WFQ)) == NULL)
101 		return (EBADF);
102 
103 	switch(flag){
104 	case ENABLE:
105 		error = altq_enable(wfqp->ifq);
106 		break;
107 	case DISABLE:
108 		error = altq_disable(wfqp->ifq);
109 		break;
110 	}
111 	return error;
112 }
113 
114 
115 static int
116 wfq_ifattach(ifacep)
117 	struct wfq_interface *ifacep;
118 {
119 	int error = 0, i;
120 	struct ifnet *ifp;
121 	wfq_state_t *new_wfqp;
122 	wfq *queue;
123 
124 	if ((ifp = ifunit(ifacep->wfq_ifacename)) == NULL) {
125 #ifdef WFQ_DEBUG
126 		printf("wfq_ifattach()...no ifp found\n");
127 #endif
128 		return (ENXIO);
129 	}
130 
131 	if (!ALTQ_IS_READY(&ifp->if_snd)) {
132 #ifdef WFQ_DEBUG
133 		printf("wfq_ifattach()...altq is not ready\n");
134 #endif
135 		return (ENXIO);
136 	}
137 
138 	/* allocate and initialize wfq_state_t */
139 	MALLOC(new_wfqp, wfq_state_t *, sizeof(wfq_state_t),
140 	       M_DEVBUF, M_WAITOK);
141 	if (new_wfqp == NULL)
142 		return (ENOMEM);
143 	bzero(new_wfqp, sizeof(wfq_state_t));
144 	MALLOC(queue, wfq *, sizeof(wfq) * DEFAULT_QSIZE,
145 	       M_DEVBUF, M_WAITOK);
146 	if (queue == NULL) {
147 		FREE(new_wfqp, M_DEVBUF);
148 		return (ENOMEM);
149 	}
150 	bzero(queue, sizeof(wfq) * DEFAULT_QSIZE);
151 
152 	/* keep the ifq */
153 	new_wfqp->ifq = &ifp->if_snd;
154 	new_wfqp->nums = DEFAULT_QSIZE;
155 	new_wfqp->hwm = HWM;
156 	new_wfqp->bytes = 0;
157 	new_wfqp->rrp = NULL;
158 	new_wfqp->queue = queue;
159 	new_wfqp->hash_func = wfq_hashbydstaddr;
160 	new_wfqp->fbmask = FIMB4_DADDR;
161 
162 	for (i = 0; i < new_wfqp->nums; i++, queue++) {
163 		queue->next = queue->prev = NULL;
164 		queue->head = queue->tail = NULL;
165 		queue->bytes = queue->quota = 0;
166 		queue->weight = 100;
167 	}
168 
169 	/*
170 	 * set WFQ to this ifnet structure.
171 	 */
172 	if ((error = altq_attach(&ifp->if_snd, ALTQT_WFQ, new_wfqp,
173 				 wfq_ifenqueue, wfq_ifdequeue, wfq_request,
174 				 new_wfqp, wfq_classify)) != 0) {
175 		FREE(queue, M_DEVBUF);
176 		FREE(new_wfqp, M_DEVBUF);
177 		return (error);
178 	}
179 
180 	new_wfqp->next = wfq_list;
181 	wfq_list = new_wfqp;
182 
183 	return (error);
184 }
185 
186 
187 static int
188 wfq_ifdetach(ifacep)
189 	struct wfq_interface *ifacep;
190 {
191 	int		error = 0;
192 	wfq_state_t	*wfqp;
193 
194 	if ((wfqp = altq_lookup(ifacep->wfq_ifacename, ALTQT_WFQ)) == NULL)
195 		return (EBADF);
196 
197 	/* free queued mbuf */
198 	wfq_flush(wfqp->ifq);
199 
200 	/* remove WFQ from the ifnet structure. */
201 	(void)altq_disable(wfqp->ifq);
202 	(void)altq_detach(wfqp->ifq);
203 
204 	/* remove from the wfqstate list */
205 	if (wfq_list == wfqp)
206 		wfq_list = wfqp->next;
207 	else {
208 		wfq_state_t *wp = wfq_list;
209 		do {
210 			if (wp->next == wfqp) {
211 				wp->next = wfqp->next;
212 				break;
213 			}
214 		} while ((wp = wp->next) != NULL);
215 	}
216 
217 	/* deallocate wfq_state_t */
218 	FREE(wfqp->queue, M_DEVBUF);
219 	FREE(wfqp, M_DEVBUF);
220 	return (error);
221 }
222 
223 static int
224 wfq_request(ifq, req, arg)
225 	struct ifaltq *ifq;
226 	int req;
227 	void *arg;
228 {
229 	wfq_state_t *wfqp = (wfq_state_t *)ifq->altq_disc;
230 
231 	switch (req) {
232 	case ALTRQ_PURGE:
233 		wfq_flush(wfqp->ifq);
234 		break;
235 	}
236 	return (0);
237 }
238 
239 
240 static int
241 wfq_flush(ifq)
242 	struct ifaltq *ifq;
243 {
244 	struct mbuf *mp;
245 
246 	while ((mp = wfq_ifdequeue(ifq, ALTDQ_REMOVE)) != NULL)
247 		m_freem(mp);
248 	if (ALTQ_IS_ENABLED(ifq))
249 		ifq->ifq_len = 0;
250 	return 0;
251 }
252 
253 static void *
254 wfq_classify(clfier, m, af)
255 	void *clfier;
256 	struct mbuf *m;
257 	int af;
258 {
259 	wfq_state_t *wfqp = (wfq_state_t *)clfier;
260 	struct flowinfo flow;
261 
262 	altq_extractflow(m, af, &flow, wfqp->fbmask);
263 	return (&wfqp->queue[(*wfqp->hash_func)(&flow, wfqp->nums)]);
264 }
265 
266 static int
267 wfq_ifenqueue(ifq, mp, pktattr)
268 	struct ifaltq *ifq;
269 	struct mbuf *mp;
270 	struct altq_pktattr *pktattr;
271 {
272 	wfq_state_t *wfqp;
273 	wfq *queue;
274 	int byte, error = 0;
275 
276 	wfqp = (wfq_state_t *)ifq->altq_disc;
277 	mp->m_nextpkt = NULL;
278 
279 	/* grab a queue selected by classifier */
280 	if (pktattr == NULL || (queue = pktattr->pattr_class) == NULL)
281 		queue = &wfqp->queue[0];
282 
283 	if (queue->tail == NULL)
284 		queue->head = mp;
285 	else
286 		queue->tail->m_nextpkt = mp;
287 	queue->tail = mp;
288 	byte = mp->m_pkthdr.len;
289 	queue->bytes += byte;
290 	wfqp->bytes += byte;
291 	ifq->ifq_len++;
292 
293 	if (queue->next == NULL) {
294 		/* this queue gets active. add the queue to the active list */
295 		if (wfqp->rrp == NULL){
296 			/* no queue in the active list */
297 			queue->next = queue->prev = queue;
298 			wfqp->rrp = queue;
299 			WFQ_ADDQUOTA(queue);
300 		} else {
301 			/* insert the queue at the tail of the active list */
302 			queue->prev = wfqp->rrp->prev;
303 			wfqp->rrp->prev->next = queue;
304 			wfqp->rrp->prev = queue;
305 			queue->next = wfqp->rrp;
306 			queue->quota = 0;
307 		}
308 	}
309 
310 	/* check overflow. if the total size exceeds the high water mark,
311 	   drop packets from the longest queue. */
312 	while (wfqp->bytes > wfqp->hwm) {
313 		wfq *drop_queue = wfq_maxqueue(wfqp);
314 
315 		/* drop the packet at the head. */
316 		mp = drop_queue->head;
317 		if ((drop_queue->head = mp->m_nextpkt) == NULL)
318 			drop_queue->tail = NULL;
319 		mp->m_nextpkt = NULL;
320 		byte = mp->m_pkthdr.len;
321 		drop_queue->bytes -= byte;
322 		PKTCNTR_ADD(&drop_queue->drop_cnt, byte);
323 		wfqp->bytes -= byte;
324 		m_freem(mp);
325 		ifq->ifq_len--;
326 		if(drop_queue == queue)
327 			/* the queue for this flow is selected to drop */
328 			error = ENOBUFS;
329 	}
330 	return error;
331 }
332 
333 
334 static u_long wfq_hash(flow, n)
335 	struct flowinfo *flow;
336 	int n;
337 {
338 	u_long val = 0;
339 
340 	if (flow != NULL) {
341 		if (flow->fi_family == AF_INET) {
342 			struct flowinfo_in *fp = (struct flowinfo_in *)flow;
343 			u_long val2;
344 
345 			val = fp->fi_dst.s_addr ^ fp->fi_src.s_addr;
346 			val = val ^ (val >> 8) ^ (val >> 16) ^ (val >> 24);
347 			val2 = fp->fi_dport ^ fp->fi_sport ^ fp->fi_proto;
348 			val2 = val2 ^ (val2 >> 8);
349 			val = val ^ val2;
350 		}
351 #ifdef INET6
352 		else if (flow->fi_family == AF_INET6) {
353 			struct flowinfo_in6 *fp6 = (struct flowinfo_in6 *)flow;
354 
355 			val = ntohl(fp6->fi6_flowlabel);
356 		}
357 #endif
358 	}
359 
360 	return (val % n);
361 }
362 
363 
364 static __inline u_long wfq_hashbydstaddr(flow, n)
365 	struct flowinfo *flow;
366 	int n;
367 {
368 	u_long val = 0;
369 
370 	if (flow != NULL) {
371 		if (flow->fi_family == AF_INET) {
372 			struct flowinfo_in *fp = (struct flowinfo_in *)flow;
373 
374 			val = fp->fi_dst.s_addr;
375 			val = val ^ (val >> 8) ^ (val >> 16) ^ (val >> 24);
376 		}
377 #ifdef INET6
378 		else if (flow->fi_family == AF_INET6) {
379 			struct flowinfo_in6 *fp6 = (struct flowinfo_in6 *)flow;
380 
381 			val = ntohl(fp6->fi6_flowlabel);
382 		}
383 #endif
384 	}
385 
386 	return (val % n);
387 }
388 
389 static __inline u_long wfq_hashbysrcport(flow, n)
390 	struct flowinfo *flow;
391 	int n;
392 {
393 	u_long val = 0;
394 
395 	if (flow != NULL) {
396 		if (flow->fi_family == AF_INET) {
397 			struct flowinfo_in *fp = (struct flowinfo_in *)flow;
398 
399 			val = fp->fi_sport;
400 		}
401 #ifdef INET6
402 		else if (flow->fi_family == AF_INET6) {
403 			struct flowinfo_in6 *fp6 = (struct flowinfo_in6 *)flow;
404 
405 			val = fp6->fi6_sport;
406 		}
407 #endif
408 	}
409 	val = val ^ (val >> 8);
410 
411 	return (val % n);
412 }
413 
414 static wfq *wfq_maxqueue(wfqp)
415 	wfq_state_t *wfqp;
416 {
417 	int byte, max_byte = 0;
418 	wfq *queue, *max_queue = NULL;
419 
420 	if((queue = wfqp->rrp) == NULL)
421 		/* never happens */
422 		return NULL;
423 	do{
424 		if ((byte = queue->bytes * 100 / queue->weight) > max_byte) {
425 			max_queue = queue;
426 			max_byte = byte;
427 		}
428 	} while ((queue = queue->next) != wfqp->rrp);
429 
430 	return max_queue;
431 }
432 
433 
434 static struct mbuf *
435 wfq_ifdequeue(ifq, op)
436 	struct ifaltq *ifq;
437 	int op;
438 {
439 	wfq_state_t *wfqp;
440 	wfq *queue;
441 	struct mbuf *mp;
442 	int byte;
443 
444 	wfqp = (wfq_state_t *)ifq->altq_disc;
445 
446 	if ((wfqp->bytes == 0) || ((queue = wfqp->rrp) == NULL))
447 		/* no packet in the queues */
448 		return NULL;
449 
450 	while (1) {
451 		if (queue->quota > 0) {
452 			if (queue->bytes <= 0) {
453 				/* this queue no longer has packet.
454 				   remove the queue from the active list. */
455 				if (queue->next == queue){
456 					/* no other active queue
457 					   -- this case never happens in
458 					   this algorithm. */
459 					queue->next = queue->prev = NULL;
460 					wfqp->rrp = NULL;
461 					return NULL;
462 				} else {
463 					queue->prev->next = queue->next;
464 					queue->next->prev = queue->prev;
465 					/* the round-robin pointer points
466 					   to this queue, advance the rrp */
467 					wfqp->rrp = queue->next;
468 					queue->next = queue->prev = NULL;
469 					queue = wfqp->rrp;
470 					WFQ_ADDQUOTA(queue);
471 					continue;
472 				}
473 			}
474 
475 			/* dequeue a packet from this queue */
476 			mp = queue->head;
477 			if (op == ALTDQ_REMOVE) {
478 				if((queue->head = mp->m_nextpkt) == NULL)
479 					queue->tail = NULL;
480 				byte = mp->m_pkthdr.len;
481 				mp->m_nextpkt = NULL;
482 				queue->quota -= byte;
483 				queue->bytes -= byte;
484 				PKTCNTR_ADD(&queue->xmit_cnt, byte);
485 				wfqp->bytes -= byte;
486 				if (ALTQ_IS_ENABLED(ifq))
487 					ifq->ifq_len--;
488 			}
489 			return mp;
490 
491 			/* if the queue gets empty by this dequeueing,
492 			   the queue will be removed from the active list
493 			   at the next round */
494 		}
495 
496 		/* advance the round-robin pointer */
497 		queue = wfqp->rrp = queue->next;
498 		WFQ_ADDQUOTA(queue);
499 	}
500 }
501 
502 static int
503 wfq_getqid(gqidp)
504 	struct wfq_getqid *gqidp;
505 {
506 	wfq_state_t *wfqp;
507 
508 	if ((wfqp = altq_lookup(gqidp->iface.wfq_ifacename, ALTQT_WFQ))
509 	    == NULL)
510 		return (EBADF);
511 
512 	gqidp->qid = (*wfqp->hash_func)(&gqidp->flow, wfqp->nums);
513 	return 0;
514 }
515 
516 static int
517 wfq_setweight(swp)
518 	struct wfq_setweight *swp;
519 {
520 	wfq_state_t	*wfqp;
521 	wfq *queue;
522 	int old;
523 
524 	if (swp->weight < 0) {
525 		printf("set weight in natural number\n");
526 		return (EINVAL);
527 	}
528 
529 	if ((wfqp = altq_lookup(swp->iface.wfq_ifacename, ALTQT_WFQ)) == NULL)
530 		return (EBADF);
531 
532 	queue = &wfqp->queue[swp->qid];
533 	old = queue->weight;
534 	queue->weight = swp->weight;
535 	swp->weight = old;
536 	return 0;
537 }
538 
539 
540 static int
541 wfq_getstats(gsp)
542 	struct wfq_getstats *gsp;
543 {
544 	wfq_state_t	*wfqp;
545 	wfq *queue;
546 	queue_stats *stats;
547 
548 	if ((wfqp = altq_lookup(gsp->iface.wfq_ifacename, ALTQT_WFQ)) == NULL)
549 		return (EBADF);
550 
551 	if (gsp->qid >= wfqp->nums)
552 		return (EINVAL);
553 
554 	queue = &wfqp->queue[gsp->qid];
555 	stats = &gsp->stats;
556 
557 	stats->bytes		= queue->bytes;
558 	stats->weight		= queue->weight;
559 	stats->xmit_cnt		= queue->xmit_cnt;
560 	stats->drop_cnt		= queue->drop_cnt;
561 
562 	return 0;
563 }
564 
565 
566 static int
567 wfq_config(cf)
568 	struct wfq_conf *cf;
569 {
570 	wfq_state_t	*wfqp;
571 	wfq		*queue;
572 	int		i, error = 0;
573 
574 	if ((wfqp = altq_lookup(cf->iface.wfq_ifacename, ALTQT_WFQ)) == NULL)
575 		return (EBADF);
576 
577 	if(cf->nqueues <= 0 ||  MAX_QSIZE < cf->nqueues)
578 		cf->nqueues = DEFAULT_QSIZE;
579 
580 	if (cf->nqueues != wfqp->nums) {
581 		/* free queued mbuf */
582 		wfq_flush(wfqp->ifq);
583 		FREE(wfqp->queue, M_DEVBUF);
584 
585 		MALLOC(queue, wfq *, sizeof(wfq) * cf->nqueues,
586 		       M_DEVBUF, M_WAITOK);
587 		if (queue == NULL)
588 			return (ENOMEM);
589 		bzero(queue, sizeof(wfq) * cf->nqueues);
590 
591 		wfqp->nums = cf->nqueues;
592 		wfqp->bytes = 0;
593 		wfqp->rrp = NULL;
594 		wfqp->queue = queue;
595 		for (i = 0; i < wfqp->nums; i++, queue++) {
596 			queue->next = queue->prev = NULL;
597 			queue->head = queue->tail = NULL;
598 			queue->bytes = queue->quota = 0;
599 			queue->weight = 100;
600 		}
601 	}
602 
603 	if (cf->qlimit != 0)
604 		wfqp->hwm = cf->qlimit;
605 
606 	switch (cf->hash_policy) {
607 	case WFQ_HASH_DSTADDR:
608 		wfqp->hash_func = wfq_hashbydstaddr;
609 		wfqp->fbmask = FIMB4_DADDR;
610 #ifdef INET6
611 		wfqp->fbmask |= FIMB6_FLABEL;	/* use flowlabel for ipv6 */
612 #endif
613 		break;
614 	case WFQ_HASH_SRCPORT:
615 		wfqp->hash_func = wfq_hashbysrcport;
616 		wfqp->fbmask = FIMB4_SPORT;
617 #ifdef INET6
618 		wfqp->fbmask |= FIMB6_SPORT;
619 #endif
620 		break;
621 	case WFQ_HASH_FULL:
622 		wfqp->hash_func = wfq_hash;
623 		wfqp->fbmask = FIMB4_ALL;
624 #ifdef INET6
625 		wfqp->fbmask |= FIMB6_FLABEL;	/* use flowlabel for ipv6 */
626 #endif
627 		break;
628 	default:
629 		error = EINVAL;
630 		break;
631 	}
632 	return error;
633 }
634 
635 /*
636  * wfq device interface
637  */
638 
639 altqdev_decl(wfq);
640 
641 int
642 wfqopen(dev, flag, fmt, p)
643 	dev_t dev;
644 	int flag, fmt;
645 	struct proc *p;
646 {
647 	return 0;
648 }
649 
650 int
651 wfqclose(dev, flag, fmt, p)
652 	dev_t dev;
653 	int flag, fmt;
654 	struct proc *p;
655 {
656 	struct ifnet *ifp;
657 	struct wfq_interface iface;
658 	wfq_state_t *wfqp;
659 	int s;
660 
661 	s = splnet();
662 	while ((wfqp = wfq_list) != NULL) {
663 		ifp = wfqp->ifq->altq_ifp;
664 #if defined(__NetBSD__) || defined(__OpenBSD__)
665 		sprintf(iface.wfq_ifacename, "%s", ifp->if_xname);
666 #else
667 		sprintf(iface.wfq_ifacename, "%s%d",
668 			ifp->if_name, ifp->if_unit);
669 #endif
670 		wfq_ifdetach(&iface);
671 	}
672 	splx(s);
673 	return 0;
674 }
675 
676 int
677 wfqioctl(dev, cmd, addr, flag, p)
678 	dev_t dev;
679 	ioctlcmd_t cmd;
680 	caddr_t addr;
681 	int flag;
682 	struct proc *p;
683 {
684 	int	error = 0;
685 	int 	s;
686 
687 	/* check cmd for superuser only */
688 	switch (cmd) {
689 	case WFQ_GET_QID:
690 	case WFQ_GET_STATS:
691 		break;
692 	default:
693 #if (__FreeBSD_version > 400000)
694 		if ((error = suser(p)) != 0)
695 #else
696 		if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
697 #endif
698 			return (error);
699 		break;
700 	}
701 
702 	s = splnet();
703 	switch (cmd) {
704 
705 	case WFQ_ENABLE:
706 		error = wfq_setenable((struct wfq_interface *)addr, ENABLE);
707 		break;
708 
709 	case WFQ_DISABLE:
710 		error = wfq_setenable((struct wfq_interface *)addr, DISABLE);
711 		break;
712 
713 	case WFQ_IF_ATTACH:
714 		error = wfq_ifattach((struct wfq_interface *)addr);
715 		break;
716 
717 	case WFQ_IF_DETACH:
718 		error = wfq_ifdetach((struct wfq_interface *)addr);
719 		break;
720 
721 	case WFQ_GET_QID:
722 		error = wfq_getqid((struct wfq_getqid *)addr);
723 		break;
724 
725 	case WFQ_SET_WEIGHT:
726 		error = wfq_setweight((struct wfq_setweight *)addr);
727 		break;
728 
729 	case WFQ_GET_STATS:
730 		error = wfq_getstats((struct wfq_getstats *)addr);
731 		break;
732 
733 	case WFQ_CONFIG:
734 		error = wfq_config((struct wfq_conf *)addr);
735 		break;
736 
737 	default:
738 		error = EINVAL;
739 		break;
740 	}
741 	splx(s);
742 	return error;
743 }
744 
745 #ifdef KLD_MODULE
746 
747 static struct altqsw wfq_sw =
748 	{"wfq", wfqopen, wfqclose, wfqioctl};
749 
750 ALTQ_MODULE(altq_wfq, ALTQT_WFQ, &wfq_sw);
751 
752 #endif /* KLD_MODULE */
753 
754 #endif /* ALTQ_WFQ */
755