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