blob: eb070b3674a1ba346c2c779889a90b636a8d3d7a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _NET_NEIGHBOUR_H
2#define _NET_NEIGHBOUR_H
3
Thomas Graf9067c722006-08-07 17:57:44 -07004#include <linux/neighbour.h>
5
Linus Torvalds1da177e2005-04-16 15:20:36 -07006/*
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
Arun Sharma600634972011-07-26 16:09:06 -070019#include <linux/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/netdevice.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020021#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/rcupdate.h>
23#include <linux/seq_file.h>
Jiri Pirko1d4c8c22013-12-07 19:26:56 +010024#include <linux/bitmap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26#include <linux/err.h>
27#include <linux/sysctl.h>
Eric Dumazete4c4e442009-07-30 03:15:07 +000028#include <linux/workqueue.h>
Thomas Grafc8822a42007-03-22 11:50:06 -070029#include <net/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Pavel Emelyanov39971552008-01-10 22:37:16 -080031/*
32 * NUD stands for "neighbor unreachability detection"
33 */
34
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#define NUD_IN_TIMER (NUD_INCOMPLETE|NUD_REACHABLE|NUD_DELAY|NUD_PROBE)
36#define NUD_VALID (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE|NUD_PROBE|NUD_STALE|NUD_DELAY)
37#define NUD_CONNECTED (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE)
38
39struct neighbour;
40
Jiri Pirko1f9248e52013-12-07 19:26:53 +010041enum {
42 NEIGH_VAR_MCAST_PROBES,
43 NEIGH_VAR_UCAST_PROBES,
44 NEIGH_VAR_APP_PROBES,
45 NEIGH_VAR_RETRANS_TIME,
46 NEIGH_VAR_BASE_REACHABLE_TIME,
47 NEIGH_VAR_DELAY_PROBE_TIME,
48 NEIGH_VAR_GC_STALETIME,
49 NEIGH_VAR_QUEUE_LEN_BYTES,
50 NEIGH_VAR_PROXY_QLEN,
51 NEIGH_VAR_ANYCAST_DELAY,
52 NEIGH_VAR_PROXY_DELAY,
53 NEIGH_VAR_LOCKTIME,
54#define NEIGH_VAR_DATA_MAX (NEIGH_VAR_LOCKTIME + 1)
55 /* Following are used as a second way to access one of the above */
56 NEIGH_VAR_QUEUE_LEN, /* same data as NEIGH_VAR_QUEUE_LEN_BYTES */
57 NEIGH_VAR_RETRANS_TIME_MS, /* same data as NEIGH_VAR_RETRANS_TIME */
58 NEIGH_VAR_BASE_REACHABLE_TIME_MS, /* same data as NEIGH_VAR_BASE_REACHABLE_TIME */
59 /* Following are used by "default" only */
60 NEIGH_VAR_GC_INTERVAL,
61 NEIGH_VAR_GC_THRESH1,
62 NEIGH_VAR_GC_THRESH2,
63 NEIGH_VAR_GC_THRESH3,
64 NEIGH_VAR_MAX
65};
66
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +000067struct neigh_parms {
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +090068#ifdef CONFIG_NET_NS
Eric W. Biederman426b5302008-01-24 00:13:18 -080069 struct net *net;
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +090070#endif
Thomas Grafc7fb64d2005-06-18 22:50:55 -070071 struct net_device *dev;
Nicolas Dichtel75fbfd32014-10-29 19:29:31 +010072 struct list_head list;
David S. Miller447f2192011-12-19 15:04:41 -050073 int (*neigh_setup)(struct neighbour *);
Alexey Kuznetsovecbb4162007-03-24 12:52:16 -070074 void (*neigh_cleanup)(struct neighbour *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 struct neigh_table *tbl;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77 void *sysctl_table;
78
79 int dead;
80 atomic_t refcnt;
81 struct rcu_head rcu_head;
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 int reachable_time;
Jiri Pirko1f9248e52013-12-07 19:26:53 +010084 int data[NEIGH_VAR_DATA_MAX];
Jiri Pirko1d4c8c22013-12-07 19:26:56 +010085 DECLARE_BITMAP(data_state, NEIGH_VAR_DATA_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086};
87
Jiri Pirko1f9248e52013-12-07 19:26:53 +010088static inline void neigh_var_set(struct neigh_parms *p, int index, int val)
89{
Jiri Pirko1d4c8c22013-12-07 19:26:56 +010090 set_bit(index, p->data_state);
Jiri Pirko1f9248e52013-12-07 19:26:53 +010091 p->data[index] = val;
92}
93
94#define NEIGH_VAR(p, attr) ((p)->data[NEIGH_VAR_ ## attr])
Jiri Pirko89740ca2014-01-09 14:13:47 +010095
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)
Jiri Pirko1f9248e52013-12-07 19:26:53 +0100100#define NEIGH_VAR_SET(p, attr, val) neigh_var_set(p, NEIGH_VAR_ ## attr, val)
101
Jiri Pirko1d4c8c22013-12-07 19:26:56 +0100102static inline void neigh_parms_data_state_setall(struct neigh_parms *p)
103{
104 bitmap_fill(p->data_state, NEIGH_VAR_DATA_MAX);
105}
106
107static inline void neigh_parms_data_state_cleanall(struct neigh_parms *p)
108{
109 bitmap_zero(p->data_state, NEIGH_VAR_DATA_MAX);
110}
111
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +0000112struct neigh_statistics {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 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
Neil Horman9a6d2762008-07-16 20:50:49 -0700117 unsigned long res_failed; /* number of failed resolutions */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
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 */
Neil Horman9a6d2762008-07-16 20:50:49 -0700127
128 unsigned long unres_discards; /* number of unresolved drops */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129};
130
Christoph Lameter4ea73342009-10-03 19:48:22 +0900131#define NEIGH_CACHE_STAT_INC(tbl, field) this_cpu_inc((tbl)->stats->field)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +0000133struct neighbour {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700134 struct neighbour __rcu *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 struct neigh_table *tbl;
136 struct neigh_parms *parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 unsigned long confirmed;
138 unsigned long updated;
Eric Dumazet46b13fc2010-11-11 06:57:19 +0000139 rwlock_t lock;
Eric Dumazet367e5e32010-09-30 05:36:29 +0000140 atomic_t refcnt;
Eric Dumazete37ef962010-10-11 12:20:54 +0000141 struct sk_buff_head arp_queue;
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000142 unsigned int arp_queue_len_bytes;
Eric Dumazete37ef962010-10-11 12:20:54 +0000143 struct timer_list timer;
144 unsigned long used;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 atomic_t probes;
Eric Dumazet46b13fc2010-11-11 06:57:19 +0000146 __u8 flags;
147 __u8 nud_state;
148 __u8 type;
149 __u8 dead;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000150 seqlock_t ha_lock;
Stephen Hemmingerd9244242006-08-10 23:03:23 -0700151 unsigned char ha[ALIGN(MAX_ADDR_LEN, sizeof(unsigned long))];
David S. Millerf6b72b62011-07-14 07:53:20 -0700152 struct hh_cache hh;
David S. Miller8f40b162011-07-17 13:34:11 -0700153 int (*output)(struct neighbour *, struct sk_buff *);
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000154 const struct neigh_ops *ops;
Eric Dumazet767e97e2010-10-06 17:49:21 -0700155 struct rcu_head rcu;
Eric Dumazete37ef962010-10-11 12:20:54 +0000156 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 u8 primary_key[0];
158};
159
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +0000160struct neigh_ops {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 int family;
David S. Miller8f40b162011-07-17 13:34:11 -0700162 void (*solicit)(struct neighbour *, struct sk_buff *);
163 void (*error_report)(struct neighbour *, struct sk_buff *);
164 int (*output)(struct neighbour *, struct sk_buff *);
165 int (*connected_output)(struct neighbour *, struct sk_buff *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166};
167
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +0000168struct pneigh_entry {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 struct pneigh_entry *next;
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900170#ifdef CONFIG_NET_NS
Eric W. Biederman426b5302008-01-24 00:13:18 -0800171 struct net *net;
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900172#endif
Eric W. Biederman426b5302008-01-24 00:13:18 -0800173 struct net_device *dev;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700174 u8 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 u8 key[0];
176};
177
178/*
179 * neighbour table manipulation
180 */
181
David S. Miller2c2aba62011-12-28 15:06:58 -0500182#define NEIGH_NUM_HASH_RND 4
183
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000184struct neigh_hash_table {
Eric Dumazet767e97e2010-10-06 17:49:21 -0700185 struct neighbour __rcu **hash_buckets;
David S. Millercd089332011-07-11 01:28:12 -0700186 unsigned int hash_shift;
David S. Miller2c2aba62011-12-28 15:06:58 -0500187 __u32 hash_rnd[NEIGH_NUM_HASH_RND];
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000188 struct rcu_head rcu;
189};
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Eric Dumazetfd2c3ef2009-11-03 03:26:03 +0000192struct neigh_table {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 struct neigh_table *next;
194 int family;
195 int entry_size;
196 int key_len;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000197 __u32 (*hash)(const void *pkey,
198 const struct net_device *dev,
David S. Miller2c2aba62011-12-28 15:06:58 -0500199 __u32 *hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 int (*constructor)(struct neighbour *);
201 int (*pconstructor)(struct pneigh_entry *);
202 void (*pdestructor)(struct pneigh_entry *);
203 void (*proxy_redo)(struct sk_buff *skb);
204 char *id;
205 struct neigh_parms parms;
Nicolas Dichtel75fbfd32014-10-29 19:29:31 +0100206 struct list_head parms_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 int gc_interval;
208 int gc_thresh1;
209 int gc_thresh2;
210 int gc_thresh3;
211 unsigned long last_flush;
Eric Dumazete4c4e442009-07-30 03:15:07 +0000212 struct delayed_work gc_work;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 struct timer_list proxy_timer;
214 struct sk_buff_head proxy_queue;
215 atomic_t entries;
216 rwlock_t lock;
217 unsigned long last_rand;
Tejun Heo7d720c32010-02-16 15:20:26 +0000218 struct neigh_statistics __percpu *stats;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000219 struct neigh_hash_table __rcu *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 struct pneigh_entry **phash_buckets;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221};
222
WANG Congd7480fd2014-11-10 15:59:36 -0800223enum {
224 NEIGH_ARP_TABLE = 0,
225 NEIGH_ND_TABLE = 1,
226 NEIGH_DN_TABLE = 2,
227 NEIGH_NR_TABLES,
228};
229
Jiri Pirko73af6142013-12-07 19:26:55 +0100230static inline int neigh_parms_family(struct neigh_parms *p)
231{
232 return p->tbl->family;
233}
234
David Miller1026fec2011-07-25 00:01:17 +0000235#define NEIGH_PRIV_ALIGN sizeof(long long)
YOSHIFUJI Hideaki / 吉藤英明daaba4f2013-02-09 07:00:59 +0000236#define NEIGH_ENTRY_SIZE(size) ALIGN((size), NEIGH_PRIV_ALIGN)
David Miller1026fec2011-07-25 00:01:17 +0000237
238static inline void *neighbour_priv(const struct neighbour *n)
239{
YOSHIFUJI Hideaki / 吉藤英明08433ef2013-01-24 00:44:23 +0000240 return (char *)n + n->tbl->entry_size;
David Miller1026fec2011-07-25 00:01:17 +0000241}
242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243/* flags for neigh_update() */
244#define NEIGH_UPDATE_F_OVERRIDE 0x00000001
245#define NEIGH_UPDATE_F_WEAK_OVERRIDE 0x00000002
246#define NEIGH_UPDATE_F_OVERRIDE_ISROUTER 0x00000004
247#define NEIGH_UPDATE_F_ISROUTER 0x40000000
248#define NEIGH_UPDATE_F_ADMIN 0x80000000
249
WANG Congd7480fd2014-11-10 15:59:36 -0800250void neigh_table_init(int index, struct neigh_table *tbl);
251int neigh_table_clear(int index, struct neigh_table *tbl);
Joe Perches90972b22013-07-31 17:31:35 -0700252struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
253 struct net_device *dev);
254struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
255 const void *pkey);
256struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey,
257 struct net_device *dev, bool want_ref);
David S. Millera263b302012-07-02 02:02:15 -0700258static inline struct neighbour *neigh_create(struct neigh_table *tbl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 const void *pkey,
David S. Millera263b302012-07-02 02:02:15 -0700260 struct net_device *dev)
261{
262 return __neigh_create(tbl, pkey, dev, true);
263}
Joe Perches90972b22013-07-31 17:31:35 -0700264void neigh_destroy(struct neighbour *neigh);
265int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb);
266int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, u32 flags);
Jiri Benc7e980562013-12-11 13:48:20 +0100267void __neigh_set_probe_once(struct neighbour *neigh);
Joe Perches90972b22013-07-31 17:31:35 -0700268void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
269int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
270int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb);
271int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb);
272int neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb);
273int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb);
274struct neighbour *neigh_event_ns(struct neigh_table *tbl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 u8 *lladdr, void *saddr,
276 struct net_device *dev);
277
Joe Perches90972b22013-07-31 17:31:35 -0700278struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
279 struct neigh_table *tbl);
280void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms);
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900281
282static inline
Joe Perches90972b22013-07-31 17:31:35 -0700283struct net *neigh_parms_net(const struct neigh_parms *parms)
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900284{
Eric Dumazete42ea982008-11-12 00:54:54 -0800285 return read_pnet(&parms->net);
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900286}
287
Joe Perches90972b22013-07-31 17:31:35 -0700288unsigned long neigh_rand_reach_time(unsigned long base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Joe Perches90972b22013-07-31 17:31:35 -0700290void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
291 struct sk_buff *skb);
292struct pneigh_entry *pneigh_lookup(struct neigh_table *tbl, struct net *net,
293 const void *key, struct net_device *dev,
294 int creat);
295struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl, struct net *net,
296 const void *key, struct net_device *dev);
297int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *key,
298 struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
Joe Perches90972b22013-07-31 17:31:35 -0700300static inline struct net *pneigh_net(const struct pneigh_entry *pneigh)
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900301{
Eric Dumazete42ea982008-11-12 00:54:54 -0800302 return read_pnet(&pneigh->net);
YOSHIFUJI Hideaki57da52c2008-03-26 03:49:59 +0900303}
304
Joe Perches90972b22013-07-31 17:31:35 -0700305void neigh_app_ns(struct neighbour *n);
306void neigh_for_each(struct neigh_table *tbl,
307 void (*cb)(struct neighbour *, void *), void *cookie);
308void __neigh_for_each_release(struct neigh_table *tbl,
309 int (*cb)(struct neighbour *));
310void pneigh_for_each(struct neigh_table *tbl,
311 void (*cb)(struct pneigh_entry *));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312
313struct neigh_seq_state {
Denis V. Lunev42508462008-01-10 03:53:12 -0800314 struct seq_net_private p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 struct neigh_table *tbl;
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000316 struct neigh_hash_table *nht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 void *(*neigh_sub_iter)(struct neigh_seq_state *state,
318 struct neighbour *n, loff_t *pos);
319 unsigned int bucket;
320 unsigned int flags;
321#define NEIGH_SEQ_NEIGH_ONLY 0x00000001
322#define NEIGH_SEQ_IS_PNEIGH 0x00000002
323#define NEIGH_SEQ_SKIP_NOARP 0x00000004
324};
Joe Perches90972b22013-07-31 17:31:35 -0700325void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *,
326 unsigned int);
327void *neigh_seq_next(struct seq_file *, void *, loff_t *);
328void neigh_seq_stop(struct seq_file *, void *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Jiri Pirkocb5b09c2013-12-07 19:26:54 +0100330int neigh_proc_dointvec(struct ctl_table *ctl, int write,
331 void __user *buffer, size_t *lenp, loff_t *ppos);
332int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write,
333 void __user *buffer,
334 size_t *lenp, loff_t *ppos);
335int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write,
336 void __user *buffer,
337 size_t *lenp, loff_t *ppos);
338
Joe Perches90972b22013-07-31 17:31:35 -0700339int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
Jiri Pirko73af6142013-12-07 19:26:55 +0100340 proc_handler *proc_handler);
Joe Perches90972b22013-07-31 17:31:35 -0700341void neigh_sysctl_unregister(struct neigh_parms *p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
343static inline void __neigh_parms_put(struct neigh_parms *parms)
344{
345 atomic_dec(&parms->refcnt);
346}
347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348static inline struct neigh_parms *neigh_parms_clone(struct neigh_parms *parms)
349{
350 atomic_inc(&parms->refcnt);
351 return parms;
352}
353
354/*
355 * Neighbour references
356 */
357
358static inline void neigh_release(struct neighbour *neigh)
359{
360 if (atomic_dec_and_test(&neigh->refcnt))
361 neigh_destroy(neigh);
362}
363
364static inline struct neighbour * neigh_clone(struct neighbour *neigh)
365{
366 if (neigh)
367 atomic_inc(&neigh->refcnt);
368 return neigh;
369}
370
371#define neigh_hold(n) atomic_inc(&(n)->refcnt)
372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373static inline int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
374{
Tetsuo Handaef22b7b2010-11-18 09:40:04 -0800375 unsigned long now = jiffies;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000376
377 if (neigh->used != now)
378 neigh->used = now;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE)))
380 return __neigh_event_send(neigh, skb);
381 return 0;
382}
383
Pablo Neira Ayuso34666d42014-09-18 11:29:03 +0200384#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
Bart De Schuymere179e632010-04-15 12:26:39 +0200385static inline int neigh_hh_bridge(struct hh_cache *hh, struct sk_buff *skb)
386{
Eric Dumazet95c96172012-04-15 05:58:06 +0000387 unsigned int seq, hh_alen;
Bart De Schuymere179e632010-04-15 12:26:39 +0200388
389 do {
390 seq = read_seqbegin(&hh->hh_lock);
391 hh_alen = HH_DATA_ALIGN(ETH_HLEN);
392 memcpy(skb->data - hh_alen, hh->hh_data, ETH_ALEN + hh_alen - ETH_HLEN);
393 } while (read_seqretry(&hh->hh_lock, seq));
394 return 0;
395}
396#endif
397
Eric Dumazet425f09a2012-08-07 02:19:56 +0000398static inline int neigh_hh_output(const struct hh_cache *hh, struct sk_buff *skb)
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800399{
Eric Dumazet95c96172012-04-15 05:58:06 +0000400 unsigned int seq;
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800401 int hh_len;
402
403 do {
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800404 seq = read_seqbegin(&hh->hh_lock);
405 hh_len = hh->hh_len;
Eric Dumazet425f09a2012-08-07 02:19:56 +0000406 if (likely(hh_len <= HH_DATA_MOD)) {
407 /* this is inlined by gcc */
408 memcpy(skb->data - HH_DATA_MOD, hh->hh_data, HH_DATA_MOD);
409 } else {
410 int hh_alen = HH_DATA_ALIGN(hh_len);
411
412 memcpy(skb->data - hh_alen, hh->hh_data, hh_alen);
413 }
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800414 } while (read_seqretry(&hh->hh_lock, seq));
415
416 skb_push(skb, hh_len);
David S. Millerb23b5452011-07-16 17:45:02 -0700417 return dev_queue_xmit(skb);
Stephen Hemminger3644f0c2006-12-07 15:08:17 -0800418}
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420static inline struct neighbour *
421__neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat)
422{
423 struct neighbour *n = neigh_lookup(tbl, pkey, dev);
424
425 if (n || !creat)
426 return n;
427
428 n = neigh_create(tbl, pkey, dev);
429 return IS_ERR(n) ? NULL : n;
430}
431
432static inline struct neighbour *
433__neigh_lookup_errno(struct neigh_table *tbl, const void *pkey,
434 struct net_device *dev)
435{
436 struct neighbour *n = neigh_lookup(tbl, pkey, dev);
437
438 if (n)
439 return n;
440
441 return neigh_create(tbl, pkey, dev);
442}
443
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700444struct neighbour_cb {
445 unsigned long sched_next;
446 unsigned int flags;
447};
448
449#define LOCALLY_ENQUEUED 0x1
450
451#define NEIGH_CB(skb) ((struct neighbour_cb *)(skb)->cb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000453static inline void neigh_ha_snapshot(char *dst, const struct neighbour *n,
454 const struct net_device *dev)
455{
456 unsigned int seq;
457
458 do {
459 seq = read_seqbegin(&n->ha_lock);
460 memcpy(dst, n->ha, dev->addr_len);
461 } while (read_seqretry(&n->ha_lock, seq));
462}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463#endif