![[BACK]](/icons/back.gif){kind=icon}
Return to altq_cbq.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / altq|
Return to altq_cbq.c CVS log | Up to [local] / sys / altq |
1.1 nbrk 1: /* $OpenBSD: altq_cbq.c,v 1.22 2007/05/28 17:16:38 henning 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
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 *
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
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
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
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
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 = splnet();
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
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
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
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 its 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
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
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 splnet
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
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: int len;
445:
446: /* grab class set by classifier */
447: if ((m->m_flags & M_PKTHDR) == 0) {
448: /* should not happen */
449: printf("altq: packet for %s does not have pkthdr\n",
450: ifq->altq_ifp->if_xname);
451: m_freem(m);
452: return (ENOBUFS);
453: }
454: if ((cl = clh_to_clp(cbqp, m->m_pkthdr.pf.qid)) == NULL) {
455: cl = cbqp->ifnp.default_;
456: if (cl == NULL) {
457: m_freem(m);
458: return (ENOBUFS);
459: }
460: cl->pktattr_ = NULL;
461: }
462:
463: len = m_pktlen(m);
464: if (rmc_queue_packet(cl, m) != 0) {
465: /* drop occurred. some mbuf was freed in rmc_queue_packet. */
466: PKTCNTR_ADD(&cl->stats_.drop_cnt, len);
467: return (ENOBUFS);
468: }
469:
470: /* successfully queued. */
471: ++cbqp->cbq_qlen;
472: IFQ_INC_LEN(ifq);
473: return (0);
474: }
475:
476: static struct mbuf *
477: cbq_dequeue(struct ifaltq *ifq, int op)
478: {
479: cbq_state_t *cbqp = (cbq_state_t *)ifq->altq_disc;
480: struct mbuf *m;
481:
482: m = rmc_dequeue_next(&cbqp->ifnp, op);
483:
484: if (m && op == ALTDQ_REMOVE) {
485: --cbqp->cbq_qlen; /* decrement # of packets in cbq */
486: IFQ_DEC_LEN(ifq);
487:
488: /* Update the class. */
489: rmc_update_class_util(&cbqp->ifnp);
490: }
491: return (m);
492: }
493:
494: /*
495: * void
496: * cbqrestart(queue_t *) - Restart sending of data.
497: * called from rmc_restart in splnet via timeout after waking up
498: * a suspended class.
499: * Returns: NONE
500: */
501:
502: static void
503: cbqrestart(struct ifaltq *ifq)
504: {
505: cbq_state_t *cbqp;
506: struct ifnet *ifp;
507:
508: if (!ALTQ_IS_ENABLED(ifq))
509: /* cbq must have been detached */
510: return;
511:
512: if ((cbqp = (cbq_state_t *)ifq->altq_disc) == NULL)
513: /* should not happen */
514: return;
515:
516: ifp = ifq->altq_ifp;
517: if (ifp->if_start &&
518: cbqp->cbq_qlen > 0 && (ifp->if_flags & IFF_OACTIVE) == 0)
519: (*ifp->if_start)(ifp);
520: }
521:
522: static void cbq_purge(cbq_state_t *cbqp)
523: {
524: struct rm_class *cl;
525: int i;
526:
527: for (i = 0; i < CBQ_MAX_CLASSES; i++)
528: if ((cl = cbqp->cbq_class_tbl[i]) != NULL)
529: rmc_dropall(cl);
530: if (ALTQ_IS_ENABLED(cbqp->ifnp.ifq_))
531: cbqp->ifnp.ifq_->ifq_len = 0;
532: }