if_llatbl.c revision 331643
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 331643 2018-03-27 18:52:27Z dim $"); 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 LLE_FREE_LOCKED(lle); 433 434 return (pkts_dropped); 435} 436 437/* 438 * (al)locate an llentry for address dst (equivalent to rtalloc for new-arp). 439 * 440 * If found the llentry * is returned referenced and unlocked. 441 */ 442struct llentry * 443llentry_alloc(struct ifnet *ifp, struct lltable *lt, 444 struct sockaddr_storage *dst) 445{ 446 struct llentry *la, *la_tmp; 447 448 IF_AFDATA_RLOCK(ifp); 449 la = lla_lookup(lt, LLE_EXCLUSIVE, (struct sockaddr *)dst); 450 IF_AFDATA_RUNLOCK(ifp); 451 452 if (la != NULL) { 453 LLE_ADDREF(la); 454 LLE_WUNLOCK(la); 455 return (la); 456 } 457 458 if ((ifp->if_flags & (IFF_NOARP | IFF_STATICARP)) == 0) { 459 la = lltable_alloc_entry(lt, 0, (struct sockaddr *)dst); 460 if (la == NULL) 461 return (NULL); 462 IF_AFDATA_WLOCK(ifp); 463 LLE_WLOCK(la); 464 /* Prefer any existing LLE over newly-created one */ 465 la_tmp = lla_lookup(lt, LLE_EXCLUSIVE, (struct sockaddr *)dst); 466 if (la_tmp == NULL) 467 lltable_link_entry(lt, la); 468 IF_AFDATA_WUNLOCK(ifp); 469 if (la_tmp != NULL) { 470 lltable_free_entry(lt, la); 471 la = la_tmp; 472 } 473 LLE_ADDREF(la); 474 LLE_WUNLOCK(la); 475 } 476 477 return (la); 478} 479 480/* 481 * Free all entries from given table and free itself. 482 */ 483 484static int 485lltable_free_cb(struct lltable *llt, struct llentry *lle, void *farg) 486{ 487 struct llentries *dchain; 488 489 dchain = (struct llentries *)farg; 490 491 LLE_WLOCK(lle); 492 LIST_INSERT_HEAD(dchain, lle, lle_chain); 493 494 return (0); 495} 496 497/* 498 * Free all entries from given table and free itself. 499 */ 500void 501lltable_free(struct lltable *llt) 502{ 503 struct llentry *lle, *next; 504 struct llentries dchain; 505 506 KASSERT(llt != NULL, ("%s: llt is NULL", __func__)); 507 508 lltable_unlink(llt); 509 510 LIST_INIT(&dchain); 511 IF_AFDATA_WLOCK(llt->llt_ifp); 512 /* Push all lles to @dchain */ 513 lltable_foreach_lle(llt, lltable_free_cb, &dchain); 514 llentries_unlink(llt, &dchain); 515 IF_AFDATA_WUNLOCK(llt->llt_ifp); 516 517 LIST_FOREACH_SAFE(lle, &dchain, lle_chain, next) { 518 if (callout_stop(&lle->lle_timer) > 0) 519 LLE_REMREF(lle); 520 llentry_free(lle); 521 } 522 523 llt->llt_free_tbl(llt); 524} 525 526#if 0 527void 528lltable_drain(int af) 529{ 530 struct lltable *llt; 531 struct llentry *lle; 532 int i; 533 534 LLTABLE_RLOCK(); 535 SLIST_FOREACH(llt, &V_lltables, llt_link) { 536 if (llt->llt_af != af) 537 continue; 538 539 for (i=0; i < llt->llt_hsize; i++) { 540 LIST_FOREACH(lle, &llt->lle_head[i], lle_next) { 541 LLE_WLOCK(lle); 542 if (lle->la_hold) { 543 m_freem(lle->la_hold); 544 lle->la_hold = NULL; 545 } 546 LLE_WUNLOCK(lle); 547 } 548 } 549 } 550 LLTABLE_RUNLOCK(); 551} 552#endif 553 554/* 555 * Deletes an address from given lltable. 556 * Used for userland interaction to remove 557 * individual entries. Skips entries added by OS. 558 */ 559int 560lltable_delete_addr(struct lltable *llt, u_int flags, 561 const struct sockaddr *l3addr) 562{ 563 struct llentry *lle; 564 struct ifnet *ifp; 565 566 ifp = llt->llt_ifp; 567 IF_AFDATA_WLOCK(ifp); 568 lle = lla_lookup(llt, LLE_EXCLUSIVE, l3addr); 569 570 if (lle == NULL) { 571 IF_AFDATA_WUNLOCK(ifp); 572 return (ENOENT); 573 } 574 if ((lle->la_flags & LLE_IFADDR) != 0 && (flags & LLE_IFADDR) == 0) { 575 IF_AFDATA_WUNLOCK(ifp); 576 LLE_WUNLOCK(lle); 577 return (EPERM); 578 } 579 580 lltable_unlink_entry(llt, lle); 581 IF_AFDATA_WUNLOCK(ifp); 582 583 llt->llt_delete_entry(llt, lle); 584 585 return (0); 586} 587 588void 589lltable_prefix_free(int af, struct sockaddr *addr, struct sockaddr *mask, 590 u_int flags) 591{ 592 struct lltable *llt; 593 594 LLTABLE_RLOCK(); 595 SLIST_FOREACH(llt, &V_lltables, llt_link) { 596 if (llt->llt_af != af) 597 continue; 598 599 llt->llt_prefix_free(llt, addr, mask, flags); 600 } 601 LLTABLE_RUNLOCK(); 602} 603 604struct lltable * 605lltable_allocate_htbl(uint32_t hsize) 606{ 607 struct lltable *llt; 608 int i; 609 610 llt = malloc(sizeof(struct lltable), M_LLTABLE, M_WAITOK | M_ZERO); 611 llt->llt_hsize = hsize; 612 llt->lle_head = malloc(sizeof(struct llentries) * hsize, 613 M_LLTABLE, M_WAITOK | M_ZERO); 614 615 for (i = 0; i < llt->llt_hsize; i++) 616 LIST_INIT(&llt->lle_head[i]); 617 618 /* Set some default callbacks */ 619 llt->llt_link_entry = htable_link_entry; 620 llt->llt_unlink_entry = htable_unlink_entry; 621 llt->llt_prefix_free = htable_prefix_free; 622 llt->llt_foreach_entry = htable_foreach_lle; 623 llt->llt_free_tbl = htable_free_tbl; 624 625 return (llt); 626} 627 628/* 629 * Links lltable to global llt list. 630 */ 631void 632lltable_link(struct lltable *llt) 633{ 634 635 LLTABLE_WLOCK(); 636 SLIST_INSERT_HEAD(&V_lltables, llt, llt_link); 637 LLTABLE_WUNLOCK(); 638} 639 640static void 641lltable_unlink(struct lltable *llt) 642{ 643 644 LLTABLE_WLOCK(); 645 SLIST_REMOVE(&V_lltables, llt, lltable, llt_link); 646 LLTABLE_WUNLOCK(); 647 648} 649 650/* 651 * External methods used by lltable consumers 652 */ 653 654int 655lltable_foreach_lle(struct lltable *llt, llt_foreach_cb_t *f, void *farg) 656{ 657 658 return (llt->llt_foreach_entry(llt, f, farg)); 659} 660 661struct llentry * 662lltable_alloc_entry(struct lltable *llt, u_int flags, 663 const struct sockaddr *l3addr) 664{ 665 666 return (llt->llt_alloc_entry(llt, flags, l3addr)); 667} 668 669void 670lltable_free_entry(struct lltable *llt, struct llentry *lle) 671{ 672 673 llt->llt_free_entry(llt, lle); 674} 675 676void 677lltable_link_entry(struct lltable *llt, struct llentry *lle) 678{ 679 680 llt->llt_link_entry(llt, lle); 681} 682 683void 684lltable_unlink_entry(struct lltable *llt, struct llentry *lle) 685{ 686 687 llt->llt_unlink_entry(lle); 688} 689 690void 691lltable_fill_sa_entry(const struct llentry *lle, struct sockaddr *sa) 692{ 693 struct lltable *llt; 694 695 llt = lle->lle_tbl; 696 llt->llt_fill_sa_entry(lle, sa); 697} 698 699struct ifnet * 700lltable_get_ifp(const struct lltable *llt) 701{ 702 703 return (llt->llt_ifp); 704} 705 706int 707lltable_get_af(const struct lltable *llt) 708{ 709 710 return (llt->llt_af); 711} 712 713/* 714 * Called in route_output when rtm_flags contains RTF_LLDATA. 715 */ 716int 717lla_rt_output(struct rt_msghdr *rtm, struct rt_addrinfo *info) 718{ 719 struct sockaddr_dl *dl = 720 (struct sockaddr_dl *)info->rti_info[RTAX_GATEWAY]; 721 struct sockaddr *dst = (struct sockaddr *)info->rti_info[RTAX_DST]; 722 struct ifnet *ifp; 723 struct lltable *llt; 724 struct llentry *lle, *lle_tmp; 725 uint8_t linkhdr[LLE_MAX_LINKHDR]; 726 size_t linkhdrsize; 727 int lladdr_off; 728 u_int laflags = 0; 729 int error; 730 731 KASSERT(dl != NULL && dl->sdl_family == AF_LINK, 732 ("%s: invalid dl\n", __func__)); 733 734 ifp = ifnet_byindex(dl->sdl_index); 735 if (ifp == NULL) { 736 log(LOG_INFO, "%s: invalid ifp (sdl_index %d)\n", 737 __func__, dl->sdl_index); 738 return EINVAL; 739 } 740 741 /* XXX linked list may be too expensive */ 742 LLTABLE_RLOCK(); 743 SLIST_FOREACH(llt, &V_lltables, llt_link) { 744 if (llt->llt_af == dst->sa_family && 745 llt->llt_ifp == ifp) 746 break; 747 } 748 LLTABLE_RUNLOCK(); 749 KASSERT(llt != NULL, ("Yep, ugly hacks are bad\n")); 750 751 error = 0; 752 753 switch (rtm->rtm_type) { 754 case RTM_ADD: 755 /* Add static LLE */ 756 laflags = 0; 757 if (rtm->rtm_rmx.rmx_expire == 0) 758 laflags = LLE_STATIC; 759 lle = lltable_alloc_entry(llt, laflags, dst); 760 if (lle == NULL) 761 return (ENOMEM); 762 763 linkhdrsize = sizeof(linkhdr); 764 if (lltable_calc_llheader(ifp, dst->sa_family, LLADDR(dl), 765 linkhdr, &linkhdrsize, &lladdr_off) != 0) 766 return (EINVAL); 767 lltable_set_entry_addr(ifp, lle, linkhdr, linkhdrsize, 768 lladdr_off); 769 if ((rtm->rtm_flags & RTF_ANNOUNCE)) 770 lle->la_flags |= LLE_PUB; 771 lle->la_expire = rtm->rtm_rmx.rmx_expire; 772 773 laflags = lle->la_flags; 774 775 /* Try to link new entry */ 776 lle_tmp = NULL; 777 IF_AFDATA_WLOCK(ifp); 778 LLE_WLOCK(lle); 779 lle_tmp = lla_lookup(llt, LLE_EXCLUSIVE, dst); 780 if (lle_tmp != NULL) { 781 /* Check if we are trying to replace immutable entry */ 782 if ((lle_tmp->la_flags & LLE_IFADDR) != 0) { 783 IF_AFDATA_WUNLOCK(ifp); 784 LLE_WUNLOCK(lle_tmp); 785 lltable_free_entry(llt, lle); 786 return (EPERM); 787 } 788 /* Unlink existing entry from table */ 789 lltable_unlink_entry(llt, lle_tmp); 790 } 791 lltable_link_entry(llt, lle); 792 IF_AFDATA_WUNLOCK(ifp); 793 794 if (lle_tmp != NULL) { 795 EVENTHANDLER_INVOKE(lle_event, lle_tmp,LLENTRY_EXPIRED); 796 lltable_free_entry(llt, lle_tmp); 797 } 798 799 /* 800 * By invoking LLE handler here we might get 801 * two events on static LLE entry insertion 802 * in routing socket. However, since we might have 803 * other subscribers we need to generate this event. 804 */ 805 EVENTHANDLER_INVOKE(lle_event, lle, LLENTRY_RESOLVED); 806 LLE_WUNLOCK(lle); 807#ifdef INET 808 /* gratuitous ARP */ 809 if ((laflags & LLE_PUB) && dst->sa_family == AF_INET) 810 arprequest(ifp, 811 &((struct sockaddr_in *)dst)->sin_addr, 812 &((struct sockaddr_in *)dst)->sin_addr, 813 (u_char *)LLADDR(dl)); 814#endif 815 816 break; 817 818 case RTM_DELETE: 819 return (lltable_delete_addr(llt, 0, dst)); 820 821 default: 822 error = EINVAL; 823 } 824 825 return (error); 826} 827 828#ifdef DDB 829struct llentry_sa { 830 struct llentry base; 831 struct sockaddr l3_addr; 832}; 833 834static void 835llatbl_lle_show(struct llentry_sa *la) 836{ 837 struct llentry *lle; 838 uint8_t octet[6]; 839 840 lle = &la->base; 841 db_printf("lle=%p\n", lle); 842 db_printf(" lle_next=%p\n", lle->lle_next.le_next); 843 db_printf(" lle_lock=%p\n", &lle->lle_lock); 844 db_printf(" lle_tbl=%p\n", lle->lle_tbl); 845 db_printf(" lle_head=%p\n", lle->lle_head); 846 db_printf(" la_hold=%p\n", lle->la_hold); 847 db_printf(" la_numheld=%d\n", lle->la_numheld); 848 db_printf(" la_expire=%ju\n", (uintmax_t)lle->la_expire); 849 db_printf(" la_flags=0x%04x\n", lle->la_flags); 850 db_printf(" la_asked=%u\n", lle->la_asked); 851 db_printf(" la_preempt=%u\n", lle->la_preempt); 852 db_printf(" ln_state=%d\n", lle->ln_state); 853 db_printf(" ln_router=%u\n", lle->ln_router); 854 db_printf(" ln_ntick=%ju\n", (uintmax_t)lle->ln_ntick); 855 db_printf(" lle_refcnt=%d\n", lle->lle_refcnt); 856 bcopy(lle->ll_addr, octet, sizeof(octet)); 857 db_printf(" ll_addr=%02x:%02x:%02x:%02x:%02x:%02x\n", 858 octet[0], octet[1], octet[2], octet[3], octet[4], octet[5]); 859 db_printf(" lle_timer=%p\n", &lle->lle_timer); 860 861 switch (la->l3_addr.sa_family) { 862#ifdef INET 863 case AF_INET: 864 { 865 struct sockaddr_in *sin; 866 char l3s[INET_ADDRSTRLEN]; 867 868 sin = (struct sockaddr_in *)&la->l3_addr; 869 inet_ntoa_r(sin->sin_addr, l3s); 870 db_printf(" l3_addr=%s\n", l3s); 871 break; 872 } 873#endif 874#ifdef INET6 875 case AF_INET6: 876 { 877 struct sockaddr_in6 *sin6; 878 char l3s[INET6_ADDRSTRLEN]; 879 880 sin6 = (struct sockaddr_in6 *)&la->l3_addr; 881 ip6_sprintf(l3s, &sin6->sin6_addr); 882 db_printf(" l3_addr=%s\n", l3s); 883 break; 884 } 885#endif 886 default: 887 db_printf(" l3_addr=N/A (af=%d)\n", la->l3_addr.sa_family); 888 break; 889 } 890} 891 892DB_SHOW_COMMAND(llentry, db_show_llentry) 893{ 894 895 if (!have_addr) { 896 db_printf("usage: show llentry <struct llentry *>\n"); 897 return; 898 } 899 900 llatbl_lle_show((struct llentry_sa *)addr); 901} 902 903static void 904llatbl_llt_show(struct lltable *llt) 905{ 906 int i; 907 struct llentry *lle; 908 909 db_printf("llt=%p llt_af=%d llt_ifp=%p\n", 910 llt, llt->llt_af, llt->llt_ifp); 911 912 for (i = 0; i < llt->llt_hsize; i++) { 913 LIST_FOREACH(lle, &llt->lle_head[i], lle_next) { 914 915 llatbl_lle_show((struct llentry_sa *)lle); 916 if (db_pager_quit) 917 return; 918 } 919 } 920} 921 922DB_SHOW_COMMAND(lltable, db_show_lltable) 923{ 924 925 if (!have_addr) { 926 db_printf("usage: show lltable <struct lltable *>\n"); 927 return; 928 } 929 930 llatbl_llt_show((struct lltable *)addr); 931} 932 933DB_SHOW_ALL_COMMAND(lltables, db_show_all_lltables) 934{ 935 VNET_ITERATOR_DECL(vnet_iter); 936 struct lltable *llt; 937 938 VNET_FOREACH(vnet_iter) { 939 CURVNET_SET_QUIET(vnet_iter); 940#ifdef VIMAGE 941 db_printf("vnet=%p\n", curvnet); 942#endif 943 SLIST_FOREACH(llt, &V_lltables, llt_link) { 944 db_printf("llt=%p llt_af=%d llt_ifp=%p(%s)\n", 945 llt, llt->llt_af, llt->llt_ifp, 946 (llt->llt_ifp != NULL) ? 947 llt->llt_ifp->if_xname : "?"); 948 if (have_addr && addr != 0) /* verbose */ 949 llatbl_llt_show(llt); 950 if (db_pager_quit) { 951 CURVNET_RESTORE(); 952 return; 953 } 954 } 955 CURVNET_RESTORE(); 956 } 957} 958#endif 959