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 mod_timer(&tbl->gc_timer, now + expire); 700 701 write_unlock(&tbl->lock); 702 } 703 704 static __inline__ int neigh_max_probes(struct neighbour *n) 705 { 706 struct neigh_parms *p = n->parms; 707 return (n->nud_state & NUD_PROBE ? 708 p->ucast_probes : 709 p->ucast_probes + p->app_probes + p->mcast_probes); 710 } 711 712 static inline void neigh_add_timer(struct neighbour *n, unsigned long when) 713 { 714 if (unlikely(mod_timer(&n->timer, when))) { 715 printk("NEIGH: BUG, double timer add, state is %x\n", 716 n->nud_state); 717 dump_stack(); 718 } 719 } 720 721 /* Called when a timer expires for a neighbour entry. */ 722 723 static void neigh_timer_handler(unsigned long arg) 724 { 725 unsigned long now, next; 726 struct neighbour *neigh = (struct neighbour *)arg; 727 unsigned state; 728 int notify = 0; 729 730 write_lock(&neigh->lock); 731 732 state = neigh->nud_state; 733 now = jiffies; 734 next = now + HZ; 735 736 if (!(state & NUD_IN_TIMER)) { 737 #ifndef CONFIG_SMP 738 printk(KERN_WARNING "neigh: timer & !nud_in_timer\n"); 739 #endif 740 goto out; 741 } 742 743 if (state & NUD_REACHABLE) { 744 if (time_before_eq(now, 745 neigh->confirmed + neigh->parms->reachable_time)) { 746 NEIGH_PRINTK2("neigh %p is still alive.\n", neigh); 747 next = neigh->confirmed + neigh->parms->reachable_time; 748 } else if (time_before_eq(now, 749 neigh->used + neigh->parms->delay_probe_time)) { 750 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh); 751 neigh->nud_state = NUD_DELAY; 752 neigh->updated = jiffies; 753 neigh_suspect(neigh); 754 next = now + neigh->parms->delay_probe_time; 755 } else { 756 NEIGH_PRINTK2("neigh %p is suspected.\n", neigh); 757 neigh->nud_state = NUD_STALE; 758 neigh->updated = jiffies; 759 neigh_suspect(neigh); 760 notify = 1; 761 } 762 } else if (state & NUD_DELAY) { 763 if (time_before_eq(now, 764 neigh->confirmed + neigh->parms->delay_probe_time)) { 765 NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh); 766 neigh->nud_state = NUD_REACHABLE; 767 neigh->updated = jiffies; 768 neigh_connect(neigh); 769 notify = 1; 770 next = neigh->confirmed + neigh->parms->reachable_time; 771 } else { 772 NEIGH_PRINTK2("neigh %p is probed.\n", neigh); 773 neigh->nud_state = NUD_PROBE; 774 neigh->updated = jiffies; 775 atomic_set(&neigh->probes, 0); 776 next = now + neigh->parms->retrans_time; 777 } 778 } else { 779 /* NUD_PROBE|NUD_INCOMPLETE */ 780 next = now + neigh->parms->retrans_time; 781 } 782 783 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) && 784 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) { 785 struct sk_buff *skb; 786 787 neigh->nud_state = NUD_FAILED; 788 neigh->updated = jiffies; 789 notify = 1; 790 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed); 791 NEIGH_PRINTK2("neigh %p is failed.\n", neigh); 792 793 /* It is very thin place. report_unreachable is very complicated 794 routine. Particularly, it can hit the same neighbour entry! 795 796 So that, we try to be accurate and avoid dead loop. --ANK 797 */ 798 while (neigh->nud_state == NUD_FAILED && 799 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 800 write_unlock(&neigh->lock); 801 neigh->ops->error_report(neigh, skb); 802 write_lock(&neigh->lock); 803 } 804 skb_queue_purge(&neigh->arp_queue); 805 } 806 807 if (neigh->nud_state & NUD_IN_TIMER) { 808 if (time_before(next, jiffies + HZ/2)) 809 next = jiffies + HZ/2; 810 if (!mod_timer(&neigh->timer, next)) 811 neigh_hold(neigh); 812 } 813 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) { 814 struct sk_buff *skb = skb_peek(&neigh->arp_queue); 815 /* keep skb alive even if arp_queue overflows */ 816 if (skb) 817 skb_get(skb); 818 write_unlock(&neigh->lock); 819 neigh->ops->solicit(neigh, skb); 820 atomic_inc(&neigh->probes); 821 if (skb) 822 kfree_skb(skb); 823 } else { 824 out: 825 write_unlock(&neigh->lock); 826 } 827 if (notify) 828 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh); 829 830 #ifdef CONFIG_ARPD 831 if (notify && neigh->parms->app_probes) 832 neigh_app_notify(neigh); 833 #endif 834 neigh_release(neigh); 835 } 836 837 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) 838 { 839 int rc; 840 unsigned long now; 841 842 write_lock_bh(&neigh->lock); 843 844 rc = 0; 845 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE)) 846 goto out_unlock_bh; 847 848 now = jiffies; 849 850 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) { 851 if (neigh->parms->mcast_probes + neigh->parms->app_probes) { 852 atomic_set(&neigh->probes, neigh->parms->ucast_probes); 853 neigh->nud_state = NUD_INCOMPLETE; 854 neigh->updated = jiffies; 855 neigh_hold(neigh); 856 neigh_add_timer(neigh, now + 1); 857 } else { 858 neigh->nud_state = NUD_FAILED; 859 neigh->updated = jiffies; 860 write_unlock_bh(&neigh->lock); 861 862 if (skb) 863 kfree_skb(skb); 864 return 1; 865 } 866 } else if (neigh->nud_state & NUD_STALE) { 867 NEIGH_PRINTK2("neigh %p is delayed.\n", neigh); 868 neigh_hold(neigh); 869 neigh->nud_state = NUD_DELAY; 870 neigh->updated = jiffies; 871 neigh_add_timer(neigh, 872 jiffies + neigh->parms->delay_probe_time); 873 } 874 875 if (neigh->nud_state == NUD_INCOMPLETE) { 876 if (skb) { 877 if (skb_queue_len(&neigh->arp_queue) >= 878 neigh->parms->queue_len) { 879 struct sk_buff *buff; 880 buff = neigh->arp_queue.next; 881 __skb_unlink(buff, &neigh->arp_queue); 882 kfree_skb(buff); 883 } 884 __skb_queue_tail(&neigh->arp_queue, skb); 885 } 886 rc = 1; 887 } 888 out_unlock_bh: 889 write_unlock_bh(&neigh->lock); 890 return rc; 891 } 892 893 static void neigh_update_hhs(struct neighbour *neigh) 894 { 895 struct hh_cache *hh; 896 void (*update)(struct hh_cache*, struct net_device*, unsigned char *) = 897 neigh->dev->header_cache_update; 898 899 if (update) { 900 for (hh = neigh->hh; hh; hh = hh->hh_next) { 901 write_seqlock_bh(&hh->hh_lock); 902 update(hh, neigh->dev, neigh->ha); 903 write_sequnlock_bh(&hh->hh_lock); 904 } 905 } 906 } 907 908 909 910 /* Generic update routine. 911 -- lladdr is new lladdr or NULL, if it is not supplied. 912 -- new is new state. 913 -- flags 914 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr, 915 if it is different. 916 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected" 917 lladdr instead of overriding it 918 if it is different. 919 It also allows to retain current state 920 if lladdr is unchanged. 921 NEIGH_UPDATE_F_ADMIN means that the change is administrative. 922 923 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing 924 NTF_ROUTER flag. 925 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as 926 a router. 927 928 Caller MUST hold reference count on the entry. 929 */ 930 931 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 932 u32 flags) 933 { 934 u8 old; 935 int err; 936 int notify = 0; 937 struct net_device *dev; 938 int update_isrouter = 0; 939 940 write_lock_bh(&neigh->lock); 941 942 dev = neigh->dev; 943 old = neigh->nud_state; 944 err = -EPERM; 945 946 if (!(flags & NEIGH_UPDATE_F_ADMIN) && 947 (old & (NUD_NOARP | NUD_PERMANENT))) 948 goto out; 949 950 if (!(new & NUD_VALID)) { 951 neigh_del_timer(neigh); 952 if (old & NUD_CONNECTED) 953 neigh_suspect(neigh); 954 neigh->nud_state = new; 955 err = 0; 956 notify = old & NUD_VALID; 957 goto out; 958 } 959 960 /* Compare new lladdr with cached one */ 961 if (!dev->addr_len) { 962 /* First case: device needs no address. */ 963 lladdr = neigh->ha; 964 } else if (lladdr) { 965 /* The second case: if something is already cached 966 and a new address is proposed: 967 - compare new & old 968 - if they are different, check override flag 969 */ 970 if ((old & NUD_VALID) && 971 !memcmp(lladdr, neigh->ha, dev->addr_len)) 972 lladdr = neigh->ha; 973 } else { 974 /* No address is supplied; if we know something, 975 use it, otherwise discard the request. 976 */ 977 err = -EINVAL; 978 if (!(old & NUD_VALID)) 979 goto out; 980 lladdr = neigh->ha; 981 } 982 983 if (new & NUD_CONNECTED) 984 neigh->confirmed = jiffies; 985 neigh->updated = jiffies; 986 987 /* If entry was valid and address is not changed, 988 do not change entry state, if new one is STALE. 989 */ 990 err = 0; 991 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER; 992 if (old & NUD_VALID) { 993 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) { 994 update_isrouter = 0; 995 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) && 996 (old & NUD_CONNECTED)) { 997 lladdr = neigh->ha; 998 new = NUD_STALE; 999 } else 1000 goto out; 1001 } else { 1002 if (lladdr == neigh->ha && new == NUD_STALE && 1003 ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) || 1004 (old & NUD_CONNECTED)) 1005 ) 1006 new = old; 1007 } 1008 } 1009 1010 if (new != old) { 1011 neigh_del_timer(neigh); 1012 if (new & NUD_IN_TIMER) { 1013 neigh_hold(neigh); 1014 neigh_add_timer(neigh, (jiffies + 1015 ((new & NUD_REACHABLE) ? 1016 neigh->parms->reachable_time : 1017 0))); 1018 } 1019 neigh->nud_state = new; 1020 } 1021 1022 if (lladdr != neigh->ha) { 1023 memcpy(&neigh->ha, lladdr, dev->addr_len); 1024 neigh_update_hhs(neigh); 1025 if (!(new & NUD_CONNECTED)) 1026 neigh->confirmed = jiffies - 1027 (neigh->parms->base_reachable_time << 1); 1028 notify = 1; 1029 } 1030 if (new == old) 1031 goto out; 1032 if (new & NUD_CONNECTED) 1033 neigh_connect(neigh); 1034 else 1035 neigh_suspect(neigh); 1036 if (!(old & NUD_VALID)) { 1037 struct sk_buff *skb; 1038 1039 /* Again: avoid dead loop if something went wrong */ 1040 1041 while (neigh->nud_state & NUD_VALID && 1042 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 1043 struct neighbour *n1 = neigh; 1044 write_unlock_bh(&neigh->lock); 1045 /* On shaper/eql skb->dst->neighbour != neigh :( */ 1046 if (skb->dst && skb->dst->neighbour) 1047 n1 = skb->dst->neighbour; 1048 n1->output(skb); 1049 write_lock_bh(&neigh->lock); 1050 } 1051 skb_queue_purge(&neigh->arp_queue); 1052 } 1053 out: 1054 if (update_isrouter) { 1055 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ? 1056 (neigh->flags | NTF_ROUTER) : 1057 (neigh->flags & ~NTF_ROUTER); 1058 } 1059 write_unlock_bh(&neigh->lock); 1060 1061 if (notify) 1062 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh); 1063 #ifdef CONFIG_ARPD 1064 if (notify && neigh->parms->app_probes) 1065 neigh_app_notify(neigh); 1066 #endif 1067 return err; 1068 } 1069 1070 struct neighbour *neigh_event_ns(struct neigh_table *tbl, 1071 u8 *lladdr, void *saddr, 1072 struct net_device *dev) 1073 { 1074 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev, 1075 lladdr || !dev->addr_len); 1076 if (neigh) 1077 neigh_update(neigh, lladdr, NUD_STALE, 1078 NEIGH_UPDATE_F_OVERRIDE); 1079 return neigh; 1080 } 1081 1082 static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst, 1083 __be16 protocol) 1084 { 1085 struct hh_cache *hh; 1086 struct net_device *dev = dst->dev; 1087 1088 for (hh = n->hh; hh; hh = hh->hh_next) 1089 if (hh->hh_type == protocol) 1090 break; 1091 1092 if (!hh && (hh = kzalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) { 1093 seqlock_init(&hh->hh_lock); 1094 hh->hh_type = protocol; 1095 atomic_set(&hh->hh_refcnt, 0); 1096 hh->hh_next = NULL; 1097 if (dev->hard_header_cache(n, hh)) { 1098 kfree(hh); 1099 hh = NULL; 1100 } else { 1101 atomic_inc(&hh->hh_refcnt); 1102 hh->hh_next = n->hh; 1103 n->hh = hh; 1104 if (n->nud_state & NUD_CONNECTED) 1105 hh->hh_output = n->ops->hh_output; 1106 else 1107 hh->hh_output = n->ops->output; 1108 } 1109 } 1110 if (hh) { 1111 atomic_inc(&hh->hh_refcnt); 1112 dst->hh = hh; 1113 } 1114 } 1115 1116 /* This function can be used in contexts, where only old dev_queue_xmit 1117 worked, f.e. if you want to override normal output path (eql, shaper), 1118 but resolution is not made yet. 1119 */ 1120 1121 int neigh_compat_output(struct sk_buff *skb) 1122 { 1123 struct net_device *dev = skb->dev; 1124 1125 __skb_pull(skb, skb->nh.raw - skb->data); 1126 1127 if (dev->hard_header && 1128 dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL, 1129 skb->len) < 0 && 1130 dev->rebuild_header(skb)) 1131 return 0; 1132 1133 return dev_queue_xmit(skb); 1134 } 1135 1136 /* Slow and careful. */ 1137 1138 int neigh_resolve_output(struct sk_buff *skb) 1139 { 1140 struct dst_entry *dst = skb->dst; 1141 struct neighbour *neigh; 1142 int rc = 0; 1143 1144 if (!dst || !(neigh = dst->neighbour)) 1145 goto discard; 1146 1147 __skb_pull(skb, skb->nh.raw - skb->data); 1148 1149 if (!neigh_event_send(neigh, skb)) { 1150 int err; 1151 struct net_device *dev = neigh->dev; 1152 if (dev->hard_header_cache && !dst->hh) { 1153 write_lock_bh(&neigh->lock); 1154 if (!dst->hh) 1155 neigh_hh_init(neigh, dst, dst->ops->protocol); 1156 err = dev->hard_header(skb, dev, ntohs(skb->protocol), 1157 neigh->ha, NULL, skb->len); 1158 write_unlock_bh(&neigh->lock); 1159 } else { 1160 read_lock_bh(&neigh->lock); 1161 err = dev->hard_header(skb, dev, ntohs(skb->protocol), 1162 neigh->ha, NULL, skb->len); 1163 read_unlock_bh(&neigh->lock); 1164 } 1165 if (err >= 0) 1166 rc = neigh->ops->queue_xmit(skb); 1167 else 1168 goto out_kfree_skb; 1169 } 1170 out: 1171 return rc; 1172 discard: 1173 NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n", 1174 dst, dst ? dst->neighbour : NULL); 1175 out_kfree_skb: 1176 rc = -EINVAL; 1177 kfree_skb(skb); 1178 goto out; 1179 } 1180 1181 /* As fast as possible without hh cache */ 1182 1183 int neigh_connected_output(struct sk_buff *skb) 1184 { 1185 int err; 1186 struct dst_entry *dst = skb->dst; 1187 struct neighbour *neigh = dst->neighbour; 1188 struct net_device *dev = neigh->dev; 1189 1190 __skb_pull(skb, skb->nh.raw - skb->data); 1191 1192 read_lock_bh(&neigh->lock); 1193 err = dev->hard_header(skb, dev, ntohs(skb->protocol), 1194 neigh->ha, NULL, skb->len); 1195 read_unlock_bh(&neigh->lock); 1196 if (err >= 0) 1197 err = neigh->ops->queue_xmit(skb); 1198 else { 1199 err = -EINVAL; 1200 kfree_skb(skb); 1201 } 1202 return err; 1203 } 1204 1205 static void neigh_proxy_process(unsigned long arg) 1206 { 1207 struct neigh_table *tbl = (struct neigh_table *)arg; 1208 long sched_next = 0; 1209 unsigned long now = jiffies; 1210 struct sk_buff *skb; 1211 1212 spin_lock(&tbl->proxy_queue.lock); 1213 1214 skb = tbl->proxy_queue.next; 1215 1216 while (skb != (struct sk_buff *)&tbl->proxy_queue) { 1217 struct sk_buff *back = skb; 1218 long tdif = NEIGH_CB(back)->sched_next - now; 1219 1220 skb = skb->next; 1221 if (tdif <= 0) { 1222 struct net_device *dev = back->dev; 1223 __skb_unlink(back, &tbl->proxy_queue); 1224 if (tbl->proxy_redo && netif_running(dev)) 1225 tbl->proxy_redo(back); 1226 else 1227 kfree_skb(back); 1228 1229 dev_put(dev); 1230 } else if (!sched_next || tdif < sched_next) 1231 sched_next = tdif; 1232 } 1233 del_timer(&tbl->proxy_timer); 1234 if (sched_next) 1235 mod_timer(&tbl->proxy_timer, jiffies + sched_next); 1236 spin_unlock(&tbl->proxy_queue.lock); 1237 } 1238 1239 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, 1240 struct sk_buff *skb) 1241 { 1242 unsigned long now = jiffies; 1243 unsigned long sched_next = now + (net_random() % p->proxy_delay); 1244 1245 if (tbl->proxy_queue.qlen > p->proxy_qlen) { 1246 kfree_skb(skb); 1247 return; 1248 } 1249 1250 NEIGH_CB(skb)->sched_next = sched_next; 1251 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED; 1252 1253 spin_lock(&tbl->proxy_queue.lock); 1254 if (del_timer(&tbl->proxy_timer)) { 1255 if (time_before(tbl->proxy_timer.expires, sched_next)) 1256 sched_next = tbl->proxy_timer.expires; 1257 } 1258 dst_release(skb->dst); 1259 skb->dst = NULL; 1260 dev_hold(skb->dev); 1261 __skb_queue_tail(&tbl->proxy_queue, skb); 1262 mod_timer(&tbl->proxy_timer, sched_next); 1263 spin_unlock(&tbl->proxy_queue.lock); 1264 } 1265 1266 1267 struct neigh_parms *neigh_parms_alloc(struct net_device *dev, 1268 struct neigh_table *tbl) 1269 { 1270 struct neigh_parms *p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL); 1271 1272 if (p) { 1273 p->tbl = tbl; 1274 atomic_set(&p->refcnt, 1); 1275 INIT_RCU_HEAD(&p->rcu_head); 1276 p->reachable_time = 1277 neigh_rand_reach_time(p->base_reachable_time); 1278 if (dev) { 1279 if (dev->neigh_setup && dev->neigh_setup(dev, p)) { 1280 kfree(p); 1281 return NULL; 1282 } 1283 1284 dev_hold(dev); 1285 p->dev = dev; 1286 } 1287 p->sysctl_table = NULL; 1288 write_lock_bh(&tbl->lock); 1289 p->next = tbl->parms.next; 1290 tbl->parms.next = p; 1291 write_unlock_bh(&tbl->lock); 1292 } 1293 return p; 1294 } 1295 1296 static void neigh_rcu_free_parms(struct rcu_head *head) 1297 { 1298 struct neigh_parms *parms = 1299 container_of(head, struct neigh_parms, rcu_head); 1300 1301 neigh_parms_put(parms); 1302 } 1303 1304 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms) 1305 { 1306 struct neigh_parms **p; 1307 1308 if (!parms || parms == &tbl->parms) 1309 return; 1310 write_lock_bh(&tbl->lock); 1311 for (p = &tbl->parms.next; *p; p = &(*p)->next) { 1312 if (*p == parms) { 1313 *p = parms->next; 1314 parms->dead = 1; 1315 write_unlock_bh(&tbl->lock); 1316 if (parms->dev) 1317 dev_put(parms->dev); 1318 call_rcu(&parms->rcu_head, neigh_rcu_free_parms); 1319 return; 1320 } 1321 } 1322 write_unlock_bh(&tbl->lock); 1323 NEIGH_PRINTK1("neigh_parms_release: not found\n"); 1324 } 1325 1326 void neigh_parms_destroy(struct neigh_parms *parms) 1327 { 1328 kfree(parms); 1329 } 1330 1331 void neigh_table_init_no_netlink(struct neigh_table *tbl) 1332 { 1333 unsigned long now = jiffies; 1334 unsigned long phsize; 1335 1336 atomic_set(&tbl->parms.refcnt, 1); 1337 INIT_RCU_HEAD(&tbl->parms.rcu_head); 1338 tbl->parms.reachable_time = 1339 neigh_rand_reach_time(tbl->parms.base_reachable_time); 1340 1341 if (!tbl->kmem_cachep) 1342 tbl->kmem_cachep = 1343 kmem_cache_create(tbl->id, tbl->entry_size, 0, 1344 SLAB_HWCACHE_ALIGN|SLAB_PANIC, 1345 NULL, NULL); 1346 tbl->stats = alloc_percpu(struct neigh_statistics); 1347 if (!tbl->stats) 1348 panic("cannot create neighbour cache statistics"); 1349 1350 #ifdef CONFIG_PROC_FS 1351 tbl->pde = create_proc_entry(tbl->id, 0, proc_net_stat); 1352 if (!tbl->pde) 1353 panic("cannot create neighbour proc dir entry"); 1354 tbl->pde->proc_fops = &neigh_stat_seq_fops; 1355 tbl->pde->data = tbl; 1356 #endif 1357 1358 tbl->hash_mask = 1; 1359 tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1); 1360 1361 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *); 1362 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL); 1363 1364 if (!tbl->hash_buckets || !tbl->phash_buckets) 1365 panic("cannot allocate neighbour cache hashes"); 1366 1367 get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd)); 1368 1369 rwlock_init(&tbl->lock); 1370 init_timer(&tbl->gc_timer); 1371 tbl->gc_timer.data = (unsigned long)tbl; 1372 tbl->gc_timer.function = neigh_periodic_timer; 1373 tbl->gc_timer.expires = now + 1; 1374 add_timer(&tbl->gc_timer); 1375 1376 init_timer(&tbl->proxy_timer); 1377 tbl->proxy_timer.data = (unsigned long)tbl; 1378 tbl->proxy_timer.function = neigh_proxy_process; 1379 skb_queue_head_init(&tbl->proxy_queue); 1380 1381 tbl->last_flush = now; 1382 tbl->last_rand = now + tbl->parms.reachable_time * 20; 1383 } 1384 1385 void neigh_table_init(struct neigh_table *tbl) 1386 { 1387 struct neigh_table *tmp; 1388 1389 neigh_table_init_no_netlink(tbl); 1390 write_lock(&neigh_tbl_lock); 1391 for (tmp = neigh_tables; tmp; tmp = tmp->next) { 1392 if (tmp->family == tbl->family) 1393 break; 1394 } 1395 tbl->next = neigh_tables; 1396 neigh_tables = tbl; 1397 write_unlock(&neigh_tbl_lock); 1398 1399 if (unlikely(tmp)) { 1400 printk(KERN_ERR "NEIGH: Registering multiple tables for " 1401 "family %d\n", tbl->family); 1402 dump_stack(); 1403 } 1404 } 1405 1406 int neigh_table_clear(struct neigh_table *tbl) 1407 { 1408 struct neigh_table **tp; 1409 1410 /* It is not clean... Fix it to unload IPv6 module safely */ 1411 del_timer_sync(&tbl->gc_timer); 1412 del_timer_sync(&tbl->proxy_timer); 1413 pneigh_queue_purge(&tbl->proxy_queue); 1414 neigh_ifdown(tbl, NULL); 1415 if (atomic_read(&tbl->entries)) 1416 printk(KERN_CRIT "neighbour leakage\n"); 1417 write_lock(&neigh_tbl_lock); 1418 for (tp = &neigh_tables; *tp; tp = &(*tp)->next) { 1419 if (*tp == tbl) { 1420 *tp = tbl->next; 1421 break; 1422 } 1423 } 1424 write_unlock(&neigh_tbl_lock); 1425 1426 neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1); 1427 tbl->hash_buckets = NULL; 1428 1429 kfree(tbl->phash_buckets); 1430 tbl->phash_buckets = NULL; 1431 1432 free_percpu(tbl->stats); 1433 tbl->stats = NULL; 1434 1435 return 0; 1436 } 1437 1438 int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 1439 { 1440 struct ndmsg *ndm; 1441 struct nlattr *dst_attr; 1442 struct neigh_table *tbl; 1443 struct net_device *dev = NULL; 1444 int err = -EINVAL; 1445 1446 if (nlmsg_len(nlh) < sizeof(*ndm)) 1447 goto out; 1448 1449 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST); 1450 if (dst_attr == NULL) 1451 goto out; 1452 1453 ndm = nlmsg_data(nlh); 1454 if (ndm->ndm_ifindex) { 1455 dev = dev_get_by_index(ndm->ndm_ifindex); 1456 if (dev == NULL) { 1457 err = -ENODEV; 1458 goto out; 1459 } 1460 } 1461 1462 read_lock(&neigh_tbl_lock); 1463 for (tbl = neigh_tables; tbl; tbl = tbl->next) { 1464 struct neighbour *neigh; 1465 1466 if (tbl->family != ndm->ndm_family) 1467 continue; 1468 read_unlock(&neigh_tbl_lock); 1469 1470 if (nla_len(dst_attr) < tbl->key_len) 1471 goto out_dev_put; 1472 1473 if (ndm->ndm_flags & NTF_PROXY) { 1474 err = pneigh_delete(tbl, nla_data(dst_attr), dev); 1475 goto out_dev_put; 1476 } 1477 1478 if (dev == NULL) 1479 goto out_dev_put; 1480 1481 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev); 1482 if (neigh == NULL) { 1483 err = -ENOENT; 1484 goto out_dev_put; 1485 } 1486 1487 err = neigh_update(neigh, NULL, NUD_FAILED, 1488 NEIGH_UPDATE_F_OVERRIDE | 1489 NEIGH_UPDATE_F_ADMIN); 1490 neigh_release(neigh); 1491 goto out_dev_put; 1492 } 1493 read_unlock(&neigh_tbl_lock); 1494 err = -EAFNOSUPPORT; 1495 1496 out_dev_put: 1497 if (dev) 1498 dev_put(dev); 1499 out: 1500 return err; 1501 } 1502 1503 int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 1504 { 1505 struct ndmsg *ndm; 1506 struct nlattr *tb[NDA_MAX+1]; 1507 struct neigh_table *tbl; 1508 struct net_device *dev = NULL; 1509 int err; 1510 1511 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL); 1512 if (err < 0) 1513 goto out; 1514 1515 err = -EINVAL; 1516 if (tb[NDA_DST] == NULL) 1517 goto out; 1518 1519 ndm = nlmsg_data(nlh); 1520 if (ndm->ndm_ifindex) { 1521 dev = dev_get_by_index(ndm->ndm_ifindex); 1522 if (dev == NULL) { 1523 err = -ENODEV; 1524 goto out; 1525 } 1526 1527 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len) 1528 goto out_dev_put; 1529 } 1530 1531 read_lock(&neigh_tbl_lock); 1532 for (tbl = neigh_tables; tbl; tbl = tbl->next) { 1533 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE; 1534 struct neighbour *neigh; 1535 void *dst, *lladdr; 1536 1537 if (tbl->family != ndm->ndm_family) 1538 continue; 1539 read_unlock(&neigh_tbl_lock); 1540 1541 if (nla_len(tb[NDA_DST]) < tbl->key_len) 1542 goto out_dev_put; 1543 dst = nla_data(tb[NDA_DST]); 1544 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL; 1545 1546 if (ndm->ndm_flags & NTF_PROXY) { 1547 struct pneigh_entry *pn; 1548 1549 err = -ENOBUFS; 1550 pn = pneigh_lookup(tbl, dst, dev, 1); 1551 if (pn) { 1552 pn->flags = ndm->ndm_flags; 1553 err = 0; 1554 } 1555 goto out_dev_put; 1556 } 1557 1558 if (dev == NULL) 1559 goto out_dev_put; 1560 1561 neigh = neigh_lookup(tbl, dst, dev); 1562 if (neigh == NULL) { 1563 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 1564 err = -ENOENT; 1565 goto out_dev_put; 1566 } 1567 1568 neigh = __neigh_lookup_errno(tbl, dst, dev); 1569 if (IS_ERR(neigh)) { 1570 err = PTR_ERR(neigh); 1571 goto out_dev_put; 1572 } 1573 } else { 1574 if (nlh->nlmsg_flags & NLM_F_EXCL) { 1575 err = -EEXIST; 1576 neigh_release(neigh); 1577 goto out_dev_put; 1578 } 1579 1580 if (!(nlh->nlmsg_flags & NLM_F_REPLACE)) 1581 flags &= ~NEIGH_UPDATE_F_OVERRIDE; 1582 } 1583 1584 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags); 1585 neigh_release(neigh); 1586 goto out_dev_put; 1587 } 1588 1589 read_unlock(&neigh_tbl_lock); 1590 err = -EAFNOSUPPORT; 1591 1592 out_dev_put: 1593 if (dev) 1594 dev_put(dev); 1595 out: 1596 return err; 1597 } 1598 1599 static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms) 1600 { 1601 struct nlattr *nest; 1602 1603 nest = nla_nest_start(skb, NDTA_PARMS); 1604 if (nest == NULL) 1605 return -ENOBUFS; 1606 1607 if (parms->dev) 1608 NLA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex); 1609 1610 NLA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt)); 1611 NLA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len); 1612 NLA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen); 1613 NLA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes); 1614 NLA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes); 1615 NLA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes); 1616 NLA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time); 1617 NLA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME, 1618 parms->base_reachable_time); 1619 NLA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime); 1620 NLA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time); 1621 NLA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time); 1622 NLA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay); 1623 NLA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay); 1624 NLA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime); 1625 1626 return nla_nest_end(skb, nest); 1627 1628 nla_put_failure: 1629 return nla_nest_cancel(skb, nest); 1630 } 1631 1632 static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl, 1633 u32 pid, u32 seq, int type, int flags) 1634 { 1635 struct nlmsghdr *nlh; 1636 struct ndtmsg *ndtmsg; 1637 1638 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 1639 if (nlh == NULL) 1640 return -ENOBUFS; 1641 1642 ndtmsg = nlmsg_data(nlh); 1643 1644 read_lock_bh(&tbl->lock); 1645 ndtmsg->ndtm_family = tbl->family; 1646 ndtmsg->ndtm_pad1 = 0; 1647 ndtmsg->ndtm_pad2 = 0; 1648 1649 NLA_PUT_STRING(skb, NDTA_NAME, tbl->id); 1650 NLA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval); 1651 NLA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1); 1652 NLA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2); 1653 NLA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3); 1654 1655 { 1656 unsigned long now = jiffies; 1657 unsigned int flush_delta = now - tbl->last_flush; 1658 unsigned int rand_delta = now - tbl->last_rand; 1659 1660 struct ndt_config ndc = { 1661 .ndtc_key_len = tbl->key_len, 1662 .ndtc_entry_size = tbl->entry_size, 1663 .ndtc_entries = atomic_read(&tbl->entries), 1664 .ndtc_last_flush = jiffies_to_msecs(flush_delta), 1665 .ndtc_last_rand = jiffies_to_msecs(rand_delta), 1666 .ndtc_hash_rnd = tbl->hash_rnd, 1667 .ndtc_hash_mask = tbl->hash_mask, 1668 .ndtc_hash_chain_gc = tbl->hash_chain_gc, 1669 .ndtc_proxy_qlen = tbl->proxy_queue.qlen, 1670 }; 1671 1672 NLA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc); 1673 } 1674 1675 { 1676 int cpu; 1677 struct ndt_stats ndst; 1678 1679 memset(&ndst, 0, sizeof(ndst)); 1680 1681 for_each_possible_cpu(cpu) { 1682 struct neigh_statistics *st; 1683 1684 st = per_cpu_ptr(tbl->stats, cpu); 1685 ndst.ndts_allocs += st->allocs; 1686 ndst.ndts_destroys += st->destroys; 1687 ndst.ndts_hash_grows += st->hash_grows; 1688 ndst.ndts_res_failed += st->res_failed; 1689 ndst.ndts_lookups += st->lookups; 1690 ndst.ndts_hits += st->hits; 1691 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast; 1692 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast; 1693 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs; 1694 ndst.ndts_forced_gc_runs += st->forced_gc_runs; 1695 } 1696 1697 NLA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst); 1698 } 1699 1700 BUG_ON(tbl->parms.dev); 1701 if (neightbl_fill_parms(skb, &tbl->parms) < 0) 1702 goto nla_put_failure; 1703 1704 read_unlock_bh(&tbl->lock); 1705 return nlmsg_end(skb, nlh); 1706 1707 nla_put_failure: 1708 read_unlock_bh(&tbl->lock); 1709 return nlmsg_cancel(skb, nlh); 1710 } 1711 1712 static int neightbl_fill_param_info(struct sk_buff *skb, 1713 struct neigh_table *tbl, 1714 struct neigh_parms *parms, 1715 u32 pid, u32 seq, int type, 1716 unsigned int flags) 1717 { 1718 struct ndtmsg *ndtmsg; 1719 struct nlmsghdr *nlh; 1720 1721 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 1722 if (nlh == NULL) 1723 return -ENOBUFS; 1724 1725 ndtmsg = nlmsg_data(nlh); 1726 1727 read_lock_bh(&tbl->lock); 1728 ndtmsg->ndtm_family = tbl->family; 1729 ndtmsg->ndtm_pad1 = 0; 1730 ndtmsg->ndtm_pad2 = 0; 1731 1732 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 || 1733 neightbl_fill_parms(skb, parms) < 0) 1734 goto errout; 1735 1736 read_unlock_bh(&tbl->lock); 1737 return nlmsg_end(skb, nlh); 1738 errout: 1739 read_unlock_bh(&tbl->lock); 1740 return nlmsg_cancel(skb, nlh); 1741 } 1742 1743 static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl, 1744 int ifindex) 1745 { 1746 struct neigh_parms *p; 1747 1748 for (p = &tbl->parms; p; p = p->next) 1749 if ((p->dev && p->dev->ifindex == ifindex) || 1750 (!p->dev && !ifindex)) 1751 return p; 1752 1753 return NULL; 1754 } 1755 1756 static struct nla_policy nl_neightbl_policy[NDTA_MAX+1] __read_mostly = { 1757 [NDTA_NAME] = { .type = NLA_STRING }, 1758 [NDTA_THRESH1] = { .type = NLA_U32 }, 1759 [NDTA_THRESH2] = { .type = NLA_U32 }, 1760 [NDTA_THRESH3] = { .type = NLA_U32 }, 1761 [NDTA_GC_INTERVAL] = { .type = NLA_U64 }, 1762 [NDTA_PARMS] = { .type = NLA_NESTED }, 1763 }; 1764 1765 static struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] __read_mostly = { 1766 [NDTPA_IFINDEX] = { .type = NLA_U32 }, 1767 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 }, 1768 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 }, 1769 [NDTPA_APP_PROBES] = { .type = NLA_U32 }, 1770 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 }, 1771 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 }, 1772 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 }, 1773 [NDTPA_GC_STALETIME] = { .type = NLA_U64 }, 1774 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 }, 1775 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 }, 1776 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 }, 1777 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 }, 1778 [NDTPA_LOCKTIME] = { .type = NLA_U64 }, 1779 }; 1780 1781 int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 1782 { 1783 struct neigh_table *tbl; 1784 struct ndtmsg *ndtmsg; 1785 struct nlattr *tb[NDTA_MAX+1]; 1786 int err; 1787 1788 err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX, 1789 nl_neightbl_policy); 1790 if (err < 0) 1791 goto errout; 1792 1793 if (tb[NDTA_NAME] == NULL) { 1794 err = -EINVAL; 1795 goto errout; 1796 } 1797 1798 ndtmsg = nlmsg_data(nlh); 1799 read_lock(&neigh_tbl_lock); 1800 for (tbl = neigh_tables; tbl; tbl = tbl->next) { 1801 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family) 1802 continue; 1803 1804 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) 1805 break; 1806 } 1807 1808 if (tbl == NULL) { 1809 err = -ENOENT; 1810 goto errout_locked; 1811 } 1812 1813 /* 1814 * We acquire tbl->lock to be nice to the periodic timers and 1815 * make sure they always see a consistent set of values. 1816 */ 1817 write_lock_bh(&tbl->lock); 1818 1819 if (tb[NDTA_PARMS]) { 1820 struct nlattr *tbp[NDTPA_MAX+1]; 1821 struct neigh_parms *p; 1822 int i, ifindex = 0; 1823 1824 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS], 1825 nl_ntbl_parm_policy); 1826 if (err < 0) 1827 goto errout_tbl_lock; 1828 1829 if (tbp[NDTPA_IFINDEX]) 1830 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]); 1831 1832 p = lookup_neigh_params(tbl, ifindex); 1833 if (p == NULL) { 1834 err = -ENOENT; 1835 goto errout_tbl_lock; 1836 } 1837 1838 for (i = 1; i <= NDTPA_MAX; i++) { 1839 if (tbp[i] == NULL) 1840 continue; 1841 1842 switch (i) { 1843 case NDTPA_QUEUE_LEN: 1844 p->queue_len = nla_get_u32(tbp[i]); 1845 break; 1846 case NDTPA_PROXY_QLEN: 1847 p->proxy_qlen = nla_get_u32(tbp[i]); 1848 break; 1849 case NDTPA_APP_PROBES: 1850 p->app_probes = nla_get_u32(tbp[i]); 1851 break; 1852 case NDTPA_UCAST_PROBES: 1853 p->ucast_probes = nla_get_u32(tbp[i]); 1854 break; 1855 case NDTPA_MCAST_PROBES: 1856 p->mcast_probes = nla_get_u32(tbp[i]); 1857 break; 1858 case NDTPA_BASE_REACHABLE_TIME: 1859 p->base_reachable_time = nla_get_msecs(tbp[i]); 1860 break; 1861 case NDTPA_GC_STALETIME: 1862 p->gc_staletime = nla_get_msecs(tbp[i]); 1863 break; 1864 case NDTPA_DELAY_PROBE_TIME: 1865 p->delay_probe_time = nla_get_msecs(tbp[i]); 1866 break; 1867 case NDTPA_RETRANS_TIME: 1868 p->retrans_time = nla_get_msecs(tbp[i]); 1869 break; 1870 case NDTPA_ANYCAST_DELAY: 1871 p->anycast_delay = nla_get_msecs(tbp[i]); 1872 break; 1873 case NDTPA_PROXY_DELAY: 1874 p->proxy_delay = nla_get_msecs(tbp[i]); 1875 break; 1876 case NDTPA_LOCKTIME: 1877 p->locktime = nla_get_msecs(tbp[i]); 1878 break; 1879 } 1880 } 1881 } 1882 1883 if (tb[NDTA_THRESH1]) 1884 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]); 1885 1886 if (tb[NDTA_THRESH2]) 1887 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]); 1888 1889 if (tb[NDTA_THRESH3]) 1890 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]); 1891 1892 if (tb[NDTA_GC_INTERVAL]) 1893 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]); 1894 1895 err = 0; 1896 1897 errout_tbl_lock: 1898 write_unlock_bh(&tbl->lock); 1899 errout_locked: 1900 read_unlock(&neigh_tbl_lock); 1901 errout: 1902 return err; 1903 } 1904 1905 int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 1906 { 1907 int family, tidx, nidx = 0; 1908 int tbl_skip = cb->args[0]; 1909 int neigh_skip = cb->args[1]; 1910 struct neigh_table *tbl; 1911 1912 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family; 1913 1914 read_lock(&neigh_tbl_lock); 1915 for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) { 1916 struct neigh_parms *p; 1917 1918 if (tidx < tbl_skip || (family && tbl->family != family)) 1919 continue; 1920 1921 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).pid, 1922 cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL, 1923 NLM_F_MULTI) <= 0) 1924 break; 1925 1926 for (nidx = 0, p = tbl->parms.next; p; p = p->next, nidx++) { 1927 if (nidx < neigh_skip) 1928 continue; 1929 1930 if (neightbl_fill_param_info(skb, tbl, p, 1931 NETLINK_CB(cb->skb).pid, 1932 cb->nlh->nlmsg_seq, 1933 RTM_NEWNEIGHTBL, 1934 NLM_F_MULTI) <= 0) 1935 goto out; 1936 } 1937 1938 neigh_skip = 0; 1939 } 1940 out: 1941 read_unlock(&neigh_tbl_lock); 1942 cb->args[0] = tidx; 1943 cb->args[1] = nidx; 1944 1945 return skb->len; 1946 } 1947 1948 static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh, 1949 u32 pid, u32 seq, int type, unsigned int flags) 1950 { 1951 unsigned long now = jiffies; 1952 struct nda_cacheinfo ci; 1953 struct nlmsghdr *nlh; 1954 struct ndmsg *ndm; 1955 1956 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags); 1957 if (nlh == NULL) 1958 return -ENOBUFS; 1959 1960 ndm = nlmsg_data(nlh); 1961 ndm->ndm_family = neigh->ops->family; 1962 ndm->ndm_pad1 = 0; 1963 ndm->ndm_pad2 = 0; 1964 ndm->ndm_flags = neigh->flags; 1965 ndm->ndm_type = neigh->type; 1966 ndm->ndm_ifindex = neigh->dev->ifindex; 1967 1968 NLA_PUT(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key); 1969 1970 read_lock_bh(&neigh->lock); 1971 ndm->ndm_state = neigh->nud_state; 1972 if ((neigh->nud_state & NUD_VALID) && 1973 nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, neigh->ha) < 0) { 1974 read_unlock_bh(&neigh->lock); 1975 goto nla_put_failure; 1976 } 1977 1978 ci.ndm_used = now - neigh->used; 1979 ci.ndm_confirmed = now - neigh->confirmed; 1980 ci.ndm_updated = now - neigh->updated; 1981 ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1; 1982 read_unlock_bh(&neigh->lock); 1983 1984 NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes)); 1985 NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci); 1986 1987 return nlmsg_end(skb, nlh); 1988 1989 nla_put_failure: 1990 return nlmsg_cancel(skb, nlh); 1991 } 1992 1993 1994 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 1995 struct netlink_callback *cb) 1996 { 1997 struct neighbour *n; 1998 int rc, h, s_h = cb->args[1]; 1999 int idx, s_idx = idx = cb->args[2]; 2000 2001 read_lock_bh(&tbl->lock); 2002 for (h = 0; h <= tbl->hash_mask; h++) { 2003 if (h < s_h) 2004 continue; 2005 if (h > s_h) 2006 s_idx = 0; 2007 for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next, idx++) { 2008 if (idx < s_idx) 2009 continue; 2010 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid, 2011 cb->nlh->nlmsg_seq, 2012 RTM_NEWNEIGH, 2013 NLM_F_MULTI) <= 0) { 2014 read_unlock_bh(&tbl->lock); 2015 rc = -1; 2016 goto out; 2017 } 2018 } 2019 } 2020 read_unlock_bh(&tbl->lock); 2021 rc = skb->len; 2022 out: 2023 cb->args[1] = h; 2024 cb->args[2] = idx; 2025 return rc; 2026 } 2027 2028 int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 2029 { 2030 struct neigh_table *tbl; 2031 int t, family, s_t; 2032 2033 read_lock(&neigh_tbl_lock); 2034 family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family; 2035 s_t = cb->args[0]; 2036 2037 for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) { 2038 if (t < s_t || (family && tbl->family != family)) 2039 continue; 2040 if (t > s_t) 2041 memset(&cb->args[1], 0, sizeof(cb->args) - 2042 sizeof(cb->args[0])); 2043 if (neigh_dump_table(tbl, skb, cb) < 0) 2044 break; 2045 } 2046 read_unlock(&neigh_tbl_lock); 2047 2048 cb->args[0] = t; 2049 return skb->len; 2050 } 2051 2052 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie) 2053 { 2054 int chain; 2055 2056 read_lock_bh(&tbl->lock); 2057 for (chain = 0; chain <= tbl->hash_mask; chain++) { 2058 struct neighbour *n; 2059 2060 for (n = tbl->hash_buckets[chain]; n; n = n->next) 2061 cb(n, cookie); 2062 } 2063 read_unlock_bh(&tbl->lock); 2064 } 2065 EXPORT_SYMBOL(neigh_for_each); 2066 2067 /* The tbl->lock must be held as a writer and BH disabled. */ 2068 void __neigh_for_each_release(struct neigh_table *tbl, 2069 int (*cb)(struct neighbour *)) 2070 { 2071 int chain; 2072 2073 for (chain = 0; chain <= tbl->hash_mask; chain++) { 2074 struct neighbour *n, **np; 2075 2076 np = &tbl->hash_buckets[chain]; 2077 while ((n = *np) != NULL) { 2078 int release; 2079 2080 write_lock(&n->lock); 2081 release = cb(n); 2082 if (release) { 2083 *np = n->next; 2084 n->dead = 1; 2085 } else 2086 np = &n->next; 2087 write_unlock(&n->lock); 2088 if (release) 2089 neigh_release(n); 2090 } 2091 } 2092 } 2093 EXPORT_SYMBOL(__neigh_for_each_release); 2094 2095 #ifdef CONFIG_PROC_FS 2096 2097 static struct neighbour *neigh_get_first(struct seq_file *seq) 2098 { 2099 struct neigh_seq_state *state = seq->private; 2100 struct neigh_table *tbl = state->tbl; 2101 struct neighbour *n = NULL; 2102 int bucket = state->bucket; 2103 2104 state->flags &= ~NEIGH_SEQ_IS_PNEIGH; 2105 for (bucket = 0; bucket <= tbl->hash_mask; bucket++) { 2106 n = tbl->hash_buckets[bucket]; 2107 2108 while (n) { 2109 if (state->neigh_sub_iter) { 2110 loff_t fakep = 0; 2111 void *v; 2112 2113 v = state->neigh_sub_iter(state, n, &fakep); 2114 if (!v) 2115 goto next; 2116 } 2117 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 2118 break; 2119 if (n->nud_state & ~NUD_NOARP) 2120 break; 2121 next: 2122 n = n->next; 2123 } 2124 2125 if (n) 2126 break; 2127 } 2128 state->bucket = bucket; 2129 2130 return n; 2131 } 2132 2133 static struct neighbour *neigh_get_next(struct seq_file *seq, 2134 struct neighbour *n, 2135 loff_t *pos) 2136 { 2137 struct neigh_seq_state *state = seq->private; 2138 struct neigh_table *tbl = state->tbl; 2139 2140 if (state->neigh_sub_iter) { 2141 void *v = state->neigh_sub_iter(state, n, pos); 2142 if (v) 2143 return n; 2144 } 2145 n = n->next; 2146 2147 while (1) { 2148 while (n) { 2149 if (state->neigh_sub_iter) { 2150 void *v = state->neigh_sub_iter(state, n, pos); 2151 if (v) 2152 return n; 2153 goto next; 2154 } 2155 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 2156 break; 2157 2158 if (n->nud_state & ~NUD_NOARP) 2159 break; 2160 next: 2161 n = n->next; 2162 } 2163 2164 if (n) 2165 break; 2166 2167 if (++state->bucket > tbl->hash_mask) 2168 break; 2169 2170 n = tbl->hash_buckets[state->bucket]; 2171 } 2172 2173 if (n && pos) 2174 --(*pos); 2175 return n; 2176 } 2177 2178 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos) 2179 { 2180 struct neighbour *n = neigh_get_first(seq); 2181 2182 if (n) { 2183 while (*pos) { 2184 n = neigh_get_next(seq, n, pos); 2185 if (!n) 2186 break; 2187 } 2188 } 2189 return *pos ? NULL : n; 2190 } 2191 2192 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq) 2193 { 2194 struct neigh_seq_state *state = seq->private; 2195 struct neigh_table *tbl = state->tbl; 2196 struct pneigh_entry *pn = NULL; 2197 int bucket = state->bucket; 2198 2199 state->flags |= NEIGH_SEQ_IS_PNEIGH; 2200 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) { 2201 pn = tbl->phash_buckets[bucket]; 2202 if (pn) 2203 break; 2204 } 2205 state->bucket = bucket; 2206 2207 return pn; 2208 } 2209 2210 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq, 2211 struct pneigh_entry *pn, 2212 loff_t *pos) 2213 { 2214 struct neigh_seq_state *state = seq->private; 2215 struct neigh_table *tbl = state->tbl; 2216 2217 pn = pn->next; 2218 while (!pn) { 2219 if (++state->bucket > PNEIGH_HASHMASK) 2220 break; 2221 pn = tbl->phash_buckets[state->bucket]; 2222 if (pn) 2223 break; 2224 } 2225 2226 if (pn && pos) 2227 --(*pos); 2228 2229 return pn; 2230 } 2231 2232 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos) 2233 { 2234 struct pneigh_entry *pn = pneigh_get_first(seq); 2235 2236 if (pn) { 2237 while (*pos) { 2238 pn = pneigh_get_next(seq, pn, pos); 2239 if (!pn) 2240 break; 2241 } 2242 } 2243 return *pos ? NULL : pn; 2244 } 2245 2246 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos) 2247 { 2248 struct neigh_seq_state *state = seq->private; 2249 void *rc; 2250 2251 rc = neigh_get_idx(seq, pos); 2252 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 2253 rc = pneigh_get_idx(seq, pos); 2254 2255 return rc; 2256 } 2257 2258 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags) 2259 { 2260 struct neigh_seq_state *state = seq->private; 2261 loff_t pos_minus_one; 2262 2263 state->tbl = tbl; 2264 state->bucket = 0; 2265 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH); 2266 2267 read_lock_bh(&tbl->lock); 2268 2269 pos_minus_one = *pos - 1; 2270 return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN; 2271 } 2272 EXPORT_SYMBOL(neigh_seq_start); 2273 2274 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2275 { 2276 struct neigh_seq_state *state; 2277 void *rc; 2278 2279 if (v == SEQ_START_TOKEN) { 2280 rc = neigh_get_idx(seq, pos); 2281 goto out; 2282 } 2283 2284 state = seq->private; 2285 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) { 2286 rc = neigh_get_next(seq, v, NULL); 2287 if (rc) 2288 goto out; 2289 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 2290 rc = pneigh_get_first(seq); 2291 } else { 2292 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY); 2293 rc = pneigh_get_next(seq, v, NULL); 2294 } 2295 out: 2296 ++(*pos); 2297 return rc; 2298 } 2299 EXPORT_SYMBOL(neigh_seq_next); 2300 2301 void neigh_seq_stop(struct seq_file *seq, void *v) 2302 { 2303 struct neigh_seq_state *state = seq->private; 2304 struct neigh_table *tbl = state->tbl; 2305 2306 read_unlock_bh(&tbl->lock); 2307 } 2308 EXPORT_SYMBOL(neigh_seq_stop); 2309 2310 /* statistics via seq_file */ 2311 2312 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos) 2313 { 2314 struct proc_dir_entry *pde = seq->private; 2315 struct neigh_table *tbl = pde->data; 2316 int cpu; 2317 2318 if (*pos == 0) 2319 return SEQ_START_TOKEN; 2320 2321 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) { 2322 if (!cpu_possible(cpu)) 2323 continue; 2324 *pos = cpu+1; 2325 return per_cpu_ptr(tbl->stats, cpu); 2326 } 2327 return NULL; 2328 } 2329 2330 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2331 { 2332 struct proc_dir_entry *pde = seq->private; 2333 struct neigh_table *tbl = pde->data; 2334 int cpu; 2335 2336 for (cpu = *pos; cpu < NR_CPUS; ++cpu) { 2337 if (!cpu_possible(cpu)) 2338 continue; 2339 *pos = cpu+1; 2340 return per_cpu_ptr(tbl->stats, cpu); 2341 } 2342 return NULL; 2343 } 2344 2345 static void neigh_stat_seq_stop(struct seq_file *seq, void *v) 2346 { 2347 2348 } 2349 2350 static int neigh_stat_seq_show(struct seq_file *seq, void *v) 2351 { 2352 struct proc_dir_entry *pde = seq->private; 2353 struct neigh_table *tbl = pde->data; 2354 struct neigh_statistics *st = v; 2355 2356 if (v == SEQ_START_TOKEN) { 2357 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"); 2358 return 0; 2359 } 2360 2361 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx " 2362 "%08lx %08lx %08lx %08lx\n", 2363 atomic_read(&tbl->entries), 2364 2365 st->allocs, 2366 st->destroys, 2367 st->hash_grows, 2368 2369 st->lookups, 2370 st->hits, 2371 2372 st->res_failed, 2373 2374 st->rcv_probes_mcast, 2375 st->rcv_probes_ucast, 2376 2377 st->periodic_gc_runs, 2378 st->forced_gc_runs 2379 ); 2380 2381 return 0; 2382 } 2383 2384 static struct seq_operations neigh_stat_seq_ops = { 2385 .start = neigh_stat_seq_start, 2386 .next = neigh_stat_seq_next, 2387 .stop = neigh_stat_seq_stop, 2388 .show = neigh_stat_seq_show, 2389 }; 2390 2391 static int neigh_stat_seq_open(struct inode *inode, struct file *file) 2392 { 2393 int ret = seq_open(file, &neigh_stat_seq_ops); 2394 2395 if (!ret) { 2396 struct seq_file *sf = file->private_data; 2397 sf->private = PDE(inode); 2398 } 2399 return ret; 2400 }; 2401 2402 static struct file_operations neigh_stat_seq_fops = { 2403 .owner = THIS_MODULE, 2404 .open = neigh_stat_seq_open, 2405 .read = seq_read, 2406 .llseek = seq_lseek, 2407 .release = seq_release, 2408 }; 2409 2410 #endif /* CONFIG_PROC_FS */ 2411 2412 #ifdef CONFIG_ARPD 2413 static inline size_t neigh_nlmsg_size(void) 2414 { 2415 return NLMSG_ALIGN(sizeof(struct ndmsg)) 2416 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */ 2417 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */ 2418 + nla_total_size(sizeof(struct nda_cacheinfo)) 2419 + nla_total_size(4); /* NDA_PROBES */ 2420 } 2421 2422 static void __neigh_notify(struct neighbour *n, int type, int flags) 2423 { 2424 struct sk_buff *skb; 2425 int err = -ENOBUFS; 2426 2427 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC); 2428 if (skb == NULL) 2429 goto errout; 2430 2431 err = neigh_fill_info(skb, n, 0, 0, type, flags); 2432 /* failure implies BUG in neigh_nlmsg_size() */ 2433 BUG_ON(err < 0); 2434 2435 err = rtnl_notify(skb, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 2436 errout: 2437 if (err < 0) 2438 rtnl_set_sk_err(RTNLGRP_NEIGH, err); 2439 } 2440 2441 void neigh_app_ns(struct neighbour *n) 2442 { 2443 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST); 2444 } 2445 2446 static void neigh_app_notify(struct neighbour *n) 2447 { 2448 __neigh_notify(n, RTM_NEWNEIGH, 0); 2449 } 2450 2451 #endif /* CONFIG_ARPD */ 2452 2453 #ifdef CONFIG_SYSCTL 2454 2455 static struct neigh_sysctl_table { 2456 struct ctl_table_header *sysctl_header; 2457 ctl_table neigh_vars[__NET_NEIGH_MAX]; 2458 ctl_table neigh_dev[2]; 2459 ctl_table neigh_neigh_dir[2]; 2460 ctl_table neigh_proto_dir[2]; 2461 ctl_table neigh_root_dir[2]; 2462 } neigh_sysctl_template __read_mostly = { 2463 .neigh_vars = { 2464 { 2465 .ctl_name = NET_NEIGH_MCAST_SOLICIT, 2466 .procname = "mcast_solicit", 2467 .maxlen = sizeof(int), 2468 .mode = 0644, 2469 .proc_handler = &proc_dointvec, 2470 }, 2471 { 2472 .ctl_name = NET_NEIGH_UCAST_SOLICIT, 2473 .procname = "ucast_solicit", 2474 .maxlen = sizeof(int), 2475 .mode = 0644, 2476 .proc_handler = &proc_dointvec, 2477 }, 2478 { 2479 .ctl_name = NET_NEIGH_APP_SOLICIT, 2480 .procname = "app_solicit", 2481 .maxlen = sizeof(int), 2482 .mode = 0644, 2483 .proc_handler = &proc_dointvec, 2484 }, 2485 { 2486 .ctl_name = NET_NEIGH_RETRANS_TIME, 2487 .procname = "retrans_time", 2488 .maxlen = sizeof(int), 2489 .mode = 0644, 2490 .proc_handler = &proc_dointvec_userhz_jiffies, 2491 }, 2492 { 2493 .ctl_name = NET_NEIGH_REACHABLE_TIME, 2494 .procname = "base_reachable_time", 2495 .maxlen = sizeof(int), 2496 .mode = 0644, 2497 .proc_handler = &proc_dointvec_jiffies, 2498 .strategy = &sysctl_jiffies, 2499 }, 2500 { 2501 .ctl_name = NET_NEIGH_DELAY_PROBE_TIME, 2502 .procname = "delay_first_probe_time", 2503 .maxlen = sizeof(int), 2504 .mode = 0644, 2505 .proc_handler = &proc_dointvec_jiffies, 2506 .strategy = &sysctl_jiffies, 2507 }, 2508 { 2509 .ctl_name = NET_NEIGH_GC_STALE_TIME, 2510 .procname = "gc_stale_time", 2511 .maxlen = sizeof(int), 2512 .mode = 0644, 2513 .proc_handler = &proc_dointvec_jiffies, 2514 .strategy = &sysctl_jiffies, 2515 }, 2516 { 2517 .ctl_name = NET_NEIGH_UNRES_QLEN, 2518 .procname = "unres_qlen", 2519 .maxlen = sizeof(int), 2520 .mode = 0644, 2521 .proc_handler = &proc_dointvec, 2522 }, 2523 { 2524 .ctl_name = NET_NEIGH_PROXY_QLEN, 2525 .procname = "proxy_qlen", 2526 .maxlen = sizeof(int), 2527 .mode = 0644, 2528 .proc_handler = &proc_dointvec, 2529 }, 2530 { 2531 .ctl_name = NET_NEIGH_ANYCAST_DELAY, 2532 .procname = "anycast_delay", 2533 .maxlen = sizeof(int), 2534 .mode = 0644, 2535 .proc_handler = &proc_dointvec_userhz_jiffies, 2536 }, 2537 { 2538 .ctl_name = NET_NEIGH_PROXY_DELAY, 2539 .procname = "proxy_delay", 2540 .maxlen = sizeof(int), 2541 .mode = 0644, 2542 .proc_handler = &proc_dointvec_userhz_jiffies, 2543 }, 2544 { 2545 .ctl_name = NET_NEIGH_LOCKTIME, 2546 .procname = "locktime", 2547 .maxlen = sizeof(int), 2548 .mode = 0644, 2549 .proc_handler = &proc_dointvec_userhz_jiffies, 2550 }, 2551 { 2552 .ctl_name = NET_NEIGH_GC_INTERVAL, 2553 .procname = "gc_interval", 2554 .maxlen = sizeof(int), 2555 .mode = 0644, 2556 .proc_handler = &proc_dointvec_jiffies, 2557 .strategy = &sysctl_jiffies, 2558 }, 2559 { 2560 .ctl_name = NET_NEIGH_GC_THRESH1, 2561 .procname = "gc_thresh1", 2562 .maxlen = sizeof(int), 2563 .mode = 0644, 2564 .proc_handler = &proc_dointvec, 2565 }, 2566 { 2567 .ctl_name = NET_NEIGH_GC_THRESH2, 2568 .procname = "gc_thresh2", 2569 .maxlen = sizeof(int), 2570 .mode = 0644, 2571 .proc_handler = &proc_dointvec, 2572 }, 2573 { 2574 .ctl_name = NET_NEIGH_GC_THRESH3, 2575 .procname = "gc_thresh3", 2576 .maxlen = sizeof(int), 2577 .mode = 0644, 2578 .proc_handler = &proc_dointvec, 2579 }, 2580 { 2581 .ctl_name = NET_NEIGH_RETRANS_TIME_MS, 2582 .procname = "retrans_time_ms", 2583 .maxlen = sizeof(int), 2584 .mode = 0644, 2585 .proc_handler = &proc_dointvec_ms_jiffies, 2586 .strategy = &sysctl_ms_jiffies, 2587 }, 2588 { 2589 .ctl_name = NET_NEIGH_REACHABLE_TIME_MS, 2590 .procname = "base_reachable_time_ms", 2591 .maxlen = sizeof(int), 2592 .mode = 0644, 2593 .proc_handler = &proc_dointvec_ms_jiffies, 2594 .strategy = &sysctl_ms_jiffies, 2595 }, 2596 }, 2597 .neigh_dev = { 2598 { 2599 .ctl_name = NET_PROTO_CONF_DEFAULT, 2600 .procname = "default", 2601 .mode = 0555, 2602 }, 2603 }, 2604 .neigh_neigh_dir = { 2605 { 2606 .procname = "neigh", 2607 .mode = 0555, 2608 }, 2609 }, 2610 .neigh_proto_dir = { 2611 { 2612 .mode = 0555, 2613 }, 2614 }, 2615 .neigh_root_dir = { 2616 { 2617 .ctl_name = CTL_NET, 2618 .procname = "net", 2619 .mode = 0555, 2620 }, 2621 }, 2622 }; 2623 2624 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, 2625 int p_id, int pdev_id, char *p_name, 2626 proc_handler *handler, ctl_handler *strategy) 2627 { 2628 struct neigh_sysctl_table *t = kmemdup(&neigh_sysctl_template, 2629 sizeof(*t), GFP_KERNEL); 2630 const char *dev_name_source = NULL; 2631 char *dev_name = NULL; 2632 int err = 0; 2633 2634 if (!t) 2635 return -ENOBUFS; 2636 t->neigh_vars[0].data = &p->mcast_probes; 2637 t->neigh_vars[1].data = &p->ucast_probes; 2638 t->neigh_vars[2].data = &p->app_probes; 2639 t->neigh_vars[3].data = &p->retrans_time; 2640 t->neigh_vars[4].data = &p->base_reachable_time; 2641 t->neigh_vars[5].data = &p->delay_probe_time; 2642 t->neigh_vars[6].data = &p->gc_staletime; 2643 t->neigh_vars[7].data = &p->queue_len; 2644 t->neigh_vars[8].data = &p->proxy_qlen; 2645 t->neigh_vars[9].data = &p->anycast_delay; 2646 t->neigh_vars[10].data = &p->proxy_delay; 2647 t->neigh_vars[11].data = &p->locktime; 2648 2649 if (dev) { 2650 dev_name_source = dev->name; 2651 t->neigh_dev[0].ctl_name = dev->ifindex; 2652 t->neigh_vars[12].procname = NULL; 2653 t->neigh_vars[13].procname = NULL; 2654 t->neigh_vars[14].procname = NULL; 2655 t->neigh_vars[15].procname = NULL; 2656 } else { 2657 dev_name_source = t->neigh_dev[0].procname; 2658 t->neigh_vars[12].data = (int *)(p + 1); 2659 t->neigh_vars[13].data = (int *)(p + 1) + 1; 2660 t->neigh_vars[14].data = (int *)(p + 1) + 2; 2661 t->neigh_vars[15].data = (int *)(p + 1) + 3; 2662 } 2663 2664 t->neigh_vars[16].data = &p->retrans_time; 2665 t->neigh_vars[17].data = &p->base_reachable_time; 2666 2667 if (handler || strategy) { 2668 /* RetransTime */ 2669 t->neigh_vars[3].proc_handler = handler; 2670 t->neigh_vars[3].strategy = strategy; 2671 t->neigh_vars[3].extra1 = dev; 2672 /* ReachableTime */ 2673 t->neigh_vars[4].proc_handler = handler; 2674 t->neigh_vars[4].strategy = strategy; 2675 t->neigh_vars[4].extra1 = dev; 2676 /* RetransTime (in milliseconds)*/ 2677 t->neigh_vars[16].proc_handler = handler; 2678 t->neigh_vars[16].strategy = strategy; 2679 t->neigh_vars[16].extra1 = dev; 2680 /* ReachableTime (in milliseconds) */ 2681 t->neigh_vars[17].proc_handler = handler; 2682 t->neigh_vars[17].strategy = strategy; 2683 t->neigh_vars[17].extra1 = dev; 2684 } 2685 2686 dev_name = kstrdup(dev_name_source, GFP_KERNEL); 2687 if (!dev_name) { 2688 err = -ENOBUFS; 2689 goto free; 2690 } 2691 2692 t->neigh_dev[0].procname = dev_name; 2693 2694 t->neigh_neigh_dir[0].ctl_name = pdev_id; 2695 2696 t->neigh_proto_dir[0].procname = p_name; 2697 t->neigh_proto_dir[0].ctl_name = p_id; 2698 2699 t->neigh_dev[0].child = t->neigh_vars; 2700 t->neigh_neigh_dir[0].child = t->neigh_dev; 2701 t->neigh_proto_dir[0].child = t->neigh_neigh_dir; 2702 t->neigh_root_dir[0].child = t->neigh_proto_dir; 2703 2704 t->sysctl_header = register_sysctl_table(t->neigh_root_dir, 0); 2705 if (!t->sysctl_header) { 2706 err = -ENOBUFS; 2707 goto free_procname; 2708 } 2709 p->sysctl_table = t; 2710 return 0; 2711 2712 /* error path */ 2713 free_procname: 2714 kfree(dev_name); 2715 free: 2716 kfree(t); 2717 2718 return err; 2719 } 2720 2721 void neigh_sysctl_unregister(struct neigh_parms *p) 2722 { 2723 if (p->sysctl_table) { 2724 struct neigh_sysctl_table *t = p->sysctl_table; 2725 p->sysctl_table = NULL; 2726 unregister_sysctl_table(t->sysctl_header); 2727 kfree(t->neigh_dev[0].procname); 2728 kfree(t); 2729 } 2730 } 2731 2732 #endif /* CONFIG_SYSCTL */ 2733 2734 EXPORT_SYMBOL(__neigh_event_send); 2735 EXPORT_SYMBOL(neigh_changeaddr); 2736 EXPORT_SYMBOL(neigh_compat_output); 2737 EXPORT_SYMBOL(neigh_connected_output); 2738 EXPORT_SYMBOL(neigh_create); 2739 EXPORT_SYMBOL(neigh_delete); 2740 EXPORT_SYMBOL(neigh_destroy); 2741 EXPORT_SYMBOL(neigh_dump_info); 2742 EXPORT_SYMBOL(neigh_event_ns); 2743 EXPORT_SYMBOL(neigh_ifdown); 2744 EXPORT_SYMBOL(neigh_lookup); 2745 EXPORT_SYMBOL(neigh_lookup_nodev); 2746 EXPORT_SYMBOL(neigh_parms_alloc); 2747 EXPORT_SYMBOL(neigh_parms_release); 2748 EXPORT_SYMBOL(neigh_rand_reach_time); 2749 EXPORT_SYMBOL(neigh_resolve_output); 2750 EXPORT_SYMBOL(neigh_table_clear); 2751 EXPORT_SYMBOL(neigh_table_init); 2752 EXPORT_SYMBOL(neigh_table_init_no_netlink); 2753 EXPORT_SYMBOL(neigh_update); 2754 EXPORT_SYMBOL(pneigh_enqueue); 2755 EXPORT_SYMBOL(pneigh_lookup); 2756 2757 #ifdef CONFIG_ARPD 2758 EXPORT_SYMBOL(neigh_app_ns); 2759 #endif 2760 #ifdef CONFIG_SYSCTL 2761 EXPORT_SYMBOL(neigh_sysctl_register); 2762 EXPORT_SYMBOL(neigh_sysctl_unregister); 2763 #endif 2764