net/classq/classq_subr.c

91 	struct ifclassq *ifq = &ifp->if_snd;
94 	IFCQ_LOCK(ifq);
95 	VERIFY(IFCQ_IS_EMPTY(ifq));
96 	ifq->ifcq_ifp = ifp;
97 	IFCQ_LEN(ifq) = 0;
98 	bzero(&ifq->ifcq_xmitcnt, sizeof (ifq->ifcq_xmitcnt));
99 	bzero(&ifq->ifcq_dropcnt, sizeof (ifq->ifcq_dropcnt));
101 	VERIFY(!IFCQ_TBR_IS_ENABLED(ifq));
102 	VERIFY(ifq->ifcq_type == PKTSCHEDT_NONE);
103 	VERIFY(ifq->ifcq_flags == 0);
104 	VERIFY(ifq->ifcq_sflags == 0);
105 	VERIFY(ifq->ifcq_disc == NULL);
106 	VERIFY(ifq->ifcq_enqueue == NULL);
107 	VERIFY(ifq->ifcq_dequeue == NULL);
108 	VERIFY(ifq->ifcq_dequeue_sc == NULL);
109 	VERIFY(ifq->ifcq_request == NULL);
114 		if ((maxlen = IFCQ_MAXLEN(ifq)) == 0)
116 		IFCQ_SET_MAXLEN(ifq, maxlen);
118 		ifq->ifcq_sflags = sflags;
119 		err = ifclassq_pktsched_setup(ifq);
121 			ifq->ifcq_flags = (IFCQF_READY | IFCQF_ENABLED);
125 	ifq->ifcq_drain = 0;
126 	IFCQ_ALTQ(ifq)->altq_ifcq = ifq;
127 	VERIFY(IFCQ_ALTQ(ifq)->altq_type == ALTQT_NONE);
128 	VERIFY(IFCQ_ALTQ(ifq)->altq_flags == 0);
129 	VERIFY(IFCQ_ALTQ(ifq)->altq_disc == NULL);
130 	VERIFY(IFCQ_ALTQ(ifq)->altq_enqueue == NULL);
131 	VERIFY(IFCQ_ALTQ(ifq)->altq_dequeue == NULL);
132 	VERIFY(IFCQ_ALTQ(ifq)->altq_dequeue_sc == NULL);
133 	VERIFY(IFCQ_ALTQ(ifq)->altq_request == NULL);
137 		ALTQ_SET_READY(IFCQ_ALTQ(ifq));
139 		ALTQ_CLEAR_READY(IFCQ_ALTQ(ifq));
141 	IFCQ_UNLOCK(ifq);
149 	struct ifclassq *ifq = &ifp->if_snd;
151 	IFCQ_LOCK(ifq);
153 	if (ALTQ_IS_READY(IFCQ_ALTQ(ifq))) {
154 		if (ALTQ_IS_ENABLED(IFCQ_ALTQ(ifq)))
155 			altq_disable(IFCQ_ALTQ(ifq));
156 		if (ALTQ_IS_ATTACHED(IFCQ_ALTQ(ifq)))
157 			altq_detach(IFCQ_ALTQ(ifq));
158 		IFCQ_ALTQ(ifq)->altq_flags = 0;
160 	ifq->ifcq_drain = 0;
161 	IFCQ_ALTQ(ifq)->altq_ifcq = NULL;
162 	VERIFY(IFCQ_ALTQ(ifq)->altq_type == ALTQT_NONE);
163 	VERIFY(IFCQ_ALTQ(ifq)->altq_flags == 0);
164 	VERIFY(IFCQ_ALTQ(ifq)->altq_disc == NULL);
165 	VERIFY(IFCQ_ALTQ(ifq)->altq_enqueue == NULL);
166 	VERIFY(IFCQ_ALTQ(ifq)->altq_dequeue == NULL);
167 	VERIFY(IFCQ_ALTQ(ifq)->altq_dequeue_sc == NULL);
168 	VERIFY(IFCQ_ALTQ(ifq)->altq_request == NULL);
171 	if (IFCQ_IS_READY(ifq)) {
172 		if (IFCQ_TBR_IS_ENABLED(ifq)) {
174 			(void) ifclassq_tbr_set(ifq, &tb, FALSE);
176 		(void) pktsched_teardown(ifq);
177 		ifq->ifcq_flags = 0;
179 	ifq->ifcq_sflags = 0;
181 	VERIFY(IFCQ_IS_EMPTY(ifq));
182 	VERIFY(!IFCQ_TBR_IS_ENABLED(ifq));
183 	VERIFY(ifq->ifcq_type == PKTSCHEDT_NONE);
184 	VERIFY(ifq->ifcq_flags == 0);
185 	VERIFY(ifq->ifcq_sflags == 0);
186 	VERIFY(ifq->ifcq_disc == NULL);
187 	VERIFY(ifq->ifcq_enqueue == NULL);
188 	VERIFY(ifq->ifcq_dequeue == NULL);
189 	VERIFY(ifq->ifcq_dequeue_sc == NULL);
190 	VERIFY(ifq->ifcq_request == NULL);
191 	IFCQ_LEN(ifq) = 0;
192 	IFCQ_MAXLEN(ifq) = 0;
193 	bzero(&ifq->ifcq_xmitcnt, sizeof (ifq->ifcq_xmitcnt));
194 	bzero(&ifq->ifcq_dropcnt, sizeof (ifq->ifcq_dropcnt));
196 	IFCQ_UNLOCK(ifq);
200 ifclassq_pktsched_setup(struct ifclassq *ifq)
202 	struct ifnet *ifp = ifq->ifcq_ifp;
205 	IFCQ_LOCK_ASSERT_HELD(ifq);
210 		err = pktsched_setup(ifq, PKTSCHEDT_TCQ, ifq->ifcq_sflags);
214 		err = pktsched_setup(ifq, PKTSCHEDT_QFQ, ifq->ifcq_sflags);
226 ifclassq_set_maxlen(struct ifclassq *ifq, u_int32_t maxqlen)
228 	IFCQ_LOCK(ifq);
231 	IFCQ_SET_MAXLEN(ifq, maxqlen);
232 	IFCQ_UNLOCK(ifq);
236 ifclassq_get_maxlen(struct ifclassq *ifq)
238 	return (IFCQ_MAXLEN(ifq));
242 ifclassq_get_len(struct ifclassq *ifq)
244 	return (IFCQ_LEN(ifq));
248 ifclassq_enqueue(struct ifclassq *ifq, struct mbuf *m)
252 	IFCQ_LOCK_SPIN(ifq);
255 	if (ALTQ_IS_ENABLED(IFCQ_ALTQ(ifq))) {
256 		ALTQ_ENQUEUE(IFCQ_ALTQ(ifq), m, err);
258 		u_int32_t qlen = IFCQ_LEN(ifq);
259 		IFCQ_ENQUEUE(ifq, m, err);
260 		if (IFCQ_LEN(ifq) > qlen)
261 			ifq->ifcq_drain += (IFCQ_LEN(ifq) - qlen);
264 	IFCQ_ENQUEUE(ifq, m, err);
267 	IFCQ_UNLOCK(ifq);
273 ifclassq_dequeue(struct ifclassq *ifq, u_int32_t limit, struct mbuf **head,
276 	return (ifclassq_dequeue_common(ifq, MBUF_SC_UNSPEC, limit, head, tail,
281 ifclassq_dequeue_sc(struct ifclassq *ifq, mbuf_svc_class_t sc,
285 	return (ifclassq_dequeue_common(ifq, sc, limit, head, tail,
290 ifclassq_dequeue_common(struct ifclassq *ifq, mbuf_svc_class_t sc,
294 	struct ifnet *ifp = ifq->ifcq_ifp;
298 	struct ifaltq *altq = IFCQ_ALTQ(ifq);
308 	ifq = &ifp->if_snd;
309 	IFCQ_LOCK_SPIN(ifq);
316 		qlen = IFCQ_LEN(ifq);
317 		draining = IFCQ_IS_DRAINING(ifq);
320 			if (IFCQ_TBR_IS_ENABLED(ifq))
321 				IFCQ_TBR_DEQUEUE_SC(ifq, sc, *head);
323 				IFCQ_DEQUEUE_SC(ifq, sc, *head);
329 			if (IFCQ_TBR_IS_ENABLED(ifq))
330 				IFCQ_TBR_DEQUEUE(ifq, *head);
332 				IFCQ_DEQUEUE(ifq, *head);
340 			VERIFY(ifq->ifcq_drain >= (qlen - IFCQ_LEN(ifq)));
341 			ifq->ifcq_drain -= (qlen - IFCQ_LEN(ifq));
345 			if (IFCQ_TBR_IS_ENABLED(ifq))
346 				IFCQ_TBR_DEQUEUE_SC(ifq, sc, *head);
348 				IFCQ_DEQUEUE_SC(ifq, sc, *head);
350 			if (IFCQ_TBR_IS_ENABLED(ifq))
351 				IFCQ_TBR_DEQUEUE(ifq, *head);
353 				IFCQ_DEQUEUE(ifq, *head);
373 	IFCQ_UNLOCK(ifq);
386 ifclassq_poll(struct ifclassq *ifq)
388 	return (ifclassq_poll_common(ifq, MBUF_SC_UNSPEC, FALSE));
392 ifclassq_poll_sc(struct ifclassq *ifq, mbuf_svc_class_t sc)
394 	return (ifclassq_poll_common(ifq, sc, TRUE));
398 ifclassq_poll_common(struct ifclassq *ifq, mbuf_svc_class_t sc,
402 	struct ifaltq *altq = IFCQ_ALTQ(ifq);
410 		if (IFCQ_TBR_IS_ENABLED(ifq))
411 			IFCQ_TBR_POLL_SC(ifq, sc, m);
412 		else if (IFCQ_IS_DRAINING(ifq))
413 			IFCQ_POLL_SC(ifq, sc, m);
419 		if (IFCQ_TBR_IS_ENABLED(ifq))
420 			IFCQ_TBR_POLL(ifq, m);
421 		else if (IFCQ_IS_DRAINING(ifq))
422 			IFCQ_POLL(ifq, m);
430 		if (IFCQ_TBR_IS_ENABLED(ifq))
431 			IFCQ_TBR_POLL_SC(ifq, sc, m);
433 			IFCQ_POLL_SC(ifq, sc, m);
435 		if (IFCQ_TBR_IS_ENABLED(ifq))
436 			IFCQ_TBR_POLL(ifq, m);
438 			IFCQ_POLL(ifq, m);
446 ifclassq_update(struct ifclassq *ifq, cqev_t ev)
448 	IFCQ_LOCK_ASSERT_HELD(ifq);
449 	VERIFY(IFCQ_IS_READY(ifq));
452 	if (ALTQ_IS_ENABLED(IFCQ_ALTQ(ifq)))
453 		ALTQ_UPDATE(IFCQ_ALTQ(ifq), ev);
455 	IFCQ_UPDATE(ifq, ev);
459 ifclassq_attach(struct ifclassq *ifq, u_int32_t type, void *discipline,
463 	IFCQ_LOCK_ASSERT_HELD(ifq);
465 	VERIFY(ifq->ifcq_disc == NULL);
470 	ifq->ifcq_type = type;
471 	ifq->ifcq_disc = discipline;
472 	ifq->ifcq_enqueue = enqueue;
473 	ifq->ifcq_dequeue = dequeue;
474 	ifq->ifcq_dequeue_sc = dequeue_sc;
475 	ifq->ifcq_request = request;
481 ifclassq_detach(struct ifclassq *ifq)
483 	IFCQ_LOCK_ASSERT_HELD(ifq);
485 	VERIFY(ifq->ifcq_disc == NULL);
487 	ifq->ifcq_type = PKTSCHEDT_NONE;
488 	ifq->ifcq_disc = NULL;
489 	ifq->ifcq_enqueue = NULL;
490 	ifq->ifcq_dequeue = NULL;
491 	ifq->ifcq_dequeue_sc = NULL;
492 	ifq->ifcq_request = NULL;
498 ifclassq_getqstats(struct ifclassq *ifq, u_int32_t qid, void *ubuf,
511 	IFCQ_LOCK(ifq);
512 	if (!IFCQ_IS_READY(ifq)) {
513 		IFCQ_UNLOCK(ifq);
518 	ifqs->ifqs_len = IFCQ_LEN(ifq);
519 	ifqs->ifqs_maxlen = IFCQ_MAXLEN(ifq);
520 	*(&ifqs->ifqs_xmitcnt) = *(&ifq->ifcq_xmitcnt);
521 	*(&ifqs->ifqs_dropcnt) = *(&ifq->ifcq_dropcnt);
522 	ifqs->ifqs_scheduler = ifq->ifcq_type;
524 	err = pktsched_getqstats(ifq, qid, ifqs);
525 	IFCQ_UNLOCK(ifq);
578 ifclassq_tbr_dequeue(struct ifclassq *ifq, int op)
580 	return (ifclassq_tbr_dequeue_common(ifq, op, MBUF_SC_UNSPEC, FALSE));
584 ifclassq_tbr_dequeue_sc(struct ifclassq *ifq, int op, mbuf_svc_class_t sc)
586 	return (ifclassq_tbr_dequeue_common(ifq, op, sc, TRUE));
590 ifclassq_tbr_dequeue_common(struct ifclassq *ifq, int op,
598 	IFCQ_LOCK_ASSERT_HELD(ifq);
601 	VERIFY(IFCQ_TBR_IS_ENABLED(ifq));
603 	tbr = &ifq->ifcq_tbr;
630 	if (IFCQ_IS_DRAINING(ifq)) {
634 				IFCQ_POLL_SC(ifq, sc, m);
636 				IFCQ_POLL(ifq, m);
639 				IFCQ_DEQUEUE_SC(ifq, sc, m);
641 				IFCQ_DEQUEUE(ifq, m);
645 		struct ifaltq *altq = IFCQ_ALTQ(ifq);
669 ifclassq_tbr_set(struct ifclassq *ifq, struct tb_profile *profile,
673 	struct ifnet *ifp = ifq->ifcq_ifp;
676 	IFCQ_LOCK_ASSERT_HELD(ifq);
677 	VERIFY(IFCQ_IS_READY(ifq));
681 	tbr = &ifq->ifcq_tbr;
696 		if (!IFCQ_TBR_IS_ENABLED(ifq))
703 		ifq->ifcq_flags &= ~IFCQF_TBR;
707 			ifclassq_update(ifq, CLASSQ_EV_LINK_SPEED);
713 		    (ifq->ifcq_flags & IFCQF_TBR) ? "reconfigured" :
721 	ifq->ifcq_flags |= IFCQF_TBR;
791 		ifclassq_update(ifq, CLASSQ_EV_LINK_SPEED);