static void
tunstart(struct ifnet *ifp)
{
struct tun_softc *tp = ifp->if_softc;
struct mbuf *m;
if (ALTQ_IS_ENABLED(&ifp->if_snd)) {
IFQ_LOCK(&ifp->if_snd);
IFQ_POLL_NOLOCK(&ifp->if_snd, m);
if (m == NULL) {
IFQ_UNLOCK(&ifp->if_snd);
return;
}
IFQ_UNLOCK(&ifp->if_snd);
}
mtx_lock(&tp->tun_mtx);
if (tp->tun_flags & TUN_RWAIT) {
tp->tun_flags &= ~TUN_RWAIT;
wakeup(tp);
}
if (tp->tun_flags & TUN_ASYNC && tp->tun_sigio) {
mtx_unlock(&tp->tun_mtx);
pgsigio(&tp->tun_sigio, SIGIO, 0);
} else
mtx_unlock(&tp->tun_mtx);
selwakeuppri(&tp->tun_rsel, PZERO + 1);
}
int
rmc_modclass(struct rm_class *cl, u_int nsecPerByte, int maxq, u_int maxidle,
int minidle, u_int offtime, int pktsize)
{
struct rm_ifdat *ifd;
u_int old_allotment;
int s;
ifd = cl->ifdat_;
old_allotment = cl->allotment_;
#ifdef __NetBSD__
s = splnet();
#else
s = splimp();
#endif
IFQ_LOCK(ifd->ifq_);
cl->allotment_ = RM_NS_PER_SEC / nsecPerByte; /* Bytes per sec */
cl->qthresh_ = 0;
cl->ns_per_byte_ = nsecPerByte;
qlimit(cl->q_) = maxq;
#if 1 /* minidle is also scaled in ALTQ */
cl->minidle_ = (minidle * nsecPerByte) / 8;
if (cl->minidle_ > 0)
cl->minidle_ = 0;
#else
cl->minidle_ = minidle;
#endif
cl->maxidle_ = (maxidle * nsecPerByte) / 8;
if (cl->maxidle_ == 0)
cl->maxidle_ = 1;
#if 1 /* offtime is also scaled in ALTQ */
cl->avgidle_ = cl->maxidle_;
cl->offtime_ = ((offtime * nsecPerByte) / 8) >> RM_FILTER_GAIN;
if (cl->offtime_ == 0)
cl->offtime_ = 1;
#else
cl->avgidle_ = 0;
cl->offtime_ = (offtime * nsecPerByte) / 8;
#endif
/*
* If CBQ's WRR is enabled, then initialize the class WRR state.
*/
if (ifd->wrr_) {
ifd->alloc_[cl->pri_] += cl->allotment_ - old_allotment;
rmc_wrr_set_weights(ifd);
}
IFQ_UNLOCK(ifd->ifq_);
splx(s);
return (0);
}
static int
priq_class_destroy(struct priq_class *cl)
{
struct priq_if *pif;
int s, pri;
s = splnet();
IFQ_LOCK(cl->cl_pif->pif_ifq);
#ifdef ALTQ3_CLFIER_COMPAT
/* delete filters referencing to this class */
acc_discard_filters(&cl->cl_pif->pif_classifier, cl, 0);
#endif
if (!qempty(cl->cl_q))
priq_purgeq(cl);
pif = cl->cl_pif;
pif->pif_classes[cl->cl_pri] = NULL;
if (pif->pif_maxpri == cl->cl_pri) {
for (pri = cl->cl_pri; pri >= 0; pri--)
if (pif->pif_classes[pri] != NULL) {
pif->pif_maxpri = pri;
break;
}
if (pri < 0)
pif->pif_maxpri = -1;
}
IFQ_UNLOCK(cl->cl_pif->pif_ifq);
splx(s);
if (cl->cl_red != NULL) {
#ifdef ALTQ_RIO
if (q_is_rio(cl->cl_q))
rio_destroy((rio_t *)cl->cl_red);
#endif
#ifdef ALTQ_RED
if (q_is_red(cl->cl_q))
red_destroy(cl->cl_red);
#endif
#ifdef ALTQ_CODEL
if (q_is_codel(cl->cl_q))
codel_destroy(cl->cl_codel);
#endif
}
free(cl->cl_q, M_DEVBUF);
free(cl, M_DEVBUF);
return (0);
}
static void
cbqrestart(struct ifaltq *ifq)
{
cbq_state_t *cbqp;
struct ifnet *ifp;
IFQ_LOCK_ASSERT(ifq);
if (!ALTQ_IS_ENABLED(ifq))
/* cbq must have been detached */
return;
if ((cbqp = (cbq_state_t *)ifq->altq_disc) == NULL)
/* should not happen */
return;
ifp = ifq->altq_ifp;
if (ifp->if_start &&
cbqp->cbq_qlen > 0 && (ifp->if_drv_flags & IFF_DRV_OACTIVE) == 0) {
IFQ_UNLOCK(ifq);
(*ifp->if_start)(ifp);
IFQ_LOCK(ifq);
}
}
void
mplsintr(void)
{
struct mbuf *m;
for (;;) {
IFQ_LOCK(&mplsintrq);
IF_DEQUEUE(&mplsintrq, m);
IFQ_UNLOCK(&mplsintrq);
if (!m)
return;
if (((m->m_flags & M_PKTHDR) == 0) ||
(m->m_pkthdr.rcvif_index == 0))
panic("mplsintr(): no pkthdr or rcvif");
#ifdef MBUFTRACE
m_claimm(m, &mpls_owner);
#endif
mpls_input(m_get_rcvif_NOMPSAFE(m), m);
}
}
void
rmc_delete_class(struct rm_ifdat *ifd, struct rm_class *cl)
{
struct rm_class *p, *head, *previous;
int s;
ASSERT(cl->children_ == NULL);
if (cl->sleeping_)
CALLOUT_STOP(&cl->callout_);
s = splnet();
IFQ_LOCK(ifd->ifq_);
/*
* Free packets in the packet queue.
* XXX - this may not be a desired behavior. Packets should be
* re-queued.
*/
rmc_dropall(cl);
/*
* If the class has a parent, then remove the class from the
* class from the parent's children chain.
*/
if (cl->parent_ != NULL) {
head = cl->parent_->children_;
p = previous = head;
if (head->next_ == NULL) {
ASSERT(head == cl);
cl->parent_->children_ = NULL;
cl->parent_->leaf_ = 1;
} else while (p != NULL) {
if (p == cl) {
if (cl == head)
cl->parent_->children_ = cl->next_;
else
previous->next_ = cl->next_;
cl->next_ = NULL;
p = NULL;
} else {
previous = p;
p = p->next_;
}
}
}
/*
* Delete class from class priority peer list.
*/
if ((p = ifd->active_[cl->pri_]) != NULL) {
/*
* If there is more than one member of this priority
* level, then look for class(cl) in the priority level.
*/
if (p != p->peer_) {
while (p->peer_ != cl)
p = p->peer_;
p->peer_ = cl->peer_;
if (ifd->active_[cl->pri_] == cl)
ifd->active_[cl->pri_] = cl->peer_;
} else {
ASSERT(p == cl);
ifd->active_[cl->pri_] = NULL;
}
}
/*
* Recompute the WRR weights.
*/
if (ifd->wrr_) {
ifd->alloc_[cl->pri_] -= cl->allotment_;
ifd->num_[cl->pri_]--;
rmc_wrr_set_weights(ifd);
}
/*
* Re-compute the depth of the tree.
*/
#if 1 /* ALTQ */
rmc_depth_recompute(cl->parent_);
#else
rmc_depth_recompute(ifd->root_);
#endif
IFQ_UNLOCK(ifd->ifq_);
splx(s);
/*
* Free the class structure.
*/
if (cl->red_ != NULL) {
#ifdef ALTQ_RIO
if (q_is_rio(cl->q_))
rio_destroy((rio_t *)cl->red_);
#endif
#ifdef ALTQ_RED
if (q_is_red(cl->q_))
red_destroy(cl->red_);
#endif
}
free(cl->q_, M_DEVBUF);
free(cl, M_DEVBUF);
}
/*
* rm_class_t *
* rmc_newclass(...) - Create a new resource management class at priority
* 'pri' on the interface given by 'ifd'.
*
* nsecPerByte is the data rate of the interface in nanoseconds/byte.
* E.g., 800 for a 10Mb/s ethernet. If the class gets less
* than 100% of the bandwidth, this number should be the
* 'effective' rate for the class. Let f be the
* bandwidth fraction allocated to this class, and let
* nsPerByte be the data rate of the output link in
* nanoseconds/byte. Then nsecPerByte is set to
* nsPerByte / f. E.g., 1600 (= 800 / .5)
* for a class that gets 50% of an ethernet's bandwidth.
*
* action the routine to call when the class is over limit.
*
* maxq max allowable queue size for class (in packets).
*
* parent parent class pointer.
*
* borrow class to borrow from (should be either 'parent' or null).
*
* maxidle max value allowed for class 'idle' time estimate (this
* parameter determines how large an initial burst of packets
* can be before overlimit action is invoked.
*
* offtime how long 'delay' action will delay when class goes over
* limit (this parameter determines the steady-state burst
* size when a class is running over its limit).
*
* Maxidle and offtime have to be computed from the following: If the
* average packet size is s, the bandwidth fraction allocated to this
* class is f, we want to allow b packet bursts, and the gain of the
* averaging filter is g (= 1 - 2^(-RM_FILTER_GAIN)), then:
*
* ptime = s * nsPerByte * (1 - f) / f
* maxidle = ptime * (1 - g^b) / g^b
* minidle = -ptime * (1 / (f - 1))
* offtime = ptime * (1 + 1/(1 - g) * (1 - g^(b - 1)) / g^(b - 1)
*
* Operationally, it's convenient to specify maxidle & offtime in units
* independent of the link bandwidth so the maxidle & offtime passed to
* this routine are the above values multiplied by 8*f/(1000*nsPerByte).
* (The constant factor is a scale factor needed to make the parameters
* integers. This scaling also means that the 'unscaled' values of
* maxidle*nsecPerByte/8 and offtime*nsecPerByte/8 will be in microseconds,
* not nanoseconds.) Also note that the 'idle' filter computation keeps
* an estimate scaled upward by 2^RM_FILTER_GAIN so the passed value of
* maxidle also must be scaled upward by this value. Thus, the passed
* values for maxidle and offtime can be computed as follows:
*
* maxidle = maxidle * 2^RM_FILTER_GAIN * 8 / (1000 * nsecPerByte)
* offtime = offtime * 8 / (1000 * nsecPerByte)
*
* When USE_HRTIME is employed, then maxidle and offtime become:
* maxidle = maxilde * (8.0 / nsecPerByte);
* offtime = offtime * (8.0 / nsecPerByte);
*/
struct rm_class *
rmc_newclass(int pri, struct rm_ifdat *ifd, u_int nsecPerByte,
void (*action)(rm_class_t *, rm_class_t *), int maxq,
struct rm_class *parent, struct rm_class *borrow, u_int maxidle,
int minidle, u_int offtime, int pktsize, int flags)
{
struct rm_class *cl;
struct rm_class *peer;
int s;
if (pri >= RM_MAXPRIO)
return (NULL);
#ifndef ALTQ_RED
if (flags & RMCF_RED) {
#ifdef ALTQ_DEBUG
printf("rmc_newclass: RED not configured for CBQ!\n");
#endif
return (NULL);
}
#endif
#ifndef ALTQ_RIO
if (flags & RMCF_RIO) {
#ifdef ALTQ_DEBUG
printf("rmc_newclass: RIO not configured for CBQ!\n");
#endif
return (NULL);
}
#endif
cl = malloc(sizeof(struct rm_class), M_DEVBUF, M_NOWAIT | M_ZERO);
if (cl == NULL)
return (NULL);
CALLOUT_INIT(&cl->callout_);
cl->q_ = malloc(sizeof(class_queue_t), M_DEVBUF, M_NOWAIT | M_ZERO);
if (cl->q_ == NULL) {
free(cl, M_DEVBUF);
return (NULL);
}
/*
* Class initialization.
*/
cl->children_ = NULL;
cl->parent_ = parent;
cl->borrow_ = borrow;
cl->leaf_ = 1;
cl->ifdat_ = ifd;
cl->pri_ = pri;
cl->allotment_ = RM_NS_PER_SEC / nsecPerByte; /* Bytes per sec */
cl->depth_ = 0;
cl->qthresh_ = 0;
cl->ns_per_byte_ = nsecPerByte;
qlimit(cl->q_) = maxq;
qtype(cl->q_) = Q_DROPHEAD;
qlen(cl->q_) = 0;
cl->flags_ = flags;
#if 1 /* minidle is also scaled in ALTQ */
cl->minidle_ = (minidle * (int)nsecPerByte) / 8;
if (cl->minidle_ > 0)
cl->minidle_ = 0;
#else
cl->minidle_ = minidle;
#endif
cl->maxidle_ = (maxidle * nsecPerByte) / 8;
if (cl->maxidle_ == 0)
cl->maxidle_ = 1;
#if 1 /* offtime is also scaled in ALTQ */
cl->avgidle_ = cl->maxidle_;
cl->offtime_ = ((offtime * nsecPerByte) / 8) >> RM_FILTER_GAIN;
if (cl->offtime_ == 0)
cl->offtime_ = 1;
#else
cl->avgidle_ = 0;
cl->offtime_ = (offtime * nsecPerByte) / 8;
#endif
cl->overlimit = action;
#ifdef ALTQ_RED
if (flags & (RMCF_RED|RMCF_RIO)) {
int red_flags, red_pkttime;
red_flags = 0;
if (flags & RMCF_ECN)
red_flags |= REDF_ECN;
if (flags & RMCF_FLOWVALVE)
red_flags |= REDF_FLOWVALVE;
#ifdef ALTQ_RIO
if (flags & RMCF_CLEARDSCP)
red_flags |= RIOF_CLEARDSCP;
#endif
red_pkttime = nsecPerByte * pktsize / 1000;
if (flags & RMCF_RED) {
cl->red_ = red_alloc(0, 0,
qlimit(cl->q_) * 10/100,
qlimit(cl->q_) * 30/100,
red_flags, red_pkttime);
if (cl->red_ != NULL)
qtype(cl->q_) = Q_RED;
}
#ifdef ALTQ_RIO
else {
cl->red_ = (red_t *)rio_alloc(0, NULL,
red_flags, red_pkttime);
if (cl->red_ != NULL)
qtype(cl->q_) = Q_RIO;
}
#endif
}
#endif /* ALTQ_RED */
/*
* put the class into the class tree
*/
s = splnet();
IFQ_LOCK(ifd->ifq_);
if ((peer = ifd->active_[pri]) != NULL) {
/* find the last class at this pri */
cl->peer_ = peer;
while (peer->peer_ != ifd->active_[pri])
peer = peer->peer_;
peer->peer_ = cl;
} else {
ifd->active_[pri] = cl;
cl->peer_ = cl;
}
if (cl->parent_) {
cl->next_ = parent->children_;
parent->children_ = cl;
parent->leaf_ = 0;
}
/*
* Compute the depth of this class and its ancestors in the class
* hierarchy.
*/
rmc_depth_compute(cl);
/*
* If CBQ's WRR is enabled, then initialize the class WRR state.
*/
if (ifd->wrr_) {
ifd->num_[pri]++;
ifd->alloc_[pri] += cl->allotment_;
rmc_wrr_set_weights(ifd);
}
IFQ_UNLOCK(ifd->ifq_);
splx(s);
return (cl);
}
static struct priq_class *
priq_class_create(struct priq_if *pif, int pri, int qlimit, int flags, int qid)
{
struct priq_class *cl;
int s;
#ifndef ALTQ_RED
if (flags & PRCF_RED) {
#ifdef ALTQ_DEBUG
printf("priq_class_create: RED not configured for PRIQ!\n");
#endif
return (NULL);
}
#endif
#ifndef ALTQ_CODEL
if (flags & PRCF_CODEL) {
#ifdef ALTQ_DEBUG
printf("priq_class_create: CODEL not configured for PRIQ!\n");
#endif
return (NULL);
}
#endif
if ((cl = pif->pif_classes[pri]) != NULL) {
/* modify the class instead of creating a new one */
s = splnet();
IFQ_LOCK(cl->cl_pif->pif_ifq);
if (!qempty(cl->cl_q))
priq_purgeq(cl);
IFQ_UNLOCK(cl->cl_pif->pif_ifq);
splx(s);
#ifdef ALTQ_RIO
if (q_is_rio(cl->cl_q))
rio_destroy((rio_t *)cl->cl_red);
#endif
#ifdef ALTQ_RED
if (q_is_red(cl->cl_q))
red_destroy(cl->cl_red);
#endif
#ifdef ALTQ_CODEL
if (q_is_codel(cl->cl_q))
codel_destroy(cl->cl_codel);
#endif
} else {
cl = malloc(sizeof(struct priq_class), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (cl == NULL)
return (NULL);
cl->cl_q = malloc(sizeof(class_queue_t), M_DEVBUF,
M_NOWAIT | M_ZERO);
if (cl->cl_q == NULL)
goto err_ret;
}
pif->pif_classes[pri] = cl;
if (flags & PRCF_DEFAULTCLASS)
pif->pif_default = cl;
if (qlimit == 0)
qlimit = 50; /* use default */
qlimit(cl->cl_q) = qlimit;
qtype(cl->cl_q) = Q_DROPTAIL;
qlen(cl->cl_q) = 0;
qsize(cl->cl_q) = 0;
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;
#ifdef ALTQ_RED
if (flags & (PRCF_RED|PRCF_RIO)) {
int red_flags, red_pkttime;
red_flags = 0;
if (flags & PRCF_ECN)
red_flags |= REDF_ECN;
#ifdef ALTQ_RIO
if (flags & PRCF_CLEARDSCP)
red_flags |= RIOF_CLEARDSCP;
#endif
if (pif->pif_bandwidth < 8)
red_pkttime = 1000 * 1000 * 1000; /* 1 sec */
else
red_pkttime = (int64_t)pif->pif_ifq->altq_ifp->if_mtu
* 1000 * 1000 * 1000 / (pif->pif_bandwidth / 8);
#ifdef ALTQ_RIO
if (flags & PRCF_RIO) {
cl->cl_red = (red_t *)rio_alloc(0, NULL,
red_flags, red_pkttime);
if (cl->cl_red == NULL)
goto err_ret;
qtype(cl->cl_q) = Q_RIO;
} else
#endif
if (flags & PRCF_RED) {
cl->cl_red = red_alloc(0, 0,
qlimit(cl->cl_q) * 10/100,
qlimit(cl->cl_q) * 30/100,
red_flags, red_pkttime);
if (cl->cl_red == NULL)
goto err_ret;
qtype(cl->cl_q) = Q_RED;
}
}
#endif /* ALTQ_RED */
#ifdef ALTQ_CODEL
if (flags & PRCF_CODEL) {
cl->cl_codel = codel_alloc(5, 100, 0);
if (cl->cl_codel != NULL)
qtype(cl->cl_q) = Q_CODEL;
}
#endif
return (cl);
err_ret:
if (cl->cl_red != NULL) {
#ifdef ALTQ_RIO
if (q_is_rio(cl->cl_q))
rio_destroy((rio_t *)cl->cl_red);
#endif
#ifdef ALTQ_RED
if (q_is_red(cl->cl_q))
red_destroy(cl->cl_red);
#endif
#ifdef ALTQ_CODEL
if (q_is_codel(cl->cl_q))
codel_destroy(cl->cl_codel);
#endif
}
if (cl->cl_q != NULL)
free(cl->cl_q, M_DEVBUF);
free(cl, M_DEVBUF);
return (NULL);
}
