ip_ndp.h revision f4b3ec61df05330d25f55a36b975b4d7519fdeb1
/*
* 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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _INET_IP_NDP_H
#define _INET_IP_NDP_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/mutex.h>
#include <sys/stream.h>
#include <netinet/in.h>
#include <netinet/icmp6.h>
#include <inet/ip.h>
/*
* Internal definitions for the kernel implementation of the IPv6
* Neighbor Discovery Protocol (NDP).
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _KERNEL
#define NCE_TABLE_SIZE 256
/* NDP Cache Entry */
typedef struct nce_s {
struct nce_s *nce_next; /* Hash chain next pointer */
struct nce_s **nce_ptpn; /* Pointer to previous next */
struct ill_s *nce_ill; /* Associated ill */
uint16_t nce_flags; /* See below */
uint16_t nce_state; /* See reachability states in if.h */
int16_t nce_pcnt; /* Probe counter */
uint16_t nce_rcnt; /* Retransmit counter */
in6_addr_t nce_addr; /* address of the nighbor */
in6_addr_t nce_mask; /* If not all ones, mask allows an */
/* entry to respond to requests for a group of addresses, for */
/* instantance multicast addresses */
in6_addr_t nce_extract_mask; /* For mappings */
uint32_t nce_ll_extract_start; /* For mappings */
#define nce_first_mp_to_free nce_fp_mp
mblk_t *nce_fp_mp; /* link layer fast path mp */
mblk_t *nce_res_mp; /* DL_UNITDATA_REQ or link layer mp */
mblk_t *nce_qd_mp; /* Head outgoing queued packets */
#define nce_last_mp_to_free nce_qd_mp
mblk_t *nce_timer_mp; /* NDP timer mblk */
mblk_t *nce_mp; /* mblk we are in, last to be freed */
uint64_t nce_last; /* Time last reachable in msec */
uint32_t nce_refcnt; /* nce active usage count */
kmutex_t nce_lock; /* See comments on top for what */
/* this field protects */
int nce_unsolicit_count; /* Unsolicited Adv count */
struct nce_s *nce_fastpath; /* for fastpath list */
timeout_id_t nce_timeout_id;
uchar_t nce_ipversion; /* IPv4(ARP)/IPv6(NDP) version */
uint_t nce_defense_count; /* number of NDP conflicts */
uint_t nce_defense_time; /* last time defended (secs) */
#ifdef NCE_DEBUG
th_trace_t *nce_trace[IP_TR_HASH_MAX];
boolean_t nce_trace_disable; /* True when alloc fails */
#endif
} nce_t;
/*
* The ndp_g_t structure contains protocol specific information needed
* to synchronize and manage neighbor cache entries for IPv4 and IPv6.
* There are 2 such structures, ips_ndp4 and ips_ndp6.
* ips_ndp6 contains the data structures needed for IPv6 Neighbor Discovery.
* ips_ndp4 has IPv4 link layer info in its nce_t structures
* Note that the nce_t is not currently used as the arp cache itself;
* it is used for the following purposes:
* - queue packets in nce_qd_mp while waiting for arp resolution to complete
* - nce_{res, fp}_mp are used to track DL_UNITDATA request/responses.
* - track state of ARP resolution in the nce_state;
*
* Locking notes:
* ndp_g_lock protects neighbor cache tables access and
* insertion/removal of cache entries into/from these tables.
* nce_lock protects nce_pcnt, nce_rcnt, nce_qd_mp nce_state,
* nce_res_mp, nce_refcnt and nce_last.
* nce_refcnt is incremented for every ire pointing to this nce and
* every time ndp_lookup() finds an nce.
* Should there be a need to obtain nce_lock and ndp_g_lock, ndp_g_lock is
* acquired first.
* To avoid becoming exclusive when deleting NCEs, ndp_walk() routine holds
* the ndp_g_lock (i.e global lock) and marks NCEs to be deleted with
* NCE_F_CONDEMNED. When all active users of such NCEs are gone the walk
* routine passes a list for deletion to nce_ire_delete_list().
*/
typedef struct ndp_g_s {
kmutex_t ndp_g_lock; /* Lock protecting cache hash table */
nce_t *nce_mask_entries; /* mask not all ones */
nce_t *nce_hash_tbl[NCE_TABLE_SIZE];
int ndp_g_walker; /* # of active thread walking hash list */
boolean_t ndp_g_walker_cleanup; /* true implies defer deletion. */
} ndp_g_t;
/* nce_flags */
#define NCE_F_PERMANENT 0x1
#define NCE_F_MAPPING 0x2
#define NCE_F_ISROUTER 0x4
#define NCE_F_PROXY 0x8
#define NCE_F_NONUD 0x10
#define NCE_F_ANYCAST 0x20
#define NCE_F_CONDEMNED 0x40
#define NCE_F_UNSOL_ADV 0x80
#define NCE_F_BCAST 0x100
#define NCE_EXTERNAL_FLAGS_MASK \
(NCE_F_PERMANENT | NCE_F_MAPPING | NCE_F_ISROUTER | NCE_F_NONUD | \
NCE_F_ANYCAST | NCE_F_UNSOL_ADV)
/* State REACHABLE, STALE, DELAY or PROBE */
#define NCE_ISREACHABLE(nce) \
(((((nce)->nce_state) >= ND_REACHABLE) && \
((nce)->nce_state) <= ND_PROBE))
/* NDP flags set in SOL/ADV requests */
#define NDP_UNICAST 0x1
#define NDP_ISROUTER 0x2
#define NDP_SOLICITED 0x4
#define NDP_ORIDE 0x8
#define NDP_PROBE 0x10
/* Number of packets queued in NDP for a neighbor */
#define ND_MAX_Q 4
#ifdef NCE_DEBUG
#define NCE_TRACE_REF(nce) nce_trace_ref(nce)
#define NCE_UNTRACE_REF(nce) nce_untrace_ref(nce)
#else
#define NCE_TRACE_REF(nce)
#define NCE_UNTRACE_REF(nce)
#endif
#define NCE_REFHOLD(nce) { \
mutex_enter(&(nce)->nce_lock); \
(nce)->nce_refcnt++; \
ASSERT((nce)->nce_refcnt != 0); \
NCE_TRACE_REF(nce); \
mutex_exit(&(nce)->nce_lock); \
}
#define NCE_REFHOLD_NOTR(nce) { \
mutex_enter(&(nce)->nce_lock); \
(nce)->nce_refcnt++; \
ASSERT((nce)->nce_refcnt != 0); \
mutex_exit(&(nce)->nce_lock); \
}
#define NCE_REFHOLD_LOCKED(nce) { \
ASSERT(MUTEX_HELD(&(nce)->nce_lock)); \
(nce)->nce_refcnt++; \
NCE_TRACE_REF(nce); \
}
/* nce_inactive destroys the mutex thus no mutex_exit is needed */
#define NCE_REFRELE(nce) { \
mutex_enter(&(nce)->nce_lock); \
NCE_UNTRACE_REF(nce); \
ASSERT((nce)->nce_refcnt != 0); \
if (--(nce)->nce_refcnt == 0) \
ndp_inactive(nce); \
else { \
mutex_exit(&(nce)->nce_lock);\
} \
}
#define NCE_REFRELE_NOTR(nce) { \
mutex_enter(&(nce)->nce_lock); \
ASSERT((nce)->nce_refcnt != 0); \
if (--(nce)->nce_refcnt == 0) \
ndp_inactive(nce); \
else { \
mutex_exit(&(nce)->nce_lock);\
} \
}
#define NDP_RESTART_TIMER(nce, ms) { \
ASSERT(!MUTEX_HELD(&(nce)->nce_lock)); \
if ((nce)->nce_timeout_id != 0) { \
/* Ok to untimeout bad id. we don't hold a lock. */ \
(void) untimeout((nce)->nce_timeout_id); \
} \
mutex_enter(&(nce)->nce_lock); \
/* Don't start the timer if the nce has been deleted */ \
if (!((nce)->nce_flags & NCE_F_CONDEMNED)) \
nce->nce_timeout_id = timeout(ndp_timer, nce, \
MSEC_TO_TICK(ms) == 0 ? 1 : MSEC_TO_TICK(ms)); \
mutex_exit(&(nce)->nce_lock); \
}
/* Structure for ndp_cache_count() */
typedef struct {
int ncc_total; /* Total number of NCEs */
int ncc_host; /* NCE entries without R bit set */
} ncc_cache_count_t;
/*
* Structure of ndp_cache_reclaim(). Each field is a fraction i.e. 1 means
* reclaim all, N means reclaim 1/Nth of all entries, 0 means reclaim none.
*/
typedef struct {
int ncr_host; /* Fraction for host entries */
} nce_cache_reclaim_t;
/*
* Structure for nce_delete_hw_changed; specifies an IPv4 address to link-layer
* address mapping. Any route that has a cached copy of a mapping for that
* IPv4 address that doesn't match the given mapping must be purged.
*/
typedef struct {
ipaddr_t hwm_addr; /* IPv4 address */
uint_t hwm_hwlen; /* Length of hardware address (may be 0) */
uchar_t *hwm_hwaddr; /* Pointer to new hardware address, if any */
} nce_hw_map_t;
/* When SAP is greater than zero address appears before SAP */
#define NCE_LL_ADDR_OFFSET(ill) (((ill)->ill_sap_length) < 0 ? \
(sizeof (dl_unitdata_req_t)) : \
((sizeof (dl_unitdata_req_t)) + (ABS((ill)->ill_sap_length))))
#define NCE_LL_SAP_OFFSET(ill) (((ill)->ill_sap_length) < 0 ? \
((sizeof (dl_unitdata_req_t)) + ((ill)->ill_phys_addr_length)) : \
(sizeof (dl_unitdata_req_t)))
#ifdef _BIG_ENDIAN
#define NCE_LL_SAP_COPY(ill, mp) \
{ \
size_t abs_sap_len = ABS((ill)->ill_sap_length); \
if (abs_sap_len > 0) { \
ASSERT(abs_sap_len <= sizeof (uint32_t)); \
ASSERT((mp)->b_rptr + NCE_LL_SAP_OFFSET(ill) + \
abs_sap_len <= ((mp)->b_wptr)); \
bcopy((uint8_t *)&(ill)->ill_sap + sizeof (ill->ill_sap) - \
abs_sap_len, \
((mp)->b_rptr + NCE_LL_SAP_OFFSET(ill)), \
abs_sap_len); \
} \
}
#else
#define NCE_LL_SAP_COPY(ill, mp) \
{ \
size_t abs_sap_len = ABS((ill)->ill_sap_length); \
if (abs_sap_len > 0) { \
uint32_t abs_sap_len = ABS((ill)->ill_sap_length); \
ASSERT(abs_sap_len <= sizeof (uint32_t)); \
ASSERT((mp)->b_rptr + NCE_LL_SAP_OFFSET(ill) + \
abs_sap_len <= ((mp)->b_wptr)); \
bcopy(&((ill)->ill_sap), \
((mp)->b_rptr + NCE_LL_SAP_OFFSET(ill)), \
abs_sap_len); \
} \
}
#endif
/*
* Exclusive-or the 6 bytes that are likely to contain the MAC
* address. Assumes table_size does not exceed 256.
* Assumes EUI-64 format for good hashing.
*/
#define NCE_ADDR_HASH_V6(addr, table_size) \
(((addr).s6_addr8[8] ^ (addr).s6_addr8[9] ^ \
(addr).s6_addr8[10] ^ (addr).s6_addr8[13] ^ \
(addr).s6_addr8[14] ^ (addr).s6_addr8[15]) % (table_size))
/* NDP Cache Entry Hash Table */
#define NCE_TABLE_SIZE 256
extern void ndp_cache_count(nce_t *, char *);
extern void ndp_cache_reclaim(nce_t *, char *);
extern void ndp_delete(nce_t *);
extern void ndp_delete_per_ill(nce_t *, uchar_t *);
extern void ndp_fastpath_flush(nce_t *, char *);
extern boolean_t ndp_fastpath_update(nce_t *, void *);
extern nd_opt_hdr_t *ndp_get_option(nd_opt_hdr_t *, int, int);
extern void ndp_inactive(nce_t *);
extern void ndp_input(ill_t *, mblk_t *, mblk_t *);
extern boolean_t ndp_lookup_ipaddr(in_addr_t, netstack_t *);
extern nce_t *ndp_lookup_v6(ill_t *, const in6_addr_t *, boolean_t);
extern nce_t *ndp_lookup_v4(ill_t *, const in_addr_t *, boolean_t);
extern int ndp_lookup_then_add(ill_t *, uchar_t *, const void *,
const void *, const void *, uint32_t, uint16_t,
uint16_t, nce_t **, mblk_t *, mblk_t *);
extern int ndp_mcastreq(ill_t *, const in6_addr_t *, uint32_t, uint32_t,
mblk_t *);
extern int ndp_noresolver(ill_t *, const in6_addr_t *);
extern void ndp_process(nce_t *, uchar_t *, uint32_t, boolean_t);
extern int ndp_query(ill_t *, lif_nd_req_t *);
extern int ndp_report(queue_t *, mblk_t *, caddr_t, cred_t *);
extern int ndp_resolver(ill_t *, const in6_addr_t *, mblk_t *, zoneid_t);
extern int ndp_sioc_update(ill_t *, lif_nd_req_t *);
extern boolean_t ndp_verify_optlen(nd_opt_hdr_t *, int);
extern void ndp_timer(void *);
extern void ndp_walk(ill_t *, pfi_t, void *, ip_stack_t *);
extern void ndp_walk_common(ndp_g_t *, ill_t *, pfi_t,
void *, boolean_t);
extern int ndp_add(ill_t *, uchar_t *, const void *,
const void *, const void *,
uint32_t, uint16_t, uint16_t, nce_t **, mblk_t *, mblk_t *);
extern boolean_t ndp_restart_dad(nce_t *);
extern void ndp_do_recovery(ipif_t *);
extern void nce_resolv_failed(nce_t *);
extern void arp_resolv_failed(nce_t *);
extern void nce_fastpath_list_add(nce_t *);
extern void nce_fastpath_list_delete(nce_t *);
extern void nce_fastpath_list_dispatch(ill_t *,
boolean_t (*)(nce_t *, void *), void *);
extern void nce_queue_mp_common(nce_t *, mblk_t *, boolean_t);
extern void ndp_flush_qd_mp(nce_t *);
extern nce_t *nce_reinit(nce_t *);
extern void nce_delete_hw_changed(nce_t *, void *);
extern void nce_fastpath(nce_t *);
#ifdef NCE_DEBUG
extern void nce_trace_inactive(nce_t *);
extern void nce_trace_ref(nce_t *);
extern void nce_untrace_ref(nce_t *);
extern int nce_thread_exit(nce_t *, caddr_t);
#endif
#endif /* _KERNEL */
#ifdef __cplusplus
}
#endif
#endif /* _INET_IP_NDP_H */