rps: Add flag to skb to indicate rxhash is based on L4 tuple
[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 <net/dst_ops.h>
12 #include <linux/netdevice.h>
13 #include <linux/rtnetlink.h>
14 #include <linux/rcupdate.h>
15 #include <linux/jiffies.h>
16 #include <net/neighbour.h>
17 #include <asm/processor.h>
18
19 #define DST_GC_MIN      (HZ/10)
20 #define DST_GC_INC      (HZ/2)
21 #define DST_GC_MAX      (120*HZ)
22
23 /* Each dst_entry has reference count and sits in some parent list(s).
24  * When it is removed from parent list, it is "freed" (dst_free).
25  * After this it enters dead state (dst->obsolete > 0) and if its refcnt
26  * is zero, it can be destroyed immediately, otherwise it is added
27  * to gc list and garbage collector periodically checks the refcnt.
28  */
29
30 struct sk_buff;
31
32 struct dst_entry {
33         struct rcu_head         rcu_head;
34         struct dst_entry        *child;
35         struct net_device       *dev;
36         struct  dst_ops         *ops;
37         unsigned long           _metrics;
38         unsigned long           expires;
39         struct dst_entry        *path;
40         struct neighbour __rcu  *_neighbour;
41 #ifdef CONFIG_XFRM
42         struct xfrm_state       *xfrm;
43 #else
44         void                    *__pad1;
45 #endif
46         int                     (*input)(struct sk_buff*);
47         int                     (*output)(struct sk_buff*);
48
49         int                     flags;
50 #define DST_HOST                0x0001
51 #define DST_NOXFRM              0x0002
52 #define DST_NOPOLICY            0x0004
53 #define DST_NOHASH              0x0008
54 #define DST_NOCACHE             0x0010
55 #define DST_NOCOUNT             0x0020
56
57         short                   error;
58         short                   obsolete;
59         unsigned short          header_len;     /* more space at head required */
60         unsigned short          trailer_len;    /* space to reserve at tail */
61 #ifdef CONFIG_IP_ROUTE_CLASSID
62         __u32                   tclassid;
63 #else
64         __u32                   __pad2;
65 #endif
66
67         /*
68          * Align __refcnt to a 64 bytes alignment
69          * (L1_CACHE_SIZE would be too much)
70          */
71 #ifdef CONFIG_64BIT
72         long                    __pad_to_align_refcnt[2];
73 #endif
74         /*
75          * __refcnt wants to be on a different cache line from
76          * input/output/ops or performance tanks badly
77          */
78         atomic_t                __refcnt;       /* client references    */
79         int                     __use;
80         unsigned long           lastuse;
81         union {
82                 struct dst_entry        *next;
83                 struct rtable __rcu     *rt_next;
84                 struct rt6_info         *rt6_next;
85                 struct dn_route __rcu   *dn_next;
86         };
87 };
88
89 static inline struct neighbour *dst_get_neighbour(struct dst_entry *dst)
90 {
91         return rcu_dereference(dst->_neighbour);
92 }
93
94 static inline struct neighbour *dst_get_neighbour_raw(struct dst_entry *dst)
95 {
96         return rcu_dereference_raw(dst->_neighbour);
97 }
98
99 static inline void dst_set_neighbour(struct dst_entry *dst, struct neighbour *neigh)
100 {
101         rcu_assign_pointer(dst->_neighbour, neigh);
102 }
103
104 extern u32 *dst_cow_metrics_generic(struct dst_entry *dst, unsigned long old);
105 extern const u32 dst_default_metrics[RTAX_MAX];
106
107 #define DST_METRICS_READ_ONLY   0x1UL
108 #define __DST_METRICS_PTR(Y)    \
109         ((u32 *)((Y) & ~DST_METRICS_READ_ONLY))
110 #define DST_METRICS_PTR(X)      __DST_METRICS_PTR((X)->_metrics)
111
112 static inline bool dst_metrics_read_only(const struct dst_entry *dst)
113 {
114         return dst->_metrics & DST_METRICS_READ_ONLY;
115 }
116
117 extern void __dst_destroy_metrics_generic(struct dst_entry *dst, unsigned long old);
118
119 static inline void dst_destroy_metrics_generic(struct dst_entry *dst)
120 {
121         unsigned long val = dst->_metrics;
122         if (!(val & DST_METRICS_READ_ONLY))
123                 __dst_destroy_metrics_generic(dst, val);
124 }
125
126 static inline u32 *dst_metrics_write_ptr(struct dst_entry *dst)
127 {
128         unsigned long p = dst->_metrics;
129
130         BUG_ON(!p);
131
132         if (p & DST_METRICS_READ_ONLY)
133                 return dst->ops->cow_metrics(dst, p);
134         return __DST_METRICS_PTR(p);
135 }
136
137 /* This may only be invoked before the entry has reached global
138  * visibility.
139  */
140 static inline void dst_init_metrics(struct dst_entry *dst,
141                                     const u32 *src_metrics,
142                                     bool read_only)
143 {
144         dst->_metrics = ((unsigned long) src_metrics) |
145                 (read_only ? DST_METRICS_READ_ONLY : 0);
146 }
147
148 static inline void dst_copy_metrics(struct dst_entry *dest, const struct dst_entry *src)
149 {
150         u32 *dst_metrics = dst_metrics_write_ptr(dest);
151
152         if (dst_metrics) {
153                 u32 *src_metrics = DST_METRICS_PTR(src);
154
155                 memcpy(dst_metrics, src_metrics, RTAX_MAX * sizeof(u32));
156         }
157 }
158
159 static inline u32 *dst_metrics_ptr(struct dst_entry *dst)
160 {
161         return DST_METRICS_PTR(dst);
162 }
163
164 static inline u32
165 dst_metric_raw(const struct dst_entry *dst, const int metric)
166 {
167         u32 *p = DST_METRICS_PTR(dst);
168
169         return p[metric-1];
170 }
171
172 static inline u32
173 dst_metric(const struct dst_entry *dst, const int metric)
174 {
175         WARN_ON_ONCE(metric == RTAX_HOPLIMIT ||
176                      metric == RTAX_ADVMSS ||
177                      metric == RTAX_MTU);
178         return dst_metric_raw(dst, metric);
179 }
180
181 static inline u32
182 dst_metric_advmss(const struct dst_entry *dst)
183 {
184         u32 advmss = dst_metric_raw(dst, RTAX_ADVMSS);
185
186         if (!advmss)
187                 advmss = dst->ops->default_advmss(dst);
188
189         return advmss;
190 }
191
192 static inline void dst_metric_set(struct dst_entry *dst, int metric, u32 val)
193 {
194         u32 *p = dst_metrics_write_ptr(dst);
195
196         if (p)
197                 p[metric-1] = val;
198 }
199
200 static inline u32
201 dst_feature(const struct dst_entry *dst, u32 feature)
202 {
203         return dst_metric(dst, RTAX_FEATURES) & feature;
204 }
205
206 static inline u32 dst_mtu(const struct dst_entry *dst)
207 {
208         u32 mtu = dst_metric_raw(dst, RTAX_MTU);
209
210         if (!mtu)
211                 mtu = dst->ops->default_mtu(dst);
212
213         return mtu;
214 }
215
216 /* RTT metrics are stored in milliseconds for user ABI, but used as jiffies */
217 static inline unsigned long dst_metric_rtt(const struct dst_entry *dst, int metric)
218 {
219         return msecs_to_jiffies(dst_metric(dst, metric));
220 }
221
222 static inline void set_dst_metric_rtt(struct dst_entry *dst, int metric,
223                                       unsigned long rtt)
224 {
225         dst_metric_set(dst, metric, jiffies_to_msecs(rtt));
226 }
227
228 static inline u32
229 dst_allfrag(const struct dst_entry *dst)
230 {
231         int ret = dst_feature(dst,  RTAX_FEATURE_ALLFRAG);
232         return ret;
233 }
234
235 static inline int
236 dst_metric_locked(const struct dst_entry *dst, int metric)
237 {
238         return dst_metric(dst, RTAX_LOCK) & (1<<metric);
239 }
240
241 static inline void dst_hold(struct dst_entry * dst)
242 {
243         /*
244          * If your kernel compilation stops here, please check
245          * __pad_to_align_refcnt declaration in struct dst_entry
246          */
247         BUILD_BUG_ON(offsetof(struct dst_entry, __refcnt) & 63);
248         atomic_inc(&dst->__refcnt);
249 }
250
251 static inline void dst_use(struct dst_entry *dst, unsigned long time)
252 {
253         dst_hold(dst);
254         dst->__use++;
255         dst->lastuse = time;
256 }
257
258 static inline void dst_use_noref(struct dst_entry *dst, unsigned long time)
259 {
260         dst->__use++;
261         dst->lastuse = time;
262 }
263
264 static inline
265 struct dst_entry * dst_clone(struct dst_entry * dst)
266 {
267         if (dst)
268                 atomic_inc(&dst->__refcnt);
269         return dst;
270 }
271
272 extern void dst_release(struct dst_entry *dst);
273
274 static inline void refdst_drop(unsigned long refdst)
275 {
276         if (!(refdst & SKB_DST_NOREF))
277                 dst_release((struct dst_entry *)(refdst & SKB_DST_PTRMASK));
278 }
279
280 /**
281  * skb_dst_drop - drops skb dst
282  * @skb: buffer
283  *
284  * Drops dst reference count if a reference was taken.
285  */
286 static inline void skb_dst_drop(struct sk_buff *skb)
287 {
288         if (skb->_skb_refdst) {
289                 refdst_drop(skb->_skb_refdst);
290                 skb->_skb_refdst = 0UL;
291         }
292 }
293
294 static inline void skb_dst_copy(struct sk_buff *nskb, const struct sk_buff *oskb)
295 {
296         nskb->_skb_refdst = oskb->_skb_refdst;
297         if (!(nskb->_skb_refdst & SKB_DST_NOREF))
298                 dst_clone(skb_dst(nskb));
299 }
300
301 /**
302  * skb_dst_force - makes sure skb dst is refcounted
303  * @skb: buffer
304  *
305  * If dst is not yet refcounted, let's do it
306  */
307 static inline void skb_dst_force(struct sk_buff *skb)
308 {
309         if (skb_dst_is_noref(skb)) {
310                 WARN_ON(!rcu_read_lock_held());
311                 skb->_skb_refdst &= ~SKB_DST_NOREF;
312                 dst_clone(skb_dst(skb));
313         }
314 }
315
316
317 /**
318  *      __skb_tunnel_rx - prepare skb for rx reinsert
319  *      @skb: buffer
320  *      @dev: tunnel device
321  *
322  *      After decapsulation, packet is going to re-enter (netif_rx()) our stack,
323  *      so make some cleanups. (no accounting done)
324  */
325 static inline void __skb_tunnel_rx(struct sk_buff *skb, struct net_device *dev)
326 {
327         skb->dev = dev;
328
329         /*
330          * Clear rxhash so that we can recalulate the hash for the
331          * encapsulated packet, unless we have already determine the hash
332          * over the L4 4-tuple.
333          */
334         if (!skb->l4_rxhash)
335                 skb->rxhash = 0;
336         skb_set_queue_mapping(skb, 0);
337         skb_dst_drop(skb);
338         nf_reset(skb);
339 }
340
341 /**
342  *      skb_tunnel_rx - prepare skb for rx reinsert
343  *      @skb: buffer
344  *      @dev: tunnel device
345  *
346  *      After decapsulation, packet is going to re-enter (netif_rx()) our stack,
347  *      so make some cleanups, and perform accounting.
348  *      Note: this accounting is not SMP safe.
349  */
350 static inline void skb_tunnel_rx(struct sk_buff *skb, struct net_device *dev)
351 {
352         /* TODO : stats should be SMP safe */
353         dev->stats.rx_packets++;
354         dev->stats.rx_bytes += skb->len;
355         __skb_tunnel_rx(skb, dev);
356 }
357
358 /* Children define the path of the packet through the
359  * Linux networking.  Thus, destinations are stackable.
360  */
361
362 static inline struct dst_entry *skb_dst_pop(struct sk_buff *skb)
363 {
364         struct dst_entry *child = dst_clone(skb_dst(skb)->child);
365
366         skb_dst_drop(skb);
367         return child;
368 }
369
370 extern int dst_discard(struct sk_buff *skb);
371 extern void *dst_alloc(struct dst_ops * ops, struct net_device *dev,
372                        int initial_ref, int initial_obsolete, int flags);
373 extern void __dst_free(struct dst_entry * dst);
374 extern struct dst_entry *dst_destroy(struct dst_entry * dst);
375
376 static inline void dst_free(struct dst_entry * dst)
377 {
378         if (dst->obsolete > 1)
379                 return;
380         if (!atomic_read(&dst->__refcnt)) {
381                 dst = dst_destroy(dst);
382                 if (!dst)
383                         return;
384         }
385         __dst_free(dst);
386 }
387
388 static inline void dst_rcu_free(struct rcu_head *head)
389 {
390         struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head);
391         dst_free(dst);
392 }
393
394 static inline void dst_confirm(struct dst_entry *dst)
395 {
396         if (dst) {
397                 struct neighbour *n;
398
399                 rcu_read_lock();
400                 n = dst_get_neighbour(dst);
401                 neigh_confirm(n);
402                 rcu_read_unlock();
403         }
404 }
405
406 static inline struct neighbour *dst_neigh_lookup(const struct dst_entry *dst, const void *daddr)
407 {
408         return dst->ops->neigh_lookup(dst, daddr);
409 }
410
411 static inline void dst_link_failure(struct sk_buff *skb)
412 {
413         struct dst_entry *dst = skb_dst(skb);
414         if (dst && dst->ops && dst->ops->link_failure)
415                 dst->ops->link_failure(skb);
416 }
417
418 static inline void dst_set_expires(struct dst_entry *dst, int timeout)
419 {
420         unsigned long expires = jiffies + timeout;
421
422         if (expires == 0)
423                 expires = 1;
424
425         if (dst->expires == 0 || time_before(expires, dst->expires))
426                 dst->expires = expires;
427 }
428
429 /* Output packet to network from transport.  */
430 static inline int dst_output(struct sk_buff *skb)
431 {
432         return skb_dst(skb)->output(skb);
433 }
434
435 /* Input packet from network to transport.  */
436 static inline int dst_input(struct sk_buff *skb)
437 {
438         return skb_dst(skb)->input(skb);
439 }
440
441 static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)
442 {
443         if (dst->obsolete)
444                 dst = dst->ops->check(dst, cookie);
445         return dst;
446 }
447
448 extern void             dst_init(void);
449
450 /* Flags for xfrm_lookup flags argument. */
451 enum {
452         XFRM_LOOKUP_ICMP = 1 << 0,
453 };
454
455 struct flowi;
456 #ifndef CONFIG_XFRM
457 static inline struct dst_entry *xfrm_lookup(struct net *net,
458                                             struct dst_entry *dst_orig,
459                                             const struct flowi *fl, struct sock *sk,
460                                             int flags)
461 {
462         return dst_orig;
463
464 #else
465 extern struct dst_entry *xfrm_lookup(struct net *net, struct dst_entry *dst_orig,
466                                      const struct flowi *fl, struct sock *sk,
467                                      int flags);
468 #endif
469
470 #endif /* _NET_DST_H */