xref: /illumos-gate/usr/src/uts/common/inet/ip/ip_ndp.c (revision ab82c29b6e890d0f1241f9cd0cefda3430f46bd5)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Copyright (c) 2019, Joyent, Inc.
 */

#include <sys/types.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/strsun.h>
#include <sys/sysmacros.h>
#include <sys/errno.h>
#include <sys/dlpi.h>
#include <sys/socket.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/cmn_err.h>
#include <sys/debug.h>
#include <sys/vtrace.h>
#include <sys/kmem.h>
#include <sys/zone.h>
#include <sys/ethernet.h>
#include <sys/sdt.h>
#include <sys/mac.h>

#include <net/if.h>
#include <net/if_types.h>
#include <net/if_dl.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/ip6.h>
#include <netinet/icmp6.h>

#include <inet/common.h>
#include <inet/mi.h>
#include <inet/mib2.h>
#include <inet/nd.h>
#include <inet/ip.h>
#include <inet/ip_impl.h>
#include <inet/ipclassifier.h>
#include <inet/ip_if.h>
#include <inet/ip_ire.h>
#include <inet/ip_rts.h>
#include <inet/ip6.h>
#include <inet/ip_ndp.h>
#include <inet/sctp_ip.h>
#include <inet/ip_arp.h>
#include <inet/ip2mac_impl.h>

#define	ANNOUNCE_INTERVAL(isv6) \
	(isv6 ? ipst->ips_ip_ndp_unsolicit_interval : \
	ipst->ips_ip_arp_publish_interval)

#define	DEFENSE_INTERVAL(isv6) \
	(isv6 ? ipst->ips_ndp_defend_interval : \
	ipst->ips_arp_defend_interval)

/* Non-tunable probe interval, based on link capabilities */
#define	ILL_PROBE_INTERVAL(ill)	((ill)->ill_note_link ? 150 : 1500)

/*
 * The IPv4 Link Local address space is special; we do extra duplicate checking
 * there, as the entire assignment mechanism rests on random numbers.
 */
#define	IS_IPV4_LL_SPACE(ptr)	(((uchar_t *)ptr)[0] == 169 && \
				((uchar_t *)ptr)[1] == 254)

/*
 * NCE_EXTERNAL_FLAGS_MASK defines the set of ncec_flags that may be passed
 * in to the ncec*add* functions.
 *
 * NCE_F_AUTHORITY means that we ignore any incoming adverts for that
 * mapping (though DAD is performed for the mapping). NCE_F_PUBLISH means
 * that we will respond to requests for the protocol address.
 */
#define	NCE_EXTERNAL_FLAGS_MASK \
	(NCE_F_MYADDR | NCE_F_ISROUTER | NCE_F_NONUD | \
	NCE_F_ANYCAST | NCE_F_UNSOL_ADV | NCE_F_BCAST | NCE_F_MCAST | \
	NCE_F_AUTHORITY | NCE_F_PUBLISH | NCE_F_STATIC)

/*
 * Lock ordering:
 *
 *	ndp_g_lock -> ill_lock -> ncec_lock
 *
 * The ndp_g_lock protects the NCE hash (nce_hash_tbl, NCE_HASH_PTR) and
 * ncec_next.  ncec_lock protects the contents of the NCE (particularly
 * ncec_refcnt).
 */

static	void	nce_cleanup_list(ncec_t *ncec);
static	void	nce_set_ll(ncec_t *ncec, uchar_t *ll_addr);
static	ncec_t	*ncec_lookup_illgrp(ill_t *, const in6_addr_t *,
    ncec_t *);
static	nce_t	*nce_lookup_addr(ill_t *, const in6_addr_t *);
static	int	nce_set_multicast_v6(ill_t *ill, const in6_addr_t *addr,
    uint16_t ncec_flags, nce_t **newnce);
static	int	nce_set_multicast_v4(ill_t *ill, const in_addr_t *dst,
    uint16_t ncec_flags, nce_t **newnce);
static	boolean_t	ndp_xmit(ill_t *ill, uint32_t operation,
    uint8_t *hwaddr, uint_t hwaddr_len, const in6_addr_t *sender,
    const in6_addr_t *target, int flag);
static void	ncec_refhold_locked(ncec_t *);
static boolean_t ill_defend_rate_limit(ill_t *, ncec_t *);
static	void	nce_queue_mp_common(ncec_t *, mblk_t *, boolean_t);
static	int	nce_add_common(ill_t *, uchar_t *, uint_t, const in6_addr_t *,
    uint16_t, uint16_t, nce_t **);
static nce_t *nce_add_impl(ill_t *, ncec_t *, nce_t *, mblk_t *, list_t *);
static nce_t *nce_add(ill_t *, ncec_t *, list_t *);
static void nce_inactive(nce_t *);
extern nce_t	*nce_lookup(ill_t *, const in6_addr_t *);
static nce_t *nce_ill_lookup_then_add(ill_t *, ncec_t *);
static int	nce_add_v6(ill_t *, uchar_t *, uint_t, const in6_addr_t *,
    uint16_t, uint16_t, nce_t **);
static int	nce_add_v4(ill_t *, uchar_t *, uint_t, const in_addr_t *,
    uint16_t, uint16_t, nce_t **);
static int  nce_add_v6_postprocess(nce_t *);
static int  nce_add_v4_postprocess(nce_t *);
static ill_t *nce_resolve_src(ncec_t *, in6_addr_t *);
static clock_t nce_fuzz_interval(clock_t, boolean_t);
static void nce_resolv_ipmp_ok(ncec_t *);
static void nce_walk_common(ill_t *, pfi_t, void *);
static void nce_start_timer(ncec_t *, uint_t);
static nce_t *nce_fastpath_create(ill_t *, ncec_t *);
static void nce_fastpath_trigger(nce_t *);
static nce_t *nce_fastpath(ncec_t *, boolean_t, nce_t *);

#ifdef DEBUG
static void	ncec_trace_cleanup(const ncec_t *);
#endif

#define	NCE_HASH_PTR_V4(ipst, addr)					\
	(&((ipst)->ips_ndp4->nce_hash_tbl[IRE_ADDR_HASH(addr, NCE_TABLE_SIZE)]))

#define	NCE_HASH_PTR_V6(ipst, addr)				 \
	(&((ipst)->ips_ndp6->nce_hash_tbl[NCE_ADDR_HASH_V6(addr, \
		NCE_TABLE_SIZE)]))

extern kmem_cache_t *ncec_cache;
extern kmem_cache_t *nce_cache;

/*
 * Send out a IPv6 (unicast) or IPv4 (broadcast) DAD probe
 * If src_ill is not null, the ncec_addr is bound to src_ill. The
 * src_ill is ignored by nce_dad for IPv4 Neighbor Cache entries where
 * the probe is sent on the ncec_ill (in the non-IPMP case) or the
 * IPMP cast_ill (in the IPMP case).
 *
 * Note that the probe interval is based on the src_ill for IPv6, and
 * the ncec_xmit_interval for IPv4.
 */
static void
nce_dad(ncec_t *ncec, ill_t *src_ill, boolean_t send_probe)
{
	boolean_t dropped;
	uint32_t probe_interval;

	ASSERT(!(ncec->ncec_flags & NCE_F_MCAST));
	ASSERT(!(ncec->ncec_flags & NCE_F_BCAST));
	if (ncec->ncec_ipversion == IPV6_VERSION) {
		dropped = ndp_xmit(src_ill, ND_NEIGHBOR_SOLICIT,
		    ncec->ncec_lladdr, ncec->ncec_lladdr_length,
		    &ipv6_all_zeros, &ncec->ncec_addr, NDP_PROBE);
		probe_interval = ILL_PROBE_INTERVAL(src_ill);
	} else {
		/* IPv4 DAD delay the initial probe. */
		if (send_probe)
			dropped = arp_probe(ncec);
		else
			dropped = B_TRUE;
		probe_interval = nce_fuzz_interval(ncec->ncec_xmit_interval,
		    !send_probe);
	}
	if (!dropped) {
		mutex_enter(&ncec->ncec_lock);
		ncec->ncec_pcnt--;
		mutex_exit(&ncec->ncec_lock);
	}
	nce_restart_timer(ncec, probe_interval);
}

/*
 * Compute default flags to use for an advertisement of this ncec's address.
 */
static int
nce_advert_flags(const ncec_t *ncec)
{
	int flag = 0;

	if (ncec->ncec_flags & NCE_F_ISROUTER)
		flag |= NDP_ISROUTER;
	if (!(ncec->ncec_flags & NCE_F_ANYCAST))
		flag |= NDP_ORIDE;

	return (flag);
}

/*
 * NDP Cache Entry creation routine.
 * This routine must always be called with ndp6->ndp_g_lock held.
 */
int
nce_add_v6(ill_t *ill, uchar_t *hw_addr, uint_t hw_addr_len,
    const in6_addr_t *addr, uint16_t flags, uint16_t state, nce_t **newnce)
{
	int		err;
	nce_t		*nce;

	ASSERT(MUTEX_HELD(&ill->ill_ipst->ips_ndp6->ndp_g_lock));
	ASSERT(ill != NULL && ill->ill_isv6);

	err = nce_add_common(ill, hw_addr, hw_addr_len, addr, flags, state,
	    &nce);
	if (err != 0)
		return (err);
	ASSERT(newnce != NULL);
	*newnce = nce;
	return (err);
}

/*
 * Post-processing routine to be executed after nce_add_v6(). This function
 * triggers fastpath (if appropriate) and DAD on the newly added nce entry
 * and must be called without any locks held.
 */
int
nce_add_v6_postprocess(nce_t *nce)
{
	ncec_t		*ncec = nce->nce_common;
	boolean_t	dropped = B_FALSE;
	uchar_t		*hw_addr = ncec->ncec_lladdr;
	uint_t		hw_addr_len = ncec->ncec_lladdr_length;
	ill_t		*ill = ncec->ncec_ill;
	int		err = 0;
	uint16_t	flags = ncec->ncec_flags;
	ip_stack_t	*ipst = ill->ill_ipst;
	boolean_t	trigger_fastpath = B_TRUE;

	/*
	 * If the hw_addr is NULL, typically for ND_INCOMPLETE nces, then
	 * we call nce_fastpath as soon as the ncec is resolved in nce_process.
	 * We call nce_fastpath from nce_update if the link layer address of
	 * the peer changes from nce_update
	 */
	if (NCE_PUBLISH(ncec) || !NCE_ISREACHABLE(ncec) ||
	    (hw_addr == NULL && ill->ill_net_type != IRE_IF_NORESOLVER))
		trigger_fastpath = B_FALSE;

	if (trigger_fastpath)
		nce_fastpath_trigger(nce);
	if (NCE_PUBLISH(ncec) && ncec->ncec_state == ND_PROBE) {
		ill_t *hwaddr_ill;
		/*
		 * Unicast entry that needs DAD.
		 */
		if (IS_IPMP(ill)) {
			hwaddr_ill = ipmp_illgrp_find_ill(ill->ill_grp,
			    hw_addr, hw_addr_len);
		} else {
			hwaddr_ill = ill;
		}
		nce_dad(ncec, hwaddr_ill, B_TRUE);
		err = EINPROGRESS;
	} else if (flags & NCE_F_UNSOL_ADV) {
		/*
		 * We account for the transmit below by assigning one
		 * less than the ndd variable. Subsequent decrements
		 * are done in nce_timer.
		 */
		mutex_enter(&ncec->ncec_lock);
		ncec->ncec_unsolicit_count =
		    ipst->ips_ip_ndp_unsolicit_count - 1;
		mutex_exit(&ncec->ncec_lock);
		dropped = ndp_xmit(ill,
		    ND_NEIGHBOR_ADVERT,
		    hw_addr,
		    hw_addr_len,
		    &ncec->ncec_addr,	/* Source and target of the adv */
		    &ipv6_all_hosts_mcast, /* Destination of the packet */
		    nce_advert_flags(ncec));
		mutex_enter(&ncec->ncec_lock);
		if (dropped)
			ncec->ncec_unsolicit_count++;
		else
			ncec->ncec_last_time_defended = ddi_get_lbolt();
		if (ncec->ncec_unsolicit_count != 0) {
			nce_start_timer(ncec,
			    ipst->ips_ip_ndp_unsolicit_interval);
		}
		mutex_exit(&ncec->ncec_lock);
	}
	return (err);
}

/*
 * Atomically lookup and add (if needed) Neighbor Cache information for
 * an address.
 *
 * IPMP notes: the ncec for non-local (i.e., !NCE_MYADDR(ncec) addresses
 * are always added pointing at the ipmp_ill. Thus, when the ill passed
 * to nce_add_v6 is an under_ill (i.e., IS_UNDER_IPMP(ill)) two nce_t
 * entries will be created, both pointing at the same ncec_t. The nce_t
 * entries will have their nce_ill set to the ipmp_ill and the under_ill
 * respectively, with the ncec_t having its ncec_ill pointing at the ipmp_ill.
 * Local addresses are always created on the ill passed to nce_add_v6.
 */
int
nce_lookup_then_add_v6(ill_t *ill, uchar_t *hw_addr, uint_t hw_addr_len,
    const in6_addr_t *addr, uint16_t flags, uint16_t state, nce_t **newnce)
{
	int		err = 0;
	ip_stack_t	*ipst = ill->ill_ipst;
	nce_t		*nce, *upper_nce = NULL;
	ill_t		*in_ill = ill;
	boolean_t	need_ill_refrele = B_FALSE;

	if (flags & NCE_F_MCAST) {
		/*
		 * hw_addr will be figured out in nce_set_multicast_v6;
		 * caller has to select the cast_ill
		 */
		ASSERT(hw_addr == NULL);
		ASSERT(!IS_IPMP(ill));
		err = nce_set_multicast_v6(ill, addr, flags, newnce);
		return (err);
	}
	ASSERT(ill->ill_isv6);
	if (IS_UNDER_IPMP(ill) && !(flags & NCE_F_MYADDR)) {
		ill = ipmp_ill_hold_ipmp_ill(ill);
		if (ill == NULL)
			return (ENXIO);
		need_ill_refrele = B_TRUE;
	}

	mutex_enter(&ipst->ips_ndp6->ndp_g_lock);
	nce = nce_lookup_addr(ill, addr);
	if (nce == NULL) {
		err = nce_add_v6(ill, hw_addr, hw_addr_len, addr, flags, state,
		    &nce);
	} else {
		err = EEXIST;
	}
	mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
	if (err == 0)
		err = nce_add_v6_postprocess(nce);
	if (in_ill != ill && nce != NULL) {
		nce_t *under_nce = NULL;

		/*
		 * in_ill was the under_ill. Try to create the under_nce.
		 * Hold the ill_g_lock to prevent changes to group membership
		 * until we are done.
		 */
		rw_enter(&ipst->ips_ill_g_lock, RW_READER);
		if (!IS_IN_SAME_ILLGRP(in_ill, ill)) {
			DTRACE_PROBE2(ill__not__in__group, nce_t *, nce,
			    ill_t *, ill);
			rw_exit(&ipst->ips_ill_g_lock);
			err = ENXIO;
			nce_refrele(nce);
			nce = NULL;
			goto bail;
		}
		under_nce = nce_fastpath_create(in_ill, nce->nce_common);
		if (under_nce == NULL) {
			rw_exit(&ipst->ips_ill_g_lock);
			err = EINVAL;
			nce_refrele(nce);
			nce = NULL;
			goto bail;
		}
		rw_exit(&ipst->ips_ill_g_lock);
		upper_nce = nce;
		nce = under_nce; /* will be returned to caller */
		if (NCE_ISREACHABLE(nce->nce_common))
			nce_fastpath_trigger(under_nce);
	}
	/* nce_refrele is deferred until the lock is dropped  */
	if (nce != NULL) {
		if (newnce != NULL)
			*newnce = nce;
		else
			nce_refrele(nce);
	}
bail:
	if (upper_nce != NULL)
		nce_refrele(upper_nce);
	if (need_ill_refrele)
		ill_refrele(ill);
	return (err);
}

/*
 * Remove all the CONDEMNED nces from the appropriate hash table.
 * We create a private list of NCEs, these may have ires pointing
 * to them, so the list will be passed through to clean up dependent
 * ires and only then we can do ncec_refrele() which can make NCE inactive.
 */
static void
nce_remove(ndp_g_t *ndp, ncec_t *ncec, ncec_t **free_nce_list)
{
	ncec_t *ncec1;
	ncec_t **ptpn;

	ASSERT(MUTEX_HELD(&ndp->ndp_g_lock));
	ASSERT(ndp->ndp_g_walker == 0);
	for (; ncec; ncec = ncec1) {
		ncec1 = ncec->ncec_next;
		mutex_enter(&ncec->ncec_lock);
		if (NCE_ISCONDEMNED(ncec)) {
			ptpn = ncec->ncec_ptpn;
			ncec1 = ncec->ncec_next;
			if (ncec1 != NULL)
				ncec1->ncec_ptpn = ptpn;
			*ptpn = ncec1;
			ncec->ncec_ptpn = NULL;
			ncec->ncec_next = NULL;
			ncec->ncec_next = *free_nce_list;
			*free_nce_list = ncec;
		}
		mutex_exit(&ncec->ncec_lock);
	}
}

/*
 * 1. Mark the entry CONDEMNED. This ensures that no new nce_lookup()
 *    will return this NCE. Also no new timeouts will
 *    be started (See nce_restart_timer).
 * 2. Cancel any currently running timeouts.
 * 3. If there is an ndp walker, return. The walker will do the cleanup.
 *    This ensures that walkers see a consistent list of NCEs while walking.
 * 4. Otherwise remove the NCE from the list of NCEs
 */
void
ncec_delete(ncec_t *ncec)
{
	ncec_t	**ptpn;
	ncec_t	*ncec1;
	int	ipversion = ncec->ncec_ipversion;
	ndp_g_t *ndp;
	ip_stack_t	*ipst = ncec->ncec_ipst;

	if (ipversion == IPV4_VERSION)
		ndp = ipst->ips_ndp4;
	else
		ndp = ipst->ips_ndp6;

	/* Serialize deletes */
	mutex_enter(&ncec->ncec_lock);
	if (NCE_ISCONDEMNED(ncec)) {
		/* Some other thread is doing the delete */
		mutex_exit(&ncec->ncec_lock);
		return;
	}
	/*
	 * Caller has a refhold. Also 1 ref for being in the list. Thus
	 * refcnt has to be >= 2
	 */
	ASSERT(ncec->ncec_refcnt >= 2);
	ncec->ncec_flags |= NCE_F_CONDEMNED;
	mutex_exit(&ncec->ncec_lock);

	/* Count how many condemned ires for kmem_cache callback */
	atomic_inc_32(&ipst->ips_num_nce_condemned);
	nce_fastpath_list_delete(ncec->ncec_ill, ncec, NULL);

	/* Complete any waiting callbacks */
	ncec_cb_dispatch(ncec);

	/*
	 * Cancel any running timer. Timeout can't be restarted
	 * since CONDEMNED is set. Can't hold ncec_lock across untimeout.
	 * Passing invalid timeout id is fine.
	 */
	if (ncec->ncec_timeout_id != 0) {
		(void) untimeout(ncec->ncec_timeout_id);
		ncec->ncec_timeout_id = 0;
	}

	mutex_enter(&ndp->ndp_g_lock);
	if (ncec->ncec_ptpn == NULL) {
		/*
		 * The last ndp walker has already removed this ncec from
		 * the list after we marked the ncec CONDEMNED and before
		 * we grabbed the global lock.
		 */
		mutex_exit(&ndp->ndp_g_lock);
		return;
	}
	if (ndp->ndp_g_walker > 0) {
		/*
		 * Can't unlink. The walker will clean up
		 */
		ndp->ndp_g_walker_cleanup = B_TRUE;
		mutex_exit(&ndp->ndp_g_lock);
		return;
	}

	/*
	 * Now remove the ncec from the list. nce_restart_timer won't restart
	 * the timer since it is marked CONDEMNED.
	 */
	ptpn = ncec->ncec_ptpn;
	ncec1 = ncec->ncec_next;
	if (ncec1 != NULL)
		ncec1->ncec_ptpn = ptpn;
	*ptpn = ncec1;
	ncec->ncec_ptpn = NULL;
	ncec->ncec_next = NULL;
	mutex_exit(&ndp->ndp_g_lock);

	/* Removed from ncec_ptpn/ncec_next list */
	ncec_refrele_notr(ncec);
}

void
ncec_inactive(ncec_t *ncec)
{
	mblk_t		**mpp;
	ill_t		*ill = ncec->ncec_ill;
	ip_stack_t	*ipst = ncec->ncec_ipst;

	ASSERT(ncec->ncec_refcnt == 0);
	ASSERT(MUTEX_HELD(&ncec->ncec_lock));

	/* Count how many condemned nces for kmem_cache callback */
	if (NCE_ISCONDEMNED(ncec))
		atomic_add_32(&ipst->ips_num_nce_condemned, -1);

	/* Free all allocated messages */
	mpp = &ncec->ncec_qd_mp;
	while (*mpp != NULL) {
		mblk_t  *mp;

		mp = *mpp;
		*mpp = mp->b_next;

		inet_freemsg(mp);
	}
	/*
	 * must have been cleaned up in ncec_delete
	 */
	ASSERT(list_is_empty(&ncec->ncec_cb));
	list_destroy(&ncec->ncec_cb);
	/*
	 * free the ncec_lladdr if one was allocated in nce_add_common()
	 */
	if (ncec->ncec_lladdr_length > 0)
		kmem_free(ncec->ncec_lladdr, ncec->ncec_lladdr_length);

#ifdef DEBUG
	ncec_trace_cleanup(ncec);
#endif

	mutex_enter(&ill->ill_lock);
	DTRACE_PROBE3(ill__decr__cnt, (ill_t *), ill,
	    (char *), "ncec", (void *), ncec);
	ill->ill_ncec_cnt--;
	ncec->ncec_ill = NULL;
	/*
	 * If the number of ncec's associated with this ill have dropped
	 * to zero, check whether we need to restart any operation that
	 * is waiting for this to happen.
	 */
	if (ILL_DOWN_OK(ill)) {
		/* ipif_ill_refrele_tail drops the ill_lock */
		ipif_ill_refrele_tail(ill);
	} else {
		mutex_exit(&ill->ill_lock);
	}

	mutex_destroy(&ncec->ncec_lock);
	kmem_cache_free(ncec_cache, ncec);
}

/*
 * ncec_walk routine.  Delete the ncec if it is associated with the ill
 * that is going away.  Always called as a writer.
 */
void
ncec_delete_per_ill(ncec_t *ncec, void *arg)
{
	if ((ncec != NULL) && ncec->ncec_ill == arg) {
		ncec_delete(ncec);
	}
}

/*
 * Neighbor Cache cleanup logic for a list of ncec_t entries.
 */
static void
nce_cleanup_list(ncec_t *ncec)
{
	ncec_t *ncec_next;

	ASSERT(ncec != NULL);
	while (ncec != NULL) {
		ncec_next = ncec->ncec_next;
		ncec->ncec_next = NULL;

		/*
		 * It is possible for the last ndp walker (this thread)
		 * to come here after ncec_delete has marked the ncec CONDEMNED
		 * and before it has removed the ncec from the fastpath list
		 * or called untimeout. So we need to do it here. It is safe
		 * for both ncec_delete and this thread to do it twice or
		 * even simultaneously since each of the threads has a
		 * reference on the ncec.
		 */
		nce_fastpath_list_delete(ncec->ncec_ill, ncec, NULL);
		/*
		 * Cancel any running timer. Timeout can't be restarted
		 * since CONDEMNED is set. The ncec_lock can't be
		 * held across untimeout though passing invalid timeout
		 * id is fine.
		 */
		if (ncec->ncec_timeout_id != 0) {
			(void) untimeout(ncec->ncec_timeout_id);
			ncec->ncec_timeout_id = 0;
		}
		/* Removed from ncec_ptpn/ncec_next list */
		ncec_refrele_notr(ncec);
		ncec = ncec_next;
	}
}

/*
 * Restart DAD on given NCE.  Returns B_TRUE if DAD has been restarted.
 */
boolean_t
nce_restart_dad(ncec_t *ncec)
{
	boolean_t started;
	ill_t *ill, *hwaddr_ill;

	if (ncec == NULL)
		return (B_FALSE);
	ill = ncec->ncec_ill;
	mutex_enter(&ncec->ncec_lock);
	if (ncec->ncec_state == ND_PROBE) {
		mutex_exit(&ncec->ncec_lock);
		started = B_TRUE;
	} else if (ncec->ncec_state == ND_REACHABLE) {
		ASSERT(ncec->ncec_lladdr != NULL);
		ncec->ncec_state = ND_PROBE;
		ncec->ncec_pcnt = ND_MAX_UNICAST_SOLICIT;
		/*
		 * Slight cheat here: we don't use the initial probe delay
		 * for IPv4 in this obscure case.
		 */
		mutex_exit(&ncec->ncec_lock);
		if (IS_IPMP(ill)) {
			hwaddr_ill = ipmp_illgrp_find_ill(ill->ill_grp,
			    ncec->ncec_lladdr, ncec->ncec_lladdr_length);
		} else {
			hwaddr_ill = ill;
		}
		nce_dad(ncec, hwaddr_ill, B_TRUE);
		started = B_TRUE;
	} else {
		mutex_exit(&ncec->ncec_lock);
		started = B_FALSE;
	}
	return (started);
}

/*
 * IPv6 Cache entry lookup.  Try to find an ncec matching the parameters passed.
 * If one is found, the refcnt on the ncec will be incremented.
 */
ncec_t *
ncec_lookup_illgrp_v6(ill_t *ill, const in6_addr_t *addr)
{
	ncec_t		*ncec;
	ip_stack_t	*ipst = ill->ill_ipst;

	rw_enter(&ipst->ips_ill_g_lock, RW_READER);
	mutex_enter(&ipst->ips_ndp6->ndp_g_lock);

	/* Get head of v6 hash table */
	ncec = *((ncec_t **)NCE_HASH_PTR_V6(ipst, *addr));
	ncec = ncec_lookup_illgrp(ill, addr, ncec);
	mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
	rw_exit(&ipst->ips_ill_g_lock);
	return (ncec);
}
/*
 * IPv4 Cache entry lookup.  Try to find an ncec matching the parameters passed.
 * If one is found, the refcnt on the ncec will be incremented.
 */
ncec_t *
ncec_lookup_illgrp_v4(ill_t *ill, const in_addr_t *addr)
{
	ncec_t	*ncec = NULL;
	in6_addr_t addr6;
	ip_stack_t *ipst = ill->ill_ipst;

	rw_enter(&ipst->ips_ill_g_lock, RW_READER);
	mutex_enter(&ipst->ips_ndp4->ndp_g_lock);

	/* Get head of v4 hash table */
	ncec = *((ncec_t **)NCE_HASH_PTR_V4(ipst, *addr));
	IN6_IPADDR_TO_V4MAPPED(*addr, &addr6);
	ncec = ncec_lookup_illgrp(ill, &addr6, ncec);
	mutex_exit(&ipst->ips_ndp4->ndp_g_lock);
	rw_exit(&ipst->ips_ill_g_lock);
	return (ncec);
}

/*
 * Cache entry lookup.  Try to find an ncec matching the parameters passed.
 * If an ncec is found, increment the hold count on that ncec.
 * The caller passes in the start of the appropriate hash table, and must
 * be holding the appropriate global lock (ndp_g_lock). In addition, since
 * this function matches ncec_t entries across the illgrp, the ips_ill_g_lock
 * must be held as reader.
 *
 * This function always matches across the ipmp group.
 */
ncec_t *
ncec_lookup_illgrp(ill_t *ill, const in6_addr_t *addr, ncec_t *ncec)
{
	ndp_g_t		*ndp;
	ip_stack_t	*ipst = ill->ill_ipst;

	if (ill->ill_isv6)
		ndp = ipst->ips_ndp6;
	else
		ndp = ipst->ips_ndp4;

	ASSERT(ill != NULL);
	ASSERT(MUTEX_HELD(&ndp->ndp_g_lock));
	if (IN6_IS_ADDR_UNSPECIFIED(addr))
		return (NULL);
	for (; ncec != NULL; ncec = ncec->ncec_next) {
		if (ncec->ncec_ill == ill ||
		    IS_IN_SAME_ILLGRP(ill, ncec->ncec_ill)) {
			if (IN6_ARE_ADDR_EQUAL(&ncec->ncec_addr, addr)) {
				mutex_enter(&ncec->ncec_lock);
				if (!NCE_ISCONDEMNED(ncec)) {
					ncec_refhold_locked(ncec);
					mutex_exit(&ncec->ncec_lock);
					break;
				}
				mutex_exit(&ncec->ncec_lock);
			}
		}
	}
	return (ncec);
}

/*
 * Find an nce_t on ill with nce_addr == addr. Lookup the nce_t
 * entries for ill only, i.e., when ill is part of an ipmp group,
 * nce_lookup_v4 will never try to match across the group.
 */
nce_t *
nce_lookup_v4(ill_t *ill, const in_addr_t *addr)
{
	nce_t *nce;
	in6_addr_t addr6;
	ip_stack_t *ipst = ill->ill_ipst;

	mutex_enter(&ipst->ips_ndp4->ndp_g_lock);
	IN6_IPADDR_TO_V4MAPPED(*addr, &addr6);
	nce = nce_lookup_addr(ill, &addr6);
	mutex_exit(&ipst->ips_ndp4->ndp_g_lock);
	return (nce);
}

/*
 * Find an nce_t on ill with nce_addr == addr. Lookup the nce_t
 * entries for ill only, i.e., when ill is part of an ipmp group,
 * nce_lookup_v6 will never try to match across the group.
 */
nce_t *
nce_lookup_v6(ill_t *ill, const in6_addr_t *addr6)
{
	nce_t *nce;
	ip_stack_t *ipst = ill->ill_ipst;

	mutex_enter(&ipst->ips_ndp6->ndp_g_lock);
	nce = nce_lookup_addr(ill, addr6);
	mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
	return (nce);
}

static nce_t *
nce_lookup_addr(ill_t *ill, const in6_addr_t *addr)
{
	nce_t *nce;

	ASSERT(ill != NULL);
#ifdef DEBUG
	if (ill->ill_isv6)
		ASSERT(MUTEX_HELD(&ill->ill_ipst->ips_ndp6->ndp_g_lock));
	else
		ASSERT(MUTEX_HELD(&ill->ill_ipst->ips_ndp4->ndp_g_lock));
#endif
	mutex_enter(&ill->ill_lock);
	nce = nce_lookup(ill, addr);
	mutex_exit(&ill->ill_lock);
	return (nce);
}


/*
 * Router turned to host.  We need to make sure that cached copies of the ncec
 * are not used for forwarding packets if they were derived from the default
 * route, and that the default route itself is removed, as  required by
 * section 7.2.5 of RFC 2461.
 *
 * Note that the ncec itself probably has valid link-layer information for the
 * nexthop, so that there is no reason to delete the ncec, as long as the
 * ISROUTER flag is turned off.
 */
static void
ncec_router_to_host(ncec_t *ncec)
{
	ire_t		*ire;
	ip_stack_t	*ipst = ncec->ncec_ipst;

	mutex_enter(&ncec->ncec_lock);
	ncec->ncec_flags &= ~NCE_F_ISROUTER;
	mutex_exit(&ncec->ncec_lock);

	ire = ire_ftable_lookup_v6(&ipv6_all_zeros, &ipv6_all_zeros,
	    &ncec->ncec_addr, IRE_DEFAULT, ncec->ncec_ill, ALL_ZONES, NULL,
	    MATCH_IRE_ILL | MATCH_IRE_TYPE | MATCH_IRE_GW, 0, ipst, NULL);
	if (ire != NULL) {
		ip_rts_rtmsg(RTM_DELETE, ire, 0, ipst);
		ire_delete(ire);
		ire_refrele(ire);
	}
}

/*
 * Process passed in parameters either from an incoming packet or via
 * user ioctl.
 */
void
nce_process(ncec_t *ncec, uchar_t *hw_addr, uint32_t flag, boolean_t is_adv)
{
	ill_t	*ill = ncec->ncec_ill;
	uint32_t hw_addr_len = ill->ill_phys_addr_length;
	boolean_t ll_updated = B_FALSE;
	boolean_t ll_changed;
	nce_t	*nce;

	ASSERT(ncec->ncec_ipversion == IPV6_VERSION);
	/*
	 * No updates of link layer address or the neighbor state is
	 * allowed, when the cache is in NONUD state.  This still
	 * allows for responding to reachability solicitation.
	 */
	mutex_enter(&ncec->ncec_lock);
	if (ncec->ncec_state == ND_INCOMPLETE) {
		if (hw_addr == NULL) {
			mutex_exit(&ncec->ncec_lock);
			return;
		}
		nce_set_ll(ncec, hw_addr);
		/*
		 * Update ncec state and send the queued packets
		 * back to ip this time ire will be added.
		 */
		if (flag & ND_NA_FLAG_SOLICITED) {
			nce_update(ncec, ND_REACHABLE, NULL);
		} else {
			nce_update(ncec, ND_STALE, NULL);
		}
		mutex_exit(&ncec->ncec_lock);
		nce = nce_fastpath(ncec, B_TRUE, NULL);
		nce_resolv_ok(ncec);
		if (nce != NULL)
			nce_refrele(nce);
		return;
	}
	ll_changed = nce_cmp_ll_addr(ncec, hw_addr, hw_addr_len);
	if (!is_adv) {
		/* If this is a SOLICITATION request only */
		if (ll_changed)
			nce_update(ncec, ND_STALE, hw_addr);
		mutex_exit(&ncec->ncec_lock);
		ncec_cb_dispatch(ncec);
		return;
	}
	if (!(flag & ND_NA_FLAG_OVERRIDE) && ll_changed) {
		/* If in any other state than REACHABLE, ignore */
		if (ncec->ncec_state == ND_REACHABLE) {
			nce_update(ncec, ND_STALE, NULL);
		}
		mutex_exit(&ncec->ncec_lock);
		ncec_cb_dispatch(ncec);
		return;
	} else {
		if (ll_changed) {
			nce_update(ncec, ND_UNCHANGED, hw_addr);
			ll_updated = B_TRUE;
		}
		if (flag & ND_NA_FLAG_SOLICITED) {
			nce_update(ncec, ND_REACHABLE, NULL);
		} else {
			if (ll_updated) {
				nce_update(ncec, ND_STALE, NULL);
			}
		}
		mutex_exit(&ncec->ncec_lock);
		if (!(flag & ND_NA_FLAG_ROUTER) && (ncec->ncec_flags &
		    NCE_F_ISROUTER)) {
			ncec_router_to_host(ncec);
		} else {
			ncec_cb_dispatch(ncec);
		}
	}
}

/*
 * Pass arg1 to the cbf supplied, along with each ncec in existence.
 * ncec_walk() places a REFHOLD on the ncec and drops the lock when
 * walking the hash list.
 */
void
ncec_walk_common(ndp_g_t *ndp, ill_t *ill, ncec_walk_cb_t cbf,
    void *arg1, boolean_t trace)
{
	ncec_t	*ncec;
	ncec_t	*ncec1;
	ncec_t	**ncep;
	ncec_t	*free_nce_list = NULL;

	mutex_enter(&ndp->ndp_g_lock);
	/* Prevent ncec_delete from unlink and free of NCE */
	ndp->ndp_g_walker++;
	mutex_exit(&ndp->ndp_g_lock);
	for (ncep = ndp->nce_hash_tbl;
	    ncep < A_END(ndp->nce_hash_tbl); ncep++) {
		for (ncec = *ncep; ncec != NULL; ncec = ncec1) {
			ncec1 = ncec->ncec_next;
			if (ill == NULL || ncec->ncec_ill == ill) {
				if (trace) {
					ncec_refhold(ncec);
					(*cbf)(ncec, arg1);
					ncec_refrele(ncec);
				} else {
					ncec_refhold_notr(ncec);
					(*cbf)(ncec, arg1);
					ncec_refrele_notr(ncec);
				}
			}
		}
	}
	mutex_enter(&ndp->ndp_g_lock);
	ndp->ndp_g_walker--;
	if (ndp->ndp_g_walker_cleanup && ndp->ndp_g_walker == 0) {
		/* Time to delete condemned entries */
		for (ncep = ndp->nce_hash_tbl;
		    ncep < A_END(ndp->nce_hash_tbl); ncep++) {
			ncec = *ncep;
			if (ncec != NULL) {
				nce_remove(ndp, ncec, &free_nce_list);
			}
		}
		ndp->ndp_g_walker_cleanup = B_FALSE;
	}

	mutex_exit(&ndp->ndp_g_lock);

	if (free_nce_list != NULL) {
		nce_cleanup_list(free_nce_list);
	}
}

/*
 * Walk everything.
 * Note that ill can be NULL hence can't derive the ipst from it.
 */
void
ncec_walk(ill_t *ill, ncec_walk_cb_t cbf, void *arg1, ip_stack_t *ipst)
{
	ncec_walk_common(ipst->ips_ndp4, ill, cbf, arg1, B_TRUE);
	ncec_walk_common(ipst->ips_ndp6, ill, cbf, arg1, B_TRUE);
}

/*
 * Cheesy globals (i.e. all netstacks) for both a limit on per-ill multicast
 * NCEs, and the number to reclaim if we hit the limit.  Used by
 * nce_set_multicast_v[46]() to limit the linked-list length of ill_nce. Until
 * we solve the multicast-mappings-shouldn't-be-NCEs problem, use this.
 */

/* Maximum number of multicast NCEs on an ill. */
uint_t ip_max_ill_mcast_nces = 16384;
/*
 * Number of NCEs to delete if we hit the maximum above.  0 means *don't* and
 * return an error.  Non-zero means delete so many, and if the number is >=
 * the max above, that means delete them all.
 */
uint_t ip_ill_mcast_reclaim = 256;

/*
 * Encapsulate multicast ill capping in a function, for easier DTrace
 * detections.  Return a list of refheld NCEs to destroy-via-refrele.  That
 * list can be NULL, but can only be non-NULL if we successfully reclaimed.
 *
 * NOTE:  This function must be called while holding the ill_lock AND
 * JUST PRIOR to making the insertion into the ill_nce list.
 *
 * We can't release the ones we delete ourselves because the ill_lock is held
 * by the caller. They are, instead, passed back in a list_t for deletion
 * outside of the ill_lock hold. nce_graveyard_free() actually frees them.
 *
 * While this covers nce_t, ncec_t gets done even further down the road.  See
 * nce_graveyard_free() for why.
 */
static boolean_t
nce_too_many_mcast(ill_t *ill, list_t *graveyard)
{
	uint_t reclaim_count, max_count, reclaimed = 0;
	boolean_t too_many;
	nce_t *nce, *deadman;

	ASSERT(graveyard != NULL);
	ASSERT(list_is_empty(graveyard));
	ASSERT(MUTEX_HELD(&ill->ill_lock));

	/*
	 * NOTE: Some grinning weirdo may have lowered the global max beyond
	 * what this ill currently has.  The behavior in this case will be
	 * trim-back just by the reclaim amount for any new ones.
	 */
	max_count = ip_max_ill_mcast_nces;
	reclaim_count = min(ip_ill_mcast_reclaim, max_count);

	/* All good? */
	if (ill->ill_mcast_nces < max_count)
		return (B_FALSE);	/* Yes, all good. */

	if (reclaim_count == 0)
		return (B_TRUE);	/* Don't bother - we're stuck. */

	/* We need to reclaim now.  Exploit our held ill_lock. */

	/*
	 * Start at the tail and work backwards, new nces are head-inserted,
	 * so we'll be reaping the oldest entries.
	 */
	nce = list_tail(&ill->ill_nce);
	while (reclaimed < reclaim_count) {
		/* Skip ahead to a multicast NCE. */
		while (nce != NULL &&
		    (nce->nce_common->ncec_flags & NCE_F_MCAST) == 0) {
			nce = list_prev(&ill->ill_nce, nce);
		}
		if (nce == NULL)
			break;

		/*
		 * NOTE: For now, we just delete the first one(s) we find.
		 * This is not optimal, and may require some inspection of nce
		 * & its ncec to be better.
		 */
		deadman = nce;
		nce = list_prev(&ill->ill_nce, nce);

		/* nce_delete() requires caller holds... */
		nce_refhold(deadman);
		nce_delete(deadman);	/* Bumps down ill_mcast_nces. */

		/* Link the dead ones singly, still refheld... */
		list_insert_tail(graveyard, deadman);
		reclaimed++;
	}

	if (reclaimed != reclaim_count) {
		/* We didn't have enough to reach reclaim_count. Why?!? */
		DTRACE_PROBE3(ill__mcast__nce__reclaim__mismatch, ill_t *, ill,
		    uint_t, reclaimed, uint_t, reclaim_count);

		/* In case for some REALLY weird reason we found none! */
		too_many = (reclaimed == 0);
	} else {
		too_many = B_FALSE;
	}

	return (too_many);
}

static void
ncec_mcast_reap_one(ncec_t *ncec, void *arg)
{
	boolean_t reapit;
	ill_t *ill = (ill_t *)arg;

	/* Obvious no-lock-needed checks... */
	if (ncec == NULL || ncec->ncec_ill != ill ||
	    (ncec->ncec_flags & NCE_F_MCAST) == 0)
		return;

	mutex_enter(&ncec->ncec_lock);
	/*
	 * It's refheld by the walk infrastructure. It has one reference for
	 * being in the ndp_g_hash, and if an nce_t exists, that's one more.
	 * We want ones without an nce_t, so 2 is the magic number.  If it's
	 * LESS than 2, we have much bigger problems anyway.
	 */
	ASSERT(ncec->ncec_refcnt >= 2);
	reapit = (ncec->ncec_refcnt == 2);
	mutex_exit(&ncec->ncec_lock);

	if (reapit) {
		IP_STAT(ill->ill_ipst, ip_nce_mcast_reclaim_deleted);
		ncec_delete(ncec);
	}
}

/*
 * Attempt to reap stray multicast ncec_t structures left in the wake of
 * nce_graveyard_free(). This is a taskq servicing routine, as it's well
 * outside any netstack-global locks being held - ndp_g_lock in this case.  We
 * have a reference hold on the ill, which will prevent any unplumbing races.
 */
static void
ncec_mcast_reap(void *arg)
{
	ill_t *ill = (ill_t *)arg;

	IP_STAT(ill->ill_ipst, ip_nce_mcast_reclaim_calls);
	ncec_walk(ill, ncec_mcast_reap_one, ill, ill->ill_ipst);
	mutex_enter(&ill->ill_lock);
	ill->ill_mcast_ncec_cleanup = B_FALSE;
	/*
	 * Inline a _notr() version of ill_refrele. See nce_graveyard_free()
	 * below for why.
	 */
	ill->ill_refcnt--;
	if (ill->ill_refcnt == 0)
		ipif_ill_refrele_tail(ill);	/* Drops ill_lock. */
	else
		mutex_exit(&ill->ill_lock);
}

/*
 * Free a list (including handling an empty list or NULL list) of
 * reference-held NCEs that were reaped from a nce_too_many_mcast()
 * call. Separate because the caller must have dropped ndp_g_lock first.
 *
 * This also schedules a taskq task to unlink underlying NCECs from the
 * ndp_g_hash, which are protected by ndp_g_lock.
 */
static void
nce_graveyard_free(list_t *graveyard)
{
	nce_t *deadman, *current;
	ill_t *ill;
	boolean_t doit;

	if (graveyard == NULL)
		return;

	current = list_head(graveyard);
	if (current == NULL) {
		list_destroy(graveyard);
		return;
	}

	ill = current->nce_ill;
	/*
	 * Normally one should ill_refhold(ill) here.  There's no _notr()
	 * variant like there is for ire_t, dce_t, or even ncec_t, but this is
	 * the ONLY case that'll break the mh_trace that IP debugging uses for
	 * reference counts (i.e. they assume same thread releases as
	 * holds). Instead, we inline ill_refhold() here.  We must do the same
	 * in the release done by the ncec_mcast_reap() above.
	 */
	mutex_enter(&ill->ill_lock);
	ill->ill_refcnt++;
	mutex_exit(&ill->ill_lock);

	while (current != NULL) {
		ASSERT3P(ill, ==, current->nce_ill);
		deadman = current;
		current = list_next(graveyard, deadman);
		list_remove(graveyard, deadman);
		ASSERT3U((deadman->nce_common->ncec_flags & NCE_F_MCAST), !=,
		    0);
		nce_refrele(deadman);
	}
	list_destroy(graveyard);

	mutex_enter(&ill->ill_lock);
	if (ill->ill_mcast_ncec_cleanup)
		doit = B_FALSE;
	else {
		ill->ill_mcast_ncec_cleanup = B_TRUE;
		doit = B_TRUE;
	}
	mutex_exit(&ill->ill_lock);
	if (!doit || taskq_dispatch(system_taskq, ncec_mcast_reap,
	    ill, TQ_NOSLEEP) == TASKQID_INVALID) {
		mutex_enter(&ill->ill_lock);
		if (doit) {
			IP_STAT(ill->ill_ipst, ip_nce_mcast_reclaim_tqfail);
			ill->ill_mcast_ncec_cleanup = B_FALSE;
		}
		/* There's no _notr() for ill_refrele(), so inline it here. */
		ill->ill_refcnt--;
		if (ill->ill_refcnt == 0)
			ipif_ill_refrele_tail(ill);	/* Drops ill_lock */
		else
			mutex_exit(&ill->ill_lock);
	}
}

/*
 * For each interface an entry is added for the unspecified multicast group.
 * Here that mapping is used to form the multicast cache entry for a particular
 * multicast destination.
 */
static int
nce_set_multicast_v6(ill_t *ill, const in6_addr_t *dst,
    uint16_t flags, nce_t **newnce)
{
	uchar_t		*hw_addr;
	int		err = 0;
	ip_stack_t	*ipst = ill->ill_ipst;
	nce_t		*nce;

	ASSERT(ill != NULL);
	ASSERT(ill->ill_isv6);
	ASSERT(!(IN6_IS_ADDR_UNSPECIFIED(dst)));

	mutex_enter(&ipst->ips_ndp6->ndp_g_lock);
	nce = nce_lookup_addr(ill, dst);
	if (nce != NULL) {
		mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
		goto done;
	}
	if (ill->ill_net_type == IRE_IF_RESOLVER) {
		/*
		 * For IRE_IF_RESOLVER a hardware mapping can be
		 * generated.
		 */
		hw_addr = kmem_alloc(ill->ill_nd_lla_len, KM_NOSLEEP);
		if (hw_addr == NULL) {
			mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
			return (ENOMEM);
		}
		ip_mcast_mapping(ill, (uchar_t *)dst, hw_addr);
	} else {
		/* No hw_addr is needed for IRE_IF_NORESOLVER. */
		hw_addr = NULL;
	}
	ASSERT((flags & NCE_F_MCAST) != 0);
	ASSERT((flags & NCE_F_NONUD) != 0);
	/* nce_state will be computed by nce_add_common() */
	err = nce_add_v6(ill, hw_addr, ill->ill_phys_addr_length, dst, flags,
	    ND_UNCHANGED, &nce);
	mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
	if (err == 0)
		err = (nce != NULL) ? nce_add_v6_postprocess(nce) : ENOMEM;
	if (hw_addr != NULL)
		kmem_free(hw_addr, ill->ill_nd_lla_len);
	if (err != 0) {
		ip1dbg(("nce_set_multicast_v6: create failed" "%d\n", err));
		return (err);
	}
done:
	ASSERT(nce->nce_common->ncec_state == ND_REACHABLE);
	if (newnce != NULL)
		*newnce = nce;
	else
		nce_refrele(nce);
	return (0);
}

/*
 * Return the link layer address, and any flags of a ncec.
 */
int
ndp_query(ill_t *ill, struct lif_nd_req *lnr)
{
	ncec_t		*ncec;
	in6_addr_t	*addr;
	sin6_t		*sin6;

	ASSERT(ill != NULL && ill->ill_isv6);
	sin6 = (sin6_t *)&lnr->lnr_addr;
	addr =  &sin6->sin6_addr;

	/*
	 * NOTE: if the ill is an IPMP interface, then match against the whole
	 * illgrp.  This e.g. allows in.ndpd to retrieve the link layer
	 * addresses for the data addresses on an IPMP interface even though
	 * ipif_ndp_up() created them with an ncec_ill of ipif_bound_ill.
	 */
	ncec = ncec_lookup_illgrp_v6(ill, addr);
	if (ncec == NULL)
		return (ESRCH);
	/* If no link layer address is available yet, return ESRCH */
	if (!NCE_ISREACHABLE(ncec)) {
		ncec_refrele(ncec);
		return (ESRCH);
	}
	lnr->lnr_hdw_len = ill->ill_phys_addr_length;
	bcopy(ncec->ncec_lladdr, (uchar_t *)&lnr->lnr_hdw_addr,
	    lnr->lnr_hdw_len);
	if (ncec->ncec_flags & NCE_F_ISROUTER)
		lnr->lnr_flags = NDF_ISROUTER_ON;
	if (ncec->ncec_flags & NCE_F_ANYCAST)
		lnr->lnr_flags |= NDF_ANYCAST_ON;
	if (ncec->ncec_flags & NCE_F_STATIC)
		lnr->lnr_flags |= NDF_STATIC;
	ncec_refrele(ncec);
	return (0);
}

/*
 * Finish setting up the Enable/Disable multicast for the driver.
 */
mblk_t *
ndp_mcastreq(ill_t *ill, const in6_addr_t *v6group, uint32_t hw_addr_len,
    uint32_t hw_addr_offset, mblk_t *mp)
{
	uchar_t		*hw_addr;
	ipaddr_t	v4group;
	uchar_t		*addr;

	ASSERT(ill->ill_net_type == IRE_IF_RESOLVER);
	if (IN6_IS_ADDR_V4MAPPED(v6group)) {
		IN6_V4MAPPED_TO_IPADDR(v6group, v4group);

		ASSERT(CLASSD(v4group));
		ASSERT(!(ill->ill_isv6));

		addr = (uchar_t *)&v4group;
	} else {
		ASSERT(IN6_IS_ADDR_MULTICAST(v6group));
		ASSERT(ill->ill_isv6);

		addr = (uchar_t *)v6group;
	}
	hw_addr = mi_offset_paramc(mp, hw_addr_offset, hw_addr_len);
	if (hw_addr == NULL) {
		ip0dbg(("ndp_mcastreq NULL hw_addr\n"));
		freemsg(mp);
		return (NULL);
	}

	ip_mcast_mapping(ill, addr, hw_addr);
	return (mp);
}

void
ip_ndp_resolve(ncec_t *ncec)
{
	in_addr_t	sender4 = INADDR_ANY;
	in6_addr_t	sender6 = ipv6_all_zeros;
	ill_t		*src_ill;
	uint32_t	ms;

	src_ill = nce_resolve_src(ncec, &sender6);
	if (src_ill == NULL) {
		/* Make sure we try again later */
		ms = ncec->ncec_ill->ill_reachable_retrans_time;
		nce_restart_timer(ncec, (clock_t)ms);
		return;
	}
	if (ncec->ncec_ipversion == IPV4_VERSION)
		IN6_V4MAPPED_TO_IPADDR(&sender6, sender4);
	mutex_enter(&ncec->ncec_lock);
	if (ncec->ncec_ipversion == IPV6_VERSION)
		ms = ndp_solicit(ncec, sender6, src_ill);
	else
		ms = arp_request(ncec, sender4, src_ill);
	mutex_exit(&ncec->ncec_lock);
	if (ms == 0) {
		if (ncec->ncec_state != ND_REACHABLE) {
			if (ncec->ncec_ipversion == IPV6_VERSION)
				ndp_resolv_failed(ncec);
			else
				arp_resolv_failed(ncec);
			ASSERT((ncec->ncec_flags & NCE_F_STATIC) == 0);
			nce_make_unreachable(ncec);
			ncec_delete(ncec);
		}
	} else {
		nce_restart_timer(ncec, (clock_t)ms);
	}
done:
	ill_refrele(src_ill);
}

/*
 * Send an IPv6 neighbor solicitation.
 * Returns number of milliseconds after which we should either rexmit or abort.
 * Return of zero means we should abort.
 * The caller holds the ncec_lock to protect ncec_qd_mp and ncec_rcnt.
 * The optional source address is used as a hint to ndp_solicit for
 * which source to use in the packet.
 *
 * NOTE: This routine drops ncec_lock (and later reacquires it) when sending
 * the packet.
 */
uint32_t
ndp_solicit(ncec_t *ncec, in6_addr_t src, ill_t *ill)
{
	in6_addr_t	dst;
	boolean_t	dropped = B_FALSE;

	ASSERT(ncec->ncec_ipversion == IPV6_VERSION);
	ASSERT(MUTEX_HELD(&ncec->ncec_lock));

	if (ncec->ncec_rcnt == 0)
		return (0);

	dst = ncec->ncec_addr;
	ncec->ncec_rcnt--;
	mutex_exit(&ncec->ncec_lock);
	dropped = ndp_xmit(ill, ND_NEIGHBOR_SOLICIT, ill->ill_phys_addr,
	    ill->ill_phys_addr_length, &src, &dst, 0);
	mutex_enter(&ncec->ncec_lock);
	if (dropped)
		ncec->ncec_rcnt++;
	return (ncec->ncec_ill->ill_reachable_retrans_time);
}

/*
 * Attempt to recover an address on an interface that's been marked as a
 * duplicate.  Because NCEs are destroyed when the interface goes down, there's
 * no easy way to just probe the address and have the right thing happen if
 * it's no longer in use.  Instead, we just bring it up normally and allow the
 * regular interface start-up logic to probe for a remaining duplicate and take
 * us back down if necessary.
 * Neither DHCP nor temporary addresses arrive here; they're excluded by
 * ip_ndp_excl.
 */
/* ARGSUSED */
void
ip_addr_recover(ipsq_t *ipsq, queue_t *rq, mblk_t *mp, void *dummy_arg)
{
	ill_t	*ill = rq->q_ptr;
	ipif_t	*ipif;
	in6_addr_t *addr6 = (in6_addr_t *)mp->b_rptr;
	in_addr_t *addr4 = (in_addr_t *)mp->b_rptr;
	boolean_t addr_equal;

	for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
		/*
		 * We do not support recovery of proxy ARP'd interfaces,
		 * because the system lacks a complete proxy ARP mechanism.
		 */
		if (ill->ill_isv6) {
			addr_equal = IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6lcl_addr,
			    addr6);
		} else {
			addr_equal = (ipif->ipif_lcl_addr == *addr4);
		}

		if ((ipif->ipif_flags & IPIF_POINTOPOINT) || !addr_equal)
			continue;

		/*
		 * If we have already recovered or if the interface is going
		 * away, then ignore.
		 */
		mutex_enter(&ill->ill_lock);
		if (!(ipif->ipif_flags & IPIF_DUPLICATE) ||
		    (ipif->ipif_state_flags & IPIF_CONDEMNED)) {
			mutex_exit(&ill->ill_lock);
			continue;
		}

		ipif->ipif_flags &= ~IPIF_DUPLICATE;
		ill->ill_ipif_dup_count--;
		mutex_exit(&ill->ill_lock);
		ipif->ipif_was_dup = B_TRUE;

		if (ill->ill_isv6) {
			VERIFY(ipif_ndp_up(ipif, B_TRUE) != EINPROGRESS);
			(void) ipif_up_done_v6(ipif);
		} else {
			VERIFY(ipif_arp_up(ipif, Res_act_initial, B_TRUE) !=
			    EINPROGRESS);
			(void) ipif_up_done(ipif);
		}
	}
	freeb(mp);
}

/*
 * Attempt to recover an IPv6 interface that's been shut down as a duplicate.
 * As long as someone else holds the address, the interface will stay down.
 * When that conflict goes away, the interface is brought back up.  This is
 * done so that accidental shutdowns of addresses aren't made permanent.  Your
 * server will recover from a failure.
 *
 * For DHCP and temporary addresses, recovery is not done in the kernel.
 * Instead, it's handled by user space processes (dhcpagent and in.ndpd).
 *
 * This function is entered on a timer expiry; the ID is in ipif_recovery_id.
 */
void
ipif_dup_recovery(void *arg)
{
	ipif_t *ipif = arg;

	ipif->ipif_recovery_id = 0;
	if (!(ipif->ipif_flags & IPIF_DUPLICATE))
		return;

	/*
	 * No lock, because this is just an optimization.
	 */
	if (ipif->ipif_state_flags & IPIF_CONDEMNED)
		return;

	/* If the link is down, we'll retry this later */
	if (!(ipif->ipif_ill->ill_phyint->phyint_flags & PHYI_RUNNING))
		return;

	ipif_do_recovery(ipif);
}

/*
 * Perform interface recovery by forcing the duplicate interfaces up and
 * allowing the system to determine which ones should stay up.
 *
 * Called both by recovery timer expiry and link-up notification.
 */
void
ipif_do_recovery(ipif_t *ipif)
{
	ill_t *ill = ipif->ipif_ill;
	mblk_t *mp;
	ip_stack_t *ipst = ill->ill_ipst;
	size_t mp_size;

	if (ipif->ipif_isv6)
		mp_size = sizeof (ipif->ipif_v6lcl_addr);
	else
		mp_size = sizeof (ipif->ipif_lcl_addr);
	mp = allocb(mp_size, BPRI_MED);
	if (mp == NULL) {
		mutex_enter(&ill->ill_lock);
		if (ipst->ips_ip_dup_recovery > 0 &&
		    ipif->ipif_recovery_id == 0 &&
		    !(ipif->ipif_state_flags & IPIF_CONDEMNED)) {
			ipif->ipif_recovery_id = timeout(ipif_dup_recovery,
			    ipif, MSEC_TO_TICK(ipst->ips_ip_dup_recovery));
		}
		mutex_exit(&ill->ill_lock);
	} else {
		/*
		 * A recovery timer may still be running if we got here from
		 * ill_restart_dad(); cancel that timer.
		 */
		if (ipif->ipif_recovery_id != 0)
			(void) untimeout(ipif->ipif_recovery_id);
		ipif->ipif_recovery_id = 0;

		if (ipif->ipif_isv6) {
			bcopy(&ipif->ipif_v6lcl_addr, mp->b_rptr,
			    sizeof (ipif->ipif_v6lcl_addr));
		} else  {
			bcopy(&ipif->ipif_lcl_addr, mp->b_rptr,
			    sizeof (ipif->ipif_lcl_addr));
		}
		ill_refhold(ill);
		qwriter_ip(ill, ill->ill_rq, mp, ip_addr_recover, NEW_OP,
		    B_FALSE);
	}
}

/*
 * Find the MAC and IP addresses in an NA/NS message.
 */
static void
ip_ndp_find_addresses(mblk_t *mp, ip_recv_attr_t *ira, ill_t *ill,
    in6_addr_t *targp, uchar_t **haddr, uint_t *haddrlenp)
{
	icmp6_t *icmp6 = (icmp6_t *)(mp->b_rptr + IPV6_HDR_LEN);
	nd_neighbor_solicit_t *ns = (nd_neighbor_solicit_t *)icmp6;
	uchar_t *addr;
	int alen;

	/* icmp_inbound_v6 ensures this */
	ASSERT(ira->ira_flags & IRAF_L2SRC_SET);

	addr = ira->ira_l2src;
	alen = ill->ill_phys_addr_length;
	if (alen > 0) {
		*haddr = addr;
		*haddrlenp = alen;
	} else {
		*haddr = NULL;
		*haddrlenp = 0;
	}

	/* nd_ns_target and nd_na_target are at the same offset, so we cheat */
	*targp = ns->nd_ns_target;
}

/*
 * This is for exclusive changes due to NDP duplicate address detection
 * failure.
 */
/* ARGSUSED */
static void
ip_ndp_excl(ipsq_t *ipsq, queue_t *rq, mblk_t *mp, void *dummy_arg)
{
	ill_t	*ill = rq->q_ptr;
	ipif_t	*ipif;
	uchar_t	*haddr;
	uint_t	haddrlen;
	ip_stack_t *ipst = ill->ill_ipst;
	in6_addr_t targ;
	ip_recv_attr_t iras;
	mblk_t	*attrmp;

	attrmp = mp;
	mp = mp->b_cont;
	attrmp->b_cont = NULL;
	if (!ip_recv_attr_from_mblk(attrmp, &iras)) {
		/* The ill or ip_stack_t disappeared on us */
		BUMP_MIB(ill->ill_ip_mib, ipIfStatsInDiscards);
		ip_drop_input("ip_recv_attr_from_mblk", mp, ill);
		freemsg(mp);
		ira_cleanup(&iras, B_TRUE);
		return;
	}

	ASSERT(ill == iras.ira_rill);

	ip_ndp_find_addresses(mp, &iras, ill, &targ, &haddr, &haddrlen);
	if (haddr != NULL && haddrlen == ill->ill_phys_addr_length) {
		/*
		 * Ignore conflicts generated by misbehaving switches that
		 * just reflect our own messages back to us.  For IPMP, we may
		 * see reflections across any ill in the illgrp.
		 *
		 * RFC2462 and revisions tried to detect both the case
		 * when a statically configured IPv6 address is a duplicate,
		 * and the case when the L2 address itself is a duplicate. The
		 * later is important because, with stateles address autoconf,
		 * if the L2 address is a duplicate, the resulting IPv6
		 * address(es) would also be duplicates. We rely on DAD of the
		 * IPv6 address itself to detect the latter case.
		 */
		/* For an under ill_grp can change under lock */
		rw_enter(&ipst->ips_ill_g_lock, RW_READER);
		if (bcmp(haddr, ill->ill_phys_addr, haddrlen) == 0 ||
		    IS_UNDER_IPMP(ill) &&
		    ipmp_illgrp_find_ill(ill->ill_grp, haddr,
		    haddrlen) != NULL) {
			rw_exit(&ipst->ips_ill_g_lock);
			goto ignore_conflict;
		}
		rw_exit(&ipst->ips_ill_g_lock);
	}

	/*
	 * Look up the appropriate ipif.
	 */
	ipif = ipif_lookup_addr_v6(&targ, ill, ALL_ZONES, ipst);
	if (ipif == NULL)
		goto ignore_conflict;

	/* Reload the ill to match the ipif */
	ill = ipif->ipif_ill;

	/* If it's already duplicate or ineligible, then don't do anything. */
	if (ipif->ipif_flags & (IPIF_POINTOPOINT|IPIF_DUPLICATE)) {
		ipif_refrele(ipif);
		goto ignore_conflict;
	}

	/*
	 * If this is a failure during duplicate recovery, then don't
	 * complain.  It may take a long time to recover.
	 */
	if (!ipif->ipif_was_dup) {
		char ibuf[LIFNAMSIZ];
		char hbuf[MAC_STR_LEN];
		char sbuf[INET6_ADDRSTRLEN];

		ipif_get_name(ipif, ibuf, sizeof (ibuf));
		cmn_err(CE_WARN, "%s has duplicate address %s (in use by %s);"
		    " disabled", ibuf,
		    inet_ntop(AF_INET6, &targ, sbuf, sizeof (sbuf)),
		    mac_colon_addr(haddr, haddrlen, hbuf, sizeof (hbuf)));
	}
	mutex_enter(&ill->ill_lock);
	ASSERT(!(ipif->ipif_flags & IPIF_DUPLICATE));
	ipif->ipif_flags |= IPIF_DUPLICATE;
	ill->ill_ipif_dup_count++;
	mutex_exit(&ill->ill_lock);
	(void) ipif_down(ipif, NULL, NULL);
	(void) ipif_down_tail(ipif);
	mutex_enter(&ill->ill_lock);
	if (!(ipif->ipif_flags & (IPIF_DHCPRUNNING|IPIF_TEMPORARY)) &&
	    ill->ill_net_type == IRE_IF_RESOLVER &&
	    !(ipif->ipif_state_flags & IPIF_CONDEMNED) &&
	    ipst->ips_ip_dup_recovery > 0) {
		ASSERT(ipif->ipif_recovery_id == 0);
		ipif->ipif_recovery_id = timeout(ipif_dup_recovery,
		    ipif, MSEC_TO_TICK(ipst->ips_ip_dup_recovery));
	}
	mutex_exit(&ill->ill_lock);
	ipif_refrele(ipif);

ignore_conflict:
	freemsg(mp);
	ira_cleanup(&iras, B_TRUE);
}

/*
 * Handle failure by tearing down the ipifs with the specified address.  Note
 * that tearing down the ipif also means deleting the ncec through ipif_down, so
 * it's not possible to do recovery by just restarting the ncec timer.  Instead,
 * we start a timer on the ipif.
 * Caller has to free mp;
 */
static void
ndp_failure(mblk_t *mp, ip_recv_attr_t *ira)
{
	const uchar_t	*haddr;
	ill_t		*ill = ira->ira_rill;

	/*
	 * Ignore conflicts generated by misbehaving switches that just
	 * reflect our own messages back to us.
	 */

	/* icmp_inbound_v6 ensures this */
	ASSERT(ira->ira_flags & IRAF_L2SRC_SET);
	haddr = ira->ira_l2src;
	if (haddr != NULL &&
	    bcmp(haddr, ill->ill_phys_addr, ill->ill_phys_addr_length) == 0) {
		return;
	}

	if ((mp = copymsg(mp)) != NULL) {
		mblk_t	*attrmp;

		attrmp = ip_recv_attr_to_mblk(ira);
		if (attrmp == NULL) {
			BUMP_MIB(ill->ill_ip_mib, ipIfStatsInDiscards);
			ip_drop_input("ipIfStatsInDiscards", mp, ill);
			freemsg(mp);
		} else {
			ASSERT(attrmp->b_cont == NULL);
			attrmp->b_cont = mp;
			mp = attrmp;
			ill_refhold(ill);
			qwriter_ip(ill, ill->ill_rq, mp, ip_ndp_excl, NEW_OP,
			    B_FALSE);
		}
	}
}

/*
 * Handle a discovered conflict: some other system is advertising that it owns
 * one of our IP addresses.  We need to defend ourselves, or just shut down the
 * interface.
 *
 * Handles both IPv4 and IPv6
 */
boolean_t
ip_nce_conflict(mblk_t *mp, ip_recv_attr_t *ira, ncec_t *ncec)
{
	ipif_t		*ipif;
	clock_t		now;
	uint_t		maxdefense;
	uint_t		defs;
	ill_t		*ill = ira->ira_ill;
	ip_stack_t	*ipst = ill->ill_ipst;
	uint32_t	elapsed;
	boolean_t	isv6 = ill->ill_isv6;
	ipaddr_t	ncec_addr;

	if (isv6) {
		ipif = ipif_lookup_addr_v6(&ncec->ncec_addr, ill, ALL_ZONES,
		    ipst);
	} else {
		if (arp_no_defense) {
			/*
			 * Yes, there is a conflict, but no, we do not
			 * defend ourself.
			 */
			return (B_TRUE);
		}
		IN6_V4MAPPED_TO_IPADDR(&ncec->ncec_addr, ncec_addr);
		ipif = ipif_lookup_addr(ncec_addr, ill, ALL_ZONES,
		    ipst);
	}
	if (ipif == NULL)
		return (B_FALSE);

	/*
	 * First, figure out if this address is disposable.
	 */
	if (ipif->ipif_flags & (IPIF_DHCPRUNNING | IPIF_TEMPORARY))
		maxdefense = ipst->ips_ip_max_temp_defend;
	else
		maxdefense = ipst->ips_ip_max_defend;

	/*
	 * Now figure out how many times we've defended ourselves.  Ignore
	 * defenses that happened long in the past.
	 */
	now = ddi_get_lbolt();
	elapsed = (drv_hztousec(now - ncec->ncec_last_time_defended))/1000000;
	mutex_enter(&ncec->ncec_lock);
	if ((defs = ncec->ncec_defense_count) > 0 &&
	    elapsed > ipst->ips_ip_defend_interval) {
		/*
		 * ip_defend_interval has elapsed.
		 * reset the defense count.
		 */
		ncec->ncec_defense_count = defs = 0;
	}
	ncec->ncec_defense_count++;
	ncec->ncec_last_time_defended = now;
	mutex_exit(&ncec->ncec_lock);
	ipif_refrele(ipif);

	/*
	 * If we've defended ourselves too many times already, then give up and
	 * tear down the interface(s) using this address.
	 * Otherwise, caller has to defend by sending out an announce.
	 */
	if (defs >= maxdefense) {
		if (isv6)
			ndp_failure(mp, ira);
		else
			arp_failure(mp, ira);
	} else {
		return (B_TRUE); /* caller must defend this address */
	}
	return (B_FALSE);
}

/*
 * Handle reception of Neighbor Solicitation messages.
 */
static void
ndp_input_solicit(mblk_t *mp, ip_recv_attr_t *ira)
{
	ill_t		*ill = ira->ira_ill, *under_ill;
	nd_neighbor_solicit_t *ns;
	uint32_t	hlen = ill->ill_phys_addr_length;
	uchar_t		*haddr = NULL;
	icmp6_t		*icmp_nd;
	ip6_t		*ip6h;
	ncec_t		*our_ncec = NULL;
	in6_addr_t	target;
	in6_addr_t	src;
	int		len;
	int		flag = 0;
	nd_opt_hdr_t	*opt = NULL;
	boolean_t	bad_solicit = B_FALSE;
	mib2_ipv6IfIcmpEntry_t	*mib = ill->ill_icmp6_mib;
	boolean_t	need_ill_refrele = B_FALSE;

	ip6h = (ip6_t *)mp->b_rptr;
	icmp_nd = (icmp6_t *)(mp->b_rptr + IPV6_HDR_LEN);
	len = mp->b_wptr - mp->b_rptr - IPV6_HDR_LEN;
	src = ip6h->ip6_src;
	ns = (nd_neighbor_solicit_t *)icmp_nd;
	target = ns->nd_ns_target;
	if (IN6_IS_ADDR_MULTICAST(&target) || IN6_IS_ADDR_V4MAPPED(&target) ||
	    IN6_IS_ADDR_LOOPBACK(&target)) {
		if (ip_debug > 2) {
			/* ip1dbg */
			pr_addr_dbg("ndp_input_solicit: Martian Target %s\n",
			    AF_INET6, &target);
		}
		bad_solicit = B_TRUE;
		goto done;
	}
	if (len > sizeof (nd_neighbor_solicit_t)) {
		/* Options present */
		opt = (nd_opt_hdr_t *)&ns[1];
		len -= sizeof (nd_neighbor_solicit_t);
		if (!ndp_verify_optlen(opt, len)) {
			ip1dbg(("ndp_input_solicit: Bad opt len\n"));
			bad_solicit = B_TRUE;
			goto done;
		}
	}
	if (IN6_IS_ADDR_UNSPECIFIED(&src)) {
		/* Check to see if this is a valid DAD solicitation */
		if (!IN6_IS_ADDR_MC_SOLICITEDNODE(&ip6h->ip6_dst)) {
			if (ip_debug > 2) {
				/* ip1dbg */
				pr_addr_dbg("ndp_input_solicit: IPv6 "
				    "Destination is not solicited node "
				    "multicast %s\n", AF_INET6,
				    &ip6h->ip6_dst);
			}
			bad_solicit = B_TRUE;
			goto done;
		}
	}

	/*
	 * NOTE: with IPMP, it's possible the nominated multicast ill (which
	 * received this packet if it's multicast) is not the ill tied to
	 * e.g. the IPMP ill's data link-local.  So we match across the illgrp
	 * to ensure we find the associated NCE.
	 */
	our_ncec = ncec_lookup_illgrp_v6(ill, &target);
	/*
	 * If this is a valid Solicitation for an address we are publishing,
	 * then a PUBLISH entry should exist in the cache
	 */
	if (our_ncec == NULL || !NCE_PUBLISH(our_ncec)) {
		ip1dbg(("ndp_input_solicit: Wrong target in NS?!"
		    "ifname=%s ", ill->ill_name));
		if (ip_debug > 2) {
			/* ip1dbg */
			pr_addr_dbg(" dst %s\n", AF_INET6, &target);
		}
		if (our_ncec == NULL)
			bad_solicit = B_TRUE;
		goto done;
	}

	/* At this point we should have a verified NS per spec */
	if (opt != NULL) {
		opt = ndp_get_option(opt, len, ND_OPT_SOURCE_LINKADDR);
		if (opt != NULL) {
			haddr = (uchar_t *)&opt[1];
			if (hlen > opt->nd_opt_len * 8 - sizeof (*opt) ||
			    hlen == 0) {
				ip1dbg(("ndp_input_advert: bad SLLA\n"));
				bad_solicit = B_TRUE;
				goto done;
			}
		}
	}

	/* If sending directly to peer, set the unicast flag */
	if (!IN6_IS_ADDR_MULTICAST(&ip6h->ip6_dst))
		flag |= NDP_UNICAST;

	/*
	 * Create/update the entry for the soliciting node on the ipmp_ill.
	 * or respond to outstanding queries, don't if
	 * the source is unspecified address.
	 */
	if (!IN6_IS_ADDR_UNSPECIFIED(&src)) {
		int	err;
		nce_t	*nnce;

		ASSERT(ill->ill_isv6);
		/*
		 * Regular solicitations *must* include the Source Link-Layer
		 * Address option.  Ignore messages that do not.
		 */
		if (haddr == NULL && IN6_IS_ADDR_MULTICAST(&ip6h->ip6_dst)) {
			ip1dbg(("ndp_input_solicit: source link-layer address "
			    "option missing with a specified source.\n"));
			bad_solicit = B_TRUE;
			goto done;
		}

		/*
		 * This is a regular solicitation.  If we're still in the
		 * process of verifying the address, then don't respond at all
		 * and don't keep track of the sender.
		 */
		if (our_ncec->ncec_state == ND_PROBE)
			goto done;

		/*
		 * If the solicitation doesn't have sender hardware address
		 * (legal for unicast solicitation), then process without
		 * installing the return NCE.  Either we already know it, or
		 * we'll be forced to look it up when (and if) we reply to the
		 * packet.
		 */
		if (haddr == NULL)
			goto no_source;

		under_ill = ill;
		if (IS_UNDER_IPMP(under_ill)) {
			ill = ipmp_ill_hold_ipmp_ill(under_ill);
			if (ill == NULL)
				ill = under_ill;
			else
				need_ill_refrele = B_TRUE;
		}
		err = nce_lookup_then_add_v6(ill,
		    haddr, hlen,
		    &src,	/* Soliciting nodes address */
		    0,
		    ND_STALE,
		    &nnce);

		if (need_ill_refrele) {
			ill_refrele(ill);
			ill = under_ill;
			need_ill_refrele =  B_FALSE;
		}
		switch (err) {
		case 0:
			/* done with this entry */
			nce_refrele(nnce);
			break;
		case EEXIST:
			/*
			 * B_FALSE indicates this is not an an advertisement.
			 */
			nce_process(nnce->nce_common, haddr, 0, B_FALSE);
			nce_refrele(nnce);
			break;
		default:
			ip1dbg(("ndp_input_solicit: Can't create NCE %d\n",
			    err));
			goto done;
		}
no_source:
		flag |= NDP_SOLICITED;
	} else {
		/*
		 * No source link layer address option should be present in a
		 * valid DAD request.
		 */
		if (haddr != NULL) {
			ip1dbg(("ndp_input_solicit: source link-layer address "
			    "option present with an unspecified source.\n"));
			bad_solicit = B_TRUE;
			goto done;
		}
		if (our_ncec->ncec_state == ND_PROBE) {
			/*
			 * Internally looped-back probes will have
			 * IRAF_L2SRC_LOOPBACK set so we can ignore our own
			 * transmissions.
			 */
			if (!(ira->ira_flags & IRAF_L2SRC_LOOPBACK)) {
				/*
				 * If someone else is probing our address, then
				 * we've crossed wires.  Declare failure.
				 */
				ndp_failure(mp, ira);
			}
			goto done;
		}
		/*
		 * This is a DAD probe.  Multicast the advertisement to the
		 * all-nodes address.
		 */
		src = ipv6_all_hosts_mcast;
	}
	flag |= nce_advert_flags(our_ncec);
	(void) ndp_xmit(ill,
	    ND_NEIGHBOR_ADVERT,
	    our_ncec->ncec_lladdr,
	    our_ncec->ncec_lladdr_length,
	    &target,	/* Source and target of the advertisement pkt */
	    &src,	/* IP Destination (source of original pkt) */
	    flag);
done:
	if (bad_solicit)
		BUMP_MIB(mib, ipv6IfIcmpInBadNeighborSolicitations);
	if (our_ncec != NULL)
		ncec_refrele(our_ncec);
}

/*
 * Handle reception of Neighbor Solicitation messages
 */
void
ndp_input_advert(mblk_t *mp, ip_recv_attr_t *ira)
{
	ill_t		*ill = ira->ira_ill;
	nd_neighbor_advert_t *na;
	uint32_t	hlen = ill->ill_phys_addr_length;
	uchar_t		*haddr = NULL;
	icmp6_t		*icmp_nd;
	ip6_t		*ip6h;
	ncec_t		*dst_ncec = NULL;
	in6_addr_t	target;
	nd_opt_hdr_t	*opt = NULL;
	int		len;
	ip_stack_t	*ipst = ill->ill_ipst;
	mib2_ipv6IfIcmpEntry_t	*mib = ill->ill_icmp6_mib;

	ip6h = (ip6_t *)mp->b_rptr;
	icmp_nd = (icmp6_t *)(mp->b_rptr + IPV6_HDR_LEN);
	len = mp->b_wptr - mp->b_rptr - IPV6_HDR_LEN;
	na = (nd_neighbor_advert_t *)icmp_nd;

	if (IN6_IS_ADDR_MULTICAST(&ip6h->ip6_dst) &&
	    (na->nd_na_flags_reserved & ND_NA_FLAG_SOLICITED)) {
		ip1dbg(("ndp_input_advert: Target is multicast but the "
		    "solicited flag is not zero\n"));
		BUMP_MIB(mib, ipv6IfIcmpInBadNeighborAdvertisements);
		return;
	}
	target = na->nd_na_target;
	if (IN6_IS_ADDR_MULTICAST(&target) || IN6_IS_ADDR_V4MAPPED(&target) ||
	    IN6_IS_ADDR_LOOPBACK(&target)) {
		if (ip_debug > 2) {
			/* ip1dbg */
			pr_addr_dbg("ndp_input_solicit: Martian Target %s\n",
			    AF_INET6, &target);
		}
		BUMP_MIB(mib, ipv6IfIcmpInBadNeighborAdvertisements);
		return;
	}
	if (len > sizeof (nd_neighbor_advert_t)) {
		opt = (nd_opt_hdr_t *)&na[1];
		if (!ndp_verify_optlen(opt,
		    len - sizeof (nd_neighbor_advert_t))) {
			ip1dbg(("ndp_input_advert: cannot verify SLLA\n"));
			BUMP_MIB(mib, ipv6IfIcmpInBadNeighborAdvertisements);
			return;
		}
		/* At this point we have a verified NA per spec */
		len -= sizeof (nd_neighbor_advert_t);
		opt = ndp_get_option(opt, len, ND_OPT_TARGET_LINKADDR);
		if (opt != NULL) {
			haddr = (uchar_t *)&opt[1];
			if (hlen > opt->nd_opt_len * 8 - sizeof (*opt) ||
			    hlen == 0) {
				ip1dbg(("ndp_input_advert: bad SLLA\n"));
				BUMP_MIB(mib,
				    ipv6IfIcmpInBadNeighborAdvertisements);
				return;
			}
		}
	}

	/*
	 * NOTE: we match across the illgrp since we need to do DAD for all of
	 * our local addresses, and those are spread across all the active
	 * ills in the group.
	 */
	if ((dst_ncec = ncec_lookup_illgrp_v6(ill, &target)) == NULL)
		return;

	if (NCE_PUBLISH(dst_ncec)) {
		/*
		 * Someone just advertised an addresses that we publish. First,
		 * check it it was us -- if so, we can safely ignore it.
		 * We don't get the haddr from the ira_l2src because, in the
		 * case that the packet originated from us, on an IPMP group,
		 * the ira_l2src may would be the link-layer address of the
		 * cast_ill used to send the packet, which may not be the same
		 * as the dst_ncec->ncec_lladdr of the address.
		 */
		if (haddr != NULL) {
			if (ira->ira_flags & IRAF_L2SRC_LOOPBACK)
				goto out;

			if (!nce_cmp_ll_addr(dst_ncec, haddr, hlen))
				goto out;   /* from us -- no conflict */

			/*
			 * If we're in an IPMP group, check if this is an echo
			 * from another ill in the group.  Use the double-
			 * checked locking pattern to avoid grabbing
			 * ill_g_lock in the non-IPMP case.
			 */
			if (IS_UNDER_IPMP(ill)) {
				rw_enter(&ipst->ips_ill_g_lock, RW_READER);
				if (IS_UNDER_IPMP(ill) && ipmp_illgrp_find_ill(
				    ill->ill_grp, haddr, hlen) != NULL) {
					rw_exit(&ipst->ips_ill_g_lock);
					goto out;
				}
				rw_exit(&ipst->ips_ill_g_lock);
			}
		}

		/*
		 * This appears to be a real conflict.  If we're trying to
		 * configure this NCE (ND_PROBE), then shut it down.
		 * Otherwise, handle the discovered conflict.
		 */
		if (dst_ncec->ncec_state == ND_PROBE) {
			ndp_failure(mp, ira);
		} else {
			if (ip_nce_conflict(mp, ira, dst_ncec)) {
				char hbuf[MAC_STR_LEN];
				char sbuf[INET6_ADDRSTRLEN];

				cmn_err(CE_WARN,
				    "node '%s' is using %s on %s",
				    inet_ntop(AF_INET6, &target, sbuf,
				    sizeof (sbuf)),
				    haddr == NULL ? "<none>" :
				    mac_colon_addr(haddr, hlen, hbuf,
				    sizeof (hbuf)), ill->ill_name);
				/*
				 * RFC 4862, Section 5.4.4 does not mandate
				 * any specific behavior when an NA matches
				 * a non-tentative address assigned to the
				 * receiver. We make the choice of defending
				 * our address, based on the assumption that
				 * the sender has not detected the Duplicate.
				 *
				 * ncec_last_time_defended has been adjusted
				 * in ip_nce_conflict()
				 */
				(void) ndp_announce(dst_ncec);
			}
		}
	} else {
		if (na->nd_na_flags_reserved & ND_NA_FLAG_ROUTER)
			dst_ncec->ncec_flags |= NCE_F_ISROUTER;

		/* B_TRUE indicates this an advertisement */
		nce_process(dst_ncec, haddr, na->nd_na_flags_reserved, B_TRUE);
	}
out:
	ncec_refrele(dst_ncec);
}

/*
 * Process NDP neighbor solicitation/advertisement messages.
 * The checksum has already checked o.k before reaching here.
 * Information about the datalink header is contained in ira_l2src, but
 * that should be ignored for loopback packets.
 */
void
ndp_input(mblk_t *mp, ip_recv_attr_t *ira)
{
	ill_t		*ill = ira->ira_rill;
	icmp6_t		*icmp_nd;
	ip6_t		*ip6h;
	int		len;
	mib2_ipv6IfIcmpEntry_t	*mib = ill->ill_icmp6_mib;
	ill_t		*orig_ill = NULL;

	/*
	 * Since ira_ill is where the IRE_LOCAL was hosted we use ira_rill
	 * and make it be the IPMP upper so avoid being confused by a packet
	 * addressed to a unicast address on a different ill.
	 */
	if (IS_UNDER_IPMP(ill)) {
		orig_ill = ill;
		ill = ipmp_ill_hold_ipmp_ill(orig_ill);
		if (ill == NULL) {
			ill = orig_ill;
			BUMP_MIB(ill->ill_ip_mib, ipIfStatsInDiscards);
			ip_drop_input("ipIfStatsInDiscards - IPMP ill",
			    mp, ill);
			freemsg(mp);
			return;
		}
		ASSERT(ill != orig_ill);
		orig_ill = ira->ira_ill;
		ira->ira_ill = ill;
		mib = ill->ill_icmp6_mib;
	}
	if (!pullupmsg(mp, -1)) {
		ip1dbg(("ndp_input: pullupmsg failed\n"));
		BUMP_MIB(ill->ill_ip_mib, ipIfStatsInDiscards);
		ip_drop_input("ipIfStatsInDiscards - pullupmsg", mp, ill);
		goto done;
	}
	ip6h = (ip6_t *)mp->b_rptr;
	if (ip6h->ip6_hops != IPV6_MAX_HOPS) {
		ip1dbg(("ndp_input: hoplimit != IPV6_MAX_HOPS\n"));
		ip_drop_input("ipv6IfIcmpBadHoplimit", mp, ill);
		BUMP_MIB(mib, ipv6IfIcmpBadHoplimit);
		goto done;
	}
	/*
	 * NDP does not accept any extension headers between the
	 * IP header and the ICMP header since e.g. a routing
	 * header could be dangerous.
	 * This assumes that any AH or ESP headers are removed
	 * by ip prior to passing the packet to ndp_input.
	 */
	if (ip6h->ip6_nxt != IPPROTO_ICMPV6) {
		ip1dbg(("ndp_input: Wrong next header 0x%x\n",
		    ip6h->ip6_nxt));
		ip_drop_input("Wrong next header", mp, ill);
		BUMP_MIB(mib, ipv6IfIcmpInErrors);
		goto done;
	}
	icmp_nd = (icmp6_t *)(mp->b_rptr + IPV6_HDR_LEN);
	ASSERT(icmp_nd->icmp6_type == ND_NEIGHBOR_SOLICIT ||
	    icmp_nd->icmp6_type == ND_NEIGHBOR_ADVERT);
	if (icmp_nd->icmp6_code != 0) {
		ip1dbg(("ndp_input: icmp6 code != 0 \n"));
		ip_drop_input("code non-zero", mp, ill);
		BUMP_MIB(mib, ipv6IfIcmpInErrors);
		goto done;
	}
	len = mp->b_wptr - mp->b_rptr - IPV6_HDR_LEN;
	/*
	 * Make sure packet length is large enough for either
	 * a NS or a NA icmp packet.
	 */
	if (len <  sizeof (struct icmp6_hdr) + sizeof (struct in6_addr)) {
		ip1dbg(("ndp_input: packet too short\n"));
		ip_drop_input("packet too short", mp, ill);
		BUMP_MIB(mib, ipv6IfIcmpInErrors);
		goto done;
	}
	if (icmp_nd->icmp6_type == ND_NEIGHBOR_SOLICIT) {
		ndp_input_solicit(mp, ira);
	} else {
		ndp_input_advert(mp, ira);
	}
done:
	freemsg(mp);
	if (orig_ill != NULL) {
		ill_refrele(ill);
		ira->ira_ill = orig_ill;
	}
}

/*
 * ndp_xmit is called to form and transmit a ND solicitation or
 * advertisement ICMP packet.
 *
 * If the source address is unspecified and this isn't a probe (used for
 * duplicate address detection), an appropriate source address and link layer
 * address will be chosen here.  The link layer address option is included if
 * the source is specified (i.e., all non-probe packets), and omitted (per the
 * specification) otherwise.
 *
 * It returns B_FALSE only if it does a successful put() to the
 * corresponding ill's ill_wq otherwise returns B_TRUE.
 */
static boolean_t
ndp_xmit(ill_t *ill, uint32_t operation, uint8_t *hw_addr, uint_t hw_addr_len,
    const in6_addr_t *sender, const in6_addr_t *target, int flag)
{
	uint32_t	len;
	icmp6_t		*icmp6;
	mblk_t		*mp;
	ip6_t		*ip6h;
	nd_opt_hdr_t	*opt;
	uint_t		plen;
	zoneid_t	zoneid = GLOBAL_ZONEID;
	ill_t		*hwaddr_ill = ill;
	ip_xmit_attr_t	ixas;
	ip_stack_t	*ipst = ill->ill_ipst;
	boolean_t	need_refrele = B_FALSE;
	boolean_t	probe = B_FALSE;

	if (IS_UNDER_IPMP(ill)) {
		probe = ipif_lookup_testaddr_v6(ill, sender, NULL);
		/*
		 * We send non-probe packets on the upper IPMP interface.
		 * ip_output_simple() will use cast_ill for sending any
		 * multicast packets. Note that we can't follow the same
		 * logic for probe packets because all interfaces in the ipmp
		 * group may have failed, so that we really want to only try
		 * to send the ND packet on the ill corresponding to the src
		 * address.
		 */
		if (!probe) {
			ill = ipmp_ill_hold_ipmp_ill(ill);
			if (ill != NULL)
				need_refrele = B_TRUE;
			else
				ill = hwaddr_ill;
		}
	}

	/*
	 * If we have a unspecified source(sender) address, select a
	 * proper source address for the solicitation here itself so
	 * that we can initialize the h/w address correctly.
	 *
	 * If the sender is specified then we use this address in order
	 * to lookup the zoneid before calling ip_output_v6(). This is to
	 * enable unicast ND_NEIGHBOR_ADVERT packets to be routed correctly
	 * by IP (we cannot guarantee that the global zone has an interface
	 * route to the destination).
	 *
	 * Note that the NA never comes here with the unspecified source
	 * address.
	 */

	/*
	 * Probes will have unspec src at this point.
	 */
	if (!(IN6_IS_ADDR_UNSPECIFIED(sender))) {
		zoneid = ipif_lookup_addr_zoneid_v6(sender, ill, ipst);
		/*
		 * It's possible for ipif_lookup_addr_zoneid_v6() to return
		 * ALL_ZONES if it cannot find a matching ipif for the address
		 * we are trying to use. In this case we err on the side of
		 * trying to send the packet by defaulting to the GLOBAL_ZONEID.
		 */
		if (zoneid == ALL_ZONES)
			zoneid = GLOBAL_ZONEID;
	}

	plen = (sizeof (nd_opt_hdr_t) + hw_addr_len + 7) / 8;
	len = IPV6_HDR_LEN + sizeof (nd_neighbor_advert_t) + plen * 8;
	mp = allocb(len,  BPRI_LO);
	if (mp == NULL) {
		if (need_refrele)
			ill_refrele(ill);
		return (B_TRUE);
	}

	bzero((char *)mp->b_rptr, len);
	mp->b_wptr = mp->b_rptr + len;

	bzero(&ixas, sizeof (ixas));
	ixas.ixa_flags = IXAF_SET_ULP_CKSUM | IXAF_NO_HW_CKSUM;

	ixas.ixa_ifindex = ill->ill_phyint->phyint_ifindex;
	ixas.ixa_ipst = ipst;
	ixas.ixa_cred = kcred;
	ixas.ixa_cpid = NOPID;
	ixas.ixa_tsl = NULL;
	ixas.ixa_zoneid = zoneid;

	ip6h = (ip6_t *)mp->b_rptr;
	ip6h->ip6_vcf = IPV6_DEFAULT_VERS_AND_FLOW;
	ip6h->ip6_plen = htons(len - IPV6_HDR_LEN);
	ip6h->ip6_nxt = IPPROTO_ICMPV6;
	ip6h->ip6_hops = IPV6_MAX_HOPS;
	ixas.ixa_multicast_ttl = ip6h->ip6_hops;
	ip6h->ip6_dst = *target;
	icmp6 = (icmp6_t *)&ip6h[1];

	if (hw_addr_len != 0) {
		opt = (nd_opt_hdr_t *)((uint8_t *)ip6h + IPV6_HDR_LEN +
		    sizeof (nd_neighbor_advert_t));
	} else {
		opt = NULL;
	}
	if (operation == ND_NEIGHBOR_SOLICIT) {
		nd_neighbor_solicit_t *ns = (nd_neighbor_solicit_t *)icmp6;

		if (opt != NULL && !(flag & NDP_PROBE)) {
			/*
			 * Note that we don't send out SLLA for ND probes
			 * per RFC 4862, even though we do send out the src
			 * haddr for IPv4 DAD probes, even though both IPv4
			 * and IPv6 go out with the unspecified/INADDR_ANY
			 * src IP addr.
			 */
			opt->nd_opt_type = ND_OPT_SOURCE_LINKADDR;
		}
		ip6h->ip6_src = *sender;
		ns->nd_ns_target = *target;
		if (!(flag & NDP_UNICAST)) {
			/* Form multicast address of the target */
			ip6h->ip6_dst = ipv6_solicited_node_mcast;
			ip6h->ip6_dst.s6_addr32[3] |=
			    ns->nd_ns_target.s6_addr32[3];
		}
	} else {
		nd_neighbor_advert_t *na = (nd_neighbor_advert_t *)icmp6;

		ASSERT(!(flag & NDP_PROBE));
		if (opt != NULL)
			opt->nd_opt_type = ND_OPT_TARGET_LINKADDR;
		ip6h->ip6_src = *sender;
		na->nd_na_target = *sender;
		if (flag & NDP_ISROUTER)
			na->nd_na_flags_reserved |= ND_NA_FLAG_ROUTER;
		if (flag & NDP_SOLICITED)
			na->nd_na_flags_reserved |= ND_NA_FLAG_SOLICITED;
		if (flag & NDP_ORIDE)
			na->nd_na_flags_reserved |= ND_NA_FLAG_OVERRIDE;
	}

	if (!(flag & NDP_PROBE)) {
		if (hw_addr != NULL && opt != NULL) {
			/* Fill in link layer address and option len */
			opt->nd_opt_len = (uint8_t)plen;
			bcopy(hw_addr, &opt[1], hw_addr_len);
		}
	}
	if (opt != NULL && opt->nd_opt_type == 0) {
		/* If there's no link layer address option, then strip it. */
		len -= plen * 8;
		mp->b_wptr = mp->b_rptr + len;
		ip6h->ip6_plen = htons(len - IPV6_HDR_LEN);
	}

	icmp6->icmp6_type = (uint8_t)operation;
	icmp6->icmp6_code = 0;
	/*
	 * Prepare for checksum by putting icmp length in the icmp
	 * checksum field. The checksum is calculated in ip_output.c.
	 */
	icmp6->icmp6_cksum = ip6h->ip6_plen;

	(void) ip_output_simple(mp, &ixas);
	ixa_cleanup(&ixas);
	if (need_refrele)
		ill_refrele(ill);
	return (B_FALSE);
}

/*
 * Used to set ND_UNREACHBLE before ncec_delete sets it NCE_F_CONDEMNED.
 * The datapath uses this as an indication that there
 * is a problem (as opposed to a NCE that was just
 * reclaimed due to lack of memory.
 * Note that static ARP entries never become unreachable.
 */
void
nce_make_unreachable(ncec_t *ncec)
{
	mutex_enter(&ncec->ncec_lock);
	ncec->ncec_state = ND_UNREACHABLE;
	mutex_exit(&ncec->ncec_lock);
}

/*
 * NCE retransmit timer. Common to IPv4 and IPv6.
 * This timer goes off when:
 * a. It is time to retransmit a resolution for resolver.
 * b. It is time to send reachability probes.
 */
void
nce_timer(void *arg)
{
	ncec_t		*ncec = arg;
	ill_t		*ill = ncec->ncec_ill, *src_ill;
	char		addrbuf[INET6_ADDRSTRLEN];
	boolean_t	dropped = B_FALSE;
	ip_stack_t	*ipst = ncec->ncec_ipst;
	boolean_t	isv6 = (ncec->ncec_ipversion == IPV6_VERSION);
	in_addr_t	sender4 = INADDR_ANY;
	in6_addr_t	sender6 = ipv6_all_zeros;

	/*
	 * The timer has to be cancelled by ncec_delete before doing the final
	 * refrele. So the NCE is guaranteed to exist when the timer runs
	 * until it clears the timeout_id. Before clearing the timeout_id
	 * bump up the refcnt so that we can continue to use the ncec
	 */
	ASSERT(ncec != NULL);
	mutex_enter(&ncec->ncec_lock);
	ncec_refhold_locked(ncec);
	ncec->ncec_timeout_id = 0;
	mutex_exit(&ncec->ncec_lock);

	src_ill = nce_resolve_src(ncec, &sender6);
	/* if we could not find a sender address, return */
	if (src_ill == NULL) {
		if (!isv6) {
			IN6_V4MAPPED_TO_IPADDR(&ncec->ncec_addr, sender4);
			ip1dbg(("no src ill for %s\n", inet_ntop(AF_INET,
			    &sender4, addrbuf, sizeof (addrbuf))));
		} else {
			ip1dbg(("no src ill for %s\n", inet_ntop(AF_INET6,
			    &ncec->ncec_addr, addrbuf, sizeof (addrbuf))));
		}
		nce_restart_timer(ncec, ill->ill_reachable_retrans_time);
		ncec_refrele(ncec);
		return;
	}
	if (!isv6)
		IN6_V4MAPPED_TO_IPADDR(&sender6, sender4);

	mutex_enter(&ncec->ncec_lock);
	/*
	 * Check the reachability state.
	 */
	switch (ncec->ncec_state) {
	case ND_DELAY:
		ASSERT(ncec->ncec_lladdr != NULL);
		ncec->ncec_state = ND_PROBE;
		ncec->ncec_pcnt = ND_MAX_UNICAST_SOLICIT;
		if (isv6) {
			mutex_exit(&ncec->ncec_lock);
			dropped = ndp_xmit(src_ill, ND_NEIGHBOR_SOLICIT,
			    src_ill->ill_phys_addr,
			    src_ill->ill_phys_addr_length,
			    &sender6, &ncec->ncec_addr,
			    NDP_UNICAST);
		} else {
			dropped = (arp_request(ncec, sender4, src_ill) == 0);
			mutex_exit(&ncec->ncec_lock);
		}
		if (!dropped) {
			mutex_enter(&ncec->ncec_lock);
			ncec->ncec_pcnt--;
			mutex_exit(&ncec->ncec_lock);
		}
		if (ip_debug > 3) {
			/* ip2dbg */
			pr_addr_dbg("nce_timer: state for %s changed "
			    "to PROBE\n", AF_INET6, &ncec->ncec_addr);
		}
		nce_restart_timer(ncec, ill->ill_reachable_retrans_time);
		break;
	case ND_PROBE:
		/* must be retransmit timer */
		ASSERT(ncec->ncec_pcnt >= -1);
		if (ncec->ncec_pcnt > 0) {
			/*
			 * As per RFC2461, the ncec gets deleted after
			 * MAX_UNICAST_SOLICIT unsuccessful re-transmissions.
			 * Note that the first unicast solicitation is sent
			 * during the DELAY state.
			 */
			ip2dbg(("nce_timer: pcount=%x dst %s\n",
			    ncec->ncec_pcnt,
			    inet_ntop((isv6? AF_INET6 : AF_INET),
			    &ncec->ncec_addr, addrbuf, sizeof (addrbuf))));
			if (NCE_PUBLISH(ncec)) {
				mutex_exit(&ncec->ncec_lock);
				/*
				 * send out a probe; note that src_ill
				 * is ignored by nce_dad() for all
				 * DAD message types other than IPv6
				 * unicast probes
				 */
				nce_dad(ncec, src_ill, B_TRUE);
			} else {
				ASSERT(src_ill != NULL);
				if (isv6) {
					mutex_exit(&ncec->ncec_lock);
					dropped = ndp_xmit(src_ill,
					    ND_NEIGHBOR_SOLICIT,
					    src_ill->ill_phys_addr,
					    src_ill->ill_phys_addr_length,
					    &sender6, &ncec->ncec_addr,
					    NDP_UNICAST);
				} else {
					/*
					 * since the nce is REACHABLE,
					 * the ARP request will be sent out
					 * as a link-layer unicast.
					 */
					dropped = (arp_request(ncec, sender4,
					    src_ill) == 0);
					mutex_exit(&ncec->ncec_lock);
				}
				if (!dropped) {
					mutex_enter(&ncec->ncec_lock);
					ncec->ncec_pcnt--;
					mutex_exit(&ncec->ncec_lock);
				}
				nce_restart_timer(ncec,
				    ill->ill_reachable_retrans_time);
			}
		} else if (ncec->ncec_pcnt < 0) {
			/* No hope, delete the ncec */
			/* Tell datapath it went bad */
			ncec->ncec_state = ND_UNREACHABLE;
			mutex_exit(&ncec->ncec_lock);
			if (ip_debug > 2) {
				/* ip1dbg */
				pr_addr_dbg("nce_timer: Delete NCE for"
				    " dst %s\n", (isv6? AF_INET6: AF_INET),
				    &ncec->ncec_addr);
			}
			/* if static ARP can't delete. */
			if ((ncec->ncec_flags & NCE_F_STATIC) == 0)
				ncec_delete(ncec);

		} else if (!NCE_PUBLISH(ncec)) {
			/*
			 * Probe count is 0 for a dynamic entry (one that we
			 * ourselves are not publishing). We should never get
			 * here if NONUD was requested, hence the ASSERT below.
			 */
			ASSERT((ncec->ncec_flags & NCE_F_NONUD) == 0);
			ip2dbg(("nce_timer: pcount=%x dst %s\n",
			    ncec->ncec_pcnt, inet_ntop(AF_INET6,
			    &ncec->ncec_addr, addrbuf, sizeof (addrbuf))));
			ncec->ncec_pcnt--;
			mutex_exit(&ncec->ncec_lock);
			/* Wait one interval before killing */
			nce_restart_timer(ncec,
			    ill->ill_reachable_retrans_time);
		} else if (ill->ill_phyint->phyint_flags & PHYI_RUNNING) {
			ipif_t *ipif;
			ipaddr_t ncec_addr;

			/*
			 * We're done probing, and we can now declare this
			 * address to be usable.  Let IP know that it's ok to
			 * use.
			 */
			ncec->ncec_state = ND_REACHABLE;
			ncec->ncec_flags &= ~NCE_F_UNVERIFIED;
			mutex_exit(&ncec->ncec_lock);
			if (isv6) {
				ipif = ipif_lookup_addr_exact_v6(
				    &ncec->ncec_addr, ill, ipst);
			} else {
				IN6_V4MAPPED_TO_IPADDR(&ncec->ncec_addr,
				    ncec_addr);
				ipif = ipif_lookup_addr_exact(ncec_addr, ill,
				    ipst);
			}
			if (ipif != NULL) {
				if (ipif->ipif_was_dup) {
					char ibuf[LIFNAMSIZ];
					char sbuf[INET6_ADDRSTRLEN];

					ipif->ipif_was_dup = B_FALSE;
					(void) inet_ntop(AF_INET6,
					    &ipif->ipif_v6lcl_addr,
					    sbuf, sizeof (sbuf));
					ipif_get_name(ipif, ibuf,
					    sizeof (ibuf));
					cmn_err(CE_NOTE, "recovered address "
					    "%s on %s", sbuf, ibuf);
				}
				if ((ipif->ipif_flags & IPIF_UP) &&
				    !ipif->ipif_addr_ready)
					ipif_up_notify(ipif);
				ipif->ipif_addr_ready = 1;
				ipif_refrele(ipif);
			}
			if (!isv6 && arp_no_defense)
				break;
			/* Begin defending our new address */
			if (ncec->ncec_unsolicit_count > 0) {
				ncec->ncec_unsolicit_count--;
				if (isv6) {
					dropped = ndp_announce(ncec);
				} else {
					dropped = arp_announce(ncec);
				}

				if (dropped)
					ncec->ncec_unsolicit_count++;
				else
					ncec->ncec_last_time_defended =
					    ddi_get_lbolt();
			}
			if (ncec->ncec_unsolicit_count > 0) {
				nce_restart_timer(ncec,
				    ANNOUNCE_INTERVAL(isv6));
			} else if (DEFENSE_INTERVAL(isv6) != 0) {
				nce_restart_timer(ncec, DEFENSE_INTERVAL(isv6));
			}
		} else {
			/*
			 * This is an address we're probing to be our own, but
			 * the ill is down.  Wait until it comes back before
			 * doing anything, but switch to reachable state so
			 * that the restart will work.
			 */
			ncec->ncec_state = ND_REACHABLE;
			mutex_exit(&ncec->ncec_lock);
		}
		break;
	case ND_INCOMPLETE: {
		mblk_t	*mp, *nextmp;
		mblk_t	**prevmpp;

		/*
		 * Per case (2) in the nce_queue_mp() comments, scan ncec_qd_mp
		 * for any IPMP probe packets, and toss them.  IPMP probe
		 * packets will always be at the head of ncec_qd_mp, so that
		 * we can stop at the first queued ND packet that is
		 * not a probe packet.
		 */
		prevmpp = &ncec->ncec_qd_mp;
		for (mp = ncec->ncec_qd_mp; mp != NULL; mp = nextmp) {
			nextmp = mp->b_next;

			if (IS_UNDER_IPMP(ill) && ncec->ncec_nprobes > 0) {
				inet_freemsg(mp);
				ncec->ncec_nprobes--;
				*prevmpp = nextmp;
			} else {
				prevmpp = &mp->b_next;
			}
		}

		/*
		 * Must be resolver's retransmit timer.
		 */
		mutex_exit(&ncec->ncec_lock);
		ip_ndp_resolve(ncec);
		break;
	}
	case ND_REACHABLE:
		if (((ncec->ncec_flags & NCE_F_UNSOL_ADV) &&
		    ncec->ncec_unsolicit_count != 0) ||
		    (NCE_PUBLISH(ncec) && DEFENSE_INTERVAL(isv6) != 0)) {
			if (ncec->ncec_unsolicit_count > 0) {
				ncec->ncec_unsolicit_count--;
				mutex_exit(&ncec->ncec_lock);
				/*
				 * When we get to zero announcements left,
				 * switch to address defense
				 */
			} else {
				boolean_t rate_limit;

				mutex_exit(&ncec->ncec_lock);
				rate_limit = ill_defend_rate_limit(ill, ncec);
				if (rate_limit) {
					nce_restart_timer(ncec,
					    DEFENSE_INTERVAL(isv6));
					break;
				}
			}
			if (isv6) {
				dropped = ndp_announce(ncec);
			} else {
				dropped = arp_announce(ncec);
			}
			mutex_enter(&ncec->ncec_lock);
			if (dropped) {
				ncec->ncec_unsolicit_count++;
			} else {
				ncec->ncec_last_time_defended =
				    ddi_get_lbolt();
			}
			mutex_exit(&ncec->ncec_lock);
			if (ncec->ncec_unsolicit_count != 0) {
				nce_restart_timer(ncec,
				    ANNOUNCE_INTERVAL(isv6));
			} else {
				nce_restart_timer(ncec, DEFENSE_INTERVAL(isv6));
			}
		} else {
			mutex_exit(&ncec->ncec_lock);
		}
		break;
	default:
		mutex_exit(&ncec->ncec_lock);
		break;
	}
done:
	ncec_refrele(ncec);
	ill_refrele(src_ill);
}

/*
 * Set a link layer address from the ll_addr passed in.
 * Copy SAP from ill.
 */
static void
nce_set_ll(ncec_t *ncec, uchar_t *ll_addr)
{
	ill_t	*ill = ncec->ncec_ill;

	ASSERT(ll_addr != NULL);
	if (ill->ill_phys_addr_length > 0) {
		/*
		 * The bcopy() below used to be called for the physical address
		 * length rather than the link layer address length. For
		 * ethernet and many other media, the phys_addr and lla are
		 * identical.
		 *
		 * The phys_addr and lla may not be the same for devices that
		 * support DL_IPV6_LINK_LAYER_ADDR, though there are currently
		 * no known instances of these.
		 *
		 * For PPP or other interfaces with a zero length
		 * physical address, don't do anything here.
		 * The bcopy() with a zero phys_addr length was previously
		 * a no-op for interfaces with a zero-length physical address.
		 * Using the lla for them would change the way they operate.
		 * Doing nothing in such cases preserves expected behavior.
		 */
		bcopy(ll_addr, ncec->ncec_lladdr, ill->ill_nd_lla_len);
	}
}

boolean_t
nce_cmp_ll_addr(const ncec_t *ncec, const uchar_t *ll_addr,
    uint32_t ll_addr_len)
{
	ASSERT(ncec->ncec_lladdr != NULL);
	if (ll_addr == NULL)
		return (B_FALSE);
	if (bcmp(ll_addr, ncec->ncec_lladdr, ll_addr_len) != 0)
		return (B_TRUE);
	return (B_FALSE);
}

/*
 * Updates the link layer address or the reachability state of
 * a cache entry.  Reset probe counter if needed.
 */
void
nce_update(ncec_t *ncec, uint16_t new_state, uchar_t *new_ll_addr)
{
	ill_t	*ill = ncec->ncec_ill;
	boolean_t need_stop_timer = B_FALSE;
	boolean_t need_fastpath_update = B_FALSE;
	nce_t	*nce = NULL;
	timeout_id_t tid;

	ASSERT(MUTEX_HELD(&ncec->ncec_lock));
	/*
	 * If this interface does not do NUD, there is no point
	 * in allowing an update to the cache entry.  Although
	 * we will respond to NS.
	 * The only time we accept an update for a resolver when
	 * NUD is turned off is when it has just been created.
	 * Non-Resolvers will always be created as REACHABLE.
	 */
	if (new_state != ND_UNCHANGED) {
		if ((ncec->ncec_flags & NCE_F_NONUD) &&
		    (ncec->ncec_state != ND_INCOMPLETE))
			return;
		ASSERT((int16_t)new_state >= ND_STATE_VALID_MIN);
		ASSERT((int16_t)new_state <= ND_STATE_VALID_MAX);
		need_stop_timer = B_TRUE;
		if (new_state == ND_REACHABLE)
			ncec->ncec_last = TICK_TO_MSEC(ddi_get_lbolt64());
		else {
			/* We force NUD in this case */
			ncec->ncec_last = 0;
		}
		ncec->ncec_state = new_state;
		ncec->ncec_pcnt = ND_MAX_UNICAST_SOLICIT;
		ASSERT(ncec->ncec_lladdr != NULL || new_state == ND_INITIAL ||
		    new_state == ND_INCOMPLETE);
	}

	tid = 0;
	if (need_stop_timer || (ncec->ncec_flags & NCE_F_STATIC)) {
		tid = ncec->ncec_timeout_id;
		ncec->ncec_timeout_id = 0;
	}
	/*
	 * Re-trigger fastpath probe and
	 * overwrite the DL_UNITDATA_REQ data, noting we'll lose
	 * whatever packets that happens to be transmitting at the time.
	 */
	if (new_ll_addr != NULL) {
		bcopy(new_ll_addr, ncec->ncec_lladdr,
		    ill->ill_phys_addr_length);
		need_fastpath_update = B_TRUE;
	}
	mutex_exit(&ncec->ncec_lock);
	if (need_stop_timer || (ncec->ncec_flags & NCE_F_STATIC)) {
		if (tid != 0)
			(void) untimeout(tid);
	}
	if (need_fastpath_update) {
		/*
		 * Delete any existing existing dlur_mp and fp_mp information.
		 * For IPMP interfaces, all underlying ill's must be checked
		 * and purged.
		 */
		nce_fastpath_list_delete(ncec->ncec_ill, ncec, NULL);
		/*
		 * add the new dlur_mp and fp_mp
		 */
		nce = nce_fastpath(ncec, B_TRUE, NULL);
		if (nce != NULL)
			nce_refrele(nce);
	}
	mutex_enter(&ncec->ncec_lock);
}

static void
nce_queue_mp_common(ncec_t *ncec, mblk_t *mp, boolean_t head_insert)
{
	uint_t	count = 0;
	mblk_t  **mpp, *tmp;

	ASSERT(MUTEX_HELD(&ncec->ncec_lock));

	for (mpp = &ncec->ncec_qd_mp; *mpp != NULL; mpp = &(*mpp)->b_next) {
		if (++count > ncec->ncec_ill->ill_max_buf) {
			tmp = ncec->ncec_qd_mp->b_next;
			ncec->ncec_qd_mp->b_next = NULL;
			/*
			 * if we never create data addrs on the under_ill
			 * does this matter?
			 */
			BUMP_MIB(ncec->ncec_ill->ill_ip_mib,
			    ipIfStatsOutDiscards);
			ip_drop_output("ipIfStatsOutDiscards", ncec->ncec_qd_mp,
			    ncec->ncec_ill);
			freemsg(ncec->ncec_qd_mp);
			ncec->ncec_qd_mp = tmp;
		}
	}

	if (head_insert) {
		ncec->ncec_nprobes++;
		mp->b_next = ncec->ncec_qd_mp;
		ncec->ncec_qd_mp = mp;
	} else {
		*mpp = mp;
	}
}

/*
 * nce_queue_mp will queue the packet into the ncec_qd_mp. The packet will be
 * queued at the head or tail of the queue based on the input argument
 * 'head_insert'. The caller should specify this argument as B_TRUE if this
 * packet is an IPMP probe packet, in which case the following happens:
 *
 *   1. Insert it at the head of the ncec_qd_mp list.  Consider the normal
 *	(non-ipmp_probe) load-speading case where the source address of the ND
 *	packet is not tied to ncec_ill. If the ill bound to the source address
 *	cannot receive, the response to the ND packet will not be received.
 *	However, if ND packets for ncec_ill's probes are queued	behind that ND
 *	packet, those probes will also fail to be sent, and thus in.mpathd will
 *	 erroneously conclude that ncec_ill has also failed.
 *
 *   2. Drop the ipmp_probe packet in ndp_timer() if the ND did	not succeed on
 *	the first attempt.  This ensures that ND problems do not manifest as
 *	probe RTT spikes.
 *
 * We achieve this by inserting ipmp_probe() packets at the head of the
 * nce_queue.
 *
 * The ncec for the probe target is created with ncec_ill set to the ipmp_ill,
 * but the caller needs to set head_insert to B_TRUE if this is a probe packet.
 */
void
nce_queue_mp(ncec_t *ncec, mblk_t *mp, boolean_t head_insert)
{
	ASSERT(MUTEX_HELD(&ncec->ncec_lock));
	nce_queue_mp_common(ncec, mp, head_insert);
}

/*
 * Called when address resolution failed due to a timeout.
 * Send an ICMP unreachable in response to all queued packets.
 */
void
ndp_resolv_failed(ncec_t *ncec)
{
	mblk_t	*mp, *nxt_mp;
	char	buf[INET6_ADDRSTRLEN];
	ill_t *ill = ncec->ncec_ill;
	ip_recv_attr_t	iras;

	bzero(&iras, sizeof (iras));
	iras.ira_flags = 0;
	/*
	 * we are setting the ira_rill to the ipmp_ill (instead of
	 * the actual ill on which the packet was received), but this
	 * is ok because we don't actually need the real ira_rill.
	 * to send the icmp unreachable to the sender.
	 */
	iras.ira_ill = iras.ira_rill = ill;
	iras.ira_ruifindex = ill->ill_phyint->phyint_ifindex;
	iras.ira_rifindex = iras.ira_ruifindex;

	ip1dbg(("ndp_resolv_failed: dst %s\n",
	    inet_ntop(AF_INET6, (char *)&ncec->ncec_addr, buf, sizeof (buf))));
	mutex_enter(&ncec->ncec_lock);
	mp = ncec->ncec_qd_mp;
	ncec->ncec_qd_mp = NULL;
	ncec->ncec_nprobes = 0;
	mutex_exit(&ncec->ncec_lock);
	while (mp != NULL) {
		nxt_mp = mp->b_next;
		mp->b_next = NULL;

		BUMP_MIB(ill->ill_ip_mib, ipIfStatsOutDiscards);
		ip_drop_output("ipIfStatsOutDiscards - address unreachable",
		    mp, ill);
		icmp_unreachable_v6(mp,
		    ICMP6_DST_UNREACH_ADDR, B_FALSE, &iras);
		ASSERT(!(iras.ira_flags & IRAF_IPSEC_SECURE));
		mp = nxt_mp;
	}
	ncec_cb_dispatch(ncec); /* finish off waiting callbacks */
}

/*
 * Handle the completion of NDP and ARP resolution.
 */
void
nce_resolv_ok(ncec_t *ncec)
{
	mblk_t *mp;
	uint_t pkt_len;
	iaflags_t ixaflags = IXAF_NO_TRACE;
	nce_t *nce;
	ill_t	*ill = ncec->ncec_ill;
	boolean_t isv6 = (ncec->ncec_ipversion == IPV6_VERSION);
	ip_stack_t *ipst = ill->ill_ipst;

	if (IS_IPMP(ncec->ncec_ill)) {
		nce_resolv_ipmp_ok(ncec);
		return;
	}
	/* non IPMP case */

	mutex_enter(&ncec->ncec_lock);
	ASSERT(ncec->ncec_nprobes == 0);
	mp = ncec->ncec_qd_mp;
	ncec->ncec_qd_mp = NULL;
	mutex_exit(&ncec->ncec_lock);

	while (mp != NULL) {
		mblk_t *nxt_mp;

		if (ill->ill_isv6) {
			ip6_t *ip6h = (ip6_t *)mp->b_rptr;

			pkt_len = ntohs(ip6h->ip6_plen) + IPV6_HDR_LEN;
		} else {
			ipha_t *ipha = (ipha_t *)mp->b_rptr;

			ixaflags |= IXAF_IS_IPV4;
			pkt_len = ntohs(ipha->ipha_length);
		}
		nxt_mp = mp->b_next;
		mp->b_next = NULL;
		/*
		 * IXAF_NO_DEV_FLOW_CTL information for TCP packets is no
		 * longer available, but it's ok to drop this flag because TCP
		 * has its own flow-control in effect, so TCP packets
		 * are not likely to get here when flow-control is in effect.
		 */
		mutex_enter(&ill->ill_lock);
		nce = nce_lookup(ill, &ncec->ncec_addr);
		mutex_exit(&ill->ill_lock);

		if (nce == NULL) {
			if (isv6) {
				BUMP_MIB(&ipst->ips_ip6_mib,
				    ipIfStatsOutDiscards);
			} else {
				BUMP_MIB(&ipst->ips_ip_mib,
				    ipIfStatsOutDiscards);
			}
			ip_drop_output("ipIfStatsOutDiscards - no nce",
			    mp, NULL);
			freemsg(mp);
		} else {
			/*
			 * We don't know the zoneid, but
			 * ip_xmit does not care since IXAF_NO_TRACE
			 * is set. (We traced the packet the first
			 * time through ip_xmit.)
			 */
			(void) ip_xmit(mp, nce, ixaflags, pkt_len, 0,
			    ALL_ZONES, 0, NULL);
			nce_refrele(nce);
		}
		mp = nxt_mp;
	}

	ncec_cb_dispatch(ncec); /* complete callbacks */
}

/*
 * Called by SIOCSNDP* ioctl to add/change an ncec entry
 * and the corresponding attributes.
 * Disallow states other than ND_REACHABLE or ND_STALE.
 */
int
ndp_sioc_update(ill_t *ill, lif_nd_req_t *lnr)
{
	sin6_t		*sin6;
	in6_addr_t	*addr;
	ncec_t		*ncec;
	nce_t		*nce;
	int		err = 0;
	uint16_t	new_flags = 0;
	uint16_t	old_flags = 0;
	int		inflags = lnr->lnr_flags;
	ip_stack_t	*ipst = ill->ill_ipst;
	boolean_t	do_postprocess = B_FALSE;

	ASSERT(ill->ill_isv6);
	if ((lnr->lnr_state_create != ND_REACHABLE) &&
	    (lnr->lnr_state_create != ND_STALE))
		return (EINVAL);

	sin6 = (sin6_t *)&lnr->lnr_addr;
	addr = &sin6->sin6_addr;

	mutex_enter(&ipst->ips_ndp6->ndp_g_lock);
	ASSERT(!IS_UNDER_IPMP(ill));
	nce = nce_lookup_addr(ill, addr);
	if (nce != NULL)
		new_flags = nce->nce_common->ncec_flags;

	switch (inflags & (NDF_ISROUTER_ON|NDF_ISROUTER_OFF)) {
	case NDF_ISROUTER_ON:
		new_flags |= NCE_F_ISROUTER;
		break;
	case NDF_ISROUTER_OFF:
		new_flags &= ~NCE_F_ISROUTER;
		break;
	case (NDF_ISROUTER_OFF|NDF_ISROUTER_ON):
		mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
		if (nce != NULL)
			nce_refrele(nce);
		return (EINVAL);
	}
	if (inflags & NDF_STATIC)
		new_flags |= NCE_F_STATIC;

	switch (inflags & (NDF_ANYCAST_ON|NDF_ANYCAST_OFF)) {
	case NDF_ANYCAST_ON:
		new_flags |= NCE_F_ANYCAST;
		break;
	case NDF_ANYCAST_OFF:
		new_flags &= ~NCE_F_ANYCAST;
		break;
	case (NDF_ANYCAST_OFF|NDF_ANYCAST_ON):
		mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
		if (nce != NULL)
			nce_refrele(nce);
		return (EINVAL);
	}

	if (nce == NULL) {
		err = nce_add_v6(ill,
		    (uchar_t *)lnr->lnr_hdw_addr,
		    ill->ill_phys_addr_length,
		    addr,
		    new_flags,
		    lnr->lnr_state_create,
		    &nce);
		if (err != 0) {
			mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
			ip1dbg(("ndp_sioc_update: Can't create NCE %d\n", err));
			return (err);
		} else {
			do_postprocess = B_TRUE;
		}
	}
	ncec = nce->nce_common;
	old_flags = ncec->ncec_flags;
	if (old_flags & NCE_F_ISROUTER && !(new_flags & NCE_F_ISROUTER)) {
		ncec_router_to_host(ncec);
		mutex_exit(&ipst->ips_ndp6->ndp_g_lock);
		if (do_postprocess)
			err = nce_add_v6_postprocess(nce);
		nce_refrele(nce);
		return (0);
	}
	mutex_exit(&ipst->ips_ndp6->ndp_g_lock);

	if (do_postprocess)
		err = nce_add_v6_postprocess(nce);
	/*
	 * err cannot be anything other than 0 because we don't support
	 * proxy arp of static addresses.
	 */
	ASSERT(err == 0);

	mutex_enter(&ncec->ncec_lock);
	ncec->ncec_flags = new_flags;
	mutex_exit(&ncec->ncec_lock);
	/*
	 * Note that we ignore the state at this point, which
	 * should be either STALE or REACHABLE.  Instead we let
	 * the link layer address passed in to determine the state
	 * much like incoming packets.
	 */
	nce_process(ncec, (uchar_t *)lnr->lnr_hdw_addr, 0, B_FALSE);
	nce_refrele(nce);
	return (0);
}

/*
 * Create an nce_t structure for ill using the ncec->ncec_lladdr to set up
 * the nce_dlur_mp. If ill != ncec->ncec_ill, then the ips_ill_g_lock must
 * be held to ensure that they are in the same group.
 */
static nce_t *
nce_fastpath_create(ill_t *ill, ncec_t *ncec)
{

	nce_t *nce;

	nce = nce_ill_lookup_then_add(ill, ncec);

	if (nce == NULL || IS_LOOPBACK(nce->nce_ill) || IS_VNI(nce->nce_ill))
		return (nce);

	/*
	 * hold the ncec_lock to synchronize with nce_update() so that,
	 * at the end of this function, the contents of nce_dlur_mp are
	 * consistent with ncec->ncec_lladdr, even though some intermediate
	 * packet may have been sent out with a mangled address, which would
	 * only be a transient condition.
	 */
	mutex_enter(&ncec->ncec_lock);
	if (ncec->ncec_lladdr != NULL) {
		bcopy(ncec->ncec_lladdr, nce->nce_dlur_mp->b_rptr +
		    NCE_LL_ADDR_OFFSET(ill), ill->ill_phys_addr_length);
	} else {
		nce->nce_dlur_mp = ill_dlur_gen(NULL, 0, ill->ill_sap,
		    ill->ill_sap_length);
	}
	mutex_exit(&ncec->ncec_lock);
	return (nce);
}

/*
 * we make nce_fp_mp to have an M_DATA prepend.
 * The caller ensures there is hold on ncec for this function.
 * Note that since ill_fastpath_probe() copies the mblk there is
 * no need to hold the nce or ncec beyond this function.
 *
 * If the caller has passed in a non-null ncec_nce to nce_fastpath() that
 * ncec_nce must correspond to the nce for ncec with nce_ill == ncec->ncec_ill
 * and will be returned back by this function, so that no extra nce_refrele
 * is required for the caller. The calls from nce_add_common() use this
 * method. All other callers (that pass in NULL ncec_nce) will have to do a
 * nce_refrele of the returned nce (when it is non-null).
 */
static nce_t *
nce_fastpath(ncec_t *ncec, boolean_t trigger_fp_req, nce_t *ncec_nce)
{
	nce_t *nce;
	ill_t *ill = ncec->ncec_ill;

	ASSERT(ill != NULL);

	if (IS_IPMP(ill) && trigger_fp_req) {
		trigger_fp_req = B_FALSE;
		ipmp_ncec_refresh_nce(ncec);
	}

	/*
	 * If the caller already has the nce corresponding to the ill, use
	 * that one. Otherwise we have to lookup/add the nce. Calls from
	 * nce_add_common() fall in the former category, and have just done
	 * the nce lookup/add that can be reused.
	 */
	if (ncec_nce == NULL)
		nce = nce_fastpath_create(ill, ncec);
	else
		nce = ncec_nce;

	if (nce == NULL || IS_LOOPBACK(nce->nce_ill) || IS_VNI(nce->nce_ill))
		return (nce);

	if (trigger_fp_req)
		nce_fastpath_trigger(nce);
	return (nce);
}

/*
 * Trigger fastpath on nce. No locks may be held.
 */
static void
nce_fastpath_trigger(nce_t *nce)
{
	int res;
	ill_t *ill = nce->nce_ill;
	ncec_t *ncec = nce->nce_common;

	res = ill_fastpath_probe(ill, nce->nce_dlur_mp);
	/*
	 * EAGAIN is an indication of a transient error
	 * i.e. allocation failure etc. leave the ncec in the list it
	 * will be updated when another probe happens for another ire
	 * if not it will be taken out of the list when the ire is
	 * deleted.
	 */
	if (res != 0 && res != EAGAIN && res != ENOTSUP)
		nce_fastpath_list_delete(ill, ncec, NULL);
}

/*
 * Add ncec to the nce fastpath list on ill.
 */
static nce_t *
nce_ill_lookup_then_add_locked(ill_t *ill, ncec_t *ncec, list_t *graveyard)
{
	nce_t *nce = NULL;

	ASSERT(MUTEX_HELD(&ill->ill_lock));
	/*
	 * Atomically ensure that the ill is not CONDEMNED and is not going
	 * down, before adding the NCE.
	 */
	if (ill->ill_state_flags & ILL_CONDEMNED)
		return (NULL);
	mutex_enter(&ncec->ncec_lock);
	/*
	 * if ncec has not been deleted and
	 * is not already in the list add it.
	 */
	if (!NCE_ISCONDEMNED(ncec)) {
		nce = nce_lookup(ill, &ncec->ncec_addr);
		if (nce != NULL)
			goto done;
		nce = nce_add(ill, ncec, graveyard);
	}
done:
	mutex_exit(&ncec->ncec_lock);
	return (nce);
}

static nce_t *
nce_ill_lookup_then_add(ill_t *ill, ncec_t *ncec)
{
	nce_t *nce;
	list_t graveyard;

	list_create(&graveyard, sizeof (nce_t), offsetof(nce_t, nce_node));
	mutex_enter(&ill->ill_lock);
	nce = nce_ill_lookup_then_add_locked(ill, ncec, &graveyard);
	mutex_exit(&ill->ill_lock);
	nce_graveyard_free(&graveyard);
	return (nce);
}


/*
 * remove ncec from the ill_nce list. If 'dead' is non-null, the deleted
 * nce is added to the 'dead' list, and the caller must nce_refrele() the
 * entry after all locks have been dropped.
 */
void
nce_fastpath_list_delete(ill_t *ill, ncec_t *ncec, list_t *dead)
{
	nce_t *nce;

	ASSERT(ill != NULL);

	/* delete any nces referencing the ncec from underlying ills */
	if (IS_IPMP(ill))
		ipmp_ncec_delete_nce(ncec);

	/* now the ill itself */
	mutex_enter(&ill->ill_lock);
	for (nce = list_head(&ill->ill_nce); nce != NULL;
	    nce = list_next(&ill->ill_nce, nce)) {
		if (nce->nce_common == ncec) {
			nce_refhold(nce);
			nce_delete(nce);
			break;
		}
	}
	mutex_exit(&ill->ill_lock);
	if (nce != NULL) {
		if (dead == NULL)
			nce_refrele(nce);
		else
			list_insert_tail(dead, nce);
	}
}

/*
 * when the fastpath response does not fit in the datab
 * associated with the existing nce_fp_mp, we delete and
 * add the nce to retrigger fastpath based on the information
 * in the ncec_t.
 */
static nce_t *
nce_delete_then_add(nce_t *nce)
{
	ill_t		*ill = nce->nce_ill;
	nce_t		*newnce = NULL;
	list_t		graveyard;

	list_create(&graveyard, sizeof (nce_t), offsetof(nce_t, nce_node));
	ip0dbg(("nce_delete_then_add nce %p ill %s\n",
	    (void *)nce, ill->ill_name));
	mutex_enter(&ill->ill_lock);
	mutex_enter(&nce->nce_common->ncec_lock);
	nce_delete(nce);
	/*
	 * Make sure that ncec is not condemned before adding. We hold the
	 * ill_lock and ncec_lock to synchronize with ncec_delete() and
	 * ipmp_ncec_delete_nce()
	 */
	if (!NCE_ISCONDEMNED(nce->nce_common))
		newnce = nce_add(ill, nce->nce_common, &graveyard);
	mutex_exit(&nce->nce_common->ncec_lock);
	mutex_exit(&ill->ill_lock);
	nce_graveyard_free(&graveyard);
	nce_refrele(nce);
	return (newnce); /* could be null if nomem */
}

typedef struct nce_fp_match_s {
	nce_t	*nce_fp_match_res;
	mblk_t	*nce_fp_match_ack_mp;
} nce_fp_match_t;

/* ARGSUSED */
static int
nce_fastpath_match_dlur(ill_t *ill, nce_t *nce, void *arg)
{
	nce_fp_match_t	*nce_fp_marg = arg;
	ncec_t		*ncec = nce->nce_common;
	mblk_t		*mp = nce_fp_marg->nce_fp_match_ack_mp;
	uchar_t	*mp_rptr, *ud_mp_rptr;
	mblk_t		*ud_mp = nce->nce_dlur_mp;
	ptrdiff_t	cmplen;

	/*
	 * mp is the mp associated with the fastpath ack.
	 * ud_mp is the outstanding DL_UNITDATA_REQ on the nce_t
	 * under consideration. If the contents match, then the
	 * fastpath ack is used to update the nce.
	 */
	if (ud_mp == NULL)
		return (0);
	mp_rptr = mp->b_rptr;
	cmplen = mp->b_wptr - mp_rptr;
	ASSERT(cmplen >= 0);

	ud_mp_rptr = ud_mp->b_rptr;
	/*
	 * The ncec is locked here to prevent any other threads from accessing
	 * and changing nce_dlur_mp when the address becomes resolved to an
	 * lla while we're in the middle of looking at and comparing the
	 * hardware address (lla). It is also locked to prevent multiple
	 * threads in nce_fastpath() from examining nce_dlur_mp at the same
	 * time.
	 */
	mutex_enter(&ncec->ncec_lock);
	if (ud_mp->b_wptr - ud_mp_rptr != cmplen ||
	    bcmp((char *)mp_rptr, (char *)ud_mp_rptr, cmplen) == 0) {
		nce_fp_marg->nce_fp_match_res = nce;
		mutex_exit(&ncec->ncec_lock);
		nce_refhold(nce);
		return (1);
	}
	mutex_exit(&ncec->ncec_lock);
	return (0);
}

/*
 * Update all NCE's that are not in fastpath mode and
 * have an nce_fp_mp that matches mp. mp->b_cont contains
 * the fastpath header.
 *
 * Returns TRUE if entry should be dequeued, or FALSE otherwise.
 */
void
nce_fastpath_update(ill_t *ill,  mblk_t *mp)
{
	nce_fp_match_t nce_fp_marg;
	nce_t *nce;
	mblk_t *nce_fp_mp, *fp_mp;

	nce_fp_marg.nce_fp_match_res = NULL;
	nce_fp_marg.nce_fp_match_ack_mp = mp;

	nce_walk(ill, nce_fastpath_match_dlur, &nce_fp_marg);

	if ((nce = nce_fp_marg.nce_fp_match_res) == NULL)
		return;

	mutex_enter(&nce->nce_lock);
	nce_fp_mp = nce->nce_fp_mp;

	if (nce_fp_mp != NULL) {
		fp_mp = mp->b_cont;
		if (nce_fp_mp->b_rptr + MBLKL(fp_mp) >
		    nce_fp_mp->b_datap->db_lim) {
			mutex_exit(&nce->nce_lock);
			nce = nce_delete_then_add(nce);
			if (nce == NULL) {
				return;
			}
			mutex_enter(&nce->nce_lock);
			nce_fp_mp = nce->nce_fp_mp;
		}
	}

	/* Matched - install mp as the fastpath mp */
	if (nce_fp_mp == NULL) {
		fp_mp = dupb(mp->b_cont);
		nce->nce_fp_mp = fp_mp;
	} else {
		fp_mp = mp->b_cont;
		bcopy(fp_mp->b_rptr, nce_fp_mp->b_rptr, MBLKL(fp_mp));
		nce->nce_fp_mp->b_wptr = nce->nce_fp_mp->b_rptr
		    + MBLKL(fp_mp);
	}
	mutex_exit(&nce->nce_lock);
	nce_refrele(nce);
}

/*
 * Return a pointer to a given option in the packet.
 * Assumes that option part of the packet have already been validated.
 */
nd_opt_hdr_t *
ndp_get_option(nd_opt_hdr_t *opt, int optlen, int opt_type)
{
	while (optlen > 0) {
		if (opt->nd_opt_type == opt_type)
			return (opt);
		optlen -= 8 * opt->nd_opt_len;
		opt = (struct nd_opt_hdr *)((char *)opt + 8 * opt->nd_opt_len);
	}
	return (NULL);
}

/*
 * Verify all option lengths present are > 0, also check to see
 * if the option lengths and packet length are consistent.
 */
boolean_t
ndp_verify_optlen(nd_opt_hdr_t *opt, int optlen)
{
	ASSERT(opt != NULL);
	while (optlen > 0) {
		if (opt->nd_opt_len == 0)
			return (B_FALSE);
		optlen -= 8 * opt->nd_opt_len;
		if (optlen < 0)
			return (B_FALSE);
		opt = (struct nd_opt_hdr *)((char *)opt + 8 * opt->nd_opt_len);
	}
	return (B_TRUE);
}

/*
 * ncec_walk function.
 * Free a fraction of the NCE cache entries.
 *
 * A possible optimization here would be to use ncec_last where possible, and
 * delete the least-frequently used entry, which would require more complex
 * computation as we walk through the ncec's (e.g., track ncec entries by
 * order of ncec_last and/or maintain state)
 */
static void
ncec_cache_reclaim(ncec_t *ncec, void *arg)
{
	ip_stack_t	*ipst = ncec->ncec_ipst;
	uint_t		fraction = *(uint_t *)arg;
	uint_t		rand;

	if ((ncec->ncec_flags &
	    (NCE_F_MYADDR | NCE_F_STATIC | NCE_F_BCAST)) != 0) {
		return;
	}

	rand = (uint_t)ddi_get_lbolt() +
	    NCE_ADDR_HASH_V6(ncec->ncec_addr, NCE_TABLE_SIZE);
	if ((rand/fraction)*fraction == rand) {
		IP_STAT(ipst, ip_nce_reclaim_deleted);
		ncec_delete(ncec);
	}
}

/*
 * kmem_cache callback to free up memory.
 *
 * For now we just delete a fixed fraction.
 */
static void
ip_nce_reclaim_stack(ip_stack_t *ipst)
{
	uint_t		fraction = ipst->ips_ip_nce_reclaim_fraction;

	IP_STAT(ipst, ip_nce_reclaim_calls);

	ncec_walk(NULL, ncec_cache_reclaim, &fraction, ipst);

	/*
	 * Walk all CONNs that can have a reference on an ire, ncec or dce.
	 * Get them to update any stale references to drop any refholds they
	 * have.
	 */
	ipcl_walk(conn_ixa_cleanup, (void *)B_FALSE, ipst);
}

/*
 * Called by the memory allocator subsystem directly, when the system
 * is running low on memory.
 */
/* ARGSUSED */
void
ip_nce_reclaim(void *args)
{
	netstack_handle_t nh;
	netstack_t *ns;
	ip_stack_t *ipst;

	netstack_next_init(&nh);
	while ((ns = netstack_next(&nh)) != NULL) {
		/*
		 * netstack_next() can return a netstack_t with a NULL
		 * netstack_ip at boot time.
		 */
		if ((ipst = ns->netstack_ip) == NULL) {
			netstack_rele(ns);
			continue;
		}
		ip_nce_reclaim_stack(ipst);
		netstack_rele(ns);
	}
	netstack_next_fini(&nh);
}

#ifdef DEBUG
void
ncec_trace_ref(ncec_t *ncec)
{
	ASSERT(MUTEX_HELD(&ncec->ncec_lock));

	if (ncec->ncec_trace_disable)
		return;

	if (!th_trace_ref(ncec, ncec->ncec_ipst)) {
		ncec->ncec_trace_disable = B_TRUE;
		ncec_trace_cleanup(ncec);
	}
}

void
ncec_untrace_ref(ncec_t *ncec)
{
	ASSERT(MUTEX_HELD(&ncec->ncec_lock));

	if (!ncec->ncec_trace_disable)
		th_trace_unref(ncec);
}

static void
ncec_trace_cleanup(const ncec_t *ncec)
{
	th_trace_cleanup(ncec, ncec->ncec_trace_disable);
}
#endif

/*
 * Called when address resolution fails due to a timeout.
 * Send an ICMP unreachable in response to all queued packets.
 */
void
arp_resolv_failed(ncec_t *ncec)
{
	mblk_t	*mp, *nxt_mp;
	char	buf[INET6_ADDRSTRLEN];
	struct in_addr ipv4addr;
	ill_t *ill = ncec->ncec_ill;
	ip_stack_t *ipst = ncec->ncec_ipst;
	ip_recv_attr_t	iras;

	bzero(&iras, sizeof (iras));
	iras.ira_flags = IRAF_IS_IPV4;
	/*
	 * we are setting the ira_rill to the ipmp_ill (instead of
	 * the actual ill on which the packet was received), but this
	 * is ok because we don't actually need the real ira_rill.
	 * to send the icmp unreachable to the sender.
	 */
	iras.ira_ill = iras.ira_rill = ill;
	iras.ira_ruifindex = ill->ill_phyint->phyint_ifindex;
	iras.ira_rifindex = iras.ira_ruifindex;

	IN6_V4MAPPED_TO_INADDR(&ncec->ncec_addr, &ipv4addr);
	ip3dbg(("arp_resolv_failed: dst %s\n",
	    inet_ntop(AF_INET, &ipv4addr, buf, sizeof (buf))));
	mutex_enter(&ncec->ncec_lock);
	mp = ncec->ncec_qd_mp;
	ncec->ncec_qd_mp = NULL;
	ncec->ncec_nprobes = 0;
	mutex_exit(&ncec->ncec_lock);
	while (mp != NULL) {
		nxt_mp = mp->b_next;
		mp->b_next = NULL;

		BUMP_MIB(ill->ill_ip_mib, ipIfStatsOutDiscards);
		ip_drop_output("ipIfStatsOutDiscards - address unreachable",
		    mp, ill);
		if (ipst->ips_ip_arp_icmp_error) {
			ip3dbg(("arp_resolv_failed: "
			    "Calling icmp_unreachable\n"));
			icmp_unreachable(mp, ICMP_HOST_UNREACHABLE, &iras);
		} else {
			freemsg(mp);
		}
		ASSERT(!(iras.ira_flags & IRAF_IPSEC_SECURE));
		mp = nxt_mp;
	}
	ncec_cb_dispatch(ncec); /* finish off waiting callbacks */
}

/*
 * if ill is an under_ill, translate it to the ipmp_ill and add the
 * nce on the ipmp_ill. Two nce_t entries (one on the ipmp_ill, and
 * one on the underlying in_ill) will be created for the
 * ncec_t in this case. The ncec_t itself will be created on the ipmp_ill.
 */
int
nce_lookup_then_add_v4(ill_t *ill, uchar_t *hw_addr, uint_t hw_addr_len,
    const in_addr_t *addr, uint16_t flags, uint16_t state, nce_t **newnce)
{
	int	err;
	in6_addr_t addr6;
	ip_stack_t *ipst = ill->ill_ipst;
	nce_t	*nce, *upper_nce = NULL;
	ill_t	*in_ill = ill, *under = NULL;
	boolean_t need_ill_refrele = B_FALSE;

	if (flags & NCE_F_MCAST) {
		/*
		 * hw_addr will be figured out in nce_set_multicast_v4;
		 * caller needs to pass in the cast_ill for ipmp
		 */
		ASSERT(hw_addr == NULL);
		ASSERT(!IS_IPMP(ill));
		err = nce_set_multicast_v4(ill, addr, flags, newnce);
		return (err);
	}

	if (IS_UNDER_IPMP(ill) && !(flags & NCE_F_MYADDR)) {
		ill = ipmp_ill_hold_ipmp_ill(ill);
		if (ill == NULL)
			return (ENXIO);
		need_ill_refrele = B_TRUE;
	}
	if ((flags & NCE_F_BCAST) != 0) {
		/*
		 * IPv4 broadcast ncec: compute the hwaddr.
		 */
		if (IS_IPMP(ill)) {
			under = ipmp_ill_hold_xmit_ill(ill, B_FALSE);
			if (under == NULL)  {
				if (need_ill_refrele)
					ill_refrele(ill);
				return (ENETDOWN);
			}
			hw_addr = under->ill_bcast_mp->b_rptr +
			    NCE_LL_ADDR_OFFSET(under);
			hw_addr_len = under->ill_phys_addr_length;
		} else {
			hw_addr = ill->ill_bcast_mp->b_rptr +
			    NCE_LL_ADDR_OFFSET(ill),
			    hw_addr_len = ill->ill_phys_addr_length;
		}
	}

	mutex_enter(&ipst->ips_ndp4->ndp_g_lock);
	IN6_IPADDR_TO_V4MAPPED(*addr, &addr6);
	nce = nce_lookup_addr(ill, &addr6);
	if (nce == NULL) {
		err = nce_add_v4(ill, hw_addr, hw_addr_len, addr, flags,
		    state, &nce);
	} else {
		err = EEXIST;
	}
	mutex_exit(&ipst->ips_ndp4->ndp_g_lock);
	if (err == 0)
		err = nce_add_v4_postprocess(nce);

	if (in_ill != ill && nce != NULL) {
		nce_t *under_nce = NULL;

		/*
		 * in_ill was the under_ill. Try to create the under_nce.
		 * Hold the ill_g_lock to prevent changes to group membership
		 * until we are done.
		 */
		rw_enter(&ipst->ips_ill_g_lock, RW_READER);
		if (!IS_IN_SAME_ILLGRP(in_ill, ill)) {
			DTRACE_PROBE2(ill__not__in__group, nce_t *, nce,
			    ill_t *, ill);
			rw_exit(&ipst->ips_ill_g_lock);
			err = ENXIO;
			nce_refrele(nce);
			nce = NULL;
			goto bail;
		}
		under_nce = nce_fastpath_create(in_ill, nce->nce_common);
		if (under_nce == NULL) {
			rw_exit(&ipst->ips_ill_g_lock);
			err = EINVAL;
			nce_refrele(nce);
			nce = NULL;
			goto bail;
		}
		rw_exit(&ipst->ips_ill_g_lock);
		upper_nce = nce;
		nce = under_nce; /* will be returned to caller */
		if (NCE_ISREACHABLE(nce->nce_common))
			nce_fastpath_trigger(under_nce);
	}
	if (nce != NULL) {
		if (newnce != NULL)
			*newnce = nce;
		else
			nce_refrele(nce);
	}
bail:
	if (under != NULL)
		ill_refrele(under);
	if (upper_nce != NULL)
		nce_refrele(upper_nce);
	if (need_ill_refrele)
		ill_refrele(ill);

	return (err);
}

/*
 * NDP Cache Entry creation routine for IPv4.
 * This routine must always be called with ndp4->ndp_g_lock held.
 * Prior to return, ncec_refcnt is incremented.
 *
 * IPMP notes: the ncec for non-local (i.e., !NCE_MYADDR(ncec) addresses
 * are always added pointing at the ipmp_ill. Thus, when the ill passed
 * to nce_add_v4 is an under_ill (i.e., IS_UNDER_IPMP(ill)) two nce_t
 * entries will be created, both pointing at the same ncec_t. The nce_t
 * entries will have their nce_ill set to the ipmp_ill and the under_ill
 * respectively, with the ncec_t having its ncec_ill pointing at the ipmp_ill.
 * Local addresses are always created on the ill passed to nce_add_v4.
 */
int
nce_add_v4(ill_t *ill, uchar_t *hw_addr, uint_t hw_addr_len,
    const in_addr_t *addr, uint16_t flags, uint16_t state, nce_t **newnce)
{
	int		err;
	boolean_t	is_multicast = (flags & NCE_F_MCAST);
	struct in6_addr	addr6;
	nce_t		*nce;

	ASSERT(MUTEX_HELD(&ill->ill_ipst->ips_ndp4->ndp_g_lock));
	ASSERT(!ill->ill_isv6);
	ASSERT(!IN_MULTICAST(htonl(*addr)) || is_multicast);

	IN6_IPADDR_TO_V4MAPPED(*addr, &addr6);
	err = nce_add_common(ill, hw_addr, hw_addr_len, &addr6, flags, state,
	    &nce);
	ASSERT(newnce != NULL);
	*newnce = nce;
	return (err);
}

/*
 * Post-processing routine to be executed after nce_add_v4(). This function
 * triggers fastpath (if appropriate) and DAD on the newly added nce entry
 * and must be called without any locks held.
 *
 * Always returns 0, but we return an int to keep this symmetric with the
 * IPv6 counter-part.
 */
int
nce_add_v4_postprocess(nce_t *nce)
{
	ncec_t		*ncec = nce->nce_common;
	uint16_t	flags = ncec->ncec_flags;
	boolean_t	ndp_need_dad = B_FALSE;
	boolean_t	dropped;
	clock_t		delay;
	ip_stack_t	*ipst = ncec->ncec_ill->ill_ipst;
	uchar_t		*hw_addr = ncec->ncec_lladdr;
	boolean_t	trigger_fastpath = B_TRUE;

	/*
	 * If the hw_addr is NULL, typically for ND_INCOMPLETE nces, then
	 * we call nce_fastpath as soon as the ncec is resolved in nce_process.
	 * We call nce_fastpath from nce_update if the link layer address of
	 * the peer changes from nce_update
	 */
	if (NCE_PUBLISH(ncec) || !NCE_ISREACHABLE(ncec) || (hw_addr == NULL &&
	    ncec->ncec_ill->ill_net_type != IRE_IF_NORESOLVER))
		trigger_fastpath = B_FALSE;

	if (trigger_fastpath)
		nce_fastpath_trigger(nce);

	if (NCE_PUBLISH(ncec) && ncec->ncec_state == ND_PROBE) {
		/*
		 * Either the caller (by passing in ND_PROBE)
		 * or nce_add_common() (by the internally computed state
		 * based on ncec_addr and ill_net_type) has determined
		 * that this unicast entry needs DAD. Trigger DAD.
		 */
		ndp_need_dad = B_TRUE;
	} else if (flags & NCE_F_UNSOL_ADV) {
		/*
		 * We account for the transmit below by assigning one
		 * less than the ndd variable. Subsequent decrements
		 * are done in nce_timer.
		 */
		mutex_enter(&ncec->ncec_lock);
		ncec->ncec_unsolicit_count =
		    ipst->ips_ip_arp_publish_count - 1;
		mutex_exit(&ncec->ncec_lock);
		dropped = arp_announce(ncec);
		mutex_enter(&ncec->ncec_lock);
		if (dropped)
			ncec->ncec_unsolicit_count++;
		else
			ncec->ncec_last_time_defended = ddi_get_lbolt();
		if (ncec->ncec_unsolicit_count != 0) {
			nce_start_timer(ncec,
			    ipst->ips_ip_arp_publish_interval);
		}
		mutex_exit(&ncec->ncec_lock);
	}

	/*
	 * If ncec_xmit_interval is 0, user has configured us to send the first
	 * probe right away.  Do so, and set up for the subsequent probes.
	 */
	if (ndp_need_dad) {
		mutex_enter(&ncec->ncec_lock);
		if (ncec->ncec_pcnt == 0) {
			/*
			 * DAD probes and announce can be
			 * administratively disabled by setting the
			 * probe_count to zero. Restart the timer in
			 * this case to mark the ipif as ready.
			 */
			ncec->ncec_unsolicit_count = 0;
			mutex_exit(&ncec->ncec_lock);
			nce_restart_timer(ncec, 0);
		} else {
			mutex_exit(&ncec->ncec_lock);
			delay = ((ncec->ncec_flags & NCE_F_FAST) ?
			    ipst->ips_arp_probe_delay :
			    ipst->ips_arp_fastprobe_delay);
			nce_dad(ncec, NULL, (delay == 0 ? B_TRUE : B_FALSE));
		}
	}
	return (0);
}

/*
 * ncec_walk routine to update all entries that have a given destination or
 * gateway address and cached link layer (MAC) address.  This is used when ARP
 * informs us that a network-to-link-layer mapping may have changed.
 */
void
nce_update_hw_changed(ncec_t *ncec, void *arg)
{
	nce_hw_map_t *hwm = arg;
	ipaddr_t ncec_addr;

	if (ncec->ncec_state != ND_REACHABLE)
		return;

	IN6_V4MAPPED_TO_IPADDR(&ncec->ncec_addr, ncec_addr);
	if (ncec_addr != hwm->hwm_addr)
		return;

	mutex_enter(&ncec->ncec_lock);
	if (hwm->hwm_flags != 0)
		ncec->ncec_flags = hwm->hwm_flags;
	nce_update(ncec, ND_STALE, hwm->hwm_hwaddr);
	mutex_exit(&ncec->ncec_lock);
}

void
ncec_refhold(ncec_t *ncec)
{
	mutex_enter(&(ncec)->ncec_lock);
	(ncec)->ncec_refcnt++;
	ASSERT((ncec)->ncec_refcnt != 0);
#ifdef DEBUG
	ncec_trace_ref(ncec);
#endif
	mutex_exit(&(ncec)->ncec_lock);
}

void
ncec_refhold_notr(ncec_t *ncec)
{
	mutex_enter(&(ncec)->ncec_lock);
	(ncec)->ncec_refcnt++;
	ASSERT((ncec)->ncec_refcnt != 0);
	mutex_exit(&(ncec)->ncec_lock);
}

static void
ncec_refhold_locked(ncec_t *ncec)
{
	ASSERT(MUTEX_HELD(&(ncec)->ncec_lock));
	(ncec)->ncec_refcnt++;
#ifdef DEBUG
	ncec_trace_ref(ncec);
#endif
}

/* ncec_inactive destroys the mutex thus no mutex_exit is needed */
void
ncec_refrele(ncec_t *ncec)
{
	mutex_enter(&(ncec)->ncec_lock);
#ifdef DEBUG
	ncec_untrace_ref(ncec);
#endif
	ASSERT((ncec)->ncec_refcnt != 0);
	if (--(ncec)->ncec_refcnt == 0) {
		ncec_inactive(ncec);
	} else {
		mutex_exit(&(ncec)->ncec_lock);
	}
}

void
ncec_refrele_notr(ncec_t *ncec)
{
	mutex_enter(&(ncec)->ncec_lock);
	ASSERT((ncec)->ncec_refcnt != 0);
	if (--(ncec)->ncec_refcnt == 0) {
		ncec_inactive(ncec);
	} else {
		mutex_exit(&(ncec)->ncec_lock);
	}
}

/*
 * Common to IPv4 and IPv6.
 */
void
nce_restart_timer(ncec_t *ncec, uint_t ms)
{
	timeout_id_t tid;

	ASSERT(!MUTEX_HELD(&(ncec)->ncec_lock));

	/* First cancel any running timer */
	mutex_enter(&ncec->ncec_lock);
	tid = ncec->ncec_timeout_id;
	ncec->ncec_timeout_id = 0;
	if (tid != 0) {
		mutex_exit(&ncec->ncec_lock);
		(void) untimeout(tid);
		mutex_enter(&ncec->ncec_lock);
	}

	/* Restart timer */
	nce_start_timer(ncec, ms);
	mutex_exit(&ncec->ncec_lock);
}

static void
nce_start_timer(ncec_t *ncec, uint_t ms)
{
	ASSERT(MUTEX_HELD(&ncec->ncec_lock));
	/*
	 * Don't start the timer if the ncec has been deleted, or if the timer
	 * is already running
	 */
	if (!NCE_ISCONDEMNED(ncec) && ncec->ncec_timeout_id == 0) {
		ncec->ncec_timeout_id = timeout(nce_timer, ncec,
		    MSEC_TO_TICK(ms) == 0 ? 1 : MSEC_TO_TICK(ms));
	}
}

int
nce_set_multicast_v4(ill_t *ill, const in_addr_t *dst,
    uint16_t flags, nce_t **newnce)
{
	uchar_t		*hw_addr;
	int		err = 0;
	ip_stack_t	*ipst = ill->ill_ipst;
	in6_addr_t	dst6;
	nce_t		*nce;

	ASSERT(!ill->ill_isv6);

	IN6_IPADDR_TO_V4MAPPED(*dst, &dst6);
	mutex_enter(&ipst->ips_ndp4->ndp_g_lock);
	if ((nce = nce_lookup_addr(ill, &dst6)) != NULL) {
		mutex_exit(&ipst->ips_ndp4->ndp_g_lock);
		goto done;
	}
	if (ill->ill_net_type == IRE_IF_RESOLVER) {
		/*
		 * For IRE_IF_RESOLVER a hardware mapping can be
		 * generated, for IRE_IF_NORESOLVER, resolution cookie
		 * in the ill is copied in nce_add_v4().
		 */
		hw_addr = kmem_alloc(ill->ill_phys_addr_length, KM_NOSLEEP);
		if (hw_addr == NULL) {
			mutex_exit(&ipst->ips_ndp4->ndp_g_lock);
			return (ENOMEM);
		}
		ip_mcast_mapping(ill, (uchar_t *)dst, hw_addr);
	} else {
		/*
		 * IRE_IF_NORESOLVER type simply copies the resolution
		 * cookie passed in.  So no hw_addr is needed.
		 */
		hw_addr = NULL;
	}
	ASSERT(flags & NCE_F_MCAST);
	ASSERT(flags & NCE_F_NONUD);
	/* nce_state will be computed by nce_add_common() */
	err = nce_add_v4(ill, hw_addr, ill->ill_phys_addr_length, dst, flags,
	    ND_UNCHANGED, &nce);
	mutex_exit(&ipst->ips_ndp4->ndp_g_lock);
	if (err == 0)
		err = (nce != NULL) ? nce_add_v4_postprocess(nce) : ENOMEM;
	if (hw_addr != NULL)
		kmem_free(hw_addr, ill->ill_phys_addr_length);
	if (err != 0) {
		ip1dbg(("nce_set_multicast_v4: create failed" "%d\n", err));
		return (err);
	}
done:
	if (newnce != NULL)
		*newnce = nce;
	else
		nce_refrele(nce);
	return (0);
}

/*
 * This is used when scanning for "old" (least recently broadcast) NCEs.  We
 * don't want to have to walk the list for every single one, so we gather up
 * batches at a time.
 */
#define	NCE_RESCHED_LIST_LEN	8

typedef struct {
	ill_t	*ncert_ill;
	uint_t	ncert_num;
	ncec_t	*ncert_nces[NCE_RESCHED_LIST_LEN];
} nce_resched_t;

/*
 * Pick the longest waiting NCEs for defense.
 */
/* ARGSUSED */
static int
ncec_reschedule(ill_t *ill, nce_t *nce, void *arg)
{
	nce_resched_t *ncert = arg;
	ncec_t **ncecs;
	ncec_t **ncec_max;
	ncec_t *ncec_temp;
	ncec_t *ncec = nce->nce_common;

	ASSERT(ncec->ncec_ill == ncert->ncert_ill);
	/*
	 * Only reachable entries that are ready for announcement are eligible.
	 */
	if (!NCE_MYADDR(ncec) || ncec->ncec_state != ND_REACHABLE)
		return (0);
	if (ncert->ncert_num < NCE_RESCHED_LIST_LEN) {
		ncec_refhold(ncec);
		ncert->ncert_nces[ncert->ncert_num++] = ncec;
	} else {
		ncecs = ncert->ncert_nces;
		ncec_max = ncecs + NCE_RESCHED_LIST_LEN;
		ncec_refhold(ncec);
		for (; ncecs < ncec_max; ncecs++) {
			ASSERT(ncec != NULL);
			if ((*ncecs)->ncec_last_time_defended >
			    ncec->ncec_last_time_defended) {
				ncec_temp = *ncecs;
				*ncecs = ncec;
				ncec = ncec_temp;
			}
		}
		ncec_refrele(ncec);
	}
	return (0);
}

/*
 * Reschedule the ARP defense of any long-waiting NCEs.  It's assumed that this
 * doesn't happen very often (if at all), and thus it needn't be highly
 * optimized.  (Note, though, that it's actually O(N) complexity, because the
 * outer loop is bounded by a constant rather than by the length of the list.)
 */
static void
nce_ill_reschedule(ill_t *ill, nce_resched_t *ncert)
{
	ncec_t		*ncec;
	ip_stack_t	*ipst = ill->ill_ipst;
	uint_t		i, defend_rate;

	i = ill->ill_defend_count;
	ill->ill_defend_count = 0;
	if (ill->ill_isv6)
		defend_rate = ipst->ips_ndp_defend_rate;
	else
		defend_rate = ipst->ips_arp_defend_rate;
	/* If none could be sitting around, then don't reschedule */
	if (i < defend_rate) {
		DTRACE_PROBE1(reschedule_none, ill_t *, ill);
		return;
	}
	ncert->ncert_ill = ill;
	while (ill->ill_defend_count < defend_rate) {
		nce_walk_common(ill, ncec_reschedule, ncert);
		for (i = 0; i < ncert->ncert_num; i++) {

			ncec = ncert->ncert_nces[i];
			mutex_enter(&ncec->ncec_lock);
			ncec->ncec_flags |= NCE_F_DELAYED;
			mutex_exit(&ncec->ncec_lock);
			/*
			 * we plan to schedule this ncec, so incr the
			 * defend_count in anticipation.
			 */
			if (++ill->ill_defend_count >= defend_rate)
				break;
		}
		if (ncert->ncert_num < NCE_RESCHED_LIST_LEN)
			break;
	}
}

/*
 * Check if the current rate-limiting parameters permit the sending
 * of another address defense announcement for both IPv4 and IPv6.
 * Returns B_TRUE if rate-limiting is in effect (i.e., send is not
 * permitted), and B_FALSE otherwise. The `defend_rate' parameter
 * determines how many address defense announcements are permitted
 * in any `defense_perio' interval.
 */
static boolean_t
ill_defend_rate_limit(ill_t *ill, ncec_t *ncec)
{
	clock_t		now = ddi_get_lbolt();
	ip_stack_t	*ipst = ill->ill_ipst;
	clock_t		start = ill->ill_defend_start;
	uint32_t	elapsed, defend_period, defend_rate;
	nce_resched_t	ncert;
	boolean_t	ret;
	int		i;

	if (ill->ill_isv6) {
		defend_period = ipst->ips_ndp_defend_period;
		defend_rate = ipst->ips_ndp_defend_rate;
	} else {
		defend_period = ipst->ips_arp_defend_period;
		defend_rate = ipst->ips_arp_defend_rate;
	}
	if (defend_rate == 0)
		return (B_TRUE);
	bzero(&ncert, sizeof (ncert));
	mutex_enter(&ill->ill_lock);
	if (start > 0) {
		elapsed = now - start;
		if (elapsed > SEC_TO_TICK(defend_period)) {
			ill->ill_defend_start = now;
			/*
			 * nce_ill_reschedule will attempt to
			 * prevent starvation by reschduling the
			 * oldest entries, which are marked with
			 * the NCE_F_DELAYED flag.
			 */
			nce_ill_reschedule(ill, &ncert);
		}
	} else {
		ill->ill_defend_start = now;
	}
	ASSERT(ill->ill_defend_count <= defend_rate);
	mutex_enter(&ncec->ncec_lock);
	if (ncec->ncec_flags & NCE_F_DELAYED) {
		/*
		 * This ncec was rescheduled as one of the really old
		 * entries needing on-going defense. The
		 * ill_defend_count was already incremented in
		 * nce_ill_reschedule. Go ahead and send the announce.
		 */
		ncec->ncec_flags &= ~NCE_F_DELAYED;
		mutex_exit(&ncec->ncec_lock);
		ret = B_FALSE;
		goto done;
	}
	mutex_exit(&ncec->ncec_lock);
	if (ill->ill_defend_count < defend_rate)
		ill->ill_defend_count++;
	if (ill->ill_defend_count == defend_rate) {
		/*
		 * we are no longer allowed to send unbidden defense
		 * messages. Wait for rescheduling.
		 */
		ret = B_TRUE;
	} else {
		ret = B_FALSE;
	}
done:
	mutex_exit(&ill->ill_lock);
	/*
	 * After all the locks have been dropped we can restart nce timer,
	 * and refrele the delayed ncecs
	 */
	for (i = 0; i < ncert.ncert_num; i++) {
		clock_t	xmit_interval;
		ncec_t	*tmp;

		tmp = ncert.ncert_nces[i];
		xmit_interval = nce_fuzz_interval(tmp->ncec_xmit_interval,
		    B_FALSE);
		nce_restart_timer(tmp, xmit_interval);
		ncec_refrele(tmp);
	}
	return (ret);
}

boolean_t
ndp_announce(ncec_t *ncec)
{
	return (ndp_xmit(ncec->ncec_ill, ND_NEIGHBOR_ADVERT, ncec->ncec_lladdr,
	    ncec->ncec_lladdr_length, &ncec->ncec_addr, &ipv6_all_hosts_mcast,
	    nce_advert_flags(ncec)));
}

ill_t *
nce_resolve_src(ncec_t *ncec, in6_addr_t *src)
{
	mblk_t		*mp;
	in6_addr_t	src6;
	ipaddr_t	src4;
	ill_t		*ill = ncec->ncec_ill;
	ill_t		*src_ill = NULL;
	ipif_t		*ipif = NULL;
	boolean_t	is_myaddr = NCE_MYADDR(ncec);
	boolean_t	isv6 = (ncec->ncec_ipversion == IPV6_VERSION);

	ASSERT(src != NULL);
	ASSERT(IN6_IS_ADDR_UNSPECIFIED(src));
	src4 = 0;
	src6 = *src;
	if (is_myaddr) {
		src6 = ncec->ncec_addr;
		if (!isv6)
			IN6_V4MAPPED_TO_IPADDR(&ncec->ncec_addr, src4);
	} else {
		/*
		 * try to find one from the outgoing packet.
		 */
		mutex_enter(&ncec->ncec_lock);
		mp = ncec->ncec_qd_mp;
		if (mp != NULL) {
			if (isv6) {
				ip6_t	*ip6h = (ip6_t *)mp->b_rptr;

				src6 = ip6h->ip6_src;
			} else {
				ipha_t  *ipha = (ipha_t *)mp->b_rptr;

				src4 = ipha->ipha_src;
				IN6_IPADDR_TO_V4MAPPED(src4, &src6);
			}
		}
		mutex_exit(&ncec->ncec_lock);
	}

	/*
	 * For outgoing packets, if the src of outgoing packet is one
	 * of the assigned interface addresses use it, otherwise we
	 * will pick the source address below.
	 * For local addresses (is_myaddr) doing DAD, NDP announce
	 * messages are mcast. So we use the (IPMP) cast_ill or the
	 * (non-IPMP) ncec_ill for these message types. The only case
	 * of unicast DAD messages are for IPv6 ND probes, for which
	 * we find the ipif_bound_ill corresponding to the ncec_addr.
	 */
	if (!IN6_IS_ADDR_UNSPECIFIED(&src6) || is_myaddr) {
		if (isv6) {
			ipif = ipif_lookup_addr_nondup_v6(&src6, ill, ALL_ZONES,
			    ill->ill_ipst);
		} else {
			ipif = ipif_lookup_addr_nondup(src4, ill, ALL_ZONES,
			    ill->ill_ipst);
		}

		/*
		 * If no relevant ipif can be found, then it's not one of our
		 * addresses.  Reset to :: and try to find a src for the NS or
		 * ARP request using ipif_select_source_v[4,6]  below.
		 * If an ipif can be found, but it's not yet done with
		 * DAD verification, and we are not being invoked for
		 * DAD (i.e., !is_myaddr), then just postpone this
		 * transmission until later.
		 */
		if (ipif == NULL) {
			src6 = ipv6_all_zeros;
			src4 = INADDR_ANY;
		} else if (!ipif->ipif_addr_ready && !is_myaddr) {
			DTRACE_PROBE2(nce__resolve__ipif__not__ready,
			    ncec_t *, ncec, ipif_t *, ipif);
			ipif_refrele(ipif);
			return (NULL);
		}
	}

	if (IN6_IS_ADDR_UNSPECIFIED(&src6) && !is_myaddr) {
		/*
		 * Pick a source address for this solicitation, but
		 * restrict the selection to addresses assigned to the
		 * output interface.  We do this because the destination will
		 * create a neighbor cache entry for the source address of
		 * this packet, so the source address had better be a valid
		 * neighbor.
		 */
		if (isv6) {
			ipif = ipif_select_source_v6(ill, &ncec->ncec_addr,
			    B_TRUE, IPV6_PREFER_SRC_DEFAULT, ALL_ZONES,
			    B_FALSE, NULL);
		} else {
			ipaddr_t nce_addr;

			IN6_V4MAPPED_TO_IPADDR(&ncec->ncec_addr, nce_addr);
			ipif = ipif_select_source_v4(ill, nce_addr, ALL_ZONES,
			    B_FALSE, NULL);
		}
		if (ipif == NULL && IS_IPMP(ill)) {
			ill_t *send_ill = ipmp_ill_hold_xmit_ill(ill, B_TRUE);

			if (send_ill != NULL) {
				if (isv6) {
					ipif = ipif_select_source_v6(send_ill,
					    &ncec->ncec_addr, B_TRUE,
					    IPV6_PREFER_SRC_DEFAULT, ALL_ZONES,
					    B_FALSE, NULL);
				} else {
					IN6_V4MAPPED_TO_IPADDR(&ncec->ncec_addr,
					    src4);
					ipif = ipif_select_source_v4(send_ill,
					    src4, ALL_ZONES, B_TRUE, NULL);
				}
				ill_refrele(send_ill);
			}
		}

		if (ipif == NULL) {
			char buf[INET6_ADDRSTRLEN];

			ip1dbg(("nce_resolve_src: No source ipif for dst %s\n",
			    inet_ntop((isv6 ? AF_INET6 : AF_INET),
			    (char *)&ncec->ncec_addr, buf, sizeof (buf))));
			DTRACE_PROBE1(nce__resolve__no__ipif, ncec_t *, ncec);
			return (NULL);
		}
		src6 = ipif->ipif_v6lcl_addr;
	}
	*src = src6;
	if (ipif != NULL) {
		src_ill = ipif->ipif_ill;
		if (IS_IPMP(src_ill))
			src_ill = ipmp_ipif_hold_bound_ill(ipif);
		else
			ill_refhold(src_ill);
		ipif_refrele(ipif);
		DTRACE_PROBE2(nce__resolve__src__ill, ncec_t *, ncec,
		    ill_t *, src_ill);
	}
	return (src_ill);
}

void
ip_nce_lookup_and_update(ipaddr_t *addr, ipif_t *ipif, ip_stack_t *ipst,
    uchar_t *hwaddr, int hwaddr_len, int flags)
{
	ill_t	*ill;
	ncec_t	*ncec;
	nce_t	*nce;
	uint16_t new_state;

	ill = (ipif ? ipif->ipif_ill : NULL);
	if (ill != NULL) {
		/*
		 * only one ncec is possible
		 */
		nce = nce_lookup_v4(ill, addr);
		if (nce != NULL) {
			ncec = nce->nce_common;
			mutex_enter(&ncec->ncec_lock);
			if (NCE_ISREACHABLE(ncec))
				new_state = ND_UNCHANGED;
			else
				new_state = ND_STALE;
			ncec->ncec_flags = flags;
			nce_update(ncec, new_state, hwaddr);
			mutex_exit(&ncec->ncec_lock);
			nce_refrele(nce);
			return;
		}
	} else {
		/*
		 * ill is wildcard; clean up all ncec's and ire's
		 * that match on addr.
		 */
		nce_hw_map_t hwm;

		hwm.hwm_addr = *addr;
		hwm.hwm_hwlen = hwaddr_len;
		hwm.hwm_hwaddr = hwaddr;
		hwm.hwm_flags = flags;

		ncec_walk_common(ipst->ips_ndp4, NULL,
		    nce_update_hw_changed, &hwm, B_TRUE);
	}
}

/*
 * Common function to add ncec entries.
 * we always add the ncec with ncec_ill == ill, and always create
 * nce_t on ncec_ill. A dlpi fastpath message may be triggered if the
 * ncec is !reachable.
 *
 * When the caller passes in an nce_state of ND_UNCHANGED,
 * nce_add_common() will determine the state of the created nce based
 * on the ill_net_type and nce_flags used. Otherwise, the nce will
 * be created with state set to the passed in nce_state.
 */
static int
nce_add_common(ill_t *ill, uchar_t *hw_addr, uint_t hw_addr_len,
    const in6_addr_t *addr, uint16_t flags, uint16_t nce_state, nce_t **retnce)
{
	static	ncec_t		nce_nil;
	uchar_t			*template = NULL;
	int			err;
	ncec_t			*ncec;
	ncec_t			**ncep;
	ip_stack_t		*ipst = ill->ill_ipst;
	uint16_t		state;
	boolean_t		fastprobe = B_FALSE;
	struct ndp_g_s		*ndp;
	nce_t			*nce = NULL;
	list_t			graveyard;
	mblk_t			*dlur_mp = NULL;

	if (ill->ill_isv6)
		ndp = ill->ill_ipst->ips_ndp6;
	else
		ndp = ill->ill_ipst->ips_ndp4;

	*retnce = NULL;
	state = 0;

	ASSERT(MUTEX_HELD(&ndp->ndp_g_lock));

	if (IN6_IS_ADDR_UNSPECIFIED(addr)) {
		ip0dbg(("nce_add_common: no addr\n"));
		return (EINVAL);
	}
	if ((flags & ~NCE_EXTERNAL_FLAGS_MASK)) {
		ip0dbg(("nce_add_common: flags = %x\n", (int)flags));
		return (EINVAL);
	}

	if (ill->ill_isv6) {
		ncep = ((ncec_t **)NCE_HASH_PTR_V6(ipst, *addr));
	} else {
		ipaddr_t v4addr;

		IN6_V4MAPPED_TO_IPADDR(addr, v4addr);
		ncep = ((ncec_t **)NCE_HASH_PTR_V4(ipst, v4addr));
	}

	/*
	 * The caller has ensured that there is no nce on ill, but there could
	 * still be an nce_common_t for the address, so that we find exisiting
	 * ncec_t strucutures first, and atomically add a new nce_t if
	 * one is found. The ndp_g_lock ensures that we don't cross threads
	 * with an ncec_delete(). Unlike ncec_lookup_illgrp() we do not
	 * compare for matches across the illgrp because this function is
	 * called via nce_lookup_then_add_v* -> nce_add_v* -> nce_add_common,
	 * with the nce_lookup_then_add_v* passing in the ipmp_ill where
	 * appropriate.
	 */
	ncec = *ncep;
	for (; ncec != NULL; ncec = ncec->ncec_next) {
		if (ncec->ncec_ill == ill) {
			if (IN6_ARE_ADDR_EQUAL(&ncec->ncec_addr, addr)) {
				/*
				 * We should never find *retnce to be
				 * MYADDR, since the caller may then
				 * incorrectly restart a DAD timer that's
				 * already running.  However, if we are in
				 * forwarding mode, and the interface is
				 * moving in/out of groups, the data
				 * path ire lookup (e.g., ire_revalidate_nce)
				 * may  have determined that some destination
				 * is offlink while the control path is adding
				 * that address as a local address.
				 * Recover from  this case by failing the
				 * lookup
				 */
				if (NCE_MYADDR(ncec))
					return (ENXIO);
				*retnce = nce_ill_lookup_then_add(ill, ncec);
				if (*retnce != NULL)
					break;
			}
		}
	}
	if (*retnce != NULL) /* caller must trigger fastpath on nce */
		return (0);

	ncec = kmem_cache_alloc(ncec_cache, KM_NOSLEEP);
	if (ncec == NULL)
		return (ENOMEM);
	*ncec = nce_nil;
	ncec->ncec_ill = ill;
	ncec->ncec_ipversion = (ill->ill_isv6 ? IPV6_VERSION : IPV4_VERSION);
	ncec->ncec_flags = flags;
	ncec->ncec_ipst = ipst;	/* No netstack_hold */

	if (!ill->ill_isv6) {
		ipaddr_t addr4;

		/*
		 * DAD probe interval and probe count are set based on
		 * fast/slow probe settings. If the underlying link doesn't
		 * have reliably up/down notifications or if we're working
		 * with IPv4 169.254.0.0/16 Link Local Address space, then
		 * don't use the fast timers.  Otherwise, use them.
		 */
		ASSERT(IN6_IS_ADDR_V4MAPPED(addr));
		IN6_V4MAPPED_TO_IPADDR(addr, addr4);
		if (ill->ill_note_link && !IS_IPV4_LL_SPACE(&addr4)) {
			fastprobe = B_TRUE;
		} else if (IS_IPMP(ill) && NCE_PUBLISH(ncec) &&
		    !IS_IPV4_LL_SPACE(&addr4)) {
			ill_t *hwaddr_ill;

			hwaddr_ill = ipmp_illgrp_find_ill(ill->ill_grp, hw_addr,
			    hw_addr_len);
			if (hwaddr_ill != NULL && hwaddr_ill->ill_note_link)
				fastprobe = B_TRUE;
		}
		if (fastprobe) {
			ncec->ncec_xmit_interval =
			    ipst->ips_arp_fastprobe_interval;
			ncec->ncec_pcnt =
			    ipst->ips_arp_fastprobe_count;
			ncec->ncec_flags |= NCE_F_FAST;
		} else {
			ncec->ncec_xmit_interval =
			    ipst->ips_arp_probe_interval;
			ncec->ncec_pcnt =
			    ipst->ips_arp_probe_count;
		}
		if (NCE_PUBLISH(ncec)) {
			ncec->ncec_unsolicit_count =
			    ipst->ips_ip_arp_publish_count;
		}
	} else {
		/*
		 * probe interval is constant: ILL_PROBE_INTERVAL
		 * probe count is constant: ND_MAX_UNICAST_SOLICIT
		 */
		ncec->ncec_pcnt = ND_MAX_UNICAST_SOLICIT;
		if (NCE_PUBLISH(ncec)) {
			ncec->ncec_unsolicit_count =
			    ipst->ips_ip_ndp_unsolicit_count;
		}
	}
	ncec->ncec_rcnt = ill->ill_xmit_count;
	ncec->ncec_addr = *addr;
	ncec->ncec_qd_mp = NULL;
	ncec->ncec_refcnt = 1; /* for ncec getting created */
	mutex_init(&ncec->ncec_lock, NULL, MUTEX_DEFAULT, NULL);
	ncec->ncec_trace_disable = B_FALSE;

	/*
	 * ncec_lladdr holds link layer address
	 */
	if (hw_addr_len > 0) {
		template = kmem_alloc(hw_addr_len, KM_NOSLEEP);
		if (template == NULL) {
			err = ENOMEM;
			goto err_ret;
		}
		ncec->ncec_lladdr = template;
		ncec->ncec_lladdr_length = hw_addr_len;
		bzero(ncec->ncec_lladdr, hw_addr_len);
	}
	if ((flags & NCE_F_BCAST) != 0) {
		state = ND_REACHABLE;
		ASSERT(hw_addr_len > 0);
	} else if (ill->ill_net_type == IRE_IF_RESOLVER) {
		state = ND_INITIAL;
	} else if (ill->ill_net_type == IRE_IF_NORESOLVER) {
		/*
		 * NORESOLVER entries are always created in the REACHABLE
		 * state.
		 */
		state = ND_REACHABLE;
		if (ill->ill_phys_addr_length == IP_ADDR_LEN &&
		    ill->ill_mactype != DL_IPV4 &&
		    ill->ill_mactype != DL_6TO4) {
			/*
			 * We create a nce_res_mp with the IP nexthop address
			 * as the destination address if the physical length
			 * is exactly 4 bytes for point-to-multipoint links
			 * that do their own resolution from IP to link-layer
			 * address (e.g. IP over X.25).
			 */
			bcopy((uchar_t *)addr,
			    ncec->ncec_lladdr, ill->ill_phys_addr_length);
		}
		if (ill->ill_phys_addr_length == IPV6_ADDR_LEN &&
		    ill->ill_mactype != DL_IPV6) {
			/*
			 * We create a nce_res_mp with the IP nexthop address
			 * as the destination address if the physical legnth
			 * is exactly 16 bytes for point-to-multipoint links
			 * that do their own resolution from IP to link-layer
			 * address.
			 */
			bcopy((uchar_t *)addr,
			    ncec->ncec_lladdr, ill->ill_phys_addr_length);
		}
		/*
		 * Since NUD is not part of the base IPv4 protocol definition,
		 * IPv4 neighbor entries on NORESOLVER interfaces will never
		 * age, and are marked NCE_F_NONUD.
		 */
		if (!ill->ill_isv6)
			ncec->ncec_flags |= NCE_F_NONUD;
	} else if (ill->ill_net_type == IRE_LOOPBACK) {
		state = ND_REACHABLE;
	}

	if (hw_addr != NULL || ill->ill_net_type == IRE_IF_NORESOLVER) {
		/*
		 * We are adding an ncec with a deterministic hw_addr,
		 * so the state can only be one of {REACHABLE, STALE, PROBE}.
		 *
		 * if we are adding a unicast ncec for the local address
		 * it would be REACHABLE; we would be adding a ND_STALE entry
		 * for the requestor of an ARP_REQUEST/ND_SOLICIT. Our own
		 * addresses are added in PROBE to trigger DAD.
		 */
		if ((flags & (NCE_F_MCAST|NCE_F_BCAST)) ||
		    ill->ill_net_type == IRE_IF_NORESOLVER)
			state = ND_REACHABLE;
		else if (!NCE_PUBLISH(ncec))
			state = ND_STALE;
		else
			state = ND_PROBE;
		if (hw_addr != NULL)
			nce_set_ll(ncec, hw_addr);
	}
	/* caller overrides internally computed state */
	if (nce_state != ND_UNCHANGED)
		state = nce_state;

	if (state == ND_PROBE)
		ncec->ncec_flags |= NCE_F_UNVERIFIED;

	ncec->ncec_state = state;

	if (state == ND_REACHABLE) {
		ncec->ncec_last = ncec->ncec_init_time =
		    TICK_TO_MSEC(ddi_get_lbolt64());
	} else {
		ncec->ncec_last = 0;
		if (state == ND_INITIAL)
			ncec->ncec_init_time = TICK_TO_MSEC(ddi_get_lbolt64());
	}
	list_create(&ncec->ncec_cb, sizeof (ncec_cb_t),
	    offsetof(ncec_cb_t, ncec_cb_node));
	/*
	 * have all the memory allocations out of the way before taking locks
	 * and adding the nce.
	 */
	nce = kmem_cache_alloc(nce_cache, KM_NOSLEEP);
	if (nce == NULL) {
		err = ENOMEM;
		goto err_ret;
	}
	if (ncec->ncec_lladdr != NULL ||
	    ill->ill_net_type == IRE_IF_NORESOLVER) {
		dlur_mp = ill_dlur_gen(ncec->ncec_lladdr,
		    ill->ill_phys_addr_length, ill->ill_sap,
		    ill->ill_sap_length);
		if (dlur_mp == NULL) {
			err = ENOMEM;
			goto err_ret;
		}
	}

	/*
	 * Atomically ensure that the ill is not CONDEMNED, before
	 * adding the NCE.
	 */
	mutex_enter(&ill->ill_lock);
	if (ill->ill_state_flags & ILL_CONDEMNED) {
		mutex_exit(&ill->ill_lock);
		err = EINVAL;
		goto err_ret;
	}
	if (!NCE_MYADDR(ncec) &&
	    (ill->ill_state_flags & ILL_DOWN_IN_PROGRESS)) {
		mutex_exit(&ill->ill_lock);
		DTRACE_PROBE1(nce__add__on__down__ill, ncec_t *, ncec);
		err = EINVAL;
		goto err_ret;
	}
	/*
	 * Acquire the ncec_lock even before adding the ncec to the list
	 * so that it cannot get deleted after the ncec is added, but
	 * before we add the nce.
	 */
	mutex_enter(&ncec->ncec_lock);
	if ((ncec->ncec_next = *ncep) != NULL)
		ncec->ncec_next->ncec_ptpn = &ncec->ncec_next;
	*ncep = ncec;
	ncec->ncec_ptpn = ncep;

	/* Bump up the number of ncec's referencing this ill */
	DTRACE_PROBE3(ill__incr__cnt, (ill_t *), ill,
	    (char *), "ncec", (void *), ncec);
	ill->ill_ncec_cnt++;
	/*
	 * Since we hold the ncec_lock at this time, the ncec cannot be
	 * condemned, and we can safely add the nce.
	 */
	list_create(&graveyard, sizeof (nce_t), offsetof(nce_t, nce_node));
	*retnce = nce_add_impl(ill, ncec, nce, dlur_mp, &graveyard);
	mutex_exit(&ncec->ncec_lock);
	mutex_exit(&ill->ill_lock);
	nce_graveyard_free(&graveyard);

	/* caller must trigger fastpath on *retnce */
	return (0);

err_ret:
	if (ncec != NULL)
		kmem_cache_free(ncec_cache, ncec);
	if (nce != NULL)
		kmem_cache_free(nce_cache, nce);
	freemsg(dlur_mp);
	if (template != NULL)
		kmem_free(template, ill->ill_phys_addr_length);
	return (err);
}

/*
 * take a ref on the nce
 */
void
nce_refhold(nce_t *nce)
{
	mutex_enter(&nce->nce_lock);
	nce->nce_refcnt++;
	ASSERT((nce)->nce_refcnt != 0);
	mutex_exit(&nce->nce_lock);
}

/*
 * release a ref on the nce; In general, this
 * cannot be called with locks held because nce_inactive
 * may result in nce_inactive which will take the ill_lock,
 * do ipif_ill_refrele_tail etc. Thus the one exception
 * where this can be called with locks held is when the caller
 * is certain that the nce_refcnt is sufficient to prevent
 * the invocation of nce_inactive.
 */
void
nce_refrele(nce_t *nce)
{
	ASSERT((nce)->nce_refcnt != 0);
	mutex_enter(&nce->nce_lock);
	if (--nce->nce_refcnt == 0)
		nce_inactive(nce); /* destroys the mutex */
	else
		mutex_exit(&nce->nce_lock);
}

/*
 * free the nce after all refs have gone away.
 */
static void
nce_inactive(nce_t *nce)
{
	ill_t *ill = nce->nce_ill;

	ASSERT(nce->nce_refcnt == 0);

	ncec_refrele_notr(nce->nce_common);
	nce->nce_common = NULL;
	freemsg(nce->nce_fp_mp);
	freemsg(nce->nce_dlur_mp);

	mutex_enter(&ill->ill_lock);
	DTRACE_PROBE3(ill__decr__cnt, (ill_t *), ill,
	    (char *), "nce", (void *), nce);
	ill->ill_nce_cnt--;
	nce->nce_ill = NULL;
	/*
	 * If the number of ncec's associated with this ill have dropped
	 * to zero, check whether we need to restart any operation that
	 * is waiting for this to happen.
	 */
	if (ILL_DOWN_OK(ill)) {
		/* ipif_ill_refrele_tail drops the ill_lock */
		ipif_ill_refrele_tail(ill);
	} else {
		mutex_exit(&ill->ill_lock);
	}

	mutex_destroy(&nce->nce_lock);
	kmem_cache_free(nce_cache, nce);
}

/*
 * Add an nce to the ill_nce list.
 *
 * Adding multicast NCEs is subject to a per-ill limit. This function returns
 * NULL if that's the case, and it may reap a number of multicast nces.
 * Callers (and upstack) must be able to cope with NULL returns.
 */
static nce_t *
nce_add_impl(ill_t *ill, ncec_t *ncec, nce_t *nce, mblk_t *dlur_mp,
    list_t *graveyard)
{
	ASSERT(MUTEX_HELD(&ill->ill_lock));

	if ((ncec->ncec_flags & NCE_F_MCAST) != 0) {
		if (nce_too_many_mcast(ill, graveyard)) {
			kmem_cache_free(nce_cache, nce);
			return (NULL);
		}
		ill->ill_mcast_nces++;
	}

	bzero(nce, sizeof (*nce));
	mutex_init(&nce->nce_lock, NULL, MUTEX_DEFAULT, NULL);
	nce->nce_common = ncec;
	nce->nce_addr = ncec->ncec_addr;
	nce->nce_ill = ill;
	DTRACE_PROBE3(ill__incr__cnt, (ill_t *), ill,
	    (char *), "nce", (void *), nce);
	ill->ill_nce_cnt++;

	nce->nce_refcnt = 1; /* for the thread */
	ncec->ncec_refcnt++; /* want ncec_refhold_locked_notr(ncec) */
	nce->nce_dlur_mp = dlur_mp;

	/* add nce to the ill's fastpath list.  */
	nce->nce_refcnt++; /* for the list */
	list_insert_head(&ill->ill_nce, nce);
	return (nce);
}

static nce_t *
nce_add(ill_t *ill, ncec_t *ncec, list_t *graveyard)
{
	nce_t	*nce;
	mblk_t	*dlur_mp = NULL;

	ASSERT(MUTEX_HELD(&ill->ill_lock));
	ASSERT(MUTEX_HELD(&ncec->ncec_lock));

	nce = kmem_cache_alloc(nce_cache, KM_NOSLEEP);
	if (nce == NULL)
		return (NULL);
	if (ncec->ncec_lladdr != NULL ||
	    ill->ill_net_type == IRE_IF_NORESOLVER) {
		dlur_mp = ill_dlur_gen(ncec->ncec_lladdr,
		    ill->ill_phys_addr_length, ill->ill_sap,
		    ill->ill_sap_length);
		if (dlur_mp == NULL) {
			kmem_cache_free(nce_cache, nce);
			return (NULL);
		}
	}
	/*
	 * If nce_add_impl() returns NULL due to on multicast limiting, caller
	 * will (correctly) assume ENOMEM.
	 */
	return (nce_add_impl(ill, ncec, nce, dlur_mp, graveyard));
}

/*
 * remove the nce from the ill_faspath list
 */
void
nce_delete(nce_t *nce)
{
	ill_t	*ill = nce->nce_ill;

	ASSERT(MUTEX_HELD(&ill->ill_lock));

	mutex_enter(&nce->nce_lock);
	if (nce->nce_is_condemned) {
		/*
		 * some other thread has removed this nce from the ill_nce list
		 */
		mutex_exit(&nce->nce_lock);
		return;
	}
	nce->nce_is_condemned = B_TRUE;
	mutex_exit(&nce->nce_lock);

	/* Update the count of multicast NCEs. */
	if ((nce->nce_common->ncec_flags & NCE_F_MCAST) == NCE_F_MCAST)
		ill->ill_mcast_nces--;

	list_remove(&ill->ill_nce, nce);
	/*
	 * even though we are holding the ill_lock, it is ok to
	 * call nce_refrele here because we know that we should have
	 * at least 2 refs on the nce: one for the thread, and one
	 * for the list. The refrele below will release the one for
	 * the list.
	 */
	nce_refrele(nce);
}

nce_t *
nce_lookup(ill_t *ill, const in6_addr_t *addr)
{
	nce_t *nce = NULL;

	ASSERT(ill != NULL);
	ASSERT(MUTEX_HELD(&ill->ill_lock));

	for (nce = list_head(&ill->ill_nce); nce != NULL;
	    nce = list_next(&ill->ill_nce, nce)) {
		if (IN6_ARE_ADDR_EQUAL(&nce->nce_addr, addr))
			break;
	}

	/*
	 * if we found the nce on the ill_nce list while holding
	 * the ill_lock, then it cannot be condemned yet.
	 */
	if (nce != NULL) {
		ASSERT(!nce->nce_is_condemned);
		nce_refhold(nce);
	}
	return (nce);
}

/*
 * Walk the ill_nce list on ill. The callback function func() cannot perform
 * any destructive actions.
 */
static void
nce_walk_common(ill_t *ill, pfi_t func, void *arg)
{
	nce_t *nce = NULL, *nce_next;

	ASSERT(MUTEX_HELD(&ill->ill_lock));
	for (nce = list_head(&ill->ill_nce); nce != NULL; ) {
		nce_next = list_next(&ill->ill_nce, nce);
		if (func(ill, nce, arg) != 0)
			break;
		nce = nce_next;
	}
}

void
nce_walk(ill_t *ill, pfi_t func, void *arg)
{
	mutex_enter(&ill->ill_lock);
	nce_walk_common(ill, func, arg);
	mutex_exit(&ill->ill_lock);
}

void
nce_flush(ill_t *ill, boolean_t flushall)
{
	nce_t *nce, *nce_next;
	list_t dead;

	list_create(&dead, sizeof (nce_t), offsetof(nce_t, nce_node));
	mutex_enter(&ill->ill_lock);
	for (nce = list_head(&ill->ill_nce); nce != NULL; ) {
		nce_next = list_next(&ill->ill_nce, nce);
		if (!flushall && NCE_PUBLISH(nce->nce_common)) {
			nce = nce_next;
			continue;
		}
		/*
		 * nce_delete requires that the caller should either not
		 * be holding locks, or should hold a ref to ensure that
		 * we wont hit ncec_inactive. So take a ref and clean up
		 * after the list is flushed.
		 */
		nce_refhold(nce);
		nce_delete(nce);
		list_insert_tail(&dead, nce);
		nce = nce_next;
	}
	mutex_exit(&ill->ill_lock);
	while ((nce = list_head(&dead)) != NULL) {
		list_remove(&dead, nce);
		nce_refrele(nce);
	}
	ASSERT(list_is_empty(&dead));
	list_destroy(&dead);
}

/* Return an interval that is anywhere in the [1 .. intv] range */
static clock_t
nce_fuzz_interval(clock_t intv, boolean_t initial_time)
{
	clock_t rnd, frac;

	(void) random_get_pseudo_bytes((uint8_t *)&rnd, sizeof (rnd));
	/* Note that clock_t is signed; must chop off bits */
	rnd &= (1ul << (NBBY * sizeof (rnd) - 1)) - 1;
	if (initial_time) {
		if (intv <= 0)
			intv = 1;
		else
			intv = (rnd % intv) + 1;
	} else {
		/* Compute 'frac' as 20% of the configured interval */
		if ((frac = intv / 5) <= 1)
			frac = 2;
		/* Set intv randomly in the range [intv-frac .. intv+frac] */
		if ((intv = intv - frac + rnd % (2 * frac + 1)) <= 0)
			intv = 1;
	}
	return (intv);
}

void
nce_resolv_ipmp_ok(ncec_t *ncec)
{
	mblk_t *mp;
	uint_t pkt_len;
	iaflags_t ixaflags = IXAF_NO_TRACE;
	nce_t *under_nce;
	ill_t	*ill = ncec->ncec_ill;
	boolean_t isv6 = (ncec->ncec_ipversion == IPV6_VERSION);
	ipif_t *src_ipif = NULL;
	ip_stack_t *ipst = ill->ill_ipst;
	ill_t *send_ill;
	uint_t nprobes;

	ASSERT(IS_IPMP(ill));

	mutex_enter(&ncec->ncec_lock);
	nprobes = ncec->ncec_nprobes;
	mp = ncec->ncec_qd_mp;
	ncec->ncec_qd_mp = NULL;
	ncec->ncec_nprobes = 0;
	mutex_exit(&ncec->ncec_lock);

	while (mp != NULL) {
		mblk_t *nxt_mp;

		nxt_mp = mp->b_next;
		mp->b_next = NULL;
		if (isv6) {
			ip6_t *ip6h = (ip6_t *)mp->b_rptr;

			pkt_len = ntohs(ip6h->ip6_plen) + IPV6_HDR_LEN;
			src_ipif = ipif_lookup_addr_nondup_v6(&ip6h->ip6_src,
			    ill, ALL_ZONES, ipst);
		} else {
			ipha_t *ipha = (ipha_t *)mp->b_rptr;

			ixaflags |= IXAF_IS_IPV4;
			pkt_len = ntohs(ipha->ipha_length);
			src_ipif = ipif_lookup_addr_nondup(ipha->ipha_src,
			    ill, ALL_ZONES, ipst);
		}

		/*
		 * find a new nce based on an under_ill. The first IPMP probe
		 * packet gets queued, so we could still find a src_ipif that
		 * matches an IPMP test address.
		 */
		if (src_ipif == NULL || IS_IPMP(src_ipif->ipif_ill)) {
			/*
			 * if src_ipif is null, this could be either a
			 * forwarded packet or a probe whose src got deleted.
			 * We identify the former case by looking for the
			 * ncec_nprobes: the first ncec_nprobes packets are
			 * probes;
			 */
			if (src_ipif == NULL && nprobes > 0)
				goto drop_pkt;

			/*
			 * For forwarded packets, we use the ipmp rotor
			 * to find send_ill.
			 */
			send_ill = ipmp_ill_hold_xmit_ill(ncec->ncec_ill,
			    B_TRUE);
		} else {
			send_ill = src_ipif->ipif_ill;
			ill_refhold(send_ill);
		}

		DTRACE_PROBE4(nce__resolve__ipmp, (mblk_t *), mp,
		    (ncec_t *), ncec, (ipif_t *),
		    src_ipif, (ill_t *), send_ill);

		if (send_ill == NULL) {
			if (src_ipif != NULL)
				ipif_refrele(src_ipif);
			goto drop_pkt;
		}
		/* create an under_nce on send_ill */
		rw_enter(&ipst->ips_ill_g_lock, RW_READER);
		if (IS_IN_SAME_ILLGRP(send_ill, ncec->ncec_ill))
			under_nce = nce_fastpath_create(send_ill, ncec);
		else
			under_nce = NULL;
		rw_exit(&ipst->ips_ill_g_lock);
		if (under_nce != NULL && NCE_ISREACHABLE(ncec))
			nce_fastpath_trigger(under_nce);

		ill_refrele(send_ill);
		if (src_ipif != NULL)
			ipif_refrele(src_ipif);

		if (under_nce != NULL) {
			(void) ip_xmit(mp, under_nce, ixaflags, pkt_len, 0,
			    ALL_ZONES, 0, NULL);
			nce_refrele(under_nce);
			if (nprobes > 0)
				nprobes--;
			mp = nxt_mp;
			continue;
		}
drop_pkt:
		if (isv6) {
			BUMP_MIB(&ipst->ips_ip6_mib, ipIfStatsOutDiscards);
		} else {
			BUMP_MIB(&ipst->ips_ip_mib, ipIfStatsOutDiscards);
		}
		ip_drop_output("ipIfStatsOutDiscards - no under_ill", mp, NULL);
		freemsg(mp);
		if (nprobes > 0)
			nprobes--;
		mp = nxt_mp;
	}
	ncec_cb_dispatch(ncec); /* complete callbacks */
}