LCOV - code coverage report
Current view: top level - include/net - neighbour.h (source / functions) Hit Total Coverage
Test: landlock.info Lines: 66 101 65.3 %
Date: 2021-04-22 12:43:58 Functions: 8 11 72.7 %

          Line data    Source code
       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef _NET_NEIGHBOUR_H
       3             : #define _NET_NEIGHBOUR_H
       4             : 
       5             : #include <linux/neighbour.h>
       6             : 
       7             : /*
       8             :  *      Generic neighbour manipulation
       9             :  *
      10             :  *      Authors:
      11             :  *      Pedro Roque             <roque@di.fc.ul.pt>
      12             :  *      Alexey Kuznetsov        <kuznet@ms2.inr.ac.ru>
      13             :  *
      14             :  *      Changes:
      15             :  *
      16             :  *      Harald Welte:           <laforge@gnumonks.org>
      17             :  *              - Add neighbour cache statistics like rtstat
      18             :  */
      19             : 
      20             : #include <linux/atomic.h>
      21             : #include <linux/refcount.h>
      22             : #include <linux/netdevice.h>
      23             : #include <linux/skbuff.h>
      24             : #include <linux/rcupdate.h>
      25             : #include <linux/seq_file.h>
      26             : #include <linux/bitmap.h>
      27             : 
      28             : #include <linux/err.h>
      29             : #include <linux/sysctl.h>
      30             : #include <linux/workqueue.h>
      31             : #include <net/rtnetlink.h>
      32             : 
      33             : /*
      34             :  * NUD stands for "neighbor unreachability detection"
      35             :  */
      36             : 
      37             : #define NUD_IN_TIMER    (NUD_INCOMPLETE|NUD_REACHABLE|NUD_DELAY|NUD_PROBE)
      38             : #define NUD_VALID       (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE|NUD_PROBE|NUD_STALE|NUD_DELAY)
      39             : #define NUD_CONNECTED   (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE)
      40             : 
      41             : struct neighbour;
      42             : 
      43             : enum {
      44             :         NEIGH_VAR_MCAST_PROBES,
      45             :         NEIGH_VAR_UCAST_PROBES,
      46             :         NEIGH_VAR_APP_PROBES,
      47             :         NEIGH_VAR_MCAST_REPROBES,
      48             :         NEIGH_VAR_RETRANS_TIME,
      49             :         NEIGH_VAR_BASE_REACHABLE_TIME,
      50             :         NEIGH_VAR_DELAY_PROBE_TIME,
      51             :         NEIGH_VAR_GC_STALETIME,
      52             :         NEIGH_VAR_QUEUE_LEN_BYTES,
      53             :         NEIGH_VAR_PROXY_QLEN,
      54             :         NEIGH_VAR_ANYCAST_DELAY,
      55             :         NEIGH_VAR_PROXY_DELAY,
      56             :         NEIGH_VAR_LOCKTIME,
      57             : #define NEIGH_VAR_DATA_MAX (NEIGH_VAR_LOCKTIME + 1)
      58             :         /* Following are used as a second way to access one of the above */
      59             :         NEIGH_VAR_QUEUE_LEN, /* same data as NEIGH_VAR_QUEUE_LEN_BYTES */
      60             :         NEIGH_VAR_RETRANS_TIME_MS, /* same data as NEIGH_VAR_RETRANS_TIME */
      61             :         NEIGH_VAR_BASE_REACHABLE_TIME_MS, /* same data as NEIGH_VAR_BASE_REACHABLE_TIME */
      62             :         /* Following are used by "default" only */
      63             :         NEIGH_VAR_GC_INTERVAL,
      64             :         NEIGH_VAR_GC_THRESH1,
      65             :         NEIGH_VAR_GC_THRESH2,
      66             :         NEIGH_VAR_GC_THRESH3,
      67             :         NEIGH_VAR_MAX
      68             : };
      69             : 
      70             : struct neigh_parms {
      71             :         possible_net_t net;
      72             :         struct net_device *dev;
      73             :         struct list_head list;
      74             :         int     (*neigh_setup)(struct neighbour *);
      75             :         struct neigh_table *tbl;
      76             : 
      77             :         void    *sysctl_table;
      78             : 
      79             :         int dead;
      80             :         refcount_t refcnt;
      81             :         struct rcu_head rcu_head;
      82             : 
      83             :         int     reachable_time;
      84             :         int     data[NEIGH_VAR_DATA_MAX];
      85             :         DECLARE_BITMAP(data_state, NEIGH_VAR_DATA_MAX);
      86             : };
      87             : 
      88           0 : static inline void neigh_var_set(struct neigh_parms *p, int index, int val)
      89             : {
      90           0 :         set_bit(index, p->data_state);
      91           0 :         p->data[index] = val;
      92           0 : }
      93             : 
      94             : #define NEIGH_VAR(p, attr) ((p)->data[NEIGH_VAR_ ## attr])
      95             : 
      96             : /* In ndo_neigh_setup, NEIGH_VAR_INIT should be used.
      97             :  * In other cases, NEIGH_VAR_SET should be used.
      98             :  */
      99             : #define NEIGH_VAR_INIT(p, attr, val) (NEIGH_VAR(p, attr) = val)
     100             : #define NEIGH_VAR_SET(p, attr, val) neigh_var_set(p, NEIGH_VAR_ ## attr, val)
     101             : 
     102           3 : static inline void neigh_parms_data_state_setall(struct neigh_parms *p)
     103             : {
     104           3 :         bitmap_fill(p->data_state, NEIGH_VAR_DATA_MAX);
     105             : }
     106             : 
     107           2 : static inline void neigh_parms_data_state_cleanall(struct neigh_parms *p)
     108             : {
     109           2 :         bitmap_zero(p->data_state, NEIGH_VAR_DATA_MAX);
     110           2 : }
     111             : 
     112             : struct neigh_statistics {
     113             :         unsigned long allocs;           /* number of allocated neighs */
     114             :         unsigned long destroys;         /* number of destroyed neighs */
     115             :         unsigned long hash_grows;       /* number of hash resizes */
     116             : 
     117             :         unsigned long res_failed;       /* number of failed resolutions */
     118             : 
     119             :         unsigned long lookups;          /* number of lookups */
     120             :         unsigned long hits;             /* number of hits (among lookups) */
     121             : 
     122             :         unsigned long rcv_probes_mcast; /* number of received mcast ipv6 */
     123             :         unsigned long rcv_probes_ucast; /* number of received ucast ipv6 */
     124             : 
     125             :         unsigned long periodic_gc_runs; /* number of periodic GC runs */
     126             :         unsigned long forced_gc_runs;   /* number of forced GC runs */
     127             : 
     128             :         unsigned long unres_discards;   /* number of unresolved drops */
     129             :         unsigned long table_fulls;      /* times even gc couldn't help */
     130             : };
     131             : 
     132             : #define NEIGH_CACHE_STAT_INC(tbl, field) this_cpu_inc((tbl)->stats->field)
     133             : 
     134             : struct neighbour {
     135             :         struct neighbour __rcu  *next;
     136             :         struct neigh_table      *tbl;
     137             :         struct neigh_parms      *parms;
     138             :         unsigned long           confirmed;
     139             :         unsigned long           updated;
     140             :         rwlock_t                lock;
     141             :         refcount_t              refcnt;
     142             :         unsigned int            arp_queue_len_bytes;
     143             :         struct sk_buff_head     arp_queue;
     144             :         struct timer_list       timer;
     145             :         unsigned long           used;
     146             :         atomic_t                probes;
     147             :         __u8                    flags;
     148             :         __u8                    nud_state;
     149             :         __u8                    type;
     150             :         __u8                    dead;
     151             :         u8                      protocol;
     152             :         seqlock_t               ha_lock;
     153             :         unsigned char           ha[ALIGN(MAX_ADDR_LEN, sizeof(unsigned long))] __aligned(8);
     154             :         struct hh_cache         hh;
     155             :         int                     (*output)(struct neighbour *, struct sk_buff *);
     156             :         const struct neigh_ops  *ops;
     157             :         struct list_head        gc_list;
     158             :         struct rcu_head         rcu;
     159             :         struct net_device       *dev;
     160             :         u8                      primary_key[0];
     161             : } __randomize_layout;
     162             : 
     163             : struct neigh_ops {
     164             :         int                     family;
     165             :         void                    (*solicit)(struct neighbour *, struct sk_buff *);
     166             :         void                    (*error_report)(struct neighbour *, struct sk_buff *);
     167             :         int                     (*output)(struct neighbour *, struct sk_buff *);
     168             :         int                     (*connected_output)(struct neighbour *, struct sk_buff *);
     169             : };
     170             : 
     171             : struct pneigh_entry {
     172             :         struct pneigh_entry     *next;
     173             :         possible_net_t          net;
     174             :         struct net_device       *dev;
     175             :         u8                      flags;
     176             :         u8                      protocol;
     177             :         u8                      key[];
     178             : };
     179             : 
     180             : /*
     181             :  *      neighbour table manipulation
     182             :  */
     183             : 
     184             : #define NEIGH_NUM_HASH_RND      4
     185             : 
     186             : struct neigh_hash_table {
     187             :         struct neighbour __rcu  **hash_buckets;
     188             :         unsigned int            hash_shift;
     189             :         __u32                   hash_rnd[NEIGH_NUM_HASH_RND];
     190             :         struct rcu_head         rcu;
     191             : };
     192             : 
     193             : 
     194             : struct neigh_table {
     195             :         int                     family;
     196             :         unsigned int            entry_size;
     197             :         unsigned int            key_len;
     198             :         __be16                  protocol;
     199             :         __u32                   (*hash)(const void *pkey,
     200             :                                         const struct net_device *dev,
     201             :                                         __u32 *hash_rnd);
     202             :         bool                    (*key_eq)(const struct neighbour *, const void *pkey);
     203             :         int                     (*constructor)(struct neighbour *);
     204             :         int                     (*pconstructor)(struct pneigh_entry *);
     205             :         void                    (*pdestructor)(struct pneigh_entry *);
     206             :         void                    (*proxy_redo)(struct sk_buff *skb);
     207             :         int                     (*is_multicast)(const void *pkey);
     208             :         bool                    (*allow_add)(const struct net_device *dev,
     209             :                                              struct netlink_ext_ack *extack);
     210             :         char                    *id;
     211             :         struct neigh_parms      parms;
     212             :         struct list_head        parms_list;
     213             :         int                     gc_interval;
     214             :         int                     gc_thresh1;
     215             :         int                     gc_thresh2;
     216             :         int                     gc_thresh3;
     217             :         unsigned long           last_flush;
     218             :         struct delayed_work     gc_work;
     219             :         struct timer_list       proxy_timer;
     220             :         struct sk_buff_head     proxy_queue;
     221             :         atomic_t                entries;
     222             :         atomic_t                gc_entries;
     223             :         struct list_head        gc_list;
     224             :         rwlock_t                lock;
     225             :         unsigned long           last_rand;
     226             :         struct neigh_statistics __percpu *stats;
     227             :         struct neigh_hash_table __rcu *nht;
     228             :         struct pneigh_entry     **phash_buckets;
     229             : };
     230             : 
     231             : enum {
     232             :         NEIGH_ARP_TABLE = 0,
     233             :         NEIGH_ND_TABLE = 1,
     234             :         NEIGH_DN_TABLE = 2,
     235             :         NEIGH_NR_TABLES,
     236             :         NEIGH_LINK_TABLE = NEIGH_NR_TABLES /* Pseudo table for neigh_xmit */
     237             : };
     238             : 
     239           3 : static inline int neigh_parms_family(struct neigh_parms *p)
     240             : {
     241           3 :         return p->tbl->family;
     242             : }
     243             : 
     244             : #define NEIGH_PRIV_ALIGN        sizeof(long long)
     245             : #define NEIGH_ENTRY_SIZE(size)  ALIGN((size), NEIGH_PRIV_ALIGN)
     246             : 
     247             : static inline void *neighbour_priv(const struct neighbour *n)
     248             : {
     249             :         return (char *)n + n->tbl->entry_size;
     250             : }
     251             : 
     252             : /* flags for neigh_update() */
     253             : #define NEIGH_UPDATE_F_OVERRIDE                 0x00000001
     254             : #define NEIGH_UPDATE_F_WEAK_OVERRIDE            0x00000002
     255             : #define NEIGH_UPDATE_F_OVERRIDE_ISROUTER        0x00000004
     256             : #define NEIGH_UPDATE_F_EXT_LEARNED              0x20000000
     257             : #define NEIGH_UPDATE_F_ISROUTER                 0x40000000
     258             : #define NEIGH_UPDATE_F_ADMIN                    0x80000000
     259             : 
     260             : extern const struct nla_policy nda_policy[];
     261             : 
     262             : static inline bool neigh_key_eq16(const struct neighbour *n, const void *pkey)
     263             : {
     264             :         return *(const u16 *)n->primary_key == *(const u16 *)pkey;
     265             : }
     266             : 
     267         448 : static inline bool neigh_key_eq32(const struct neighbour *n, const void *pkey)
     268             : {
     269         448 :         return *(const u32 *)n->primary_key == *(const u32 *)pkey;
     270             : }
     271             : 
     272           0 : static inline bool neigh_key_eq128(const struct neighbour *n, const void *pkey)
     273             : {
     274           0 :         const u32 *n32 = (const u32 *)n->primary_key;
     275           0 :         const u32 *p32 = pkey;
     276             : 
     277           0 :         return ((n32[0] ^ p32[0]) | (n32[1] ^ p32[1]) |
     278           0 :                 (n32[2] ^ p32[2]) | (n32[3] ^ p32[3])) == 0;
     279             : }
     280             : 
     281         449 : static inline struct neighbour *___neigh_lookup_noref(
     282             :         struct neigh_table *tbl,
     283             :         bool (*key_eq)(const struct neighbour *n, const void *pkey),
     284             :         __u32 (*hash)(const void *pkey,
     285             :                       const struct net_device *dev,
     286             :                       __u32 *hash_rnd),
     287             :         const void *pkey,
     288             :         struct net_device *dev)
     289             : {
     290         449 :         struct neigh_hash_table *nht = rcu_dereference_bh(tbl->nht);
     291         449 :         struct neighbour *n;
     292         449 :         u32 hash_val;
     293             : 
     294         449 :         hash_val = hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
     295         449 :         for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
     296         449 :              n != NULL;
     297           0 :              n = rcu_dereference_bh(n->next)) {
     298         447 :                 if (n->dev == dev && key_eq(n, pkey))
     299         447 :                         return n;
     300             :         }
     301             : 
     302             :         return NULL;
     303             : }
     304             : 
     305           3 : static inline struct neighbour *__neigh_lookup_noref(struct neigh_table *tbl,
     306             :                                                      const void *pkey,
     307             :                                                      struct net_device *dev)
     308             : {
     309           3 :         return ___neigh_lookup_noref(tbl, tbl->key_eq, tbl->hash, pkey, dev);
     310             : }
     311             : 
     312             : void neigh_table_init(int index, struct neigh_table *tbl);
     313             : int neigh_table_clear(int index, struct neigh_table *tbl);
     314             : struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
     315             :                                struct net_device *dev);
     316             : struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
     317             :                                      const void *pkey);
     318             : struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey,
     319             :                                  struct net_device *dev, bool want_ref);
     320           0 : static inline struct neighbour *neigh_create(struct neigh_table *tbl,
     321             :                                              const void *pkey,
     322             :                                              struct net_device *dev)
     323             : {
     324           0 :         return __neigh_create(tbl, pkey, dev, true);
     325             : }
     326             : void neigh_destroy(struct neighbour *neigh);
     327             : int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb);
     328             : int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, u32 flags,
     329             :                  u32 nlmsg_pid);
     330             : void __neigh_set_probe_once(struct neighbour *neigh);
     331             : bool neigh_remove_one(struct neighbour *ndel, struct neigh_table *tbl);
     332             : void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
     333             : int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
     334             : int neigh_carrier_down(struct neigh_table *tbl, struct net_device *dev);
     335             : int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb);
     336             : int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb);
     337             : int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb);
     338             : struct neighbour *neigh_event_ns(struct neigh_table *tbl,
     339             :                                                 u8 *lladdr, void *saddr,
     340             :                                                 struct net_device *dev);
     341             : 
     342             : struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
     343             :                                       struct neigh_table *tbl);
     344             : void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms);
     345             : 
     346             : static inline
     347           6 : struct net *neigh_parms_net(const struct neigh_parms *parms)
     348             : {
     349           6 :         return read_pnet(&parms->net);
     350             : }
     351             : 
     352             : unsigned long neigh_rand_reach_time(unsigned long base);
     353             : 
     354             : void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
     355             :                     struct sk_buff *skb);
     356             : struct pneigh_entry *pneigh_lookup(struct neigh_table *tbl, struct net *net,
     357             :                                    const void *key, struct net_device *dev,
     358             :                                    int creat);
     359             : struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl, struct net *net,
     360             :                                      const void *key, struct net_device *dev);
     361             : int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *key,
     362             :                   struct net_device *dev);
     363             : 
     364           0 : static inline struct net *pneigh_net(const struct pneigh_entry *pneigh)
     365             : {
     366           0 :         return read_pnet(&pneigh->net);
     367             : }
     368             : 
     369             : void neigh_app_ns(struct neighbour *n);
     370             : void neigh_for_each(struct neigh_table *tbl,
     371             :                     void (*cb)(struct neighbour *, void *), void *cookie);
     372             : void __neigh_for_each_release(struct neigh_table *tbl,
     373             :                               int (*cb)(struct neighbour *));
     374             : int neigh_xmit(int fam, struct net_device *, const void *, struct sk_buff *);
     375             : void pneigh_for_each(struct neigh_table *tbl,
     376             :                      void (*cb)(struct pneigh_entry *));
     377             : 
     378             : struct neigh_seq_state {
     379             :         struct seq_net_private p;
     380             :         struct neigh_table *tbl;
     381             :         struct neigh_hash_table *nht;
     382             :         void *(*neigh_sub_iter)(struct neigh_seq_state *state,
     383             :                                 struct neighbour *n, loff_t *pos);
     384             :         unsigned int bucket;
     385             :         unsigned int flags;
     386             : #define NEIGH_SEQ_NEIGH_ONLY    0x00000001
     387             : #define NEIGH_SEQ_IS_PNEIGH     0x00000002
     388             : #define NEIGH_SEQ_SKIP_NOARP    0x00000004
     389             : };
     390             : void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *,
     391             :                       unsigned int);
     392             : void *neigh_seq_next(struct seq_file *, void *, loff_t *);
     393             : void neigh_seq_stop(struct seq_file *, void *);
     394             : 
     395             : int neigh_proc_dointvec(struct ctl_table *ctl, int write,
     396             :                         void *buffer, size_t *lenp, loff_t *ppos);
     397             : int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write,
     398             :                                 void *buffer,
     399             :                                 size_t *lenp, loff_t *ppos);
     400             : int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write,
     401             :                                    void *buffer, size_t *lenp, loff_t *ppos);
     402             : 
     403             : int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
     404             :                           proc_handler *proc_handler);
     405             : void neigh_sysctl_unregister(struct neigh_parms *p);
     406             : 
     407           2 : static inline void __neigh_parms_put(struct neigh_parms *parms)
     408             : {
     409           2 :         refcount_dec(&parms->refcnt);
     410             : }
     411             : 
     412           4 : static inline struct neigh_parms *neigh_parms_clone(struct neigh_parms *parms)
     413             : {
     414           4 :         refcount_inc(&parms->refcnt);
     415           4 :         return parms;
     416             : }
     417             : 
     418             : /*
     419             :  *      Neighbour references
     420             :  */
     421             : 
     422          14 : static inline void neigh_release(struct neighbour *neigh)
     423             : {
     424          14 :         if (refcount_dec_and_test(&neigh->refcnt))
     425           0 :                 neigh_destroy(neigh);
     426          14 : }
     427             : 
     428             : static inline struct neighbour * neigh_clone(struct neighbour *neigh)
     429             : {
     430             :         if (neigh)
     431             :                 refcount_inc(&neigh->refcnt);
     432             :         return neigh;
     433             : }
     434             : 
     435             : #define neigh_hold(n)   refcount_inc(&(n)->refcnt)
     436             : 
     437           8 : static inline int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
     438             : {
     439           8 :         unsigned long now = jiffies;
     440             :         
     441           8 :         if (READ_ONCE(neigh->used) != now)
     442           5 :                 WRITE_ONCE(neigh->used, now);
     443           8 :         if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE)))
     444           4 :                 return __neigh_event_send(neigh, skb);
     445             :         return 0;
     446             : }
     447             : 
     448             : #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
     449             : static inline int neigh_hh_bridge(struct hh_cache *hh, struct sk_buff *skb)
     450             : {
     451             :         unsigned int seq, hh_alen;
     452             : 
     453             :         do {
     454             :                 seq = read_seqbegin(&hh->hh_lock);
     455             :                 hh_alen = HH_DATA_ALIGN(ETH_HLEN);
     456             :                 memcpy(skb->data - hh_alen, hh->hh_data, ETH_ALEN + hh_alen - ETH_HLEN);
     457             :         } while (read_seqretry(&hh->hh_lock, seq));
     458             :         return 0;
     459             : }
     460             : #endif
     461             : 
     462         437 : static inline int neigh_hh_output(const struct hh_cache *hh, struct sk_buff *skb)
     463             : {
     464         437 :         unsigned int hh_alen = 0;
     465         437 :         unsigned int seq;
     466         437 :         unsigned int hh_len;
     467             : 
     468         437 :         do {
     469         437 :                 seq = read_seqbegin(&hh->hh_lock);
     470         437 :                 hh_len = READ_ONCE(hh->hh_len);
     471         437 :                 if (likely(hh_len <= HH_DATA_MOD)) {
     472         437 :                         hh_alen = HH_DATA_MOD;
     473             : 
     474             :                         /* skb_push() would proceed silently if we have room for
     475             :                          * the unaligned size but not for the aligned size:
     476             :                          * check headroom explicitly.
     477             :                          */
     478         437 :                         if (likely(skb_headroom(skb) >= HH_DATA_MOD)) {
     479             :                                 /* this is inlined by gcc */
     480         437 :                                 memcpy(skb->data - HH_DATA_MOD, hh->hh_data,
     481             :                                        HH_DATA_MOD);
     482             :                         }
     483             :                 } else {
     484           0 :                         hh_alen = HH_DATA_ALIGN(hh_len);
     485             : 
     486           0 :                         if (likely(skb_headroom(skb) >= hh_alen)) {
     487           0 :                                 memcpy(skb->data - hh_alen, hh->hh_data,
     488             :                                        hh_alen);
     489             :                         }
     490             :                 }
     491         437 :         } while (read_seqretry(&hh->hh_lock, seq));
     492             : 
     493         437 :         if (WARN_ON_ONCE(skb_headroom(skb) < hh_alen)) {
     494           0 :                 kfree_skb(skb);
     495           0 :                 return NET_XMIT_DROP;
     496             :         }
     497             : 
     498         437 :         __skb_push(skb, hh_len);
     499         437 :         return dev_queue_xmit(skb);
     500             : }
     501             : 
     502         444 : static inline int neigh_output(struct neighbour *n, struct sk_buff *skb,
     503             :                                bool skip_cache)
     504             : {
     505         444 :         const struct hh_cache *hh = &n->hh;
     506             : 
     507         444 :         if ((n->nud_state & NUD_CONNECTED) && hh->hh_len && !skip_cache)
     508         437 :                 return neigh_hh_output(hh, skb);
     509             :         else
     510           7 :                 return n->output(n, skb);
     511             : }
     512             : 
     513             : static inline struct neighbour *
     514           4 : __neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat)
     515             : {
     516           4 :         struct neighbour *n = neigh_lookup(tbl, pkey, dev);
     517             : 
     518           4 :         if (n || !creat)
     519             :                 return n;
     520             : 
     521           0 :         n = neigh_create(tbl, pkey, dev);
     522           0 :         return IS_ERR(n) ? NULL : n;
     523             : }
     524             : 
     525             : static inline struct neighbour *
     526           0 : __neigh_lookup_errno(struct neigh_table *tbl, const void *pkey,
     527             :   struct net_device *dev)
     528             : {
     529           0 :         struct neighbour *n = neigh_lookup(tbl, pkey, dev);
     530             : 
     531           0 :         if (n)
     532             :                 return n;
     533             : 
     534           0 :         return neigh_create(tbl, pkey, dev);
     535             : }
     536             : 
     537             : struct neighbour_cb {
     538             :         unsigned long sched_next;
     539             :         unsigned int flags;
     540             : };
     541             : 
     542             : #define LOCALLY_ENQUEUED 0x1
     543             : 
     544             : #define NEIGH_CB(skb)   ((struct neighbour_cb *)(skb)->cb)
     545             : 
     546           9 : static inline void neigh_ha_snapshot(char *dst, const struct neighbour *n,
     547             :                                      const struct net_device *dev)
     548             : {
     549           9 :         unsigned int seq;
     550             : 
     551           9 :         do {
     552           9 :                 seq = read_seqbegin(&n->ha_lock);
     553           9 :                 memcpy(dst, n->ha, dev->addr_len);
     554           9 :         } while (read_seqretry(&n->ha_lock, seq));
     555           9 : }
     556             : 
     557           0 : static inline void neigh_update_is_router(struct neighbour *neigh, u32 flags,
     558             :                                           int *notify)
     559             : {
     560           0 :         u8 ndm_flags = 0;
     561             : 
     562           0 :         ndm_flags |= (flags & NEIGH_UPDATE_F_ISROUTER) ? NTF_ROUTER : 0;
     563           0 :         if ((neigh->flags ^ ndm_flags) & NTF_ROUTER) {
     564           0 :                 if (ndm_flags & NTF_ROUTER)
     565           0 :                         neigh->flags |= NTF_ROUTER;
     566             :                 else
     567           0 :                         neigh->flags &= ~NTF_ROUTER;
     568           0 :                 *notify = 1;
     569             :         }
     570           0 : }
     571             : #endif

Generated by: LCOV version 1.14