VERIFY(ifp != NULL);
if (ev != CLASSQ_EV_LINK_DOWN) {
(*sp->sfb_bins)[0].fudge = sfb_random(sp);
(*sp->sfb_bins)[1].fudge = sfb_random(sp);
sp->sfb_allocation = ((sfb_allocation == 0) ?
(sp->sfb_qlim / 3) : sfb_allocation);
sp->sfb_drop_thresh = sp->sfb_allocation +
(sp->sfb_allocation >> 1);
}
sp->sfb_clearpkts = 0;
sp->sfb_current = 0;
eff_rate = ifnet_output_linkrate(ifp);
sp->sfb_eff_rate = eff_rate;
sfb_calc_holdtime(sp, eff_rate);
sfb_calc_pboxtime(sp, eff_rate);
sfb_calc_hinterval(sp, NULL);
ifclassq_calc_target_qdelay(ifp, &sp->sfb_target_qdelay);
sfb_calc_update_interval(sp, eff_rate);
if (ev == CLASSQ_EV_LINK_DOWN ||
ev == CLASSQ_EV_LINK_UP)
sfb_fclists_clean(sp);
bzero(sp->sfb_bins, sizeof (*sp->sfb_bins));
bzero(&sp->sfb_stats, sizeof (sp->sfb_stats));
static struct fairq_class *
fairq_class_create(struct fairq_if *fif, int pri, u_int32_t qlimit,
u_int64_t bandwidth, u_int32_t nbuckets, int flags, u_int64_t hogs_m1,
u_int64_t lssc_m1, u_int64_t lssc_d, u_int64_t lssc_m2, u_int32_t qid)
{
#pragma unused(lssc_d, lssc_m2)
struct ifnet *ifp;
struct ifclassq *ifq;
struct fairq_class *cl;
u_int32_t i;
IFCQ_LOCK_ASSERT_HELD(fif->fif_ifq);
/* Sanitize flags unless internally configured */
if (fif->fif_flags & FAIRQIFF_ALTQ)
flags &= FARF_USERFLAGS;
#if !CLASSQ_RED
if (flags & FARF_RED) {
log(LOG_ERR, "%s: %s RED not available!\n",
if_name(FAIRQIF_IFP(fif)), fairq_style(fif));
return (NULL);
}
#endif /* !CLASSQ_RED */
#if !CLASSQ_RIO
if (flags & FARF_RIO) {
log(LOG_ERR, "%s: %s RIO not available!\n",
if_name(FAIRQIF_IFP(fif)), fairq_style(fif));
return (NULL);
}
#endif /* CLASSQ_RIO */
#if !CLASSQ_BLUE
if (flags & FARF_BLUE) {
log(LOG_ERR, "%s: %s BLUE not available!\n",
if_name(FAIRQIF_IFP(fif)), fairq_style(fif));
return (NULL);
}
#endif /* CLASSQ_BLUE */
/* These are mutually exclusive */
if ((flags & (FARF_RED|FARF_RIO|FARF_BLUE|FARF_SFB)) &&
(flags & (FARF_RED|FARF_RIO|FARF_BLUE|FARF_SFB)) != FARF_RED &&
(flags & (FARF_RED|FARF_RIO|FARF_BLUE|FARF_SFB)) != FARF_RIO &&
(flags & (FARF_RED|FARF_RIO|FARF_BLUE|FARF_SFB)) != FARF_BLUE &&
(flags & (FARF_RED|FARF_RIO|FARF_BLUE|FARF_SFB)) != FARF_SFB) {
log(LOG_ERR, "%s: %s more than one RED|RIO|BLUE|SFB\n",
if_name(FAIRQIF_IFP(fif)), fairq_style(fif));
return (NULL);
}
if (bandwidth == 0 || (bandwidth / 8) == 0) {
log(LOG_ERR, "%s: %s invalid data rate %llu\n",
if_name(FAIRQIF_IFP(fif)), fairq_style(fif), bandwidth);
return (NULL);
}
if (nbuckets == 0)
nbuckets = 256;
if (nbuckets > FAIRQ_MAX_BUCKETS)
nbuckets = FAIRQ_MAX_BUCKETS;
/* enforce power-of-2 size */
while ((nbuckets ^ (nbuckets - 1)) != ((nbuckets << 1) - 1))
++nbuckets;
ifq = fif->fif_ifq;
ifp = FAIRQIF_IFP(fif);
if ((cl = fif->fif_classes[pri]) != NULL) {
/* modify the class instead of creating a new one */
if (cl->cl_head)
fairq_purgeq(fif, cl, 0, NULL, NULL);
#if CLASSQ_RIO
if (cl->cl_qtype == Q_RIO)
rio_destroy(cl->cl_rio);
#endif /* CLASSQ_RIO */
#if CLASSQ_RED
if (cl->cl_qtype == Q_RED)
red_destroy(cl->cl_red);
#endif /* CLASSQ_RED */
#if CLASSQ_BLUE
if (cl->cl_qtype == Q_BLUE)
blue_destroy(cl->cl_blue);
#endif /* CLASSQ_BLUE */
if (cl->cl_qtype == Q_SFB && cl->cl_sfb != NULL)
sfb_destroy(cl->cl_sfb);
cl->cl_qalg.ptr = NULL;
cl->cl_qtype = Q_DROPTAIL;
cl->cl_qstate = QS_RUNNING;
} else {
cl = zalloc(fairq_cl_zone);
if (cl == NULL)
goto err_ret;
bzero(cl, fairq_cl_size);
cl->cl_nbuckets = nbuckets;
cl->cl_nbucket_mask = nbuckets - 1;
cl->cl_buckets = _MALLOC(sizeof (struct fairq_bucket) *
cl->cl_nbuckets, M_DEVBUF, M_WAITOK|M_ZERO);
if (cl->cl_buckets == NULL)
goto err_buckets;
cl->cl_head = NULL;
}
fif->fif_classes[pri] = cl;
if (flags & FARF_DEFAULTCLASS)
fif->fif_default = cl;
if (qlimit == 0 || qlimit > IFCQ_MAXLEN(ifq)) {
qlimit = IFCQ_MAXLEN(ifq);
if (qlimit == 0)
qlimit = DEFAULT_QLIMIT; /* use default */
}
cl->cl_qlimit = qlimit;
for (i = 0; i < cl->cl_nbuckets; ++i) {
_qinit(&cl->cl_buckets[i].queue, Q_DROPTAIL, qlimit);
}
cl->cl_bandwidth = bandwidth / 8; /* cvt to bytes per second */
cl->cl_qtype = Q_DROPTAIL;
cl->cl_qstate = QS_RUNNING;
cl->cl_flags = flags;
cl->cl_pri = pri;
if (pri > fif->fif_maxpri)
fif->fif_maxpri = pri;
cl->cl_fif = fif;
cl->cl_handle = qid;
cl->cl_hogs_m1 = hogs_m1 / 8;
cl->cl_lssc_m1 = lssc_m1 / 8; /* NOT YET USED */
cl->cl_bw_current = 0;
if (flags & (FARF_RED|FARF_RIO|FARF_BLUE|FARF_SFB)) {
#if CLASSQ_RED || CLASSQ_RIO
u_int64_t ifbandwidth = ifnet_output_linkrate(ifp);
int pkttime;
#endif /* CLASSQ_RED || CLASSQ_RIO */
cl->cl_qflags = 0;
if (flags & FARF_ECN) {
if (flags & FARF_BLUE)
cl->cl_qflags |= BLUEF_ECN;
else if (flags & FARF_SFB)
cl->cl_qflags |= SFBF_ECN;
else if (flags & FARF_RED)
cl->cl_qflags |= REDF_ECN;
else if (flags & FARF_RIO)
cl->cl_qflags |= RIOF_ECN;
}
if (flags & FARF_FLOWCTL) {
if (flags & FARF_SFB)
cl->cl_qflags |= SFBF_FLOWCTL;
}
if (flags & FARF_CLEARDSCP) {
if (flags & FARF_RIO)
cl->cl_qflags |= RIOF_CLEARDSCP;
}
#if CLASSQ_RED || CLASSQ_RIO
/*
* XXX: RED & RIO should be watching link speed and MTU
* events and recompute pkttime accordingly.
*/
if (ifbandwidth < 8)
pkttime = 1000 * 1000 * 1000; /* 1 sec */
else
pkttime = (int64_t)ifp->if_mtu * 1000 * 1000 * 1000 /
(ifbandwidth / 8);
/* Test for exclusivity {RED,RIO,BLUE,SFB} was done above */
#if CLASSQ_RIO
if (flags & FARF_RIO) {
cl->cl_rio =
rio_alloc(ifp, 0, NULL, cl->cl_qflags, pkttime);
if (cl->cl_rio != NULL)
cl->cl_qtype = Q_RIO;
}
#endif /* CLASSQ_RIO */
#if CLASSQ_RED
if (flags & FARF_RED) {
cl->cl_red = red_alloc(ifp, 0, 0,
cl->cl_qlimit * 10/100,
cl->cl_qlimit * 30/100,
cl->cl_qflags, pkttime);
if (cl->cl_red != NULL)
cl->cl_qtype = Q_RED;
}
#endif /* CLASSQ_RED */
#endif /* CLASSQ_RED || CLASSQ_RIO */
#if CLASSQ_BLUE
if (flags & FARF_BLUE) {
cl->cl_blue = blue_alloc(ifp, 0, 0, cl->cl_qflags);
if (cl->cl_blue != NULL)
cl->cl_qtype = Q_BLUE;
}
#endif /* CLASSQ_BLUE */
if (flags & FARF_SFB) {
if (!(cl->cl_flags & FARF_LAZY))
cl->cl_sfb = sfb_alloc(ifp, cl->cl_handle,
cl->cl_qlimit, cl->cl_qflags);
if (cl->cl_sfb != NULL || (cl->cl_flags & FARF_LAZY))
cl->cl_qtype = Q_SFB;
}
}
if (pktsched_verbose) {
log(LOG_DEBUG, "%s: %s created qid=%d pri=%d qlimit=%d "
"flags=%b\n", if_name(ifp), fairq_style(fif),
cl->cl_handle, cl->cl_pri, cl->cl_qlimit, flags, FARF_BITS);
}
return (cl);
err_buckets:
if (cl->cl_buckets != NULL)
_FREE(cl->cl_buckets, M_DEVBUF);
err_ret:
if (cl != NULL) {
if (cl->cl_qalg.ptr != NULL) {
#if CLASSQ_RIO
if (cl->cl_qtype == Q_RIO)
rio_destroy(cl->cl_rio);
#endif /* CLASSQ_RIO */
#if CLASSQ_RED
if (cl->cl_qtype == Q_RED)
red_destroy(cl->cl_red);
#endif /* CLASSQ_RED */
#if CLASSQ_BLUE
if (cl->cl_qtype == Q_BLUE)
blue_destroy(cl->cl_blue);
#endif /* CLASSQ_BLUE */
if (cl->cl_qtype == Q_SFB && cl->cl_sfb != NULL)
sfb_destroy(cl->cl_sfb);
cl->cl_qalg.ptr = NULL;
cl->cl_qtype = Q_DROPTAIL;
cl->cl_qstate = QS_RUNNING;
}
zfree(fairq_cl_zone, cl);
}
return (NULL);
}
static struct priq_class *
priq_class_create(struct priq_if *pif, int pri, u_int32_t qlimit,
int flags, u_int32_t qid)
{
struct ifnet *ifp;
struct ifclassq *ifq;
struct priq_class *cl;
IFCQ_LOCK_ASSERT_HELD(pif->pif_ifq);
/* Sanitize flags unless internally configured */
if (pif->pif_flags & PRIQIFF_ALTQ)
flags &= PRCF_USERFLAGS;
#if !CLASSQ_RED
if (flags & PRCF_RED) {
log(LOG_ERR, "%s: %s RED not available!\n",
if_name(PRIQIF_IFP(pif)), priq_style(pif));
return (NULL);
}
#endif /* !CLASSQ_RED */
#if !CLASSQ_RIO
if (flags & PRCF_RIO) {
log(LOG_ERR, "%s: %s RIO not available!\n",
if_name(PRIQIF_IFP(pif)), priq_style(pif));
return (NULL);
}
#endif /* CLASSQ_RIO */
#if !CLASSQ_BLUE
if (flags & PRCF_BLUE) {
log(LOG_ERR, "%s: %s BLUE not available!\n",
if_name(PRIQIF_IFP(pif)), priq_style(pif));
return (NULL);
}
#endif /* CLASSQ_BLUE */
/* These are mutually exclusive */
if ((flags & (PRCF_RED|PRCF_RIO|PRCF_BLUE|PRCF_SFB)) &&
(flags & (PRCF_RED|PRCF_RIO|PRCF_BLUE|PRCF_SFB)) != PRCF_RED &&
(flags & (PRCF_RED|PRCF_RIO|PRCF_BLUE|PRCF_SFB)) != PRCF_RIO &&
(flags & (PRCF_RED|PRCF_RIO|PRCF_BLUE|PRCF_SFB)) != PRCF_BLUE &&
(flags & (PRCF_RED|PRCF_RIO|PRCF_BLUE|PRCF_SFB)) != PRCF_SFB) {
log(LOG_ERR, "%s: %s more than one RED|RIO|BLUE|SFB\n",
if_name(PRIQIF_IFP(pif)), priq_style(pif));
return (NULL);
}
ifq = pif->pif_ifq;
ifp = PRIQIF_IFP(pif);
if ((cl = pif->pif_classes[pri]) != NULL) {
/* modify the class instead of creating a new one */
if (!qempty(&cl->cl_q))
priq_purgeq(pif, cl, 0, NULL, NULL);
#if CLASSQ_RIO
if (q_is_rio(&cl->cl_q))
rio_destroy(cl->cl_rio);
#endif /* CLASSQ_RIO */
#if CLASSQ_RED
if (q_is_red(&cl->cl_q))
red_destroy(cl->cl_red);
#endif /* CLASSQ_RED */
#if CLASSQ_BLUE
if (q_is_blue(&cl->cl_q))
blue_destroy(cl->cl_blue);
#endif /* CLASSQ_BLUE */
if (q_is_sfb(&cl->cl_q) && cl->cl_sfb != NULL)
sfb_destroy(cl->cl_sfb);
cl->cl_qalg.ptr = NULL;
qtype(&cl->cl_q) = Q_DROPTAIL;
qstate(&cl->cl_q) = QS_RUNNING;
} else {
cl = zalloc(priq_cl_zone);
if (cl == NULL)
return (NULL);
bzero(cl, priq_cl_size);
}
pif->pif_classes[pri] = cl;
if (flags & PRCF_DEFAULTCLASS)
pif->pif_default = cl;
if (qlimit == 0 || qlimit > IFCQ_MAXLEN(ifq)) {
qlimit = IFCQ_MAXLEN(ifq);
if (qlimit == 0)
qlimit = DEFAULT_QLIMIT; /* use default */
}
_qinit(&cl->cl_q, Q_DROPTAIL, qlimit);
cl->cl_flags = flags;
cl->cl_pri = pri;
if (pri > pif->pif_maxpri)
pif->pif_maxpri = pri;
cl->cl_pif = pif;
cl->cl_handle = qid;
if (flags & (PRCF_RED|PRCF_RIO|PRCF_BLUE|PRCF_SFB)) {
#if CLASSQ_RED || CLASSQ_RIO
u_int64_t ifbandwidth = ifnet_output_linkrate(ifp);
int pkttime;
#endif /* CLASSQ_RED || CLASSQ_RIO */
cl->cl_qflags = 0;
if (flags & PRCF_ECN) {
if (flags & PRCF_BLUE)
cl->cl_qflags |= BLUEF_ECN;
else if (flags & PRCF_SFB)
cl->cl_qflags |= SFBF_ECN;
else if (flags & PRCF_RED)
cl->cl_qflags |= REDF_ECN;
else if (flags & PRCF_RIO)
cl->cl_qflags |= RIOF_ECN;
}
if (flags & PRCF_FLOWCTL) {
if (flags & PRCF_SFB)
cl->cl_qflags |= SFBF_FLOWCTL;
}
if (flags & PRCF_CLEARDSCP) {
if (flags & PRCF_RIO)
cl->cl_qflags |= RIOF_CLEARDSCP;
}
#if CLASSQ_RED || CLASSQ_RIO
/*
* XXX: RED & RIO should be watching link speed and MTU
* events and recompute pkttime accordingly.
*/
if (ifbandwidth < 8)
pkttime = 1000 * 1000 * 1000; /* 1 sec */
else
pkttime = (int64_t)ifp->if_mtu * 1000 * 1000 * 1000 /
(ifbandwidth / 8);
/* Test for exclusivity {RED,RIO,BLUE,SFB} was done above */
#if CLASSQ_RED
if (flags & PRCF_RED) {
cl->cl_red = red_alloc(ifp, 0, 0,
qlimit(&cl->cl_q) * 10/100,
qlimit(&cl->cl_q) * 30/100,
cl->cl_qflags, pkttime);
if (cl->cl_red != NULL)
qtype(&cl->cl_q) = Q_RED;
}
#endif /* CLASSQ_RED */
#if CLASSQ_RIO
if (flags & PRCF_RIO) {
cl->cl_rio =
rio_alloc(ifp, 0, NULL, cl->cl_qflags, pkttime);
if (cl->cl_rio != NULL)
qtype(&cl->cl_q) = Q_RIO;
}
#endif /* CLASSQ_RIO */
#endif /* CLASSQ_RED || CLASSQ_RIO */
#if CLASSQ_BLUE
if (flags & PRCF_BLUE) {
cl->cl_blue = blue_alloc(ifp, 0, 0, cl->cl_qflags);
if (cl->cl_blue != NULL)
qtype(&cl->cl_q) = Q_BLUE;
}
#endif /* CLASSQ_BLUE */
if (flags & PRCF_SFB) {
if (!(cl->cl_flags & PRCF_LAZY))
cl->cl_sfb = sfb_alloc(ifp, cl->cl_handle,
qlimit(&cl->cl_q), cl->cl_qflags);
if (cl->cl_sfb != NULL || (cl->cl_flags & PRCF_LAZY))
qtype(&cl->cl_q) = Q_SFB;
}
}
if (pktsched_verbose) {
log(LOG_DEBUG, "%s: %s created qid=%d pri=%d qlimit=%d "
"flags=%b\n", if_name(ifp), priq_style(pif),
cl->cl_handle, cl->cl_pri, qlimit, flags, PRCF_BITS);
}
return (cl);
}
