xref: /illumos-gate/usr/src/uts/common/inet/ip.h (revision 9294ad19ef6f3441b67cd3c05a5f95a4eae29902)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 /* Copyright (c) 1990 Mentat Inc. */
27 
28 #ifndef	_INET_IP_H
29 #define	_INET_IP_H
30 
31 #ifdef	__cplusplus
32 extern "C" {
33 #endif
34 
35 #include <sys/isa_defs.h>
36 #include <sys/types.h>
37 #include <inet/mib2.h>
38 #include <inet/nd.h>
39 #include <sys/atomic.h>
40 #include <net/if_dl.h>
41 #include <net/if.h>
42 #include <netinet/ip.h>
43 #include <netinet/igmp.h>
44 #include <sys/neti.h>
45 #include <sys/hook.h>
46 #include <sys/hook_event.h>
47 #include <sys/hook_impl.h>
48 #include <inet/ip_stack.h>
49 
50 #ifdef _KERNEL
51 #include <netinet/ip6.h>
52 #include <sys/avl.h>
53 #include <sys/list.h>
54 #include <sys/vmem.h>
55 #include <sys/squeue.h>
56 #include <net/route.h>
57 #include <sys/systm.h>
58 #include <sys/multidata.h>
59 #include <sys/list.h>
60 #include <net/radix.h>
61 #include <sys/modhash.h>
62 
63 #ifdef DEBUG
64 #define	CONN_DEBUG
65 #endif
66 
67 #define	IP_DEBUG
68 /*
69  * The mt-streams(9F) flags for the IP module; put here so that other
70  * "drivers" that are actually IP (e.g., ICMP, UDP) can use the same set
71  * of flags.
72  */
73 #define	IP_DEVMTFLAGS D_MP
74 #endif	/* _KERNEL */
75 
76 #define	IP_MOD_NAME	"ip"
77 #define	IP_DEV_NAME	"/dev/ip"
78 #define	IP6_DEV_NAME	"/dev/ip6"
79 
80 #define	UDP_MOD_NAME	"udp"
81 #define	UDP_DEV_NAME	"/dev/udp"
82 #define	UDP6_DEV_NAME	"/dev/udp6"
83 
84 #define	TCP_MOD_NAME	"tcp"
85 #define	TCP_DEV_NAME	"/dev/tcp"
86 #define	TCP6_DEV_NAME	"/dev/tcp6"
87 
88 #define	SCTP_MOD_NAME	"sctp"
89 
90 #ifndef	_IPADDR_T
91 #define	_IPADDR_T
92 typedef uint32_t ipaddr_t;
93 #endif
94 
95 /* Number of bits in an address */
96 #define	IP_ABITS		32
97 #define	IPV6_ABITS		128
98 
99 #define	IP_HOST_MASK		(ipaddr_t)0xffffffffU
100 
101 #define	IP_CSUM(mp, off, sum)		(~ip_cksum(mp, off, sum) & 0xFFFF)
102 #define	IP_CSUM_PARTIAL(mp, off, sum)	ip_cksum(mp, off, sum)
103 #define	IP_BCSUM_PARTIAL(bp, len, sum)	bcksum(bp, len, sum)
104 #define	IP_MD_CSUM(pd, off, sum)	(~ip_md_cksum(pd, off, sum) & 0xffff)
105 #define	IP_MD_CSUM_PARTIAL(pd, off, sum) ip_md_cksum(pd, off, sum)
106 
107 /*
108  * Flag to IP write side to indicate that the appln has sent in a pre-built
109  * IP header. Stored in ipha_ident (which is otherwise zero).
110  */
111 #define	IP_HDR_INCLUDED			0xFFFF
112 
113 #define	ILL_FRAG_HASH_TBL_COUNT	((unsigned int)64)
114 #define	ILL_FRAG_HASH_TBL_SIZE	(ILL_FRAG_HASH_TBL_COUNT * sizeof (ipfb_t))
115 
116 #define	IPV4_ADDR_LEN			4
117 #define	IP_ADDR_LEN			IPV4_ADDR_LEN
118 #define	IP_ARP_PROTO_TYPE		0x0800
119 
120 #define	IPV4_VERSION			4
121 #define	IP_VERSION			IPV4_VERSION
122 #define	IP_SIMPLE_HDR_LENGTH_IN_WORDS	5
123 #define	IP_SIMPLE_HDR_LENGTH		20
124 #define	IP_MAX_HDR_LENGTH		60
125 
126 #define	IP_MAX_OPT_LENGTH (IP_MAX_HDR_LENGTH-IP_SIMPLE_HDR_LENGTH)
127 
128 #define	IP_MIN_MTU			(IP_MAX_HDR_LENGTH + 8)	/* 68 bytes */
129 
130 /*
131  * XXX IP_MAXPACKET is defined in <netinet/ip.h> as well. At some point the
132  * 2 files should be cleaned up to remove all redundant definitions.
133  */
134 #define	IP_MAXPACKET			65535
135 #define	IP_SIMPLE_HDR_VERSION \
136 	((IP_VERSION << 4) | IP_SIMPLE_HDR_LENGTH_IN_WORDS)
137 
138 #define	UDPH_SIZE			8
139 
140 /* Leave room for ip_newroute to tack on the src and target addresses */
141 #define	OK_RESOLVER_MP(mp)						\
142 	((mp) && ((mp)->b_wptr - (mp)->b_rptr) >= (2 * IP_ADDR_LEN))
143 
144 /*
145  * Constants and type definitions to support IP IOCTL commands
146  */
147 #define	IP_IOCTL			(('i'<<8)|'p')
148 #define	IP_IOC_IRE_DELETE		4
149 #define	IP_IOC_IRE_DELETE_NO_REPLY	5
150 #define	IP_IOC_IRE_ADVISE_NO_REPLY	6
151 #define	IP_IOC_RTS_REQUEST		7
152 
153 /* Common definitions used by IP IOCTL data structures */
154 typedef struct ipllcmd_s {
155 	uint_t	ipllc_cmd;
156 	uint_t	ipllc_name_offset;
157 	uint_t	ipllc_name_length;
158 } ipllc_t;
159 
160 /* IP IRE Change Command Structure. */
161 typedef struct ipic_s {
162 	ipllc_t	ipic_ipllc;
163 	uint_t	ipic_ire_type;
164 	uint_t	ipic_max_frag;
165 	uint_t	ipic_addr_offset;
166 	uint_t	ipic_addr_length;
167 	uint_t	ipic_mask_offset;
168 	uint_t	ipic_mask_length;
169 	uint_t	ipic_src_addr_offset;
170 	uint_t	ipic_src_addr_length;
171 	uint_t	ipic_ll_hdr_offset;
172 	uint_t	ipic_ll_hdr_length;
173 	uint_t	ipic_gateway_addr_offset;
174 	uint_t	ipic_gateway_addr_length;
175 	clock_t	ipic_rtt;
176 	uint32_t ipic_ssthresh;
177 	clock_t	ipic_rtt_sd;
178 	uchar_t ipic_ire_marks;
179 } ipic_t;
180 
181 #define	ipic_cmd		ipic_ipllc.ipllc_cmd
182 #define	ipic_ll_name_length	ipic_ipllc.ipllc_name_length
183 #define	ipic_ll_name_offset	ipic_ipllc.ipllc_name_offset
184 
185 /* IP IRE Delete Command Structure. */
186 typedef struct ipid_s {
187 	ipllc_t	ipid_ipllc;
188 	uint_t	ipid_ire_type;
189 	uint_t	ipid_addr_offset;
190 	uint_t	ipid_addr_length;
191 	uint_t	ipid_mask_offset;
192 	uint_t	ipid_mask_length;
193 } ipid_t;
194 
195 #define	ipid_cmd		ipid_ipllc.ipllc_cmd
196 
197 #ifdef _KERNEL
198 /*
199  * Temporary state for ip options parser.
200  */
201 typedef struct ipoptp_s
202 {
203 	uint8_t		*ipoptp_next;	/* next option to look at */
204 	uint8_t		*ipoptp_end;	/* end of options */
205 	uint8_t		*ipoptp_cur;	/* start of current option */
206 	uint8_t		ipoptp_len;	/* length of current option */
207 	uint32_t	ipoptp_flags;
208 } ipoptp_t;
209 
210 /*
211  * Flag(s) for ipoptp_flags
212  */
213 #define	IPOPTP_ERROR	0x00000001
214 #endif	/* _KERNEL */
215 
216 /* Controls forwarding of IP packets, set via ndd */
217 #define	IP_FORWARD_NEVER	0
218 #define	IP_FORWARD_ALWAYS	1
219 
220 #define	WE_ARE_FORWARDING(ipst)	((ipst)->ips_ip_g_forward == IP_FORWARD_ALWAYS)
221 
222 #define	IPH_HDR_LENGTH(ipha)						\
223 	((int)(((ipha_t *)ipha)->ipha_version_and_hdr_length & 0xF) << 2)
224 
225 #define	IPH_HDR_VERSION(ipha)						\
226 	((int)(((ipha_t *)ipha)->ipha_version_and_hdr_length) >> 4)
227 
228 #ifdef _KERNEL
229 /*
230  * IP reassembly macros.  We hide starting and ending offsets in b_next and
231  * b_prev of messages on the reassembly queue.	The messages are chained using
232  * b_cont.  These macros are used in ip_reassemble() so we don't have to see
233  * the ugly casts and assignments.
234  * Note that the offsets are <= 64k i.e. a uint_t is sufficient to represent
235  * them.
236  */
237 #define	IP_REASS_START(mp)		((uint_t)(uintptr_t)((mp)->b_next))
238 #define	IP_REASS_SET_START(mp, u)	\
239 	((mp)->b_next = (mblk_t *)(uintptr_t)(u))
240 #define	IP_REASS_END(mp)		((uint_t)(uintptr_t)((mp)->b_prev))
241 #define	IP_REASS_SET_END(mp, u)		\
242 	((mp)->b_prev = (mblk_t *)(uintptr_t)(u))
243 
244 #define	IP_REASS_COMPLETE	0x1
245 #define	IP_REASS_PARTIAL	0x2
246 #define	IP_REASS_FAILED		0x4
247 
248 /*
249  * Test to determine whether this is a module instance of IP or a
250  * driver instance of IP.
251  */
252 #define	CONN_Q(q)	(WR(q)->q_next == NULL)
253 
254 #define	Q_TO_CONN(q)	((conn_t *)(q)->q_ptr)
255 #define	Q_TO_TCP(q)	(Q_TO_CONN((q))->conn_tcp)
256 #define	Q_TO_UDP(q)	(Q_TO_CONN((q))->conn_udp)
257 #define	Q_TO_ICMP(q)	(Q_TO_CONN((q))->conn_icmp)
258 #define	Q_TO_RTS(q)	(Q_TO_CONN((q))->conn_rts)
259 
260 /*
261  * The following two macros are used by IP to get the appropriate
262  * wq and rq for a conn. If it is a TCP conn, then we need
263  * tcp_wq/tcp_rq else, conn_wq/conn_rq. IP can use conn_wq and conn_rq
264  * from a conn directly if it knows that the conn is not TCP.
265  */
266 #define	CONNP_TO_WQ(connp)	\
267 	(IPCL_IS_TCP(connp) ? (connp)->conn_tcp->tcp_wq : (connp)->conn_wq)
268 
269 #define	CONNP_TO_RQ(connp)	RD(CONNP_TO_WQ(connp))
270 
271 #define	GRAB_CONN_LOCK(q)	{				\
272 	if (q != NULL && CONN_Q(q))				\
273 		mutex_enter(&(Q_TO_CONN(q))->conn_lock);	\
274 }
275 
276 #define	RELEASE_CONN_LOCK(q)	{				\
277 	if (q != NULL && CONN_Q(q))				\
278 		mutex_exit(&(Q_TO_CONN(q))->conn_lock);		\
279 }
280 
281 /* "Congestion controlled" protocol */
282 #define	IP_FLOW_CONTROLLED_ULP(p)   ((p) == IPPROTO_TCP || (p) == IPPROTO_SCTP)
283 
284 /*
285  * Complete the pending operation. Usually an ioctl. Can also
286  * be a bind or option management request that got enqueued
287  * in an ipsq_t. Called on completion of the operation.
288  */
289 #define	CONN_OPER_PENDING_DONE(connp)	{			\
290 	mutex_enter(&(connp)->conn_lock);			\
291 	(connp)->conn_oper_pending_ill = NULL;			\
292 	cv_broadcast(&(connp)->conn_refcv);			\
293 	mutex_exit(&(connp)->conn_lock);			\
294 	CONN_DEC_REF(connp);					\
295 }
296 
297 /*
298  * Flags for the various ip_fanout_* routines.
299  */
300 #define	IP_FF_SEND_ICMP		0x01	/* Send an ICMP error */
301 #define	IP_FF_HDR_COMPLETE	0x02	/* Call ip_hdr_complete if error */
302 #define	IP_FF_CKSUM		0x04	/* Recompute ipha_cksum if error */
303 #define	IP_FF_RAWIP		0x08	/* Use rawip mib variable */
304 #define	IP_FF_SRC_QUENCH	0x10	/* OK to send ICMP_SOURCE_QUENCH */
305 #define	IP_FF_SYN_ADDIRE	0x20	/* Add IRE if TCP syn packet */
306 #define	IP_FF_IPINFO		0x80	/* Used for both V4 and V6 */
307 #define	IP_FF_SEND_SLLA		0x100	/* Send source link layer info ? */
308 #define	IPV6_REACHABILITY_CONFIRMATION	0x200	/* Flags for ip_xmit_v6 */
309 #define	IP_FF_NO_MCAST_LOOP	0x400	/* No multicasts for sending zone */
310 
311 /*
312  * Following flags are used by IPQoS to determine if policy processing is
313  * required.
314  */
315 #define	IP6_NO_IPPOLICY		0x800	/* Don't do IPQoS processing */
316 #define	IP6_IN_LLMCAST		0x1000	/* Multicast */
317 
318 #define	IP_FF_LOOPBACK		0x2000	/* Loopback fanout */
319 #define	IP_FF_SCTP_CSUM_ERR	0x4000	/* sctp pkt has failed chksum */
320 
321 #ifndef	IRE_DB_TYPE
322 #define	IRE_DB_TYPE	M_SIG
323 #endif
324 
325 #ifndef	IRE_DB_REQ_TYPE
326 #define	IRE_DB_REQ_TYPE	M_PCSIG
327 #endif
328 
329 #ifndef	IRE_ARPRESOLVE_TYPE
330 #define	IRE_ARPRESOLVE_TYPE	M_EVENT
331 #endif
332 
333 /*
334  * Values for squeue switch:
335  */
336 
337 #define	IP_SQUEUE_ENTER_NODRAIN	1
338 #define	IP_SQUEUE_ENTER	2
339 /*
340  * This is part of the interface between Transport provider and
341  * IP which can be used to set policy information. This is usually
342  * accompanied with O_T_BIND_REQ/T_BIND_REQ.ip_bind assumes that
343  * only IPSEC_POLICY_SET is there when it is found in the chain.
344  * The information contained is an struct ipsec_req_t. On success
345  * or failure, either the T_BIND_ACK or the T_ERROR_ACK is returned.
346  * IPSEC_POLICY_SET is never returned.
347  */
348 #define	IPSEC_POLICY_SET	M_SETOPTS
349 
350 #define	IRE_IS_LOCAL(ire)	((ire != NULL) && \
351 				((ire)->ire_type & (IRE_LOCAL | IRE_LOOPBACK)))
352 
353 #define	IRE_IS_TARGET(ire)	((ire != NULL) && \
354 				((ire)->ire_type != IRE_BROADCAST))
355 
356 /* IP Fragmentation Reassembly Header */
357 typedef struct ipf_s {
358 	struct ipf_s	*ipf_hash_next;
359 	struct ipf_s	**ipf_ptphn;	/* Pointer to previous hash next. */
360 	uint32_t	ipf_ident;	/* Ident to match. */
361 	uint8_t		ipf_protocol;	/* Protocol to match. */
362 	uchar_t		ipf_last_frag_seen : 1;	/* Last fragment seen ? */
363 	time_t		ipf_timestamp;	/* Reassembly start time. */
364 	mblk_t		*ipf_mp;	/* mblk we live in. */
365 	mblk_t		*ipf_tail_mp;	/* Frag queue tail pointer. */
366 	int		ipf_hole_cnt;	/* Number of holes (hard-case). */
367 	int		ipf_end;	/* Tail end offset (0 -> hard-case). */
368 	uint_t		ipf_gen;	/* Frag queue generation */
369 	size_t		ipf_count;	/* Count of bytes used by frag */
370 	uint_t		ipf_nf_hdr_len; /* Length of nonfragmented header */
371 	in6_addr_t	ipf_v6src;	/* IPv6 source address */
372 	in6_addr_t	ipf_v6dst;	/* IPv6 dest address */
373 	uint_t		ipf_prev_nexthdr_offset; /* Offset for nexthdr value */
374 	uint8_t		ipf_ecn;	/* ECN info for the fragments */
375 	uint8_t		ipf_num_dups;	/* Number of times dup frags recvd */
376 	uint16_t	ipf_checksum_flags; /* Hardware checksum flags */
377 	uint32_t	ipf_checksum;	/* Partial checksum of fragment data */
378 } ipf_t;
379 
380 /*
381  * IPv4 Fragments
382  */
383 #define	IS_V4_FRAGMENT(ipha_fragment_offset_and_flags)			\
384 	(((ntohs(ipha_fragment_offset_and_flags) & IPH_OFFSET) != 0) ||	\
385 	((ntohs(ipha_fragment_offset_and_flags) & IPH_MF) != 0))
386 
387 #define	ipf_src	V4_PART_OF_V6(ipf_v6src)
388 #define	ipf_dst	V4_PART_OF_V6(ipf_v6dst)
389 
390 typedef enum {
391 	IB_PKT = 0x01,
392 	OB_PKT = 0x02
393 } ip_pkt_t;
394 
395 #define	UPDATE_IB_PKT_COUNT(ire)\
396 	{ \
397 	(ire)->ire_ib_pkt_count++; \
398 	if ((ire)->ire_ipif != NULL) { \
399 		/* \
400 		 * forwarding packet \
401 		 */ \
402 		if ((ire)->ire_type & (IRE_LOCAL|IRE_BROADCAST)) \
403 			atomic_add_32(&(ire)->ire_ipif->ipif_ib_pkt_count, 1);\
404 		else \
405 			atomic_add_32(&(ire)->ire_ipif->ipif_fo_pkt_count, 1);\
406 	} \
407 	}
408 
409 #define	UPDATE_OB_PKT_COUNT(ire)\
410 	{ \
411 	(ire)->ire_ob_pkt_count++;\
412 	if ((ire)->ire_ipif != NULL) { \
413 		atomic_add_32(&(ire)->ire_ipif->ipif_ob_pkt_count, 1); \
414 	} \
415 	}
416 
417 #define	IP_RPUT_LOCAL(q, mp, ipha, ire, recv_ill) \
418 { \
419 	switch (ipha->ipha_protocol) { \
420 		case IPPROTO_UDP: \
421 			ip_udp_input(q, mp, ipha, ire, recv_ill); \
422 			break; \
423 		default: \
424 			ip_proto_input(q, mp, ipha, ire, recv_ill, 0); \
425 			break; \
426 	} \
427 }
428 
429 /*
430  * NCE_EXPIRED is TRUE when we have a non-permanent nce that was
431  * found to be REACHABLE more than ip_ire_arp_interval ms ago.
432  * This macro is used to age existing nce_t entries. The
433  * nce's will get cleaned up in the following circumstances:
434  * - ip_ire_trash_reclaim will free nce's using ndp_cache_reclaim
435  *    when memory is low,
436  * - ip_arp_news, when updates are received.
437  * - if the nce is NCE_EXPIRED(), it will deleted, so that a new
438  *   arp request will need to be triggered from an ND_INITIAL nce.
439  *
440  * Note that the nce state transition follows the pattern:
441  *	ND_INITIAL -> ND_INCOMPLETE -> ND_REACHABLE
442  * after which the nce is deleted when it has expired.
443  *
444  * nce_last is the timestamp that indicates when the nce_res_mp in the
445  * nce_t was last updated to a valid link-layer address.  nce_last gets
446  * modified/updated :
447  *  - when the nce is created
448  *  - every time we get a sane arp response for the nce.
449  */
450 #define	NCE_EXPIRED(nce, ipst)	(nce->nce_last > 0 &&	\
451 	    ((nce->nce_flags & NCE_F_PERMANENT) == 0) &&	\
452 	    ((TICK_TO_MSEC(lbolt64) - nce->nce_last) > 		\
453 		(ipst)->ips_ip_ire_arp_interval))
454 
455 #endif /* _KERNEL */
456 
457 /* ICMP types */
458 #define	ICMP_ECHO_REPLY			0
459 #define	ICMP_DEST_UNREACHABLE		3
460 #define	ICMP_SOURCE_QUENCH		4
461 #define	ICMP_REDIRECT			5
462 #define	ICMP_ECHO_REQUEST		8
463 #define	ICMP_ROUTER_ADVERTISEMENT	9
464 #define	ICMP_ROUTER_SOLICITATION	10
465 #define	ICMP_TIME_EXCEEDED		11
466 #define	ICMP_PARAM_PROBLEM		12
467 #define	ICMP_TIME_STAMP_REQUEST		13
468 #define	ICMP_TIME_STAMP_REPLY		14
469 #define	ICMP_INFO_REQUEST		15
470 #define	ICMP_INFO_REPLY			16
471 #define	ICMP_ADDRESS_MASK_REQUEST	17
472 #define	ICMP_ADDRESS_MASK_REPLY		18
473 
474 /* ICMP_TIME_EXCEEDED codes */
475 #define	ICMP_TTL_EXCEEDED		0
476 #define	ICMP_REASSEMBLY_TIME_EXCEEDED	1
477 
478 /* ICMP_DEST_UNREACHABLE codes */
479 #define	ICMP_NET_UNREACHABLE		0
480 #define	ICMP_HOST_UNREACHABLE		1
481 #define	ICMP_PROTOCOL_UNREACHABLE	2
482 #define	ICMP_PORT_UNREACHABLE		3
483 #define	ICMP_FRAGMENTATION_NEEDED	4
484 #define	ICMP_SOURCE_ROUTE_FAILED	5
485 #define	ICMP_DEST_NET_UNKNOWN		6
486 #define	ICMP_DEST_HOST_UNKNOWN		7
487 #define	ICMP_SRC_HOST_ISOLATED		8
488 #define	ICMP_DEST_NET_UNREACH_ADMIN	9
489 #define	ICMP_DEST_HOST_UNREACH_ADMIN	10
490 #define	ICMP_DEST_NET_UNREACH_TOS	11
491 #define	ICMP_DEST_HOST_UNREACH_TOS	12
492 
493 /* ICMP Header Structure */
494 typedef struct icmph_s {
495 	uint8_t		icmph_type;
496 	uint8_t		icmph_code;
497 	uint16_t	icmph_checksum;
498 	union {
499 		struct { /* ECHO request/response structure */
500 			uint16_t	u_echo_ident;
501 			uint16_t	u_echo_seqnum;
502 		} u_echo;
503 		struct { /* Destination unreachable structure */
504 			uint16_t	u_du_zero;
505 			uint16_t	u_du_mtu;
506 		} u_du;
507 		struct { /* Parameter problem structure */
508 			uint8_t		u_pp_ptr;
509 			uint8_t		u_pp_rsvd[3];
510 		} u_pp;
511 		struct { /* Redirect structure */
512 			ipaddr_t	u_rd_gateway;
513 		} u_rd;
514 	} icmph_u;
515 } icmph_t;
516 
517 #define	icmph_echo_ident	icmph_u.u_echo.u_echo_ident
518 #define	icmph_echo_seqnum	icmph_u.u_echo.u_echo_seqnum
519 #define	icmph_du_zero		icmph_u.u_du.u_du_zero
520 #define	icmph_du_mtu		icmph_u.u_du.u_du_mtu
521 #define	icmph_pp_ptr		icmph_u.u_pp.u_pp_ptr
522 #define	icmph_rd_gateway	icmph_u.u_rd.u_rd_gateway
523 
524 #define	ICMPH_SIZE	8
525 
526 /*
527  * Minimum length of transport layer header included in an ICMP error
528  * message for it to be considered valid.
529  */
530 #define	ICMP_MIN_TP_HDR_LEN	8
531 
532 /* Aligned IP header */
533 typedef struct ipha_s {
534 	uint8_t		ipha_version_and_hdr_length;
535 	uint8_t		ipha_type_of_service;
536 	uint16_t	ipha_length;
537 	uint16_t	ipha_ident;
538 	uint16_t	ipha_fragment_offset_and_flags;
539 	uint8_t		ipha_ttl;
540 	uint8_t		ipha_protocol;
541 	uint16_t	ipha_hdr_checksum;
542 	ipaddr_t	ipha_src;
543 	ipaddr_t	ipha_dst;
544 } ipha_t;
545 
546 /*
547  * IP Flags
548  *
549  * Some of these constant names are copied for the DTrace IP provider in
550  * usr/src/lib/libdtrace/common/{ip.d.in, ip.sed.in}, which should be kept
551  * in sync.
552  */
553 #define	IPH_DF		0x4000	/* Don't fragment */
554 #define	IPH_MF		0x2000	/* More fragments to come */
555 #define	IPH_OFFSET	0x1FFF	/* Where the offset lives */
556 #define	IPH_FRAG_HDR	0x8000	/* IPv6 don't fragment bit */
557 
558 /* ECN code points for IPv4 TOS byte and IPv6 traffic class octet. */
559 #define	IPH_ECN_NECT	0x0	/* Not ECN-Capable Transport */
560 #define	IPH_ECN_ECT1	0x1	/* ECN-Capable Transport, ECT(1) */
561 #define	IPH_ECN_ECT0	0x2	/* ECN-Capable Transport, ECT(0) */
562 #define	IPH_ECN_CE	0x3	/* ECN-Congestion Experienced (CE) */
563 
564 struct ill_s;
565 
566 typedef	boolean_t ip_v6intfid_func_t(struct ill_s *, in6_addr_t *);
567 typedef	boolean_t ip_v6mapinfo_func_t(uint_t, uint8_t *, uint8_t *, uint32_t *,
568     in6_addr_t *);
569 typedef boolean_t ip_v4mapinfo_func_t(uint_t, uint8_t *, uint8_t *, uint32_t *,
570     ipaddr_t *);
571 
572 /* IP Mac info structure */
573 typedef struct ip_m_s {
574 	t_uscalar_t		ip_m_mac_type;	/* From <sys/dlpi.h> */
575 	int			ip_m_type;	/* From <net/if_types.h> */
576 	ip_v4mapinfo_func_t	*ip_m_v4mapinfo;
577 	ip_v6mapinfo_func_t	*ip_m_v6mapinfo;
578 	ip_v6intfid_func_t	*ip_m_v6intfid;
579 } ip_m_t;
580 
581 /*
582  * The following functions attempt to reduce the link layer dependency
583  * of the IP stack. The current set of link specific operations are:
584  * a. map from IPv4 class D (224.0/4) multicast address range to the link
585  * layer multicast address range.
586  * b. map from IPv6 multicast address range (ff00::/8) to the link
587  * layer multicast address range.
588  * c. derive the default IPv6 interface identifier from the interface.
589  * d. derive the default IPv6 destination interface identifier from
590  * the interface (point-to-point only).
591  */
592 #define	MEDIA_V4MINFO(ip_m, plen, bphys, maddr, hwxp, v4ptr) \
593 	(((ip_m)->ip_m_v4mapinfo != NULL) && \
594 	(*(ip_m)->ip_m_v4mapinfo)(plen, bphys, maddr, hwxp, v4ptr))
595 #define	MEDIA_V6MINFO(ip_m, plen, bphys, maddr, hwxp, v6ptr) \
596 	(((ip_m)->ip_m_v6mapinfo != NULL) && \
597 	(*(ip_m)->ip_m_v6mapinfo)(plen, bphys, maddr, hwxp, v6ptr))
598 #define	MEDIA_V6INTFID(ip_m, ill, v6ptr) \
599 	(((ip_m)->ip_m_v6intfid != NULL) && \
600 	(*(ip_m)->ip_m_v6intfid)(ill, v6ptr))
601 #define	MEDIA_V6DESTINTFID(ip_m, ill, v6ptr) \
602 	(((ip_m)->ip_m_v6destintfid != NULL) && \
603 	(*(ip_m)->ip_m_v6destintfid)(ill, v6ptr))
604 
605 /* Router entry types */
606 #define	IRE_BROADCAST		0x0001	/* Route entry for broadcast address */
607 #define	IRE_DEFAULT		0x0002	/* Route entry for default gateway */
608 #define	IRE_LOCAL		0x0004	/* Route entry for local address */
609 #define	IRE_LOOPBACK		0x0008	/* Route entry for loopback address */
610 #define	IRE_PREFIX		0x0010	/* Route entry for prefix routes */
611 #define	IRE_CACHE		0x0020	/* Cached Route entry */
612 #define	IRE_IF_NORESOLVER	0x0040	/* Route entry for local interface */
613 					/* net without any address mapping. */
614 #define	IRE_IF_RESOLVER		0x0080	/* Route entry for local interface */
615 					/* net with resolver. */
616 #define	IRE_HOST		0x0100	/* Host route entry */
617 #define	IRE_HOST_REDIRECT	0x0200	/* only used for T_SVR4_OPTMGMT_REQ */
618 
619 #define	IRE_INTERFACE		(IRE_IF_NORESOLVER | IRE_IF_RESOLVER)
620 #define	IRE_OFFSUBNET		(IRE_DEFAULT | IRE_PREFIX | IRE_HOST)
621 #define	IRE_CACHETABLE		(IRE_CACHE | IRE_BROADCAST | IRE_LOCAL | \
622 				IRE_LOOPBACK)
623 #define	IRE_FORWARDTABLE	(IRE_INTERFACE | IRE_OFFSUBNET)
624 
625 /*
626  * If an IRE is marked with IRE_MARK_CONDEMNED, the last walker of
627  * the bucket should delete this IRE from this bucket.
628  */
629 #define	IRE_MARK_CONDEMNED	0x0001
630 
631 /*
632  * An IRE with IRE_MARK_TESTHIDDEN is used by in.mpathd for test traffic.  It
633  * can only be looked up by requesting MATCH_IRE_MARK_TESTHIDDEN.
634  */
635 #define	IRE_MARK_TESTHIDDEN	0x0004
636 
637 /*
638  * An IRE with IRE_MARK_NOADD is created in ip_newroute_ipif when the outgoing
639  * interface is specified by e.g. IP_PKTINFO.  The IRE is not added to the IRE
640  * cache table.
641  */
642 #define	IRE_MARK_NOADD		0x0008	/* Mark not to add ire in cache */
643 
644 /*
645  * IRE marked with IRE_MARK_TEMPORARY means that this IRE has been used
646  * either for forwarding a packet or has not been used for sending
647  * traffic on TCP connections terminated on this system.  In both
648  * cases, this IRE is the first to go when IRE is being cleaned up.
649  */
650 #define	IRE_MARK_TEMPORARY	0x0010
651 
652 /*
653  * IRE marked with IRE_MARK_USESRC_CHECK means that while adding an IRE with
654  * this mark, additional atomic checks need to be performed. For eg: by the
655  * time an IRE_CACHE is created, sent up to ARP and then comes back to IP; the
656  * usesrc grouping could have changed in which case we want to fail adding
657  * the IRE_CACHE entry
658  */
659 #define	IRE_MARK_USESRC_CHECK	0x0020
660 
661 /*
662  * IRE_MARK_PRIVATE_ADDR is used for IP_NEXTHOP. When IP_NEXTHOP is set, the
663  * routing table lookup for the destination is bypassed and the packet is
664  * sent directly to the specified nexthop. The associated IRE_CACHE entries
665  * should be marked with IRE_MARK_PRIVATE_ADDR flag so that they don't show up
666  * in regular ire cache lookups.
667  */
668 #define	IRE_MARK_PRIVATE_ADDR	0x0040
669 
670 /*
671  * When we send an ARP resolution query for the nexthop gateway's ire,
672  * we use esballoc to create the ire_t in the AR_ENTRY_QUERY mblk
673  * chain, and mark its ire_marks with IRE_MARK_UNCACHED. This flag
674  * indicates that information from ARP has not been transferred to a
675  * permanent IRE_CACHE entry. The flag is reset only when the
676  * information is successfully transferred to an ire_cache entry (in
677  * ire_add()). Attempting to free the AR_ENTRY_QUERY mblk chain prior
678  * to ire_add (e.g., from arp, or from ip`ip_wput_nondata) will
679  * require that the resources (incomplete ire_cache and/or nce) must
680  * be cleaned up. The free callback routine (ire_freemblk()) checks
681  * for IRE_MARK_UNCACHED to see if any resources that are pinned down
682  * will need to be cleaned up or not.
683  */
684 
685 #define	IRE_MARK_UNCACHED	0x0080
686 
687 /*
688  * The comment below (and for other netstack_t references) refers
689  * to the fact that we only do netstack_hold in particular cases,
690  * such as the references from open streams (ill_t and conn_t's
691  * pointers). Internally within IP we rely on IP's ability to cleanup e.g.
692  * ire_t's when an ill goes away.
693  */
694 typedef struct ire_expire_arg_s {
695 	int		iea_flush_flag;
696 	ip_stack_t	*iea_ipst;	/* Does not have a netstack_hold */
697 } ire_expire_arg_t;
698 
699 /* Flags with ire_expire routine */
700 #define	FLUSH_ARP_TIME		0x0001	/* ARP info potentially stale timer */
701 #define	FLUSH_REDIRECT_TIME	0x0002	/* Redirects potentially stale */
702 #define	FLUSH_MTU_TIME		0x0004	/* Include path MTU per RFC 1191 */
703 
704 /* Arguments to ire_flush_cache() */
705 #define	IRE_FLUSH_DELETE	0
706 #define	IRE_FLUSH_ADD		1
707 
708 /*
709  * Open/close synchronization flags.
710  * These are kept in a separate field in the conn and the synchronization
711  * depends on the atomic 32 bit access to that field.
712  */
713 #define	CONN_CLOSING		0x01	/* ip_close waiting for ip_wsrv */
714 #define	CONN_IPSEC_LOAD_WAIT	0x02	/* waiting for load */
715 #define	CONN_CONDEMNED		0x04	/* conn is closing, no more refs */
716 #define	CONN_INCIPIENT		0x08	/* conn not yet visible, no refs */
717 #define	CONN_QUIESCED		0x10	/* conn is now quiescent */
718 
719 /* Used to check connection state flags before caching the IRE */
720 #define	CONN_CACHE_IRE(connp)	\
721 	(!((connp)->conn_state_flags & (CONN_CLOSING|CONN_CONDEMNED)))
722 
723 /*
724  * Parameter to ip_output giving the identity of the caller.
725  * IP_WSRV means the packet was enqueued in the STREAMS queue
726  * due to flow control and is now being reprocessed in the context of
727  * the STREAMS service procedure, consequent to flow control relief.
728  * IRE_SEND means the packet is being reprocessed consequent to an
729  * ire cache creation and addition and this may or may not be happening
730  * in the service procedure context. Anything other than the above 2
731  * cases is identified as IP_WPUT. Most commonly this is the case of
732  * packets coming down from the application.
733  */
734 #ifdef _KERNEL
735 #define	IP_WSRV			1	/* Called from ip_wsrv */
736 #define	IP_WPUT			2	/* Called from ip_wput */
737 #define	IRE_SEND		3	/* Called from ire_send */
738 
739 /*
740  * Extra structures need for per-src-addr filtering (IGMPv3/MLDv2)
741  */
742 #define	MAX_FILTER_SIZE	64
743 
744 typedef struct slist_s {
745 	int		sl_numsrc;
746 	in6_addr_t	sl_addr[MAX_FILTER_SIZE];
747 } slist_t;
748 
749 /*
750  * Following struct is used to maintain retransmission state for
751  * a multicast group.  One rtx_state_t struct is an in-line field
752  * of the ilm_t struct; the slist_ts in the rtx_state_t struct are
753  * alloc'd as needed.
754  */
755 typedef struct rtx_state_s {
756 	uint_t		rtx_timer;	/* retrans timer */
757 	int		rtx_cnt;	/* retrans count */
758 	int		rtx_fmode_cnt;	/* retrans count for fmode change */
759 	slist_t		*rtx_allow;
760 	slist_t		*rtx_block;
761 } rtx_state_t;
762 
763 /*
764  * Used to construct list of multicast address records that will be
765  * sent in a single listener report.
766  */
767 typedef struct mrec_s {
768 	struct mrec_s	*mrec_next;
769 	uint8_t		mrec_type;
770 	uint8_t		mrec_auxlen;	/* currently unused */
771 	in6_addr_t	mrec_group;
772 	slist_t		mrec_srcs;
773 } mrec_t;
774 
775 /* Group membership list per upper conn */
776 /*
777  * XXX add ilg info for ifaddr/ifindex.
778  * XXX can we make ilg survive an ifconfig unplumb + plumb
779  * by setting the ipif/ill to NULL and recover that later?
780  *
781  * ilg_ipif is used by IPv4 as multicast groups are joined using an interface
782  * address (ipif).
783  * ilg_ill is used by IPv6 as multicast groups are joined using an interface
784  * index (phyint->phyint_ifindex).
785  * ilg_ill is NULL for IPv4 and ilg_ipif is NULL for IPv6.
786  *
787  * ilg records the state of multicast memberships of a socket end point.
788  * ilm records the state of multicast memberships with the driver and is
789  * maintained per interface.
790  *
791  * There is no direct link between a given ilg and ilm. If the
792  * application has joined a group G with ifindex I, we will have
793  * an ilg with ilg_v6group and ilg_ill. There will be a corresponding
794  * ilm with ilm_ill/ilm_v6addr recording the multicast membership.
795  * To delete the membership:
796  *
797  *	a) Search for ilg matching on G and I with ilg_v6group
798  *	   and ilg_ill. Delete ilg_ill.
799  *	b) Search the corresponding ilm matching on G and I with
800  *	   ilm_v6addr and ilm_ill. Delete ilm.
801  *
802  * For IPv4 the only difference is that we look using ipifs, not ills.
803  */
804 
805 /*
806  * The ilg_t and ilm_t members are protected by ipsq. They can be changed only
807  * by a thread executing in the ipsq. In other words add/delete of a
808  * multicast group has to execute in the ipsq.
809  */
810 #define	ILG_DELETED	0x1		/* ilg_flags */
811 typedef struct ilg_s {
812 	in6_addr_t	ilg_v6group;
813 	struct ipif_s	*ilg_ipif;	/* Logical interface we are member on */
814 	struct ill_s	*ilg_ill;	/* Used by IPv6 */
815 	uint_t		ilg_flags;
816 	mcast_record_t	ilg_fmode;	/* MODE_IS_INCLUDE/MODE_IS_EXCLUDE */
817 	slist_t		*ilg_filter;
818 } ilg_t;
819 
820 /*
821  * Multicast address list entry for ill.
822  * ilm_ipif is used by IPv4 as multicast groups are joined using ipif.
823  * ilm_ill is used by IPv6 as multicast groups are joined using ill.
824  * ilm_ill is NULL for IPv4 and ilm_ipif is NULL for IPv6.
825  *
826  * The comment below (and for other netstack_t references) refers
827  * to the fact that we only do netstack_hold in particular cases,
828  * such as the references from open streams (ill_t and conn_t's
829  * pointers). Internally within IP we rely on IP's ability to cleanup e.g.
830  * ire_t's when an ill goes away.
831  */
832 #define	ILM_DELETED	0x1		/* ilm_flags */
833 typedef struct ilm_s {
834 	in6_addr_t	ilm_v6addr;
835 	int		ilm_refcnt;
836 	uint_t		ilm_timer;	/* IGMP/MLD query resp timer, in msec */
837 	struct ipif_s	*ilm_ipif;	/* Back pointer to ipif for IPv4 */
838 	struct ilm_s	*ilm_next;	/* Linked list for each ill */
839 	uint_t		ilm_state;	/* state of the membership */
840 	struct ill_s	*ilm_ill;	/* Back pointer to ill for IPv6 */
841 	uint_t		ilm_flags;
842 	boolean_t	ilm_notify_driver; /* Need to notify the driver */
843 	zoneid_t	ilm_zoneid;
844 	int		ilm_no_ilg_cnt;	/* number of joins w/ no ilg */
845 	mcast_record_t	ilm_fmode;	/* MODE_IS_INCLUDE/MODE_IS_EXCLUDE */
846 	slist_t		*ilm_filter;	/* source filter list */
847 	slist_t		*ilm_pendsrcs;	/* relevant src addrs for pending req */
848 	rtx_state_t	ilm_rtx;	/* SCR retransmission state */
849 	ip_stack_t	*ilm_ipst;	/* Does not have a netstack_hold */
850 } ilm_t;
851 
852 #define	ilm_addr	V4_PART_OF_V6(ilm_v6addr)
853 
854 typedef struct ilm_walker {
855 	struct ill_s	*ilw_ill;	/* associated ill */
856 	struct ill_s	*ilw_ipmp_ill; 	/* associated ipmp ill (if any) */
857 	struct ill_s	*ilw_walk_ill; 	/* current ill being walked */
858 } ilm_walker_t;
859 
860 /*
861  * Soft reference to an IPsec SA.
862  *
863  * On relative terms, conn's can be persistent (living as long as the
864  * processes which create them), while SA's are ephemeral (dying when
865  * they hit their time-based or byte-based lifetimes).
866  *
867  * We could hold a hard reference to an SA from an ipsec_latch_t,
868  * but this would cause expired SA's to linger for a potentially
869  * unbounded time.
870  *
871  * Instead, we remember the hash bucket number and bucket generation
872  * in addition to the pointer.  The bucket generation is incremented on
873  * each deletion.
874  */
875 typedef struct ipsa_ref_s
876 {
877 	struct ipsa_s	*ipsr_sa;
878 	struct isaf_s	*ipsr_bucket;
879 	uint64_t	ipsr_gen;
880 } ipsa_ref_t;
881 
882 /*
883  * IPsec "latching" state.
884  *
885  * In the presence of IPsec policy, fully-bound conn's bind a connection
886  * to more than just the 5-tuple, but also a specific IPsec action and
887  * identity-pair.
888  *
889  * As an optimization, we also cache soft references to IPsec SA's
890  * here so that we can fast-path around most of the work needed for
891  * outbound IPsec SA selection.
892  *
893  * Were it not for TCP's detached connections, this state would be
894  * in-line in conn_t; instead, this is in a separate structure so it
895  * can be handed off to TCP when a connection is detached.
896  */
897 typedef struct ipsec_latch_s
898 {
899 	kmutex_t	ipl_lock;
900 	uint32_t	ipl_refcnt;
901 
902 	uint64_t	ipl_unique;
903 	struct ipsec_policy_s	*ipl_in_policy; /* latched policy (in) */
904 	struct ipsec_policy_s	*ipl_out_policy; /* latched policy (out) */
905 	struct ipsec_action_s	*ipl_in_action;	/* latched action (in) */
906 	struct ipsec_action_s	*ipl_out_action; /* latched action (out) */
907 	cred_t		*ipl_local_id;
908 	struct ipsid_s	*ipl_local_cid;
909 	struct ipsid_s	*ipl_remote_cid;
910 	unsigned int
911 			ipl_out_action_latched : 1,
912 			ipl_in_action_latched : 1,
913 			ipl_out_policy_latched : 1,
914 			ipl_in_policy_latched : 1,
915 
916 			ipl_ids_latched : 1,
917 
918 			ipl_pad_to_bit_31 : 27;
919 
920 	ipsa_ref_t	ipl_ref[2]; /* 0: ESP, 1: AH */
921 
922 } ipsec_latch_t;
923 
924 #define	IPLATCH_REFHOLD(ipl) { \
925 	atomic_add_32(&(ipl)->ipl_refcnt, 1);		\
926 	ASSERT((ipl)->ipl_refcnt != 0);			\
927 }
928 
929 #define	IPLATCH_REFRELE(ipl, ns) {				\
930 	ASSERT((ipl)->ipl_refcnt != 0);				\
931 	membar_exit();						\
932 	if (atomic_add_32_nv(&(ipl)->ipl_refcnt, -1) == 0)	\
933 		iplatch_free(ipl, ns);			\
934 }
935 
936 /*
937  * peer identity structure.
938  */
939 
940 typedef struct conn_s conn_t;
941 
942 /*
943  * The old IP client structure "ipc_t" is gone. All the data is stored in the
944  * connection structure "conn_t" now. The mapping of old and new fields looks
945  * like this:
946  *
947  * ipc_ulp			conn_ulp
948  * ipc_rq			conn_rq
949  * ipc_wq			conn_wq
950  *
951  * ipc_laddr			conn_src
952  * ipc_faddr			conn_rem
953  * ipc_v6laddr			conn_srcv6
954  * ipc_v6faddr			conn_remv6
955  *
956  * ipc_lport			conn_lport
957  * ipc_fport			conn_fport
958  * ipc_ports			conn_ports
959  *
960  * ipc_policy			conn_policy
961  * ipc_latch			conn_latch
962  *
963  * ipc_irc_lock			conn_lock
964  * ipc_ire_cache		conn_ire_cache
965  *
966  * ipc_state_flags		conn_state_flags
967  * ipc_outgoing_ill		conn_outgoing_ill
968  *
969  * ipc_dontroute 		conn_dontroute
970  * ipc_loopback 		conn_loopback
971  * ipc_broadcast		conn_broadcast
972  * ipc_reuseaddr		conn_reuseaddr
973  *
974  * ipc_multicast_loop		conn_multicast_loop
975  * ipc_multi_router		conn_multi_router
976  * ipc_draining 		conn_draining
977  *
978  * ipc_did_putbq		conn_did_putbq
979  * ipc_unspec_src		conn_unspec_src
980  * ipc_policy_cached		conn_policy_cached
981  *
982  * ipc_in_enforce_policy 	conn_in_enforce_policy
983  * ipc_out_enforce_policy 	conn_out_enforce_policy
984  * ipc_af_isv6			conn_af_isv6
985  * ipc_pkt_isv6			conn_pkt_isv6
986  *
987  * ipc_ipv6_recvpktinfo		conn_ipv6_recvpktinfo
988  *
989  * ipc_ipv6_recvhoplimit	conn_ipv6_recvhoplimit
990  * ipc_ipv6_recvhopopts		conn_ipv6_recvhopopts
991  * ipc_ipv6_recvdstopts		conn_ipv6_recvdstopts
992  *
993  * ipc_ipv6_recvrthdr 		conn_ipv6_recvrthdr
994  * ipc_ipv6_recvrtdstopts	conn_ipv6_recvrtdstopts
995  * ipc_fully_bound		conn_fully_bound
996  *
997  * ipc_recvif			conn_recvif
998  *
999  * ipc_recvslla 		conn_recvslla
1000  * ipc_acking_unbind 		conn_acking_unbind
1001  * ipc_pad_to_bit_31 		conn_pad_to_bit_31
1002  *
1003  * ipc_proto			conn_proto
1004  * ipc_incoming_ill		conn_incoming_ill
1005  * ipc_pending_ill		conn_pending_ill
1006  * ipc_unbind_mp		conn_unbind_mp
1007  * ipc_ilg			conn_ilg
1008  * ipc_ilg_allocated		conn_ilg_allocated
1009  * ipc_ilg_inuse		conn_ilg_inuse
1010  * ipc_ilg_walker_cnt		conn_ilg_walker_cnt
1011  * ipc_refcv			conn_refcv
1012  * ipc_multicast_ipif		conn_multicast_ipif
1013  * ipc_multicast_ill		conn_multicast_ill
1014  * ipc_drain_next		conn_drain_next
1015  * ipc_drain_prev		conn_drain_prev
1016  * ipc_idl			conn_idl
1017  */
1018 
1019 /*
1020  * This is used to match an inbound/outbound datagram with policy.
1021  */
1022 typedef	struct ipsec_selector {
1023 	in6_addr_t	ips_local_addr_v6;
1024 	in6_addr_t	ips_remote_addr_v6;
1025 	uint16_t	ips_local_port;
1026 	uint16_t	ips_remote_port;
1027 	uint8_t		ips_icmp_type;
1028 	uint8_t		ips_icmp_code;
1029 	uint8_t		ips_protocol;
1030 	uint8_t		ips_isv4 : 1,
1031 			ips_is_icmp_inv_acq: 1;
1032 } ipsec_selector_t;
1033 
1034 /*
1035  * Note that we put v4 addresses in the *first* 32-bit word of the
1036  * selector rather than the last to simplify the prefix match/mask code
1037  * in spd.c
1038  */
1039 #define	ips_local_addr_v4 ips_local_addr_v6.s6_addr32[0]
1040 #define	ips_remote_addr_v4 ips_remote_addr_v6.s6_addr32[0]
1041 
1042 /* Values used in IP by IPSEC Code */
1043 #define		IPSEC_OUTBOUND		B_TRUE
1044 #define		IPSEC_INBOUND		B_FALSE
1045 
1046 /*
1047  * There are two variants in policy failures. The packet may come in
1048  * secure when not needed (IPSEC_POLICY_???_NOT_NEEDED) or it may not
1049  * have the desired level of protection (IPSEC_POLICY_MISMATCH).
1050  */
1051 #define	IPSEC_POLICY_NOT_NEEDED		0
1052 #define	IPSEC_POLICY_MISMATCH		1
1053 #define	IPSEC_POLICY_AUTH_NOT_NEEDED	2
1054 #define	IPSEC_POLICY_ENCR_NOT_NEEDED	3
1055 #define	IPSEC_POLICY_SE_NOT_NEEDED	4
1056 #define	IPSEC_POLICY_MAX		5	/* Always max + 1. */
1057 
1058 /*
1059  * Folowing macro is used whenever the code does not know whether there
1060  * is a M_CTL present in the front and it needs to examine the actual mp
1061  * i.e the IP header. As a M_CTL message could be in the front, this
1062  * extracts the packet into mp and the M_CTL mp into first_mp. If M_CTL
1063  * mp is not present, both first_mp and mp point to the same message.
1064  */
1065 #define	EXTRACT_PKT_MP(mp, first_mp, mctl_present)	\
1066 	(first_mp) = (mp);				\
1067 	if ((mp)->b_datap->db_type == M_CTL) {		\
1068 		(mp) = (mp)->b_cont;			\
1069 		(mctl_present) = B_TRUE;		\
1070 	} else {					\
1071 		(mctl_present) = B_FALSE;		\
1072 	}
1073 
1074 /*
1075  * Check with IPSEC inbound policy if
1076  *
1077  * 1) per-socket policy is present - indicated by conn_in_enforce_policy.
1078  * 2) Or if we have not cached policy on the conn and the global policy is
1079  *    non-empty.
1080  */
1081 #define	CONN_INBOUND_POLICY_PRESENT(connp, ipss)	\
1082 	((connp)->conn_in_enforce_policy ||		\
1083 	(!((connp)->conn_policy_cached) && 		\
1084 	(ipss)->ipsec_inbound_v4_policy_present))
1085 
1086 #define	CONN_INBOUND_POLICY_PRESENT_V6(connp, ipss)	\
1087 	((connp)->conn_in_enforce_policy ||		\
1088 	(!(connp)->conn_policy_cached &&		\
1089 	(ipss)->ipsec_inbound_v6_policy_present))
1090 
1091 #define	CONN_OUTBOUND_POLICY_PRESENT(connp, ipss)	\
1092 	((connp)->conn_out_enforce_policy ||		\
1093 	(!((connp)->conn_policy_cached) &&		\
1094 	(ipss)->ipsec_outbound_v4_policy_present))
1095 
1096 #define	CONN_OUTBOUND_POLICY_PRESENT_V6(connp, ipss)	\
1097 	((connp)->conn_out_enforce_policy ||		\
1098 	(!(connp)->conn_policy_cached &&		\
1099 	(ipss)->ipsec_outbound_v6_policy_present))
1100 
1101 /*
1102  * Information cached in IRE for upper layer protocol (ULP).
1103  *
1104  * Notice that ire_max_frag is not included in the iulp_t structure, which
1105  * it may seem that it should.  But ire_max_frag cannot really be cached.  It
1106  * is fixed for each interface.  For MTU found by PMTUd, we may want to cache
1107  * it.  But currently, we do not do that.
1108  */
1109 typedef struct iulp_s {
1110 	boolean_t	iulp_set;	/* Is any metric set? */
1111 	uint32_t	iulp_ssthresh;	/* Slow start threshold (TCP). */
1112 	clock_t		iulp_rtt;	/* Guestimate in millisecs. */
1113 	clock_t		iulp_rtt_sd;	/* Cached value of RTT variance. */
1114 	uint32_t	iulp_spipe;	/* Send pipe size. */
1115 	uint32_t	iulp_rpipe;	/* Receive pipe size. */
1116 	uint32_t	iulp_rtomax;	/* Max round trip timeout. */
1117 	uint32_t	iulp_sack;	/* Use SACK option (TCP)? */
1118 	uint32_t
1119 		iulp_tstamp_ok : 1,	/* Use timestamp option (TCP)? */
1120 		iulp_wscale_ok : 1,	/* Use window scale option (TCP)? */
1121 		iulp_ecn_ok : 1,	/* Enable ECN (for TCP)? */
1122 		iulp_pmtud_ok : 1,	/* Enable PMTUd? */
1123 
1124 		iulp_not_used : 28;
1125 } iulp_t;
1126 
1127 /* Zero iulp_t. */
1128 extern const iulp_t ire_uinfo_null;
1129 
1130 /*
1131  * The conn drain list structure (idl_t).
1132  * The list is protected by idl_lock. Each conn_t inserted in the list
1133  * points back at this idl_t using conn_idl. IP primes the draining of the
1134  * conns queued in these lists, by qenabling the 1st conn of each list. This
1135  * occurs when STREAMS backenables ip_wsrv on the IP module. Each conn instance
1136  * of ip_wsrv successively qenables the next conn in the list.
1137  * idl_lock protects all other members of idl_t and conn_drain_next
1138  * and conn_drain_prev of conn_t. The conn_lock protects IPCF_DRAIN_DISABLED
1139  * flag of the conn_t and conn_idl.
1140  *
1141  * The conn drain list, idl_t, itself is part of tx cookie list structure.
1142  * A tx cookie list points to a blocked Tx ring and contains the list of
1143  * all conn's that are blocked due to the flow-controlled Tx ring (via
1144  * the idl drain list). Note that a link can have multiple Tx rings. The
1145  * drain list will store the conn's blocked due to Tx ring being flow
1146  * controlled.
1147  */
1148 
1149 typedef uintptr_t ip_mac_tx_cookie_t;
1150 typedef	struct idl_s idl_t;
1151 typedef	struct idl_tx_list_s idl_tx_list_t;
1152 
1153 struct idl_tx_list_s {
1154 	ip_mac_tx_cookie_t	txl_cookie;
1155 	kmutex_t		txl_lock;	/* Lock for this list */
1156 	idl_t			*txl_drain_list;
1157 	int			txl_drain_index;
1158 };
1159 
1160 struct idl_s {
1161 	conn_t		*idl_conn;		/* Head of drain list */
1162 	kmutex_t	idl_lock;		/* Lock for this list */
1163 	conn_t		*idl_conn_draining;	/* conn that is draining */
1164 	uint32_t
1165 		idl_repeat : 1,			/* Last conn must re-enable */
1166 						/* drain list again */
1167 		idl_unused : 31;
1168 	idl_tx_list_t	*idl_itl;
1169 };
1170 
1171 #define	CONN_DRAIN_LIST_LOCK(connp)	(&((connp)->conn_idl->idl_lock))
1172 /*
1173  * Interface route structure which holds the necessary information to recreate
1174  * routes that are tied to an interface (namely where ire_ipif != NULL).
1175  * These routes which were initially created via a routing socket or via the
1176  * SIOCADDRT ioctl may be gateway routes (RTF_GATEWAY being set) or may be
1177  * traditional interface routes.  When an interface comes back up after being
1178  * marked down, this information will be used to recreate the routes.  These
1179  * are part of an mblk_t chain that hangs off of the IPIF (ipif_saved_ire_mp).
1180  */
1181 typedef struct ifrt_s {
1182 	ushort_t	ifrt_type;		/* Type of IRE */
1183 	in6_addr_t	ifrt_v6addr;		/* Address IRE represents. */
1184 	in6_addr_t	ifrt_v6gateway_addr;	/* Gateway if IRE_OFFSUBNET */
1185 	in6_addr_t	ifrt_v6src_addr;	/* Src addr if RTF_SETSRC */
1186 	in6_addr_t	ifrt_v6mask;		/* Mask for matching IRE. */
1187 	uint32_t	ifrt_flags;		/* flags related to route */
1188 	uint_t		ifrt_max_frag;		/* MTU (next hop or path). */
1189 	iulp_t		ifrt_iulp_info;		/* Cached IRE ULP info. */
1190 } ifrt_t;
1191 
1192 #define	ifrt_addr		V4_PART_OF_V6(ifrt_v6addr)
1193 #define	ifrt_gateway_addr	V4_PART_OF_V6(ifrt_v6gateway_addr)
1194 #define	ifrt_src_addr		V4_PART_OF_V6(ifrt_v6src_addr)
1195 #define	ifrt_mask		V4_PART_OF_V6(ifrt_v6mask)
1196 
1197 /* Number of IP addresses that can be hosted on a physical interface */
1198 #define	MAX_ADDRS_PER_IF	8192
1199 /*
1200  * Number of Source addresses to be considered for source address
1201  * selection. Used by ipif_select_source[_v6].
1202  */
1203 #define	MAX_IPIF_SELECT_SOURCE	50
1204 
1205 #ifdef IP_DEBUG
1206 /*
1207  * Trace refholds and refreles for debugging.
1208  */
1209 #define	TR_STACK_DEPTH	14
1210 typedef struct tr_buf_s {
1211 	int	tr_depth;
1212 	clock_t	tr_time;
1213 	pc_t	tr_stack[TR_STACK_DEPTH];
1214 } tr_buf_t;
1215 
1216 typedef struct th_trace_s {
1217 	int		th_refcnt;
1218 	uint_t		th_trace_lastref;
1219 	kthread_t	*th_id;
1220 #define	TR_BUF_MAX	38
1221 	tr_buf_t	th_trbuf[TR_BUF_MAX];
1222 } th_trace_t;
1223 
1224 typedef struct th_hash_s {
1225 	list_node_t	thh_link;
1226 	mod_hash_t	*thh_hash;
1227 	ip_stack_t	*thh_ipst;
1228 } th_hash_t;
1229 #endif
1230 
1231 /* The following are ipif_state_flags */
1232 #define	IPIF_CONDEMNED		0x1	/* The ipif is being removed */
1233 #define	IPIF_CHANGING		0x2	/* A critcal ipif field is changing */
1234 #define	IPIF_SET_LINKLOCAL	0x10	/* transient flag during bringup */
1235 #define	IPIF_ZERO_SOURCE	0x20	/* transient flag during bringup */
1236 
1237 /* IP interface structure, one per local address */
1238 typedef struct ipif_s {
1239 	struct	ipif_s	*ipif_next;
1240 	struct	ill_s	*ipif_ill;	/* Back pointer to our ill */
1241 	int	ipif_id;		/* Logical unit number */
1242 	uint_t	ipif_mtu;		/* Starts at ipif_ill->ill_max_frag */
1243 	in6_addr_t ipif_v6lcl_addr;	/* Local IP address for this if. */
1244 	in6_addr_t ipif_v6src_addr;	/* Source IP address for this if. */
1245 	in6_addr_t ipif_v6subnet;	/* Subnet prefix for this if. */
1246 	in6_addr_t ipif_v6net_mask;	/* Net mask for this interface. */
1247 	in6_addr_t ipif_v6brd_addr;	/* Broadcast addr for this interface. */
1248 	in6_addr_t ipif_v6pp_dst_addr;	/* Point-to-point dest address. */
1249 	uint64_t ipif_flags;		/* Interface flags. */
1250 	uint_t	ipif_metric;		/* BSD if metric, for compatibility. */
1251 	uint_t	ipif_ire_type;		/* IRE_LOCAL or IRE_LOOPBACK */
1252 	mblk_t	*ipif_arp_del_mp;	/* Allocated at time arp comes up, to */
1253 					/* prevent awkward out of mem */
1254 					/* condition later */
1255 	mblk_t	*ipif_saved_ire_mp;	/* Allocated for each extra */
1256 					/* IRE_IF_NORESOLVER/IRE_IF_RESOLVER */
1257 					/* on this interface so that they */
1258 					/* can survive ifconfig down. */
1259 	kmutex_t ipif_saved_ire_lock;	/* Protects ipif_saved_ire_mp */
1260 
1261 	mrec_t	*ipif_igmp_rpt;		/* List of group memberships which */
1262 					/* will be reported on.  Used when */
1263 					/* handling an igmp timeout.	   */
1264 
1265 	/*
1266 	 * The packet counts in the ipif contain the sum of the
1267 	 * packet counts in dead IREs that were affiliated with
1268 	 * this ipif.
1269 	 */
1270 	uint_t	ipif_fo_pkt_count;	/* Forwarded thru our dead IREs */
1271 	uint_t	ipif_ib_pkt_count;	/* Inbound packets for our dead IREs */
1272 	uint_t	ipif_ob_pkt_count;	/* Outbound packets to our dead IREs */
1273 	/* Exclusive bit fields, protected by ipsq_t */
1274 	unsigned int
1275 		ipif_multicast_up : 1,	/* ipif_multicast_up() successful */
1276 		ipif_was_up : 1,	/* ipif was up before */
1277 		ipif_addr_ready : 1,	/* DAD is done */
1278 		ipif_was_dup : 1,	/* DAD had failed */
1279 
1280 		ipif_joined_allhosts : 1, /* allhosts joined */
1281 		ipif_added_nce:1,	/* nce added for local address */
1282 		ipif_pad_to_31 : 26;
1283 
1284 	uint_t	ipif_seqid;		/* unique index across all ills */
1285 	uint_t	ipif_state_flags;	/* See IPIF_* flag defs above */
1286 	uint_t	ipif_refcnt;		/* active consistent reader cnt */
1287 
1288 	/* Number of ire's and ilm's referencing this ipif */
1289 	uint_t	ipif_ire_cnt;
1290 	uint_t	ipif_ilm_cnt;
1291 
1292 	uint_t  ipif_saved_ire_cnt;
1293 	zoneid_t ipif_zoneid;		/* zone ID number */
1294 	timeout_id_t ipif_recovery_id;	/* Timer for DAD recovery */
1295 	boolean_t ipif_trace_disable;	/* True when alloc fails */
1296 	/*
1297 	 * For an IPMP interface, ipif_bound_ill tracks the ill whose hardware
1298 	 * information this ipif is associated with via ARP/NDP.  We can use
1299 	 * an ill pointer (rather than an index) because only ills that are
1300 	 * part of a group will be pointed to, and an ill cannot disappear
1301 	 * while it's in a group.
1302 	 */
1303 	struct ill_s	*ipif_bound_ill;
1304 	struct ipif_s	*ipif_bound_next; /* bound ipif chain */
1305 	boolean_t	ipif_bound;	 /* B_TRUE if we successfully bound */
1306 } ipif_t;
1307 
1308 /*
1309  * IPIF_FREE_OK() means that there are no incoming references
1310  * to the ipif. Incoming refs would prevent the ipif from being freed.
1311  */
1312 #define	IPIF_FREE_OK(ipif)	\
1313 	((ipif)->ipif_ire_cnt == 0 && (ipif)->ipif_ilm_cnt == 0)
1314 /*
1315  * IPIF_DOWN_OK() determines whether the incoming pointer reference counts
1316  * would permit the ipif to be considered quiescent. In order for
1317  * an ipif or ill to be considered quiescent, the ire and nce references
1318  * to that ipif/ill must be zero.
1319  *
1320  * We do not require the ilm references to go to zero for quiescence
1321  * because the quiescence checks are done to ensure that
1322  * outgoing packets do not use addresses from the ipif/ill after it
1323  * has been marked down, and incoming packets to addresses on a
1324  * queiscent interface are rejected. This implies that all the
1325  * ire/nce's using that source address need to be deleted and future
1326  * creation of any ires using that source address must be prevented.
1327  * Similarly incoming unicast packets destined to the 'down' address
1328  * will not be accepted once that ire is gone. However incoming
1329  * multicast packets are not destined to the downed address.
1330  * They are only related to the ill in question. Furthermore
1331  * the current API behavior allows applications to join or leave
1332  * multicast groups, i.e., IP_ADD_MEMBERSHIP / LEAVE_MEMBERSHIP, using a
1333  * down address. Therefore the ilm references are not included in
1334  * the _DOWN_OK macros.
1335  */
1336 #define	IPIF_DOWN_OK(ipif)		((ipif)->ipif_ire_cnt == 0)
1337 
1338 /*
1339  * The following table lists the protection levels of the various members
1340  * of the ipif_t. The following notation is used.
1341  *
1342  * Write once - Written to only once at the time of bringing up
1343  * the interface and can be safely read after the bringup without any lock.
1344  *
1345  * ipsq - Need to execute in the ipsq to perform the indicated access.
1346  *
1347  * ill_lock - Need to hold this mutex to perform the indicated access.
1348  *
1349  * ill_g_lock - Need to hold this rw lock as reader/writer for read access or
1350  * write access respectively.
1351  *
1352  * down ill - Written to only when the ill is down (i.e all ipifs are down)
1353  * up ill - Read only when the ill is up (i.e. at least 1 ipif is up)
1354  *
1355  *		 Table of ipif_t members and their protection
1356  *
1357  * ipif_next		ipsq + ill_lock +	ipsq OR ill_lock OR
1358  *			ill_g_lock		ill_g_lock
1359  * ipif_ill		ipsq + down ipif	write once
1360  * ipif_id		ipsq + down ipif	write once
1361  * ipif_mtu		ipsq
1362  * ipif_v6lcl_addr	ipsq + down ipif	up ipif
1363  * ipif_v6src_addr	ipsq + down ipif	up ipif
1364  * ipif_v6subnet	ipsq + down ipif	up ipif
1365  * ipif_v6net_mask	ipsq + down ipif	up ipif
1366  *
1367  * ipif_v6brd_addr
1368  * ipif_v6pp_dst_addr
1369  * ipif_flags		ill_lock		ill_lock
1370  * ipif_metric
1371  * ipif_ire_type	ipsq + down ill		up ill
1372  *
1373  * ipif_arp_del_mp	ipsq			ipsq
1374  * ipif_saved_ire_mp	ipif_saved_ire_lock	ipif_saved_ire_lock
1375  * ipif_igmp_rpt	ipsq			ipsq
1376  *
1377  * ipif_fo_pkt_count	Approx
1378  * ipif_ib_pkt_count	Approx
1379  * ipif_ob_pkt_count	Approx
1380  *
1381  * bit fields		ill_lock		ill_lock
1382  *
1383  * ipif_seqid		ipsq			Write once
1384  *
1385  * ipif_state_flags	ill_lock		ill_lock
1386  * ipif_refcnt		ill_lock		ill_lock
1387  * ipif_ire_cnt		ill_lock		ill_lock
1388  * ipif_ilm_cnt		ill_lock		ill_lock
1389  * ipif_saved_ire_cnt
1390  *
1391  * ipif_bound_ill	ipsq + ipmp_lock	ipsq OR ipmp_lock
1392  * ipif_bound_next	ipsq			ipsq
1393  * ipif_bound		ipsq			ipsq
1394  */
1395 
1396 #define	IP_TR_HASH(tid)	((((uintptr_t)tid) >> 6) & (IP_TR_HASH_MAX - 1))
1397 
1398 #ifdef DEBUG
1399 #define	IPIF_TRACE_REF(ipif)	ipif_trace_ref(ipif)
1400 #define	ILL_TRACE_REF(ill)	ill_trace_ref(ill)
1401 #define	IPIF_UNTRACE_REF(ipif)	ipif_untrace_ref(ipif)
1402 #define	ILL_UNTRACE_REF(ill)	ill_untrace_ref(ill)
1403 #else
1404 #define	IPIF_TRACE_REF(ipif)
1405 #define	ILL_TRACE_REF(ill)
1406 #define	IPIF_UNTRACE_REF(ipif)
1407 #define	ILL_UNTRACE_REF(ill)
1408 #endif
1409 
1410 /* IPv4 compatibility macros */
1411 #define	ipif_lcl_addr		V4_PART_OF_V6(ipif_v6lcl_addr)
1412 #define	ipif_src_addr		V4_PART_OF_V6(ipif_v6src_addr)
1413 #define	ipif_subnet		V4_PART_OF_V6(ipif_v6subnet)
1414 #define	ipif_net_mask		V4_PART_OF_V6(ipif_v6net_mask)
1415 #define	ipif_brd_addr		V4_PART_OF_V6(ipif_v6brd_addr)
1416 #define	ipif_pp_dst_addr	V4_PART_OF_V6(ipif_v6pp_dst_addr)
1417 
1418 /* Macros for easy backreferences to the ill. */
1419 #define	ipif_wq			ipif_ill->ill_wq
1420 #define	ipif_rq			ipif_ill->ill_rq
1421 #define	ipif_net_type		ipif_ill->ill_net_type
1422 #define	ipif_ipif_up_count	ipif_ill->ill_ipif_up_count
1423 #define	ipif_type		ipif_ill->ill_type
1424 #define	ipif_isv6		ipif_ill->ill_isv6
1425 
1426 #define	SIOCLIFADDR_NDX 112	/* ndx of SIOCLIFADDR in the ndx ioctl table */
1427 
1428 /*
1429  * mode value for ip_ioctl_finish for finishing an ioctl
1430  */
1431 #define	CONN_CLOSE	1		/* No mi_copy */
1432 #define	COPYOUT		2		/* do an mi_copyout if needed */
1433 #define	NO_COPYOUT	3		/* do an mi_copy_done */
1434 #define	IPI2MODE(ipi)	((ipi)->ipi_flags & IPI_GET_CMD ? COPYOUT : NO_COPYOUT)
1435 
1436 /*
1437  * The IP-MT design revolves around the serialization objects ipsq_t (IPSQ)
1438  * and ipxop_t (exclusive operation or "xop").  Becoming "writer" on an IPSQ
1439  * ensures that no other threads can become "writer" on any IPSQs sharing that
1440  * IPSQ's xop until the writer thread is done.
1441  *
1442  * Each phyint points to one IPSQ that remains fixed over the phyint's life.
1443  * Each IPSQ points to one xop that can change over the IPSQ's life.  If a
1444  * phyint is *not* in an IPMP group, then its IPSQ will refer to the IPSQ's
1445  * "own" xop (ipsq_ownxop).  If a phyint *is* part of an IPMP group, then its
1446  * IPSQ will refer to the "group" xop, which is shorthand for the xop of the
1447  * IPSQ of the IPMP meta-interface's phyint.  Thus, all phyints that are part
1448  * of the same IPMP group will have their IPSQ's point to the group xop, and
1449  * thus becoming "writer" on any phyint in the group will prevent any other
1450  * writer on any other phyint in the group.  All IPSQs sharing the same xop
1451  * are chained together through ipsq_next (in the degenerate common case,
1452  * ipsq_next simply refers to itself).  Note that the group xop is guaranteed
1453  * to exist at least as long as there are members in the group, since the IPMP
1454  * meta-interface can only be destroyed if the group is empty.
1455  *
1456  * Incoming exclusive operation requests are enqueued on the IPSQ they arrived
1457  * on rather than the xop.  This makes switching xop's (as would happen when a
1458  * phyint leaves an IPMP group) simple, because after the phyint leaves the
1459  * group, any operations enqueued on its IPSQ can be safely processed with
1460  * respect to its new xop, and any operations enqueued on the IPSQs of its
1461  * former group can be processed with respect to their existing group xop.
1462  * Even so, switching xops is a subtle dance; see ipsq_dq() for details.
1463  *
1464  * An IPSQ's "own" xop is embedded within the IPSQ itself since they have have
1465  * identical lifetimes, and because doing so simplifies pointer management.
1466  * While each phyint and IPSQ point to each other, it is not possible to free
1467  * the IPSQ when the phyint is freed, since we may still *inside* the IPSQ
1468  * when the phyint is being freed.  Thus, ipsq_phyint is set to NULL when the
1469  * phyint is freed, and the IPSQ free is later done in ipsq_exit().
1470  *
1471  * ipsq_t synchronization:	read			write
1472  *
1473  *	ipsq_xopq_mphead	ipx_lock		ipx_lock
1474  *	ipsq_xopq_mptail	ipx_lock		ipx_lock
1475  *	ipsq_xop_switch_mp	ipsq_lock		ipsq_lock
1476  *	ipsq_phyint		write once		write once
1477  *	ipsq_next		RW_READER ill_g_lock	RW_WRITER ill_g_lock
1478  *	ipsq_xop 		ipsq_lock or ipsq	ipsq_lock + ipsq
1479  *	ipsq_swxop		ipsq			ipsq
1480  * 	ipsq_ownxop		see ipxop_t		see ipxop_t
1481  *	ipsq_ipst		write once		write once
1482  *
1483  * ipxop_t synchronization:     read			write
1484  *
1485  *	ipx_writer  		ipx_lock		ipx_lock
1486  *	ipx_xop_queued		ipx_lock 		ipx_lock
1487  *	ipx_mphead		ipx_lock		ipx_lock
1488  *	ipx_mptail		ipx_lock		ipx_lock
1489  *	ipx_ipsq		write once		write once
1490  *	ips_ipsq_queued		ipx_lock		ipx_lock
1491  *	ipx_waitfor		ipsq or ipx_lock	ipsq + ipx_lock
1492  *	ipx_reentry_cnt		ipsq or ipx_lock	ipsq + ipx_lock
1493  *	ipx_current_done	ipsq			ipsq
1494  *	ipx_current_ioctl	ipsq			ipsq
1495  *	ipx_current_ipif	ipsq or ipx_lock	ipsq + ipx_lock
1496  *	ipx_pending_ipif	ipsq or ipx_lock	ipsq + ipx_lock
1497  *	ipx_pending_mp		ipsq or ipx_lock	ipsq + ipx_lock
1498  *	ipx_forced		ipsq			ipsq
1499  *	ipx_depth		ipsq			ipsq
1500  *	ipx_stack		ipsq			ipsq
1501  */
1502 typedef struct ipxop_s {
1503 	kmutex_t	ipx_lock;	/* see above */
1504 	kthread_t	*ipx_writer;  	/* current owner */
1505 	mblk_t		*ipx_mphead;	/* messages tied to this op */
1506 	mblk_t		*ipx_mptail;
1507 	struct ipsq_s	*ipx_ipsq;	/* associated ipsq */
1508 	boolean_t	ipx_ipsq_queued; /* ipsq using xop has queued op */
1509 	int		ipx_waitfor;	/* waiting; values encoded below */
1510 	int		ipx_reentry_cnt;
1511 	boolean_t	ipx_current_done;  /* is the current operation done? */
1512 	int		ipx_current_ioctl; /* current ioctl, or 0 if no ioctl */
1513 	ipif_t		*ipx_current_ipif; /* ipif for current op */
1514 	ipif_t		*ipx_pending_ipif; /* ipif for ipsq_pending_mp */
1515 	mblk_t 		*ipx_pending_mp;   /* current ioctl mp while waiting */
1516 	boolean_t	ipx_forced; 			/* debugging aid */
1517 #ifdef DEBUG
1518 	int		ipx_depth;			/* debugging aid */
1519 #define	IPX_STACK_DEPTH	15
1520 	pc_t		ipx_stack[IPX_STACK_DEPTH];	/* debugging aid */
1521 #endif
1522 } ipxop_t;
1523 
1524 typedef struct ipsq_s {
1525 	kmutex_t ipsq_lock;		/* see above */
1526 	mblk_t	*ipsq_switch_mp;	/* op to handle right after switch */
1527 	mblk_t	*ipsq_xopq_mphead;	/* list of excl ops (mostly ioctls) */
1528 	mblk_t	*ipsq_xopq_mptail;
1529 	struct phyint	*ipsq_phyint;	/* associated phyint */
1530 	struct ipsq_s	*ipsq_next;	/* next ipsq sharing ipsq_xop */
1531 	struct ipxop_s	*ipsq_xop;	/* current xop synchronization info */
1532 	struct ipxop_s	*ipsq_swxop;	/* switch xop to on ipsq_exit() */
1533 	struct ipxop_s	ipsq_ownxop;	/* our own xop (may not be in-use) */
1534 	ip_stack_t	*ipsq_ipst;	/* does not have a netstack_hold */
1535 } ipsq_t;
1536 
1537 /*
1538  * ipx_waitfor values:
1539  */
1540 enum {
1541 	IPIF_DOWN = 1,	/* ipif_down() waiting for refcnts to drop */
1542 	ILL_DOWN,	/* ill_down() waiting for refcnts to drop */
1543 	IPIF_FREE,	/* ipif_free() waiting for refcnts to drop */
1544 	ILL_FREE	/* ill unplumb waiting for refcnts to drop */
1545 };
1546 
1547 /* Operation types for ipsq_try_enter() */
1548 #define	CUR_OP 0	/* request writer within current operation */
1549 #define	NEW_OP 1	/* request writer for a new operation */
1550 #define	SWITCH_OP 2	/* request writer once IPSQ XOP switches */
1551 
1552 /*
1553  * Kstats tracked on each IPMP meta-interface.  Order here must match
1554  * ipmp_kstats[] in ip/ipmp.c.
1555  */
1556 enum {
1557 	IPMP_KSTAT_OBYTES,	IPMP_KSTAT_OBYTES64,	IPMP_KSTAT_RBYTES,
1558 	IPMP_KSTAT_RBYTES64,	IPMP_KSTAT_OPACKETS,	IPMP_KSTAT_OPACKETS64,
1559 	IPMP_KSTAT_OERRORS,	IPMP_KSTAT_IPACKETS,	IPMP_KSTAT_IPACKETS64,
1560 	IPMP_KSTAT_IERRORS,	IPMP_KSTAT_MULTIRCV,	IPMP_KSTAT_MULTIXMT,
1561 	IPMP_KSTAT_BRDCSTRCV,	IPMP_KSTAT_BRDCSTXMT,	IPMP_KSTAT_LINK_UP,
1562 	IPMP_KSTAT_MAX		/* keep last */
1563 };
1564 
1565 /*
1566  * phyint represents state that is common to both IPv4 and IPv6 interfaces.
1567  * There is a separate ill_t representing IPv4 and IPv6 which has a
1568  * backpointer to the phyint structure for accessing common state.
1569  */
1570 typedef struct phyint {
1571 	struct ill_s	*phyint_illv4;
1572 	struct ill_s	*phyint_illv6;
1573 	uint_t		phyint_ifindex;		/* SIOCSLIFINDEX */
1574 	uint64_t	phyint_flags;
1575 	avl_node_t	phyint_avl_by_index;	/* avl tree by index */
1576 	avl_node_t	phyint_avl_by_name;	/* avl tree by name */
1577 	kmutex_t	phyint_lock;
1578 	struct ipsq_s	*phyint_ipsq;		/* back pointer to ipsq */
1579 	struct ipmp_grp_s *phyint_grp;		/* associated IPMP group */
1580 	char		phyint_name[LIFNAMSIZ];	/* physical interface name */
1581 	uint64_t	phyint_kstats0[IPMP_KSTAT_MAX];	/* baseline kstats */
1582 } phyint_t;
1583 
1584 #define	CACHE_ALIGN_SIZE 64
1585 #define	CACHE_ALIGN(align_struct)	P2ROUNDUP(sizeof (struct align_struct),\
1586 							CACHE_ALIGN_SIZE)
1587 struct _phyint_list_s_ {
1588 	avl_tree_t	phyint_list_avl_by_index;	/* avl tree by index */
1589 	avl_tree_t	phyint_list_avl_by_name;	/* avl tree by name */
1590 };
1591 
1592 typedef union phyint_list_u {
1593 	struct	_phyint_list_s_ phyint_list_s;
1594 	char	phyint_list_filler[CACHE_ALIGN(_phyint_list_s_)];
1595 } phyint_list_t;
1596 
1597 #define	phyint_list_avl_by_index	phyint_list_s.phyint_list_avl_by_index
1598 #define	phyint_list_avl_by_name		phyint_list_s.phyint_list_avl_by_name
1599 
1600 /*
1601  * Fragmentation hash bucket
1602  */
1603 typedef struct ipfb_s {
1604 	struct ipf_s	*ipfb_ipf;	/* List of ... */
1605 	size_t		ipfb_count;	/* Count of bytes used by frag(s) */
1606 	kmutex_t	ipfb_lock;	/* Protect all ipf in list */
1607 	uint_t		ipfb_frag_pkts; /* num of distinct fragmented pkts */
1608 } ipfb_t;
1609 
1610 /*
1611  * IRE bucket structure. Usually there is an array of such structures,
1612  * each pointing to a linked list of ires. irb_refcnt counts the number
1613  * of walkers of a given hash bucket. Usually the reference count is
1614  * bumped up if the walker wants no IRES to be DELETED while walking the
1615  * list. Bumping up does not PREVENT ADDITION. This allows walking a given
1616  * hash bucket without stumbling up on a free pointer.
1617  *
1618  * irb_t structures in ip_ftable are dynamically allocated and freed.
1619  * In order to identify the irb_t structures that can be safely kmem_free'd
1620  * we need to ensure that
1621  *  - the irb_refcnt is quiescent, indicating no other walkers,
1622  *  - no other threads or ire's are holding references to the irb,
1623  *	i.e., irb_nire == 0,
1624  *  - there are no active ire's in the bucket, i.e., irb_ire_cnt == 0
1625  */
1626 typedef struct irb {
1627 	struct ire_s	*irb_ire;	/* First ire in this bucket */
1628 					/* Should be first in this struct */
1629 	krwlock_t	irb_lock;	/* Protect this bucket */
1630 	uint_t		irb_refcnt;	/* Protected by irb_lock */
1631 	uchar_t		irb_marks;	/* CONDEMNED ires in this bucket ? */
1632 #define	IRB_MARK_CONDEMNED	0x0001
1633 #define	IRB_MARK_FTABLE		0x0002
1634 	uint_t		irb_ire_cnt;	/* Num of active IRE in this bucket */
1635 	uint_t		irb_tmp_ire_cnt; /* Num of temporary IRE */
1636 	struct ire_s	*irb_rr_origin;	/* origin for round-robin */
1637 	int		irb_nire;	/* Num of ftable ire's that ref irb */
1638 	ip_stack_t	*irb_ipst;	/* Does not have a netstack_hold */
1639 } irb_t;
1640 
1641 #define	IRB2RT(irb)	(rt_t *)((caddr_t)(irb) - offsetof(rt_t, rt_irb))
1642 
1643 /* The following are return values of ip_xmit_v4() */
1644 typedef enum {
1645 	SEND_PASSED = 0,	 /* sent packet out on wire */
1646 	SEND_FAILED,	 /* sending of packet failed */
1647 	LOOKUP_IN_PROGRESS, /* ire cache found, ARP resolution in progress */
1648 	LLHDR_RESLV_FAILED  /* macaddr resl of onlink dst or nexthop failed */
1649 } ipxmit_state_t;
1650 
1651 #define	IP_V4_G_HEAD	0
1652 #define	IP_V6_G_HEAD	1
1653 
1654 #define	MAX_G_HEADS	2
1655 
1656 /*
1657  * unpadded ill_if structure
1658  */
1659 struct 	_ill_if_s_ {
1660 	union ill_if_u	*illif_next;
1661 	union ill_if_u	*illif_prev;
1662 	avl_tree_t	illif_avl_by_ppa;	/* AVL tree sorted on ppa */
1663 	vmem_t		*illif_ppa_arena;	/* ppa index space */
1664 	uint16_t	illif_mcast_v1;		/* hints for		  */
1665 	uint16_t	illif_mcast_v2;		/* [igmp|mld]_slowtimo	  */
1666 	int		illif_name_len;		/* name length */
1667 	char		illif_name[LIFNAMSIZ];	/* name of interface type */
1668 };
1669 
1670 /* cache aligned ill_if structure */
1671 typedef union 	ill_if_u {
1672 	struct  _ill_if_s_ ill_if_s;
1673 	char 	illif_filler[CACHE_ALIGN(_ill_if_s_)];
1674 } ill_if_t;
1675 
1676 #define	illif_next		ill_if_s.illif_next
1677 #define	illif_prev		ill_if_s.illif_prev
1678 #define	illif_avl_by_ppa	ill_if_s.illif_avl_by_ppa
1679 #define	illif_ppa_arena		ill_if_s.illif_ppa_arena
1680 #define	illif_mcast_v1		ill_if_s.illif_mcast_v1
1681 #define	illif_mcast_v2		ill_if_s.illif_mcast_v2
1682 #define	illif_name		ill_if_s.illif_name
1683 #define	illif_name_len		ill_if_s.illif_name_len
1684 
1685 typedef struct ill_walk_context_s {
1686 	int	ctx_current_list; /* current list being searched */
1687 	int	ctx_last_list;	 /* last list to search */
1688 } ill_walk_context_t;
1689 
1690 /*
1691  * ill_g_heads structure, one for IPV4 and one for IPV6
1692  */
1693 struct _ill_g_head_s_ {
1694 	ill_if_t	*ill_g_list_head;
1695 	ill_if_t	*ill_g_list_tail;
1696 };
1697 
1698 typedef union ill_g_head_u {
1699 	struct _ill_g_head_s_ ill_g_head_s;
1700 	char	ill_g_head_filler[CACHE_ALIGN(_ill_g_head_s_)];
1701 } ill_g_head_t;
1702 
1703 #define	ill_g_list_head	ill_g_head_s.ill_g_list_head
1704 #define	ill_g_list_tail	ill_g_head_s.ill_g_list_tail
1705 
1706 #define	IP_V4_ILL_G_LIST(ipst)	\
1707 	(ipst)->ips_ill_g_heads[IP_V4_G_HEAD].ill_g_list_head
1708 #define	IP_V6_ILL_G_LIST(ipst)	\
1709 	(ipst)->ips_ill_g_heads[IP_V6_G_HEAD].ill_g_list_head
1710 #define	IP_VX_ILL_G_LIST(i, ipst)	\
1711 	(ipst)->ips_ill_g_heads[i].ill_g_list_head
1712 
1713 #define	ILL_START_WALK_V4(ctx_ptr, ipst)	\
1714 	ill_first(IP_V4_G_HEAD, IP_V4_G_HEAD, ctx_ptr, ipst)
1715 #define	ILL_START_WALK_V6(ctx_ptr, ipst)	\
1716 	ill_first(IP_V6_G_HEAD, IP_V6_G_HEAD, ctx_ptr, ipst)
1717 #define	ILL_START_WALK_ALL(ctx_ptr, ipst)	\
1718 	ill_first(MAX_G_HEADS, MAX_G_HEADS, ctx_ptr, ipst)
1719 
1720 /*
1721  * Capabilities, possible flags for ill_capabilities.
1722  */
1723 
1724 #define	ILL_CAPAB_AH		0x01		/* IPsec AH acceleration */
1725 #define	ILL_CAPAB_ESP		0x02		/* IPsec ESP acceleration */
1726 #define	ILL_CAPAB_MDT		0x04		/* Multidata Transmit */
1727 #define	ILL_CAPAB_HCKSUM	0x08		/* Hardware checksumming */
1728 #define	ILL_CAPAB_ZEROCOPY	0x10		/* Zero-copy */
1729 #define	ILL_CAPAB_DLD		0x20		/* DLD capabilities */
1730 #define	ILL_CAPAB_DLD_POLL	0x40		/* Polling */
1731 #define	ILL_CAPAB_DLD_DIRECT	0x80		/* Direct function call */
1732 #define	ILL_CAPAB_DLD_LSO	0x100		/* Large Segment Offload */
1733 
1734 /*
1735  * Per-ill Multidata Transmit capabilities.
1736  */
1737 typedef struct ill_mdt_capab_s ill_mdt_capab_t;
1738 
1739 /*
1740  * Per-ill IPsec capabilities.
1741  */
1742 typedef struct ill_ipsec_capab_s ill_ipsec_capab_t;
1743 
1744 /*
1745  * Per-ill Hardware Checksumming capbilities.
1746  */
1747 typedef struct ill_hcksum_capab_s ill_hcksum_capab_t;
1748 
1749 /*
1750  * Per-ill Zero-copy capabilities.
1751  */
1752 typedef struct ill_zerocopy_capab_s ill_zerocopy_capab_t;
1753 
1754 /*
1755  * DLD capbilities.
1756  */
1757 typedef struct ill_dld_capab_s ill_dld_capab_t;
1758 
1759 /*
1760  * Per-ill polling resource map.
1761  */
1762 typedef struct ill_rx_ring ill_rx_ring_t;
1763 
1764 /*
1765  * Per-ill Large Segment Offload capabilities.
1766  */
1767 typedef struct ill_lso_capab_s ill_lso_capab_t;
1768 
1769 /* The following are ill_state_flags */
1770 #define	ILL_LL_SUBNET_PENDING	0x01	/* Waiting for DL_INFO_ACK from drv */
1771 #define	ILL_CONDEMNED		0x02	/* No more new ref's to the ILL */
1772 #define	ILL_CHANGING		0x04	/* ILL not globally visible */
1773 #define	ILL_DL_UNBIND_IN_PROGRESS	0x08	/* UNBIND_REQ is sent */
1774 
1775 /* Is this an ILL whose source address is used by other ILL's ? */
1776 #define	IS_USESRC_ILL(ill)			\
1777 	(((ill)->ill_usesrc_ifindex == 0) &&	\
1778 	((ill)->ill_usesrc_grp_next != NULL))
1779 
1780 /* Is this a client/consumer of the usesrc ILL ? */
1781 #define	IS_USESRC_CLI_ILL(ill)			\
1782 	(((ill)->ill_usesrc_ifindex != 0) &&	\
1783 	((ill)->ill_usesrc_grp_next != NULL))
1784 
1785 /* Is this an virtual network interface (vni) ILL ? */
1786 #define	IS_VNI(ill)							     \
1787 	(((ill) != NULL) &&						     \
1788 	(((ill)->ill_phyint->phyint_flags & (PHYI_LOOPBACK|PHYI_VIRTUAL)) == \
1789 	PHYI_VIRTUAL))
1790 
1791 /* Is this a loopback ILL? */
1792 #define	IS_LOOPBACK(ill) \
1793 	((ill)->ill_phyint->phyint_flags & PHYI_LOOPBACK)
1794 
1795 /* Is this an IPMP meta-interface ILL? */
1796 #define	IS_IPMP(ill)							\
1797 	((ill)->ill_phyint->phyint_flags & PHYI_IPMP)
1798 
1799 /* Is this ILL under an IPMP meta-interface? (aka "in a group?") */
1800 #define	IS_UNDER_IPMP(ill)						\
1801 	((ill)->ill_grp != NULL && !IS_IPMP(ill))
1802 
1803 /* Is ill1 in the same illgrp as ill2? */
1804 #define	IS_IN_SAME_ILLGRP(ill1, ill2)					\
1805 	((ill1)->ill_grp != NULL && ((ill1)->ill_grp == (ill2)->ill_grp))
1806 
1807 /* Is ill1 on the same LAN as ill2? */
1808 #define	IS_ON_SAME_LAN(ill1, ill2)					\
1809 	((ill1) == (ill2) || IS_IN_SAME_ILLGRP(ill1, ill2))
1810 
1811 #define	ILL_OTHER(ill)							\
1812 	((ill)->ill_isv6 ? (ill)->ill_phyint->phyint_illv4 :		\
1813 	    (ill)->ill_phyint->phyint_illv6)
1814 
1815 /*
1816  * IPMP group ILL state structure -- up to two per IPMP group (V4 and V6).
1817  * Created when the V4 and/or V6 IPMP meta-interface is I_PLINK'd.  It is
1818  * guaranteed to persist while there are interfaces of that type in the group.
1819  * In general, most fields are accessed outside of the IPSQ (e.g., in the
1820  * datapath), and thus use locks in addition to the IPSQ for protection.
1821  *
1822  * synchronization:		read			write
1823  *
1824  *	ig_if			ipsq or ill_g_lock	ipsq and ill_g_lock
1825  *	ig_actif		ipsq or ipmp_lock	ipsq and ipmp_lock
1826  *	ig_nactif		ipsq or ipmp_lock	ipsq and ipmp_lock
1827  *	ig_next_ill		ipsq or ipmp_lock	ipsq and ipmp_lock
1828  *	ig_ipmp_ill		write once		write once
1829  *	ig_cast_ill		ipsq or ipmp_lock	ipsq and ipmp_lock
1830  *	ig_arpent		ipsq			ipsq
1831  *	ig_mtu			ipsq			ipsq
1832  */
1833 typedef struct ipmp_illgrp_s {
1834 	list_t		ig_if; 		/* list of all interfaces */
1835 	list_t		ig_actif;	/* list of active interfaces */
1836 	uint_t		ig_nactif;	/* number of active interfaces */
1837 	struct ill_s	*ig_next_ill;	/* next active interface to use */
1838 	struct ill_s	*ig_ipmp_ill;	/* backpointer to IPMP meta-interface */
1839 	struct ill_s	*ig_cast_ill;	/* nominated ill for multi/broadcast */
1840 	list_t		ig_arpent;	/* list of ARP entries */
1841 	uint_t		ig_mtu;		/* ig_ipmp_ill->ill_max_mtu */
1842 } ipmp_illgrp_t;
1843 
1844 /*
1845  * IPMP group state structure -- one per IPMP group.  Created when the
1846  * IPMP meta-interface is plumbed; it is guaranteed to persist while there
1847  * are interfaces in it.
1848  *
1849  * ipmp_grp_t synchronization:		read			write
1850  *
1851  *	gr_name				ipmp_lock		ipmp_lock
1852  *	gr_ifname			write once		write once
1853  *	gr_mactype			ipmp_lock		ipmp_lock
1854  *	gr_phyint			write once		write once
1855  *	gr_nif				ipmp_lock		ipmp_lock
1856  *	gr_nactif			ipsq			ipsq
1857  *	gr_v4				ipmp_lock		ipmp_lock
1858  *	gr_v6				ipmp_lock		ipmp_lock
1859  *	gr_nv4				ipmp_lock		ipmp_lock
1860  *	gr_nv6				ipmp_lock		ipmp_lock
1861  *	gr_pendv4			ipmp_lock		ipmp_lock
1862  *	gr_pendv6			ipmp_lock		ipmp_lock
1863  *	gr_linkdownmp			ipsq			ipsq
1864  *	gr_ksp				ipmp_lock		ipmp_lock
1865  *	gr_kstats0			atomic			atomic
1866  */
1867 typedef struct ipmp_grp_s {
1868 	char		gr_name[LIFGRNAMSIZ];	/* group name */
1869 	char		gr_ifname[LIFNAMSIZ];	/* interface name */
1870 	t_uscalar_t	gr_mactype;	/* DLPI mactype of group */
1871 	phyint_t	*gr_phyint;	/* IPMP group phyint */
1872 	uint_t		gr_nif;		/* number of interfaces in group */
1873 	uint_t		gr_nactif; 	/* number of active interfaces */
1874 	ipmp_illgrp_t	*gr_v4;		/* V4 group information */
1875 	ipmp_illgrp_t	*gr_v6;		/* V6 group information */
1876 	uint_t		gr_nv4;		/* number of ills in V4 group */
1877 	uint_t		gr_nv6;		/* number of ills in V6 group */
1878 	uint_t		gr_pendv4; 	/* number of pending ills in V4 group */
1879 	uint_t		gr_pendv6; 	/* number of pending ills in V6 group */
1880 	mblk_t		*gr_linkdownmp;	/* message used to bring link down */
1881 	kstat_t		*gr_ksp;	/* group kstat pointer */
1882 	uint64_t	gr_kstats0[IPMP_KSTAT_MAX]; /* baseline group kstats */
1883 } ipmp_grp_t;
1884 
1885 /*
1886  * IPMP ARP entry -- one per SIOCS*ARP entry tied to the group.  Used to keep
1887  * ARP up-to-date as the active set of interfaces in the group changes.
1888  */
1889 typedef struct ipmp_arpent_s {
1890 	mblk_t		*ia_area_mp;	/* AR_ENTRY_ADD pointer */
1891 	ipaddr_t	ia_ipaddr; 	/* IP address for this entry */
1892 	boolean_t	ia_proxyarp; 	/* proxy ARP entry? */
1893 	boolean_t	ia_notified; 	/* ARP notified about this entry? */
1894 	list_node_t	ia_node; 	/* next ARP entry in list */
1895 } ipmp_arpent_t;
1896 
1897 /*
1898  * IP Lower level Structure.
1899  * Instance data structure in ip_open when there is a device below us.
1900  */
1901 typedef struct ill_s {
1902 	ill_if_t *ill_ifptr;		/* pointer to interface type */
1903 	queue_t	*ill_rq;		/* Read queue. */
1904 	queue_t	*ill_wq;		/* Write queue. */
1905 
1906 	int	ill_error;		/* Error value sent up by device. */
1907 
1908 	ipif_t	*ill_ipif;		/* Interface chain for this ILL. */
1909 
1910 	uint_t	ill_ipif_up_count;	/* Number of IPIFs currently up. */
1911 	uint_t	ill_max_frag;		/* Max IDU from DLPI. */
1912 	char	*ill_name;		/* Our name. */
1913 	uint_t	ill_ipif_dup_count;	/* Number of duplicate addresses. */
1914 	uint_t	ill_name_length;	/* Name length, incl. terminator. */
1915 	char	*ill_ndd_name;		/* Name + ":ip?_forwarding" for NDD. */
1916 	uint_t	ill_net_type;		/* IRE_IF_RESOLVER/IRE_IF_NORESOLVER. */
1917 	/*
1918 	 * Physical Point of Attachment num.  If DLPI style 1 provider
1919 	 * then this is derived from the devname.
1920 	 */
1921 	uint_t	ill_ppa;
1922 	t_uscalar_t	ill_sap;
1923 	t_scalar_t	ill_sap_length;	/* Including sign (for position) */
1924 	uint_t	ill_phys_addr_length;	/* Excluding the sap. */
1925 	uint_t	ill_bcast_addr_length;	/* Only set when the DL provider */
1926 					/* supports broadcast. */
1927 	t_uscalar_t	ill_mactype;
1928 	uint8_t	*ill_frag_ptr;		/* Reassembly state. */
1929 	timeout_id_t ill_frag_timer_id; /* timeout id for the frag timer */
1930 	ipfb_t	*ill_frag_hash_tbl;	/* Fragment hash list head. */
1931 	ipif_t	*ill_pending_ipif;	/* IPIF waiting for DL operation. */
1932 
1933 	ilm_t	*ill_ilm;		/* Multicast membership for ill */
1934 	uint_t	ill_global_timer;	/* for IGMPv3/MLDv2 general queries */
1935 	int	ill_mcast_type;		/* type of router which is querier */
1936 					/* on this interface */
1937 	uint16_t ill_mcast_v1_time;	/* # slow timeouts since last v1 qry */
1938 	uint16_t ill_mcast_v2_time;	/* # slow timeouts since last v2 qry */
1939 	uint8_t	ill_mcast_v1_tset;	/* 1 => timer is set; 0 => not set */
1940 	uint8_t	ill_mcast_v2_tset;	/* 1 => timer is set; 0 => not set */
1941 
1942 	uint8_t	ill_mcast_rv;		/* IGMPv3/MLDv2 robustness variable */
1943 	int	ill_mcast_qi;		/* IGMPv3/MLDv2 query interval var */
1944 
1945 	mblk_t	*ill_pending_mp;	/* IOCTL/DLPI awaiting completion. */
1946 	/*
1947 	 * All non-NULL cells between 'ill_first_mp_to_free' and
1948 	 * 'ill_last_mp_to_free' are freed in ill_delete.
1949 	 */
1950 #define	ill_first_mp_to_free	ill_bcast_mp
1951 	mblk_t	*ill_bcast_mp;		/* DLPI header for broadcasts. */
1952 	mblk_t	*ill_resolver_mp;	/* Resolver template. */
1953 	mblk_t	*ill_unbind_mp;		/* unbind mp from ill_dl_up() */
1954 	mblk_t	*ill_promiscoff_mp;	/* for ill_leave_allmulti() */
1955 	mblk_t	*ill_dlpi_deferred;	/* b_next chain of control messages */
1956 	mblk_t	*ill_ardeact_mp;	/* deact mp from ipmp_ill_activate() */
1957 	mblk_t	*ill_replumb_mp;	/* replumb mp from ill_replumb() */
1958 	mblk_t	*ill_phys_addr_mp;	/* mblk which holds ill_phys_addr */
1959 #define	ill_last_mp_to_free	ill_phys_addr_mp
1960 
1961 	cred_t	*ill_credp;		/* opener's credentials */
1962 	uint8_t	*ill_phys_addr;		/* ill_phys_addr_mp->b_rptr + off */
1963 
1964 	uint_t	ill_state_flags;	/* see ILL_* flags above */
1965 
1966 	/* Following bit fields protected by ipsq_t */
1967 	uint_t
1968 		ill_needs_attach : 1,
1969 		ill_reserved : 1,
1970 		ill_isv6 : 1,
1971 		ill_dlpi_style_set : 1,
1972 
1973 		ill_ifname_pending : 1,
1974 		ill_join_allmulti : 1,
1975 		ill_logical_down : 1,
1976 		ill_is_6to4tun : 1,	/* Interface is a 6to4 tunnel */
1977 
1978 		ill_promisc_on_phys : 1, /* phys interface in promisc mode */
1979 		ill_dl_up : 1,
1980 		ill_up_ipifs : 1,
1981 		ill_note_link : 1,	/* supports link-up notification */
1982 		ill_capab_reneg : 1, /* capability renegotiation to be done */
1983 		ill_dld_capab_inprog : 1, /* direct dld capab call in prog */
1984 		ill_need_recover_multicast : 1,
1985 		ill_pad_to_bit_31 : 17;
1986 
1987 	/* Following bit fields protected by ill_lock */
1988 	uint_t
1989 		ill_fragtimer_executing : 1,
1990 		ill_fragtimer_needrestart : 1,
1991 		ill_ilm_cleanup_reqd : 1,
1992 		ill_arp_closing : 1,
1993 
1994 		ill_arp_bringup_pending : 1,
1995 		ill_arp_extend : 1,	/* ARP has DAD extensions */
1996 		ill_pad_bit_31 : 26;
1997 
1998 	/*
1999 	 * Used in SIOCSIFMUXID and SIOCGIFMUXID for 'ifconfig unplumb'.
2000 	 */
2001 	int	ill_arp_muxid;		/* muxid returned from plink for arp */
2002 	int	ill_ip_muxid;		/* muxid returned from plink for ip */
2003 
2004 	/* Used for IP frag reassembly throttling on a per ILL basis.  */
2005 	uint_t	ill_ipf_gen;		/* Generation of next fragment queue */
2006 	uint_t	ill_frag_count;		/* Count of all reassembly mblk bytes */
2007 	uint_t	ill_frag_free_num_pkts;	 /* num of fragmented packets to free */
2008 	clock_t	ill_last_frag_clean_time; /* time when frag's were pruned */
2009 	int	ill_type;		/* From <net/if_types.h> */
2010 	uint_t	ill_dlpi_multicast_state;	/* See below IDS_* */
2011 	uint_t	ill_dlpi_fastpath_state;	/* See below IDS_* */
2012 
2013 	/*
2014 	 * Capabilities related fields.
2015 	 */
2016 	uint_t  ill_dlpi_capab_state;	/* State of capability query, IDCS_* */
2017 	uint_t	ill_capab_pending_cnt;
2018 	uint64_t ill_capabilities;	/* Enabled capabilities, ILL_CAPAB_* */
2019 	ill_mdt_capab_t	*ill_mdt_capab;	/* Multidata Transmit capabilities */
2020 	ill_ipsec_capab_t *ill_ipsec_capab_ah;	/* IPsec AH capabilities */
2021 	ill_ipsec_capab_t *ill_ipsec_capab_esp;	/* IPsec ESP capabilities */
2022 	ill_hcksum_capab_t *ill_hcksum_capab; /* H/W cksumming capabilities */
2023 	ill_zerocopy_capab_t *ill_zerocopy_capab; /* Zero-copy capabilities */
2024 	ill_dld_capab_t *ill_dld_capab; /* DLD capabilities */
2025 	ill_lso_capab_t	*ill_lso_capab;	/* Large Segment Offload capabilities */
2026 	mblk_t	*ill_capab_reset_mp;	/* Preallocated mblk for capab reset */
2027 
2028 	/*
2029 	 * New fields for IPv6
2030 	 */
2031 	uint8_t	ill_max_hops;	/* Maximum hops for any logical interface */
2032 	uint_t	ill_max_mtu;	/* Maximum MTU for any logical interface */
2033 	uint_t	ill_user_mtu;	/* User-specified MTU via SIOCSLIFLNKINFO */
2034 	uint32_t ill_reachable_time;	/* Value for ND algorithm in msec */
2035 	uint32_t ill_reachable_retrans_time; /* Value for ND algorithm msec */
2036 	uint_t	ill_max_buf;		/* Max # of req to buffer for ND */
2037 	in6_addr_t	ill_token;
2038 	uint_t		ill_token_length;
2039 	uint32_t	ill_xmit_count;		/* ndp max multicast xmits */
2040 	mib2_ipIfStatsEntry_t	*ill_ip_mib;	/* ver indep. interface mib */
2041 	mib2_ipv6IfIcmpEntry_t	*ill_icmp6_mib;	/* Per interface mib */
2042 	/*
2043 	 * Following two mblks are allocated common to all
2044 	 * the ipifs when the first interface is coming up.
2045 	 * It is sent up to arp when the last ipif is coming
2046 	 * down.
2047 	 */
2048 	mblk_t			*ill_arp_down_mp;
2049 	mblk_t			*ill_arp_del_mapping_mp;
2050 	/*
2051 	 * Used for implementing IFF_NOARP. As IFF_NOARP is used
2052 	 * to turn off for all the logicals, it is here instead
2053 	 * of the ipif.
2054 	 */
2055 	mblk_t			*ill_arp_on_mp;
2056 
2057 	phyint_t		*ill_phyint;
2058 	uint64_t		ill_flags;
2059 
2060 	kmutex_t	ill_lock;	/* Please see table below */
2061 	/*
2062 	 * The ill_nd_lla* fields handle the link layer address option
2063 	 * from neighbor discovery. This is used for external IPv6
2064 	 * address resolution.
2065 	 */
2066 	mblk_t		*ill_nd_lla_mp;	/* mblk which holds ill_nd_lla */
2067 	uint8_t		*ill_nd_lla;	/* Link Layer Address */
2068 	uint_t		ill_nd_lla_len;	/* Link Layer Address length */
2069 	/*
2070 	 * We now have 3 phys_addr_req's sent down. This field keeps track
2071 	 * of which one is pending.
2072 	 */
2073 	t_uscalar_t	ill_phys_addr_pend; /* which dl_phys_addr_req pending */
2074 	/*
2075 	 * Used to save errors that occur during plumbing
2076 	 */
2077 	uint_t		ill_ifname_pending_err;
2078 	avl_node_t	ill_avl_byppa; /* avl node based on ppa */
2079 	void		*ill_fastpath_list; /* both ire and nce hang off this */
2080 	uint_t		ill_refcnt;	/* active refcnt by threads */
2081 	uint_t		ill_ire_cnt;	/* ires associated with this ill */
2082 	kcondvar_t	ill_cv;
2083 	uint_t		ill_ilm_walker_cnt;	/* snmp ilm walkers */
2084 	uint_t		ill_nce_cnt;	/* nces associated with this ill */
2085 	uint_t		ill_waiters;	/* threads waiting in ipsq_enter */
2086 	/*
2087 	 * Contains the upper read queue pointer of the module immediately
2088 	 * beneath IP.  This field allows IP to validate sub-capability
2089 	 * acknowledgments coming up from downstream.
2090 	 */
2091 	queue_t		*ill_lmod_rq;	/* read queue pointer of module below */
2092 	uint_t		ill_lmod_cnt;	/* number of modules beneath IP */
2093 	ip_m_t		*ill_media;	/* media specific params/functions */
2094 	t_uscalar_t	ill_dlpi_pending; /* Last DLPI primitive issued */
2095 	uint_t		ill_usesrc_ifindex; /* use src addr from this ILL */
2096 	struct ill_s	*ill_usesrc_grp_next; /* Next ILL in the usesrc group */
2097 	boolean_t	ill_trace_disable;	/* True when alloc fails */
2098 	zoneid_t	ill_zoneid;
2099 	ip_stack_t	*ill_ipst;	/* Corresponds to a netstack_hold */
2100 	uint32_t	ill_dhcpinit;	/* IP_DHCPINIT_IFs for ill */
2101 	void		*ill_flownotify_mh; /* Tx flow ctl, mac cb handle */
2102 	uint_t		ill_ilm_cnt;    /* ilms referencing this ill */
2103 	uint_t		ill_ipallmulti_cnt; /* ip_join_allmulti() calls */
2104 	/*
2105 	 * IPMP fields.
2106 	 */
2107 	ipmp_illgrp_t	*ill_grp;	/* IPMP group information */
2108 	list_node_t	ill_actnode; 	/* next active ill in group */
2109 	list_node_t	ill_grpnode;	/* next ill in group */
2110 	ipif_t		*ill_src_ipif;	/* source address selection rotor */
2111 	ipif_t		*ill_move_ipif;	/* ipif awaiting move to new ill */
2112 	boolean_t	ill_nom_cast;	/* nominated for mcast/bcast */
2113 	uint_t		ill_bound_cnt;	/* # of data addresses bound to ill */
2114 	ipif_t		*ill_bound_ipif; /* ipif chain bound to ill */
2115 	timeout_id_t	ill_refresh_tid; /* ill refresh retry timeout id */
2116 } ill_t;
2117 
2118 /*
2119  * ILL_FREE_OK() means that there are no incoming pointer references
2120  * to the ill.
2121  */
2122 #define	ILL_FREE_OK(ill)					\
2123 	((ill)->ill_ire_cnt == 0 && (ill)->ill_ilm_cnt == 0 &&	\
2124 	(ill)->ill_nce_cnt == 0)
2125 
2126 /*
2127  * An ipif/ill can be marked down only when the ire and nce references
2128  * to that ipif/ill goes to zero. ILL_DOWN_OK() is a necessary condition
2129  * quiescence checks. See comments above IPIF_DOWN_OK for details
2130  * on why ires and nces are selectively considered for this macro.
2131  */
2132 #define	ILL_DOWN_OK(ill)	(ill->ill_ire_cnt == 0 && ill->ill_nce_cnt == 0)
2133 
2134 /*
2135  * The following table lists the protection levels of the various members
2136  * of the ill_t. Same notation as that used for ipif_t above is used.
2137  *
2138  *				Write			Read
2139  *
2140  * ill_ifptr			ill_g_lock + s		Write once
2141  * ill_rq			ipsq			Write once
2142  * ill_wq			ipsq			Write once
2143  *
2144  * ill_error			ipsq			None
2145  * ill_ipif			ill_g_lock + ipsq	ill_g_lock OR ipsq
2146  * ill_ipif_up_count		ill_lock + ipsq		ill_lock OR ipsq
2147  * ill_max_frag			ipsq			Write once
2148  *
2149  * ill_name			ill_g_lock + ipsq	Write once
2150  * ill_name_length		ill_g_lock + ipsq	Write once
2151  * ill_ndd_name			ipsq			Write once
2152  * ill_net_type			ipsq			Write once
2153  * ill_ppa			ill_g_lock + ipsq	Write once
2154  * ill_sap			ipsq + down ill		Write once
2155  * ill_sap_length		ipsq + down ill		Write once
2156  * ill_phys_addr_length		ipsq + down ill		Write once
2157  *
2158  * ill_bcast_addr_length	ipsq			ipsq
2159  * ill_mactype			ipsq			ipsq
2160  * ill_frag_ptr			ipsq			ipsq
2161  *
2162  * ill_frag_timer_id		ill_lock		ill_lock
2163  * ill_frag_hash_tbl		ipsq			up ill
2164  * ill_ilm			ipsq + ill_lock		ill_lock
2165  * ill_mcast_type		ill_lock		ill_lock
2166  * ill_mcast_v1_time		ill_lock		ill_lock
2167  * ill_mcast_v2_time		ill_lock		ill_lock
2168  * ill_mcast_v1_tset		ill_lock		ill_lock
2169  * ill_mcast_v2_tset		ill_lock		ill_lock
2170  * ill_mcast_rv			ill_lock		ill_lock
2171  * ill_mcast_qi			ill_lock		ill_lock
2172  * ill_pending_mp		ill_lock		ill_lock
2173  *
2174  * ill_bcast_mp			ipsq			ipsq
2175  * ill_resolver_mp		ipsq			only when ill is up
2176  * ill_down_mp			ipsq			ipsq
2177  * ill_dlpi_deferred		ill_lock		ill_lock
2178  * ill_dlpi_pending		ill_lock		ill_lock
2179  * ill_phys_addr_mp		ipsq + down ill		only when ill is up
2180  * ill_phys_addr		ipsq + down ill		only when ill is up
2181  *
2182  * ill_state_flags		ill_lock		ill_lock
2183  * exclusive bit flags		ipsq_t			ipsq_t
2184  * shared bit flags		ill_lock		ill_lock
2185  *
2186  * ill_arp_muxid		ipsq			Not atomic
2187  * ill_ip_muxid			ipsq			Not atomic
2188  *
2189  * ill_ipf_gen			Not atomic
2190  * ill_frag_count		atomics			atomics
2191  * ill_type			ipsq + down ill		only when ill is up
2192  * ill_dlpi_multicast_state	ill_lock		ill_lock
2193  * ill_dlpi_fastpath_state	ill_lock		ill_lock
2194  * ill_dlpi_capab_state		ipsq			ipsq
2195  * ill_max_hops			ipsq			Not atomic
2196  *
2197  * ill_max_mtu
2198  *
2199  * ill_user_mtu			ipsq + ill_lock		ill_lock
2200  * ill_reachable_time		ipsq + ill_lock		ill_lock
2201  * ill_reachable_retrans_time	ipsq + ill_lock		ill_lock
2202  * ill_max_buf			ipsq + ill_lock		ill_lock
2203  *
2204  * Next 2 fields need ill_lock because of the get ioctls. They should not
2205  * report partially updated results without executing in the ipsq.
2206  * ill_token			ipsq + ill_lock		ill_lock
2207  * ill_token_length		ipsq + ill_lock		ill_lock
2208  * ill_xmit_count		ipsq + down ill		write once
2209  * ill_ip6_mib			ipsq + down ill		only when ill is up
2210  * ill_icmp6_mib		ipsq + down ill		only when ill is up
2211  * ill_arp_down_mp		ipsq			ipsq
2212  * ill_arp_del_mapping_mp	ipsq			ipsq
2213  * ill_arp_on_mp		ipsq			ipsq
2214  *
2215  * ill_phyint			ipsq, ill_g_lock, ill_lock	Any of them
2216  * ill_flags			ill_lock		ill_lock
2217  * ill_nd_lla_mp		ipsq + down ill		only when ill is up
2218  * ill_nd_lla			ipsq + down ill		only when ill is up
2219  * ill_nd_lla_len		ipsq + down ill		only when ill is up
2220  * ill_phys_addr_pend		ipsq + down ill		only when ill is up
2221  * ill_ifname_pending_err	ipsq			ipsq
2222  * ill_avl_byppa		ipsq, ill_g_lock	write once
2223  *
2224  * ill_fastpath_list		ill_lock		ill_lock
2225  * ill_refcnt			ill_lock		ill_lock
2226  * ill_ire_cnt			ill_lock		ill_lock
2227  * ill_cv			ill_lock		ill_lock
2228  * ill_ilm_walker_cnt		ill_lock		ill_lock
2229  * ill_nce_cnt			ill_lock		ill_lock
2230  * ill_ilm_cnt			ill_lock		ill_lock
2231  * ill_src_ipif			ill_g_lock		ill_g_lock
2232  * ill_trace			ill_lock		ill_lock
2233  * ill_usesrc_grp_next		ill_g_usesrc_lock	ill_g_usesrc_lock
2234  * ill_dhcpinit			atomics			atomics
2235  * ill_flownotify_mh		write once		write once
2236  * ill_capab_pending_cnt	ipsq			ipsq
2237  *
2238  * ill_bound_cnt		ipsq			ipsq
2239  * ill_bound_ipif		ipsq			ipsq
2240  * ill_actnode			ipsq + ipmp_lock	ipsq OR ipmp_lock
2241  * ill_grpnode			ipsq + ill_g_lock	ipsq OR ill_g_lock
2242  * ill_src_ipif			ill_g_lock		ill_g_lock
2243  * ill_move_ipif		ipsq			ipsq
2244  * ill_nom_cast			ipsq			ipsq OR advisory
2245  * ill_refresh_tid		ill_lock		ill_lock
2246  * ill_grp (for IPMP ill)	write once		write once
2247  * ill_grp (for underlying ill)	ipsq + ill_g_lock	ipsq OR ill_g_lock
2248  *
2249  * NOTE: It's OK to make heuristic decisions on an underlying interface
2250  *	 by using IS_UNDER_IPMP() or comparing ill_grp's raw pointer value.
2251  */
2252 
2253 /*
2254  * For ioctl restart mechanism see ip_reprocess_ioctl()
2255  */
2256 struct ip_ioctl_cmd_s;
2257 
2258 typedef	int (*ifunc_t)(ipif_t *, struct sockaddr_in *, queue_t *, mblk_t *,
2259     struct ip_ioctl_cmd_s *, void *);
2260 
2261 typedef struct ip_ioctl_cmd_s {
2262 	int	ipi_cmd;
2263 	size_t	ipi_copyin_size;
2264 	uint_t	ipi_flags;
2265 	uint_t	ipi_cmd_type;
2266 	ifunc_t	ipi_func;
2267 	ifunc_t	ipi_func_restart;
2268 } ip_ioctl_cmd_t;
2269 
2270 /*
2271  * ipi_cmd_type:
2272  *
2273  * IF_CMD		1	old style ifreq cmd
2274  * LIF_CMD		2	new style lifreq cmd
2275  * TUN_CMD		3	tunnel related
2276  * ARP_CMD		4	arpreq cmd
2277  * XARP_CMD		5	xarpreq cmd
2278  * MSFILT_CMD		6	multicast source filter cmd
2279  * MISC_CMD		7	misc cmd (not a more specific one above)
2280  */
2281 
2282 enum { IF_CMD = 1, LIF_CMD, TUN_CMD, ARP_CMD, XARP_CMD, MSFILT_CMD, MISC_CMD };
2283 
2284 #define	IPI_DONTCARE	0	/* For ioctl encoded values that don't matter */
2285 
2286 /* Flag values in ipi_flags */
2287 #define	IPI_PRIV	0x1	/* Root only command */
2288 #define	IPI_MODOK	0x2	/* Permitted on mod instance of IP */
2289 #define	IPI_WR		0x4	/* Need to grab writer access */
2290 #define	IPI_GET_CMD	0x8	/* branch to mi_copyout on success */
2291 /*	unused		0x10	*/
2292 #define	IPI_NULL_BCONT	0x20	/* ioctl has not data and hence no b_cont */
2293 #define	IPI_PASS_DOWN	0x40	/* pass this ioctl down when a module only */
2294 
2295 extern ip_ioctl_cmd_t	ip_ndx_ioctl_table[];
2296 extern ip_ioctl_cmd_t	ip_misc_ioctl_table[];
2297 extern int ip_ndx_ioctl_count;
2298 extern int ip_misc_ioctl_count;
2299 
2300 /* Passed down by ARP to IP during I_PLINK/I_PUNLINK */
2301 typedef struct ipmx_s {
2302 	char	ipmx_name[LIFNAMSIZ];		/* if name */
2303 	uint_t
2304 		ipmx_arpdev_stream : 1,		/* This is the arp stream */
2305 		ipmx_notused : 31;
2306 } ipmx_t;
2307 
2308 /*
2309  * State for detecting if a driver supports certain features.
2310  * Support for DL_ENABMULTI_REQ uses ill_dlpi_multicast_state.
2311  * Support for DLPI M_DATA fastpath uses ill_dlpi_fastpath_state.
2312  */
2313 #define	IDS_UNKNOWN	0	/* No DLPI request sent */
2314 #define	IDS_INPROGRESS	1	/* DLPI request sent */
2315 #define	IDS_OK		2	/* DLPI request completed successfully */
2316 #define	IDS_FAILED	3	/* DLPI request failed */
2317 
2318 /* Support for DL_CAPABILITY_REQ uses ill_dlpi_capab_state. */
2319 enum {
2320 	IDCS_UNKNOWN,
2321 	IDCS_PROBE_SENT,
2322 	IDCS_OK,
2323 	IDCS_RESET_SENT,
2324 	IDCS_RENEG,
2325 	IDCS_FAILED
2326 };
2327 
2328 /* Named Dispatch Parameter Management Structure */
2329 typedef struct ipparam_s {
2330 	uint_t	ip_param_min;
2331 	uint_t	ip_param_max;
2332 	uint_t	ip_param_value;
2333 	char	*ip_param_name;
2334 } ipparam_t;
2335 
2336 /* Extended NDP Management Structure */
2337 typedef struct ipndp_s {
2338 	ndgetf_t	ip_ndp_getf;
2339 	ndsetf_t	ip_ndp_setf;
2340 	caddr_t		ip_ndp_data;
2341 	char		*ip_ndp_name;
2342 } ipndp_t;
2343 
2344 /*
2345  * The kernel stores security attributes of all gateways in a database made
2346  * up of one or more tsol_gcdb_t elements.  Each tsol_gcdb_t contains the
2347  * security-related credentials of the gateway.  More than one gateways may
2348  * share entries in the database.
2349  *
2350  * The tsol_gc_t structure represents the gateway to credential association,
2351  * and refers to an entry in the database.  One or more tsol_gc_t entities are
2352  * grouped together to form one or more tsol_gcgrp_t, each representing the
2353  * list of security attributes specific to the gateway.  A gateway may be
2354  * associated with at most one credentials group.
2355  */
2356 struct tsol_gcgrp_s;
2357 
2358 extern uchar_t	ip6opt_ls;	/* TX IPv6 enabler */
2359 
2360 /*
2361  * Gateway security credential record.
2362  */
2363 typedef struct tsol_gcdb_s {
2364 	uint_t		gcdb_refcnt;	/* reference count */
2365 	struct rtsa_s	gcdb_attr;	/* security attributes */
2366 #define	gcdb_mask	gcdb_attr.rtsa_mask
2367 #define	gcdb_doi	gcdb_attr.rtsa_doi
2368 #define	gcdb_slrange	gcdb_attr.rtsa_slrange
2369 } tsol_gcdb_t;
2370 
2371 /*
2372  * Gateway to credential association.
2373  */
2374 typedef struct tsol_gc_s {
2375 	uint_t		gc_refcnt;	/* reference count */
2376 	struct tsol_gcgrp_s *gc_grp;	/* pointer to group */
2377 	struct tsol_gc_s *gc_prev;	/* previous in list */
2378 	struct tsol_gc_s *gc_next;	/* next in list */
2379 	tsol_gcdb_t	*gc_db;		/* pointer to actual credentials */
2380 } tsol_gc_t;
2381 
2382 /*
2383  * Gateway credentials group address.
2384  */
2385 typedef struct tsol_gcgrp_addr_s {
2386 	int		ga_af;		/* address family */
2387 	in6_addr_t	ga_addr;	/* IPv4 mapped or IPv6 address */
2388 } tsol_gcgrp_addr_t;
2389 
2390 /*
2391  * Gateway credentials group.
2392  */
2393 typedef struct tsol_gcgrp_s {
2394 	uint_t		gcgrp_refcnt;	/* reference count */
2395 	krwlock_t	gcgrp_rwlock;	/* lock to protect following */
2396 	uint_t		gcgrp_count;	/* number of credentials */
2397 	tsol_gc_t	*gcgrp_head;	/* first credential in list */
2398 	tsol_gc_t	*gcgrp_tail;	/* last credential in list */
2399 	tsol_gcgrp_addr_t gcgrp_addr;	/* next-hop gateway address */
2400 } tsol_gcgrp_t;
2401 
2402 extern kmutex_t gcgrp_lock;
2403 
2404 #define	GC_REFRELE(p) {				\
2405 	ASSERT((p)->gc_grp != NULL);		\
2406 	rw_enter(&(p)->gc_grp->gcgrp_rwlock, RW_WRITER); \
2407 	ASSERT((p)->gc_refcnt > 0);		\
2408 	if (--((p)->gc_refcnt) == 0)		\
2409 		gc_inactive(p);			\
2410 	else					\
2411 		rw_exit(&(p)->gc_grp->gcgrp_rwlock); \
2412 }
2413 
2414 #define	GCGRP_REFHOLD(p) {			\
2415 	mutex_enter(&gcgrp_lock);		\
2416 	++((p)->gcgrp_refcnt);			\
2417 	ASSERT((p)->gcgrp_refcnt != 0);		\
2418 	mutex_exit(&gcgrp_lock);		\
2419 }
2420 
2421 #define	GCGRP_REFRELE(p) {			\
2422 	mutex_enter(&gcgrp_lock);		\
2423 	ASSERT((p)->gcgrp_refcnt > 0);		\
2424 	if (--((p)->gcgrp_refcnt) == 0)		\
2425 		gcgrp_inactive(p);		\
2426 	ASSERT(MUTEX_HELD(&gcgrp_lock));	\
2427 	mutex_exit(&gcgrp_lock);		\
2428 }
2429 
2430 /*
2431  * IRE gateway security attributes structure, pointed to by tsol_ire_gw_secattr
2432  */
2433 struct tsol_tnrhc;
2434 
2435 typedef struct tsol_ire_gw_secattr_s {
2436 	kmutex_t	igsa_lock;	/* lock to protect following */
2437 	struct tsol_tnrhc *igsa_rhc;	/* host entry for gateway */
2438 	tsol_gc_t	*igsa_gc;	/* for prefix IREs */
2439 	tsol_gcgrp_t	*igsa_gcgrp;	/* for cache IREs */
2440 } tsol_ire_gw_secattr_t;
2441 
2442 /*
2443  * Following are the macros to increment/decrement the reference
2444  * count of the IREs and IRBs (ire bucket).
2445  *
2446  * 1) We bump up the reference count of an IRE to make sure that
2447  *    it does not get deleted and freed while we are using it.
2448  *    Typically all the lookup functions hold the bucket lock,
2449  *    and look for the IRE. If it finds an IRE, it bumps up the
2450  *    reference count before dropping the lock. Sometimes we *may* want
2451  *    to bump up the reference count after we *looked* up i.e without
2452  *    holding the bucket lock. So, the IRE_REFHOLD macro does not assert
2453  *    on the bucket lock being held. Any thread trying to delete from
2454  *    the hash bucket can still do so but cannot free the IRE if
2455  *    ire_refcnt is not 0.
2456  *
2457  * 2) We bump up the reference count on the bucket where the IRE resides
2458  *    (IRB), when we want to prevent the IREs getting deleted from a given
2459  *    hash bucket. This makes life easier for ire_walk type functions which
2460  *    wants to walk the IRE list, call a function, but needs to drop
2461  *    the bucket lock to prevent recursive rw_enters. While the
2462  *    lock is dropped, the list could be changed by other threads or
2463  *    the same thread could end up deleting the ire or the ire pointed by
2464  *    ire_next. IRE_REFHOLDing the ire or ire_next is not sufficient as
2465  *    a delete will still remove the ire from the bucket while we have
2466  *    dropped the lock and hence the ire_next would be NULL. Thus, we
2467  *    need a mechanism to prevent deletions from a given bucket.
2468  *
2469  *    To prevent deletions, we bump up the reference count on the
2470  *    bucket. If the bucket is held, ire_delete just marks IRE_MARK_CONDEMNED
2471  *    both on the ire's ire_marks and the bucket's irb_marks. When the
2472  *    reference count on the bucket drops to zero, all the CONDEMNED ires
2473  *    are deleted. We don't have to bump up the reference count on the
2474  *    bucket if we are walking the bucket and never have to drop the bucket
2475  *    lock. Note that IRB_REFHOLD does not prevent addition of new ires
2476  *    in the list. It is okay because addition of new ires will not cause
2477  *    ire_next to point to freed memory. We do IRB_REFHOLD only when
2478  *    all of the 3 conditions are true :
2479  *
2480  *    1) The code needs to walk the IRE bucket from start to end.
2481  *    2) It may have to drop the bucket lock sometimes while doing (1)
2482  *    3) It does not want any ires to be deleted meanwhile.
2483  */
2484 
2485 /*
2486  * Bump up the reference count on the IRE. We cannot assert that the
2487  * bucket lock is being held as it is legal to bump up the reference
2488  * count after the first lookup has returned the IRE without
2489  * holding the lock. Currently ip_wput does this for caching IRE_CACHEs.
2490  */
2491 
2492 #ifdef DEBUG
2493 #define	IRE_UNTRACE_REF(ire)	ire_untrace_ref(ire);
2494 #define	IRE_TRACE_REF(ire)	ire_trace_ref(ire);
2495 #else
2496 #define	IRE_UNTRACE_REF(ire)
2497 #define	IRE_TRACE_REF(ire)
2498 #endif
2499 
2500 #define	IRE_REFHOLD_NOTR(ire) {				\
2501 	atomic_add_32(&(ire)->ire_refcnt, 1);		\
2502 	ASSERT((ire)->ire_refcnt != 0);			\
2503 }
2504 
2505 #define	IRE_REFHOLD(ire) {				\
2506 	IRE_REFHOLD_NOTR(ire);				\
2507 	IRE_TRACE_REF(ire);				\
2508 }
2509 
2510 #define	IRE_REFHOLD_LOCKED(ire)	{			\
2511 	IRE_TRACE_REF(ire);				\
2512 	(ire)->ire_refcnt++;				\
2513 }
2514 
2515 /*
2516  * Decrement the reference count on the IRE.
2517  * In architectures e.g sun4u, where atomic_add_32_nv is just
2518  * a cas, we need to maintain the right memory barrier semantics
2519  * as that of mutex_exit i.e all the loads and stores should complete
2520  * before the cas is executed. membar_exit() does that here.
2521  *
2522  * NOTE : This macro is used only in places where we want performance.
2523  *	  To avoid bloating the code, we use the function "ire_refrele"
2524  *	  which essentially calls the macro.
2525  */
2526 #define	IRE_REFRELE_NOTR(ire) {					\
2527 	ASSERT((ire)->ire_refcnt != 0);				\
2528 	membar_exit();						\
2529 	if (atomic_add_32_nv(&(ire)->ire_refcnt, -1) == 0)	\
2530 		ire_inactive(ire);				\
2531 }
2532 
2533 #define	IRE_REFRELE(ire) {					\
2534 	if (ire->ire_bucket != NULL) {				\
2535 		IRE_UNTRACE_REF(ire);				\
2536 	}							\
2537 	IRE_REFRELE_NOTR(ire);					\
2538 }
2539 
2540 /*
2541  * Bump up the reference count on the hash bucket - IRB to
2542  * prevent ires from being deleted in this bucket.
2543  */
2544 #define	IRB_REFHOLD(irb) {				\
2545 	rw_enter(&(irb)->irb_lock, RW_WRITER);		\
2546 	(irb)->irb_refcnt++;				\
2547 	ASSERT((irb)->irb_refcnt != 0);			\
2548 	rw_exit(&(irb)->irb_lock);			\
2549 }
2550 #define	IRB_REFHOLD_LOCKED(irb) {			\
2551 	ASSERT(RW_WRITE_HELD(&(irb)->irb_lock));	\
2552 	(irb)->irb_refcnt++;				\
2553 	ASSERT((irb)->irb_refcnt != 0);			\
2554 }
2555 
2556 void irb_refrele_ftable(irb_t *);
2557 /*
2558  * Note: when IRB_MARK_FTABLE (i.e., IRE_CACHETABLE entry), the irb_t
2559  * is statically allocated, so that when the irb_refcnt goes to 0,
2560  * we simply clean up the ire list and continue.
2561  */
2562 #define	IRB_REFRELE(irb) {				\
2563 	if ((irb)->irb_marks & IRB_MARK_FTABLE) {	\
2564 		irb_refrele_ftable((irb));		\
2565 	} else {					\
2566 		rw_enter(&(irb)->irb_lock, RW_WRITER);		\
2567 		ASSERT((irb)->irb_refcnt != 0);			\
2568 		if (--(irb)->irb_refcnt	== 0 &&			\
2569 		    ((irb)->irb_marks & IRE_MARK_CONDEMNED)) {	\
2570 			ire_t *ire_list;			\
2571 								\
2572 			ire_list = ire_unlink(irb);		\
2573 			rw_exit(&(irb)->irb_lock);		\
2574 			ASSERT(ire_list != NULL);		\
2575 			ire_cleanup(ire_list);			\
2576 		} else {					\
2577 			rw_exit(&(irb)->irb_lock);		\
2578 		}						\
2579 	}							\
2580 }
2581 
2582 extern struct kmem_cache *rt_entry_cache;
2583 
2584 /*
2585  * Lock the fast path mp for access, since the fp_mp can be deleted
2586  * due a DL_NOTE_FASTPATH_FLUSH in the case of IRE_BROADCAST
2587  */
2588 
2589 #define	LOCK_IRE_FP_MP(ire) {				\
2590 		if ((ire)->ire_type == IRE_BROADCAST)	\
2591 			mutex_enter(&ire->ire_nce->nce_lock);	\
2592 	}
2593 #define	UNLOCK_IRE_FP_MP(ire) {				\
2594 		if ((ire)->ire_type == IRE_BROADCAST)	\
2595 			mutex_exit(&ire->ire_nce->nce_lock);	\
2596 	}
2597 
2598 typedef struct ire4 {
2599 	ipaddr_t ire4_src_addr;		/* Source address to use. */
2600 	ipaddr_t ire4_mask;		/* Mask for matching this IRE. */
2601 	ipaddr_t ire4_addr;		/* Address this IRE represents. */
2602 	ipaddr_t ire4_gateway_addr;	/* Gateway if IRE_CACHE/IRE_OFFSUBNET */
2603 	ipaddr_t ire4_cmask;		/* Mask from parent prefix route */
2604 } ire4_t;
2605 
2606 typedef struct ire6 {
2607 	in6_addr_t ire6_src_addr;	/* Source address to use. */
2608 	in6_addr_t ire6_mask;		/* Mask for matching this IRE. */
2609 	in6_addr_t ire6_addr;		/* Address this IRE represents. */
2610 	in6_addr_t ire6_gateway_addr;	/* Gateway if IRE_CACHE/IRE_OFFSUBNET */
2611 	in6_addr_t ire6_cmask;		/* Mask from parent prefix route */
2612 } ire6_t;
2613 
2614 typedef union ire_addr {
2615 	ire6_t	ire6_u;
2616 	ire4_t	ire4_u;
2617 } ire_addr_u_t;
2618 
2619 /* Internet Routing Entry */
2620 typedef struct ire_s {
2621 	struct	ire_s	*ire_next;	/* The hash chain must be first. */
2622 	struct	ire_s	**ire_ptpn;	/* Pointer to previous next. */
2623 	uint32_t	ire_refcnt;	/* Number of references */
2624 	mblk_t		*ire_mp;	/* Non-null if allocated as mblk */
2625 	queue_t		*ire_rfq;	/* recv from this queue */
2626 	queue_t		*ire_stq;	/* send to this queue */
2627 	union {
2628 		uint_t	*max_fragp;	/* Used only during ire creation */
2629 		uint_t	max_frag;	/* MTU (next hop or path). */
2630 	} imf_u;
2631 #define	ire_max_frag	imf_u.max_frag
2632 #define	ire_max_fragp	imf_u.max_fragp
2633 	uint32_t	ire_frag_flag;	/* IPH_DF or zero. */
2634 	uint32_t	ire_ident;	/* Per IRE IP ident. */
2635 	uint32_t	ire_tire_mark;	/* Used for reclaim of unused. */
2636 	uchar_t		ire_ipversion;	/* IPv4/IPv6 version */
2637 	uchar_t		ire_marks;	/* IRE_MARK_CONDEMNED etc. */
2638 	ushort_t	ire_type;	/* Type of IRE */
2639 	uint_t	ire_ib_pkt_count;	/* Inbound packets for ire_addr */
2640 	uint_t	ire_ob_pkt_count;	/* Outbound packets to ire_addr */
2641 	uint_t	ire_ll_hdr_length;	/* Non-zero if we do M_DATA prepends */
2642 	time_t	ire_create_time;	/* Time (in secs) IRE was created. */
2643 	uint32_t	ire_phandle;	/* Associate prefix IREs to cache */
2644 	uint32_t	ire_ihandle;	/* Associate interface IREs to cache */
2645 	ipif_t		*ire_ipif;	/* the interface that this ire uses */
2646 	uint32_t	ire_flags;	/* flags related to route (RTF_*) */
2647 	uint_t ire_ipsec_overhead;	/* IPSEC overhead */
2648 	/*
2649 	 * Neighbor Cache Entry for IPv6; arp info for IPv4
2650 	 */
2651 	struct	nce_s	*ire_nce;
2652 	uint_t		ire_masklen;	/* # bits in ire_mask{,_v6} */
2653 	ire_addr_u_t	ire_u;		/* IPv4/IPv6 address info. */
2654 
2655 	irb_t		*ire_bucket;	/* Hash bucket when ire_ptphn is set */
2656 	iulp_t		ire_uinfo;	/* Upper layer protocol info. */
2657 	/*
2658 	 * Protects ire_uinfo, ire_max_frag, and ire_frag_flag.
2659 	 */
2660 	kmutex_t	ire_lock;
2661 	uint_t		ire_ipif_seqid; /* ipif_seqid of ire_ipif */
2662 	uint_t		ire_ipif_ifindex; /* ifindex associated with ipif */
2663 	clock_t		ire_last_used_time;	/* Last used time */
2664 	tsol_ire_gw_secattr_t *ire_gw_secattr; /* gateway security attributes */
2665 	zoneid_t	ire_zoneid;	/* for local address discrimination */
2666 	/*
2667 	 * ire's that are embedded inside mblk_t and sent to the external
2668 	 * resolver use the ire_stq_ifindex to track the ifindex of the
2669 	 * ire_stq, so that the ill (if it exists) can be correctly recovered
2670 	 * for cleanup in the esbfree routine when arp failure occurs.
2671 	 * Similarly, the ire_stackid is used to recover the ip_stack_t.
2672 	 */
2673 	uint_t		ire_stq_ifindex;
2674 	netstackid_t	ire_stackid;
2675 	uint_t		ire_defense_count;	/* number of ARP conflicts */
2676 	uint_t		ire_defense_time;	/* last time defended (secs) */
2677 	boolean_t	ire_trace_disable;	/* True when alloc fails */
2678 	ip_stack_t	*ire_ipst;	/* Does not have a netstack_hold */
2679 } ire_t;
2680 
2681 /* IPv4 compatibility macros */
2682 #define	ire_src_addr		ire_u.ire4_u.ire4_src_addr
2683 #define	ire_mask		ire_u.ire4_u.ire4_mask
2684 #define	ire_addr		ire_u.ire4_u.ire4_addr
2685 #define	ire_gateway_addr	ire_u.ire4_u.ire4_gateway_addr
2686 #define	ire_cmask		ire_u.ire4_u.ire4_cmask
2687 
2688 #define	ire_src_addr_v6		ire_u.ire6_u.ire6_src_addr
2689 #define	ire_mask_v6		ire_u.ire6_u.ire6_mask
2690 #define	ire_addr_v6		ire_u.ire6_u.ire6_addr
2691 #define	ire_gateway_addr_v6	ire_u.ire6_u.ire6_gateway_addr
2692 #define	ire_cmask_v6		ire_u.ire6_u.ire6_cmask
2693 
2694 /* Convenient typedefs for sockaddrs */
2695 typedef	struct sockaddr_in	sin_t;
2696 typedef	struct sockaddr_in6	sin6_t;
2697 
2698 /* Address structure used for internal bind with IP */
2699 typedef struct ipa_conn_s {
2700 	ipaddr_t	ac_laddr;
2701 	ipaddr_t	ac_faddr;
2702 	uint16_t	ac_fport;
2703 	uint16_t	ac_lport;
2704 } ipa_conn_t;
2705 
2706 typedef struct ipa6_conn_s {
2707 	in6_addr_t	ac6_laddr;
2708 	in6_addr_t	ac6_faddr;
2709 	uint16_t	ac6_fport;
2710 	uint16_t	ac6_lport;
2711 } ipa6_conn_t;
2712 
2713 /*
2714  * Using ipa_conn_x_t or ipa6_conn_x_t allows us to modify the behavior of IP's
2715  * bind handler.
2716  */
2717 typedef struct ipa_conn_extended_s {
2718 	uint64_t	acx_flags;
2719 	ipa_conn_t	acx_conn;
2720 } ipa_conn_x_t;
2721 
2722 typedef struct ipa6_conn_extended_s {
2723 	uint64_t	ac6x_flags;
2724 	ipa6_conn_t	ac6x_conn;
2725 } ipa6_conn_x_t;
2726 
2727 /* flag values for ipa_conn_x_t and ipa6_conn_x_t. */
2728 #define	ACX_VERIFY_DST	0x1ULL	/* verify destination address is reachable */
2729 
2730 /* Name/Value Descriptor. */
2731 typedef struct nv_s {
2732 	uint64_t nv_value;
2733 	char	*nv_name;
2734 } nv_t;
2735 
2736 #define	ILL_FRAG_HASH(s, i) \
2737 	((ntohl(s) ^ ((i) ^ ((i) >> 8))) % ILL_FRAG_HASH_TBL_COUNT)
2738 
2739 /*
2740  * The MAX number of allowed fragmented packets per hash bucket
2741  * calculation is based on the most common mtu size of 1500. This limit
2742  * will work well for other mtu sizes as well.
2743  */
2744 #define	COMMON_IP_MTU 1500
2745 #define	MAX_FRAG_MIN 10
2746 #define	MAX_FRAG_PKTS(ipst)	\
2747 	MAX(MAX_FRAG_MIN, (2 * (ipst->ips_ip_reass_queue_bytes / \
2748 	    (COMMON_IP_MTU * ILL_FRAG_HASH_TBL_COUNT))))
2749 
2750 /*
2751  * Maximum dups allowed per packet.
2752  */
2753 extern uint_t ip_max_frag_dups;
2754 
2755 /*
2756  * Per-packet information for received packets and transmitted.
2757  * Used by the transport protocols when converting between the packet
2758  * and ancillary data and socket options.
2759  *
2760  * Note: This private data structure and related IPPF_* constant
2761  * definitions are exposed to enable compilation of some debugging tools
2762  * like lsof which use struct tcp_t in <inet/tcp.h>. This is intended to be
2763  * a temporary hack and long term alternate interfaces should be defined
2764  * to support the needs of such tools and private definitions moved to
2765  * private headers.
2766  */
2767 struct ip6_pkt_s {
2768 	uint_t		ipp_fields;		/* Which fields are valid */
2769 	uint_t		ipp_sticky_ignored;	/* sticky fields to ignore */
2770 	uint_t		ipp_ifindex;		/* pktinfo ifindex */
2771 	in6_addr_t	ipp_addr;		/* pktinfo src/dst addr */
2772 	uint_t		ipp_unicast_hops;	/* IPV6_UNICAST_HOPS */
2773 	uint_t		ipp_multicast_hops;	/* IPV6_MULTICAST_HOPS */
2774 	uint_t		ipp_hoplimit;		/* IPV6_HOPLIMIT */
2775 	uint_t		ipp_hopoptslen;
2776 	uint_t		ipp_rtdstoptslen;
2777 	uint_t		ipp_rthdrlen;
2778 	uint_t		ipp_dstoptslen;
2779 	uint_t		ipp_pathmtulen;
2780 	uint_t		ipp_fraghdrlen;
2781 	ip6_hbh_t	*ipp_hopopts;
2782 	ip6_dest_t	*ipp_rtdstopts;
2783 	ip6_rthdr_t	*ipp_rthdr;
2784 	ip6_dest_t	*ipp_dstopts;
2785 	ip6_frag_t	*ipp_fraghdr;
2786 	struct ip6_mtuinfo *ipp_pathmtu;
2787 	in6_addr_t	ipp_nexthop;		/* Transmit only */
2788 	uint8_t		ipp_tclass;
2789 	int8_t		ipp_use_min_mtu;
2790 };
2791 typedef struct ip6_pkt_s ip6_pkt_t;
2792 
2793 extern void ip6_pkt_free(ip6_pkt_t *);	/* free storage inside ip6_pkt_t */
2794 
2795 /*
2796  * This struct is used by ULP_opt_set() functions to return value of IPv4
2797  * ancillary options. Currently this is only used by udp and icmp and only
2798  * IP_PKTINFO option is supported.
2799  */
2800 typedef struct ip4_pkt_s {
2801 	uint_t		ip4_ill_index;	/* interface index */
2802 	ipaddr_t	ip4_addr;	/* source address */
2803 } ip4_pkt_t;
2804 
2805 /*
2806  * Used by ULP's to pass options info to ip_output
2807  * currently only IP_PKTINFO is supported.
2808  */
2809 typedef struct ip_opt_info_s {
2810 	uint_t ip_opt_ill_index;
2811 	uint_t ip_opt_flags;
2812 } ip_opt_info_t;
2813 
2814 /*
2815  * value for ip_opt_flags
2816  */
2817 #define	IP_VERIFY_SRC	0x1
2818 
2819 /*
2820  * This structure is used to convey information from IP and the ULP.
2821  * Currently used for the IP_RECVSLLA, IP_RECVIF and IP_RECVPKTINFO options.
2822  * The type of information field is set to IN_PKTINFO (i.e inbound pkt info)
2823  */
2824 typedef struct ip_pktinfo {
2825 	uint32_t		ip_pkt_ulp_type;	/* type of info sent */
2826 	uint32_t		ip_pkt_flags;	/* what is sent up by IP */
2827 	uint32_t		ip_pkt_ifindex;	/* inbound interface index */
2828 	struct sockaddr_dl	ip_pkt_slla;	/* has source link layer addr */
2829 	struct in_addr		ip_pkt_match_addr; /* matched address */
2830 } ip_pktinfo_t;
2831 
2832 /*
2833  * flags to tell UDP what IP is sending; in_pkt_flags
2834  */
2835 #define	IPF_RECVIF	0x01	/* inbound interface index */
2836 #define	IPF_RECVSLLA	0x02	/* source link layer address */
2837 /*
2838  * Inbound interface index + matched address.
2839  * Used only by IPV4.
2840  */
2841 #define	IPF_RECVADDR	0x04
2842 
2843 /* ipp_fields values */
2844 #define	IPPF_IFINDEX	0x0001	/* Part of in6_pktinfo: ifindex */
2845 #define	IPPF_ADDR	0x0002	/* Part of in6_pktinfo: src/dst addr */
2846 #define	IPPF_SCOPE_ID	0x0004	/* Add xmit ip6i_t for sin6_scope_id */
2847 #define	IPPF_NO_CKSUM	0x0008	/* Add xmit ip6i_t for IP6I_NO_*_CKSUM */
2848 
2849 #define	IPPF_RAW_CKSUM	0x0010	/* Add xmit ip6i_t for IP6I_RAW_CHECKSUM */
2850 #define	IPPF_HOPLIMIT	0x0020
2851 #define	IPPF_HOPOPTS	0x0040
2852 #define	IPPF_RTHDR	0x0080
2853 
2854 #define	IPPF_RTDSTOPTS	0x0100
2855 #define	IPPF_DSTOPTS	0x0200
2856 #define	IPPF_NEXTHOP	0x0400
2857 #define	IPPF_PATHMTU	0x0800
2858 
2859 #define	IPPF_TCLASS	0x1000
2860 #define	IPPF_DONTFRAG	0x2000
2861 #define	IPPF_USE_MIN_MTU	0x04000
2862 #define	IPPF_MULTICAST_HOPS	0x08000
2863 
2864 #define	IPPF_UNICAST_HOPS	0x10000
2865 #define	IPPF_FRAGHDR		0x20000
2866 
2867 #define	IPPF_HAS_IP6I \
2868 	(IPPF_IFINDEX|IPPF_ADDR|IPPF_NEXTHOP|IPPF_SCOPE_ID| \
2869 	IPPF_NO_CKSUM|IPPF_RAW_CKSUM|IPPF_HOPLIMIT|IPPF_DONTFRAG| \
2870 	IPPF_USE_MIN_MTU|IPPF_MULTICAST_HOPS|IPPF_UNICAST_HOPS)
2871 
2872 #define	TCP_PORTS_OFFSET	0
2873 #define	UDP_PORTS_OFFSET	0
2874 
2875 /*
2876  * lookups return the ill/ipif only if the flags are clear OR Iam writer.
2877  * ill / ipif lookup functions increment the refcnt on the ill / ipif only
2878  * after calling these macros. This ensures that the refcnt on the ipif or
2879  * ill will eventually drop down to zero.
2880  */
2881 #define	ILL_LOOKUP_FAILED	1	/* Used as error code */
2882 #define	IPIF_LOOKUP_FAILED	2	/* Used as error code */
2883 
2884 #define	ILL_CAN_LOOKUP(ill)						\
2885 	(!((ill)->ill_state_flags & (ILL_CONDEMNED | ILL_CHANGING)) ||	\
2886 	IAM_WRITER_ILL(ill))
2887 
2888 #define	ILL_CAN_WAIT(ill, q)	\
2889 	(((q) != NULL) && !((ill)->ill_state_flags & (ILL_CONDEMNED)))
2890 
2891 #define	ILL_CAN_LOOKUP_WALKER(ill)	\
2892 	(!((ill)->ill_state_flags & ILL_CONDEMNED))
2893 
2894 #define	IPIF_CAN_LOOKUP(ipif)	\
2895 	(!((ipif)->ipif_state_flags & (IPIF_CONDEMNED | IPIF_CHANGING)) || \
2896 	IAM_WRITER_IPIF(ipif))
2897 
2898 /*
2899  * If the parameter 'q' is NULL, the caller is not interested in wait and
2900  * restart of the operation if the ILL or IPIF cannot be looked up when it is
2901  * marked as 'CHANGING'. Typically a thread that tries to send out data  will
2902  * end up passing NULLs as the last 4 parameters to ill_lookup_on_ifindex and
2903  * in this case 'q' is NULL
2904  */
2905 #define	IPIF_CAN_WAIT(ipif, q)	\
2906 	(((q) != NULL) && !((ipif)->ipif_state_flags & (IPIF_CONDEMNED)))
2907 
2908 #define	IPIF_CAN_LOOKUP_WALKER(ipif)					\
2909 	(!((ipif)->ipif_state_flags & (IPIF_CONDEMNED)) ||		\
2910 	IAM_WRITER_IPIF(ipif))
2911 
2912 #define	ILL_UNMARK_CHANGING(ill)                                \
2913 	(ill)->ill_state_flags &= ~ILL_CHANGING;
2914 
2915 /* Macros used to assert that this thread is a writer */
2916 #define	IAM_WRITER_IPSQ(ipsq)	((ipsq)->ipsq_xop->ipx_writer == curthread)
2917 #define	IAM_WRITER_ILL(ill)	IAM_WRITER_IPSQ((ill)->ill_phyint->phyint_ipsq)
2918 #define	IAM_WRITER_IPIF(ipif)	IAM_WRITER_ILL((ipif)->ipif_ill)
2919 
2920 /*
2921  * Grab ill locks in the proper order. The order is highest addressed
2922  * ill is locked first.
2923  */
2924 #define	GRAB_ILL_LOCKS(ill_1, ill_2)				\
2925 {								\
2926 	if ((ill_1) > (ill_2)) {				\
2927 		if (ill_1 != NULL)				\
2928 			mutex_enter(&(ill_1)->ill_lock);	\
2929 		if (ill_2 != NULL)				\
2930 			mutex_enter(&(ill_2)->ill_lock);	\
2931 	} else {						\
2932 		if (ill_2 != NULL)				\
2933 			mutex_enter(&(ill_2)->ill_lock);	\
2934 		if (ill_1 != NULL && ill_1 != ill_2)		\
2935 			mutex_enter(&(ill_1)->ill_lock);	\
2936 	}							\
2937 }
2938 
2939 #define	RELEASE_ILL_LOCKS(ill_1, ill_2)		\
2940 {						\
2941 	if (ill_1 != NULL)			\
2942 		mutex_exit(&(ill_1)->ill_lock); \
2943 	if (ill_2 != NULL && ill_2 != ill_1)	\
2944 		mutex_exit(&(ill_2)->ill_lock); \
2945 }
2946 
2947 /* Get the other protocol instance ill */
2948 #define	ILL_OTHER(ill)						\
2949 	((ill)->ill_isv6 ? (ill)->ill_phyint->phyint_illv4 :	\
2950 	    (ill)->ill_phyint->phyint_illv6)
2951 
2952 /* ioctl command info: Ioctl properties extracted and stored in here */
2953 typedef struct cmd_info_s
2954 {
2955 	ipif_t  *ci_ipif;	/* ipif associated with [l]ifreq ioctl's */
2956 	sin_t	*ci_sin;	/* the sin struct passed down */
2957 	sin6_t	*ci_sin6;	/* the sin6_t struct passed down */
2958 	struct lifreq *ci_lifr;	/* the lifreq struct passed down */
2959 } cmd_info_t;
2960 
2961 /*
2962  * List of AH and ESP IPsec acceleration capable ills
2963  */
2964 typedef struct ipsec_capab_ill_s {
2965 	uint_t ill_index;
2966 	boolean_t ill_isv6;
2967 	struct ipsec_capab_ill_s *next;
2968 } ipsec_capab_ill_t;
2969 
2970 extern struct kmem_cache *ire_cache;
2971 
2972 extern ipaddr_t	ip_g_all_ones;
2973 
2974 extern	uint_t	ip_loopback_mtu;	/* /etc/system */
2975 
2976 extern vmem_t *ip_minor_arena_sa;
2977 extern vmem_t *ip_minor_arena_la;
2978 
2979 /*
2980  * ip_g_forward controls IP forwarding.  It takes two values:
2981  *	0: IP_FORWARD_NEVER	Don't forward packets ever.
2982  *	1: IP_FORWARD_ALWAYS	Forward packets for elsewhere.
2983  *
2984  * RFC1122 says there must be a configuration switch to control forwarding,
2985  * but that the default MUST be to not forward packets ever.  Implicit
2986  * control based on configuration of multiple interfaces MUST NOT be
2987  * implemented (Section 3.1).  SunOS 4.1 did provide the "automatic" capability
2988  * and, in fact, it was the default.  That capability is now provided in the
2989  * /etc/rc2.d/S69inet script.
2990  */
2991 
2992 #define	ips_ip_respond_to_address_mask_broadcast ips_param_arr[0].ip_param_value
2993 #define	ips_ip_g_resp_to_echo_bcast	ips_param_arr[1].ip_param_value
2994 #define	ips_ip_g_resp_to_echo_mcast	ips_param_arr[2].ip_param_value
2995 #define	ips_ip_g_resp_to_timestamp	ips_param_arr[3].ip_param_value
2996 #define	ips_ip_g_resp_to_timestamp_bcast ips_param_arr[4].ip_param_value
2997 #define	ips_ip_g_send_redirects		ips_param_arr[5].ip_param_value
2998 #define	ips_ip_g_forward_directed_bcast	ips_param_arr[6].ip_param_value
2999 #define	ips_ip_mrtdebug			ips_param_arr[7].ip_param_value
3000 #define	ips_ip_timer_interval		ips_param_arr[8].ip_param_value
3001 #define	ips_ip_ire_arp_interval		ips_param_arr[9].ip_param_value
3002 #define	ips_ip_ire_redir_interval	ips_param_arr[10].ip_param_value
3003 #define	ips_ip_def_ttl			ips_param_arr[11].ip_param_value
3004 #define	ips_ip_forward_src_routed	ips_param_arr[12].ip_param_value
3005 #define	ips_ip_wroff_extra		ips_param_arr[13].ip_param_value
3006 #define	ips_ip_ire_pathmtu_interval	ips_param_arr[14].ip_param_value
3007 #define	ips_ip_icmp_return		ips_param_arr[15].ip_param_value
3008 #define	ips_ip_path_mtu_discovery	ips_param_arr[16].ip_param_value
3009 #define	ips_ip_ignore_delete_time	ips_param_arr[17].ip_param_value
3010 #define	ips_ip_ignore_redirect		ips_param_arr[18].ip_param_value
3011 #define	ips_ip_output_queue		ips_param_arr[19].ip_param_value
3012 #define	ips_ip_broadcast_ttl		ips_param_arr[20].ip_param_value
3013 #define	ips_ip_icmp_err_interval	ips_param_arr[21].ip_param_value
3014 #define	ips_ip_icmp_err_burst		ips_param_arr[22].ip_param_value
3015 #define	ips_ip_reass_queue_bytes	ips_param_arr[23].ip_param_value
3016 #define	ips_ip_strict_dst_multihoming	ips_param_arr[24].ip_param_value
3017 #define	ips_ip_addrs_per_if		ips_param_arr[25].ip_param_value
3018 #define	ips_ipsec_override_persocket_policy ips_param_arr[26].ip_param_value
3019 #define	ips_icmp_accept_clear_messages	ips_param_arr[27].ip_param_value
3020 #define	ips_igmp_accept_clear_messages	ips_param_arr[28].ip_param_value
3021 
3022 /* IPv6 configuration knobs */
3023 #define	ips_delay_first_probe_time	ips_param_arr[29].ip_param_value
3024 #define	ips_max_unicast_solicit		ips_param_arr[30].ip_param_value
3025 #define	ips_ipv6_def_hops		ips_param_arr[31].ip_param_value
3026 #define	ips_ipv6_icmp_return		ips_param_arr[32].ip_param_value
3027 #define	ips_ipv6_forward_src_routed	ips_param_arr[33].ip_param_value
3028 #define	ips_ipv6_resp_echo_mcast	ips_param_arr[34].ip_param_value
3029 #define	ips_ipv6_send_redirects		ips_param_arr[35].ip_param_value
3030 #define	ips_ipv6_ignore_redirect	ips_param_arr[36].ip_param_value
3031 #define	ips_ipv6_strict_dst_multihoming	ips_param_arr[37].ip_param_value
3032 #define	ips_ip_ire_reclaim_fraction	ips_param_arr[38].ip_param_value
3033 #define	ips_ipsec_policy_log_interval	ips_param_arr[39].ip_param_value
3034 #define	ips_pim_accept_clear_messages	ips_param_arr[40].ip_param_value
3035 #define	ips_ip_ndp_unsolicit_interval	ips_param_arr[41].ip_param_value
3036 #define	ips_ip_ndp_unsolicit_count	ips_param_arr[42].ip_param_value
3037 #define	ips_ipv6_ignore_home_address_opt ips_param_arr[43].ip_param_value
3038 
3039 /* Misc IP configuration knobs */
3040 #define	ips_ip_policy_mask		ips_param_arr[44].ip_param_value
3041 #define	ips_ip_multirt_resolution_interval ips_param_arr[45].ip_param_value
3042 #define	ips_ip_multirt_ttl  		ips_param_arr[46].ip_param_value
3043 #define	ips_ip_multidata_outbound	ips_param_arr[47].ip_param_value
3044 #define	ips_ip_ndp_defense_interval	ips_param_arr[48].ip_param_value
3045 #define	ips_ip_max_temp_idle		ips_param_arr[49].ip_param_value
3046 #define	ips_ip_max_temp_defend		ips_param_arr[50].ip_param_value
3047 #define	ips_ip_max_defend		ips_param_arr[51].ip_param_value
3048 #define	ips_ip_defend_interval		ips_param_arr[52].ip_param_value
3049 #define	ips_ip_dup_recovery		ips_param_arr[53].ip_param_value
3050 #define	ips_ip_restrict_interzone_loopback ips_param_arr[54].ip_param_value
3051 #define	ips_ip_lso_outbound		ips_param_arr[55].ip_param_value
3052 #define	ips_igmp_max_version		ips_param_arr[56].ip_param_value
3053 #define	ips_mld_max_version		ips_param_arr[57].ip_param_value
3054 #define	ips_ip_pmtu_min			ips_param_arr[58].ip_param_value
3055 #define	ips_ipv6_drop_inbound_icmpv6	ips_param_arr[59].ip_param_value
3056 
3057 extern int	dohwcksum;	/* use h/w cksum if supported by the h/w */
3058 #ifdef ZC_TEST
3059 extern int	noswcksum;
3060 #endif
3061 
3062 extern char	ipif_loopback_name[];
3063 
3064 extern nv_t	*ire_nv_tbl;
3065 
3066 extern struct module_info ip_mod_info;
3067 
3068 #define	HOOKS4_INTERESTED_PHYSICAL_IN(ipst)	\
3069 	((ipst)->ips_ip4_physical_in_event.he_interested)
3070 #define	HOOKS6_INTERESTED_PHYSICAL_IN(ipst)	\
3071 	((ipst)->ips_ip6_physical_in_event.he_interested)
3072 #define	HOOKS4_INTERESTED_PHYSICAL_OUT(ipst)	\
3073 	((ipst)->ips_ip4_physical_out_event.he_interested)
3074 #define	HOOKS6_INTERESTED_PHYSICAL_OUT(ipst)	\
3075 	((ipst)->ips_ip6_physical_out_event.he_interested)
3076 #define	HOOKS4_INTERESTED_FORWARDING(ipst)	\
3077 	((ipst)->ips_ip4_forwarding_event.he_interested)
3078 #define	HOOKS6_INTERESTED_FORWARDING(ipst)	\
3079 	((ipst)->ips_ip6_forwarding_event.he_interested)
3080 #define	HOOKS4_INTERESTED_LOOPBACK_IN(ipst)	\
3081 	((ipst)->ips_ip4_loopback_in_event.he_interested)
3082 #define	HOOKS6_INTERESTED_LOOPBACK_IN(ipst)	\
3083 	((ipst)->ips_ip6_loopback_in_event.he_interested)
3084 #define	HOOKS4_INTERESTED_LOOPBACK_OUT(ipst)	\
3085 	((ipst)->ips_ip4_loopback_out_event.he_interested)
3086 #define	HOOKS6_INTERESTED_LOOPBACK_OUT(ipst)	\
3087 	((ipst)->ips_ip6_loopback_out_event.he_interested)
3088 
3089 /*
3090  * Hooks macros used inside of ip
3091  */
3092 #define	FW_HOOKS(_hook, _event, _ilp, _olp, _iph, _fm, _m, _llm, ipst)	\
3093 									\
3094 	if ((_hook).he_interested) {	\
3095 		hook_pkt_event_t info;					\
3096 									\
3097 		_NOTE(CONSTCOND)					\
3098 		ASSERT((_ilp != NULL) || (_olp != NULL));		\
3099 									\
3100 		FW_SET_ILL_INDEX(info.hpe_ifp, (ill_t *)_ilp);		\
3101 		FW_SET_ILL_INDEX(info.hpe_ofp, (ill_t *)_olp);		\
3102 		info.hpe_protocol = ipst->ips_ipv4_net_data;		\
3103 		info.hpe_hdr = _iph;					\
3104 		info.hpe_mp = &(_fm);					\
3105 		info.hpe_mb = _m;					\
3106 		info.hpe_flags = _llm;					\
3107 		if (hook_run(ipst->ips_ipv4_net_data->netd_hooks,	\
3108 		    _event, (hook_data_t)&info) != 0) {			\
3109 			ip2dbg(("%s hook dropped mblk chain %p hdr %p\n",\
3110 			    (_hook).he_name, (void *)_fm, (void *)_m));	\
3111 			freemsg(_fm);					\
3112 			_fm = NULL;					\
3113 			_iph = NULL;					\
3114 			_m = NULL;					\
3115 		} else {						\
3116 			_iph = info.hpe_hdr;				\
3117 			_m = info.hpe_mb;				\
3118 		}							\
3119 	}
3120 
3121 #define	FW_HOOKS6(_hook, _event, _ilp, _olp, _iph, _fm, _m, _llm, ipst)	\
3122 									\
3123 	if ((_hook).he_interested) {	\
3124 		hook_pkt_event_t info;					\
3125 									\
3126 		_NOTE(CONSTCOND)					\
3127 		ASSERT((_ilp != NULL) || (_olp != NULL));		\
3128 									\
3129 		FW_SET_ILL_INDEX(info.hpe_ifp, (ill_t *)_ilp);		\
3130 		FW_SET_ILL_INDEX(info.hpe_ofp, (ill_t *)_olp);		\
3131 		info.hpe_protocol = ipst->ips_ipv6_net_data;		\
3132 		info.hpe_hdr = _iph;					\
3133 		info.hpe_mp = &(_fm);					\
3134 		info.hpe_mb = _m;					\
3135 		info.hpe_flags = _llm;					\
3136 		if (hook_run(ipst->ips_ipv6_net_data->netd_hooks,	\
3137 		    _event, (hook_data_t)&info) != 0) {			\
3138 			ip2dbg(("%s hook dropped mblk chain %p hdr %p\n",\
3139 			    (_hook).he_name, (void *)_fm, (void *)_m));	\
3140 			freemsg(_fm);					\
3141 			_fm = NULL;					\
3142 			_iph = NULL;					\
3143 			_m = NULL;					\
3144 		} else {						\
3145 			_iph = info.hpe_hdr;				\
3146 			_m = info.hpe_mb;				\
3147 		}							\
3148 	}
3149 
3150 #define	FW_SET_ILL_INDEX(fp, ill)					\
3151 	_NOTE(CONSTCOND)						\
3152 	if ((ill) == NULL || (ill)->ill_phyint == NULL) {		\
3153 		(fp) = 0;						\
3154 		_NOTE(CONSTCOND)					\
3155 	} else if (IS_UNDER_IPMP(ill)) {				\
3156 		(fp) = ipmp_ill_get_ipmp_ifindex(ill);			\
3157 	} else {							\
3158 		(fp) = (ill)->ill_phyint->phyint_ifindex;		\
3159 	}
3160 
3161 /*
3162  * Network byte order macros
3163  */
3164 #ifdef	_BIG_ENDIAN
3165 #define	N_IN_CLASSA_NET		IN_CLASSA_NET
3166 #define	N_IN_CLASSD_NET		IN_CLASSD_NET
3167 #define	N_INADDR_UNSPEC_GROUP	INADDR_UNSPEC_GROUP
3168 #define	N_IN_LOOPBACK_NET	(ipaddr_t)0x7f000000U
3169 #else /* _BIG_ENDIAN */
3170 #define	N_IN_CLASSA_NET		(ipaddr_t)0x000000ffU
3171 #define	N_IN_CLASSD_NET		(ipaddr_t)0x000000f0U
3172 #define	N_INADDR_UNSPEC_GROUP	(ipaddr_t)0x000000e0U
3173 #define	N_IN_LOOPBACK_NET	(ipaddr_t)0x0000007fU
3174 #endif /* _BIG_ENDIAN */
3175 #define	CLASSD(addr)	(((addr) & N_IN_CLASSD_NET) == N_INADDR_UNSPEC_GROUP)
3176 #define	CLASSE(addr)	(((addr) & N_IN_CLASSD_NET) == N_IN_CLASSD_NET)
3177 #define	IP_LOOPBACK_ADDR(addr)			\
3178 	(((addr) & N_IN_CLASSA_NET == N_IN_LOOPBACK_NET))
3179 
3180 #ifdef DEBUG
3181 /* IPsec HW acceleration debugging support */
3182 
3183 #define	IPSECHW_CAPAB		0x0001	/* capability negotiation */
3184 #define	IPSECHW_SADB		0x0002	/* SADB exchange */
3185 #define	IPSECHW_PKT		0x0004	/* general packet flow */
3186 #define	IPSECHW_PKTIN		0x0008	/* driver in pkt processing details */
3187 #define	IPSECHW_PKTOUT		0x0010	/* driver out pkt processing details */
3188 
3189 #define	IPSECHW_DEBUG(f, x)	if (ipsechw_debug & (f)) { (void) printf x; }
3190 #define	IPSECHW_CALL(f, r, x)	if (ipsechw_debug & (f)) { (void) r x; }
3191 
3192 extern uint32_t ipsechw_debug;
3193 #else
3194 #define	IPSECHW_DEBUG(f, x)	{}
3195 #define	IPSECHW_CALL(f, r, x)	{}
3196 #endif
3197 
3198 extern int	ip_debug;
3199 extern uint_t	ip_thread_data;
3200 extern krwlock_t ip_thread_rwlock;
3201 extern list_t	ip_thread_list;
3202 
3203 #ifdef IP_DEBUG
3204 #include <sys/debug.h>
3205 #include <sys/promif.h>
3206 
3207 #define	ip0dbg(a)	printf a
3208 #define	ip1dbg(a)	if (ip_debug > 2) printf a
3209 #define	ip2dbg(a)	if (ip_debug > 3) printf a
3210 #define	ip3dbg(a)	if (ip_debug > 4) printf a
3211 #else
3212 #define	ip0dbg(a)	/* */
3213 #define	ip1dbg(a)	/* */
3214 #define	ip2dbg(a)	/* */
3215 #define	ip3dbg(a)	/* */
3216 #endif	/* IP_DEBUG */
3217 
3218 /* Default MAC-layer address string length for mac_colon_addr */
3219 #define	MAC_STR_LEN	128
3220 
3221 struct	ipsec_out_s;
3222 
3223 struct	mac_header_info_s;
3224 
3225 extern void	ill_frag_timer(void *);
3226 extern ill_t	*ill_first(int, int, ill_walk_context_t *, ip_stack_t *);
3227 extern ill_t	*ill_next(ill_walk_context_t *, ill_t *);
3228 extern void	ill_frag_timer_start(ill_t *);
3229 extern void	ill_nic_event_dispatch(ill_t *, lif_if_t, nic_event_t,
3230     nic_event_data_t, size_t);
3231 extern mblk_t	*ip_carve_mp(mblk_t **, ssize_t);
3232 extern mblk_t	*ip_dlpi_alloc(size_t, t_uscalar_t);
3233 extern mblk_t	*ip_dlnotify_alloc(uint_t, uint_t);
3234 extern char	*ip_dot_addr(ipaddr_t, char *);
3235 extern const char *mac_colon_addr(const uint8_t *, size_t, char *, size_t);
3236 extern void	ip_lwput(queue_t *, mblk_t *);
3237 extern boolean_t icmp_err_rate_limit(ip_stack_t *);
3238 extern void	icmp_time_exceeded(queue_t *, mblk_t *, uint8_t, zoneid_t,
3239     ip_stack_t *);
3240 extern void	icmp_unreachable(queue_t *, mblk_t *, uint8_t, zoneid_t,
3241     ip_stack_t *);
3242 extern mblk_t	*ip_add_info(mblk_t *, ill_t *, uint_t, zoneid_t, ip_stack_t *);
3243 cred_t		*ip_best_cred(mblk_t *, conn_t *);
3244 extern mblk_t	*ip_bind_v4(queue_t *, mblk_t *, conn_t *);
3245 extern	boolean_t ip_bind_ipsec_policy_set(conn_t *, mblk_t *);
3246 extern	int	ip_bind_laddr_v4(conn_t *, mblk_t **, uint8_t, ipaddr_t,
3247     uint16_t, boolean_t);
3248 extern	int	ip_proto_bind_laddr_v4(conn_t *, mblk_t **, uint8_t, ipaddr_t,
3249     uint16_t, boolean_t);
3250 extern	int	ip_proto_bind_connected_v4(conn_t *, mblk_t **,
3251     uint8_t, ipaddr_t *, uint16_t, ipaddr_t, uint16_t, boolean_t, boolean_t,
3252     cred_t *);
3253 extern	int	ip_bind_connected_v4(conn_t *, mblk_t **, uint8_t, ipaddr_t *,
3254     uint16_t, ipaddr_t, uint16_t, boolean_t, boolean_t, cred_t *);
3255 extern uint_t	ip_cksum(mblk_t *, int, uint32_t);
3256 extern int	ip_close(queue_t *, int);
3257 extern uint16_t	ip_csum_hdr(ipha_t *);
3258 extern void	ip_proto_not_sup(queue_t *, mblk_t *, uint_t, zoneid_t,
3259     ip_stack_t *);
3260 extern void	ip_ire_g_fini(void);
3261 extern void	ip_ire_g_init(void);
3262 extern void	ip_ire_fini(ip_stack_t *);
3263 extern void	ip_ire_init(ip_stack_t *);
3264 extern int	ip_openv4(queue_t *q, dev_t *devp, int flag, int sflag,
3265 		    cred_t *credp);
3266 extern int	ip_openv6(queue_t *q, dev_t *devp, int flag, int sflag,
3267 		    cred_t *credp);
3268 extern int	ip_reassemble(mblk_t *, ipf_t *, uint_t, boolean_t, ill_t *,
3269     size_t);
3270 extern int	ip_opt_set_ill(conn_t *, int, boolean_t, boolean_t,
3271     int, int, mblk_t *);
3272 extern void	ip_rput(queue_t *, mblk_t *);
3273 extern void	ip_input(ill_t *, ill_rx_ring_t *, mblk_t *,
3274     struct mac_header_info_s *);
3275 extern mblk_t	*ip_accept_tcp(ill_t *, ill_rx_ring_t *, squeue_t *,
3276     mblk_t *, mblk_t **, uint_t *cnt);
3277 extern void	ip_rput_dlpi(queue_t *, mblk_t *);
3278 extern void	ip_rput_forward(ire_t *, ipha_t *, mblk_t *, ill_t *);
3279 extern void	ip_rput_forward_multicast(ipaddr_t, mblk_t *, ipif_t *);
3280 
3281 extern void	ip_mib2_add_ip_stats(mib2_ipIfStatsEntry_t *,
3282 		    mib2_ipIfStatsEntry_t *);
3283 extern void	ip_mib2_add_icmp6_stats(mib2_ipv6IfIcmpEntry_t *,
3284 		    mib2_ipv6IfIcmpEntry_t *);
3285 extern void	ip_udp_input(queue_t *, mblk_t *, ipha_t *, ire_t *, ill_t *);
3286 extern void	ip_proto_input(queue_t *, mblk_t *, ipha_t *, ire_t *, ill_t *,
3287     uint32_t);
3288 extern void	ip_rput_other(ipsq_t *, queue_t *, mblk_t *, void *);
3289 extern ire_t	*ip_check_multihome(void *, ire_t *, ill_t *);
3290 extern void	ip_setpktversion(conn_t *, boolean_t, boolean_t, ip_stack_t *);
3291 extern void	ip_trash_ire_reclaim(void *);
3292 extern void	ip_trash_timer_expire(void *);
3293 extern void	ip_wput(queue_t *, mblk_t *);
3294 extern void	ip_output(void *, mblk_t *, void *, int);
3295 extern void	ip_output_options(void *, mblk_t *, void *, int,
3296     ip_opt_info_t *);
3297 
3298 extern void	ip_wput_ire(queue_t *, mblk_t *, ire_t *, conn_t *, int,
3299 		    zoneid_t);
3300 extern void	ip_wput_local(queue_t *, ill_t *, ipha_t *, mblk_t *, ire_t *,
3301 		    int, zoneid_t);
3302 extern void	ip_wput_multicast(queue_t *, mblk_t *, ipif_t *, zoneid_t);
3303 extern void	ip_wput_nondata(ipsq_t *, queue_t *, mblk_t *, void *);
3304 extern void	ip_wsrv(queue_t *);
3305 extern char	*ip_nv_lookup(nv_t *, int);
3306 extern boolean_t ip_local_addr_ok_v6(const in6_addr_t *, const in6_addr_t *);
3307 extern boolean_t ip_remote_addr_ok_v6(const in6_addr_t *, const in6_addr_t *);
3308 extern ipaddr_t ip_massage_options(ipha_t *, netstack_t *);
3309 extern ipaddr_t ip_net_mask(ipaddr_t);
3310 extern void	ip_newroute(queue_t *, mblk_t *, ipaddr_t, conn_t *, zoneid_t,
3311 		    ip_stack_t *);
3312 extern ipxmit_state_t	ip_xmit_v4(mblk_t *, ire_t *, struct ipsec_out_s *,
3313     boolean_t, conn_t *);
3314 extern int	ip_hdr_complete(ipha_t *, zoneid_t, ip_stack_t *);
3315 
3316 extern struct qinit iprinitv6;
3317 extern struct qinit ipwinitv6;
3318 
3319 extern void	ipmp_init(ip_stack_t *);
3320 extern void	ipmp_destroy(ip_stack_t *);
3321 extern ipmp_grp_t *ipmp_grp_create(const char *, phyint_t *);
3322 extern void	ipmp_grp_destroy(ipmp_grp_t *);
3323 extern void	ipmp_grp_info(const ipmp_grp_t *, lifgroupinfo_t *);
3324 extern int	ipmp_grp_rename(ipmp_grp_t *, const char *);
3325 extern ipmp_grp_t *ipmp_grp_lookup(const char *, ip_stack_t *);
3326 extern int	ipmp_grp_vet_phyint(ipmp_grp_t *, phyint_t *);
3327 extern ipmp_illgrp_t *ipmp_illgrp_create(ill_t *);
3328 extern void	ipmp_illgrp_destroy(ipmp_illgrp_t *);
3329 extern ill_t	*ipmp_illgrp_add_ipif(ipmp_illgrp_t *, ipif_t *);
3330 extern void	ipmp_illgrp_del_ipif(ipmp_illgrp_t *, ipif_t *);
3331 extern ill_t	*ipmp_illgrp_next_ill(ipmp_illgrp_t *);
3332 extern ill_t	*ipmp_illgrp_hold_next_ill(ipmp_illgrp_t *);
3333 extern ill_t	*ipmp_illgrp_cast_ill(ipmp_illgrp_t *);
3334 extern ill_t	*ipmp_illgrp_hold_cast_ill(ipmp_illgrp_t *);
3335 extern ill_t	*ipmp_illgrp_ipmp_ill(ipmp_illgrp_t *);
3336 extern void	ipmp_illgrp_refresh_mtu(ipmp_illgrp_t *);
3337 extern ipmp_arpent_t *ipmp_illgrp_create_arpent(ipmp_illgrp_t *, mblk_t *,
3338     boolean_t);
3339 extern void	ipmp_illgrp_destroy_arpent(ipmp_illgrp_t *, ipmp_arpent_t *);
3340 extern ipmp_arpent_t *ipmp_illgrp_lookup_arpent(ipmp_illgrp_t *, ipaddr_t *);
3341 extern void	ipmp_illgrp_refresh_arpent(ipmp_illgrp_t *);
3342 extern void	ipmp_illgrp_mark_arpent(ipmp_illgrp_t *, ipmp_arpent_t *);
3343 extern ill_t	*ipmp_illgrp_find_ill(ipmp_illgrp_t *, uchar_t *, uint_t);
3344 extern void	ipmp_illgrp_link_grp(ipmp_illgrp_t *, ipmp_grp_t *);
3345 extern int	ipmp_illgrp_unlink_grp(ipmp_illgrp_t *);
3346 extern uint_t	ipmp_ill_get_ipmp_ifindex(const ill_t *);
3347 extern void	ipmp_ill_join_illgrp(ill_t *, ipmp_illgrp_t *);
3348 extern void	ipmp_ill_leave_illgrp(ill_t *);
3349 extern ill_t	*ipmp_ill_hold_ipmp_ill(ill_t *);
3350 extern boolean_t ipmp_ill_is_active(ill_t *);
3351 extern void	ipmp_ill_refresh_active(ill_t *);
3352 extern void	ipmp_phyint_join_grp(phyint_t *, ipmp_grp_t *);
3353 extern void	ipmp_phyint_leave_grp(phyint_t *);
3354 extern void	ipmp_phyint_refresh_active(phyint_t *);
3355 extern ill_t	*ipmp_ipif_bound_ill(const ipif_t *);
3356 extern ill_t	*ipmp_ipif_hold_bound_ill(const ipif_t *);
3357 extern boolean_t ipmp_ipif_is_dataaddr(const ipif_t *);
3358 extern boolean_t ipmp_ipif_is_stubaddr(const ipif_t *);
3359 
3360 extern void	conn_drain_insert(conn_t *, idl_tx_list_t *);
3361 extern int	conn_ipsec_length(conn_t *);
3362 extern void	ip_wput_ipsec_out(queue_t *, mblk_t *, ipha_t *, ill_t *,
3363     ire_t *);
3364 extern ipaddr_t	ip_get_dst(ipha_t *);
3365 extern int	ipsec_out_extra_length(mblk_t *);
3366 extern int	ipsec_in_extra_length(mblk_t *);
3367 extern mblk_t	*ipsec_in_alloc(boolean_t, netstack_t *);
3368 extern boolean_t ipsec_in_is_secure(mblk_t *);
3369 extern void	ipsec_out_process(queue_t *, mblk_t *, ire_t *, uint_t);
3370 extern void	ipsec_out_to_in(mblk_t *);
3371 extern void	ip_fanout_proto_again(mblk_t *, ill_t *, ill_t *, ire_t *);
3372 
3373 extern void	ire_cleanup(ire_t *);
3374 extern void	ire_inactive(ire_t *);
3375 extern boolean_t irb_inactive(irb_t *);
3376 extern ire_t	*ire_unlink(irb_t *);
3377 
3378 #ifdef DEBUG
3379 extern	boolean_t th_trace_ref(const void *, ip_stack_t *);
3380 extern	void	th_trace_unref(const void *);
3381 extern	void	th_trace_cleanup(const void *, boolean_t);
3382 extern	void	ire_trace_ref(ire_t *);
3383 extern	void	ire_untrace_ref(ire_t *);
3384 #endif
3385 
3386 extern int	ip_srcid_insert(const in6_addr_t *, zoneid_t, ip_stack_t *);
3387 extern int	ip_srcid_remove(const in6_addr_t *, zoneid_t, ip_stack_t *);
3388 extern void	ip_srcid_find_id(uint_t, in6_addr_t *, zoneid_t, netstack_t *);
3389 extern uint_t	ip_srcid_find_addr(const in6_addr_t *, zoneid_t, netstack_t *);
3390 
3391 extern uint8_t	ipoptp_next(ipoptp_t *);
3392 extern uint8_t	ipoptp_first(ipoptp_t *, ipha_t *);
3393 extern int	ip_opt_get_user(const ipha_t *, uchar_t *);
3394 extern int	ipsec_req_from_conn(conn_t *, ipsec_req_t *, int);
3395 extern int	ip_snmp_get(queue_t *q, mblk_t *mctl, int level);
3396 extern int	ip_snmp_set(queue_t *q, int, int, uchar_t *, int);
3397 extern void	ip_process_ioctl(ipsq_t *, queue_t *, mblk_t *, void *);
3398 extern void	ip_quiesce_conn(conn_t *);
3399 extern  void    ip_reprocess_ioctl(ipsq_t *, queue_t *, mblk_t *, void *);
3400 extern void	ip_restart_optmgmt(ipsq_t *, queue_t *, mblk_t *, void *);
3401 extern void	ip_ioctl_finish(queue_t *, mblk_t *, int, int, ipsq_t *);
3402 
3403 extern boolean_t ip_cmpbuf(const void *, uint_t, boolean_t, const void *,
3404     uint_t);
3405 extern boolean_t ip_allocbuf(void **, uint_t *, boolean_t, const void *,
3406     uint_t);
3407 extern void	ip_savebuf(void **, uint_t *, boolean_t, const void *, uint_t);
3408 
3409 extern boolean_t	ipsq_pending_mp_cleanup(ill_t *, conn_t *);
3410 extern void	conn_ioctl_cleanup(conn_t *);
3411 extern ill_t	*conn_get_held_ill(conn_t *, ill_t **, int *);
3412 
3413 struct tcp_stack;
3414 extern void ip_xmit_reset_serialize(mblk_t *, int, zoneid_t, struct tcp_stack *,
3415     conn_t *);
3416 
3417 struct multidata_s;
3418 struct pdesc_s;
3419 
3420 extern mblk_t	*ip_mdinfo_alloc(ill_mdt_capab_t *);
3421 extern mblk_t	*ip_mdinfo_return(ire_t *, conn_t *, char *, ill_mdt_capab_t *);
3422 extern mblk_t	*ip_lsoinfo_alloc(ill_lso_capab_t *);
3423 extern mblk_t	*ip_lsoinfo_return(ire_t *, conn_t *, char *,
3424     ill_lso_capab_t *);
3425 extern uint_t	ip_md_cksum(struct pdesc_s *, int, uint_t);
3426 extern boolean_t ip_md_addr_attr(struct multidata_s *, struct pdesc_s *,
3427 			const mblk_t *);
3428 extern boolean_t ip_md_hcksum_attr(struct multidata_s *, struct pdesc_s *,
3429 			uint32_t, uint32_t, uint32_t, uint32_t);
3430 extern boolean_t ip_md_zcopy_attr(struct multidata_s *, struct pdesc_s *,
3431 			uint_t);
3432 extern	void	ip_unbind(conn_t *connp);
3433 
3434 extern void tnet_init(void);
3435 extern void tnet_fini(void);
3436 
3437 /* Hooks for CGTP (multirt routes) filtering module */
3438 #define	CGTP_FILTER_REV_1	1
3439 #define	CGTP_FILTER_REV_2	2
3440 #define	CGTP_FILTER_REV_3	3
3441 #define	CGTP_FILTER_REV		CGTP_FILTER_REV_3
3442 
3443 /* cfo_filter and cfo_filter_v6 hooks return values */
3444 #define	CGTP_IP_PKT_NOT_CGTP	0
3445 #define	CGTP_IP_PKT_PREMIUM	1
3446 #define	CGTP_IP_PKT_DUPLICATE	2
3447 
3448 /* Version 3 of the filter interface */
3449 typedef struct cgtp_filter_ops {
3450 	int	cfo_filter_rev;			/* CGTP_FILTER_REV_3 */
3451 	int	(*cfo_change_state)(netstackid_t, int);
3452 	int	(*cfo_add_dest_v4)(netstackid_t, ipaddr_t, ipaddr_t,
3453 		    ipaddr_t, ipaddr_t);
3454 	int	(*cfo_del_dest_v4)(netstackid_t, ipaddr_t, ipaddr_t);
3455 	int	(*cfo_add_dest_v6)(netstackid_t, in6_addr_t *, in6_addr_t *,
3456 		    in6_addr_t *, in6_addr_t *);
3457 	int	(*cfo_del_dest_v6)(netstackid_t, in6_addr_t *, in6_addr_t *);
3458 	int	(*cfo_filter)(netstackid_t, uint_t, mblk_t *);
3459 	int	(*cfo_filter_v6)(netstackid_t, uint_t, ip6_t *,
3460 		    ip6_frag_t *);
3461 } cgtp_filter_ops_t;
3462 
3463 #define	CGTP_MCAST_SUCCESS	1
3464 
3465 /*
3466  * The separate CGTP module needs this global symbol so that it
3467  * can check the version and determine whether to use the old or the new
3468  * version of the filtering interface.
3469  */
3470 extern int	ip_cgtp_filter_rev;
3471 
3472 extern int	ip_cgtp_filter_supported(void);
3473 extern int	ip_cgtp_filter_register(netstackid_t, cgtp_filter_ops_t *);
3474 extern int	ip_cgtp_filter_unregister(netstackid_t);
3475 extern int	ip_cgtp_filter_is_registered(netstackid_t);
3476 
3477 /* Flags for ire_multirt_lookup() */
3478 
3479 #define	MULTIRT_USESTAMP	0x0001
3480 #define	MULTIRT_SETSTAMP	0x0002
3481 #define	MULTIRT_CACHEGW		0x0004
3482 
3483 /* Debug stuff for multirt route resolution. */
3484 #if defined(DEBUG) && !defined(__lint)
3485 /* Our "don't send, rather drop" flag. */
3486 #define	MULTIRT_DEBUG_FLAG	0x8000
3487 
3488 #define	MULTIRT_TRACE(x)	ip2dbg(x)
3489 
3490 #define	MULTIRT_DEBUG_TAG(mblk)	\
3491 	do { \
3492 		ASSERT(mblk != NULL); \
3493 		MULTIRT_TRACE(("%s[%d]: tagging mblk %p, tag was %d\n", \
3494 		__FILE__, __LINE__, \
3495 		(void *)(mblk), (mblk)->b_flag & MULTIRT_DEBUG_FLAG)); \
3496 		(mblk)->b_flag |= MULTIRT_DEBUG_FLAG; \
3497 	} while (0)
3498 
3499 #define	MULTIRT_DEBUG_UNTAG(mblk) \
3500 	do { \
3501 		ASSERT(mblk != NULL); \
3502 		MULTIRT_TRACE(("%s[%d]: untagging mblk %p, tag was %d\n", \
3503 		__FILE__, __LINE__, \
3504 		(void *)(mblk), (mblk)->b_flag & MULTIRT_DEBUG_FLAG)); \
3505 		(mblk)->b_flag &= ~MULTIRT_DEBUG_FLAG; \
3506 	} while (0)
3507 
3508 #define	MULTIRT_DEBUG_TAGGED(mblk) \
3509 	(((mblk)->b_flag & MULTIRT_DEBUG_FLAG) ? B_TRUE : B_FALSE)
3510 #else
3511 #define	MULTIRT_DEBUG_TAG(mblk)		ASSERT(mblk != NULL)
3512 #define	MULTIRT_DEBUG_UNTAG(mblk)	ASSERT(mblk != NULL)
3513 #define	MULTIRT_DEBUG_TAGGED(mblk)	B_FALSE
3514 #endif
3515 
3516 /*
3517  * IP observability hook support
3518  */
3519 
3520 /*
3521  * ipobs_hooktype_t describes the hook types supported
3522  * by the ip module. IPOBS_HOOK_LOCAL refers to packets
3523  * which are looped back internally within the ip module.
3524  */
3525 
3526 typedef enum ipobs_hook_type {
3527 	IPOBS_HOOK_LOCAL,
3528 	IPOBS_HOOK_OUTBOUND,
3529 	IPOBS_HOOK_INBOUND
3530 } ipobs_hook_type_t;
3531 
3532 typedef void ipobs_cbfunc_t(mblk_t *);
3533 
3534 typedef struct ipobs_cb {
3535 	ipobs_cbfunc_t	*ipobs_cbfunc;
3536 	list_node_t	ipobs_cbnext;
3537 } ipobs_cb_t;
3538 
3539 /*
3540  * This structure holds the data passed back from the ip module to
3541  * observability consumers.
3542  *
3543  * ihd_mp	  Pointer to the IP packet.
3544  * ihd_zsrc	  Source zoneid; set to ALL_ZONES when unknown.
3545  * ihd_zdst	  Destination zoneid; set to ALL_ZONES when unknown.
3546  * ihd_htype	  IPobs hook type, see above for the defined types.
3547  * ihd_ipver	  IP version of the packet.
3548  * ihd_ifindex	  Interface index that the packet was received/sent over.
3549  *		  For local packets, this is the index of the interface
3550  *		  associated with the local destination address.
3551  * ihd_grifindex  IPMP group interface index (zero unless ihd_ifindex
3552  *		  is an IPMP underlying interface).
3553  * ihd_stack	  Netstack the packet is from.
3554  */
3555 typedef struct ipobs_hook_data {
3556 	mblk_t			*ihd_mp;
3557 	zoneid_t		ihd_zsrc;
3558 	zoneid_t		ihd_zdst;
3559 	ipobs_hook_type_t	ihd_htype;
3560 	uint16_t		ihd_ipver;
3561 	uint64_t		ihd_ifindex;
3562 	uint64_t 		ihd_grifindex;
3563 	netstack_t		*ihd_stack;
3564 } ipobs_hook_data_t;
3565 
3566 /*
3567  * Per-ILL Multidata Transmit capabilities.
3568  */
3569 struct ill_mdt_capab_s {
3570 	uint_t ill_mdt_version;  /* interface version */
3571 	uint_t ill_mdt_on;	 /* on/off switch for MDT on this ILL */
3572 	uint_t ill_mdt_hdr_head; /* leading header fragment extra space */
3573 	uint_t ill_mdt_hdr_tail; /* trailing header fragment extra space */
3574 	uint_t ill_mdt_max_pld;	 /* maximum payload buffers per Multidata */
3575 	uint_t ill_mdt_span_limit; /* maximum payload span per packet */
3576 };
3577 
3578 struct ill_hcksum_capab_s {
3579 	uint_t	ill_hcksum_version;	/* interface version */
3580 	uint_t	ill_hcksum_txflags;	/* capabilities on transmit */
3581 };
3582 
3583 struct ill_zerocopy_capab_s {
3584 	uint_t	ill_zerocopy_version;	/* interface version */
3585 	uint_t	ill_zerocopy_flags;	/* capabilities */
3586 };
3587 
3588 struct ill_lso_capab_s {
3589 	uint_t	ill_lso_on;		/* on/off switch for LSO on this ILL */
3590 	uint_t	ill_lso_flags;		/* capabilities */
3591 	uint_t	ill_lso_max;		/* maximum size of payload */
3592 };
3593 
3594 /*
3595  * rr_ring_state cycles in the order shown below from RR_FREE through
3596  * RR_FREE_IN_PROG and  back to RR_FREE.
3597  */
3598 typedef enum {
3599 	RR_FREE,			/* Free slot */
3600 	RR_SQUEUE_UNBOUND,		/* Ring's squeue is unbound */
3601 	RR_SQUEUE_BIND_INPROG,		/* Ring's squeue bind in progress */
3602 	RR_SQUEUE_BOUND,		/* Ring's squeue bound to cpu */
3603 	RR_FREE_INPROG			/* Ring is being freed */
3604 } ip_ring_state_t;
3605 
3606 #define	ILL_MAX_RINGS		256	/* Max num of rx rings we can manage */
3607 #define	ILL_POLLING		0x01	/* Polling in use */
3608 
3609 /*
3610  * These functions pointer types are exported by the mac/dls layer.
3611  * we need to duplicate the definitions here because we cannot
3612  * include mac/dls header files here.
3613  */
3614 typedef void			(*ip_mac_intr_disable_t)(void *);
3615 typedef void			(*ip_mac_intr_enable_t)(void *);
3616 typedef ip_mac_tx_cookie_t	(*ip_dld_tx_t)(void *, mblk_t *,
3617     uint64_t, uint16_t);
3618 typedef	void			(*ip_flow_enable_t)(void *, ip_mac_tx_cookie_t);
3619 typedef void			*(*ip_dld_callb_t)(void *,
3620     ip_flow_enable_t, void *);
3621 typedef boolean_t		(*ip_dld_fctl_t)(void *, ip_mac_tx_cookie_t);
3622 typedef int			(*ip_capab_func_t)(void *, uint_t,
3623     void *, uint_t);
3624 
3625 /*
3626  * POLLING README
3627  * sq_get_pkts() is called to pick packets from softring in poll mode. It
3628  * calls rr_rx to get the chain and process it with rr_ip_accept.
3629  * rr_rx = mac_soft_ring_poll() to pick packets
3630  * rr_ip_accept = ip_accept_tcp() to process packets
3631  */
3632 
3633 /*
3634  * XXX: With protocol, service specific squeues, they will have
3635  * specific acceptor functions.
3636  */
3637 typedef	mblk_t *(*ip_mac_rx_t)(void *, size_t);
3638 typedef mblk_t *(*ip_accept_t)(ill_t *, ill_rx_ring_t *,
3639     squeue_t *, mblk_t *, mblk_t **, uint_t *);
3640 
3641 /*
3642  * rr_intr_enable, rr_intr_disable, rr_rx_handle, rr_rx:
3643  * May be accessed while in the squeue AND after checking that SQS_POLL_CAPAB
3644  * is set.
3645  *
3646  * rr_ring_state: Protected by ill_lock.
3647  */
3648 struct ill_rx_ring {
3649 	ip_mac_intr_disable_t	rr_intr_disable; /* Interrupt disabling func */
3650 	ip_mac_intr_enable_t	rr_intr_enable;	/* Interrupt enabling func */
3651 	void			*rr_intr_handle; /* Handle interrupt funcs */
3652 	ip_mac_rx_t		rr_rx;		/* Driver receive function */
3653 	ip_accept_t		rr_ip_accept;	/* IP accept function */
3654 	void			*rr_rx_handle;	/* Handle for Rx ring */
3655 	squeue_t		*rr_sqp; /* Squeue the ring is bound to */
3656 	ill_t			*rr_ill;	/* back pointer to ill */
3657 	ip_ring_state_t		rr_ring_state;	/* State of this ring */
3658 };
3659 
3660 /*
3661  * IP - DLD direct function call capability
3662  * Suffixes, df - dld function, dh - dld handle,
3663  * cf - client (IP) function, ch - client handle
3664  */
3665 typedef struct ill_dld_direct_s {		/* DLD provided driver Tx */
3666 	ip_dld_tx_t		idd_tx_df;	/* str_mdata_fastpath_put */
3667 	void			*idd_tx_dh;	/* dld_str_t *dsp */
3668 	ip_dld_callb_t		idd_tx_cb_df;	/* mac_tx_srs_notify */
3669 	void			*idd_tx_cb_dh;	/* mac_client_handle_t *mch */
3670 	ip_dld_fctl_t		idd_tx_fctl_df;	/* mac_tx_is_flow_blocked */
3671 	void			*idd_tx_fctl_dh;	/* mac_client_handle */
3672 } ill_dld_direct_t;
3673 
3674 /* IP - DLD polling capability */
3675 typedef struct ill_dld_poll_s {
3676 	ill_rx_ring_t		idp_ring_tbl[ILL_MAX_RINGS];
3677 } ill_dld_poll_t;
3678 
3679 /* Describes ill->ill_dld_capab */
3680 struct ill_dld_capab_s {
3681 	ip_capab_func_t		idc_capab_df;	/* dld_capab_func */
3682 	void			*idc_capab_dh;	/* dld_str_t *dsp */
3683 	ill_dld_direct_t	idc_direct;
3684 	ill_dld_poll_t		idc_poll;
3685 };
3686 
3687 /*
3688  * IP squeues exports
3689  */
3690 extern boolean_t 	ip_squeue_fanout;
3691 
3692 #define	IP_SQUEUE_GET(hint) ip_squeue_random(hint)
3693 
3694 extern void ip_squeue_init(void (*)(squeue_t *));
3695 extern squeue_t	*ip_squeue_random(uint_t);
3696 extern squeue_t *ip_squeue_get(ill_rx_ring_t *);
3697 extern squeue_t *ip_squeue_getfree(pri_t);
3698 extern int ip_squeue_cpu_move(squeue_t *, processorid_t);
3699 extern void *ip_squeue_add_ring(ill_t *, void *);
3700 extern void ip_squeue_bind_ring(ill_t *, ill_rx_ring_t *, processorid_t);
3701 extern void ip_squeue_clean_ring(ill_t *, ill_rx_ring_t *);
3702 extern void ip_squeue_quiesce_ring(ill_t *, ill_rx_ring_t *);
3703 extern void ip_squeue_restart_ring(ill_t *, ill_rx_ring_t *);
3704 extern void ip_squeue_clean_all(ill_t *);
3705 
3706 extern void tcp_wput(queue_t *, mblk_t *);
3707 
3708 extern int	ip_fill_mtuinfo(struct in6_addr *, in_port_t,
3709 	struct ip6_mtuinfo *, netstack_t *);
3710 extern	ipif_t *conn_get_held_ipif(conn_t *, ipif_t **, int *);
3711 extern void ipobs_register_hook(netstack_t *, ipobs_cbfunc_t *);
3712 extern void ipobs_unregister_hook(netstack_t *, ipobs_cbfunc_t *);
3713 extern void ipobs_hook(mblk_t *, int, zoneid_t, zoneid_t, const ill_t *, int,
3714     uint32_t, ip_stack_t *);
3715 typedef void    (*ipsq_func_t)(ipsq_t *, queue_t *, mblk_t *, void *);
3716 
3717 /*
3718  * Squeue tags. Tags only need to be unique when the callback function is the
3719  * same to distinguish between different calls, but we use unique tags for
3720  * convenience anyway.
3721  */
3722 #define	SQTAG_IP_INPUT			1
3723 #define	SQTAG_TCP_INPUT_ICMP_ERR	2
3724 #define	SQTAG_TCP6_INPUT_ICMP_ERR	3
3725 #define	SQTAG_IP_TCP_INPUT		4
3726 #define	SQTAG_IP6_TCP_INPUT		5
3727 #define	SQTAG_IP_TCP_CLOSE		6
3728 #define	SQTAG_TCP_OUTPUT		7
3729 #define	SQTAG_TCP_TIMER			8
3730 #define	SQTAG_TCP_TIMEWAIT		9
3731 #define	SQTAG_TCP_ACCEPT_FINISH		10
3732 #define	SQTAG_TCP_ACCEPT_FINISH_Q0	11
3733 #define	SQTAG_TCP_ACCEPT_PENDING	12
3734 #define	SQTAG_TCP_LISTEN_DISCON		13
3735 #define	SQTAG_TCP_CONN_REQ_1		14
3736 #define	SQTAG_TCP_EAGER_BLOWOFF		15
3737 #define	SQTAG_TCP_EAGER_CLEANUP		16
3738 #define	SQTAG_TCP_EAGER_CLEANUP_Q0	17
3739 #define	SQTAG_TCP_CONN_IND		18
3740 #define	SQTAG_TCP_RSRV			19
3741 #define	SQTAG_TCP_ABORT_BUCKET		20
3742 #define	SQTAG_TCP_REINPUT		21
3743 #define	SQTAG_TCP_REINPUT_EAGER		22
3744 #define	SQTAG_TCP_INPUT_MCTL		23
3745 #define	SQTAG_TCP_RPUTOTHER		24
3746 #define	SQTAG_IP_PROTO_AGAIN		25
3747 #define	SQTAG_IP_FANOUT_TCP		26
3748 #define	SQTAG_IPSQ_CLEAN_RING		27
3749 #define	SQTAG_TCP_WPUT_OTHER		28
3750 #define	SQTAG_TCP_CONN_REQ_UNBOUND	29
3751 #define	SQTAG_TCP_SEND_PENDING		30
3752 #define	SQTAG_BIND_RETRY		31
3753 #define	SQTAG_UDP_FANOUT		32
3754 #define	SQTAG_UDP_INPUT			33
3755 #define	SQTAG_UDP_WPUT			34
3756 #define	SQTAG_UDP_OUTPUT		35
3757 #define	SQTAG_TCP_KSSL_INPUT		36
3758 #define	SQTAG_TCP_DROP_Q0		37
3759 #define	SQTAG_TCP_CONN_REQ_2		38
3760 #define	SQTAG_IP_INPUT_RX_RING		39
3761 #define	SQTAG_SQUEUE_CHANGE		40
3762 #define	SQTAG_CONNECT_FINISH		41
3763 #define	SQTAG_SYNCHRONOUS_OP		42
3764 #define	SQTAG_TCP_SHUTDOWN_OUTPUT	43
3765 #define	SQTAG_XMIT_EARLY_RESET		44
3766 
3767 #define	NOT_OVER_IP(ip_wq)	\
3768 	(ip_wq->q_next != NULL ||	\
3769 	    (ip_wq->q_qinfo->qi_minfo->mi_idname) == NULL ||	\
3770 	    strcmp(ip_wq->q_qinfo->qi_minfo->mi_idname,	\
3771 	    IP_MOD_NAME) != 0 ||	\
3772 	    ip_wq->q_qinfo->qi_minfo->mi_idnum != IP_MOD_ID)
3773 
3774 #define	PROTO_FLOW_CNTRLD(connp)	(connp->conn_flow_cntrld)
3775 #endif	/* _KERNEL */
3776 
3777 #ifdef	__cplusplus
3778 }
3779 #endif
3780 
3781 #endif	/* _INET_IP_H */
3782