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/sched.h> 23 #include <linux/netdevice.h> 24 #include <linux/proc_fs.h> 25 #ifdef CONFIG_SYSCTL 26 #include <linux/sysctl.h> 27 #endif 28 #include <linux/times.h> 29 #include <net/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 38 #define NEIGH_DEBUG 1 39 40 #define NEIGH_PRINTK(x...) printk(x) 41 #define NEIGH_NOPRINTK(x...) do { ; } while(0) 42 #define NEIGH_PRINTK0 NEIGH_PRINTK 43 #define NEIGH_PRINTK1 NEIGH_NOPRINTK 44 #define NEIGH_PRINTK2 NEIGH_NOPRINTK 45 46 #if NEIGH_DEBUG >= 1 47 #undef NEIGH_PRINTK1 48 #define NEIGH_PRINTK1 NEIGH_PRINTK 49 #endif 50 #if NEIGH_DEBUG >= 2 51 #undef NEIGH_PRINTK2 52 #define NEIGH_PRINTK2 NEIGH_PRINTK 53 #endif 54 55 #define PNEIGH_HASHMASK 0xF 56 57 static void neigh_timer_handler(unsigned long arg); 58 #ifdef CONFIG_ARPD 59 static void neigh_app_notify(struct neighbour *n); 60 #endif 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 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 /* 109 * It is random distribution in the interval (1/2)*base...(3/2)*base. 110 * It corresponds to default IPv6 settings and is not overridable, 111 * because it is really reasonable choice. 112 */ 113 114 unsigned long neigh_rand_reach_time(unsigned long base) 115 { 116 return (base ? (net_random() % base) + (base >> 1) : 0); 117 } 118 119 120 static int neigh_forced_gc(struct neigh_table *tbl) 121 { 122 int shrunk = 0; 123 int i; 124 125 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs); 126 127 write_lock_bh(&tbl->lock); 128 for (i = 0; i <= tbl->hash_mask; i++) { 129 struct neighbour *n, **np; 130 131 np = &tbl->hash_buckets[i]; 132 while ((n = *np) != NULL) { 133 /* Neighbour record may be discarded if: 134 * - nobody refers to it. 135 * - it is not permanent 136 */ 137 write_lock(&n->lock); 138 if (atomic_read(&n->refcnt) == 1 && 139 !(n->nud_state & NUD_PERMANENT)) { 140 *np = n->next; 141 n->dead = 1; 142 shrunk = 1; 143 write_unlock(&n->lock); 144 neigh_release(n); 145 continue; 146 } 147 write_unlock(&n->lock); 148 np = &n->next; 149 } 150 } 151 152 tbl->last_flush = jiffies; 153 154 write_unlock_bh(&tbl->lock); 155 156 return shrunk; 157 } 158 159 static int neigh_del_timer(struct neighbour *n) 160 { 161 if ((n->nud_state & NUD_IN_TIMER) && 162 del_timer(&n->timer)) { 163 neigh_release(n); 164 return 1; 165 } 166 return 0; 167 } 168 169 static void pneigh_queue_purge(struct sk_buff_head *list) 170 { 171 struct sk_buff *skb; 172 173 while ((skb = skb_dequeue(list)) != NULL) { 174 dev_put(skb->dev); 175 kfree_skb(skb); 176 } 177 } 178 179 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev) 180 { 181 int i; 182 183 for (i = 0; i <= tbl->hash_mask; i++) { 184 struct neighbour *n, **np = &tbl->hash_buckets[i]; 185 186 while ((n = *np) != NULL) { 187 if (dev && n->dev != dev) { 188 np = &n->next; 189 continue; 190 } 191 *np = n->next; 192 write_lock(&n->lock); 193 neigh_del_timer(n); 194 n->dead = 1; 195 196 if (atomic_read(&n->refcnt) != 1) { 197 /* The most unpleasant situation. 198 We must destroy neighbour entry, 199 but someone still uses it. 200 201 The destroy will be delayed until 202 the last user releases us, but 203 we must kill timers etc. and move 204 it to safe state. 205 */ 206 skb_queue_purge(&n->arp_queue); 207 n->output = neigh_blackhole; 208 if (n->nud_state & NUD_VALID) 209 n->nud_state = NUD_NOARP; 210 else 211 n->nud_state = NUD_NONE; 212 NEIGH_PRINTK2("neigh %p is stray.\n", n); 213 } 214 write_unlock(&n->lock); 215 neigh_release(n); 216 } 217 } 218 } 219 220 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev) 221 { 222 write_lock_bh(&tbl->lock); 223 neigh_flush_dev(tbl, dev); 224 write_unlock_bh(&tbl->lock); 225 } 226 227 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 228 { 229 write_lock_bh(&tbl->lock); 230 neigh_flush_dev(tbl, dev); 231 pneigh_ifdown(tbl, dev); 232 write_unlock_bh(&tbl->lock); 233 234 del_timer_sync(&tbl->proxy_timer); 235 pneigh_queue_purge(&tbl->proxy_queue); 236 return 0; 237 } 238 239 static struct neighbour *neigh_alloc(struct neigh_table *tbl) 240 { 241 struct neighbour *n = NULL; 242 unsigned long now = jiffies; 243 int entries; 244 245 entries = atomic_inc_return(&tbl->entries) - 1; 246 if (entries >= tbl->gc_thresh3 || 247 (entries >= tbl->gc_thresh2 && 248 time_after(now, tbl->last_flush + 5 * HZ))) { 249 if (!neigh_forced_gc(tbl) && 250 entries >= tbl->gc_thresh3) 251 goto out_entries; 252 } 253 254 n = kmem_cache_alloc(tbl->kmem_cachep, GFP_ATOMIC); 255 if (!n) 256 goto out_entries; 257 258 memset(n, 0, tbl->entry_size); 259 260 skb_queue_head_init(&n->arp_queue); 261 rwlock_init(&n->lock); 262 n->updated = n->used = now; 263 n->nud_state = NUD_NONE; 264 n->output = neigh_blackhole; 265 n->parms = neigh_parms_clone(&tbl->parms); 266 init_timer(&n->timer); 267 n->timer.function = neigh_timer_handler; 268 n->timer.data = (unsigned long)n; 269 270 NEIGH_CACHE_STAT_INC(tbl, allocs); 271 n->tbl = tbl; 272 atomic_set(&n->refcnt, 1); 273 n->dead = 1; 274 out: 275 return n; 276 277 out_entries: 278 atomic_dec(&tbl->entries); 279 goto out; 280 } 281 282 static struct neighbour **neigh_hash_alloc(unsigned int entries) 283 { 284 unsigned long size = entries * sizeof(struct neighbour *); 285 struct neighbour **ret; 286 287 if (size <= PAGE_SIZE) { 288 ret = kzalloc(size, GFP_ATOMIC); 289 } else { 290 ret = (struct neighbour **) 291 __get_free_pages(GFP_ATOMIC|__GFP_ZERO, get_order(size)); 292 } 293 return ret; 294 } 295 296 static void neigh_hash_free(struct neighbour **hash, unsigned int entries) 297 { 298 unsigned long size = entries * sizeof(struct neighbour *); 299 300 if (size <= PAGE_SIZE) 301 kfree(hash); 302 else 303 free_pages((unsigned long)hash, get_order(size)); 304 } 305 306 static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries) 307 { 308 struct neighbour **new_hash, **old_hash; 309 unsigned int i, new_hash_mask, old_entries; 310 311 NEIGH_CACHE_STAT_INC(tbl, hash_grows); 312 313 BUG_ON(new_entries & (new_entries - 1)); 314 new_hash = neigh_hash_alloc(new_entries); 315 if (!new_hash) 316 return; 317 318 old_entries = tbl->hash_mask + 1; 319 new_hash_mask = new_entries - 1; 320 old_hash = tbl->hash_buckets; 321 322 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd)); 323 for (i = 0; i < old_entries; i++) { 324 struct neighbour *n, *next; 325 326 for (n = old_hash[i]; n; n = next) { 327 unsigned int hash_val = tbl->hash(n->primary_key, n->dev); 328 329 hash_val &= new_hash_mask; 330 next = n->next; 331 332 n->next = new_hash[hash_val]; 333 new_hash[hash_val] = n; 334 } 335 } 336 tbl->hash_buckets = new_hash; 337 tbl->hash_mask = new_hash_mask; 338 339 neigh_hash_free(old_hash, old_entries); 340 } 341 342 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey, 343 struct net_device *dev) 344 { 345 struct neighbour *n; 346 int key_len = tbl->key_len; 347 u32 hash_val = tbl->hash(pkey, dev); 348 349 NEIGH_CACHE_STAT_INC(tbl, lookups); 350 351 read_lock_bh(&tbl->lock); 352 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) { 353 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) { 354 neigh_hold(n); 355 NEIGH_CACHE_STAT_INC(tbl, hits); 356 break; 357 } 358 } 359 read_unlock_bh(&tbl->lock); 360 return n; 361 } 362 363 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, const void *pkey) 364 { 365 struct neighbour *n; 366 int key_len = tbl->key_len; 367 u32 hash_val = tbl->hash(pkey, NULL); 368 369 NEIGH_CACHE_STAT_INC(tbl, lookups); 370 371 read_lock_bh(&tbl->lock); 372 for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) { 373 if (!memcmp(n->primary_key, pkey, key_len)) { 374 neigh_hold(n); 375 NEIGH_CACHE_STAT_INC(tbl, hits); 376 break; 377 } 378 } 379 read_unlock_bh(&tbl->lock); 380 return n; 381 } 382 383 struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey, 384 struct net_device *dev) 385 { 386 u32 hash_val; 387 int key_len = tbl->key_len; 388 int error; 389 struct neighbour *n1, *rc, *n = neigh_alloc(tbl); 390 391 if (!n) { 392 rc = ERR_PTR(-ENOBUFS); 393 goto out; 394 } 395 396 memcpy(n->primary_key, pkey, key_len); 397 n->dev = dev; 398 dev_hold(dev); 399 400 /* Protocol specific setup. */ 401 if (tbl->constructor && (error = tbl->constructor(n)) < 0) { 402 rc = ERR_PTR(error); 403 goto out_neigh_release; 404 } 405 406 /* Device specific setup. */ 407 if (n->parms->neigh_setup && 408 (error = n->parms->neigh_setup(n)) < 0) { 409 rc = ERR_PTR(error); 410 goto out_neigh_release; 411 } 412 413 n->confirmed = jiffies - (n->parms->base_reachable_time << 1); 414 415 write_lock_bh(&tbl->lock); 416 417 if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1)) 418 neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1); 419 420 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask; 421 422 if (n->parms->dead) { 423 rc = ERR_PTR(-EINVAL); 424 goto out_tbl_unlock; 425 } 426 427 for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) { 428 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) { 429 neigh_hold(n1); 430 rc = n1; 431 goto out_tbl_unlock; 432 } 433 } 434 435 n->next = tbl->hash_buckets[hash_val]; 436 tbl->hash_buckets[hash_val] = n; 437 n->dead = 0; 438 neigh_hold(n); 439 write_unlock_bh(&tbl->lock); 440 NEIGH_PRINTK2("neigh %p is created.\n", n); 441 rc = n; 442 out: 443 return rc; 444 out_tbl_unlock: 445 write_unlock_bh(&tbl->lock); 446 out_neigh_release: 447 neigh_release(n); 448 goto out; 449 } 450 451 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, const void *pkey, 452 struct net_device *dev, int creat) 453 { 454 struct pneigh_entry *n; 455 int key_len = tbl->key_len; 456 u32 hash_val = *(u32 *)(pkey + key_len - 4); 457 458 hash_val ^= (hash_val >> 16); 459 hash_val ^= hash_val >> 8; 460 hash_val ^= hash_val >> 4; 461 hash_val &= PNEIGH_HASHMASK; 462 463 read_lock_bh(&tbl->lock); 464 465 for (n = tbl->phash_buckets[hash_val]; n; n = n->next) { 466 if (!memcmp(n->key, pkey, key_len) && 467 (n->dev == dev || !n->dev)) { 468 read_unlock_bh(&tbl->lock); 469 goto out; 470 } 471 } 472 read_unlock_bh(&tbl->lock); 473 n = NULL; 474 if (!creat) 475 goto out; 476 477 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL); 478 if (!n) 479 goto out; 480 481 memcpy(n->key, pkey, key_len); 482 n->dev = dev; 483 if (dev) 484 dev_hold(dev); 485 486 if (tbl->pconstructor && tbl->pconstructor(n)) { 487 if (dev) 488 dev_put(dev); 489 kfree(n); 490 n = NULL; 491 goto out; 492 } 493 494 write_lock_bh(&tbl->lock); 495 n->next = tbl->phash_buckets[hash_val]; 496 tbl->phash_buckets[hash_val] = n; 497 write_unlock_bh(&tbl->lock); 498 out: 499 return n; 500 } 501 502 503 int pneigh_delete(struct neigh_table *tbl, const void *pkey, 504 struct net_device *dev) 505 { 506 struct pneigh_entry *n, **np; 507 int key_len = tbl->key_len; 508 u32 hash_val = *(u32 *)(pkey + key_len - 4); 509 510 hash_val ^= (hash_val >> 16); 511 hash_val ^= hash_val >> 8; 512 hash_val ^= hash_val >> 4; 513 hash_val &= PNEIGH_HASHMASK; 514 515 write_lock_bh(&tbl->lock); 516 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL; 517 np = &n->next) { 518 if (!memcmp(n->key, pkey, key_len) && n->dev == dev) { 519 *np = n->next; 520 write_unlock_bh(&tbl->lock); 521 if (tbl->pdestructor) 522 tbl->pdestructor(n); 523 if (n->dev) 524 dev_put(n->dev); 525 kfree(n); 526 return 0; 527 } 528 } 529 write_unlock_bh(&tbl->lock); 530 return -ENOENT; 531 } 532 533 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 534 { 535 struct pneigh_entry *n, **np; 536 u32 h; 537 538 for (h = 0; h <= PNEIGH_HASHMASK; h++) { 539 np = &tbl->phash_buckets[h]; 540 while ((n = *np) != NULL) { 541 if (!dev || n->dev == dev) { 542 *np = n->next; 543 if (tbl->pdestructor) 544 tbl->pdestructor(n); 545 if (n->dev) 546 dev_put(n->dev); 547 kfree(n); 548 continue; 549 } 550 np = &n->next; 551 } 552 } 553 return -ENOENT; 554 } 555 556 557 /* 558 * neighbour must already be out of the table; 559 * 560 */ 561 void neigh_destroy(struct neighbour *neigh) 562 { 563 struct hh_cache *hh; 564 565 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys); 566 567 if (!neigh->dead) { 568 printk(KERN_WARNING 569 "Destroying alive neighbour %p\n", neigh); 570 dump_stack(); 571 return; 572 } 573 574 if (neigh_del_timer(neigh)) 575 printk(KERN_WARNING "Impossible event.\n"); 576 577 while ((hh = neigh->hh) != NULL) { 578 neigh->hh = hh->hh_next; 579 hh->hh_next = NULL; 580 581 write_seqlock_bh(&hh->hh_lock); 582 hh->hh_output = neigh_blackhole; 583 write_sequnlock_bh(&hh->hh_lock); 584 if (atomic_dec_and_test(&hh->hh_refcnt)) 585 kfree(hh); 586 } 587 588 if (neigh->parms->neigh_destructor) 589 (neigh->parms->neigh_destructor)(neigh); 590 591 skb_queue_purge(&neigh->arp_queue); 592 593 dev_put(neigh->dev); 594 neigh_parms_put(neigh->parms); 595 596 NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh); 597 598 atomic_dec(&neigh->tbl->entries); 599 kmem_cache_free(neigh->tbl->kmem_cachep, neigh); 600 } 601 602 /* Neighbour state is suspicious; 603 disable fast path. 604 605 Called with write_locked neigh. 606 */ 607 static void neigh_suspect(struct neighbour *neigh) 608 { 609 struct hh_cache *hh; 610 611 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh); 612 613 neigh->output = neigh->ops->output; 614 615 for (hh = neigh->hh; hh; hh = hh->hh_next) 616 hh->hh_output = neigh->ops->output; 617 } 618 619 /* Neighbour state is OK; 620 enable fast path. 621 622 Called with write_locked neigh. 623 */ 624 static void neigh_connect(struct neighbour *neigh) 625 { 626 struct hh_cache *hh; 627 628 NEIGH_PRINTK2("neigh %p is connected.\n", neigh); 629 630 neigh->output = neigh->ops->connected_output; 631 632 for (hh = neigh->hh; hh; hh = hh->hh_next) 633 hh->hh_output = neigh->ops->hh_output; 634 } 635 636 static void neigh_periodic_timer(unsigned long arg) 637 { 638 struct neigh_table *tbl = (struct neigh_table *)arg; 639 struct neighbour *n, **np; 640 unsigned long expire, now = jiffies; 641 642 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs); 643 644 write_lock(&tbl->lock); 645 646 /* 647 * periodically recompute ReachableTime from random function 648 */ 649 650 if (time_after(now, tbl->last_rand + 300 * HZ)) { 651 struct neigh_parms *p; 652 tbl->last_rand = now; 653 for (p = &tbl->parms; p; p = p->next) 654 p->reachable_time = 655 neigh_rand_reach_time(p->base_reachable_time); 656 } 657 658 np = &tbl->hash_buckets[tbl->hash_chain_gc]; 659 tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask); 660 661 while ((n = *np) != NULL) { 662 unsigned int state; 663 664 write_lock(&n->lock); 665 666 state = n->nud_state; 667 if (state & (NUD_PERMANENT | NUD_IN_TIMER)) { 668 write_unlock(&n->lock); 669 goto next_elt; 670 } 671 672 if (time_before(n->used, n->confirmed)) 673 n->used = n->confirmed; 674 675 if (atomic_read(&n->refcnt) == 1 && 676 (state == NUD_FAILED || 677 time_after(now, n->used + n->parms->gc_staletime))) { 678 *np = n->next; 679 n->dead = 1; 680 write_unlock(&n->lock); 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 neigh_release(n); 2096 } 2097 } 2098 } 2099 EXPORT_SYMBOL(__neigh_for_each_release); 2100 2101 #ifdef CONFIG_PROC_FS 2102 2103 static struct neighbour *neigh_get_first(struct seq_file *seq) 2104 { 2105 struct neigh_seq_state *state = seq->private; 2106 struct neigh_table *tbl = state->tbl; 2107 struct neighbour *n = NULL; 2108 int bucket = state->bucket; 2109 2110 state->flags &= ~NEIGH_SEQ_IS_PNEIGH; 2111 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) { 2112 n = tbl->hash_buckets[bucket]; 2113 2114 while (n) { 2115 if (state->neigh_sub_iter) { 2116 loff_t fakep = 0; 2117 void *v; 2118 2119 v = state->neigh_sub_iter(state, n, &fakep); 2120 if (!v) 2121 goto next; 2122 } 2123 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 2124 break; 2125 if (n->nud_state & ~NUD_NOARP) 2126 break; 2127 next: 2128 n = n->next; 2129 } 2130 2131 if (n) 2132 break; 2133 } 2134 state->bucket = bucket; 2135 2136 return n; 2137 } 2138 2139 static struct neighbour *neigh_get_next(struct seq_file *seq, 2140 struct neighbour *n, 2141 loff_t *pos) 2142 { 2143 struct neigh_seq_state *state = seq->private; 2144 struct neigh_table *tbl = state->tbl; 2145 2146 if (state->neigh_sub_iter) { 2147 void *v = state->neigh_sub_iter(state, n, pos); 2148 if (v) 2149 return n; 2150 } 2151 n = n->next; 2152 2153 while (1) { 2154 while (n) { 2155 if (state->neigh_sub_iter) { 2156 void *v = state->neigh_sub_iter(state, n, pos); 2157 if (v) 2158 return n; 2159 goto next; 2160 } 2161 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 2162 break; 2163 2164 if (n->nud_state & ~NUD_NOARP) 2165 break; 2166 next: 2167 n = n->next; 2168 } 2169 2170 if (n) 2171 break; 2172 2173 if (++state->bucket > tbl->hash_mask) 2174 break; 2175 2176 n = tbl->hash_buckets[state->bucket]; 2177 } 2178 2179 if (n && pos) 2180 --(*pos); 2181 return n; 2182 } 2183 2184 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos) 2185 { 2186 struct neighbour *n = neigh_get_first(seq); 2187 2188 if (n) { 2189 while (*pos) { 2190 n = neigh_get_next(seq, n, pos); 2191 if (!n) 2192 break; 2193 } 2194 } 2195 return *pos ? NULL : n; 2196 } 2197 2198 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq) 2199 { 2200 struct neigh_seq_state *state = seq->private; 2201 struct neigh_table *tbl = state->tbl; 2202 struct pneigh_entry *pn = NULL; 2203 int bucket = state->bucket; 2204 2205 state->flags |= NEIGH_SEQ_IS_PNEIGH; 2206 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) { 2207 pn = tbl->phash_buckets[bucket]; 2208 if (pn) 2209 break; 2210 } 2211 state->bucket = bucket; 2212 2213 return pn; 2214 } 2215 2216 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq, 2217 struct pneigh_entry *pn, 2218 loff_t *pos) 2219 { 2220 struct neigh_seq_state *state = seq->private; 2221 struct neigh_table *tbl = state->tbl; 2222 2223 pn = pn->next; 2224 while (!pn) { 2225 if (++state->bucket > PNEIGH_HASHMASK) 2226 break; 2227 pn = tbl->phash_buckets[state->bucket]; 2228 if (pn) 2229 break; 2230 } 2231 2232 if (pn && pos) 2233 --(*pos); 2234 2235 return pn; 2236 } 2237 2238 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos) 2239 { 2240 struct pneigh_entry *pn = pneigh_get_first(seq); 2241 2242 if (pn) { 2243 while (*pos) { 2244 pn = pneigh_get_next(seq, pn, pos); 2245 if (!pn) 2246 break; 2247 } 2248 } 2249 return *pos ? NULL : pn; 2250 } 2251 2252 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos) 2253 { 2254 struct neigh_seq_state *state = seq->private; 2255 void *rc; 2256 2257 rc = neigh_get_idx(seq, pos); 2258 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 2259 rc = pneigh_get_idx(seq, pos); 2260 2261 return rc; 2262 } 2263 2264 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags) 2265 { 2266 struct neigh_seq_state *state = seq->private; 2267 loff_t pos_minus_one; 2268 2269 state->tbl = tbl; 2270 state->bucket = 0; 2271 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH); 2272 2273 read_lock_bh(&tbl->lock); 2274 2275 pos_minus_one = *pos - 1; 2276 return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN; 2277 } 2278 EXPORT_SYMBOL(neigh_seq_start); 2279 2280 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2281 { 2282 struct neigh_seq_state *state; 2283 void *rc; 2284 2285 if (v == SEQ_START_TOKEN) { 2286 rc = neigh_get_idx(seq, pos); 2287 goto out; 2288 } 2289 2290 state = seq->private; 2291 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) { 2292 rc = neigh_get_next(seq, v, NULL); 2293 if (rc) 2294 goto out; 2295 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 2296 rc = pneigh_get_first(seq); 2297 } else { 2298 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY); 2299 rc = pneigh_get_next(seq, v, NULL); 2300 } 2301 out: 2302 ++(*pos); 2303 return rc; 2304 } 2305 EXPORT_SYMBOL(neigh_seq_next); 2306 2307 void neigh_seq_stop(struct seq_file *seq, void *v) 2308 { 2309 struct neigh_seq_state *state = seq->private; 2310 struct neigh_table *tbl = state->tbl; 2311 2312 read_unlock_bh(&tbl->lock); 2313 } 2314 EXPORT_SYMBOL(neigh_seq_stop); 2315 2316 /* statistics via seq_file */ 2317 2318 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos) 2319 { 2320 struct proc_dir_entry *pde = seq->private; 2321 struct neigh_table *tbl = pde->data; 2322 int cpu; 2323 2324 if (*pos == 0) 2325 return SEQ_START_TOKEN; 2326 2327 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) { 2328 if (!cpu_possible(cpu)) 2329 continue; 2330 *pos = cpu+1; 2331 return per_cpu_ptr(tbl->stats, cpu); 2332 } 2333 return NULL; 2334 } 2335 2336 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2337 { 2338 struct proc_dir_entry *pde = seq->private; 2339 struct neigh_table *tbl = pde->data; 2340 int cpu; 2341 2342 for (cpu = *pos; cpu < NR_CPUS; ++cpu) { 2343 if (!cpu_possible(cpu)) 2344 continue; 2345 *pos = cpu+1; 2346 return per_cpu_ptr(tbl->stats, cpu); 2347 } 2348 return NULL; 2349 } 2350 2351 static void neigh_stat_seq_stop(struct seq_file *seq, void *v) 2352 { 2353 2354 } 2355 2356 static int neigh_stat_seq_show(struct seq_file *seq, void *v) 2357 { 2358 struct proc_dir_entry *pde = seq->private; 2359 struct neigh_table *tbl = pde->data; 2360 struct neigh_statistics *st = v; 2361 2362 if (v == SEQ_START_TOKEN) { 2363 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"); 2364 return 0; 2365 } 2366 2367 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx " 2368 "%08lx %08lx %08lx %08lx\n", 2369 atomic_read(&tbl->entries), 2370 2371 st->allocs, 2372 st->destroys, 2373 st->hash_grows, 2374 2375 st->lookups, 2376 st->hits, 2377 2378 st->res_failed, 2379 2380 st->rcv_probes_mcast, 2381 st->rcv_probes_ucast, 2382 2383 st->periodic_gc_runs, 2384 st->forced_gc_runs 2385 ); 2386 2387 return 0; 2388 } 2389 2390 static struct seq_operations neigh_stat_seq_ops = { 2391 .start = neigh_stat_seq_start, 2392 .next = neigh_stat_seq_next, 2393 .stop = neigh_stat_seq_stop, 2394 .show = neigh_stat_seq_show, 2395 }; 2396 2397 static int neigh_stat_seq_open(struct inode *inode, struct file *file) 2398 { 2399 int ret = seq_open(file, &neigh_stat_seq_ops); 2400 2401 if (!ret) { 2402 struct seq_file *sf = file->private_data; 2403 sf->private = PDE(inode); 2404 } 2405 return ret; 2406 }; 2407 2408 static struct file_operations neigh_stat_seq_fops = { 2409 .owner = THIS_MODULE, 2410 .open = neigh_stat_seq_open, 2411 .read = seq_read, 2412 .llseek = seq_lseek, 2413 .release = seq_release, 2414 }; 2415 2416 #endif /* CONFIG_PROC_FS */ 2417 2418 #ifdef CONFIG_ARPD 2419 static inline size_t neigh_nlmsg_size(void) 2420 { 2421 return NLMSG_ALIGN(sizeof(struct ndmsg)) 2422 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */ 2423 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */ 2424 + nla_total_size(sizeof(struct nda_cacheinfo)) 2425 + nla_total_size(4); /* NDA_PROBES */ 2426 } 2427 2428 static void __neigh_notify(struct neighbour *n, int type, int flags) 2429 { 2430 struct sk_buff *skb; 2431 int err = -ENOBUFS; 2432 2433 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC); 2434 if (skb == NULL) 2435 goto errout; 2436 2437 err = neigh_fill_info(skb, n, 0, 0, type, flags); 2438 if (err < 0) { 2439 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */ 2440 WARN_ON(err == -EMSGSIZE); 2441 kfree_skb(skb); 2442 goto errout; 2443 } 2444 err = rtnl_notify(skb, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 2445 errout: 2446 if (err < 0) 2447 rtnl_set_sk_err(RTNLGRP_NEIGH, err); 2448 } 2449 2450 void neigh_app_ns(struct neighbour *n) 2451 { 2452 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST); 2453 } 2454 2455 static void neigh_app_notify(struct neighbour *n) 2456 { 2457 __neigh_notify(n, RTM_NEWNEIGH, 0); 2458 } 2459 2460 #endif /* CONFIG_ARPD */ 2461 2462 #ifdef CONFIG_SYSCTL 2463 2464 static struct neigh_sysctl_table { 2465 struct ctl_table_header *sysctl_header; 2466 ctl_table neigh_vars[__NET_NEIGH_MAX]; 2467 ctl_table neigh_dev[2]; 2468 ctl_table neigh_neigh_dir[2]; 2469 ctl_table neigh_proto_dir[2]; 2470 ctl_table neigh_root_dir[2]; 2471 } neigh_sysctl_template __read_mostly = { 2472 .neigh_vars = { 2473 { 2474 .ctl_name = NET_NEIGH_MCAST_SOLICIT, 2475 .procname = "mcast_solicit", 2476 .maxlen = sizeof(int), 2477 .mode = 0644, 2478 .proc_handler = &proc_dointvec, 2479 }, 2480 { 2481 .ctl_name = NET_NEIGH_UCAST_SOLICIT, 2482 .procname = "ucast_solicit", 2483 .maxlen = sizeof(int), 2484 .mode = 0644, 2485 .proc_handler = &proc_dointvec, 2486 }, 2487 { 2488 .ctl_name = NET_NEIGH_APP_SOLICIT, 2489 .procname = "app_solicit", 2490 .maxlen = sizeof(int), 2491 .mode = 0644, 2492 .proc_handler = &proc_dointvec, 2493 }, 2494 { 2495 .ctl_name = NET_NEIGH_RETRANS_TIME, 2496 .procname = "retrans_time", 2497 .maxlen = sizeof(int), 2498 .mode = 0644, 2499 .proc_handler = &proc_dointvec_userhz_jiffies, 2500 }, 2501 { 2502 .ctl_name = NET_NEIGH_REACHABLE_TIME, 2503 .procname = "base_reachable_time", 2504 .maxlen = sizeof(int), 2505 .mode = 0644, 2506 .proc_handler = &proc_dointvec_jiffies, 2507 .strategy = &sysctl_jiffies, 2508 }, 2509 { 2510 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME, 2511 .procname = "delay_first_probe_time", 2512 .maxlen = sizeof(int), 2513 .mode = 0644, 2514 .proc_handler = &proc_dointvec_jiffies, 2515 .strategy = &sysctl_jiffies, 2516 }, 2517 { 2518 .ctl_name = NET_NEIGH_GC_STALE_TIME, 2519 .procname = "gc_stale_time", 2520 .maxlen = sizeof(int), 2521 .mode = 0644, 2522 .proc_handler = &proc_dointvec_jiffies, 2523 .strategy = &sysctl_jiffies, 2524 }, 2525 { 2526 .ctl_name = NET_NEIGH_UNRES_QLEN, 2527 .procname = "unres_qlen", 2528 .maxlen = sizeof(int), 2529 .mode = 0644, 2530 .proc_handler = &proc_dointvec, 2531 }, 2532 { 2533 .ctl_name = NET_NEIGH_PROXY_QLEN, 2534 .procname = "proxy_qlen", 2535 .maxlen = sizeof(int), 2536 .mode = 0644, 2537 .proc_handler = &proc_dointvec, 2538 }, 2539 { 2540 .ctl_name = NET_NEIGH_ANYCAST_DELAY, 2541 .procname = "anycast_delay", 2542 .maxlen = sizeof(int), 2543 .mode = 0644, 2544 .proc_handler = &proc_dointvec_userhz_jiffies, 2545 }, 2546 { 2547 .ctl_name = NET_NEIGH_PROXY_DELAY, 2548 .procname = "proxy_delay", 2549 .maxlen = sizeof(int), 2550 .mode = 0644, 2551 .proc_handler = &proc_dointvec_userhz_jiffies, 2552 }, 2553 { 2554 .ctl_name = NET_NEIGH_LOCKTIME, 2555 .procname = "locktime", 2556 .maxlen = sizeof(int), 2557 .mode = 0644, 2558 .proc_handler = &proc_dointvec_userhz_jiffies, 2559 }, 2560 { 2561 .ctl_name = NET_NEIGH_GC_INTERVAL, 2562 .procname = "gc_interval", 2563 .maxlen = sizeof(int), 2564 .mode = 0644, 2565 .proc_handler = &proc_dointvec_jiffies, 2566 .strategy = &sysctl_jiffies, 2567 }, 2568 { 2569 .ctl_name = NET_NEIGH_GC_THRESH1, 2570 .procname = "gc_thresh1", 2571 .maxlen = sizeof(int), 2572 .mode = 0644, 2573 .proc_handler = &proc_dointvec, 2574 }, 2575 { 2576 .ctl_name = NET_NEIGH_GC_THRESH2, 2577 .procname = "gc_thresh2", 2578 .maxlen = sizeof(int), 2579 .mode = 0644, 2580 .proc_handler = &proc_dointvec, 2581 }, 2582 { 2583 .ctl_name = NET_NEIGH_GC_THRESH3, 2584 .procname = "gc_thresh3", 2585 .maxlen = sizeof(int), 2586 .mode = 0644, 2587 .proc_handler = &proc_dointvec, 2588 }, 2589 { 2590 .ctl_name = NET_NEIGH_RETRANS_TIME_MS, 2591 .procname = "retrans_time_ms", 2592 .maxlen = sizeof(int), 2593 .mode = 0644, 2594 .proc_handler = &proc_dointvec_ms_jiffies, 2595 .strategy = &sysctl_ms_jiffies, 2596 }, 2597 { 2598 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS, 2599 .procname = "base_reachable_time_ms", 2600 .maxlen = sizeof(int), 2601 .mode = 0644, 2602 .proc_handler = &proc_dointvec_ms_jiffies, 2603 .strategy = &sysctl_ms_jiffies, 2604 }, 2605 }, 2606 .neigh_dev = { 2607 { 2608 .ctl_name = NET_PROTO_CONF_DEFAULT, 2609 .procname = "default", 2610 .mode = 0555, 2611 }, 2612 }, 2613 .neigh_neigh_dir = { 2614 { 2615 .procname = "neigh", 2616 .mode = 0555, 2617 }, 2618 }, 2619 .neigh_proto_dir = { 2620 { 2621 .mode = 0555, 2622 }, 2623 }, 2624 .neigh_root_dir = { 2625 { 2626 .ctl_name = CTL_NET, 2627 .procname = "net", 2628 .mode = 0555, 2629 }, 2630 }, 2631 }; 2632 2633 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, 2634 int p_id, int pdev_id, char *p_name, 2635 proc_handler *handler, ctl_handler *strategy) 2636 { 2637 struct neigh_sysctl_table *t = kmemdup(&neigh_sysctl_template, 2638 sizeof(*t), GFP_KERNEL); 2639 const char *dev_name_source = NULL; 2640 char *dev_name = NULL; 2641 int err = 0; 2642 2643 if (!t) 2644 return -ENOBUFS; 2645 t->neigh_vars[0].data = &p->mcast_probes; 2646 t->neigh_vars[1].data = &p->ucast_probes; 2647 t->neigh_vars[2].data = &p->app_probes; 2648 t->neigh_vars[3].data = &p->retrans_time; 2649 t->neigh_vars[4].data = &p->base_reachable_time; 2650 t->neigh_vars[5].data = &p->delay_probe_time; 2651 t->neigh_vars[6].data = &p->gc_staletime; 2652 t->neigh_vars[7].data = &p->queue_len; 2653 t->neigh_vars[8].data = &p->proxy_qlen; 2654 t->neigh_vars[9].data = &p->anycast_delay; 2655 t->neigh_vars[10].data = &p->proxy_delay; 2656 t->neigh_vars[11].data = &p->locktime; 2657 2658 if (dev) { 2659 dev_name_source = dev->name; 2660 t->neigh_dev[0].ctl_name = dev->ifindex; 2661 t->neigh_vars[12].procname = NULL; 2662 t->neigh_vars[13].procname = NULL; 2663 t->neigh_vars[14].procname = NULL; 2664 t->neigh_vars[15].procname = NULL; 2665 } else { 2666 dev_name_source = t->neigh_dev[0].procname; 2667 t->neigh_vars[12].data = (int *)(p + 1); 2668 t->neigh_vars[13].data = (int *)(p + 1) + 1; 2669 t->neigh_vars[14].data = (int *)(p + 1) + 2; 2670 t->neigh_vars[15].data = (int *)(p + 1) + 3; 2671 } 2672 2673 t->neigh_vars[16].data = &p->retrans_time; 2674 t->neigh_vars[17].data = &p->base_reachable_time; 2675 2676 if (handler || strategy) { 2677 /* RetransTime */ 2678 t->neigh_vars[3].proc_handler = handler; 2679 t->neigh_vars[3].strategy = strategy; 2680 t->neigh_vars[3].extra1 = dev; 2681 /* ReachableTime */ 2682 t->neigh_vars[4].proc_handler = handler; 2683 t->neigh_vars[4].strategy = strategy; 2684 t->neigh_vars[4].extra1 = dev; 2685 /* RetransTime (in milliseconds)*/ 2686 t->neigh_vars[16].proc_handler = handler; 2687 t->neigh_vars[16].strategy = strategy; 2688 t->neigh_vars[16].extra1 = dev; 2689 /* ReachableTime (in milliseconds) */ 2690 t->neigh_vars[17].proc_handler = handler; 2691 t->neigh_vars[17].strategy = strategy; 2692 t->neigh_vars[17].extra1 = dev; 2693 } 2694 2695 dev_name = kstrdup(dev_name_source, GFP_KERNEL); 2696 if (!dev_name) { 2697 err = -ENOBUFS; 2698 goto free; 2699 } 2700 2701 t->neigh_dev[0].procname = dev_name; 2702 2703 t->neigh_neigh_dir[0].ctl_name = pdev_id; 2704 2705 t->neigh_proto_dir[0].procname = p_name; 2706 t->neigh_proto_dir[0].ctl_name = p_id; 2707 2708 t->neigh_dev[0].child = t->neigh_vars; 2709 t->neigh_neigh_dir[0].child = t->neigh_dev; 2710 t->neigh_proto_dir[0].child = t->neigh_neigh_dir; 2711 t->neigh_root_dir[0].child = t->neigh_proto_dir; 2712 2713 t->sysctl_header = register_sysctl_table(t->neigh_root_dir, 0); 2714 if (!t->sysctl_header) { 2715 err = -ENOBUFS; 2716 goto free_procname; 2717 } 2718 p->sysctl_table = t; 2719 return 0; 2720 2721 /* error path */ 2722 free_procname: 2723 kfree(dev_name); 2724 free: 2725 kfree(t); 2726 2727 return err; 2728 } 2729 2730 void neigh_sysctl_unregister(struct neigh_parms *p) 2731 { 2732 if (p->sysctl_table) { 2733 struct neigh_sysctl_table *t = p->sysctl_table; 2734 p->sysctl_table = NULL; 2735 unregister_sysctl_table(t->sysctl_header); 2736 kfree(t->neigh_dev[0].procname); 2737 kfree(t); 2738 } 2739 } 2740 2741 #endif /* CONFIG_SYSCTL */ 2742 2743 EXPORT_SYMBOL(__neigh_event_send); 2744 EXPORT_SYMBOL(neigh_changeaddr); 2745 EXPORT_SYMBOL(neigh_compat_output); 2746 EXPORT_SYMBOL(neigh_connected_output); 2747 EXPORT_SYMBOL(neigh_create); 2748 EXPORT_SYMBOL(neigh_delete); 2749 EXPORT_SYMBOL(neigh_destroy); 2750 EXPORT_SYMBOL(neigh_dump_info); 2751 EXPORT_SYMBOL(neigh_event_ns); 2752 EXPORT_SYMBOL(neigh_ifdown); 2753 EXPORT_SYMBOL(neigh_lookup); 2754 EXPORT_SYMBOL(neigh_lookup_nodev); 2755 EXPORT_SYMBOL(neigh_parms_alloc); 2756 EXPORT_SYMBOL(neigh_parms_release); 2757 EXPORT_SYMBOL(neigh_rand_reach_time); 2758 EXPORT_SYMBOL(neigh_resolve_output); 2759 EXPORT_SYMBOL(neigh_table_clear); 2760 EXPORT_SYMBOL(neigh_table_init); 2761 EXPORT_SYMBOL(neigh_table_init_no_netlink); 2762 EXPORT_SYMBOL(neigh_update); 2763 EXPORT_SYMBOL(pneigh_enqueue); 2764 EXPORT_SYMBOL(pneigh_lookup); 2765 2766 #ifdef CONFIG_ARPD 2767 EXPORT_SYMBOL(neigh_app_ns); 2768 #endif 2769 #ifdef CONFIG_SYSCTL 2770 EXPORT_SYMBOL(neigh_sysctl_register); 2771 EXPORT_SYMBOL(neigh_sysctl_unregister); 2772 #endif 2773