sys/contrib/altq/altq/altq_cbq.c

   1 /*      $FreeBSD$       */
   2 /*      $KAME: altq_cbq.c,v 1.19 2003/09/17 14:23:25 kjc 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 #if defined(__FreeBSD__) || defined(__NetBSD__)
  35 #include "opt_altq.h"
  36 #include "opt_inet.h"
  37 #ifdef __FreeBSD__
  38 #include "opt_inet6.h"
  39 #endif
  40 #endif /* __FreeBSD__ || __NetBSD__ */
  41 #ifdef ALTQ_CBQ /* cbq is enabled by ALTQ_CBQ option in opt_altq.h */
  42
  43 #include <sys/param.h>
  44 #include <sys/malloc.h>
  45 #include <sys/mbuf.h>
  46 #include <sys/socket.h>
  47 #include <sys/systm.h>
  48 #include <sys/proc.h>
  49 #include <sys/errno.h>
  50 #include <sys/time.h>
  51 #ifdef ALTQ3_COMPAT
  52 #include <sys/uio.h>
  53 #include <sys/kernel.h>
  54 #endif
  55
  56 #include <net/if.h>
  57 #include <net/if_var.h>
  58 #include <netinet/in.h>
  59
  60 #include <netpfil/pf/pf.h>
  61 #include <netpfil/pf/pf_altq.h>
  62 #include <netpfil/pf/pf_mtag.h>
  63 #include <altq/altq.h>
  64 #include <altq/altq_cbq.h>
  65 #ifdef ALTQ3_COMPAT
  66 #include <altq/altq_conf.h>
  67 #endif
  68
  69 #ifdef ALTQ3_COMPAT
  70 /*
  71  * Local Data structures.
  72  */
  73 static cbq_state_t *cbq_list = NULL;
  74 #endif
  75
  76 /*
  77  * Forward Declarations.
  78  */
  79 static int               cbq_class_destroy(cbq_state_t *, struct rm_class *);
  80 static struct rm_class  *clh_to_clp(cbq_state_t *, u_int32_t);
  81 static int               cbq_clear_interface(cbq_state_t *);
  82 static int               cbq_request(struct ifaltq *, int, void *);
  83 static int               cbq_enqueue(struct ifaltq *, struct mbuf *,
  84                              struct altq_pktattr *);
  85 static struct mbuf      *cbq_dequeue(struct ifaltq *, int);
  86 static void              cbqrestart(struct ifaltq *);
  87 static void              get_class_stats(class_stats_t *, struct rm_class *);
  88 static void              cbq_purge(cbq_state_t *);
  89 #ifdef ALTQ3_COMPAT
  90 static int      cbq_add_class(struct cbq_add_class *);
  91 static int      cbq_delete_class(struct cbq_delete_class *);
  92 static int      cbq_modify_class(struct cbq_modify_class *);
  93 static int      cbq_class_create(cbq_state_t *, struct cbq_add_class *,
  94                                  struct rm_class *, struct rm_class *);
  95 static int      cbq_clear_hierarchy(struct cbq_interface *);
  96 static int      cbq_set_enable(struct cbq_interface *, int);
  97 static int      cbq_ifattach(struct cbq_interface *);
  98 static int      cbq_ifdetach(struct cbq_interface *);
  99 static int      cbq_getstats(struct cbq_getstats *);
 100
 101 static int      cbq_add_filter(struct cbq_add_filter *);
 102 static int      cbq_delete_filter(struct cbq_delete_filter *);
 103 #endif /* ALTQ3_COMPAT */
 104
 105 /*
 106  * int
 107  * cbq_class_destroy(cbq_mod_state_t *, struct rm_class *) - This
 108  *      function destroys a given traffic class.  Before destroying
 109  *      the class, all traffic for that class is released.
 110  */
 111 static int
 112 cbq_class_destroy(cbq_state_t *cbqp, struct rm_class *cl)
 113 {
 114         int     i;
 115
 116         /* delete the class */
 117         rmc_delete_class(&cbqp->ifnp, cl);
 118
 119         /*
 120          * free the class handle
 121          */
 122         for (i = 0; i < CBQ_MAX_CLASSES; i++)
 123                 if (cbqp->cbq_class_tbl[i] == cl)
 124                         cbqp->cbq_class_tbl[i] = NULL;
 125
 126         if (cl == cbqp->ifnp.root_)
 127                 cbqp->ifnp.root_ = NULL;
 128         if (cl == cbqp->ifnp.default_)
 129                 cbqp->ifnp.default_ = NULL;
 130 #ifdef ALTQ3_COMPAT
 131         if (cl == cbqp->ifnp.ctl_)
 132                 cbqp->ifnp.ctl_ = NULL;
 133 #endif
 134         return (0);
 135 }
 136
 137 /* convert class handle to class pointer */
 138 static struct rm_class *
 139 clh_to_clp(cbq_state_t *cbqp, u_int32_t chandle)
 140 {
 141         int i;
 142         struct rm_class *cl;
 143
 144         if (chandle == 0)
 145                 return (NULL);
 146         /*
 147          * first, try optimistically the slot matching the lower bits of
 148          * the handle.  if it fails, do the linear table search.
 149          */
 150         i = chandle % CBQ_MAX_CLASSES;
 151         if ((cl = cbqp->cbq_class_tbl[i]) != NULL &&
 152             cl->stats_.handle == chandle)
 153                 return (cl);
 154         for (i = 0; i < CBQ_MAX_CLASSES; i++)
 155                 if ((cl = cbqp->cbq_class_tbl[i]) != NULL &&
 156                     cl->stats_.handle == chandle)
 157                         return (cl);
 158         return (NULL);
 159 }
 160
 161 static int
 162 cbq_clear_interface(cbq_state_t *cbqp)
 163 {
 164         int              again, i;
 165         struct rm_class *cl;
 166
 167 #ifdef ALTQ3_CLFIER_COMPAT
 168         /* free the filters for this interface */
 169         acc_discard_filters(&cbqp->cbq_classifier, NULL, 1);
 170 #endif
 171
 172         /* clear out the classes now */
 173         do {
 174                 again = 0;
 175                 for (i = 0; i < CBQ_MAX_CLASSES; i++) {
 176                         if ((cl = cbqp->cbq_class_tbl[i]) != NULL) {
 177                                 if (is_a_parent_class(cl))
 178                                         again++;
 179                                 else {
 180                                         cbq_class_destroy(cbqp, cl);
 181                                         cbqp->cbq_class_tbl[i] = NULL;
 182                                         if (cl == cbqp->ifnp.root_)
 183                                                 cbqp->ifnp.root_ = NULL;
 184                                         if (cl == cbqp->ifnp.default_)
 185                                                 cbqp->ifnp.default_ = NULL;
 186 #ifdef ALTQ3_COMPAT
 187                                         if (cl == cbqp->ifnp.ctl_)
 188                                                 cbqp->ifnp.ctl_ = NULL;
 189 #endif
 190                                 }
 191                         }
 192                 }
 193         } while (again);
 194
 195         return (0);
 196 }
 197
 198 static int
 199 cbq_request(struct ifaltq *ifq, int req, void *arg)
 200 {
 201         cbq_state_t     *cbqp = (cbq_state_t *)ifq->altq_disc;
 202
 203         IFQ_LOCK_ASSERT(ifq);
 204
 205         switch (req) {
 206         case ALTRQ_PURGE:
 207                 cbq_purge(cbqp);
 208                 break;
 209         }
 210         return (0);
 211 }
 212
 213 /* copy the stats info in rm_class to class_states_t */
 214 static void
 215 get_class_stats(class_stats_t *statsp, struct rm_class *cl)
 216 {
 217         statsp->xmit_cnt        = cl->stats_.xmit_cnt;
 218         statsp->drop_cnt        = cl->stats_.drop_cnt;
 219         statsp->over            = cl->stats_.over;
 220         statsp->borrows         = cl->stats_.borrows;
 221         statsp->overactions     = cl->stats_.overactions;
 222         statsp->delays          = cl->stats_.delays;
 223
 224         statsp->depth           = cl->depth_;
 225         statsp->priority        = cl->pri_;
 226         statsp->maxidle         = cl->maxidle_;
 227         statsp->minidle         = cl->minidle_;
 228         statsp->offtime         = cl->offtime_;
 229         statsp->qmax            = qlimit(cl->q_);
 230         statsp->ns_per_byte     = cl->ns_per_byte_;
 231         statsp->wrr_allot       = cl->w_allotment_;
 232         statsp->qcnt            = qlen(cl->q_);
 233         statsp->avgidle         = cl->avgidle_;
 234
 235         statsp->qtype           = qtype(cl->q_);
 236 #ifdef ALTQ_RED
 237         if (q_is_red(cl->q_))
 238                 red_getstats(cl->red_, &statsp->red[0]);
 239 #endif
 240 #ifdef ALTQ_RIO
 241         if (q_is_rio(cl->q_))
 242                 rio_getstats((rio_t *)cl->red_, &statsp->red[0]);
 243 #endif
 244 #ifdef ALTQ_CODEL
 245         if (q_is_codel(cl->q_))
 246                 codel_getstats(cl->codel_, &statsp->codel);
 247 #endif
 248 }
 249
 250 int
 251 cbq_pfattach(struct pf_altq *a)
 252 {
 253         struct ifnet    *ifp;
 254         int              s, error;
 255
 256         if ((ifp = ifunit(a->ifname)) == NULL || a->altq_disc == NULL)
 257                 return (EINVAL);
 258 #ifdef __NetBSD__
 259         s = splnet();
 260 #else
 261         s = splimp();
 262 #endif
 263         error = altq_attach(&ifp->if_snd, ALTQT_CBQ, a->altq_disc,
 264             cbq_enqueue, cbq_dequeue, cbq_request, NULL, NULL);
 265         splx(s);
 266         return (error);
 267 }
 268
 269 int
 270 cbq_add_altq(struct pf_altq *a)
 271 {
 272         cbq_state_t     *cbqp;
 273         struct ifnet    *ifp;
 274
 275         if ((ifp = ifunit(a->ifname)) == NULL)
 276                 return (EINVAL);
 277         if (!ALTQ_IS_READY(&ifp->if_snd))
 278                 return (ENODEV);
 279
 280         /* allocate and initialize cbq_state_t */
 281         cbqp = malloc(sizeof(cbq_state_t), M_DEVBUF, M_NOWAIT | M_ZERO);
 282         if (cbqp == NULL)
 283                 return (ENOMEM);
 284         CALLOUT_INIT(&cbqp->cbq_callout);
 285         cbqp->cbq_qlen = 0;
 286         cbqp->ifnp.ifq_ = &ifp->if_snd;     /* keep the ifq */
 287
 288         /* keep the state in pf_altq */
 289         a->altq_disc = cbqp;
 290
 291         return (0);
 292 }
 293
 294 int
 295 cbq_remove_altq(struct pf_altq *a)
 296 {
 297         cbq_state_t     *cbqp;
 298
 299         if ((cbqp = a->altq_disc) == NULL)
 300                 return (EINVAL);
 301         a->altq_disc = NULL;
 302
 303         cbq_clear_interface(cbqp);
 304
 305         if (cbqp->ifnp.default_)
 306                 cbq_class_destroy(cbqp, cbqp->ifnp.default_);
 307         if (cbqp->ifnp.root_)
 308                 cbq_class_destroy(cbqp, cbqp->ifnp.root_);
 309
 310         /* deallocate cbq_state_t */
 311         free(cbqp, M_DEVBUF);
 312
 313         return (0);
 314 }
 315
 316 int
 317 cbq_add_queue(struct pf_altq *a)
 318 {
 319         struct rm_class *borrow, *parent;
 320         cbq_state_t     *cbqp;
 321         struct rm_class *cl;
 322         struct cbq_opts *opts;
 323         int             i;
 324
 325         if ((cbqp = a->altq_disc) == NULL)
 326                 return (EINVAL);
 327         if (a->qid == 0)
 328                 return (EINVAL);
 329
 330         /*
 331          * find a free slot in the class table.  if the slot matching
 332          * the lower bits of qid is free, use this slot.  otherwise,
 333          * use the first free slot.
 334          */
 335         i = a->qid % CBQ_MAX_CLASSES;
 336         if (cbqp->cbq_class_tbl[i] != NULL) {
 337                 for (i = 0; i < CBQ_MAX_CLASSES; i++)
 338                         if (cbqp->cbq_class_tbl[i] == NULL)
 339                                 break;
 340                 if (i == CBQ_MAX_CLASSES)
 341                         return (EINVAL);
 342         }
 343
 344         opts = &a->pq_u.cbq_opts;
 345         /* check parameters */
 346         if (a->priority >= CBQ_MAXPRI)
 347                 return (EINVAL);
 348
 349         /* Get pointers to parent and borrow classes.  */
 350         parent = clh_to_clp(cbqp, a->parent_qid);
 351         if (opts->flags & CBQCLF_BORROW)
 352                 borrow = parent;
 353         else
 354                 borrow = NULL;
 355
 356         /*
 357          * A class must borrow from it's parent or it can not
 358          * borrow at all.  Hence, borrow can be null.
 359          */
 360         if (parent == NULL && (opts->flags & CBQCLF_ROOTCLASS) == 0) {
 361                 printf("cbq_add_queue: no parent class!\n");
 362                 return (EINVAL);
 363         }
 364
 365         if ((borrow != parent)  && (borrow != NULL)) {
 366                 printf("cbq_add_class: borrow class != parent\n");
 367                 return (EINVAL);
 368         }
 369
 370         /*
 371          * check parameters
 372          */
 373         switch (opts->flags & CBQCLF_CLASSMASK) {
 374         case CBQCLF_ROOTCLASS:
 375                 if (parent != NULL)
 376                         return (EINVAL);
 377                 if (cbqp->ifnp.root_)
 378                         return (EINVAL);
 379                 break;
 380         case CBQCLF_DEFCLASS:
 381                 if (cbqp->ifnp.default_)
 382                         return (EINVAL);
 383                 break;
 384         case 0:
 385                 if (a->qid == 0)
 386                         return (EINVAL);
 387                 break;
 388         default:
 389                 /* more than two flags bits set */
 390                 return (EINVAL);
 391         }
 392
 393         /*
 394          * create a class.  if this is a root class, initialize the
 395          * interface.
 396          */
 397         if ((opts->flags & CBQCLF_CLASSMASK) == CBQCLF_ROOTCLASS) {
 398                 rmc_init(cbqp->ifnp.ifq_, &cbqp->ifnp, opts->ns_per_byte,
 399                     cbqrestart, a->qlimit, RM_MAXQUEUED,
 400                     opts->maxidle, opts->minidle, opts->offtime,
 401                     opts->flags);
 402                 cl = cbqp->ifnp.root_;
 403         } else {
 404                 cl = rmc_newclass(a->priority,
 405                                   &cbqp->ifnp, opts->ns_per_byte,
 406                                   rmc_delay_action, a->qlimit, parent, borrow,
 407                                   opts->maxidle, opts->minidle, opts->offtime,
 408                                   opts->pktsize, opts->flags);
 409         }
 410         if (cl == NULL)
 411                 return (ENOMEM);
 412
 413         /* return handle to user space. */
 414         cl->stats_.handle = a->qid;
 415         cl->stats_.depth = cl->depth_;
 416
 417         /* save the allocated class */
 418         cbqp->cbq_class_tbl[i] = cl;
 419
 420         if ((opts->flags & CBQCLF_CLASSMASK) == CBQCLF_DEFCLASS)
 421                 cbqp->ifnp.default_ = cl;
 422
 423         return (0);
 424 }
 425
 426 int
 427 cbq_remove_queue(struct pf_altq *a)
 428 {
 429         struct rm_class *cl;
 430         cbq_state_t     *cbqp;
 431         int             i;
 432
 433         if ((cbqp = a->altq_disc) == NULL)
 434                 return (EINVAL);
 435
 436         if ((cl = clh_to_clp(cbqp, a->qid)) == NULL)
 437                 return (EINVAL);
 438
 439         /* if we are a parent class, then return an error. */
 440         if (is_a_parent_class(cl))
 441                 return (EINVAL);
 442
 443         /* delete the class */
 444         rmc_delete_class(&cbqp->ifnp, cl);
 445
 446         /*
 447          * free the class handle
 448          */
 449         for (i = 0; i < CBQ_MAX_CLASSES; i++)
 450                 if (cbqp->cbq_class_tbl[i] == cl) {
 451                         cbqp->cbq_class_tbl[i] = NULL;
 452                         if (cl == cbqp->ifnp.root_)
 453                                 cbqp->ifnp.root_ = NULL;
 454                         if (cl == cbqp->ifnp.default_)
 455                                 cbqp->ifnp.default_ = NULL;
 456                         break;
 457                 }
 458
 459         return (0);
 460 }
 461
 462 int
 463 cbq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes)
 464 {
 465         cbq_state_t     *cbqp;
 466         struct rm_class *cl;
 467         class_stats_t    stats;
 468         int              error = 0;
 469
 470         if ((cbqp = altq_lookup(a->ifname, ALTQT_CBQ)) == NULL)
 471                 return (EBADF);
 472
 473         if ((cl = clh_to_clp(cbqp, a->qid)) == NULL)
 474                 return (EINVAL);
 475
 476         if (*nbytes < sizeof(stats))
 477                 return (EINVAL);
 478
 479         get_class_stats(&stats, cl);
 480
 481         if ((error = copyout((caddr_t)&stats, ubuf, sizeof(stats))) != 0)
 482                 return (error);
 483         *nbytes = sizeof(stats);
 484         return (0);
 485 }
 486
 487 /*
 488  * int
 489  * cbq_enqueue(struct ifaltq *ifq, struct mbuf *m, struct altq_pktattr *pattr)
 490  *              - Queue data packets.
 491  *
 492  *      cbq_enqueue is set to ifp->if_altqenqueue and called by an upper
 493  *      layer (e.g. ether_output).  cbq_enqueue queues the given packet
 494  *      to the cbq, then invokes the driver's start routine.
 495  *
 496  *      Assumptions:    called in splimp
 497  *      Returns:        0 if the queueing is successful.
 498  *                      ENOBUFS if a packet dropping occurred as a result of
 499  *                      the queueing.
 500  */
 501
 502 static int
 503 cbq_enqueue(struct ifaltq *ifq, struct mbuf *m, struct altq_pktattr *pktattr)
 504 {
 505         cbq_state_t     *cbqp = (cbq_state_t *)ifq->altq_disc;
 506         struct rm_class *cl;
 507         struct pf_mtag  *t;
 508         int              len;
 509
 510         IFQ_LOCK_ASSERT(ifq);
 511
 512         /* grab class set by classifier */
 513         if ((m->m_flags & M_PKTHDR) == 0) {
 514                 /* should not happen */
 515                 printf("altq: packet for %s does not have pkthdr\n",
 516                     ifq->altq_ifp->if_xname);
 517                 m_freem(m);
 518                 return (ENOBUFS);
 519         }
 520         cl = NULL;
 521         if ((t = pf_find_mtag(m)) != NULL)
 522                 cl = clh_to_clp(cbqp, t->qid);
 523 #ifdef ALTQ3_COMPAT
 524         else if ((ifq->altq_flags & ALTQF_CLASSIFY) && pktattr != NULL)
 525                 cl = pktattr->pattr_class;
 526 #endif
 527         if (cl == NULL) {
 528                 cl = cbqp->ifnp.default_;
 529                 if (cl == NULL) {
 530                         m_freem(m);
 531                         return (ENOBUFS);
 532                 }
 533         }
 534 #ifdef ALTQ3_COMPAT
 535         if (pktattr != NULL)
 536                 cl->pktattr_ = pktattr;  /* save proto hdr used by ECN */
 537         else
 538 #endif
 539                 cl->pktattr_ = NULL;
 540         len = m_pktlen(m);
 541         if (rmc_queue_packet(cl, m) != 0) {
 542                 /* drop occurred.  some mbuf was freed in rmc_queue_packet. */
 543                 PKTCNTR_ADD(&cl->stats_.drop_cnt, len);
 544                 return (ENOBUFS);
 545         }
 546
 547         /* successfully queued. */
 548         ++cbqp->cbq_qlen;
 549         IFQ_INC_LEN(ifq);
 550         return (0);
 551 }
 552
 553 static struct mbuf *
 554 cbq_dequeue(struct ifaltq *ifq, int op)
 555 {
 556         cbq_state_t     *cbqp = (cbq_state_t *)ifq->altq_disc;
 557         struct mbuf     *m;
 558
 559         IFQ_LOCK_ASSERT(ifq);
 560
 561         m = rmc_dequeue_next(&cbqp->ifnp, op);
 562
 563         if (m && op == ALTDQ_REMOVE) {
 564                 --cbqp->cbq_qlen;  /* decrement # of packets in cbq */
 565                 IFQ_DEC_LEN(ifq);
 566
 567                 /* Update the class. */
 568                 rmc_update_class_util(&cbqp->ifnp);
 569         }
 570         return (m);
 571 }
 572
 573 /*
 574  * void
 575  * cbqrestart(queue_t *) - Restart sending of data.
 576  * called from rmc_restart in splimp via timeout after waking up
 577  * a suspended class.
 578  *      Returns:        NONE
 579  */
 580
 581 static void
 582 cbqrestart(struct ifaltq *ifq)
 583 {
 584         cbq_state_t     *cbqp;
 585         struct ifnet    *ifp;
 586
 587         IFQ_LOCK_ASSERT(ifq);
 588
 589         if (!ALTQ_IS_ENABLED(ifq))
 590                 /* cbq must have been detached */
 591                 return;
 592
 593         if ((cbqp = (cbq_state_t *)ifq->altq_disc) == NULL)
 594                 /* should not happen */
 595                 return;
 596
 597         ifp = ifq->altq_ifp;
 598         if (ifp->if_start &&
 599             cbqp->cbq_qlen > 0 && (ifp->if_drv_flags & IFF_DRV_OACTIVE) == 0) {
 600                 IFQ_UNLOCK(ifq);
 601                 (*ifp->if_start)(ifp);
 602                 IFQ_LOCK(ifq);
 603         }
 604 }
 605
 606 static void cbq_purge(cbq_state_t *cbqp)
 607 {
 608         struct rm_class *cl;
 609         int              i;
 610
 611         for (i = 0; i < CBQ_MAX_CLASSES; i++)
 612                 if ((cl = cbqp->cbq_class_tbl[i]) != NULL)
 613                         rmc_dropall(cl);
 614         if (ALTQ_IS_ENABLED(cbqp->ifnp.ifq_))
 615                 cbqp->ifnp.ifq_->ifq_len = 0;
 616 }
 617 #ifdef ALTQ3_COMPAT
 618
 619 static int
 620 cbq_add_class(acp)
 621         struct cbq_add_class *acp;
 622 {
 623         char            *ifacename;
 624         struct rm_class *borrow, *parent;
 625         cbq_state_t     *cbqp;
 626
 627         ifacename = acp->cbq_iface.cbq_ifacename;
 628         if ((cbqp = altq_lookup(ifacename, ALTQT_CBQ)) == NULL)
 629                 return (EBADF);
 630
 631         /* check parameters */
 632         if (acp->cbq_class.priority >= CBQ_MAXPRI ||
 633             acp->cbq_class.maxq > CBQ_MAXQSIZE)
 634                 return (EINVAL);
 635
 636         /* Get pointers to parent and borrow classes.  */
 637         parent = clh_to_clp(cbqp, acp->cbq_class.parent_class_handle);
 638         borrow = clh_to_clp(cbqp, acp->cbq_class.borrow_class_handle);
 639
 640         /*
 641          * A class must borrow from it's parent or it can not
 642          * borrow at all.  Hence, borrow can be null.
 643          */
 644         if (parent == NULL && (acp->cbq_class.flags & CBQCLF_ROOTCLASS) == 0) {
 645                 printf("cbq_add_class: no parent class!\n");
 646                 return (EINVAL);
 647         }
 648
 649         if ((borrow != parent)  && (borrow != NULL)) {
 650                 printf("cbq_add_class: borrow class != parent\n");
 651                 return (EINVAL);
 652         }
 653
 654         return cbq_class_create(cbqp, acp, parent, borrow);
 655 }
 656
 657 static int
 658 cbq_delete_class(dcp)
 659         struct cbq_delete_class *dcp;
 660 {
 661         char            *ifacename;
 662         struct rm_class *cl;
 663         cbq_state_t     *cbqp;
 664
 665         ifacename = dcp->cbq_iface.cbq_ifacename;
 666         if ((cbqp = altq_lookup(ifacename, ALTQT_CBQ)) == NULL)
 667                 return (EBADF);
 668
 669         if ((cl = clh_to_clp(cbqp, dcp->cbq_class_handle)) == NULL)
 670                 return (EINVAL);
 671
 672         /* if we are a parent class, then return an error. */
 673         if (is_a_parent_class(cl))
 674                 return (EINVAL);
 675
 676         /* if a filter has a reference to this class delete the filter */
 677         acc_discard_filters(&cbqp->cbq_classifier, cl, 0);
 678
 679         return cbq_class_destroy(cbqp, cl);
 680 }
 681
 682 static int
 683 cbq_modify_class(acp)
 684         struct cbq_modify_class *acp;
 685 {
 686         char            *ifacename;
 687         struct rm_class *cl;
 688         cbq_state_t     *cbqp;
 689
 690         ifacename = acp->cbq_iface.cbq_ifacename;
 691         if ((cbqp = altq_lookup(ifacename, ALTQT_CBQ)) == NULL)
 692                 return (EBADF);
 693
 694         /* Get pointer to this class */
 695         if ((cl = clh_to_clp(cbqp, acp->cbq_class_handle)) == NULL)
 696                 return (EINVAL);
 697
 698         if (rmc_modclass(cl, acp->cbq_class.nano_sec_per_byte,
 699                          acp->cbq_class.maxq, acp->cbq_class.maxidle,
 700                          acp->cbq_class.minidle, acp->cbq_class.offtime,
 701                          acp->cbq_class.pktsize) < 0)
 702                 return (EINVAL);
 703         return (0);
 704 }
 705
 706 /*
 707  * struct rm_class *
 708  * cbq_class_create(cbq_mod_state_t *cbqp, struct cbq_add_class *acp,
 709  *              struct rm_class *parent, struct rm_class *borrow)
 710  *
 711  * This function create a new traffic class in the CBQ class hierarchy of
 712  * given paramters.  The class that created is either the root, default,
 713  * or a new dynamic class.  If CBQ is not initilaized, the the root class
 714  * will be created.
 715  */
 716 static int
 717 cbq_class_create(cbqp, acp, parent, borrow)
 718         cbq_state_t *cbqp;
 719         struct cbq_add_class *acp;
 720         struct rm_class *parent, *borrow;
 721 {
 722         struct rm_class *cl;
 723         cbq_class_spec_t *spec = &acp->cbq_class;
 724         u_int32_t       chandle;
 725         int             i;
 726
 727         /*
 728          * allocate class handle
 729          */
 730         for (i = 1; i < CBQ_MAX_CLASSES; i++)
 731                 if (cbqp->cbq_class_tbl[i] == NULL)
 732                         break;
 733         if (i == CBQ_MAX_CLASSES)
 734                 return (EINVAL);
 735         chandle = i;    /* use the slot number as class handle */
 736
 737         /*
 738          * create a class.  if this is a root class, initialize the
 739          * interface.
 740          */
 741         if ((spec->flags & CBQCLF_CLASSMASK) == CBQCLF_ROOTCLASS) {
 742                 rmc_init(cbqp->ifnp.ifq_, &cbqp->ifnp, spec->nano_sec_per_byte,
 743                          cbqrestart, spec->maxq, RM_MAXQUEUED,
 744                          spec->maxidle, spec->minidle, spec->offtime,
 745                          spec->flags);
 746                 cl = cbqp->ifnp.root_;
 747         } else {
 748                 cl = rmc_newclass(spec->priority,
 749                                   &cbqp->ifnp, spec->nano_sec_per_byte,
 750                                   rmc_delay_action, spec->maxq, parent, borrow,
 751                                   spec->maxidle, spec->minidle, spec->offtime,
 752                                   spec->pktsize, spec->flags);
 753         }
 754         if (cl == NULL)
 755                 return (ENOMEM);
 756
 757         /* return handle to user space. */
 758         acp->cbq_class_handle = chandle;
 759
 760         cl->stats_.handle = chandle;
 761         cl->stats_.depth = cl->depth_;
 762
 763         /* save the allocated class */
 764         cbqp->cbq_class_tbl[i] = cl;
 765
 766         if ((spec->flags & CBQCLF_CLASSMASK) == CBQCLF_DEFCLASS)
 767                 cbqp->ifnp.default_ = cl;
 768         if ((spec->flags & CBQCLF_CLASSMASK) == CBQCLF_CTLCLASS)
 769                 cbqp->ifnp.ctl_ = cl;
 770
 771         return (0);
 772 }
 773
 774 static int
 775 cbq_add_filter(afp)
 776         struct cbq_add_filter *afp;
 777 {
 778         char            *ifacename;
 779         cbq_state_t     *cbqp;
 780         struct rm_class *cl;
 781
 782         ifacename = afp->cbq_iface.cbq_ifacename;
 783         if ((cbqp = altq_lookup(ifacename, ALTQT_CBQ)) == NULL)
 784                 return (EBADF);
 785
 786         /* Get the pointer to class. */
 787         if ((cl = clh_to_clp(cbqp, afp->cbq_class_handle)) == NULL)
 788                 return (EINVAL);
 789
 790         return acc_add_filter(&cbqp->cbq_classifier, &afp->cbq_filter,
 791                               cl, &afp->cbq_filter_handle);
 792 }
 793
 794 static int
 795 cbq_delete_filter(dfp)
 796         struct cbq_delete_filter *dfp;
 797 {
 798         char            *ifacename;
 799         cbq_state_t     *cbqp;
 800
 801         ifacename = dfp->cbq_iface.cbq_ifacename;
 802         if ((cbqp = altq_lookup(ifacename, ALTQT_CBQ)) == NULL)
 803                 return (EBADF);
 804
 805         return acc_delete_filter(&cbqp->cbq_classifier,
 806                                  dfp->cbq_filter_handle);
 807 }
 808
 809 /*
 810  * cbq_clear_hierarchy deletes all classes and their filters on the
 811  * given interface.
 812  */
 813 static int
 814 cbq_clear_hierarchy(ifacep)
 815         struct cbq_interface *ifacep;
 816 {
 817         char            *ifacename;
 818         cbq_state_t     *cbqp;
 819
 820         ifacename = ifacep->cbq_ifacename;
 821         if ((cbqp = altq_lookup(ifacename, ALTQT_CBQ)) == NULL)
 822                 return (EBADF);
 823
 824         return cbq_clear_interface(cbqp);
 825 }
 826
 827 /*
 828  * static int
 829  * cbq_set_enable(struct cbq_enable *ep) - this function processed the
 830  *      ioctl request to enable class based queueing.  It searches the list
 831  *      of interfaces for the specified interface and then enables CBQ on
 832  *      that interface.
 833  *
 834  *      Returns:        0, for no error.
 835  *                      EBADF, for specified inteface not found.
 836  */
 837
 838 static int
 839 cbq_set_enable(ep, enable)
 840         struct cbq_interface *ep;
 841         int enable;
 842 {
 843         int     error = 0;
 844         cbq_state_t     *cbqp;
 845         char    *ifacename;
 846
 847         ifacename = ep->cbq_ifacename;
 848         if ((cbqp = altq_lookup(ifacename, ALTQT_CBQ)) == NULL)
 849                 return (EBADF);
 850
 851         switch (enable) {
 852         case ENABLE:
 853                 if (cbqp->ifnp.root_ == NULL || cbqp->ifnp.default_ == NULL ||
 854                     cbqp->ifnp.ctl_ == NULL) {
 855                         if (cbqp->ifnp.root_ == NULL)
 856                                 printf("No Root Class for %s\n", ifacename);
 857                         if (cbqp->ifnp.default_ == NULL)
 858                                 printf("No Default Class for %s\n", ifacename);
 859                         if (cbqp->ifnp.ctl_ == NULL)
 860                                 printf("No Control Class for %s\n", ifacename);
 861                         error = EINVAL;
 862                 } else if ((error = altq_enable(cbqp->ifnp.ifq_)) == 0) {
 863                         cbqp->cbq_qlen = 0;
 864                 }
 865                 break;
 866
 867         case DISABLE:
 868                 error = altq_disable(cbqp->ifnp.ifq_);
 869                 break;
 870         }
 871         return (error);
 872 }
 873
 874 static int
 875 cbq_getstats(gsp)
 876         struct cbq_getstats *gsp;
 877 {
 878         char            *ifacename;
 879         int             i, n, nclasses;
 880         cbq_state_t     *cbqp;
 881         struct rm_class *cl;
 882         class_stats_t   stats, *usp;
 883         int error = 0;
 884
 885         ifacename = gsp->iface.cbq_ifacename;
 886         nclasses = gsp->nclasses;
 887         usp = gsp->stats;
 888
 889         if ((cbqp = altq_lookup(ifacename, ALTQT_CBQ)) == NULL)
 890                 return (EBADF);
 891         if (nclasses <= 0)
 892                 return (EINVAL);
 893
 894         for (n = 0, i = 0; n < nclasses && i < CBQ_MAX_CLASSES; n++, i++) {
 895                 while ((cl = cbqp->cbq_class_tbl[i]) == NULL)
 896                         if (++i >= CBQ_MAX_CLASSES)
 897                                 goto out;
 898
 899                 get_class_stats(&stats, cl);
 900                 stats.handle = cl->stats_.handle;
 901
 902                 if ((error = copyout((caddr_t)&stats, (caddr_t)usp++,
 903                     sizeof(stats))) != 0)
 904                         return (error);
 905         }
 906
 907  out:
 908         gsp->nclasses = n;
 909         return (error);
 910 }
 911
 912 static int
 913 cbq_ifattach(ifacep)
 914         struct cbq_interface *ifacep;
 915 {
 916         int             error = 0;
 917         char            *ifacename;
 918         cbq_state_t     *new_cbqp;
 919         struct ifnet    *ifp;
 920
 921         ifacename = ifacep->cbq_ifacename;
 922         if ((ifp = ifunit(ifacename)) == NULL)
 923                 return (ENXIO);
 924         if (!ALTQ_IS_READY(&ifp->if_snd))
 925                 return (ENXIO);
 926
 927         /* allocate and initialize cbq_state_t */
 928         new_cbqp = malloc(sizeof(cbq_state_t), M_DEVBUF, M_WAITOK);
 929         if (new_cbqp == NULL)
 930                 return (ENOMEM);
 931         bzero(new_cbqp, sizeof(cbq_state_t));
 932         CALLOUT_INIT(&new_cbqp->cbq_callout);
 933
 934         new_cbqp->cbq_qlen = 0;
 935         new_cbqp->ifnp.ifq_ = &ifp->if_snd;         /* keep the ifq */
 936
 937         /*
 938          * set CBQ to this ifnet structure.
 939          */
 940         error = altq_attach(&ifp->if_snd, ALTQT_CBQ, new_cbqp,
 941                             cbq_enqueue, cbq_dequeue, cbq_request,
 942                             &new_cbqp->cbq_classifier, acc_classify);
 943         if (error) {
 944                 free(new_cbqp, M_DEVBUF);
 945                 return (error);
 946         }
 947
 948         /* prepend to the list of cbq_state_t's. */
 949         new_cbqp->cbq_next = cbq_list;
 950         cbq_list = new_cbqp;
 951
 952         return (0);
 953 }
 954
 955 static int
 956 cbq_ifdetach(ifacep)
 957         struct cbq_interface *ifacep;
 958 {
 959         char            *ifacename;
 960         cbq_state_t     *cbqp;
 961
 962         ifacename = ifacep->cbq_ifacename;
 963         if ((cbqp = altq_lookup(ifacename, ALTQT_CBQ)) == NULL)
 964                 return (EBADF);
 965
 966         (void)cbq_set_enable(ifacep, DISABLE);
 967
 968         cbq_clear_interface(cbqp);
 969
 970         /* remove CBQ from the ifnet structure. */
 971         (void)altq_detach(cbqp->ifnp.ifq_);
 972
 973         /* remove from the list of cbq_state_t's. */
 974         if (cbq_list == cbqp)
 975                 cbq_list = cbqp->cbq_next;
 976         else {
 977                 cbq_state_t *cp;
 978
 979                 for (cp = cbq_list; cp != NULL; cp = cp->cbq_next)
 980                         if (cp->cbq_next == cbqp) {
 981                                 cp->cbq_next = cbqp->cbq_next;
 982                                 break;
 983                         }
 984                 ASSERT(cp != NULL);
 985         }
 986
 987         /* deallocate cbq_state_t */
 988         free(cbqp, M_DEVBUF);
 989
 990         return (0);
 991 }
 992
 993 /*
 994  * cbq device interface
 995  */
 996
 997 altqdev_decl(cbq);
 998
 999 int
1000 cbqopen(dev, flag, fmt, p)
1001         dev_t dev;
1002         int flag, fmt;
1003 #if (__FreeBSD_version > 500000)
1004         struct thread *p;
1005 #else
1006         struct proc *p;
1007 #endif
1008 {
1009         return (0);
1010 }
1011
1012 int
1013 cbqclose(dev, flag, fmt, p)
1014         dev_t dev;
1015         int flag, fmt;
1016 #if (__FreeBSD_version > 500000)
1017         struct thread *p;
1018 #else
1019         struct proc *p;
1020 #endif
1021 {
1022         struct ifnet *ifp;
1023         struct cbq_interface iface;
1024         int err, error = 0;
1025
1026         while (cbq_list) {
1027                 ifp = cbq_list->ifnp.ifq_->altq_ifp;
1028                 sprintf(iface.cbq_ifacename, "%s", ifp->if_xname);
1029                 err = cbq_ifdetach(&iface);
1030                 if (err != 0 && error == 0)
1031                         error = err;
1032         }
1033
1034         return (error);
1035 }
1036
1037 int
1038 cbqioctl(dev, cmd, addr, flag, p)
1039         dev_t dev;
1040         ioctlcmd_t cmd;
1041         caddr_t addr;
1042         int flag;
1043 #if (__FreeBSD_version > 500000)
1044         struct thread *p;
1045 #else
1046         struct proc *p;
1047 #endif
1048 {
1049         int     error = 0;
1050
1051         /* check cmd for superuser only */
1052         switch (cmd) {
1053         case CBQ_GETSTATS:
1054                 /* currently only command that an ordinary user can call */
1055                 break;
1056         default:
1057 #if (__FreeBSD_version > 700000)
1058                 error = priv_check(p, PRIV_ALTQ_MANAGE);
1059 #elsif (__FreeBSD_version > 400000)
1060                 error = suser(p);
1061 #else
1062                 error = suser(p->p_ucred, &p->p_acflag);
1063 #endif
1064                 if (error)
1065                         return (error);
1066                 break;
1067         }
1068
1069         switch (cmd) {
1070
1071         case CBQ_ENABLE:
1072                 error = cbq_set_enable((struct cbq_interface *)addr, ENABLE);
1073                 break;
1074
1075         case CBQ_DISABLE:
1076                 error = cbq_set_enable((struct cbq_interface *)addr, DISABLE);
1077                 break;
1078
1079         case CBQ_ADD_FILTER:
1080                 error = cbq_add_filter((struct cbq_add_filter *)addr);
1081                 break;
1082
1083         case CBQ_DEL_FILTER:
1084                 error = cbq_delete_filter((struct cbq_delete_filter *)addr);
1085                 break;
1086
1087         case CBQ_ADD_CLASS:
1088                 error = cbq_add_class((struct cbq_add_class *)addr);
1089                 break;
1090
1091         case CBQ_DEL_CLASS:
1092                 error = cbq_delete_class((struct cbq_delete_class *)addr);
1093                 break;
1094
1095         case CBQ_MODIFY_CLASS:
1096                 error = cbq_modify_class((struct cbq_modify_class *)addr);
1097                 break;
1098
1099         case CBQ_CLEAR_HIERARCHY:
1100                 error = cbq_clear_hierarchy((struct cbq_interface *)addr);
1101                 break;
1102
1103         case CBQ_IF_ATTACH:
1104                 error = cbq_ifattach((struct cbq_interface *)addr);
1105                 break;
1106
1107         case CBQ_IF_DETACH:
1108                 error = cbq_ifdetach((struct cbq_interface *)addr);
1109                 break;
1110
1111         case CBQ_GETSTATS:
1112                 error = cbq_getstats((struct cbq_getstats *)addr);
1113                 break;
1114
1115         default:
1116                 error = EINVAL;
1117                 break;
1118         }
1119
1120         return error;
1121 }
1122
1123 #if 0
1124 /* for debug */
1125 static void cbq_class_dump(int);
1126
1127 static void cbq_class_dump(i)
1128         int i;
1129 {
1130         struct rm_class *cl;
1131         rm_class_stats_t *s;
1132         struct _class_queue_ *q;
1133
1134         if (cbq_list == NULL) {
1135                 printf("cbq_class_dump: no cbq_state found\n");
1136                 return;
1137         }
1138         cl = cbq_list->cbq_class_tbl[i];
1139
1140         printf("class %d cl=%p\n", i, cl);
1141         if (cl != NULL) {
1142                 s = &cl->stats_;
1143                 q = cl->q_;
1144
1145                 printf("pri=%d, depth=%d, maxrate=%d, allotment=%d\n",
1146                        cl->pri_, cl->depth_, cl->maxrate_, cl->allotment_);
1147                 printf("w_allotment=%d, bytes_alloc=%d, avgidle=%d, maxidle=%d\n",
1148                        cl->w_allotment_, cl->bytes_alloc_, cl->avgidle_,
1149                        cl->maxidle_);
1150                 printf("minidle=%d, offtime=%d, sleeping=%d, leaf=%d\n",
1151                        cl->minidle_, cl->offtime_, cl->sleeping_, cl->leaf_);
1152                 printf("handle=%d, depth=%d, packets=%d, bytes=%d\n",
1153                        s->handle, s->depth,
1154                        (int)s->xmit_cnt.packets, (int)s->xmit_cnt.bytes);
1155                 printf("over=%d\n, borrows=%d, drops=%d, overactions=%d, delays=%d\n",
1156                        s->over, s->borrows, (int)s->drop_cnt.packets,
1157                        s->overactions, s->delays);
1158                 printf("tail=%p, head=%p, qlen=%d, qlim=%d, qthresh=%d,qtype=%d\n",
1159                        q->tail_, q->head_, q->qlen_, q->qlim_,
1160                        q->qthresh_, q->qtype_);
1161         }
1162 }
1163 #endif /* 0 */
1164
1165 #ifdef KLD_MODULE
1166
1167 static struct altqsw cbq_sw =
1168         {"cbq", cbqopen, cbqclose, cbqioctl};
1169
1170 ALTQ_MODULE(altq_cbq, ALTQT_CBQ, &cbq_sw);
1171 MODULE_DEPEND(altq_cbq, altq_red, 1, 1, 1);
1172 MODULE_DEPEND(altq_cbq, altq_rio, 1, 1, 1);
1173
1174 #endif /* KLD_MODULE */
1175 #endif /* ALTQ3_COMPAT */
1176
1177 #endif /* ALTQ_CBQ */