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 / dst.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  5.7 KB  |  269 lines
  1. /*
  2.  * net/dst.h    Protocol independent destination cache definitions.
  3.  *
  4.  * Authors:    Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  5.  *
  6.  */
  7.  
  8. #ifndef _NET_DST_H
  9. #define _NET_DST_H
  10.  
  11. #include <linux/netdevice.h>
  12. #include <linux/rtnetlink.h>
  13. #include <linux/rcupdate.h>
  14. #include <linux/jiffies.h>
  15. #include <net/neighbour.h>
  16. #include <asm/processor.h>
  17.  
  18. /*
  19.  * 0 - no debugging messages
  20.  * 1 - rare events and bugs (default)
  21.  * 2 - trace mode.
  22.  */
  23. #define RT_CACHE_DEBUG        0
  24.  
  25. #define DST_GC_MIN    (HZ/10)
  26. #define DST_GC_INC    (HZ/2)
  27. #define DST_GC_MAX    (120*HZ)
  28.  
  29. /* Each dst_entry has reference count and sits in some parent list(s).
  30.  * When it is removed from parent list, it is "freed" (dst_free).
  31.  * After this it enters dead state (dst->obsolete > 0) and if its refcnt
  32.  * is zero, it can be destroyed immediately, otherwise it is added
  33.  * to gc list and garbage collector periodically checks the refcnt.
  34.  */
  35.  
  36. struct sk_buff;
  37.  
  38. struct dst_entry
  39. {
  40.     struct dst_entry        *next;
  41.     atomic_t        __refcnt;    /* client references    */
  42.     int            __use;
  43.     struct dst_entry    *child;
  44.     struct net_device       *dev;
  45.     short            error;
  46.     short            obsolete;
  47.     int            flags;
  48. #define DST_HOST        1
  49. #define DST_NOXFRM        2
  50. #define DST_NOPOLICY        4
  51. #define DST_NOHASH        8
  52. #define DST_BALANCED            0x10
  53.     unsigned long        lastuse;
  54.     unsigned long        expires;
  55.  
  56.     unsigned short        header_len;    /* more space at head required */
  57.     unsigned short        trailer_len;    /* space to reserve at tail */
  58.  
  59.     u32            metrics[RTAX_MAX];
  60.     struct dst_entry    *path;
  61.  
  62.     unsigned long        rate_last;    /* rate limiting for ICMP */
  63.     unsigned long        rate_tokens;
  64.  
  65.     struct neighbour    *neighbour;
  66.     struct hh_cache        *hh;
  67.     struct xfrm_state    *xfrm;
  68.  
  69.     int            (*input)(struct sk_buff*);
  70.     int            (*output)(struct sk_buff*);
  71.  
  72. #ifdef CONFIG_NET_CLS_ROUTE
  73.     __u32            tclassid;
  74. #endif
  75.  
  76.     struct  dst_ops            *ops;
  77.     struct rcu_head        rcu_head;
  78.         
  79.     char            info[0];
  80. };
  81.  
  82.  
  83. struct dst_ops
  84. {
  85.     unsigned short        family;
  86.     unsigned short        protocol;
  87.     unsigned        gc_thresh;
  88.  
  89.     int            (*gc)(void);
  90.     struct dst_entry *    (*check)(struct dst_entry *, __u32 cookie);
  91.     void            (*destroy)(struct dst_entry *);
  92.     void            (*ifdown)(struct dst_entry *,
  93.                       struct net_device *dev, int how);
  94.     struct dst_entry *    (*negative_advice)(struct dst_entry *);
  95.     void            (*link_failure)(struct sk_buff *);
  96.     void            (*update_pmtu)(struct dst_entry *dst, u32 mtu);
  97.     int            entry_size;
  98.  
  99.     atomic_t        entries;
  100.     kmem_cache_t         *kmem_cachep;
  101. };
  102.  
  103. #ifdef __KERNEL__
  104.  
  105. static inline u32
  106. dst_metric(const struct dst_entry *dst, int metric)
  107. {
  108.     return dst->metrics[metric-1];
  109. }
  110.  
  111. static inline u32 dst_mtu(const struct dst_entry *dst)
  112. {
  113.     u32 mtu = dst_metric(dst, RTAX_MTU);
  114.     /*
  115.      * Alexey put it here, so ask him about it :)
  116.      */
  117.     barrier();
  118.     return mtu;
  119. }
  120.  
  121. static inline u32
  122. dst_allfrag(const struct dst_entry *dst)
  123. {
  124.     int ret = dst_metric(dst, RTAX_FEATURES) & RTAX_FEATURE_ALLFRAG;
  125.     /* Yes, _exactly_. This is paranoia. */
  126.     barrier();
  127.     return ret;
  128. }
  129.  
  130. static inline int
  131. dst_metric_locked(struct dst_entry *dst, int metric)
  132. {
  133.     return dst_metric(dst, RTAX_LOCK) & (1<<metric);
  134. }
  135.  
  136. static inline void dst_hold(struct dst_entry * dst)
  137. {
  138.     atomic_inc(&dst->__refcnt);
  139. }
  140.  
  141. static inline
  142. struct dst_entry * dst_clone(struct dst_entry * dst)
  143. {
  144.     if (dst)
  145.         atomic_inc(&dst->__refcnt);
  146.     return dst;
  147. }
  148.  
  149. static inline
  150. void dst_release(struct dst_entry * dst)
  151. {
  152.     if (dst) {
  153.         WARN_ON(atomic_read(&dst->__refcnt) < 1);
  154.         smp_mb__before_atomic_dec();
  155.         atomic_dec(&dst->__refcnt);
  156.     }
  157. }
  158.  
  159. /* Children define the path of the packet through the
  160.  * Linux networking.  Thus, destinations are stackable.
  161.  */
  162.  
  163. static inline struct dst_entry *dst_pop(struct dst_entry *dst)
  164. {
  165.     struct dst_entry *child = dst_clone(dst->child);
  166.  
  167.     dst_release(dst);
  168.     return child;
  169. }
  170.  
  171. extern void * dst_alloc(struct dst_ops * ops);
  172. extern void __dst_free(struct dst_entry * dst);
  173. extern struct dst_entry *dst_destroy(struct dst_entry * dst);
  174.  
  175. static inline void dst_free(struct dst_entry * dst)
  176. {
  177.     if (dst->obsolete > 1)
  178.         return;
  179.     if (!atomic_read(&dst->__refcnt)) {
  180.         dst = dst_destroy(dst);
  181.         if (!dst)
  182.             return;
  183.     }
  184.     __dst_free(dst);
  185. }
  186.  
  187. static inline void dst_rcu_free(struct rcu_head *head)
  188. {
  189.     struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head);
  190.     dst_free(dst);
  191. }
  192.  
  193. static inline void dst_confirm(struct dst_entry *dst)
  194. {
  195.     if (dst)
  196.         neigh_confirm(dst->neighbour);
  197. }
  198.  
  199. static inline void dst_negative_advice(struct dst_entry **dst_p)
  200. {
  201.     struct dst_entry * dst = *dst_p;
  202.     if (dst && dst->ops->negative_advice)
  203.         *dst_p = dst->ops->negative_advice(dst);
  204. }
  205.  
  206. static inline void dst_link_failure(struct sk_buff *skb)
  207. {
  208.     struct dst_entry * dst = skb->dst;
  209.     if (dst && dst->ops && dst->ops->link_failure)
  210.         dst->ops->link_failure(skb);
  211. }
  212.  
  213. static inline void dst_set_expires(struct dst_entry *dst, int timeout)
  214. {
  215.     unsigned long expires = jiffies + timeout;
  216.  
  217.     if (expires == 0)
  218.         expires = 1;
  219.  
  220.     if (dst->expires == 0 || time_before(expires, dst->expires))
  221.         dst->expires = expires;
  222. }
  223.  
  224. /* Output packet to network from transport.  */
  225. static inline int dst_output(struct sk_buff *skb)
  226. {
  227.     return skb->dst->output(skb);
  228. }
  229.  
  230. /* Input packet from network to transport.  */
  231. static inline int dst_input(struct sk_buff *skb)
  232. {
  233.     int err;
  234.  
  235.     for (;;) {
  236.         err = skb->dst->input(skb);
  237.  
  238.         if (likely(err == 0))
  239.             return err;
  240.         /* Oh, Jamal... Seems, I will not forgive you this mess. :-) */
  241.         if (unlikely(err != NET_XMIT_BYPASS))
  242.             return err;
  243.     }
  244. }
  245.  
  246. static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)
  247. {
  248.     if (dst->obsolete)
  249.         dst = dst->ops->check(dst, cookie);
  250.     return dst;
  251. }
  252.  
  253. extern void        dst_init(void);
  254.  
  255. struct flowi;
  256. #ifndef CONFIG_XFRM
  257. static inline int xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
  258.                struct sock *sk, int flags)
  259. {
  260.     return 0;
  261. } 
  262. #else
  263. extern int xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
  264.                struct sock *sk, int flags);
  265. #endif
  266. #endif
  267.  
  268. #endif /* _NET_DST_H */
  269.