[net-next-2.6.git] / include / net / pkt_act.h

#ifndef __NET_PKT_ACT_H
#define __NET_PKT_ACT_H

#include <asm/uaccess.h>
#include <asm/system.h>
#include <linux/bitops.h>
#include <linux/config.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/in.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <net/sock.h>
#include <net/pkt_sched.h>

#define tca_st(val) (struct tcf_##val *)
#define PRIV(a,name) ( tca_st(name) (a)->priv)

#if 0 /* 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

static __inline__ unsigned
tcf_hash(u32 index)
{
	return index & MY_TAB_MASK;
}

/* probably move this from being inline
 * and put into act_generic
*/
static inline void
tcf_hash_destroy(struct tcf_st *p)
{
	unsigned h = tcf_hash(p->index);
	struct tcf_st **p1p;

	for (p1p = &tcf_ht[h]; *p1p; p1p = &(*p1p)->next) {
		if (*p1p == p) {
			write_lock_bh(&tcf_t_lock);
			*p1p = p->next;
			write_unlock_bh(&tcf_t_lock);
#ifdef CONFIG_NET_ESTIMATOR
			gen_kill_estimator(&p->bstats, &p->rate_est);
#endif
			kfree(p);
			return;
		}
	}
	BUG_TRAP(0);
}

static inline int
tcf_hash_release(struct tcf_st *p, int bind )
{
	int ret = 0;
	if (p) {
		if (bind) {
			p->bindcnt--;
		}
		p->refcnt--;
	       	if(p->bindcnt <=0 && p->refcnt <= 0) {
			tcf_hash_destroy(p);
			ret = 1;
		}
	}
	return ret;
}

static __inline__ int
tcf_dump_walker(struct sk_buff *skb, struct netlink_callback *cb,
		struct tc_action *a)
{
	struct tcf_st *p;
	int err =0, index =  -1,i= 0, s_i = 0, n_i = 0;
	struct rtattr *r ;

	read_lock(&tcf_t_lock);

	s_i = cb->args[0];

	for (i = 0; i < MY_TAB_SIZE; i++) {
		p = tcf_ht[tcf_hash(i)];

		for (; p; p = p->next) {
			index++;
			if (index < s_i)
				continue;
			a->priv = p;
			a->order = n_i;
			r = (struct rtattr*) skb->tail;
			RTA_PUT(skb, a->order, 0, NULL);
			err = tcf_action_dump_1(skb, a, 0, 0);
			if (0 > err) {
				index--;
				skb_trim(skb, (u8*)r - skb->data);
				goto done;
			}
			r->rta_len = skb->tail - (u8*)r;
			n_i++;
			if (n_i >= TCA_ACT_MAX_PRIO) {
				goto done;
			}
		}
	}
done:
	read_unlock(&tcf_t_lock);
	if (n_i)
		cb->args[0] += n_i;
	return n_i;

rtattr_failure:
	skb_trim(skb, (u8*)r - skb->data);
	goto done;
}

static __inline__ int
tcf_del_walker(struct sk_buff *skb, struct tc_action *a)
{
	struct tcf_st *p, *s_p;
	struct rtattr *r ;
	int i= 0, n_i = 0;

	r = (struct rtattr*) skb->tail;
	RTA_PUT(skb, a->order, 0, NULL);
	RTA_PUT(skb, TCA_KIND, IFNAMSIZ, a->ops->kind);
	for (i = 0; i < MY_TAB_SIZE; i++) {
		p = tcf_ht[tcf_hash(i)];

		while (p != NULL) {
			s_p = p->next;
			if (ACT_P_DELETED == tcf_hash_release(p, 0)) {
				 module_put(a->ops->owner);
			}
			n_i++;
			p = s_p;
		}
	}
	RTA_PUT(skb, TCA_FCNT, 4, &n_i);
	r->rta_len = skb->tail - (u8*)r;

	return n_i;
rtattr_failure:
	skb_trim(skb, (u8*)r - skb->data);
	return -EINVAL;
}

static __inline__ int
tcf_generic_walker(struct sk_buff *skb, struct netlink_callback *cb, int type,
		struct tc_action *a)
{
		if (type == RTM_DELACTION) {
			return tcf_del_walker(skb,a);
		} else if (type == RTM_GETACTION) {
			return tcf_dump_walker(skb,cb,a);
		} else {
			printk("tcf_generic_walker: unknown action %d\n",type);
			return -EINVAL;
		}
}

static __inline__ struct tcf_st *
tcf_hash_lookup(u32 index)
{
	struct tcf_st *p;

	read_lock(&tcf_t_lock);
	for (p = tcf_ht[tcf_hash(index)]; p; p = p->next) {
		if (p->index == index)
			break;
	}
	read_unlock(&tcf_t_lock);
	return p;
}

static __inline__ u32
tcf_hash_new_index(void)
{
	do {
		if (++idx_gen == 0)
			idx_gen = 1;
	} while (tcf_hash_lookup(idx_gen));

	return idx_gen;
}


static inline int
tcf_hash_search(struct tc_action *a, u32 index)
{
	struct tcf_st *p = tcf_hash_lookup(index);

	if (p != NULL) {
		a->priv = p;
		return 1;
	}
	return 0;
}

#ifdef CONFIG_NET_ACT_INIT
static inline struct tcf_st *
tcf_hash_check(u32 index, struct tc_action *a, int ovr, int bind)
{
	struct tcf_st *p = NULL;
	if (index && (p = tcf_hash_lookup(index)) != NULL) {
		if (bind) {
			p->bindcnt++;
			p->refcnt++;
		}
		a->priv = p;
	}
	return p;
}

static inline struct tcf_st *
tcf_hash_create(u32 index, struct rtattr *est, struct tc_action *a, int size, int ovr, int bind)
{
	struct tcf_st *p = NULL;

	p = kmalloc(size, GFP_KERNEL);
	if (p == NULL)
		return p;

	memset(p, 0, size);
	p->refcnt = 1;

	if (bind) {
		p->bindcnt = 1;
	}

	spin_lock_init(&p->lock);
	p->stats_lock = &p->lock;
	p->index = index ? : tcf_hash_new_index();
	p->tm.install = jiffies;
	p->tm.lastuse = jiffies;
#ifdef CONFIG_NET_ESTIMATOR
	if (est)
		gen_new_estimator(&p->bstats, &p->rate_est, p->stats_lock, est);
#endif
	a->priv = (void *) p;
	return p;
}

static inline void tcf_hash_insert(struct tcf_st *p)
{
	unsigned h = tcf_hash(p->index);

	write_lock_bh(&tcf_t_lock);
	p->next = tcf_ht[h];
	tcf_ht[h] = p;
	write_unlock_bh(&tcf_t_lock);
}

#endif

#endif
Commit	Line	Data
1da177e4 LT	1	#ifndef __NET_PKT_ACT_H
	2	#define __NET_PKT_ACT_H
	3
	4	#include <asm/uaccess.h>
	5	#include <asm/system.h>
	6	#include <linux/bitops.h>
	7	#include <linux/config.h>
	8	#include <linux/types.h>
	9	#include <linux/kernel.h>
	10	#include <linux/sched.h>
	11	#include <linux/string.h>
	12	#include <linux/mm.h>
	13	#include <linux/socket.h>
	14	#include <linux/sockios.h>
	15	#include <linux/in.h>
	16	#include <linux/errno.h>
	17	#include <linux/interrupt.h>
1da177e4 LT	18	#include <linux/skbuff.h>
	19	#include <linux/rtnetlink.h>
	20	#include <linux/module.h>
	21	#include <linux/init.h>
	22	#include <linux/proc_fs.h>
	23	#include <net/sock.h>
	24	#include <net/pkt_sched.h>
	25
	26	#define tca_st(val) (struct tcf_##val *)
	27	#define PRIV(a,name) ( tca_st(name) (a)->priv)
	28
	29	#if 0 /* control */
	30	#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
	31	#else
	32	#define DPRINTK(format,args...)
	33	#endif
	34
	35	#if 0 /* data */
	36	#define D2PRINTK(format,args...) printk(KERN_DEBUG format,##args)
	37	#else
	38	#define D2PRINTK(format,args...)
	39	#endif
	40
	41	static __inline__ unsigned
	42	tcf_hash(u32 index)
	43	{
	44	return index & MY_TAB_MASK;
	45	}
	46
	47	/* probably move this from being inline
	48	* and put into act_generic
	49	*/
	50	static inline void
	51	tcf_hash_destroy(struct tcf_st *p)
	52	{
	53	unsigned h = tcf_hash(p->index);
	54	struct tcf_st **p1p;
	55
	56	for (p1p = &tcf_ht[h]; p1p; p1p = &(p1p)->next) {
	57	if (*p1p == p) {
	58	write_lock_bh(&tcf_t_lock);
	59	*p1p = p->next;
	60	write_unlock_bh(&tcf_t_lock);
	61	#ifdef CONFIG_NET_ESTIMATOR
	62	gen_kill_estimator(&p->bstats, &p->rate_est);
	63	#endif
	64	kfree(p);
	65	return;
	66	}
	67	}
	68	BUG_TRAP(0);
	69	}
	70
	71	static inline int
	72	tcf_hash_release(struct tcf_st *p, int bind )
	73	{
	74	int ret = 0;
	75	if (p) {
	76	if (bind) {
	77	p->bindcnt--;
	78	}
	79	p->refcnt--;
	80	if(p->bindcnt <=0 && p->refcnt <= 0) {
	81	tcf_hash_destroy(p);
82	ret = 1;
83	}
84	}
85	return ret;
86	}
87
88	static __inline__ int
89	tcf_dump_walker(struct sk_buff skb, struct netlink_callback cb,
90	struct tc_action *a)
91	{
92	struct tcf_st *p;
93	int err =0, index = -1,i= 0, s_i = 0, n_i = 0;
94	struct rtattr *r ;
95
96	read_lock(&tcf_t_lock);
97
98	s_i = cb->args[0];
99
100	for (i = 0; i < MY_TAB_SIZE; i++) {
101	p = tcf_ht[tcf_hash(i)];
102
103	for (; p; p = p->next) {
104	index++;
105	if (index < s_i)
106	continue;
107	a->priv = p;
108	a->order = n_i;
109	r = (struct rtattr*) skb->tail;
110	RTA_PUT(skb, a->order, 0, NULL);
111	err = tcf_action_dump_1(skb, a, 0, 0);
112	if (0 > err) {
113	index--;
114	skb_trim(skb, (u8*)r - skb->data);
115	goto done;
116	}
117	r->rta_len = skb->tail - (u8*)r;
118	n_i++;
119	if (n_i >= TCA_ACT_MAX_PRIO) {
120	goto done;
121	}
122	}
123	}
124	done:
125	read_unlock(&tcf_t_lock);
126	if (n_i)
127	cb->args[0] += n_i;
128	return n_i;
129
130	rtattr_failure:
131	skb_trim(skb, (u8*)r - skb->data);
132	goto done;
133	}
134
135	static __inline__ int
136	tcf_del_walker(struct sk_buff skb, struct tc_action a)
137	{
138	struct tcf_st p, s_p;
139	struct rtattr *r ;
140	int i= 0, n_i = 0;
141
142	r = (struct rtattr*) skb->tail;
143	RTA_PUT(skb, a->order, 0, NULL);
144	RTA_PUT(skb, TCA_KIND, IFNAMSIZ, a->ops->kind);
145	for (i = 0; i < MY_TAB_SIZE; i++) {
146	p = tcf_ht[tcf_hash(i)];
147
148	while (p != NULL) {
149	s_p = p->next;
150	if (ACT_P_DELETED == tcf_hash_release(p, 0)) {
151	module_put(a->ops->owner);
152	}
153	n_i++;
154	p = s_p;
155	}
156	}
157	RTA_PUT(skb, TCA_FCNT, 4, &n_i);
158	r->rta_len = skb->tail - (u8*)r;
159
160	return n_i;
161	rtattr_failure:
162	skb_trim(skb, (u8*)r - skb->data);
163	return -EINVAL;
164	}
165
166	static __inline__ int
167	tcf_generic_walker(struct sk_buff skb, struct netlink_callback cb, int type,
168	struct tc_action *a)
169	{
170	if (type == RTM_DELACTION) {
171	return tcf_del_walker(skb,a);
172	} else if (type == RTM_GETACTION) {
173	return tcf_dump_walker(skb,cb,a);
174	} else {
175	printk("tcf_generic_walker: unknown action %d\n",type);
176	return -EINVAL;
177	}
178	}
179
180	static __inline__ struct tcf_st *
181	tcf_hash_lookup(u32 index)
182	{
183	struct tcf_st *p;
184
185	read_lock(&tcf_t_lock);
186	for (p = tcf_ht[tcf_hash(index)]; p; p = p->next) {
187	if (p->index == index)
188	break;
189	}
190	read_unlock(&tcf_t_lock);
191	return p;
192	}
193
194	static __inline__ u32
195	tcf_hash_new_index(void)
196	{
197	do {
198	if (++idx_gen == 0)
199	idx_gen = 1;
200	} while (tcf_hash_lookup(idx_gen));
201
202	return idx_gen;
203	}
204
205
206	static inline int
207	tcf_hash_search(struct tc_action *a, u32 index)
208	{
209	struct tcf_st *p = tcf_hash_lookup(index);
210
211	if (p != NULL) {
212	a->priv = p;
213	return 1;
214	}
215	return 0;
216	}
217
218	#ifdef CONFIG_NET_ACT_INIT
219	static inline struct tcf_st *
220	tcf_hash_check(u32 index, struct tc_action *a, int ovr, int bind)
221	{
222	struct tcf_st *p = NULL;
223	if (index && (p = tcf_hash_lookup(index)) != NULL) {
224	if (bind) {
225	p->bindcnt++;
226	p->refcnt++;
227	}
228	a->priv = p;
229	}
230	return p;
231	}
232
233	static inline struct tcf_st *
234	tcf_hash_create(u32 index, struct rtattr est, struct tc_action a, int size, int ovr, int bind)
235	{
236	struct tcf_st *p = NULL;
237
238	p = kmalloc(size, GFP_KERNEL);
239	if (p == NULL)
240	return p;
241
242	memset(p, 0, size);
243	p->refcnt = 1;
244
245	if (bind) {
246	p->bindcnt = 1;
247	}
248
249	spin_lock_init(&p->lock);
250	p->stats_lock = &p->lock;
251	p->index = index ? : tcf_hash_new_index();
252	p->tm.install = jiffies;
253	p->tm.lastuse = jiffies;
254	#ifdef CONFIG_NET_ESTIMATOR
255	if (est)
256	gen_new_estimator(&p->bstats, &p->rate_est, p->stats_lock, est);
257	#endif
258	a->priv = (void *) p;
259	return p;
260	}
261
262	static inline void tcf_hash_insert(struct tcf_st *p)
263	{
264	unsigned h = tcf_hash(p->index);
265
266	write_lock_bh(&tcf_t_lock);
267	p->next = tcf_ht[h];
268	tcf_ht[h] = p;
269	write_unlock_bh(&tcf_t_lock);
270	}
271
272	#endif
273
274	#endif