net: fix NULL dereferences in check_peer_redir()
[~shefty/rdma-dev.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         skb->rxhash = 0;
329         skb_set_queue_mapping(skb, 0);
330         skb_dst_drop(skb);
331         nf_reset(skb);
332 }
333
334 /**
335  *      skb_tunnel_rx - prepare skb for rx reinsert
336  *      @skb: buffer
337  *      @dev: tunnel device
338  *
339  *      After decapsulation, packet is going to re-enter (netif_rx()) our stack,
340  *      so make some cleanups, and perform accounting.
341  *      Note: this accounting is not SMP safe.
342  */
343 static inline void skb_tunnel_rx(struct sk_buff *skb, struct net_device *dev)
344 {
345         /* TODO : stats should be SMP safe */
346         dev->stats.rx_packets++;
347         dev->stats.rx_bytes += skb->len;
348         __skb_tunnel_rx(skb, dev);
349 }
350
351 /* Children define the path of the packet through the
352  * Linux networking.  Thus, destinations are stackable.
353  */
354
355 static inline struct dst_entry *skb_dst_pop(struct sk_buff *skb)
356 {
357         struct dst_entry *child = dst_clone(skb_dst(skb)->child);
358
359         skb_dst_drop(skb);
360         return child;
361 }
362
363 extern int dst_discard(struct sk_buff *skb);
364 extern void *dst_alloc(struct dst_ops * ops, struct net_device *dev,
365                        int initial_ref, int initial_obsolete, int flags);
366 extern void __dst_free(struct dst_entry * dst);
367 extern struct dst_entry *dst_destroy(struct dst_entry * dst);
368
369 static inline void dst_free(struct dst_entry * dst)
370 {
371         if (dst->obsolete > 1)
372                 return;
373         if (!atomic_read(&dst->__refcnt)) {
374                 dst = dst_destroy(dst);
375                 if (!dst)
376                         return;
377         }
378         __dst_free(dst);
379 }
380
381 static inline void dst_rcu_free(struct rcu_head *head)
382 {
383         struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head);
384         dst_free(dst);
385 }
386
387 static inline void dst_confirm(struct dst_entry *dst)
388 {
389         if (dst) {
390                 struct neighbour *n;
391
392                 rcu_read_lock();
393                 n = dst_get_neighbour(dst);
394                 neigh_confirm(n);
395                 rcu_read_unlock();
396         }
397 }
398
399 static inline struct neighbour *dst_neigh_lookup(const struct dst_entry *dst, const void *daddr)
400 {
401         return dst->ops->neigh_lookup(dst, daddr);
402 }
403
404 static inline void dst_link_failure(struct sk_buff *skb)
405 {
406         struct dst_entry *dst = skb_dst(skb);
407         if (dst && dst->ops && dst->ops->link_failure)
408                 dst->ops->link_failure(skb);
409 }
410
411 static inline void dst_set_expires(struct dst_entry *dst, int timeout)
412 {
413         unsigned long expires = jiffies + timeout;
414
415         if (expires == 0)
416                 expires = 1;
417
418         if (dst->expires == 0 || time_before(expires, dst->expires))
419                 dst->expires = expires;
420 }
421
422 /* Output packet to network from transport.  */
423 static inline int dst_output(struct sk_buff *skb)
424 {
425         return skb_dst(skb)->output(skb);
426 }
427
428 /* Input packet from network to transport.  */
429 static inline int dst_input(struct sk_buff *skb)
430 {
431         return skb_dst(skb)->input(skb);
432 }
433
434 static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)
435 {
436         if (dst->obsolete)
437                 dst = dst->ops->check(dst, cookie);
438         return dst;
439 }
440
441 extern void             dst_init(void);
442
443 /* Flags for xfrm_lookup flags argument. */
444 enum {
445         XFRM_LOOKUP_ICMP = 1 << 0,
446 };
447
448 struct flowi;
449 #ifndef CONFIG_XFRM
450 static inline struct dst_entry *xfrm_lookup(struct net *net,
451                                             struct dst_entry *dst_orig,
452                                             const struct flowi *fl, struct sock *sk,
453                                             int flags)
454 {
455         return dst_orig;
456
457 #else
458 extern struct dst_entry *xfrm_lookup(struct net *net, struct dst_entry *dst_orig,
459                                      const struct flowi *fl, struct sock *sk,
460                                      int flags);
461 #endif
462
463 #endif /* _NET_DST_H */