Annotation of sys/altq/altq_priq.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: altq_priq.c,v 1.20 2007/05/28 17:16:38 henning Exp $ */
! 2: /* $KAME: altq_priq.c,v 1.1 2000/10/18 09:15:23 kjc Exp $ */
! 3: /*
! 4: * Copyright (C) 2000
! 5: * Sony Computer Science Laboratories Inc. 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: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
! 17: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 18: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 19: * ARE DISCLAIMED. IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE
! 20: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 21: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 22: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 26: * SUCH DAMAGE.
! 27: */
! 28: /*
! 29: * priority queue
! 30: */
! 31:
! 32: #include <sys/param.h>
! 33: #include <sys/malloc.h>
! 34: #include <sys/mbuf.h>
! 35: #include <sys/socket.h>
! 36: #include <sys/systm.h>
! 37: #include <sys/proc.h>
! 38: #include <sys/errno.h>
! 39: #include <sys/kernel.h>
! 40: #include <sys/queue.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_priq.h>
! 48:
! 49: /*
! 50: * function prototypes
! 51: */
! 52: static int priq_clear_interface(struct priq_if *);
! 53: static int priq_request(struct ifaltq *, int, void *);
! 54: static void priq_purge(struct priq_if *);
! 55: static struct priq_class *priq_class_create(struct priq_if *, int, int, int,
! 56: int);
! 57: static int priq_class_destroy(struct priq_class *);
! 58: static int priq_enqueue(struct ifaltq *, struct mbuf *,
! 59: struct altq_pktattr *);
! 60: static struct mbuf *priq_dequeue(struct ifaltq *, int);
! 61:
! 62: static int priq_addq(struct priq_class *, struct mbuf *);
! 63: static struct mbuf *priq_getq(struct priq_class *);
! 64: static struct mbuf *priq_pollq(struct priq_class *);
! 65: static void priq_purgeq(struct priq_class *);
! 66:
! 67: static void get_class_stats(struct priq_classstats *, struct priq_class *);
! 68: static struct priq_class *clh_to_clp(struct priq_if *, u_int32_t);
! 69:
! 70: int
! 71: priq_pfattach(struct pf_altq *a)
! 72: {
! 73: struct ifnet *ifp;
! 74: int s, error;
! 75:
! 76: if ((ifp = ifunit(a->ifname)) == NULL || a->altq_disc == NULL)
! 77: return (EINVAL);
! 78: s = splnet();
! 79: error = altq_attach(&ifp->if_snd, ALTQT_PRIQ, a->altq_disc,
! 80: priq_enqueue, priq_dequeue, priq_request, NULL, NULL);
! 81: splx(s);
! 82: return (error);
! 83: }
! 84:
! 85: int
! 86: priq_add_altq(struct pf_altq *a)
! 87: {
! 88: struct priq_if *pif;
! 89: struct ifnet *ifp;
! 90:
! 91: if ((ifp = ifunit(a->ifname)) == NULL)
! 92: return (EINVAL);
! 93: if (!ALTQ_IS_READY(&ifp->if_snd))
! 94: return (ENODEV);
! 95:
! 96: MALLOC(pif, struct priq_if *, sizeof(struct priq_if),
! 97: M_DEVBUF, M_WAITOK);
! 98: if (pif == NULL)
! 99: return (ENOMEM);
! 100: bzero(pif, sizeof(struct priq_if));
! 101: pif->pif_bandwidth = a->ifbandwidth;
! 102: pif->pif_maxpri = -1;
! 103: pif->pif_ifq = &ifp->if_snd;
! 104:
! 105: /* keep the state in pf_altq */
! 106: a->altq_disc = pif;
! 107:
! 108: return (0);
! 109: }
! 110:
! 111: int
! 112: priq_remove_altq(struct pf_altq *a)
! 113: {
! 114: struct priq_if *pif;
! 115:
! 116: if ((pif = a->altq_disc) == NULL)
! 117: return (EINVAL);
! 118: a->altq_disc = NULL;
! 119:
! 120: (void)priq_clear_interface(pif);
! 121:
! 122: FREE(pif, M_DEVBUF);
! 123: return (0);
! 124: }
! 125:
! 126: int
! 127: priq_add_queue(struct pf_altq *a)
! 128: {
! 129: struct priq_if *pif;
! 130: struct priq_class *cl;
! 131:
! 132: if ((pif = a->altq_disc) == NULL)
! 133: return (EINVAL);
! 134:
! 135: /* check parameters */
! 136: if (a->priority >= PRIQ_MAXPRI)
! 137: return (EINVAL);
! 138: if (a->qid == 0)
! 139: return (EINVAL);
! 140: if (pif->pif_classes[a->priority] != NULL)
! 141: return (EBUSY);
! 142: if (clh_to_clp(pif, a->qid) != NULL)
! 143: return (EBUSY);
! 144:
! 145: cl = priq_class_create(pif, a->priority, a->qlimit,
! 146: a->pq_u.priq_opts.flags, a->qid);
! 147: if (cl == NULL)
! 148: return (ENOMEM);
! 149:
! 150: return (0);
! 151: }
! 152:
! 153: int
! 154: priq_remove_queue(struct pf_altq *a)
! 155: {
! 156: struct priq_if *pif;
! 157: struct priq_class *cl;
! 158:
! 159: if ((pif = a->altq_disc) == NULL)
! 160: return (EINVAL);
! 161:
! 162: if ((cl = clh_to_clp(pif, a->qid)) == NULL)
! 163: return (EINVAL);
! 164:
! 165: return (priq_class_destroy(cl));
! 166: }
! 167:
! 168: int
! 169: priq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes)
! 170: {
! 171: struct priq_if *pif;
! 172: struct priq_class *cl;
! 173: struct priq_classstats stats;
! 174: int error = 0;
! 175:
! 176: if ((pif = altq_lookup(a->ifname, ALTQT_PRIQ)) == NULL)
! 177: return (EBADF);
! 178:
! 179: if ((cl = clh_to_clp(pif, a->qid)) == NULL)
! 180: return (EINVAL);
! 181:
! 182: if (*nbytes < sizeof(stats))
! 183: return (EINVAL);
! 184:
! 185: get_class_stats(&stats, cl);
! 186:
! 187: if ((error = copyout((caddr_t)&stats, ubuf, sizeof(stats))) != 0)
! 188: return (error);
! 189: *nbytes = sizeof(stats);
! 190: return (0);
! 191: }
! 192:
! 193: /*
! 194: * bring the interface back to the initial state by discarding
! 195: * all the filters and classes.
! 196: */
! 197: static int
! 198: priq_clear_interface(struct priq_if *pif)
! 199: {
! 200: struct priq_class *cl;
! 201: int pri;
! 202:
! 203: /* clear out the classes */
! 204: for (pri = 0; pri <= pif->pif_maxpri; pri++)
! 205: if ((cl = pif->pif_classes[pri]) != NULL)
! 206: priq_class_destroy(cl);
! 207:
! 208: return (0);
! 209: }
! 210:
! 211: static int
! 212: priq_request(struct ifaltq *ifq, int req, void *arg)
! 213: {
! 214: struct priq_if *pif = (struct priq_if *)ifq->altq_disc;
! 215:
! 216: switch (req) {
! 217: case ALTRQ_PURGE:
! 218: priq_purge(pif);
! 219: break;
! 220: }
! 221: return (0);
! 222: }
! 223:
! 224: /* discard all the queued packets on the interface */
! 225: static void
! 226: priq_purge(struct priq_if *pif)
! 227: {
! 228: struct priq_class *cl;
! 229: int pri;
! 230:
! 231: for (pri = 0; pri <= pif->pif_maxpri; pri++) {
! 232: if ((cl = pif->pif_classes[pri]) != NULL && !qempty(cl->cl_q))
! 233: priq_purgeq(cl);
! 234: }
! 235: if (ALTQ_IS_ENABLED(pif->pif_ifq))
! 236: pif->pif_ifq->ifq_len = 0;
! 237: }
! 238:
! 239: static struct priq_class *
! 240: priq_class_create(struct priq_if *pif, int pri, int qlimit, int flags, int qid)
! 241: {
! 242: struct priq_class *cl;
! 243: int s;
! 244:
! 245: #ifndef ALTQ_RED
! 246: if (flags & PRCF_RED) {
! 247: #ifdef ALTQ_DEBUG
! 248: printf("priq_class_create: RED not configured for PRIQ!\n");
! 249: #endif
! 250: return (NULL);
! 251: }
! 252: #endif
! 253:
! 254: if ((cl = pif->pif_classes[pri]) != NULL) {
! 255: /* modify the class instead of creating a new one */
! 256: s = splnet();
! 257: if (!qempty(cl->cl_q))
! 258: priq_purgeq(cl);
! 259: splx(s);
! 260: #ifdef ALTQ_RIO
! 261: if (q_is_rio(cl->cl_q))
! 262: rio_destroy((rio_t *)cl->cl_red);
! 263: #endif
! 264: #ifdef ALTQ_RED
! 265: if (q_is_red(cl->cl_q))
! 266: red_destroy(cl->cl_red);
! 267: #endif
! 268: } else {
! 269: MALLOC(cl, struct priq_class *, sizeof(struct priq_class),
! 270: M_DEVBUF, M_WAITOK);
! 271: if (cl == NULL)
! 272: return (NULL);
! 273: bzero(cl, sizeof(struct priq_class));
! 274:
! 275: MALLOC(cl->cl_q, class_queue_t *, sizeof(class_queue_t),
! 276: M_DEVBUF, M_WAITOK);
! 277: if (cl->cl_q == NULL)
! 278: goto err_ret;
! 279: bzero(cl->cl_q, sizeof(class_queue_t));
! 280: }
! 281:
! 282: pif->pif_classes[pri] = cl;
! 283: if (flags & PRCF_DEFAULTCLASS)
! 284: pif->pif_default = cl;
! 285: if (qlimit == 0)
! 286: qlimit = 50; /* use default */
! 287: qlimit(cl->cl_q) = qlimit;
! 288: qtype(cl->cl_q) = Q_DROPTAIL;
! 289: qlen(cl->cl_q) = 0;
! 290: cl->cl_flags = flags;
! 291: cl->cl_pri = pri;
! 292: if (pri > pif->pif_maxpri)
! 293: pif->pif_maxpri = pri;
! 294: cl->cl_pif = pif;
! 295: cl->cl_handle = qid;
! 296:
! 297: #ifdef ALTQ_RED
! 298: if (flags & (PRCF_RED|PRCF_RIO)) {
! 299: int red_flags, red_pkttime;
! 300:
! 301: red_flags = 0;
! 302: if (flags & PRCF_ECN)
! 303: red_flags |= REDF_ECN;
! 304: #ifdef ALTQ_RIO
! 305: if (flags & PRCF_CLEARDSCP)
! 306: red_flags |= RIOF_CLEARDSCP;
! 307: #endif
! 308: if (pif->pif_bandwidth < 8)
! 309: red_pkttime = 1000 * 1000 * 1000; /* 1 sec */
! 310: else
! 311: red_pkttime = (int64_t)pif->pif_ifq->altq_ifp->if_mtu
! 312: * 1000 * 1000 * 1000 / (pif->pif_bandwidth / 8);
! 313: #ifdef ALTQ_RIO
! 314: if (flags & PRCF_RIO) {
! 315: cl->cl_red = (red_t *)rio_alloc(0, NULL,
! 316: red_flags, red_pkttime);
! 317: if (cl->cl_red != NULL)
! 318: qtype(cl->cl_q) = Q_RIO;
! 319: } else
! 320: #endif
! 321: if (flags & PRCF_RED) {
! 322: cl->cl_red = red_alloc(0, 0,
! 323: qlimit(cl->cl_q) * 10/100,
! 324: qlimit(cl->cl_q) * 30/100,
! 325: red_flags, red_pkttime);
! 326: if (cl->cl_red != NULL)
! 327: qtype(cl->cl_q) = Q_RED;
! 328: }
! 329: }
! 330: #endif /* ALTQ_RED */
! 331:
! 332: return (cl);
! 333:
! 334: err_ret:
! 335: if (cl->cl_red != NULL) {
! 336: #ifdef ALTQ_RIO
! 337: if (q_is_rio(cl->cl_q))
! 338: rio_destroy((rio_t *)cl->cl_red);
! 339: #endif
! 340: #ifdef ALTQ_RED
! 341: if (q_is_red(cl->cl_q))
! 342: red_destroy(cl->cl_red);
! 343: #endif
! 344: }
! 345: if (cl->cl_q != NULL)
! 346: FREE(cl->cl_q, M_DEVBUF);
! 347: FREE(cl, M_DEVBUF);
! 348: return (NULL);
! 349: }
! 350:
! 351: static int
! 352: priq_class_destroy(struct priq_class *cl)
! 353: {
! 354: struct priq_if *pif;
! 355: int s, pri;
! 356:
! 357: s = splnet();
! 358:
! 359: if (!qempty(cl->cl_q))
! 360: priq_purgeq(cl);
! 361:
! 362: pif = cl->cl_pif;
! 363: pif->pif_classes[cl->cl_pri] = NULL;
! 364: if (pif->pif_maxpri == cl->cl_pri) {
! 365: for (pri = cl->cl_pri; pri >= 0; pri--)
! 366: if (pif->pif_classes[pri] != NULL) {
! 367: pif->pif_maxpri = pri;
! 368: break;
! 369: }
! 370: if (pri < 0)
! 371: pif->pif_maxpri = -1;
! 372: }
! 373: splx(s);
! 374:
! 375: if (cl->cl_red != NULL) {
! 376: #ifdef ALTQ_RIO
! 377: if (q_is_rio(cl->cl_q))
! 378: rio_destroy((rio_t *)cl->cl_red);
! 379: #endif
! 380: #ifdef ALTQ_RED
! 381: if (q_is_red(cl->cl_q))
! 382: red_destroy(cl->cl_red);
! 383: #endif
! 384: }
! 385: FREE(cl->cl_q, M_DEVBUF);
! 386: FREE(cl, M_DEVBUF);
! 387: return (0);
! 388: }
! 389:
! 390: /*
! 391: * priq_enqueue is an enqueue function to be registered to
! 392: * (*altq_enqueue) in struct ifaltq.
! 393: */
! 394: static int
! 395: priq_enqueue(struct ifaltq *ifq, struct mbuf *m, struct altq_pktattr *pktattr)
! 396: {
! 397: struct priq_if *pif = (struct priq_if *)ifq->altq_disc;
! 398: struct priq_class *cl;
! 399: int len;
! 400:
! 401: /* grab class set by classifier */
! 402: if ((m->m_flags & M_PKTHDR) == 0) {
! 403: /* should not happen */
! 404: printf("altq: packet for %s does not have pkthdr\n",
! 405: ifq->altq_ifp->if_xname);
! 406: m_freem(m);
! 407: return (ENOBUFS);
! 408: }
! 409: if ((cl = clh_to_clp(pif, m->m_pkthdr.pf.qid)) == NULL) {
! 410: cl = pif->pif_default;
! 411: if (cl == NULL) {
! 412: m_freem(m);
! 413: return (ENOBUFS);
! 414: }
! 415: cl->cl_pktattr = NULL;
! 416: }
! 417:
! 418: len = m_pktlen(m);
! 419: if (priq_addq(cl, m) != 0) {
! 420: /* drop occurred. mbuf was freed in priq_addq. */
! 421: PKTCNTR_ADD(&cl->cl_dropcnt, len);
! 422: return (ENOBUFS);
! 423: }
! 424: IFQ_INC_LEN(ifq);
! 425:
! 426: /* successfully queued. */
! 427: return (0);
! 428: }
! 429:
! 430: /*
! 431: * priq_dequeue is a dequeue function to be registered to
! 432: * (*altq_dequeue) in struct ifaltq.
! 433: *
! 434: * note: ALTDQ_POLL returns the next packet without removing the packet
! 435: * from the queue. ALTDQ_REMOVE is a normal dequeue operation.
! 436: * ALTDQ_REMOVE must return the same packet if called immediately
! 437: * after ALTDQ_POLL.
! 438: */
! 439: static struct mbuf *
! 440: priq_dequeue(struct ifaltq *ifq, int op)
! 441: {
! 442: struct priq_if *pif = (struct priq_if *)ifq->altq_disc;
! 443: struct priq_class *cl;
! 444: struct mbuf *m;
! 445: int pri;
! 446:
! 447: if (IFQ_IS_EMPTY(ifq))
! 448: /* no packet in the queue */
! 449: return (NULL);
! 450:
! 451: for (pri = pif->pif_maxpri; pri >= 0; pri--) {
! 452: if ((cl = pif->pif_classes[pri]) != NULL &&
! 453: !qempty(cl->cl_q)) {
! 454: if (op == ALTDQ_POLL)
! 455: return (priq_pollq(cl));
! 456:
! 457: m = priq_getq(cl);
! 458: if (m != NULL) {
! 459: IFQ_DEC_LEN(ifq);
! 460: if (qempty(cl->cl_q))
! 461: cl->cl_period++;
! 462: PKTCNTR_ADD(&cl->cl_xmitcnt, m_pktlen(m));
! 463: }
! 464: return (m);
! 465: }
! 466: }
! 467: return (NULL);
! 468: }
! 469:
! 470: static int
! 471: priq_addq(struct priq_class *cl, struct mbuf *m)
! 472: {
! 473:
! 474: #ifdef ALTQ_RIO
! 475: if (q_is_rio(cl->cl_q))
! 476: return rio_addq((rio_t *)cl->cl_red, cl->cl_q, m,
! 477: cl->cl_pktattr);
! 478: #endif
! 479: #ifdef ALTQ_RED
! 480: if (q_is_red(cl->cl_q))
! 481: return red_addq(cl->cl_red, cl->cl_q, m, cl->cl_pktattr);
! 482: #endif
! 483: if (qlen(cl->cl_q) >= qlimit(cl->cl_q)) {
! 484: m_freem(m);
! 485: return (-1);
! 486: }
! 487:
! 488: if (cl->cl_flags & PRCF_CLEARDSCP)
! 489: write_dsfield(m, cl->cl_pktattr, 0);
! 490:
! 491: _addq(cl->cl_q, m);
! 492:
! 493: return (0);
! 494: }
! 495:
! 496: static struct mbuf *
! 497: priq_getq(struct priq_class *cl)
! 498: {
! 499: #ifdef ALTQ_RIO
! 500: if (q_is_rio(cl->cl_q))
! 501: return rio_getq((rio_t *)cl->cl_red, cl->cl_q);
! 502: #endif
! 503: #ifdef ALTQ_RED
! 504: if (q_is_red(cl->cl_q))
! 505: return red_getq(cl->cl_red, cl->cl_q);
! 506: #endif
! 507: return _getq(cl->cl_q);
! 508: }
! 509:
! 510: static struct mbuf *
! 511: priq_pollq(cl)
! 512: struct priq_class *cl;
! 513: {
! 514: return qhead(cl->cl_q);
! 515: }
! 516:
! 517: static void
! 518: priq_purgeq(struct priq_class *cl)
! 519: {
! 520: struct mbuf *m;
! 521:
! 522: if (qempty(cl->cl_q))
! 523: return;
! 524:
! 525: while ((m = _getq(cl->cl_q)) != NULL) {
! 526: PKTCNTR_ADD(&cl->cl_dropcnt, m_pktlen(m));
! 527: m_freem(m);
! 528: }
! 529: ASSERT(qlen(cl->cl_q) == 0);
! 530: }
! 531:
! 532: static void
! 533: get_class_stats(struct priq_classstats *sp, struct priq_class *cl)
! 534: {
! 535: sp->class_handle = cl->cl_handle;
! 536: sp->qlength = qlen(cl->cl_q);
! 537: sp->qlimit = qlimit(cl->cl_q);
! 538: sp->period = cl->cl_period;
! 539: sp->xmitcnt = cl->cl_xmitcnt;
! 540: sp->dropcnt = cl->cl_dropcnt;
! 541:
! 542: sp->qtype = qtype(cl->cl_q);
! 543: #ifdef ALTQ_RED
! 544: if (q_is_red(cl->cl_q))
! 545: red_getstats(cl->cl_red, &sp->red[0]);
! 546: #endif
! 547: #ifdef ALTQ_RIO
! 548: if (q_is_rio(cl->cl_q))
! 549: rio_getstats((rio_t *)cl->cl_red, &sp->red[0]);
! 550: #endif
! 551:
! 552: }
! 553:
! 554: /* convert a class handle to the corresponding class pointer */
! 555: static struct priq_class *
! 556: clh_to_clp(struct priq_if *pif, u_int32_t chandle)
! 557: {
! 558: struct priq_class *cl;
! 559: int idx;
! 560:
! 561: if (chandle == 0)
! 562: return (NULL);
! 563:
! 564: for (idx = pif->pif_maxpri; idx >= 0; idx--)
! 565: if ((cl = pif->pif_classes[idx]) != NULL &&
! 566: cl->cl_handle == chandle)
! 567: return (cl);
! 568:
! 569: return (NULL);
! 570: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to altq_priq.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / altq