Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef _NET_NEIGHBOUR_H |
| 2 | #define _NET_NEIGHBOUR_H |
| 3 | |
Thomas Graf | 9067c72 | 2006-08-07 17:57:44 -0700 | [diff] [blame] | 4 | #include <linux/neighbour.h> |
| 5 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | /* |
| 7 | * Generic neighbour manipulation |
| 8 | * |
| 9 | * Authors: |
| 10 | * Pedro Roque <roque@di.fc.ul.pt> |
| 11 | * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> |
| 12 | * |
| 13 | * Changes: |
| 14 | * |
| 15 | * Harald Welte: <laforge@gnumonks.org> |
| 16 | * - Add neighbour cache statistics like rtstat |
| 17 | */ |
| 18 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <asm/atomic.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/netdevice.h> |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 21 | #include <linux/skbuff.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #include <linux/rcupdate.h> |
| 23 | #include <linux/seq_file.h> |
| 24 | |
| 25 | #include <linux/err.h> |
| 26 | #include <linux/sysctl.h> |
Eric Dumazet | e4c4e44 | 2009-07-30 03:15:07 +0000 | [diff] [blame] | 27 | #include <linux/workqueue.h> |
Thomas Graf | c8822a4 | 2007-03-22 11:50:06 -0700 | [diff] [blame] | 28 | #include <net/rtnetlink.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | |
Pavel Emelyanov | 3997155 | 2008-01-10 22:37:16 -0800 | [diff] [blame] | 30 | /* |
| 31 | * NUD stands for "neighbor unreachability detection" |
| 32 | */ |
| 33 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | #define NUD_IN_TIMER (NUD_INCOMPLETE|NUD_REACHABLE|NUD_DELAY|NUD_PROBE) |
| 35 | #define NUD_VALID (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE|NUD_PROBE|NUD_STALE|NUD_DELAY) |
| 36 | #define NUD_CONNECTED (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE) |
| 37 | |
| 38 | struct neighbour; |
| 39 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 40 | struct neigh_parms { |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 41 | #ifdef CONFIG_NET_NS |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 42 | struct net *net; |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 43 | #endif |
Thomas Graf | c7fb64d | 2005-06-18 22:50:55 -0700 | [diff] [blame] | 44 | struct net_device *dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | struct neigh_parms *next; |
| 46 | int (*neigh_setup)(struct neighbour *); |
Alexey Kuznetsov | ecbb416 | 2007-03-24 12:52:16 -0700 | [diff] [blame] | 47 | void (*neigh_cleanup)(struct neighbour *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | struct neigh_table *tbl; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | |
| 50 | void *sysctl_table; |
| 51 | |
| 52 | int dead; |
| 53 | atomic_t refcnt; |
| 54 | struct rcu_head rcu_head; |
| 55 | |
| 56 | int base_reachable_time; |
| 57 | int retrans_time; |
| 58 | int gc_staletime; |
| 59 | int reachable_time; |
| 60 | int delay_probe_time; |
| 61 | |
| 62 | int queue_len; |
| 63 | int ucast_probes; |
| 64 | int app_probes; |
| 65 | int mcast_probes; |
| 66 | int anycast_delay; |
| 67 | int proxy_delay; |
| 68 | int proxy_qlen; |
| 69 | int locktime; |
| 70 | }; |
| 71 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 72 | struct neigh_statistics { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | unsigned long allocs; /* number of allocated neighs */ |
| 74 | unsigned long destroys; /* number of destroyed neighs */ |
| 75 | unsigned long hash_grows; /* number of hash resizes */ |
| 76 | |
Neil Horman | 9a6d276 | 2008-07-16 20:50:49 -0700 | [diff] [blame] | 77 | unsigned long res_failed; /* number of failed resolutions */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | |
| 79 | unsigned long lookups; /* number of lookups */ |
| 80 | unsigned long hits; /* number of hits (among lookups) */ |
| 81 | |
| 82 | unsigned long rcv_probes_mcast; /* number of received mcast ipv6 */ |
| 83 | unsigned long rcv_probes_ucast; /* number of received ucast ipv6 */ |
| 84 | |
| 85 | unsigned long periodic_gc_runs; /* number of periodic GC runs */ |
| 86 | unsigned long forced_gc_runs; /* number of forced GC runs */ |
Neil Horman | 9a6d276 | 2008-07-16 20:50:49 -0700 | [diff] [blame] | 87 | |
| 88 | unsigned long unres_discards; /* number of unresolved drops */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | }; |
| 90 | |
Christoph Lameter | 4ea7334 | 2009-10-03 19:48:22 +0900 | [diff] [blame] | 91 | #define NEIGH_CACHE_STAT_INC(tbl, field) this_cpu_inc((tbl)->stats->field) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 93 | struct neighbour { |
Eric Dumazet | 767e97e | 2010-10-06 17:49:21 -0700 | [diff] [blame] | 94 | struct neighbour __rcu *next; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | struct neigh_table *tbl; |
| 96 | struct neigh_parms *parms; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | unsigned long confirmed; |
| 98 | unsigned long updated; |
Eric Dumazet | 46b13fc | 2010-11-11 06:57:19 +0000 | [diff] [blame] | 99 | rwlock_t lock; |
Eric Dumazet | 367e5e3 | 2010-09-30 05:36:29 +0000 | [diff] [blame] | 100 | atomic_t refcnt; |
Eric Dumazet | e37ef96 | 2010-10-11 12:20:54 +0000 | [diff] [blame] | 101 | struct sk_buff_head arp_queue; |
| 102 | struct timer_list timer; |
| 103 | unsigned long used; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | atomic_t probes; |
Eric Dumazet | 46b13fc | 2010-11-11 06:57:19 +0000 | [diff] [blame] | 105 | __u8 flags; |
| 106 | __u8 nud_state; |
| 107 | __u8 type; |
| 108 | __u8 dead; |
Eric Dumazet | 0ed8ddf | 2010-10-07 10:44:07 +0000 | [diff] [blame] | 109 | seqlock_t ha_lock; |
Stephen Hemminger | d924424 | 2006-08-10 23:03:23 -0700 | [diff] [blame] | 110 | unsigned char ha[ALIGN(MAX_ADDR_LEN, sizeof(unsigned long))]; |
David S. Miller | f6b72b6 | 2011-07-14 07:53:20 -0700 | [diff] [blame] | 111 | struct hh_cache hh; |
David S. Miller | 8f40b16 | 2011-07-17 13:34:11 -0700 | [diff] [blame^] | 112 | int (*output)(struct neighbour *, struct sk_buff *); |
Stephen Hemminger | 89d69d2 | 2009-09-01 11:13:19 +0000 | [diff] [blame] | 113 | const struct neigh_ops *ops; |
Eric Dumazet | 767e97e | 2010-10-06 17:49:21 -0700 | [diff] [blame] | 114 | struct rcu_head rcu; |
Eric Dumazet | e37ef96 | 2010-10-11 12:20:54 +0000 | [diff] [blame] | 115 | struct net_device *dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | u8 primary_key[0]; |
| 117 | }; |
| 118 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 119 | struct neigh_ops { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | int family; |
David S. Miller | 8f40b16 | 2011-07-17 13:34:11 -0700 | [diff] [blame^] | 121 | void (*solicit)(struct neighbour *, struct sk_buff *); |
| 122 | void (*error_report)(struct neighbour *, struct sk_buff *); |
| 123 | int (*output)(struct neighbour *, struct sk_buff *); |
| 124 | int (*connected_output)(struct neighbour *, struct sk_buff *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | }; |
| 126 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 127 | struct pneigh_entry { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | struct pneigh_entry *next; |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 129 | #ifdef CONFIG_NET_NS |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 130 | struct net *net; |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 131 | #endif |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 132 | struct net_device *dev; |
Ville Nuorvala | 62dd931 | 2006-09-22 14:43:19 -0700 | [diff] [blame] | 133 | u8 flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | u8 key[0]; |
| 135 | }; |
| 136 | |
| 137 | /* |
| 138 | * neighbour table manipulation |
| 139 | */ |
| 140 | |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 141 | struct neigh_hash_table { |
Eric Dumazet | 767e97e | 2010-10-06 17:49:21 -0700 | [diff] [blame] | 142 | struct neighbour __rcu **hash_buckets; |
David S. Miller | cd08933 | 2011-07-11 01:28:12 -0700 | [diff] [blame] | 143 | unsigned int hash_shift; |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 144 | __u32 hash_rnd; |
| 145 | struct rcu_head rcu; |
| 146 | }; |
| 147 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 149 | struct neigh_table { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | struct neigh_table *next; |
| 151 | int family; |
| 152 | int entry_size; |
| 153 | int key_len; |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 154 | __u32 (*hash)(const void *pkey, |
| 155 | const struct net_device *dev, |
| 156 | __u32 hash_rnd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | int (*constructor)(struct neighbour *); |
| 158 | int (*pconstructor)(struct pneigh_entry *); |
| 159 | void (*pdestructor)(struct pneigh_entry *); |
| 160 | void (*proxy_redo)(struct sk_buff *skb); |
| 161 | char *id; |
| 162 | struct neigh_parms parms; |
Kulikov Vasiliy | 787a344 | 2010-06-30 06:08:15 +0000 | [diff] [blame] | 163 | /* HACK. gc_* should follow parms without a gap! */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | int gc_interval; |
| 165 | int gc_thresh1; |
| 166 | int gc_thresh2; |
| 167 | int gc_thresh3; |
| 168 | unsigned long last_flush; |
Eric Dumazet | e4c4e44 | 2009-07-30 03:15:07 +0000 | [diff] [blame] | 169 | struct delayed_work gc_work; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | struct timer_list proxy_timer; |
| 171 | struct sk_buff_head proxy_queue; |
| 172 | atomic_t entries; |
| 173 | rwlock_t lock; |
| 174 | unsigned long last_rand; |
Eric Dumazet | 367e5e3 | 2010-09-30 05:36:29 +0000 | [diff] [blame] | 175 | struct kmem_cache *kmem_cachep; |
Tejun Heo | 7d720c3 | 2010-02-16 15:20:26 +0000 | [diff] [blame] | 176 | struct neigh_statistics __percpu *stats; |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 177 | struct neigh_hash_table __rcu *nht; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | struct pneigh_entry **phash_buckets; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | }; |
| 180 | |
| 181 | /* flags for neigh_update() */ |
| 182 | #define NEIGH_UPDATE_F_OVERRIDE 0x00000001 |
| 183 | #define NEIGH_UPDATE_F_WEAK_OVERRIDE 0x00000002 |
| 184 | #define NEIGH_UPDATE_F_OVERRIDE_ISROUTER 0x00000004 |
| 185 | #define NEIGH_UPDATE_F_ISROUTER 0x40000000 |
| 186 | #define NEIGH_UPDATE_F_ADMIN 0x80000000 |
| 187 | |
| 188 | extern void neigh_table_init(struct neigh_table *tbl); |
Simon Kelley | bd89efc | 2006-05-12 14:56:08 -0700 | [diff] [blame] | 189 | extern void neigh_table_init_no_netlink(struct neigh_table *tbl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | extern int neigh_table_clear(struct neigh_table *tbl); |
| 191 | extern struct neighbour * neigh_lookup(struct neigh_table *tbl, |
| 192 | const void *pkey, |
| 193 | struct net_device *dev); |
| 194 | extern struct neighbour * neigh_lookup_nodev(struct neigh_table *tbl, |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 195 | struct net *net, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | const void *pkey); |
| 197 | extern struct neighbour * neigh_create(struct neigh_table *tbl, |
| 198 | const void *pkey, |
| 199 | struct net_device *dev); |
| 200 | extern void neigh_destroy(struct neighbour *neigh); |
| 201 | extern int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb); |
| 202 | extern int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, |
| 203 | u32 flags); |
| 204 | extern void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev); |
| 205 | extern int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev); |
David S. Miller | 8f40b16 | 2011-07-17 13:34:11 -0700 | [diff] [blame^] | 206 | extern int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb); |
| 207 | extern int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb); |
| 208 | extern int neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb); |
| 209 | extern int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | extern struct neighbour *neigh_event_ns(struct neigh_table *tbl, |
| 211 | u8 *lladdr, void *saddr, |
| 212 | struct net_device *dev); |
| 213 | |
| 214 | extern struct neigh_parms *neigh_parms_alloc(struct net_device *dev, struct neigh_table *tbl); |
| 215 | extern void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms); |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 216 | |
| 217 | static inline |
| 218 | struct net *neigh_parms_net(const struct neigh_parms *parms) |
| 219 | { |
Eric Dumazet | e42ea98 | 2008-11-12 00:54:54 -0800 | [diff] [blame] | 220 | return read_pnet(&parms->net); |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 221 | } |
| 222 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | extern unsigned long neigh_rand_reach_time(unsigned long base); |
| 224 | |
| 225 | extern void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, |
| 226 | struct sk_buff *skb); |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 227 | extern struct pneigh_entry *pneigh_lookup(struct neigh_table *tbl, struct net *net, const void *key, struct net_device *dev, int creat); |
Pavel Emelyanov | fa86d32 | 2008-03-24 14:48:59 -0700 | [diff] [blame] | 228 | extern struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl, |
| 229 | struct net *net, |
| 230 | const void *key, |
| 231 | struct net_device *dev); |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 232 | extern int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *key, struct net_device *dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 234 | static inline |
| 235 | struct net *pneigh_net(const struct pneigh_entry *pneigh) |
| 236 | { |
Eric Dumazet | e42ea98 | 2008-11-12 00:54:54 -0800 | [diff] [blame] | 237 | return read_pnet(&pneigh->net); |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 238 | } |
| 239 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | extern void neigh_app_ns(struct neighbour *n); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | extern void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie); |
| 242 | extern void __neigh_for_each_release(struct neigh_table *tbl, int (*cb)(struct neighbour *)); |
| 243 | extern void pneigh_for_each(struct neigh_table *tbl, void (*cb)(struct pneigh_entry *)); |
| 244 | |
| 245 | struct neigh_seq_state { |
Denis V. Lunev | 4250846 | 2008-01-10 03:53:12 -0800 | [diff] [blame] | 246 | struct seq_net_private p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | struct neigh_table *tbl; |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 248 | struct neigh_hash_table *nht; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | void *(*neigh_sub_iter)(struct neigh_seq_state *state, |
| 250 | struct neighbour *n, loff_t *pos); |
| 251 | unsigned int bucket; |
| 252 | unsigned int flags; |
| 253 | #define NEIGH_SEQ_NEIGH_ONLY 0x00000001 |
| 254 | #define NEIGH_SEQ_IS_PNEIGH 0x00000002 |
| 255 | #define NEIGH_SEQ_SKIP_NOARP 0x00000004 |
| 256 | }; |
| 257 | extern void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *, unsigned int); |
| 258 | extern void *neigh_seq_next(struct seq_file *, void *, loff_t *); |
| 259 | extern void neigh_seq_stop(struct seq_file *, void *); |
| 260 | |
| 261 | extern int neigh_sysctl_register(struct net_device *dev, |
| 262 | struct neigh_parms *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | char *p_name, |
Eric W. Biederman | f8572d8 | 2009-11-05 13:32:03 -0800 | [diff] [blame] | 264 | proc_handler *proc_handler); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | extern void neigh_sysctl_unregister(struct neigh_parms *p); |
| 266 | |
| 267 | static inline void __neigh_parms_put(struct neigh_parms *parms) |
| 268 | { |
| 269 | atomic_dec(&parms->refcnt); |
| 270 | } |
| 271 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | static inline struct neigh_parms *neigh_parms_clone(struct neigh_parms *parms) |
| 273 | { |
| 274 | atomic_inc(&parms->refcnt); |
| 275 | return parms; |
| 276 | } |
| 277 | |
| 278 | /* |
| 279 | * Neighbour references |
| 280 | */ |
| 281 | |
| 282 | static inline void neigh_release(struct neighbour *neigh) |
| 283 | { |
| 284 | if (atomic_dec_and_test(&neigh->refcnt)) |
| 285 | neigh_destroy(neigh); |
| 286 | } |
| 287 | |
| 288 | static inline struct neighbour * neigh_clone(struct neighbour *neigh) |
| 289 | { |
| 290 | if (neigh) |
| 291 | atomic_inc(&neigh->refcnt); |
| 292 | return neigh; |
| 293 | } |
| 294 | |
| 295 | #define neigh_hold(n) atomic_inc(&(n)->refcnt) |
| 296 | |
| 297 | static inline void neigh_confirm(struct neighbour *neigh) |
| 298 | { |
| 299 | if (neigh) |
| 300 | neigh->confirmed = jiffies; |
| 301 | } |
| 302 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | static inline int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) |
| 304 | { |
Tetsuo Handa | ef22b7b | 2010-11-18 09:40:04 -0800 | [diff] [blame] | 305 | unsigned long now = jiffies; |
Eric Dumazet | 0ed8ddf | 2010-10-07 10:44:07 +0000 | [diff] [blame] | 306 | |
| 307 | if (neigh->used != now) |
| 308 | neigh->used = now; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 309 | if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE))) |
| 310 | return __neigh_event_send(neigh, skb); |
| 311 | return 0; |
| 312 | } |
| 313 | |
Bart De Schuymer | e179e63 | 2010-04-15 12:26:39 +0200 | [diff] [blame] | 314 | #ifdef CONFIG_BRIDGE_NETFILTER |
| 315 | static inline int neigh_hh_bridge(struct hh_cache *hh, struct sk_buff *skb) |
| 316 | { |
| 317 | unsigned seq, hh_alen; |
| 318 | |
| 319 | do { |
| 320 | seq = read_seqbegin(&hh->hh_lock); |
| 321 | hh_alen = HH_DATA_ALIGN(ETH_HLEN); |
| 322 | memcpy(skb->data - hh_alen, hh->hh_data, ETH_ALEN + hh_alen - ETH_HLEN); |
| 323 | } while (read_seqretry(&hh->hh_lock, seq)); |
| 324 | return 0; |
| 325 | } |
| 326 | #endif |
| 327 | |
Stephen Hemminger | 3644f0c | 2006-12-07 15:08:17 -0800 | [diff] [blame] | 328 | static inline int neigh_hh_output(struct hh_cache *hh, struct sk_buff *skb) |
| 329 | { |
| 330 | unsigned seq; |
| 331 | int hh_len; |
| 332 | |
| 333 | do { |
| 334 | int hh_alen; |
| 335 | |
| 336 | seq = read_seqbegin(&hh->hh_lock); |
| 337 | hh_len = hh->hh_len; |
| 338 | hh_alen = HH_DATA_ALIGN(hh_len); |
| 339 | memcpy(skb->data - hh_alen, hh->hh_data, hh_alen); |
| 340 | } while (read_seqretry(&hh->hh_lock, seq)); |
| 341 | |
| 342 | skb_push(skb, hh_len); |
David S. Miller | b23b545 | 2011-07-16 17:45:02 -0700 | [diff] [blame] | 343 | return dev_queue_xmit(skb); |
Stephen Hemminger | 3644f0c | 2006-12-07 15:08:17 -0800 | [diff] [blame] | 344 | } |
| 345 | |
David S. Miller | 05e3aa0 | 2011-07-16 17:26:00 -0700 | [diff] [blame] | 346 | static inline int neigh_output(struct neighbour *n, struct sk_buff *skb) |
| 347 | { |
| 348 | struct hh_cache *hh = &n->hh; |
David S. Miller | b23b545 | 2011-07-16 17:45:02 -0700 | [diff] [blame] | 349 | if ((n->nud_state & NUD_CONNECTED) && hh->hh_len) |
David S. Miller | 05e3aa0 | 2011-07-16 17:26:00 -0700 | [diff] [blame] | 350 | return neigh_hh_output(hh, skb); |
| 351 | else |
David S. Miller | 8f40b16 | 2011-07-17 13:34:11 -0700 | [diff] [blame^] | 352 | return n->output(n, skb); |
David S. Miller | 05e3aa0 | 2011-07-16 17:26:00 -0700 | [diff] [blame] | 353 | } |
| 354 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | static inline struct neighbour * |
| 356 | __neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat) |
| 357 | { |
| 358 | struct neighbour *n = neigh_lookup(tbl, pkey, dev); |
| 359 | |
| 360 | if (n || !creat) |
| 361 | return n; |
| 362 | |
| 363 | n = neigh_create(tbl, pkey, dev); |
| 364 | return IS_ERR(n) ? NULL : n; |
| 365 | } |
| 366 | |
| 367 | static inline struct neighbour * |
| 368 | __neigh_lookup_errno(struct neigh_table *tbl, const void *pkey, |
| 369 | struct net_device *dev) |
| 370 | { |
| 371 | struct neighbour *n = neigh_lookup(tbl, pkey, dev); |
| 372 | |
| 373 | if (n) |
| 374 | return n; |
| 375 | |
| 376 | return neigh_create(tbl, pkey, dev); |
| 377 | } |
| 378 | |
Patrick McHardy | a61bbcf | 2005-08-14 17:24:31 -0700 | [diff] [blame] | 379 | struct neighbour_cb { |
| 380 | unsigned long sched_next; |
| 381 | unsigned int flags; |
| 382 | }; |
| 383 | |
| 384 | #define LOCALLY_ENQUEUED 0x1 |
| 385 | |
| 386 | #define NEIGH_CB(skb) ((struct neighbour_cb *)(skb)->cb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | |
Eric Dumazet | 0ed8ddf | 2010-10-07 10:44:07 +0000 | [diff] [blame] | 388 | static inline void neigh_ha_snapshot(char *dst, const struct neighbour *n, |
| 389 | const struct net_device *dev) |
| 390 | { |
| 391 | unsigned int seq; |
| 392 | |
| 393 | do { |
| 394 | seq = read_seqbegin(&n->ha_lock); |
| 395 | memcpy(dst, n->ha, dev->addr_len); |
| 396 | } while (read_seqretry(&n->ha_lock, seq)); |
| 397 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 398 | #endif |