[apple/xnu.git] / bsd / net / classq / if_classq.h

/*
 * Copyright (c) 2011-2012 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

#ifndef _NET_CLASSQ_IF_CLASSQ_H_
#define	_NET_CLASSQ_IF_CLASSQ_H_

#ifdef PRIVATE
#define	IFCQ_SC_MAX		10		/* max number of queues */

#ifdef BSD_KERNEL_PRIVATE
#include <net/classq/classq.h>
/* classq dequeue op arg */
typedef enum cqdq_op {
	CLASSQDQ_REMOVE =	1,	/* dequeue mbuf from the queue */
	CLASSQDQ_POLL =		2,	/* don't dequeue mbuf from the queue */
} cqdq_op_t;

/* classq request types */
typedef enum cqrq {
	CLASSQRQ_PURGE =	1,	/* purge all packets */
	CLASSQRQ_PURGE_SC =	2,	/* purge service class (and flow) */
	CLASSQRQ_EVENT =	3,	/* interface events */
	CLASSQRQ_THROTTLE =	4,	/* throttle packets */
} cqrq_t;

/* classq purge_sc request argument */
typedef struct cqrq_purge_sc {
	mbuf_svc_class_t	sc;	/* (in) service class */
	u_int32_t		flow;	/* (in) 0 means all flows */
	u_int32_t		packets; /* (out) purged packets */
	u_int32_t		bytes;	/* (out) purged bytes */
} cqrq_purge_sc_t;

/* classq throttle request argument */
typedef struct cqrq_throttle {
	u_int32_t		set;	/* set or get */
	u_int32_t		level;	/* (in/out) throttling level */
} cqrq_throttle_t;

#if PF_ALTQ
#include <net/altq/if_altq.h>
#endif /* PF_ALTQ */

/*
 * A token-bucket regulator limits the rate that a network driver can
 * dequeue packets from the output queue.  Modern cards are able to buffer
 * a large amount of packets and dequeue too many packets at a time.  This
 * bursty dequeue behavior makes it impossible to schedule packets by
 * queueing disciplines.  A token-bucket is used to control the burst size
 * in a device independent manner.
 */
struct tb_regulator {
	u_int64_t	tbr_rate_raw;	/* (unscaled) token bucket rate */
	u_int32_t	tbr_percent;	/* token bucket rate in percentage */
	int64_t		tbr_rate;	/* (scaled) token bucket rate */
	int64_t		tbr_depth;	/* (scaled) token bucket depth */

	int64_t		tbr_token;	/* (scaled) current token */
	int64_t		tbr_filluptime;	/* (scaled) time to fill up bucket */
	u_int64_t	tbr_last;	/* last time token was updated */

	int		tbr_lastop;	/* last dequeue operation type */
					/*   needed for poll-and-dequeue */
};

/* simple token bucket meter profile */
struct tb_profile {
	u_int64_t	rate;	/* rate in bit-per-sec */
	u_int32_t	percent; /* rate in percentage */
	u_int32_t	depth;	/* depth in bytes */
};

struct ifclassq;
enum cqdq_op;
enum cqrq;

typedef int (*ifclassq_enq_func)(struct ifclassq *, struct mbuf *);
typedef struct mbuf *(*ifclassq_deq_func)(struct ifclassq *, enum cqdq_op);
typedef struct mbuf *(*ifclassq_deq_sc_func)(struct ifclassq *,
    mbuf_svc_class_t, enum cqdq_op);
typedef int (*ifclassq_req_func)(struct ifclassq *, enum cqrq, void *);

/*
 * Structure defining a queue for a network interface.
 */
struct ifclassq {
	decl_lck_mtx_data(, ifcq_lock);

	struct ifnet	*ifcq_ifp;	/* back pointer to interface */
	u_int32_t	ifcq_len;
	u_int32_t	ifcq_maxlen;
	struct pktcntr	ifcq_xmitcnt;
	struct pktcntr	ifcq_dropcnt;

	u_int32_t	ifcq_type;	/* scheduler type */
	u_int32_t	ifcq_flags;	/* flags */
	u_int32_t	ifcq_sflags;	/* scheduler flags */
	void		*ifcq_disc;	/* for scheduler-specific use */
	/*
	 * ifcq_disc_slots[] represents the leaf classes configured for the
	 * corresponding discpline/scheduler, ordered by their corresponding
	 * service class index.  Each slot holds the queue ID used to identify
	 * the class instance, as well as the class instance pointer itself.
	 * The latter is used during enqueue and dequeue in order to avoid the
	 * costs associated with looking up the class pointer based on the
	 * queue ID.  The queue ID is used when querying the statistics from
	 * user space.
	 *
	 * Avoiding the use of queue ID during enqueue and dequeue is made
	 * possible by virtue of knowing the particular mbuf service class
	 * associated with the packets.  The service class index of the
	 * packet is used as the index to ifcq_disc_slots[].
	 *
	 * ifcq_disc_slots[] therefore also acts as a lookup table which
	 * provides for the mapping between MBUF_SC values and the actual
	 * scheduler classes.
	 */
	struct ifclassq_disc_slot {
		u_int32_t	qid;
		void		*cl;
	} ifcq_disc_slots[IFCQ_SC_MAX]; /* for discipline use */

	ifclassq_enq_func	ifcq_enqueue;
	ifclassq_deq_func	ifcq_dequeue;
	ifclassq_deq_sc_func	ifcq_dequeue_sc;
	ifclassq_req_func	ifcq_request;

	/* token bucket regulator */
	struct tb_regulator	ifcq_tbr;	/* TBR */

#if PF_ALTQ
	u_int32_t	ifcq_drain;
	struct ifaltq	ifcq_altq;
#endif /* PF_ALTQ */
};

#if PF_ALTQ
#define	IFCQ_ALTQ(_ifcq)		(&(_ifcq)->ifcq_altq)
#define	IFCQ_IS_DRAINING(_ifcq)		((_ifcq)->ifcq_drain > 0)
#endif /* PF_ALTQ */

/* ifcq_flags */
#define	IFCQF_READY	 0x01		/* ifclassq supports discipline */
#define	IFCQF_ENABLED	 0x02		/* ifclassq is in use */
#define	IFCQF_TBR	 0x04		/* Token Bucket Regulator is in use */

#define	IFCQ_IS_READY(_ifcq)		((_ifcq)->ifcq_flags & IFCQF_READY)
#define	IFCQ_IS_ENABLED(_ifcq)		((_ifcq)->ifcq_flags & IFCQF_ENABLED)
#define	IFCQ_TBR_IS_ENABLED(_ifcq)	((_ifcq)->ifcq_flags & IFCQF_TBR)

/* classq enqueue return value */
#define CLASSQEQ_DROPPED	(-1)	/* packet dropped (freed)  */
#define CLASSQEQ_SUCCESS	0	/* success, packet enqueued */
#define CLASSQEQ_SUCCESS_FC	1	/* packet enqueued; */
					/*   give flow control feedback */
#define CLASSQEQ_DROPPED_FC	2	/* packet dropped; */
					/*  give flow control feedback */
#define	CLASSQEQ_DROPPED_SP	3	/* packet dropped due to suspension; */
					/*  give flow control feedback */

/* interface event argument for CLASSQRQ_EVENT */
typedef enum cqev {
	CLASSQ_EV_LINK_SPEED =	1,	/* link speed has changed */
	CLASSQ_EV_LINK_MTU =	2,	/* link MTU has changed */
	CLASSQ_EV_LINK_UP =	3,	/* link is now up */
	CLASSQ_EV_LINK_DOWN =	4,	/* link is now down */
} cqev_t;
#endif /* BSD_KERNEL_PRIVATE */

#include <net/pktsched/pktsched_priq.h>
#include <net/pktsched/pktsched_fairq.h>
#include <net/pktsched/pktsched_tcq.h>
#include <net/pktsched/pktsched_cbq.h>
#include <net/pktsched/pktsched_hfsc.h>
#include <net/pktsched/pktsched_qfq.h>

#ifdef __cplusplus
extern "C" {
#endif

struct if_ifclassq_stats {
	u_int32_t	ifqs_len;
	u_int32_t	ifqs_maxlen;
	struct pktcntr	ifqs_xmitcnt;
	struct pktcntr	ifqs_dropcnt;
	u_int32_t	ifqs_scheduler;
	union {
		struct priq_classstats	ifqs_priq_stats;
		struct fairq_classstats	ifqs_fairq_stats;
		struct tcq_classstats	ifqs_tcq_stats;
		struct cbq_classstats	ifqs_cbq_stats;
		struct hfsc_classstats	ifqs_hfsc_stats;
		struct qfq_classstats	ifqs_qfq_stats;
	};
} __attribute__((aligned(8)));

#ifdef __cplusplus
}
#endif

#ifdef BSD_KERNEL_PRIVATE
/*
 * For ifclassq lock
 */
#define	IFCQ_LOCK_ASSERT_HELD(_ifcq)					\
	lck_mtx_assert(&(_ifcq)->ifcq_lock, LCK_MTX_ASSERT_OWNED)

#define	IFCQ_LOCK_ASSERT_NOTHELD(_ifcq)					\
	lck_mtx_assert(&(_ifcq)->ifcq_lock, LCK_MTX_ASSERT_NOTOWNED)

#define	IFCQ_LOCK(_ifcq)						\
	lck_mtx_lock(&(_ifcq)->ifcq_lock)

#define	IFCQ_LOCK_SPIN(_ifcq)						\
	lck_mtx_lock_spin(&(_ifcq)->ifcq_lock)

#define	IFCQ_CONVERT_LOCK(_ifcq) do {					\
	IFCQ_LOCK_ASSERT_HELD(_ifcq);					\
	lck_mtx_convert_spin(&(_ifcq)->ifcq_lock);			\
} while (0)

#define	IFCQ_UNLOCK(_ifcq)						\
	lck_mtx_unlock(&(_ifcq)->ifcq_lock)

/*
 * For ifclassq operations
 */
#define	IFCQ_ENQUEUE(_ifq, _m, _err) do {				\
	(_err) = (*(_ifq)->ifcq_enqueue)(_ifq, _m);			\
} while (0)

#define	IFCQ_DEQUEUE(_ifq, _m) do {					\
	(_m) = (*(_ifq)->ifcq_dequeue)(_ifq, CLASSQDQ_REMOVE);		\
} while (0)

#define	IFCQ_DEQUEUE_SC(_ifq, _sc, _m) do {				\
	(_m) = (*(_ifq)->ifcq_dequeue_sc)(_ifq, _sc, CLASSQDQ_REMOVE);	\
} while (0)

#define	IFCQ_TBR_DEQUEUE(_ifcq, _m) do {				\
	(_m) = ifclassq_tbr_dequeue(_ifcq, CLASSQDQ_REMOVE);		\
} while (0)

#define	IFCQ_TBR_DEQUEUE_SC(_ifcq, _sc, _m) do {			\
	(_m) = ifclassq_tbr_dequeue_sc(_ifcq, CLASSQDQ_REMOVE, _sc);	\
} while (0)

#define	IFCQ_POLL(_ifq, _m) do {					\
	(_m) = (*(_ifq)->ifcq_dequeue)(_ifq, CLASSQDQ_POLL);		\
} while (0)

#define	IFCQ_POLL_SC(_ifq, _sc, _m) do {				\
	(_m) = (*(_ifq)->ifcq_dequeue_sc)(_ifq, _sc, CLASSQDQ_POLL);	\
} while (0)

#define	IFCQ_TBR_POLL(_ifcq, _m) do {					\
	(_m) = ifclassq_tbr_dequeue(_ifcq, CLASSQDQ_POLL);		\
} while (0)

#define	IFCQ_TBR_POLL_SC(_ifcq, _sc, _m) do {				\
	(_m) = ifclassq_tbr_dequeue_sc(_ifcq, CLASSQDQ_POLL, _sc);	\
} while (0)

#define	IFCQ_PURGE(_ifq) do {						\
	(void) (*(_ifq)->ifcq_request)(_ifq, CLASSQRQ_PURGE, NULL);	\
} while (0)

#define	IFCQ_PURGE_SC(_ifq, _sc, _flow, _packets, _bytes) do {		\
	cqrq_purge_sc_t _req = { _sc, _flow, 0, 0 };			\
	(void) (*(_ifq)->ifcq_request)(_ifq, CLASSQRQ_PURGE_SC, &_req);	\
	(_packets) = _req.packets;					\
	(_bytes) = _req.bytes;						\
} while (0)

#define	IFCQ_UPDATE(_ifq, _ev) do {					\
	(void) (*(_ifq)->ifcq_request)(_ifq, CLASSQRQ_EVENT,		\
	    (void *)(_ev));						\
} while (0)

#define	IFCQ_SET_THROTTLE(_ifq, _level, _err) do {			\
	cqrq_throttle_t _req = { 1, _level };				\
	(_err) = (*(_ifq)->ifcq_request)				\
	    (_ifq, CLASSQRQ_THROTTLE, &_req);				\
} while (0)

#define	IFCQ_GET_THROTTLE(_ifq, _level, _err) do {			\
	cqrq_throttle_t _req = { 0, IFNET_THROTTLE_OFF };		\
	(_err) = (*(_ifq)->ifcq_request)				\
	    (_ifq, CLASSQRQ_THROTTLE, &_req);				\
	(_level) = _req.level;						\
} while (0)

#define	IFCQ_LEN(_ifcq)		((_ifcq)->ifcq_len)
#define	IFCQ_QFULL(_ifcq)	(IFCQ_LEN(_ifcq) >= (_ifcq)->ifcq_maxlen)
#define	IFCQ_IS_EMPTY(_ifcq)	(IFCQ_LEN(_ifcq) == 0)
#define	IFCQ_INC_LEN(_ifcq)	(IFCQ_LEN(_ifcq)++)
#define	IFCQ_DEC_LEN(_ifcq)	(IFCQ_LEN(_ifcq)--)
#define	IFCQ_MAXLEN(_ifcq)	((_ifcq)->ifcq_maxlen)
#define	IFCQ_SET_MAXLEN(_ifcq, _len) ((_ifcq)->ifcq_maxlen = (_len))

#define	IFCQ_XMIT_ADD(_ifcq, _pkt, _len) do {				\
	PKTCNTR_ADD(&(_ifcq)->ifcq_xmitcnt, _pkt, _len);		\
} while (0)

#define	IFCQ_DROP_ADD(_ifcq, _pkt, _len) do {				\
	PKTCNTR_ADD(&(_ifcq)->ifcq_dropcnt, _pkt, _len);		\
} while (0)

extern int ifclassq_setup(struct ifnet *, u_int32_t, boolean_t);
extern void ifclassq_teardown(struct ifnet *);
extern int ifclassq_pktsched_setup(struct ifclassq *);
extern void ifclassq_set_maxlen(struct ifclassq *, u_int32_t);
extern u_int32_t ifclassq_get_maxlen(struct ifclassq *);
extern u_int32_t ifclassq_get_len(struct ifclassq *);
extern errno_t ifclassq_enqueue(struct ifclassq *, struct mbuf *);
extern errno_t ifclassq_dequeue(struct ifclassq *, u_int32_t, struct mbuf **,
    struct mbuf **, u_int32_t *, u_int32_t *);
extern errno_t ifclassq_dequeue_sc(struct ifclassq *, mbuf_svc_class_t,
    u_int32_t, struct mbuf **, struct mbuf **, u_int32_t *, u_int32_t *);
extern struct mbuf *ifclassq_poll(struct ifclassq *);
extern struct mbuf *ifclassq_poll_sc(struct ifclassq *, mbuf_svc_class_t);
extern void ifclassq_update(struct ifclassq *, cqev_t);
extern int ifclassq_attach(struct ifclassq *, u_int32_t, void *,
    ifclassq_enq_func, ifclassq_deq_func, ifclassq_deq_sc_func,
    ifclassq_req_func);
extern int ifclassq_detach(struct ifclassq *);
extern int ifclassq_getqstats(struct ifclassq *, u_int32_t,
    void *, u_int32_t *);
extern const char *ifclassq_ev2str(cqev_t);
extern int ifclassq_tbr_set(struct ifclassq *, struct tb_profile *, boolean_t);
extern struct mbuf *ifclassq_tbr_dequeue(struct ifclassq *, int);
extern struct mbuf *ifclassq_tbr_dequeue_sc(struct ifclassq *, int,
    mbuf_svc_class_t);
#endif /* BSD_KERNEL_PRIVATE */
#endif /* PRIVATE */
#endif /* _NET_CLASSQ_IF_CLASSQ_H_ */
Commit	Line	Data
316670eb A	1	/*
	2	* Copyright (c) 2011-2012 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
	29	#ifndef _NET_CLASSQ_IF_CLASSQ_H_
	30	#define _NET_CLASSQ_IF_CLASSQ_H_
	31
	32	#ifdef PRIVATE
	33	#define IFCQ_SC_MAX 10 /* max number of queues */
	34
	35	#ifdef BSD_KERNEL_PRIVATE
	36	#include <net/classq/classq.h>
	37	/* classq dequeue op arg */
	38	typedef enum cqdq_op {
	39	CLASSQDQ_REMOVE = 1, /* dequeue mbuf from the queue */
	40	CLASSQDQ_POLL = 2, /* don't dequeue mbuf from the queue */
	41	} cqdq_op_t;
	42
	43	/* classq request types */
	44	typedef enum cqrq {
	45	CLASSQRQ_PURGE = 1, /* purge all packets */
	46	CLASSQRQ_PURGE_SC = 2, /* purge service class (and flow) */
	47	CLASSQRQ_EVENT = 3, /* interface events */
	48	CLASSQRQ_THROTTLE = 4, /* throttle packets */
	49	} cqrq_t;
	50
	51	/* classq purge_sc request argument */
	52	typedef struct cqrq_purge_sc {
	53	mbuf_svc_class_t sc; /* (in) service class */
	54	u_int32_t flow; /* (in) 0 means all flows */
	55	u_int32_t packets; /* (out) purged packets */
	56	u_int32_t bytes; /* (out) purged bytes */
	57	} cqrq_purge_sc_t;
	58
	59	/* classq throttle request argument */
	60	typedef struct cqrq_throttle {
	61	u_int32_t set; /* set or get */
	62	u_int32_t level; /* (in/out) throttling level */
	63	} cqrq_throttle_t;
	64
65	#if PF_ALTQ
66	#include <net/altq/if_altq.h>
67	#endif /* PF_ALTQ */
68
69	/*
70	* A token-bucket regulator limits the rate that a network driver can
71	* dequeue packets from the output queue. Modern cards are able to buffer
72	* a large amount of packets and dequeue too many packets at a time. This
73	* bursty dequeue behavior makes it impossible to schedule packets by
74	* queueing disciplines. A token-bucket is used to control the burst size
75	* in a device independent manner.
76	*/
77	struct tb_regulator {
78	u_int64_t tbr_rate_raw; /* (unscaled) token bucket rate */
79	u_int32_t tbr_percent; /* token bucket rate in percentage */
80	int64_t tbr_rate; /* (scaled) token bucket rate */
81	int64_t tbr_depth; /* (scaled) token bucket depth */
82
83	int64_t tbr_token; /* (scaled) current token */
84	int64_t tbr_filluptime; /* (scaled) time to fill up bucket */
85	u_int64_t tbr_last; /* last time token was updated */
86
87	int tbr_lastop; /* last dequeue operation type */
88	/* needed for poll-and-dequeue */
89	};
90
91	/* simple token bucket meter profile */
92	struct tb_profile {
93	u_int64_t rate; /* rate in bit-per-sec */
94	u_int32_t percent; /* rate in percentage */
95	u_int32_t depth; /* depth in bytes */
96	};
97
98	struct ifclassq;
99	enum cqdq_op;
100	enum cqrq;
101
102	typedef int (ifclassq_enq_func)(struct ifclassq , struct mbuf *);
103	typedef struct mbuf (ifclassq_deq_func)(struct ifclassq *, enum cqdq_op);
104	typedef struct mbuf (ifclassq_deq_sc_func)(struct ifclassq *,
105	mbuf_svc_class_t, enum cqdq_op);
106	typedef int (ifclassq_req_func)(struct ifclassq , enum cqrq, void *);
107
108	/*
109	* Structure defining a queue for a network interface.
110	*/
111	struct ifclassq {
112	decl_lck_mtx_data(, ifcq_lock);
113
114	struct ifnet ifcq_ifp; / back pointer to interface */
115	u_int32_t ifcq_len;
116	u_int32_t ifcq_maxlen;
117	struct pktcntr ifcq_xmitcnt;
118	struct pktcntr ifcq_dropcnt;
119
120	u_int32_t ifcq_type; /* scheduler type */
121	u_int32_t ifcq_flags; /* flags */
122	u_int32_t ifcq_sflags; /* scheduler flags */
123	void ifcq_disc; / for scheduler-specific use */
124	/*
125	* ifcq_disc_slots[] represents the leaf classes configured for the
126	* corresponding discpline/scheduler, ordered by their corresponding
127	* service class index. Each slot holds the queue ID used to identify
128	* the class instance, as well as the class instance pointer itself.
129	* The latter is used during enqueue and dequeue in order to avoid the
130	* costs associated with looking up the class pointer based on the
131	* queue ID. The queue ID is used when querying the statistics from
132	* user space.
133	*
134	* Avoiding the use of queue ID during enqueue and dequeue is made
135	* possible by virtue of knowing the particular mbuf service class
136	* associated with the packets. The service class index of the
137	* packet is used as the index to ifcq_disc_slots[].
138	*
139	* ifcq_disc_slots[] therefore also acts as a lookup table which
140	* provides for the mapping between MBUF_SC values and the actual
141	* scheduler classes.
142	*/
143	struct ifclassq_disc_slot {
144	u_int32_t qid;
145	void *cl;
146	} ifcq_disc_slots[IFCQ_SC_MAX]; /* for discipline use */
147
148	ifclassq_enq_func ifcq_enqueue;
149	ifclassq_deq_func ifcq_dequeue;
150	ifclassq_deq_sc_func ifcq_dequeue_sc;
151	ifclassq_req_func ifcq_request;
152
153	/* token bucket regulator */
154	struct tb_regulator ifcq_tbr; /* TBR */
155
156	#if PF_ALTQ
157	u_int32_t ifcq_drain;
158	struct ifaltq ifcq_altq;
159	#endif /* PF_ALTQ */
160	};
161
162	#if PF_ALTQ
163	#define IFCQ_ALTQ(_ifcq) (&(_ifcq)->ifcq_altq)
164	#define IFCQ_IS_DRAINING(_ifcq) ((_ifcq)->ifcq_drain > 0)
165	#endif /* PF_ALTQ */
166
167	/* ifcq_flags */
168	#define IFCQF_READY 0x01 /* ifclassq supports discipline */
169	#define IFCQF_ENABLED 0x02 /* ifclassq is in use */
170	#define IFCQF_TBR 0x04 /* Token Bucket Regulator is in use */
171
172	#define IFCQ_IS_READY(_ifcq) ((_ifcq)->ifcq_flags & IFCQF_READY)
173	#define IFCQ_IS_ENABLED(_ifcq) ((_ifcq)->ifcq_flags & IFCQF_ENABLED)
174	#define IFCQ_TBR_IS_ENABLED(_ifcq) ((_ifcq)->ifcq_flags & IFCQF_TBR)
175
176	/* classq enqueue return value */
177	#define CLASSQEQ_DROPPED (-1) /* packet dropped (freed) */
178	#define CLASSQEQ_SUCCESS 0 /* success, packet enqueued */
179	#define CLASSQEQ_SUCCESS_FC 1 /* packet enqueued; */
180	/* give flow control feedback */
181	#define CLASSQEQ_DROPPED_FC 2 /* packet dropped; */
182	/* give flow control feedback */
183	#define CLASSQEQ_DROPPED_SP 3 /* packet dropped due to suspension; */
184	/* give flow control feedback */
185
186	/* interface event argument for CLASSQRQ_EVENT */
187	typedef enum cqev {
188	CLASSQ_EV_LINK_SPEED = 1, /* link speed has changed */
189	CLASSQ_EV_LINK_MTU = 2, /* link MTU has changed */
190	CLASSQ_EV_LINK_UP = 3, /* link is now up */
191	CLASSQ_EV_LINK_DOWN = 4, /* link is now down */
192	} cqev_t;
193	#endif /* BSD_KERNEL_PRIVATE */
194
195	#include <net/pktsched/pktsched_priq.h>
196	#include <net/pktsched/pktsched_fairq.h>
197	#include <net/pktsched/pktsched_tcq.h>
198	#include <net/pktsched/pktsched_cbq.h>
199	#include <net/pktsched/pktsched_hfsc.h>
200	#include <net/pktsched/pktsched_qfq.h>
201
202	#ifdef __cplusplus
203	extern "C" {
204	#endif
205
206	struct if_ifclassq_stats {
207	u_int32_t ifqs_len;
208	u_int32_t ifqs_maxlen;
209	struct pktcntr ifqs_xmitcnt;
210	struct pktcntr ifqs_dropcnt;
211	u_int32_t ifqs_scheduler;
212	union {
213	struct priq_classstats ifqs_priq_stats;
214	struct fairq_classstats ifqs_fairq_stats;
215	struct tcq_classstats ifqs_tcq_stats;
216	struct cbq_classstats ifqs_cbq_stats;
217	struct hfsc_classstats ifqs_hfsc_stats;
218	struct qfq_classstats ifqs_qfq_stats;
219	};
220	} __attribute__((aligned(8)));
221
222	#ifdef __cplusplus
223	}
224	#endif
225
226	#ifdef BSD_KERNEL_PRIVATE
227	/*
228	* For ifclassq lock
229	*/
230	#define IFCQ_LOCK_ASSERT_HELD(_ifcq) \
231	lck_mtx_assert(&(_ifcq)->ifcq_lock, LCK_MTX_ASSERT_OWNED)
232
233	#define IFCQ_LOCK_ASSERT_NOTHELD(_ifcq) \
234	lck_mtx_assert(&(_ifcq)->ifcq_lock, LCK_MTX_ASSERT_NOTOWNED)
235
236	#define IFCQ_LOCK(_ifcq) \
237	lck_mtx_lock(&(_ifcq)->ifcq_lock)
238
239	#define IFCQ_LOCK_SPIN(_ifcq) \
240	lck_mtx_lock_spin(&(_ifcq)->ifcq_lock)
241
242	#define IFCQ_CONVERT_LOCK(_ifcq) do { \
243	IFCQ_LOCK_ASSERT_HELD(_ifcq); \
244	lck_mtx_convert_spin(&(_ifcq)->ifcq_lock); \
245	} while (0)
246
247	#define IFCQ_UNLOCK(_ifcq) \
248	lck_mtx_unlock(&(_ifcq)->ifcq_lock)
249
250	/*
251	* For ifclassq operations
252	*/
253	#define IFCQ_ENQUEUE(_ifq, _m, _err) do { \
254	(_err) = (*(_ifq)->ifcq_enqueue)(_ifq, _m); \
255	} while (0)
256
257	#define IFCQ_DEQUEUE(_ifq, _m) do { \
258	(_m) = (*(_ifq)->ifcq_dequeue)(_ifq, CLASSQDQ_REMOVE); \
259	} while (0)
260
261	#define IFCQ_DEQUEUE_SC(_ifq, _sc, _m) do { \
262	(_m) = (*(_ifq)->ifcq_dequeue_sc)(_ifq, _sc, CLASSQDQ_REMOVE); \
263	} while (0)
264
265	#define IFCQ_TBR_DEQUEUE(_ifcq, _m) do { \
266	(_m) = ifclassq_tbr_dequeue(_ifcq, CLASSQDQ_REMOVE); \
267	} while (0)
268
269	#define IFCQ_TBR_DEQUEUE_SC(_ifcq, _sc, _m) do { \
270	(_m) = ifclassq_tbr_dequeue_sc(_ifcq, CLASSQDQ_REMOVE, _sc); \
271	} while (0)
272
273	#define IFCQ_POLL(_ifq, _m) do { \
274	(_m) = (*(_ifq)->ifcq_dequeue)(_ifq, CLASSQDQ_POLL); \
275	} while (0)
276
277	#define IFCQ_POLL_SC(_ifq, _sc, _m) do { \
278	(_m) = (*(_ifq)->ifcq_dequeue_sc)(_ifq, _sc, CLASSQDQ_POLL); \
279	} while (0)
280
281	#define IFCQ_TBR_POLL(_ifcq, _m) do { \
282	(_m) = ifclassq_tbr_dequeue(_ifcq, CLASSQDQ_POLL); \
283	} while (0)
284
285	#define IFCQ_TBR_POLL_SC(_ifcq, _sc, _m) do { \
286	(_m) = ifclassq_tbr_dequeue_sc(_ifcq, CLASSQDQ_POLL, _sc); \
287	} while (0)
288
289	#define IFCQ_PURGE(_ifq) do { \
290	(void) (*(_ifq)->ifcq_request)(_ifq, CLASSQRQ_PURGE, NULL); \
291	} while (0)
292
293	#define IFCQ_PURGE_SC(_ifq, _sc, _flow, _packets, _bytes) do { \
294	cqrq_purge_sc_t _req = { _sc, _flow, 0, 0 }; \
295	(void) (*(_ifq)->ifcq_request)(_ifq, CLASSQRQ_PURGE_SC, &_req); \
296	(_packets) = _req.packets; \
297	(_bytes) = _req.bytes; \
298	} while (0)
299
300	#define IFCQ_UPDATE(_ifq, _ev) do { \
301	(void) (*(_ifq)->ifcq_request)(_ifq, CLASSQRQ_EVENT, \
302	(void *)(_ev)); \
303	} while (0)
304
305	#define IFCQ_SET_THROTTLE(_ifq, _level, _err) do { \
306	cqrq_throttle_t _req = { 1, _level }; \
307	(_err) = (*(_ifq)->ifcq_request) \
308	(_ifq, CLASSQRQ_THROTTLE, &_req); \
309	} while (0)
310
311	#define IFCQ_GET_THROTTLE(_ifq, _level, _err) do { \
312	cqrq_throttle_t _req = { 0, IFNET_THROTTLE_OFF }; \
313	(_err) = (*(_ifq)->ifcq_request) \
314	(_ifq, CLASSQRQ_THROTTLE, &_req); \
315	(_level) = _req.level; \
316	} while (0)
317
318	#define IFCQ_LEN(_ifcq) ((_ifcq)->ifcq_len)
319	#define IFCQ_QFULL(_ifcq) (IFCQ_LEN(_ifcq) >= (_ifcq)->ifcq_maxlen)
320	#define IFCQ_IS_EMPTY(_ifcq) (IFCQ_LEN(_ifcq) == 0)
321	#define IFCQ_INC_LEN(_ifcq) (IFCQ_LEN(_ifcq)++)
322	#define IFCQ_DEC_LEN(_ifcq) (IFCQ_LEN(_ifcq)--)
323	#define IFCQ_MAXLEN(_ifcq) ((_ifcq)->ifcq_maxlen)
324	#define IFCQ_SET_MAXLEN(_ifcq, _len) ((_ifcq)->ifcq_maxlen = (_len))
325
326	#define IFCQ_XMIT_ADD(_ifcq, _pkt, _len) do { \
327	PKTCNTR_ADD(&(_ifcq)->ifcq_xmitcnt, _pkt, _len); \
328	} while (0)
329
330	#define IFCQ_DROP_ADD(_ifcq, _pkt, _len) do { \
331	PKTCNTR_ADD(&(_ifcq)->ifcq_dropcnt, _pkt, _len); \
332	} while (0)
333
334	extern int ifclassq_setup(struct ifnet *, u_int32_t, boolean_t);
335	extern void ifclassq_teardown(struct ifnet *);
336	extern int ifclassq_pktsched_setup(struct ifclassq *);
337	extern void ifclassq_set_maxlen(struct ifclassq *, u_int32_t);
338	extern u_int32_t ifclassq_get_maxlen(struct ifclassq *);
339	extern u_int32_t ifclassq_get_len(struct ifclassq *);
340	extern errno_t ifclassq_enqueue(struct ifclassq , struct mbuf );
341	extern errno_t ifclassq_dequeue(struct ifclassq , u_int32_t, struct mbuf *,
342	struct mbuf *, u_int32_t , u_int32_t *);
343	extern errno_t ifclassq_dequeue_sc(struct ifclassq *, mbuf_svc_class_t,
344	u_int32_t, struct mbuf , struct mbuf , u_int32_t , u_int32_t );
345	extern struct mbuf ifclassq_poll(struct ifclassq );
346	extern struct mbuf ifclassq_poll_sc(struct ifclassq , mbuf_svc_class_t);
347	extern void ifclassq_update(struct ifclassq *, cqev_t);
348	extern int ifclassq_attach(struct ifclassq , u_int32_t, void ,
349	ifclassq_enq_func, ifclassq_deq_func, ifclassq_deq_sc_func,
350	ifclassq_req_func);
351	extern int ifclassq_detach(struct ifclassq *);
352	extern int ifclassq_getqstats(struct ifclassq *, u_int32_t,
353	void , u_int32_t );
354	extern const char *ifclassq_ev2str(cqev_t);
355	extern int ifclassq_tbr_set(struct ifclassq , struct tb_profile , boolean_t);
356	extern struct mbuf ifclassq_tbr_dequeue(struct ifclassq , int);
357	extern struct mbuf ifclassq_tbr_dequeue_sc(struct ifclassq , int,
358	mbuf_svc_class_t);
359	#endif /* BSD_KERNEL_PRIVATE */
360	#endif /* PRIVATE */
361	#endif /* _NET_CLASSQ_IF_CLASSQ_H_ */