LCOV - code coverage report
Current view: top level - include/net - neighbour.h (source / functions) Hit Total Coverage
Test: Real Lines: 52 64 81.2 %
Date: 2020-10-17 15:46:16 Functions: 1 10 10.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     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                 :            : 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                 :            : }
      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                 :            : 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                 :            : static inline void neigh_parms_data_state_cleanall(struct neigh_parms *p)
     108                 :            : {
     109                 :          3 :         bitmap_zero(p->data_state, NEIGH_VAR_DATA_MAX);
     110                 :            : }
     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[0];
     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                 :            :         bool                    (*allow_add)(const struct net_device *dev,
     208                 :            :                                              struct netlink_ext_ack *extack);
     209                 :            :         char                    *id;
     210                 :            :         struct neigh_parms      parms;
     211                 :            :         struct list_head        parms_list;
     212                 :            :         int                     gc_interval;
     213                 :            :         int                     gc_thresh1;
     214                 :            :         int                     gc_thresh2;
     215                 :            :         int                     gc_thresh3;
     216                 :            :         unsigned long           last_flush;
     217                 :            :         struct delayed_work     gc_work;
     218                 :            :         struct timer_list       proxy_timer;
     219                 :            :         struct sk_buff_head     proxy_queue;
     220                 :            :         atomic_t                entries;
     221                 :            :         atomic_t                gc_entries;
     222                 :            :         struct list_head        gc_list;
     223                 :            :         rwlock_t                lock;
     224                 :            :         unsigned long           last_rand;
     225                 :            :         struct neigh_statistics __percpu *stats;
     226                 :            :         struct neigh_hash_table __rcu *nht;
     227                 :            :         struct pneigh_entry     **phash_buckets;
     228                 :            : };
     229                 :            : 
     230                 :            : enum {
     231                 :            :         NEIGH_ARP_TABLE = 0,
     232                 :            :         NEIGH_ND_TABLE = 1,
     233                 :            :         NEIGH_DN_TABLE = 2,
     234                 :            :         NEIGH_NR_TABLES,
     235                 :            :         NEIGH_LINK_TABLE = NEIGH_NR_TABLES /* Pseudo table for neigh_xmit */
     236                 :            : };
     237                 :            : 
     238                 :            : static inline int neigh_parms_family(struct neigh_parms *p)
     239                 :            : {
     240                 :          3 :         return p->tbl->family;
     241                 :            : }
     242                 :            : 
     243                 :            : #define NEIGH_PRIV_ALIGN        sizeof(long long)
     244                 :            : #define NEIGH_ENTRY_SIZE(size)  ALIGN((size), NEIGH_PRIV_ALIGN)
     245                 :            : 
     246                 :            : static inline void *neighbour_priv(const struct neighbour *n)
     247                 :            : {
     248                 :            :         return (char *)n + n->tbl->entry_size;
     249                 :            : }
     250                 :            : 
     251                 :            : /* flags for neigh_update() */
     252                 :            : #define NEIGH_UPDATE_F_OVERRIDE                 0x00000001
     253                 :            : #define NEIGH_UPDATE_F_WEAK_OVERRIDE            0x00000002
     254                 :            : #define NEIGH_UPDATE_F_OVERRIDE_ISROUTER        0x00000004
     255                 :            : #define NEIGH_UPDATE_F_EXT_LEARNED              0x20000000
     256                 :            : #define NEIGH_UPDATE_F_ISROUTER                 0x40000000
     257                 :            : #define NEIGH_UPDATE_F_ADMIN                    0x80000000
     258                 :            : 
     259                 :            : extern const struct nla_policy nda_policy[];
     260                 :            : 
     261                 :            : static inline bool neigh_key_eq16(const struct neighbour *n, const void *pkey)
     262                 :            : {
     263                 :            :         return *(const u16 *)n->primary_key == *(const u16 *)pkey;
     264                 :            : }
     265                 :            : 
     266                 :          3 : static inline bool neigh_key_eq32(const struct neighbour *n, const void *pkey)
     267                 :            : {
     268                 :          3 :         return *(const u32 *)n->primary_key == *(const u32 *)pkey;
     269                 :            : }
     270                 :            : 
     271                 :          3 : static inline bool neigh_key_eq128(const struct neighbour *n, const void *pkey)
     272                 :            : {
     273                 :            :         const u32 *n32 = (const u32 *)n->primary_key;
     274                 :            :         const u32 *p32 = pkey;
     275                 :            : 
     276                 :          3 :         return ((n32[0] ^ p32[0]) | (n32[1] ^ p32[1]) |
     277                 :          3 :                 (n32[2] ^ p32[2]) | (n32[3] ^ p32[3])) == 0;
     278                 :            : }
     279                 :            : 
     280                 :          3 : static inline struct neighbour *___neigh_lookup_noref(
     281                 :            :         struct neigh_table *tbl,
     282                 :            :         bool (*key_eq)(const struct neighbour *n, const void *pkey),
     283                 :            :         __u32 (*hash)(const void *pkey,
     284                 :            :                       const struct net_device *dev,
     285                 :            :                       __u32 *hash_rnd),
     286                 :            :         const void *pkey,
     287                 :            :         struct net_device *dev)
     288                 :            : {
     289                 :          3 :         struct neigh_hash_table *nht = rcu_dereference_bh(tbl->nht);
     290                 :            :         struct neighbour *n;
     291                 :            :         u32 hash_val;
     292                 :            : 
     293                 :          3 :         hash_val = hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
     294                 :          3 :         for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
     295                 :            :              n != NULL;
     296                 :          3 :              n = rcu_dereference_bh(n->next)) {
     297                 :          3 :                 if (n->dev == dev && key_eq(n, pkey))
     298                 :          3 :                         return n;
     299                 :            :         }
     300                 :            : 
     301                 :            :         return NULL;
     302                 :            : }
     303                 :            : 
     304                 :            : static inline struct neighbour *__neigh_lookup_noref(struct neigh_table *tbl,
     305                 :            :                                                      const void *pkey,
     306                 :            :                                                      struct net_device *dev)
     307                 :            : {
     308                 :          3 :         return ___neigh_lookup_noref(tbl, tbl->key_eq, tbl->hash, pkey, dev);
     309                 :            : }
     310                 :            : 
     311                 :            : void neigh_table_init(int index, struct neigh_table *tbl);
     312                 :            : int neigh_table_clear(int index, struct neigh_table *tbl);
     313                 :            : struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
     314                 :            :                                struct net_device *dev);
     315                 :            : struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
     316                 :            :                                      const void *pkey);
     317                 :            : struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey,
     318                 :            :                                  struct net_device *dev, bool want_ref);
     319                 :            : static inline struct neighbour *neigh_create(struct neigh_table *tbl,
     320                 :            :                                              const void *pkey,
     321                 :            :                                              struct net_device *dev)
     322                 :            : {
     323                 :          1 :         return __neigh_create(tbl, pkey, dev, true);
     324                 :            : }
     325                 :            : void neigh_destroy(struct neighbour *neigh);
     326                 :            : int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb);
     327                 :            : int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, u32 flags,
     328                 :            :                  u32 nlmsg_pid);
     329                 :            : void __neigh_set_probe_once(struct neighbour *neigh);
     330                 :            : bool neigh_remove_one(struct neighbour *ndel, struct neigh_table *tbl);
     331                 :            : void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
     332                 :            : int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
     333                 :            : int neigh_carrier_down(struct neigh_table *tbl, struct net_device *dev);
     334                 :            : int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb);
     335                 :            : int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb);
     336                 :            : int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb);
     337                 :            : struct neighbour *neigh_event_ns(struct neigh_table *tbl,
     338                 :            :                                                 u8 *lladdr, void *saddr,
     339                 :            :                                                 struct net_device *dev);
     340                 :            : 
     341                 :            : struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
     342                 :            :                                       struct neigh_table *tbl);
     343                 :            : void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms);
     344                 :            : 
     345                 :            : static inline
     346                 :            : struct net *neigh_parms_net(const struct neigh_parms *parms)
     347                 :            : {
     348                 :            :         return read_pnet(&parms->net);
     349                 :            : }
     350                 :            : 
     351                 :            : unsigned long neigh_rand_reach_time(unsigned long base);
     352                 :            : 
     353                 :            : void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
     354                 :            :                     struct sk_buff *skb);
     355                 :            : struct pneigh_entry *pneigh_lookup(struct neigh_table *tbl, struct net *net,
     356                 :            :                                    const void *key, struct net_device *dev,
     357                 :            :                                    int creat);
     358                 :            : struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl, struct net *net,
     359                 :            :                                      const void *key, struct net_device *dev);
     360                 :            : int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *key,
     361                 :            :                   struct net_device *dev);
     362                 :            : 
     363                 :            : static inline struct net *pneigh_net(const struct pneigh_entry *pneigh)
     364                 :            : {
     365                 :            :         return read_pnet(&pneigh->net);
     366                 :            : }
     367                 :            : 
     368                 :            : void neigh_app_ns(struct neighbour *n);
     369                 :            : void neigh_for_each(struct neigh_table *tbl,
     370                 :            :                     void (*cb)(struct neighbour *, void *), void *cookie);
     371                 :            : void __neigh_for_each_release(struct neigh_table *tbl,
     372                 :            :                               int (*cb)(struct neighbour *));
     373                 :            : int neigh_xmit(int fam, struct net_device *, const void *, struct sk_buff *);
     374                 :            : void pneigh_for_each(struct neigh_table *tbl,
     375                 :            :                      void (*cb)(struct pneigh_entry *));
     376                 :            : 
     377                 :            : struct neigh_seq_state {
     378                 :            :         struct seq_net_private p;
     379                 :            :         struct neigh_table *tbl;
     380                 :            :         struct neigh_hash_table *nht;
     381                 :            :         void *(*neigh_sub_iter)(struct neigh_seq_state *state,
     382                 :            :                                 struct neighbour *n, loff_t *pos);
     383                 :            :         unsigned int bucket;
     384                 :            :         unsigned int flags;
     385                 :            : #define NEIGH_SEQ_NEIGH_ONLY    0x00000001
     386                 :            : #define NEIGH_SEQ_IS_PNEIGH     0x00000002
     387                 :            : #define NEIGH_SEQ_SKIP_NOARP    0x00000004
     388                 :            : };
     389                 :            : void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *,
     390                 :            :                       unsigned int);
     391                 :            : void *neigh_seq_next(struct seq_file *, void *, loff_t *);
     392                 :            : void neigh_seq_stop(struct seq_file *, void *);
     393                 :            : 
     394                 :            : int neigh_proc_dointvec(struct ctl_table *ctl, int write,
     395                 :            :                         void __user *buffer, size_t *lenp, loff_t *ppos);
     396                 :            : int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write,
     397                 :            :                                 void __user *buffer,
     398                 :            :                                 size_t *lenp, loff_t *ppos);
     399                 :            : int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write,
     400                 :            :                                    void __user *buffer,
     401                 :            :                                    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                 :            : static inline void __neigh_parms_put(struct neigh_parms *parms)
     408                 :            : {
     409                 :          3 :         refcount_dec(&parms->refcnt);
     410                 :            : }
     411                 :            : 
     412                 :            : static inline struct neigh_parms *neigh_parms_clone(struct neigh_parms *parms)
     413                 :            : {
     414                 :          3 :         refcount_inc(&parms->refcnt);
     415                 :            :         return parms;
     416                 :            : }
     417                 :            : 
     418                 :            : /*
     419                 :            :  *      Neighbour references
     420                 :            :  */
     421                 :            : 
     422                 :          3 : static inline void neigh_release(struct neighbour *neigh)
     423                 :            : {
     424                 :          3 :         if (refcount_dec_and_test(&neigh->refcnt))
     425                 :          2 :                 neigh_destroy(neigh);
     426                 :          3 : }
     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                 :          3 : static inline int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
     438                 :            : {
     439                 :          3 :         unsigned long now = jiffies;
     440                 :            :         
     441                 :          3 :         if (READ_ONCE(neigh->used) != now)
     442                 :            :                 WRITE_ONCE(neigh->used, now);
     443                 :          3 :         if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE)))
     444                 :          3 :                 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                 :          3 : static inline int neigh_hh_output(const struct hh_cache *hh, struct sk_buff *skb)
     463                 :            : {
     464                 :            :         unsigned int hh_alen = 0;
     465                 :            :         unsigned int seq;
     466                 :            :         unsigned int hh_len;
     467                 :            : 
     468                 :            :         do {
     469                 :            :                 seq = read_seqbegin(&hh->hh_lock);
     470                 :            :                 hh_len = READ_ONCE(hh->hh_len);
     471                 :          3 :                 if (likely(hh_len <= HH_DATA_MOD)) {
     472                 :            :                         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                 :          3 :                         if (likely(skb_headroom(skb) >= HH_DATA_MOD)) {
     479                 :            :                                 /* this is inlined by gcc */
     480                 :          3 :                                 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                 :          3 :         } while (read_seqretry(&hh->hh_lock, seq));
     492                 :            : 
     493                 :          3 :         if (WARN_ON_ONCE(skb_headroom(skb) < hh_alen)) {
     494                 :          0 :                 kfree_skb(skb);
     495                 :          0 :                 return NET_XMIT_DROP;
     496                 :            :         }
     497                 :            : 
     498                 :            :         __skb_push(skb, hh_len);
     499                 :          3 :         return dev_queue_xmit(skb);
     500                 :            : }
     501                 :            : 
     502                 :          3 : static inline int neigh_output(struct neighbour *n, struct sk_buff *skb,
     503                 :            :                                bool skip_cache)
     504                 :            : {
     505                 :          3 :         const struct hh_cache *hh = &n->hh;
     506                 :            : 
     507                 :          3 :         if ((n->nud_state & NUD_CONNECTED) && hh->hh_len && !skip_cache)
     508                 :          3 :                 return neigh_hh_output(hh, skb);
     509                 :            :         else
     510                 :          3 :                 return n->output(n, skb);
     511                 :            : }
     512                 :            : 
     513                 :            : static inline struct neighbour *
     514                 :          3 : __neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat)
     515                 :            : {
     516                 :          3 :         struct neighbour *n = neigh_lookup(tbl, pkey, dev);
     517                 :            : 
     518                 :          3 :         if (n || !creat)
     519                 :            :                 return n;
     520                 :            : 
     521                 :            :         n = neigh_create(tbl, pkey, dev);
     522                 :          3 :         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                 :          3 : static inline void neigh_ha_snapshot(char *dst, const struct neighbour *n,
     547                 :            :                                      const struct net_device *dev)
     548                 :            : {
     549                 :            :         unsigned int seq;
     550                 :            : 
     551                 :            :         do {
     552                 :            :                 seq = read_seqbegin(&n->ha_lock);
     553                 :          3 :                 memcpy(dst, n->ha, dev->addr_len);
     554                 :          3 :         } while (read_seqretry(&n->ha_lock, seq));
     555                 :          3 : }
     556                 :            : 
     557                 :            : static inline void neigh_update_is_router(struct neighbour *neigh, u32 flags,
     558                 :            :                                           int *notify)
     559                 :            : {
     560                 :            :         u8 ndm_flags = 0;
     561                 :            : 
     562                 :          1 :         ndm_flags |= (flags & NEIGH_UPDATE_F_ISROUTER) ? NTF_ROUTER : 0;
     563                 :          1 :         if ((neigh->flags ^ ndm_flags) & NTF_ROUTER) {
     564                 :          1 :                 if (ndm_flags & NTF_ROUTER)
     565                 :          1 :                         neigh->flags |= NTF_ROUTER;
     566                 :            :                 else
     567                 :          0 :                         neigh->flags &= ~NTF_ROUTER;
     568                 :            :                 *notify = 1;
     569                 :            :         }
     570                 :            : }
     571                 :            : #endif
    

Generated by: LCOV version 1.14