Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Alexey Dobriyan | 86393e5 | 2009-08-29 01:34:49 +0000 | [diff] [blame] | 11 | #include <net/dst_ops.h> |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 12 | #include <linux/netdevice.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | /* |
| 20 | * 0 - no debugging messages |
| 21 | * 1 - rare events and bugs (default) |
| 22 | * 2 - trace mode. |
| 23 | */ |
| 24 | #define RT_CACHE_DEBUG 0 |
| 25 | |
| 26 | #define DST_GC_MIN (HZ/10) |
| 27 | #define DST_GC_INC (HZ/2) |
| 28 | #define DST_GC_MAX (120*HZ) |
| 29 | |
| 30 | /* Each dst_entry has reference count and sits in some parent list(s). |
| 31 | * When it is removed from parent list, it is "freed" (dst_free). |
| 32 | * After this it enters dead state (dst->obsolete > 0) and if its refcnt |
| 33 | * is zero, it can be destroyed immediately, otherwise it is added |
| 34 | * to gc list and garbage collector periodically checks the refcnt. |
| 35 | */ |
| 36 | |
| 37 | struct sk_buff; |
| 38 | |
| 39 | struct dst_entry |
| 40 | { |
Eric Dumazet | 1e19e02 | 2007-02-09 16:26:55 -0800 | [diff] [blame] | 41 | struct rcu_head rcu_head; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 42 | struct dst_entry *child; |
| 43 | struct net_device *dev; |
Herbert Xu | c4d5411 | 2005-04-19 20:46:37 -0700 | [diff] [blame] | 44 | short error; |
| 45 | short obsolete; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | int flags; |
| 47 | #define DST_HOST 1 |
| 48 | #define DST_NOXFRM 2 |
| 49 | #define DST_NOPOLICY 4 |
| 50 | #define DST_NOHASH 8 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | unsigned long expires; |
| 52 | |
| 53 | unsigned short header_len; /* more space at head required */ |
| 54 | unsigned short trailer_len; /* space to reserve at tail */ |
| 55 | |
Eric Dumazet | 69a7382 | 2008-01-22 06:18:34 -0800 | [diff] [blame] | 56 | unsigned int rate_tokens; |
Zhang Yanmin | f1dd9c3 | 2008-03-12 22:52:37 -0700 | [diff] [blame] | 57 | unsigned long rate_last; /* rate limiting for ICMP */ |
Eric Dumazet | 69a7382 | 2008-01-22 06:18:34 -0800 | [diff] [blame] | 58 | |
Zhang Yanmin | f1dd9c3 | 2008-03-12 22:52:37 -0700 | [diff] [blame] | 59 | struct dst_entry *path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | struct neighbour *neighbour; |
| 62 | struct hh_cache *hh; |
Alexey Dobriyan | def8b4f | 2008-10-28 13:24:06 -0700 | [diff] [blame] | 63 | #ifdef CONFIG_XFRM |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | struct xfrm_state *xfrm; |
Eric Dumazet | 5635c10 | 2008-11-16 19:46:36 -0800 | [diff] [blame] | 65 | #else |
| 66 | void *__pad1; |
Alexey Dobriyan | def8b4f | 2008-10-28 13:24:06 -0700 | [diff] [blame] | 67 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | int (*input)(struct sk_buff*); |
| 69 | int (*output)(struct sk_buff*); |
| 70 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | struct dst_ops *ops; |
Zhang Yanmin | f1dd9c3 | 2008-03-12 22:52:37 -0700 | [diff] [blame] | 72 | |
| 73 | u32 metrics[RTAX_MAX]; |
| 74 | |
| 75 | #ifdef CONFIG_NET_CLS_ROUTE |
| 76 | __u32 tclassid; |
Eric Dumazet | 5635c10 | 2008-11-16 19:46:36 -0800 | [diff] [blame] | 77 | #else |
| 78 | __u32 __pad2; |
Zhang Yanmin | f1dd9c3 | 2008-03-12 22:52:37 -0700 | [diff] [blame] | 79 | #endif |
| 80 | |
Eric Dumazet | 5635c10 | 2008-11-16 19:46:36 -0800 | [diff] [blame] | 81 | |
| 82 | /* |
| 83 | * Align __refcnt to a 64 bytes alignment |
| 84 | * (L1_CACHE_SIZE would be too much) |
| 85 | */ |
| 86 | #ifdef CONFIG_64BIT |
| 87 | long __pad_to_align_refcnt[2]; |
| 88 | #else |
| 89 | long __pad_to_align_refcnt[1]; |
| 90 | #endif |
Zhang Yanmin | f1dd9c3 | 2008-03-12 22:52:37 -0700 | [diff] [blame] | 91 | /* |
| 92 | * __refcnt wants to be on a different cache line from |
| 93 | * input/output/ops or performance tanks badly |
| 94 | */ |
Eric Dumazet | 1e19e02 | 2007-02-09 16:26:55 -0800 | [diff] [blame] | 95 | atomic_t __refcnt; /* client references */ |
| 96 | int __use; |
Zhang Yanmin | f1dd9c3 | 2008-03-12 22:52:37 -0700 | [diff] [blame] | 97 | unsigned long lastuse; |
Eric Dumazet | 1e19e02 | 2007-02-09 16:26:55 -0800 | [diff] [blame] | 98 | union { |
| 99 | struct dst_entry *next; |
| 100 | struct rtable *rt_next; |
| 101 | struct rt6_info *rt6_next; |
| 102 | struct dn_route *dn_next; |
| 103 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | }; |
| 105 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | #ifdef __KERNEL__ |
| 107 | |
| 108 | static inline u32 |
| 109 | dst_metric(const struct dst_entry *dst, int metric) |
| 110 | { |
| 111 | return dst->metrics[metric-1]; |
| 112 | } |
| 113 | |
Gilad Ben-Yossef | 0c3adfb | 2009-10-28 04:15:23 +0000 | [diff] [blame^] | 114 | static inline u32 |
| 115 | dst_feature(const struct dst_entry *dst, u32 feature) |
| 116 | { |
| 117 | return dst_metric(dst, RTAX_FEATURES) & feature; |
| 118 | } |
| 119 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | static inline u32 dst_mtu(const struct dst_entry *dst) |
| 121 | { |
| 122 | u32 mtu = dst_metric(dst, RTAX_MTU); |
| 123 | /* |
| 124 | * Alexey put it here, so ask him about it :) |
| 125 | */ |
| 126 | barrier(); |
| 127 | return mtu; |
| 128 | } |
| 129 | |
Stephen Hemminger | c1e20f7 | 2008-07-18 23:02:15 -0700 | [diff] [blame] | 130 | /* RTT metrics are stored in milliseconds for user ABI, but used as jiffies */ |
| 131 | static inline unsigned long dst_metric_rtt(const struct dst_entry *dst, int metric) |
| 132 | { |
| 133 | return msecs_to_jiffies(dst_metric(dst, metric)); |
| 134 | } |
| 135 | |
| 136 | static inline void set_dst_metric_rtt(struct dst_entry *dst, int metric, |
| 137 | unsigned long rtt) |
| 138 | { |
| 139 | dst->metrics[metric-1] = jiffies_to_msecs(rtt); |
| 140 | } |
| 141 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | static inline u32 |
| 143 | dst_allfrag(const struct dst_entry *dst) |
| 144 | { |
Gilad Ben-Yossef | 0c3adfb | 2009-10-28 04:15:23 +0000 | [diff] [blame^] | 145 | int ret = dst_feature(dst, RTAX_FEATURE_ALLFRAG); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | /* Yes, _exactly_. This is paranoia. */ |
| 147 | barrier(); |
| 148 | return ret; |
| 149 | } |
| 150 | |
| 151 | static inline int |
| 152 | dst_metric_locked(struct dst_entry *dst, int metric) |
| 153 | { |
| 154 | return dst_metric(dst, RTAX_LOCK) & (1<<metric); |
| 155 | } |
| 156 | |
| 157 | static inline void dst_hold(struct dst_entry * dst) |
| 158 | { |
Eric Dumazet | 5635c10 | 2008-11-16 19:46:36 -0800 | [diff] [blame] | 159 | /* |
| 160 | * If your kernel compilation stops here, please check |
| 161 | * __pad_to_align_refcnt declaration in struct dst_entry |
| 162 | */ |
| 163 | BUILD_BUG_ON(offsetof(struct dst_entry, __refcnt) & 63); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | atomic_inc(&dst->__refcnt); |
| 165 | } |
| 166 | |
Pavel Emelyanov | 03f49f3 | 2007-11-10 21:28:34 -0800 | [diff] [blame] | 167 | static inline void dst_use(struct dst_entry *dst, unsigned long time) |
| 168 | { |
| 169 | dst_hold(dst); |
| 170 | dst->__use++; |
| 171 | dst->lastuse = time; |
| 172 | } |
| 173 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | static inline |
| 175 | struct dst_entry * dst_clone(struct dst_entry * dst) |
| 176 | { |
| 177 | if (dst) |
| 178 | atomic_inc(&dst->__refcnt); |
| 179 | return dst; |
| 180 | } |
| 181 | |
Ilpo Järvinen | 8d33086 | 2008-03-27 17:53:31 -0700 | [diff] [blame] | 182 | extern void dst_release(struct dst_entry *dst); |
Eric Dumazet | adf3090 | 2009-06-02 05:19:30 +0000 | [diff] [blame] | 183 | static inline void skb_dst_drop(struct sk_buff *skb) |
| 184 | { |
| 185 | if (skb->_skb_dst) |
| 186 | dst_release(skb_dst(skb)); |
| 187 | skb->_skb_dst = 0UL; |
| 188 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | |
| 190 | /* Children define the path of the packet through the |
| 191 | * Linux networking. Thus, destinations are stackable. |
| 192 | */ |
| 193 | |
| 194 | static inline struct dst_entry *dst_pop(struct dst_entry *dst) |
| 195 | { |
| 196 | struct dst_entry *child = dst_clone(dst->child); |
| 197 | |
| 198 | dst_release(dst); |
| 199 | return child; |
| 200 | } |
| 201 | |
Herbert Xu | 352e512 | 2007-11-13 21:34:06 -0800 | [diff] [blame] | 202 | extern int dst_discard(struct sk_buff *skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | extern void * dst_alloc(struct dst_ops * ops); |
| 204 | extern void __dst_free(struct dst_entry * dst); |
| 205 | extern struct dst_entry *dst_destroy(struct dst_entry * dst); |
| 206 | |
| 207 | static inline void dst_free(struct dst_entry * dst) |
| 208 | { |
| 209 | if (dst->obsolete > 1) |
| 210 | return; |
| 211 | if (!atomic_read(&dst->__refcnt)) { |
| 212 | dst = dst_destroy(dst); |
| 213 | if (!dst) |
| 214 | return; |
| 215 | } |
| 216 | __dst_free(dst); |
| 217 | } |
| 218 | |
| 219 | static inline void dst_rcu_free(struct rcu_head *head) |
| 220 | { |
| 221 | struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head); |
| 222 | dst_free(dst); |
| 223 | } |
| 224 | |
| 225 | static inline void dst_confirm(struct dst_entry *dst) |
| 226 | { |
| 227 | if (dst) |
| 228 | neigh_confirm(dst->neighbour); |
| 229 | } |
| 230 | |
Krishna Kumar | ea94ff3 | 2009-10-19 23:46:45 +0000 | [diff] [blame] | 231 | static inline void dst_negative_advice(struct dst_entry **dst_p, |
| 232 | struct sock *sk) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | { |
| 234 | struct dst_entry * dst = *dst_p; |
Krishna Kumar | ea94ff3 | 2009-10-19 23:46:45 +0000 | [diff] [blame] | 235 | if (dst && dst->ops->negative_advice) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | *dst_p = dst->ops->negative_advice(dst); |
Krishna Kumar | ea94ff3 | 2009-10-19 23:46:45 +0000 | [diff] [blame] | 237 | |
| 238 | if (dst != *dst_p) { |
| 239 | extern void sk_reset_txq(struct sock *sk); |
| 240 | |
| 241 | sk_reset_txq(sk); |
| 242 | } |
| 243 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | static inline void dst_link_failure(struct sk_buff *skb) |
| 247 | { |
Eric Dumazet | adf3090 | 2009-06-02 05:19:30 +0000 | [diff] [blame] | 248 | struct dst_entry *dst = skb_dst(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | if (dst && dst->ops && dst->ops->link_failure) |
| 250 | dst->ops->link_failure(skb); |
| 251 | } |
| 252 | |
| 253 | static inline void dst_set_expires(struct dst_entry *dst, int timeout) |
| 254 | { |
| 255 | unsigned long expires = jiffies + timeout; |
| 256 | |
| 257 | if (expires == 0) |
| 258 | expires = 1; |
| 259 | |
| 260 | if (dst->expires == 0 || time_before(expires, dst->expires)) |
| 261 | dst->expires = expires; |
| 262 | } |
| 263 | |
| 264 | /* Output packet to network from transport. */ |
| 265 | static inline int dst_output(struct sk_buff *skb) |
| 266 | { |
Eric Dumazet | adf3090 | 2009-06-02 05:19:30 +0000 | [diff] [blame] | 267 | return skb_dst(skb)->output(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | } |
| 269 | |
| 270 | /* Input packet from network to transport. */ |
| 271 | static inline int dst_input(struct sk_buff *skb) |
| 272 | { |
Eric Dumazet | adf3090 | 2009-06-02 05:19:30 +0000 | [diff] [blame] | 273 | return skb_dst(skb)->input(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | } |
| 275 | |
| 276 | static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie) |
| 277 | { |
| 278 | if (dst->obsolete) |
| 279 | dst = dst->ops->check(dst, cookie); |
| 280 | return dst; |
| 281 | } |
| 282 | |
| 283 | extern void dst_init(void); |
| 284 | |
Herbert Xu | 815f4e5 | 2007-12-12 10:36:59 -0800 | [diff] [blame] | 285 | /* Flags for xfrm_lookup flags argument. */ |
| 286 | enum { |
| 287 | XFRM_LOOKUP_WAIT = 1 << 0, |
Herbert Xu | 8b7817f | 2007-12-12 10:44:43 -0800 | [diff] [blame] | 288 | XFRM_LOOKUP_ICMP = 1 << 1, |
Herbert Xu | 815f4e5 | 2007-12-12 10:36:59 -0800 | [diff] [blame] | 289 | }; |
| 290 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | struct flowi; |
| 292 | #ifndef CONFIG_XFRM |
Alexey Dobriyan | 52479b6 | 2008-11-25 17:35:18 -0800 | [diff] [blame] | 293 | static inline int xfrm_lookup(struct net *net, struct dst_entry **dst_p, |
| 294 | struct flowi *fl, struct sock *sk, int flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 295 | { |
| 296 | return 0; |
| 297 | } |
Alexey Dobriyan | 52479b6 | 2008-11-25 17:35:18 -0800 | [diff] [blame] | 298 | static inline int __xfrm_lookup(struct net *net, struct dst_entry **dst_p, |
| 299 | struct flowi *fl, struct sock *sk, int flags) |
David S. Miller | 14e50e5 | 2007-05-24 18:17:54 -0700 | [diff] [blame] | 300 | { |
| 301 | return 0; |
| 302 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | #else |
Alexey Dobriyan | 52479b6 | 2008-11-25 17:35:18 -0800 | [diff] [blame] | 304 | extern int xfrm_lookup(struct net *net, struct dst_entry **dst_p, |
| 305 | struct flowi *fl, struct sock *sk, int flags); |
| 306 | extern int __xfrm_lookup(struct net *net, struct dst_entry **dst_p, |
| 307 | struct flowi *fl, struct sock *sk, int flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | #endif |
| 309 | #endif |
| 310 | |
| 311 | #endif /* _NET_DST_H */ |