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