home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / net / pkt_act.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  5.1 KB  |  274 lines

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