LCOV - code coverage report
Current view: top level - include/net - neighbour.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 6 6 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       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 <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             : 
      38             : struct neighbour;
      39             : 
      40             : struct 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;
      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           1 : 
      72             : struct 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           2 : 
      91             : #define NEIGH_CACHE_STAT_INC(tbl, field) this_cpu_inc((tbl)->stats->field)
      92             : 
      93             : struct neighbour {
      94             :         struct neighbour        *next;
      95             :         struct neigh_table      *tbl;
      96             :         struct neigh_parms      *parms;
      97             :         struct net_device               *dev;
      98             :         unsigned long           used;
      99             :         unsigned long           confirmed;
     100             :         unsigned long           updated;
     101             :         __u8                    flags;
     102             :         __u8                    nud_state;
     103             :         __u8                    type;
     104             :         __u8                    dead;
     105             :         atomic_t                probes;
     106             :         rwlock_t                lock;
     107             :         unsigned char           ha[ALIGN(MAX_ADDR_LEN, sizeof(unsigned long))];
     108             :         struct hh_cache         *hh;
     109             :         atomic_t                refcnt;
     110             :         int                     (*output)(struct sk_buff *skb);
     111             :         struct sk_buff_head     arp_queue;
     112             :         struct timer_list       timer;
     113             :         const struct neigh_ops  *ops;
     114             :         u8                      primary_key[0];
     115             : };
     116           1 : 
     117             : struct neigh_ops {
     118             :         int                     family;
     119             :         void                    (*solicit)(struct neighbour *, struct sk_buff*);
     120             :         void                    (*error_report)(struct neighbour *, struct sk_buff*);
     121             :         int                     (*output)(struct sk_buff*);
     122             :         int                     (*connected_output)(struct sk_buff*);
     123             :         int                     (*hh_output)(struct sk_buff*);
     124             :         int                     (*queue_xmit)(struct sk_buff*);
     125             : };
     126           1 : 
     127             : struct pneigh_entry {
     128             :         struct pneigh_entry     *next;
     129             : #ifdef CONFIG_NET_NS
     130             :         struct net              *net;
     131             : #endif
     132             :         struct net_device       *dev;
     133             :         u8                      flags;
     134             :         u8                      key[0];
     135             : };
     136           1 : 
     137             : /*
     138             :  *      neighbour table manipulation
     139             :  */
     140             : 
     141             : 
     142             : struct neigh_table {
     143             :         struct neigh_table      *next;
     144             :         int                     family;
     145             :         int                     entry_size;
     146             :         int                     key_len;
     147             :         __u32                   (*hash)(const void *pkey, const struct net_device *);
     148             :         int                     (*constructor)(struct neighbour *);
     149             :         int                     (*pconstructor)(struct pneigh_entry *);
     150             :         void                    (*pdestructor)(struct pneigh_entry *);
     151             :         void                    (*proxy_redo)(struct sk_buff *skb);
     152             :         char                    *id;
     153             :         struct neigh_parms      parms;
     154             :         /* HACK. gc_* shoul follow parms without a gap! */
     155             :         int                     gc_interval;
     156             :         int                     gc_thresh1;
     157             :         int                     gc_thresh2;
     158             :         int                     gc_thresh3;
     159             :         unsigned long           last_flush;
     160             :         struct delayed_work     gc_work;
     161             :         struct timer_list       proxy_timer;
     162             :         struct sk_buff_head     proxy_queue;
     163             :         atomic_t                entries;
     164             :         rwlock_t                lock;
     165             :         unsigned long           last_rand;
     166             :         struct kmem_cache               *kmem_cachep;
     167             :         struct neigh_statistics *stats;
     168             :         struct neighbour        **hash_buckets;
     169             :         unsigned int            hash_mask;
     170             :         __u32                   hash_rnd;
     171             :         struct pneigh_entry     **phash_buckets;
     172             : };
     173             : 
     174             : /* flags for neigh_update() */
     175             : #define NEIGH_UPDATE_F_OVERRIDE                 0x00000001
     176             : #define NEIGH_UPDATE_F_WEAK_OVERRIDE            0x00000002
     177             : #define NEIGH_UPDATE_F_OVERRIDE_ISROUTER        0x00000004
     178             : #define NEIGH_UPDATE_F_ISROUTER                 0x40000000
     179             : #define NEIGH_UPDATE_F_ADMIN                    0x80000000
     180             : 
     181             : extern void                     neigh_table_init(struct neigh_table *tbl);
     182             : extern void                     neigh_table_init_no_netlink(struct neigh_table *tbl);
     183             : extern int                      neigh_table_clear(struct neigh_table *tbl);
     184             : extern struct neighbour *       neigh_lookup(struct neigh_table *tbl,
     185             :                                              const void *pkey,
     186             :                                              struct net_device *dev);
     187             : extern struct neighbour *       neigh_lookup_nodev(struct neigh_table *tbl,
     188             :                                                    struct net *net,
     189             :                                                    const void *pkey);
     190             : extern struct neighbour *       neigh_create(struct neigh_table *tbl,
     191             :                                              const void *pkey,
     192             :                                              struct net_device *dev);
     193             : extern void                     neigh_destroy(struct neighbour *neigh);
     194             : extern int                      __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb);
     195             : extern int                      neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 
     196             :                                              u32 flags);
     197             : extern void                     neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
     198             : extern int                      neigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
     199             : extern int                      neigh_resolve_output(struct sk_buff *skb);
     200             : extern int                      neigh_connected_output(struct sk_buff *skb);
     201             : extern int                      neigh_compat_output(struct sk_buff *skb);
     202             : extern struct neighbour         *neigh_event_ns(struct neigh_table *tbl,
     203             :                                                 u8 *lladdr, void *saddr,
     204             :                                                 struct net_device *dev);
     205             : 
     206             : extern struct neigh_parms       *neigh_parms_alloc(struct net_device *dev, struct neigh_table *tbl);
     207             : extern void                     neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms);
     208             : 
     209             : static inline
     210             : struct net                      *neigh_parms_net(const struct neigh_parms *parms)
     211             : {
     212             :         return read_pnet(&parms->net);
     213             : }
     214             : 
     215             : extern unsigned long            neigh_rand_reach_time(unsigned long base);
     216             : 
     217             : extern void                     pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
     218             :                                                struct sk_buff *skb);
     219             : extern struct pneigh_entry      *pneigh_lookup(struct neigh_table *tbl, struct net *net, const void *key, struct net_device *dev, int creat);
     220             : extern struct pneigh_entry      *__pneigh_lookup(struct neigh_table *tbl,
     221             :                                                  struct net *net,
     222             :                                                  const void *key,
     223             :                                                  struct net_device *dev);
     224             : extern int                      pneigh_delete(struct neigh_table *tbl, struct net *net, const void *key, struct net_device *dev);
     225             : 
     226             : static inline
     227             : struct net                      *pneigh_net(const struct pneigh_entry *pneigh)
     228             : {
     229             :         return read_pnet(&pneigh->net);
     230             : }
     231             : 
     232             : extern void neigh_app_ns(struct neighbour *n);
     233             : extern void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie);
     234             : extern void __neigh_for_each_release(struct neigh_table *tbl, int (*cb)(struct neighbour *));
     235             : extern void pneigh_for_each(struct neigh_table *tbl, void (*cb)(struct pneigh_entry *));
     236             : 
     237             : struct neigh_seq_state {
     238             :         struct seq_net_private p;
     239             :         struct neigh_table *tbl;
     240             :         void *(*neigh_sub_iter)(struct neigh_seq_state *state,
     241             :                                 struct neighbour *n, loff_t *pos);
     242             :         unsigned int bucket;
     243             :         unsigned int flags;
     244             : #define NEIGH_SEQ_NEIGH_ONLY    0x00000001
     245             : #define NEIGH_SEQ_IS_PNEIGH     0x00000002
     246             : #define NEIGH_SEQ_SKIP_NOARP    0x00000004
     247             : };
     248             : extern void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *, unsigned int);
     249             : extern void *neigh_seq_next(struct seq_file *, void *, loff_t *);
     250             : extern void neigh_seq_stop(struct seq_file *, void *);
     251             : 
     252             : extern int                      neigh_sysctl_register(struct net_device *dev, 
     253             :                                                       struct neigh_parms *p,
     254             :                                                       int p_id, int pdev_id,
     255             :                                                       char *p_name,
     256             :                                                       proc_handler *proc_handler);
     257             : extern void                     neigh_sysctl_unregister(struct neigh_parms *p);
     258             : 
     259             : static inline void __neigh_parms_put(struct neigh_parms *parms)
     260             : {
     261             :         atomic_dec(&parms->refcnt);
     262             : }
     263             : 
     264             : static inline struct neigh_parms *neigh_parms_clone(struct neigh_parms *parms)
     265             : {
     266             :         atomic_inc(&parms->refcnt);
     267             :         return parms;
     268             : }
     269             : 
     270             : /*
     271             :  *      Neighbour references
     272             :  */
     273             : 
     274             : static inline void neigh_release(struct neighbour *neigh)
     275             : {
     276             :         if (atomic_dec_and_test(&neigh->refcnt))
     277             :                 neigh_destroy(neigh);
     278             : }
     279             : 
     280             : static inline struct neighbour * neigh_clone(struct neighbour *neigh)
     281             : {
     282             :         if (neigh)
     283             :                 atomic_inc(&neigh->refcnt);
     284             :         return neigh;
     285             : }
     286             : 
     287             : #define neigh_hold(n)   atomic_inc(&(n)->refcnt)
     288             : 
     289             : static inline void neigh_confirm(struct neighbour *neigh)
     290             : {
     291             :         if (neigh)
     292             :                 neigh->confirmed = jiffies;
     293             : }
     294             : 
     295             : static inline int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
     296             : {
     297             :         neigh->used = jiffies;
     298             :         if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE)))
     299             :                 return __neigh_event_send(neigh, skb);
     300             :         return 0;
     301             : }
     302             : 
     303             : static inline int neigh_hh_output(struct hh_cache *hh, struct sk_buff *skb)
     304             : {
     305             :         unsigned seq;
     306             :         int hh_len;
     307             : 
     308             :         do {
     309             :                 int hh_alen;
     310             : 
     311             :                 seq = read_seqbegin(&hh->hh_lock);
     312             :                 hh_len = hh->hh_len;
     313             :                 hh_alen = HH_DATA_ALIGN(hh_len);
     314             :                 memcpy(skb->data - hh_alen, hh->hh_data, hh_alen);
     315             :         } while (read_seqretry(&hh->hh_lock, seq));
     316             : 
     317             :         skb_push(skb, hh_len);
     318             :         return hh->hh_output(skb);
     319             : }
     320             : 
     321             : static inline struct neighbour *
     322             : __neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat)
     323             : {
     324             :         struct neighbour *n = neigh_lookup(tbl, pkey, dev);
     325             : 
     326             :         if (n || !creat)
     327             :                 return n;
     328             : 
     329             :         n = neigh_create(tbl, pkey, dev);
     330             :         return IS_ERR(n) ? NULL : n;
     331             : }
     332             : 
     333             : static inline struct neighbour *
     334             : __neigh_lookup_errno(struct neigh_table *tbl, const void *pkey,
     335             :   struct net_device *dev)
     336             : {
     337             :         struct neighbour *n = neigh_lookup(tbl, pkey, dev);
     338             : 
     339             :         if (n)
     340             :                 return n;
     341             : 
     342             :         return neigh_create(tbl, pkey, dev);
     343             : }
     344             : 
     345             : struct neighbour_cb {
     346             :         unsigned long sched_next;
     347             :         unsigned int flags;
     348             : };
     349           3 : 
     350             : #define LOCALLY_ENQUEUED 0x1
     351             : 
     352             : #define NEIGH_CB(skb)   ((struct neighbour_cb *)(skb)->cb)
     353             : 
     354             : #endif

Generated by: LCOV version 1.10