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