[deliverable/linux.git] / net / sched / sch_netem.c

/*
 * net/sched/sch_netem.c	Network emulator
 *
 * 		This program is free software; you can redistribute it and/or
 * 		modify it under the terms of the GNU General Public License
 * 		as published by the Free Software Foundation; either version
 * 		2 of the License.
 *
 *  		Many of the algorithms and ideas for this came from
 *		NIST Net which is not copyrighted.
 *
 * Authors:	Stephen Hemminger <shemminger@osdl.org>
 *		Catalin(ux aka Dino) BOIE <catab at umbrella dot ro>
 */

#include <linux/module.h>
#include <linux/bitops.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>

#include <net/netlink.h>
#include <net/pkt_sched.h>

#define VERSION "1.2"

/*	Network Emulation Queuing algorithm.
	====================================

	Sources: [1] Mark Carson, Darrin Santay, "NIST Net - A Linux-based
		 Network Emulation Tool
		 [2] Luigi Rizzo, DummyNet for FreeBSD

	 ----------------------------------------------------------------

	 This started out as a simple way to delay outgoing packets to
	 test TCP but has grown to include most of the functionality
	 of a full blown network emulator like NISTnet. It can delay
	 packets and add random jitter (and correlation). The random
	 distribution can be loaded from a table as well to provide
	 normal, Pareto, or experimental curves. Packet loss,
	 duplication, and reordering can also be emulated.

	 This qdisc does not do classification that can be handled in
	 layering other disciplines.  It does not need to do bandwidth
	 control either since that can be handled by using token
	 bucket or other rate control.

	 The simulator is limited by the Linux timer resolution
	 and will create packet bursts on the HZ boundary (1ms).
*/

struct netem_sched_data {
	struct Qdisc	*qdisc;
	struct qdisc_watchdog watchdog;

	u32 latency;
	u32 loss;
	u32 limit;
	u32 counter;
	u32 gap;
	u32 jitter;
	u32 duplicate;
	u32 reorder;
	u32 corrupt;

	struct crndstate {
		unsigned long last;
		unsigned long rho;
	} delay_cor, loss_cor, dup_cor, reorder_cor, corrupt_cor;

	struct disttable {
		u32  size;
		s16 table[0];
	} *delay_dist;
};

/* Time stamp put into socket buffer control block */
struct netem_skb_cb {
	psched_time_t	time_to_send;
};

/* init_crandom - initialize correlated random number generator
 * Use entropy source for initial seed.
 */
static void init_crandom(struct crndstate *state, unsigned long rho)
{
	state->rho = rho;
	state->last = net_random();
}

/* get_crandom - correlated random number generator
 * Next number depends on last value.
 * rho is scaled to avoid floating point.
 */
static unsigned long get_crandom(struct crndstate *state)
{
	u64 value, rho;
	unsigned long answer;

	if (state->rho == 0)	/* no correllation */
		return net_random();

	value = net_random();
	rho = (u64)state->rho + 1;
	answer = (value * ((1ull<<32) - rho) + state->last * rho) >> 32;
	state->last = answer;
	return answer;
}

/* tabledist - return a pseudo-randomly distributed value with mean mu and
 * std deviation sigma.  Uses table lookup to approximate the desired
 * distribution, and a uniformly-distributed pseudo-random source.
 */
static long tabledist(unsigned long mu, long sigma,
		      struct crndstate *state, const struct disttable *dist)
{
	long t, x;
	unsigned long rnd;

	if (sigma == 0)
		return mu;

	rnd = get_crandom(state);

	/* default uniform distribution */
	if (dist == NULL)
		return (rnd % (2*sigma)) - sigma + mu;

	t = dist->table[rnd % dist->size];
	x = (sigma % NETEM_DIST_SCALE) * t;
	if (x >= 0)
		x += NETEM_DIST_SCALE/2;
	else
		x -= NETEM_DIST_SCALE/2;

	return  x / NETEM_DIST_SCALE + (sigma / NETEM_DIST_SCALE) * t + mu;
}

/*
 * Insert one skb into qdisc.
 * Note: parent depends on return value to account for queue length.
 * 	NET_XMIT_DROP: queue length didn't change.
 *      NET_XMIT_SUCCESS: one skb was queued.
 */
static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	/* We don't fill cb now as skb_unshare() may invalidate it */
	struct netem_skb_cb *cb;
	struct sk_buff *skb2;
	int ret;
	int count = 1;

	pr_debug("netem_enqueue skb=%p\n", skb);

	/* Random duplication */
	if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor))
		++count;

	/* Random packet drop 0 => none, ~0 => all */
	if (q->loss && q->loss >= get_crandom(&q->loss_cor))
		--count;

	if (count == 0) {
		sch->qstats.drops++;
		kfree_skb(skb);
		return NET_XMIT_BYPASS;
	}

	skb_orphan(skb);

	/*
	 * If we need to duplicate packet, then re-insert at top of the
	 * qdisc tree, since parent queuer expects that only one
	 * skb will be queued.
	 */
	if (count > 1 && (skb2 = skb_clone(skb, GFP_ATOMIC)) != NULL) {
		struct Qdisc *rootq = sch->dev->qdisc;
		u32 dupsave = q->duplicate; /* prevent duplicating a dup... */
		q->duplicate = 0;

		rootq->enqueue(skb2, rootq);
		q->duplicate = dupsave;
	}

	/*
	 * Randomized packet corruption.
	 * Make copy if needed since we are modifying
	 * If packet is going to be hardware checksummed, then
	 * do it now in software before we mangle it.
	 */
	if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) {
		if (!(skb = skb_unshare(skb, GFP_ATOMIC))
		    || (skb->ip_summed == CHECKSUM_PARTIAL
			&& skb_checksum_help(skb))) {
			sch->qstats.drops++;
			return NET_XMIT_DROP;
		}

		skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8);
	}

	cb = (struct netem_skb_cb *)skb->cb;
	if (q->gap == 0 		/* not doing reordering */
	    || q->counter < q->gap 	/* inside last reordering gap */
	    || q->reorder < get_crandom(&q->reorder_cor)) {
		psched_time_t now;
		psched_tdiff_t delay;

		delay = tabledist(q->latency, q->jitter,
				  &q->delay_cor, q->delay_dist);

		PSCHED_GET_TIME(now);
		PSCHED_TADD2(now, delay, cb->time_to_send);
		++q->counter;
		ret = q->qdisc->enqueue(skb, q->qdisc);
	} else {
		/*
		 * Do re-ordering by putting one out of N packets at the front
		 * of the queue.
		 */
		PSCHED_GET_TIME(cb->time_to_send);
		q->counter = 0;
		ret = q->qdisc->ops->requeue(skb, q->qdisc);
	}

	if (likely(ret == NET_XMIT_SUCCESS)) {
		sch->q.qlen++;
		sch->bstats.bytes += skb->len;
		sch->bstats.packets++;
	} else
		sch->qstats.drops++;

	pr_debug("netem: enqueue ret %d\n", ret);
	return ret;
}

/* Requeue packets but don't change time stamp */
static int netem_requeue(struct sk_buff *skb, struct Qdisc *sch)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	int ret;

	if ((ret = q->qdisc->ops->requeue(skb, q->qdisc)) == 0) {
		sch->q.qlen++;
		sch->qstats.requeues++;
	}

	return ret;
}

static unsigned int netem_drop(struct Qdisc* sch)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	unsigned int len = 0;

	if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) {
		sch->q.qlen--;
		sch->qstats.drops++;
	}
	return len;
}

static struct sk_buff *netem_dequeue(struct Qdisc *sch)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	struct sk_buff *skb;

	skb = q->qdisc->dequeue(q->qdisc);
	if (skb) {
		const struct netem_skb_cb *cb
			= (const struct netem_skb_cb *)skb->cb;
		psched_time_t now;

		/* if more time remaining? */
		PSCHED_GET_TIME(now);

		if (PSCHED_TLESS(cb->time_to_send, now)) {
			pr_debug("netem_dequeue: return skb=%p\n", skb);
			sch->q.qlen--;
			sch->flags &= ~TCQ_F_THROTTLED;
			return skb;
		} else {
			qdisc_watchdog_schedule(&q->watchdog, cb->time_to_send);

			if (q->qdisc->ops->requeue(skb, q->qdisc) != NET_XMIT_SUCCESS) {
				qdisc_tree_decrease_qlen(q->qdisc, 1);
				sch->qstats.drops++;
				printk(KERN_ERR "netem: queue discpline %s could not requeue\n",
				       q->qdisc->ops->id);
			}
		}
	}

	return NULL;
}

static void netem_reset(struct Qdisc *sch)
{
	struct netem_sched_data *q = qdisc_priv(sch);

	qdisc_reset(q->qdisc);
	sch->q.qlen = 0;
	qdisc_watchdog_cancel(&q->watchdog);
}

/* Pass size change message down to embedded FIFO */
static int set_fifo_limit(struct Qdisc *q, int limit)
{
	struct rtattr *rta;
	int ret = -ENOMEM;

	/* Hack to avoid sending change message to non-FIFO */
	if (strncmp(q->ops->id + 1, "fifo", 4) != 0)
		return 0;

	rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
	if (rta) {
		rta->rta_type = RTM_NEWQDISC;
		rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt));
		((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit;

		ret = q->ops->change(q, rta);
		kfree(rta);
	}
	return ret;
}

/*
 * Distribution data is a variable size payload containing
 * signed 16 bit values.
 */
static int get_dist_table(struct Qdisc *sch, const struct rtattr *attr)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	unsigned long n = RTA_PAYLOAD(attr)/sizeof(__s16);
	const __s16 *data = RTA_DATA(attr);
	struct disttable *d;
	int i;

	if (n > 65536)
		return -EINVAL;

	d = kmalloc(sizeof(*d) + n*sizeof(d->table[0]), GFP_KERNEL);
	if (!d)
		return -ENOMEM;

	d->size = n;
	for (i = 0; i < n; i++)
		d->table[i] = data[i];

	spin_lock_bh(&sch->dev->queue_lock);
	d = xchg(&q->delay_dist, d);
	spin_unlock_bh(&sch->dev->queue_lock);

	kfree(d);
	return 0;
}

static int get_correlation(struct Qdisc *sch, const struct rtattr *attr)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	const struct tc_netem_corr *c = RTA_DATA(attr);

	if (RTA_PAYLOAD(attr) != sizeof(*c))
		return -EINVAL;

	init_crandom(&q->delay_cor, c->delay_corr);
	init_crandom(&q->loss_cor, c->loss_corr);
	init_crandom(&q->dup_cor, c->dup_corr);
	return 0;
}

static int get_reorder(struct Qdisc *sch, const struct rtattr *attr)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	const struct tc_netem_reorder *r = RTA_DATA(attr);

	if (RTA_PAYLOAD(attr) != sizeof(*r))
		return -EINVAL;

	q->reorder = r->probability;
	init_crandom(&q->reorder_cor, r->correlation);
	return 0;
}

static int get_corrupt(struct Qdisc *sch, const struct rtattr *attr)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	const struct tc_netem_corrupt *r = RTA_DATA(attr);

	if (RTA_PAYLOAD(attr) != sizeof(*r))
		return -EINVAL;

	q->corrupt = r->probability;
	init_crandom(&q->corrupt_cor, r->correlation);
	return 0;
}

/* Parse netlink message to set options */
static int netem_change(struct Qdisc *sch, struct rtattr *opt)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	struct tc_netem_qopt *qopt;
	int ret;

	if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt))
		return -EINVAL;

	qopt = RTA_DATA(opt);
	ret = set_fifo_limit(q->qdisc, qopt->limit);
	if (ret) {
		pr_debug("netem: can't set fifo limit\n");
		return ret;
	}

	q->latency = qopt->latency;
	q->jitter = qopt->jitter;
	q->limit = qopt->limit;
	q->gap = qopt->gap;
	q->counter = 0;
	q->loss = qopt->loss;
	q->duplicate = qopt->duplicate;

	/* for compatiablity with earlier versions.
	 * if gap is set, need to assume 100% probablity
	 */
	q->reorder = ~0;

	/* Handle nested options after initial queue options.
	 * Should have put all options in nested format but too late now.
	 */
	if (RTA_PAYLOAD(opt) > sizeof(*qopt)) {
		struct rtattr *tb[TCA_NETEM_MAX];
		if (rtattr_parse(tb, TCA_NETEM_MAX,
				 RTA_DATA(opt) + sizeof(*qopt),
				 RTA_PAYLOAD(opt) - sizeof(*qopt)))
			return -EINVAL;

		if (tb[TCA_NETEM_CORR-1]) {
			ret = get_correlation(sch, tb[TCA_NETEM_CORR-1]);
			if (ret)
				return ret;
		}

		if (tb[TCA_NETEM_DELAY_DIST-1]) {
			ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST-1]);
			if (ret)
				return ret;
		}

		if (tb[TCA_NETEM_REORDER-1]) {
			ret = get_reorder(sch, tb[TCA_NETEM_REORDER-1]);
			if (ret)
				return ret;
		}

		if (tb[TCA_NETEM_CORRUPT-1]) {
			ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT-1]);
			if (ret)
				return ret;
		}
	}

	return 0;
}

/*
 * Special case version of FIFO queue for use by netem.
 * It queues in order based on timestamps in skb's
 */
struct fifo_sched_data {
	u32 limit;
};

static int tfifo_enqueue(struct sk_buff *nskb, struct Qdisc *sch)
{
	struct fifo_sched_data *q = qdisc_priv(sch);
	struct sk_buff_head *list = &sch->q;
	const struct netem_skb_cb *ncb
		= (const struct netem_skb_cb *)nskb->cb;
	struct sk_buff *skb;

	if (likely(skb_queue_len(list) < q->limit)) {
		skb_queue_reverse_walk(list, skb) {
			const struct netem_skb_cb *cb
				= (const struct netem_skb_cb *)skb->cb;

			if (!PSCHED_TLESS(ncb->time_to_send, cb->time_to_send))
				break;
		}

		__skb_queue_after(list, skb, nskb);

		sch->qstats.backlog += nskb->len;
		sch->bstats.bytes += nskb->len;
		sch->bstats.packets++;

		return NET_XMIT_SUCCESS;
	}

	return qdisc_drop(nskb, sch);
}

static int tfifo_init(struct Qdisc *sch, struct rtattr *opt)
{
	struct fifo_sched_data *q = qdisc_priv(sch);

	if (opt) {
		struct tc_fifo_qopt *ctl = RTA_DATA(opt);
		if (RTA_PAYLOAD(opt) < sizeof(*ctl))
			return -EINVAL;

		q->limit = ctl->limit;
	} else
		q->limit = max_t(u32, sch->dev->tx_queue_len, 1);

	return 0;
}

static int tfifo_dump(struct Qdisc *sch, struct sk_buff *skb)
{
	struct fifo_sched_data *q = qdisc_priv(sch);
	struct tc_fifo_qopt opt = { .limit = q->limit };

	RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
	return skb->len;

rtattr_failure:
	return -1;
}

static struct Qdisc_ops tfifo_qdisc_ops = {
	.id		=	"tfifo",
	.priv_size	=	sizeof(struct fifo_sched_data),
	.enqueue	=	tfifo_enqueue,
	.dequeue	=	qdisc_dequeue_head,
	.requeue	=	qdisc_requeue,
	.drop		=	qdisc_queue_drop,
	.init		=	tfifo_init,
	.reset		=	qdisc_reset_queue,
	.change		=	tfifo_init,
	.dump		=	tfifo_dump,
};

static int netem_init(struct Qdisc *sch, struct rtattr *opt)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	int ret;

	if (!opt)
		return -EINVAL;

	qdisc_watchdog_init(&q->watchdog, sch);

	q->qdisc = qdisc_create_dflt(sch->dev, &tfifo_qdisc_ops,
				     TC_H_MAKE(sch->handle, 1));
	if (!q->qdisc) {
		pr_debug("netem: qdisc create failed\n");
		return -ENOMEM;
	}

	ret = netem_change(sch, opt);
	if (ret) {
		pr_debug("netem: change failed\n");
		qdisc_destroy(q->qdisc);
	}
	return ret;
}

static void netem_destroy(struct Qdisc *sch)
{
	struct netem_sched_data *q = qdisc_priv(sch);

	qdisc_watchdog_cancel(&q->watchdog);
	qdisc_destroy(q->qdisc);
	kfree(q->delay_dist);
}

static int netem_dump(struct Qdisc *sch, struct sk_buff *skb)
{
	const struct netem_sched_data *q = qdisc_priv(sch);
	unsigned char *b = skb_tail_pointer(skb);
	struct rtattr *rta = (struct rtattr *) b;
	struct tc_netem_qopt qopt;
	struct tc_netem_corr cor;
	struct tc_netem_reorder reorder;
	struct tc_netem_corrupt corrupt;

	qopt.latency = q->latency;
	qopt.jitter = q->jitter;
	qopt.limit = q->limit;
	qopt.loss = q->loss;
	qopt.gap = q->gap;
	qopt.duplicate = q->duplicate;
	RTA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt);

	cor.delay_corr = q->delay_cor.rho;
	cor.loss_corr = q->loss_cor.rho;
	cor.dup_corr = q->dup_cor.rho;
	RTA_PUT(skb, TCA_NETEM_CORR, sizeof(cor), &cor);

	reorder.probability = q->reorder;
	reorder.correlation = q->reorder_cor.rho;
	RTA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder);

	corrupt.probability = q->corrupt;
	corrupt.correlation = q->corrupt_cor.rho;
	RTA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);

	rta->rta_len = skb_tail_pointer(skb) - b;

	return skb->len;

rtattr_failure:
	nlmsg_trim(skb, b);
	return -1;
}

static int netem_dump_class(struct Qdisc *sch, unsigned long cl,
			  struct sk_buff *skb, struct tcmsg *tcm)
{
	struct netem_sched_data *q = qdisc_priv(sch);

	if (cl != 1) 	/* only one class */
		return -ENOENT;

	tcm->tcm_handle |= TC_H_MIN(1);
	tcm->tcm_info = q->qdisc->handle;

	return 0;
}

static int netem_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
		     struct Qdisc **old)
{
	struct netem_sched_data *q = qdisc_priv(sch);

	if (new == NULL)
		new = &noop_qdisc;

	sch_tree_lock(sch);
	*old = xchg(&q->qdisc, new);
	qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
	qdisc_reset(*old);
	sch_tree_unlock(sch);

	return 0;
}

static struct Qdisc *netem_leaf(struct Qdisc *sch, unsigned long arg)
{
	struct netem_sched_data *q = qdisc_priv(sch);
	return q->qdisc;
}

static unsigned long netem_get(struct Qdisc *sch, u32 classid)
{
	return 1;
}

static void netem_put(struct Qdisc *sch, unsigned long arg)
{
}

static int netem_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
			    struct rtattr **tca, unsigned long *arg)
{
	return -ENOSYS;
}

static int netem_delete(struct Qdisc *sch, unsigned long arg)
{
	return -ENOSYS;
}

static void netem_walk(struct Qdisc *sch, struct qdisc_walker *walker)
{
	if (!walker->stop) {
		if (walker->count >= walker->skip)
			if (walker->fn(sch, 1, walker) < 0) {
				walker->stop = 1;
				return;
			}
		walker->count++;
	}
}

static struct tcf_proto **netem_find_tcf(struct Qdisc *sch, unsigned long cl)
{
	return NULL;
}

static struct Qdisc_class_ops netem_class_ops = {
	.graft		=	netem_graft,
	.leaf		=	netem_leaf,
	.get		=	netem_get,
	.put		=	netem_put,
	.change		=	netem_change_class,
	.delete		=	netem_delete,
	.walk		=	netem_walk,
	.tcf_chain	=	netem_find_tcf,
	.dump		=	netem_dump_class,
};

static struct Qdisc_ops netem_qdisc_ops = {
	.id		=	"netem",
	.cl_ops		=	&netem_class_ops,
	.priv_size	=	sizeof(struct netem_sched_data),
	.enqueue	=	netem_enqueue,
	.dequeue	=	netem_dequeue,
	.requeue	=	netem_requeue,
	.drop		=	netem_drop,
	.init		=	netem_init,
	.reset		=	netem_reset,
	.destroy	=	netem_destroy,
	.change		=	netem_change,
	.dump		=	netem_dump,
	.owner		=	THIS_MODULE,
};


static int __init netem_module_init(void)
{
	pr_info("netem: version " VERSION "\n");
	return register_qdisc(&netem_qdisc_ops);
}
static void __exit netem_module_exit(void)
{
	unregister_qdisc(&netem_qdisc_ops);
}
module_init(netem_module_init)
module_exit(netem_module_exit)
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* net/sched/sch_netem.c Network emulator
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
798b6b19	7	* 2 of the License.
1da177e4 LT	8	*
1da177e4 LT	9	* Many of the algorithms and ideas for this came from
10297b99	10	* NIST Net which is not copyrighted.
1da177e4 LT	11	*
	12	* Authors: Stephen Hemminger <shemminger@osdl.org>
	13	* Catalin(ux aka Dino) BOIE <catab at umbrella dot ro>
	14	*/
	15
1da177e4 LT	16	#include <linux/module.h>
	17	#include <linux/bitops.h>
	18	#include <linux/types.h>
	19	#include <linux/kernel.h>
	20	#include <linux/errno.h>
	21	#include <linux/netdevice.h>
	22	#include <linux/skbuff.h>
	23	#include <linux/rtnetlink.h>
	24
dc5fc579	25	#include <net/netlink.h>
1da177e4 LT	26	#include <net/pkt_sched.h>
1da177e4 LT	27
c865e5d9	28	#define VERSION "1.2"
eb229c4c	29
1da177e4 LT	30	/* Network Emulation Queuing algorithm.
	31	====================================
	32
	33	Sources: [1] Mark Carson, Darrin Santay, "NIST Net - A Linux-based
	34	Network Emulation Tool
	35	[2] Luigi Rizzo, DummyNet for FreeBSD
	36
	37	----------------------------------------------------------------
	38
	39	This started out as a simple way to delay outgoing packets to
	40	test TCP but has grown to include most of the functionality
	41	of a full blown network emulator like NISTnet. It can delay
	42	packets and add random jitter (and correlation). The random
	43	distribution can be loaded from a table as well to provide
	44	normal, Pareto, or experimental curves. Packet loss,
	45	duplication, and reordering can also be emulated.
	46
	47	This qdisc does not do classification that can be handled in
	48	layering other disciplines. It does not need to do bandwidth
	49	control either since that can be handled by using token
	50	bucket or other rate control.
	51
	52	The simulator is limited by the Linux timer resolution
	53	and will create packet bursts on the HZ boundary (1ms).
	54	*/
	55
	56	struct netem_sched_data {
	57	struct Qdisc *qdisc;
59cb5c67	58	struct qdisc_watchdog watchdog;
1da177e4 LT	59
	60	u32 latency;
	61	u32 loss;
	62	u32 limit;
	63	u32 counter;
	64	u32 gap;
	65	u32 jitter;
	66	u32 duplicate;
0dca51d3	67	u32 reorder;
c865e5d9	68	u32 corrupt;
1da177e4 LT	69
	70	struct crndstate {
	71	unsigned long last;
	72	unsigned long rho;
c865e5d9	73	} delay_cor, loss_cor, dup_cor, reorder_cor, corrupt_cor;
1da177e4 LT	74
	75	struct disttable {
	76	u32 size;
	77	s16 table[0];
	78	} *delay_dist;
	79	};
	80
	81	/* Time stamp put into socket buffer control block */
	82	struct netem_skb_cb {
	83	psched_time_t time_to_send;
	84	};
	85
	86	/* init_crandom - initialize correlated random number generator
	87	* Use entropy source for initial seed.
	88	*/
	89	static void init_crandom(struct crndstate *state, unsigned long rho)
	90	{
	91	state->rho = rho;
	92	state->last = net_random();
	93	}
	94
	95	/* get_crandom - correlated random number generator
	96	* Next number depends on last value.
	97	* rho is scaled to avoid floating point.
	98	*/
	99	static unsigned long get_crandom(struct crndstate *state)
	100	{
	101	u64 value, rho;
	102	unsigned long answer;
	103
	104	if (state->rho == 0) /* no correllation */
	105	return net_random();
	106
	107	value = net_random();
	108	rho = (u64)state->rho + 1;
	109	answer = (value * ((1ull<<32) - rho) + state->last * rho) >> 32;
	110	state->last = answer;
	111	return answer;
	112	}
	113
	114	/* tabledist - return a pseudo-randomly distributed value with mean mu and
	115	* std deviation sigma. Uses table lookup to approximate the desired
	116	* distribution, and a uniformly-distributed pseudo-random source.
	117	*/
10297b99	118	static long tabledist(unsigned long mu, long sigma,
1da177e4 LT	119	struct crndstate state, const struct disttable dist)
	120	{
	121	long t, x;
	122	unsigned long rnd;
	123
	124	if (sigma == 0)
	125	return mu;
	126
	127	rnd = get_crandom(state);
	128
	129	/* default uniform distribution */
10297b99	130	if (dist == NULL)
1da177e4 LT	131	return (rnd % (2*sigma)) - sigma + mu;
	132
	133	t = dist->table[rnd % dist->size];
	134	x = (sigma % NETEM_DIST_SCALE) * t;
	135	if (x >= 0)
	136	x += NETEM_DIST_SCALE/2;
	137	else
	138	x -= NETEM_DIST_SCALE/2;
	139
	140	return x / NETEM_DIST_SCALE + (sigma / NETEM_DIST_SCALE) * t + mu;
	141	}
	142
0afb51e7 SH	143	/*
	144	* Insert one skb into qdisc.
	145	* Note: parent depends on return value to account for queue length.
	146	* NET_XMIT_DROP: queue length didn't change.
	147	* NET_XMIT_SUCCESS: one skb was queued.
	148	*/
1da177e4 LT	149	static int netem_enqueue(struct sk_buff skb, struct Qdisc sch)
	150	{
	151	struct netem_sched_data *q = qdisc_priv(sch);
89e1df74 GC	152	/* We don't fill cb now as skb_unshare() may invalidate it */
89e1df74 GC	153	struct netem_skb_cb *cb;
0afb51e7	154	struct sk_buff *skb2;
1da177e4	155	int ret;
0afb51e7	156	int count = 1;
1da177e4	157
771018e7	158	pr_debug("netem_enqueue skb=%p\n", skb);
1da177e4	159
0afb51e7 SH	160	/* Random duplication */
	161	if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor))
	162	++count;
	163
1da177e4	164	/* Random packet drop 0 => none, ~0 => all */
0afb51e7 SH	165	if (q->loss && q->loss >= get_crandom(&q->loss_cor))
	166	--count;
	167
	168	if (count == 0) {
1da177e4 LT	169	sch->qstats.drops++;
1da177e4 LT	170	kfree_skb(skb);
89bbb0a3	171	return NET_XMIT_BYPASS;
1da177e4 LT	172	}
1da177e4 LT	173
4e8a5201 DM	174	skb_orphan(skb);
4e8a5201 DM	175
0afb51e7 SH	176	/*
	177	* If we need to duplicate packet, then re-insert at top of the
	178	* qdisc tree, since parent queuer expects that only one
	179	* skb will be queued.
	180	*/
	181	if (count > 1 && (skb2 = skb_clone(skb, GFP_ATOMIC)) != NULL) {
	182	struct Qdisc *rootq = sch->dev->qdisc;
	183	u32 dupsave = q->duplicate; /* prevent duplicating a dup... */
	184	q->duplicate = 0;
	185
	186	rootq->enqueue(skb2, rootq);
	187	q->duplicate = dupsave;
1da177e4 LT	188	}
1da177e4 LT	189
c865e5d9 SH	190	/*
	191	* Randomized packet corruption.
	192	* Make copy if needed since we are modifying
	193	* If packet is going to be hardware checksummed, then
	194	* do it now in software before we mangle it.
	195	*/
	196	if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) {
	197	if (!(skb = skb_unshare(skb, GFP_ATOMIC))
84fa7933 PM	198	\|\| (skb->ip_summed == CHECKSUM_PARTIAL
84fa7933 PM	199	&& skb_checksum_help(skb))) {
c865e5d9 SH	200	sch->qstats.drops++;
	201	return NET_XMIT_DROP;
	202	}
	203
	204	skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8);
	205	}
	206
89e1df74	207	cb = (struct netem_skb_cb *)skb->cb;
0dca51d3 SH	208	if (q->gap == 0 /* not doing reordering */
	209	\|\| q->counter < q->gap /* inside last reordering gap */
	210	\|\| q->reorder < get_crandom(&q->reorder_cor)) {
0f9f32ac	211	psched_time_t now;
07aaa115 SH	212	psched_tdiff_t delay;
	213
	214	delay = tabledist(q->latency, q->jitter,
	215	&q->delay_cor, q->delay_dist);
	216
0f9f32ac	217	PSCHED_GET_TIME(now);
07aaa115	218	PSCHED_TADD2(now, delay, cb->time_to_send);
1da177e4 LT	219	++q->counter;
	220	ret = q->qdisc->enqueue(skb, q->qdisc);
	221	} else {
10297b99	222	/*
0dca51d3 SH	223	* Do re-ordering by putting one out of N packets at the front
	224	* of the queue.
	225	*/
0f9f32ac	226	PSCHED_GET_TIME(cb->time_to_send);
0dca51d3	227	q->counter = 0;
0f9f32ac	228	ret = q->qdisc->ops->requeue(skb, q->qdisc);
1da177e4 LT	229	}
	230
	231	if (likely(ret == NET_XMIT_SUCCESS)) {
	232	sch->q.qlen++;
	233	sch->bstats.bytes += skb->len;
	234	sch->bstats.packets++;
	235	} else
	236	sch->qstats.drops++;
	237
d5d75cd6	238	pr_debug("netem: enqueue ret %d\n", ret);
1da177e4 LT	239	return ret;
	240	}
	241
	242	/* Requeue packets but don't change time stamp */
	243	static int netem_requeue(struct sk_buff skb, struct Qdisc sch)
	244	{
	245	struct netem_sched_data *q = qdisc_priv(sch);
	246	int ret;
	247
	248	if ((ret = q->qdisc->ops->requeue(skb, q->qdisc)) == 0) {
	249	sch->q.qlen++;
	250	sch->qstats.requeues++;
	251	}
	252
	253	return ret;
	254	}
	255
	256	static unsigned int netem_drop(struct Qdisc* sch)
	257	{
	258	struct netem_sched_data *q = qdisc_priv(sch);
6d037a26	259	unsigned int len = 0;
1da177e4	260
6d037a26	261	if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) {
1da177e4 LT	262	sch->q.qlen--;
	263	sch->qstats.drops++;
	264	}
	265	return len;
	266	}
	267
1da177e4 LT	268	static struct sk_buff netem_dequeue(struct Qdisc sch)
	269	{
	270	struct netem_sched_data *q = qdisc_priv(sch);
	271	struct sk_buff *skb;
	272
	273	skb = q->qdisc->dequeue(q->qdisc);
771018e7	274	if (skb) {
0f9f32ac SH	275	const struct netem_skb_cb *cb
	276	= (const struct netem_skb_cb *)skb->cb;
	277	psched_time_t now;
0f9f32ac SH	278
	279	/* if more time remaining? */
	280	PSCHED_GET_TIME(now);
07aaa115 SH	281
07aaa115 SH	282	if (PSCHED_TLESS(cb->time_to_send, now)) {
0f9f32ac SH	283	pr_debug("netem_dequeue: return skb=%p\n", skb);
	284	sch->q.qlen--;
	285	sch->flags &= ~TCQ_F_THROTTLED;
	286	return skb;
07aaa115	287	} else {
59cb5c67	288	qdisc_watchdog_schedule(&q->watchdog, cb->time_to_send);
0f9f32ac	289
07aaa115	290	if (q->qdisc->ops->requeue(skb, q->qdisc) != NET_XMIT_SUCCESS) {
e488eafc	291	qdisc_tree_decrease_qlen(q->qdisc, 1);
07aaa115	292	sch->qstats.drops++;
07aaa115 SH	293	printk(KERN_ERR "netem: queue discpline %s could not requeue\n",
07aaa115 SH	294	q->qdisc->ops->id);
07aaa115	295	}
07aaa115	296	}
0f9f32ac SH	297	}
	298
	299	return NULL;
1da177e4 LT	300	}
1da177e4 LT	301
1da177e4 LT	302	static void netem_reset(struct Qdisc *sch)
	303	{
	304	struct netem_sched_data *q = qdisc_priv(sch);
	305
	306	qdisc_reset(q->qdisc);
1da177e4	307	sch->q.qlen = 0;
59cb5c67	308	qdisc_watchdog_cancel(&q->watchdog);
1da177e4 LT	309	}
1da177e4 LT	310
300ce174	311	/* Pass size change message down to embedded FIFO */
1da177e4 LT	312	static int set_fifo_limit(struct Qdisc *q, int limit)
1da177e4 LT	313	{
10297b99	314	struct rtattr *rta;
1da177e4 LT	315	int ret = -ENOMEM;
1da177e4 LT	316
300ce174 SH	317	/* Hack to avoid sending change message to non-FIFO */
	318	if (strncmp(q->ops->id + 1, "fifo", 4) != 0)
	319	return 0;
	320
1da177e4 LT	321	rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
	322	if (rta) {
	323	rta->rta_type = RTM_NEWQDISC;
10297b99	324	rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt));
1da177e4	325	((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit;
10297b99	326
1da177e4 LT	327	ret = q->ops->change(q, rta);
	328	kfree(rta);
	329	}
	330	return ret;
	331	}
	332
	333	/*
	334	* Distribution data is a variable size payload containing
	335	* signed 16 bit values.
	336	*/
	337	static int get_dist_table(struct Qdisc sch, const struct rtattr attr)
	338	{
	339	struct netem_sched_data *q = qdisc_priv(sch);
	340	unsigned long n = RTA_PAYLOAD(attr)/sizeof(__s16);
	341	const __s16 *data = RTA_DATA(attr);
	342	struct disttable *d;
	343	int i;
	344
	345	if (n > 65536)
	346	return -EINVAL;
	347
	348	d = kmalloc(sizeof(d) + nsizeof(d->table[0]), GFP_KERNEL);
	349	if (!d)
	350	return -ENOMEM;
	351
	352	d->size = n;
	353	for (i = 0; i < n; i++)
	354	d->table[i] = data[i];
10297b99	355
1da177e4 LT	356	spin_lock_bh(&sch->dev->queue_lock);
	357	d = xchg(&q->delay_dist, d);
	358	spin_unlock_bh(&sch->dev->queue_lock);
	359
	360	kfree(d);
	361	return 0;
	362	}
	363
	364	static int get_correlation(struct Qdisc sch, const struct rtattr attr)
	365	{
	366	struct netem_sched_data *q = qdisc_priv(sch);
	367	const struct tc_netem_corr *c = RTA_DATA(attr);
	368
	369	if (RTA_PAYLOAD(attr) != sizeof(*c))
	370	return -EINVAL;
	371
	372	init_crandom(&q->delay_cor, c->delay_corr);
	373	init_crandom(&q->loss_cor, c->loss_corr);
	374	init_crandom(&q->dup_cor, c->dup_corr);
	375	return 0;
	376	}
	377
0dca51d3 SH	378	static int get_reorder(struct Qdisc sch, const struct rtattr attr)
	379	{
	380	struct netem_sched_data *q = qdisc_priv(sch);
	381	const struct tc_netem_reorder *r = RTA_DATA(attr);
	382
	383	if (RTA_PAYLOAD(attr) != sizeof(*r))
	384	return -EINVAL;
	385
	386	q->reorder = r->probability;
	387	init_crandom(&q->reorder_cor, r->correlation);
	388	return 0;
	389	}
	390
c865e5d9 SH	391	static int get_corrupt(struct Qdisc sch, const struct rtattr attr)
	392	{
	393	struct netem_sched_data *q = qdisc_priv(sch);
	394	const struct tc_netem_corrupt *r = RTA_DATA(attr);
	395
	396	if (RTA_PAYLOAD(attr) != sizeof(*r))
	397	return -EINVAL;
	398
	399	q->corrupt = r->probability;
	400	init_crandom(&q->corrupt_cor, r->correlation);
	401	return 0;
	402	}
	403
	404	/* Parse netlink message to set options */
1da177e4 LT	405	static int netem_change(struct Qdisc sch, struct rtattr opt)
	406	{
	407	struct netem_sched_data *q = qdisc_priv(sch);
	408	struct tc_netem_qopt *qopt;
	409	int ret;
10297b99	410
1da177e4 LT	411	if (opt == NULL \|\| RTA_PAYLOAD(opt) < sizeof(*qopt))
	412	return -EINVAL;
	413
	414	qopt = RTA_DATA(opt);
	415	ret = set_fifo_limit(q->qdisc, qopt->limit);
	416	if (ret) {
	417	pr_debug("netem: can't set fifo limit\n");
	418	return ret;
	419	}
10297b99	420
1da177e4 LT	421	q->latency = qopt->latency;
	422	q->jitter = qopt->jitter;
	423	q->limit = qopt->limit;
	424	q->gap = qopt->gap;
0dca51d3	425	q->counter = 0;
1da177e4 LT	426	q->loss = qopt->loss;
	427	q->duplicate = qopt->duplicate;
	428
0dca51d3 SH	429	/* for compatiablity with earlier versions.
	430	* if gap is set, need to assume 100% probablity
	431	*/
	432	q->reorder = ~0;
	433
1da177e4 LT	434	/* Handle nested options after initial queue options.
1da177e4 LT	435	* Should have put all options in nested format but too late now.
10297b99	436	*/
1da177e4 LT	437	if (RTA_PAYLOAD(opt) > sizeof(*qopt)) {
1da177e4 LT	438	struct rtattr *tb[TCA_NETEM_MAX];
10297b99	439	if (rtattr_parse(tb, TCA_NETEM_MAX,
1da177e4 LT	440	RTA_DATA(opt) + sizeof(*qopt),
	441	RTA_PAYLOAD(opt) - sizeof(*qopt)))
	442	return -EINVAL;
	443
	444	if (tb[TCA_NETEM_CORR-1]) {
	445	ret = get_correlation(sch, tb[TCA_NETEM_CORR-1]);
	446	if (ret)
	447	return ret;
	448	}
	449
	450	if (tb[TCA_NETEM_DELAY_DIST-1]) {
	451	ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST-1]);
	452	if (ret)
	453	return ret;
	454	}
c865e5d9	455
0dca51d3 SH	456	if (tb[TCA_NETEM_REORDER-1]) {
	457	ret = get_reorder(sch, tb[TCA_NETEM_REORDER-1]);
	458	if (ret)
	459	return ret;
	460	}
1da177e4	461
c865e5d9 SH	462	if (tb[TCA_NETEM_CORRUPT-1]) {
	463	ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT-1]);
	464	if (ret)
	465	return ret;
	466	}
	467	}
1da177e4 LT	468
	469	return 0;
	470	}
	471
300ce174 SH	472	/*
	473	* Special case version of FIFO queue for use by netem.
	474	* It queues in order based on timestamps in skb's
	475	*/
	476	struct fifo_sched_data {
	477	u32 limit;
	478	};
	479
	480	static int tfifo_enqueue(struct sk_buff nskb, struct Qdisc sch)
	481	{
	482	struct fifo_sched_data *q = qdisc_priv(sch);
	483	struct sk_buff_head *list = &sch->q;
	484	const struct netem_skb_cb *ncb
	485	= (const struct netem_skb_cb *)nskb->cb;
	486	struct sk_buff *skb;
	487
	488	if (likely(skb_queue_len(list) < q->limit)) {
	489	skb_queue_reverse_walk(list, skb) {
	490	const struct netem_skb_cb *cb
	491	= (const struct netem_skb_cb *)skb->cb;
	492
aa875166	493	if (!PSCHED_TLESS(ncb->time_to_send, cb->time_to_send))
300ce174 SH	494	break;
	495	}
	496
	497	__skb_queue_after(list, skb, nskb);
	498
	499	sch->qstats.backlog += nskb->len;
	500	sch->bstats.bytes += nskb->len;
	501	sch->bstats.packets++;
	502
	503	return NET_XMIT_SUCCESS;
	504	}
	505
	506	return qdisc_drop(nskb, sch);
	507	}
	508
	509	static int tfifo_init(struct Qdisc sch, struct rtattr opt)
	510	{
	511	struct fifo_sched_data *q = qdisc_priv(sch);
	512
	513	if (opt) {
	514	struct tc_fifo_qopt *ctl = RTA_DATA(opt);
	515	if (RTA_PAYLOAD(opt) < sizeof(*ctl))
	516	return -EINVAL;
	517
	518	q->limit = ctl->limit;
	519	} else
	520	q->limit = max_t(u32, sch->dev->tx_queue_len, 1);
	521
	522	return 0;
	523	}
	524
	525	static int tfifo_dump(struct Qdisc sch, struct sk_buff skb)
	526	{
	527	struct fifo_sched_data *q = qdisc_priv(sch);
	528	struct tc_fifo_qopt opt = { .limit = q->limit };
	529
	530	RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
	531	return skb->len;
	532
	533	rtattr_failure:
	534	return -1;
	535	}
	536
	537	static struct Qdisc_ops tfifo_qdisc_ops = {
	538	.id = "tfifo",
	539	.priv_size = sizeof(struct fifo_sched_data),
	540	.enqueue = tfifo_enqueue,
	541	.dequeue = qdisc_dequeue_head,
	542	.requeue = qdisc_requeue,
	543	.drop = qdisc_queue_drop,
	544	.init = tfifo_init,
	545	.reset = qdisc_reset_queue,
	546	.change = tfifo_init,
	547	.dump = tfifo_dump,
	548	};
	549
1da177e4 LT	550	static int netem_init(struct Qdisc sch, struct rtattr opt)
	551	{
	552	struct netem_sched_data *q = qdisc_priv(sch);
	553	int ret;
	554
	555	if (!opt)
	556	return -EINVAL;
	557
59cb5c67	558	qdisc_watchdog_init(&q->watchdog, sch);
1da177e4	559
9f9afec4 PM	560	q->qdisc = qdisc_create_dflt(sch->dev, &tfifo_qdisc_ops,
9f9afec4 PM	561	TC_H_MAKE(sch->handle, 1));
1da177e4 LT	562	if (!q->qdisc) {
	563	pr_debug("netem: qdisc create failed\n");
	564	return -ENOMEM;
	565	}
	566
	567	ret = netem_change(sch, opt);
	568	if (ret) {
	569	pr_debug("netem: change failed\n");
	570	qdisc_destroy(q->qdisc);
	571	}
	572	return ret;
	573	}
	574
	575	static void netem_destroy(struct Qdisc *sch)
	576	{
	577	struct netem_sched_data *q = qdisc_priv(sch);
	578
59cb5c67	579	qdisc_watchdog_cancel(&q->watchdog);
1da177e4 LT	580	qdisc_destroy(q->qdisc);
	581	kfree(q->delay_dist);
	582	}
	583
	584	static int netem_dump(struct Qdisc sch, struct sk_buff skb)
	585	{
	586	const struct netem_sched_data *q = qdisc_priv(sch);
27a884dc	587	unsigned char *b = skb_tail_pointer(skb);
1da177e4 LT	588	struct rtattr rta = (struct rtattr ) b;
	589	struct tc_netem_qopt qopt;
	590	struct tc_netem_corr cor;
0dca51d3	591	struct tc_netem_reorder reorder;
c865e5d9	592	struct tc_netem_corrupt corrupt;
1da177e4 LT	593
	594	qopt.latency = q->latency;
	595	qopt.jitter = q->jitter;
	596	qopt.limit = q->limit;
	597	qopt.loss = q->loss;
	598	qopt.gap = q->gap;
	599	qopt.duplicate = q->duplicate;
	600	RTA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt);
	601
	602	cor.delay_corr = q->delay_cor.rho;
	603	cor.loss_corr = q->loss_cor.rho;
	604	cor.dup_corr = q->dup_cor.rho;
	605	RTA_PUT(skb, TCA_NETEM_CORR, sizeof(cor), &cor);
0dca51d3 SH	606
	607	reorder.probability = q->reorder;
	608	reorder.correlation = q->reorder_cor.rho;
	609	RTA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
	610
c865e5d9 SH	611	corrupt.probability = q->corrupt;
	612	corrupt.correlation = q->corrupt_cor.rho;
	613	RTA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
	614
27a884dc	615	rta->rta_len = skb_tail_pointer(skb) - b;
1da177e4 LT	616
	617	return skb->len;
	618
	619	rtattr_failure:
dc5fc579	620	nlmsg_trim(skb, b);
1da177e4 LT	621	return -1;
	622	}
	623
	624	static int netem_dump_class(struct Qdisc *sch, unsigned long cl,
	625	struct sk_buff skb, struct tcmsg tcm)
	626	{
	627	struct netem_sched_data *q = qdisc_priv(sch);
	628
	629	if (cl != 1) /* only one class */
	630	return -ENOENT;
	631
	632	tcm->tcm_handle \|= TC_H_MIN(1);
	633	tcm->tcm_info = q->qdisc->handle;
	634
	635	return 0;
	636	}
	637
	638	static int netem_graft(struct Qdisc sch, unsigned long arg, struct Qdisc new,
	639	struct Qdisc **old)
	640	{
	641	struct netem_sched_data *q = qdisc_priv(sch);
	642
	643	if (new == NULL)
	644	new = &noop_qdisc;
	645
	646	sch_tree_lock(sch);
	647	*old = xchg(&q->qdisc, new);
5e50da01	648	qdisc_tree_decrease_qlen(old, (old)->q.qlen);
1da177e4	649	qdisc_reset(*old);
1da177e4 LT	650	sch_tree_unlock(sch);
	651
	652	return 0;
	653	}
	654
	655	static struct Qdisc netem_leaf(struct Qdisc sch, unsigned long arg)
	656	{
	657	struct netem_sched_data *q = qdisc_priv(sch);
	658	return q->qdisc;
	659	}
	660
	661	static unsigned long netem_get(struct Qdisc *sch, u32 classid)
	662	{
	663	return 1;
	664	}
	665
	666	static void netem_put(struct Qdisc *sch, unsigned long arg)
	667	{
	668	}
	669
10297b99	670	static int netem_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
1da177e4 LT	671	struct rtattr *tca, unsigned long arg)
	672	{
	673	return -ENOSYS;
	674	}
	675
	676	static int netem_delete(struct Qdisc *sch, unsigned long arg)
	677	{
	678	return -ENOSYS;
	679	}
	680
	681	static void netem_walk(struct Qdisc sch, struct qdisc_walker walker)
	682	{
	683	if (!walker->stop) {
	684	if (walker->count >= walker->skip)
	685	if (walker->fn(sch, 1, walker) < 0) {
	686	walker->stop = 1;
	687	return;
	688	}
	689	walker->count++;
	690	}
	691	}
	692
	693	static struct tcf_proto *netem_find_tcf(struct Qdisc sch, unsigned long cl)
	694	{
	695	return NULL;
	696	}
	697
	698	static struct Qdisc_class_ops netem_class_ops = {
	699	.graft = netem_graft,
	700	.leaf = netem_leaf,
	701	.get = netem_get,
	702	.put = netem_put,
	703	.change = netem_change_class,
	704	.delete = netem_delete,
	705	.walk = netem_walk,
	706	.tcf_chain = netem_find_tcf,
	707	.dump = netem_dump_class,
	708	};
	709
	710	static struct Qdisc_ops netem_qdisc_ops = {
	711	.id = "netem",
	712	.cl_ops = &netem_class_ops,
	713	.priv_size = sizeof(struct netem_sched_data),
	714	.enqueue = netem_enqueue,
	715	.dequeue = netem_dequeue,
	716	.requeue = netem_requeue,
	717	.drop = netem_drop,
	718	.init = netem_init,
	719	.reset = netem_reset,
	720	.destroy = netem_destroy,
	721	.change = netem_change,
	722	.dump = netem_dump,
	723	.owner = THIS_MODULE,
	724	};
	725
	726
	727	static int __init netem_module_init(void)
	728	{
eb229c4c	729	pr_info("netem: version " VERSION "\n");
1da177e4 LT	730	return register_qdisc(&netem_qdisc_ops);
	731	}
	732	static void __exit netem_module_exit(void)
	733	{
	734	unregister_qdisc(&netem_qdisc_ops);
	735	}
	736	module_init(netem_module_init)
	737	module_exit(netem_module_exit)
	738	MODULE_LICENSE("GPL");