bsd/net/classq/if_classq.h

   1 /*
   2  * Copyright (c) 2011-2013 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         CLASSQRQ_STAT_SC =      5,      /* get service class queue stats */
  50 } cqrq_t;
  51
  52 /* classq purge_sc request argument */
  53 typedef struct cqrq_purge_sc {
  54         mbuf_svc_class_t        sc;     /* (in) service class */
  55         u_int32_t               flow;   /* (in) 0 means all flows */
  56         u_int32_t               packets; /* (out) purged packets */
  57         u_int32_t               bytes;  /* (out) purged bytes */
  58 } cqrq_purge_sc_t;
  59
  60 /* classq throttle request argument */
  61 typedef struct cqrq_throttle {
  62         u_int32_t               set;    /* set or get */
  63         u_int32_t               level;  /* (in/out) throttling level */
  64 } cqrq_throttle_t;
  65
  66 /* classq service class stats request argument */
  67 typedef struct cqrq_stat_sc {
  68         mbuf_svc_class_t        sc;     /* (in) service class */
  69         u_int32_t               packets; /* (out) packets enqueued */
  70         u_int32_t               bytes;  /* (out) bytes enqueued */
  71 } cqrq_stat_sc_t;
  72
  73 #if PF_ALTQ
  74 #include <net/altq/if_altq.h>
  75 #endif /* PF_ALTQ */
  76
  77 /*
  78  * A token-bucket regulator limits the rate that a network driver can
  79  * dequeue packets from the output queue.  Modern cards are able to buffer
  80  * a large amount of packets and dequeue too many packets at a time.  This
  81  * bursty dequeue behavior makes it impossible to schedule packets by
  82  * queueing disciplines.  A token-bucket is used to control the burst size
  83  * in a device independent manner.
  84  */
  85 struct tb_regulator {
  86         u_int64_t       tbr_rate_raw;   /* (unscaled) token bucket rate */
  87         u_int32_t       tbr_percent;    /* token bucket rate in percentage */
  88         int64_t         tbr_rate;       /* (scaled) token bucket rate */
  89         int64_t         tbr_depth;      /* (scaled) token bucket depth */
  90
  91         int64_t         tbr_token;      /* (scaled) current token */
  92         int64_t         tbr_filluptime; /* (scaled) time to fill up bucket */
  93         u_int64_t       tbr_last;       /* last time token was updated */
  94
  95         int             tbr_lastop;     /* last dequeue operation type */
  96                                         /*   needed for poll-and-dequeue */
  97 };
  98
  99 /* simple token bucket meter profile */
 100 struct tb_profile {
 101         u_int64_t       rate;   /* rate in bit-per-sec */
 102         u_int32_t       percent; /* rate in percentage */
 103         u_int32_t       depth;  /* depth in bytes */
 104 };
 105
 106 struct ifclassq;
 107 enum cqdq_op;
 108 enum cqrq;
 109
 110 typedef int (*ifclassq_enq_func)(struct ifclassq *, struct mbuf *);
 111 typedef struct mbuf *(*ifclassq_deq_func)(struct ifclassq *, enum cqdq_op);
 112 typedef struct mbuf *(*ifclassq_deq_sc_func)(struct ifclassq *,
 113     mbuf_svc_class_t, enum cqdq_op);
 114 typedef int (*ifclassq_req_func)(struct ifclassq *, enum cqrq, void *);
 115
 116 /*
 117  * Structure defining a queue for a network interface.
 118  */
 119 struct ifclassq {
 120         decl_lck_mtx_data(, ifcq_lock);
 121
 122         struct ifnet    *ifcq_ifp;      /* back pointer to interface */
 123         u_int32_t       ifcq_len;
 124         u_int32_t       ifcq_maxlen;
 125         struct pktcntr  ifcq_xmitcnt;
 126         struct pktcntr  ifcq_dropcnt;
 127
 128         u_int32_t       ifcq_type;      /* scheduler type */
 129         u_int32_t       ifcq_flags;     /* flags */
 130         u_int32_t       ifcq_sflags;    /* scheduler flags */
 131         void            *ifcq_disc;     /* for scheduler-specific use */
 132         /*
 133          * ifcq_disc_slots[] represents the leaf classes configured for the
 134          * corresponding discpline/scheduler, ordered by their corresponding
 135          * service class index.  Each slot holds the queue ID used to identify
 136          * the class instance, as well as the class instance pointer itself.
 137          * The latter is used during enqueue and dequeue in order to avoid the
 138          * costs associated with looking up the class pointer based on the
 139          * queue ID.  The queue ID is used when querying the statistics from
 140          * user space.
 141          *
 142          * Avoiding the use of queue ID during enqueue and dequeue is made
 143          * possible by virtue of knowing the particular mbuf service class
 144          * associated with the packets.  The service class index of the
 145          * packet is used as the index to ifcq_disc_slots[].
 146          *
 147          * ifcq_disc_slots[] therefore also acts as a lookup table which
 148          * provides for the mapping between MBUF_SC values and the actual
 149          * scheduler classes.
 150          */
 151         struct ifclassq_disc_slot {
 152                 u_int32_t       qid;
 153                 void            *cl;
 154         } ifcq_disc_slots[IFCQ_SC_MAX]; /* for discipline use */
 155
 156         ifclassq_enq_func       ifcq_enqueue;
 157         ifclassq_deq_func       ifcq_dequeue;
 158         ifclassq_deq_sc_func    ifcq_dequeue_sc;
 159         ifclassq_req_func       ifcq_request;
 160
 161         /* token bucket regulator */
 162         struct tb_regulator     ifcq_tbr;       /* TBR */
 163
 164 #if PF_ALTQ
 165         u_int32_t       ifcq_drain;
 166         struct ifaltq   ifcq_altq;
 167 #endif /* PF_ALTQ */
 168 };
 169
 170 #if PF_ALTQ
 171 #define IFCQ_ALTQ(_ifcq)                (&(_ifcq)->ifcq_altq)
 172 #define IFCQ_IS_DRAINING(_ifcq)         ((_ifcq)->ifcq_drain > 0)
 173 #endif /* PF_ALTQ */
 174
 175 /* ifcq_flags */
 176 #define IFCQF_READY      0x01           /* ifclassq supports discipline */
 177 #define IFCQF_ENABLED    0x02           /* ifclassq is in use */
 178 #define IFCQF_TBR        0x04           /* Token Bucket Regulator is in use */
 179
 180 #define IFCQ_IS_READY(_ifcq)            ((_ifcq)->ifcq_flags & IFCQF_READY)
 181 #define IFCQ_IS_ENABLED(_ifcq)          ((_ifcq)->ifcq_flags & IFCQF_ENABLED)
 182 #define IFCQ_TBR_IS_ENABLED(_ifcq)      ((_ifcq)->ifcq_flags & IFCQF_TBR)
 183
 184 /* classq enqueue return value */
 185 #define CLASSQEQ_DROPPED        (-1)    /* packet dropped (freed)  */
 186 #define CLASSQEQ_SUCCESS        0       /* success, packet enqueued */
 187 #define CLASSQEQ_SUCCESS_FC     1       /* packet enqueued; */
 188                                         /*   give flow control feedback */
 189 #define CLASSQEQ_DROPPED_FC     2       /* packet dropped; */
 190                                         /*  give flow control feedback */
 191 #define CLASSQEQ_DROPPED_SP     3       /* packet dropped due to suspension; */
 192                                         /*  give flow control feedback */
 193
 194 /* interface event argument for CLASSQRQ_EVENT */
 195 typedef enum cqev {
 196         CLASSQ_EV_LINK_BANDWIDTH = 1,   /* link bandwidth has changed */
 197         CLASSQ_EV_LINK_LATENCY = 2,     /* link latency has changed */
 198         CLASSQ_EV_LINK_MTU =    3,      /* link MTU has changed */
 199         CLASSQ_EV_LINK_UP =     4,      /* link is now up */
 200         CLASSQ_EV_LINK_DOWN =   5,      /* link is now down */
 201 } cqev_t;
 202 #endif /* BSD_KERNEL_PRIVATE */
 203
 204 #include <net/pktsched/pktsched_priq.h>
 205 #include <net/pktsched/pktsched_fairq.h>
 206 #include <net/pktsched/pktsched_tcq.h>
 207 #include <net/pktsched/pktsched_cbq.h>
 208 #include <net/pktsched/pktsched_hfsc.h>
 209 #include <net/pktsched/pktsched_qfq.h>
 210
 211 #ifdef __cplusplus
 212 extern "C" {
 213 #endif
 214
 215 struct if_ifclassq_stats {
 216         u_int32_t       ifqs_len;
 217         u_int32_t       ifqs_maxlen;
 218         struct pktcntr  ifqs_xmitcnt;
 219         struct pktcntr  ifqs_dropcnt;
 220         u_int32_t       ifqs_scheduler;
 221         union {
 222                 struct priq_classstats  ifqs_priq_stats;
 223                 struct fairq_classstats ifqs_fairq_stats;
 224                 struct tcq_classstats   ifqs_tcq_stats;
 225                 struct cbq_classstats   ifqs_cbq_stats;
 226                 struct hfsc_classstats  ifqs_hfsc_stats;
 227                 struct qfq_classstats   ifqs_qfq_stats;
 228         };
 229 } __attribute__((aligned(8)));
 230
 231 #ifdef __cplusplus
 232 }
 233 #endif
 234
 235 #ifdef BSD_KERNEL_PRIVATE
 236 /*
 237  * For ifclassq lock
 238  */
 239 #define IFCQ_LOCK_ASSERT_HELD(_ifcq)                                    \
 240         lck_mtx_assert(&(_ifcq)->ifcq_lock, LCK_MTX_ASSERT_OWNED)
 241
 242 #define IFCQ_LOCK_ASSERT_NOTHELD(_ifcq)                                 \
 243         lck_mtx_assert(&(_ifcq)->ifcq_lock, LCK_MTX_ASSERT_NOTOWNED)
 244
 245 #define IFCQ_LOCK(_ifcq)                                                \
 246         lck_mtx_lock(&(_ifcq)->ifcq_lock)
 247
 248 #define IFCQ_LOCK_SPIN(_ifcq)                                           \
 249         lck_mtx_lock_spin(&(_ifcq)->ifcq_lock)
 250
 251 #define IFCQ_CONVERT_LOCK(_ifcq) do {                                   \
 252         IFCQ_LOCK_ASSERT_HELD(_ifcq);                                   \
 253         lck_mtx_convert_spin(&(_ifcq)->ifcq_lock);                      \
 254 } while (0)
 255
 256 #define IFCQ_UNLOCK(_ifcq)                                              \
 257         lck_mtx_unlock(&(_ifcq)->ifcq_lock)
 258
 259 /*
 260  * For ifclassq operations
 261  */
 262 #define IFCQ_ENQUEUE(_ifq, _m, _err) do {                               \
 263         (_err) = (*(_ifq)->ifcq_enqueue)(_ifq, _m);                     \
 264 } while (0)
 265
 266 #define IFCQ_DEQUEUE(_ifq, _m) do {                                     \
 267         (_m) = (*(_ifq)->ifcq_dequeue)(_ifq, CLASSQDQ_REMOVE);          \
 268 } while (0)
 269
 270 #define IFCQ_DEQUEUE_SC(_ifq, _sc, _m) do {                             \
 271         (_m) = (*(_ifq)->ifcq_dequeue_sc)(_ifq, _sc, CLASSQDQ_REMOVE);  \
 272 } while (0)
 273
 274 #define IFCQ_TBR_DEQUEUE(_ifcq, _m) do {                                \
 275         (_m) = ifclassq_tbr_dequeue(_ifcq, CLASSQDQ_REMOVE);            \
 276 } while (0)
 277
 278 #define IFCQ_TBR_DEQUEUE_SC(_ifcq, _sc, _m) do {                        \
 279         (_m) = ifclassq_tbr_dequeue_sc(_ifcq, CLASSQDQ_REMOVE, _sc);    \
 280 } while (0)
 281
 282 #define IFCQ_POLL(_ifq, _m) do {                                        \
 283         (_m) = (*(_ifq)->ifcq_dequeue)(_ifq, CLASSQDQ_POLL);            \
 284 } while (0)
 285
 286 #define IFCQ_POLL_SC(_ifq, _sc, _m) do {                                \
 287         (_m) = (*(_ifq)->ifcq_dequeue_sc)(_ifq, _sc, CLASSQDQ_POLL);    \
 288 } while (0)
 289
 290 #define IFCQ_TBR_POLL(_ifcq, _m) do {                                   \
 291         (_m) = ifclassq_tbr_dequeue(_ifcq, CLASSQDQ_POLL);              \
 292 } while (0)
 293
 294 #define IFCQ_TBR_POLL_SC(_ifcq, _sc, _m) do {                           \
 295         (_m) = ifclassq_tbr_dequeue_sc(_ifcq, CLASSQDQ_POLL, _sc);      \
 296 } while (0)
 297
 298 #define IFCQ_PURGE(_ifq) do {                                           \
 299         (void) (*(_ifq)->ifcq_request)(_ifq, CLASSQRQ_PURGE, NULL);     \
 300 } while (0)
 301
 302 #define IFCQ_PURGE_SC(_ifq, _sc, _flow, _packets, _bytes) do {          \
 303         cqrq_purge_sc_t _req = { _sc, _flow, 0, 0 };                    \
 304         (void) (*(_ifq)->ifcq_request)(_ifq, CLASSQRQ_PURGE_SC, &_req); \
 305         (_packets) = _req.packets;                                      \
 306         (_bytes) = _req.bytes;                                          \
 307 } while (0)
 308
 309 #define IFCQ_UPDATE(_ifq, _ev) do {                                     \
 310         (void) (*(_ifq)->ifcq_request)(_ifq, CLASSQRQ_EVENT,            \
 311             (void *)(_ev));                                             \
 312 } while (0)
 313
 314 #define IFCQ_SET_THROTTLE(_ifq, _level, _err) do {                      \
 315         cqrq_throttle_t _req = { 1, _level };                           \
 316         (_err) = (*(_ifq)->ifcq_request)                                \
 317             (_ifq, CLASSQRQ_THROTTLE, &_req);                           \
 318 } while (0)
 319
 320 #define IFCQ_GET_THROTTLE(_ifq, _level, _err) do {                      \
 321         cqrq_throttle_t _req = { 0, IFNET_THROTTLE_OFF };               \
 322         (_err) = (*(_ifq)->ifcq_request)                                \
 323             (_ifq, CLASSQRQ_THROTTLE, &_req);                           \
 324         (_level) = _req.level;                                          \
 325 } while (0)
 326
 327 #define IFCQ_LEN_SC(_ifq, _sc, _packets, _bytes, _err) do {             \
 328         cqrq_stat_sc_t _req = { _sc, 0, 0 };                            \
 329         (_err) = (*(ifq)->ifcq_request)(_ifq, CLASSQRQ_STAT_SC, &_req); \
 330         if ((_packets) != NULL)                                         \
 331                 (*(_packets)) = _req.packets;                           \
 332         if ((_bytes) != NULL)                                           \
 333                 (*(_bytes)) = _req.bytes;                               \
 334 } while (0)
 335
 336 #define IFCQ_LEN(_ifcq)         ((_ifcq)->ifcq_len)
 337 #define IFCQ_QFULL(_ifcq)       (IFCQ_LEN(_ifcq) >= (_ifcq)->ifcq_maxlen)
 338 #define IFCQ_IS_EMPTY(_ifcq)    (IFCQ_LEN(_ifcq) == 0)
 339 #define IFCQ_INC_LEN(_ifcq)     (IFCQ_LEN(_ifcq)++)
 340 #define IFCQ_DEC_LEN(_ifcq)     (IFCQ_LEN(_ifcq)--)
 341 #define IFCQ_MAXLEN(_ifcq)      ((_ifcq)->ifcq_maxlen)
 342 #define IFCQ_SET_MAXLEN(_ifcq, _len) ((_ifcq)->ifcq_maxlen = (_len))
 343
 344 #define IFCQ_XMIT_ADD(_ifcq, _pkt, _len) do {                           \
 345         PKTCNTR_ADD(&(_ifcq)->ifcq_xmitcnt, _pkt, _len);                \
 346 } while (0)
 347
 348 #define IFCQ_DROP_ADD(_ifcq, _pkt, _len) do {                           \
 349         PKTCNTR_ADD(&(_ifcq)->ifcq_dropcnt, _pkt, _len);                \
 350 } while (0)
 351
 352 extern int ifclassq_setup(struct ifnet *, u_int32_t, boolean_t);
 353 extern void ifclassq_teardown(struct ifnet *);
 354 extern int ifclassq_pktsched_setup(struct ifclassq *);
 355 extern void ifclassq_set_maxlen(struct ifclassq *, u_int32_t);
 356 extern u_int32_t ifclassq_get_maxlen(struct ifclassq *);
 357 extern int ifclassq_get_len(struct ifclassq *, mbuf_svc_class_t,
 358     u_int32_t *, u_int32_t *);
 359 extern errno_t ifclassq_enqueue(struct ifclassq *, struct mbuf *);
 360 extern errno_t ifclassq_dequeue(struct ifclassq *, u_int32_t, struct mbuf **,
 361     struct mbuf **, u_int32_t *, u_int32_t *);
 362 extern errno_t ifclassq_dequeue_sc(struct ifclassq *, mbuf_svc_class_t,
 363     u_int32_t, struct mbuf **, struct mbuf **, u_int32_t *, u_int32_t *);
 364 extern struct mbuf *ifclassq_poll(struct ifclassq *);
 365 extern struct mbuf *ifclassq_poll_sc(struct ifclassq *, mbuf_svc_class_t);
 366 extern void ifclassq_update(struct ifclassq *, cqev_t);
 367 extern int ifclassq_attach(struct ifclassq *, u_int32_t, void *,
 368     ifclassq_enq_func, ifclassq_deq_func, ifclassq_deq_sc_func,
 369     ifclassq_req_func);
 370 extern int ifclassq_detach(struct ifclassq *);
 371 extern int ifclassq_getqstats(struct ifclassq *, u_int32_t,
 372     void *, u_int32_t *);
 373 extern const char *ifclassq_ev2str(cqev_t);
 374 extern int ifclassq_tbr_set(struct ifclassq *, struct tb_profile *, boolean_t);
 375 extern struct mbuf *ifclassq_tbr_dequeue(struct ifclassq *, int);
 376 extern struct mbuf *ifclassq_tbr_dequeue_sc(struct ifclassq *, int,
 377     mbuf_svc_class_t);
 378 #endif /* BSD_KERNEL_PRIVATE */
 379 #endif /* PRIVATE */
 380 #endif /* _NET_CLASSQ_IF_CLASSQ_H_ */