static inline struct mbuf *
priq_getq(struct priq_class *cl)
{
IFCQ_LOCK_ASSERT_HELD(cl->cl_pif->pif_ifq);
#if CLASSQ_RIO
if (q_is_rio(&cl->cl_q))
return (rio_getq(cl->cl_rio, &cl->cl_q));
else
#endif /* CLASSQ_RIO */
#if CLASSQ_RED
if (q_is_red(&cl->cl_q))
return (red_getq(cl->cl_red, &cl->cl_q));
else
#endif /* CLASSQ_RED */
#if CLASSQ_BLUE
if (q_is_blue(&cl->cl_q))
return (blue_getq(cl->cl_blue, &cl->cl_q));
else
#endif /* CLASSQ_BLUE */
if (q_is_sfb(&cl->cl_q) && cl->cl_sfb != NULL)
return (sfb_getq(cl->cl_sfb, &cl->cl_q));
return (_getq(&cl->cl_q));
}
static int
codel_request(struct ifaltq *ifq, int req, void *arg)
{
struct codel_if *cif = (struct codel_if *)ifq->altq_disc;
struct mbuf *m;
IFQ_LOCK_ASSERT(ifq);
switch (req) {
case ALTRQ_PURGE:
if (!ALTQ_IS_ENABLED(cif->cif_ifq))
break;
if (qempty(cif->cl_q))
break;
while ((m = _getq(cif->cl_q)) != NULL) {
PKTCNTR_ADD(&cif->cl_stats.cl_dropcnt, m_pktlen(m));
m_freem(m);
IFQ_DEC_LEN(cif->cif_ifq);
}
cif->cif_ifq->ifq_len = 0;
break;
}
return (0);
}
static struct mbuf *
priq_getq(struct priq_class *cl)
{
#ifdef ALTQ_RIO
if (q_is_rio(cl->cl_q))
return rio_getq((rio_t *)cl->cl_red, cl->cl_q);
#endif
#ifdef ALTQ_RED
if (q_is_red(cl->cl_q))
return red_getq(cl->cl_red, cl->cl_q);
#endif
return _getq(cl->cl_q);
}
static void
priq_purgeq(struct priq_class *cl)
{
struct mbuf *m;
if (qempty(cl->cl_q))
return;
while ((m = _getq(cl->cl_q)) != NULL) {
PKTCNTR_ADD(&cl->cl_dropcnt, m_pktlen(m));
m_freem(m);
}
KKASSERT(qlen(cl->cl_q) == 0);
}
static inline struct mbuf *
fairq_getq(struct fairq_class *cl, u_int64_t cur_time)
{
fairq_bucket_t *b;
struct mbuf *m;
IFCQ_LOCK_ASSERT_HELD(cl->cl_fif->fif_ifq);
b = fairq_selectq(cl, 0);
if (b == NULL)
m = NULL;
#if CLASSQ_RIO
else if (cl->cl_qtype == Q_RIO)
m = rio_getq(cl->cl_rio, &b->queue);
#endif /* CLASSQ_RIO */
#if CLASSQ_RED
else if (cl->cl_qtype == Q_RED)
m = red_getq(cl->cl_red, &b->queue);
#endif /* CLASSQ_RED */
#if CLASSQ_BLUE
else if (cl->cl_qtype == Q_BLUE)
m = blue_getq(cl->cl_blue, &b->queue);
#endif /* CLASSQ_BLUE */
else if (cl->cl_qtype == Q_SFB && cl->cl_sfb != NULL)
m = sfb_getq(cl->cl_sfb, &b->queue);
else
m = _getq(&b->queue);
/*
* Calculate the BW change
*/
if (m != NULL) {
u_int64_t delta;
/*
* Per-class bandwidth calculation
*/
delta = (cur_time - cl->cl_last_time);
if (delta > machclk_freq * 8)
delta = machclk_freq * 8;
cl->cl_bw_delta += delta;
cl->cl_bw_bytes += m->m_pkthdr.len;
cl->cl_last_time = cur_time;
if (cl->cl_bw_delta > machclk_freq) {
cl->cl_bw_delta -= cl->cl_bw_delta >> 2;
cl->cl_bw_bytes -= cl->cl_bw_bytes >> 2;
}
struct mbuf *
codel_getq(struct codel *c, class_queue_t *q)
{
struct mbuf *m;
u_int64_t now;
int drop;
if ((m = _getq(q)) == NULL) {
c->vars.dropping = 0;
return (m);
}
now = read_machclk();
drop = codel_should_drop(c, q, m, now);
if (c->vars.dropping) {
if (!drop) {
/* sojourn time below target - leave dropping state */
c->vars.dropping = 0;
} else if (codel_time_after_eq(now, c->vars.drop_next)) {
/* It's time for the next drop. Drop the current
* packet and dequeue the next. The dequeue might
* take us out of dropping state.
* If not, schedule the next drop.
* A large backlog might result in drop rates so high
* that the next drop should happen now,
* hence the while loop.
*/
while (c->vars.dropping &&
codel_time_after_eq(now, c->vars.drop_next)) {
c->vars.count++; /* don't care of possible wrap
* since there is no more
* divide */
codel_Newton_step(&c->vars);
/* TODO ECN */
PKTCNTR_ADD(&c->stats.drop_cnt, m_pktlen(m));
m_freem(m);
m = _getq(q);
if (!codel_should_drop(c, q, m, now))
/* leave dropping state */
c->vars.dropping = 0;
else
/* and schedule the next drop */
c->vars.drop_next =
codel_control_law(c->vars.drop_next,
c->params.interval,
c->vars.rec_inv_sqrt);
}
}
} else if (drop) {
/* TODO ECN */
PKTCNTR_ADD(&c->stats.drop_cnt, m_pktlen(m));
m_freem(m);
m = _getq(q);
drop = codel_should_drop(c, q, m, now);
c->vars.dropping = 1;
/* if min went above target close to when we last went below it
* assume that the drop rate that controlled the queue on the
* last cycle is a good starting point to control it now.
*/
if (codel_time_before(now - c->vars.drop_next,
16 * c->params.interval)) {
c->vars.count = (c->vars.count - c->vars.lastcount) | 1;
/* we dont care if rec_inv_sqrt approximation
* is not very precise :
* Next Newton steps will correct it quadratically.
*/
codel_Newton_step(&c->vars);
} else {
c->vars.count = 1;
c->vars.rec_inv_sqrt = ~0U >> REC_INV_SQRT_SHIFT;
}
c->vars.lastcount = c->vars.count;
c->vars.drop_next = codel_control_law(now, c->params.interval,
c->vars.rec_inv_sqrt);
}
return (m);
}
