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 <linux/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 <linux/workqueue.h>
  28#include <net/rtnetlink.h>
  29
  30/*
  31 * NUD stands for "neighbor unreachability detection"
  32 */
  33
  34#define NUD_IN_TIMER    (NUD_INCOMPLETE|NUD_REACHABLE|NUD_DELAY|NUD_PROBE)
  35#define NUD_VALID       (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE|NUD_PROBE|NUD_STALE|NUD_DELAY)
  36#define NUD_CONNECTED   (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE)
  37
  38struct neighbour;
  39
  40struct neigh_parms {
  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_bytes;
  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        unsigned long allocs;           /* number of allocated neighs */
  74        unsigned long destroys;         /* number of destroyed neighs */
  75        unsigned long hash_grows;       /* number of hash resizes */
  76
  77        unsigned long res_failed;       /* number of failed resolutions */
  78
  79        unsigned long lookups;          /* number of lookups */
  80        unsigned long hits;             /* number of hits (among lookups) */
  81
  82        unsigned long rcv_probes_mcast; /* number of received mcast ipv6 */
  83        unsigned long rcv_probes_ucast; /* number of received ucast ipv6 */
  84
  85        unsigned long periodic_gc_runs; /* number of periodic GC runs */
  86        unsigned long forced_gc_runs;   /* number of forced GC runs */
  87
  88        unsigned long unres_discards;   /* number of unresolved drops */
  89};
  90
  91#define NEIGH_CACHE_STAT_INC(tbl, field) this_cpu_inc((tbl)->stats->field)
  92
  93struct neighbour {
  94        struct neighbour __rcu  *next;
  95        struct neigh_table      *tbl;
  96        struct neigh_parms      *parms;
  97        unsigned long           confirmed;
  98        unsigned long           updated;
  99        rwlock_t                lock;
 100        atomic_t                refcnt;
 101        struct sk_buff_head     arp_queue;
 102        unsigned int            arp_queue_len_bytes;
 103        struct timer_list       timer;
 104        unsigned long           used;
 105        atomic_t                probes;
 106        __u8                    flags;
 107        __u8                    nud_state;
 108        __u8                    type;
 109        __u8                    dead;
 110        seqlock_t               ha_lock;
 111        unsigned char           ha[ALIGN(MAX_ADDR_LEN, sizeof(unsigned long))];
 112        struct hh_cache         hh;
 113        int                     (*output)(struct neighbour *, struct sk_buff *);
 114        const struct neigh_ops  *ops;
 115        struct rcu_head         rcu;
 116        struct net_device       *dev;
 117        u8                      primary_key[0];
 118};
 119
 120struct neigh_ops {
 121        int                     family;
 122        void                    (*solicit)(struct neighbour *, struct sk_buff *);
 123        void                    (*error_report)(struct neighbour *, struct sk_buff *);
 124        int                     (*output)(struct neighbour *, struct sk_buff *);
 125        int                     (*connected_output)(struct neighbour *, struct sk_buff *);
 126};
 127
 128struct pneigh_entry {
 129        struct pneigh_entry     *next;
 130#ifdef CONFIG_NET_NS
 131        struct net              *net;
 132#endif
 133        struct net_device       *dev;
 134        u8                      flags;
 135        u8                      key[0];
 136};
 137
 138/*
 139 *      neighbour table manipulation
 140 */
 141
 142#define NEIGH_NUM_HASH_RND      4
 143
 144struct neigh_hash_table {
 145        struct neighbour __rcu  **hash_buckets;
 146        unsigned int            hash_shift;
 147        __u32                   hash_rnd[NEIGH_NUM_HASH_RND];
 148        struct rcu_head         rcu;
 149};
 150
 151
 152struct neigh_table {
 153        struct neigh_table      *next;
 154        int                     family;
 155        int                     entry_size;
 156        int                     key_len;
 157        __u32                   (*hash)(const void *pkey,
 158                                        const struct net_device *dev,
 159                                        __u32 *hash_rnd);
 160        int                     (*constructor)(struct neighbour *);
 161        int                     (*pconstructor)(struct pneigh_entry *);
 162        void                    (*pdestructor)(struct pneigh_entry *);
 163        void                    (*proxy_redo)(struct sk_buff *skb);
 164        char                    *id;
 165        struct neigh_parms      parms;
 166        /* HACK. gc_* should follow parms without a gap! */
 167        int                     gc_interval;
 168        int                     gc_thresh1;
 169        int                     gc_thresh2;
 170        int                     gc_thresh3;
 171        unsigned long           last_flush;
 172        struct delayed_work     gc_work;
 173        struct timer_list       proxy_timer;
 174        struct sk_buff_head     proxy_queue;
 175        atomic_t                entries;
 176        rwlock_t                lock;
 177        unsigned long           last_rand;
 178        struct neigh_statistics __percpu *stats;
 179        struct neigh_hash_table __rcu *nht;
 180        struct pneigh_entry     **phash_buckets;
 181};
 182
 183#define NEIGH_PRIV_ALIGN        sizeof(long long)
 184
 185static inline void *neighbour_priv(const struct neighbour *n)
 186{
 187        return (char *)n + ALIGN(sizeof(*n) + n->tbl->key_len, NEIGH_PRIV_ALIGN);
 188}
 189
 190/* flags for neigh_update() */
 191#define NEIGH_UPDATE_F_OVERRIDE                 0x00000001
 192#define NEIGH_UPDATE_F_WEAK_OVERRIDE            0x00000002
 193#define NEIGH_UPDATE_F_OVERRIDE_ISROUTER        0x00000004
 194#define NEIGH_UPDATE_F_ISROUTER                 0x40000000
 195#define NEIGH_UPDATE_F_ADMIN                    0x80000000
 196
 197extern void                     neigh_table_init(struct neigh_table *tbl);
 198extern int                      neigh_table_clear(struct neigh_table *tbl);
 199extern struct neighbour *       neigh_lookup(struct neigh_table *tbl,
 200                                             const void *pkey,
 201                                             struct net_device *dev);
 202extern struct neighbour *       neigh_lookup_nodev(struct neigh_table *tbl,
 203                                                   struct net *net,
 204                                                   const void *pkey);
 205extern struct neighbour *       __neigh_create(struct neigh_table *tbl,
 206                                               const void *pkey,
 207                                               struct net_device *dev,
 208                                               bool want_ref);
 209static inline struct neighbour *neigh_create(struct neigh_table *tbl,
 210                                             const void *pkey,
 211                                             struct net_device *dev)
 212{
 213        return __neigh_create(tbl, pkey, dev, true);
 214}
 215extern void                     neigh_destroy(struct neighbour *neigh);
 216extern int                      __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb);
 217extern int                      neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 
 218                                             u32 flags);
 219extern void                     neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
 220extern int                      neigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
 221extern int                      neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb);
 222extern int                      neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb);
 223extern int                      neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb);
 224extern int                      neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb);
 225extern struct neighbour         *neigh_event_ns(struct neigh_table *tbl,
 226                                                u8 *lladdr, void *saddr,
 227                                                struct net_device *dev);
 228
 229extern struct neigh_parms       *neigh_parms_alloc(struct net_device *dev, struct neigh_table *tbl);
 230extern void                     neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms);
 231
 232static inline
 233struct net                      *neigh_parms_net(const struct neigh_parms *parms)
 234{
 235        return read_pnet(&parms->net);
 236}
 237
 238extern unsigned long            neigh_rand_reach_time(unsigned long base);
 239
 240extern void                     pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
 241                                               struct sk_buff *skb);
 242extern struct pneigh_entry      *pneigh_lookup(struct neigh_table *tbl, struct net *net, const void *key, struct net_device *dev, int creat);
 243extern struct pneigh_entry      *__pneigh_lookup(struct neigh_table *tbl,
 244                                                 struct net *net,
 245                                                 const void *key,
 246                                                 struct net_device *dev);
 247extern int                      pneigh_delete(struct neigh_table *tbl, struct net *net, const void *key, struct net_device *dev);
 248
 249static inline
 250struct net                      *pneigh_net(const struct pneigh_entry *pneigh)
 251{
 252        return read_pnet(&pneigh->net);
 253}
 254
 255extern void neigh_app_ns(struct neighbour *n);
 256extern void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie);
 257extern void __neigh_for_each_release(struct neigh_table *tbl, int (*cb)(struct neighbour *));
 258extern void pneigh_for_each(struct neigh_table *tbl, void (*cb)(struct pneigh_entry *));
 259
 260struct neigh_seq_state {
 261        struct seq_net_private p;
 262        struct neigh_table *tbl;
 263        struct neigh_hash_table *nht;
 264        void *(*neigh_sub_iter)(struct neigh_seq_state *state,
 265                                struct neighbour *n, loff_t *pos);
 266        unsigned int bucket;
 267        unsigned int flags;
 268#define NEIGH_SEQ_NEIGH_ONLY    0x00000001
 269#define NEIGH_SEQ_IS_PNEIGH     0x00000002
 270#define NEIGH_SEQ_SKIP_NOARP    0x00000004
 271};
 272extern void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *, unsigned int);
 273extern void *neigh_seq_next(struct seq_file *, void *, loff_t *);
 274extern void neigh_seq_stop(struct seq_file *, void *);
 275
 276extern int                      neigh_sysctl_register(struct net_device *dev, 
 277                                                      struct neigh_parms *p,
 278                                                      char *p_name,
 279                                                      proc_handler *proc_handler);
 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 int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
 313{
 314        unsigned long now = jiffies;
 315        
 316        if (neigh->used != now)
 317                neigh->used = now;
 318        if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE)))
 319                return __neigh_event_send(neigh, skb);
 320        return 0;
 321}
 322
 323#ifdef CONFIG_BRIDGE_NETFILTER
 324static inline int neigh_hh_bridge(struct hh_cache *hh, struct sk_buff *skb)
 325{
 326        unsigned int seq, hh_alen;
 327
 328        do {
 329                seq = read_seqbegin(&hh->hh_lock);
 330                hh_alen = HH_DATA_ALIGN(ETH_HLEN);
 331                memcpy(skb->data - hh_alen, hh->hh_data, ETH_ALEN + hh_alen - ETH_HLEN);
 332        } while (read_seqretry(&hh->hh_lock, seq));
 333        return 0;
 334}
 335#endif
 336
 337static inline int neigh_hh_output(const struct hh_cache *hh, struct sk_buff *skb)
 338{
 339        unsigned int seq;
 340        int hh_len;
 341
 342        do {
 343                seq = read_seqbegin(&hh->hh_lock);
 344                hh_len = hh->hh_len;
 345                if (likely(hh_len <= HH_DATA_MOD)) {
 346                        /* this is inlined by gcc */
 347                        memcpy(skb->data - HH_DATA_MOD, hh->hh_data, HH_DATA_MOD);
 348                } else {
 349                        int hh_alen = HH_DATA_ALIGN(hh_len);
 350
 351                        memcpy(skb->data - hh_alen, hh->hh_data, hh_alen);
 352                }
 353        } while (read_seqretry(&hh->hh_lock, seq));
 354
 355        skb_push(skb, hh_len);
 356        return dev_queue_xmit(skb);
 357}
 358
 359static inline struct neighbour *
 360__neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat)
 361{
 362        struct neighbour *n = neigh_lookup(tbl, pkey, dev);
 363
 364        if (n || !creat)
 365                return n;
 366
 367        n = neigh_create(tbl, pkey, dev);
 368        return IS_ERR(n) ? NULL : n;
 369}
 370
 371static inline struct neighbour *
 372__neigh_lookup_errno(struct neigh_table *tbl, const void *pkey,
 373  struct net_device *dev)
 374{
 375        struct neighbour *n = neigh_lookup(tbl, pkey, dev);
 376
 377        if (n)
 378                return n;
 379
 380        return neigh_create(tbl, pkey, dev);
 381}
 382
 383struct neighbour_cb {
 384        unsigned long sched_next;
 385        unsigned int flags;
 386};
 387
 388#define LOCALLY_ENQUEUED 0x1
 389
 390#define NEIGH_CB(skb)   ((struct neighbour_cb *)(skb)->cb)
 391
 392static inline void neigh_ha_snapshot(char *dst, const struct neighbour *n,
 393                                     const struct net_device *dev)
 394{
 395        unsigned int seq;
 396
 397        do {
 398                seq = read_seqbegin(&n->ha_lock);
 399                memcpy(dst, n->ha, dev->addr_len);
 400        } while (read_seqretry(&n->ha_lock, seq));
 401}
 402#endif
 403
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.