blob: 9a7881066fb316b02fdd7ed52aaf84d038ded1f6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Alexey Dobriyan86393e52009-08-29 01:34:49 +000011#include <net/dst_ops.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020012#include <linux/netdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/rtnetlink.h>
14#include <linux/rcupdate.h>
Paul Gortmaker187f1882011-11-23 20:12:59 -050015#include <linux/bug.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/jiffies.h>
17#include <net/neighbour.h>
18#include <asm/processor.h>
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#define DST_GC_MIN (HZ/10)
21#define DST_GC_INC (HZ/2)
22#define DST_GC_MAX (120*HZ)
23
24/* Each dst_entry has reference count and sits in some parent list(s).
25 * When it is removed from parent list, it is "freed" (dst_free).
26 * After this it enters dead state (dst->obsolete > 0) and if its refcnt
27 * is zero, it can be destroyed immediately, otherwise it is added
28 * to gc list and garbage collector periodically checks the refcnt.
29 */
30
31struct sk_buff;
32
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +000033struct dst_entry {
Eric Dumazet1e19e022007-02-09 16:26:55 -080034 struct rcu_head rcu_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 struct dst_entry *child;
36 struct net_device *dev;
David S. Miller62fa8a82011-01-26 20:51:05 -080037 struct dst_ops *ops;
38 unsigned long _metrics;
Gao feng1716a962012-04-06 00:13:10 +000039 union {
40 unsigned long expires;
41 /* point to where the dst_entry copied from */
42 struct dst_entry *from;
43 };
Zhang Yanminf1dd9c32008-03-12 22:52:37 -070044 struct dst_entry *path;
David S. Miller36bdbca2012-07-02 22:58:02 -070045 void *__pad0;
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -070046#ifdef CONFIG_XFRM
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 struct xfrm_state *xfrm;
Eric Dumazet5635c102008-11-16 19:46:36 -080048#else
49 void *__pad1;
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -070050#endif
Eldad Zack7f95e182012-06-16 15:14:49 +020051 int (*input)(struct sk_buff *);
52 int (*output)(struct sk_buff *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
David S. Miller5110effe2012-07-02 02:21:03 -070054 unsigned short flags;
David S. Millerf6b72b622011-07-14 07:53:20 -070055#define DST_HOST 0x0001
56#define DST_NOXFRM 0x0002
57#define DST_NOPOLICY 0x0004
58#define DST_NOHASH 0x0008
59#define DST_NOCACHE 0x0010
60#define DST_NOCOUNT 0x0020
Eric Dumazete688a602011-12-22 04:15:53 +000061#define DST_NOPEER 0x0040
Peter Huang (Peng)a881e962012-04-19 20:12:51 +000062#define DST_FAKE_RTABLE 0x0080
Gao feng0c183372012-05-26 01:30:53 +000063#define DST_XFRM_TUNNEL 0x0100
David S. Millerf6b72b622011-07-14 07:53:20 -070064
David S. Miller5110effe2012-07-02 02:21:03 -070065 unsigned short pending_confirm;
66
David S. Miller62fa8a82011-01-26 20:51:05 -080067 short error;
David S. Millerf5b0a872012-07-19 12:31:33 -070068
69 /* A non-zero value of dst->obsolete forces by-hand validation
70 * of the route entry. Positive values are set by the generic
71 * dst layer to indicate that the entry has been forcefully
72 * destroyed.
73 *
74 * Negative values are used by the implementation layer code to
75 * force invocation of the dst_ops->check() method.
76 */
David S. Miller62fa8a82011-01-26 20:51:05 -080077 short obsolete;
David S. Millerf5b0a872012-07-19 12:31:33 -070078#define DST_OBSOLETE_NONE 0
79#define DST_OBSOLETE_DEAD 2
80#define DST_OBSOLETE_FORCE_CHK -1
David S. Millerceb33202012-07-17 11:31:28 -070081#define DST_OBSOLETE_KILL -2
David S. Miller62fa8a82011-01-26 20:51:05 -080082 unsigned short header_len; /* more space at head required */
83 unsigned short trailer_len; /* space to reserve at tail */
Patrick McHardyc7066f72011-01-14 13:36:42 +010084#ifdef CONFIG_IP_ROUTE_CLASSID
Zhang Yanminf1dd9c32008-03-12 22:52:37 -070085 __u32 tclassid;
Eric Dumazet5635c102008-11-16 19:46:36 -080086#else
87 __u32 __pad2;
Zhang Yanminf1dd9c32008-03-12 22:52:37 -070088#endif
89
Eric Dumazet5635c102008-11-16 19:46:36 -080090 /*
91 * Align __refcnt to a 64 bytes alignment
92 * (L1_CACHE_SIZE would be too much)
93 */
94#ifdef CONFIG_64BIT
David S. Millerf6b72b622011-07-14 07:53:20 -070095 long __pad_to_align_refcnt[2];
Eric Dumazet5635c102008-11-16 19:46:36 -080096#endif
Zhang Yanminf1dd9c32008-03-12 22:52:37 -070097 /*
98 * __refcnt wants to be on a different cache line from
99 * input/output/ops or performance tanks badly
100 */
Eric Dumazet1e19e022007-02-09 16:26:55 -0800101 atomic_t __refcnt; /* client references */
102 int __use;
Zhang Yanminf1dd9c32008-03-12 22:52:37 -0700103 unsigned long lastuse;
Eric Dumazet1e19e022007-02-09 16:26:55 -0800104 union {
Eric Dumazetfc766e4c2010-10-29 03:09:24 +0000105 struct dst_entry *next;
106 struct rtable __rcu *rt_next;
107 struct rt6_info *rt6_next;
108 struct dn_route __rcu *dn_next;
Eric Dumazet1e19e022007-02-09 16:26:55 -0800109 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110};
111
David S. Miller62fa8a82011-01-26 20:51:05 -0800112extern u32 *dst_cow_metrics_generic(struct dst_entry *dst, unsigned long old);
Eric Dumazeta37e6e32012-08-07 10:55:45 +0000113extern const u32 dst_default_metrics[];
David S. Miller62fa8a82011-01-26 20:51:05 -0800114
115#define DST_METRICS_READ_ONLY 0x1UL
116#define __DST_METRICS_PTR(Y) \
117 ((u32 *)((Y) & ~DST_METRICS_READ_ONLY))
118#define DST_METRICS_PTR(X) __DST_METRICS_PTR((X)->_metrics)
119
120static inline bool dst_metrics_read_only(const struct dst_entry *dst)
121{
122 return dst->_metrics & DST_METRICS_READ_ONLY;
123}
124
125extern void __dst_destroy_metrics_generic(struct dst_entry *dst, unsigned long old);
126
127static inline void dst_destroy_metrics_generic(struct dst_entry *dst)
128{
129 unsigned long val = dst->_metrics;
130 if (!(val & DST_METRICS_READ_ONLY))
131 __dst_destroy_metrics_generic(dst, val);
132}
133
134static inline u32 *dst_metrics_write_ptr(struct dst_entry *dst)
135{
136 unsigned long p = dst->_metrics;
137
Stephen Hemminger1f370702011-05-24 13:50:52 -0400138 BUG_ON(!p);
139
David S. Miller62fa8a82011-01-26 20:51:05 -0800140 if (p & DST_METRICS_READ_ONLY)
141 return dst->ops->cow_metrics(dst, p);
142 return __DST_METRICS_PTR(p);
143}
144
145/* This may only be invoked before the entry has reached global
146 * visibility.
147 */
148static inline void dst_init_metrics(struct dst_entry *dst,
149 const u32 *src_metrics,
150 bool read_only)
151{
152 dst->_metrics = ((unsigned long) src_metrics) |
153 (read_only ? DST_METRICS_READ_ONLY : 0);
154}
155
156static inline void dst_copy_metrics(struct dst_entry *dest, const struct dst_entry *src)
157{
158 u32 *dst_metrics = dst_metrics_write_ptr(dest);
159
160 if (dst_metrics) {
161 u32 *src_metrics = DST_METRICS_PTR(src);
162
163 memcpy(dst_metrics, src_metrics, RTAX_MAX * sizeof(u32));
164 }
165}
166
167static inline u32 *dst_metrics_ptr(struct dst_entry *dst)
168{
169 return DST_METRICS_PTR(dst);
170}
171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172static inline u32
David S. Miller5170ae82010-12-12 21:35:57 -0800173dst_metric_raw(const struct dst_entry *dst, const int metric)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174{
David S. Miller62fa8a82011-01-26 20:51:05 -0800175 u32 *p = DST_METRICS_PTR(dst);
176
177 return p[metric-1];
David S. Millerdefb3512010-12-08 21:16:57 -0800178}
179
David S. Miller5170ae82010-12-12 21:35:57 -0800180static inline u32
181dst_metric(const struct dst_entry *dst, const int metric)
182{
David S. Miller0dbaee32010-12-13 12:52:14 -0800183 WARN_ON_ONCE(metric == RTAX_HOPLIMIT ||
David S. Millerd33e4552010-12-14 13:01:14 -0800184 metric == RTAX_ADVMSS ||
185 metric == RTAX_MTU);
David S. Miller5170ae82010-12-12 21:35:57 -0800186 return dst_metric_raw(dst, metric);
187}
188
David S. Miller0dbaee32010-12-13 12:52:14 -0800189static inline u32
190dst_metric_advmss(const struct dst_entry *dst)
191{
192 u32 advmss = dst_metric_raw(dst, RTAX_ADVMSS);
193
194 if (!advmss)
195 advmss = dst->ops->default_advmss(dst);
196
197 return advmss;
198}
199
David S. Millerdefb3512010-12-08 21:16:57 -0800200static inline void dst_metric_set(struct dst_entry *dst, int metric, u32 val)
201{
David S. Miller62fa8a82011-01-26 20:51:05 -0800202 u32 *p = dst_metrics_write_ptr(dst);
David S. Millerdefb3512010-12-08 21:16:57 -0800203
David S. Miller62fa8a82011-01-26 20:51:05 -0800204 if (p)
205 p[metric-1] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
Gilad Ben-Yossef0c3adfb2009-10-28 04:15:23 +0000208static inline u32
209dst_feature(const struct dst_entry *dst, u32 feature)
210{
David S. Millerbb5b7c12009-12-15 20:56:42 -0800211 return dst_metric(dst, RTAX_FEATURES) & feature;
Gilad Ben-Yossef0c3adfb2009-10-28 04:15:23 +0000212}
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214static inline u32 dst_mtu(const struct dst_entry *dst)
215{
Steffen Klassert618f9bc2011-11-23 02:13:31 +0000216 return dst->ops->mtu(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
218
Stephen Hemmingerc1e20f72008-07-18 23:02:15 -0700219/* RTT metrics are stored in milliseconds for user ABI, but used as jiffies */
220static inline unsigned long dst_metric_rtt(const struct dst_entry *dst, int metric)
221{
222 return msecs_to_jiffies(dst_metric(dst, metric));
223}
224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225static inline u32
226dst_allfrag(const struct dst_entry *dst)
227{
Gilad Ben-Yossef0c3adfb2009-10-28 04:15:23 +0000228 int ret = dst_feature(dst, RTAX_FEATURE_ALLFRAG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 return ret;
230}
231
232static inline int
David S. Millerd33e4552010-12-14 13:01:14 -0800233dst_metric_locked(const struct dst_entry *dst, int metric)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
235 return dst_metric(dst, RTAX_LOCK) & (1<<metric);
236}
237
Eldad Zack7f95e182012-06-16 15:14:49 +0200238static inline void dst_hold(struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239{
Eric Dumazet5635c102008-11-16 19:46:36 -0800240 /*
241 * If your kernel compilation stops here, please check
242 * __pad_to_align_refcnt declaration in struct dst_entry
243 */
244 BUILD_BUG_ON(offsetof(struct dst_entry, __refcnt) & 63);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 atomic_inc(&dst->__refcnt);
246}
247
Pavel Emelyanov03f49f32007-11-10 21:28:34 -0800248static inline void dst_use(struct dst_entry *dst, unsigned long time)
249{
250 dst_hold(dst);
251 dst->__use++;
252 dst->lastuse = time;
253}
254
Eric Dumazet7fee2262010-05-11 23:19:48 +0000255static inline void dst_use_noref(struct dst_entry *dst, unsigned long time)
256{
257 dst->__use++;
258 dst->lastuse = time;
259}
260
Eldad Zack7f95e182012-06-16 15:14:49 +0200261static inline struct dst_entry *dst_clone(struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
263 if (dst)
264 atomic_inc(&dst->__refcnt);
265 return dst;
266}
267
Ilpo Järvinen8d330862008-03-27 17:53:31 -0700268extern void dst_release(struct dst_entry *dst);
Eric Dumazet7fee2262010-05-11 23:19:48 +0000269
270static inline void refdst_drop(unsigned long refdst)
271{
272 if (!(refdst & SKB_DST_NOREF))
273 dst_release((struct dst_entry *)(refdst & SKB_DST_PTRMASK));
274}
275
276/**
277 * skb_dst_drop - drops skb dst
278 * @skb: buffer
279 *
280 * Drops dst reference count if a reference was taken.
281 */
Eric Dumazetadf30902009-06-02 05:19:30 +0000282static inline void skb_dst_drop(struct sk_buff *skb)
283{
Eric Dumazet7fee2262010-05-11 23:19:48 +0000284 if (skb->_skb_refdst) {
285 refdst_drop(skb->_skb_refdst);
286 skb->_skb_refdst = 0UL;
287 }
288}
289
290static inline void skb_dst_copy(struct sk_buff *nskb, const struct sk_buff *oskb)
291{
292 nskb->_skb_refdst = oskb->_skb_refdst;
293 if (!(nskb->_skb_refdst & SKB_DST_NOREF))
294 dst_clone(skb_dst(nskb));
295}
296
297/**
298 * skb_dst_force - makes sure skb dst is refcounted
299 * @skb: buffer
300 *
301 * If dst is not yet refcounted, let's do it
302 */
303static inline void skb_dst_force(struct sk_buff *skb)
304{
305 if (skb_dst_is_noref(skb)) {
306 WARN_ON(!rcu_read_lock_held());
307 skb->_skb_refdst &= ~SKB_DST_NOREF;
308 dst_clone(skb_dst(skb));
309 }
Eric Dumazetadf30902009-06-02 05:19:30 +0000310}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
Eric Dumazetd19d56d2010-05-17 22:36:55 -0700312
313/**
Eric Dumazet290b8952010-09-27 00:33:35 +0000314 * __skb_tunnel_rx - prepare skb for rx reinsert
315 * @skb: buffer
316 * @dev: tunnel device
317 *
318 * After decapsulation, packet is going to re-enter (netif_rx()) our stack,
319 * so make some cleanups. (no accounting done)
320 */
321static inline void __skb_tunnel_rx(struct sk_buff *skb, struct net_device *dev)
322{
323 skb->dev = dev;
Tom Herbertbdeab992011-08-14 19:45:55 +0000324
325 /*
326 * Clear rxhash so that we can recalulate the hash for the
327 * encapsulated packet, unless we have already determine the hash
328 * over the L4 4-tuple.
329 */
330 if (!skb->l4_rxhash)
331 skb->rxhash = 0;
Eric Dumazet290b8952010-09-27 00:33:35 +0000332 skb_set_queue_mapping(skb, 0);
333 skb_dst_drop(skb);
334 nf_reset(skb);
335}
336
337/**
Eric Dumazetd19d56d2010-05-17 22:36:55 -0700338 * skb_tunnel_rx - prepare skb for rx reinsert
339 * @skb: buffer
340 * @dev: tunnel device
341 *
342 * After decapsulation, packet is going to re-enter (netif_rx()) our stack,
343 * so make some cleanups, and perform accounting.
Eric Dumazet290b8952010-09-27 00:33:35 +0000344 * Note: this accounting is not SMP safe.
Eric Dumazetd19d56d2010-05-17 22:36:55 -0700345 */
346static inline void skb_tunnel_rx(struct sk_buff *skb, struct net_device *dev)
347{
Eric Dumazetd19d56d2010-05-17 22:36:55 -0700348 /* TODO : stats should be SMP safe */
349 dev->stats.rx_packets++;
350 dev->stats.rx_bytes += skb->len;
Eric Dumazet290b8952010-09-27 00:33:35 +0000351 __skb_tunnel_rx(skb, dev);
Eric Dumazetd19d56d2010-05-17 22:36:55 -0700352}
353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354/* Children define the path of the packet through the
355 * Linux networking. Thus, destinations are stackable.
356 */
357
Steffen Klassert8764ab22010-06-04 01:57:38 +0000358static inline struct dst_entry *skb_dst_pop(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Steffen Klasserte4334302011-03-15 21:09:32 +0000360 struct dst_entry *child = dst_clone(skb_dst(skb)->child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Steffen Klassert8764ab22010-06-04 01:57:38 +0000362 skb_dst_drop(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return child;
364}
365
Herbert Xu352e5122007-11-13 21:34:06 -0800366extern int dst_discard(struct sk_buff *skb);
Eldad Zack7f95e182012-06-16 15:14:49 +0200367extern void *dst_alloc(struct dst_ops *ops, struct net_device *dev,
David S. Miller5110effe2012-07-02 02:21:03 -0700368 int initial_ref, int initial_obsolete,
369 unsigned short flags);
Eldad Zack7f95e182012-06-16 15:14:49 +0200370extern void __dst_free(struct dst_entry *dst);
371extern struct dst_entry *dst_destroy(struct dst_entry *dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Eldad Zack7f95e182012-06-16 15:14:49 +0200373static inline void dst_free(struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374{
David S. Millerf5b0a872012-07-19 12:31:33 -0700375 if (dst->obsolete > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 return;
377 if (!atomic_read(&dst->__refcnt)) {
378 dst = dst_destroy(dst);
379 if (!dst)
380 return;
381 }
382 __dst_free(dst);
383}
384
385static inline void dst_rcu_free(struct rcu_head *head)
386{
387 struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head);
388 dst_free(dst);
389}
390
391static inline void dst_confirm(struct dst_entry *dst)
392{
David S. Miller5110effe2012-07-02 02:21:03 -0700393 dst->pending_confirm = 1;
394}
Eric Dumazetf2c31e32011-07-29 19:00:53 +0000395
David S. Miller5110effe2012-07-02 02:21:03 -0700396static inline int dst_neigh_output(struct dst_entry *dst, struct neighbour *n,
397 struct sk_buff *skb)
398{
Eric Dumazet425f09a2012-08-07 02:19:56 +0000399 const struct hh_cache *hh;
David S. Miller5110effe2012-07-02 02:21:03 -0700400
Eric Dumazet425f09a2012-08-07 02:19:56 +0000401 if (dst->pending_confirm) {
402 unsigned long now = jiffies;
403
David S. Miller5110effe2012-07-02 02:21:03 -0700404 dst->pending_confirm = 0;
Eric Dumazet425f09a2012-08-07 02:19:56 +0000405 /* avoid dirtying neighbour */
406 if (n->confirmed != now)
407 n->confirmed = now;
David S. Miller69cce1d2011-07-17 23:09:49 -0700408 }
David S. Miller5110effe2012-07-02 02:21:03 -0700409
410 hh = &n->hh;
411 if ((n->nud_state & NUD_CONNECTED) && hh->hh_len)
412 return neigh_hh_output(hh, skb);
413 else
414 return n->output(n, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415}
416
David S. Millerd3aaeb32011-07-18 00:40:17 -0700417static inline struct neighbour *dst_neigh_lookup(const struct dst_entry *dst, const void *daddr)
418{
David S. Millerf894cbf2012-07-02 21:52:24 -0700419 return dst->ops->neigh_lookup(dst, NULL, daddr);
420}
421
422static inline struct neighbour *dst_neigh_lookup_skb(const struct dst_entry *dst,
423 struct sk_buff *skb)
424{
425 return dst->ops->neigh_lookup(dst, skb, NULL);
David S. Millerd3aaeb32011-07-18 00:40:17 -0700426}
427
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428static inline void dst_link_failure(struct sk_buff *skb)
429{
Eric Dumazetadf30902009-06-02 05:19:30 +0000430 struct dst_entry *dst = skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 if (dst && dst->ops && dst->ops->link_failure)
432 dst->ops->link_failure(skb);
433}
434
435static inline void dst_set_expires(struct dst_entry *dst, int timeout)
436{
437 unsigned long expires = jiffies + timeout;
438
439 if (expires == 0)
440 expires = 1;
441
442 if (dst->expires == 0 || time_before(expires, dst->expires))
443 dst->expires = expires;
444}
445
446/* Output packet to network from transport. */
447static inline int dst_output(struct sk_buff *skb)
448{
Eric Dumazetadf30902009-06-02 05:19:30 +0000449 return skb_dst(skb)->output(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450}
451
452/* Input packet from network to transport. */
453static inline int dst_input(struct sk_buff *skb)
454{
Eric Dumazetadf30902009-06-02 05:19:30 +0000455 return skb_dst(skb)->input(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456}
457
458static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)
459{
460 if (dst->obsolete)
461 dst = dst->ops->check(dst, cookie);
462 return dst;
463}
464
465extern void dst_init(void);
466
Herbert Xu815f4e52007-12-12 10:36:59 -0800467/* Flags for xfrm_lookup flags argument. */
468enum {
David S. Miller80c0bc92011-03-01 14:36:37 -0800469 XFRM_LOOKUP_ICMP = 1 << 0,
Herbert Xu815f4e52007-12-12 10:36:59 -0800470};
471
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472struct flowi;
473#ifndef CONFIG_XFRM
David S. Miller452edd52011-03-02 13:27:41 -0800474static inline struct dst_entry *xfrm_lookup(struct net *net,
475 struct dst_entry *dst_orig,
476 const struct flowi *fl, struct sock *sk,
477 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
David S. Miller452edd52011-03-02 13:27:41 -0800479 return dst_orig;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480}
481#else
David S. Miller452edd52011-03-02 13:27:41 -0800482extern struct dst_entry *xfrm_lookup(struct net *net, struct dst_entry *dst_orig,
483 const struct flowi *fl, struct sock *sk,
484 int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
487#endif /* _NET_DST_H */