50adc913653099ea49c2753aeae0438c4a380bdd
[linux-3.10.git] / include / net / dst.h
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/config.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         int                     obsolete;
46         int                     flags;
47 #define DST_HOST                1
48 #define DST_NOXFRM              2
49 #define DST_NOPOLICY            4
50 #define DST_NOHASH              8
51 #define DST_BALANCED            0x10
52         unsigned long           lastuse;
53         unsigned long           expires;
54
55         unsigned short          header_len;     /* more space at head required */
56         unsigned short          trailer_len;    /* space to reserve at tail */
57
58         u32                     metrics[RTAX_MAX];
59         struct dst_entry        *path;
60
61         unsigned long           rate_last;      /* rate limiting for ICMP */
62         unsigned long           rate_tokens;
63
64         int                     error;
65
66         struct neighbour        *neighbour;
67         struct hh_cache         *hh;
68         struct xfrm_state       *xfrm;
69
70         int                     (*input)(struct sk_buff*);
71         int                     (*output)(struct sk_buff*);
72
73 #ifdef CONFIG_NET_CLS_ROUTE
74         __u32                   tclassid;
75 #endif
76
77         struct  dst_ops         *ops;
78         struct rcu_head         rcu_head;
79                 
80         char                    info[0];
81 };
82
83
84 struct dst_ops
85 {
86         unsigned short          family;
87         unsigned short          protocol;
88         unsigned                gc_thresh;
89
90         int                     (*gc)(void);
91         struct dst_entry *      (*check)(struct dst_entry *, __u32 cookie);
92         void                    (*destroy)(struct dst_entry *);
93         void                    (*ifdown)(struct dst_entry *,
94                                           struct net_device *dev, int how);
95         struct dst_entry *      (*negative_advice)(struct dst_entry *);
96         void                    (*link_failure)(struct sk_buff *);
97         void                    (*update_pmtu)(struct dst_entry *dst, u32 mtu);
98         int                     (*get_mss)(struct dst_entry *dst, u32 mtu);
99         int                     entry_size;
100
101         atomic_t                entries;
102         kmem_cache_t            *kmem_cachep;
103 };
104
105 #ifdef __KERNEL__
106
107 static inline u32
108 dst_metric(const struct dst_entry *dst, int metric)
109 {
110         return dst->metrics[metric-1];
111 }
112
113 static inline u32 dst_mtu(const struct dst_entry *dst)
114 {
115         u32 mtu = dst_metric(dst, RTAX_MTU);
116         /*
117          * Alexey put it here, so ask him about it :)
118          */
119         barrier();
120         return mtu;
121 }
122
123 static inline u32
124 dst_allfrag(const struct dst_entry *dst)
125 {
126         int ret = dst_metric(dst, RTAX_FEATURES) & RTAX_FEATURE_ALLFRAG;
127         /* Yes, _exactly_. This is paranoia. */
128         barrier();
129         return ret;
130 }
131
132 static inline int
133 dst_metric_locked(struct dst_entry *dst, int metric)
134 {
135         return dst_metric(dst, RTAX_LOCK) & (1<<metric);
136 }
137
138 static inline void dst_hold(struct dst_entry * dst)
139 {
140         atomic_inc(&dst->__refcnt);
141 }
142
143 static inline
144 struct dst_entry * dst_clone(struct dst_entry * dst)
145 {
146         if (dst)
147                 atomic_inc(&dst->__refcnt);
148         return dst;
149 }
150
151 static inline
152 void dst_release(struct dst_entry * dst)
153 {
154         if (dst) {
155                 WARN_ON(atomic_read(&dst->__refcnt) < 1);
156                 smp_mb__before_atomic_dec();
157                 atomic_dec(&dst->__refcnt);
158         }
159 }
160
161 /* Children define the path of the packet through the
162  * Linux networking.  Thus, destinations are stackable.
163  */
164
165 static inline struct dst_entry *dst_pop(struct dst_entry *dst)
166 {
167         struct dst_entry *child = dst_clone(dst->child);
168
169         dst_release(dst);
170         return child;
171 }
172
173 extern void * dst_alloc(struct dst_ops * ops);
174 extern void __dst_free(struct dst_entry * dst);
175 extern struct dst_entry *dst_destroy(struct dst_entry * dst);
176
177 static inline void dst_free(struct dst_entry * dst)
178 {
179         if (dst->obsolete > 1)
180                 return;
181         if (!atomic_read(&dst->__refcnt)) {
182                 dst = dst_destroy(dst);
183                 if (!dst)
184                         return;
185         }
186         __dst_free(dst);
187 }
188
189 static inline void dst_rcu_free(struct rcu_head *head)
190 {
191         struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head);
192         dst_free(dst);
193 }
194
195 static inline void dst_confirm(struct dst_entry *dst)
196 {
197         if (dst)
198                 neigh_confirm(dst->neighbour);
199 }
200
201 static inline void dst_negative_advice(struct dst_entry **dst_p)
202 {
203         struct dst_entry * dst = *dst_p;
204         if (dst && dst->ops->negative_advice)
205                 *dst_p = dst->ops->negative_advice(dst);
206 }
207
208 static inline void dst_link_failure(struct sk_buff *skb)
209 {
210         struct dst_entry * dst = skb->dst;
211         if (dst && dst->ops && dst->ops->link_failure)
212                 dst->ops->link_failure(skb);
213 }
214
215 static inline void dst_set_expires(struct dst_entry *dst, int timeout)
216 {
217         unsigned long expires = jiffies + timeout;
218
219         if (expires == 0)
220                 expires = 1;
221
222         if (dst->expires == 0 || time_before(expires, dst->expires))
223                 dst->expires = expires;
224 }
225
226 /* Output packet to network from transport.  */
227 static inline int dst_output(struct sk_buff *skb)
228 {
229         int err;
230
231         for (;;) {
232                 err = skb->dst->output(skb);
233
234                 if (likely(err == 0))
235                         return err;
236                 if (unlikely(err != NET_XMIT_BYPASS))
237                         return err;
238         }
239 }
240
241 /* Input packet from network to transport.  */
242 static inline int dst_input(struct sk_buff *skb)
243 {
244         int err;
245
246         for (;;) {
247                 err = skb->dst->input(skb);
248
249                 if (likely(err == 0))
250                         return err;
251                 /* Oh, Jamal... Seems, I will not forgive you this mess. :-) */
252                 if (unlikely(err != NET_XMIT_BYPASS))
253                         return err;
254         }
255 }
256
257 static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)
258 {
259         if (dst->obsolete)
260                 dst = dst->ops->check(dst, cookie);
261         return dst;
262 }
263
264 extern void             dst_init(void);
265
266 struct flowi;
267 #ifndef CONFIG_XFRM
268 static inline int xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
269                        struct sock *sk, int flags)
270 {
271         return 0;
272
273 #else
274 extern int xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl,
275                        struct sock *sk, int flags);
276 #endif
277 #endif
278
279 #endif /* _NET_DST_H */