dst.h 10 KB

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