1 files changed, 606 insertions, 0 deletions

diff --git a/include/linux/pkt_sched.h b/include/linux/pkt_sched.h
new file mode 100644
index 00000000000..c5336705921
--- /dev/null
+++ b/include/linux/pkt_sched.h
@@ -0,0 +1,606 @@
+#ifndef __LINUX_PKT_SCHED_H
+#define __LINUX_PKT_SCHED_H
+
+#include <linux/types.h>
+
+/* Logical priority bands not depending on specific packet scheduler.
+   Every scheduler will map them to real traffic classes, if it has
+   no more precise mechanism to classify packets.
+
+   These numbers have no special meaning, though their coincidence
+   with obsolete IPv6 values is not occasional :-). New IPv6 drafts
+   preferred full anarchy inspired by diffserv group.
+
+   Note: TC_PRIO_BESTEFFORT does not mean that it is the most unhappy
+   class, actually, as rule it will be handled with more care than
+   filler or even bulk.
+ */
+
+#define TC_PRIO_BESTEFFORT              0
+#define TC_PRIO_FILLER                  1
+#define TC_PRIO_BULK                    2
+#define TC_PRIO_INTERACTIVE_BULK        4
+#define TC_PRIO_INTERACTIVE             6
+#define TC_PRIO_CONTROL                 7
+
+#define TC_PRIO_MAX                     15
+
+/* Generic queue statistics, available for all the elements.
+   Particular schedulers may have also their private records.
+ */
+
+struct tc_stats {
+        __u64   bytes;                  /* NUmber of enqueues bytes */
+        __u32   packets;                /* Number of enqueued packets   */
+        __u32   drops;                  /* Packets dropped because of lack of resources */
+        __u32   overlimits;             /* Number of throttle events when this
+                                         * flow goes out of allocated bandwidth */
+        __u32   bps;                    /* Current flow byte rate */
+        __u32   pps;                    /* Current flow packet rate */
+        __u32   qlen;
+        __u32   backlog;
+};
+
+struct tc_estimator {
+        signed char     interval;
+        unsigned char   ewma_log;
+};
+
+/* "Handles"
+   ---------
+
+    All the traffic control objects have 32bit identifiers, or "handles".
+
+    They can be considered as opaque numbers from user API viewpoint,
+    but actually they always consist of two fields: major and
+    minor numbers, which are interpreted by kernel specially,
+    that may be used by applications, though not recommended.
+
+    F.e. qdisc handles always have minor number equal to zero,
+    classes (or flows) have major equal to parent qdisc major, and
+    minor uniquely identifying class inside qdisc.
+
+    Macros to manipulate handles:
+ */
+
+#define TC_H_MAJ_MASK (0xFFFF0000U)
+#define TC_H_MIN_MASK (0x0000FFFFU)
+#define TC_H_MAJ(h) ((h)&TC_H_MAJ_MASK)
+#define TC_H_MIN(h) ((h)&TC_H_MIN_MASK)
+#define TC_H_MAKE(maj,min) (((maj)&TC_H_MAJ_MASK)|((min)&TC_H_MIN_MASK))
+
+#define TC_H_UNSPEC     (0U)
+#define TC_H_ROOT       (0xFFFFFFFFU)
+#define TC_H_INGRESS    (0xFFFFFFF1U)
+
+struct tc_ratespec {
+        unsigned char   cell_log;
+        unsigned char   __reserved;
+        unsigned short  overhead;
+        short           cell_align;
+        unsigned short  mpu;
+        __u32           rate;
+};
+
+#define TC_RTAB_SIZE    1024
+
+struct tc_sizespec {
+        unsigned char   cell_log;
+        unsigned char   size_log;
+        short           cell_align;
+        int             overhead;
+        unsigned int    linklayer;
+        unsigned int    mpu;
+        unsigned int    mtu;
+        unsigned int    tsize;
+};
+
+enum {
+        TCA_STAB_UNSPEC,
+        TCA_STAB_BASE,
+        TCA_STAB_DATA,
+        __TCA_STAB_MAX
+};
+
+#define TCA_STAB_MAX (__TCA_STAB_MAX - 1)
+
+/* FIFO section */
+
+struct tc_fifo_qopt {
+        __u32   limit;  /* Queue length: bytes for bfifo, packets for pfifo */
+};
+
+/* PRIO section */
+
+#define TCQ_PRIO_BANDS  16
+#define TCQ_MIN_PRIO_BANDS 2
+
+struct tc_prio_qopt {
+        int     bands;                  /* Number of bands */
+        __u8    priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> PRIO band */
+};
+
+/* MULTIQ section */
+
+struct tc_multiq_qopt {
+        __u16   bands;                  /* Number of bands */
+        __u16   max_bands;              /* Maximum number of queues */
+};
+
+/* TBF section */
+
+struct tc_tbf_qopt {
+        struct tc_ratespec rate;
+        struct tc_ratespec peakrate;
+        __u32           limit;
+        __u32           buffer;
+        __u32           mtu;
+};
+
+enum {
+        TCA_TBF_UNSPEC,
+        TCA_TBF_PARMS,
+        TCA_TBF_RTAB,
+        TCA_TBF_PTAB,
+        __TCA_TBF_MAX,
+};
+
+#define TCA_TBF_MAX (__TCA_TBF_MAX - 1)
+
+
+/* TEQL section */
+
+/* TEQL does not require any parameters */
+
+/* SFQ section */
+
+struct tc_sfq_qopt {
+        unsigned        quantum;        /* Bytes per round allocated to flow */
+        int             perturb_period; /* Period of hash perturbation */
+        __u32           limit;          /* Maximal packets in queue */
+        unsigned        divisor;        /* Hash divisor  */
+        unsigned        flows;          /* Maximal number of flows  */
+};
+
+struct tc_sfq_xstats {
+        __s32           allot;
+};
+
+/*
+ *  NOTE: limit, divisor and flows are hardwired to code at the moment.
+ *
+ *      limit=flows=128, divisor=1024;
+ *
+ *      The only reason for this is efficiency, it is possible
+ *      to change these parameters in compile time.
+ */
+
+/* RED section */
+
+enum {
+        TCA_RED_UNSPEC,
+        TCA_RED_PARMS,
+        TCA_RED_STAB,
+        __TCA_RED_MAX,
+};
+
+#define TCA_RED_MAX (__TCA_RED_MAX - 1)
+
+struct tc_red_qopt {
+        __u32           limit;          /* HARD maximal queue length (bytes)    */
+        __u32           qth_min;        /* Min average length threshold (bytes) */
+        __u32           qth_max;        /* Max average length threshold (bytes) */
+        unsigned char   Wlog;           /* log(W)               */
+        unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
+        unsigned char   Scell_log;      /* cell size for idle damping */
+        unsigned char   flags;
+#define TC_RED_ECN      1
+#define TC_RED_HARDDROP 2
+};
+
+struct tc_red_xstats {
+        __u32           early;          /* Early drops */
+        __u32           pdrop;          /* Drops due to queue limits */
+        __u32           other;          /* Drops due to drop() calls */
+        __u32           marked;         /* Marked packets */
+};
+
+/* GRED section */
+
+#define MAX_DPs 16
+
+enum {
+       TCA_GRED_UNSPEC,
+       TCA_GRED_PARMS,
+       TCA_GRED_STAB,
+       TCA_GRED_DPS,
+           __TCA_GRED_MAX,
+};
+
+#define TCA_GRED_MAX (__TCA_GRED_MAX - 1)
+
+struct tc_gred_qopt {
+        __u32           limit;        /* HARD maximal queue length (bytes)    */
+        __u32           qth_min;      /* Min average length threshold (bytes) */
+        __u32           qth_max;      /* Max average length threshold (bytes) */
+        __u32           DP;           /* up to 2^32 DPs */
+        __u32           backlog;
+        __u32           qave;
+        __u32           forced;
+        __u32           early;
+        __u32           other;
+        __u32           pdrop;
+        __u8            Wlog;         /* log(W)               */
+        __u8            Plog;         /* log(P_max/(qth_max-qth_min)) */
+        __u8            Scell_log;    /* cell size for idle damping */
+        __u8            prio;         /* prio of this VQ */
+        __u32           packets;
+        __u32           bytesin;
+};
+
+/* gred setup */
+struct tc_gred_sopt {
+        __u32           DPs;
+        __u32           def_DP;
+        __u8            grio;
+        __u8            flags;
+        __u16           pad1;
+};
+
+/* CHOKe section */
+
+enum {
+        TCA_CHOKE_UNSPEC,
+        TCA_CHOKE_PARMS,
+        TCA_CHOKE_STAB,
+        __TCA_CHOKE_MAX,
+};
+
+#define TCA_CHOKE_MAX (__TCA_CHOKE_MAX - 1)
+
+struct tc_choke_qopt {
+        __u32           limit;          /* Hard queue length (packets)  */
+        __u32           qth_min;        /* Min average threshold (packets) */
+        __u32           qth_max;        /* Max average threshold (packets) */
+        unsigned char   Wlog;           /* log(W)               */
+        unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
+        unsigned char   Scell_log;      /* cell size for idle damping */
+        unsigned char   flags;          /* see RED flags */
+};
+
+struct tc_choke_xstats {
+        __u32           early;          /* Early drops */
+        __u32           pdrop;          /* Drops due to queue limits */
+        __u32           other;          /* Drops due to drop() calls */
+        __u32           marked;         /* Marked packets */
+        __u32           matched;        /* Drops due to flow match */
+};
+
+/* HTB section */
+#define TC_HTB_NUMPRIO          8
+#define TC_HTB_MAXDEPTH         8
+#define TC_HTB_PROTOVER         3 /* the same as HTB and TC's major */
+
+struct tc_htb_opt {
+        struct tc_ratespec      rate;
+        struct tc_ratespec      ceil;
+        __u32   buffer;
+        __u32   cbuffer;
+        __u32   quantum;
+        __u32   level;          /* out only */
+        __u32   prio;
+};
+struct tc_htb_glob {
+        __u32 version;          /* to match HTB/TC */
+        __u32 rate2quantum;     /* bps->quantum divisor */
+        __u32 defcls;           /* default class number */
+        __u32 debug;            /* debug flags */
+
+        /* stats */
+        __u32 direct_pkts; /* count of non shapped packets */
+};
+enum {
+        TCA_HTB_UNSPEC,
+        TCA_HTB_PARMS,
+        TCA_HTB_INIT,
+        TCA_HTB_CTAB,
+        TCA_HTB_RTAB,
+        __TCA_HTB_MAX,
+};
+
+#define TCA_HTB_MAX (__TCA_HTB_MAX - 1)
+
+struct tc_htb_xstats {
+        __u32 lends;
+        __u32 borrows;
+        __u32 giants;   /* too big packets (rate will not be accurate) */
+        __u32 tokens;
+        __u32 ctokens;
+};
+
+/* HFSC section */
+
+struct tc_hfsc_qopt {
+        __u16   defcls;         /* default class */
+};
+
+struct tc_service_curve {
+        __u32   m1;             /* slope of the first segment in bps */
+        __u32   d;              /* x-projection of the first segment in us */
+        __u32   m2;             /* slope of the second segment in bps */
+};
+
+struct tc_hfsc_stats {
+        __u64   work;           /* total work done */
+        __u64   rtwork;         /* work done by real-time criteria */
+        __u32   period;         /* current period */
+        __u32   level;          /* class level in hierarchy */
+};
+
+enum {
+        TCA_HFSC_UNSPEC,
+        TCA_HFSC_RSC,
+        TCA_HFSC_FSC,
+        TCA_HFSC_USC,
+        __TCA_HFSC_MAX,
+};
+
+#define TCA_HFSC_MAX (__TCA_HFSC_MAX - 1)
+
+
+/* CBQ section */
+
+#define TC_CBQ_MAXPRIO          8
+#define TC_CBQ_MAXLEVEL         8
+#define TC_CBQ_DEF_EWMA         5
+
+struct tc_cbq_lssopt {
+        unsigned char   change;
+        unsigned char   flags;
+#define TCF_CBQ_LSS_BOUNDED     1
+#define TCF_CBQ_LSS_ISOLATED    2
+        unsigned char   ewma_log;
+        unsigned char   level;
+#define TCF_CBQ_LSS_FLAGS       1
+#define TCF_CBQ_LSS_EWMA        2
+#define TCF_CBQ_LSS_MAXIDLE     4
+#define TCF_CBQ_LSS_MINIDLE     8
+#define TCF_CBQ_LSS_OFFTIME     0x10
+#define TCF_CBQ_LSS_AVPKT       0x20
+        __u32           maxidle;
+        __u32           minidle;
+        __u32           offtime;
+        __u32           avpkt;
+};
+
+struct tc_cbq_wrropt {
+        unsigned char   flags;
+        unsigned char   priority;
+        unsigned char   cpriority;
+        unsigned char   __reserved;
+        __u32           allot;
+        __u32           weight;
+};
+
+struct tc_cbq_ovl {
+        unsigned char   strategy;
+#define TC_CBQ_OVL_CLASSIC      0
+#define TC_CBQ_OVL_DELAY        1
+#define TC_CBQ_OVL_LOWPRIO      2
+#define TC_CBQ_OVL_DROP         3
+#define TC_CBQ_OVL_RCLASSIC     4
+        unsigned char   priority2;
+        __u16           pad;
+        __u32           penalty;
+};
+
+struct tc_cbq_police {
+        unsigned char   police;
+        unsigned char   __res1;
+        unsigned short  __res2;
+};
+
+struct tc_cbq_fopt {
+        __u32           split;
+        __u32           defmap;
+        __u32           defchange;
+};
+
+struct tc_cbq_xstats {
+        __u32           borrows;
+        __u32           overactions;
+        __s32           avgidle;
+        __s32           undertime;
+};
+
+enum {
+        TCA_CBQ_UNSPEC,
+        TCA_CBQ_LSSOPT,
+        TCA_CBQ_WRROPT,
+        TCA_CBQ_FOPT,
+        TCA_CBQ_OVL_STRATEGY,
+        TCA_CBQ_RATE,
+        TCA_CBQ_RTAB,
+        TCA_CBQ_POLICE,
+        __TCA_CBQ_MAX,
+};
+
+#define TCA_CBQ_MAX     (__TCA_CBQ_MAX - 1)
+
+/* dsmark section */
+
+enum {
+        TCA_DSMARK_UNSPEC,
+        TCA_DSMARK_INDICES,
+        TCA_DSMARK_DEFAULT_INDEX,
+        TCA_DSMARK_SET_TC_INDEX,
+        TCA_DSMARK_MASK,
+        TCA_DSMARK_VALUE,
+        __TCA_DSMARK_MAX,
+};
+
+#define TCA_DSMARK_MAX (__TCA_DSMARK_MAX - 1)
+
+/* ATM  section */
+
+enum {
+        TCA_ATM_UNSPEC,
+        TCA_ATM_FD,             /* file/socket descriptor */
+        TCA_ATM_PTR,            /* pointer to descriptor - later */
+        TCA_ATM_HDR,            /* LL header */
+        TCA_ATM_EXCESS,         /* excess traffic class (0 for CLP)  */
+        TCA_ATM_ADDR,           /* PVC address (for output only) */
+        TCA_ATM_STATE,          /* VC state (ATM_VS_*; for output only) */
+        __TCA_ATM_MAX,
+};
+
+#define TCA_ATM_MAX     (__TCA_ATM_MAX - 1)
+
+/* Network emulator */
+
+enum {
+        TCA_NETEM_UNSPEC,
+        TCA_NETEM_CORR,
+        TCA_NETEM_DELAY_DIST,
+        TCA_NETEM_REORDER,
+        TCA_NETEM_CORRUPT,
+        TCA_NETEM_LOSS,
+        __TCA_NETEM_MAX,
+};
+
+#define TCA_NETEM_MAX (__TCA_NETEM_MAX - 1)
+
+struct tc_netem_qopt {
+        __u32   latency;        /* added delay (us) */
+        __u32   limit;          /* fifo limit (packets) */
+        __u32   loss;           /* random packet loss (0=none ~0=100%) */
+        __u32   gap;            /* re-ordering gap (0 for none) */
+        __u32   duplicate;      /* random packet dup  (0=none ~0=100%) */
+        __u32   jitter;         /* random jitter in latency (us) */
+};
+
+struct tc_netem_corr {
+        __u32   delay_corr;     /* delay correlation */
+        __u32   loss_corr;      /* packet loss correlation */
+        __u32   dup_corr;       /* duplicate correlation  */
+};
+
+struct tc_netem_reorder {
+        __u32   probability;
+        __u32   correlation;
+};
+
+struct tc_netem_corrupt {
+        __u32   probability;
+        __u32   correlation;
+};
+
+enum {
+        NETEM_LOSS_UNSPEC,
+        NETEM_LOSS_GI,          /* General Intuitive - 4 state model */
+        NETEM_LOSS_GE,          /* Gilbert Elliot models */
+        __NETEM_LOSS_MAX
+};
+#define NETEM_LOSS_MAX (__NETEM_LOSS_MAX - 1)
+
+/* State transition probablities for 4 state model */
+struct tc_netem_gimodel {
+        __u32   p13;
+        __u32   p31;
+        __u32   p32;
+        __u32   p14;
+        __u32   p23;
+};
+
+/* Gilbert-Elliot models */
+struct tc_netem_gemodel {
+        __u32 p;
+        __u32 r;
+        __u32 h;
+        __u32 k1;
+};
+
+#define NETEM_DIST_SCALE        8192
+#define NETEM_DIST_MAX          16384
+
+/* DRR */
+
+enum {
+        TCA_DRR_UNSPEC,
+        TCA_DRR_QUANTUM,
+        __TCA_DRR_MAX
+};
+
+#define TCA_DRR_MAX     (__TCA_DRR_MAX - 1)
+
+struct tc_drr_stats {
+        __u32   deficit;
+};
+
+/* MQPRIO */
+#define TC_QOPT_BITMASK 15
+#define TC_QOPT_MAX_QUEUE 16
+
+struct tc_mqprio_qopt {
+        __u8    num_tc;
+        __u8    prio_tc_map[TC_QOPT_BITMASK + 1];
+        __u8    hw;
+        __u16   count[TC_QOPT_MAX_QUEUE];
+        __u16   offset[TC_QOPT_MAX_QUEUE];
+};
+
+/* SFB */
+
+enum {
+        TCA_SFB_UNSPEC,
+        TCA_SFB_PARMS,
+        __TCA_SFB_MAX,
+};
+
+#define TCA_SFB_MAX (__TCA_SFB_MAX - 1)
+
+/*
+ * Note: increment, decrement are Q0.16 fixed-point values.
+ */
+struct tc_sfb_qopt {
+        __u32 rehash_interval;  /* delay between hash move, in ms */
+        __u32 warmup_time;      /* double buffering warmup time in ms (warmup_time < rehash_interval) */
+        __u32 max;              /* max len of qlen_min */
+        __u32 bin_size;         /* maximum queue length per bin */
+        __u32 increment;        /* probability increment, (d1 in Blue) */
+        __u32 decrement;        /* probability decrement, (d2 in Blue) */
+        __u32 limit;            /* max SFB queue length */
+        __u32 penalty_rate;     /* inelastic flows are rate limited to 'rate' pps */
+        __u32 penalty_burst;
+};
+
+struct tc_sfb_xstats {
+        __u32 earlydrop;
+        __u32 penaltydrop;
+        __u32 bucketdrop;
+        __u32 queuedrop;
+        __u32 childdrop; /* drops in child qdisc */
+        __u32 marked;
+        __u32 maxqlen;
+        __u32 maxprob;
+        __u32 avgprob;
+};
+
+#define SFB_MAX_PROB 0xFFFF
+
+/* QFQ */
+enum {
+        TCA_QFQ_UNSPEC,
+        TCA_QFQ_WEIGHT,
+        TCA_QFQ_LMAX,
+        __TCA_QFQ_MAX
+};
+
+#define TCA_QFQ_MAX     (__TCA_QFQ_MAX - 1)
+
+struct tc_qfq_stats {
+        __u32 weight;
+        __u32 lmax;
+};
+
+#endif