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