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