1 #ifndef _NET_NEIGHBOUR_H 2 #define _NET_NEIGHBOUR_H 3 4 #include <linux/neighbour.h> 5 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 19 #include <linux/atomic.h> 20 #include <linux/netdevice.h> 21 #include <linux/skbuff.h> 22 #include <linux/rcupdate.h> 23 #include <linux/seq_file.h> 24 25 #include <linux/err.h> 26 #include <linux/sysctl.h> 27 #include <linux/workqueue.h> 28 #include <net/rtnetlink.h> 29 30 /* 31 * NUD stands for "neighbor unreachability detection" 32 */ 33 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 40 enum { 41 NEIGH_VAR_MCAST_PROBES, 42 NEIGH_VAR_UCAST_PROBES, 43 NEIGH_VAR_APP_PROBES, 44 NEIGH_VAR_RETRANS_TIME, 45 NEIGH_VAR_BASE_REACHABLE_TIME, 46 NEIGH_VAR_DELAY_PROBE_TIME, 47 NEIGH_VAR_GC_STALETIME, 48 NEIGH_VAR_QUEUE_LEN_BYTES, 49 NEIGH_VAR_PROXY_QLEN, 50 NEIGH_VAR_ANYCAST_DELAY, 51 NEIGH_VAR_PROXY_DELAY, 52 NEIGH_VAR_LOCKTIME, 53 #define NEIGH_VAR_DATA_MAX (NEIGH_VAR_LOCKTIME + 1) 54 /* Following are used as a second way to access one of the above */ 55 NEIGH_VAR_QUEUE_LEN, /* same data as NEIGH_VAR_QUEUE_LEN_BYTES */ 56 NEIGH_VAR_RETRANS_TIME_MS, /* same data as NEIGH_VAR_RETRANS_TIME */ 57 NEIGH_VAR_BASE_REACHABLE_TIME_MS, /* same data as NEIGH_VAR_BASE_REACHABLE_TIME */ 58 /* Following are used by "default" only */ 59 NEIGH_VAR_GC_INTERVAL, 60 NEIGH_VAR_GC_THRESH1, 61 NEIGH_VAR_GC_THRESH2, 62 NEIGH_VAR_GC_THRESH3, 63 NEIGH_VAR_MAX 64 }; 65 66 struct neigh_parms { 67 #ifdef CONFIG_NET_NS 68 struct net *net; 69 #endif 70 struct net_device *dev; 71 struct neigh_parms *next; 72 int (*neigh_setup)(struct neighbour *); 73 void (*neigh_cleanup)(struct neighbour *); 74 struct neigh_table *tbl; 75 76 void *sysctl_table; 77 78 int dead; 79 atomic_t refcnt; 80 struct rcu_head rcu_head; 81 82 int reachable_time; 83 int data[NEIGH_VAR_DATA_MAX]; 84 }; 85 86 static inline void neigh_var_set(struct neigh_parms *p, int index, int val) 87 { 88 p->data[index] = val; 89 } 90 91 #define NEIGH_VAR(p, attr) ((p)->data[NEIGH_VAR_ ## attr]) 92 #define NEIGH_VAR_SET(p, attr, val) neigh_var_set(p, NEIGH_VAR_ ## attr, val) 93 94 struct neigh_statistics { 95 unsigned long allocs; /* number of allocated neighs */ 96 unsigned long destroys; /* number of destroyed neighs */ 97 unsigned long hash_grows; /* number of hash resizes */ 98 99 unsigned long res_failed; /* number of failed resolutions */ 100 101 unsigned long lookups; /* number of lookups */ 102 unsigned long hits; /* number of hits (among lookups) */ 103 104 unsigned long rcv_probes_mcast; /* number of received mcast ipv6 */ 105 unsigned long rcv_probes_ucast; /* number of received ucast ipv6 */ 106 107 unsigned long periodic_gc_runs; /* number of periodic GC runs */ 108 unsigned long forced_gc_runs; /* number of forced GC runs */ 109 110 unsigned long unres_discards; /* number of unresolved drops */ 111 }; 112 113 #define NEIGH_CACHE_STAT_INC(tbl, field) this_cpu_inc((tbl)->stats->field) 114 115 struct neighbour { 116 struct neighbour __rcu *next; 117 struct neigh_table *tbl; 118 struct neigh_parms *parms; 119 unsigned long confirmed; 120 unsigned long updated; 121 rwlock_t lock; 122 atomic_t refcnt; 123 struct sk_buff_head arp_queue; 124 unsigned int arp_queue_len_bytes; 125 struct timer_list timer; 126 unsigned long used; 127 atomic_t probes; 128 __u8 flags; 129 __u8 nud_state; 130 __u8 type; 131 __u8 dead; 132 seqlock_t ha_lock; 133 unsigned char ha[ALIGN(MAX_ADDR_LEN, sizeof(unsigned long))]; 134 struct hh_cache hh; 135 int (*output)(struct neighbour *, struct sk_buff *); 136 const struct neigh_ops *ops; 137 struct rcu_head rcu; 138 struct net_device *dev; 139 u8 primary_key[0]; 140 }; 141 142 struct neigh_ops { 143 int family; 144 void (*solicit)(struct neighbour *, struct sk_buff *); 145 void (*error_report)(struct neighbour *, struct sk_buff *); 146 int (*output)(struct neighbour *, struct sk_buff *); 147 int (*connected_output)(struct neighbour *, struct sk_buff *); 148 }; 149 150 struct pneigh_entry { 151 struct pneigh_entry *next; 152 #ifdef CONFIG_NET_NS 153 struct net *net; 154 #endif 155 struct net_device *dev; 156 u8 flags; 157 u8 key[0]; 158 }; 159 160 /* 161 * neighbour table manipulation 162 */ 163 164 #define NEIGH_NUM_HASH_RND 4 165 166 struct neigh_hash_table { 167 struct neighbour __rcu **hash_buckets; 168 unsigned int hash_shift; 169 __u32 hash_rnd[NEIGH_NUM_HASH_RND]; 170 struct rcu_head rcu; 171 }; 172 173 174 struct neigh_table { 175 struct neigh_table *next; 176 int family; 177 int entry_size; 178 int key_len; 179 __u32 (*hash)(const void *pkey, 180 const struct net_device *dev, 181 __u32 *hash_rnd); 182 int (*constructor)(struct neighbour *); 183 int (*pconstructor)(struct pneigh_entry *); 184 void (*pdestructor)(struct pneigh_entry *); 185 void (*proxy_redo)(struct sk_buff *skb); 186 char *id; 187 struct neigh_parms parms; 188 /* HACK. gc_* should follow parms without a gap! */ 189 int gc_interval; 190 int gc_thresh1; 191 int gc_thresh2; 192 int gc_thresh3; 193 unsigned long last_flush; 194 struct delayed_work gc_work; 195 struct timer_list proxy_timer; 196 struct sk_buff_head proxy_queue; 197 atomic_t entries; 198 rwlock_t lock; 199 unsigned long last_rand; 200 struct neigh_statistics __percpu *stats; 201 struct neigh_hash_table __rcu *nht; 202 struct pneigh_entry **phash_buckets; 203 }; 204 205 static inline int neigh_parms_family(struct neigh_parms *p) 206 { 207 return p->tbl->family; 208 } 209 210 #define NEIGH_PRIV_ALIGN sizeof(long long) 211 #define NEIGH_ENTRY_SIZE(size) ALIGN((size), NEIGH_PRIV_ALIGN) 212 213 static inline void *neighbour_priv(const struct neighbour *n) 214 { 215 return (char *)n + n->tbl->entry_size; 216 } 217 218 /* flags for neigh_update() */ 219 #define NEIGH_UPDATE_F_OVERRIDE 0x00000001 220 #define NEIGH_UPDATE_F_WEAK_OVERRIDE 0x00000002 221 #define NEIGH_UPDATE_F_OVERRIDE_ISROUTER 0x00000004 222 #define NEIGH_UPDATE_F_ISROUTER 0x40000000 223 #define NEIGH_UPDATE_F_ADMIN 0x80000000 224 225 void neigh_table_init(struct neigh_table *tbl); 226 int neigh_table_clear(struct neigh_table *tbl); 227 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey, 228 struct net_device *dev); 229 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net, 230 const void *pkey); 231 struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey, 232 struct net_device *dev, bool want_ref); 233 static inline struct neighbour *neigh_create(struct neigh_table *tbl, 234 const void *pkey, 235 struct net_device *dev) 236 { 237 return __neigh_create(tbl, pkey, dev, true); 238 } 239 void neigh_destroy(struct neighbour *neigh); 240 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb); 241 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, u32 flags); 242 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev); 243 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev); 244 int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb); 245 int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb); 246 int neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb); 247 int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb); 248 struct neighbour *neigh_event_ns(struct neigh_table *tbl, 249 u8 *lladdr, void *saddr, 250 struct net_device *dev); 251 252 struct neigh_parms *neigh_parms_alloc(struct net_device *dev, 253 struct neigh_table *tbl); 254 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms); 255 256 static inline 257 struct net *neigh_parms_net(const struct neigh_parms *parms) 258 { 259 return read_pnet(&parms->net); 260 } 261 262 unsigned long neigh_rand_reach_time(unsigned long base); 263 264 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, 265 struct sk_buff *skb); 266 struct pneigh_entry *pneigh_lookup(struct neigh_table *tbl, struct net *net, 267 const void *key, struct net_device *dev, 268 int creat); 269 struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl, struct net *net, 270 const void *key, struct net_device *dev); 271 int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *key, 272 struct net_device *dev); 273 274 static inline struct net *pneigh_net(const struct pneigh_entry *pneigh) 275 { 276 return read_pnet(&pneigh->net); 277 } 278 279 void neigh_app_ns(struct neighbour *n); 280 void neigh_for_each(struct neigh_table *tbl, 281 void (*cb)(struct neighbour *, void *), void *cookie); 282 void __neigh_for_each_release(struct neigh_table *tbl, 283 int (*cb)(struct neighbour *)); 284 void pneigh_for_each(struct neigh_table *tbl, 285 void (*cb)(struct pneigh_entry *)); 286 287 struct neigh_seq_state { 288 struct seq_net_private p; 289 struct neigh_table *tbl; 290 struct neigh_hash_table *nht; 291 void *(*neigh_sub_iter)(struct neigh_seq_state *state, 292 struct neighbour *n, loff_t *pos); 293 unsigned int bucket; 294 unsigned int flags; 295 #define NEIGH_SEQ_NEIGH_ONLY 0x00000001 296 #define NEIGH_SEQ_IS_PNEIGH 0x00000002 297 #define NEIGH_SEQ_SKIP_NOARP 0x00000004 298 }; 299 void *neigh_seq_start(struct seq_file *, loff_t *, struct neigh_table *, 300 unsigned int); 301 void *neigh_seq_next(struct seq_file *, void *, loff_t *); 302 void neigh_seq_stop(struct seq_file *, void *); 303 304 int neigh_proc_dointvec(struct ctl_table *ctl, int write, 305 void __user *buffer, size_t *lenp, loff_t *ppos); 306 int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write, 307 void __user *buffer, 308 size_t *lenp, loff_t *ppos); 309 int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write, 310 void __user *buffer, 311 size_t *lenp, loff_t *ppos); 312 313 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, 314 proc_handler *proc_handler); 315 void neigh_sysctl_unregister(struct neigh_parms *p); 316 317 static inline void __neigh_parms_put(struct neigh_parms *parms) 318 { 319 atomic_dec(&parms->refcnt); 320 } 321 322 static inline struct neigh_parms *neigh_parms_clone(struct neigh_parms *parms) 323 { 324 atomic_inc(&parms->refcnt); 325 return parms; 326 } 327 328 /* 329 * Neighbour references 330 */ 331 332 static inline void neigh_release(struct neighbour *neigh) 333 { 334 if (atomic_dec_and_test(&neigh->refcnt)) 335 neigh_destroy(neigh); 336 } 337 338 static inline struct neighbour * neigh_clone(struct neighbour *neigh) 339 { 340 if (neigh) 341 atomic_inc(&neigh->refcnt); 342 return neigh; 343 } 344 345 #define neigh_hold(n) atomic_inc(&(n)->refcnt) 346 347 static inline int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) 348 { 349 unsigned long now = jiffies; 350 351 if (neigh->used != now) 352 neigh->used = now; 353 if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE))) 354 return __neigh_event_send(neigh, skb); 355 return 0; 356 } 357 358 #ifdef CONFIG_BRIDGE_NETFILTER 359 static inline int neigh_hh_bridge(struct hh_cache *hh, struct sk_buff *skb) 360 { 361 unsigned int seq, hh_alen; 362 363 do { 364 seq = read_seqbegin(&hh->hh_lock); 365 hh_alen = HH_DATA_ALIGN(ETH_HLEN); 366 memcpy(skb->data - hh_alen, hh->hh_data, ETH_ALEN + hh_alen - ETH_HLEN); 367 } while (read_seqretry(&hh->hh_lock, seq)); 368 return 0; 369 } 370 #endif 371 372 static inline int neigh_hh_output(const struct hh_cache *hh, struct sk_buff *skb) 373 { 374 unsigned int seq; 375 int hh_len; 376 377 do { 378 seq = read_seqbegin(&hh->hh_lock); 379 hh_len = hh->hh_len; 380 if (likely(hh_len <= HH_DATA_MOD)) { 381 /* this is inlined by gcc */ 382 memcpy(skb->data - HH_DATA_MOD, hh->hh_data, HH_DATA_MOD); 383 } else { 384 int hh_alen = HH_DATA_ALIGN(hh_len); 385 386 memcpy(skb->data - hh_alen, hh->hh_data, hh_alen); 387 } 388 } while (read_seqretry(&hh->hh_lock, seq)); 389 390 skb_push(skb, hh_len); 391 return dev_queue_xmit(skb); 392 } 393 394 static inline struct neighbour * 395 __neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat) 396 { 397 struct neighbour *n = neigh_lookup(tbl, pkey, dev); 398 399 if (n || !creat) 400 return n; 401 402 n = neigh_create(tbl, pkey, dev); 403 return IS_ERR(n) ? NULL : n; 404 } 405 406 static inline struct neighbour * 407 __neigh_lookup_errno(struct neigh_table *tbl, const void *pkey, 408 struct net_device *dev) 409 { 410 struct neighbour *n = neigh_lookup(tbl, pkey, dev); 411 412 if (n) 413 return n; 414 415 return neigh_create(tbl, pkey, dev); 416 } 417 418 struct neighbour_cb { 419 unsigned long sched_next; 420 unsigned int flags; 421 }; 422 423 #define LOCALLY_ENQUEUED 0x1 424 425 #define NEIGH_CB(skb) ((struct neighbour_cb *)(skb)->cb) 426 427 static inline void neigh_ha_snapshot(char *dst, const struct neighbour *n, 428 const struct net_device *dev) 429 { 430 unsigned int seq; 431 432 do { 433 seq = read_seqbegin(&n->ha_lock); 434 memcpy(dst, n->ha, dev->addr_len); 435 } while (read_seqretry(&n->ha_lock, seq)); 436 } 437 #endif 438