1 /* 2 * Generic address resolution entity 3 * 4 * Authors: 5 * Pedro Roque <roque@di.fc.ul.pt> 6 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 * 13 * Fixes: 14 * Vitaly E. Lavrov releasing NULL neighbor in neigh_add. 15 * Harald Welte Add neighbour cache statistics like rtstat 16 */ 17 18 #include <linux/config.h> 19 #include <linux/types.h> 20 #include <linux/kernel.h> 21 #include <linux/module.h> 22 #include <linux/socket.h> 23 #include <linux/sched.h> 24 #include <linux/netdevice.h> 25 #include <linux/proc_fs.h> 26 #ifdef CONFIG_SYSCTL 27 #include <linux/sysctl.h> 28 #endif 29 #include <linux/times.h> 30 #include <net/neighbour.h> 31 #include <net/dst.h> 32 #include <net/sock.h> 33 #include <linux/rtnetlink.h> 34 #include <linux/random.h> 35 #include <linux/string.h> 36 37 #define NEIGH_DEBUG 1 38 39 #define NEIGH_PRINTK(x...) printk(x) 40 #define NEIGH_NOPRINTK(x...) do { ; } while(0) 41 #define NEIGH_PRINTK0 NEIGH_PRINTK 42 #define NEIGH_PRINTK1 NEIGH_NOPRINTK 43 #define NEIGH_PRINTK2 NEIGH_NOPRINTK 44 45 #if NEIGH_DEBUG >= 1 46 #undef NEIGH_PRINTK1 47 #define NEIGH_PRINTK1 NEIGH_PRINTK 48 #endif 49 #if NEIGH_DEBUG >= 2 50 #undef NEIGH_PRINTK2 51 #define NEIGH_PRINTK2 NEIGH_PRINTK 52 #endif 53 54 #define PNEIGH_HASHMASK 0xF 55 56 static void neigh_timer_handler(unsigned long arg); 57 #ifdef CONFIG_ARPD 58 static void neigh_app_notify(struct neighbour *n); 59 #endif 60 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev); 61 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev); 62 63 static struct neigh_table *neigh_tables; 64 #ifdef CONFIG_PROC_FS 65 static struct file_operations neigh_stat_seq_fops; 66 #endif 67 68 /* 69 Neighbour hash table buckets are protected with rwlock tbl->lock. 70 71 - All the scans/updates to hash buckets MUST be made under this lock. 72 - NOTHING clever should be made under this lock: no callbacks 73 to protocol backends, no attempts to send something to network. 74 It will result in deadlocks, if backend/driver wants to use neighbour 75 cache. 76 - If the entry requires some non-trivial actions, increase 77 its reference count and release table lock. 78 79 Neighbour entries are protected: 80 - with reference count. 81 - with rwlock neigh->lock 82 83 Reference count prevents destruction. 84 85 neigh->lock mainly serializes ll address data and its validity state. 86 However, the same lock is used to protect another entry fields: 87 - timer 88 - resolution queue 89 90 Again, nothing clever shall be made under neigh->lock, 91 the most complicated procedure, which we allow is dev->hard_header. 92 It is supposed, that dev->hard_header is simplistic and does 93 not make callbacks to neighbour tables. 94 95 The last lock is neigh_tbl_lock. It is pure SMP lock, protecting 96 list of neighbour tables. This list is used only in process context, 97 */ 98 99 static DEFINE_RWLOCK(neigh_tbl_lock); 100 101 static int neigh_blackhole(struct sk_buff *skb) 102 { 103 kfree_skb(skb); 104 return -ENETDOWN; 105 } 106 107 /* 108 * It is random distribution in the interval (1/2)*base...(3/2)*base. 109 * It corresponds to default IPv6 settings and is not overridable, 110 * because it is really reasonable choice. 111 */ 112 113 unsigned long neigh_rand_reach_time(unsigned long base) 114 { 115 return (base ? (net_random() % base) + (base >> 1) : 0); 116 } 117 118 119 static int neigh_forced_gc(struct neigh_table *tbl) 120 { 121 int shrunk = 0; 122 int i; 123 124 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs); 125 126 write_lock_bh(&tbl->lock); 127 for (i = 0; i <= tbl->hash_mask; i++) { 128 struct neighbour *n, **np; 129 130 np = &tbl->hash_buckets[i]; 131 while ((n = *np) != NULL) { 132 /* Neighbour record may be discarded if: 133 * - nobody refers to it. 134 * - it is not permanent 135 */ 136 write_lock(&n->lock); 137 if (atomic_read(&n->refcnt) == 1 && 138 !(n->nud_state & NUD_PERMANENT)) { 139 *np = n->next; 140 n->dead = 1; 141 shrunk = 1; 142 write_unlock(&n->lock); 143 neigh_release(n); 144 continue; 145 } 146 write_unlock(&n->lock); 147 np = &n->next; 148 } 149 } 150 151 tbl->last_flush = jiffies; 152 153 write_unlock_bh(&tbl->lock); 154 155 return shrunk; 156 } 157 158 static int neigh_del_timer(struct neighbour *n) 159 { 160 if ((n->nud_state & NUD_IN_TIMER) && 161 del_timer(&n->timer)) { 162 neigh_release(n); 163 return 1; 164 } 165 return 0; 166 } 167 168 static void pneigh_queue_purge(struct sk_buff_head *list) 169 { 170 struct sk_buff *skb; 171 172 while ((skb = skb_dequeue(list)) != NULL) { 173 dev_put(skb->dev); 174 kfree_skb(skb); 175 } 176 } 177 178 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev) 179 { 180 int i; 181 182 for (i = 0; i <= tbl->hash_mask; i++) { 183 struct neighbour *n, **np = &tbl->hash_buckets[i]; 184 185 while ((n = *np) != NULL) { 186 if (dev && n->dev != dev) { 187 np = &n->next; 188 continue; 189 } 190 *np = n->next; 191 write_lock(&n->lock); 192 neigh_del_timer(n); 193 n->dead = 1; 194 195 if (atomic_read(&n->refcnt) != 1) { 196 /* The most unpleasant situation. 197 We must destroy neighbour entry, 198 but someone still uses it. 199 200 The destroy will be delayed until 201 the last user releases us, but 202 we must kill timers etc. and move 203 it to safe state. 204 */ 205 skb_queue_purge(&n->arp_queue); 206 n->output = neigh_blackhole; 207 if (n->nud_state & NUD_VALID) 208 n->nud_state = NUD_NOARP; 209 else 210 n->nud_state = NUD_NONE; 211 NEIGH_PRINTK2("neigh %p is stray.\n", n); 212 } 213 write_unlock(&n->lock); 214 neigh_release(n); 215 } 216 } 217 } 218 219 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev) 220 { 221 write_lock_bh(&tbl->lock); 222 neigh_flush_dev(tbl, dev); 223 write_unlock_bh(&tbl->lock); 224 } 225 226 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 227 { 228 write_lock_bh(&tbl->lock); 229 neigh_flush_dev(tbl, dev); 230 pneigh_ifdown(tbl, dev); 231 write_unlock_bh(&tbl->lock); 232 233 del_timer_sync(&tbl->proxy_timer); 234 pneigh_queue_purge(&tbl->proxy_queue); 235 return 0; 236 } 237 238 static struct neighbour *neigh_alloc(struct neigh_table *tbl) 239 { 240 struct neighbour *n = NULL; 241 unsigned long now = jiffies; 242 int entries; 243 244 entries = atomic_inc_return(&tbl->entries) - 1; 245 if (entries >= tbl->gc_thresh3 || 246 (entries >= tbl->gc_thresh2 && 247 time_after(now, tbl->last_flush + 5 * HZ))) { 248 if (!neigh_forced_gc(tbl) && 249 entries >= tbl->gc_thresh3) 250 goto out_entries; 251 } 252 253 n = kmem_cache_alloc(tbl->kmem_cachep, SLAB_ATOMIC); 254 if (!n) 255 goto out_entries; 256 257 memset(n, 0, tbl->entry_size); 258 259 skb_queue_head_init(&n->arp_queue); 260 rwlock_init(&n->lock); 261 n->updated = n->used = now; 262 n->nud_state = NUD_NONE; 263 n->output = neigh_blackhole; 264 n->parms = neigh_parms_clone(&tbl->parms); 265 init_timer(&n->timer); 266 n->timer.function = neigh_timer_handler; 267 n->timer.data = (unsigned long)n; 268 269 NEIGH_CACHE_STAT_INC(tbl, allocs); 270 n->tbl = tbl; 271 atomic_set(&n->refcnt, 1); 272 n->dead = 1; 273 out: 274 return n; 275 276 out_entries: 277 atomic_dec(&tbl->entries); 278 goto out; 279 } 280 281 static struct neighbour **neigh_hash_alloc(unsigned int entries) 282 { 283 unsigned long size = entries * sizeof(struct neighbour *); 284 struct neighbour **ret; 285 286 if (size <= PAGE_SIZE) { 287 ret = kzalloc(size, GFP_ATOMIC); 288 } else { 289 ret = (struct neighbour **) 290 __get_free_pages(GFP_ATOMIC|__GFP_ZERO, get_order(size)); 291 } 292 return ret; 293 } 294 295 static void neigh_hash_free(struct neighbour **hash, unsigned int entries) 296 { 297 unsigned long size = entries * sizeof(struct neighbour *); 298 299 if (size <= PAGE_SIZE) 300 kfree(hash); 301 else 302 free_pages((unsigned long)hash, get_order(size)); 303 } 304 305 static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries) 306 { 307 struct neighbour **new_hash, **old_hash; 308 unsigned int i, new_hash_mask, old_entries; 309 310 NEIGH_CACHE_STAT_INC(tbl, hash_grows); 311 312 BUG_ON(new_entries & (new_entries - 1)); 313 new_hash = neigh_hash_alloc(new_entries); 314 if (!new_hash) 315 return; 316 317 old_entries = tbl->hash_mask + 1; 318 new_hash_mask = new_entries - 1; 319 old_hash = tbl->hash_buckets; 320 321 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd)); 322 for (i = 0; i < old_entries; i++) { 323 struct neighbour *n, *next; 324 325 for (n = old_hash[i]; n; n = next) { 326 unsigned int hash_val = tbl->hash(n->primary_key, n->dev); 327 328 hash_val &= new_hash_mask; 329 next = n->next; 330 331 n->next = new_hash[hash_val]; 332 new_hash[hash_val] = n; 333 } 334 } 335 tbl->hash_buckets = new_hash; 336 tbl->hash_mask = new_hash_mask; 337 338 neigh_hash_free(old_hash, old_entries); 339 } 340 341 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey, 342 struct net_device *dev) 343 { 344 struct neighbour *n; 345 int key_len = tbl->key_len; 346 u32 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask; 347 348 NEIGH_CACHE_STAT_INC(tbl, lookups); 349 350 read_lock_bh(&tbl->lock); 351 for (n = tbl->hash_buckets[hash_val]; n; n = n->next) { 352 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) { 353 neigh_hold(n); 354 NEIGH_CACHE_STAT_INC(tbl, hits); 355 break; 356 } 357 } 358 read_unlock_bh(&tbl->lock); 359 return n; 360 } 361 362 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, const void *pkey) 363 { 364 struct neighbour *n; 365 int key_len = tbl->key_len; 366 u32 hash_val = tbl->hash(pkey, NULL) & tbl->hash_mask; 367 368 NEIGH_CACHE_STAT_INC(tbl, lookups); 369 370 read_lock_bh(&tbl->lock); 371 for (n = tbl->hash_buckets[hash_val]; n; n = n->next) { 372 if (!memcmp(n->primary_key, pkey, key_len)) { 373 neigh_hold(n); 374 NEIGH_CACHE_STAT_INC(tbl, hits); 375 break; 376 } 377 } 378 read_unlock_bh(&tbl->lock); 379 return n; 380 } 381 382 struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey, 383 struct net_device *dev) 384 { 385 u32 hash_val; 386 int key_len = tbl->key_len; 387 int error; 388 struct neighbour *n1, *rc, *n = neigh_alloc(tbl); 389 390 if (!n) { 391 rc = ERR_PTR(-ENOBUFS); 392 goto out; 393 } 394 395 memcpy(n->primary_key, pkey, key_len); 396 n->dev = dev; 397 dev_hold(dev); 398 399 /* Protocol specific setup. */ 400 if (tbl->constructor && (error = tbl->constructor(n)) < 0) { 401 rc = ERR_PTR(error); 402 goto out_neigh_release; 403 } 404 405 /* Device specific setup. */ 406 if (n->parms->neigh_setup && 407 (error = n->parms->neigh_setup(n)) < 0) { 408 rc = ERR_PTR(error); 409 goto out_neigh_release; 410 } 411 412 n->confirmed = jiffies - (n->parms->base_reachable_time << 1); 413 414 write_lock_bh(&tbl->lock); 415 416 if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1)) 417 neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1); 418 419 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask; 420 421 if (n->parms->dead) { 422 rc = ERR_PTR(-EINVAL); 423 goto out_tbl_unlock; 424 } 425 426 for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) { 427 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) { 428 neigh_hold(n1); 429 rc = n1; 430 goto out_tbl_unlock; 431 } 432 } 433 434 n->next = tbl->hash_buckets[hash_val]; 435 tbl->hash_buckets[hash_val] = n; 436 n->dead = 0; 437 neigh_hold(n); 438 write_unlock_bh(&tbl->lock); 439 NEIGH_PRINTK2("neigh %p is created.\n", n); 440 rc = n; 441 out: 442 return rc; 443 out_tbl_unlock: 444 write_unlock_bh(&tbl->lock); 445 out_neigh_release: 446 neigh_release(n); 447 goto out; 448 } 449 450 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, const void *pkey, 451 struct net_device *dev, int creat) 452 { 453 struct pneigh_entry *n; 454 int key_len = tbl->key_len; 455 u32 hash_val = *(u32 *)(pkey + key_len - 4); 456 457 hash_val ^= (hash_val >> 16); 458 hash_val ^= hash_val >> 8; 459 hash_val ^= hash_val >> 4; 460 hash_val &= PNEIGH_HASHMASK; 461 462 read_lock_bh(&tbl->lock); 463 464 for (n = tbl->phash_buckets[hash_val]; n; n = n->next) { 465 if (!memcmp(n->key, pkey, key_len) && 466 (n->dev == dev || !n->dev)) { 467 read_unlock_bh(&tbl->lock); 468 goto out; 469 } 470 } 471 read_unlock_bh(&tbl->lock); 472 n = NULL; 473 if (!creat) 474 goto out; 475 476 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL); 477 if (!n) 478 goto out; 479 480 memcpy(n->key, pkey, key_len); 481 n->dev = dev; 482 if (dev) 483 dev_hold(dev); 484 485 if (tbl->pconstructor && tbl->pconstructor(n)) { 486 if (dev) 487 dev_put(dev); 488 kfree(n); 489 n = NULL; 490 goto out; 491 } 492 493 write_lock_bh(&tbl->lock); 494 n->next = tbl->phash_buckets[hash_val]; 495 tbl->phash_buckets[hash_val] = n; 496 write_unlock_bh(&tbl->lock); 497 out: 498 return n; 499 } 500 501 502 int pneigh_delete(struct neigh_table *tbl, const void *pkey, 503 struct net_device *dev) 504 { 505 struct pneigh_entry *n, **np; 506 int key_len = tbl->key_len; 507 u32 hash_val = *(u32 *)(pkey + key_len - 4); 508 509 hash_val ^= (hash_val >> 16); 510 hash_val ^= hash_val >> 8; 511 hash_val ^= hash_val >> 4; 512 hash_val &= PNEIGH_HASHMASK; 513 514 write_lock_bh(&tbl->lock); 515 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL; 516 np = &n->next) { 517 if (!memcmp(n->key, pkey, key_len) && n->dev == dev) { 518 *np = n->next; 519 write_unlock_bh(&tbl->lock); 520 if (tbl->pdestructor) 521 tbl->pdestructor(n); 522 if (n->dev) 523 dev_put(n->dev); 524 kfree(n); 525 return 0; 526 } 527 } 528 write_unlock_bh(&tbl->lock); 529 return -ENOENT; 530 } 531 532 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 533 { 534 struct pneigh_entry *n, **np; 535 u32 h; 536 537 for (h = 0; h <= PNEIGH_HASHMASK; h++) { 538 np = &tbl->phash_buckets[h]; 539 while ((n = *np) != NULL) { 540 if (!dev || n->dev == dev) { 541 *np = n->next; 542 if (tbl->pdestructor) 543 tbl->pdestructor(n); 544 if (n->dev) 545 dev_put(n->dev); 546 kfree(n); 547 continue; 548 } 549 np = &n->next; 550 } 551 } 552 return -ENOENT; 553 } 554 555 556 /* 557 * neighbour must already be out of the table; 558 * 559 */ 560 void neigh_destroy(struct neighbour *neigh) 561 { 562 struct hh_cache *hh; 563 564 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys); 565 566 if (!neigh->dead) { 567 printk(KERN_WARNING 568 "Destroying alive neighbour %p\n", neigh); 569 dump_stack(); 570 return; 571 } 572 573 if (neigh_del_timer(neigh)) 574 printk(KERN_WARNING "Impossible event.\n"); 575 576 while ((hh = neigh->hh) != NULL) { 577 neigh->hh = hh->hh_next; 578 hh->hh_next = NULL; 579 write_lock_bh(&hh->hh_lock); 580 hh->hh_output = neigh_blackhole; 581 write_unlock_bh(&hh->hh_lock); 582 if (atomic_dec_and_test(&hh->hh_refcnt)) 583 kfree(hh); 584 } 585 586 if (neigh->parms->neigh_destructor) 587 (neigh->parms->neigh_destructor)(neigh); 588 589 skb_queue_purge(&neigh->arp_queue); 590 591 dev_put(neigh->dev); 592 neigh_parms_put(neigh->parms); 593 594 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh); 595 596 atomic_dec(&neigh->tbl->entries); 597 kmem_cache_free(neigh->tbl->kmem_cachep, neigh); 598 } 599 600 /* Neighbour state is suspicious; 601 disable fast path. 602 603 Called with write_locked neigh. 604 */ 605 static void neigh_suspect(struct neighbour *neigh) 606 { 607 struct hh_cache *hh; 608 609 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh); 610 611 neigh->output = neigh->ops->output; 612 613 for (hh = neigh->hh; hh; hh = hh->hh_next) 614 hh->hh_output = neigh->ops->output; 615 } 616 617 /* Neighbour state is OK; 618 enable fast path. 619 620 Called with write_locked neigh. 621 */ 622 static void neigh_connect(struct neighbour *neigh) 623 { 624 struct hh_cache *hh; 625 626 NEIGH_PRINTK2("neigh %p is connected.\n", neigh); 627 628 neigh->output = neigh->ops->connected_output; 629 630 for (hh = neigh->hh; hh; hh = hh->hh_next) 631 hh->hh_output = neigh->ops->hh_output; 632 } 633 634 static void neigh_periodic_timer(unsigned long arg) 635 { 636 struct neigh_table *tbl = (struct neigh_table *)arg; 637 struct neighbour *n, **np; 638 unsigned long expire, now = jiffies; 639 640 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs); 641 642 write_lock(&tbl->lock); 643 644 /* 645 * periodically recompute ReachableTime from random function 646 */ 647 648 if (time_after(now, tbl->last_rand + 300 * HZ)) { 649 struct neigh_parms *p; 650 tbl->last_rand = now; 651 for (p = &tbl->parms; p; p = p->next) 652 p->reachable_time = 653 neigh_rand_reach_time(p->base_reachable_time); 654 } 655 656 np = &tbl->hash_buckets[tbl->hash_chain_gc]; 657 tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask); 658 659 while ((n = *np) != NULL) { 660 unsigned int state; 661 662 write_lock(&n->lock); 663 664 state = n->nud_state; 665 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) { 666 write_unlock(&n->lock); 667 goto next_elt; 668 } 669 670 if (time_before(n->used, n->confirmed)) 671 n->used = n->confirmed; 672 673 if (atomic_read(&n->refcnt) == 1 && 674 (state == NUD_FAILED || 675 time_after(now, n->used + n->parms->gc_staletime))) { 676 *np = n->next; 677 n->dead = 1; 678 write_unlock(&n->lock); 679 neigh_release(n); 680 continue; 681 } 682 write_unlock(&n->lock); 683 684 next_elt: 685 np = &n->next; 686 } 687 688 /* Cycle through all hash buckets every base_reachable_time/2 ticks. 689 * ARP entry timeouts range from 1/2 base_reachable_time to 3/2 690 * base_reachable_time. 691 */ 692 expire = tbl->parms.base_reachable_time >> 1; 693 expire /= (tbl->hash_mask + 1); 694 if (!expire) 695 expire = 1; 696 697 mod_timer(&tbl->gc_timer, now + expire); 698 699 write_unlock(&tbl->lock); 700 } 701 702 static __inline__ int neigh_max_probes(struct neighbour *n) 703 { 704 struct neigh_parms *p = n->parms; 705 return (n->nud_state & NUD_PROBE ? 706 p->ucast_probes : 707 p->ucast_probes + p->app_probes + p->mcast_probes); 708 } 709 710 static inline void neigh_add_timer(struct neighbour *n, unsigned long when) 711 { 712 if (unlikely(mod_timer(&n->timer, when))) { 713 printk("NEIGH: BUG, double timer add, state is %x\n", 714 n->nud_state); 715 dump_stack(); 716 } 717 } 718 719 /* Called when a timer expires for a neighbour entry. */ 720 721 static void neigh_timer_handler(unsigned long arg) 722 { 723 unsigned long now, next; 724 struct neighbour *neigh = (struct neighbour *)arg; 725 unsigned state; 726 int notify = 0; 727 728 write_lock(&neigh->lock); 729 730 state = neigh->nud_state; 731 now = jiffies; 732 next = now + HZ; 733 734 if (!(state & NUD_IN_TIMER)) { 735 #ifndef CONFIG_SMP 736 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n"); 737 #endif 738 goto out; 739 } 740 741 if (state & NUD_REACHABLE) { 742 if (time_before_eq(now, 743 neigh->confirmed + neigh->parms->reachable_time)) { 744 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh); 745 next = neigh->confirmed + neigh->parms->reachable_time; 746 } else if (time_before_eq(now, 747 neigh->used + neigh->parms->delay_probe_time)) { 748 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh); 749 neigh->nud_state = NUD_DELAY; 750 neigh->updated = jiffies; 751 neigh_suspect(neigh); 752 next = now + neigh->parms->delay_probe_time; 753 } else { 754 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh); 755 neigh->nud_state = NUD_STALE; 756 neigh->updated = jiffies; 757 neigh_suspect(neigh); 758 } 759 } else if (state & NUD_DELAY) { 760 if (time_before_eq(now, 761 neigh->confirmed + neigh->parms->delay_probe_time)) { 762 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh); 763 neigh->nud_state = NUD_REACHABLE; 764 neigh->updated = jiffies; 765 neigh_connect(neigh); 766 next = neigh->confirmed + neigh->parms->reachable_time; 767 } else { 768 NEIGH_PRINTK2("neigh %p is probed.\n", neigh); 769 neigh->nud_state = NUD_PROBE; 770 neigh->updated = jiffies; 771 atomic_set(&neigh->probes, 0); 772 next = now + neigh->parms->retrans_time; 773 } 774 } else { 775 /* NUD_PROBE|NUD_INCOMPLETE */ 776 next = now + neigh->parms->retrans_time; 777 } 778 779 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) && 780 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) { 781 struct sk_buff *skb; 782 783 neigh->nud_state = NUD_FAILED; 784 neigh->updated = jiffies; 785 notify = 1; 786 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed); 787 NEIGH_PRINTK2("neigh %p is failed.\n", neigh); 788 789 /* It is very thin place. report_unreachable is very complicated 790 routine. Particularly, it can hit the same neighbour entry! 791 792 So that, we try to be accurate and avoid dead loop. --ANK 793 */ 794 while (neigh->nud_state == NUD_FAILED && 795 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 796 write_unlock(&neigh->lock); 797 neigh->ops->error_report(neigh, skb); 798 write_lock(&neigh->lock); 799 } 800 skb_queue_purge(&neigh->arp_queue); 801 } 802 803 if (neigh->nud_state & NUD_IN_TIMER) { 804 if (time_before(next, jiffies + HZ/2)) 805 next = jiffies + HZ/2; 806 if (!mod_timer(&neigh->timer, next)) 807 neigh_hold(neigh); 808 } 809 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) { 810 struct sk_buff *skb = skb_peek(&neigh->arp_queue); 811 /* keep skb alive even if arp_queue overflows */ 812 if (skb) 813 skb_get(skb); 814 write_unlock(&neigh->lock); 815 neigh->ops->solicit(neigh, skb); 816 atomic_inc(&neigh->probes); 817 if (skb) 818 kfree_skb(skb); 819 } else { 820 out: 821 write_unlock(&neigh->lock); 822 } 823 824 #ifdef CONFIG_ARPD 825 if (notify && neigh->parms->app_probes) 826 neigh_app_notify(neigh); 827 #endif 828 neigh_release(neigh); 829 } 830 831 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) 832 { 833 int rc; 834 unsigned long now; 835 836 write_lock_bh(&neigh->lock); 837 838 rc = 0; 839 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE)) 840 goto out_unlock_bh; 841 842 now = jiffies; 843 844 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) { 845 if (neigh->parms->mcast_probes + neigh->parms->app_probes) { 846 atomic_set(&neigh->probes, neigh->parms->ucast_probes); 847 neigh->nud_state = NUD_INCOMPLETE; 848 neigh->updated = jiffies; 849 neigh_hold(neigh); 850 neigh_add_timer(neigh, now + 1); 851 } else { 852 neigh->nud_state = NUD_FAILED; 853 neigh->updated = jiffies; 854 write_unlock_bh(&neigh->lock); 855 856 if (skb) 857 kfree_skb(skb); 858 return 1; 859 } 860 } else if (neigh->nud_state & NUD_STALE) { 861 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh); 862 neigh_hold(neigh); 863 neigh->nud_state = NUD_DELAY; 864 neigh->updated = jiffies; 865 neigh_add_timer(neigh, 866 jiffies + neigh->parms->delay_probe_time); 867 } 868 869 if (neigh->nud_state == NUD_INCOMPLETE) { 870 if (skb) { 871 if (skb_queue_len(&neigh->arp_queue) >= 872 neigh->parms->queue_len) { 873 struct sk_buff *buff; 874 buff = neigh->arp_queue.next; 875 __skb_unlink(buff, &neigh->arp_queue); 876 kfree_skb(buff); 877 } 878 __skb_queue_tail(&neigh->arp_queue, skb); 879 } 880 rc = 1; 881 } 882 out_unlock_bh: 883 write_unlock_bh(&neigh->lock); 884 return rc; 885 } 886 887 static __inline__ void neigh_update_hhs(struct neighbour *neigh) 888 { 889 struct hh_cache *hh; 890 void (*update)(struct hh_cache*, struct net_device*, unsigned char *) = 891 neigh->dev->header_cache_update; 892 893 if (update) { 894 for (hh = neigh->hh; hh; hh = hh->hh_next) { 895 write_lock_bh(&hh->hh_lock); 896 update(hh, neigh->dev, neigh->ha); 897 write_unlock_bh(&hh->hh_lock); 898 } 899 } 900 } 901 902 903 904 /* Generic update routine. 905 -- lladdr is new lladdr or NULL, if it is not supplied. 906 -- new is new state. 907 -- flags 908 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr, 909 if it is different. 910 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected" 911 lladdr instead of overriding it 912 if it is different. 913 It also allows to retain current state 914 if lladdr is unchanged. 915 NEIGH_UPDATE_F_ADMIN means that the change is administrative. 916 917 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing 918 NTF_ROUTER flag. 919 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as 920 a router. 921 922 Caller MUST hold reference count on the entry. 923 */ 924 925 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 926 u32 flags) 927 { 928 u8 old; 929 int err; 930 #ifdef CONFIG_ARPD 931 int notify = 0; 932 #endif 933 struct net_device *dev; 934 int update_isrouter = 0; 935 936 write_lock_bh(&neigh->lock); 937 938 dev = neigh->dev; 939 old = neigh->nud_state; 940 err = -EPERM; 941 942 if (!(flags & NEIGH_UPDATE_F_ADMIN) && 943 (old & (NUD_NOARP | NUD_PERMANENT))) 944 goto out; 945 946 if (!(new & NUD_VALID)) { 947 neigh_del_timer(neigh); 948 if (old & NUD_CONNECTED) 949 neigh_suspect(neigh); 950 neigh->nud_state = new; 951 err = 0; 952 #ifdef CONFIG_ARPD 953 notify = old & NUD_VALID; 954 #endif 955 goto out; 956 } 957 958 /* Compare new lladdr with cached one */ 959 if (!dev->addr_len) { 960 /* First case: device needs no address. */ 961 lladdr = neigh->ha; 962 } else if (lladdr) { 963 /* The second case: if something is already cached 964 and a new address is proposed: 965 - compare new & old 966 - if they are different, check override flag 967 */ 968 if ((old & NUD_VALID) && 969 !memcmp(lladdr, neigh->ha, dev->addr_len)) 970 lladdr = neigh->ha; 971 } else { 972 /* No address is supplied; if we know something, 973 use it, otherwise discard the request. 974 */ 975 err = -EINVAL; 976 if (!(old & NUD_VALID)) 977 goto out; 978 lladdr = neigh->ha; 979 } 980 981 if (new & NUD_CONNECTED) 982 neigh->confirmed = jiffies; 983 neigh->updated = jiffies; 984 985 /* If entry was valid and address is not changed, 986 do not change entry state, if new one is STALE. 987 */ 988 err = 0; 989 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER; 990 if (old & NUD_VALID) { 991 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) { 992 update_isrouter = 0; 993 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) && 994 (old & NUD_CONNECTED)) { 995 lladdr = neigh->ha; 996 new = NUD_STALE; 997 } else 998 goto out; 999 } else { 1000 if (lladdr == neigh->ha && new == NUD_STALE && 1001 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) || 1002 (old & NUD_CONNECTED)) 1003 ) 1004 new = old; 1005 } 1006 } 1007 1008 if (new != old) { 1009 neigh_del_timer(neigh); 1010 if (new & NUD_IN_TIMER) { 1011 neigh_hold(neigh); 1012 neigh_add_timer(neigh, (jiffies + 1013 ((new & NUD_REACHABLE) ? 1014 neigh->parms->reachable_time : 1015 0))); 1016 } 1017 neigh->nud_state = new; 1018 } 1019 1020 if (lladdr != neigh->ha) { 1021 memcpy(&neigh->ha, lladdr, dev->addr_len); 1022 neigh_update_hhs(neigh); 1023 if (!(new & NUD_CONNECTED)) 1024 neigh->confirmed = jiffies - 1025 (neigh->parms->base_reachable_time << 1); 1026 #ifdef CONFIG_ARPD 1027 notify = 1; 1028 #endif 1029 } 1030 if (new == old) 1031 goto out; 1032 if (new & NUD_CONNECTED) 1033 neigh_connect(neigh); 1034 else 1035 neigh_suspect(neigh); 1036 if (!(old & NUD_VALID)) { 1037 struct sk_buff *skb; 1038 1039 /* Again: avoid dead loop if something went wrong */ 1040 1041 while (neigh->nud_state & NUD_VALID && 1042 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 1043 struct neighbour *n1 = neigh; 1044 write_unlock_bh(&neigh->lock); 1045 /* On shaper/eql skb->dst->neighbour != neigh :( */ 1046 if (skb->dst && skb->dst->neighbour) 1047 n1 = skb->dst->neighbour; 1048 n1->output(skb); 1049 write_lock_bh(&neigh->lock); 1050 } 1051 skb_queue_purge(&neigh->arp_queue); 1052 } 1053 out: 1054 if (update_isrouter) { 1055 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ? 1056 (neigh->flags | NTF_ROUTER) : 1057 (neigh->flags & ~NTF_ROUTER); 1058 } 1059 write_unlock_bh(&neigh->lock); 1060 #ifdef CONFIG_ARPD 1061 if (notify && neigh->parms->app_probes) 1062 neigh_app_notify(neigh); 1063 #endif 1064 return err; 1065 } 1066 1067 struct neighbour *neigh_event_ns(struct neigh_table *tbl, 1068 u8 *lladdr, void *saddr, 1069 struct net_device *dev) 1070 { 1071 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev, 1072 lladdr || !dev->addr_len); 1073 if (neigh) 1074 neigh_update(neigh, lladdr, NUD_STALE, 1075 NEIGH_UPDATE_F_OVERRIDE); 1076 return neigh; 1077 } 1078 1079 static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst, 1080 u16 protocol) 1081 { 1082 struct hh_cache *hh; 1083 struct net_device *dev = dst->dev; 1084 1085 for (hh = n->hh; hh; hh = hh->hh_next) 1086 if (hh->hh_type == protocol) 1087 break; 1088 1089 if (!hh && (hh = kzalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) { 1090 rwlock_init(&hh->hh_lock); 1091 hh->hh_type = protocol; 1092 atomic_set(&hh->hh_refcnt, 0); 1093 hh->hh_next = NULL; 1094 if (dev->hard_header_cache(n, hh)) { 1095 kfree(hh); 1096 hh = NULL; 1097 } else { 1098 atomic_inc(&hh->hh_refcnt); 1099 hh->hh_next = n->hh; 1100 n->hh = hh; 1101 if (n->nud_state & NUD_CONNECTED) 1102 hh->hh_output = n->ops->hh_output; 1103 else 1104 hh->hh_output = n->ops->output; 1105 } 1106 } 1107 if (hh) { 1108 atomic_inc(&hh->hh_refcnt); 1109 dst->hh = hh; 1110 } 1111 } 1112 1113 /* This function can be used in contexts, where only old dev_queue_xmit 1114 worked, f.e. if you want to override normal output path (eql, shaper), 1115 but resolution is not made yet. 1116 */ 1117 1118 int neigh_compat_output(struct sk_buff *skb) 1119 { 1120 struct net_device *dev = skb->dev; 1121 1122 __skb_pull(skb, skb->nh.raw - skb->data); 1123 1124 if (dev->hard_header && 1125 dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL, 1126 skb->len) < 0 && 1127 dev->rebuild_header(skb)) 1128 return 0; 1129 1130 return dev_queue_xmit(skb); 1131 } 1132 1133 /* Slow and careful. */ 1134 1135 int neigh_resolve_output(struct sk_buff *skb) 1136 { 1137 struct dst_entry *dst = skb->dst; 1138 struct neighbour *neigh; 1139 int rc = 0; 1140 1141 if (!dst || !(neigh = dst->neighbour)) 1142 goto discard; 1143 1144 __skb_pull(skb, skb->nh.raw - skb->data); 1145 1146 if (!neigh_event_send(neigh, skb)) { 1147 int err; 1148 struct net_device *dev = neigh->dev; 1149 if (dev->hard_header_cache && !dst->hh) { 1150 write_lock_bh(&neigh->lock); 1151 if (!dst->hh) 1152 neigh_hh_init(neigh, dst, dst->ops->protocol); 1153 err = dev->hard_header(skb, dev, ntohs(skb->protocol), 1154 neigh->ha, NULL, skb->len); 1155 write_unlock_bh(&neigh->lock); 1156 } else { 1157 read_lock_bh(&neigh->lock); 1158 err = dev->hard_header(skb, dev, ntohs(skb->protocol), 1159 neigh->ha, NULL, skb->len); 1160 read_unlock_bh(&neigh->lock); 1161 } 1162 if (err >= 0) 1163 rc = neigh->ops->queue_xmit(skb); 1164 else 1165 goto out_kfree_skb; 1166 } 1167 out: 1168 return rc; 1169 discard: 1170 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n", 1171 dst, dst ? dst->neighbour : NULL); 1172 out_kfree_skb: 1173 rc = -EINVAL; 1174 kfree_skb(skb); 1175 goto out; 1176 } 1177 1178 /* As fast as possible without hh cache */ 1179 1180 int neigh_connected_output(struct sk_buff *skb) 1181 { 1182 int err; 1183 struct dst_entry *dst = skb->dst; 1184 struct neighbour *neigh = dst->neighbour; 1185 struct net_device *dev = neigh->dev; 1186 1187 __skb_pull(skb, skb->nh.raw - skb->data); 1188 1189 read_lock_bh(&neigh->lock); 1190 err = dev->hard_header(skb, dev, ntohs(skb->protocol), 1191 neigh->ha, NULL, skb->len); 1192 read_unlock_bh(&neigh->lock); 1193 if (err >= 0) 1194 err = neigh->ops->queue_xmit(skb); 1195 else { 1196 err = -EINVAL; 1197 kfree_skb(skb); 1198 } 1199 return err; 1200 } 1201 1202 static void neigh_proxy_process(unsigned long arg) 1203 { 1204 struct neigh_table *tbl = (struct neigh_table *)arg; 1205 long sched_next = 0; 1206 unsigned long now = jiffies; 1207 struct sk_buff *skb; 1208 1209 spin_lock(&tbl->proxy_queue.lock); 1210 1211 skb = tbl->proxy_queue.next; 1212 1213 while (skb != (struct sk_buff *)&tbl->proxy_queue) { 1214 struct sk_buff *back = skb; 1215 long tdif = NEIGH_CB(back)->sched_next - now; 1216 1217 skb = skb->next; 1218 if (tdif <= 0) { 1219 struct net_device *dev = back->dev; 1220 __skb_unlink(back, &tbl->proxy_queue); 1221 if (tbl->proxy_redo && netif_running(dev)) 1222 tbl->proxy_redo(back); 1223 else 1224 kfree_skb(back); 1225 1226 dev_put(dev); 1227 } else if (!sched_next || tdif < sched_next) 1228 sched_next = tdif; 1229 } 1230 del_timer(&tbl->proxy_timer); 1231 if (sched_next) 1232 mod_timer(&tbl->proxy_timer, jiffies + sched_next); 1233 spin_unlock(&tbl->proxy_queue.lock); 1234 } 1235 1236 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, 1237 struct sk_buff *skb) 1238 { 1239 unsigned long now = jiffies; 1240 unsigned long sched_next = now + (net_random() % p->proxy_delay); 1241 1242 if (tbl->proxy_queue.qlen > p->proxy_qlen) { 1243 kfree_skb(skb); 1244 return; 1245 } 1246 1247 NEIGH_CB(skb)->sched_next = sched_next; 1248 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED; 1249 1250 spin_lock(&tbl->proxy_queue.lock); 1251 if (del_timer(&tbl->proxy_timer)) { 1252 if (time_before(tbl->proxy_timer.expires, sched_next)) 1253 sched_next = tbl->proxy_timer.expires; 1254 } 1255 dst_release(skb->dst); 1256 skb->dst = NULL; 1257 dev_hold(skb->dev); 1258 __skb_queue_tail(&tbl->proxy_queue, skb); 1259 mod_timer(&tbl->proxy_timer, sched_next); 1260 spin_unlock(&tbl->proxy_queue.lock); 1261 } 1262 1263 1264 struct neigh_parms *neigh_parms_alloc(struct net_device *dev, 1265 struct neigh_table *tbl) 1266 { 1267 struct neigh_parms *p = kmalloc(sizeof(*p), GFP_KERNEL); 1268 1269 if (p) { 1270 memcpy(p, &tbl->parms, sizeof(*p)); 1271 p->tbl = tbl; 1272 atomic_set(&p->refcnt, 1); 1273 INIT_RCU_HEAD(&p->rcu_head); 1274 p->reachable_time = 1275 neigh_rand_reach_time(p->base_reachable_time); 1276 if (dev) { 1277 if (dev->neigh_setup && dev->neigh_setup(dev, p)) { 1278 kfree(p); 1279 return NULL; 1280 } 1281 1282 dev_hold(dev); 1283 p->dev = dev; 1284 } 1285 p->sysctl_table = NULL; 1286 write_lock_bh(&tbl->lock); 1287 p->next = tbl->parms.next; 1288 tbl->parms.next = p; 1289 write_unlock_bh(&tbl->lock); 1290 } 1291 return p; 1292 } 1293 1294 static void neigh_rcu_free_parms(struct rcu_head *head) 1295 { 1296 struct neigh_parms *parms = 1297 container_of(head, struct neigh_parms, rcu_head); 1298 1299 neigh_parms_put(parms); 1300 } 1301 1302 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms) 1303 { 1304 struct neigh_parms **p; 1305 1306 if (!parms || parms == &tbl->parms) 1307 return; 1308 write_lock_bh(&tbl->lock); 1309 for (p = &tbl->parms.next; *p; p = &(*p)->next) { 1310 if (*p == parms) { 1311 *p = parms->next; 1312 parms->dead = 1; 1313 write_unlock_bh(&tbl->lock); 1314 if (parms->dev) 1315 dev_put(parms->dev); 1316 call_rcu(&parms->rcu_head, neigh_rcu_free_parms); 1317 return; 1318 } 1319 } 1320 write_unlock_bh(&tbl->lock); 1321 NEIGH_PRINTK1("neigh_parms_release: not found\n"); 1322 } 1323 1324 void neigh_parms_destroy(struct neigh_parms *parms) 1325 { 1326 kfree(parms); 1327 } 1328 1329 void neigh_table_init_no_netlink(struct neigh_table *tbl) 1330 { 1331 unsigned long now = jiffies; 1332 unsigned long phsize; 1333 1334 atomic_set(&tbl->parms.refcnt, 1); 1335 INIT_RCU_HEAD(&tbl->parms.rcu_head); 1336 tbl->parms.reachable_time = 1337 neigh_rand_reach_time(tbl->parms.base_reachable_time); 1338 1339 if (!tbl->kmem_cachep) 1340 tbl->kmem_cachep = kmem_cache_create(tbl->id, 1341 tbl->entry_size, 1342 0, SLAB_HWCACHE_ALIGN, 1343 NULL, NULL); 1344 1345 if (!tbl->kmem_cachep) 1346 panic("cannot create neighbour cache"); 1347 1348 tbl->stats = alloc_percpu(struct neigh_statistics); 1349 if (!tbl->stats) 1350 panic("cannot create neighbour cache statistics"); 1351 1352 #ifdef CONFIG_PROC_FS 1353 tbl->pde = create_proc_entry(tbl->id, 0, proc_net_stat); 1354 if (!tbl->pde) 1355 panic("cannot create neighbour proc dir entry"); 1356 tbl->pde->proc_fops = &neigh_stat_seq_fops; 1357 tbl->pde->data = tbl; 1358 #endif 1359 1360 tbl->hash_mask = 1; 1361 tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1); 1362 1363 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *); 1364 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL); 1365 1366 if (!tbl->hash_buckets || !tbl->phash_buckets) 1367 panic("cannot allocate neighbour cache hashes"); 1368 1369 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd)); 1370 1371 rwlock_init(&tbl->lock); 1372 init_timer(&tbl->gc_timer); 1373 tbl->gc_timer.data = (unsigned long)tbl; 1374 tbl->gc_timer.function = neigh_periodic_timer; 1375 tbl->gc_timer.expires = now + 1; 1376 add_timer(&tbl->gc_timer); 1377 1378 init_timer(&tbl->proxy_timer); 1379 tbl->proxy_timer.data = (unsigned long)tbl; 1380 tbl->proxy_timer.function = neigh_proxy_process; 1381 skb_queue_head_init(&tbl->proxy_queue); 1382 1383 tbl->last_flush = now; 1384 tbl->last_rand = now + tbl->parms.reachable_time * 20; 1385 } 1386 1387 void neigh_table_init(struct neigh_table *tbl) 1388 { 1389 struct neigh_table *tmp; 1390 1391 neigh_table_init_no_netlink(tbl); 1392 write_lock(&neigh_tbl_lock); 1393 for (tmp = neigh_tables; tmp; tmp = tmp->next) { 1394 if (tmp->family == tbl->family) 1395 break; 1396 } 1397 tbl->next = neigh_tables; 1398 neigh_tables = tbl; 1399 write_unlock(&neigh_tbl_lock); 1400 1401 if (unlikely(tmp)) { 1402 printk(KERN_ERR "NEIGH: Registering multiple tables for " 1403 "family %d\n", tbl->family); 1404 dump_stack(); 1405 } 1406 } 1407 1408 int neigh_table_clear(struct neigh_table *tbl) 1409 { 1410 struct neigh_table **tp; 1411 1412 /* It is not clean... Fix it to unload IPv6 module safely */ 1413 del_timer_sync(&tbl->gc_timer); 1414 del_timer_sync(&tbl->proxy_timer); 1415 pneigh_queue_purge(&tbl->proxy_queue); 1416 neigh_ifdown(tbl, NULL); 1417 if (atomic_read(&tbl->entries)) 1418 printk(KERN_CRIT "neighbour leakage\n"); 1419 write_lock(&neigh_tbl_lock); 1420 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) { 1421 if (*tp == tbl) { 1422 *tp = tbl->next; 1423 break; 1424 } 1425 } 1426 write_unlock(&neigh_tbl_lock); 1427 1428 neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1); 1429 tbl->hash_buckets = NULL; 1430 1431 kfree(tbl->phash_buckets); 1432 tbl->phash_buckets = NULL; 1433 1434 return 0; 1435 } 1436 1437 int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 1438 { 1439 struct ndmsg *ndm = NLMSG_DATA(nlh); 1440 struct rtattr **nda = arg; 1441 struct neigh_table *tbl; 1442 struct net_device *dev = NULL; 1443 int err = -ENODEV; 1444 1445 if (ndm->ndm_ifindex && 1446 (dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL) 1447 goto out; 1448 1449 read_lock(&neigh_tbl_lock); 1450 for (tbl = neigh_tables; tbl; tbl = tbl->next) { 1451 struct rtattr *dst_attr = nda[NDA_DST - 1]; 1452 struct neighbour *n; 1453 1454 if (tbl->family != ndm->ndm_family) 1455 continue; 1456 read_unlock(&neigh_tbl_lock); 1457 1458 err = -EINVAL; 1459 if (!dst_attr || RTA_PAYLOAD(dst_attr) < tbl->key_len) 1460 goto out_dev_put; 1461 1462 if (ndm->ndm_flags & NTF_PROXY) { 1463 err = pneigh_delete(tbl, RTA_DATA(dst_attr), dev); 1464 goto out_dev_put; 1465 } 1466 1467 if (!dev) 1468 goto out; 1469 1470 n = neigh_lookup(tbl, RTA_DATA(dst_attr), dev); 1471 if (n) { 1472 err = neigh_update(n, NULL, NUD_FAILED, 1473 NEIGH_UPDATE_F_OVERRIDE| 1474 NEIGH_UPDATE_F_ADMIN); 1475 neigh_release(n); 1476 } 1477 goto out_dev_put; 1478 } 1479 read_unlock(&neigh_tbl_lock); 1480 err = -EADDRNOTAVAIL; 1481 out_dev_put: 1482 if (dev) 1483 dev_put(dev); 1484 out: 1485 return err; 1486 } 1487 1488 int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 1489 { 1490 struct ndmsg *ndm = NLMSG_DATA(nlh); 1491 struct rtattr **nda = arg; 1492 struct neigh_table *tbl; 1493 struct net_device *dev = NULL; 1494 int err = -ENODEV; 1495 1496 if (ndm->ndm_ifindex && 1497 (dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL) 1498 goto out; 1499 1500 read_lock(&neigh_tbl_lock); 1501 for (tbl = neigh_tables; tbl; tbl = tbl->next) { 1502 struct rtattr *lladdr_attr = nda[NDA_LLADDR - 1]; 1503 struct rtattr *dst_attr = nda[NDA_DST - 1]; 1504 int override = 1; 1505 struct neighbour *n; 1506 1507 if (tbl->family != ndm->ndm_family) 1508 continue; 1509 read_unlock(&neigh_tbl_lock); 1510 1511 err = -EINVAL; 1512 if (!dst_attr || RTA_PAYLOAD(dst_attr) < tbl->key_len) 1513 goto out_dev_put; 1514 1515 if (ndm->ndm_flags & NTF_PROXY) { 1516 err = -ENOBUFS; 1517 if (pneigh_lookup(tbl, RTA_DATA(dst_attr), dev, 1)) 1518 err = 0; 1519 goto out_dev_put; 1520 } 1521 1522 err = -EINVAL; 1523 if (!dev) 1524 goto out; 1525 if (lladdr_attr && RTA_PAYLOAD(lladdr_attr) < dev->addr_len) 1526 goto out_dev_put; 1527 1528 n = neigh_lookup(tbl, RTA_DATA(dst_attr), dev); 1529 if (n) { 1530 if (nlh->nlmsg_flags & NLM_F_EXCL) { 1531 err = -EEXIST; 1532 neigh_release(n); 1533 goto out_dev_put; 1534 } 1535 1536 override = nlh->nlmsg_flags & NLM_F_REPLACE; 1537 } else if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 1538 err = -ENOENT; 1539 goto out_dev_put; 1540 } else { 1541 n = __neigh_lookup_errno(tbl, RTA_DATA(dst_attr), dev); 1542 if (IS_ERR(n)) { 1543 err = PTR_ERR(n); 1544 goto out_dev_put; 1545 } 1546 } 1547 1548 err = neigh_update(n, 1549 lladdr_attr ? RTA_DATA(lladdr_attr) : NULL, 1550 ndm->ndm_state, 1551 (override ? NEIGH_UPDATE_F_OVERRIDE : 0) | 1552 NEIGH_UPDATE_F_ADMIN); 1553 1554 neigh_release(n); 1555 goto out_dev_put; 1556 } 1557 1558 read_unlock(&neigh_tbl_lock); 1559 err = -EADDRNOTAVAIL; 1560 out_dev_put: 1561 if (dev) 1562 dev_put(dev); 1563 out: 1564 return err; 1565 } 1566 1567 static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms) 1568 { 1569 struct rtattr *nest = NULL; 1570 1571 nest = RTA_NEST(skb, NDTA_PARMS); 1572 1573 if (parms->dev) 1574 RTA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex); 1575 1576 RTA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt)); 1577 RTA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len); 1578 RTA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen); 1579 RTA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes); 1580 RTA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes); 1581 RTA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes); 1582 RTA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time); 1583 RTA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME, 1584 parms->base_reachable_time); 1585 RTA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime); 1586 RTA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time); 1587 RTA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time); 1588 RTA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay); 1589 RTA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay); 1590 RTA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime); 1591 1592 return RTA_NEST_END(skb, nest); 1593 1594 rtattr_failure: 1595 return RTA_NEST_CANCEL(skb, nest); 1596 } 1597 1598 static int neightbl_fill_info(struct neigh_table *tbl, struct sk_buff *skb, 1599 struct netlink_callback *cb) 1600 { 1601 struct nlmsghdr *nlh; 1602 struct ndtmsg *ndtmsg; 1603 1604 nlh = NLMSG_NEW_ANSWER(skb, cb, RTM_NEWNEIGHTBL, sizeof(struct ndtmsg), 1605 NLM_F_MULTI); 1606 1607 ndtmsg = NLMSG_DATA(nlh); 1608 1609 read_lock_bh(&tbl->lock); 1610 ndtmsg->ndtm_family = tbl->family; 1611 ndtmsg->ndtm_pad1 = 0; 1612 ndtmsg->ndtm_pad2 = 0; 1613 1614 RTA_PUT_STRING(skb, NDTA_NAME, tbl->id); 1615 RTA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval); 1616 RTA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1); 1617 RTA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2); 1618 RTA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3); 1619 1620 { 1621 unsigned long now = jiffies; 1622 unsigned int flush_delta = now - tbl->last_flush; 1623 unsigned int rand_delta = now - tbl->last_rand; 1624 1625 struct ndt_config ndc = { 1626 .ndtc_key_len = tbl->key_len, 1627 .ndtc_entry_size = tbl->entry_size, 1628 .ndtc_entries = atomic_read(&tbl->entries), 1629 .ndtc_last_flush = jiffies_to_msecs(flush_delta), 1630 .ndtc_last_rand = jiffies_to_msecs(rand_delta), 1631 .ndtc_hash_rnd = tbl->hash_rnd, 1632 .ndtc_hash_mask = tbl->hash_mask, 1633 .ndtc_hash_chain_gc = tbl->hash_chain_gc, 1634 .ndtc_proxy_qlen = tbl->proxy_queue.qlen, 1635 }; 1636 1637 RTA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc); 1638 } 1639 1640 { 1641 int cpu; 1642 struct ndt_stats ndst; 1643 1644 memset(&ndst, 0, sizeof(ndst)); 1645 1646 for_each_possible_cpu(cpu) { 1647 struct neigh_statistics *st; 1648 1649 st = per_cpu_ptr(tbl->stats, cpu); 1650 ndst.ndts_allocs += st->allocs; 1651 ndst.ndts_destroys += st->destroys; 1652 ndst.ndts_hash_grows += st->hash_grows; 1653 ndst.ndts_res_failed += st->res_failed; 1654 ndst.ndts_lookups += st->lookups; 1655 ndst.ndts_hits += st->hits; 1656 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast; 1657 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast; 1658 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs; 1659 ndst.ndts_forced_gc_runs += st->forced_gc_runs; 1660 } 1661 1662 RTA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst); 1663 } 1664 1665 BUG_ON(tbl->parms.dev); 1666 if (neightbl_fill_parms(skb, &tbl->parms) < 0) 1667 goto rtattr_failure; 1668 1669 read_unlock_bh(&tbl->lock); 1670 return NLMSG_END(skb, nlh); 1671 1672 rtattr_failure: 1673 read_unlock_bh(&tbl->lock); 1674 return NLMSG_CANCEL(skb, nlh); 1675 1676 nlmsg_failure: 1677 return -1; 1678 } 1679 1680 static int neightbl_fill_param_info(struct neigh_table *tbl, 1681 struct neigh_parms *parms, 1682 struct sk_buff *skb, 1683 struct netlink_callback *cb) 1684 { 1685 struct ndtmsg *ndtmsg; 1686 struct nlmsghdr *nlh; 1687 1688 nlh = NLMSG_NEW_ANSWER(skb, cb, RTM_NEWNEIGHTBL, sizeof(struct ndtmsg), 1689 NLM_F_MULTI); 1690 1691 ndtmsg = NLMSG_DATA(nlh); 1692 1693 read_lock_bh(&tbl->lock); 1694 ndtmsg->ndtm_family = tbl->family; 1695 ndtmsg->ndtm_pad1 = 0; 1696 ndtmsg->ndtm_pad2 = 0; 1697 RTA_PUT_STRING(skb, NDTA_NAME, tbl->id); 1698 1699 if (neightbl_fill_parms(skb, parms) < 0) 1700 goto rtattr_failure; 1701 1702 read_unlock_bh(&tbl->lock); 1703 return NLMSG_END(skb, nlh); 1704 1705 rtattr_failure: 1706 read_unlock_bh(&tbl->lock); 1707 return NLMSG_CANCEL(skb, nlh); 1708 1709 nlmsg_failure: 1710 return -1; 1711 } 1712 1713 static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl, 1714 int ifindex) 1715 { 1716 struct neigh_parms *p; 1717 1718 for (p = &tbl->parms; p; p = p->next) 1719 if ((p->dev && p->dev->ifindex == ifindex) || 1720 (!p->dev && !ifindex)) 1721 return p; 1722 1723 return NULL; 1724 } 1725 1726 int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 1727 { 1728 struct neigh_table *tbl; 1729 struct ndtmsg *ndtmsg = NLMSG_DATA(nlh); 1730 struct rtattr **tb = arg; 1731 int err = -EINVAL; 1732 1733 if (!tb[NDTA_NAME - 1] || !RTA_PAYLOAD(tb[NDTA_NAME - 1])) 1734 return -EINVAL; 1735 1736 read_lock(&neigh_tbl_lock); 1737 for (tbl = neigh_tables; tbl; tbl = tbl->next) { 1738 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family) 1739 continue; 1740 1741 if (!rtattr_strcmp(tb[NDTA_NAME - 1], tbl->id)) 1742 break; 1743 } 1744 1745 if (tbl == NULL) { 1746 err = -ENOENT; 1747 goto errout; 1748 } 1749 1750 /* 1751 * We acquire tbl->lock to be nice to the periodic timers and 1752 * make sure they always see a consistent set of values. 1753 */ 1754 write_lock_bh(&tbl->lock); 1755 1756 if (tb[NDTA_THRESH1 - 1]) 1757 tbl->gc_thresh1 = RTA_GET_U32(tb[NDTA_THRESH1 - 1]); 1758 1759 if (tb[NDTA_THRESH2 - 1]) 1760 tbl->gc_thresh2 = RTA_GET_U32(tb[NDTA_THRESH2 - 1]); 1761 1762 if (tb[NDTA_THRESH3 - 1]) 1763 tbl->gc_thresh3 = RTA_GET_U32(tb[NDTA_THRESH3 - 1]); 1764 1765 if (tb[NDTA_GC_INTERVAL - 1]) 1766 tbl->gc_interval = RTA_GET_MSECS(tb[NDTA_GC_INTERVAL - 1]); 1767 1768 if (tb[NDTA_PARMS - 1]) { 1769 struct rtattr *tbp[NDTPA_MAX]; 1770 struct neigh_parms *p; 1771 u32 ifindex = 0; 1772 1773 if (rtattr_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS - 1]) < 0) 1774 goto rtattr_failure; 1775 1776 if (tbp[NDTPA_IFINDEX - 1]) 1777 ifindex = RTA_GET_U32(tbp[NDTPA_IFINDEX - 1]); 1778 1779 p = lookup_neigh_params(tbl, ifindex); 1780 if (p == NULL) { 1781 err = -ENOENT; 1782 goto rtattr_failure; 1783 } 1784 1785 if (tbp[NDTPA_QUEUE_LEN - 1]) 1786 p->queue_len = RTA_GET_U32(tbp[NDTPA_QUEUE_LEN - 1]); 1787 1788 if (tbp[NDTPA_PROXY_QLEN - 1]) 1789 p->proxy_qlen = RTA_GET_U32(tbp[NDTPA_PROXY_QLEN - 1]); 1790 1791 if (tbp[NDTPA_APP_PROBES - 1]) 1792 p->app_probes = RTA_GET_U32(tbp[NDTPA_APP_PROBES - 1]); 1793 1794 if (tbp[NDTPA_UCAST_PROBES - 1]) 1795 p->ucast_probes = 1796 RTA_GET_U32(tbp[NDTPA_UCAST_PROBES - 1]); 1797 1798 if (tbp[NDTPA_MCAST_PROBES - 1]) 1799 p->mcast_probes = 1800 RTA_GET_U32(tbp[NDTPA_MCAST_PROBES - 1]); 1801 1802 if (tbp[NDTPA_BASE_REACHABLE_TIME - 1]) 1803 p->base_reachable_time = 1804 RTA_GET_MSECS(tbp[NDTPA_BASE_REACHABLE_TIME - 1]); 1805 1806 if (tbp[NDTPA_GC_STALETIME - 1]) 1807 p->gc_staletime = 1808 RTA_GET_MSECS(tbp[NDTPA_GC_STALETIME - 1]); 1809 1810 if (tbp[NDTPA_DELAY_PROBE_TIME - 1]) 1811 p->delay_probe_time = 1812 RTA_GET_MSECS(tbp[NDTPA_DELAY_PROBE_TIME - 1]); 1813 1814 if (tbp[NDTPA_RETRANS_TIME - 1]) 1815 p->retrans_time = 1816 RTA_GET_MSECS(tbp[NDTPA_RETRANS_TIME - 1]); 1817 1818 if (tbp[NDTPA_ANYCAST_DELAY - 1]) 1819 p->anycast_delay = 1820 RTA_GET_MSECS(tbp[NDTPA_ANYCAST_DELAY - 1]); 1821 1822 if (tbp[NDTPA_PROXY_DELAY - 1]) 1823 p->proxy_delay = 1824 RTA_GET_MSECS(tbp[NDTPA_PROXY_DELAY - 1]); 1825 1826 if (tbp[NDTPA_LOCKTIME - 1]) 1827 p->locktime = RTA_GET_MSECS(tbp[NDTPA_LOCKTIME - 1]); 1828 } 1829 1830 err = 0; 1831 1832 rtattr_failure: 1833 write_unlock_bh(&tbl->lock); 1834 errout: 1835 read_unlock(&neigh_tbl_lock); 1836 return err; 1837 } 1838 1839 int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 1840 { 1841 int idx, family; 1842 int s_idx = cb->args[0]; 1843 struct neigh_table *tbl; 1844 1845 family = ((struct rtgenmsg *)NLMSG_DATA(cb->nlh))->rtgen_family; 1846 1847 read_lock(&neigh_tbl_lock); 1848 for (tbl = neigh_tables, idx = 0; tbl; tbl = tbl->next) { 1849 struct neigh_parms *p; 1850 1851 if (idx < s_idx || (family && tbl->family != family)) 1852 continue; 1853 1854 if (neightbl_fill_info(tbl, skb, cb) <= 0) 1855 break; 1856 1857 for (++idx, p = tbl->parms.next; p; p = p->next, idx++) { 1858 if (idx < s_idx) 1859 continue; 1860 1861 if (neightbl_fill_param_info(tbl, p, skb, cb) <= 0) 1862 goto out; 1863 } 1864 1865 } 1866 out: 1867 read_unlock(&neigh_tbl_lock); 1868 cb->args[0] = idx; 1869 1870 return skb->len; 1871 } 1872 1873 static int neigh_fill_info(struct sk_buff *skb, struct neighbour *n, 1874 u32 pid, u32 seq, int event, unsigned int flags) 1875 { 1876 unsigned long now = jiffies; 1877 unsigned char *b = skb->tail; 1878 struct nda_cacheinfo ci; 1879 int locked = 0; 1880 u32 probes; 1881 struct nlmsghdr *nlh = NLMSG_NEW(skb, pid, seq, event, 1882 sizeof(struct ndmsg), flags); 1883 struct ndmsg *ndm = NLMSG_DATA(nlh); 1884 1885 ndm->ndm_family = n->ops->family; 1886 ndm->ndm_pad1 = 0; 1887 ndm->ndm_pad2 = 0; 1888 ndm->ndm_flags = n->flags; 1889 ndm->ndm_type = n->type; 1890 ndm->ndm_ifindex = n->dev->ifindex; 1891 RTA_PUT(skb, NDA_DST, n->tbl->key_len, n->primary_key); 1892 read_lock_bh(&n->lock); 1893 locked = 1; 1894 ndm->ndm_state = n->nud_state; 1895 if (n->nud_state & NUD_VALID) 1896 RTA_PUT(skb, NDA_LLADDR, n->dev->addr_len, n->ha); 1897 ci.ndm_used = now - n->used; 1898 ci.ndm_confirmed = now - n->confirmed; 1899 ci.ndm_updated = now - n->updated; 1900 ci.ndm_refcnt = atomic_read(&n->refcnt) - 1; 1901 probes = atomic_read(&n->probes); 1902 read_unlock_bh(&n->lock); 1903 locked = 0; 1904 RTA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci); 1905 RTA_PUT(skb, NDA_PROBES, sizeof(probes), &probes); 1906 nlh->nlmsg_len = skb->tail - b; 1907 return skb->len; 1908 1909 nlmsg_failure: 1910 rtattr_failure: 1911 if (locked) 1912 read_unlock_bh(&n->lock); 1913 skb_trim(skb, b - skb->data); 1914 return -1; 1915 } 1916 1917 1918 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 1919 struct netlink_callback *cb) 1920 { 1921 struct neighbour *n; 1922 int rc, h, s_h = cb->args[1]; 1923 int idx, s_idx = idx = cb->args[2]; 1924 1925 for (h = 0; h <= tbl->hash_mask; h++) { 1926 if (h < s_h) 1927 continue; 1928 if (h > s_h) 1929 s_idx = 0; 1930 read_lock_bh(&tbl->lock); 1931 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next, idx++) { 1932 if (idx < s_idx) 1933 continue; 1934 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid, 1935 cb->nlh->nlmsg_seq, 1936 RTM_NEWNEIGH, 1937 NLM_F_MULTI) <= 0) { 1938 read_unlock_bh(&tbl->lock); 1939 rc = -1; 1940 goto out; 1941 } 1942 } 1943 read_unlock_bh(&tbl->lock); 1944 } 1945 rc = skb->len; 1946 out: 1947 cb->args[1] = h; 1948 cb->args[2] = idx; 1949 return rc; 1950 } 1951 1952 int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 1953 { 1954 struct neigh_table *tbl; 1955 int t, family, s_t; 1956 1957 read_lock(&neigh_tbl_lock); 1958 family = ((struct rtgenmsg *)NLMSG_DATA(cb->nlh))->rtgen_family; 1959 s_t = cb->args[0]; 1960 1961 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) { 1962 if (t < s_t || (family && tbl->family != family)) 1963 continue; 1964 if (t > s_t) 1965 memset(&cb->args[1], 0, sizeof(cb->args) - 1966 sizeof(cb->args[0])); 1967 if (neigh_dump_table(tbl, skb, cb) < 0) 1968 break; 1969 } 1970 read_unlock(&neigh_tbl_lock); 1971 1972 cb->args[0] = t; 1973 return skb->len; 1974 } 1975 1976 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie) 1977 { 1978 int chain; 1979 1980 read_lock_bh(&tbl->lock); 1981 for (chain = 0; chain <= tbl->hash_mask; chain++) { 1982 struct neighbour *n; 1983 1984 for (n = tbl->hash_buckets[chain]; n; n = n->next) 1985 cb(n, cookie); 1986 } 1987 read_unlock_bh(&tbl->lock); 1988 } 1989 EXPORT_SYMBOL(neigh_for_each); 1990 1991 /* The tbl->lock must be held as a writer and BH disabled. */ 1992 void __neigh_for_each_release(struct neigh_table *tbl, 1993 int (*cb)(struct neighbour *)) 1994 { 1995 int chain; 1996 1997 for (chain = 0; chain <= tbl->hash_mask; chain++) { 1998 struct neighbour *n, **np; 1999 2000 np = &tbl->hash_buckets[chain]; 2001 while ((n = *np) != NULL) { 2002 int release; 2003 2004 write_lock(&n->lock); 2005 release = cb(n); 2006 if (release) { 2007 *np = n->next; 2008 n->dead = 1; 2009 } else 2010 np = &n->next; 2011 write_unlock(&n->lock); 2012 if (release) 2013 neigh_release(n); 2014 } 2015 } 2016 } 2017 EXPORT_SYMBOL(__neigh_for_each_release); 2018 2019 #ifdef CONFIG_PROC_FS 2020 2021 static struct neighbour *neigh_get_first(struct seq_file *seq) 2022 { 2023 struct neigh_seq_state *state = seq->private; 2024 struct neigh_table *tbl = state->tbl; 2025 struct neighbour *n = NULL; 2026 int bucket = state->bucket; 2027 2028 state->flags &= ~NEIGH_SEQ_IS_PNEIGH; 2029 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) { 2030 n = tbl->hash_buckets[bucket]; 2031 2032 while (n) { 2033 if (state->neigh_sub_iter) { 2034 loff_t fakep = 0; 2035 void *v; 2036 2037 v = state->neigh_sub_iter(state, n, &fakep); 2038 if (!v) 2039 goto next; 2040 } 2041 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 2042 break; 2043 if (n->nud_state & ~NUD_NOARP) 2044 break; 2045 next: 2046 n = n->next; 2047 } 2048 2049 if (n) 2050 break; 2051 } 2052 state->bucket = bucket; 2053 2054 return n; 2055 } 2056 2057 static struct neighbour *neigh_get_next(struct seq_file *seq, 2058 struct neighbour *n, 2059 loff_t *pos) 2060 { 2061 struct neigh_seq_state *state = seq->private; 2062 struct neigh_table *tbl = state->tbl; 2063 2064 if (state->neigh_sub_iter) { 2065 void *v = state->neigh_sub_iter(state, n, pos); 2066 if (v) 2067 return n; 2068 } 2069 n = n->next; 2070 2071 while (1) { 2072 while (n) { 2073 if (state->neigh_sub_iter) { 2074 void *v = state->neigh_sub_iter(state, n, pos); 2075 if (v) 2076 return n; 2077 goto next; 2078 } 2079 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 2080 break; 2081 2082 if (n->nud_state & ~NUD_NOARP) 2083 break; 2084 next: 2085 n = n->next; 2086 } 2087 2088 if (n) 2089 break; 2090 2091 if (++state->bucket > tbl->hash_mask) 2092 break; 2093 2094 n = tbl->hash_buckets[state->bucket]; 2095 } 2096 2097 if (n && pos) 2098 --(*pos); 2099 return n; 2100 } 2101 2102 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos) 2103 { 2104 struct neighbour *n = neigh_get_first(seq); 2105 2106 if (n) { 2107 while (*pos) { 2108 n = neigh_get_next(seq, n, pos); 2109 if (!n) 2110 break; 2111 } 2112 } 2113 return *pos ? NULL : n; 2114 } 2115 2116 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq) 2117 { 2118 struct neigh_seq_state *state = seq->private; 2119 struct neigh_table *tbl = state->tbl; 2120 struct pneigh_entry *pn = NULL; 2121 int bucket = state->bucket; 2122 2123 state->flags |= NEIGH_SEQ_IS_PNEIGH; 2124 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) { 2125 pn = tbl->phash_buckets[bucket]; 2126 if (pn) 2127 break; 2128 } 2129 state->bucket = bucket; 2130 2131 return pn; 2132 } 2133 2134 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq, 2135 struct pneigh_entry *pn, 2136 loff_t *pos) 2137 { 2138 struct neigh_seq_state *state = seq->private; 2139 struct neigh_table *tbl = state->tbl; 2140 2141 pn = pn->next; 2142 while (!pn) { 2143 if (++state->bucket > PNEIGH_HASHMASK) 2144 break; 2145 pn = tbl->phash_buckets[state->bucket]; 2146 if (pn) 2147 break; 2148 } 2149 2150 if (pn && pos) 2151 --(*pos); 2152 2153 return pn; 2154 } 2155 2156 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos) 2157 { 2158 struct pneigh_entry *pn = pneigh_get_first(seq); 2159 2160 if (pn) { 2161 while (*pos) { 2162 pn = pneigh_get_next(seq, pn, pos); 2163 if (!pn) 2164 break; 2165 } 2166 } 2167 return *pos ? NULL : pn; 2168 } 2169 2170 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos) 2171 { 2172 struct neigh_seq_state *state = seq->private; 2173 void *rc; 2174 2175 rc = neigh_get_idx(seq, pos); 2176 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 2177 rc = pneigh_get_idx(seq, pos); 2178 2179 return rc; 2180 } 2181 2182 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags) 2183 { 2184 struct neigh_seq_state *state = seq->private; 2185 loff_t pos_minus_one; 2186 2187 state->tbl = tbl; 2188 state->bucket = 0; 2189 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH); 2190 2191 read_lock_bh(&tbl->lock); 2192 2193 pos_minus_one = *pos - 1; 2194 return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN; 2195 } 2196 EXPORT_SYMBOL(neigh_seq_start); 2197 2198 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2199 { 2200 struct neigh_seq_state *state; 2201 void *rc; 2202 2203 if (v == SEQ_START_TOKEN) { 2204 rc = neigh_get_idx(seq, pos); 2205 goto out; 2206 } 2207 2208 state = seq->private; 2209 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) { 2210 rc = neigh_get_next(seq, v, NULL); 2211 if (rc) 2212 goto out; 2213 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 2214 rc = pneigh_get_first(seq); 2215 } else { 2216 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY); 2217 rc = pneigh_get_next(seq, v, NULL); 2218 } 2219 out: 2220 ++(*pos); 2221 return rc; 2222 } 2223 EXPORT_SYMBOL(neigh_seq_next); 2224 2225 void neigh_seq_stop(struct seq_file *seq, void *v) 2226 { 2227 struct neigh_seq_state *state = seq->private; 2228 struct neigh_table *tbl = state->tbl; 2229 2230 read_unlock_bh(&tbl->lock); 2231 } 2232 EXPORT_SYMBOL(neigh_seq_stop); 2233 2234 /* statistics via seq_file */ 2235 2236 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos) 2237 { 2238 struct proc_dir_entry *pde = seq->private; 2239 struct neigh_table *tbl = pde->data; 2240 int cpu; 2241 2242 if (*pos == 0) 2243 return SEQ_START_TOKEN; 2244 2245 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) { 2246 if (!cpu_possible(cpu)) 2247 continue; 2248 *pos = cpu+1; 2249 return per_cpu_ptr(tbl->stats, cpu); 2250 } 2251 return NULL; 2252 } 2253 2254 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2255 { 2256 struct proc_dir_entry *pde = seq->private; 2257 struct neigh_table *tbl = pde->data; 2258 int cpu; 2259 2260 for (cpu = *pos; cpu < NR_CPUS; ++cpu) { 2261 if (!cpu_possible(cpu)) 2262 continue; 2263 *pos = cpu+1; 2264 return per_cpu_ptr(tbl->stats, cpu); 2265 } 2266 return NULL; 2267 } 2268 2269 static void neigh_stat_seq_stop(struct seq_file *seq, void *v) 2270 { 2271 2272 } 2273 2274 static int neigh_stat_seq_show(struct seq_file *seq, void *v) 2275 { 2276 struct proc_dir_entry *pde = seq->private; 2277 struct neigh_table *tbl = pde->data; 2278 struct neigh_statistics *st = v; 2279 2280 if (v == SEQ_START_TOKEN) { 2281 seq_printf(seq, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs\n"); 2282 return 0; 2283 } 2284 2285 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx " 2286 "%08lx %08lx %08lx %08lx\n", 2287 atomic_read(&tbl->entries), 2288 2289 st->allocs, 2290 st->destroys, 2291 st->hash_grows, 2292 2293 st->lookups, 2294 st->hits, 2295 2296 st->res_failed, 2297 2298 st->rcv_probes_mcast, 2299 st->rcv_probes_ucast, 2300 2301 st->periodic_gc_runs, 2302 st->forced_gc_runs 2303 ); 2304 2305 return 0; 2306 } 2307 2308 static struct seq_operations neigh_stat_seq_ops = { 2309 .start = neigh_stat_seq_start, 2310 .next = neigh_stat_seq_next, 2311 .stop = neigh_stat_seq_stop, 2312 .show = neigh_stat_seq_show, 2313 }; 2314 2315 static int neigh_stat_seq_open(struct inode *inode, struct file *file) 2316 { 2317 int ret = seq_open(file, &neigh_stat_seq_ops); 2318 2319 if (!ret) { 2320 struct seq_file *sf = file->private_data; 2321 sf->private = PDE(inode); 2322 } 2323 return ret; 2324 }; 2325 2326 static struct file_operations neigh_stat_seq_fops = { 2327 .owner = THIS_MODULE, 2328 .open = neigh_stat_seq_open, 2329 .read = seq_read, 2330 .llseek = seq_lseek, 2331 .release = seq_release, 2332 }; 2333 2334 #endif /* CONFIG_PROC_FS */ 2335 2336 #ifdef CONFIG_ARPD 2337 void neigh_app_ns(struct neighbour *n) 2338 { 2339 struct nlmsghdr *nlh; 2340 int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256); 2341 struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC); 2342 2343 if (!skb) 2344 return; 2345 2346 if (neigh_fill_info(skb, n, 0, 0, RTM_GETNEIGH, 0) < 0) { 2347 kfree_skb(skb); 2348 return; 2349 } 2350 nlh = (struct nlmsghdr *)skb->data; 2351 nlh->nlmsg_flags = NLM_F_REQUEST; 2352 NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH; 2353 netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC); 2354 } 2355 2356 static void neigh_app_notify(struct neighbour *n) 2357 { 2358 struct nlmsghdr *nlh; 2359 int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256); 2360 struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC); 2361 2362 if (!skb) 2363 return; 2364 2365 if (neigh_fill_info(skb, n, 0, 0, RTM_NEWNEIGH, 0) < 0) { 2366 kfree_skb(skb); 2367 return; 2368 } 2369 nlh = (struct nlmsghdr *)skb->data; 2370 NETLINK_CB(skb).dst_group = RTNLGRP_NEIGH; 2371 netlink_broadcast(rtnl, skb, 0, RTNLGRP_NEIGH, GFP_ATOMIC); 2372 } 2373 2374 #endif /* CONFIG_ARPD */ 2375 2376 #ifdef CONFIG_SYSCTL 2377 2378 static struct neigh_sysctl_table { 2379 struct ctl_table_header *sysctl_header; 2380 ctl_table neigh_vars[__NET_NEIGH_MAX]; 2381 ctl_table neigh_dev[2]; 2382 ctl_table neigh_neigh_dir[2]; 2383 ctl_table neigh_proto_dir[2]; 2384 ctl_table neigh_root_dir[2]; 2385 } neigh_sysctl_template = { 2386 .neigh_vars = { 2387 { 2388 .ctl_name = NET_NEIGH_MCAST_SOLICIT, 2389 .procname = "mcast_solicit", 2390 .maxlen = sizeof(int), 2391 .mode = 0644, 2392 .proc_handler = &proc_dointvec, 2393 }, 2394 { 2395 .ctl_name = NET_NEIGH_UCAST_SOLICIT, 2396 .procname = "ucast_solicit", 2397 .maxlen = sizeof(int), 2398 .mode = 0644, 2399 .proc_handler = &proc_dointvec, 2400 }, 2401 { 2402 .ctl_name = NET_NEIGH_APP_SOLICIT, 2403 .procname = "app_solicit", 2404 .maxlen = sizeof(int), 2405 .mode = 0644, 2406 .proc_handler = &proc_dointvec, 2407 }, 2408 { 2409 .ctl_name = NET_NEIGH_RETRANS_TIME, 2410 .procname = "retrans_time", 2411 .maxlen = sizeof(int), 2412 .mode = 0644, 2413 .proc_handler = &proc_dointvec_userhz_jiffies, 2414 }, 2415 { 2416 .ctl_name = NET_NEIGH_REACHABLE_TIME, 2417 .procname = "base_reachable_time", 2418 .maxlen = sizeof(int), 2419 .mode = 0644, 2420 .proc_handler = &proc_dointvec_jiffies, 2421 .strategy = &sysctl_jiffies, 2422 }, 2423 { 2424 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME, 2425 .procname = "delay_first_probe_time", 2426 .maxlen = sizeof(int), 2427 .mode = 0644, 2428 .proc_handler = &proc_dointvec_jiffies, 2429 .strategy = &sysctl_jiffies, 2430 }, 2431 { 2432 .ctl_name = NET_NEIGH_GC_STALE_TIME, 2433 .procname = "gc_stale_time", 2434 .maxlen = sizeof(int), 2435 .mode = 0644, 2436 .proc_handler = &proc_dointvec_jiffies, 2437 .strategy = &sysctl_jiffies, 2438 }, 2439 { 2440 .ctl_name = NET_NEIGH_UNRES_QLEN, 2441 .procname = "unres_qlen", 2442 .maxlen = sizeof(int), 2443 .mode = 0644, 2444 .proc_handler = &proc_dointvec, 2445 }, 2446 { 2447 .ctl_name = NET_NEIGH_PROXY_QLEN, 2448 .procname = "proxy_qlen", 2449 .maxlen = sizeof(int), 2450 .mode = 0644, 2451 .proc_handler = &proc_dointvec, 2452 }, 2453 { 2454 .ctl_name = NET_NEIGH_ANYCAST_DELAY, 2455 .procname = "anycast_delay", 2456 .maxlen = sizeof(int), 2457 .mode = 0644, 2458 .proc_handler = &proc_dointvec_userhz_jiffies, 2459 }, 2460 { 2461 .ctl_name = NET_NEIGH_PROXY_DELAY, 2462 .procname = "proxy_delay", 2463 .maxlen = sizeof(int), 2464 .mode = 0644, 2465 .proc_handler = &proc_dointvec_userhz_jiffies, 2466 }, 2467 { 2468 .ctl_name = NET_NEIGH_LOCKTIME, 2469 .procname = "locktime", 2470 .maxlen = sizeof(int), 2471 .mode = 0644, 2472 .proc_handler = &proc_dointvec_userhz_jiffies, 2473 }, 2474 { 2475 .ctl_name = NET_NEIGH_GC_INTERVAL, 2476 .procname = "gc_interval", 2477 .maxlen = sizeof(int), 2478 .mode = 0644, 2479 .proc_handler = &proc_dointvec_jiffies, 2480 .strategy = &sysctl_jiffies, 2481 }, 2482 { 2483 .ctl_name = NET_NEIGH_GC_THRESH1, 2484 .procname = "gc_thresh1", 2485 .maxlen = sizeof(int), 2486 .mode = 0644, 2487 .proc_handler = &proc_dointvec, 2488 }, 2489 { 2490 .ctl_name = NET_NEIGH_GC_THRESH2, 2491 .procname = "gc_thresh2", 2492 .maxlen = sizeof(int), 2493 .mode = 0644, 2494 .proc_handler = &proc_dointvec, 2495 }, 2496 { 2497 .ctl_name = NET_NEIGH_GC_THRESH3, 2498 .procname = "gc_thresh3", 2499 .maxlen = sizeof(int), 2500 .mode = 0644, 2501 .proc_handler = &proc_dointvec, 2502 }, 2503 { 2504 .ctl_name = NET_NEIGH_RETRANS_TIME_MS, 2505 .procname = "retrans_time_ms", 2506 .maxlen = sizeof(int), 2507 .mode = 0644, 2508 .proc_handler = &proc_dointvec_ms_jiffies, 2509 .strategy = &sysctl_ms_jiffies, 2510 }, 2511 { 2512 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS, 2513 .procname = "base_reachable_time_ms", 2514 .maxlen = sizeof(int), 2515 .mode = 0644, 2516 .proc_handler = &proc_dointvec_ms_jiffies, 2517 .strategy = &sysctl_ms_jiffies, 2518 }, 2519 }, 2520 .neigh_dev = { 2521 { 2522 .ctl_name = NET_PROTO_CONF_DEFAULT, 2523 .procname = "default", 2524 .mode = 0555, 2525 }, 2526 }, 2527 .neigh_neigh_dir = { 2528 { 2529 .procname = "neigh", 2530 .mode = 0555, 2531 }, 2532 }, 2533 .neigh_proto_dir = { 2534 { 2535 .mode = 0555, 2536 }, 2537 }, 2538 .neigh_root_dir = { 2539 { 2540 .ctl_name = CTL_NET, 2541 .procname = "net", 2542 .mode = 0555, 2543 }, 2544 }, 2545 }; 2546 2547 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, 2548 int p_id, int pdev_id, char *p_name, 2549 proc_handler *handler, ctl_handler *strategy) 2550 { 2551 struct neigh_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL); 2552 const char *dev_name_source = NULL; 2553 char *dev_name = NULL; 2554 int err = 0; 2555 2556 if (!t) 2557 return -ENOBUFS; 2558 memcpy(t, &neigh_sysctl_template, sizeof(*t)); 2559 t->neigh_vars[0].data = &p->mcast_probes; 2560 t->neigh_vars[1].data = &p->ucast_probes; 2561 t->neigh_vars[2].data = &p->app_probes; 2562 t->neigh_vars[3].data = &p->retrans_time; 2563 t->neigh_vars[4].data = &p->base_reachable_time; 2564 t->neigh_vars[5].data = &p->delay_probe_time; 2565 t->neigh_vars[6].data = &p->gc_staletime; 2566 t->neigh_vars[7].data = &p->queue_len; 2567 t->neigh_vars[8].data = &p->proxy_qlen; 2568 t->neigh_vars[9].data = &p->anycast_delay; 2569 t->neigh_vars[10].data = &p->proxy_delay; 2570 t->neigh_vars[11].data = &p->locktime; 2571 2572 if (dev) { 2573 dev_name_source = dev->name; 2574 t->neigh_dev[0].ctl_name = dev->ifindex; 2575 t->neigh_vars[12].procname = NULL; 2576 t->neigh_vars[13].procname = NULL; 2577 t->neigh_vars[14].procname = NULL; 2578 t->neigh_vars[15].procname = NULL; 2579 } else { 2580 dev_name_source = t->neigh_dev[0].procname; 2581 t->neigh_vars[12].data = (int *)(p + 1); 2582 t->neigh_vars[13].data = (int *)(p + 1) + 1; 2583 t->neigh_vars[14].data = (int *)(p + 1) + 2; 2584 t->neigh_vars[15].data = (int *)(p + 1) + 3; 2585 } 2586 2587 t->neigh_vars[16].data = &p->retrans_time; 2588 t->neigh_vars[17].data = &p->base_reachable_time; 2589 2590 if (handler || strategy) { 2591 /* RetransTime */ 2592 t->neigh_vars[3].proc_handler = handler; 2593 t->neigh_vars[3].strategy = strategy; 2594 t->neigh_vars[3].extra1 = dev; 2595 /* ReachableTime */ 2596 t->neigh_vars[4].proc_handler = handler; 2597 t->neigh_vars[4].strategy = strategy; 2598 t->neigh_vars[4].extra1 = dev; 2599 /* RetransTime (in milliseconds)*/ 2600 t->neigh_vars[16].proc_handler = handler; 2601 t->neigh_vars[16].strategy = strategy; 2602 t->neigh_vars[16].extra1 = dev; 2603 /* ReachableTime (in milliseconds) */ 2604 t->neigh_vars[17].proc_handler = handler; 2605 t->neigh_vars[17].strategy = strategy; 2606 t->neigh_vars[17].extra1 = dev; 2607 } 2608 2609 dev_name = kstrdup(dev_name_source, GFP_KERNEL); 2610 if (!dev_name) { 2611 err = -ENOBUFS; 2612 goto free; 2613 } 2614 2615 t->neigh_dev[0].procname = dev_name; 2616 2617 t->neigh_neigh_dir[0].ctl_name = pdev_id; 2618 2619 t->neigh_proto_dir[0].procname = p_name; 2620 t->neigh_proto_dir[0].ctl_name = p_id; 2621 2622 t->neigh_dev[0].child = t->neigh_vars; 2623 t->neigh_neigh_dir[0].child = t->neigh_dev; 2624 t->neigh_proto_dir[0].child = t->neigh_neigh_dir; 2625 t->neigh_root_dir[0].child = t->neigh_proto_dir; 2626 2627 t->sysctl_header = register_sysctl_table(t->neigh_root_dir, 0); 2628 if (!t->sysctl_header) { 2629 err = -ENOBUFS; 2630 goto free_procname; 2631 } 2632 p->sysctl_table = t; 2633 return 0; 2634 2635 /* error path */ 2636 free_procname: 2637 kfree(dev_name); 2638 free: 2639 kfree(t); 2640 2641 return err; 2642 } 2643 2644 void neigh_sysctl_unregister(struct neigh_parms *p) 2645 { 2646 if (p->sysctl_table) { 2647 struct neigh_sysctl_table *t = p->sysctl_table; 2648 p->sysctl_table = NULL; 2649 unregister_sysctl_table(t->sysctl_header); 2650 kfree(t->neigh_dev[0].procname); 2651 kfree(t); 2652 } 2653 } 2654 2655 #endif /* CONFIG_SYSCTL */ 2656 2657 EXPORT_SYMBOL(__neigh_event_send); 2658 EXPORT_SYMBOL(neigh_add); 2659 EXPORT_SYMBOL(neigh_changeaddr); 2660 EXPORT_SYMBOL(neigh_compat_output); 2661 EXPORT_SYMBOL(neigh_connected_output); 2662 EXPORT_SYMBOL(neigh_create); 2663 EXPORT_SYMBOL(neigh_delete); 2664 EXPORT_SYMBOL(neigh_destroy); 2665 EXPORT_SYMBOL(neigh_dump_info); 2666 EXPORT_SYMBOL(neigh_event_ns); 2667 EXPORT_SYMBOL(neigh_ifdown); 2668 EXPORT_SYMBOL(neigh_lookup); 2669 EXPORT_SYMBOL(neigh_lookup_nodev); 2670 EXPORT_SYMBOL(neigh_parms_alloc); 2671 EXPORT_SYMBOL(neigh_parms_release); 2672 EXPORT_SYMBOL(neigh_rand_reach_time); 2673 EXPORT_SYMBOL(neigh_resolve_output); 2674 EXPORT_SYMBOL(neigh_table_clear); 2675 EXPORT_SYMBOL(neigh_table_init); 2676 EXPORT_SYMBOL(neigh_table_init_no_netlink); 2677 EXPORT_SYMBOL(neigh_update); 2678 EXPORT_SYMBOL(neigh_update_hhs); 2679 EXPORT_SYMBOL(pneigh_enqueue); 2680 EXPORT_SYMBOL(pneigh_lookup); 2681 EXPORT_SYMBOL(neightbl_dump_info); 2682 EXPORT_SYMBOL(neightbl_set); 2683 2684 #ifdef CONFIG_ARPD 2685 EXPORT_SYMBOL(neigh_app_ns); 2686 #endif 2687 #ifdef CONFIG_SYSCTL 2688 EXPORT_SYMBOL(neigh_sysctl_register); 2689 EXPORT_SYMBOL(neigh_sysctl_unregister); 2690 #endif 2691