if_llatbl.c

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

FreeBSD/Linux Kernel Cross Reference
sys/net/if_llatbl.c
