| #ifndef __NET_PKT_ACT_H | |
| #define __NET_PKT_ACT_H | |
| #include <asm/uaccess.h> | |
| #include <asm/system.h> | |
| #include <linux/bitops.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 |