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