cl 75 altq/altq_cbq.c rmc_delete_class(&cbqp->ifnp, cl);
cl 81 altq/altq_cbq.c if (cbqp->cbq_class_tbl[i] == cl)
cl 84 altq/altq_cbq.c if (cl == cbqp->ifnp.root_)
cl 86 altq/altq_cbq.c if (cl == cbqp->ifnp.default_)
cl 96 altq/altq_cbq.c struct rm_class *cl;
cl 105 altq/altq_cbq.c if ((cl = cbqp->cbq_class_tbl[i]) != NULL &&
cl 106 altq/altq_cbq.c cl->stats_.handle == chandle)
cl 107 altq/altq_cbq.c return (cl);
cl 109 altq/altq_cbq.c if ((cl = cbqp->cbq_class_tbl[i]) != NULL &&
cl 110 altq/altq_cbq.c cl->stats_.handle == chandle)
cl 111 altq/altq_cbq.c return (cl);
cl 119 altq/altq_cbq.c struct rm_class *cl;
cl 125 altq/altq_cbq.c if ((cl = cbqp->cbq_class_tbl[i]) != NULL) {
cl 126 altq/altq_cbq.c if (is_a_parent_class(cl))
cl 129 altq/altq_cbq.c cbq_class_destroy(cbqp, cl);
cl 131 altq/altq_cbq.c if (cl == cbqp->ifnp.root_)
cl 133 altq/altq_cbq.c if (cl == cbqp->ifnp.default_)
cl 160 altq/altq_cbq.c statsp->handle = cl->stats_.handle;
cl 161 altq/altq_cbq.c statsp->xmit_cnt = cl->stats_.xmit_cnt;
cl 162 altq/altq_cbq.c statsp->drop_cnt = cl->stats_.drop_cnt;
cl 163 altq/altq_cbq.c statsp->over = cl->stats_.over;
cl 164 altq/altq_cbq.c statsp->borrows = cl->stats_.borrows;
cl 165 altq/altq_cbq.c statsp->overactions = cl->stats_.overactions;
cl 166 altq/altq_cbq.c statsp->delays = cl->stats_.delays;
cl 168 altq/altq_cbq.c statsp->depth = cl->depth_;
cl 169 altq/altq_cbq.c statsp->priority = cl->pri_;
cl 170 altq/altq_cbq.c statsp->maxidle = cl->maxidle_;
cl 171 altq/altq_cbq.c statsp->minidle = cl->minidle_;
cl 172 altq/altq_cbq.c statsp->offtime = cl->offtime_;
cl 173 altq/altq_cbq.c statsp->qmax = qlimit(cl->q_);
cl 174 altq/altq_cbq.c statsp->ns_per_byte = cl->ns_per_byte_;
cl 175 altq/altq_cbq.c statsp->wrr_allot = cl->w_allotment_;
cl 176 altq/altq_cbq.c statsp->qcnt = qlen(cl->q_);
cl 177 altq/altq_cbq.c statsp->avgidle = cl->avgidle_;
cl 179 altq/altq_cbq.c statsp->qtype = qtype(cl->q_);
cl 181 altq/altq_cbq.c if (q_is_red(cl->q_))
cl 182 altq/altq_cbq.c red_getstats(cl->red_, &statsp->red[0]);
cl 185 altq/altq_cbq.c if (q_is_rio(cl->q_))
cl 186 altq/altq_cbq.c rio_getstats((rio_t *)cl->red_, &statsp->red[0]);
cl 258 altq/altq_cbq.c struct rm_class *cl;
cl 339 altq/altq_cbq.c cl = cbqp->ifnp.root_;
cl 341 altq/altq_cbq.c cl = rmc_newclass(a->priority,
cl 347 altq/altq_cbq.c if (cl == NULL)
cl 351 altq/altq_cbq.c cl->stats_.handle = a->qid;
cl 352 altq/altq_cbq.c cl->stats_.depth = cl->depth_;
cl 355 altq/altq_cbq.c cbqp->cbq_class_tbl[i] = cl;
cl 358 altq/altq_cbq.c cbqp->ifnp.default_ = cl;
cl 366 altq/altq_cbq.c struct rm_class *cl;
cl 373 altq/altq_cbq.c if ((cl = clh_to_clp(cbqp, a->qid)) == NULL)
cl 377 altq/altq_cbq.c if (is_a_parent_class(cl))
cl 381 altq/altq_cbq.c rmc_delete_class(&cbqp->ifnp, cl);
cl 387 altq/altq_cbq.c if (cbqp->cbq_class_tbl[i] == cl) {
cl 389 altq/altq_cbq.c if (cl == cbqp->ifnp.root_)
cl 391 altq/altq_cbq.c if (cl == cbqp->ifnp.default_)
cl 403 altq/altq_cbq.c struct rm_class *cl;
cl 410 altq/altq_cbq.c if ((cl = clh_to_clp(cbqp, a->qid)) == NULL)
cl 416 altq/altq_cbq.c get_class_stats(&stats, cl);
cl 443 altq/altq_cbq.c struct rm_class *cl;
cl 454 altq/altq_cbq.c if ((cl = clh_to_clp(cbqp, m->m_pkthdr.pf.qid)) == NULL) {
cl 455 altq/altq_cbq.c cl = cbqp->ifnp.default_;
cl 456 altq/altq_cbq.c if (cl == NULL) {
cl 460 altq/altq_cbq.c cl->pktattr_ = NULL;
cl 464 altq/altq_cbq.c if (rmc_queue_packet(cl, m) != 0) {
cl 466 altq/altq_cbq.c PKTCNTR_ADD(&cl->stats_.drop_cnt, len);
cl 524 altq/altq_cbq.c struct rm_class *cl;
cl 528 altq/altq_cbq.c if ((cl = cbqp->cbq_class_tbl[i]) != NULL)
cl 529 altq/altq_cbq.c rmc_dropall(cl);
cl 127 altq/altq_hfsc.c #define is_a_parent_class(cl) ((cl)->cl_children != NULL)
cl 200 altq/altq_hfsc.c struct hfsc_class *cl, *parent;
cl 231 altq/altq_hfsc.c cl = hfsc_class_create(hif, &rtsc, &lssc, &ulsc,
cl 233 altq/altq_hfsc.c if (cl == NULL)
cl 243 altq/altq_hfsc.c struct hfsc_class *cl;
cl 248 altq/altq_hfsc.c if ((cl = clh_to_clp(hif, a->qid)) == NULL)
cl 251 altq/altq_hfsc.c return (hfsc_class_destroy(cl));
cl 258 altq/altq_hfsc.c struct hfsc_class *cl;
cl 265 altq/altq_hfsc.c if ((cl = clh_to_clp(hif, a->qid)) == NULL)
cl 271 altq/altq_hfsc.c get_class_stats(&stats, cl);
cl 286 altq/altq_hfsc.c struct hfsc_class *cl;
cl 290 altq/altq_hfsc.c (cl = hif->hif_rootclass->cl_children) != NULL) {
cl 295 altq/altq_hfsc.c for (; cl != NULL; cl = hfsc_nextclass(cl)) {
cl 296 altq/altq_hfsc.c if (!is_a_parent_class(cl)) {
cl 297 altq/altq_hfsc.c (void)hfsc_class_destroy(cl);
cl 323 altq/altq_hfsc.c struct hfsc_class *cl;
cl 325 altq/altq_hfsc.c for (cl = hif->hif_rootclass; cl != NULL; cl = hfsc_nextclass(cl))
cl 326 altq/altq_hfsc.c if (!qempty(cl->cl_q))
cl 327 altq/altq_hfsc.c hfsc_purgeq(cl);
cl 337 altq/altq_hfsc.c struct hfsc_class *cl, *p;
cl 352 altq/altq_hfsc.c MALLOC(cl, struct hfsc_class *, sizeof(struct hfsc_class),
cl 354 altq/altq_hfsc.c if (cl == NULL)
cl 356 altq/altq_hfsc.c bzero(cl, sizeof(struct hfsc_class));
cl 358 altq/altq_hfsc.c MALLOC(cl->cl_q, class_queue_t *, sizeof(class_queue_t),
cl 360 altq/altq_hfsc.c if (cl->cl_q == NULL)
cl 362 altq/altq_hfsc.c bzero(cl->cl_q, sizeof(class_queue_t));
cl 364 altq/altq_hfsc.c cl->cl_actc = actlist_alloc();
cl 365 altq/altq_hfsc.c if (cl->cl_actc == NULL)
cl 370 altq/altq_hfsc.c qlimit(cl->cl_q) = qlimit;
cl 371 altq/altq_hfsc.c qtype(cl->cl_q) = Q_DROPTAIL;
cl 372 altq/altq_hfsc.c qlen(cl->cl_q) = 0;
cl 373 altq/altq_hfsc.c cl->cl_flags = flags;
cl 400 altq/altq_hfsc.c cl->cl_red = red_alloc(0, 0,
cl 401 altq/altq_hfsc.c qlimit(cl->cl_q) * 10/100,
cl 402 altq/altq_hfsc.c qlimit(cl->cl_q) * 30/100,
cl 404 altq/altq_hfsc.c if (cl->cl_red != NULL)
cl 405 altq/altq_hfsc.c qtype(cl->cl_q) = Q_RED;
cl 409 altq/altq_hfsc.c cl->cl_red = (red_t *)rio_alloc(0, NULL,
cl 411 altq/altq_hfsc.c if (cl->cl_red != NULL)
cl 412 altq/altq_hfsc.c qtype(cl->cl_q) = Q_RIO;
cl 419 altq/altq_hfsc.c MALLOC(cl->cl_rsc, struct internal_sc *,
cl 421 altq/altq_hfsc.c if (cl->cl_rsc == NULL)
cl 423 altq/altq_hfsc.c sc2isc(rsc, cl->cl_rsc);
cl 424 altq/altq_hfsc.c rtsc_init(&cl->cl_deadline, cl->cl_rsc, 0, 0);
cl 425 altq/altq_hfsc.c rtsc_init(&cl->cl_eligible, cl->cl_rsc, 0, 0);
cl 428 altq/altq_hfsc.c MALLOC(cl->cl_fsc, struct internal_sc *,
cl 430 altq/altq_hfsc.c if (cl->cl_fsc == NULL)
cl 432 altq/altq_hfsc.c sc2isc(fsc, cl->cl_fsc);
cl 433 altq/altq_hfsc.c rtsc_init(&cl->cl_virtual, cl->cl_fsc, 0, 0);
cl 436 altq/altq_hfsc.c MALLOC(cl->cl_usc, struct internal_sc *,
cl 438 altq/altq_hfsc.c if (cl->cl_usc == NULL)
cl 440 altq/altq_hfsc.c sc2isc(usc, cl->cl_usc);
cl 441 altq/altq_hfsc.c rtsc_init(&cl->cl_ulimit, cl->cl_usc, 0, 0);
cl 444 altq/altq_hfsc.c cl->cl_id = hif->hif_classid++;
cl 445 altq/altq_hfsc.c cl->cl_handle = qid;
cl 446 altq/altq_hfsc.c cl->cl_hif = hif;
cl 447 altq/altq_hfsc.c cl->cl_parent = parent;
cl 459 altq/altq_hfsc.c hif->hif_class_tbl[i] = cl;
cl 463 altq/altq_hfsc.c hif->hif_class_tbl[i] = cl;
cl 473 altq/altq_hfsc.c hif->hif_defaultclass = cl;
cl 477 altq/altq_hfsc.c hif->hif_rootclass = cl;
cl 481 altq/altq_hfsc.c parent->cl_children = cl;
cl 485 altq/altq_hfsc.c p->cl_siblings = cl;
cl 490 altq/altq_hfsc.c return (cl);
cl 493 altq/altq_hfsc.c if (cl->cl_actc != NULL)
cl 494 altq/altq_hfsc.c actlist_destroy(cl->cl_actc);
cl 495 altq/altq_hfsc.c if (cl->cl_red != NULL) {
cl 497 altq/altq_hfsc.c if (q_is_rio(cl->cl_q))
cl 498 altq/altq_hfsc.c rio_destroy((rio_t *)cl->cl_red);
cl 501 altq/altq_hfsc.c if (q_is_red(cl->cl_q))
cl 502 altq/altq_hfsc.c red_destroy(cl->cl_red);
cl 505 altq/altq_hfsc.c if (cl->cl_fsc != NULL)
cl 506 altq/altq_hfsc.c FREE(cl->cl_fsc, M_DEVBUF);
cl 507 altq/altq_hfsc.c if (cl->cl_rsc != NULL)
cl 508 altq/altq_hfsc.c FREE(cl->cl_rsc, M_DEVBUF);
cl 509 altq/altq_hfsc.c if (cl->cl_usc != NULL)
cl 510 altq/altq_hfsc.c FREE(cl->cl_usc, M_DEVBUF);
cl 511 altq/altq_hfsc.c if (cl->cl_q != NULL)
cl 512 altq/altq_hfsc.c FREE(cl->cl_q, M_DEVBUF);
cl 513 altq/altq_hfsc.c FREE(cl, M_DEVBUF);
cl 522 altq/altq_hfsc.c if (cl == NULL)
cl 525 altq/altq_hfsc.c if (is_a_parent_class(cl))
cl 530 altq/altq_hfsc.c if (!qempty(cl->cl_q))
cl 531 altq/altq_hfsc.c hfsc_purgeq(cl);
cl 533 altq/altq_hfsc.c if (cl->cl_parent == NULL) {
cl 536 altq/altq_hfsc.c struct hfsc_class *p = cl->cl_parent->cl_children;
cl 538 altq/altq_hfsc.c if (p == cl)
cl 539 altq/altq_hfsc.c cl->cl_parent->cl_children = cl->cl_siblings;
cl 541 altq/altq_hfsc.c if (p->cl_siblings == cl) {
cl 542 altq/altq_hfsc.c p->cl_siblings = cl->cl_siblings;
cl 550 altq/altq_hfsc.c if (cl->cl_hif->hif_class_tbl[i] == cl) {
cl 551 altq/altq_hfsc.c cl->cl_hif->hif_class_tbl[i] = NULL;
cl 555 altq/altq_hfsc.c cl->cl_hif->hif_classes--;
cl 558 altq/altq_hfsc.c actlist_destroy(cl->cl_actc);
cl 560 altq/altq_hfsc.c if (cl->cl_red != NULL) {
cl 562 altq/altq_hfsc.c if (q_is_rio(cl->cl_q))
cl 563 altq/altq_hfsc.c rio_destroy((rio_t *)cl->cl_red);
cl 566 altq/altq_hfsc.c if (q_is_red(cl->cl_q))
cl 567 altq/altq_hfsc.c red_destroy(cl->cl_red);
cl 571 altq/altq_hfsc.c if (cl == cl->cl_hif->hif_rootclass)
cl 572 altq/altq_hfsc.c cl->cl_hif->hif_rootclass = NULL;
cl 573 altq/altq_hfsc.c if (cl == cl->cl_hif->hif_defaultclass)
cl 574 altq/altq_hfsc.c cl->cl_hif->hif_defaultclass = NULL;
cl 576 altq/altq_hfsc.c if (cl->cl_usc != NULL)
cl 577 altq/altq_hfsc.c FREE(cl->cl_usc, M_DEVBUF);
cl 578 altq/altq_hfsc.c if (cl->cl_fsc != NULL)
cl 579 altq/altq_hfsc.c FREE(cl->cl_fsc, M_DEVBUF);
cl 580 altq/altq_hfsc.c if (cl->cl_rsc != NULL)
cl 581 altq/altq_hfsc.c FREE(cl->cl_rsc, M_DEVBUF);
cl 582 altq/altq_hfsc.c FREE(cl->cl_q, M_DEVBUF);
cl 583 altq/altq_hfsc.c FREE(cl, M_DEVBUF);
cl 597 altq/altq_hfsc.c if (cl->cl_children != NULL)
cl 598 altq/altq_hfsc.c cl = cl->cl_children;
cl 599 altq/altq_hfsc.c else if (cl->cl_siblings != NULL)
cl 600 altq/altq_hfsc.c cl = cl->cl_siblings;
cl 602 altq/altq_hfsc.c while ((cl = cl->cl_parent) != NULL)
cl 603 altq/altq_hfsc.c if (cl->cl_siblings) {
cl 604 altq/altq_hfsc.c cl = cl->cl_siblings;
cl 609 altq/altq_hfsc.c return (cl);
cl 620 altq/altq_hfsc.c struct hfsc_class *cl;
cl 631 altq/altq_hfsc.c if ((cl = clh_to_clp(hif, m->m_pkthdr.pf.qid)) == NULL ||
cl 632 altq/altq_hfsc.c is_a_parent_class(cl)) {
cl 633 altq/altq_hfsc.c cl = hif->hif_defaultclass;
cl 634 altq/altq_hfsc.c if (cl == NULL) {
cl 638 altq/altq_hfsc.c cl->cl_pktattr = NULL;
cl 642 altq/altq_hfsc.c if (hfsc_addq(cl, m) != 0) {
cl 644 altq/altq_hfsc.c PKTCNTR_ADD(&cl->cl_stats.drop_cnt, len);
cl 648 altq/altq_hfsc.c cl->cl_hif->hif_packets++;
cl 651 altq/altq_hfsc.c if (qlen(cl->cl_q) == 1)
cl 652 altq/altq_hfsc.c set_active(cl, m_pktlen(m));
cl 670 altq/altq_hfsc.c struct hfsc_class *cl;
cl 684 altq/altq_hfsc.c cl = hif->hif_pollcache;
cl 687 altq/altq_hfsc.c if (cl->cl_rsc != NULL)
cl 688 altq/altq_hfsc.c realtime = (cl->cl_e <= cur_time);
cl 695 altq/altq_hfsc.c if ((cl = ellist_get_mindl(hif->hif_eligible, cur_time))
cl 706 altq/altq_hfsc.c cl = hif->hif_rootclass;
cl 707 altq/altq_hfsc.c while (is_a_parent_class(cl)) {
cl 709 altq/altq_hfsc.c cl = actlist_firstfit(cl, cur_time);
cl 710 altq/altq_hfsc.c if (cl == NULL) {
cl 721 altq/altq_hfsc.c if (cl->cl_parent->cl_cvtmin < cl->cl_vt)
cl 722 altq/altq_hfsc.c cl->cl_parent->cl_cvtmin = cl->cl_vt;
cl 730 altq/altq_hfsc.c hif->hif_pollcache = cl;
cl 731 altq/altq_hfsc.c m = hfsc_pollq(cl);
cl 736 altq/altq_hfsc.c m = hfsc_getq(cl);
cl 740 altq/altq_hfsc.c cl->cl_hif->hif_packets--;
cl 742 altq/altq_hfsc.c PKTCNTR_ADD(&cl->cl_stats.xmit_cnt, len);
cl 744 altq/altq_hfsc.c update_vf(cl, len, cur_time);
cl 746 altq/altq_hfsc.c cl->cl_cumul += len;
cl 748 altq/altq_hfsc.c if (!qempty(cl->cl_q)) {
cl 749 altq/altq_hfsc.c if (cl->cl_rsc != NULL) {
cl 751 altq/altq_hfsc.c next_len = m_pktlen(qhead(cl->cl_q));
cl 754 altq/altq_hfsc.c update_ed(cl, next_len);
cl 756 altq/altq_hfsc.c update_d(cl, next_len);
cl 760 altq/altq_hfsc.c set_passive(cl);
cl 771 altq/altq_hfsc.c if (q_is_rio(cl->cl_q))
cl 772 altq/altq_hfsc.c return rio_addq((rio_t *)cl->cl_red, cl->cl_q,
cl 773 altq/altq_hfsc.c m, cl->cl_pktattr);
cl 776 altq/altq_hfsc.c if (q_is_red(cl->cl_q))
cl 777 altq/altq_hfsc.c return red_addq(cl->cl_red, cl->cl_q, m, cl->cl_pktattr);
cl 779 altq/altq_hfsc.c if (qlen(cl->cl_q) >= qlimit(cl->cl_q)) {
cl 784 altq/altq_hfsc.c if (cl->cl_flags & HFCF_CLEARDSCP)
cl 785 altq/altq_hfsc.c write_dsfield(m, cl->cl_pktattr, 0);
cl 787 altq/altq_hfsc.c _addq(cl->cl_q, m);
cl 796 altq/altq_hfsc.c if (q_is_rio(cl->cl_q))
cl 797 altq/altq_hfsc.c return rio_getq((rio_t *)cl->cl_red, cl->cl_q);
cl 800 altq/altq_hfsc.c if (q_is_red(cl->cl_q))
cl 801 altq/altq_hfsc.c return red_getq(cl->cl_red, cl->cl_q);
cl 803 altq/altq_hfsc.c return _getq(cl->cl_q);
cl 809 altq/altq_hfsc.c return qhead(cl->cl_q);
cl 817 altq/altq_hfsc.c if (qempty(cl->cl_q))
cl 820 altq/altq_hfsc.c while ((m = _getq(cl->cl_q)) != NULL) {
cl 821 altq/altq_hfsc.c PKTCNTR_ADD(&cl->cl_stats.drop_cnt, m_pktlen(m));
cl 823 altq/altq_hfsc.c cl->cl_hif->hif_packets--;
cl 824 altq/altq_hfsc.c IFQ_DEC_LEN(cl->cl_hif->hif_ifq);
cl 826 altq/altq_hfsc.c ASSERT(qlen(cl->cl_q) == 0);
cl 828 altq/altq_hfsc.c update_vf(cl, 0, 0); /* remove cl from the actlist */
cl 829 altq/altq_hfsc.c set_passive(cl);
cl 835 altq/altq_hfsc.c if (cl->cl_rsc != NULL)
cl 836 altq/altq_hfsc.c init_ed(cl, len);
cl 837 altq/altq_hfsc.c if (cl->cl_fsc != NULL)
cl 838 altq/altq_hfsc.c init_vf(cl, len);
cl 840 altq/altq_hfsc.c cl->cl_stats.period++;
cl 846 altq/altq_hfsc.c if (cl->cl_rsc != NULL)
cl 847 altq/altq_hfsc.c ellist_remove(cl);
cl 863 altq/altq_hfsc.c rtsc_min(&cl->cl_deadline, cl->cl_rsc, cur_time, cl->cl_cumul);
cl 870 altq/altq_hfsc.c cl->cl_eligible = cl->cl_deadline;
cl 871 altq/altq_hfsc.c if (cl->cl_rsc->sm1 <= cl->cl_rsc->sm2) {
cl 872 altq/altq_hfsc.c cl->cl_eligible.dx = 0;
cl 873 altq/altq_hfsc.c cl->cl_eligible.dy = 0;
cl 877 altq/altq_hfsc.c cl->cl_e = rtsc_y2x(&cl->cl_eligible, cl->cl_cumul);
cl 878 altq/altq_hfsc.c cl->cl_d = rtsc_y2x(&cl->cl_deadline, cl->cl_cumul + next_len);
cl 880 altq/altq_hfsc.c ellist_insert(cl);
cl 886 altq/altq_hfsc.c cl->cl_e = rtsc_y2x(&cl->cl_eligible, cl->cl_cumul);
cl 887 altq/altq_hfsc.c cl->cl_d = rtsc_y2x(&cl->cl_deadline, cl->cl_cumul + next_len);
cl 889 altq/altq_hfsc.c ellist_update(cl);
cl 895 altq/altq_hfsc.c cl->cl_d = rtsc_y2x(&cl->cl_deadline, cl->cl_cumul + next_len);
cl 907 altq/altq_hfsc.c for ( ; cl->cl_parent != NULL; cl = cl->cl_parent) {
cl 909 altq/altq_hfsc.c if (go_active && cl->cl_nactive++ == 0)
cl 915 altq/altq_hfsc.c max_cl = actlist_last(cl->cl_parent->cl_actc);
cl 923 altq/altq_hfsc.c if (cl->cl_parent->cl_cvtmin != 0)
cl 924 altq/altq_hfsc.c vt = (cl->cl_parent->cl_cvtmin + vt)/2;
cl 926 altq/altq_hfsc.c if (cl->cl_parent->cl_vtperiod !=
cl 927 altq/altq_hfsc.c cl->cl_parentperiod || vt > cl->cl_vt)
cl 928 altq/altq_hfsc.c cl->cl_vt = vt;
cl 936 altq/altq_hfsc.c vt = cl->cl_parent->cl_cvtmax;
cl 937 altq/altq_hfsc.c for (p = cl->cl_parent->cl_children; p != NULL;
cl 940 altq/altq_hfsc.c cl->cl_vt = 0;
cl 941 altq/altq_hfsc.c cl->cl_parent->cl_cvtmax = 0;
cl 942 altq/altq_hfsc.c cl->cl_parent->cl_cvtmin = 0;
cl 944 altq/altq_hfsc.c cl->cl_initvt = cl->cl_vt;
cl 947 altq/altq_hfsc.c vt = cl->cl_vt + cl->cl_vtoff;
cl 948 altq/altq_hfsc.c rtsc_min(&cl->cl_virtual, cl->cl_fsc, vt, cl->cl_total);
cl 949 altq/altq_hfsc.c if (cl->cl_virtual.x == vt) {
cl 950 altq/altq_hfsc.c cl->cl_virtual.x -= cl->cl_vtoff;
cl 951 altq/altq_hfsc.c cl->cl_vtoff = 0;
cl 953 altq/altq_hfsc.c cl->cl_vtadj = 0;
cl 955 altq/altq_hfsc.c cl->cl_vtperiod++; /* increment vt period */
cl 956 altq/altq_hfsc.c cl->cl_parentperiod = cl->cl_parent->cl_vtperiod;
cl 957 altq/altq_hfsc.c if (cl->cl_parent->cl_nactive == 0)
cl 958 altq/altq_hfsc.c cl->cl_parentperiod++;
cl 959 altq/altq_hfsc.c cl->cl_f = 0;
cl 961 altq/altq_hfsc.c actlist_insert(cl);
cl 963 altq/altq_hfsc.c if (cl->cl_usc != NULL) {
cl 969 altq/altq_hfsc.c rtsc_min(&cl->cl_ulimit, cl->cl_usc, cur_time,
cl 970 altq/altq_hfsc.c cl->cl_total);
cl 972 altq/altq_hfsc.c cl->cl_myf = rtsc_y2x(&cl->cl_ulimit,
cl 973 altq/altq_hfsc.c cl->cl_total);
cl 974 altq/altq_hfsc.c cl->cl_myfadj = 0;
cl 978 altq/altq_hfsc.c if (cl->cl_myf > cl->cl_cfmin)
cl 979 altq/altq_hfsc.c f = cl->cl_myf;
cl 981 altq/altq_hfsc.c f = cl->cl_cfmin;
cl 982 altq/altq_hfsc.c if (f != cl->cl_f) {
cl 983 altq/altq_hfsc.c cl->cl_f = f;
cl 984 altq/altq_hfsc.c update_cfmin(cl->cl_parent);
cl 995 altq/altq_hfsc.c go_passive = qempty(cl->cl_q);
cl 997 altq/altq_hfsc.c for (; cl->cl_parent != NULL; cl = cl->cl_parent) {
cl 999 altq/altq_hfsc.c cl->cl_total += len;
cl 1001 altq/altq_hfsc.c if (cl->cl_fsc == NULL || cl->cl_nactive == 0)
cl 1004 altq/altq_hfsc.c if (go_passive && --cl->cl_nactive == 0)
cl 1013 altq/altq_hfsc.c if (cl->cl_vt > cl->cl_parent->cl_cvtmax)
cl 1014 altq/altq_hfsc.c cl->cl_parent->cl_cvtmax = cl->cl_vt;
cl 1017 altq/altq_hfsc.c actlist_remove(cl);
cl 1019 altq/altq_hfsc.c update_cfmin(cl->cl_parent);
cl 1027 altq/altq_hfsc.c cl->cl_vt = rtsc_y2x(&cl->cl_virtual, cl->cl_total)
cl 1028 altq/altq_hfsc.c - cl->cl_vtoff + cl->cl_vtadj;
cl 1035 altq/altq_hfsc.c if (cl->cl_vt < cl->cl_parent->cl_cvtmin) {
cl 1036 altq/altq_hfsc.c cl->cl_vtadj += cl->cl_parent->cl_cvtmin - cl->cl_vt;
cl 1037 altq/altq_hfsc.c cl->cl_vt = cl->cl_parent->cl_cvtmin;
cl 1041 altq/altq_hfsc.c actlist_update(cl);
cl 1043 altq/altq_hfsc.c if (cl->cl_usc != NULL) {
cl 1044 altq/altq_hfsc.c cl->cl_myf = cl->cl_myfadj
cl 1045 altq/altq_hfsc.c + rtsc_y2x(&cl->cl_ulimit, cl->cl_total);
cl 1055 altq/altq_hfsc.c if (cl->cl_myf < myf_bound) {
cl 1056 altq/altq_hfsc.c delta = cur_time - cl->cl_myf;
cl 1057 altq/altq_hfsc.c cl->cl_myfadj += delta;
cl 1058 altq/altq_hfsc.c cl->cl_myf += delta;
cl 1063 altq/altq_hfsc.c if (cl->cl_myf > cl->cl_cfmin)
cl 1064 altq/altq_hfsc.c f = cl->cl_myf;
cl 1066 altq/altq_hfsc.c f = cl->cl_cfmin;
cl 1067 altq/altq_hfsc.c if (f != cl->cl_f) {
cl 1068 altq/altq_hfsc.c cl->cl_f = f;
cl 1069 altq/altq_hfsc.c update_cfmin(cl->cl_parent);
cl 1080 altq/altq_hfsc.c if (TAILQ_EMPTY(cl->cl_actc)) {
cl 1081 altq/altq_hfsc.c cl->cl_cfmin = 0;
cl 1085 altq/altq_hfsc.c TAILQ_FOREACH(p, cl->cl_actc, cl_actlist) {
cl 1087 altq/altq_hfsc.c cl->cl_cfmin = 0;
cl 1093 altq/altq_hfsc.c cl->cl_cfmin = cfmin;
cl 1124 altq/altq_hfsc.c struct hfsc_if *hif = cl->cl_hif;
cl 1129 altq/altq_hfsc.c p->cl_e <= cl->cl_e) {
cl 1130 altq/altq_hfsc.c TAILQ_INSERT_TAIL(hif->hif_eligible, cl, cl_ellist);
cl 1135 altq/altq_hfsc.c if (cl->cl_e < p->cl_e) {
cl 1136 altq/altq_hfsc.c TAILQ_INSERT_BEFORE(p, cl, cl_ellist);
cl 1146 altq/altq_hfsc.c struct hfsc_if *hif = cl->cl_hif;
cl 1148 altq/altq_hfsc.c TAILQ_REMOVE(hif->hif_eligible, cl, cl_ellist);
cl 1154 altq/altq_hfsc.c struct hfsc_if *hif = cl->cl_hif;
cl 1161 altq/altq_hfsc.c p = TAILQ_NEXT(cl, cl_ellist);
cl 1162 altq/altq_hfsc.c if (p == NULL || cl->cl_e <= p->cl_e)
cl 1168 altq/altq_hfsc.c if (last->cl_e <= cl->cl_e) {
cl 1169 altq/altq_hfsc.c TAILQ_REMOVE(hif->hif_eligible, cl, cl_ellist);
cl 1170 altq/altq_hfsc.c TAILQ_INSERT_TAIL(hif->hif_eligible, cl, cl_ellist);
cl 1179 altq/altq_hfsc.c if (cl->cl_e < p->cl_e) {
cl 1180 altq/altq_hfsc.c TAILQ_REMOVE(hif->hif_eligible, cl, cl_ellist);
cl 1181 altq/altq_hfsc.c TAILQ_INSERT_BEFORE(p, cl, cl_ellist);
cl 1192 altq/altq_hfsc.c struct hfsc_class *p, *cl = NULL;
cl 1197 altq/altq_hfsc.c if (cl == NULL || p->cl_d < cl->cl_d)
cl 1198 altq/altq_hfsc.c cl = p;
cl 1200 altq/altq_hfsc.c return (cl);
cl 1229 altq/altq_hfsc.c if ((p = TAILQ_LAST(cl->cl_parent->cl_actc, _active)) == NULL
cl 1230 altq/altq_hfsc.c || p->cl_vt <= cl->cl_vt) {
cl 1231 altq/altq_hfsc.c TAILQ_INSERT_TAIL(cl->cl_parent->cl_actc, cl, cl_actlist);
cl 1235 altq/altq_hfsc.c TAILQ_FOREACH(p, cl->cl_parent->cl_actc, cl_actlist) {
cl 1236 altq/altq_hfsc.c if (cl->cl_vt < p->cl_vt) {
cl 1237 altq/altq_hfsc.c TAILQ_INSERT_BEFORE(p, cl, cl_actlist);
cl 1247 altq/altq_hfsc.c TAILQ_REMOVE(cl->cl_parent->cl_actc, cl, cl_actlist);
cl 1260 altq/altq_hfsc.c p = TAILQ_NEXT(cl, cl_actlist);
cl 1261 altq/altq_hfsc.c if (p == NULL || cl->cl_vt < p->cl_vt)
cl 1265 altq/altq_hfsc.c last = TAILQ_LAST(cl->cl_parent->cl_actc, _active);
cl 1267 altq/altq_hfsc.c if (last->cl_vt <= cl->cl_vt) {
cl 1268 altq/altq_hfsc.c TAILQ_REMOVE(cl->cl_parent->cl_actc, cl, cl_actlist);
cl 1269 altq/altq_hfsc.c TAILQ_INSERT_TAIL(cl->cl_parent->cl_actc, cl, cl_actlist);
cl 1278 altq/altq_hfsc.c if (cl->cl_vt < p->cl_vt) {
cl 1279 altq/altq_hfsc.c TAILQ_REMOVE(cl->cl_parent->cl_actc, cl, cl_actlist);
cl 1280 altq/altq_hfsc.c TAILQ_INSERT_BEFORE(p, cl, cl_actlist);
cl 1292 altq/altq_hfsc.c TAILQ_FOREACH(p, cl->cl_actc, cl_actlist) {
cl 1548 altq/altq_hfsc.c sp->class_id = cl->cl_id;
cl 1549 altq/altq_hfsc.c sp->class_handle = cl->cl_handle;
cl 1551 altq/altq_hfsc.c if (cl->cl_rsc != NULL) {
cl 1552 altq/altq_hfsc.c sp->rsc.m1 = sm2m(cl->cl_rsc->sm1);
cl 1553 altq/altq_hfsc.c sp->rsc.d = dx2d(cl->cl_rsc->dx);
cl 1554 altq/altq_hfsc.c sp->rsc.m2 = sm2m(cl->cl_rsc->sm2);
cl 1560 altq/altq_hfsc.c if (cl->cl_fsc != NULL) {
cl 1561 altq/altq_hfsc.c sp->fsc.m1 = sm2m(cl->cl_fsc->sm1);
cl 1562 altq/altq_hfsc.c sp->fsc.d = dx2d(cl->cl_fsc->dx);
cl 1563 altq/altq_hfsc.c sp->fsc.m2 = sm2m(cl->cl_fsc->sm2);
cl 1569 altq/altq_hfsc.c if (cl->cl_usc != NULL) {
cl 1570 altq/altq_hfsc.c sp->usc.m1 = sm2m(cl->cl_usc->sm1);
cl 1571 altq/altq_hfsc.c sp->usc.d = dx2d(cl->cl_usc->dx);
cl 1572 altq/altq_hfsc.c sp->usc.m2 = sm2m(cl->cl_usc->sm2);
cl 1579 altq/altq_hfsc.c sp->total = cl->cl_total;
cl 1580 altq/altq_hfsc.c sp->cumul = cl->cl_cumul;
cl 1582 altq/altq_hfsc.c sp->d = cl->cl_d;
cl 1583 altq/altq_hfsc.c sp->e = cl->cl_e;
cl 1584 altq/altq_hfsc.c sp->vt = cl->cl_vt;
cl 1585 altq/altq_hfsc.c sp->f = cl->cl_f;
cl 1587 altq/altq_hfsc.c sp->initvt = cl->cl_initvt;
cl 1588 altq/altq_hfsc.c sp->vtperiod = cl->cl_vtperiod;
cl 1589 altq/altq_hfsc.c sp->parentperiod = cl->cl_parentperiod;
cl 1590 altq/altq_hfsc.c sp->nactive = cl->cl_nactive;
cl 1591 altq/altq_hfsc.c sp->vtoff = cl->cl_vtoff;
cl 1592 altq/altq_hfsc.c sp->cvtmax = cl->cl_cvtmax;
cl 1593 altq/altq_hfsc.c sp->myf = cl->cl_myf;
cl 1594 altq/altq_hfsc.c sp->cfmin = cl->cl_cfmin;
cl 1595 altq/altq_hfsc.c sp->cvtmin = cl->cl_cvtmin;
cl 1596 altq/altq_hfsc.c sp->myfadj = cl->cl_myfadj;
cl 1597 altq/altq_hfsc.c sp->vtadj = cl->cl_vtadj;
cl 1602 altq/altq_hfsc.c sp->qlength = qlen(cl->cl_q);
cl 1603 altq/altq_hfsc.c sp->qlimit = qlimit(cl->cl_q);
cl 1604 altq/altq_hfsc.c sp->xmit_cnt = cl->cl_stats.xmit_cnt;
cl 1605 altq/altq_hfsc.c sp->drop_cnt = cl->cl_stats.drop_cnt;
cl 1606 altq/altq_hfsc.c sp->period = cl->cl_stats.period;
cl 1608 altq/altq_hfsc.c sp->qtype = qtype(cl->cl_q);
cl 1610 altq/altq_hfsc.c if (q_is_red(cl->cl_q))
cl 1611 altq/altq_hfsc.c red_getstats(cl->cl_red, &sp->red[0]);
cl 1614 altq/altq_hfsc.c if (q_is_rio(cl->cl_q))
cl 1615 altq/altq_hfsc.c rio_getstats((rio_t *)cl->cl_red, &sp->red[0]);
cl 1624 altq/altq_hfsc.c struct hfsc_class *cl;
cl 1633 altq/altq_hfsc.c if ((cl = hif->hif_class_tbl[i]) != NULL && cl->cl_handle == chandle)
cl 1634 altq/altq_hfsc.c return (cl);
cl 1636 altq/altq_hfsc.c if ((cl = hif->hif_class_tbl[i]) != NULL &&
cl 1637 altq/altq_hfsc.c cl->cl_handle == chandle)
cl 1638 altq/altq_hfsc.c return (cl);
cl 130 altq/altq_priq.c struct priq_class *cl;
cl 145 altq/altq_priq.c cl = priq_class_create(pif, a->priority, a->qlimit,
cl 147 altq/altq_priq.c if (cl == NULL)
cl 157 altq/altq_priq.c struct priq_class *cl;
cl 162 altq/altq_priq.c if ((cl = clh_to_clp(pif, a->qid)) == NULL)
cl 165 altq/altq_priq.c return (priq_class_destroy(cl));
cl 172 altq/altq_priq.c struct priq_class *cl;
cl 179 altq/altq_priq.c if ((cl = clh_to_clp(pif, a->qid)) == NULL)
cl 185 altq/altq_priq.c get_class_stats(&stats, cl);
cl 200 altq/altq_priq.c struct priq_class *cl;
cl 205 altq/altq_priq.c if ((cl = pif->pif_classes[pri]) != NULL)
cl 206 altq/altq_priq.c priq_class_destroy(cl);
cl 228 altq/altq_priq.c struct priq_class *cl;
cl 232 altq/altq_priq.c if ((cl = pif->pif_classes[pri]) != NULL && !qempty(cl->cl_q))
cl 233 altq/altq_priq.c priq_purgeq(cl);
cl 242 altq/altq_priq.c struct priq_class *cl;
cl 254 altq/altq_priq.c if ((cl = pif->pif_classes[pri]) != NULL) {
cl 257 altq/altq_priq.c if (!qempty(cl->cl_q))
cl 258 altq/altq_priq.c priq_purgeq(cl);
cl 261 altq/altq_priq.c if (q_is_rio(cl->cl_q))
cl 262 altq/altq_priq.c rio_destroy((rio_t *)cl->cl_red);
cl 265 altq/altq_priq.c if (q_is_red(cl->cl_q))
cl 266 altq/altq_priq.c red_destroy(cl->cl_red);
cl 269 altq/altq_priq.c MALLOC(cl, struct priq_class *, sizeof(struct priq_class),
cl 271 altq/altq_priq.c if (cl == NULL)
cl 273 altq/altq_priq.c bzero(cl, sizeof(struct priq_class));
cl 275 altq/altq_priq.c MALLOC(cl->cl_q, class_queue_t *, sizeof(class_queue_t),
cl 277 altq/altq_priq.c if (cl->cl_q == NULL)
cl 279 altq/altq_priq.c bzero(cl->cl_q, sizeof(class_queue_t));
cl 282 altq/altq_priq.c pif->pif_classes[pri] = cl;
cl 284 altq/altq_priq.c pif->pif_default = cl;
cl 287 altq/altq_priq.c qlimit(cl->cl_q) = qlimit;
cl 288 altq/altq_priq.c qtype(cl->cl_q) = Q_DROPTAIL;
cl 289 altq/altq_priq.c qlen(cl->cl_q) = 0;
cl 290 altq/altq_priq.c cl->cl_flags = flags;
cl 291 altq/altq_priq.c cl->cl_pri = pri;
cl 294 altq/altq_priq.c cl->cl_pif = pif;
cl 295 altq/altq_priq.c cl->cl_handle = qid;
cl 315 altq/altq_priq.c cl->cl_red = (red_t *)rio_alloc(0, NULL,
cl 317 altq/altq_priq.c if (cl->cl_red != NULL)
cl 318 altq/altq_priq.c qtype(cl->cl_q) = Q_RIO;
cl 322 altq/altq_priq.c cl->cl_red = red_alloc(0, 0,
cl 323 altq/altq_priq.c qlimit(cl->cl_q) * 10/100,
cl 324 altq/altq_priq.c qlimit(cl->cl_q) * 30/100,
cl 326 altq/altq_priq.c if (cl->cl_red != NULL)
cl 327 altq/altq_priq.c qtype(cl->cl_q) = Q_RED;
cl 332 altq/altq_priq.c return (cl);
cl 335 altq/altq_priq.c if (cl->cl_red != NULL) {
cl 337 altq/altq_priq.c if (q_is_rio(cl->cl_q))
cl 338 altq/altq_priq.c rio_destroy((rio_t *)cl->cl_red);
cl 341 altq/altq_priq.c if (q_is_red(cl->cl_q))
cl 342 altq/altq_priq.c red_destroy(cl->cl_red);
cl 345 altq/altq_priq.c if (cl->cl_q != NULL)
cl 346 altq/altq_priq.c FREE(cl->cl_q, M_DEVBUF);
cl 347 altq/altq_priq.c FREE(cl, M_DEVBUF);
cl 359 altq/altq_priq.c if (!qempty(cl->cl_q))
cl 360 altq/altq_priq.c priq_purgeq(cl);
cl 362 altq/altq_priq.c pif = cl->cl_pif;
cl 363 altq/altq_priq.c pif->pif_classes[cl->cl_pri] = NULL;
cl 364 altq/altq_priq.c if (pif->pif_maxpri == cl->cl_pri) {
cl 365 altq/altq_priq.c for (pri = cl->cl_pri; pri >= 0; pri--)
cl 375 altq/altq_priq.c if (cl->cl_red != NULL) {
cl 377 altq/altq_priq.c if (q_is_rio(cl->cl_q))
cl 378 altq/altq_priq.c rio_destroy((rio_t *)cl->cl_red);
cl 381 altq/altq_priq.c if (q_is_red(cl->cl_q))
cl 382 altq/altq_priq.c red_destroy(cl->cl_red);
cl 385 altq/altq_priq.c FREE(cl->cl_q, M_DEVBUF);
cl 386 altq/altq_priq.c FREE(cl, M_DEVBUF);
cl 398 altq/altq_priq.c struct priq_class *cl;
cl 409 altq/altq_priq.c if ((cl = clh_to_clp(pif, m->m_pkthdr.pf.qid)) == NULL) {
cl 410 altq/altq_priq.c cl = pif->pif_default;
cl 411 altq/altq_priq.c if (cl == NULL) {
cl 415 altq/altq_priq.c cl->cl_pktattr = NULL;
cl 419 altq/altq_priq.c if (priq_addq(cl, m) != 0) {
cl 421 altq/altq_priq.c PKTCNTR_ADD(&cl->cl_dropcnt, len);
cl 443 altq/altq_priq.c struct priq_class *cl;
cl 452 altq/altq_priq.c if ((cl = pif->pif_classes[pri]) != NULL &&
cl 453 altq/altq_priq.c !qempty(cl->cl_q)) {
cl 455 altq/altq_priq.c return (priq_pollq(cl));
cl 457 altq/altq_priq.c m = priq_getq(cl);
cl 460 altq/altq_priq.c if (qempty(cl->cl_q))
cl 461 altq/altq_priq.c cl->cl_period++;
cl 462 altq/altq_priq.c PKTCNTR_ADD(&cl->cl_xmitcnt, m_pktlen(m));
cl 475 altq/altq_priq.c if (q_is_rio(cl->cl_q))
cl 476 altq/altq_priq.c return rio_addq((rio_t *)cl->cl_red, cl->cl_q, m,
cl 477 altq/altq_priq.c cl->cl_pktattr);
cl 480 altq/altq_priq.c if (q_is_red(cl->cl_q))
cl 481 altq/altq_priq.c return red_addq(cl->cl_red, cl->cl_q, m, cl->cl_pktattr);
cl 483 altq/altq_priq.c if (qlen(cl->cl_q) >= qlimit(cl->cl_q)) {
cl 488 altq/altq_priq.c if (cl->cl_flags & PRCF_CLEARDSCP)
cl 489 altq/altq_priq.c write_dsfield(m, cl->cl_pktattr, 0);
cl 491 altq/altq_priq.c _addq(cl->cl_q, m);
cl 500 altq/altq_priq.c if (q_is_rio(cl->cl_q))
cl 501 altq/altq_priq.c return rio_getq((rio_t *)cl->cl_red, cl->cl_q);
cl 504 altq/altq_priq.c if (q_is_red(cl->cl_q))
cl 505 altq/altq_priq.c return red_getq(cl->cl_red, cl->cl_q);
cl 507 altq/altq_priq.c return _getq(cl->cl_q);
cl 514 altq/altq_priq.c return qhead(cl->cl_q);
cl 522 altq/altq_priq.c if (qempty(cl->cl_q))
cl 525 altq/altq_priq.c while ((m = _getq(cl->cl_q)) != NULL) {
cl 526 altq/altq_priq.c PKTCNTR_ADD(&cl->cl_dropcnt, m_pktlen(m));
cl 529 altq/altq_priq.c ASSERT(qlen(cl->cl_q) == 0);
cl 535 altq/altq_priq.c sp->class_handle = cl->cl_handle;
cl 536 altq/altq_priq.c sp->qlength = qlen(cl->cl_q);
cl 537 altq/altq_priq.c sp->qlimit = qlimit(cl->cl_q);
cl 538 altq/altq_priq.c sp->period = cl->cl_period;
cl 539 altq/altq_priq.c sp->xmitcnt = cl->cl_xmitcnt;
cl 540 altq/altq_priq.c sp->dropcnt = cl->cl_dropcnt;
cl 542 altq/altq_priq.c sp->qtype = qtype(cl->cl_q);
cl 544 altq/altq_priq.c if (q_is_red(cl->cl_q))
cl 545 altq/altq_priq.c red_getstats(cl->cl_red, &sp->red[0]);
cl 548 altq/altq_priq.c if (q_is_rio(cl->cl_q))
cl 549 altq/altq_priq.c rio_getstats((rio_t *)cl->cl_red, &sp->red[0]);
cl 558 altq/altq_priq.c struct priq_class *cl;
cl 565 altq/altq_priq.c if ((cl = pif->pif_classes[idx]) != NULL &&
cl 566 altq/altq_priq.c cl->cl_handle == chandle)
cl 567 altq/altq_priq.c return (cl);
cl 180 altq/altq_rmclass.c struct rm_class *cl;
cl 203 altq/altq_rmclass.c MALLOC(cl, struct rm_class *, sizeof(struct rm_class),
cl 205 altq/altq_rmclass.c if (cl == NULL)
cl 207 altq/altq_rmclass.c bzero(cl, sizeof(struct rm_class));
cl 208 altq/altq_rmclass.c CALLOUT_INIT(&cl->callout_);
cl 209 altq/altq_rmclass.c MALLOC(cl->q_, class_queue_t *, sizeof(class_queue_t),
cl 211 altq/altq_rmclass.c if (cl->q_ == NULL) {
cl 212 altq/altq_rmclass.c FREE(cl, M_DEVBUF);
cl 215 altq/altq_rmclass.c bzero(cl->q_, sizeof(class_queue_t));
cl 220 altq/altq_rmclass.c cl->children_ = NULL;
cl 221 altq/altq_rmclass.c cl->parent_ = parent;
cl 222 altq/altq_rmclass.c cl->borrow_ = borrow;
cl 223 altq/altq_rmclass.c cl->leaf_ = 1;
cl 224 altq/altq_rmclass.c cl->ifdat_ = ifd;
cl 225 altq/altq_rmclass.c cl->pri_ = pri;
cl 226 altq/altq_rmclass.c cl->allotment_ = RM_NS_PER_SEC / nsecPerByte; /* Bytes per sec */
cl 227 altq/altq_rmclass.c cl->depth_ = 0;
cl 228 altq/altq_rmclass.c cl->qthresh_ = 0;
cl 229 altq/altq_rmclass.c cl->ns_per_byte_ = nsecPerByte;
cl 231 altq/altq_rmclass.c qlimit(cl->q_) = maxq;
cl 232 altq/altq_rmclass.c qtype(cl->q_) = Q_DROPHEAD;
cl 233 altq/altq_rmclass.c qlen(cl->q_) = 0;
cl 234 altq/altq_rmclass.c cl->flags_ = flags;
cl 237 altq/altq_rmclass.c cl->minidle_ = (minidle * (int)nsecPerByte) / 8;
cl 238 altq/altq_rmclass.c if (cl->minidle_ > 0)
cl 239 altq/altq_rmclass.c cl->minidle_ = 0;
cl 241 altq/altq_rmclass.c cl->minidle_ = minidle;
cl 243 altq/altq_rmclass.c cl->maxidle_ = (maxidle * nsecPerByte) / 8;
cl 244 altq/altq_rmclass.c if (cl->maxidle_ == 0)
cl 245 altq/altq_rmclass.c cl->maxidle_ = 1;
cl 247 altq/altq_rmclass.c cl->avgidle_ = cl->maxidle_;
cl 248 altq/altq_rmclass.c cl->offtime_ = ((offtime * nsecPerByte) / 8) >> RM_FILTER_GAIN;
cl 249 altq/altq_rmclass.c if (cl->offtime_ == 0)
cl 250 altq/altq_rmclass.c cl->offtime_ = 1;
cl 252 altq/altq_rmclass.c cl->avgidle_ = 0;
cl 253 altq/altq_rmclass.c cl->offtime_ = (offtime * nsecPerByte) / 8;
cl 255 altq/altq_rmclass.c cl->overlimit = action;
cl 273 altq/altq_rmclass.c cl->red_ = red_alloc(0, 0,
cl 274 altq/altq_rmclass.c qlimit(cl->q_) * 10/100,
cl 275 altq/altq_rmclass.c qlimit(cl->q_) * 30/100,
cl 277 altq/altq_rmclass.c if (cl->red_ != NULL)
cl 278 altq/altq_rmclass.c qtype(cl->q_) = Q_RED;
cl 282 altq/altq_rmclass.c cl->red_ = (red_t *)rio_alloc(0, NULL,
cl 284 altq/altq_rmclass.c if (cl->red_ != NULL)
cl 285 altq/altq_rmclass.c qtype(cl->q_) = Q_RIO;
cl 297 altq/altq_rmclass.c cl->peer_ = peer;
cl 300 altq/altq_rmclass.c peer->peer_ = cl;
cl 302 altq/altq_rmclass.c ifd->active_[pri] = cl;
cl 303 altq/altq_rmclass.c cl->peer_ = cl;
cl 306 altq/altq_rmclass.c if (cl->parent_) {
cl 307 altq/altq_rmclass.c cl->next_ = parent->children_;
cl 308 altq/altq_rmclass.c parent->children_ = cl;
cl 316 altq/altq_rmclass.c rmc_depth_compute(cl);
cl 323 altq/altq_rmclass.c ifd->alloc_[pri] += cl->allotment_;
cl 327 altq/altq_rmclass.c return (cl);
cl 338 altq/altq_rmclass.c ifd = cl->ifdat_;
cl 339 altq/altq_rmclass.c old_allotment = cl->allotment_;
cl 342 altq/altq_rmclass.c cl->allotment_ = RM_NS_PER_SEC / nsecPerByte; /* Bytes per sec */
cl 343 altq/altq_rmclass.c cl->qthresh_ = 0;
cl 344 altq/altq_rmclass.c cl->ns_per_byte_ = nsecPerByte;
cl 346 altq/altq_rmclass.c qlimit(cl->q_) = maxq;
cl 349 altq/altq_rmclass.c cl->minidle_ = (minidle * nsecPerByte) / 8;
cl 350 altq/altq_rmclass.c if (cl->minidle_ > 0)
cl 351 altq/altq_rmclass.c cl->minidle_ = 0;
cl 353 altq/altq_rmclass.c cl->minidle_ = minidle;
cl 355 altq/altq_rmclass.c cl->maxidle_ = (maxidle * nsecPerByte) / 8;
cl 356 altq/altq_rmclass.c if (cl->maxidle_ == 0)
cl 357 altq/altq_rmclass.c cl->maxidle_ = 1;
cl 359 altq/altq_rmclass.c cl->avgidle_ = cl->maxidle_;
cl 360 altq/altq_rmclass.c cl->offtime_ = ((offtime * nsecPerByte) / 8) >> RM_FILTER_GAIN;
cl 361 altq/altq_rmclass.c if (cl->offtime_ == 0)
cl 362 altq/altq_rmclass.c cl->offtime_ = 1;
cl 364 altq/altq_rmclass.c cl->avgidle_ = 0;
cl 365 altq/altq_rmclass.c cl->offtime_ = (offtime * nsecPerByte) / 8;
cl 372 altq/altq_rmclass.c ifd->alloc_[cl->pri_] += cl->allotment_ - old_allotment;
cl 392 altq/altq_rmclass.c struct rm_class *cl, *clh;
cl 412 altq/altq_rmclass.c clh = cl = ifd->active_[i];
cl 416 altq/altq_rmclass.c cl->w_allotment_ = 0;
cl 418 altq/altq_rmclass.c cl->w_allotment_ = cl->allotment_ /
cl 420 altq/altq_rmclass.c cl = cl->peer_;
cl 421 altq/altq_rmclass.c } while ((cl != NULL) && (cl != clh));
cl 446 altq/altq_rmclass.c rm_class_t *t = cl, *p;
cl 475 altq/altq_rmclass.c p = cl;
cl 500 altq/altq_rmclass.c if (cl->depth_ >= 1) {
cl 501 altq/altq_rmclass.c if (cl->children_ == NULL) {
cl 502 altq/altq_rmclass.c cl->depth_ = 0;
cl 503 altq/altq_rmclass.c } else if ((t = cl->children_) != NULL) {
cl 510 altq/altq_rmclass.c rmc_depth_compute(cl);
cl 530 altq/altq_rmclass.c ASSERT(cl->children_ == NULL);
cl 532 altq/altq_rmclass.c if (cl->sleeping_)
cl 533 altq/altq_rmclass.c CALLOUT_STOP(&cl->callout_);
cl 541 altq/altq_rmclass.c rmc_dropall(cl);
cl 547 altq/altq_rmclass.c if (cl->parent_ != NULL) {
cl 548 altq/altq_rmclass.c head = cl->parent_->children_;
cl 551 altq/altq_rmclass.c ASSERT(head == cl);
cl 552 altq/altq_rmclass.c cl->parent_->children_ = NULL;
cl 553 altq/altq_rmclass.c cl->parent_->leaf_ = 1;
cl 555 altq/altq_rmclass.c if (p == cl) {
cl 556 altq/altq_rmclass.c if (cl == head)
cl 557 altq/altq_rmclass.c cl->parent_->children_ = cl->next_;
cl 559 altq/altq_rmclass.c previous->next_ = cl->next_;
cl 560 altq/altq_rmclass.c cl->next_ = NULL;
cl 572 altq/altq_rmclass.c if ((p = ifd->active_[cl->pri_]) != NULL) {
cl 578 altq/altq_rmclass.c while (p->peer_ != cl)
cl 580 altq/altq_rmclass.c p->peer_ = cl->peer_;
cl 582 altq/altq_rmclass.c if (ifd->active_[cl->pri_] == cl)
cl 583 altq/altq_rmclass.c ifd->active_[cl->pri_] = cl->peer_;
cl 585 altq/altq_rmclass.c ASSERT(p == cl);
cl 586 altq/altq_rmclass.c ifd->active_[cl->pri_] = NULL;
cl 594 altq/altq_rmclass.c ifd->alloc_[cl->pri_] -= cl->allotment_;
cl 595 altq/altq_rmclass.c ifd->num_[cl->pri_]--;
cl 603 altq/altq_rmclass.c rmc_depth_recompute(cl->parent_);
cl 613 altq/altq_rmclass.c if (cl->red_ != NULL) {
cl 615 altq/altq_rmclass.c if (q_is_rio(cl->q_))
cl 616 altq/altq_rmclass.c rio_destroy((rio_t *)cl->red_);
cl 619 altq/altq_rmclass.c if (q_is_red(cl->q_))
cl 620 altq/altq_rmclass.c red_destroy(cl->red_);
cl 623 altq/altq_rmclass.c FREE(cl->q_, M_DEVBUF);
cl 624 altq/altq_rmclass.c FREE(cl, M_DEVBUF);
cl 725 altq/altq_rmclass.c struct rm_ifdat *ifd = cl->ifdat_;
cl 726 altq/altq_rmclass.c int cpri = cl->pri_;
cl 727 altq/altq_rmclass.c int is_empty = qempty(cl->q_);
cl 731 altq/altq_rmclass.c if (TV_LT(&cl->undertime_, &now)) {
cl 732 altq/altq_rmclass.c if (ifd->cutoff_ > cl->depth_)
cl 733 altq/altq_rmclass.c ifd->cutoff_ = cl->depth_;
cl 734 altq/altq_rmclass.c CBQTRACE(rmc_queue_packet, 'ffoc', cl->depth_);
cl 743 altq/altq_rmclass.c struct rm_class *borrow = cl->borrow_;
cl 756 altq/altq_rmclass.c else if ((ifd->cutoff_ > 1) && cl->borrow_) {
cl 757 altq/altq_rmclass.c if (TV_LT(&cl->borrow_->undertime_, &now)) {
cl 758 altq/altq_rmclass.c ifd->cutoff_ = cl->borrow_->depth_;
cl 760 altq/altq_rmclass.c cl->borrow_->depth_);
cl 766 altq/altq_rmclass.c if (_rmc_addq(cl, m) < 0)
cl 771 altq/altq_rmclass.c CBQTRACE(rmc_queue_packet, 'ytpe', cl->stats_.handle);
cl 775 altq/altq_rmclass.c if (qlen(cl->q_) > qlimit(cl->q_)) {
cl 777 altq/altq_rmclass.c rmc_drop_action(cl);
cl 820 altq/altq_rmclass.c if (cl == NULL)
cl 822 altq/altq_rmclass.c if (TV_LT(now, &cl->undertime_))
cl 824 altq/altq_rmclass.c if (cl->depth_ == 0) {
cl 825 altq/altq_rmclass.c if (!cl->sleeping_ && (qlen(cl->q_) > cl->qthresh_))
cl 830 altq/altq_rmclass.c if (cl->children_ != NULL) {
cl 831 altq/altq_rmclass.c p = cl->children_;
cl 851 altq/altq_rmclass.c rm_class_t *p = cl;
cl 853 altq/altq_rmclass.c struct rm_ifdat *ifd = cl->ifdat_;
cl 860 altq/altq_rmclass.c if (cl->parent_ == NULL)
cl 863 altq/altq_rmclass.c if (cl->sleeping_) {
cl 864 altq/altq_rmclass.c if (TV_LT(now, &cl->undertime_))
cl 867 altq/altq_rmclass.c CALLOUT_STOP(&cl->callout_);
cl 868 altq/altq_rmclass.c cl->sleeping_ = 0;
cl 869 altq/altq_rmclass.c cl->undertime_.tv_sec = 0;
cl 874 altq/altq_rmclass.c while (cl->undertime_.tv_sec && TV_LT(now, &cl->undertime_)) {
cl 875 altq/altq_rmclass.c if (((cl = cl->borrow_) == NULL) ||
cl 876 altq/altq_rmclass.c (cl->depth_ > ifd->cutoff_)) {
cl 878 altq/altq_rmclass.c if (cl != NULL)
cl 890 altq/altq_rmclass.c if (cl != NULL) {
cl 892 altq/altq_rmclass.c top = cl;
cl 905 altq/altq_rmclass.c top = cl;
cl 908 altq/altq_rmclass.c if (cl != p)
cl 909 altq/altq_rmclass.c ifd->borrowed_[ifd->qi_] = cl;
cl 933 altq/altq_rmclass.c struct rm_class *cl = NULL, *first = NULL;
cl 946 altq/altq_rmclass.c cl = ifd->pollcache_;
cl 947 altq/altq_rmclass.c cpri = cl->pri_;
cl 950 altq/altq_rmclass.c if (cl->undertime_.tv_sec != 0 &&
cl 951 altq/altq_rmclass.c rmc_under_limit(cl, &now) == 0)
cl 952 altq/altq_rmclass.c first = cl;
cl 979 altq/altq_rmclass.c cl = ifd->active_[cpri];
cl 980 altq/altq_rmclass.c ASSERT(cl != NULL);
cl 982 altq/altq_rmclass.c if ((deficit < 2) && (cl->bytes_alloc_ <= 0))
cl 983 altq/altq_rmclass.c cl->bytes_alloc_ += cl->w_allotment_;
cl 984 altq/altq_rmclass.c if (!qempty(cl->q_)) {
cl 985 altq/altq_rmclass.c if ((cl->undertime_.tv_sec == 0) ||
cl 986 altq/altq_rmclass.c rmc_under_limit(cl, &now)) {
cl 987 altq/altq_rmclass.c if (cl->bytes_alloc_ > 0 || deficit > 1)
cl 996 altq/altq_rmclass.c else if (first == NULL && cl->borrow_ != NULL)
cl 997 altq/altq_rmclass.c first = cl; /* borrowing candidate */
cl 1000 altq/altq_rmclass.c cl->bytes_alloc_ = 0;
cl 1001 altq/altq_rmclass.c cl = cl->peer_;
cl 1002 altq/altq_rmclass.c } while (cl != ifd->active_[cpri]);
cl 1034 altq/altq_rmclass.c cl = first;
cl 1035 altq/altq_rmclass.c cpri = cl->pri_;
cl 1037 altq/altq_rmclass.c if (cl->sleeping_)
cl 1038 altq/altq_rmclass.c CALLOUT_STOP(&cl->callout_);
cl 1039 altq/altq_rmclass.c cl->sleeping_ = 0;
cl 1040 altq/altq_rmclass.c cl->undertime_.tv_sec = 0;
cl 1042 altq/altq_rmclass.c ifd->borrowed_[ifd->qi_] = cl->borrow_;
cl 1043 altq/altq_rmclass.c ifd->cutoff_ = cl->borrow_->depth_;
cl 1050 altq/altq_rmclass.c m = _rmc_getq(cl);
cl 1053 altq/altq_rmclass.c if (qempty(cl->q_))
cl 1059 altq/altq_rmclass.c if (cl->bytes_alloc_ > 0)
cl 1060 altq/altq_rmclass.c cl->bytes_alloc_ -= m_pktlen(m);
cl 1062 altq/altq_rmclass.c if ((cl->bytes_alloc_ <= 0) || first == cl)
cl 1063 altq/altq_rmclass.c ifd->active_[cl->pri_] = cl->peer_;
cl 1065 altq/altq_rmclass.c ifd->active_[cl->pri_] = cl;
cl 1067 altq/altq_rmclass.c ifd->class_[ifd->qi_] = cl;
cl 1074 altq/altq_rmclass.c m = _rmc_pollq(cl);
cl 1075 altq/altq_rmclass.c ifd->pollcache_ = cl;
cl 1091 altq/altq_rmclass.c struct rm_class *cl, *first = NULL;
cl 1101 altq/altq_rmclass.c cl = ifd->pollcache_;
cl 1102 altq/altq_rmclass.c cpri = cl->pri_;
cl 1116 altq/altq_rmclass.c cl = ifd->active_[cpri];
cl 1117 altq/altq_rmclass.c ASSERT(cl != NULL);
cl 1119 altq/altq_rmclass.c if (!qempty(cl->q_)) {
cl 1120 altq/altq_rmclass.c if ((cl->undertime_.tv_sec == 0) ||
cl 1121 altq/altq_rmclass.c rmc_under_limit(cl, &now))
cl 1123 altq/altq_rmclass.c if (first == NULL && cl->borrow_ != NULL)
cl 1124 altq/altq_rmclass.c first = cl;
cl 1126 altq/altq_rmclass.c cl = cl->peer_;
cl 1127 altq/altq_rmclass.c } while (cl != ifd->active_[cpri]);
cl 1149 altq/altq_rmclass.c cl = first;
cl 1150 altq/altq_rmclass.c cpri = cl->pri_;
cl 1152 altq/altq_rmclass.c if (cl->sleeping_)
cl 1153 altq/altq_rmclass.c CALLOUT_STOP(&cl->callout_);
cl 1154 altq/altq_rmclass.c cl->sleeping_ = 0;
cl 1155 altq/altq_rmclass.c cl->undertime_.tv_sec = 0;
cl 1157 altq/altq_rmclass.c ifd->borrowed_[ifd->qi_] = cl->borrow_;
cl 1158 altq/altq_rmclass.c ifd->cutoff_ = cl->borrow_->depth_;
cl 1165 altq/altq_rmclass.c m = _rmc_getq(cl);
cl 1168 altq/altq_rmclass.c if (qempty(cl->q_))
cl 1171 altq/altq_rmclass.c ifd->active_[cpri] = cl->peer_;
cl 1173 altq/altq_rmclass.c ifd->class_[ifd->qi_] = cl;
cl 1180 altq/altq_rmclass.c m = _rmc_pollq(cl);
cl 1181 altq/altq_rmclass.c ifd->pollcache_ = cl;
cl 1229 altq/altq_rmclass.c rm_class_t *cl, *borrowed;
cl 1236 altq/altq_rmclass.c if ((cl = ifd->class_[ifd->qo_]) == NULL)
cl 1243 altq/altq_rmclass.c PKTCNTR_ADD(&cl->stats_.xmit_cnt, pktlen);
cl 1290 altq/altq_rmclass.c while (cl != NULL) {
cl 1291 altq/altq_rmclass.c TV_DELTA(&ifd->ifnow_, &cl->last_, idle);
cl 1297 altq/altq_rmclass.c cl->avgidle_ = cl->maxidle_;
cl 1301 altq/altq_rmclass.c pkt_time = pktlen * cl->ns_per_byte_;
cl 1304 altq/altq_rmclass.c pkt_time = pktlen * cl->ns_per_byte_ / 1000;
cl 1308 altq/altq_rmclass.c avgidle = cl->avgidle_;
cl 1310 altq/altq_rmclass.c cl->avgidle_ = avgidle;
cl 1314 altq/altq_rmclass.c CBQTRACE(rmc_update_class_util, 'milo', cl->stats_.handle);
cl 1320 altq/altq_rmclass.c if (avgidle < cl->minidle_)
cl 1321 altq/altq_rmclass.c avgidle = cl->avgidle_ = cl->minidle_;
cl 1326 altq/altq_rmclass.c TV_ADD_DELTA(nowp, tidle, &cl->undertime_);
cl 1327 altq/altq_rmclass.c ++cl->stats_.over;
cl 1329 altq/altq_rmclass.c cl->avgidle_ =
cl 1330 altq/altq_rmclass.c (avgidle > cl->maxidle_) ? cl->maxidle_ : avgidle;
cl 1331 altq/altq_rmclass.c cl->undertime_.tv_sec = 0;
cl 1332 altq/altq_rmclass.c if (cl->sleeping_) {
cl 1333 altq/altq_rmclass.c CALLOUT_STOP(&cl->callout_);
cl 1334 altq/altq_rmclass.c cl->sleeping_ = 0;
cl 1339 altq/altq_rmclass.c if (borrows != cl)
cl 1340 altq/altq_rmclass.c ++cl->stats_.borrows;
cl 1344 altq/altq_rmclass.c cl->last_ = ifd->ifnow_;
cl 1345 altq/altq_rmclass.c cl->last_pkttime_ = pkt_time;
cl 1348 altq/altq_rmclass.c if (cl->parent_ == NULL) {
cl 1350 altq/altq_rmclass.c PKTCNTR_ADD(&cl->stats_.xmit_cnt, pktlen);
cl 1354 altq/altq_rmclass.c cl = cl->parent_;
cl 1360 altq/altq_rmclass.c cl = ifd->class_[ifd->qo_];
cl 1363 altq/altq_rmclass.c if ((qlen(cl->q_) <= 0) || TV_LT(nowp, &borrowed->undertime_)) {
cl 1371 altq/altq_rmclass.c if ((qlen(cl->q_) <= 1) || TV_LT(&now, &borrowed->undertime_)) {
cl 1406 altq/altq_rmclass.c struct rm_ifdat *ifd = cl->ifdat_;
cl 1408 altq/altq_rmclass.c ASSERT(qlen(cl->q_) > 0);
cl 1409 altq/altq_rmclass.c _rmc_dropq(cl);
cl 1410 altq/altq_rmclass.c if (qempty(cl->q_))
cl 1411 altq/altq_rmclass.c ifd->na_[cl->pri_]--;
cl 1416 altq/altq_rmclass.c struct rm_ifdat *ifd = cl->ifdat_;
cl 1418 altq/altq_rmclass.c if (!qempty(cl->q_)) {
cl 1419 altq/altq_rmclass.c _flushq(cl->q_);
cl 1421 altq/altq_rmclass.c ifd->na_[cl->pri_]--;
cl 1442 altq/altq_rmclass.c cl->stats_.overactions++;
cl 1443 altq/altq_rmclass.c TV_DELTA(&cl->undertime_, &cl->overtime_, delay);
cl 1445 altq/altq_rmclass.c delay += cl->offtime_;
cl 1448 altq/altq_rmclass.c if (!cl->sleeping_) {
cl 1449 altq/altq_rmclass.c CBQTRACE(rmc_delay_action, 'yled', cl->stats_.handle);
cl 1455 altq/altq_rmclass.c extradelay = cl->offtime_;
cl 1466 altq/altq_rmclass.c extradelay -= cl->last_pkttime_;
cl 1469 altq/altq_rmclass.c TV_ADD_DELTA(&cl->undertime_, extradelay, &cl->undertime_);
cl 1473 altq/altq_rmclass.c cl->sleeping_ = 1;
cl 1474 altq/altq_rmclass.c cl->stats_.delays++;
cl 1486 altq/altq_rmclass.c t = hzto(&cl->undertime_);
cl 1489 altq/altq_rmclass.c t = hzto(&cl->undertime_) + 1;
cl 1493 altq/altq_rmclass.c CALLOUT_RESET(&cl->callout_, t,
cl 1494 altq/altq_rmclass.c (timeout_t *)rmc_restart, (caddr_t)cl);
cl 1518 altq/altq_rmclass.c struct rm_ifdat *ifd = cl->ifdat_;
cl 1522 altq/altq_rmclass.c if (cl->sleeping_) {
cl 1523 altq/altq_rmclass.c cl->sleeping_ = 0;
cl 1524 altq/altq_rmclass.c cl->undertime_.tv_sec = 0;
cl 1527 altq/altq_rmclass.c CBQTRACE(rmc_restart, 'trts', cl->stats_.handle);
cl 1558 altq/altq_rmclass.c if (q_is_rio(cl->q_))
cl 1559 altq/altq_rmclass.c return rio_addq((rio_t *)cl->red_, cl->q_, m, cl->pktattr_);
cl 1562 altq/altq_rmclass.c if (q_is_red(cl->q_))
cl 1563 altq/altq_rmclass.c return red_addq(cl->red_, cl->q_, m, cl->pktattr_);
cl 1566 altq/altq_rmclass.c if (cl->flags_ & RMCF_CLEARDSCP)
cl 1567 altq/altq_rmclass.c write_dsfield(m, cl->pktattr_, 0);
cl 1569 altq/altq_rmclass.c _addq(cl->q_, m);
cl 1579 altq/altq_rmclass.c if ((m = _getq(cl->q_)) != NULL)
cl 1587 altq/altq_rmclass.c if (q_is_rio(cl->q_))
cl 1588 altq/altq_rmclass.c return rio_getq((rio_t *)cl->red_, cl->q_);
cl 1591 altq/altq_rmclass.c if (q_is_red(cl->q_))
cl 1592 altq/altq_rmclass.c return red_getq(cl->red_, cl->q_);
cl 1594 altq/altq_rmclass.c return _getq(cl->q_);
cl 1600 altq/altq_rmclass.c return qhead(cl->q_);
cl 242 altq/altq_rmclass.h #define is_a_parent_class(cl) ((cl)->children_ != NULL)
cl 461 dev/ic/ac97.c { 0x01408300, "Creative", cl(ac97_cr) },
cl 462 dev/ic/ac97.c { 0x41445300, "Analog Devices", cl(ac97_ad) },
cl 463 dev/ic/ac97.c { 0x414b4D00, "Asahi Kasei", cl(ac97_ak) },
cl 464 dev/ic/ac97.c { 0x414c4300, "Realtek", cl(ac97_rl) },
cl 465 dev/ic/ac97.c { 0x414c4700, "Avance Logic", cl(ac97_av) },
cl 466 dev/ic/ac97.c { 0x434d4900, "C-Media Electronics", cl(ac97_cm) },
cl 467 dev/ic/ac97.c { 0x43525900, "Cirrus Logic", cl(ac97_cs) },
cl 468 dev/ic/ac97.c { 0x43585400, "Conexant", cl(ac97_cx) },
cl 469 dev/ic/ac97.c { 0x44543000, "Diamond Technology", cl(ac97_dt) },
cl 470 dev/ic/ac97.c { 0x454d4300, "eMicro", cl(ac97_em) },
cl 471 dev/ic/ac97.c { 0x45838300, "ESS Technology", cl(ac97_es) },
cl 472 dev/ic/ac97.c { 0x48525300, "Intersil", cl(ac97_is) },
cl 473 dev/ic/ac97.c { 0x49434500, "ICEnsemble", cl(ac97_ic) },
cl 474 dev/ic/ac97.c { 0x49544500, "ITE, Inc.", cl(ac97_it) },
cl 475 dev/ic/ac97.c { 0x4e534300, "National Semiconductor", cl(ac97_ns) },
cl 476 dev/ic/ac97.c { 0x50534300, "Philips Semiconductor", cl(ac97_ps) },
cl 477 dev/ic/ac97.c { 0x53494c00, "Silicon Laboratory", cl(ac97_sl) },
cl 478 dev/ic/ac97.c { 0x54524100, "TriTech Microelectronics", cl(ac97_tt) },
cl 479 dev/ic/ac97.c { 0x54584e00, "Texas Instruments", cl(ac97_ti) },
cl 480 dev/ic/ac97.c { 0x56494100, "VIA Technologies", cl(ac97_vi) },
cl 481 dev/ic/ac97.c { 0x57454300, "Winbond", cl(ac97_wb) },
cl 482 dev/ic/ac97.c { 0x574d4c00, "Wolfson", cl(ac97_wo) },
cl 483 dev/ic/ac97.c { 0x594d4800, "Yamaha", cl(ac97_ym) },
cl 484 dev/ic/ac97.c { 0x83847600, "SigmaTel", cl(ac97_st) },
cl 1484 dev/ic/i82596.c int cl = 32;
cl 1490 dev/ic/i82596.c ptr = (ptr + cl - 1) & ~(cl - 1); /* set alignment and stick with it */
cl 1497 dev/ic/i82596.c ptr += cl;
cl 1502 dev/ic/i82596.c ptr += cl;
cl 1507 dev/ic/i82596.c ptr += cl;
cl 1515 dev/ic/i82596.c ptr = (ptr + cl - 1) & ~(cl - 1); /* re-align.. just in case */
cl 1531 dev/ic/i82596.c ptr += cl;
cl 1536 dev/ic/i82596.c ptr += cl;
cl 628 dev/ic/wdc.c u_int8_t st0, st1, sc, sn, cl, ch;
cl 696 dev/ic/wdc.c cl = CHP_READ_REG(chp, wdr_cyl_lo);
cl 698 dev/ic/wdc.c WDC_LOG_REG(chp, wdr_cyl_lo, (ch << 8) | cl);
cl 703 dev/ic/wdc.c chp->channel, drive, st0, WDCS_BITS, sc, sn, cl, ch),
cl 710 dev/ic/wdc.c if (cl == 0x14 && ch == 0xeb)
cl 124 dev/pci/if_hme_pci.c pcireg_t cl, id;
cl 142 dev/pci/if_hme_pci.c cl = pci_conf_read(epa.pa_pc, epa.pa_tag, PCI_CLASS_REG);
cl 145 dev/pci/if_hme_pci.c if (PCI_CLASS(cl) != PCI_CLASS_BRIDGE ||
cl 3946 dev/pci/pciide.c uint8_t scnt, sn, cl, ch;
cl 4019 dev/pci/pciide.c cl = CHP_READ_REG(chp, wdr_cyl_lo);
cl 4026 dev/pci/pciide.c cl = bus_space_read_1(chp->cmd_iot,
cl 4034 dev/pci/pciide.c scnt, sn, cl, ch);
cl 4041 dev/pci/pciide.c if (cl == 0x14 && ch == 0xeb)
cl 6774 dev/pci/pciide.c u_int16_t scnt, sn, cl, ch;
cl 6819 dev/pci/pciide.c cl = bus_space_read_2(chp->cmd_iot, iohs[wdr_cyl_lo], 0);
cl 6824 dev/pci/pciide.c scnt, sn, cl, ch);
cl 6831 dev/pci/pciide.c if (cl == 0x14 && ch == 0xeb)
cl 7436 dev/pci/pciide.c uint8_t scnt, sn, cl, ch;
cl 7506 dev/pci/pciide.c cl = CHP_READ_REG(chp, wdr_cyl_lo);
cl 7513 dev/pci/pciide.c cl = bus_space_read_1(chp->cmd_iot,
cl 7521 dev/pci/pciide.c scnt, sn, cl, ch);
cl 7528 dev/pci/pciide.c if (cl == 0x14 && ch == 0xeb)
cl 756 dev/softraid.c struct sr_chunk_head *cl;
cl 781 dev/softraid.c cl = &sd->sd_vol.sv_chunk_list;
cl 782 dev/softraid.c SLIST_INIT(cl);
cl 783 dev/softraid.c if (sr_open_chunks(sc, cl, dt, no_chunk))
cl 839 dev/softraid.c SLIST_FOREACH(ch_entry, cl, src_link)
cl 843 dev/softraid.c sr_create_chunk_meta(sc, cl);
cl 846 dev/softraid.c ch_entry = SLIST_FIRST(cl);
cl 1037 dev/softraid.c SLIST_INSERT_HEAD(cl, ch_entry, src_link);
cl 1103 dev/softraid.c struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list;
cl 1118 dev/softraid.c SLIST_FOREACH(ch_entry, cl, src_link) {
cl 1258 dev/softraid.c SLIST_FOREACH(ch_entry, cl, src_link) {
cl 1274 dev/softraid.c SLIST_FOREACH(ch_entry, cl, src_link)
cl 1279 dev/softraid.c SLIST_FOREACH(ch_entry, cl, src_link)
cl 1301 dev/softraid.c if (!cl)
cl 1304 dev/softraid.c for (ch_entry = SLIST_FIRST(cl);
cl 1305 dev/softraid.c ch_entry != SLIST_END(cl); ch_entry = ch_next) {
cl 1316 dev/softraid.c SLIST_INIT(cl);
cl 1788 dev/softraid.c struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list;
cl 1800 dev/softraid.c SLIST_FOREACH(ch_entry, cl, src_link) {
cl 436 isofs/cd9660/cd9660_vnops.c int cl, sl, assoc;
cl 440 isofs/cd9660/cd9660_vnops.c cl = idp->current.d_namlen;
cl 443 isofs/cd9660/cd9660_vnops.c if ((assoc = cl > 1 && *cname == ASSOCCHAR)) {
cl 444 isofs/cd9660/cd9660_vnops.c cl--;
cl 456 isofs/cd9660/cd9660_vnops.c if (sl != cl
cl 741 msdosfs/msdosfs_fat.c uint32_t cl, n;
cl 743 msdosfs/msdosfs_fat.c for (cl = start, n = count; n-- > 0;)
cl 744 msdosfs/msdosfs_fat.c usemap_alloc(pmp, cl++);
cl 655 ntfs/ntfs_subr.c cn_t *cl;
cl 668 ntfs/ntfs_subr.c cl = (cn_t *) malloc(cnt * sizeof(cn_t), M_NTFSRUN, M_WAITOK);
cl 676 ntfs/ntfs_subr.c cl[cnt] = 0;
cl 679 ntfs/ntfs_subr.c cl[cnt] += (u_int32_t) run[off++] << (i << 3);
cl 699 ntfs/ntfs_subr.c *rclp = cl;
cl 1545 ntfs/ntfs_subr.c cn_t ccn, ccl, cn, left, cl;
cl 1594 ntfs/ntfs_subr.c cl = ntfs_btocl(tocopy + off);
cl 1595 ntfs/ntfs_subr.c KASSERT(cl == 1 && tocopy <= ntfs_cntob(1));
cl 1598 ntfs/ntfs_subr.c (u_int32_t) cn, (u_int32_t) cl,
cl 1601 ntfs/ntfs_subr.c if ((off == 0) && (tocopy == ntfs_cntob(cl)))
cl 1604 ntfs/ntfs_subr.c ntfs_cntob(cl), 0, 0);
cl 1608 ntfs/ntfs_subr.c ntfs_cntob(cl), NOCRED, &bp);
cl 1623 ntfs/ntfs_subr.c cn += cl;
cl 1624 ntfs/ntfs_subr.c ccl -= cl;
cl 1658 ntfs/ntfs_subr.c cn_t ccn, ccl, cn, left, cl;
cl 1700 ntfs/ntfs_subr.c cl = ntfs_btocl(tocopy + off);
cl 1701 ntfs/ntfs_subr.c KASSERT(cl == 1 &&
cl 1708 ntfs/ntfs_subr.c (u_int32_t) cl,
cl 1714 ntfs/ntfs_subr.c ntfs_cntob(cl),
cl 1732 ntfs/ntfs_subr.c cn += cl;
cl 1733 ntfs/ntfs_subr.c ccl -= cl;
cl 1946 ntfs/ntfs_subr.c *cl = 0;
cl 1954 ntfs/ntfs_subr.c *cl += (u_int32_t) run[(*off)++] << (i << 3);
cl 57 ntfs/ntfs_subr.h cn_t * cl;
cl 67 ntfs/ntfs_subr.h #define va_vruncl va_d.vrun.cl