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 | |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 19 | #include <linux/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; |
David S. Miller | 447f219 | 2011-12-19 15:04:41 -0500 | [diff] [blame] | 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 | |
Eric Dumazet | 8b5c171 | 2011-11-09 12:07:14 +0000 | [diff] [blame] | 62 | int queue_len_bytes; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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; |
Eric Dumazet | 8b5c171 | 2011-11-09 12:07:14 +0000 | [diff] [blame] | 102 | unsigned int arp_queue_len_bytes; |
Eric Dumazet | e37ef96 | 2010-10-11 12:20:54 +0000 | [diff] [blame] | 103 | struct timer_list timer; |
| 104 | unsigned long used; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | atomic_t probes; |
Eric Dumazet | 46b13fc | 2010-11-11 06:57:19 +0000 | [diff] [blame] | 106 | __u8 flags; |
| 107 | __u8 nud_state; |
| 108 | __u8 type; |
| 109 | __u8 dead; |
Eric Dumazet | 0ed8ddf | 2010-10-07 10:44:07 +0000 | [diff] [blame] | 110 | seqlock_t ha_lock; |
Stephen Hemminger | d924424 | 2006-08-10 23:03:23 -0700 | [diff] [blame] | 111 | unsigned char ha[ALIGN(MAX_ADDR_LEN, sizeof(unsigned long))]; |
David S. Miller | f6b72b6 | 2011-07-14 07:53:20 -0700 | [diff] [blame] | 112 | struct hh_cache hh; |
David S. Miller | 8f40b16 | 2011-07-17 13:34:11 -0700 | [diff] [blame] | 113 | int (*output)(struct neighbour *, struct sk_buff *); |
Stephen Hemminger | 89d69d2 | 2009-09-01 11:13:19 +0000 | [diff] [blame] | 114 | const struct neigh_ops *ops; |
Eric Dumazet | 767e97e | 2010-10-06 17:49:21 -0700 | [diff] [blame] | 115 | struct rcu_head rcu; |
Eric Dumazet | e37ef96 | 2010-10-11 12:20:54 +0000 | [diff] [blame] | 116 | struct net_device *dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | u8 primary_key[0]; |
| 118 | }; |
| 119 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 120 | struct neigh_ops { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | int family; |
David S. Miller | 8f40b16 | 2011-07-17 13:34:11 -0700 | [diff] [blame] | 122 | void (*solicit)(struct neighbour *, struct sk_buff *); |
| 123 | void (*error_report)(struct neighbour *, struct sk_buff *); |
| 124 | int (*output)(struct neighbour *, struct sk_buff *); |
| 125 | int (*connected_output)(struct neighbour *, struct sk_buff *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | }; |
| 127 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 128 | struct pneigh_entry { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | struct pneigh_entry *next; |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 130 | #ifdef CONFIG_NET_NS |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 131 | struct net *net; |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 132 | #endif |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 133 | struct net_device *dev; |
Ville Nuorvala | 62dd931 | 2006-09-22 14:43:19 -0700 | [diff] [blame] | 134 | u8 flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | u8 key[0]; |
| 136 | }; |
| 137 | |
| 138 | /* |
| 139 | * neighbour table manipulation |
| 140 | */ |
| 141 | |
David S. Miller | 2c2aba6 | 2011-12-28 15:06:58 -0500 | [diff] [blame] | 142 | #define NEIGH_NUM_HASH_RND 4 |
| 143 | |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 144 | struct neigh_hash_table { |
Eric Dumazet | 767e97e | 2010-10-06 17:49:21 -0700 | [diff] [blame] | 145 | struct neighbour __rcu **hash_buckets; |
David S. Miller | cd08933 | 2011-07-11 01:28:12 -0700 | [diff] [blame] | 146 | unsigned int hash_shift; |
David S. Miller | 2c2aba6 | 2011-12-28 15:06:58 -0500 | [diff] [blame] | 147 | __u32 hash_rnd[NEIGH_NUM_HASH_RND]; |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 148 | struct rcu_head rcu; |
| 149 | }; |
| 150 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 152 | struct neigh_table { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | struct neigh_table *next; |
| 154 | int family; |
| 155 | int entry_size; |
| 156 | int key_len; |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 157 | __u32 (*hash)(const void *pkey, |
| 158 | const struct net_device *dev, |
David S. Miller | 2c2aba6 | 2011-12-28 15:06:58 -0500 | [diff] [blame] | 159 | __u32 *hash_rnd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | int (*constructor)(struct neighbour *); |
| 161 | int (*pconstructor)(struct pneigh_entry *); |
| 162 | void (*pdestructor)(struct pneigh_entry *); |
| 163 | void (*proxy_redo)(struct sk_buff *skb); |
| 164 | char *id; |
| 165 | struct neigh_parms parms; |
Kulikov Vasiliy | 787a344 | 2010-06-30 06:08:15 +0000 | [diff] [blame] | 166 | /* HACK. gc_* should follow parms without a gap! */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | int gc_interval; |
| 168 | int gc_thresh1; |
| 169 | int gc_thresh2; |
| 170 | int gc_thresh3; |
| 171 | unsigned long last_flush; |
Eric Dumazet | e4c4e44 | 2009-07-30 03:15:07 +0000 | [diff] [blame] | 172 | struct delayed_work gc_work; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | struct timer_list proxy_timer; |
| 174 | struct sk_buff_head proxy_queue; |
| 175 | atomic_t entries; |
| 176 | rwlock_t lock; |
| 177 | unsigned long last_rand; |
Tejun Heo | 7d720c3 | 2010-02-16 15:20:26 +0000 | [diff] [blame] | 178 | struct neigh_statistics __percpu *stats; |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 179 | struct neigh_hash_table __rcu *nht; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | struct pneigh_entry **phash_buckets; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | }; |
| 182 | |
David Miller | 1026fec | 2011-07-25 00:01:17 +0000 | [diff] [blame] | 183 | #define NEIGH_PRIV_ALIGN sizeof(long long) |
| 184 | |
| 185 | static inline void *neighbour_priv(const struct neighbour *n) |
| 186 | { |
| 187 | return (char *)n + ALIGN(sizeof(*n) + n->tbl->key_len, NEIGH_PRIV_ALIGN); |
| 188 | } |
| 189 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | /* flags for neigh_update() */ |
| 191 | #define NEIGH_UPDATE_F_OVERRIDE 0x00000001 |
| 192 | #define NEIGH_UPDATE_F_WEAK_OVERRIDE 0x00000002 |
| 193 | #define NEIGH_UPDATE_F_OVERRIDE_ISROUTER 0x00000004 |
| 194 | #define NEIGH_UPDATE_F_ISROUTER 0x40000000 |
| 195 | #define NEIGH_UPDATE_F_ADMIN 0x80000000 |
| 196 | |
| 197 | extern void neigh_table_init(struct neigh_table *tbl); |
| 198 | extern int neigh_table_clear(struct neigh_table *tbl); |
| 199 | extern struct neighbour * neigh_lookup(struct neigh_table *tbl, |
| 200 | const void *pkey, |
| 201 | struct net_device *dev); |
| 202 | extern struct neighbour * neigh_lookup_nodev(struct neigh_table *tbl, |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 203 | struct net *net, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | const void *pkey); |
David S. Miller | a263b30 | 2012-07-02 02:02:15 -0700 | [diff] [blame] | 205 | extern struct neighbour * __neigh_create(struct neigh_table *tbl, |
| 206 | const void *pkey, |
| 207 | struct net_device *dev, |
| 208 | bool want_ref); |
| 209 | static inline struct neighbour *neigh_create(struct neigh_table *tbl, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | const void *pkey, |
David S. Miller | a263b30 | 2012-07-02 02:02:15 -0700 | [diff] [blame] | 211 | struct net_device *dev) |
| 212 | { |
| 213 | return __neigh_create(tbl, pkey, dev, true); |
| 214 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | extern void neigh_destroy(struct neighbour *neigh); |
| 216 | extern int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb); |
| 217 | extern int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, |
| 218 | u32 flags); |
| 219 | extern void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev); |
| 220 | 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] | 221 | extern int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb); |
| 222 | extern int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb); |
| 223 | extern int neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb); |
| 224 | extern int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | extern struct neighbour *neigh_event_ns(struct neigh_table *tbl, |
| 226 | u8 *lladdr, void *saddr, |
| 227 | struct net_device *dev); |
| 228 | |
| 229 | extern struct neigh_parms *neigh_parms_alloc(struct net_device *dev, struct neigh_table *tbl); |
| 230 | 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] | 231 | |
| 232 | static inline |
| 233 | struct net *neigh_parms_net(const struct neigh_parms *parms) |
| 234 | { |
Eric Dumazet | e42ea98 | 2008-11-12 00:54:54 -0800 | [diff] [blame] | 235 | return read_pnet(&parms->net); |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 236 | } |
| 237 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | extern unsigned long neigh_rand_reach_time(unsigned long base); |
| 239 | |
| 240 | extern void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, |
| 241 | struct sk_buff *skb); |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 242 | 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] | 243 | extern struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl, |
| 244 | struct net *net, |
| 245 | const void *key, |
| 246 | struct net_device *dev); |
Eric W. Biederman | 426b530 | 2008-01-24 00:13:18 -0800 | [diff] [blame] | 247 | 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] | 248 | |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 249 | static inline |
| 250 | struct net *pneigh_net(const struct pneigh_entry *pneigh) |
| 251 | { |
Eric Dumazet | e42ea98 | 2008-11-12 00:54:54 -0800 | [diff] [blame] | 252 | return read_pnet(&pneigh->net); |
YOSHIFUJI Hideaki | 57da52c | 2008-03-26 03:49:59 +0900 | [diff] [blame] | 253 | } |
| 254 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | extern void neigh_app_ns(struct neighbour *n); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | extern void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie); |
| 257 | extern void __neigh_for_each_release(struct neigh_table *tbl, int (*cb)(struct neighbour *)); |
| 258 | extern void pneigh_for_each(struct neigh_table *tbl, void (*cb)(struct pneigh_entry *)); |
| 259 | |
| 260 | struct neigh_seq_state { |
Denis V. Lunev | 4250846 | 2008-01-10 03:53:12 -0800 | [diff] [blame] | 261 | struct seq_net_private p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | struct neigh_table *tbl; |
Eric Dumazet | d6bf781 | 2010-10-04 06:15:44 +0000 | [diff] [blame] | 263 | struct neigh_hash_table *nht; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | void *(*neigh_sub_iter)(struct neigh_seq_state *state, |
| 265 | struct neighbour *n, loff_t *pos); |
| 266 | unsigned int bucket; |
| 267 | unsigned int flags; |
| 268 | #define NEIGH_SEQ_NEIGH_ONLY 0x00000001 |
| 269 | #define NEIGH_SEQ_IS_PNEIGH 0x00000002 |
| 270 | #define NEIGH_SEQ_SKIP_NOARP 0x00000004 |
| 271 | }; |
| 272 | extern void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *, unsigned int); |
| 273 | extern void *neigh_seq_next(struct seq_file *, void *, loff_t *); |
| 274 | extern void neigh_seq_stop(struct seq_file *, void *); |
| 275 | |
| 276 | extern int neigh_sysctl_register(struct net_device *dev, |
| 277 | struct neigh_parms *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | char *p_name, |
Eric W. Biederman | f8572d8 | 2009-11-05 13:32:03 -0800 | [diff] [blame] | 279 | proc_handler *proc_handler); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | extern void neigh_sysctl_unregister(struct neigh_parms *p); |
| 281 | |
| 282 | static inline void __neigh_parms_put(struct neigh_parms *parms) |
| 283 | { |
| 284 | atomic_dec(&parms->refcnt); |
| 285 | } |
| 286 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 287 | static inline struct neigh_parms *neigh_parms_clone(struct neigh_parms *parms) |
| 288 | { |
| 289 | atomic_inc(&parms->refcnt); |
| 290 | return parms; |
| 291 | } |
| 292 | |
| 293 | /* |
| 294 | * Neighbour references |
| 295 | */ |
| 296 | |
| 297 | static inline void neigh_release(struct neighbour *neigh) |
| 298 | { |
| 299 | if (atomic_dec_and_test(&neigh->refcnt)) |
| 300 | neigh_destroy(neigh); |
| 301 | } |
| 302 | |
| 303 | static inline struct neighbour * neigh_clone(struct neighbour *neigh) |
| 304 | { |
| 305 | if (neigh) |
| 306 | atomic_inc(&neigh->refcnt); |
| 307 | return neigh; |
| 308 | } |
| 309 | |
| 310 | #define neigh_hold(n) atomic_inc(&(n)->refcnt) |
| 311 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 312 | static inline int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) |
| 313 | { |
Tetsuo Handa | ef22b7b | 2010-11-18 09:40:04 -0800 | [diff] [blame] | 314 | unsigned long now = jiffies; |
Eric Dumazet | 0ed8ddf | 2010-10-07 10:44:07 +0000 | [diff] [blame] | 315 | |
| 316 | if (neigh->used != now) |
| 317 | neigh->used = now; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 318 | if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE))) |
| 319 | return __neigh_event_send(neigh, skb); |
| 320 | return 0; |
| 321 | } |
| 322 | |
Bart De Schuymer | e179e63 | 2010-04-15 12:26:39 +0200 | [diff] [blame] | 323 | #ifdef CONFIG_BRIDGE_NETFILTER |
| 324 | static inline int neigh_hh_bridge(struct hh_cache *hh, struct sk_buff *skb) |
| 325 | { |
Eric Dumazet | 95c9617 | 2012-04-15 05:58:06 +0000 | [diff] [blame] | 326 | unsigned int seq, hh_alen; |
Bart De Schuymer | e179e63 | 2010-04-15 12:26:39 +0200 | [diff] [blame] | 327 | |
| 328 | do { |
| 329 | seq = read_seqbegin(&hh->hh_lock); |
| 330 | hh_alen = HH_DATA_ALIGN(ETH_HLEN); |
| 331 | memcpy(skb->data - hh_alen, hh->hh_data, ETH_ALEN + hh_alen - ETH_HLEN); |
| 332 | } while (read_seqretry(&hh->hh_lock, seq)); |
| 333 | return 0; |
| 334 | } |
| 335 | #endif |
| 336 | |
Stephen Hemminger | 3644f0c | 2006-12-07 15:08:17 -0800 | [diff] [blame] | 337 | static inline int neigh_hh_output(struct hh_cache *hh, struct sk_buff *skb) |
| 338 | { |
Eric Dumazet | 95c9617 | 2012-04-15 05:58:06 +0000 | [diff] [blame] | 339 | unsigned int seq; |
Stephen Hemminger | 3644f0c | 2006-12-07 15:08:17 -0800 | [diff] [blame] | 340 | int hh_len; |
| 341 | |
| 342 | do { |
| 343 | int hh_alen; |
| 344 | |
| 345 | seq = read_seqbegin(&hh->hh_lock); |
| 346 | hh_len = hh->hh_len; |
| 347 | hh_alen = HH_DATA_ALIGN(hh_len); |
| 348 | memcpy(skb->data - hh_alen, hh->hh_data, hh_alen); |
| 349 | } while (read_seqretry(&hh->hh_lock, seq)); |
| 350 | |
| 351 | skb_push(skb, hh_len); |
David S. Miller | b23b545 | 2011-07-16 17:45:02 -0700 | [diff] [blame] | 352 | return dev_queue_xmit(skb); |
Stephen Hemminger | 3644f0c | 2006-12-07 15:08:17 -0800 | [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 |