linux/include/net/neighbour.h
<<
>>
Prefs
   1#ifndef _NET_NEIGHBOUR_H
   2#define _NET_NEIGHBOUR_H
   3
   4#include <linux/neighbour.h>
   5
   6/*
   7 *      Generic neighbour manipulation
   8 *
   9 *      Authors:
  10 *      Pedro Roque             <roque@di.fc.ul.pt>
  11 *      Alexey Kuznetsov        <kuznet@ms2.inr.ac.ru>
  12 *
  13 *      Changes:
  14 *
  15 *      Harald Welte:           <laforge@gnumonks.org>
  16 *              - Add neighbour cache statistics like rtstat
  17 */
  18
  19#include <asm/atomic.h>
  20#include <linux/netdevice.h>
  21#include <linux/skbuff.h>
  22#include <linux/rcupdate.h>
  23#include <linux/seq_file.h>
  24
  25#include <linux/err.h>
  26#include <linux/sysctl.h>
  27#include <net/rtnetlink.h>
  28
  29/*
  30 * NUD stands for "neighbor unreachability detection"
  31 */
  32
  33#define NUD_IN_TIMER    (NUD_INCOMPLETE|NUD_REACHABLE|NUD_DELAY|NUD_PROBE)
  34#define NUD_VALID       (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE|NUD_PROBE|NUD_STALE|NUD_DELAY)
  35#define NUD_CONNECTED   (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE)
  36
  37struct neighbour;
  38
  39struct neigh_parms
  40{
  41#ifdef CONFIG_NET_NS
  42        struct net *net;
  43#endif
  44        struct net_device *dev;
  45        struct neigh_parms *next;
  46        int     (*neigh_setup)(struct neighbour *);
  47        void    (*neigh_cleanup)(struct neighbour *);
  48        struct neigh_table *tbl;
  49
  50        void    *sysctl_table;
  51
  52        int dead;
  53        atomic_t refcnt;
  54        struct rcu_head rcu_head;
  55
  56        int     base_reachable_time;
  57        int     retrans_time;
  58        int     gc_staletime;
  59        int     reachable_time;
  60        int     delay_probe_time;
  61
  62        int     queue_len;
  63        int     ucast_probes;
  64        int     app_probes;
  65        int     mcast_probes;
  66        int     anycast_delay;
  67        int     proxy_delay;
  68        int     proxy_qlen;
  69        int     locktime;
  70};
  71
  72struct neigh_statistics
  73{
  74        unsigned long allocs;           /* number of allocated neighs */
  75        unsigned long destroys;         /* number of destroyed neighs */
  76        unsigned long hash_grows;       /* number of hash resizes */
  77
  78        unsigned long res_failed;       /* number of failed resolutions */
  79
  80        unsigned long lookups;          /* number of lookups */
  81        unsigned long hits;             /* number of hits (among lookups) */
  82
  83        unsigned long rcv_probes_mcast; /* number of received mcast ipv6 */
  84        unsigned long rcv_probes_ucast; /* number of received ucast ipv6 */
  85
  86        unsigned long periodic_gc_runs; /* number of periodic GC runs */
  87        unsigned long forced_gc_runs;   /* number of forced GC runs */
  88
  89        unsigned long unres_discards;   /* number of unresolved drops */
  90};
  91
  92#define NEIGH_CACHE_STAT_INC(tbl, field)                                \
  93        do {                                                            \
  94                preempt_disable();                                      \
  95                (per_cpu_ptr((tbl)->stats, smp_processor_id())->field)++; \
  96                preempt_enable();                                       \
  97        } while (0)
  98
  99struct neighbour
 100{
 101        struct neighbour        *next;
 102        struct neigh_table      *tbl;
 103        struct neigh_parms      *parms;
 104        struct net_device               *dev;
 105        unsigned long           used;
 106        unsigned long           confirmed;
 107        unsigned long           updated;
 108        __u8                    flags;
 109        __u8                    nud_state;
 110        __u8                    type;
 111        __u8                    dead;
 112        atomic_t                probes;
 113        rwlock_t                lock;
 114        unsigned char           ha[ALIGN(MAX_ADDR_LEN, sizeof(unsigned long))];
 115        struct hh_cache         *hh;
 116        atomic_t                refcnt;
 117        int                     (*output)(struct sk_buff *skb);
 118        struct sk_buff_head     arp_queue;
 119        struct timer_list       timer;
 120        struct neigh_ops        *ops;
 121        u8                      primary_key[0];
 122};
 123
 124struct neigh_ops
 125{
 126        int                     family;
 127        void                    (*solicit)(struct neighbour *, struct sk_buff*);
 128        void                    (*error_report)(struct neighbour *, struct sk_buff*);
 129        int                     (*output)(struct sk_buff*);
 130        int                     (*connected_output)(struct sk_buff*);
 131        int                     (*hh_output)(struct sk_buff*);
 132        int                     (*queue_xmit)(struct sk_buff*);
 133};
 134
 135struct pneigh_entry
 136{
 137        struct pneigh_entry     *next;
 138#ifdef CONFIG_NET_NS
 139        struct net              *net;
 140#endif
 141        struct net_device       *dev;
 142        u8                      flags;
 143        u8                      key[0];
 144};
 145
 146/*
 147 *      neighbour table manipulation
 148 */
 149
 150
 151struct neigh_table
 152{
 153        struct neigh_table      *next;
 154        int                     family;
 155        int                     entry_size;
 156        int                     key_len;
 157        __u32                   (*hash)(const void *pkey, const struct net_device *);
 158        int                     (*constructor)(struct neighbour *);
 159        int                     (*pconstructor)(struct pneigh_entry *);
 160        void                    (*pdestructor)(struct pneigh_entry *);
 161        void                    (*proxy_redo)(struct sk_buff *skb);
 162        char                    *id;
 163        struct neigh_parms      parms;
 164        /* HACK. gc_* shoul follow parms without a gap! */
 165        int                     gc_interval;
 166        int                     gc_thresh1;
 167        int                     gc_thresh2;
 168        int                     gc_thresh3;
 169        unsigned long           last_flush;
 170        struct timer_list       gc_timer;
 171        struct timer_list       proxy_timer;
 172        struct sk_buff_head     proxy_queue;
 173        atomic_t                entries;
 174        rwlock_t                lock;
 175        unsigned long           last_rand;
 176        struct kmem_cache               *kmem_cachep;
 177        struct neigh_statistics *stats;
 178        struct neighbour        **hash_buckets;
 179        unsigned int            hash_mask;
 180        __u32                   hash_rnd;
 181        unsigned int            hash_chain_gc;
 182        struct pneigh_entry     **phash_buckets;
 183#ifdef CONFIG_PROC_FS
 184        struct proc_dir_entry   *pde;
 185#endif
 186};
 187
 188/* flags for neigh_update() */
 189#define NEIGH_UPDATE_F_OVERRIDE                 0x00000001
 190#define NEIGH_UPDATE_F_WEAK_OVERRIDE            0x00000002
 191#define NEIGH_UPDATE_F_OVERRIDE_ISROUTER        0x00000004
 192#define NEIGH_UPDATE_F_ISROUTER                 0x40000000
 193#define NEIGH_UPDATE_F_ADMIN                    0x80000000
 194
 195extern void                     neigh_table_init(struct neigh_table *tbl);
 196extern void                     neigh_table_init_no_netlink(struct neigh_table *tbl);
 197extern int                      neigh_table_clear(struct neigh_table *tbl);
 198extern struct neighbour *       neigh_lookup(struct neigh_table *tbl,
 199                                             const void *pkey,
 200                                             struct net_device *dev);
 201extern struct neighbour *       neigh_lookup_nodev(struct neigh_table *tbl,
 202                                                   struct net *net,
 203                                                   const void *pkey);
 204extern struct neighbour *       neigh_create(struct neigh_table *tbl,
 205                                             const void *pkey,
 206                                             struct net_device *dev);
 207extern void                     neigh_destroy(struct neighbour *neigh);
 208extern int                      __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb);
 209extern int                      neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 
 210                                             u32 flags);
 211extern void                     neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
 212extern int                      neigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
 213extern int                      neigh_resolve_output(struct sk_buff *skb);
 214extern int                      neigh_connected_output(struct sk_buff *skb);
 215extern int                      neigh_compat_output(struct sk_buff *skb);
 216extern struct neighbour         *neigh_event_ns(struct neigh_table *tbl,
 217                                                u8 *lladdr, void *saddr,
 218                                                struct net_device *dev);
 219
 220extern struct neigh_parms       *neigh_parms_alloc(struct net_device *dev, struct neigh_table *tbl);
 221extern void                     neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms);
 222
 223static inline
 224struct net                      *neigh_parms_net(const struct neigh_parms *parms)
 225{
 226#ifdef CONFIG_NET_NS
 227        return parms->net;
 228#else
 229        return &init_net;
 230#endif
 231}
 232
 233extern unsigned long            neigh_rand_reach_time(unsigned long base);
 234
 235extern void                     pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
 236                                               struct sk_buff *skb);
 237extern struct pneigh_entry      *pneigh_lookup(struct neigh_table *tbl, struct net *net, const void *key, struct net_device *dev, int creat);
 238extern struct pneigh_entry      *__pneigh_lookup(struct neigh_table *tbl,
 239                                                 struct net *net,
 240                                                 const void *key,
 241                                                 struct net_device *dev);
 242extern int                      pneigh_delete(struct neigh_table *tbl, struct net *net, const void *key, struct net_device *dev);
 243
 244static inline
 245struct net                      *pneigh_net(const struct pneigh_entry *pneigh)
 246{
 247#ifdef CONFIG_NET_NS
 248        return pneigh->net;
 249#else
 250        return &init_net;
 251#endif
 252}
 253
 254extern void neigh_app_ns(struct neighbour *n);
 255extern void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie);
 256extern void __neigh_for_each_release(struct neigh_table *tbl, int (*cb)(struct neighbour *));
 257extern void pneigh_for_each(struct neigh_table *tbl, void (*cb)(struct pneigh_entry *));
 258
 259struct neigh_seq_state {
 260        struct seq_net_private p;
 261        struct neigh_table *tbl;
 262        void *(*neigh_sub_iter)(struct neigh_seq_state *state,
 263                                struct neighbour *n, loff_t *pos);
 264        unsigned int bucket;
 265        unsigned int flags;
 266#define NEIGH_SEQ_NEIGH_ONLY    0x00000001
 267#define NEIGH_SEQ_IS_PNEIGH     0x00000002
 268#define NEIGH_SEQ_SKIP_NOARP    0x00000004
 269};
 270extern void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *, unsigned int);
 271extern void *neigh_seq_next(struct seq_file *, void *, loff_t *);
 272extern void neigh_seq_stop(struct seq_file *, void *);
 273
 274extern int                      neigh_sysctl_register(struct net_device *dev, 
 275                                                      struct neigh_parms *p,
 276                                                      int p_id, int pdev_id,
 277                                                      char *p_name,
 278                                                      proc_handler *proc_handler,
 279                                                      ctl_handler *strategy);
 280extern void                     neigh_sysctl_unregister(struct neigh_parms *p);
 281
 282static inline void __neigh_parms_put(struct neigh_parms *parms)
 283{
 284        atomic_dec(&parms->refcnt);
 285}
 286
 287static inline struct neigh_parms *neigh_parms_clone(struct neigh_parms *parms)
 288{
 289        atomic_inc(&parms->refcnt);
 290        return parms;
 291}
 292
 293/*
 294 *      Neighbour references
 295 */
 296
 297static inline void neigh_release(struct neighbour *neigh)
 298{
 299        if (atomic_dec_and_test(&neigh->refcnt))
 300                neigh_destroy(neigh);
 301}
 302
 303static inline struct neighbour * neigh_clone(struct neighbour *neigh)
 304{
 305        if (neigh)
 306                atomic_inc(&neigh->refcnt);
 307        return neigh;
 308}
 309
 310#define neigh_hold(n)   atomic_inc(&(n)->refcnt)
 311
 312static inline void neigh_confirm(struct neighbour *neigh)
 313{
 314        if (neigh)
 315                neigh->confirmed = jiffies;
 316}
 317
 318static inline int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
 319{
 320        neigh->used = jiffies;
 321        if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE)))
 322                return __neigh_event_send(neigh, skb);
 323        return 0;
 324}
 325
 326static inline int neigh_hh_output(struct hh_cache *hh, struct sk_buff *skb)
 327{
 328        unsigned seq;
 329        int hh_len;
 330
 331        do {
 332                int hh_alen;
 333
 334                seq = read_seqbegin(&hh->hh_lock);
 335                hh_len = hh->hh_len;
 336                hh_alen = HH_DATA_ALIGN(hh_len);
 337                memcpy(skb->data - hh_alen, hh->hh_data, hh_alen);
 338        } while (read_seqretry(&hh->hh_lock, seq));
 339
 340        skb_push(skb, hh_len);
 341        return hh->hh_output(skb);
 342}
 343
 344static inline struct neighbour *
 345__neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat)
 346{
 347        struct neighbour *n = neigh_lookup(tbl, pkey, dev);
 348
 349        if (n || !creat)
 350                return n;
 351
 352        n = neigh_create(tbl, pkey, dev);
 353        return IS_ERR(n) ? NULL : n;
 354}
 355
 356static inline struct neighbour *
 357__neigh_lookup_errno(struct neigh_table *tbl, const void *pkey,
 358  struct net_device *dev)
 359{
 360        struct neighbour *n = neigh_lookup(tbl, pkey, dev);
 361
 362        if (n)
 363                return n;
 364
 365        return neigh_create(tbl, pkey, dev);
 366}
 367
 368struct neighbour_cb {
 369        unsigned long sched_next;
 370        unsigned int flags;
 371};
 372
 373#define LOCALLY_ENQUEUED 0x1
 374
 375#define NEIGH_CB(skb)   ((struct neighbour_cb *)(skb)->cb)
 376
 377#endif
 378