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