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