1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2004 Luigi Rizzo, Alessandro Cerri. All rights reserved. 5 * Copyright (c) 2004-2008 Qing Li. All rights reserved. 6 * Copyright (c) 2008 Kip Macy. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include "opt_ddb.h" 33 #include "opt_inet.h" 34 #include "opt_inet6.h" 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/eventhandler.h> 39 #include <sys/malloc.h> 40 #include <sys/mbuf.h> 41 #include <sys/syslog.h> 42 #include <sys/sysctl.h> 43 #include <sys/socket.h> 44 #include <sys/kernel.h> 45 #include <sys/lock.h> 46 #include <sys/mutex.h> 47 #include <sys/rwlock.h> 48 49 #ifdef DDB 50 #include <ddb/ddb.h> 51 #endif 52 53 #include <vm/uma.h> 54 55 #include <netinet/in.h> 56 #include <net/if_llatbl.h> 57 #include <net/if.h> 58 #include <net/if_dl.h> 59 #include <net/if_var.h> 60 #include <net/route.h> 61 #include <net/vnet.h> 62 #include <netinet/if_ether.h> 63 #include <netinet6/in6_var.h> 64 #include <netinet6/nd6.h> 65 66 MALLOC_DEFINE(M_LLTABLE, "lltable", "link level address tables"); 67 68 VNET_DEFINE_STATIC(SLIST_HEAD(, lltable), lltables) = 69 SLIST_HEAD_INITIALIZER(lltables); 70 #define V_lltables VNET(lltables) 71 72 static struct rwlock lltable_list_lock; 73 RW_SYSINIT(lltable_list_lock, &lltable_list_lock, "lltable_list_lock"); 74 #define LLTABLE_LIST_RLOCK() rw_rlock(&lltable_list_lock) 75 #define LLTABLE_LIST_RUNLOCK() rw_runlock(&lltable_list_lock) 76 #define LLTABLE_LIST_WLOCK() rw_wlock(&lltable_list_lock) 77 #define LLTABLE_LIST_WUNLOCK() rw_wunlock(&lltable_list_lock) 78 #define LLTABLE_LIST_LOCK_ASSERT() rw_assert(&lltable_list_lock, RA_LOCKED) 79 80 static void lltable_unlink(struct lltable *llt); 81 static void llentries_unlink(struct lltable *llt, struct llentries *head); 82 83 /* 84 * Dump lle state for a specific address family. 85 */ 86 static int 87 lltable_dump_af(struct lltable *llt, struct sysctl_req *wr) 88 { 89 struct epoch_tracker et; 90 int error; 91 92 LLTABLE_LIST_LOCK_ASSERT(); 93 94 if (llt->llt_ifp->if_flags & IFF_LOOPBACK) 95 return (0); 96 error = 0; 97 98 NET_EPOCH_ENTER(et); 99 error = lltable_foreach_lle(llt, 100 (llt_foreach_cb_t *)llt->llt_dump_entry, wr); 101 NET_EPOCH_EXIT(et); 102 103 return (error); 104 } 105 106 /* 107 * Dump arp state for a specific address family. 108 */ 109 int 110 lltable_sysctl_dumparp(int af, struct sysctl_req *wr) 111 { 112 struct lltable *llt; 113 int error = 0; 114 115 LLTABLE_LIST_RLOCK(); 116 SLIST_FOREACH(llt, &V_lltables, llt_link) { 117 if (llt->llt_af == af) { 118 error = lltable_dump_af(llt, wr); 119 if (error != 0) 120 goto done; 121 } 122 } 123 done: 124 LLTABLE_LIST_RUNLOCK(); 125 return (error); 126 } 127 128 /* 129 * Common function helpers for chained hash table. 130 */ 131 132 /* 133 * Runs specified callback for each entry in @llt. 134 * Caller does the locking. 135 * 136 */ 137 static int 138 htable_foreach_lle(struct lltable *llt, llt_foreach_cb_t *f, void *farg) 139 { 140 struct llentry *lle, *next; 141 int i, error; 142 143 error = 0; 144 145 for (i = 0; i < llt->llt_hsize; i++) { 146 CK_LIST_FOREACH_SAFE(lle, &llt->lle_head[i], lle_next, next) { 147 error = f(llt, lle, farg); 148 if (error != 0) 149 break; 150 } 151 } 152 153 return (error); 154 } 155 156 static void 157 htable_link_entry(struct lltable *llt, struct llentry *lle) 158 { 159 struct llentries *lleh; 160 uint32_t hashidx; 161 162 if ((lle->la_flags & LLE_LINKED) != 0) 163 return; 164 165 IF_AFDATA_WLOCK_ASSERT(llt->llt_ifp); 166 167 hashidx = llt->llt_hash(lle, llt->llt_hsize); 168 lleh = &llt->lle_head[hashidx]; 169 170 lle->lle_tbl = llt; 171 lle->lle_head = lleh; 172 lle->la_flags |= LLE_LINKED; 173 CK_LIST_INSERT_HEAD(lleh, lle, lle_next); 174 } 175 176 static void 177 htable_unlink_entry(struct llentry *lle) 178 { 179 180 if ((lle->la_flags & LLE_LINKED) == 0) 181 return; 182 183 IF_AFDATA_WLOCK_ASSERT(lle->lle_tbl->llt_ifp); 184 CK_LIST_REMOVE(lle, lle_next); 185 lle->la_flags &= ~(LLE_VALID | LLE_LINKED); 186 #if 0 187 lle->lle_tbl = NULL; 188 lle->lle_head = NULL; 189 #endif 190 } 191 192 struct prefix_match_data { 193 const struct sockaddr *addr; 194 const struct sockaddr *mask; 195 struct llentries dchain; 196 u_int flags; 197 }; 198 199 static int 200 htable_prefix_free_cb(struct lltable *llt, struct llentry *lle, void *farg) 201 { 202 struct prefix_match_data *pmd; 203 204 pmd = (struct prefix_match_data *)farg; 205 206 if (llt->llt_match_prefix(pmd->addr, pmd->mask, pmd->flags, lle)) { 207 LLE_WLOCK(lle); 208 CK_LIST_INSERT_HEAD(&pmd->dchain, lle, lle_chain); 209 } 210 211 return (0); 212 } 213 214 static void 215 htable_prefix_free(struct lltable *llt, const struct sockaddr *addr, 216 const struct sockaddr *mask, u_int flags) 217 { 218 struct llentry *lle, *next; 219 struct prefix_match_data pmd; 220 221 bzero(&pmd, sizeof(pmd)); 222 pmd.addr = addr; 223 pmd.mask = mask; 224 pmd.flags = flags; 225 CK_LIST_INIT(&pmd.dchain); 226 227 IF_AFDATA_WLOCK(llt->llt_ifp); 228 /* Push matching lles to chain */ 229 lltable_foreach_lle(llt, htable_prefix_free_cb, &pmd); 230 231 llentries_unlink(llt, &pmd.dchain); 232 IF_AFDATA_WUNLOCK(llt->llt_ifp); 233 234 CK_LIST_FOREACH_SAFE(lle, &pmd.dchain, lle_chain, next) 235 lltable_free_entry(llt, lle); 236 } 237 238 static void 239 htable_free_tbl(struct lltable *llt) 240 { 241 242 free(llt->lle_head, M_LLTABLE); 243 free(llt, M_LLTABLE); 244 } 245 246 static void 247 llentries_unlink(struct lltable *llt, struct llentries *head) 248 { 249 struct llentry *lle, *next; 250 251 CK_LIST_FOREACH_SAFE(lle, head, lle_chain, next) 252 llt->llt_unlink_entry(lle); 253 } 254 255 /* 256 * Helper function used to drop all mbufs in hold queue. 257 * 258 * Returns the number of held packets, if any, that were dropped. 259 */ 260 size_t 261 lltable_drop_entry_queue(struct llentry *lle) 262 { 263 size_t pkts_dropped; 264 struct mbuf *next; 265 266 LLE_WLOCK_ASSERT(lle); 267 268 pkts_dropped = 0; 269 while ((lle->la_numheld > 0) && (lle->la_hold != NULL)) { 270 next = lle->la_hold->m_nextpkt; 271 m_freem(lle->la_hold); 272 lle->la_hold = next; 273 lle->la_numheld--; 274 pkts_dropped++; 275 } 276 277 KASSERT(lle->la_numheld == 0, 278 ("%s: la_numheld %d > 0, pkts_droped %zd", __func__, 279 lle->la_numheld, pkts_dropped)); 280 281 return (pkts_dropped); 282 } 283 284 void 285 lltable_set_entry_addr(struct ifnet *ifp, struct llentry *lle, 286 const char *linkhdr, size_t linkhdrsize, int lladdr_off) 287 { 288 289 memcpy(lle->r_linkdata, linkhdr, linkhdrsize); 290 lle->r_hdrlen = linkhdrsize; 291 lle->ll_addr = &lle->r_linkdata[lladdr_off]; 292 lle->la_flags |= LLE_VALID; 293 lle->r_flags |= RLLE_VALID; 294 } 295 296 /* 297 * Tries to update @lle link-level address. 298 * Since update requires AFDATA WLOCK, function 299 * drops @lle lock, acquires AFDATA lock and then acquires 300 * @lle lock to maintain lock order. 301 * 302 * Returns 1 on success. 303 */ 304 int 305 lltable_try_set_entry_addr(struct ifnet *ifp, struct llentry *lle, 306 const char *linkhdr, size_t linkhdrsize, int lladdr_off) 307 { 308 309 /* Perform real LLE update */ 310 /* use afdata WLOCK to update fields */ 311 LLE_WLOCK_ASSERT(lle); 312 LLE_ADDREF(lle); 313 LLE_WUNLOCK(lle); 314 IF_AFDATA_WLOCK(ifp); 315 LLE_WLOCK(lle); 316 317 /* 318 * Since we droppped LLE lock, other thread might have deleted 319 * this lle. Check and return 320 */ 321 if ((lle->la_flags & LLE_DELETED) != 0) { 322 IF_AFDATA_WUNLOCK(ifp); 323 LLE_FREE_LOCKED(lle); 324 return (0); 325 } 326 327 /* Update data */ 328 lltable_set_entry_addr(ifp, lle, linkhdr, linkhdrsize, lladdr_off); 329 330 IF_AFDATA_WUNLOCK(ifp); 331 332 LLE_REMREF(lle); 333 334 return (1); 335 } 336 337 /* 338 * Helper function used to pre-compute full/partial link-layer 339 * header data suitable for feeding into if_output(). 340 */ 341 int 342 lltable_calc_llheader(struct ifnet *ifp, int family, char *lladdr, 343 char *buf, size_t *bufsize, int *lladdr_off) 344 { 345 struct if_encap_req ereq; 346 int error; 347 348 bzero(buf, *bufsize); 349 bzero(&ereq, sizeof(ereq)); 350 ereq.buf = buf; 351 ereq.bufsize = *bufsize; 352 ereq.rtype = IFENCAP_LL; 353 ereq.family = family; 354 ereq.lladdr = lladdr; 355 ereq.lladdr_len = ifp->if_addrlen; 356 error = ifp->if_requestencap(ifp, &ereq); 357 if (error == 0) { 358 *bufsize = ereq.bufsize; 359 *lladdr_off = ereq.lladdr_off; 360 } 361 362 return (error); 363 } 364 365 /* 366 * Update link-layer header for given @lle after 367 * interface lladdr was changed. 368 */ 369 static int 370 llentry_update_ifaddr(struct lltable *llt, struct llentry *lle, void *farg) 371 { 372 struct ifnet *ifp; 373 u_char linkhdr[LLE_MAX_LINKHDR]; 374 size_t linkhdrsize; 375 u_char *lladdr; 376 int lladdr_off; 377 378 ifp = (struct ifnet *)farg; 379 380 lladdr = lle->ll_addr; 381 382 LLE_WLOCK(lle); 383 if ((lle->la_flags & LLE_VALID) == 0) { 384 LLE_WUNLOCK(lle); 385 return (0); 386 } 387 388 if ((lle->la_flags & LLE_IFADDR) != 0) 389 lladdr = IF_LLADDR(ifp); 390 391 linkhdrsize = sizeof(linkhdr); 392 lltable_calc_llheader(ifp, llt->llt_af, lladdr, linkhdr, &linkhdrsize, 393 &lladdr_off); 394 memcpy(lle->r_linkdata, linkhdr, linkhdrsize); 395 LLE_WUNLOCK(lle); 396 397 return (0); 398 } 399 400 /* 401 * Update all calculated headers for given @llt 402 */ 403 void 404 lltable_update_ifaddr(struct lltable *llt) 405 { 406 407 if (llt->llt_ifp->if_flags & IFF_LOOPBACK) 408 return; 409 410 IF_AFDATA_WLOCK(llt->llt_ifp); 411 lltable_foreach_lle(llt, llentry_update_ifaddr, llt->llt_ifp); 412 IF_AFDATA_WUNLOCK(llt->llt_ifp); 413 } 414 415 /* 416 * 417 * Performs generic cleanup routines and frees lle. 418 * 419 * Called for non-linked entries, with callouts and 420 * other AF-specific cleanups performed. 421 * 422 * @lle must be passed WLOCK'ed 423 * 424 * Returns the number of held packets, if any, that were dropped. 425 */ 426 size_t 427 llentry_free(struct llentry *lle) 428 { 429 size_t pkts_dropped; 430 431 LLE_WLOCK_ASSERT(lle); 432 433 KASSERT((lle->la_flags & LLE_LINKED) == 0, ("freeing linked lle")); 434 435 pkts_dropped = lltable_drop_entry_queue(lle); 436 437 /* cancel timer */ 438 if (callout_stop(&lle->lle_timer) > 0) 439 LLE_REMREF(lle); 440 LLE_FREE_LOCKED(lle); 441 442 return (pkts_dropped); 443 } 444 445 /* 446 * Free all entries from given table and free itself. 447 */ 448 449 static int 450 lltable_free_cb(struct lltable *llt, struct llentry *lle, void *farg) 451 { 452 struct llentries *dchain; 453 454 dchain = (struct llentries *)farg; 455 456 LLE_WLOCK(lle); 457 CK_LIST_INSERT_HEAD(dchain, lle, lle_chain); 458 459 return (0); 460 } 461 462 /* 463 * Free all entries from given table and free itself. 464 */ 465 void 466 lltable_free(struct lltable *llt) 467 { 468 struct llentry *lle, *next; 469 struct llentries dchain; 470 471 KASSERT(llt != NULL, ("%s: llt is NULL", __func__)); 472 473 lltable_unlink(llt); 474 475 CK_LIST_INIT(&dchain); 476 IF_AFDATA_WLOCK(llt->llt_ifp); 477 /* Push all lles to @dchain */ 478 lltable_foreach_lle(llt, lltable_free_cb, &dchain); 479 llentries_unlink(llt, &dchain); 480 IF_AFDATA_WUNLOCK(llt->llt_ifp); 481 482 CK_LIST_FOREACH_SAFE(lle, &dchain, lle_chain, next) { 483 llentry_free(lle); 484 } 485 486 llt->llt_free_tbl(llt); 487 } 488 489 /* 490 * Deletes an address from given lltable. 491 * Used for userland interaction to remove 492 * individual entries. Skips entries added by OS. 493 */ 494 int 495 lltable_delete_addr(struct lltable *llt, u_int flags, 496 const struct sockaddr *l3addr) 497 { 498 struct llentry *lle; 499 struct ifnet *ifp; 500 501 ifp = llt->llt_ifp; 502 IF_AFDATA_WLOCK(ifp); 503 lle = lla_lookup(llt, LLE_EXCLUSIVE, l3addr); 504 505 if (lle == NULL) { 506 IF_AFDATA_WUNLOCK(ifp); 507 return (ENOENT); 508 } 509 if ((lle->la_flags & LLE_IFADDR) != 0 && (flags & LLE_IFADDR) == 0) { 510 IF_AFDATA_WUNLOCK(ifp); 511 LLE_WUNLOCK(lle); 512 return (EPERM); 513 } 514 515 lltable_unlink_entry(llt, lle); 516 IF_AFDATA_WUNLOCK(ifp); 517 518 llt->llt_delete_entry(llt, lle); 519 520 return (0); 521 } 522 523 void 524 lltable_prefix_free(int af, struct sockaddr *addr, struct sockaddr *mask, 525 u_int flags) 526 { 527 struct lltable *llt; 528 529 LLTABLE_LIST_RLOCK(); 530 SLIST_FOREACH(llt, &V_lltables, llt_link) { 531 if (llt->llt_af != af) 532 continue; 533 534 llt->llt_prefix_free(llt, addr, mask, flags); 535 } 536 LLTABLE_LIST_RUNLOCK(); 537 } 538 539 struct lltable * 540 lltable_allocate_htbl(uint32_t hsize) 541 { 542 struct lltable *llt; 543 int i; 544 545 llt = malloc(sizeof(struct lltable), M_LLTABLE, M_WAITOK | M_ZERO); 546 llt->llt_hsize = hsize; 547 llt->lle_head = malloc(sizeof(struct llentries) * hsize, 548 M_LLTABLE, M_WAITOK | M_ZERO); 549 550 for (i = 0; i < llt->llt_hsize; i++) 551 CK_LIST_INIT(&llt->lle_head[i]); 552 553 /* Set some default callbacks */ 554 llt->llt_link_entry = htable_link_entry; 555 llt->llt_unlink_entry = htable_unlink_entry; 556 llt->llt_prefix_free = htable_prefix_free; 557 llt->llt_foreach_entry = htable_foreach_lle; 558 llt->llt_free_tbl = htable_free_tbl; 559 560 return (llt); 561 } 562 563 /* 564 * Links lltable to global llt list. 565 */ 566 void 567 lltable_link(struct lltable *llt) 568 { 569 570 LLTABLE_LIST_WLOCK(); 571 SLIST_INSERT_HEAD(&V_lltables, llt, llt_link); 572 LLTABLE_LIST_WUNLOCK(); 573 } 574 575 static void 576 lltable_unlink(struct lltable *llt) 577 { 578 579 LLTABLE_LIST_WLOCK(); 580 SLIST_REMOVE(&V_lltables, llt, lltable, llt_link); 581 LLTABLE_LIST_WUNLOCK(); 582 583 } 584 585 /* 586 * External methods used by lltable consumers 587 */ 588 589 int 590 lltable_foreach_lle(struct lltable *llt, llt_foreach_cb_t *f, void *farg) 591 { 592 593 return (llt->llt_foreach_entry(llt, f, farg)); 594 } 595 596 struct llentry * 597 lltable_alloc_entry(struct lltable *llt, u_int flags, 598 const struct sockaddr *l3addr) 599 { 600 601 return (llt->llt_alloc_entry(llt, flags, l3addr)); 602 } 603 604 void 605 lltable_free_entry(struct lltable *llt, struct llentry *lle) 606 { 607 608 llt->llt_free_entry(llt, lle); 609 } 610 611 void 612 lltable_link_entry(struct lltable *llt, struct llentry *lle) 613 { 614 615 llt->llt_link_entry(llt, lle); 616 } 617 618 void 619 lltable_unlink_entry(struct lltable *llt, struct llentry *lle) 620 { 621 622 llt->llt_unlink_entry(lle); 623 } 624 625 void 626 lltable_fill_sa_entry(const struct llentry *lle, struct sockaddr *sa) 627 { 628 struct lltable *llt; 629 630 llt = lle->lle_tbl; 631 llt->llt_fill_sa_entry(lle, sa); 632 } 633 634 struct ifnet * 635 lltable_get_ifp(const struct lltable *llt) 636 { 637 638 return (llt->llt_ifp); 639 } 640 641 int 642 lltable_get_af(const struct lltable *llt) 643 { 644 645 return (llt->llt_af); 646 } 647 648 /* 649 * Called in route_output when rtm_flags contains RTF_LLDATA. 650 */ 651 int 652 lla_rt_output(struct rt_msghdr *rtm, struct rt_addrinfo *info) 653 { 654 struct sockaddr_dl *dl = 655 (struct sockaddr_dl *)info->rti_info[RTAX_GATEWAY]; 656 struct sockaddr *dst = (struct sockaddr *)info->rti_info[RTAX_DST]; 657 struct ifnet *ifp; 658 struct lltable *llt; 659 struct llentry *lle, *lle_tmp; 660 uint8_t linkhdr[LLE_MAX_LINKHDR]; 661 size_t linkhdrsize; 662 int lladdr_off; 663 u_int laflags = 0; 664 int error; 665 666 if (dl == NULL || dl->sdl_family != AF_LINK) 667 return (EINVAL); 668 669 ifp = ifnet_byindex(dl->sdl_index); 670 if (ifp == NULL) { 671 log(LOG_INFO, "%s: invalid ifp (sdl_index %d)\n", 672 __func__, dl->sdl_index); 673 return EINVAL; 674 } 675 676 /* XXX linked list may be too expensive */ 677 LLTABLE_LIST_RLOCK(); 678 SLIST_FOREACH(llt, &V_lltables, llt_link) { 679 if (llt->llt_af == dst->sa_family && 680 llt->llt_ifp == ifp) 681 break; 682 } 683 LLTABLE_LIST_RUNLOCK(); 684 if (llt == NULL) 685 return (ESRCH); 686 687 error = 0; 688 689 switch (rtm->rtm_type) { 690 case RTM_ADD: 691 /* Add static LLE */ 692 laflags = 0; 693 if (rtm->rtm_rmx.rmx_expire == 0) 694 laflags = LLE_STATIC; 695 lle = lltable_alloc_entry(llt, laflags, dst); 696 if (lle == NULL) 697 return (ENOMEM); 698 699 linkhdrsize = sizeof(linkhdr); 700 if (lltable_calc_llheader(ifp, dst->sa_family, LLADDR(dl), 701 linkhdr, &linkhdrsize, &lladdr_off) != 0) 702 return (EINVAL); 703 lltable_set_entry_addr(ifp, lle, linkhdr, linkhdrsize, 704 lladdr_off); 705 if ((rtm->rtm_flags & RTF_ANNOUNCE)) 706 lle->la_flags |= LLE_PUB; 707 lle->la_expire = rtm->rtm_rmx.rmx_expire; 708 709 laflags = lle->la_flags; 710 711 /* Try to link new entry */ 712 lle_tmp = NULL; 713 IF_AFDATA_WLOCK(ifp); 714 LLE_WLOCK(lle); 715 lle_tmp = lla_lookup(llt, LLE_EXCLUSIVE, dst); 716 if (lle_tmp != NULL) { 717 /* Check if we are trying to replace immutable entry */ 718 if ((lle_tmp->la_flags & LLE_IFADDR) != 0) { 719 IF_AFDATA_WUNLOCK(ifp); 720 LLE_WUNLOCK(lle_tmp); 721 lltable_free_entry(llt, lle); 722 return (EPERM); 723 } 724 /* Unlink existing entry from table */ 725 lltable_unlink_entry(llt, lle_tmp); 726 } 727 lltable_link_entry(llt, lle); 728 IF_AFDATA_WUNLOCK(ifp); 729 730 if (lle_tmp != NULL) { 731 EVENTHANDLER_INVOKE(lle_event, lle_tmp,LLENTRY_EXPIRED); 732 lltable_free_entry(llt, lle_tmp); 733 } 734 735 /* 736 * By invoking LLE handler here we might get 737 * two events on static LLE entry insertion 738 * in routing socket. However, since we might have 739 * other subscribers we need to generate this event. 740 */ 741 EVENTHANDLER_INVOKE(lle_event, lle, LLENTRY_RESOLVED); 742 LLE_WUNLOCK(lle); 743 #ifdef INET 744 /* gratuitous ARP */ 745 if ((laflags & LLE_PUB) && dst->sa_family == AF_INET) 746 arprequest(ifp, 747 &((struct sockaddr_in *)dst)->sin_addr, 748 &((struct sockaddr_in *)dst)->sin_addr, 749 (u_char *)LLADDR(dl)); 750 #endif 751 752 break; 753 754 case RTM_DELETE: 755 return (lltable_delete_addr(llt, 0, dst)); 756 757 default: 758 error = EINVAL; 759 } 760 761 return (error); 762 } 763 764 #ifdef DDB 765 struct llentry_sa { 766 struct llentry base; 767 struct sockaddr l3_addr; 768 }; 769 770 static void 771 llatbl_lle_show(struct llentry_sa *la) 772 { 773 struct llentry *lle; 774 uint8_t octet[6]; 775 776 lle = &la->base; 777 db_printf("lle=%p\n", lle); 778 db_printf(" lle_next=%p\n", lle->lle_next.cle_next); 779 db_printf(" lle_lock=%p\n", &lle->lle_lock); 780 db_printf(" lle_tbl=%p\n", lle->lle_tbl); 781 db_printf(" lle_head=%p\n", lle->lle_head); 782 db_printf(" la_hold=%p\n", lle->la_hold); 783 db_printf(" la_numheld=%d\n", lle->la_numheld); 784 db_printf(" la_expire=%ju\n", (uintmax_t)lle->la_expire); 785 db_printf(" la_flags=0x%04x\n", lle->la_flags); 786 db_printf(" la_asked=%u\n", lle->la_asked); 787 db_printf(" la_preempt=%u\n", lle->la_preempt); 788 db_printf(" ln_state=%d\n", lle->ln_state); 789 db_printf(" ln_router=%u\n", lle->ln_router); 790 db_printf(" ln_ntick=%ju\n", (uintmax_t)lle->ln_ntick); 791 db_printf(" lle_refcnt=%d\n", lle->lle_refcnt); 792 bcopy(lle->ll_addr, octet, sizeof(octet)); 793 db_printf(" ll_addr=%02x:%02x:%02x:%02x:%02x:%02x\n", 794 octet[0], octet[1], octet[2], octet[3], octet[4], octet[5]); 795 db_printf(" lle_timer=%p\n", &lle->lle_timer); 796 797 switch (la->l3_addr.sa_family) { 798 #ifdef INET 799 case AF_INET: 800 { 801 struct sockaddr_in *sin; 802 char l3s[INET_ADDRSTRLEN]; 803 804 sin = (struct sockaddr_in *)&la->l3_addr; 805 inet_ntoa_r(sin->sin_addr, l3s); 806 db_printf(" l3_addr=%s\n", l3s); 807 break; 808 } 809 #endif 810 #ifdef INET6 811 case AF_INET6: 812 { 813 struct sockaddr_in6 *sin6; 814 char l3s[INET6_ADDRSTRLEN]; 815 816 sin6 = (struct sockaddr_in6 *)&la->l3_addr; 817 ip6_sprintf(l3s, &sin6->sin6_addr); 818 db_printf(" l3_addr=%s\n", l3s); 819 break; 820 } 821 #endif 822 default: 823 db_printf(" l3_addr=N/A (af=%d)\n", la->l3_addr.sa_family); 824 break; 825 } 826 } 827 828 DB_SHOW_COMMAND(llentry, db_show_llentry) 829 { 830 831 if (!have_addr) { 832 db_printf("usage: show llentry <struct llentry *>\n"); 833 return; 834 } 835 836 llatbl_lle_show((struct llentry_sa *)addr); 837 } 838 839 static void 840 llatbl_llt_show(struct lltable *llt) 841 { 842 int i; 843 struct llentry *lle; 844 845 db_printf("llt=%p llt_af=%d llt_ifp=%p\n", 846 llt, llt->llt_af, llt->llt_ifp); 847 848 for (i = 0; i < llt->llt_hsize; i++) { 849 CK_LIST_FOREACH(lle, &llt->lle_head[i], lle_next) { 850 851 llatbl_lle_show((struct llentry_sa *)lle); 852 if (db_pager_quit) 853 return; 854 } 855 } 856 } 857 858 DB_SHOW_COMMAND(lltable, db_show_lltable) 859 { 860 861 if (!have_addr) { 862 db_printf("usage: show lltable <struct lltable *>\n"); 863 return; 864 } 865 866 llatbl_llt_show((struct lltable *)addr); 867 } 868 869 DB_SHOW_ALL_COMMAND(lltables, db_show_all_lltables) 870 { 871 VNET_ITERATOR_DECL(vnet_iter); 872 struct lltable *llt; 873 874 VNET_FOREACH(vnet_iter) { 875 CURVNET_SET_QUIET(vnet_iter); 876 #ifdef VIMAGE 877 db_printf("vnet=%p\n", curvnet); 878 #endif 879 SLIST_FOREACH(llt, &V_lltables, llt_link) { 880 db_printf("llt=%p llt_af=%d llt_ifp=%p(%s)\n", 881 llt, llt->llt_af, llt->llt_ifp, 882 (llt->llt_ifp != NULL) ? 883 llt->llt_ifp->if_xname : "?"); 884 if (have_addr && addr != 0) /* verbose */ 885 llatbl_llt_show(llt); 886 if (db_pager_quit) { 887 CURVNET_RESTORE(); 888 return; 889 } 890 } 891 CURVNET_RESTORE(); 892 } 893 } 894 #endif 895