linux/include/net/dst.h
<<
>>
Prefs
   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/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
  31struct sk_buff;
  32
  33struct dst_entry {
  34        struct rcu_head         rcu_head;
  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
  87        __u32                   __pad2;
  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;
 106                struct rtable __rcu     *rt_next;
 107                struct rt6_info         *rt6_next;
 108                struct dn_route __rcu   *dn_next;
 109        };
 110};
 111
 112extern u32 *dst_cow_metrics_generic(struct dst_entry *dst, unsigned long old);
 113extern 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
 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
 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 */
 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
 172static inline u32
 173dst_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
 180static inline u32
 181dst_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
 189static 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
 200static 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
 208static inline u32
 209dst_feature(const struct dst_entry *dst, u32 feature)
 210{
 211        return dst_metric(dst, RTAX_FEATURES) & feature;
 212}
 213
 214static 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 */
 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
 225static inline u32
 226dst_allfrag(const struct dst_entry *dst)
 227{
 228        int ret = dst_feature(dst,  RTAX_FEATURE_ALLFRAG);
 229        return ret;
 230}
 231
 232static inline int
 233dst_metric_locked(const struct dst_entry *dst, int metric)
 234{
 235        return dst_metric(dst, RTAX_LOCK) & (1<<metric);
 236}
 237
 238static 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
 248static 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
 255static inline void dst_use_noref(struct dst_entry *dst, unsigned long time)
 256{
 257        dst->__use++;
 258        dst->lastuse = time;
 259}
 260
 261static inline struct dst_entry *dst_clone(struct dst_entry *dst)
 262{
 263        if (dst)
 264                atomic_inc(&dst->__refcnt);
 265        return dst;
 266}
 267
 268extern void dst_release(struct dst_entry *dst);
 269
 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 */
 282static 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
 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        }
 310}
 311
 312
 313/**
 314 *      __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;
 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
 337/**
 338 *      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.
 344 *      Note: this accounting is not SMP safe.
 345 */
 346static 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
 358static 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
 366extern int dst_discard(struct sk_buff *skb);
 367extern void *dst_alloc(struct dst_ops *ops, struct net_device *dev,
 368                       int initial_ref, int initial_obsolete,
 369                       unsigned short flags);
 370extern void __dst_free(struct dst_entry *dst);
 371extern struct dst_entry *dst_destroy(struct dst_entry *dst);
 372
 373static 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
 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{
 393        dst->pending_confirm = 1;
 394}
 395
 396static inline int dst_neigh_output(struct dst_entry *dst, struct neighbour *n,
 397                                   struct sk_buff *skb)
 398{
 399        struct hh_cache *hh;
 400
 401        if (unlikely(dst->pending_confirm)) {
 402                n->confirmed = jiffies;
 403                dst->pending_confirm = 0;
 404        }
 405
 406        hh = &n->hh;
 407        if ((n->nud_state & NUD_CONNECTED) && hh->hh_len)
 408                return neigh_hh_output(hh, skb);
 409        else
 410                return n->output(n, skb);
 411}
 412
 413static inline struct neighbour *dst_neigh_lookup(const struct dst_entry *dst, const void *daddr)
 414{
 415        return dst->ops->neigh_lookup(dst, NULL, daddr);
 416}
 417
 418static inline struct neighbour *dst_neigh_lookup_skb(const struct dst_entry *dst,
 419                                                     struct sk_buff *skb)
 420{
 421        return dst->ops->neigh_lookup(dst, skb, NULL);
 422}
 423
 424static inline void dst_link_failure(struct sk_buff *skb)
 425{
 426        struct dst_entry *dst = skb_dst(skb);
 427        if (dst && dst->ops && dst->ops->link_failure)
 428                dst->ops->link_failure(skb);
 429}
 430
 431static inline void dst_set_expires(struct dst_entry *dst, int timeout)
 432{
 433        unsigned long expires = jiffies + timeout;
 434
 435        if (expires == 0)
 436                expires = 1;
 437
 438        if (dst->expires == 0 || time_before(expires, dst->expires))
 439                dst->expires = expires;
 440}
 441
 442/* Output packet to network from transport.  */
 443static inline int dst_output(struct sk_buff *skb)
 444{
 445        return skb_dst(skb)->output(skb);
 446}
 447
 448/* Input packet from network to transport.  */
 449static inline int dst_input(struct sk_buff *skb)
 450{
 451        return skb_dst(skb)->input(skb);
 452}
 453
 454static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)
 455{
 456        if (dst->obsolete)
 457                dst = dst->ops->check(dst, cookie);
 458        return dst;
 459}
 460
 461extern void             dst_init(void);
 462
 463/* Flags for xfrm_lookup flags argument. */
 464enum {
 465        XFRM_LOOKUP_ICMP = 1 << 0,
 466};
 467
 468struct flowi;
 469#ifndef CONFIG_XFRM
 470static inline struct dst_entry *xfrm_lookup(struct net *net,
 471                                            struct dst_entry *dst_orig,
 472                                            const struct flowi *fl, struct sock *sk,
 473                                            int flags)
 474{
 475        return dst_orig;
 476} 
 477#else
 478extern struct dst_entry *xfrm_lookup(struct net *net, struct dst_entry *dst_orig,
 479                                     const struct flowi *fl, struct sock *sk,
 480                                     int flags);
 481#endif
 482
 483#endif /* _NET_DST_H */
 484
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.