xref: /xnu-8796.101.5/bsd/netinet/ip_dummynet.h (revision aca3beaa3dfbd42498b42c5e5ce20a938e6554e5)

/*
 * Copyright (c) 2000-2021 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@
 */
/*
 * Copyright (c) 1998-2002 Luigi Rizzo, Universita` di Pisa
 * Portions Copyright (c) 2000 Akamba Corp.
 * All rights reserved
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD: src/sys/netinet/ip_dummynet.h,v 1.32 2004/08/17 22:05:54 andre Exp $
 */

#ifndef _IP_DUMMYNET_H
#define _IP_DUMMYNET_H

#include <sys/appleapiopts.h>

#ifdef PRIVATE
#include <netinet/ip_flowid.h>

/* Apply ipv6 mask on ipv6 addr */
#define APPLY_MASK(addr, mask)                          \
    (addr)->__u6_addr.__u6_addr32[0] &= (mask)->__u6_addr.__u6_addr32[0]; \
    (addr)->__u6_addr.__u6_addr32[1] &= (mask)->__u6_addr.__u6_addr32[1]; \
    (addr)->__u6_addr.__u6_addr32[2] &= (mask)->__u6_addr.__u6_addr32[2]; \
    (addr)->__u6_addr.__u6_addr32[3] &= (mask)->__u6_addr.__u6_addr32[3];

/*
 * Definition of dummynet data structures. In the structures, I decided
 * not to use the macros in <sys/queue.h> in the hope of making the code
 * easier to port to other architectures. The type of lists and queue we
 * use here is pretty simple anyways.
 */

/*
 * We start with a heap, which is used in the scheduler to decide when
 * to transmit packets etc.
 *
 * The key for the heap is used for two different values:
 *
 * 1. timer ticks- max 10K/second, so 32 bits are enough;
 *
 * 2. virtual times. These increase in steps of len/x, where len is the
 *    packet length, and x is either the weight of the flow, or the
 *    sum of all weights.
 *    If we limit to max 1000 flows and a max weight of 100, then
 *    x needs 17 bits. The packet size is 16 bits, so we can easily
 *    overflow if we do not allow errors.
 * So we use a key "dn_key" which is 64 bits. Some macros are used to
 * compare key values and handle wraparounds.
 * MAX64 returns the largest of two key values.
 * MY_M is used as a shift count when doing fixed point arithmetic
 * (a better name would be useful...).
 */
typedef u_int64_t dn_key;       /* sorting key */
#define DN_KEY_LT(a, b)     ((int64_t)((a)-(b)) < 0)
#define DN_KEY_LEQ(a, b)    ((int64_t)((a)-(b)) <= 0)
#define DN_KEY_GT(a, b)     ((int64_t)((a)-(b)) > 0)
#define DN_KEY_GEQ(a, b)    ((int64_t)((a)-(b)) >= 0)
#define MAX64(x, y)  (( (int64_t) ( (y)-(x) )) > 0 ) ? (y) : (x)
#define MY_M    16 /* number of left shift to obtain a larger precision */

/*
 * XXX With this scaling, max 1000 flows, max weight 100, 1Gbit/s, the
 * virtual time wraps every 15 days.
 */

/*
 * The maximum hash table size for queues.  This value must be a power
 * of 2.
 */
#define DN_MAX_HASH_SIZE 65536

/*
 * A heap entry is made of a key and a pointer to the actual
 * object stored in the heap.
 * The heap is an array of dn_heap_entry entries, dynamically allocated.
 * Current size is "size", with "elements" actually in use.
 * The heap normally supports only ordered insert and extract from the top.
 * If we want to extract an object from the middle of the heap, we
 * have to know where the object itself is located in the heap (or we
 * need to scan the whole array). To this purpose, an object has a
 * field (int) which contains the index of the object itself into the
 * heap. When the object is moved, the field must also be updated.
 * The offset of the index in the object is stored in the 'offset'
 * field in the heap descriptor. The assumption is that this offset
 * is non-zero if we want to support extract from the middle.
 */
struct dn_heap_entry {
	dn_key key;     /* sorting key. Topmost element is smallest one */
	void *object;   /* object pointer */
};

struct dn_heap {
	int size;
	int elements;
	int offset; /* XXX if > 0 this is the offset of direct ptr to obj */
	struct dn_heap_entry *p; /* really an array of "size" entries */
};

/*
 * Packets processed by dummynet have an mbuf tag associated with
 * them that carries their dummynet state.  This is used within
 * the dummynet code as well as outside when checking for special
 * processing requirements.
 */
#ifdef KERNEL
#include <net/if_var.h>
#include <net/route.h>
#include <netinet/ip_var.h>     /* for ip_out_args */
#include <netinet/ip6.h>        /* for ip6_out_args */
#include <netinet/in.h>
#include <netinet6/ip6_var.h>   /* for ip6_out_args */

struct dn_pkt_tag {
	void                *dn_pf_rule;        /* matching PF rule */
	int                 dn_dir;             /* action when packet comes out. */
#define DN_TO_IP_OUT    1
#define DN_TO_IP_IN     2
#define DN_TO_BDG_FWD   3
#define DN_TO_IP6_IN    4
#define DN_TO_IP6_OUT   5
	dn_key              dn_output_time;     /* when the pkt is due for delivery	*/
	struct ifnet        *dn_ifp;            /* interface, for ip[6]_output		*/
	union {
		struct sockaddr_in      _dn_dst;
		struct sockaddr_in6     _dn_dst6;
	}                   dn_dst_;
#define dn_dst dn_dst_._dn_dst
#define dn_dst6 dn_dst_._dn_dst6
	union {
		struct route            _dn_ro; /* route, for ip_output. MUST COPY	*/
		struct route_in6        _dn_ro6;/* route, for ip6_output. MUST COPY	*/
	}               dn_ro_;
#define dn_ro dn_ro_._dn_ro
#define dn_ro6 dn_ro_._dn_ro6
	struct route_in6    dn_ro6_pmtu;        /* for ip6_output */
	struct ifnet        *dn_origifp;        /* for ip6_output */
	u_int32_t           dn_mtu;             /* for ip6_output */
	u_int32_t           dn_unfragpartlen;   /* for ip6_output */
	struct ip6_exthdrs  dn_exthdrs;         /* for ip6_output */
	int                 dn_flags;           /* flags, for ip[6]_output */
	union {
		struct ip_out_args      _dn_ipoa;/* output args, for ip_output. MUST COPY */
		struct ip6_out_args     _dn_ip6oa;/* output args, for ip_output. MUST COPY */
	}                   dn_ipoa_;
#define dn_ipoa dn_ipoa_._dn_ipoa
#define dn_ip6oa dn_ipoa_._dn_ip6oa
};
#else
struct dn_pkt;
#endif /* KERNEL */

/*
 * Overall structure of dummynet (with WF2Q+):
 *
 *  In dummynet, packets are selected with the firewall rules, and passed
 *  to two different objects: PIPE or QUEUE.
 *
 *  A QUEUE is just a queue with configurable size and queue management
 *  policy. It is also associated with a mask (to discriminate among
 *  different flows), a weight (used to give different shares of the
 *  bandwidth to different flows) and a "pipe", which essentially
 *  supplies the transmit clock for all queues associated with that
 *  pipe.
 *
 *  A PIPE emulates a fixed-bandwidth link, whose bandwidth is
 *  configurable.  The "clock" for a pipe can come from either an
 *  internal timer, or from the transmit interrupt of an interface.
 *  A pipe is also associated with one (or more, if masks are used)
 *  queue, where all packets for that pipe are stored.
 *
 *  The bandwidth available on the pipe is shared by the queues
 *  associated with that pipe (only one in case the packet is sent
 *  to a PIPE) according to the WF2Q+ scheduling algorithm and the
 *  configured weights.
 *
 *  In general, incoming packets are stored in the appropriate queue,
 *  which is then placed into one of a few heaps managed by a scheduler
 *  to decide when the packet should be extracted.
 *  The scheduler (a function called dummynet()) is run at every timer
 *  tick, and grabs queues from the head of the heaps when they are
 *  ready for processing.
 *
 *  There are three data structures definining a pipe and associated queues:
 *
 + dn_pipe, which contains the main configuration parameters related
 +  to delay and bandwidth;
 + dn_flow_set, which contains WF2Q+ configuration, flow
 +  masks, plr and RED configuration;
 + dn_flow_queue, which is the per-flow queue (containing the packets)
 +
 +  Multiple dn_flow_set can be linked to the same pipe, and multiple
 +  dn_flow_queue can be linked to the same dn_flow_set.
 +  All data structures are linked in a linear list which is used for
 +  housekeeping purposes.
 +
 +  During configuration, we create and initialize the dn_flow_set
 +  and dn_pipe structures (a dn_pipe also contains a dn_flow_set).
 +
 +  At runtime: packets are sent to the appropriate dn_flow_set (either
 +  WFQ ones, or the one embedded in the dn_pipe for fixed-rate flows),
 +  which in turn dispatches them to the appropriate dn_flow_queue
 +  (created dynamically according to the masks).
 +
 +  The transmit clock for fixed rate flows (ready_event()) selects the
 +  dn_flow_queue to be used to transmit the next packet. For WF2Q,
 +  wfq_ready_event() extract a pipe which in turn selects the right
 +  flow using a number of heaps defined into the pipe itself.
 +
 *
 */

/*
 * per flow queue. This contains the flow identifier, the queue
 * of packets, counters, and parameters used to support both RED and
 * WF2Q+.
 *
 * A dn_flow_queue is created and initialized whenever a packet for
 * a new flow arrives.
 */
struct dn_flow_queue {
	struct dn_flow_queue *next;
	struct ip_flow_id id;

	struct mbuf *head, *tail; /* queue of packets */
	u_int len;
	u_int len_bytes;
	u_int32_t numbytes;             /* credit for transmission (dynamic queues) */

	u_int64_t tot_pkts;     /* statistics counters	*/
	u_int64_t tot_bytes;
	u_int32_t drops;

	int hash_slot;          /* debugging/diagnostic */

	/* RED parameters */
	int avg;                /* average queue length est. (scaled) */
	int count;              /* arrivals since last RED drop */
	int random;             /* random value (scaled) */
	u_int64_t q_time;       /* start of queue idle time */

	/* WF2Q+ support */
	struct dn_flow_set *fs; /* parent flow set */
	int heap_pos;           /* position (index) of struct in heap */
	dn_key sched_time;      /* current time when queue enters ready_heap */

	dn_key S, F;            /* start time, finish time */
	/*
	 * Setting F < S means the timestamp is invalid. We only need
	 * to test this when the queue is empty.
	 */
};

/*
 * flow_set descriptor. Contains the "template" parameters for the
 * queue configuration, and pointers to the hash table of dn_flow_queue's.
 *
 * The hash table is an array of lists -- we identify the slot by
 * hashing the flow-id, then scan the list looking for a match.
 * The size of the hash table (buckets) is configurable on a per-queue
 * basis.
 *
 * A dn_flow_set is created whenever a new queue or pipe is created (in the
 * latter case, the structure is located inside the struct dn_pipe).
 */
struct dn_flow_set {
	SLIST_ENTRY(dn_flow_set)    next;/* linked list in a hash slot */

	u_short fs_nr;          /* flow_set number       */
	u_short flags_fs;
#define DN_HAVE_FLOW_MASK       0x0001
#define DN_IS_RED               0x0002
#define DN_IS_GENTLE_RED        0x0004
#define DN_QSIZE_IS_BYTES       0x0008  /* queue size is measured in bytes */
#define DN_NOERROR              0x0010  /* do not report ENOBUFS on drops  */
#define DN_IS_PIPE              0x4000
#define DN_IS_QUEUE             0x8000

	struct dn_pipe *pipe;   /* pointer to parent pipe */
	u_short parent_nr;      /* parent pipe#, 0 if local to a pipe */

	int weight;             /* WFQ queue weight */
	int qsize;              /* queue size in slots or bytes */
	int plr;                /* pkt loss rate (2^31-1 means 100%) */

	struct ip_flow_id flow_mask;

	/* hash table of queues onto this flow_set */
	int rq_size;            /* number of slots */
	int rq_elements;        /* active elements */
	struct dn_flow_queue **rq; /* array of rq_size entries */

	u_int32_t last_expired; /* do not expire too frequently */
	int backlogged;         /* #active queues for this flowset */

	/* RED parameters */
#define SCALE_RED               16
#define SCALE(x)                ( (x) << SCALE_RED )
#define SCALE_VAL(x)            ( (x) >> SCALE_RED )
#define SCALE_MUL(x, y)          ( ( (x) * (y) ) >> SCALE_RED )
	int w_q;                /* queue weight (scaled) */
	int max_th;             /* maximum threshold for queue (scaled) */
	int min_th;             /* minimum threshold for queue (scaled) */
	int max_p;              /* maximum value for p_b (scaled) */
	u_int c_1;              /* max_p/(max_th-min_th) (scaled) */
	u_int c_2;              /* max_p*min_th/(max_th-min_th) (scaled) */
	u_int c_3;              /* for GRED, (1-max_p)/max_th (scaled) */
	u_int c_4;              /* for GRED, 1 - 2*max_p (scaled) */
	u_int * w_q_lookup;     /* lookup table for computing (1-w_q)^t */
	u_int lookup_depth;     /* depth of lookup table */
	int lookup_step;        /* granularity inside the lookup table */
	int lookup_weight;      /* equal to (1-w_q)^t / (1-w_q)^(t+1) */
	int avg_pkt_size;       /* medium packet size */
	int max_pkt_size;       /* max packet size */
};

SLIST_HEAD(dn_flow_set_head, dn_flow_set);

/*
 * Pipe descriptor. Contains global parameters, delay-line queue,
 * and the flow_set used for fixed-rate queues.
 *
 * For WF2Q+ support it also has 3 heaps holding dn_flow_queue:
 *   not_eligible_heap, for queues whose start time is higher
 *	than the virtual time. Sorted by start time.
 *   scheduler_heap, for queues eligible for scheduling. Sorted by
 *	finish time.
 *   idle_heap, all flows that are idle and can be removed. We
 *	do that on each tick so we do not slow down too much
 *	operations during forwarding.
 *
 */
struct dn_pipe {                /* a pipe */
	SLIST_ENTRY(dn_pipe)        next;/* linked list in a hash slot */

	int pipe_nr;            /* number	*/
	int bandwidth;          /* really, bytes/tick.	*/
	int delay;              /* really, ticks	*/

	struct      mbuf *head, *tail;  /* packets in delay line */

	/* WF2Q+ */
	struct dn_heap scheduler_heap; /* top extract - key Finish time*/
	struct dn_heap not_eligible_heap; /* top extract- key Start time */
	struct dn_heap idle_heap; /* random extract - key Start=Finish time */

	dn_key V;               /* virtual time */
	int sum;                /* sum of weights of all active sessions */
	int numbytes;           /* bits I can transmit (more or less). */

	dn_key sched_time;      /* time pipe was scheduled in ready_heap */

	/*
	 * When the tx clock come from an interface (if_name[0] != '\0'), its name
	 * is stored below, whereas the ifp is filled when the rule is configured.
	 */
	char if_name[IFNAMSIZ];
	struct ifnet *ifp;
	int ready; /* set if ifp != NULL and we got a signal from it */

	struct dn_flow_set fs; /* used with fixed-rate flows */
};

SLIST_HEAD(dn_pipe_head, dn_pipe);

#ifdef BSD_KERNEL_PRIVATE
extern uint32_t my_random(void);
void ip_dn_init(void);

typedef int ip_dn_ctl_t(struct sockopt *); /* raw_ip.c */
typedef int ip_dn_io_t(struct mbuf *m, int pipe_nr, int dir,
    struct ip_fw_args *fwa);
extern  ip_dn_ctl_t *ip_dn_ctl_ptr;
extern  ip_dn_io_t *ip_dn_io_ptr;
#define DUMMYNET_LOADED (ip_dn_io_ptr != NULL)

#pragma pack(4)

struct dn_heap_32 {
	int size;
	int elements;
	int offset; /* XXX if > 0 this is the offset of direct ptr to obj */
	user32_addr_t p; /* really an array of "size" entries */
};

struct dn_flow_queue_32 {
	user32_addr_t next;
	struct ip_flow_id id;

	user32_addr_t head, tail; /* queue of packets */
	u_int len;
	u_int len_bytes;
	u_int32_t numbytes;     /* credit for transmission (dynamic queues) */

	u_int64_t tot_pkts;     /* statistics counters	*/
	u_int64_t tot_bytes;
	u_int32_t drops;

	int hash_slot;                  /* debugging/diagnostic */

	/* RED parameters */
	int avg;                /* average queue length est. (scaled) */
	int count;              /* arrivals since last RED drop */
	int random;             /* random value (scaled) */
	u_int32_t q_time;       /* start of queue idle time */

	/* WF2Q+ support */
	user32_addr_t fs; /* parent flow set */
	int heap_pos;           /* position (index) of struct in heap */
	dn_key sched_time;      /* current time when queue enters ready_heap */

	dn_key S, F;            /* start time, finish time */
	/*
	 * Setting F < S means the timestamp is invalid. We only need
	 * to test this when the queue is empty.
	 */
};

struct dn_flow_set_32 {
	user32_addr_t       next;/* next flow set in all_flow_sets list */

	u_short fs_nr;                  /* flow_set number       */
	u_short flags_fs;
#define DN_HAVE_FLOW_MASK       0x0001
#define DN_IS_RED               0x0002
#define DN_IS_GENTLE_RED        0x0004
#define DN_QSIZE_IS_BYTES       0x0008  /* queue size is measured in bytes */
#define DN_NOERROR              0x0010          /* do not report ENOBUFS on drops  */
#define DN_IS_PIPE              0x4000
#define DN_IS_QUEUE             0x8000

	user32_addr_t pipe;     /* pointer to parent pipe */
	u_short parent_nr;      /* parent pipe#, 0 if local to a pipe */

	int weight;             /* WFQ queue weight */
	int qsize;              /* queue size in slots or bytes */
	int plr;                /* pkt loss rate (2^31-1 means 100%) */

	struct ip_flow_id flow_mask;

	/* hash table of queues onto this flow_set */
	int rq_size;            /* number of slots */
	int rq_elements; /* active elements */
	user32_addr_t rq; /* array of rq_size entries */

	u_int32_t last_expired; /* do not expire too frequently */
	int backlogged;                 /* #active queues for this flowset */

	/* RED parameters */
#define SCALE_RED               16
#define SCALE(x)                ( (x) << SCALE_RED )
#define SCALE_VAL(x)            ( (x) >> SCALE_RED )
#define SCALE_MUL(x, y)          ( ( (x) * (y) ) >> SCALE_RED )
	int w_q;                /* queue weight (scaled) */
	int max_th;             /* maximum threshold for queue (scaled) */
	int min_th;             /* minimum threshold for queue (scaled) */
	int max_p;              /* maximum value for p_b (scaled) */
	u_int c_1;              /* max_p/(max_th-min_th) (scaled) */
	u_int c_2;              /* max_p*min_th/(max_th-min_th) (scaled) */
	u_int c_3;              /* for GRED, (1-max_p)/max_th (scaled) */
	u_int c_4;              /* for GRED, 1 - 2*max_p (scaled) */
	user32_addr_t w_q_lookup; /* lookup table for computing (1-w_q)^t */
	u_int lookup_depth;     /* depth of lookup table */
	int lookup_step;        /* granularity inside the lookup table */
	int lookup_weight;      /* equal to (1-w_q)^t / (1-w_q)^(t+1) */
	int avg_pkt_size;       /* medium packet size */
	int max_pkt_size;       /* max packet size */
};

struct dn_pipe_32 {             /* a pipe */
	user32_addr_t       next;

	int pipe_nr;            /* number	*/
	int bandwidth;          /* really, bytes/tick.	*/
	int delay;              /* really, ticks	*/

	user32_addr_t head, tail; /* packets in delay line */

	/* WF2Q+ */
	struct dn_heap_32 scheduler_heap; /* top extract - key Finish time*/
	struct dn_heap_32 not_eligible_heap; /* top extract- key Start time */
	struct dn_heap_32 idle_heap; /* random extract - key Start=Finish time */

	dn_key V;               /* virtual time */
	int sum;                /* sum of weights of all active sessions */
	int numbytes;           /* bits I can transmit (more or less). */

	dn_key sched_time; /* time pipe was scheduled in ready_heap */

	/*
	 * When the tx clock come from an interface (if_name[0] != '\0'), its name
	 * is stored below, whereas the ifp is filled when the rule is configured.
	 */
	char if_name[IFNAMSIZ];
	user32_addr_t ifp;
	int ready;              /* set if ifp != NULL and we got a signal from it */

	struct dn_flow_set_32 fs; /* used with fixed-rate flows */
};
#pragma pack()


struct dn_heap_64 {
	int size;
	int elements;
	int offset; /* XXX if > 0 this is the offset of direct ptr to obj */
	user64_addr_t p; /* really an array of "size" entries */
};


struct dn_flow_queue_64 {
	user64_addr_t next;
	struct ip_flow_id id;

	user64_addr_t head, tail; /* queue of packets */
	u_int len;
	u_int len_bytes;
	u_int32_t numbytes;             /* credit for transmission (dynamic queues) */

	u_int64_t tot_pkts;             /* statistics counters	*/
	u_int64_t tot_bytes;
	u_int32_t drops;

	int hash_slot;                          /* debugging/diagnostic */

	/* RED parameters */
	int avg;                /* average queue length est. (scaled) */
	int count;              /* arrivals since last RED drop */
	int random;             /* random value (scaled) */
	u_int32_t q_time;       /* start of queue idle time */

	/* WF2Q+ support */
	user64_addr_t fs;               /* parent flow set */
	int heap_pos;                           /* position (index) of struct in heap */
	dn_key sched_time;              /* current time when queue enters ready_heap */

	dn_key S, F;                            /* start time, finish time */
	/*
	 * Setting F < S means the timestamp is invalid. We only need
	 * to test this when the queue is empty.
	 */
};

struct dn_flow_set_64 {
	user64_addr_t next;             /* next flow set in all_flow_sets list */

	u_short fs_nr;          /* flow_set number       */
	u_short flags_fs;
#define DN_HAVE_FLOW_MASK       0x0001
#define DN_IS_RED               0x0002
#define DN_IS_GENTLE_RED        0x0004
#define DN_QSIZE_IS_BYTES       0x0008  /* queue size is measured in bytes */
#define DN_NOERROR              0x0010          /* do not report ENOBUFS on drops  */
#define DN_IS_PIPE              0x4000
#define DN_IS_QUEUE             0x8000

	user64_addr_t pipe;     /* pointer to parent pipe */
	u_short parent_nr;      /* parent pipe#, 0 if local to a pipe */

	int weight;             /* WFQ queue weight */
	int qsize;              /* queue size in slots or bytes */
	int plr;                /* pkt loss rate (2^31-1 means 100%) */

	struct ip_flow_id flow_mask;

	/* hash table of queues onto this flow_set */
	int rq_size;            /* number of slots */
	int rq_elements; /* active elements */
	user64_addr_t rq; /* array of rq_size entries */

	u_int32_t last_expired; /* do not expire too frequently */
	int backlogged;                 /* #active queues for this flowset */

	/* RED parameters */
#define SCALE_RED               16
#define SCALE(x)                ( (x) << SCALE_RED )
#define SCALE_VAL(x)            ( (x) >> SCALE_RED )
#define SCALE_MUL(x, y)          ( ( (x) * (y) ) >> SCALE_RED )
	int w_q;                /* queue weight (scaled) */
	int max_th;             /* maximum threshold for queue (scaled) */
	int min_th;             /* minimum threshold for queue (scaled) */
	int max_p;              /* maximum value for p_b (scaled) */
	u_int c_1;              /* max_p/(max_th-min_th) (scaled) */
	u_int c_2;              /* max_p*min_th/(max_th-min_th) (scaled) */
	u_int c_3;              /* for GRED, (1-max_p)/max_th (scaled) */
	u_int c_4;              /* for GRED, 1 - 2*max_p (scaled) */
	user64_addr_t w_q_lookup; /* lookup table for computing (1-w_q)^t */
	u_int lookup_depth;     /* depth of lookup table */
	int lookup_step;        /* granularity inside the lookup table */
	int lookup_weight;      /* equal to (1-w_q)^t / (1-w_q)^(t+1) */
	int avg_pkt_size;       /* medium packet size */
	int max_pkt_size;       /* max packet size */
};

struct dn_pipe_64 {             /* a pipe */
	user64_addr_t       next;

	int pipe_nr;            /* number	*/
	int bandwidth;          /* really, bytes/tick.	*/
	int delay;              /* really, ticks	*/

	user64_addr_t head, tail; /* packets in delay line */

	/* WF2Q+ */
	struct dn_heap_64 scheduler_heap;       /* top extract - key Finish time*/
	struct dn_heap_64 not_eligible_heap;    /* top extract- key Start time */
	struct dn_heap_64 idle_heap;                    /* random extract - key Start=Finish time */

	dn_key V;               /* virtual time */
	int sum;                /* sum of weights of all active sessions */
	int numbytes;           /* bits I can transmit (more or less). */

	dn_key sched_time; /* time pipe was scheduled in ready_heap */

	/*
	 * When the tx clock come from an interface (if_name[0] != '\0'), its name
	 * is stored below, whereas the ifp is filled when the rule is configured.
	 */
	char if_name[IFNAMSIZ];
	user64_addr_t ifp;
	int ready; /* set if ifp != NULL and we got a signal from it */

	struct dn_flow_set_64 fs; /* used with fixed-rate flows */
};

#include <sys/eventhandler.h>
/* Dummynet event handling declarations */
extern struct eventhandler_lists_ctxt dummynet_evhdlr_ctxt;
extern void dummynet_init(void);

struct dn_pipe_mini_config {
	uint32_t bandwidth;
	uint32_t delay;
	uint32_t plr;
};

struct dn_rule_mini_config {
	uint32_t dir;
	uint32_t af;
	uint32_t proto;
	/*
	 * XXX PF rules actually define ranges of ports and
	 * along with range goes an opcode ((not) equal to, less than
	 * greater than, etc.
	 * For now the following works assuming there's no port range
	 * and the rule is for specific port.
	 * Also the operation is assumed as equal to.
	 */
	uint32_t src_port;
	uint32_t dst_port;
	char ifname[IFXNAMSIZ];
};

struct dummynet_event {
	uint32_t dn_event_code;
	union {
		struct dn_pipe_mini_config _dnev_pipe_config;
		struct dn_rule_mini_config _dnev_rule_config;
	} dn_event;
};

#define dn_event_pipe_config    dn_event._dnev_pipe_config
#define dn_event_rule_config    dn_event._dnev_rule_config

extern void dummynet_event_enqueue_nwk_wq_entry(struct dummynet_event *);

enum {
	DUMMYNET_RULE_CONFIG,
	DUMMYNET_RULE_DELETE,
	DUMMYNET_PIPE_CONFIG,
	DUMMYNET_PIPE_DELETE,
	DUMMYNET_NLC_DISABLED,
};

enum    { DN_INOUT, DN_IN, DN_OUT };
/*
 * The signature for the callback is:
 * eventhandler_entry_arg	__unused
 * dummynet_event		pointer to dummynet event object
 */
typedef void (*dummynet_event_fn) (struct eventhandler_entry_arg, struct dummynet_event *);
EVENTHANDLER_DECLARE(dummynet_event, dummynet_event_fn);
#endif /* BSD_KERNEL_PRIVATE */
#endif /* PRIVATE */
#endif /* _IP_DUMMYNET_H */