[mirror_ubuntu-artful-kernel.git] / net / sched / sch_ingress.c

/* net/sched/sch_ingress.c - Ingress qdisc
 *              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, or (at your option) any later version.
 *
 * Authors:     Jamal Hadi Salim 1999
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/list.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/netfilter_ipv4.h>
#include <linux/netfilter_ipv6.h>
#include <linux/netfilter.h>
#include <net/netlink.h>
#include <net/pkt_sched.h>


#undef DEBUG_INGRESS

#ifdef DEBUG_INGRESS  /* control */
#define DPRINTK(format, args...) printk(KERN_DEBUG format,##args)
#else
#define DPRINTK(format, args...)
#endif

#if 0  /* data */
#define D2PRINTK(format, args...) printk(KERN_DEBUG format,##args)
#else
#define D2PRINTK(format, args...)
#endif

#define PRIV(sch) qdisc_priv(sch)

/* Thanks to Doron Oz for this hack */
#ifndef CONFIG_NET_CLS_ACT
#ifdef CONFIG_NETFILTER
static int nf_registered;
#endif
#endif

struct ingress_qdisc_data {
	struct Qdisc		*q;
	struct tcf_proto	*filter_list;
};

/* ------------------------- Class/flow operations ------------------------- */

static int ingress_graft(struct Qdisc *sch, unsigned long arg,
			 struct Qdisc *new, struct Qdisc **old)
{
#ifdef DEBUG_INGRESS
	struct ingress_qdisc_data *p = PRIV(sch);
#endif

	DPRINTK("ingress_graft(sch %p,[qdisc %p],new %p,old %p)\n",
		sch, p, new, old);
	DPRINTK("\n ingress_graft: You cannot add qdiscs to classes");
	return 1;
}

static struct Qdisc *ingress_leaf(struct Qdisc *sch, unsigned long arg)
{
	return NULL;
}

static unsigned long ingress_get(struct Qdisc *sch, u32 classid)
{
#ifdef DEBUG_INGRESS
	struct ingress_qdisc_data *p = PRIV(sch);
#endif
	DPRINTK("ingress_get(sch %p,[qdisc %p],classid %x)\n",
		sch, p, classid);
	return TC_H_MIN(classid) + 1;
}

static unsigned long ingress_bind_filter(struct Qdisc *sch,
					 unsigned long parent, u32 classid)
{
	return ingress_get(sch, classid);
}

static void ingress_put(struct Qdisc *sch, unsigned long cl)
{
}

static int ingress_change(struct Qdisc *sch, u32 classid, u32 parent,
			  struct rtattr **tca, unsigned long *arg)
{
#ifdef DEBUG_INGRESS
	struct ingress_qdisc_data *p = PRIV(sch);
#endif
	DPRINTK("ingress_change(sch %p,[qdisc %p],classid %x,parent %x),"
		"arg 0x%lx\n", sch, p, classid, parent, *arg);
	DPRINTK("No effect. sch_ingress doesn't maintain classes at the moment");
	return 0;
}

static void ingress_walk(struct Qdisc *sch, struct qdisc_walker *walker)
{
#ifdef DEBUG_INGRESS
	struct ingress_qdisc_data *p = PRIV(sch);
#endif
	DPRINTK("ingress_walk(sch %p,[qdisc %p],walker %p)\n", sch, p, walker);
	DPRINTK("No effect. sch_ingress doesn't maintain classes at the moment");
}

static struct tcf_proto **ingress_find_tcf(struct Qdisc *sch, unsigned long cl)
{
	struct ingress_qdisc_data *p = PRIV(sch);

	return &p->filter_list;
}

/* --------------------------- Qdisc operations ---------------------------- */

static int ingress_enqueue(struct sk_buff *skb, struct Qdisc *sch)
{
	struct ingress_qdisc_data *p = PRIV(sch);
	struct tcf_result res;
	int result;

	D2PRINTK("ingress_enqueue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);
	result = tc_classify(skb, p->filter_list, &res);
	D2PRINTK("result %d class 0x%04x\n", result, res.classid);
	/*
	 * Unlike normal "enqueue" functions, ingress_enqueue returns a
	 * firewall FW_* code.
	 */
#ifdef CONFIG_NET_CLS_ACT
	sch->bstats.packets++;
	sch->bstats.bytes += skb->len;
	switch (result) {
	case TC_ACT_SHOT:
		result = TC_ACT_SHOT;
		sch->qstats.drops++;
		break;
	case TC_ACT_STOLEN:
	case TC_ACT_QUEUED:
		result = TC_ACT_STOLEN;
		break;
	case TC_ACT_RECLASSIFY:
	case TC_ACT_OK:
		skb->tc_index = TC_H_MIN(res.classid);
	default:
		result = TC_ACT_OK;
		break;
	}
#else
	D2PRINTK("Overriding result to ACCEPT\n");
	result = NF_ACCEPT;
	sch->bstats.packets++;
	sch->bstats.bytes += skb->len;
#endif

	return result;
}

static struct sk_buff *ingress_dequeue(struct Qdisc *sch)
{
/*
	struct ingress_qdisc_data *p = PRIV(sch);
	D2PRINTK("ingress_dequeue(sch %p,[qdisc %p])\n",sch,PRIV(p));
*/
	return NULL;
}

static int ingress_requeue(struct sk_buff *skb, struct Qdisc *sch)
{
/*
	struct ingress_qdisc_data *p = PRIV(sch);
	D2PRINTK("ingress_requeue(skb %p,sch %p,[qdisc %p])\n",skb,sch,PRIV(p));
*/
	return 0;
}

static unsigned int ingress_drop(struct Qdisc *sch)
{
#ifdef DEBUG_INGRESS
	struct ingress_qdisc_data *p = PRIV(sch);
#endif
	DPRINTK("ingress_drop(sch %p,[qdisc %p])\n", sch, p);
	return 0;
}

#ifndef CONFIG_NET_CLS_ACT
#ifdef CONFIG_NETFILTER
static unsigned int ing_hook(unsigned int hook, struct sk_buff *skb,
			     const struct net_device *indev,
			     const struct net_device *outdev,
			     int (*okfn)(struct sk_buff *))
{

	struct Qdisc *q;
	struct net_device *dev = skb->dev;
	int fwres = NF_ACCEPT;

	DPRINTK("ing_hook: skb %s dev=%s len=%u\n",
		skb->sk ? "(owned)" : "(unowned)",
		skb->dev ? skb->dev->name : "(no dev)",
		skb->len);

	if (dev->qdisc_ingress) {
		spin_lock(&dev->ingress_lock);
		if ((q = dev->qdisc_ingress) != NULL)
			fwres = q->enqueue(skb, q);
		spin_unlock(&dev->ingress_lock);
	}

	return fwres;
}

/* after ipt_filter */
static struct nf_hook_ops ing_ops[] __read_mostly = {
	{
		.hook           = ing_hook,
		.owner		= THIS_MODULE,
		.pf             = PF_INET,
		.hooknum        = NF_INET_PRE_ROUTING,
		.priority       = NF_IP_PRI_FILTER + 1,
	},
	{
		.hook           = ing_hook,
		.owner		= THIS_MODULE,
		.pf             = PF_INET6,
		.hooknum        = NF_INET_PRE_ROUTING,
		.priority       = NF_IP6_PRI_FILTER + 1,
	},
};
#endif
#endif

static int ingress_init(struct Qdisc *sch, struct rtattr *opt)
{
	struct ingress_qdisc_data *p = PRIV(sch);

	/* Make sure either netfilter or preferably CLS_ACT is
	 * compiled in */
#ifndef CONFIG_NET_CLS_ACT
#ifndef CONFIG_NETFILTER
	printk("You MUST compile classifier actions into the kernel\n");
	return -EINVAL;
#else
	printk("Ingress scheduler: Classifier actions prefered over netfilter\n");
#endif
#endif

#ifndef CONFIG_NET_CLS_ACT
#ifdef CONFIG_NETFILTER
	if (!nf_registered) {
		if (nf_register_hooks(ing_ops, ARRAY_SIZE(ing_ops)) < 0) {
			printk("ingress qdisc registration error \n");
			return -EINVAL;
		}
		nf_registered++;
	}
#endif
#endif

	DPRINTK("ingress_init(sch %p,[qdisc %p],opt %p)\n", sch, p, opt);
	p->q = &noop_qdisc;
	return 0;
}

static void ingress_reset(struct Qdisc *sch)
{
	struct ingress_qdisc_data *p = PRIV(sch);

	DPRINTK("ingress_reset(sch %p,[qdisc %p])\n", sch, p);

/*
#if 0
*/
/* for future use */
	qdisc_reset(p->q);
/*
#endif
*/
}

/* ------------------------------------------------------------- */

static void ingress_destroy(struct Qdisc *sch)
{
	struct ingress_qdisc_data *p = PRIV(sch);

	DPRINTK("ingress_destroy(sch %p,[qdisc %p])\n", sch, p);
	tcf_destroy_chain(p->filter_list);
#if 0
/* for future use */
	qdisc_destroy(p->q);
#endif
}

static int ingress_dump(struct Qdisc *sch, struct sk_buff *skb)
{
	unsigned char *b = skb_tail_pointer(skb);
	struct rtattr *rta;

	rta = (struct rtattr *)b;
	RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
	rta->rta_len = skb_tail_pointer(skb) - b;
	return skb->len;

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

static const struct Qdisc_class_ops ingress_class_ops = {
	.graft		=	ingress_graft,
	.leaf		=	ingress_leaf,
	.get		=	ingress_get,
	.put		=	ingress_put,
	.change		=	ingress_change,
	.walk		=	ingress_walk,
	.tcf_chain	=	ingress_find_tcf,
	.bind_tcf	=	ingress_bind_filter,
	.unbind_tcf	=	ingress_put,
};

static struct Qdisc_ops ingress_qdisc_ops __read_mostly = {
	.cl_ops		=	&ingress_class_ops,
	.id		=	"ingress",
	.priv_size	=	sizeof(struct ingress_qdisc_data),
	.enqueue	=	ingress_enqueue,
	.dequeue	=	ingress_dequeue,
	.requeue	=	ingress_requeue,
	.drop		=	ingress_drop,
	.init		=	ingress_init,
	.reset		=	ingress_reset,
	.destroy	=	ingress_destroy,
	.dump		=	ingress_dump,
	.owner		=	THIS_MODULE,
};

static int __init ingress_module_init(void)
{
	int ret = 0;

	if ((ret = register_qdisc(&ingress_qdisc_ops)) < 0) {
		printk("Unable to register Ingress qdisc\n");
		return ret;
	}

	return ret;
}

static void __exit ingress_module_exit(void)
{
	unregister_qdisc(&ingress_qdisc_ops);
#ifndef CONFIG_NET_CLS_ACT
#ifdef CONFIG_NETFILTER
	if (nf_registered)
		nf_unregister_hooks(ing_ops, ARRAY_SIZE(ing_ops));
#endif
#endif
}

module_init(ingress_module_init)
module_exit(ingress_module_exit)
MODULE_LICENSE("GPL");
Commit	Line	Data
10297b99	1	/* net/sched/sch_ingress.c - Ingress qdisc
1da177e4 LT	2	* This program is free software; you can redistribute it and/or
	3	* modify it under the terms of the GNU General Public License
	4	* as published by the Free Software Foundation; either version
	5	* 2 of the License, or (at your option) any later version.
	6	*
	7	* Authors: Jamal Hadi Salim 1999
	8	*/
	9
1da177e4 LT	10	#include <linux/module.h>
1da177e4 LT	11	#include <linux/types.h>
0ba48053	12	#include <linux/list.h>
1da177e4	13	#include <linux/skbuff.h>
1da177e4 LT	14	#include <linux/rtnetlink.h>
	15	#include <linux/netfilter_ipv4.h>
	16	#include <linux/netfilter_ipv6.h>
	17	#include <linux/netfilter.h>
dc5fc579	18	#include <net/netlink.h>
1da177e4	19	#include <net/pkt_sched.h>
1da177e4 LT	20
	21
	22	#undef DEBUG_INGRESS
	23
	24	#ifdef DEBUG_INGRESS /* control */
58f4df42	25	#define DPRINTK(format, args...) printk(KERN_DEBUG format,##args)
1da177e4	26	#else
58f4df42	27	#define DPRINTK(format, args...)
1da177e4 LT	28	#endif
	29
	30	#if 0 /* data */
58f4df42	31	#define D2PRINTK(format, args...) printk(KERN_DEBUG format,##args)
1da177e4	32	#else
58f4df42	33	#define D2PRINTK(format, args...)
1da177e4 LT	34	#endif
1da177e4 LT	35
1da177e4 LT	36	#define PRIV(sch) qdisc_priv(sch)
1da177e4 LT	37
58f4df42	38	/* Thanks to Doron Oz for this hack */
1da177e4 LT	39	#ifndef CONFIG_NET_CLS_ACT
1da177e4 LT	40	#ifdef CONFIG_NETFILTER
10297b99	41	static int nf_registered;
1da177e4 LT	42	#endif
	43	#endif
	44
	45	struct ingress_qdisc_data {
	46	struct Qdisc *q;
	47	struct tcf_proto *filter_list;
	48	};
	49
1da177e4 LT	50	/* ------------------------- Class/flow operations ------------------------- */
1da177e4 LT	51
58f4df42 PM	52	static int ingress_graft(struct Qdisc *sch, unsigned long arg,
58f4df42 PM	53	struct Qdisc new, struct Qdisc *old)
1da177e4 LT	54	{
	55	#ifdef DEBUG_INGRESS
	56	struct ingress_qdisc_data *p = PRIV(sch);
	57	#endif
	58
	59	DPRINTK("ingress_graft(sch %p,[qdisc %p],new %p,old %p)\n",
	60	sch, p, new, old);
	61	DPRINTK("\n ingress_graft: You cannot add qdiscs to classes");
10297b99	62	return 1;
1da177e4 LT	63	}
1da177e4 LT	64
1da177e4 LT	65	static struct Qdisc ingress_leaf(struct Qdisc sch, unsigned long arg)
	66	{
	67	return NULL;
	68	}
	69
58f4df42	70	static unsigned long ingress_get(struct Qdisc *sch, u32 classid)
1da177e4 LT	71	{
	72	#ifdef DEBUG_INGRESS
	73	struct ingress_qdisc_data *p = PRIV(sch);
	74	#endif
58f4df42 PM	75	DPRINTK("ingress_get(sch %p,[qdisc %p],classid %x)\n",
58f4df42 PM	76	sch, p, classid);
1da177e4 LT	77	return TC_H_MIN(classid) + 1;
	78	}
	79
1da177e4	80	static unsigned long ingress_bind_filter(struct Qdisc *sch,
58f4df42	81	unsigned long parent, u32 classid)
1da177e4 LT	82	{
	83	return ingress_get(sch, classid);
	84	}
	85
1da177e4 LT	86	static void ingress_put(struct Qdisc *sch, unsigned long cl)
	87	{
	88	}
	89
1da177e4	90	static int ingress_change(struct Qdisc *sch, u32 classid, u32 parent,
58f4df42	91	struct rtattr *tca, unsigned long arg)
1da177e4 LT	92	{
	93	#ifdef DEBUG_INGRESS
	94	struct ingress_qdisc_data *p = PRIV(sch);
	95	#endif
	96	DPRINTK("ingress_change(sch %p,[qdisc %p],classid %x,parent %x),"
	97	"arg 0x%lx\n", sch, p, classid, parent, *arg);
	98	DPRINTK("No effect. sch_ingress doesn't maintain classes at the moment");
	99	return 0;
	100	}
	101
58f4df42	102	static void ingress_walk(struct Qdisc sch, struct qdisc_walker walker)
1da177e4 LT	103	{
	104	#ifdef DEBUG_INGRESS
	105	struct ingress_qdisc_data *p = PRIV(sch);
	106	#endif
	107	DPRINTK("ingress_walk(sch %p,[qdisc %p],walker %p)\n", sch, p, walker);
	108	DPRINTK("No effect. sch_ingress doesn't maintain classes at the moment");
	109	}
	110
58f4df42	111	static struct tcf_proto *ingress_find_tcf(struct Qdisc sch, unsigned long cl)
1da177e4 LT	112	{
	113	struct ingress_qdisc_data *p = PRIV(sch);
	114
	115	return &p->filter_list;
	116	}
	117
1da177e4 LT	118	/* --------------------------- Qdisc operations ---------------------------- */
1da177e4 LT	119
58f4df42	120	static int ingress_enqueue(struct sk_buff skb, struct Qdisc sch)
1da177e4 LT	121	{
	122	struct ingress_qdisc_data *p = PRIV(sch);
	123	struct tcf_result res;
	124	int result;
	125
	126	D2PRINTK("ingress_enqueue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);
	127	result = tc_classify(skb, p->filter_list, &res);
	128	D2PRINTK("result %d class 0x%04x\n", result, res.classid);
	129	/*
	130	* Unlike normal "enqueue" functions, ingress_enqueue returns a
	131	* firewall FW_* code.
	132	*/
	133	#ifdef CONFIG_NET_CLS_ACT
	134	sch->bstats.packets++;
	135	sch->bstats.bytes += skb->len;
	136	switch (result) {
58f4df42 PM	137	case TC_ACT_SHOT:
	138	result = TC_ACT_SHOT;
	139	sch->qstats.drops++;
	140	break;
	141	case TC_ACT_STOLEN:
	142	case TC_ACT_QUEUED:
	143	result = TC_ACT_STOLEN;
	144	break;
	145	case TC_ACT_RECLASSIFY:
	146	case TC_ACT_OK:
	147	skb->tc_index = TC_H_MIN(res.classid);
	148	default:
	149	result = TC_ACT_OK;
	150	break;
3ff50b79	151	}
1da177e4 LT	152	#else
	153	D2PRINTK("Overriding result to ACCEPT\n");
	154	result = NF_ACCEPT;
	155	sch->bstats.packets++;
	156	sch->bstats.bytes += skb->len;
1da177e4 LT	157	#endif
	158
	159	return result;
	160	}
	161
1da177e4 LT	162	static struct sk_buff ingress_dequeue(struct Qdisc sch)
	163	{
	164	/*
	165	struct ingress_qdisc_data *p = PRIV(sch);
	166	D2PRINTK("ingress_dequeue(sch %p,[qdisc %p])\n",sch,PRIV(p));
	167	*/
	168	return NULL;
	169	}
	170
58f4df42	171	static int ingress_requeue(struct sk_buff skb, struct Qdisc sch)
1da177e4 LT	172	{
	173	/*
	174	struct ingress_qdisc_data *p = PRIV(sch);
	175	D2PRINTK("ingress_requeue(skb %p,sch %p,[qdisc %p])\n",skb,sch,PRIV(p));
	176	*/
	177	return 0;
	178	}
	179
	180	static unsigned int ingress_drop(struct Qdisc *sch)
	181	{
	182	#ifdef DEBUG_INGRESS
	183	struct ingress_qdisc_data *p = PRIV(sch);
	184	#endif
	185	DPRINTK("ingress_drop(sch %p,[qdisc %p])\n", sch, p);
	186	return 0;
	187	}
	188
	189	#ifndef CONFIG_NET_CLS_ACT
	190	#ifdef CONFIG_NETFILTER
58f4df42	191	static unsigned int ing_hook(unsigned int hook, struct sk_buff *skb,
10297b99 YH	192	const struct net_device *indev,
	193	const struct net_device *outdev,
	194	int (okfn)(struct sk_buff ))
1da177e4	195	{
10297b99	196
1da177e4	197	struct Qdisc *q;
10297b99	198	struct net_device *dev = skb->dev;
58f4df42	199	int fwres = NF_ACCEPT;
1da177e4 LT	200
	201	DPRINTK("ing_hook: skb %s dev=%s len=%u\n",
	202	skb->sk ? "(owned)" : "(unowned)",
3db05fea	203	skb->dev ? skb->dev->name : "(no dev)",
1da177e4 LT	204	skb->len);
1da177e4 LT	205
1da177e4	206	if (dev->qdisc_ingress) {
fd44de7c	207	spin_lock(&dev->ingress_lock);
1da177e4 LT	208	if ((q = dev->qdisc_ingress) != NULL)
1da177e4 LT	209	fwres = q->enqueue(skb, q);
fd44de7c	210	spin_unlock(&dev->ingress_lock);
10297b99 YH	211	}
10297b99 YH	212
1da177e4 LT	213	return fwres;
	214	}
	215
	216	/* after ipt_filter */
1999414a	217	static struct nf_hook_ops ing_ops[] __read_mostly = {
41c5b317 PM	218	{
	219	.hook = ing_hook,
	220	.owner = THIS_MODULE,
	221	.pf = PF_INET,
	222	.hooknum = NF_INET_PRE_ROUTING,
	223	.priority = NF_IP_PRI_FILTER + 1,
	224	},
	225	{
	226	.hook = ing_hook,
	227	.owner = THIS_MODULE,
	228	.pf = PF_INET6,
	229	.hooknum = NF_INET_PRE_ROUTING,
	230	.priority = NF_IP6_PRI_FILTER + 1,
	231	},
1da177e4	232	};
1da177e4 LT	233	#endif
	234	#endif
	235
58f4df42	236	static int ingress_init(struct Qdisc sch, struct rtattr opt)
1da177e4 LT	237	{
	238	struct ingress_qdisc_data *p = PRIV(sch);
	239
58f4df42 PM	240	/* Make sure either netfilter or preferably CLS_ACT is
58f4df42 PM	241	* compiled in */
1da177e4 LT	242	#ifndef CONFIG_NET_CLS_ACT
	243	#ifndef CONFIG_NETFILTER
	244	printk("You MUST compile classifier actions into the kernel\n");
	245	return -EINVAL;
	246	#else
	247	printk("Ingress scheduler: Classifier actions prefered over netfilter\n");
	248	#endif
	249	#endif
10297b99	250
1da177e4 LT	251	#ifndef CONFIG_NET_CLS_ACT
	252	#ifdef CONFIG_NETFILTER
	253	if (!nf_registered) {
41c5b317	254	if (nf_register_hooks(ing_ops, ARRAY_SIZE(ing_ops)) < 0) {
1da177e4 LT	255	printk("ingress qdisc registration error \n");
	256	return -EINVAL;
	257	}
	258	nf_registered++;
1da177e4 LT	259	}
	260	#endif
	261	#endif
	262
58f4df42	263	DPRINTK("ingress_init(sch %p,[qdisc %p],opt %p)\n", sch, p, opt);
1da177e4 LT	264	p->q = &noop_qdisc;
	265	return 0;
	266	}
	267
1da177e4 LT	268	static void ingress_reset(struct Qdisc *sch)
	269	{
	270	struct ingress_qdisc_data *p = PRIV(sch);
	271
	272	DPRINTK("ingress_reset(sch %p,[qdisc %p])\n", sch, p);
	273
	274	/*
	275	#if 0
	276	*/
	277	/* for future use */
	278	qdisc_reset(p->q);
	279	/*
	280	#endif
	281	*/
	282	}
	283
1da177e4 LT	284	/* ------------------------------------------------------------- */
	285
	286	static void ingress_destroy(struct Qdisc *sch)
	287	{
	288	struct ingress_qdisc_data *p = PRIV(sch);
1da177e4 LT	289
1da177e4 LT	290	DPRINTK("ingress_destroy(sch %p,[qdisc %p])\n", sch, p);
a48b5a61	291	tcf_destroy_chain(p->filter_list);
1da177e4 LT	292	#if 0
	293	/* for future use */
	294	qdisc_destroy(p->q);
	295	#endif
	296	}
	297
1da177e4 LT	298	static int ingress_dump(struct Qdisc sch, struct sk_buff skb)
1da177e4 LT	299	{
27a884dc	300	unsigned char *b = skb_tail_pointer(skb);
1da177e4 LT	301	struct rtattr *rta;
1da177e4 LT	302
58f4df42	303	rta = (struct rtattr *)b;
1da177e4	304	RTA_PUT(skb, TCA_OPTIONS, 0, NULL);
27a884dc	305	rta->rta_len = skb_tail_pointer(skb) - b;
1da177e4 LT	306	return skb->len;
	307
	308	rtattr_failure:
dc5fc579	309	nlmsg_trim(skb, b);
1da177e4 LT	310	return -1;
	311	}
	312
20fea08b	313	static const struct Qdisc_class_ops ingress_class_ops = {
1da177e4 LT	314	.graft = ingress_graft,
	315	.leaf = ingress_leaf,
	316	.get = ingress_get,
	317	.put = ingress_put,
	318	.change = ingress_change,
1da177e4 LT	319	.walk = ingress_walk,
	320	.tcf_chain = ingress_find_tcf,
	321	.bind_tcf = ingress_bind_filter,
	322	.unbind_tcf = ingress_put,
1da177e4 LT	323	};
1da177e4 LT	324
20fea08b	325	static struct Qdisc_ops ingress_qdisc_ops __read_mostly = {
1da177e4 LT	326	.cl_ops = &ingress_class_ops,
	327	.id = "ingress",
	328	.priv_size = sizeof(struct ingress_qdisc_data),
	329	.enqueue = ingress_enqueue,
	330	.dequeue = ingress_dequeue,
	331	.requeue = ingress_requeue,
	332	.drop = ingress_drop,
	333	.init = ingress_init,
	334	.reset = ingress_reset,
	335	.destroy = ingress_destroy,
1da177e4 LT	336	.dump = ingress_dump,
	337	.owner = THIS_MODULE,
	338	};
	339
	340	static int __init ingress_module_init(void)
	341	{
	342	int ret = 0;
	343
	344	if ((ret = register_qdisc(&ingress_qdisc_ops)) < 0) {
	345	printk("Unable to register Ingress qdisc\n");
	346	return ret;
	347	}
	348
	349	return ret;
	350	}
58f4df42	351
10297b99	352	static void __exit ingress_module_exit(void)
1da177e4 LT	353	{
	354	unregister_qdisc(&ingress_qdisc_ops);
	355	#ifndef CONFIG_NET_CLS_ACT
	356	#ifdef CONFIG_NETFILTER
41c5b317 PM	357	if (nf_registered)
41c5b317 PM	358	nf_unregister_hooks(ing_ops, ARRAY_SIZE(ing_ops));
1da177e4 LT	359	#endif
	360	#endif
	361	}
58f4df42	362
1da177e4 LT	363	module_init(ingress_module_init)
	364	module_exit(ingress_module_exit)
	365	MODULE_LICENSE("GPL");