1 /* $OpenBSD: altq_cbq.c,v 1.18 2004/01/14 08:42:23 kjc Exp $ */
2 /* $KAME: altq_cbq.c,v 1.9 2000/12/14 08:12:45 thorpej Exp $ */
3
4 /*
5 * Copyright (c) Sun Microsystems, Inc. 1993-1998 All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 *
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the SMCC Technology
21 * Development Group at Sun Microsystems, Inc.
22 *
23 * 4. The name of the Sun Microsystems, Inc nor may not be used to endorse or
24 * promote products derived from this software without specific prior
25 * written permission.
26 *
27 * SUN MICROSYSTEMS DOES NOT CLAIM MERCHANTABILITY OF THIS SOFTWARE OR THE
28 * SUITABILITY OF THIS SOFTWARE FOR ANY PARTICULAR PURPOSE. The software is
29 * provided "as is" without express or implied warranty of any kind.
30 *
31 * These notices must be retained in any copies of any part of this software.
32 */
33
34 #include <sys/param.h>
35 #include <sys/malloc.h>
36 #include <sys/mbuf.h>
37 #include <sys/socket.h>
38 #include <sys/systm.h>
39 #include <sys/errno.h>
40 #include <sys/time.h>
41
42 #include <net/if.h>
43 #include <netinet/in.h>
44
45 #include <net/pfvar.h>
46 #include <altq/altq.h>
47 #include <altq/altq_cbq.h>
48
49 /*
50 * Forward Declarations.
51 */
52 static int cbq_class_destroy(cbq_state_t *, struct rm_class *);
53 static struct rm_class *clh_to_clp(cbq_state_t *, u_int32_t);
54 static int cbq_clear_interface(cbq_state_t *);
55 static int cbq_request(struct ifaltq *, int, void *);
56 static int cbq_enqueue(struct ifaltq *, struct mbuf *,
57 struct altq_pktattr *);
58 static struct mbuf *cbq_dequeue(struct ifaltq *, int);
59 static void cbqrestart(struct ifaltq *);
60 static void get_class_stats(class_stats_t *, struct rm_class *);
61 static void cbq_purge(cbq_state_t *);
62
63 /*
64 * int
65 * cbq_class_destroy(cbq_mod_state_t *, struct rm_class *) - This
66 * function destroys a given traffic class. Before destroying
67 * the class, all traffic for that class is released.
68 */
69 static int
cbq_class_destroy(cbq_state_t * cbqp,struct rm_class * cl)70 cbq_class_destroy(cbq_state_t *cbqp, struct rm_class *cl)
71 {
72 int i;
73
74 /* delete the class */
75 rmc_delete_class(&cbqp->ifnp, cl);
76
77 /*
78 * free the class handle
79 */
80 for (i = 0; i < CBQ_MAX_CLASSES; i++)
81 if (cbqp->cbq_class_tbl[i] == cl)
82 cbqp->cbq_class_tbl[i] = NULL;
83
84 if (cl == cbqp->ifnp.root_)
85 cbqp->ifnp.root_ = NULL;
86 if (cl == cbqp->ifnp.default_)
87 cbqp->ifnp.default_ = NULL;
88 return (0);
89 }
90
91 /* convert class handle to class pointer */
92 static struct rm_class *
clh_to_clp(cbq_state_t * cbqp,u_int32_t chandle)93 clh_to_clp(cbq_state_t *cbqp, u_int32_t chandle)
94 {
95 int i;
96 struct rm_class *cl;
97
98 if (chandle == 0)
99 return (NULL);
100 /*
101 * first, try the slot corresponding to the lower bits of the handle.
102 * if it does not match, do the linear table search.
103 */
104 i = chandle % CBQ_MAX_CLASSES;
105 if ((cl = cbqp->cbq_class_tbl[i]) != NULL &&
106 cl->stats_.handle == chandle)
107 return (cl);
108 for (i = 0; i < CBQ_MAX_CLASSES; i++)
109 if ((cl = cbqp->cbq_class_tbl[i]) != NULL &&
110 cl->stats_.handle == chandle)
111 return (cl);
112 return (NULL);
113 }
114
115 static int
cbq_clear_interface(cbq_state_t * cbqp)116 cbq_clear_interface(cbq_state_t *cbqp)
117 {
118 int again, i;
119 struct rm_class *cl;
120
121 /* clear out the classes now */
122 do {
123 again = 0;
124 for (i = 0; i < CBQ_MAX_CLASSES; i++) {
125 if ((cl = cbqp->cbq_class_tbl[i]) != NULL) {
126 if (is_a_parent_class(cl))
127 again++;
128 else {
129 cbq_class_destroy(cbqp, cl);
130 cbqp->cbq_class_tbl[i] = NULL;
131 if (cl == cbqp->ifnp.root_)
132 cbqp->ifnp.root_ = NULL;
133 if (cl == cbqp->ifnp.default_)
134 cbqp->ifnp.default_ = NULL;
135 }
136 }
137 }
138 } while (again);
139
140 return (0);
141 }
142
143 static int
cbq_request(struct ifaltq * ifq,int req,void * arg)144 cbq_request(struct ifaltq *ifq, int req, void *arg)
145 {
146 cbq_state_t *cbqp = (cbq_state_t *)ifq->altq_disc;
147
148 switch (req) {
149 case ALTRQ_PURGE:
150 cbq_purge(cbqp);
151 break;
152 }
153 return (0);
154 }
155
156 /* copy the stats info in rm_class to class_states_t */
157 static void
get_class_stats(class_stats_t * statsp,struct rm_class * cl)158 get_class_stats(class_stats_t *statsp, struct rm_class *cl)
159 {
160 statsp->handle = cl->stats_.handle;
161 statsp->xmit_cnt = cl->stats_.xmit_cnt;
162 statsp->drop_cnt = cl->stats_.drop_cnt;
163 statsp->over = cl->stats_.over;
164 statsp->borrows = cl->stats_.borrows;
165 statsp->overactions = cl->stats_.overactions;
166 statsp->delays = cl->stats_.delays;
167
168 statsp->depth = cl->depth_;
169 statsp->priority = cl->pri_;
170 statsp->maxidle = cl->maxidle_;
171 statsp->minidle = cl->minidle_;
172 statsp->offtime = cl->offtime_;
173 statsp->qmax = qlimit(cl->q_);
174 statsp->ns_per_byte = cl->ns_per_byte_;
175 statsp->wrr_allot = cl->w_allotment_;
176 statsp->qcnt = qlen(cl->q_);
177 statsp->avgidle = cl->avgidle_;
178
179 statsp->qtype = qtype(cl->q_);
180 #ifdef ALTQ_RED
181 if (q_is_red(cl->q_))
182 red_getstats(cl->red_, &statsp->red[0]);
183 #endif
184 #ifdef ALTQ_RIO
185 if (q_is_rio(cl->q_))
186 rio_getstats((rio_t *)cl->red_, &statsp->red[0]);
187 #endif
188 }
189
190 int
cbq_pfattach(struct pf_altq * a)191 cbq_pfattach(struct pf_altq *a)
192 {
193 struct ifnet *ifp;
194 int s, error;
195
196 if ((ifp = ifunit(a->ifname)) == NULL || a->altq_disc == NULL)
197 return (EINVAL);
198 s = splimp();
199 error = altq_attach(&ifp->if_snd, ALTQT_CBQ, a->altq_disc,
200 cbq_enqueue, cbq_dequeue, cbq_request, NULL, NULL);
201 splx(s);
202 return (error);
203 }
204
205 int
cbq_add_altq(struct pf_altq * a)206 cbq_add_altq(struct pf_altq *a)
207 {
208 cbq_state_t *cbqp;
209 struct ifnet *ifp;
210
211 if ((ifp = ifunit(a->ifname)) == NULL)
212 return (EINVAL);
213 if (!ALTQ_IS_READY(&ifp->if_snd))
214 return (ENODEV);
215
216 /* allocate and initialize cbq_state_t */
217 MALLOC(cbqp, cbq_state_t *, sizeof(cbq_state_t), M_DEVBUF, M_WAITOK);
218 if (cbqp == NULL)
219 return (ENOMEM);
220 bzero(cbqp, sizeof(cbq_state_t));
221 CALLOUT_INIT(&cbqp->cbq_callout);
222 cbqp->cbq_qlen = 0;
223 cbqp->ifnp.ifq_ = &ifp->if_snd; /* keep the ifq */
224
225 /* keep the state in pf_altq */
226 a->altq_disc = cbqp;
227
228 return (0);
229 }
230
231 int
cbq_remove_altq(struct pf_altq * a)232 cbq_remove_altq(struct pf_altq *a)
233 {
234 cbq_state_t *cbqp;
235
236 if ((cbqp = a->altq_disc) == NULL)
237 return (EINVAL);
238 a->altq_disc = NULL;
239
240 cbq_clear_interface(cbqp);
241
242 if (cbqp->ifnp.default_)
243 cbq_class_destroy(cbqp, cbqp->ifnp.default_);
244 if (cbqp->ifnp.root_)
245 cbq_class_destroy(cbqp, cbqp->ifnp.root_);
246
247 /* deallocate cbq_state_t */
248 FREE(cbqp, M_DEVBUF);
249
250 return (0);
251 }
252
253 int
cbq_add_queue(struct pf_altq * a)254 cbq_add_queue(struct pf_altq *a)
255 {
256 struct rm_class *borrow, *parent;
257 cbq_state_t *cbqp;
258 struct rm_class *cl;
259 struct cbq_opts *opts;
260 int i;
261
262 if ((cbqp = a->altq_disc) == NULL)
263 return (EINVAL);
264 if (a->qid == 0)
265 return (EINVAL);
266
267 /*
268 * find a free slot in the class table. if the slot matching
269 * the lower bits of qid is free, use this slot. otherwise,
270 * use the first free slot.
271 */
272 i = a->qid % CBQ_MAX_CLASSES;
273 if (cbqp->cbq_class_tbl[i] != NULL) {
274 for (i = 0; i < CBQ_MAX_CLASSES; i++)
275 if (cbqp->cbq_class_tbl[i] == NULL)
276 break;
277 if (i == CBQ_MAX_CLASSES)
278 return (EINVAL);
279 }
280
281 opts = &a->pq_u.cbq_opts;
282 /* check parameters */
283 if (a->priority >= CBQ_MAXPRI)
284 return (EINVAL);
285
286 /* Get pointers to parent and borrow classes. */
287 parent = clh_to_clp(cbqp, a->parent_qid);
288 if (opts->flags & CBQCLF_BORROW)
289 borrow = parent;
290 else
291 borrow = NULL;
292
293 /*
294 * A class must borrow from it's parent or it can not
295 * borrow at all. Hence, borrow can be null.
296 */
297 if (parent == NULL && (opts->flags & CBQCLF_ROOTCLASS) == 0) {
298 printf("cbq_add_queue: no parent class!\n");
299 return (EINVAL);
300 }
301
302 if ((borrow != parent) && (borrow != NULL)) {
303 printf("cbq_add_class: borrow class != parent\n");
304 return (EINVAL);
305 }
306
307 /*
308 * check parameters
309 */
310 switch (opts->flags & CBQCLF_CLASSMASK) {
311 case CBQCLF_ROOTCLASS:
312 if (parent != NULL)
313 return (EINVAL);
314 if (cbqp->ifnp.root_)
315 return (EINVAL);
316 break;
317 case CBQCLF_DEFCLASS:
318 if (cbqp->ifnp.default_)
319 return (EINVAL);
320 break;
321 case 0:
322 if (a->qid == 0)
323 return (EINVAL);
324 break;
325 default:
326 /* more than two flags bits set */
327 return (EINVAL);
328 }
329
330 /*
331 * create a class. if this is a root class, initialize the
332 * interface.
333 */
334 if ((opts->flags & CBQCLF_CLASSMASK) == CBQCLF_ROOTCLASS) {
335 rmc_init(cbqp->ifnp.ifq_, &cbqp->ifnp, opts->ns_per_byte,
336 cbqrestart, a->qlimit, RM_MAXQUEUED,
337 opts->maxidle, opts->minidle, opts->offtime,
338 opts->flags);
339 cl = cbqp->ifnp.root_;
340 } else {
341 cl = rmc_newclass(a->priority,
342 &cbqp->ifnp, opts->ns_per_byte,
343 rmc_delay_action, a->qlimit, parent, borrow,
344 opts->maxidle, opts->minidle, opts->offtime,
345 opts->pktsize, opts->flags);
346 }
347 if (cl == NULL)
348 return (ENOMEM);
349
350 /* return handle to user space. */
351 cl->stats_.handle = a->qid;
352 cl->stats_.depth = cl->depth_;
353
354 /* save the allocated class */
355 cbqp->cbq_class_tbl[i] = cl;
356
357 if ((opts->flags & CBQCLF_CLASSMASK) == CBQCLF_DEFCLASS)
358 cbqp->ifnp.default_ = cl;
359
360 return (0);
361 }
362
363 int
cbq_remove_queue(struct pf_altq * a)364 cbq_remove_queue(struct pf_altq *a)
365 {
366 struct rm_class *cl;
367 cbq_state_t *cbqp;
368 int i;
369
370 if ((cbqp = a->altq_disc) == NULL)
371 return (EINVAL);
372
373 if ((cl = clh_to_clp(cbqp, a->qid)) == NULL)
374 return (EINVAL);
375
376 /* if we are a parent class, then return an error. */
377 if (is_a_parent_class(cl))
378 return (EINVAL);
379
380 /* delete the class */
381 rmc_delete_class(&cbqp->ifnp, cl);
382
383 /*
384 * free the class handle
385 */
386 for (i = 0; i < CBQ_MAX_CLASSES; i++)
387 if (cbqp->cbq_class_tbl[i] == cl) {
388 cbqp->cbq_class_tbl[i] = NULL;
389 if (cl == cbqp->ifnp.root_)
390 cbqp->ifnp.root_ = NULL;
391 if (cl == cbqp->ifnp.default_)
392 cbqp->ifnp.default_ = NULL;
393 break;
394 }
395
396 return (0);
397 }
398
399 int
cbq_getqstats(struct pf_altq * a,void * ubuf,int * nbytes)400 cbq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes)
401 {
402 cbq_state_t *cbqp;
403 struct rm_class *cl;
404 class_stats_t stats;
405 int error = 0;
406
407 if ((cbqp = altq_lookup(a->ifname, ALTQT_CBQ)) == NULL)
408 return (EBADF);
409
410 if ((cl = clh_to_clp(cbqp, a->qid)) == NULL)
411 return (EINVAL);
412
413 if (*nbytes < sizeof(stats))
414 return (EINVAL);
415
416 get_class_stats(&stats, cl);
417
418 if ((error = copyout((caddr_t)&stats, ubuf, sizeof(stats))) != 0)
419 return (error);
420 *nbytes = sizeof(stats);
421 return (0);
422 }
423
424 /*
425 * int
426 * cbq_enqueue(struct ifaltq *ifq, struct mbuf *m, struct altq_pktattr *pattr)
427 * - Queue data packets.
428 *
429 * cbq_enqueue is set to ifp->if_altqenqueue and called by an upper
430 * layer (e.g. ether_output). cbq_enqueue queues the given packet
431 * to the cbq, then invokes the driver's start routine.
432 *
433 * Assumptions: called in splimp
434 * Returns: 0 if the queueing is successful.
435 * ENOBUFS if a packet dropping occurred as a result of
436 * the queueing.
437 */
438
439 static int
cbq_enqueue(struct ifaltq * ifq,struct mbuf * m,struct altq_pktattr * pktattr)440 cbq_enqueue(struct ifaltq *ifq, struct mbuf *m, struct altq_pktattr *pktattr)
441 {
442 cbq_state_t *cbqp = (cbq_state_t *)ifq->altq_disc;
443 struct rm_class *cl;
444 struct m_tag *t;
445 int len;
446
447 /* grab class set by classifier */
448 if ((m->m_flags & M_PKTHDR) == 0) {
449 /* should not happen */
450 printf("altq: packet for %s does not have pkthdr\n",
451 ifq->altq_ifp->if_xname);
452 m_freem(m);
453 return (ENOBUFS);
454 }
455 t = m_tag_find(m, PACKET_TAG_PF_QID, NULL);
456 if (t == NULL ||
457 (cl = clh_to_clp(cbqp, ((struct altq_tag *)(t+1))->qid)) == NULL) {
458 cl = cbqp->ifnp.default_;
459 if (cl == NULL) {
460 m_freem(m);
461 return (ENOBUFS);
462 }
463 cl->pktattr_ = NULL;
464 }
465
466 len = m_pktlen(m);
467 if (rmc_queue_packet(cl, m) != 0) {
468 /* drop occurred. some mbuf was freed in rmc_queue_packet. */
469 PKTCNTR_ADD(&cl->stats_.drop_cnt, len);
470 return (ENOBUFS);
471 }
472
473 /* successfully queued. */
474 ++cbqp->cbq_qlen;
475 IFQ_INC_LEN(ifq);
476 return (0);
477 }
478
479 static struct mbuf *
cbq_dequeue(struct ifaltq * ifq,int op)480 cbq_dequeue(struct ifaltq *ifq, int op)
481 {
482 cbq_state_t *cbqp = (cbq_state_t *)ifq->altq_disc;
483 struct mbuf *m;
484
485 m = rmc_dequeue_next(&cbqp->ifnp, op);
486
487 if (m && op == ALTDQ_REMOVE) {
488 --cbqp->cbq_qlen; /* decrement # of packets in cbq */
489 IFQ_DEC_LEN(ifq);
490
491 /* Update the class. */
492 rmc_update_class_util(&cbqp->ifnp);
493 }
494 return (m);
495 }
496
497 /*
498 * void
499 * cbqrestart(queue_t *) - Restart sending of data.
500 * called from rmc_restart in splimp via timeout after waking up
501 * a suspended class.
502 * Returns: NONE
503 */
504
505 static void
cbqrestart(struct ifaltq * ifq)506 cbqrestart(struct ifaltq *ifq)
507 {
508 cbq_state_t *cbqp;
509 struct ifnet *ifp;
510
511 if (!ALTQ_IS_ENABLED(ifq))
512 /* cbq must have been detached */
513 return;
514
515 if ((cbqp = (cbq_state_t *)ifq->altq_disc) == NULL)
516 /* should not happen */
517 return;
518
519 ifp = ifq->altq_ifp;
520 if (ifp->if_start &&
521 cbqp->cbq_qlen > 0 && (ifp->if_flags & IFF_OACTIVE) == 0)
522 (*ifp->if_start)(ifp);
523 }
524
cbq_purge(cbq_state_t * cbqp)525 static void cbq_purge(cbq_state_t *cbqp)
526 {
527 struct rm_class *cl;
528 int i;
529
530 for (i = 0; i < CBQ_MAX_CLASSES; i++)
531 if ((cl = cbqp->cbq_class_tbl[i]) != NULL)
532 rmc_dropall(cl);
533 if (ALTQ_IS_ENABLED(cbqp->ifnp.ifq_))
534 cbqp->ifnp.ifq_->ifq_len = 0;
535 }
536