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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 19 20 #include <linux/slab.h> 21 #include <linux/kmemleak.h> 22 #include <linux/types.h> 23 #include <linux/kernel.h> 24 #include <linux/module.h> 25 #include <linux/socket.h> 26 #include <linux/netdevice.h> 27 #include <linux/proc_fs.h> 28 #ifdef CONFIG_SYSCTL 29 #include <linux/sysctl.h> 30 #endif 31 #include <linux/times.h> 32 #include <net/net_namespace.h> 33 #include <net/neighbour.h> 34 #include <net/arp.h> 35 #include <net/dst.h> 36 #include <net/sock.h> 37 #include <net/netevent.h> 38 #include <net/netlink.h> 39 #include <linux/rtnetlink.h> 40 #include <linux/random.h> 41 #include <linux/string.h> 42 #include <linux/log2.h> 43 #include <linux/inetdevice.h> 44 #include <net/addrconf.h> 45 46 #include <trace/events/neigh.h> 47 48 #define DEBUG 49 #define NEIGH_DEBUG 1 50 #define neigh_dbg(level, fmt, ...) \ 51 do { \ 52 if (level <= NEIGH_DEBUG) \ 53 pr_debug(fmt, ##__VA_ARGS__); \ 54 } while (0) 55 56 #define PNEIGH_HASHMASK 0xF 57 58 static void neigh_timer_handler(struct timer_list *t); 59 static void __neigh_notify(struct neighbour *n, int type, int flags, 60 u32 pid); 61 static void neigh_update_notify(struct neighbour *neigh, u32 nlmsg_pid); 62 static int pneigh_ifdown_and_unlock(struct neigh_table *tbl, 63 struct net_device *dev); 64 65 #ifdef CONFIG_PROC_FS 66 static const struct seq_operations neigh_stat_seq_ops; 67 #endif 68 69 /* 70 Neighbour hash table buckets are protected with rwlock tbl->lock. 71 72 - All the scans/updates to hash buckets MUST be made under this lock. 73 - NOTHING clever should be made under this lock: no callbacks 74 to protocol backends, no attempts to send something to network. 75 It will result in deadlocks, if backend/driver wants to use neighbour 76 cache. 77 - If the entry requires some non-trivial actions, increase 78 its reference count and release table lock. 79 80 Neighbour entries are protected: 81 - with reference count. 82 - with rwlock neigh->lock 83 84 Reference count prevents destruction. 85 86 neigh->lock mainly serializes ll address data and its validity state. 87 However, the same lock is used to protect another entry fields: 88 - timer 89 - resolution queue 90 91 Again, nothing clever shall be made under neigh->lock, 92 the most complicated procedure, which we allow is dev->hard_header. 93 It is supposed, that dev->hard_header is simplistic and does 94 not make callbacks to neighbour tables. 95 */ 96 97 static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb) 98 { 99 kfree_skb(skb); 100 return -ENETDOWN; 101 } 102 103 static void neigh_cleanup_and_release(struct neighbour *neigh) 104 { 105 if (neigh->parms->neigh_cleanup) 106 neigh->parms->neigh_cleanup(neigh); 107 108 trace_neigh_cleanup_and_release(neigh, 0); 109 __neigh_notify(neigh, RTM_DELNEIGH, 0, 0); 110 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh); 111 neigh_release(neigh); 112 } 113 114 /* 115 * It is random distribution in the interval (1/2)*base...(3/2)*base. 116 * It corresponds to default IPv6 settings and is not overridable, 117 * because it is really reasonable choice. 118 */ 119 120 unsigned long neigh_rand_reach_time(unsigned long base) 121 { 122 return base ? (prandom_u32() % base) + (base >> 1) : 0; 123 } 124 EXPORT_SYMBOL(neigh_rand_reach_time); 125 126 static void neigh_mark_dead(struct neighbour *n) 127 { 128 n->dead = 1; 129 if (!list_empty(&n->gc_list)) { 130 list_del_init(&n->gc_list); 131 atomic_dec(&n->tbl->gc_entries); 132 } 133 } 134 135 static void neigh_update_gc_list(struct neighbour *n) 136 { 137 bool on_gc_list, exempt_from_gc; 138 139 write_lock_bh(&n->tbl->lock); 140 write_lock(&n->lock); 141 142 /* remove from the gc list if new state is permanent or if neighbor 143 * is externally learned; otherwise entry should be on the gc list 144 */ 145 exempt_from_gc = n->nud_state & NUD_PERMANENT || 146 n->flags & NTF_EXT_LEARNED; 147 on_gc_list = !list_empty(&n->gc_list); 148 149 if (exempt_from_gc && on_gc_list) { 150 list_del_init(&n->gc_list); 151 atomic_dec(&n->tbl->gc_entries); 152 } else if (!exempt_from_gc && !on_gc_list) { 153 /* add entries to the tail; cleaning removes from the front */ 154 list_add_tail(&n->gc_list, &n->tbl->gc_list); 155 atomic_inc(&n->tbl->gc_entries); 156 } 157 158 write_unlock(&n->lock); 159 write_unlock_bh(&n->tbl->lock); 160 } 161 162 static bool neigh_update_ext_learned(struct neighbour *neigh, u32 flags, 163 int *notify) 164 { 165 bool rc = false; 166 u8 ndm_flags; 167 168 if (!(flags & NEIGH_UPDATE_F_ADMIN)) 169 return rc; 170 171 ndm_flags = (flags & NEIGH_UPDATE_F_EXT_LEARNED) ? NTF_EXT_LEARNED : 0; 172 if ((neigh->flags ^ ndm_flags) & NTF_EXT_LEARNED) { 173 if (ndm_flags & NTF_EXT_LEARNED) 174 neigh->flags |= NTF_EXT_LEARNED; 175 else 176 neigh->flags &= ~NTF_EXT_LEARNED; 177 rc = true; 178 *notify = 1; 179 } 180 181 return rc; 182 } 183 184 static bool neigh_del(struct neighbour *n, struct neighbour __rcu **np, 185 struct neigh_table *tbl) 186 { 187 bool retval = false; 188 189 write_lock(&n->lock); 190 if (refcount_read(&n->refcnt) == 1) { 191 struct neighbour *neigh; 192 193 neigh = rcu_dereference_protected(n->next, 194 lockdep_is_held(&tbl->lock)); 195 rcu_assign_pointer(*np, neigh); 196 neigh_mark_dead(n); 197 retval = true; 198 } 199 write_unlock(&n->lock); 200 if (retval) 201 neigh_cleanup_and_release(n); 202 return retval; 203 } 204 205 bool neigh_remove_one(struct neighbour *ndel, struct neigh_table *tbl) 206 { 207 struct neigh_hash_table *nht; 208 void *pkey = ndel->primary_key; 209 u32 hash_val; 210 struct neighbour *n; 211 struct neighbour __rcu **np; 212 213 nht = rcu_dereference_protected(tbl->nht, 214 lockdep_is_held(&tbl->lock)); 215 hash_val = tbl->hash(pkey, ndel->dev, nht->hash_rnd); 216 hash_val = hash_val >> (32 - nht->hash_shift); 217 218 np = &nht->hash_buckets[hash_val]; 219 while ((n = rcu_dereference_protected(*np, 220 lockdep_is_held(&tbl->lock)))) { 221 if (n == ndel) 222 return neigh_del(n, np, tbl); 223 np = &n->next; 224 } 225 return false; 226 } 227 228 static int neigh_forced_gc(struct neigh_table *tbl) 229 { 230 int max_clean = atomic_read(&tbl->gc_entries) - tbl->gc_thresh2; 231 unsigned long tref = jiffies - 5 * HZ; 232 struct neighbour *n, *tmp; 233 int shrunk = 0; 234 235 NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs); 236 237 write_lock_bh(&tbl->lock); 238 239 list_for_each_entry_safe(n, tmp, &tbl->gc_list, gc_list) { 240 if (refcount_read(&n->refcnt) == 1) { 241 bool remove = false; 242 243 write_lock(&n->lock); 244 if ((n->nud_state == NUD_FAILED) || 245 time_after(tref, n->updated)) 246 remove = true; 247 write_unlock(&n->lock); 248 249 if (remove && neigh_remove_one(n, tbl)) 250 shrunk++; 251 if (shrunk >= max_clean) 252 break; 253 } 254 } 255 256 tbl->last_flush = jiffies; 257 258 write_unlock_bh(&tbl->lock); 259 260 return shrunk; 261 } 262 263 static void neigh_add_timer(struct neighbour *n, unsigned long when) 264 { 265 neigh_hold(n); 266 if (unlikely(mod_timer(&n->timer, when))) { 267 printk("NEIGH: BUG, double timer add, state is %x\n", 268 n->nud_state); 269 dump_stack(); 270 } 271 } 272 273 static int neigh_del_timer(struct neighbour *n) 274 { 275 if ((n->nud_state & NUD_IN_TIMER) && 276 del_timer(&n->timer)) { 277 neigh_release(n); 278 return 1; 279 } 280 return 0; 281 } 282 283 static void pneigh_queue_purge(struct sk_buff_head *list) 284 { 285 struct sk_buff *skb; 286 287 while ((skb = skb_dequeue(list)) != NULL) { 288 dev_put(skb->dev); 289 kfree_skb(skb); 290 } 291 } 292 293 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev, 294 bool skip_perm) 295 { 296 int i; 297 struct neigh_hash_table *nht; 298 299 nht = rcu_dereference_protected(tbl->nht, 300 lockdep_is_held(&tbl->lock)); 301 302 for (i = 0; i < (1 << nht->hash_shift); i++) { 303 struct neighbour *n; 304 struct neighbour __rcu **np = &nht->hash_buckets[i]; 305 306 while ((n = rcu_dereference_protected(*np, 307 lockdep_is_held(&tbl->lock))) != NULL) { 308 if (dev && n->dev != dev) { 309 np = &n->next; 310 continue; 311 } 312 if (skip_perm && n->nud_state & NUD_PERMANENT) { 313 np = &n->next; 314 continue; 315 } 316 rcu_assign_pointer(*np, 317 rcu_dereference_protected(n->next, 318 lockdep_is_held(&tbl->lock))); 319 write_lock(&n->lock); 320 neigh_del_timer(n); 321 neigh_mark_dead(n); 322 if (refcount_read(&n->refcnt) != 1) { 323 /* The most unpleasant situation. 324 We must destroy neighbour entry, 325 but someone still uses it. 326 327 The destroy will be delayed until 328 the last user releases us, but 329 we must kill timers etc. and move 330 it to safe state. 331 */ 332 __skb_queue_purge(&n->arp_queue); 333 n->arp_queue_len_bytes = 0; 334 n->output = neigh_blackhole; 335 if (n->nud_state & NUD_VALID) 336 n->nud_state = NUD_NOARP; 337 else 338 n->nud_state = NUD_NONE; 339 neigh_dbg(2, "neigh %p is stray\n", n); 340 } 341 write_unlock(&n->lock); 342 neigh_cleanup_and_release(n); 343 } 344 } 345 } 346 347 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev) 348 { 349 write_lock_bh(&tbl->lock); 350 neigh_flush_dev(tbl, dev, false); 351 write_unlock_bh(&tbl->lock); 352 } 353 EXPORT_SYMBOL(neigh_changeaddr); 354 355 static int __neigh_ifdown(struct neigh_table *tbl, struct net_device *dev, 356 bool skip_perm) 357 { 358 write_lock_bh(&tbl->lock); 359 neigh_flush_dev(tbl, dev, skip_perm); 360 pneigh_ifdown_and_unlock(tbl, dev); 361 362 del_timer_sync(&tbl->proxy_timer); 363 pneigh_queue_purge(&tbl->proxy_queue); 364 return 0; 365 } 366 367 int neigh_carrier_down(struct neigh_table *tbl, struct net_device *dev) 368 { 369 __neigh_ifdown(tbl, dev, true); 370 return 0; 371 } 372 EXPORT_SYMBOL(neigh_carrier_down); 373 374 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 375 { 376 __neigh_ifdown(tbl, dev, false); 377 return 0; 378 } 379 EXPORT_SYMBOL(neigh_ifdown); 380 381 static struct neighbour *neigh_alloc(struct neigh_table *tbl, 382 struct net_device *dev, 383 bool exempt_from_gc) 384 { 385 struct neighbour *n = NULL; 386 unsigned long now = jiffies; 387 int entries; 388 389 if (exempt_from_gc) 390 goto do_alloc; 391 392 entries = atomic_inc_return(&tbl->gc_entries) - 1; 393 if (entries >= tbl->gc_thresh3 || 394 (entries >= tbl->gc_thresh2 && 395 time_after(now, tbl->last_flush + 5 * HZ))) { 396 if (!neigh_forced_gc(tbl) && 397 entries >= tbl->gc_thresh3) { 398 net_info_ratelimited("%s: neighbor table overflow!\n", 399 tbl->id); 400 NEIGH_CACHE_STAT_INC(tbl, table_fulls); 401 goto out_entries; 402 } 403 } 404 405 do_alloc: 406 n = kzalloc(tbl->entry_size + dev->neigh_priv_len, GFP_ATOMIC); 407 if (!n) 408 goto out_entries; 409 410 __skb_queue_head_init(&n->arp_queue); 411 rwlock_init(&n->lock); 412 seqlock_init(&n->ha_lock); 413 n->updated = n->used = now; 414 n->nud_state = NUD_NONE; 415 n->output = neigh_blackhole; 416 seqlock_init(&n->hh.hh_lock); 417 n->parms = neigh_parms_clone(&tbl->parms); 418 timer_setup(&n->timer, neigh_timer_handler, 0); 419 420 NEIGH_CACHE_STAT_INC(tbl, allocs); 421 n->tbl = tbl; 422 refcount_set(&n->refcnt, 1); 423 n->dead = 1; 424 INIT_LIST_HEAD(&n->gc_list); 425 426 atomic_inc(&tbl->entries); 427 out: 428 return n; 429 430 out_entries: 431 if (!exempt_from_gc) 432 atomic_dec(&tbl->gc_entries); 433 goto out; 434 } 435 436 static void neigh_get_hash_rnd(u32 *x) 437 { 438 *x = get_random_u32() | 1; 439 } 440 441 static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift) 442 { 443 size_t size = (1 << shift) * sizeof(struct neighbour *); 444 struct neigh_hash_table *ret; 445 struct neighbour __rcu **buckets; 446 int i; 447 448 ret = kmalloc(sizeof(*ret), GFP_ATOMIC); 449 if (!ret) 450 return NULL; 451 if (size <= PAGE_SIZE) { 452 buckets = kzalloc(size, GFP_ATOMIC); 453 } else { 454 buckets = (struct neighbour __rcu **) 455 __get_free_pages(GFP_ATOMIC | __GFP_ZERO, 456 get_order(size)); 457 kmemleak_alloc(buckets, size, 1, GFP_ATOMIC); 458 } 459 if (!buckets) { 460 kfree(ret); 461 return NULL; 462 } 463 ret->hash_buckets = buckets; 464 ret->hash_shift = shift; 465 for (i = 0; i < NEIGH_NUM_HASH_RND; i++) 466 neigh_get_hash_rnd(&ret->hash_rnd[i]); 467 return ret; 468 } 469 470 static void neigh_hash_free_rcu(struct rcu_head *head) 471 { 472 struct neigh_hash_table *nht = container_of(head, 473 struct neigh_hash_table, 474 rcu); 475 size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *); 476 struct neighbour __rcu **buckets = nht->hash_buckets; 477 478 if (size <= PAGE_SIZE) { 479 kfree(buckets); 480 } else { 481 kmemleak_free(buckets); 482 free_pages((unsigned long)buckets, get_order(size)); 483 } 484 kfree(nht); 485 } 486 487 static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl, 488 unsigned long new_shift) 489 { 490 unsigned int i, hash; 491 struct neigh_hash_table *new_nht, *old_nht; 492 493 NEIGH_CACHE_STAT_INC(tbl, hash_grows); 494 495 old_nht = rcu_dereference_protected(tbl->nht, 496 lockdep_is_held(&tbl->lock)); 497 new_nht = neigh_hash_alloc(new_shift); 498 if (!new_nht) 499 return old_nht; 500 501 for (i = 0; i < (1 << old_nht->hash_shift); i++) { 502 struct neighbour *n, *next; 503 504 for (n = rcu_dereference_protected(old_nht->hash_buckets[i], 505 lockdep_is_held(&tbl->lock)); 506 n != NULL; 507 n = next) { 508 hash = tbl->hash(n->primary_key, n->dev, 509 new_nht->hash_rnd); 510 511 hash >>= (32 - new_nht->hash_shift); 512 next = rcu_dereference_protected(n->next, 513 lockdep_is_held(&tbl->lock)); 514 515 rcu_assign_pointer(n->next, 516 rcu_dereference_protected( 517 new_nht->hash_buckets[hash], 518 lockdep_is_held(&tbl->lock))); 519 rcu_assign_pointer(new_nht->hash_buckets[hash], n); 520 } 521 } 522 523 rcu_assign_pointer(tbl->nht, new_nht); 524 call_rcu(&old_nht->rcu, neigh_hash_free_rcu); 525 return new_nht; 526 } 527 528 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey, 529 struct net_device *dev) 530 { 531 struct neighbour *n; 532 533 NEIGH_CACHE_STAT_INC(tbl, lookups); 534 535 rcu_read_lock_bh(); 536 n = __neigh_lookup_noref(tbl, pkey, dev); 537 if (n) { 538 if (!refcount_inc_not_zero(&n->refcnt)) 539 n = NULL; 540 NEIGH_CACHE_STAT_INC(tbl, hits); 541 } 542 543 rcu_read_unlock_bh(); 544 return n; 545 } 546 EXPORT_SYMBOL(neigh_lookup); 547 548 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net, 549 const void *pkey) 550 { 551 struct neighbour *n; 552 unsigned int key_len = tbl->key_len; 553 u32 hash_val; 554 struct neigh_hash_table *nht; 555 556 NEIGH_CACHE_STAT_INC(tbl, lookups); 557 558 rcu_read_lock_bh(); 559 nht = rcu_dereference_bh(tbl->nht); 560 hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift); 561 562 for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); 563 n != NULL; 564 n = rcu_dereference_bh(n->next)) { 565 if (!memcmp(n->primary_key, pkey, key_len) && 566 net_eq(dev_net(n->dev), net)) { 567 if (!refcount_inc_not_zero(&n->refcnt)) 568 n = NULL; 569 NEIGH_CACHE_STAT_INC(tbl, hits); 570 break; 571 } 572 } 573 574 rcu_read_unlock_bh(); 575 return n; 576 } 577 EXPORT_SYMBOL(neigh_lookup_nodev); 578 579 static struct neighbour *___neigh_create(struct neigh_table *tbl, 580 const void *pkey, 581 struct net_device *dev, 582 bool exempt_from_gc, bool want_ref) 583 { 584 struct neighbour *n1, *rc, *n = neigh_alloc(tbl, dev, exempt_from_gc); 585 u32 hash_val; 586 unsigned int key_len = tbl->key_len; 587 int error; 588 struct neigh_hash_table *nht; 589 590 if (!n) { 591 rc = ERR_PTR(-ENOBUFS); 592 goto out; 593 } 594 595 memcpy(n->primary_key, pkey, key_len); 596 n->dev = dev; 597 dev_hold(dev); 598 599 /* Protocol specific setup. */ 600 if (tbl->constructor && (error = tbl->constructor(n)) < 0) { 601 rc = ERR_PTR(error); 602 goto out_neigh_release; 603 } 604 605 if (dev->netdev_ops->ndo_neigh_construct) { 606 error = dev->netdev_ops->ndo_neigh_construct(dev, n); 607 if (error < 0) { 608 rc = ERR_PTR(error); 609 goto out_neigh_release; 610 } 611 } 612 613 /* Device specific setup. */ 614 if (n->parms->neigh_setup && 615 (error = n->parms->neigh_setup(n)) < 0) { 616 rc = ERR_PTR(error); 617 goto out_neigh_release; 618 } 619 620 n->confirmed = jiffies - (NEIGH_VAR(n->parms, BASE_REACHABLE_TIME) << 1); 621 622 write_lock_bh(&tbl->lock); 623 nht = rcu_dereference_protected(tbl->nht, 624 lockdep_is_held(&tbl->lock)); 625 626 if (atomic_read(&tbl->entries) > (1 << nht->hash_shift)) 627 nht = neigh_hash_grow(tbl, nht->hash_shift + 1); 628 629 hash_val = tbl->hash(n->primary_key, dev, nht->hash_rnd) >> (32 - nht->hash_shift); 630 631 if (n->parms->dead) { 632 rc = ERR_PTR(-EINVAL); 633 goto out_tbl_unlock; 634 } 635 636 for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val], 637 lockdep_is_held(&tbl->lock)); 638 n1 != NULL; 639 n1 = rcu_dereference_protected(n1->next, 640 lockdep_is_held(&tbl->lock))) { 641 if (dev == n1->dev && !memcmp(n1->primary_key, n->primary_key, key_len)) { 642 if (want_ref) 643 neigh_hold(n1); 644 rc = n1; 645 goto out_tbl_unlock; 646 } 647 } 648 649 n->dead = 0; 650 if (!exempt_from_gc) 651 list_add_tail(&n->gc_list, &n->tbl->gc_list); 652 653 if (want_ref) 654 neigh_hold(n); 655 rcu_assign_pointer(n->next, 656 rcu_dereference_protected(nht->hash_buckets[hash_val], 657 lockdep_is_held(&tbl->lock))); 658 rcu_assign_pointer(nht->hash_buckets[hash_val], n); 659 write_unlock_bh(&tbl->lock); 660 neigh_dbg(2, "neigh %p is created\n", n); 661 rc = n; 662 out: 663 return rc; 664 out_tbl_unlock: 665 write_unlock_bh(&tbl->lock); 666 out_neigh_release: 667 if (!exempt_from_gc) 668 atomic_dec(&tbl->gc_entries); 669 neigh_release(n); 670 goto out; 671 } 672 673 struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey, 674 struct net_device *dev, bool want_ref) 675 { 676 return ___neigh_create(tbl, pkey, dev, false, want_ref); 677 } 678 EXPORT_SYMBOL(__neigh_create); 679 680 static u32 pneigh_hash(const void *pkey, unsigned int key_len) 681 { 682 u32 hash_val = *(u32 *)(pkey + key_len - 4); 683 hash_val ^= (hash_val >> 16); 684 hash_val ^= hash_val >> 8; 685 hash_val ^= hash_val >> 4; 686 hash_val &= PNEIGH_HASHMASK; 687 return hash_val; 688 } 689 690 static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n, 691 struct net *net, 692 const void *pkey, 693 unsigned int key_len, 694 struct net_device *dev) 695 { 696 while (n) { 697 if (!memcmp(n->key, pkey, key_len) && 698 net_eq(pneigh_net(n), net) && 699 (n->dev == dev || !n->dev)) 700 return n; 701 n = n->next; 702 } 703 return NULL; 704 } 705 706 struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl, 707 struct net *net, const void *pkey, struct net_device *dev) 708 { 709 unsigned int key_len = tbl->key_len; 710 u32 hash_val = pneigh_hash(pkey, key_len); 711 712 return __pneigh_lookup_1(tbl->phash_buckets[hash_val], 713 net, pkey, key_len, dev); 714 } 715 EXPORT_SYMBOL_GPL(__pneigh_lookup); 716 717 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, 718 struct net *net, const void *pkey, 719 struct net_device *dev, int creat) 720 { 721 struct pneigh_entry *n; 722 unsigned int key_len = tbl->key_len; 723 u32 hash_val = pneigh_hash(pkey, key_len); 724 725 read_lock_bh(&tbl->lock); 726 n = __pneigh_lookup_1(tbl->phash_buckets[hash_val], 727 net, pkey, key_len, dev); 728 read_unlock_bh(&tbl->lock); 729 730 if (n || !creat) 731 goto out; 732 733 ASSERT_RTNL(); 734 735 n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL); 736 if (!n) 737 goto out; 738 739 n->protocol = 0; 740 write_pnet(&n->net, net); 741 memcpy(n->key, pkey, key_len); 742 n->dev = dev; 743 if (dev) 744 dev_hold(dev); 745 746 if (tbl->pconstructor && tbl->pconstructor(n)) { 747 if (dev) 748 dev_put(dev); 749 kfree(n); 750 n = NULL; 751 goto out; 752 } 753 754 write_lock_bh(&tbl->lock); 755 n->next = tbl->phash_buckets[hash_val]; 756 tbl->phash_buckets[hash_val] = n; 757 write_unlock_bh(&tbl->lock); 758 out: 759 return n; 760 } 761 EXPORT_SYMBOL(pneigh_lookup); 762 763 764 int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey, 765 struct net_device *dev) 766 { 767 struct pneigh_entry *n, **np; 768 unsigned int key_len = tbl->key_len; 769 u32 hash_val = pneigh_hash(pkey, key_len); 770 771 write_lock_bh(&tbl->lock); 772 for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL; 773 np = &n->next) { 774 if (!memcmp(n->key, pkey, key_len) && n->dev == dev && 775 net_eq(pneigh_net(n), net)) { 776 *np = n->next; 777 write_unlock_bh(&tbl->lock); 778 if (tbl->pdestructor) 779 tbl->pdestructor(n); 780 if (n->dev) 781 dev_put(n->dev); 782 kfree(n); 783 return 0; 784 } 785 } 786 write_unlock_bh(&tbl->lock); 787 return -ENOENT; 788 } 789 790 static int pneigh_ifdown_and_unlock(struct neigh_table *tbl, 791 struct net_device *dev) 792 { 793 struct pneigh_entry *n, **np, *freelist = NULL; 794 u32 h; 795 796 for (h = 0; h <= PNEIGH_HASHMASK; h++) { 797 np = &tbl->phash_buckets[h]; 798 while ((n = *np) != NULL) { 799 if (!dev || n->dev == dev) { 800 *np = n->next; 801 n->next = freelist; 802 freelist = n; 803 continue; 804 } 805 np = &n->next; 806 } 807 } 808 write_unlock_bh(&tbl->lock); 809 while ((n = freelist)) { 810 freelist = n->next; 811 n->next = NULL; 812 if (tbl->pdestructor) 813 tbl->pdestructor(n); 814 if (n->dev) 815 dev_put(n->dev); 816 kfree(n); 817 } 818 return -ENOENT; 819 } 820 821 static void neigh_parms_destroy(struct neigh_parms *parms); 822 823 static inline void neigh_parms_put(struct neigh_parms *parms) 824 { 825 if (refcount_dec_and_test(&parms->refcnt)) 826 neigh_parms_destroy(parms); 827 } 828 829 /* 830 * neighbour must already be out of the table; 831 * 832 */ 833 void neigh_destroy(struct neighbour *neigh) 834 { 835 struct net_device *dev = neigh->dev; 836 837 NEIGH_CACHE_STAT_INC(neigh->tbl, destroys); 838 839 if (!neigh->dead) { 840 pr_warn("Destroying alive neighbour %p\n", neigh); 841 dump_stack(); 842 return; 843 } 844 845 if (neigh_del_timer(neigh)) 846 pr_warn("Impossible event\n"); 847 848 write_lock_bh(&neigh->lock); 849 __skb_queue_purge(&neigh->arp_queue); 850 write_unlock_bh(&neigh->lock); 851 neigh->arp_queue_len_bytes = 0; 852 853 if (dev->netdev_ops->ndo_neigh_destroy) 854 dev->netdev_ops->ndo_neigh_destroy(dev, neigh); 855 856 dev_put(dev); 857 neigh_parms_put(neigh->parms); 858 859 neigh_dbg(2, "neigh %p is destroyed\n", neigh); 860 861 atomic_dec(&neigh->tbl->entries); 862 kfree_rcu(neigh, rcu); 863 } 864 EXPORT_SYMBOL(neigh_destroy); 865 866 /* Neighbour state is suspicious; 867 disable fast path. 868 869 Called with write_locked neigh. 870 */ 871 static void neigh_suspect(struct neighbour *neigh) 872 { 873 neigh_dbg(2, "neigh %p is suspected\n", neigh); 874 875 neigh->output = neigh->ops->output; 876 } 877 878 /* Neighbour state is OK; 879 enable fast path. 880 881 Called with write_locked neigh. 882 */ 883 static void neigh_connect(struct neighbour *neigh) 884 { 885 neigh_dbg(2, "neigh %p is connected\n", neigh); 886 887 neigh->output = neigh->ops->connected_output; 888 } 889 890 static void neigh_periodic_work(struct work_struct *work) 891 { 892 struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work); 893 struct neighbour *n; 894 struct neighbour __rcu **np; 895 unsigned int i; 896 struct neigh_hash_table *nht; 897 898 NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs); 899 900 write_lock_bh(&tbl->lock); 901 nht = rcu_dereference_protected(tbl->nht, 902 lockdep_is_held(&tbl->lock)); 903 904 /* 905 * periodically recompute ReachableTime from random function 906 */ 907 908 if (time_after(jiffies, tbl->last_rand + 300 * HZ)) { 909 struct neigh_parms *p; 910 tbl->last_rand = jiffies; 911 list_for_each_entry(p, &tbl->parms_list, list) 912 p->reachable_time = 913 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 914 } 915 916 if (atomic_read(&tbl->entries) < tbl->gc_thresh1) 917 goto out; 918 919 for (i = 0 ; i < (1 << nht->hash_shift); i++) { 920 np = &nht->hash_buckets[i]; 921 922 while ((n = rcu_dereference_protected(*np, 923 lockdep_is_held(&tbl->lock))) != NULL) { 924 unsigned int state; 925 926 write_lock(&n->lock); 927 928 state = n->nud_state; 929 if ((state & (NUD_PERMANENT | NUD_IN_TIMER)) || 930 (n->flags & NTF_EXT_LEARNED)) { 931 write_unlock(&n->lock); 932 goto next_elt; 933 } 934 935 if (time_before(n->used, n->confirmed)) 936 n->used = n->confirmed; 937 938 if (refcount_read(&n->refcnt) == 1 && 939 (state == NUD_FAILED || 940 time_after(jiffies, n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) { 941 *np = n->next; 942 neigh_mark_dead(n); 943 write_unlock(&n->lock); 944 neigh_cleanup_and_release(n); 945 continue; 946 } 947 write_unlock(&n->lock); 948 949 next_elt: 950 np = &n->next; 951 } 952 /* 953 * It's fine to release lock here, even if hash table 954 * grows while we are preempted. 955 */ 956 write_unlock_bh(&tbl->lock); 957 cond_resched(); 958 write_lock_bh(&tbl->lock); 959 nht = rcu_dereference_protected(tbl->nht, 960 lockdep_is_held(&tbl->lock)); 961 } 962 out: 963 /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks. 964 * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2 965 * BASE_REACHABLE_TIME. 966 */ 967 queue_delayed_work(system_power_efficient_wq, &tbl->gc_work, 968 NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME) >> 1); 969 write_unlock_bh(&tbl->lock); 970 } 971 972 static __inline__ int neigh_max_probes(struct neighbour *n) 973 { 974 struct neigh_parms *p = n->parms; 975 return NEIGH_VAR(p, UCAST_PROBES) + NEIGH_VAR(p, APP_PROBES) + 976 (n->nud_state & NUD_PROBE ? NEIGH_VAR(p, MCAST_REPROBES) : 977 NEIGH_VAR(p, MCAST_PROBES)); 978 } 979 980 static void neigh_invalidate(struct neighbour *neigh) 981 __releases(neigh->lock) 982 __acquires(neigh->lock) 983 { 984 struct sk_buff *skb; 985 986 NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed); 987 neigh_dbg(2, "neigh %p is failed\n", neigh); 988 neigh->updated = jiffies; 989 990 /* It is very thin place. report_unreachable is very complicated 991 routine. Particularly, it can hit the same neighbour entry! 992 993 So that, we try to be accurate and avoid dead loop. --ANK 994 */ 995 while (neigh->nud_state == NUD_FAILED && 996 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 997 write_unlock(&neigh->lock); 998 neigh->ops->error_report(neigh, skb); 999 write_lock(&neigh->lock); 1000 } 1001 __skb_queue_purge(&neigh->arp_queue); 1002 neigh->arp_queue_len_bytes = 0; 1003 } 1004 1005 static void neigh_probe(struct neighbour *neigh) 1006 __releases(neigh->lock) 1007 { 1008 struct sk_buff *skb = skb_peek_tail(&neigh->arp_queue); 1009 /* keep skb alive even if arp_queue overflows */ 1010 if (skb) 1011 skb = skb_clone(skb, GFP_ATOMIC); 1012 write_unlock(&neigh->lock); 1013 if (neigh->ops->solicit) 1014 neigh->ops->solicit(neigh, skb); 1015 atomic_inc(&neigh->probes); 1016 consume_skb(skb); 1017 } 1018 1019 /* Called when a timer expires for a neighbour entry. */ 1020 1021 static void neigh_timer_handler(struct timer_list *t) 1022 { 1023 unsigned long now, next; 1024 struct neighbour *neigh = from_timer(neigh, t, timer); 1025 unsigned int state; 1026 int notify = 0; 1027 1028 write_lock(&neigh->lock); 1029 1030 state = neigh->nud_state; 1031 now = jiffies; 1032 next = now + HZ; 1033 1034 if (!(state & NUD_IN_TIMER)) 1035 goto out; 1036 1037 if (state & NUD_REACHABLE) { 1038 if (time_before_eq(now, 1039 neigh->confirmed + neigh->parms->reachable_time)) { 1040 neigh_dbg(2, "neigh %p is still alive\n", neigh); 1041 next = neigh->confirmed + neigh->parms->reachable_time; 1042 } else if (time_before_eq(now, 1043 neigh->used + 1044 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) { 1045 neigh_dbg(2, "neigh %p is delayed\n", neigh); 1046 neigh->nud_state = NUD_DELAY; 1047 neigh->updated = jiffies; 1048 neigh_suspect(neigh); 1049 next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME); 1050 } else { 1051 neigh_dbg(2, "neigh %p is suspected\n", neigh); 1052 neigh->nud_state = NUD_STALE; 1053 neigh->updated = jiffies; 1054 neigh_suspect(neigh); 1055 notify = 1; 1056 } 1057 } else if (state & NUD_DELAY) { 1058 if (time_before_eq(now, 1059 neigh->confirmed + 1060 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) { 1061 neigh_dbg(2, "neigh %p is now reachable\n", neigh); 1062 neigh->nud_state = NUD_REACHABLE; 1063 neigh->updated = jiffies; 1064 neigh_connect(neigh); 1065 notify = 1; 1066 next = neigh->confirmed + neigh->parms->reachable_time; 1067 } else { 1068 neigh_dbg(2, "neigh %p is probed\n", neigh); 1069 neigh->nud_state = NUD_PROBE; 1070 neigh->updated = jiffies; 1071 atomic_set(&neigh->probes, 0); 1072 notify = 1; 1073 next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); 1074 } 1075 } else { 1076 /* NUD_PROBE|NUD_INCOMPLETE */ 1077 next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); 1078 } 1079 1080 if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) && 1081 atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) { 1082 neigh->nud_state = NUD_FAILED; 1083 notify = 1; 1084 neigh_invalidate(neigh); 1085 goto out; 1086 } 1087 1088 if (neigh->nud_state & NUD_IN_TIMER) { 1089 if (time_before(next, jiffies + HZ/2)) 1090 next = jiffies + HZ/2; 1091 if (!mod_timer(&neigh->timer, next)) 1092 neigh_hold(neigh); 1093 } 1094 if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) { 1095 neigh_probe(neigh); 1096 } else { 1097 out: 1098 write_unlock(&neigh->lock); 1099 } 1100 1101 if (notify) 1102 neigh_update_notify(neigh, 0); 1103 1104 trace_neigh_timer_handler(neigh, 0); 1105 1106 neigh_release(neigh); 1107 } 1108 1109 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) 1110 { 1111 int rc; 1112 bool immediate_probe = false; 1113 1114 write_lock_bh(&neigh->lock); 1115 1116 rc = 0; 1117 if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE)) 1118 goto out_unlock_bh; 1119 if (neigh->dead) 1120 goto out_dead; 1121 1122 if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) { 1123 if (NEIGH_VAR(neigh->parms, MCAST_PROBES) + 1124 NEIGH_VAR(neigh->parms, APP_PROBES)) { 1125 unsigned long next, now = jiffies; 1126 1127 atomic_set(&neigh->probes, 1128 NEIGH_VAR(neigh->parms, UCAST_PROBES)); 1129 neigh->nud_state = NUD_INCOMPLETE; 1130 neigh->updated = now; 1131 next = now + max(NEIGH_VAR(neigh->parms, RETRANS_TIME), 1132 HZ/2); 1133 neigh_add_timer(neigh, next); 1134 immediate_probe = true; 1135 } else { 1136 neigh->nud_state = NUD_FAILED; 1137 neigh->updated = jiffies; 1138 write_unlock_bh(&neigh->lock); 1139 1140 kfree_skb(skb); 1141 return 1; 1142 } 1143 } else if (neigh->nud_state & NUD_STALE) { 1144 neigh_dbg(2, "neigh %p is delayed\n", neigh); 1145 neigh->nud_state = NUD_DELAY; 1146 neigh->updated = jiffies; 1147 neigh_add_timer(neigh, jiffies + 1148 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME)); 1149 } 1150 1151 if (neigh->nud_state == NUD_INCOMPLETE) { 1152 if (skb) { 1153 while (neigh->arp_queue_len_bytes + skb->truesize > 1154 NEIGH_VAR(neigh->parms, QUEUE_LEN_BYTES)) { 1155 struct sk_buff *buff; 1156 1157 buff = __skb_dequeue(&neigh->arp_queue); 1158 if (!buff) 1159 break; 1160 neigh->arp_queue_len_bytes -= buff->truesize; 1161 kfree_skb(buff); 1162 NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards); 1163 } 1164 skb_dst_force(skb); 1165 __skb_queue_tail(&neigh->arp_queue, skb); 1166 neigh->arp_queue_len_bytes += skb->truesize; 1167 } 1168 rc = 1; 1169 } 1170 out_unlock_bh: 1171 if (immediate_probe) 1172 neigh_probe(neigh); 1173 else 1174 write_unlock(&neigh->lock); 1175 local_bh_enable(); 1176 trace_neigh_event_send_done(neigh, rc); 1177 return rc; 1178 1179 out_dead: 1180 if (neigh->nud_state & NUD_STALE) 1181 goto out_unlock_bh; 1182 write_unlock_bh(&neigh->lock); 1183 kfree_skb(skb); 1184 trace_neigh_event_send_dead(neigh, 1); 1185 return 1; 1186 } 1187 EXPORT_SYMBOL(__neigh_event_send); 1188 1189 static void neigh_update_hhs(struct neighbour *neigh) 1190 { 1191 struct hh_cache *hh; 1192 void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *) 1193 = NULL; 1194 1195 if (neigh->dev->header_ops) 1196 update = neigh->dev->header_ops->cache_update; 1197 1198 if (update) { 1199 hh = &neigh->hh; 1200 if (hh->hh_len) { 1201 write_seqlock_bh(&hh->hh_lock); 1202 update(hh, neigh->dev, neigh->ha); 1203 write_sequnlock_bh(&hh->hh_lock); 1204 } 1205 } 1206 } 1207 1208 1209 1210 /* Generic update routine. 1211 -- lladdr is new lladdr or NULL, if it is not supplied. 1212 -- new is new state. 1213 -- flags 1214 NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr, 1215 if it is different. 1216 NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected" 1217 lladdr instead of overriding it 1218 if it is different. 1219 NEIGH_UPDATE_F_ADMIN means that the change is administrative. 1220 1221 NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing 1222 NTF_ROUTER flag. 1223 NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as 1224 a router. 1225 1226 Caller MUST hold reference count on the entry. 1227 */ 1228 1229 static int __neigh_update(struct neighbour *neigh, const u8 *lladdr, 1230 u8 new, u32 flags, u32 nlmsg_pid, 1231 struct netlink_ext_ack *extack) 1232 { 1233 bool ext_learn_change = false; 1234 u8 old; 1235 int err; 1236 int notify = 0; 1237 struct net_device *dev; 1238 int update_isrouter = 0; 1239 1240 trace_neigh_update(neigh, lladdr, new, flags, nlmsg_pid); 1241 1242 write_lock_bh(&neigh->lock); 1243 1244 dev = neigh->dev; 1245 old = neigh->nud_state; 1246 err = -EPERM; 1247 1248 if (!(flags & NEIGH_UPDATE_F_ADMIN) && 1249 (old & (NUD_NOARP | NUD_PERMANENT))) 1250 goto out; 1251 if (neigh->dead) { 1252 NL_SET_ERR_MSG(extack, "Neighbor entry is now dead"); 1253 goto out; 1254 } 1255 1256 ext_learn_change = neigh_update_ext_learned(neigh, flags, ¬ify); 1257 1258 if (!(new & NUD_VALID)) { 1259 neigh_del_timer(neigh); 1260 if (old & NUD_CONNECTED) 1261 neigh_suspect(neigh); 1262 neigh->nud_state = new; 1263 err = 0; 1264 notify = old & NUD_VALID; 1265 if ((old & (NUD_INCOMPLETE | NUD_PROBE)) && 1266 (new & NUD_FAILED)) { 1267 neigh_invalidate(neigh); 1268 notify = 1; 1269 } 1270 goto out; 1271 } 1272 1273 /* Compare new lladdr with cached one */ 1274 if (!dev->addr_len) { 1275 /* First case: device needs no address. */ 1276 lladdr = neigh->ha; 1277 } else if (lladdr) { 1278 /* The second case: if something is already cached 1279 and a new address is proposed: 1280 - compare new & old 1281 - if they are different, check override flag 1282 */ 1283 if ((old & NUD_VALID) && 1284 !memcmp(lladdr, neigh->ha, dev->addr_len)) 1285 lladdr = neigh->ha; 1286 } else { 1287 /* No address is supplied; if we know something, 1288 use it, otherwise discard the request. 1289 */ 1290 err = -EINVAL; 1291 if (!(old & NUD_VALID)) { 1292 NL_SET_ERR_MSG(extack, "No link layer address given"); 1293 goto out; 1294 } 1295 lladdr = neigh->ha; 1296 } 1297 1298 /* Update confirmed timestamp for neighbour entry after we 1299 * received ARP packet even if it doesn't change IP to MAC binding. 1300 */ 1301 if (new & NUD_CONNECTED) 1302 neigh->confirmed = jiffies; 1303 1304 /* If entry was valid and address is not changed, 1305 do not change entry state, if new one is STALE. 1306 */ 1307 err = 0; 1308 update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER; 1309 if (old & NUD_VALID) { 1310 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) { 1311 update_isrouter = 0; 1312 if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) && 1313 (old & NUD_CONNECTED)) { 1314 lladdr = neigh->ha; 1315 new = NUD_STALE; 1316 } else 1317 goto out; 1318 } else { 1319 if (lladdr == neigh->ha && new == NUD_STALE && 1320 !(flags & NEIGH_UPDATE_F_ADMIN)) 1321 new = old; 1322 } 1323 } 1324 1325 /* Update timestamp only once we know we will make a change to the 1326 * neighbour entry. Otherwise we risk to move the locktime window with 1327 * noop updates and ignore relevant ARP updates. 1328 */ 1329 if (new != old || lladdr != neigh->ha) 1330 neigh->updated = jiffies; 1331 1332 if (new != old) { 1333 neigh_del_timer(neigh); 1334 if (new & NUD_PROBE) 1335 atomic_set(&neigh->probes, 0); 1336 if (new & NUD_IN_TIMER) 1337 neigh_add_timer(neigh, (jiffies + 1338 ((new & NUD_REACHABLE) ? 1339 neigh->parms->reachable_time : 1340 0))); 1341 neigh->nud_state = new; 1342 notify = 1; 1343 } 1344 1345 if (lladdr != neigh->ha) { 1346 write_seqlock(&neigh->ha_lock); 1347 memcpy(&neigh->ha, lladdr, dev->addr_len); 1348 write_sequnlock(&neigh->ha_lock); 1349 neigh_update_hhs(neigh); 1350 if (!(new & NUD_CONNECTED)) 1351 neigh->confirmed = jiffies - 1352 (NEIGH_VAR(neigh->parms, BASE_REACHABLE_TIME) << 1); 1353 notify = 1; 1354 } 1355 if (new == old) 1356 goto out; 1357 if (new & NUD_CONNECTED) 1358 neigh_connect(neigh); 1359 else 1360 neigh_suspect(neigh); 1361 if (!(old & NUD_VALID)) { 1362 struct sk_buff *skb; 1363 1364 /* Again: avoid dead loop if something went wrong */ 1365 1366 while (neigh->nud_state & NUD_VALID && 1367 (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 1368 struct dst_entry *dst = skb_dst(skb); 1369 struct neighbour *n2, *n1 = neigh; 1370 write_unlock_bh(&neigh->lock); 1371 1372 rcu_read_lock(); 1373 1374 /* Why not just use 'neigh' as-is? The problem is that 1375 * things such as shaper, eql, and sch_teql can end up 1376 * using alternative, different, neigh objects to output 1377 * the packet in the output path. So what we need to do 1378 * here is re-lookup the top-level neigh in the path so 1379 * we can reinject the packet there. 1380 */ 1381 n2 = NULL; 1382 if (dst) { 1383 n2 = dst_neigh_lookup_skb(dst, skb); 1384 if (n2) 1385 n1 = n2; 1386 } 1387 n1->output(n1, skb); 1388 if (n2) 1389 neigh_release(n2); 1390 rcu_read_unlock(); 1391 1392 write_lock_bh(&neigh->lock); 1393 } 1394 __skb_queue_purge(&neigh->arp_queue); 1395 neigh->arp_queue_len_bytes = 0; 1396 } 1397 out: 1398 if (update_isrouter) 1399 neigh_update_is_router(neigh, flags, ¬ify); 1400 write_unlock_bh(&neigh->lock); 1401 1402 if (((new ^ old) & NUD_PERMANENT) || ext_learn_change) 1403 neigh_update_gc_list(neigh); 1404 1405 if (notify) 1406 neigh_update_notify(neigh, nlmsg_pid); 1407 1408 trace_neigh_update_done(neigh, err); 1409 1410 return err; 1411 } 1412 1413 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 1414 u32 flags, u32 nlmsg_pid) 1415 { 1416 return __neigh_update(neigh, lladdr, new, flags, nlmsg_pid, NULL); 1417 } 1418 EXPORT_SYMBOL(neigh_update); 1419 1420 /* Update the neigh to listen temporarily for probe responses, even if it is 1421 * in a NUD_FAILED state. The caller has to hold neigh->lock for writing. 1422 */ 1423 void __neigh_set_probe_once(struct neighbour *neigh) 1424 { 1425 if (neigh->dead) 1426 return; 1427 neigh->updated = jiffies; 1428 if (!(neigh->nud_state & NUD_FAILED)) 1429 return; 1430 neigh->nud_state = NUD_INCOMPLETE; 1431 atomic_set(&neigh->probes, neigh_max_probes(neigh)); 1432 neigh_add_timer(neigh, 1433 jiffies + NEIGH_VAR(neigh->parms, RETRANS_TIME)); 1434 } 1435 EXPORT_SYMBOL(__neigh_set_probe_once); 1436 1437 struct neighbour *neigh_event_ns(struct neigh_table *tbl, 1438 u8 *lladdr, void *saddr, 1439 struct net_device *dev) 1440 { 1441 struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev, 1442 lladdr || !dev->addr_len); 1443 if (neigh) 1444 neigh_update(neigh, lladdr, NUD_STALE, 1445 NEIGH_UPDATE_F_OVERRIDE, 0); 1446 return neigh; 1447 } 1448 EXPORT_SYMBOL(neigh_event_ns); 1449 1450 /* called with read_lock_bh(&n->lock); */ 1451 static void neigh_hh_init(struct neighbour *n) 1452 { 1453 struct net_device *dev = n->dev; 1454 __be16 prot = n->tbl->protocol; 1455 struct hh_cache *hh = &n->hh; 1456 1457 write_lock_bh(&n->lock); 1458 1459 /* Only one thread can come in here and initialize the 1460 * hh_cache entry. 1461 */ 1462 if (!hh->hh_len) 1463 dev->header_ops->cache(n, hh, prot); 1464 1465 write_unlock_bh(&n->lock); 1466 } 1467 1468 /* Slow and careful. */ 1469 1470 int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb) 1471 { 1472 int rc = 0; 1473 1474 if (!neigh_event_send(neigh, skb)) { 1475 int err; 1476 struct net_device *dev = neigh->dev; 1477 unsigned int seq; 1478 1479 if (dev->header_ops->cache && !neigh->hh.hh_len) 1480 neigh_hh_init(neigh); 1481 1482 do { 1483 __skb_pull(skb, skb_network_offset(skb)); 1484 seq = read_seqbegin(&neigh->ha_lock); 1485 err = dev_hard_header(skb, dev, ntohs(skb->protocol), 1486 neigh->ha, NULL, skb->len); 1487 } while (read_seqretry(&neigh->ha_lock, seq)); 1488 1489 if (err >= 0) 1490 rc = dev_queue_xmit(skb); 1491 else 1492 goto out_kfree_skb; 1493 } 1494 out: 1495 return rc; 1496 out_kfree_skb: 1497 rc = -EINVAL; 1498 kfree_skb(skb); 1499 goto out; 1500 } 1501 EXPORT_SYMBOL(neigh_resolve_output); 1502 1503 /* As fast as possible without hh cache */ 1504 1505 int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb) 1506 { 1507 struct net_device *dev = neigh->dev; 1508 unsigned int seq; 1509 int err; 1510 1511 do { 1512 __skb_pull(skb, skb_network_offset(skb)); 1513 seq = read_seqbegin(&neigh->ha_lock); 1514 err = dev_hard_header(skb, dev, ntohs(skb->protocol), 1515 neigh->ha, NULL, skb->len); 1516 } while (read_seqretry(&neigh->ha_lock, seq)); 1517 1518 if (err >= 0) 1519 err = dev_queue_xmit(skb); 1520 else { 1521 err = -EINVAL; 1522 kfree_skb(skb); 1523 } 1524 return err; 1525 } 1526 EXPORT_SYMBOL(neigh_connected_output); 1527 1528 int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb) 1529 { 1530 return dev_queue_xmit(skb); 1531 } 1532 EXPORT_SYMBOL(neigh_direct_output); 1533 1534 static void neigh_proxy_process(struct timer_list *t) 1535 { 1536 struct neigh_table *tbl = from_timer(tbl, t, proxy_timer); 1537 long sched_next = 0; 1538 unsigned long now = jiffies; 1539 struct sk_buff *skb, *n; 1540 1541 spin_lock(&tbl->proxy_queue.lock); 1542 1543 skb_queue_walk_safe(&tbl->proxy_queue, skb, n) { 1544 long tdif = NEIGH_CB(skb)->sched_next - now; 1545 1546 if (tdif <= 0) { 1547 struct net_device *dev = skb->dev; 1548 1549 __skb_unlink(skb, &tbl->proxy_queue); 1550 if (tbl->proxy_redo && netif_running(dev)) { 1551 rcu_read_lock(); 1552 tbl->proxy_redo(skb); 1553 rcu_read_unlock(); 1554 } else { 1555 kfree_skb(skb); 1556 } 1557 1558 dev_put(dev); 1559 } else if (!sched_next || tdif < sched_next) 1560 sched_next = tdif; 1561 } 1562 del_timer(&tbl->proxy_timer); 1563 if (sched_next) 1564 mod_timer(&tbl->proxy_timer, jiffies + sched_next); 1565 spin_unlock(&tbl->proxy_queue.lock); 1566 } 1567 1568 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, 1569 struct sk_buff *skb) 1570 { 1571 unsigned long now = jiffies; 1572 1573 unsigned long sched_next = now + (prandom_u32() % 1574 NEIGH_VAR(p, PROXY_DELAY)); 1575 1576 if (tbl->proxy_queue.qlen > NEIGH_VAR(p, PROXY_QLEN)) { 1577 kfree_skb(skb); 1578 return; 1579 } 1580 1581 NEIGH_CB(skb)->sched_next = sched_next; 1582 NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED; 1583 1584 spin_lock(&tbl->proxy_queue.lock); 1585 if (del_timer(&tbl->proxy_timer)) { 1586 if (time_before(tbl->proxy_timer.expires, sched_next)) 1587 sched_next = tbl->proxy_timer.expires; 1588 } 1589 skb_dst_drop(skb); 1590 dev_hold(skb->dev); 1591 __skb_queue_tail(&tbl->proxy_queue, skb); 1592 mod_timer(&tbl->proxy_timer, sched_next); 1593 spin_unlock(&tbl->proxy_queue.lock); 1594 } 1595 EXPORT_SYMBOL(pneigh_enqueue); 1596 1597 static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl, 1598 struct net *net, int ifindex) 1599 { 1600 struct neigh_parms *p; 1601 1602 list_for_each_entry(p, &tbl->parms_list, list) { 1603 if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) || 1604 (!p->dev && !ifindex && net_eq(net, &init_net))) 1605 return p; 1606 } 1607 1608 return NULL; 1609 } 1610 1611 struct neigh_parms *neigh_parms_alloc(struct net_device *dev, 1612 struct neigh_table *tbl) 1613 { 1614 struct neigh_parms *p; 1615 struct net *net = dev_net(dev); 1616 const struct net_device_ops *ops = dev->netdev_ops; 1617 1618 p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL); 1619 if (p) { 1620 p->tbl = tbl; 1621 refcount_set(&p->refcnt, 1); 1622 p->reachable_time = 1623 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 1624 dev_hold(dev); 1625 p->dev = dev; 1626 write_pnet(&p->net, net); 1627 p->sysctl_table = NULL; 1628 1629 if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) { 1630 dev_put(dev); 1631 kfree(p); 1632 return NULL; 1633 } 1634 1635 write_lock_bh(&tbl->lock); 1636 list_add(&p->list, &tbl->parms.list); 1637 write_unlock_bh(&tbl->lock); 1638 1639 neigh_parms_data_state_cleanall(p); 1640 } 1641 return p; 1642 } 1643 EXPORT_SYMBOL(neigh_parms_alloc); 1644 1645 static void neigh_rcu_free_parms(struct rcu_head *head) 1646 { 1647 struct neigh_parms *parms = 1648 container_of(head, struct neigh_parms, rcu_head); 1649 1650 neigh_parms_put(parms); 1651 } 1652 1653 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms) 1654 { 1655 if (!parms || parms == &tbl->parms) 1656 return; 1657 write_lock_bh(&tbl->lock); 1658 list_del(&parms->list); 1659 parms->dead = 1; 1660 write_unlock_bh(&tbl->lock); 1661 if (parms->dev) 1662 dev_put(parms->dev); 1663 call_rcu(&parms->rcu_head, neigh_rcu_free_parms); 1664 } 1665 EXPORT_SYMBOL(neigh_parms_release); 1666 1667 static void neigh_parms_destroy(struct neigh_parms *parms) 1668 { 1669 kfree(parms); 1670 } 1671 1672 static struct lock_class_key neigh_table_proxy_queue_class; 1673 1674 static struct neigh_table *neigh_tables[NEIGH_NR_TABLES] __read_mostly; 1675 1676 void neigh_table_init(int index, struct neigh_table *tbl) 1677 { 1678 unsigned long now = jiffies; 1679 unsigned long phsize; 1680 1681 INIT_LIST_HEAD(&tbl->parms_list); 1682 INIT_LIST_HEAD(&tbl->gc_list); 1683 list_add(&tbl->parms.list, &tbl->parms_list); 1684 write_pnet(&tbl->parms.net, &init_net); 1685 refcount_set(&tbl->parms.refcnt, 1); 1686 tbl->parms.reachable_time = 1687 neigh_rand_reach_time(NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME)); 1688 1689 tbl->stats = alloc_percpu(struct neigh_statistics); 1690 if (!tbl->stats) 1691 panic("cannot create neighbour cache statistics"); 1692 1693 #ifdef CONFIG_PROC_FS 1694 if (!proc_create_seq_data(tbl->id, 0, init_net.proc_net_stat, 1695 &neigh_stat_seq_ops, tbl)) 1696 panic("cannot create neighbour proc dir entry"); 1697 #endif 1698 1699 RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3)); 1700 1701 phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *); 1702 tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL); 1703 1704 if (!tbl->nht || !tbl->phash_buckets) 1705 panic("cannot allocate neighbour cache hashes"); 1706 1707 if (!tbl->entry_size) 1708 tbl->entry_size = ALIGN(offsetof(struct neighbour, primary_key) + 1709 tbl->key_len, NEIGH_PRIV_ALIGN); 1710 else 1711 WARN_ON(tbl->entry_size % NEIGH_PRIV_ALIGN); 1712 1713 rwlock_init(&tbl->lock); 1714 INIT_DEFERRABLE_WORK(&tbl->gc_work, neigh_periodic_work); 1715 queue_delayed_work(system_power_efficient_wq, &tbl->gc_work, 1716 tbl->parms.reachable_time); 1717 timer_setup(&tbl->proxy_timer, neigh_proxy_process, 0); 1718 skb_queue_head_init_class(&tbl->proxy_queue, 1719 &neigh_table_proxy_queue_class); 1720 1721 tbl->last_flush = now; 1722 tbl->last_rand = now + tbl->parms.reachable_time * 20; 1723 1724 neigh_tables[index] = tbl; 1725 } 1726 EXPORT_SYMBOL(neigh_table_init); 1727 1728 int neigh_table_clear(int index, struct neigh_table *tbl) 1729 { 1730 neigh_tables[index] = NULL; 1731 /* It is not clean... Fix it to unload IPv6 module safely */ 1732 cancel_delayed_work_sync(&tbl->gc_work); 1733 del_timer_sync(&tbl->proxy_timer); 1734 pneigh_queue_purge(&tbl->proxy_queue); 1735 neigh_ifdown(tbl, NULL); 1736 if (atomic_read(&tbl->entries)) 1737 pr_crit("neighbour leakage\n"); 1738 1739 call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu, 1740 neigh_hash_free_rcu); 1741 tbl->nht = NULL; 1742 1743 kfree(tbl->phash_buckets); 1744 tbl->phash_buckets = NULL; 1745 1746 remove_proc_entry(tbl->id, init_net.proc_net_stat); 1747 1748 free_percpu(tbl->stats); 1749 tbl->stats = NULL; 1750 1751 return 0; 1752 } 1753 EXPORT_SYMBOL(neigh_table_clear); 1754 1755 static struct neigh_table *neigh_find_table(int family) 1756 { 1757 struct neigh_table *tbl = NULL; 1758 1759 switch (family) { 1760 case AF_INET: 1761 tbl = neigh_tables[NEIGH_ARP_TABLE]; 1762 break; 1763 case AF_INET6: 1764 tbl = neigh_tables[NEIGH_ND_TABLE]; 1765 break; 1766 case AF_DECnet: 1767 tbl = neigh_tables[NEIGH_DN_TABLE]; 1768 break; 1769 } 1770 1771 return tbl; 1772 } 1773 1774 const struct nla_policy nda_policy[NDA_MAX+1] = { 1775 [NDA_DST] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, 1776 [NDA_LLADDR] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, 1777 [NDA_CACHEINFO] = { .len = sizeof(struct nda_cacheinfo) }, 1778 [NDA_PROBES] = { .type = NLA_U32 }, 1779 [NDA_VLAN] = { .type = NLA_U16 }, 1780 [NDA_PORT] = { .type = NLA_U16 }, 1781 [NDA_VNI] = { .type = NLA_U32 }, 1782 [NDA_IFINDEX] = { .type = NLA_U32 }, 1783 [NDA_MASTER] = { .type = NLA_U32 }, 1784 [NDA_PROTOCOL] = { .type = NLA_U8 }, 1785 }; 1786 1787 static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, 1788 struct netlink_ext_ack *extack) 1789 { 1790 struct net *net = sock_net(skb->sk); 1791 struct ndmsg *ndm; 1792 struct nlattr *dst_attr; 1793 struct neigh_table *tbl; 1794 struct neighbour *neigh; 1795 struct net_device *dev = NULL; 1796 int err = -EINVAL; 1797 1798 ASSERT_RTNL(); 1799 if (nlmsg_len(nlh) < sizeof(*ndm)) 1800 goto out; 1801 1802 dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST); 1803 if (!dst_attr) { 1804 NL_SET_ERR_MSG(extack, "Network address not specified"); 1805 goto out; 1806 } 1807 1808 ndm = nlmsg_data(nlh); 1809 if (ndm->ndm_ifindex) { 1810 dev = __dev_get_by_index(net, ndm->ndm_ifindex); 1811 if (dev == NULL) { 1812 err = -ENODEV; 1813 goto out; 1814 } 1815 } 1816 1817 tbl = neigh_find_table(ndm->ndm_family); 1818 if (tbl == NULL) 1819 return -EAFNOSUPPORT; 1820 1821 if (nla_len(dst_attr) < (int)tbl->key_len) { 1822 NL_SET_ERR_MSG(extack, "Invalid network address"); 1823 goto out; 1824 } 1825 1826 if (ndm->ndm_flags & NTF_PROXY) { 1827 err = pneigh_delete(tbl, net, nla_data(dst_attr), dev); 1828 goto out; 1829 } 1830 1831 if (dev == NULL) 1832 goto out; 1833 1834 neigh = neigh_lookup(tbl, nla_data(dst_attr), dev); 1835 if (neigh == NULL) { 1836 err = -ENOENT; 1837 goto out; 1838 } 1839 1840 err = __neigh_update(neigh, NULL, NUD_FAILED, 1841 NEIGH_UPDATE_F_OVERRIDE | NEIGH_UPDATE_F_ADMIN, 1842 NETLINK_CB(skb).portid, extack); 1843 write_lock_bh(&tbl->lock); 1844 neigh_release(neigh); 1845 neigh_remove_one(neigh, tbl); 1846 write_unlock_bh(&tbl->lock); 1847 1848 out: 1849 return err; 1850 } 1851 1852 static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, 1853 struct netlink_ext_ack *extack) 1854 { 1855 int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE | 1856 NEIGH_UPDATE_F_OVERRIDE_ISROUTER; 1857 struct net *net = sock_net(skb->sk); 1858 struct ndmsg *ndm; 1859 struct nlattr *tb[NDA_MAX+1]; 1860 struct neigh_table *tbl; 1861 struct net_device *dev = NULL; 1862 struct neighbour *neigh; 1863 void *dst, *lladdr; 1864 u8 protocol = 0; 1865 int err; 1866 1867 ASSERT_RTNL(); 1868 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, 1869 nda_policy, extack); 1870 if (err < 0) 1871 goto out; 1872 1873 err = -EINVAL; 1874 if (!tb[NDA_DST]) { 1875 NL_SET_ERR_MSG(extack, "Network address not specified"); 1876 goto out; 1877 } 1878 1879 ndm = nlmsg_data(nlh); 1880 if (ndm->ndm_ifindex) { 1881 dev = __dev_get_by_index(net, ndm->ndm_ifindex); 1882 if (dev == NULL) { 1883 err = -ENODEV; 1884 goto out; 1885 } 1886 1887 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len) { 1888 NL_SET_ERR_MSG(extack, "Invalid link address"); 1889 goto out; 1890 } 1891 } 1892 1893 tbl = neigh_find_table(ndm->ndm_family); 1894 if (tbl == NULL) 1895 return -EAFNOSUPPORT; 1896 1897 if (nla_len(tb[NDA_DST]) < (int)tbl->key_len) { 1898 NL_SET_ERR_MSG(extack, "Invalid network address"); 1899 goto out; 1900 } 1901 1902 dst = nla_data(tb[NDA_DST]); 1903 lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL; 1904 1905 if (tb[NDA_PROTOCOL]) 1906 protocol = nla_get_u8(tb[NDA_PROTOCOL]); 1907 1908 if (ndm->ndm_flags & NTF_PROXY) { 1909 struct pneigh_entry *pn; 1910 1911 err = -ENOBUFS; 1912 pn = pneigh_lookup(tbl, net, dst, dev, 1); 1913 if (pn) { 1914 pn->flags = ndm->ndm_flags; 1915 if (protocol) 1916 pn->protocol = protocol; 1917 err = 0; 1918 } 1919 goto out; 1920 } 1921 1922 if (!dev) { 1923 NL_SET_ERR_MSG(extack, "Device not specified"); 1924 goto out; 1925 } 1926 1927 if (tbl->allow_add && !tbl->allow_add(dev, extack)) { 1928 err = -EINVAL; 1929 goto out; 1930 } 1931 1932 neigh = neigh_lookup(tbl, dst, dev); 1933 if (neigh == NULL) { 1934 bool exempt_from_gc; 1935 1936 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 1937 err = -ENOENT; 1938 goto out; 1939 } 1940 1941 exempt_from_gc = ndm->ndm_state & NUD_PERMANENT || 1942 ndm->ndm_flags & NTF_EXT_LEARNED; 1943 neigh = ___neigh_create(tbl, dst, dev, exempt_from_gc, true); 1944 if (IS_ERR(neigh)) { 1945 err = PTR_ERR(neigh); 1946 goto out; 1947 } 1948 } else { 1949 if (nlh->nlmsg_flags & NLM_F_EXCL) { 1950 err = -EEXIST; 1951 neigh_release(neigh); 1952 goto out; 1953 } 1954 1955 if (!(nlh->nlmsg_flags & NLM_F_REPLACE)) 1956 flags &= ~(NEIGH_UPDATE_F_OVERRIDE | 1957 NEIGH_UPDATE_F_OVERRIDE_ISROUTER); 1958 } 1959 1960 if (ndm->ndm_flags & NTF_EXT_LEARNED) 1961 flags |= NEIGH_UPDATE_F_EXT_LEARNED; 1962 1963 if (ndm->ndm_flags & NTF_ROUTER) 1964 flags |= NEIGH_UPDATE_F_ISROUTER; 1965 1966 if (ndm->ndm_flags & NTF_USE) { 1967 neigh_event_send(neigh, NULL); 1968 err = 0; 1969 } else 1970 err = __neigh_update(neigh, lladdr, ndm->ndm_state, flags, 1971 NETLINK_CB(skb).portid, extack); 1972 1973 if (protocol) 1974 neigh->protocol = protocol; 1975 1976 neigh_release(neigh); 1977 1978 out: 1979 return err; 1980 } 1981 1982 static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms) 1983 { 1984 struct nlattr *nest; 1985 1986 nest = nla_nest_start_noflag(skb, NDTA_PARMS); 1987 if (nest == NULL) 1988 return -ENOBUFS; 1989 1990 if ((parms->dev && 1991 nla_put_u32(skb, NDTPA_IFINDEX, parms->dev->ifindex)) || 1992 nla_put_u32(skb, NDTPA_REFCNT, refcount_read(&parms->refcnt)) || 1993 nla_put_u32(skb, NDTPA_QUEUE_LENBYTES, 1994 NEIGH_VAR(parms, QUEUE_LEN_BYTES)) || 1995 /* approximative value for deprecated QUEUE_LEN (in packets) */ 1996 nla_put_u32(skb, NDTPA_QUEUE_LEN, 1997 NEIGH_VAR(parms, QUEUE_LEN_BYTES) / SKB_TRUESIZE(ETH_FRAME_LEN)) || 1998 nla_put_u32(skb, NDTPA_PROXY_QLEN, NEIGH_VAR(parms, PROXY_QLEN)) || 1999 nla_put_u32(skb, NDTPA_APP_PROBES, NEIGH_VAR(parms, APP_PROBES)) || 2000 nla_put_u32(skb, NDTPA_UCAST_PROBES, 2001 NEIGH_VAR(parms, UCAST_PROBES)) || 2002 nla_put_u32(skb, NDTPA_MCAST_PROBES, 2003 NEIGH_VAR(parms, MCAST_PROBES)) || 2004 nla_put_u32(skb, NDTPA_MCAST_REPROBES, 2005 NEIGH_VAR(parms, MCAST_REPROBES)) || 2006 nla_put_msecs(skb, NDTPA_REACHABLE_TIME, parms->reachable_time, 2007 NDTPA_PAD) || 2008 nla_put_msecs(skb, NDTPA_BASE_REACHABLE_TIME, 2009 NEIGH_VAR(parms, BASE_REACHABLE_TIME), NDTPA_PAD) || 2010 nla_put_msecs(skb, NDTPA_GC_STALETIME, 2011 NEIGH_VAR(parms, GC_STALETIME), NDTPA_PAD) || 2012 nla_put_msecs(skb, NDTPA_DELAY_PROBE_TIME, 2013 NEIGH_VAR(parms, DELAY_PROBE_TIME), NDTPA_PAD) || 2014 nla_put_msecs(skb, NDTPA_RETRANS_TIME, 2015 NEIGH_VAR(parms, RETRANS_TIME), NDTPA_PAD) || 2016 nla_put_msecs(skb, NDTPA_ANYCAST_DELAY, 2017 NEIGH_VAR(parms, ANYCAST_DELAY), NDTPA_PAD) || 2018 nla_put_msecs(skb, NDTPA_PROXY_DELAY, 2019 NEIGH_VAR(parms, PROXY_DELAY), NDTPA_PAD) || 2020 nla_put_msecs(skb, NDTPA_LOCKTIME, 2021 NEIGH_VAR(parms, LOCKTIME), NDTPA_PAD)) 2022 goto nla_put_failure; 2023 return nla_nest_end(skb, nest); 2024 2025 nla_put_failure: 2026 nla_nest_cancel(skb, nest); 2027 return -EMSGSIZE; 2028 } 2029 2030 static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl, 2031 u32 pid, u32 seq, int type, int flags) 2032 { 2033 struct nlmsghdr *nlh; 2034 struct ndtmsg *ndtmsg; 2035 2036 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 2037 if (nlh == NULL) 2038 return -EMSGSIZE; 2039 2040 ndtmsg = nlmsg_data(nlh); 2041 2042 read_lock_bh(&tbl->lock); 2043 ndtmsg->ndtm_family = tbl->family; 2044 ndtmsg->ndtm_pad1 = 0; 2045 ndtmsg->ndtm_pad2 = 0; 2046 2047 if (nla_put_string(skb, NDTA_NAME, tbl->id) || 2048 nla_put_msecs(skb, NDTA_GC_INTERVAL, tbl->gc_interval, NDTA_PAD) || 2049 nla_put_u32(skb, NDTA_THRESH1, tbl->gc_thresh1) || 2050 nla_put_u32(skb, NDTA_THRESH2, tbl->gc_thresh2) || 2051 nla_put_u32(skb, NDTA_THRESH3, tbl->gc_thresh3)) 2052 goto nla_put_failure; 2053 { 2054 unsigned long now = jiffies; 2055 unsigned int flush_delta = now - tbl->last_flush; 2056 unsigned int rand_delta = now - tbl->last_rand; 2057 struct neigh_hash_table *nht; 2058 struct ndt_config ndc = { 2059 .ndtc_key_len = tbl->key_len, 2060 .ndtc_entry_size = tbl->entry_size, 2061 .ndtc_entries = atomic_read(&tbl->entries), 2062 .ndtc_last_flush = jiffies_to_msecs(flush_delta), 2063 .ndtc_last_rand = jiffies_to_msecs(rand_delta), 2064 .ndtc_proxy_qlen = tbl->proxy_queue.qlen, 2065 }; 2066 2067 rcu_read_lock_bh(); 2068 nht = rcu_dereference_bh(tbl->nht); 2069 ndc.ndtc_hash_rnd = nht->hash_rnd[0]; 2070 ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1); 2071 rcu_read_unlock_bh(); 2072 2073 if (nla_put(skb, NDTA_CONFIG, sizeof(ndc), &ndc)) 2074 goto nla_put_failure; 2075 } 2076 2077 { 2078 int cpu; 2079 struct ndt_stats ndst; 2080 2081 memset(&ndst, 0, sizeof(ndst)); 2082 2083 for_each_possible_cpu(cpu) { 2084 struct neigh_statistics *st; 2085 2086 st = per_cpu_ptr(tbl->stats, cpu); 2087 ndst.ndts_allocs += st->allocs; 2088 ndst.ndts_destroys += st->destroys; 2089 ndst.ndts_hash_grows += st->hash_grows; 2090 ndst.ndts_res_failed += st->res_failed; 2091 ndst.ndts_lookups += st->lookups; 2092 ndst.ndts_hits += st->hits; 2093 ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast; 2094 ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast; 2095 ndst.ndts_periodic_gc_runs += st->periodic_gc_runs; 2096 ndst.ndts_forced_gc_runs += st->forced_gc_runs; 2097 ndst.ndts_table_fulls += st->table_fulls; 2098 } 2099 2100 if (nla_put_64bit(skb, NDTA_STATS, sizeof(ndst), &ndst, 2101 NDTA_PAD)) 2102 goto nla_put_failure; 2103 } 2104 2105 BUG_ON(tbl->parms.dev); 2106 if (neightbl_fill_parms(skb, &tbl->parms) < 0) 2107 goto nla_put_failure; 2108 2109 read_unlock_bh(&tbl->lock); 2110 nlmsg_end(skb, nlh); 2111 return 0; 2112 2113 nla_put_failure: 2114 read_unlock_bh(&tbl->lock); 2115 nlmsg_cancel(skb, nlh); 2116 return -EMSGSIZE; 2117 } 2118 2119 static int neightbl_fill_param_info(struct sk_buff *skb, 2120 struct neigh_table *tbl, 2121 struct neigh_parms *parms, 2122 u32 pid, u32 seq, int type, 2123 unsigned int flags) 2124 { 2125 struct ndtmsg *ndtmsg; 2126 struct nlmsghdr *nlh; 2127 2128 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 2129 if (nlh == NULL) 2130 return -EMSGSIZE; 2131 2132 ndtmsg = nlmsg_data(nlh); 2133 2134 read_lock_bh(&tbl->lock); 2135 ndtmsg->ndtm_family = tbl->family; 2136 ndtmsg->ndtm_pad1 = 0; 2137 ndtmsg->ndtm_pad2 = 0; 2138 2139 if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 || 2140 neightbl_fill_parms(skb, parms) < 0) 2141 goto errout; 2142 2143 read_unlock_bh(&tbl->lock); 2144 nlmsg_end(skb, nlh); 2145 return 0; 2146 errout: 2147 read_unlock_bh(&tbl->lock); 2148 nlmsg_cancel(skb, nlh); 2149 return -EMSGSIZE; 2150 } 2151 2152 static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = { 2153 [NDTA_NAME] = { .type = NLA_STRING }, 2154 [NDTA_THRESH1] = { .type = NLA_U32 }, 2155 [NDTA_THRESH2] = { .type = NLA_U32 }, 2156 [NDTA_THRESH3] = { .type = NLA_U32 }, 2157 [NDTA_GC_INTERVAL] = { .type = NLA_U64 }, 2158 [NDTA_PARMS] = { .type = NLA_NESTED }, 2159 }; 2160 2161 static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = { 2162 [NDTPA_IFINDEX] = { .type = NLA_U32 }, 2163 [NDTPA_QUEUE_LEN] = { .type = NLA_U32 }, 2164 [NDTPA_PROXY_QLEN] = { .type = NLA_U32 }, 2165 [NDTPA_APP_PROBES] = { .type = NLA_U32 }, 2166 [NDTPA_UCAST_PROBES] = { .type = NLA_U32 }, 2167 [NDTPA_MCAST_PROBES] = { .type = NLA_U32 }, 2168 [NDTPA_MCAST_REPROBES] = { .type = NLA_U32 }, 2169 [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 }, 2170 [NDTPA_GC_STALETIME] = { .type = NLA_U64 }, 2171 [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 }, 2172 [NDTPA_RETRANS_TIME] = { .type = NLA_U64 }, 2173 [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 }, 2174 [NDTPA_PROXY_DELAY] = { .type = NLA_U64 }, 2175 [NDTPA_LOCKTIME] = { .type = NLA_U64 }, 2176 }; 2177 2178 static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, 2179 struct netlink_ext_ack *extack) 2180 { 2181 struct net *net = sock_net(skb->sk); 2182 struct neigh_table *tbl; 2183 struct ndtmsg *ndtmsg; 2184 struct nlattr *tb[NDTA_MAX+1]; 2185 bool found = false; 2186 int err, tidx; 2187 2188 err = nlmsg_parse_deprecated(nlh, sizeof(*ndtmsg), tb, NDTA_MAX, 2189 nl_neightbl_policy, extack); 2190 if (err < 0) 2191 goto errout; 2192 2193 if (tb[NDTA_NAME] == NULL) { 2194 err = -EINVAL; 2195 goto errout; 2196 } 2197 2198 ndtmsg = nlmsg_data(nlh); 2199 2200 for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) { 2201 tbl = neigh_tables[tidx]; 2202 if (!tbl) 2203 continue; 2204 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family) 2205 continue; 2206 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) { 2207 found = true; 2208 break; 2209 } 2210 } 2211 2212 if (!found) 2213 return -ENOENT; 2214 2215 /* 2216 * We acquire tbl->lock to be nice to the periodic timers and 2217 * make sure they always see a consistent set of values. 2218 */ 2219 write_lock_bh(&tbl->lock); 2220 2221 if (tb[NDTA_PARMS]) { 2222 struct nlattr *tbp[NDTPA_MAX+1]; 2223 struct neigh_parms *p; 2224 int i, ifindex = 0; 2225 2226 err = nla_parse_nested_deprecated(tbp, NDTPA_MAX, 2227 tb[NDTA_PARMS], 2228 nl_ntbl_parm_policy, extack); 2229 if (err < 0) 2230 goto errout_tbl_lock; 2231 2232 if (tbp[NDTPA_IFINDEX]) 2233 ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]); 2234 2235 p = lookup_neigh_parms(tbl, net, ifindex); 2236 if (p == NULL) { 2237 err = -ENOENT; 2238 goto errout_tbl_lock; 2239 } 2240 2241 for (i = 1; i <= NDTPA_MAX; i++) { 2242 if (tbp[i] == NULL) 2243 continue; 2244 2245 switch (i) { 2246 case NDTPA_QUEUE_LEN: 2247 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES, 2248 nla_get_u32(tbp[i]) * 2249 SKB_TRUESIZE(ETH_FRAME_LEN)); 2250 break; 2251 case NDTPA_QUEUE_LENBYTES: 2252 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES, 2253 nla_get_u32(tbp[i])); 2254 break; 2255 case NDTPA_PROXY_QLEN: 2256 NEIGH_VAR_SET(p, PROXY_QLEN, 2257 nla_get_u32(tbp[i])); 2258 break; 2259 case NDTPA_APP_PROBES: 2260 NEIGH_VAR_SET(p, APP_PROBES, 2261 nla_get_u32(tbp[i])); 2262 break; 2263 case NDTPA_UCAST_PROBES: 2264 NEIGH_VAR_SET(p, UCAST_PROBES, 2265 nla_get_u32(tbp[i])); 2266 break; 2267 case NDTPA_MCAST_PROBES: 2268 NEIGH_VAR_SET(p, MCAST_PROBES, 2269 nla_get_u32(tbp[i])); 2270 break; 2271 case NDTPA_MCAST_REPROBES: 2272 NEIGH_VAR_SET(p, MCAST_REPROBES, 2273 nla_get_u32(tbp[i])); 2274 break; 2275 case NDTPA_BASE_REACHABLE_TIME: 2276 NEIGH_VAR_SET(p, BASE_REACHABLE_TIME, 2277 nla_get_msecs(tbp[i])); 2278 /* update reachable_time as well, otherwise, the change will 2279 * only be effective after the next time neigh_periodic_work 2280 * decides to recompute it (can be multiple minutes) 2281 */ 2282 p->reachable_time = 2283 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 2284 break; 2285 case NDTPA_GC_STALETIME: 2286 NEIGH_VAR_SET(p, GC_STALETIME, 2287 nla_get_msecs(tbp[i])); 2288 break; 2289 case NDTPA_DELAY_PROBE_TIME: 2290 NEIGH_VAR_SET(p, DELAY_PROBE_TIME, 2291 nla_get_msecs(tbp[i])); 2292 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE, p); 2293 break; 2294 case NDTPA_RETRANS_TIME: 2295 NEIGH_VAR_SET(p, RETRANS_TIME, 2296 nla_get_msecs(tbp[i])); 2297 break; 2298 case NDTPA_ANYCAST_DELAY: 2299 NEIGH_VAR_SET(p, ANYCAST_DELAY, 2300 nla_get_msecs(tbp[i])); 2301 break; 2302 case NDTPA_PROXY_DELAY: 2303 NEIGH_VAR_SET(p, PROXY_DELAY, 2304 nla_get_msecs(tbp[i])); 2305 break; 2306 case NDTPA_LOCKTIME: 2307 NEIGH_VAR_SET(p, LOCKTIME, 2308 nla_get_msecs(tbp[i])); 2309 break; 2310 } 2311 } 2312 } 2313 2314 err = -ENOENT; 2315 if ((tb[NDTA_THRESH1] || tb[NDTA_THRESH2] || 2316 tb[NDTA_THRESH3] || tb[NDTA_GC_INTERVAL]) && 2317 !net_eq(net, &init_net)) 2318 goto errout_tbl_lock; 2319 2320 if (tb[NDTA_THRESH1]) 2321 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]); 2322 2323 if (tb[NDTA_THRESH2]) 2324 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]); 2325 2326 if (tb[NDTA_THRESH3]) 2327 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]); 2328 2329 if (tb[NDTA_GC_INTERVAL]) 2330 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]); 2331 2332 err = 0; 2333 2334 errout_tbl_lock: 2335 write_unlock_bh(&tbl->lock); 2336 errout: 2337 return err; 2338 } 2339 2340 static int neightbl_valid_dump_info(const struct nlmsghdr *nlh, 2341 struct netlink_ext_ack *extack) 2342 { 2343 struct ndtmsg *ndtm; 2344 2345 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndtm))) { 2346 NL_SET_ERR_MSG(extack, "Invalid header for neighbor table dump request"); 2347 return -EINVAL; 2348 } 2349 2350 ndtm = nlmsg_data(nlh); 2351 if (ndtm->ndtm_pad1 || ndtm->ndtm_pad2) { 2352 NL_SET_ERR_MSG(extack, "Invalid values in header for neighbor table dump request"); 2353 return -EINVAL; 2354 } 2355 2356 if (nlmsg_attrlen(nlh, sizeof(*ndtm))) { 2357 NL_SET_ERR_MSG(extack, "Invalid data after header in neighbor table dump request"); 2358 return -EINVAL; 2359 } 2360 2361 return 0; 2362 } 2363 2364 static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 2365 { 2366 const struct nlmsghdr *nlh = cb->nlh; 2367 struct net *net = sock_net(skb->sk); 2368 int family, tidx, nidx = 0; 2369 int tbl_skip = cb->args[0]; 2370 int neigh_skip = cb->args[1]; 2371 struct neigh_table *tbl; 2372 2373 if (cb->strict_check) { 2374 int err = neightbl_valid_dump_info(nlh, cb->extack); 2375 2376 if (err < 0) 2377 return err; 2378 } 2379 2380 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family; 2381 2382 for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) { 2383 struct neigh_parms *p; 2384 2385 tbl = neigh_tables[tidx]; 2386 if (!tbl) 2387 continue; 2388 2389 if (tidx < tbl_skip || (family && tbl->family != family)) 2390 continue; 2391 2392 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).portid, 2393 nlh->nlmsg_seq, RTM_NEWNEIGHTBL, 2394 NLM_F_MULTI) < 0) 2395 break; 2396 2397 nidx = 0; 2398 p = list_next_entry(&tbl->parms, list); 2399 list_for_each_entry_from(p, &tbl->parms_list, list) { 2400 if (!net_eq(neigh_parms_net(p), net)) 2401 continue; 2402 2403 if (nidx < neigh_skip) 2404 goto next; 2405 2406 if (neightbl_fill_param_info(skb, tbl, p, 2407 NETLINK_CB(cb->skb).portid, 2408 nlh->nlmsg_seq, 2409 RTM_NEWNEIGHTBL, 2410 NLM_F_MULTI) < 0) 2411 goto out; 2412 next: 2413 nidx++; 2414 } 2415 2416 neigh_skip = 0; 2417 } 2418 out: 2419 cb->args[0] = tidx; 2420 cb->args[1] = nidx; 2421 2422 return skb->len; 2423 } 2424 2425 static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh, 2426 u32 pid, u32 seq, int type, unsigned int flags) 2427 { 2428 unsigned long now = jiffies; 2429 struct nda_cacheinfo ci; 2430 struct nlmsghdr *nlh; 2431 struct ndmsg *ndm; 2432 2433 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags); 2434 if (nlh == NULL) 2435 return -EMSGSIZE; 2436 2437 ndm = nlmsg_data(nlh); 2438 ndm->ndm_family = neigh->ops->family; 2439 ndm->ndm_pad1 = 0; 2440 ndm->ndm_pad2 = 0; 2441 ndm->ndm_flags = neigh->flags; 2442 ndm->ndm_type = neigh->type; 2443 ndm->ndm_ifindex = neigh->dev->ifindex; 2444 2445 if (nla_put(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key)) 2446 goto nla_put_failure; 2447 2448 read_lock_bh(&neigh->lock); 2449 ndm->ndm_state = neigh->nud_state; 2450 if (neigh->nud_state & NUD_VALID) { 2451 char haddr[MAX_ADDR_LEN]; 2452 2453 neigh_ha_snapshot(haddr, neigh, neigh->dev); 2454 if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) { 2455 read_unlock_bh(&neigh->lock); 2456 goto nla_put_failure; 2457 } 2458 } 2459 2460 ci.ndm_used = jiffies_to_clock_t(now - neigh->used); 2461 ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed); 2462 ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated); 2463 ci.ndm_refcnt = refcount_read(&neigh->refcnt) - 1; 2464 read_unlock_bh(&neigh->lock); 2465 2466 if (nla_put_u32(skb, NDA_PROBES, atomic_read(&neigh->probes)) || 2467 nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci)) 2468 goto nla_put_failure; 2469 2470 if (neigh->protocol && nla_put_u8(skb, NDA_PROTOCOL, neigh->protocol)) 2471 goto nla_put_failure; 2472 2473 nlmsg_end(skb, nlh); 2474 return 0; 2475 2476 nla_put_failure: 2477 nlmsg_cancel(skb, nlh); 2478 return -EMSGSIZE; 2479 } 2480 2481 static int pneigh_fill_info(struct sk_buff *skb, struct pneigh_entry *pn, 2482 u32 pid, u32 seq, int type, unsigned int flags, 2483 struct neigh_table *tbl) 2484 { 2485 struct nlmsghdr *nlh; 2486 struct ndmsg *ndm; 2487 2488 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags); 2489 if (nlh == NULL) 2490 return -EMSGSIZE; 2491 2492 ndm = nlmsg_data(nlh); 2493 ndm->ndm_family = tbl->family; 2494 ndm->ndm_pad1 = 0; 2495 ndm->ndm_pad2 = 0; 2496 ndm->ndm_flags = pn->flags | NTF_PROXY; 2497 ndm->ndm_type = RTN_UNICAST; 2498 ndm->ndm_ifindex = pn->dev ? pn->dev->ifindex : 0; 2499 ndm->ndm_state = NUD_NONE; 2500 2501 if (nla_put(skb, NDA_DST, tbl->key_len, pn->key)) 2502 goto nla_put_failure; 2503 2504 if (pn->protocol && nla_put_u8(skb, NDA_PROTOCOL, pn->protocol)) 2505 goto nla_put_failure; 2506 2507 nlmsg_end(skb, nlh); 2508 return 0; 2509 2510 nla_put_failure: 2511 nlmsg_cancel(skb, nlh); 2512 return -EMSGSIZE; 2513 } 2514 2515 static void neigh_update_notify(struct neighbour *neigh, u32 nlmsg_pid) 2516 { 2517 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh); 2518 __neigh_notify(neigh, RTM_NEWNEIGH, 0, nlmsg_pid); 2519 } 2520 2521 static bool neigh_master_filtered(struct net_device *dev, int master_idx) 2522 { 2523 struct net_device *master; 2524 2525 if (!master_idx) 2526 return false; 2527 2528 master = dev ? netdev_master_upper_dev_get(dev) : NULL; 2529 if (!master || master->ifindex != master_idx) 2530 return true; 2531 2532 return false; 2533 } 2534 2535 static bool neigh_ifindex_filtered(struct net_device *dev, int filter_idx) 2536 { 2537 if (filter_idx && (!dev || dev->ifindex != filter_idx)) 2538 return true; 2539 2540 return false; 2541 } 2542 2543 struct neigh_dump_filter { 2544 int master_idx; 2545 int dev_idx; 2546 }; 2547 2548 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 2549 struct netlink_callback *cb, 2550 struct neigh_dump_filter *filter) 2551 { 2552 struct net *net = sock_net(skb->sk); 2553 struct neighbour *n; 2554 int rc, h, s_h = cb->args[1]; 2555 int idx, s_idx = idx = cb->args[2]; 2556 struct neigh_hash_table *nht; 2557 unsigned int flags = NLM_F_MULTI; 2558 2559 if (filter->dev_idx || filter->master_idx) 2560 flags |= NLM_F_DUMP_FILTERED; 2561 2562 rcu_read_lock_bh(); 2563 nht = rcu_dereference_bh(tbl->nht); 2564 2565 for (h = s_h; h < (1 << nht->hash_shift); h++) { 2566 if (h > s_h) 2567 s_idx = 0; 2568 for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; 2569 n != NULL; 2570 n = rcu_dereference_bh(n->next)) { 2571 if (idx < s_idx || !net_eq(dev_net(n->dev), net)) 2572 goto next; 2573 if (neigh_ifindex_filtered(n->dev, filter->dev_idx) || 2574 neigh_master_filtered(n->dev, filter->master_idx)) 2575 goto next; 2576 if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid, 2577 cb->nlh->nlmsg_seq, 2578 RTM_NEWNEIGH, 2579 flags) < 0) { 2580 rc = -1; 2581 goto out; 2582 } 2583 next: 2584 idx++; 2585 } 2586 } 2587 rc = skb->len; 2588 out: 2589 rcu_read_unlock_bh(); 2590 cb->args[1] = h; 2591 cb->args[2] = idx; 2592 return rc; 2593 } 2594 2595 static int pneigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 2596 struct netlink_callback *cb, 2597 struct neigh_dump_filter *filter) 2598 { 2599 struct pneigh_entry *n; 2600 struct net *net = sock_net(skb->sk); 2601 int rc, h, s_h = cb->args[3]; 2602 int idx, s_idx = idx = cb->args[4]; 2603 unsigned int flags = NLM_F_MULTI; 2604 2605 if (filter->dev_idx || filter->master_idx) 2606 flags |= NLM_F_DUMP_FILTERED; 2607 2608 read_lock_bh(&tbl->lock); 2609 2610 for (h = s_h; h <= PNEIGH_HASHMASK; h++) { 2611 if (h > s_h) 2612 s_idx = 0; 2613 for (n = tbl->phash_buckets[h], idx = 0; n; n = n->next) { 2614 if (idx < s_idx || pneigh_net(n) != net) 2615 goto next; 2616 if (neigh_ifindex_filtered(n->dev, filter->dev_idx) || 2617 neigh_master_filtered(n->dev, filter->master_idx)) 2618 goto next; 2619 if (pneigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid, 2620 cb->nlh->nlmsg_seq, 2621 RTM_NEWNEIGH, flags, tbl) < 0) { 2622 read_unlock_bh(&tbl->lock); 2623 rc = -1; 2624 goto out; 2625 } 2626 next: 2627 idx++; 2628 } 2629 } 2630 2631 read_unlock_bh(&tbl->lock); 2632 rc = skb->len; 2633 out: 2634 cb->args[3] = h; 2635 cb->args[4] = idx; 2636 return rc; 2637 2638 } 2639 2640 static int neigh_valid_dump_req(const struct nlmsghdr *nlh, 2641 bool strict_check, 2642 struct neigh_dump_filter *filter, 2643 struct netlink_ext_ack *extack) 2644 { 2645 struct nlattr *tb[NDA_MAX + 1]; 2646 int err, i; 2647 2648 if (strict_check) { 2649 struct ndmsg *ndm; 2650 2651 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) { 2652 NL_SET_ERR_MSG(extack, "Invalid header for neighbor dump request"); 2653 return -EINVAL; 2654 } 2655 2656 ndm = nlmsg_data(nlh); 2657 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_ifindex || 2658 ndm->ndm_state || ndm->ndm_type) { 2659 NL_SET_ERR_MSG(extack, "Invalid values in header for neighbor dump request"); 2660 return -EINVAL; 2661 } 2662 2663 if (ndm->ndm_flags & ~NTF_PROXY) { 2664 NL_SET_ERR_MSG(extack, "Invalid flags in header for neighbor dump request"); 2665 return -EINVAL; 2666 } 2667 2668 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), 2669 tb, NDA_MAX, nda_policy, 2670 extack); 2671 } else { 2672 err = nlmsg_parse_deprecated(nlh, sizeof(struct ndmsg), tb, 2673 NDA_MAX, nda_policy, extack); 2674 } 2675 if (err < 0) 2676 return err; 2677 2678 for (i = 0; i <= NDA_MAX; ++i) { 2679 if (!tb[i]) 2680 continue; 2681 2682 /* all new attributes should require strict_check */ 2683 switch (i) { 2684 case NDA_IFINDEX: 2685 filter->dev_idx = nla_get_u32(tb[i]); 2686 break; 2687 case NDA_MASTER: 2688 filter->master_idx = nla_get_u32(tb[i]); 2689 break; 2690 default: 2691 if (strict_check) { 2692 NL_SET_ERR_MSG(extack, "Unsupported attribute in neighbor dump request"); 2693 return -EINVAL; 2694 } 2695 } 2696 } 2697 2698 return 0; 2699 } 2700 2701 static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 2702 { 2703 const struct nlmsghdr *nlh = cb->nlh; 2704 struct neigh_dump_filter filter = {}; 2705 struct neigh_table *tbl; 2706 int t, family, s_t; 2707 int proxy = 0; 2708 int err; 2709 2710 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family; 2711 2712 /* check for full ndmsg structure presence, family member is 2713 * the same for both structures 2714 */ 2715 if (nlmsg_len(nlh) >= sizeof(struct ndmsg) && 2716 ((struct ndmsg *)nlmsg_data(nlh))->ndm_flags == NTF_PROXY) 2717 proxy = 1; 2718 2719 err = neigh_valid_dump_req(nlh, cb->strict_check, &filter, cb->extack); 2720 if (err < 0 && cb->strict_check) 2721 return err; 2722 2723 s_t = cb->args[0]; 2724 2725 for (t = 0; t < NEIGH_NR_TABLES; t++) { 2726 tbl = neigh_tables[t]; 2727 2728 if (!tbl) 2729 continue; 2730 if (t < s_t || (family && tbl->family != family)) 2731 continue; 2732 if (t > s_t) 2733 memset(&cb->args[1], 0, sizeof(cb->args) - 2734 sizeof(cb->args[0])); 2735 if (proxy) 2736 err = pneigh_dump_table(tbl, skb, cb, &filter); 2737 else 2738 err = neigh_dump_table(tbl, skb, cb, &filter); 2739 if (err < 0) 2740 break; 2741 } 2742 2743 cb->args[0] = t; 2744 return skb->len; 2745 } 2746 2747 static int neigh_valid_get_req(const struct nlmsghdr *nlh, 2748 struct neigh_table **tbl, 2749 void **dst, int *dev_idx, u8 *ndm_flags, 2750 struct netlink_ext_ack *extack) 2751 { 2752 struct nlattr *tb[NDA_MAX + 1]; 2753 struct ndmsg *ndm; 2754 int err, i; 2755 2756 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) { 2757 NL_SET_ERR_MSG(extack, "Invalid header for neighbor get request"); 2758 return -EINVAL; 2759 } 2760 2761 ndm = nlmsg_data(nlh); 2762 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state || 2763 ndm->ndm_type) { 2764 NL_SET_ERR_MSG(extack, "Invalid values in header for neighbor get request"); 2765 return -EINVAL; 2766 } 2767 2768 if (ndm->ndm_flags & ~NTF_PROXY) { 2769 NL_SET_ERR_MSG(extack, "Invalid flags in header for neighbor get request"); 2770 return -EINVAL; 2771 } 2772 2773 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb, 2774 NDA_MAX, nda_policy, extack); 2775 if (err < 0) 2776 return err; 2777 2778 *ndm_flags = ndm->ndm_flags; 2779 *dev_idx = ndm->ndm_ifindex; 2780 *tbl = neigh_find_table(ndm->ndm_family); 2781 if (*tbl == NULL) { 2782 NL_SET_ERR_MSG(extack, "Unsupported family in header for neighbor get request"); 2783 return -EAFNOSUPPORT; 2784 } 2785 2786 for (i = 0; i <= NDA_MAX; ++i) { 2787 if (!tb[i]) 2788 continue; 2789 2790 switch (i) { 2791 case NDA_DST: 2792 if (nla_len(tb[i]) != (int)(*tbl)->key_len) { 2793 NL_SET_ERR_MSG(extack, "Invalid network address in neighbor get request"); 2794 return -EINVAL; 2795 } 2796 *dst = nla_data(tb[i]); 2797 break; 2798 default: 2799 NL_SET_ERR_MSG(extack, "Unsupported attribute in neighbor get request"); 2800 return -EINVAL; 2801 } 2802 } 2803 2804 return 0; 2805 } 2806 2807 static inline size_t neigh_nlmsg_size(void) 2808 { 2809 return NLMSG_ALIGN(sizeof(struct ndmsg)) 2810 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */ 2811 + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */ 2812 + nla_total_size(sizeof(struct nda_cacheinfo)) 2813 + nla_total_size(4) /* NDA_PROBES */ 2814 + nla_total_size(1); /* NDA_PROTOCOL */ 2815 } 2816 2817 static int neigh_get_reply(struct net *net, struct neighbour *neigh, 2818 u32 pid, u32 seq) 2819 { 2820 struct sk_buff *skb; 2821 int err = 0; 2822 2823 skb = nlmsg_new(neigh_nlmsg_size(), GFP_KERNEL); 2824 if (!skb) 2825 return -ENOBUFS; 2826 2827 err = neigh_fill_info(skb, neigh, pid, seq, RTM_NEWNEIGH, 0); 2828 if (err) { 2829 kfree_skb(skb); 2830 goto errout; 2831 } 2832 2833 err = rtnl_unicast(skb, net, pid); 2834 errout: 2835 return err; 2836 } 2837 2838 static inline size_t pneigh_nlmsg_size(void) 2839 { 2840 return NLMSG_ALIGN(sizeof(struct ndmsg)) 2841 + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */ 2842 + nla_total_size(1); /* NDA_PROTOCOL */ 2843 } 2844 2845 static int pneigh_get_reply(struct net *net, struct pneigh_entry *neigh, 2846 u32 pid, u32 seq, struct neigh_table *tbl) 2847 { 2848 struct sk_buff *skb; 2849 int err = 0; 2850 2851 skb = nlmsg_new(pneigh_nlmsg_size(), GFP_KERNEL); 2852 if (!skb) 2853 return -ENOBUFS; 2854 2855 err = pneigh_fill_info(skb, neigh, pid, seq, RTM_NEWNEIGH, 0, tbl); 2856 if (err) { 2857 kfree_skb(skb); 2858 goto errout; 2859 } 2860 2861 err = rtnl_unicast(skb, net, pid); 2862 errout: 2863 return err; 2864 } 2865 2866 static int neigh_get(struct sk_buff *in_skb, struct nlmsghdr *nlh, 2867 struct netlink_ext_ack *extack) 2868 { 2869 struct net *net = sock_net(in_skb->sk); 2870 struct net_device *dev = NULL; 2871 struct neigh_table *tbl = NULL; 2872 struct neighbour *neigh; 2873 void *dst = NULL; 2874 u8 ndm_flags = 0; 2875 int dev_idx = 0; 2876 int err; 2877 2878 err = neigh_valid_get_req(nlh, &tbl, &dst, &dev_idx, &ndm_flags, 2879 extack); 2880 if (err < 0) 2881 return err; 2882 2883 if (dev_idx) { 2884 dev = __dev_get_by_index(net, dev_idx); 2885 if (!dev) { 2886 NL_SET_ERR_MSG(extack, "Unknown device ifindex"); 2887 return -ENODEV; 2888 } 2889 } 2890 2891 if (!dst) { 2892 NL_SET_ERR_MSG(extack, "Network address not specified"); 2893 return -EINVAL; 2894 } 2895 2896 if (ndm_flags & NTF_PROXY) { 2897 struct pneigh_entry *pn; 2898 2899 pn = pneigh_lookup(tbl, net, dst, dev, 0); 2900 if (!pn) { 2901 NL_SET_ERR_MSG(extack, "Proxy neighbour entry not found"); 2902 return -ENOENT; 2903 } 2904 return pneigh_get_reply(net, pn, NETLINK_CB(in_skb).portid, 2905 nlh->nlmsg_seq, tbl); 2906 } 2907 2908 if (!dev) { 2909 NL_SET_ERR_MSG(extack, "No device specified"); 2910 return -EINVAL; 2911 } 2912 2913 neigh = neigh_lookup(tbl, dst, dev); 2914 if (!neigh) { 2915 NL_SET_ERR_MSG(extack, "Neighbour entry not found"); 2916 return -ENOENT; 2917 } 2918 2919 err = neigh_get_reply(net, neigh, NETLINK_CB(in_skb).portid, 2920 nlh->nlmsg_seq); 2921 2922 neigh_release(neigh); 2923 2924 return err; 2925 } 2926 2927 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie) 2928 { 2929 int chain; 2930 struct neigh_hash_table *nht; 2931 2932 rcu_read_lock_bh(); 2933 nht = rcu_dereference_bh(tbl->nht); 2934 2935 read_lock(&tbl->lock); /* avoid resizes */ 2936 for (chain = 0; chain < (1 << nht->hash_shift); chain++) { 2937 struct neighbour *n; 2938 2939 for (n = rcu_dereference_bh(nht->hash_buckets[chain]); 2940 n != NULL; 2941 n = rcu_dereference_bh(n->next)) 2942 cb(n, cookie); 2943 } 2944 read_unlock(&tbl->lock); 2945 rcu_read_unlock_bh(); 2946 } 2947 EXPORT_SYMBOL(neigh_for_each); 2948 2949 /* The tbl->lock must be held as a writer and BH disabled. */ 2950 void __neigh_for_each_release(struct neigh_table *tbl, 2951 int (*cb)(struct neighbour *)) 2952 { 2953 int chain; 2954 struct neigh_hash_table *nht; 2955 2956 nht = rcu_dereference_protected(tbl->nht, 2957 lockdep_is_held(&tbl->lock)); 2958 for (chain = 0; chain < (1 << nht->hash_shift); chain++) { 2959 struct neighbour *n; 2960 struct neighbour __rcu **np; 2961 2962 np = &nht->hash_buckets[chain]; 2963 while ((n = rcu_dereference_protected(*np, 2964 lockdep_is_held(&tbl->lock))) != NULL) { 2965 int release; 2966 2967 write_lock(&n->lock); 2968 release = cb(n); 2969 if (release) { 2970 rcu_assign_pointer(*np, 2971 rcu_dereference_protected(n->next, 2972 lockdep_is_held(&tbl->lock))); 2973 neigh_mark_dead(n); 2974 } else 2975 np = &n->next; 2976 write_unlock(&n->lock); 2977 if (release) 2978 neigh_cleanup_and_release(n); 2979 } 2980 } 2981 } 2982 EXPORT_SYMBOL(__neigh_for_each_release); 2983 2984 int neigh_xmit(int index, struct net_device *dev, 2985 const void *addr, struct sk_buff *skb) 2986 { 2987 int err = -EAFNOSUPPORT; 2988 if (likely(index < NEIGH_NR_TABLES)) { 2989 struct neigh_table *tbl; 2990 struct neighbour *neigh; 2991 2992 tbl = neigh_tables[index]; 2993 if (!tbl) 2994 goto out; 2995 rcu_read_lock_bh(); 2996 if (index == NEIGH_ARP_TABLE) { 2997 u32 key = *((u32 *)addr); 2998 2999 neigh = __ipv4_neigh_lookup_noref(dev, key); 3000 } else { 3001 neigh = __neigh_lookup_noref(tbl, addr, dev); 3002 } 3003 if (!neigh) 3004 neigh = __neigh_create(tbl, addr, dev, false); 3005 err = PTR_ERR(neigh); 3006 if (IS_ERR(neigh)) { 3007 rcu_read_unlock_bh(); 3008 goto out_kfree_skb; 3009 } 3010 err = neigh->output(neigh, skb); 3011 rcu_read_unlock_bh(); 3012 } 3013 else if (index == NEIGH_LINK_TABLE) { 3014 err = dev_hard_header(skb, dev, ntohs(skb->protocol), 3015 addr, NULL, skb->len); 3016 if (err < 0) 3017 goto out_kfree_skb; 3018 err = dev_queue_xmit(skb); 3019 } 3020 out: 3021 return err; 3022 out_kfree_skb: 3023 kfree_skb(skb); 3024 goto out; 3025 } 3026 EXPORT_SYMBOL(neigh_xmit); 3027 3028 #ifdef CONFIG_PROC_FS 3029 3030 static struct neighbour *neigh_get_first(struct seq_file *seq) 3031 { 3032 struct neigh_seq_state *state = seq->private; 3033 struct net *net = seq_file_net(seq); 3034 struct neigh_hash_table *nht = state->nht; 3035 struct neighbour *n = NULL; 3036 int bucket = state->bucket; 3037 3038 state->flags &= ~NEIGH_SEQ_IS_PNEIGH; 3039 for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) { 3040 n = rcu_dereference_bh(nht->hash_buckets[bucket]); 3041 3042 while (n) { 3043 if (!net_eq(dev_net(n->dev), net)) 3044 goto next; 3045 if (state->neigh_sub_iter) { 3046 loff_t fakep = 0; 3047 void *v; 3048 3049 v = state->neigh_sub_iter(state, n, &fakep); 3050 if (!v) 3051 goto next; 3052 } 3053 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 3054 break; 3055 if (n->nud_state & ~NUD_NOARP) 3056 break; 3057 next: 3058 n = rcu_dereference_bh(n->next); 3059 } 3060 3061 if (n) 3062 break; 3063 } 3064 state->bucket = bucket; 3065 3066 return n; 3067 } 3068 3069 static struct neighbour *neigh_get_next(struct seq_file *seq, 3070 struct neighbour *n, 3071 loff_t *pos) 3072 { 3073 struct neigh_seq_state *state = seq->private; 3074 struct net *net = seq_file_net(seq); 3075 struct neigh_hash_table *nht = state->nht; 3076 3077 if (state->neigh_sub_iter) { 3078 void *v = state->neigh_sub_iter(state, n, pos); 3079 if (v) 3080 return n; 3081 } 3082 n = rcu_dereference_bh(n->next); 3083 3084 while (1) { 3085 while (n) { 3086 if (!net_eq(dev_net(n->dev), net)) 3087 goto next; 3088 if (state->neigh_sub_iter) { 3089 void *v = state->neigh_sub_iter(state, n, pos); 3090 if (v) 3091 return n; 3092 goto next; 3093 } 3094 if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 3095 break; 3096 3097 if (n->nud_state & ~NUD_NOARP) 3098 break; 3099 next: 3100 n = rcu_dereference_bh(n->next); 3101 } 3102 3103 if (n) 3104 break; 3105 3106 if (++state->bucket >= (1 << nht->hash_shift)) 3107 break; 3108 3109 n = rcu_dereference_bh(nht->hash_buckets[state->bucket]); 3110 } 3111 3112 if (n && pos) 3113 --(*pos); 3114 return n; 3115 } 3116 3117 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos) 3118 { 3119 struct neighbour *n = neigh_get_first(seq); 3120 3121 if (n) { 3122 --(*pos); 3123 while (*pos) { 3124 n = neigh_get_next(seq, n, pos); 3125 if (!n) 3126 break; 3127 } 3128 } 3129 return *pos ? NULL : n; 3130 } 3131 3132 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq) 3133 { 3134 struct neigh_seq_state *state = seq->private; 3135 struct net *net = seq_file_net(seq); 3136 struct neigh_table *tbl = state->tbl; 3137 struct pneigh_entry *pn = NULL; 3138 int bucket = state->bucket; 3139 3140 state->flags |= NEIGH_SEQ_IS_PNEIGH; 3141 for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) { 3142 pn = tbl->phash_buckets[bucket]; 3143 while (pn && !net_eq(pneigh_net(pn), net)) 3144 pn = pn->next; 3145 if (pn) 3146 break; 3147 } 3148 state->bucket = bucket; 3149 3150 return pn; 3151 } 3152 3153 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq, 3154 struct pneigh_entry *pn, 3155 loff_t *pos) 3156 { 3157 struct neigh_seq_state *state = seq->private; 3158 struct net *net = seq_file_net(seq); 3159 struct neigh_table *tbl = state->tbl; 3160 3161 do { 3162 pn = pn->next; 3163 } while (pn && !net_eq(pneigh_net(pn), net)); 3164 3165 while (!pn) { 3166 if (++state->bucket > PNEIGH_HASHMASK) 3167 break; 3168 pn = tbl->phash_buckets[state->bucket]; 3169 while (pn && !net_eq(pneigh_net(pn), net)) 3170 pn = pn->next; 3171 if (pn) 3172 break; 3173 } 3174 3175 if (pn && pos) 3176 --(*pos); 3177 3178 return pn; 3179 } 3180 3181 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos) 3182 { 3183 struct pneigh_entry *pn = pneigh_get_first(seq); 3184 3185 if (pn) { 3186 --(*pos); 3187 while (*pos) { 3188 pn = pneigh_get_next(seq, pn, pos); 3189 if (!pn) 3190 break; 3191 } 3192 } 3193 return *pos ? NULL : pn; 3194 } 3195 3196 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos) 3197 { 3198 struct neigh_seq_state *state = seq->private; 3199 void *rc; 3200 loff_t idxpos = *pos; 3201 3202 rc = neigh_get_idx(seq, &idxpos); 3203 if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 3204 rc = pneigh_get_idx(seq, &idxpos); 3205 3206 return rc; 3207 } 3208 3209 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags) 3210 __acquires(rcu_bh) 3211 { 3212 struct neigh_seq_state *state = seq->private; 3213 3214 state->tbl = tbl; 3215 state->bucket = 0; 3216 state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH); 3217 3218 rcu_read_lock_bh(); 3219 state->nht = rcu_dereference_bh(tbl->nht); 3220 3221 return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN; 3222 } 3223 EXPORT_SYMBOL(neigh_seq_start); 3224 3225 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos) 3226 { 3227 struct neigh_seq_state *state; 3228 void *rc; 3229 3230 if (v == SEQ_START_TOKEN) { 3231 rc = neigh_get_first(seq); 3232 goto out; 3233 } 3234 3235 state = seq->private; 3236 if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) { 3237 rc = neigh_get_next(seq, v, NULL); 3238 if (rc) 3239 goto out; 3240 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 3241 rc = pneigh_get_first(seq); 3242 } else { 3243 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY); 3244 rc = pneigh_get_next(seq, v, NULL); 3245 } 3246 out: 3247 ++(*pos); 3248 return rc; 3249 } 3250 EXPORT_SYMBOL(neigh_seq_next); 3251 3252 void neigh_seq_stop(struct seq_file *seq, void *v) 3253 __releases(rcu_bh) 3254 { 3255 rcu_read_unlock_bh(); 3256 } 3257 EXPORT_SYMBOL(neigh_seq_stop); 3258 3259 /* statistics via seq_file */ 3260 3261 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos) 3262 { 3263 struct neigh_table *tbl = PDE_DATA(file_inode(seq->file)); 3264 int cpu; 3265 3266 if (*pos == 0) 3267 return SEQ_START_TOKEN; 3268 3269 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) { 3270 if (!cpu_possible(cpu)) 3271 continue; 3272 *pos = cpu+1; 3273 return per_cpu_ptr(tbl->stats, cpu); 3274 } 3275 return NULL; 3276 } 3277 3278 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos) 3279 { 3280 struct neigh_table *tbl = PDE_DATA(file_inode(seq->file)); 3281 int cpu; 3282 3283 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) { 3284 if (!cpu_possible(cpu)) 3285 continue; 3286 *pos = cpu+1; 3287 return per_cpu_ptr(tbl->stats, cpu); 3288 } 3289 return NULL; 3290 } 3291 3292 static void neigh_stat_seq_stop(struct seq_file *seq, void *v) 3293 { 3294 3295 } 3296 3297 static int neigh_stat_seq_show(struct seq_file *seq, void *v) 3298 { 3299 struct neigh_table *tbl = PDE_DATA(file_inode(seq->file)); 3300 struct neigh_statistics *st = v; 3301 3302 if (v == SEQ_START_TOKEN) { 3303 seq_printf(seq, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs unresolved_discards table_fulls\n"); 3304 return 0; 3305 } 3306 3307 seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx " 3308 "%08lx %08lx %08lx %08lx %08lx %08lx\n", 3309 atomic_read(&tbl->entries), 3310 3311 st->allocs, 3312 st->destroys, 3313 st->hash_grows, 3314 3315 st->lookups, 3316 st->hits, 3317 3318 st->res_failed, 3319 3320 st->rcv_probes_mcast, 3321 st->rcv_probes_ucast, 3322 3323 st->periodic_gc_runs, 3324 st->forced_gc_runs, 3325 st->unres_discards, 3326 st->table_fulls 3327 ); 3328 3329 return 0; 3330 } 3331 3332 static const struct seq_operations neigh_stat_seq_ops = { 3333 .start = neigh_stat_seq_start, 3334 .next = neigh_stat_seq_next, 3335 .stop = neigh_stat_seq_stop, 3336 .show = neigh_stat_seq_show, 3337 }; 3338 #endif /* CONFIG_PROC_FS */ 3339 3340 static void __neigh_notify(struct neighbour *n, int type, int flags, 3341 u32 pid) 3342 { 3343 struct net *net = dev_net(n->dev); 3344 struct sk_buff *skb; 3345 int err = -ENOBUFS; 3346 3347 skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC); 3348 if (skb == NULL) 3349 goto errout; 3350 3351 err = neigh_fill_info(skb, n, pid, 0, type, flags); 3352 if (err < 0) { 3353 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */ 3354 WARN_ON(err == -EMSGSIZE); 3355 kfree_skb(skb); 3356 goto errout; 3357 } 3358 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 3359 return; 3360 errout: 3361 if (err < 0) 3362 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err); 3363 } 3364 3365 void neigh_app_ns(struct neighbour *n) 3366 { 3367 __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST, 0); 3368 } 3369 EXPORT_SYMBOL(neigh_app_ns); 3370 3371 #ifdef CONFIG_SYSCTL 3372 static int zero; 3373 static int int_max = INT_MAX; 3374 static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN); 3375 3376 static int proc_unres_qlen(struct ctl_table *ctl, int write, 3377 void __user *buffer, size_t *lenp, loff_t *ppos) 3378 { 3379 int size, ret; 3380 struct ctl_table tmp = *ctl; 3381 3382 tmp.extra1 = &zero; 3383 tmp.extra2 = &unres_qlen_max; 3384 tmp.data = &size; 3385 3386 size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN); 3387 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 3388 3389 if (write && !ret) 3390 *(int *)ctl->data = size * SKB_TRUESIZE(ETH_FRAME_LEN); 3391 return ret; 3392 } 3393 3394 static struct neigh_parms *neigh_get_dev_parms_rcu(struct net_device *dev, 3395 int family) 3396 { 3397 switch (family) { 3398 case AF_INET: 3399 return __in_dev_arp_parms_get_rcu(dev); 3400 case AF_INET6: 3401 return __in6_dev_nd_parms_get_rcu(dev); 3402 } 3403 return NULL; 3404 } 3405 3406 static void neigh_copy_dflt_parms(struct net *net, struct neigh_parms *p, 3407 int index) 3408 { 3409 struct net_device *dev; 3410 int family = neigh_parms_family(p); 3411 3412 rcu_read_lock(); 3413 for_each_netdev_rcu(net, dev) { 3414 struct neigh_parms *dst_p = 3415 neigh_get_dev_parms_rcu(dev, family); 3416 3417 if (dst_p && !test_bit(index, dst_p->data_state)) 3418 dst_p->data[index] = p->data[index]; 3419 } 3420 rcu_read_unlock(); 3421 } 3422 3423 static void neigh_proc_update(struct ctl_table *ctl, int write) 3424 { 3425 struct net_device *dev = ctl->extra1; 3426 struct neigh_parms *p = ctl->extra2; 3427 struct net *net = neigh_parms_net(p); 3428 int index = (int *) ctl->data - p->data; 3429 3430 if (!write) 3431 return; 3432 3433 set_bit(index, p->data_state); 3434 if (index == NEIGH_VAR_DELAY_PROBE_TIME) 3435 call_netevent_notifiers(NETEVENT_DELAY_PROBE_TIME_UPDATE, p); 3436 if (!dev) /* NULL dev means this is default value */ 3437 neigh_copy_dflt_parms(net, p, index); 3438 } 3439 3440 static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write, 3441 void __user *buffer, 3442 size_t *lenp, loff_t *ppos) 3443 { 3444 struct ctl_table tmp = *ctl; 3445 int ret; 3446 3447 tmp.extra1 = &zero; 3448 tmp.extra2 = &int_max; 3449 3450 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 3451 neigh_proc_update(ctl, write); 3452 return ret; 3453 } 3454 3455 int neigh_proc_dointvec(struct ctl_table *ctl, int write, 3456 void __user *buffer, size_t *lenp, loff_t *ppos) 3457 { 3458 int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 3459 3460 neigh_proc_update(ctl, write); 3461 return ret; 3462 } 3463 EXPORT_SYMBOL(neigh_proc_dointvec); 3464 3465 int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write, 3466 void __user *buffer, 3467 size_t *lenp, loff_t *ppos) 3468 { 3469 int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos); 3470 3471 neigh_proc_update(ctl, write); 3472 return ret; 3473 } 3474 EXPORT_SYMBOL(neigh_proc_dointvec_jiffies); 3475 3476 static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write, 3477 void __user *buffer, 3478 size_t *lenp, loff_t *ppos) 3479 { 3480 int ret = proc_dointvec_userhz_jiffies(ctl, write, buffer, lenp, ppos); 3481 3482 neigh_proc_update(ctl, write); 3483 return ret; 3484 } 3485 3486 int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write, 3487 void __user *buffer, 3488 size_t *lenp, loff_t *ppos) 3489 { 3490 int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos); 3491 3492 neigh_proc_update(ctl, write); 3493 return ret; 3494 } 3495 EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies); 3496 3497 static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write, 3498 void __user *buffer, 3499 size_t *lenp, loff_t *ppos) 3500 { 3501 int ret = proc_unres_qlen(ctl, write, buffer, lenp, ppos); 3502 3503 neigh_proc_update(ctl, write); 3504 return ret; 3505 } 3506 3507 static int neigh_proc_base_reachable_time(struct ctl_table *ctl, int write, 3508 void __user *buffer, 3509 size_t *lenp, loff_t *ppos) 3510 { 3511 struct neigh_parms *p = ctl->extra2; 3512 int ret; 3513 3514 if (strcmp(ctl->procname, "base_reachable_time") == 0) 3515 ret = neigh_proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos); 3516 else if (strcmp(ctl->procname, "base_reachable_time_ms") == 0) 3517 ret = neigh_proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos); 3518 else 3519 ret = -1; 3520 3521 if (write && ret == 0) { 3522 /* update reachable_time as well, otherwise, the change will 3523 * only be effective after the next time neigh_periodic_work 3524 * decides to recompute it 3525 */ 3526 p->reachable_time = 3527 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 3528 } 3529 return ret; 3530 } 3531 3532 #define NEIGH_PARMS_DATA_OFFSET(index) \ 3533 (&((struct neigh_parms *) 0)->data[index]) 3534 3535 #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \ 3536 [NEIGH_VAR_ ## attr] = { \ 3537 .procname = name, \ 3538 .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \ 3539 .maxlen = sizeof(int), \ 3540 .mode = mval, \ 3541 .proc_handler = proc, \ 3542 } 3543 3544 #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \ 3545 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax) 3546 3547 #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \ 3548 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies) 3549 3550 #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \ 3551 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies) 3552 3553 #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \ 3554 NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies) 3555 3556 #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \ 3557 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies) 3558 3559 #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \ 3560 NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen) 3561 3562 static struct neigh_sysctl_table { 3563 struct ctl_table_header *sysctl_header; 3564 struct ctl_table neigh_vars[NEIGH_VAR_MAX + 1]; 3565 } neigh_sysctl_template __read_mostly = { 3566 .neigh_vars = { 3567 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES, "mcast_solicit"), 3568 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES, "ucast_solicit"), 3569 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES, "app_solicit"), 3570 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_REPROBES, "mcast_resolicit"), 3571 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME, "retrans_time"), 3572 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME, "base_reachable_time"), 3573 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME, "delay_first_probe_time"), 3574 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME, "gc_stale_time"), 3575 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES, "unres_qlen_bytes"), 3576 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN, "proxy_qlen"), 3577 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY, "anycast_delay"), 3578 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY, "proxy_delay"), 3579 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME, "locktime"), 3580 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN, QUEUE_LEN_BYTES, "unres_qlen"), 3581 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS, RETRANS_TIME, "retrans_time_ms"), 3582 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS, BASE_REACHABLE_TIME, "base_reachable_time_ms"), 3583 [NEIGH_VAR_GC_INTERVAL] = { 3584 .procname = "gc_interval", 3585 .maxlen = sizeof(int), 3586 .mode = 0644, 3587 .proc_handler = proc_dointvec_jiffies, 3588 }, 3589 [NEIGH_VAR_GC_THRESH1] = { 3590 .procname = "gc_thresh1", 3591 .maxlen = sizeof(int), 3592 .mode = 0644, 3593 .extra1 = &zero, 3594 .extra2 = &int_max, 3595 .proc_handler = proc_dointvec_minmax, 3596 }, 3597 [NEIGH_VAR_GC_THRESH2] = { 3598 .procname = "gc_thresh2", 3599 .maxlen = sizeof(int), 3600 .mode = 0644, 3601 .extra1 = &zero, 3602 .extra2 = &int_max, 3603 .proc_handler = proc_dointvec_minmax, 3604 }, 3605 [NEIGH_VAR_GC_THRESH3] = { 3606 .procname = "gc_thresh3", 3607 .maxlen = sizeof(int), 3608 .mode = 0644, 3609 .extra1 = &zero, 3610 .extra2 = &int_max, 3611 .proc_handler = proc_dointvec_minmax, 3612 }, 3613 {}, 3614 }, 3615 }; 3616 3617 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, 3618 proc_handler *handler) 3619 { 3620 int i; 3621 struct neigh_sysctl_table *t; 3622 const char *dev_name_source; 3623 char neigh_path[ sizeof("net//neigh/") + IFNAMSIZ + IFNAMSIZ ]; 3624 char *p_name; 3625 3626 t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL); 3627 if (!t) 3628 goto err; 3629 3630 for (i = 0; i < NEIGH_VAR_GC_INTERVAL; i++) { 3631 t->neigh_vars[i].data += (long) p; 3632 t->neigh_vars[i].extra1 = dev; 3633 t->neigh_vars[i].extra2 = p; 3634 } 3635 3636 if (dev) { 3637 dev_name_source = dev->name; 3638 /* Terminate the table early */ 3639 memset(&t->neigh_vars[NEIGH_VAR_GC_INTERVAL], 0, 3640 sizeof(t->neigh_vars[NEIGH_VAR_GC_INTERVAL])); 3641 } else { 3642 struct neigh_table *tbl = p->tbl; 3643 dev_name_source = "default"; 3644 t->neigh_vars[NEIGH_VAR_GC_INTERVAL].data = &tbl->gc_interval; 3645 t->neigh_vars[NEIGH_VAR_GC_THRESH1].data = &tbl->gc_thresh1; 3646 t->neigh_vars[NEIGH_VAR_GC_THRESH2].data = &tbl->gc_thresh2; 3647 t->neigh_vars[NEIGH_VAR_GC_THRESH3].data = &tbl->gc_thresh3; 3648 } 3649 3650 if (handler) { 3651 /* RetransTime */ 3652 t->neigh_vars[NEIGH_VAR_RETRANS_TIME].proc_handler = handler; 3653 /* ReachableTime */ 3654 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = handler; 3655 /* RetransTime (in milliseconds)*/ 3656 t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].proc_handler = handler; 3657 /* ReachableTime (in milliseconds) */ 3658 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = handler; 3659 } else { 3660 /* Those handlers will update p->reachable_time after 3661 * base_reachable_time(_ms) is set to ensure the new timer starts being 3662 * applied after the next neighbour update instead of waiting for 3663 * neigh_periodic_work to update its value (can be multiple minutes) 3664 * So any handler that replaces them should do this as well 3665 */ 3666 /* ReachableTime */ 3667 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = 3668 neigh_proc_base_reachable_time; 3669 /* ReachableTime (in milliseconds) */ 3670 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = 3671 neigh_proc_base_reachable_time; 3672 } 3673 3674 /* Don't export sysctls to unprivileged users */ 3675 if (neigh_parms_net(p)->user_ns != &init_user_ns) 3676 t->neigh_vars[0].procname = NULL; 3677 3678 switch (neigh_parms_family(p)) { 3679 case AF_INET: 3680 p_name = "ipv4"; 3681 break; 3682 case AF_INET6: 3683 p_name = "ipv6"; 3684 break; 3685 default: 3686 BUG(); 3687 } 3688 3689 snprintf(neigh_path, sizeof(neigh_path), "net/%s/neigh/%s", 3690 p_name, dev_name_source); 3691 t->sysctl_header = 3692 register_net_sysctl(neigh_parms_net(p), neigh_path, t->neigh_vars); 3693 if (!t->sysctl_header) 3694 goto free; 3695 3696 p->sysctl_table = t; 3697 return 0; 3698 3699 free: 3700 kfree(t); 3701 err: 3702 return -ENOBUFS; 3703 } 3704 EXPORT_SYMBOL(neigh_sysctl_register); 3705 3706 void neigh_sysctl_unregister(struct neigh_parms *p) 3707 { 3708 if (p->sysctl_table) { 3709 struct neigh_sysctl_table *t = p->sysctl_table; 3710 p->sysctl_table = NULL; 3711 unregister_net_sysctl_table(t->sysctl_header); 3712 kfree(t); 3713 } 3714 } 3715 EXPORT_SYMBOL(neigh_sysctl_unregister); 3716 3717 #endif /* CONFIG_SYSCTL */ 3718 3719 static int __init neigh_init(void) 3720 { 3721 rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, 0); 3722 rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, 0); 3723 rtnl_register(PF_UNSPEC, RTM_GETNEIGH, neigh_get, neigh_dump_info, 0); 3724 3725 rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info, 3726 0); 3727 rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, 0); 3728 3729 return 0; 3730 } 3731 3732 subsys_initcall(neigh_init); 3733