Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dst.h
Go to the documentation of this file.
1 /*
2  * net/dst.h Protocol independent destination cache definitions.
3  *
4  * Authors: Alexey Kuznetsov, <[email protected]>
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/bug.h>
16 #include <linux/jiffies.h>
17 #include <net/neighbour.h>
18 #include <asm/processor.h>
19 
20 #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 
31 struct sk_buff;
32 
33 struct dst_entry {
35  struct dst_entry *child;
36  struct net_device *dev;
37  struct dst_ops *ops;
38  unsigned long _metrics;
39  union {
40  unsigned long expires;
41  /* point to where the dst_entry copied from */
42  struct dst_entry *from;
43  };
44  struct dst_entry *path;
45  void *__pad0;
46 #ifdef CONFIG_XFRM
47  struct xfrm_state *xfrm;
48 #else
49  void *__pad1;
50 #endif
51  int (*input)(struct sk_buff *);
52  int (*output)(struct sk_buff *);
53 
54  unsigned short flags;
55 #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
61 #define DST_NOPEER 0x0040
62 #define DST_FAKE_RTABLE 0x0080
63 #define DST_XFRM_TUNNEL 0x0100
64 
65  unsigned short pending_confirm;
66 
67  short error;
68 
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  */
77  short obsolete;
78 #define DST_OBSOLETE_NONE 0
79 #define DST_OBSOLETE_DEAD 2
80 #define DST_OBSOLETE_FORCE_CHK -1
81 #define DST_OBSOLETE_KILL -2
82  unsigned short header_len; /* more space at head required */
83  unsigned short trailer_len; /* space to reserve at tail */
84 #ifdef CONFIG_IP_ROUTE_CLASSID
85  __u32 tclassid;
86 #else
88 #endif
89 
90  /*
91  * Align __refcnt to a 64 bytes alignment
92  * (L1_CACHE_SIZE would be too much)
93  */
94 #ifdef CONFIG_64BIT
95  long __pad_to_align_refcnt[2];
96 #endif
97  /*
98  * __refcnt wants to be on a different cache line from
99  * input/output/ops or performance tanks badly
100  */
101  atomic_t __refcnt; /* client references */
102  int __use;
103  unsigned long lastuse;
104  union {
105  struct dst_entry *next;
109  };
110 };
111 
112 extern u32 *dst_cow_metrics_generic(struct dst_entry *dst, unsigned long old);
113 extern const u32 dst_default_metrics[];
114 
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 
120 static inline bool dst_metrics_read_only(const struct dst_entry *dst)
121 {
122  return dst->_metrics & DST_METRICS_READ_ONLY;
123 }
124 
125 extern void __dst_destroy_metrics_generic(struct dst_entry *dst, unsigned long old);
126 
127 static inline void dst_destroy_metrics_generic(struct dst_entry *dst)
128 {
129  unsigned long val = dst->_metrics;
130  if (!(val & DST_METRICS_READ_ONLY))
132 }
133 
134 static inline u32 *dst_metrics_write_ptr(struct dst_entry *dst)
135 {
136  unsigned long p = dst->_metrics;
137 
138  BUG_ON(!p);
139 
140  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  */
148 static 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 
156 static 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 
167 static inline u32 *dst_metrics_ptr(struct dst_entry *dst)
168 {
169  return DST_METRICS_PTR(dst);
170 }
171 
172 static inline u32
173 dst_metric_raw(const struct dst_entry *dst, const int metric)
174 {
175  u32 *p = DST_METRICS_PTR(dst);
176 
177  return p[metric-1];
178 }
179 
180 static inline u32
181 dst_metric(const struct dst_entry *dst, const int metric)
182 {
183  WARN_ON_ONCE(metric == RTAX_HOPLIMIT ||
184  metric == RTAX_ADVMSS ||
185  metric == RTAX_MTU);
186  return dst_metric_raw(dst, metric);
187 }
188 
189 static inline u32
190 dst_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 
200 static inline void dst_metric_set(struct dst_entry *dst, int metric, u32 val)
201 {
202  u32 *p = dst_metrics_write_ptr(dst);
203 
204  if (p)
205  p[metric-1] = val;
206 }
207 
208 static inline u32
209 dst_feature(const struct dst_entry *dst, u32 feature)
210 {
211  return dst_metric(dst, RTAX_FEATURES) & feature;
212 }
213 
214 static inline u32 dst_mtu(const struct dst_entry *dst)
215 {
216  return dst->ops->mtu(dst);
217 }
218 
219 /* RTT metrics are stored in milliseconds for user ABI, but used as jiffies */
220 static 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 
225 static inline u32
226 dst_allfrag(const struct dst_entry *dst)
227 {
228  int ret = dst_feature(dst, RTAX_FEATURE_ALLFRAG);
229  return ret;
230 }
231 
232 static inline int
233 dst_metric_locked(const struct dst_entry *dst, int metric)
234 {
235  return dst_metric(dst, RTAX_LOCK) & (1<<metric);
236 }
237 
238 static inline void dst_hold(struct dst_entry *dst)
239 {
240  /*
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);
245  atomic_inc(&dst->__refcnt);
246 }
247 
248 static 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 
255 static inline void dst_use_noref(struct dst_entry *dst, unsigned long time)
256 {
257  dst->__use++;
258  dst->lastuse = time;
259 }
260 
261 static inline struct dst_entry *dst_clone(struct dst_entry *dst)
262 {
263  if (dst)
264  atomic_inc(&dst->__refcnt);
265  return dst;
266 }
267 
268 extern void dst_release(struct dst_entry *dst);
269 
270 static 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 
282 static inline void skb_dst_drop(struct sk_buff *skb)
283 {
284  if (skb->_skb_refdst) {
285  refdst_drop(skb->_skb_refdst);
286  skb->_skb_refdst = 0UL;
287  }
288 }
289 
290 static 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 
303 static 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  }
310 }
311 
312 
321 static inline void __skb_tunnel_rx(struct sk_buff *skb, struct net_device *dev)
322 {
323  skb->dev = dev;
324 
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;
332  skb_set_queue_mapping(skb, 0);
333  skb_dst_drop(skb);
334  nf_reset(skb);
335 }
336 
346 static inline void skb_tunnel_rx(struct sk_buff *skb, struct net_device *dev)
347 {
348  /* TODO : stats should be SMP safe */
349  dev->stats.rx_packets++;
350  dev->stats.rx_bytes += skb->len;
351  __skb_tunnel_rx(skb, dev);
352 }
353 
354 /* Children define the path of the packet through the
355  * Linux networking. Thus, destinations are stackable.
356  */
357 
358 static inline struct dst_entry *skb_dst_pop(struct sk_buff *skb)
359 {
360  struct dst_entry *child = dst_clone(skb_dst(skb)->child);
361 
362  skb_dst_drop(skb);
363  return child;
364 }
365 
366 extern int dst_discard(struct sk_buff *skb);
367 extern void *dst_alloc(struct dst_ops *ops, struct net_device *dev,
368  int initial_ref, int initial_obsolete,
369  unsigned short flags);
370 extern void __dst_free(struct dst_entry *dst);
371 extern struct dst_entry *dst_destroy(struct dst_entry *dst);
372 
373 static inline void dst_free(struct dst_entry *dst)
374 {
375  if (dst->obsolete > 0)
376  return;
377  if (!atomic_read(&dst->__refcnt)) {
378  dst = dst_destroy(dst);
379  if (!dst)
380  return;
381  }
382  __dst_free(dst);
383 }
384 
385 static 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 
391 static inline void dst_confirm(struct dst_entry *dst)
392 {
393  dst->pending_confirm = 1;
394 }
395 
396 static inline int dst_neigh_output(struct dst_entry *dst, struct neighbour *n,
397  struct sk_buff *skb)
398 {
399  const struct hh_cache *hh;
400 
401  if (dst->pending_confirm) {
402  unsigned long now = jiffies;
403 
404  dst->pending_confirm = 0;
405  /* avoid dirtying neighbour */
406  if (n->confirmed != now)
407  n->confirmed = now;
408  }
409 
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);
415 }
416 
417 static inline struct neighbour *dst_neigh_lookup(const struct dst_entry *dst, const void *daddr)
418 {
419  return dst->ops->neigh_lookup(dst, NULL, daddr);
420 }
421 
422 static 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);
426 }
427 
428 static inline void dst_link_failure(struct sk_buff *skb)
429 {
430  struct dst_entry *dst = skb_dst(skb);
431  if (dst && dst->ops && dst->ops->link_failure)
432  dst->ops->link_failure(skb);
433 }
434 
435 static 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. */
447 static inline int dst_output(struct sk_buff *skb)
448 {
449  return skb_dst(skb)->output(skb);
450 }
451 
452 /* Input packet from network to transport. */
453 static inline int dst_input(struct sk_buff *skb)
454 {
455  return skb_dst(skb)->input(skb);
456 }
457 
458 static 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 
465 extern void dst_init(void);
466 
467 /* Flags for xfrm_lookup flags argument. */
468 enum {
470 };
471 
472 struct flowi;
473 #ifndef CONFIG_XFRM
474 static 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)
478 {
479  return dst_orig;
480 }
481 #else
482 extern struct dst_entry *xfrm_lookup(struct net *net, struct dst_entry *dst_orig,
483  const struct flowi *fl, struct sock *sk,
484  int flags);
485 #endif
486 
487 #endif /* _NET_DST_H */