sys/net/if_llatbl.c

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