xref: /titanic_52/usr/src/uts/common/inet/ip.h (revision 9c75c6bf17b72bb057d7a8879feba77ece65241a)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 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 #pragma ident	"%Z%%M%	%I%	%E% SMI"
32 
33 #ifdef	__cplusplus
34 extern "C" {
35 #endif
36 
37 #include <sys/isa_defs.h>
38 #include <sys/types.h>
39 #include <inet/mib2.h>
40 #include <inet/nd.h>
41 #include <sys/atomic.h>
42 #include <sys/socket.h>
43 #include <net/if_dl.h>
44 #include <net/if.h>
45 #include <netinet/ip.h>
46 #include <sys/dlpi.h>
47 #include <netinet/igmp.h>
48 
49 #ifdef _KERNEL
50 #include <netinet/ip6.h>
51 #include <sys/avl.h>
52 #include <sys/vmem.h>
53 #include <sys/squeue.h>
54 #include <sys/systm.h>
55 #include <sys/multidata.h>
56 
57 #ifdef DEBUG
58 #define	ILL_DEBUG
59 #define	IRE_DEBUG
60 #define	NCE_DEBUG
61 #define	CONN_DEBUG
62 #endif
63 
64 #define	IP_DEBUG
65 /*
66  * The mt-streams(9F) flags for the IP module; put here so that other
67  * "drivers" that are actually IP (e.g., ICMP, UDP) can use the same set
68  * of flags.
69  */
70 #define	IP_DEVMTFLAGS D_MP
71 #endif	/* _KERNEL */
72 
73 #define	IP_MOD_NAME	"ip"
74 #define	IP_DEV_NAME	"/dev/ip"
75 #define	IP6_DEV_NAME	"/dev/ip6"
76 
77 #define	UDP_MOD_NAME	"udp"
78 #define	UDP_DEV_NAME	"/dev/udp"
79 #define	UDP6_DEV_NAME	"/dev/udp6"
80 
81 #define	TCP_MOD_NAME	"tcp"
82 #define	TCP_DEV_NAME	"/dev/tcp"
83 #define	TCP6_DEV_NAME	"/dev/tcp6"
84 
85 /* Minor numbers */
86 #define	IPV4_MINOR	0
87 #define	IPV6_MINOR	1
88 #define	TCP_MINOR	2
89 #define	TCP_MINOR6	3
90 
91 #ifndef	_IPADDR_T
92 #define	_IPADDR_T
93 typedef uint32_t ipaddr_t;
94 #endif
95 
96 /* Number of bits in an address */
97 #define	IP_ABITS		32
98 #define	IPV6_ABITS		128
99 
100 #define	IP_HOST_MASK		(ipaddr_t)0xffffffffU
101 
102 #define	IP_CSUM(mp, off, sum)		(~ip_cksum(mp, off, sum) & 0xFFFF)
103 #define	IP_CSUM_PARTIAL(mp, off, sum)	ip_cksum(mp, off, sum)
104 #define	IP_BCSUM_PARTIAL(bp, len, sum)	bcksum(bp, len, sum)
105 #define	IP_MD_CSUM(pd, off, sum)	(~ip_md_cksum(pd, off, sum) & 0xffff)
106 #define	IP_MD_CSUM_PARTIAL(pd, off, sum) ip_md_cksum(pd, off, sum)
107 
108 /*
109  * Flag to IP write side to indicate that the appln has sent in a pre-built
110  * IP header. Stored in ipha_ident (which is otherwise zero).
111  */
112 #define	IP_HDR_INCLUDED			0xFFFF
113 
114 #define	ILL_FRAG_HASH_TBL_COUNT	((unsigned int)64)
115 #define	ILL_FRAG_HASH_TBL_SIZE	(ILL_FRAG_HASH_TBL_COUNT * sizeof (ipfb_t))
116 
117 #define	IPV4_ADDR_LEN			4
118 #define	IP_ADDR_LEN			IPV4_ADDR_LEN
119 #define	IP_ARP_PROTO_TYPE		0x0800
120 
121 #define	IPV4_VERSION			4
122 #define	IP_VERSION			IPV4_VERSION
123 #define	IP_SIMPLE_HDR_LENGTH_IN_WORDS	5
124 #define	IP_SIMPLE_HDR_LENGTH		20
125 #define	IP_MAX_HDR_LENGTH		60
126 
127 #define	IP_MIN_MTU			(IP_MAX_HDR_LENGTH + 8)	/* 68 bytes */
128 
129 /*
130  * XXX IP_MAXPACKET is defined in <netinet/ip.h> as well. At some point the
131  * 2 files should be cleaned up to remove all redundant definitions.
132  */
133 #define	IP_MAXPACKET			65535
134 #define	IP_SIMPLE_HDR_VERSION \
135 	((IP_VERSION << 4) | IP_SIMPLE_HDR_LENGTH_IN_WORDS)
136 
137 /*
138  * Constants and type definitions to support IP IOCTL commands
139  */
140 #define	IP_IOCTL			(('i'<<8)|'p')
141 #define	IP_IOC_IRE_DELETE		4
142 #define	IP_IOC_IRE_DELETE_NO_REPLY	5
143 #define	IP_IOC_IRE_ADVISE_NO_REPLY	6
144 #define	IP_IOC_RTS_REQUEST		7
145 
146 /* Common definitions used by IP IOCTL data structures */
147 typedef struct ipllcmd_s {
148 	uint_t	ipllc_cmd;
149 	uint_t	ipllc_name_offset;
150 	uint_t	ipllc_name_length;
151 } ipllc_t;
152 
153 /* IP IRE Change Command Structure. */
154 typedef struct ipic_s {
155 	ipllc_t	ipic_ipllc;
156 	uint_t	ipic_ire_type;
157 	uint_t	ipic_max_frag;
158 	uint_t	ipic_addr_offset;
159 	uint_t	ipic_addr_length;
160 	uint_t	ipic_mask_offset;
161 	uint_t	ipic_mask_length;
162 	uint_t	ipic_src_addr_offset;
163 	uint_t	ipic_src_addr_length;
164 	uint_t	ipic_ll_hdr_offset;
165 	uint_t	ipic_ll_hdr_length;
166 	uint_t	ipic_gateway_addr_offset;
167 	uint_t	ipic_gateway_addr_length;
168 	clock_t	ipic_rtt;
169 	uint32_t ipic_ssthresh;
170 	clock_t	ipic_rtt_sd;
171 	uchar_t ipic_ire_marks;
172 } ipic_t;
173 
174 #define	ipic_cmd		ipic_ipllc.ipllc_cmd
175 #define	ipic_ll_name_length	ipic_ipllc.ipllc_name_length
176 #define	ipic_ll_name_offset	ipic_ipllc.ipllc_name_offset
177 
178 /* IP IRE Delete Command Structure. */
179 typedef struct ipid_s {
180 	ipllc_t	ipid_ipllc;
181 	uint_t	ipid_ire_type;
182 	uint_t	ipid_addr_offset;
183 	uint_t	ipid_addr_length;
184 	uint_t	ipid_mask_offset;
185 	uint_t	ipid_mask_length;
186 } ipid_t;
187 
188 #define	ipid_cmd		ipid_ipllc.ipllc_cmd
189 
190 #ifdef _KERNEL
191 /*
192  * Temporary state for ip options parser.
193  */
194 typedef struct ipoptp_s
195 {
196 	uint8_t		*ipoptp_next;	/* next option to look at */
197 	uint8_t		*ipoptp_end;	/* end of options */
198 	uint8_t		*ipoptp_cur;	/* start of current option */
199 	uint8_t		ipoptp_len;	/* length of current option */
200 	uint32_t	ipoptp_flags;
201 } ipoptp_t;
202 
203 /*
204  * Flag(s) for ipoptp_flags
205  */
206 #define	IPOPTP_ERROR	0x00000001
207 #endif	/* _KERNEL */
208 
209 
210 /* Controls forwarding of IP packets, set via ndd */
211 #define	IP_FORWARD_NEVER	0
212 #define	IP_FORWARD_ALWAYS	1
213 
214 #define	WE_ARE_FORWARDING	(ip_g_forward == IP_FORWARD_ALWAYS)
215 
216 #define	IPH_HDR_LENGTH(ipha)						\
217 	((int)(((ipha_t *)ipha)->ipha_version_and_hdr_length & 0xF) << 2)
218 
219 #define	IPH_HDR_VERSION(ipha)						\
220 	((int)(((ipha_t *)ipha)->ipha_version_and_hdr_length) >> 4)
221 
222 #ifdef _KERNEL
223 /*
224  * IP reassembly macros.  We hide starting and ending offsets in b_next and
225  * b_prev of messages on the reassembly queue.	The messages are chained using
226  * b_cont.  These macros are used in ip_reassemble() so we don't have to see
227  * the ugly casts and assignments.
228  * Note that the offsets are <= 64k i.e. a uint_t is sufficient to represent
229  * them.
230  */
231 #define	IP_REASS_START(mp)		((uint_t)(uintptr_t)((mp)->b_next))
232 #define	IP_REASS_SET_START(mp, u)	\
233 	((mp)->b_next = (mblk_t *)(uintptr_t)(u))
234 #define	IP_REASS_END(mp)		((uint_t)(uintptr_t)((mp)->b_prev))
235 #define	IP_REASS_SET_END(mp, u)		\
236 	((mp)->b_prev = (mblk_t *)(uintptr_t)(u))
237 
238 #define	IP_REASS_COMPLETE	0x1
239 #define	IP_REASS_PARTIAL	0x2
240 #define	IP_REASS_FAILED		0x4
241 
242 /*
243  * Test to determine whether this is a module instance of IP or a
244  * driver instance of IP.
245  */
246 #define	CONN_Q(q)	(WR(q)->q_next == NULL)
247 
248 #define	Q_TO_CONN(q)	((conn_t *)(q)->q_ptr)
249 #define	Q_TO_TCP(q)	(Q_TO_CONN((q))->conn_tcp)
250 #define	Q_TO_UDP(q)	(Q_TO_CONN((q))->conn_udp)
251 
252 /*
253  * The following two macros are used by IP to get the appropriate
254  * wq and rq for a conn. If it is a TCP conn, then we need
255  * tcp_wq/tcp_rq else, conn_wq/conn_rq. IP can use conn_wq and conn_rq
256  * from a conn directly if it knows that the conn is not TCP.
257  */
258 #define	CONNP_TO_WQ(connp)	\
259 	(IPCL_IS_TCP(connp) ? (connp)->conn_tcp->tcp_wq : (connp)->conn_wq)
260 
261 #define	CONNP_TO_RQ(connp)	RD(CONNP_TO_WQ(connp))
262 
263 #define	GRAB_CONN_LOCK(q)	{				\
264 	if (q != NULL && CONN_Q(q))				\
265 		mutex_enter(&(Q_TO_CONN(q))->conn_lock);	\
266 }
267 
268 #define	RELEASE_CONN_LOCK(q)	{				\
269 	if (q != NULL && CONN_Q(q))				\
270 		mutex_exit(&(Q_TO_CONN(q))->conn_lock);		\
271 }
272 
273 /* "Congestion controlled" protocol */
274 #define	IP_FLOW_CONTROLLED_ULP(p)   ((p) == IPPROTO_TCP || (p) == IPPROTO_SCTP)
275 
276 /*
277  * Complete the pending operation. Usually an ioctl. Can also
278  * be a bind or option management request that got enqueued
279  * in an ipsq_t. Called on completion of the operation.
280  */
281 #define	CONN_OPER_PENDING_DONE(connp)	{			\
282 	mutex_enter(&(connp)->conn_lock);			\
283 	(connp)->conn_oper_pending_ill = NULL;			\
284 	cv_broadcast(&(connp)->conn_refcv);			\
285 	mutex_exit(&(connp)->conn_lock);			\
286 	CONN_DEC_REF(connp);					\
287 }
288 
289 /* Get the credential of an IP queue of unknown type */
290 #define	GET_QUEUE_CRED(wq)						\
291 	((wq)->q_next ? (((ill_t *)(wq)->q_ptr)->ill_credp) \
292 	    : ((Q_TO_CONN((wq)))->conn_cred))
293 
294 /*
295  * Flags for the various ip_fanout_* routines.
296  */
297 #define	IP_FF_SEND_ICMP		0x01	/* Send an ICMP error */
298 #define	IP_FF_HDR_COMPLETE	0x02	/* Call ip_hdr_complete if error */
299 #define	IP_FF_CKSUM		0x04	/* Recompute ipha_cksum if error */
300 #define	IP_FF_RAWIP		0x08	/* Use rawip mib variable */
301 #define	IP_FF_SRC_QUENCH	0x10	/* OK to send ICMP_SOURCE_QUENCH */
302 #define	IP_FF_SYN_ADDIRE	0x20	/* Add IRE if TCP syn packet */
303 #define	IP_FF_IP6INFO		0x80	/* Add ip6i_t if needed */
304 #define	IP_FF_SEND_SLLA		0x100	/* Send source link layer info ? */
305 #define	IPV6_REACHABILITY_CONFIRMATION	0x200	/* Flags for ip_xmit_v6 */
306 #define	IP_FF_NO_MCAST_LOOP	0x400	/* No multicasts for sending zone */
307 
308 /*
309  * Following flags are used by IPQoS to determine if policy processing is
310  * required.
311  */
312 #define	IP6_NO_IPPOLICY		0x800	/* Don't do IPQoS processing */
313 #define	IP6_IN_LLMCAST		0x1000	/* Multicast */
314 
315 #define	IP_FF_LOOPBACK		0x2000	/* Loopback fanout */
316 
317 #ifndef	IRE_DB_TYPE
318 #define	IRE_DB_TYPE	M_SIG
319 #endif
320 
321 #ifndef	IRE_DB_REQ_TYPE
322 #define	IRE_DB_REQ_TYPE	M_PCSIG
323 #endif
324 
325 /*
326  * Values for squeue switch:
327  */
328 
329 #define	IP_SQUEUE_ENTER_NODRAIN	1
330 #define	IP_SQUEUE_ENTER	2
331 /*
332  * This is part of the interface between Transport provider and
333  * IP which can be used to set policy information. This is usually
334  * accompanied with O_T_BIND_REQ/T_BIND_REQ.ip_bind assumes that
335  * only IPSEC_POLICY_SET is there when it is found in the chain.
336  * The information contained is an struct ipsec_req_t. On success
337  * or failure, either the T_BIND_ACK or the T_ERROR_ACK is returned.
338  * IPSEC_POLICY_SET is never returned.
339  */
340 #define	IPSEC_POLICY_SET	M_SETOPTS
341 
342 #define	IRE_IS_LOCAL(ire)	((ire != NULL) && \
343 				((ire)->ire_type & (IRE_LOCAL | IRE_LOOPBACK)))
344 
345 #define	IRE_IS_TARGET(ire)	((ire != NULL) && \
346 				((ire)->ire_type != IRE_BROADCAST))
347 
348 /* IP Fragmentation Reassembly Header */
349 typedef struct ipf_s {
350 	struct ipf_s	*ipf_hash_next;
351 	struct ipf_s	**ipf_ptphn;	/* Pointer to previous hash next. */
352 	uint32_t	ipf_ident;	/* Ident to match. */
353 	uint8_t		ipf_protocol;	/* Protocol to match. */
354 	uchar_t		ipf_last_frag_seen : 1;	/* Last fragment seen ? */
355 	time_t		ipf_timestamp;	/* Reassembly start time. */
356 	mblk_t		*ipf_mp;	/* mblk we live in. */
357 	mblk_t		*ipf_tail_mp;	/* Frag queue tail pointer. */
358 	int		ipf_hole_cnt;	/* Number of holes (hard-case). */
359 	int		ipf_end;	/* Tail end offset (0 -> hard-case). */
360 	uint_t		ipf_gen;	/* Frag queue generation */
361 	size_t		ipf_count;	/* Count of bytes used by frag */
362 	uint_t		ipf_nf_hdr_len; /* Length of nonfragmented header */
363 	in6_addr_t	ipf_v6src;	/* IPv6 source address */
364 	in6_addr_t	ipf_v6dst;	/* IPv6 dest address */
365 	uint_t		ipf_prev_nexthdr_offset; /* Offset for nexthdr value */
366 	uint8_t		ipf_ecn;	/* ECN info for the fragments */
367 	uint8_t		ipf_num_dups;	/* Number of times dup frags recvd */
368 	uint16_t	ipf_checksum_flags; /* Hardware checksum flags */
369 	uint32_t	ipf_checksum;	/* Partial checksum of fragment data */
370 } ipf_t;
371 
372 #define	ipf_src	V4_PART_OF_V6(ipf_v6src)
373 #define	ipf_dst	V4_PART_OF_V6(ipf_v6dst)
374 
375 typedef enum {
376 	IB_PKT =  0x01,
377 	OB_PKT = 0x02
378 } ip_pkt_t;
379 
380 #define	UPDATE_IB_PKT_COUNT(ire)\
381 	{ \
382 	(ire)->ire_ib_pkt_count++; \
383 	if ((ire)->ire_ipif != NULL) { \
384 		/* \
385 		 * forwarding packet \
386 		 */ \
387 		if ((ire)->ire_type & (IRE_LOCAL|IRE_BROADCAST)) \
388 			atomic_add_32(&(ire)->ire_ipif->ipif_ib_pkt_count, 1);\
389 		else \
390 			atomic_add_32(&(ire)->ire_ipif->ipif_fo_pkt_count, 1);\
391 	} \
392 	}
393 #define	UPDATE_OB_PKT_COUNT(ire)\
394 	{ \
395 	(ire)->ire_ob_pkt_count++;\
396 	if ((ire)->ire_ipif != NULL) { \
397 		atomic_add_32(&(ire)->ire_ipif->ipif_ob_pkt_count, 1); \
398 	} \
399 	}
400 
401 
402 #define	IP_RPUT_LOCAL(q, mp, ipha, ire, recv_ill) \
403 { \
404 	switch (ipha->ipha_protocol) { \
405 		case IPPROTO_UDP: \
406 			ip_udp_input(q, mp, ipha, ire, recv_ill); \
407 			break; \
408 		default: \
409 			ip_proto_input(q, mp, ipha, ire, recv_ill); \
410 			break; \
411 	} \
412 }
413 
414 
415 #endif /* _KERNEL */
416 
417 /* ICMP types */
418 #define	ICMP_ECHO_REPLY			0
419 #define	ICMP_DEST_UNREACHABLE		3
420 #define	ICMP_SOURCE_QUENCH		4
421 #define	ICMP_REDIRECT			5
422 #define	ICMP_ECHO_REQUEST		8
423 #define	ICMP_ROUTER_ADVERTISEMENT	9
424 #define	ICMP_ROUTER_SOLICITATION	10
425 #define	ICMP_TIME_EXCEEDED		11
426 #define	ICMP_PARAM_PROBLEM		12
427 #define	ICMP_TIME_STAMP_REQUEST		13
428 #define	ICMP_TIME_STAMP_REPLY		14
429 #define	ICMP_INFO_REQUEST		15
430 #define	ICMP_INFO_REPLY			16
431 #define	ICMP_ADDRESS_MASK_REQUEST	17
432 #define	ICMP_ADDRESS_MASK_REPLY		18
433 
434 /* ICMP_TIME_EXCEEDED codes */
435 #define	ICMP_TTL_EXCEEDED		0
436 #define	ICMP_REASSEMBLY_TIME_EXCEEDED	1
437 
438 /* ICMP_DEST_UNREACHABLE codes */
439 #define	ICMP_NET_UNREACHABLE		0
440 #define	ICMP_HOST_UNREACHABLE		1
441 #define	ICMP_PROTOCOL_UNREACHABLE	2
442 #define	ICMP_PORT_UNREACHABLE		3
443 #define	ICMP_FRAGMENTATION_NEEDED	4
444 #define	ICMP_SOURCE_ROUTE_FAILED	5
445 #define	ICMP_DEST_NET_UNKNOWN		6
446 #define	ICMP_DEST_HOST_UNKNOWN		7
447 #define	ICMP_SRC_HOST_ISOLATED		8
448 #define	ICMP_DEST_NET_UNREACH_ADMIN	9
449 #define	ICMP_DEST_HOST_UNREACH_ADMIN	10
450 #define	ICMP_DEST_NET_UNREACH_TOS	11
451 #define	ICMP_DEST_HOST_UNREACH_TOS	12
452 
453 /* ICMP Header Structure */
454 typedef struct icmph_s {
455 	uint8_t		icmph_type;
456 	uint8_t		icmph_code;
457 	uint16_t	icmph_checksum;
458 	union {
459 		struct { /* ECHO request/response structure */
460 			uint16_t	u_echo_ident;
461 			uint16_t	u_echo_seqnum;
462 		} u_echo;
463 		struct { /* Destination unreachable structure */
464 			uint16_t	u_du_zero;
465 			uint16_t	u_du_mtu;
466 		} u_du;
467 		struct { /* Parameter problem structure */
468 			uint8_t		u_pp_ptr;
469 			uint8_t		u_pp_rsvd[3];
470 		} u_pp;
471 		struct { /* Redirect structure */
472 			ipaddr_t	u_rd_gateway;
473 		} u_rd;
474 	} icmph_u;
475 } icmph_t;
476 
477 #define	icmph_echo_ident	icmph_u.u_echo.u_echo_ident
478 #define	icmph_echo_seqnum	icmph_u.u_echo.u_echo_seqnum
479 #define	icmph_du_zero		icmph_u.u_du.u_du_zero
480 #define	icmph_du_mtu		icmph_u.u_du.u_du_mtu
481 #define	icmph_pp_ptr		icmph_u.u_pp.u_pp_ptr
482 #define	icmph_rd_gateway	icmph_u.u_rd.u_rd_gateway
483 
484 #define	ICMPH_SIZE	8
485 
486 /*
487  * Minimum length of transport layer header included in an ICMP error
488  * message for it to be considered valid.
489  */
490 #define	ICMP_MIN_TP_HDR_LEN	8
491 
492 /* Aligned IP header */
493 typedef struct ipha_s {
494 	uint8_t		ipha_version_and_hdr_length;
495 	uint8_t		ipha_type_of_service;
496 	uint16_t	ipha_length;
497 	uint16_t	ipha_ident;
498 	uint16_t	ipha_fragment_offset_and_flags;
499 	uint8_t		ipha_ttl;
500 	uint8_t		ipha_protocol;
501 	uint16_t	ipha_hdr_checksum;
502 	ipaddr_t	ipha_src;
503 	ipaddr_t	ipha_dst;
504 } ipha_t;
505 
506 #define	IPH_DF		0x4000	/* Don't fragment */
507 #define	IPH_MF		0x2000	/* More fragments to come */
508 #define	IPH_OFFSET	0x1FFF	/* Where the offset lives */
509 #define	IPH_FRAG_HDR	0x8000	/* IPv6 don't fragment bit */
510 
511 /* ECN code points for IPv4 TOS byte and IPv6 traffic class octet. */
512 #define	IPH_ECN_NECT	0x0	/* Not ECN-Capabable Transport */
513 #define	IPH_ECN_ECT1	0x1	/* ECN-Capable Transport, ECT(1) */
514 #define	IPH_ECN_ECT0	0x2	/* ECN-Capable Transport, ECT(0) */
515 #define	IPH_ECN_CE	0x3	/* ECN-Congestion Experienced (CE) */
516 
517 /* IP Mac info structure */
518 typedef struct ip_m_s {
519 	t_uscalar_t	ip_m_mac_type;	/* From <sys/dlpi.h> */
520 	int		ip_m_type;	/* From <net/if_types.h> */
521 	boolean_t	(*ip_m_v4mapinfo)(uint_t, uint8_t *, uint8_t *,
522 			    uint32_t *, ipaddr_t *);
523 	boolean_t	(*ip_m_v6mapinfo)(uint_t, uint8_t *, uint8_t *,
524 			    uint32_t *, in6_addr_t *);
525 	boolean_t	(*ip_m_v6intfid)(uint_t, uint8_t *, in6_addr_t *);
526 } ip_m_t;
527 
528 /*
529  * The following functions attempt to reduce the link layer dependency
530  * of the IP stack. The current set of link specific operations are:
531  * a. map from IPv4 class D (224.0/4) multicast address range to the link
532  * layer multicast address range.
533  * b. map from IPv6 multicast address range (ff00::/8) to the link
534  * layer multicast address range.
535  * c. derive the default IPv6 interface identifier from the link layer
536  * address.
537  */
538 #define	MEDIA_V4MINFO(ip_m, plen, bphys, maddr, hwxp, v4ptr) \
539 	(((ip_m)->ip_m_v4mapinfo != NULL) && \
540 	(*(ip_m)->ip_m_v4mapinfo)(plen, bphys, maddr, hwxp, v4ptr))
541 #define	MEDIA_V6INTFID(ip_m, plen, phys, v6ptr) \
542 	(((ip_m)->ip_m_v6intfid != NULL) && \
543 	(*(ip_m)->ip_m_v6intfid)(plen, phys, v6ptr))
544 #define	MEDIA_V6MINFO(ip_m, plen, bphys, maddr, hwxp, v6ptr) \
545 	(((ip_m)->ip_m_v6mapinfo != NULL) && \
546 	(*(ip_m)->ip_m_v6mapinfo)(plen, bphys, maddr, hwxp, v6ptr))
547 
548 /* Router entry types */
549 #define	IRE_BROADCAST		0x0001	/* Route entry for broadcast address */
550 #define	IRE_DEFAULT		0x0002	/* Route entry for default gateway */
551 #define	IRE_LOCAL		0x0004	/* Route entry for local address */
552 #define	IRE_LOOPBACK		0x0008	/* Route entry for loopback address */
553 #define	IRE_PREFIX		0x0010	/* Route entry for prefix routes */
554 #define	IRE_CACHE		0x0020	/* Cached Route entry */
555 #define	IRE_IF_NORESOLVER	0x0040	/* Route entry for local interface */
556 					/* net without any address mapping. */
557 #define	IRE_IF_RESOLVER		0x0080	/* Route entry for local interface */
558 					/* net with resolver. */
559 #define	IRE_HOST		0x0100	/* Host route entry */
560 #define	IRE_HOST_REDIRECT	0x0200	/* Host route entry from redirects */
561 
562 /*
563  * IRE_MIPRTUN is only set on the ires in the ip_mrtun_table.
564  * This ire_type must not be set for ftable and ctable routing entries.
565  */
566 #define	IRE_MIPRTUN		0x0400	/* Reverse tunnel route entry */
567 
568 #define	IRE_INTERFACE		(IRE_IF_NORESOLVER | IRE_IF_RESOLVER)
569 #define	IRE_OFFSUBNET		(IRE_DEFAULT | IRE_PREFIX | IRE_HOST | \
570 				IRE_HOST_REDIRECT)
571 #define	IRE_CACHETABLE		(IRE_CACHE | IRE_BROADCAST | IRE_LOCAL | \
572 				IRE_LOOPBACK)
573 #define	IRE_FORWARDTABLE	(IRE_INTERFACE | IRE_OFFSUBNET)
574 
575 /*
576  * If an IRE is marked with IRE_MARK_CONDEMNED, the last walker of
577  * the bucket should delete this IRE from this bucket.
578  */
579 #define	IRE_MARK_CONDEMNED	0x0001
580 /*
581  * If a broadcast IRE is marked with IRE_MARK_NORECV, ip_rput will drop the
582  * broadcast packets received on that interface. This is marked only
583  * on broadcast ires. Employed by IPMP, where we have multiple NICs on the
584  * same subnet receiving the same broadcast packet.
585  */
586 #define	IRE_MARK_NORECV		0x0002
587 /*
588  * IRE_CACHE marked this way won't be returned by ire_cache_lookup. Need
589  * to look specifically using MATCH_IRE_MARK_HIDDEN. Used by IPMP.
590  */
591 #define	IRE_MARK_HIDDEN		0x0004	/* Typically Used by in.mpathd */
592 
593 /*
594  * ire with IRE_MARK_NOADD is  created in ip_newroute_ipif, when outgoing
595  * interface is specified by IP_XMIT_IF socket option. This ire is not
596  * added in IRE_CACHE.  For example, this is used by mipagent to prevent
597  * any entry to be added in the cache table. We do not want to add any
598  * entry for a mobile-node in the routing table for foreign agent originated
599  * packets. Adding routes in cache table in this case, may run the risks of
600  * incorrect routing path in case of private overlapping addresses.
601  */
602 #define	IRE_MARK_NOADD		0x0008	/* Mark not to add ire in cache */
603 
604 /*
605  * IRE marked with IRE_MARK_TEMPORARY means that this IRE has been used
606  * either for forwarding a packet or has not been used for sending
607  * traffic on TCP connections terminated on this system.  In both
608  * cases, this IRE is the first to go when IRE is being cleaned up.
609  */
610 #define	IRE_MARK_TEMPORARY	0x0010
611 
612 /*
613  * IRE marked with IRE_MARK_USESRC_CHECK means that while adding an IRE with
614  * this mark, additional atomic checks need to be performed. For eg: by the
615  * time an IRE_CACHE is created, sent up to ARP and then comes back to IP; the
616  * usesrc grouping could have changed in which case we want to fail adding
617  * the IRE_CACHE entry
618  */
619 #define	IRE_MARK_USESRC_CHECK	0x0020
620 
621 /* Flags with ire_expire routine */
622 #define	FLUSH_ARP_TIME		0x0001	/* ARP info potentially stale timer */
623 #define	FLUSH_REDIRECT_TIME	0x0002	/* Redirects potentially stale */
624 #define	FLUSH_MTU_TIME		0x0004	/* Include path MTU per RFC 1191 */
625 
626 /* Arguments to ire_flush_cache() */
627 #define	IRE_FLUSH_DELETE	0
628 #define	IRE_FLUSH_ADD		1
629 
630 /*
631  * Open/close synchronization flags.
632  * These are kept in a separate field in the conn and the synchronization
633  * depends on the atomic 32 bit access to that field.
634  */
635 #define	CONN_CLOSING		0x01	/* ip_close waiting for ip_wsrv */
636 #define	CONN_IPSEC_LOAD_WAIT	0x02	/* waiting for load */
637 #define	CONN_CONDEMNED		0x04	/* conn is closing, no more refs */
638 #define	CONN_INCIPIENT		0x08	/* conn not yet visible, no refs */
639 #define	CONN_QUIESCED		0x10	/* conn is now quiescent */
640 
641 /*
642  * Parameter to ip_output giving the identity of the caller.
643  * IP_WSRV means the packet was enqueued in the STREAMS queue
644  * due to flow control and is now being reprocessed in the context of
645  * the STREAMS service procedure, consequent to flow control relief.
646  * IRE_SEND means the packet is being reprocessed consequent to an
647  * ire cache creation and addition and this may or may not be happening
648  * in the service procedure context. Anything other than the above 2
649  * cases is identified as IP_WPUT. Most commonly this is the case of
650  * packets coming down from the application.
651  */
652 #ifdef _KERNEL
653 #define	IP_WSRV			1	/* Called from ip_wsrv */
654 #define	IP_WPUT			2	/* Called from ip_wput */
655 #define	IRE_SEND		3	/* Called from ire_send */
656 
657 /*
658  * Extra structures need for per-src-addr filtering (IGMPv3/MLDv2)
659  */
660 #define	MAX_FILTER_SIZE	64
661 
662 typedef struct slist_s {
663 	int		sl_numsrc;
664 	in6_addr_t	sl_addr[MAX_FILTER_SIZE];
665 } slist_t;
666 
667 /*
668  * Following struct is used to maintain retransmission state for
669  * a multicast group.  One rtx_state_t struct is an in-line field
670  * of the ilm_t struct; the slist_ts in the rtx_state_t struct are
671  * alloc'd as needed.
672  */
673 typedef struct rtx_state_s {
674 	uint_t		rtx_timer;	/* retrans timer */
675 	int		rtx_cnt;	/* retrans count */
676 	int		rtx_fmode_cnt;	/* retrans count for fmode change */
677 	slist_t		*rtx_allow;
678 	slist_t		*rtx_block;
679 } rtx_state_t;
680 
681 /*
682  * Used to construct list of multicast address records that will be
683  * sent in a single listener report.
684  */
685 typedef struct mrec_s {
686 	struct mrec_s	*mrec_next;
687 	uint8_t		mrec_type;
688 	uint8_t		mrec_auxlen;	/* currently unused */
689 	in6_addr_t	mrec_group;
690 	slist_t		mrec_srcs;
691 } mrec_t;
692 
693 /* Group membership list per upper conn */
694 /*
695  * XXX add ilg info for ifaddr/ifindex.
696  * XXX can we make ilg survive an ifconfig unplumb + plumb
697  * by setting the ipif/ill to NULL and recover that later?
698  *
699  * ilg_ipif is used by IPv4 as multicast groups are joined using an interface
700  * address (ipif).
701  * ilg_ill is used by IPv6 as multicast groups are joined using an interface
702  * index (phyint->phyint_ifindex).
703  * ilg_ill is NULL for IPv4 and ilg_ipif is NULL for IPv6.
704  *
705  * ilg records the state of multicast memberships of a socket end point.
706  * ilm records the state of multicast memberships with the driver and is
707  * maintained per interface.
708  *
709  * Notes :
710  *
711  * 1) There is no direct link between a given ilg and ilm. If the
712  *    application has joined a group G with ifindex I, we will have
713  *    an ilg with ilg_v6group and ilg_ill. There will be a corresponding
714  *    ilm with ilm_ill/ilm_v6addr recording the multicast membership.
715  *    To delete the membership,
716  *
717  *		a) Search for ilg matching on G and I with ilg_v6group
718  *		   and ilg_ill. Delete ilg_ill.
719  *		b) Search the corresponding ilm matching on G and I with
720  *		   ilm_v6addr and ilm_ill. Delete ilm.
721  *
722  *    In IPv4, the only difference is, we look using ipifs instead of
723  *    ills.
724  *
725  * 2) With IP multipathing, we want to keep receiving even after the
726  *    interface has failed. We do this by moving multicast memberships
727  *    to a new_ill within the group. This is acheived by sending
728  *    DL_DISABMULTI_REQS on ilg_ill/ilm_ill and sending DL_ENABMULTIREQS
729  *    on the new_ill and changing ilg_ill/ilm_ill to new_ill. But, we
730  *    need to be able to delete memberships which will still come down
731  *    with the ifindex of the old ill which is what the application
732  *    knows of. Thus we store the ilm_/ilg_orig_ifindex to keep track
733  *    of where we joined initially so that we can lookup even after we
734  *    moved the membership. It is also used for moving back the membership
735  *    when the old ill has been repaired. This is done by looking up for
736  *    ilms with ilm_orig_ifindex matching on the old ill's ifindex. Only
737  *    ilms actually move from old ill to new ill. ilgs don't move (just
738  *    the ilg_ill is changed when it moves) as it just records the state
739  *    of the application that has joined a group G where as ilm records
740  *    the state joined with the driver. Thus when we send DL_XXXMULTI_REQs
741  *    we also need to keep the ilm in the right ill.
742  *
743  *    In IPv4, as ipifs move from old ill to new_ill, ilgs and ilms move
744  *    implicitly as we use only ipifs in IPv4. Thus, one can always lookup
745  *    a given ilm/ilg even after it fails without the support of
746  *    orig_ifindex. We move ilms still to record the driver state as
747  *    mentioned above.
748  */
749 
750 /*
751  * The ilg_t and ilm_t members are protected by ipsq. They can be changed only
752  * by a thread executing in the ipsq. In other words add/delete of a
753  * multicast group has to execute in the ipsq.
754  */
755 #define	ILG_DELETED	0x1		/* ilg_flags */
756 typedef struct ilg_s {
757 	in6_addr_t	ilg_v6group;
758 	struct ipif_s	*ilg_ipif;	/* Logical interface we are member on */
759 	struct ill_s	*ilg_ill;	/* Used by IPv6 */
760 	int		ilg_orig_ifindex; /* Interface originally joined on */
761 	uint_t		ilg_flags;
762 	mcast_record_t	ilg_fmode;	/* MODE_IS_INCLUDE/MODE_IS_EXCLUDE */
763 	slist_t		*ilg_filter;
764 } ilg_t;
765 
766 
767 /*
768  * Multicast address list entry for lower ill.
769  * ilm_ipif is used by IPv4 as multicast groups are joined using ipif.
770  * ilm_ill is used by IPv6 as multicast groups are joined using ill.
771  * ilm_ill is NULL for IPv4 and ilm_ipif is NULL for IPv6.
772  */
773 #define	ILM_DELETED	0x1		/* ilm_flags */
774 typedef struct ilm_s {
775 	in6_addr_t	ilm_v6addr;
776 	int		ilm_refcnt;
777 	uint_t		ilm_timer;	/* IGMP/MLD query resp timer, in msec */
778 	struct ipif_s	*ilm_ipif;	/* Back pointer to ipif for IPv4 */
779 	struct ilm_s	*ilm_next;	/* Linked list for each ill */
780 	uint_t		ilm_state;	/* state of the membership */
781 	struct ill_s	*ilm_ill;	/* Back pointer to ill for IPv6 */
782 	int		ilm_orig_ifindex;  /* V6_MULTICAST_IF/ilm_ipif index */
783 	uint_t		ilm_flags;
784 	boolean_t	ilm_is_new;	/* new ilm */
785 	boolean_t	ilm_notify_driver; /* Need to notify the driver */
786 	zoneid_t	ilm_zoneid;
787 	int		ilm_no_ilg_cnt;	/* number of joins w/ no ilg */
788 	mcast_record_t	ilm_fmode;	/* MODE_IS_INCLUDE/MODE_IS_EXCLUDE */
789 	slist_t		*ilm_filter;	/* source filter list */
790 	slist_t		*ilm_pendsrcs;	/* relevant src addrs for pending req */
791 	rtx_state_t	ilm_rtx;	/* SCR retransmission state */
792 } ilm_t;
793 
794 #define	ilm_addr	V4_PART_OF_V6(ilm_v6addr)
795 
796 /*
797  * ilm_walker_cleanup needs to execute when the ilm_walker_cnt goes down to
798  * zero. In addition it needs to block new walkers while it is unlinking ilm's
799  * from the list. Thus simple atomics for the ill_ilm_walker_cnt don't suffice.
800  */
801 #define	ILM_WALKER_HOLD(ill)    {               \
802 	mutex_enter(&(ill)->ill_lock);          \
803 	ill->ill_ilm_walker_cnt++;              \
804 	mutex_exit(&(ill)->ill_lock);           \
805 }
806 
807 #define	ILM_WALKER_RELE(ill)	{ 		\
808 	mutex_enter(&(ill)->ill_lock);		\
809 	(ill)->ill_ilm_walker_cnt--;		\
810 	if ((ill)->ill_ilm_walker_cnt == 0 && (ill)->ill_ilm_cleanup_reqd) \
811 		ilm_walker_cleanup(ill);	\
812 	mutex_exit(&(ill)->ill_lock);		\
813 }
814 
815 /*
816  * Soft reference to an IPsec SA.
817  *
818  * On relative terms, conn's can be persistant (living as long as the
819  * processes which create them), while SA's are ephemeral (dying when
820  * they hit their time-based or byte-based lifetimes).
821  *
822  * We could hold a hard reference to an SA from an ipsec_latch_t,
823  * but this would cause expired SA's to linger for a potentially
824  * unbounded time.
825  *
826  * Instead, we remember the hash bucket number and bucket generation
827  * in addition to the pointer.  The bucket generation is incremented on
828  * each deletion.
829  */
830 typedef struct ipsa_ref_s
831 {
832 	struct ipsa_s	*ipsr_sa;
833 	struct isaf_s	*ipsr_bucket;
834 	uint64_t	ipsr_gen;
835 } ipsa_ref_t;
836 
837 /*
838  * IPsec "latching" state.
839  *
840  * In the presence of IPsec policy, fully-bound conn's bind a connection
841  * to more than just the 5-tuple, but also a specific IPsec action and
842  * identity-pair.
843  *
844  * As an optimization, we also cache soft references to IPsec SA's
845  * here so that we can fast-path around most of the work needed for
846  * outbound IPsec SA selection.
847  *
848  * Were it not for TCP's detached connections, this state would be
849  * in-line in conn_t; instead, this is in a separate structure so it
850  * can be handed off to TCP when a connection is detached.
851  */
852 typedef struct ipsec_latch_s
853 {
854 	kmutex_t	ipl_lock;
855 	uint32_t	ipl_refcnt;
856 
857 	uint64_t	ipl_unique;
858 	struct ipsec_policy_s	*ipl_in_policy; /* latched policy (in) */
859 	struct ipsec_policy_s	*ipl_out_policy; /* latched policy (out) */
860 	struct ipsec_action_s	*ipl_in_action;	/* latched action (in) */
861 	struct ipsec_action_s	*ipl_out_action; /* latched action (out) */
862 	cred_t		*ipl_local_id;
863 	struct ipsid_s	*ipl_local_cid;
864 	struct ipsid_s	*ipl_remote_cid;
865 	unsigned int
866 			ipl_out_action_latched : 1,
867 			ipl_in_action_latched : 1,
868 			ipl_out_policy_latched : 1,
869 			ipl_in_policy_latched : 1,
870 
871 			ipl_ids_latched : 1,
872 
873 			ipl_pad_to_bit_31 : 27;
874 
875 	ipsa_ref_t	ipl_ref[2]; /* 0: ESP, 1: AH */
876 
877 } ipsec_latch_t;
878 
879 #define	IPLATCH_REFHOLD(ipl) { \
880 	atomic_add_32(&(ipl)->ipl_refcnt, 1);		\
881 	ASSERT((ipl)->ipl_refcnt != 0);			\
882 }
883 
884 #define	IPLATCH_REFRELE(ipl) {					\
885 	ASSERT((ipl)->ipl_refcnt != 0);				\
886 	membar_exit();						\
887 	if (atomic_add_32_nv(&(ipl)->ipl_refcnt, -1) == 0)	\
888 		iplatch_free(ipl);				\
889 }
890 
891 /*
892  * peer identity structure.
893  */
894 
895 typedef struct conn_s conn_t;
896 
897 /*
898  * The old IP client structure "ipc_t" is gone. All the data is stored in the
899  * connection structure "conn_t" now. The mapping of old and new fields looks
900  * like this:
901  *
902  * ipc_ulp			conn_ulp
903  * ipc_rq			conn_rq
904  * ipc_wq			conn_wq
905  *
906  * ipc_laddr			conn_src
907  * ipc_faddr			conn_rem
908  * ipc_v6laddr			conn_srcv6
909  * ipc_v6faddr			conn_remv6
910  *
911  * ipc_lport			conn_lport
912  * ipc_fport			conn_fport
913  * ipc_ports			conn_ports
914  *
915  * ipc_policy			conn_policy
916  * ipc_latch			conn_latch
917  *
918  * ipc_irc_lock			conn_lock
919  * ipc_ire_cache		conn_ire_cache
920  *
921  * ipc_state_flags		conn_state_flags
922  * ipc_outgoing_ill		conn_outgoing_ill
923  *
924  * ipc_dontroute 		conn_dontroute
925  * ipc_loopback 		conn_loopback
926  * ipc_broadcast		conn_broadcast
927  * ipc_reuseaddr		conn_reuseaddr
928  *
929  * ipc_multicast_loop		conn_multicast_loop
930  * ipc_multi_router		conn_multi_router
931  * ipc_priv_stream 		conn_priv_stream
932  * ipc_draining 		conn_draining
933  *
934  * ipc_did_putbq		conn_did_putbq
935  * ipc_unspec_src		conn_unspec_src
936  * ipc_policy_cached		conn_policy_cached
937  *
938  * ipc_in_enforce_policy 	conn_in_enforce_policy
939  * ipc_out_enforce_policy 	conn_out_enforce_policy
940  * ipc_af_isv6			conn_af_isv6
941  * ipc_pkt_isv6			conn_pkt_isv6
942  *
943  * ipc_ipv6_recvpktinfo		conn_ipv6_recvpktinfo
944  *
945  * ipc_ipv6_recvhoplimit	conn_ipv6_recvhoplimit
946  * ipc_ipv6_recvhopopts		conn_ipv6_recvhopopts
947  * ipc_ipv6_recvdstopts		conn_ipv6_recvdstopts
948  *
949  * ipc_ipv6_recvrthdr 		conn_ipv6_recvrthdr
950  * ipc_ipv6_recvrtdstopts	conn_ipv6_recvrtdstopts
951  * ipc_fully_bound		conn_fully_bound
952  *
953  * ipc_recvif			conn_recvif
954  *
955  * ipc_recvslla 		conn_recvslla
956  * ipc_acking_unbind 		conn_acking_unbind
957  * ipc_pad_to_bit_31 		conn_pad_to_bit_31
958  *
959  * ipc_xmit_if_ill		conn_xmit_if_ill
960  * ipc_nofailover_ill		conn_nofailover_ill
961  *
962  * ipc_proto			conn_proto
963  * ipc_incoming_ill		conn_incoming_ill
964  * ipc_outgoing_pill		conn_outgoing_pill
965  * ipc_pending_ill		conn_pending_ill
966  * ipc_unbind_mp		conn_unbind_mp
967  * ipc_ilg			conn_ilg
968  * ipc_ilg_allocated		conn_ilg_allocated
969  * ipc_ilg_inuse		conn_ilg_inuse
970  * ipc_ilg_walker_cnt		conn_ilg_walker_cnt
971  * ipc_refcv			conn_refcv
972  * ipc_multicast_ipif		conn_multicast_ipif
973  * ipc_multicast_ill		conn_multicast_ill
974  * ipc_orig_bound_ifindex	conn_orig_bound_ifindex
975  * ipc_orig_multicast_ifindex	conn_orig_multicast_ifindex
976  * ipc_orig_xmit_ifindex	conn_orig_xmit_ifindex
977  * ipc_drain_next		conn_drain_next
978  * ipc_drain_prev		conn_drain_prev
979  * ipc_idl			conn_idl
980  */
981 
982 /*
983  * This is used to match an inbound/outbound datagram with
984  * policy.
985  */
986 
987 typedef	struct ipsec_selector {
988 	in6_addr_t	ips_local_addr_v6;
989 	in6_addr_t	ips_remote_addr_v6;
990 	uint16_t	ips_local_port;
991 	uint16_t	ips_remote_port;
992 	uint8_t		ips_icmp_type;
993 	uint8_t		ips_icmp_code;
994 	uint8_t		ips_protocol;
995 	uint8_t		ips_isv4 : 1,
996 			ips_is_icmp_inv_acq: 1;
997 } ipsec_selector_t;
998 
999 /*
1000  * Note that we put v4 addresses in the *first* 32-bit word of the
1001  * selector rather than the last to simplify the prefix match/mask code
1002  * in spd.c
1003  */
1004 #define	ips_local_addr_v4 ips_local_addr_v6.s6_addr32[0]
1005 #define	ips_remote_addr_v4 ips_remote_addr_v6.s6_addr32[0]
1006 
1007 /* Values used in IP by IPSEC Code */
1008 #define		IPSEC_OUTBOUND		B_TRUE
1009 #define		IPSEC_INBOUND		B_FALSE
1010 
1011 /*
1012  * There are two variants in policy failures. The packet may come in
1013  * secure when not needed (IPSEC_POLICY_???_NOT_NEEDED) or it may not
1014  * have the desired level of protection (IPSEC_POLICY_MISMATCH).
1015  */
1016 #define	IPSEC_POLICY_NOT_NEEDED		0
1017 #define	IPSEC_POLICY_MISMATCH		1
1018 #define	IPSEC_POLICY_AUTH_NOT_NEEDED	2
1019 #define	IPSEC_POLICY_ENCR_NOT_NEEDED	3
1020 #define	IPSEC_POLICY_SE_NOT_NEEDED	4
1021 #define	IPSEC_POLICY_MAX		5	/* Always max + 1. */
1022 
1023 /*
1024  * Folowing macro is used whenever the code does not know whether there
1025  * is a M_CTL present in the front and it needs to examine the actual mp
1026  * i.e the IP header. As a M_CTL message could be in the front, this
1027  * extracts the packet into mp and the M_CTL mp into first_mp. If M_CTL
1028  * mp is not present, both first_mp and mp point to the same message.
1029  */
1030 #define	EXTRACT_PKT_MP(mp, first_mp, mctl_present)	\
1031 	(first_mp) = (mp);				\
1032 	if ((mp)->b_datap->db_type == M_CTL) {		\
1033 		(mp) = (mp)->b_cont;			\
1034 		(mctl_present) = B_TRUE;		\
1035 	} else {					\
1036 		(mctl_present) = B_FALSE;		\
1037 	}
1038 
1039 /*
1040  * Check with IPSEC inbound policy if
1041  *
1042  * 1) per-socket policy is present - indicated by conn_in_enforce_policy.
1043  * 2) Or if we have not cached policy on the conn and the global policy is
1044  *    non-empty.
1045  */
1046 #define	CONN_INBOUND_POLICY_PRESENT(connp)	\
1047 	((connp)->conn_in_enforce_policy ||	\
1048 	(!((connp)->conn_policy_cached) &&	\
1049 	ipsec_inbound_v4_policy_present))
1050 
1051 #define	CONN_INBOUND_POLICY_PRESENT_V6(connp)	\
1052 	((connp)->conn_in_enforce_policy ||	\
1053 	(!(connp)->conn_policy_cached &&	\
1054 	ipsec_inbound_v6_policy_present))
1055 
1056 #define	CONN_OUTBOUND_POLICY_PRESENT(connp)	\
1057 	((connp)->conn_out_enforce_policy ||	\
1058 	(!((connp)->conn_policy_cached) &&	\
1059 	ipsec_outbound_v4_policy_present))
1060 
1061 #define	CONN_OUTBOUND_POLICY_PRESENT_V6(connp)	\
1062 	((connp)->conn_out_enforce_policy ||	\
1063 	(!(connp)->conn_policy_cached &&	\
1064 	ipsec_outbound_v6_policy_present))
1065 
1066 /*
1067  * Information cached in IRE for upper layer protocol (ULP).
1068  *
1069  * Notice that ire_max_frag is not included in the iulp_t structure, which
1070  * it may seem that it should.  But ire_max_frag cannot really be cached.  It
1071  * is fixed for each interface.  For MTU found by PMTUd, we may want to cache
1072  * it.  But currently, we do not do that.
1073  */
1074 typedef struct iulp_s {
1075 	boolean_t	iulp_set;	/* Is any metric set? */
1076 	uint32_t	iulp_ssthresh;	/* Slow start threshold (TCP). */
1077 	clock_t		iulp_rtt;	/* Guestimate in millisecs. */
1078 	clock_t		iulp_rtt_sd;	/* Cached value of RTT variance. */
1079 	uint32_t	iulp_spipe;	/* Send pipe size. */
1080 	uint32_t	iulp_rpipe;	/* Receive pipe size. */
1081 	uint32_t	iulp_rtomax;	/* Max round trip timeout. */
1082 	uint32_t	iulp_sack;	/* Use SACK option (TCP)? */
1083 	uint32_t
1084 		iulp_tstamp_ok : 1,	/* Use timestamp option (TCP)? */
1085 		iulp_wscale_ok : 1,	/* Use window scale option (TCP)? */
1086 		iulp_ecn_ok : 1,	/* Enable ECN (for TCP)? */
1087 		iulp_pmtud_ok : 1,	/* Enable PMTUd? */
1088 
1089 		iulp_not_used : 28;
1090 } iulp_t;
1091 
1092 /* Zero iulp_t. */
1093 extern const iulp_t ire_uinfo_null;
1094 
1095 /*
1096  * The conn drain list structure.
1097  * The list is protected by idl_lock. Each conn_t inserted in the list
1098  * points back at this idl_t using conn_idl. IP primes the draining of the
1099  * conns queued in these lists, by qenabling the 1st conn of each list. This
1100  * occurs when STREAMS backenables ip_wsrv on the IP module. Each conn instance
1101  * of ip_wsrv successively qenables the next conn in the list.
1102  * idl_lock protects all other members of idl_t and conn_drain_next
1103  * and conn_drain_prev of conn_t. The conn_lock protects IPCF_DRAIN_DISABLED
1104  * flag of the conn_t and conn_idl.
1105  */
1106 typedef struct idl_s {
1107 	conn_t		*idl_conn;		/* Head of drain list */
1108 	kmutex_t	idl_lock;		/* Lock for this list */
1109 	conn_t		*idl_conn_draining;	/* conn that is draining */
1110 	uint32_t
1111 		idl_repeat : 1,			/* Last conn must re-enable */
1112 						/* drain list again */
1113 		idl_unused : 31;
1114 } idl_t;
1115 
1116 #define	CONN_DRAIN_LIST_LOCK(connp)	(&((connp)->conn_idl->idl_lock))
1117 /*
1118  * Interface route structure which holds the necessary information to recreate
1119  * routes that are tied to an interface (namely where ire_ipif != NULL).
1120  * These routes which were initially created via a routing socket or via the
1121  * SIOCADDRT ioctl may be gateway routes (RTF_GATEWAY being set) or may be
1122  * traditional interface routes.  When an interface comes back up after being
1123  * marked down, this information will be used to recreate the routes.  These
1124  * are part of an mblk_t chain that hangs off of the IPIF (ipif_saved_ire_mp).
1125  */
1126 typedef struct ifrt_s {
1127 	ushort_t	ifrt_type;		/* Type of IRE */
1128 	in6_addr_t	ifrt_v6addr;		/* Address IRE represents. */
1129 	in6_addr_t	ifrt_v6gateway_addr;	/* Gateway if IRE_OFFSUBNET */
1130 	in6_addr_t	ifrt_v6src_addr;	/* Src addr if RTF_SETSRC */
1131 	in6_addr_t	ifrt_v6mask;		/* Mask for matching IRE. */
1132 	uint32_t	ifrt_flags;		/* flags related to route */
1133 	uint_t		ifrt_max_frag;		/* MTU (next hop or path). */
1134 	iulp_t		ifrt_iulp_info;		/* Cached IRE ULP info. */
1135 } ifrt_t;
1136 
1137 #define	ifrt_addr		V4_PART_OF_V6(ifrt_v6addr)
1138 #define	ifrt_gateway_addr	V4_PART_OF_V6(ifrt_v6gateway_addr)
1139 #define	ifrt_src_addr		V4_PART_OF_V6(ifrt_v6src_addr)
1140 #define	ifrt_mask		V4_PART_OF_V6(ifrt_v6mask)
1141 
1142 /* Number of IP addresses that can be hosted on a physical interface */
1143 #define	MAX_ADDRS_PER_IF	8192
1144 /*
1145  * Number of Source addresses to be considered for source address
1146  * selection. Used by ipif_select_source[_v6].
1147  */
1148 #define	MAX_IPIF_SELECT_SOURCE	50
1149 
1150 #ifdef IP_DEBUG
1151 /*
1152  * Tracing refholds and refreleases for debugging. Existing tracing mechanisms
1153  * do not allow the granularity need to trace refrences to ipif/ill/ire's. This
1154  * mechanism should be revisited once dtrace is available.
1155  */
1156 #define	IP_STACK_DEPTH	15
1157 typedef struct tr_buf_s {
1158 	int	tr_depth;
1159 	pc_t	tr_stack[IP_STACK_DEPTH];
1160 } tr_buf_t;
1161 
1162 typedef struct th_trace_s {
1163 	struct	th_trace_s *th_next;
1164 	struct	th_trace_s **th_prev;
1165 	kthread_t	*th_id;
1166 	int	th_refcnt;
1167 	uint_t	th_trace_lastref;
1168 #define	TR_BUF_MAX	38
1169 	tr_buf_t th_trbuf[TR_BUF_MAX];
1170 } th_trace_t;
1171 #endif
1172 
1173 /* The following are ipif_state_flags */
1174 #define	IPIF_CONDEMNED		0x1	/* The ipif is being removed */
1175 #define	IPIF_CHANGING		0x2	/* A critcal ipif field is changing */
1176 #define	IPIF_MOVING		0x8	/* The ipif is being moved */
1177 #define	IPIF_SET_LINKLOCAL	0x10	/* transient flag during bringup */
1178 #define	IPIF_ZERO_SOURCE	0x20	/* transient flag during bringup */
1179 
1180 /* IP interface structure, one per local address */
1181 typedef struct ipif_s {
1182 	struct	ipif_s	*ipif_next;
1183 	struct	ill_s	*ipif_ill;	/* Back pointer to our ill */
1184 	int	ipif_id;		/* Logical unit number */
1185 	uint_t	ipif_mtu;		/* Starts at ipif_ill->ill_max_frag */
1186 	uint_t	ipif_saved_mtu;		/* Save of mtu during ipif_move() */
1187 	in6_addr_t ipif_v6lcl_addr;	/* Local IP address for this if. */
1188 	in6_addr_t ipif_v6src_addr;	/* Source IP address for this if. */
1189 	in6_addr_t ipif_v6subnet;	/* Subnet prefix for this if. */
1190 	in6_addr_t ipif_v6net_mask;	/* Net mask for this interface. */
1191 	in6_addr_t ipif_v6brd_addr;	/* Broadcast addr for this interface. */
1192 	in6_addr_t ipif_v6pp_dst_addr;	/* Point-to-point dest address. */
1193 	uint64_t ipif_flags;		/* Interface flags. */
1194 	uint_t	ipif_metric;		/* BSD if metric, for compatibility. */
1195 	uint_t	ipif_ire_type;		/* IRE_LOCAL or IRE_LOOPBACK */
1196 	mblk_t	*ipif_arp_del_mp;	/* Allocated at time arp comes up, to */
1197 					/* prevent awkward out of mem */
1198 					/* condition later */
1199 	mblk_t	*ipif_saved_ire_mp;	/* Allocated for each extra */
1200 					/* IRE_IF_NORESOLVER/IRE_IF_RESOLVER */
1201 					/* on this interface so that they */
1202 					/* can survive ifconfig down. */
1203 	kmutex_t ipif_saved_ire_lock;	/* Protects ipif_saved_ire_mp */
1204 
1205 	mrec_t	*ipif_igmp_rpt;		/* List of group memberships which */
1206 					/* will be reported on.  Used when */
1207 					/* handling an igmp timeout.	   */
1208 
1209 	/*
1210 	 * The packet counts in the ipif contain the sum of the
1211 	 * packet counts in dead IREs that were affiliated with
1212 	 * this ipif.
1213 	 */
1214 	uint_t	ipif_fo_pkt_count;	/* Forwarded thru our dead IREs */
1215 	uint_t	ipif_ib_pkt_count;	/* Inbound packets for our dead IREs */
1216 	uint_t	ipif_ob_pkt_count;	/* Outbound packets to our dead IREs */
1217 	/* Exclusive bit fields, protected by ipsq_t */
1218 	unsigned int
1219 		ipif_multicast_up : 1,	/* We have joined the allhosts group */
1220 		ipif_solmcast_up : 1,	/* We joined solicited node mcast */
1221 		ipif_replace_zero : 1,	/* Replacement for zero */
1222 		ipif_was_up : 1,	/* ipif was up before */
1223 
1224 		ipif_pad_to_31 : 28;
1225 
1226 	int	ipif_orig_ifindex;	/* ifindex before SLIFFAILOVER */
1227 	uint_t	ipif_seqid;		/* unique index across all ills */
1228 	uint_t	ipif_orig_ipifid;	/* ipif_id before SLIFFAILOVER */
1229 	uint_t	ipif_state_flags;	/* See IPIF_* flag defs above */
1230 	uint_t	ipif_refcnt;		/* active consistent reader cnt */
1231 	uint_t	ipif_ire_cnt;		/* Number of ire's referencing ipif */
1232 	uint_t	ipif_saved_ire_cnt;
1233 	zoneid_t
1234 		ipif_zoneid;		/* zone ID number */
1235 #ifdef ILL_DEBUG
1236 #define	IP_TR_HASH_MAX	64
1237 	th_trace_t *ipif_trace[IP_TR_HASH_MAX];
1238 	boolean_t	ipif_trace_disable;	/* True when alloc fails */
1239 #endif
1240 } ipif_t;
1241 
1242 /*
1243  * The following table lists the protection levels of the various members
1244  * of the ipif_t. The following notation is used.
1245  *
1246  * Write once - Written to only once at the time of bringing up
1247  * the interface and can be safely read after the bringup without any lock.
1248  *
1249  * ipsq - Need to execute in the ipsq to perform the indicated access.
1250  *
1251  * ill_lock - Need to hold this mutex to perform the indicated access.
1252  *
1253  * ill_g_lock - Need to hold this rw lock as reader/writer for read access or
1254  * write access respectively.
1255  *
1256  * down ill - Written to only when the ill is down (i.e all ipifs are down)
1257  * up ill - Read only when the ill is up (i.e. at least 1 ipif is up)
1258  *
1259  *		 Table of ipif_t members and their protection
1260  *
1261  * ipif_next		ill_g_lock		ill_g_lock
1262  * ipif_ill		ipsq + down ipif		write once
1263  * ipif_id		ipsq + down ipif		write once
1264  * ipif_mtu		ipsq
1265  * ipif_v6lcl_addr	ipsq + down ipif		up ipif
1266  * ipif_v6src_addr	ipsq + down ipif		up ipif
1267  * ipif_v6subnet	ipsq + down ipif		up ipif
1268  * ipif_v6net_mask	ipsq + down ipif		up ipif
1269  *
1270  * ipif_v6brd_addr
1271  * ipif_v6pp_dst_addr
1272  * ipif_flags		ill_lock		ill_lock
1273  * ipif_metric
1274  * ipif_ire_type	ipsq + down ill		up ill
1275  *
1276  * ipif_arp_del_mp	ipsq			ipsq
1277  * ipif_saved_ire_mp	ipif_saved_ire_lock	ipif_saved_ire_lock
1278  * ipif_igmp_rpt	ipsq			ipsq
1279  *
1280  * ipif_fo_pkt_count	Approx
1281  * ipif_ib_pkt_count	Approx
1282  * ipif_ob_pkt_count	Approx
1283  *
1284  * bit fields		ill_lock		ill_lock
1285  *
1286  * ipif_orig_ifindex	ipsq			None
1287  * ipif_orig_ipifid	ipsq			None
1288  * ipif_seqid		ipsq			Write once
1289  *
1290  * ipif_state_flags	ill_lock		ill_lock
1291  * ipif_refcnt		ill_lock		ill_lock
1292  * ipif_ire_cnt		ill_lock		ill_lock
1293  * ipif_saved_ire_cnt
1294  */
1295 
1296 #define	IP_TR_HASH(tid)	((((uintptr_t)tid) >> 6) & (IP_TR_HASH_MAX - 1))
1297 
1298 #ifdef ILL_DEBUG
1299 #define	IPIF_TRACE_REF(ipif)	ipif_trace_ref(ipif)
1300 #define	ILL_TRACE_REF(ill)	ill_trace_ref(ill)
1301 #define	IPIF_UNTRACE_REF(ipif)	ipif_untrace_ref(ipif)
1302 #define	ILL_UNTRACE_REF(ill)	ill_untrace_ref(ill)
1303 #define	ILL_TRACE_CLEANUP(ill)	ill_trace_cleanup(ill)
1304 #define	IPIF_TRACE_CLEANUP(ipif)	ipif_trace_cleanup(ipif)
1305 #else
1306 #define	IPIF_TRACE_REF(ipif)
1307 #define	ILL_TRACE_REF(ill)
1308 #define	IPIF_UNTRACE_REF(ipif)
1309 #define	ILL_UNTRACE_REF(ill)
1310 #define	ILL_TRACE_CLEANUP(ill)
1311 #define	IPIF_TRACE_CLEANUP(ipif)
1312 #endif
1313 
1314 /* IPv4 compatability macros */
1315 #define	ipif_lcl_addr		V4_PART_OF_V6(ipif_v6lcl_addr)
1316 #define	ipif_src_addr		V4_PART_OF_V6(ipif_v6src_addr)
1317 #define	ipif_subnet		V4_PART_OF_V6(ipif_v6subnet)
1318 #define	ipif_net_mask		V4_PART_OF_V6(ipif_v6net_mask)
1319 #define	ipif_brd_addr		V4_PART_OF_V6(ipif_v6brd_addr)
1320 #define	ipif_pp_dst_addr	V4_PART_OF_V6(ipif_v6pp_dst_addr)
1321 
1322 /* Macros for easy backreferences to the ill. */
1323 #define	ipif_wq			ipif_ill->ill_wq
1324 #define	ipif_rq			ipif_ill->ill_rq
1325 #define	ipif_net_type		ipif_ill->ill_net_type
1326 #define	ipif_resolver_mp	ipif_ill->ill_resolver_mp
1327 #define	ipif_ipif_up_count	ipif_ill->ill_ipif_up_count
1328 #define	ipif_bcast_mp		ipif_ill->ill_bcast_mp
1329 #define	ipif_type		ipif_ill->ill_type
1330 #define	ipif_isv6		ipif_ill->ill_isv6
1331 
1332 #define	SIOCLIFADDR_NDX 112	/* ndx of SIOCLIFADDR in the ndx ioctl table */
1333 
1334 /*
1335  * mode value for ip_ioctl_finish for finishing an ioctl
1336  */
1337 #define	CONN_CLOSE	1		/* No mi_copy */
1338 #define	COPYOUT		2		/* do an mi_copyout if needed */
1339 #define	NO_COPYOUT	3		/* do an mi_copy_done */
1340 
1341 /*
1342  * The IP-MT design revolves around the serialization object ipsq_t.
1343  * It is associated with an IPMP group. If IPMP is not enabled, there is
1344  * 1 ipsq_t per phyint. Eg. an ipsq_t would cover both hme0's IPv4 stream
1345  *
1346  * ipsq_lock protects
1347  *	ipsq_reentry_cnt, ipsq_writer, ipsq_xopq_mphead, ipsq_xopq_mptail,
1348  *	ipsq_mphead, ipsq_mptail, ipsq_split
1349  *
1350  *	ipsq_pending_ipif, ipsq_current_ipif, ipsq_pending_mp, ipsq_flags,
1351  *	ipsq_waitfor
1352  *
1353  * The fields in the last line above below are set mostly by a writer thread
1354  * But there is an exception in the last call to ipif_ill_refrele_tail which
1355  * could also race with a conn close which could be cleaning up the
1356  * fields. So we choose to protect using ipsq_lock instead of depending on
1357  * the property of the writer.
1358  * ill_g_lock protects
1359  *	ipsq_refs, ipsq_phyint_list
1360  */
1361 typedef struct ipsq_s {
1362 	kmutex_t ipsq_lock;
1363 	int	ipsq_reentry_cnt;
1364 	kthread_t	*ipsq_writer;	/* current owner (thread id) */
1365 	int	ipsq_flags;
1366 	mblk_t	*ipsq_xopq_mphead;	/* list of excl ops mostly ioctls */
1367 	mblk_t	*ipsq_xopq_mptail;
1368 	mblk_t	*ipsq_mphead;		/* msgs on ipsq linked thru b_next */
1369 	mblk_t	*ipsq_mptail;		/* msgs on ipsq linked thru b_next */
1370 	ipif_t	*ipsq_pending_ipif;	/* ipif associated w. ipsq_pending_mp */
1371 	ipif_t	*ipsq_current_ipif;	/* ipif associated with current ioctl */
1372 	mblk_t	*ipsq_pending_mp;	/* current ioctl mp while waiting for */
1373 					/* response from another module */
1374 	struct	ipsq_s	*ipsq_next;	/* list of all syncq's (ipsq_g_list) */
1375 	uint_t		ipsq_refs;	/* Number of phyints on this ipsq */
1376 	struct phyint	*ipsq_phyint_list; /* List of phyints on this ipsq */
1377 	boolean_t	ipsq_split;	/* ipsq may need to be split */
1378 	int		ipsq_waitfor;	/* Values encoded below */
1379 	char		ipsq_name[LIFNAMSIZ+1];	/* same as phyint_groupname */
1380 	int		ipsq_last_cmd;	/* debugging aid */
1381 #ifdef ILL_DEBUG
1382 	int		ipsq_depth;	/* debugging aid */
1383 	pc_t		ipsq_stack[IP_STACK_DEPTH];	/* debugging aid */
1384 #endif
1385 } ipsq_t;
1386 
1387 /* ipsq_flags */
1388 #define	IPSQ_GROUP	0x1	/* This ipsq belongs to an IPMP group */
1389 
1390 /*
1391  * ipsq_waitfor:
1392  *
1393  * IPIF_DOWN	1	ipif_down waiting for refcnts to drop
1394  * ILL_DOWN	2	ill_down waiting for refcnts to drop
1395  * IPIF_FREE	3	ipif_free waiting for refcnts to drop
1396  * ILL_FREE	4	ill unplumb waiting for refcnts to drop
1397  * ILL_MOVE_OK	5	failover waiting for refcnts to drop
1398  */
1399 
1400 enum { IPIF_DOWN = 1, ILL_DOWN, IPIF_FREE, ILL_FREE, ILL_MOVE_OK };
1401 
1402 /* Flags passed to ipsq_try_enter */
1403 #define	CUR_OP 0		/* Current ioctl continuing again */
1404 #define	NEW_OP 1		/* New ioctl starting afresh */
1405 
1406 /*
1407  * phyint represents state that is common to both IPv4 and IPv6 interfaces.
1408  * There is a separate ill_t representing IPv4 and IPv6 which has a
1409  * backpointer to the phyint structure for acessing common state.
1410  *
1411  * NOTE : It just stores the group name as there is only one name for
1412  *	  IPv4 and IPv6 i.e it is a underlying link property. Actually
1413  *        IPv4 and IPv6 ill are grouped together when their phyints have
1414  *        the same name.
1415  */
1416 typedef struct phyint {
1417 	struct ill_s	*phyint_illv4;
1418 	struct ill_s	*phyint_illv6;
1419 	uint_t		phyint_ifindex;		/* SIOCLSLIFINDEX */
1420 	uint_t		phyint_notify_delay;	/* SIOCSLIFNOTIFYDELAY */
1421 	char		*phyint_groupname;	/* SIOCSLIFGROUPNAME */
1422 	uint_t		phyint_groupname_len;
1423 	uint64_t	phyint_flags;
1424 	avl_node_t	phyint_avl_by_index;	/* avl tree by index */
1425 	avl_node_t	phyint_avl_by_name;	/* avl tree by name */
1426 	kmutex_t	phyint_lock;
1427 	struct ipsq_s	*phyint_ipsq;		/* back pointer to ipsq */
1428 	struct phyint	*phyint_ipsq_next;	/* phyint list on this ipsq */
1429 } phyint_t;
1430 
1431 #define	CACHE_ALIGN_SIZE 64
1432 
1433 #define	CACHE_ALIGN(align_struct)	P2ROUNDUP(sizeof (struct align_struct),\
1434 							CACHE_ALIGN_SIZE)
1435 struct _phyint_list_s_ {
1436 	avl_tree_t	phyint_list_avl_by_index;	/* avl tree by index */
1437 	avl_tree_t	phyint_list_avl_by_name;	/* avl tree by name */
1438 };
1439 
1440 typedef union phyint_list_u {
1441 	struct	_phyint_list_s_ phyint_list_s;
1442 	char	phyint_list_filler[CACHE_ALIGN(_phyint_list_s_)];
1443 } phyint_list_t;
1444 
1445 #define	phyint_list_avl_by_index	phyint_list_s.phyint_list_avl_by_index
1446 #define	phyint_list_avl_by_name		phyint_list_s.phyint_list_avl_by_name
1447 /*
1448  * ILL groups. We group ills,
1449  *
1450  * - if the ills have the same group name. (New way)
1451  *
1452  * ill_group locking notes:
1453  *
1454  * illgrp_lock protects ill_grp_ill_schednext.
1455  *
1456  * ill_g_lock protects ill_grp_next, illgrp_ill, illgrp_ill_count.
1457  * Holding ill_g_lock freezes the memberships of ills in IPMP groups.
1458  * It also freezes the global list of ills and all ipifs in all ills.
1459  *
1460  * To remove an ipif from the linked list of ipifs of that ill ipif_free_tail
1461  * holds both ill_g_lock, and ill_lock. Similarly to remove an ill from the
1462  * global list of ills, ill_delete_glist holds ill_g_lock as writer.
1463  * This simplifies things for ipif_select_source, illgrp_scheduler etc.
1464  * that need to walk the members of an illgrp. They just hold ill_g_lock
1465  * as reader to do the walk.
1466  *
1467  */
1468 typedef	struct ill_group {
1469 	kmutex_t	illgrp_lock;
1470 	struct ill_group *illgrp_next;		/* Next ill_group */
1471 	struct ill_s	*illgrp_ill_schednext;	/* Next ill to be scheduled */
1472 	struct ill_s	*illgrp_ill;		/* First ill in the group */
1473 	int		illgrp_ill_count;
1474 } ill_group_t;
1475 
1476 extern	ill_group_t	*illgrp_head_v6;
1477 
1478 /*
1479  * Fragmentation hash bucket
1480  */
1481 typedef struct ipfb_s {
1482 	struct ipf_s	*ipfb_ipf;	/* List of ... */
1483 	size_t		ipfb_count;	/* Count of bytes used by frag(s) */
1484 	kmutex_t	ipfb_lock;	/* Protect all ipf in list */
1485 	uint_t		ipfb_frag_pkts; /* num of distinct fragmented pkts */
1486 } ipfb_t;
1487 
1488 /*
1489  * IRE bucket structure. Usually there is an array of such structures,
1490  * each pointing to a linked list of ires. irb_refcnt counts the number
1491  * of walkers of a given hash bucket. Usually the reference count is
1492  * bumped up if the walker wants no IRES to be DELETED while walking the
1493  * list. Bumping up does not PREVENT ADDITION. This allows walking a given
1494  * hash bucket without stumbling up on a free pointer.
1495  */
1496 typedef struct irb {
1497 	struct ire_s	*irb_ire;	/* First ire in this bucket */
1498 					/* Should be first in this struct */
1499 	krwlock_t	irb_lock;	/* Protect this bucket */
1500 	uint_t		irb_refcnt;	/* Protected by irb_lock */
1501 	uchar_t		irb_marks;	/* CONDEMNED ires in this bucket ? */
1502 	uint_t		irb_ire_cnt;	/* Num of IRE in this bucket */
1503 	uint_t		irb_tmp_ire_cnt; /* Num of temporary IRE */
1504 } irb_t;
1505 
1506 #define	IP_V4_G_HEAD	0
1507 #define	IP_V6_G_HEAD	1
1508 
1509 #define	MAX_G_HEADS	2
1510 
1511 /*
1512  * unpadded ill_if structure
1513  */
1514 struct 	_ill_if_s_ {
1515 	union ill_if_u	*illif_next;
1516 	union ill_if_u	*illif_prev;
1517 	avl_tree_t	illif_avl_by_ppa;	/* AVL tree sorted on ppa */
1518 	vmem_t		*illif_ppa_arena;	/* ppa index space */
1519 	uint16_t	illif_mcast_v1;		/* hints for		  */
1520 	uint16_t	illif_mcast_v2;		/* [igmp|mld]_slowtimo	  */
1521 	int		illif_name_len;		/* name length */
1522 	char		illif_name[LIFNAMSIZ];	/* name of interface type */
1523 };
1524 
1525 /* cache aligned ill_if structure */
1526 typedef union 	ill_if_u {
1527 	struct  _ill_if_s_ ill_if_s;
1528 	char 	illif_filler[CACHE_ALIGN(_ill_if_s_)];
1529 } ill_if_t;
1530 
1531 
1532 #define	illif_next		ill_if_s.illif_next
1533 #define	illif_prev		ill_if_s.illif_prev
1534 #define	illif_avl_by_ppa	ill_if_s.illif_avl_by_ppa
1535 #define	illif_ppa_arena		ill_if_s.illif_ppa_arena
1536 #define	illif_mcast_v1		ill_if_s.illif_mcast_v1
1537 #define	illif_mcast_v2		ill_if_s.illif_mcast_v2
1538 #define	illif_name		ill_if_s.illif_name
1539 #define	illif_name_len		ill_if_s.illif_name_len
1540 
1541 typedef struct ill_walk_context_s {
1542 	int	ctx_current_list; /* current list being searched */
1543 	int	ctx_last_list;	 /* last list to search */
1544 } ill_walk_context_t;
1545 
1546 /*
1547  * ill_gheads structure, one for IPV4 and one for IPV6
1548  */
1549 struct _ill_g_head_s_ {
1550 	ill_if_t	*ill_g_list_head;
1551 	ill_if_t	*ill_g_list_tail;
1552 };
1553 
1554 typedef union ill_g_head_u {
1555 	struct _ill_g_head_s_ ill_g_head_s;
1556 	char	ill_g_head_filler[CACHE_ALIGN(_ill_g_head_s_)];
1557 } ill_g_head_t;
1558 
1559 #define	ill_g_list_head	ill_g_head_s.ill_g_list_head
1560 #define	ill_g_list_tail	ill_g_head_s.ill_g_list_tail
1561 
1562 #pragma align CACHE_ALIGN_SIZE(ill_g_heads)
1563 extern ill_g_head_t	ill_g_heads[];	/* ILL List Head */
1564 
1565 
1566 #define	IP_V4_ILL_G_LIST	ill_g_heads[IP_V4_G_HEAD].ill_g_list_head
1567 #define	IP_V6_ILL_G_LIST	ill_g_heads[IP_V6_G_HEAD].ill_g_list_head
1568 #define	IP_VX_ILL_G_LIST(i)	ill_g_heads[i].ill_g_list_head
1569 
1570 #define	ILL_START_WALK_V4(ctx_ptr)	ill_first(IP_V4_G_HEAD, IP_V4_G_HEAD, \
1571 					ctx_ptr)
1572 #define	ILL_START_WALK_V6(ctx_ptr)	ill_first(IP_V6_G_HEAD, IP_V6_G_HEAD, \
1573 					ctx_ptr)
1574 #define	ILL_START_WALK_ALL(ctx_ptr)	ill_first(MAX_G_HEADS, MAX_G_HEADS, \
1575 					ctx_ptr)
1576 
1577 /*
1578  * Capabilities, possible flags for ill_capabilities.
1579  */
1580 
1581 #define	ILL_CAPAB_AH		0x01		/* IPsec AH acceleration */
1582 #define	ILL_CAPAB_ESP		0x02		/* IPsec ESP acceleration */
1583 #define	ILL_CAPAB_MDT		0x04		/* Multidata Transmit */
1584 #define	ILL_CAPAB_HCKSUM	0x08		/* Hardware checksumming */
1585 #define	ILL_CAPAB_ZEROCOPY	0x10		/* Zero-copy */
1586 #define	ILL_CAPAB_POLL		0x20		/* Polling Toggle */
1587 
1588 /*
1589  * Per-ill Multidata Transmit capabilities.
1590  */
1591 typedef struct ill_mdt_capab_s ill_mdt_capab_t;
1592 
1593 /*
1594  * Per-ill IPsec capabilities.
1595  */
1596 typedef struct ill_ipsec_capab_s ill_ipsec_capab_t;
1597 
1598 /*
1599  * Per-ill Hardware Checksumming capbilities.
1600  */
1601 typedef struct ill_hcksum_capab_s ill_hcksum_capab_t;
1602 
1603 /*
1604  * Per-ill Zero-copy capabilities.
1605  */
1606 typedef struct ill_zerocopy_capab_s ill_zerocopy_capab_t;
1607 
1608 /*
1609  * Per-ill Polling capbilities.
1610  */
1611 typedef struct ill_poll_capab_s ill_poll_capab_t;
1612 
1613 /*
1614  * Per-ill polling resource map.
1615  */
1616 typedef struct ill_rx_ring ill_rx_ring_t;
1617 
1618 /* The following are ill_state_flags */
1619 #define	ILL_LL_SUBNET_PENDING	0x01	/* Waiting for DL_INFO_ACK from drv */
1620 #define	ILL_CONDEMNED		0x02	/* No more new ref's to the ILL */
1621 #define	ILL_CHANGING		0x04	/* ILL not globally visible */
1622 #define	ILL_DL_UNBIND_DONE	0x08	/* UNBIND_REQ has been Acked */
1623 
1624 /* Is this an ILL whose source address is used by other ILL's ? */
1625 #define	IS_USESRC_ILL(ill)			\
1626 	(((ill)->ill_usesrc_ifindex == 0) &&	\
1627 	((ill)->ill_usesrc_grp_next != NULL))	\
1628 
1629 /* Is this a client/consumer of the usesrc ILL ? */
1630 #define	IS_USESRC_CLI_ILL(ill)			\
1631 	(((ill)->ill_usesrc_ifindex != 0) &&	\
1632 	((ill)->ill_usesrc_grp_next != NULL))	\
1633 
1634 /* Is this an virtual network interface (vni) ILL ? */
1635 #define	IS_VNI(ill)							\
1636 	(((ill) != NULL) && !((ill)->ill_phyint->phyint_flags &		\
1637 	PHYI_LOOPBACK) && ((ill)->ill_phyint->phyint_flags &		\
1638 	PHYI_VIRTUAL))							\
1639 
1640 /*
1641  * IP Lower level Structure.
1642  * Instance data structure in ip_open when there is a device below us.
1643  */
1644 typedef struct ill_s {
1645 	ill_if_t *ill_ifptr;		/* pointer to interface type */
1646 	queue_t	*ill_rq;		/* Read queue. */
1647 	queue_t	*ill_wq;		/* Write queue. */
1648 
1649 	int	ill_error;		/* Error value sent up by device. */
1650 
1651 	ipif_t	*ill_ipif;		/* Interface chain for this ILL. */
1652 
1653 	uint_t	ill_ipif_up_count;	/* Number of IPIFs currently up. */
1654 	uint_t	ill_max_frag;		/* Max IDU from DLPI. */
1655 	char	*ill_name;		/* Our name. */
1656 	uint_t	ill_name_length;	/* Name length, incl. terminator. */
1657 	char	*ill_ndd_name;		/* Name + ":ip?_forwarding" for NDD. */
1658 	uint_t	ill_net_type;		/* IRE_IF_RESOLVER/IRE_IF_NORESOLVER. */
1659 	/*
1660 	 * Physical Point of Attachment num.  If DLPI style 1 provider
1661 	 * then this is derived from the devname.
1662 	 */
1663 	uint_t	ill_ppa;
1664 	t_uscalar_t	ill_sap;
1665 	t_scalar_t	ill_sap_length;	/* Including sign (for position) */
1666 	uint_t	ill_phys_addr_length;	/* Excluding the sap. */
1667 	uint_t	ill_bcast_addr_length;	/* Only set when the DL provider */
1668 					/* supports broadcast. */
1669 	t_uscalar_t	ill_mactype;
1670 	uint8_t	*ill_frag_ptr;		/* Reassembly state. */
1671 	timeout_id_t ill_frag_timer_id; /* timeout id for the frag timer */
1672 	ipfb_t	*ill_frag_hash_tbl;	/* Fragment hash list head. */
1673 	ipif_t	*ill_pending_ipif;	/* IPIF waiting for DL operation. */
1674 
1675 	ilm_t	*ill_ilm;		/* Multicast mebership for lower ill */
1676 	uint_t	ill_global_timer;	/* for IGMPv3/MLDv2 general queries */
1677 	int	ill_mcast_type;		/* type of router which is querier */
1678 					/* on this interface */
1679 	uint16_t ill_mcast_v1_time;	/* # slow timeouts since last v1 qry */
1680 	uint16_t ill_mcast_v2_time;	/* # slow timeouts since last v2 qry */
1681 	uint8_t	ill_mcast_v1_tset;	/* 1 => timer is set; 0 => not set */
1682 	uint8_t	ill_mcast_v2_tset;	/* 1 => timer is set; 0 => not set */
1683 
1684 	uint8_t	ill_mcast_rv;		/* IGMPv3/MLDv2 robustness variable */
1685 	int	ill_mcast_qi;		/* IGMPv3/MLDv2 query interval var */
1686 
1687 	mblk_t	*ill_pending_mp;	/* IOCTL/DLPI awaiting completion. */
1688 	/*
1689 	 * All non-NULL cells between 'ill_first_mp_to_free' and
1690 	 * 'ill_last_mp_to_free' are freed in ill_delete.
1691 	 */
1692 #define	ill_first_mp_to_free	ill_bcast_mp
1693 	mblk_t	*ill_bcast_mp;		/* DLPI header for broadcasts. */
1694 	mblk_t	*ill_resolver_mp;	/* Resolver template. */
1695 	mblk_t	*ill_detach_mp;		/* detach mp, or NULL if style1 */
1696 	mblk_t	*ill_unbind_mp;		/* unbind mp from ill_dl_up() */
1697 	mblk_t	*ill_dlpi_deferred;	/* b_next chain of control messages */
1698 	mblk_t	*ill_phys_addr_mp;	/* mblk which holds ill_phys_addr */
1699 #define	ill_last_mp_to_free	ill_phys_addr_mp
1700 
1701 	cred_t	*ill_credp;		/* opener's credentials */
1702 	uint8_t	*ill_phys_addr;		/* ill_phys_addr_mp->b_rptr + off */
1703 
1704 	uint_t	ill_state_flags;	/* see ILL_* flags above */
1705 
1706 	/* Following bit fields protected by ipsq_t */
1707 	uint_t
1708 		ill_needs_attach : 1,
1709 		ill_reserved : 1,
1710 		ill_isv6 : 1,
1711 		ill_dlpi_style_set : 1,
1712 
1713 		ill_ifname_pending : 1,
1714 		ill_move_in_progress : 1, /* FAILOVER/FAILBACK in progress */
1715 		ill_join_allmulti : 1,
1716 		ill_logical_down : 1,
1717 
1718 		ill_is_6to4tun : 1,	/* Interface is a 6to4 tunnel */
1719 		ill_promisc_on_phys : 1, /* phys interface in promisc mode */
1720 		ill_dl_up : 1,
1721 		ill_up_ipifs : 1,
1722 
1723 		ill_pad_to_bit_31 : 20;
1724 
1725 	/* Following bit fields protected by ill_lock */
1726 	uint_t
1727 		ill_fragtimer_executing : 1,
1728 		ill_fragtimer_needrestart : 1,
1729 		ill_ilm_cleanup_reqd : 1,
1730 		ill_arp_closing : 1,
1731 
1732 		ill_arp_bringup_pending : 1,
1733 		ill_mtu_userspecified : 1, /* SIOCSLNKINFO has set the mtu */
1734 		ill_pad_bit_31 : 26;
1735 
1736 	/*
1737 	 * Used in SIOCSIFMUXID and SIOCGIFMUXID for 'ifconfig unplumb'.
1738 	 */
1739 	int	ill_arp_muxid;		/* muxid returned from plink for arp */
1740 	int	ill_ip_muxid;		/* muxid returned from plink for ip */
1741 
1742 	/*
1743 	 * Used for IP frag reassembly throttling on a per ILL basis.
1744 	 *
1745 	 * Note: frag_count is approximate, its added to and subtracted from
1746 	 *	 without any locking, so simultaneous load/modify/stores can
1747 	 *	 collide, also ill_frag_purge() recalculates its value by
1748 	 *	 summing all the ipfb_count's without locking out updates
1749 	 *	 to the ipfb's.
1750 	 */
1751 	uint_t	ill_ipf_gen;		/* Generation of next fragment queue */
1752 	uint_t	ill_frag_count;		/* Approx count of all mblk bytes */
1753 	uint_t	ill_frag_free_num_pkts;	 /* num of fragmented packets to free */
1754 	clock_t	ill_last_frag_clean_time; /* time when frag's were pruned */
1755 	int	ill_type;		/* From <net/if_types.h> */
1756 	uint_t	ill_dlpi_multicast_state;	/* See below IDMS_* */
1757 	uint_t	ill_dlpi_fastpath_state;	/* See below IDMS_* */
1758 
1759 	/*
1760 	 * Capabilities related fields.
1761 	 */
1762 	uint_t  ill_capab_state;	/* State of capability query, IDMS_* */
1763 	uint64_t ill_capabilities;	/* Enabled capabilities, ILL_CAPAB_* */
1764 	ill_mdt_capab_t	*ill_mdt_capab;	/* Multidata Transmit capabilities */
1765 	ill_ipsec_capab_t *ill_ipsec_capab_ah;	/* IPsec AH capabilities */
1766 	ill_ipsec_capab_t *ill_ipsec_capab_esp;	/* IPsec ESP capabilities */
1767 	ill_hcksum_capab_t *ill_hcksum_capab; /* H/W cksumming capabilities */
1768 	ill_zerocopy_capab_t *ill_zerocopy_capab; /* Zero-copy capabilities */
1769 	ill_poll_capab_t *ill_poll_capab; /* Polling capabilities */
1770 
1771 	/*
1772 	 * New fields for IPv6
1773 	 */
1774 	uint8_t	ill_max_hops;	/* Maximum hops for any logical interface */
1775 	uint_t	ill_max_mtu;	/* Maximum MTU for any logical interface */
1776 	uint32_t ill_reachable_time;	/* Value for ND algorithm in msec */
1777 	uint32_t ill_reachable_retrans_time; /* Value for ND algorithm msec */
1778 	uint_t	ill_max_buf;		/* Max # of req to buffer for ND */
1779 	in6_addr_t	ill_token;
1780 	uint_t		ill_token_length;
1781 	uint32_t	ill_xmit_count;		/* ndp max multicast xmits */
1782 	mib2_ipv6IfStatsEntry_t	*ill_ip6_mib;	/* Per interface mib */
1783 	mib2_ipv6IfIcmpEntry_t	*ill_icmp6_mib;	/* Per interface mib */
1784 	/*
1785 	 * Following two mblks are allocated common to all
1786 	 * the ipifs when the first interface is coming up.
1787 	 * It is sent up to arp when the last ipif is coming
1788 	 * down.
1789 	 */
1790 	mblk_t			*ill_arp_down_mp;
1791 	mblk_t			*ill_arp_del_mapping_mp;
1792 	/*
1793 	 * Used for implementing IFF_NOARP. As IFF_NOARP is used
1794 	 * to turn off for all the logicals, it is here instead
1795 	 * of the ipif.
1796 	 */
1797 	mblk_t			*ill_arp_on_mp;
1798 	/* Peer ill of an IPMP move operation */
1799 	struct ill_s		*ill_move_peer;
1800 
1801 	phyint_t		*ill_phyint;
1802 	uint64_t		ill_flags;
1803 	ill_group_t		*ill_group;
1804 	struct ill_s		*ill_group_next;
1805 	/*
1806 	 * Reverse tunnel related count. This count
1807 	 * determines how many mobile nodes are using this
1808 	 * ill to send packet to reverse tunnel via foreign
1809 	 * agent. A non-zero count specifies presence of
1810 	 * mobile node(s) using reverse tunnel through this
1811 	 * interface.
1812 	 */
1813 	uint32_t		ill_mrtun_refcnt;
1814 
1815 	/*
1816 	 * This count is bumped up when a route is added with
1817 	 * RTA_SRCIFP bit flag using routing socket.
1818 	 */
1819 	uint32_t		ill_srcif_refcnt;
1820 	/*
1821 	 * Pointer to the special interface based routing table.
1822 	 * This routing table is created dynamically when RTA_SRCIFP
1823 	 * is set by the routing socket.
1824 	 */
1825 	irb_t			*ill_srcif_table;
1826 	kmutex_t	ill_lock;	/* Please see table below */
1827 	/*
1828 	 * The ill_nd_lla* fields handle the link layer address option
1829 	 * from neighbor discovery. This is used for external IPv6
1830 	 * address resolution.
1831 	 */
1832 	mblk_t		*ill_nd_lla_mp;	/* mblk which holds ill_nd_lla */
1833 	uint8_t		*ill_nd_lla;	/* Link Layer Address */
1834 	uint_t		ill_nd_lla_len;	/* Link Layer Address length */
1835 	/*
1836 	 * We now have 3 phys_addr_req's sent down. This field keeps track
1837 	 * of which one is pending.
1838 	 */
1839 	t_uscalar_t	ill_phys_addr_pend; /* which dl_phys_addr_req pending */
1840 	/*
1841 	 * Used to save errors that occur during plumbing
1842 	 */
1843 	uint_t		ill_ifname_pending_err;
1844 	avl_node_t	ill_avl_byppa; /* avl node based on ppa */
1845 	void		*ill_fastpath_list; /* both ire and nce hang off this */
1846 	uint_t		ill_refcnt;	/* active refcnt by threads */
1847 	uint_t		ill_ire_cnt;	/* ires associated with this ill */
1848 	kcondvar_t	ill_cv;
1849 	uint_t		ill_ilm_walker_cnt;	/* snmp ilm walkers */
1850 	uint_t		ill_nce_cnt;	/* nces associated with this ill */
1851 	uint_t		ill_waiters;	/* threads waiting in ipsq_enter */
1852 	/*
1853 	 * Contains the upper read queue pointer of the module immediately
1854 	 * beneath IP.  This field allows IP to validate sub-capability
1855 	 * acknowledgments coming up from downstream.
1856 	 */
1857 	queue_t		*ill_lmod_rq;	/* read queue pointer of module below */
1858 	uint_t		ill_lmod_cnt;	/* number of modules beneath IP */
1859 	ip_m_t		*ill_media;	/* media specific params/functions */
1860 	t_uscalar_t	ill_dlpi_pending; /* Last DLPI primitive issued */
1861 	uint_t		ill_usesrc_ifindex; /* use src addr from this ILL */
1862 	struct ill_s	*ill_usesrc_grp_next; /* Next ILL in the usesrc group */
1863 #ifdef ILL_DEBUG
1864 	th_trace_t	*ill_trace[IP_TR_HASH_MAX];
1865 	boolean_t	ill_trace_disable;	/* True when alloc fails */
1866 #endif
1867 } ill_t;
1868 
1869 extern	void	ill_delete_glist(ill_t *);
1870 
1871 /*
1872  * The following table lists the protection levels of the various members
1873  * of the ill_t. Same notation as that used for ipif_t above is used.
1874  *
1875  *				Write			Read
1876  *
1877  * ill_ifptr			ill_g_lock + s		Write once
1878  * ill_rq			ipsq			Write once
1879  * ill_wq			ipsq			Write once
1880  *
1881  * ill_error			ipsq			None
1882  * ill_ipif			ill_g_lock + ipsq	ill_g_lock OR ipsq
1883  * ill_ipif_up_count		ill_lock + ipsq		ill_lock
1884  * ill_max_frag			ipsq			Write once
1885  *
1886  * ill_name			ill_g_lock + ipsq		Write once
1887  * ill_name_length		ill_g_lock + ipsq		Write once
1888  * ill_ndd_name			ipsq			Write once
1889  * ill_net_type			ipsq			Write once
1890  * ill_ppa			ill_g_lock + ipsq		Write once
1891  * ill_sap			ipsq + down ill		Write once
1892  * ill_sap_length		ipsq + down ill		Write once
1893  * ill_phys_addr_length		ipsq + down ill		Write once
1894  *
1895  * ill_bcast_addr_length	ipsq			ipsq
1896  * ill_mactype			ipsq			ipsq
1897  * ill_frag_ptr			ipsq			ipsq
1898  *
1899  * ill_frag_timer_id		ill_lock		ill_lock
1900  * ill_frag_hash_tbl		ipsq			up ill
1901  * ill_ilm			ipsq + ill_lock		ill_lock
1902  * ill_mcast_type		ill_lock		ill_lock
1903  * ill_mcast_v1_time		ill_lock		ill_lock
1904  * ill_mcast_v2_time		ill_lock		ill_lock
1905  * ill_mcast_v1_tset		ill_lock		ill_lock
1906  * ill_mcast_v2_tset		ill_lock		ill_lock
1907  * ill_mcast_rv			ill_lock		ill_lock
1908  * ill_mcast_qi			ill_lock		ill_lock
1909  * ill_pending_mp		ill_lock		ill_lock
1910  *
1911  * ill_bcast_mp			ipsq			ipsq
1912  * ill_resolver_mp		ipsq			only when ill is up
1913  * ill_down_mp			ipsq			ipsq
1914  * ill_dlpi_deferred		ipsq			ipsq
1915  * ill_phys_addr_mp		ipsq			ipsq
1916  * ill_phys_addr		ipsq			up ill
1917  * ill_ick			ipsq + down ill		only when ill is up
1918  *
1919  * ill_state_flags		ill_lock		ill_lock
1920  * exclusive bit flags		ipsq_t			ipsq_t
1921  * shared bit flags		ill_lock		ill_lock
1922  *
1923  * ill_arp_muxid		ipsq			Not atomic
1924  * ill_ip_muxid			ipsq			Not atomic
1925  *
1926  * ill_ipf_gen			Not atomic
1927  * ill_frag_count		Approx. not protected
1928  * ill_type			ipsq + down ill		only when ill is up
1929  * ill_dlpi_multicast_state	ill_lock		ill_lock
1930  * ill_dlpi_fastpath_state	ill_lock		ill_lock
1931  * ill_max_hops			ipsq			Not atomic
1932  *
1933  * ill_max_mtu
1934  *
1935  * ill_reachable_time		ipsq + ill_lock		ill_lock
1936  * ill_reachable_retrans_time	ipsq  + ill_lock		ill_lock
1937  * ill_max_buf			ipsq + ill_lock		ill_lock
1938  *
1939  * Next 2 fields need ill_lock because of the get ioctls. They should not
1940  * report partially updated results without executing in the ipsq.
1941  * ill_token			ipsq + ill_lock		ill_lock
1942  * ill_token_length		ipsq + ill_lock		ill_lock
1943  * ill_xmit_count		ipsq + down ill		write once
1944  * ill_ip6_mib			ipsq + down ill		only when ill is up
1945  * ill_icmp6_mib		ipsq + down ill		only when ill is up
1946  * ill_arp_down_mp		ipsq			ipsq
1947  * ill_arp_del_mapping_mp	ipsq			ipsq
1948  * ill_arp_on_mp		ipsq			ipsq
1949  * ill_move_peer		ipsq			ipsq
1950  *
1951  * ill_phyint			ipsq, ill_g_lock, ill_lock	Any of them
1952  * ill_flags			ill_lock		ill_lock
1953  * ill_group			ipsq, ill_g_lock, ill_lock	Any of them
1954  * ill_group_next		ipsq, ill_g_lock, ill_lock	Any of them
1955  * ill_mrtun_refcnt		ill_lock		ill_lock
1956  * ill_srcif_refcnt		ill_lock		ill_lock
1957  * ill_srcif_table		ill_lock		ill_lock
1958  * ill_nd_lla_mp		ill_lock		ill_lock
1959  * ill_nd_lla			ill_lock		ill_lock
1960  * ill_nd_lla_len		ill_lock		ill_lock
1961  * ill_phys_addr_pend		ipsq + down ill		only when ill is up
1962  * ill_ifname_pending_err	ipsq			ipsq
1963  * ill_avl_byppa		ipsq, ill_g_lock		Write once
1964  *
1965  * ill_fastpath_list		ill_lock		ill_lock
1966  * ill_refcnt			ill_lock		ill_lock
1967  * ill_ire_cnt			ill_lock		ill_lock
1968  * ill_cv			ill_lock		ill_lock
1969  * ill_ilm_walker_cnt		ill_lock		ill_lock
1970  * ill_nce_cnt			ill_lock		ill_lock
1971  * ill_trace			ill_lock		ill_lock
1972  * ill_usesrc_grp_next		ill_g_usesrc_lock	ill_g_usesrc_lock
1973  */
1974 
1975 /*
1976  * For ioctl restart mechanism see ip_reprocess_ioctl()
1977  */
1978 struct ip_ioctl_cmd_s;
1979 
1980 typedef	int (*ifunc_t)(ipif_t *, struct sockaddr_in *, queue_t *, mblk_t *,
1981     struct ip_ioctl_cmd_s *, void *);
1982 
1983 typedef struct ip_ioctl_cmd_s {
1984 	int	ipi_cmd;
1985 	size_t	ipi_copyin_size;
1986 	uint_t	ipi_flags;
1987 	uint_t	ipi_cmd_type;
1988 	ifunc_t	ipi_func;
1989 	ifunc_t	ipi_func_restart;
1990 } ip_ioctl_cmd_t;
1991 
1992 /*
1993  * ipi_cmd_type:
1994  *
1995  * IF_CMD		1	old style ifreq cmd
1996  * LIF_CMD		2	new style lifreq cmd
1997  * MISC_CMD		3	Misc. (non [l]ifreq, tun) cmds
1998  * TUN_CMD		4	tunnel related
1999  */
2000 
2001 enum { IF_CMD = 1, LIF_CMD, MISC_CMD, TUN_CMD };
2002 
2003 #define	IPI_DONTCARE	0	/* For ioctl encoded values that don't matter */
2004 
2005 /* Flag values in ipi_flags */
2006 #define	IPI_PRIV	0x1		/* Root only command */
2007 #define	IPI_MODOK	0x2		/* Permitted on mod instance of IP */
2008 #define	IPI_WR		0x4		/* Need to grab writer access */
2009 #define	IPI_GET_CMD	0x8		/* branch to mi_copyout on success */
2010 #define	IPI_REPL	0x10	/* valid for replacement ipif created in MOVE */
2011 #define	IPI_NULL_BCONT	0x20	/* ioctl has not data and hence no b_cont */
2012 #define	IPI_PASS_DOWN	0x40	/* pass this ioctl down when a module only */
2013 
2014 extern ip_ioctl_cmd_t	ip_ndx_ioctl_table[];
2015 extern ip_ioctl_cmd_t	ip_misc_ioctl_table[];
2016 extern int ip_ndx_ioctl_count;
2017 extern int ip_misc_ioctl_count;
2018 
2019 #define	ILL_CLEAR_MOVE(ill) {				\
2020 	ill_t *peer_ill;				\
2021 							\
2022 	peer_ill = (ill)->ill_move_peer;		\
2023 	ASSERT(peer_ill != NULL);			\
2024 	(ill)->ill_move_in_progress = B_FALSE;		\
2025 	peer_ill->ill_move_in_progress = B_FALSE;	\
2026 	(ill)->ill_move_peer = NULL;			\
2027 	peer_ill->ill_move_peer = NULL;			\
2028 }
2029 
2030 /* Passed down by ARP to IP during I_PLINK/I_PUNLINK */
2031 typedef struct ipmx_s {
2032 	char	ipmx_name[LIFNAMSIZ];		/* if name */
2033 	uint_t
2034 		ipmx_arpdev_stream : 1,		/* This is the arp stream */
2035 		ipmx_notused : 31;
2036 } ipmx_t;
2037 
2038 /*
2039  * State for detecting if a driver supports certain features.
2040  * Support for DL_ENABMULTI_REQ uses ill_dlpi_multicast_state.
2041  * Support for DLPI M_DATA fastpath uses ill_dlpi_fastpath_state.
2042  */
2043 #define	IDMS_UNKNOWN	0	/* No DL_ENABMULTI_REQ sent */
2044 #define	IDMS_INPROGRESS	1	/* Sent DL_ENABMULTI_REQ */
2045 #define	IDMS_OK		2	/* DL_ENABMULTI_REQ ok */
2046 #define	IDMS_FAILED	3	/* DL_ENABMULTI_REQ failed */
2047 #define	IDMS_RENEG	4	/* Driver asked for a renegotiation */
2048 
2049 /* Named Dispatch Parameter Management Structure */
2050 typedef struct ipparam_s {
2051 	uint_t	ip_param_min;
2052 	uint_t	ip_param_max;
2053 	uint_t	ip_param_value;
2054 	char	*ip_param_name;
2055 } ipparam_t;
2056 
2057 /* Extended NDP Management Structure */
2058 typedef struct ipndp_s {
2059 	ndgetf_t	ip_ndp_getf;
2060 	ndsetf_t	ip_ndp_setf;
2061 	caddr_t		ip_ndp_data;
2062 	char		*ip_ndp_name;
2063 } ipndp_t;
2064 
2065 /*
2066  * Following are the macros to increment/decrement the reference
2067  * count of the IREs and IRBs (ire bucket).
2068  *
2069  * 1) We bump up the reference count of an IRE to make sure that
2070  *    it does not get deleted and freed while we are using it.
2071  *    Typically all the lookup functions hold the bucket lock,
2072  *    and look for the IRE. If it finds an IRE, it bumps up the
2073  *    reference count before dropping the lock. Sometimes we *may* want
2074  *    to bump up the reference count after we *looked* up i.e without
2075  *    holding the bucket lock. So, the IRE_REFHOLD macro does not assert
2076  *    on the bucket lock being held. Any thread trying to delete from
2077  *    the hash bucket can still do so but cannot free the IRE if
2078  *    ire_refcnt is not 0.
2079  *
2080  * 2) We bump up the reference count on the bucket where the IRE resides
2081  *    (IRB), when we want to prevent the IREs getting deleted from a given
2082  *    hash bucket. This makes life easier for ire_walk type functions which
2083  *    wants to walk the IRE list, call a function, but needs to drop
2084  *    the bucket lock to prevent recursive rw_enters. While the
2085  *    lock is dropped, the list could be changed by other threads or
2086  *    the same thread could end up deleting the ire or the ire pointed by
2087  *    ire_next. IRE_REFHOLDing the ire or ire_next is not sufficient as
2088  *    a delete will still remove the ire from the bucket while we have
2089  *    dropped the lock and hence the ire_next would be NULL. Thus, we
2090  *    need a mechanism to prevent deletions from a given bucket.
2091  *
2092  *    To prevent deletions, we bump up the reference count on the
2093  *    bucket. If the bucket is held, ire_delete just marks IRE_MARK_CONDEMNED
2094  *    both on the ire's ire_marks and the bucket's irb_marks. When the
2095  *    reference count on the bucket drops to zero, all the CONDEMNED ires
2096  *    are deleted. We don't have to bump up the reference count on the
2097  *    bucket if we are walking the bucket and never have to drop the bucket
2098  *    lock. Note that IRB_REFHOLD does not prevent addition of new ires
2099  *    in the list. It is okay because addition of new ires will not cause
2100  *    ire_next to point to freed memory. We do IRB_REFHOLD only when
2101  *    all of the 3 conditions are true :
2102  *
2103  *    1) The code needs to walk the IRE bucket from start to end.
2104  *    2) It may have to drop the bucket lock sometimes while doing (1)
2105  *    3) It does not want any ires to be deleted meanwhile.
2106  */
2107 
2108 /*
2109  * Bump up the reference count on the IRE. We cannot assert that the
2110  * bucket lock is being held as it is legal to bump up the reference
2111  * count after the first lookup has returned the IRE without
2112  * holding the lock. Currently ip_wput does this for caching IRE_CACHEs.
2113  */
2114 
2115 #ifndef IRE_DEBUG
2116 
2117 #define	IRE_REFHOLD_NOTR(ire)	IRE_REFHOLD(ire)
2118 #define	IRE_UNTRACE_REF(ire)
2119 #define	IRE_TRACE_REF(ire)
2120 
2121 #else
2122 
2123 #define	IRE_REFHOLD_NOTR(ire) {				\
2124 	atomic_add_32(&(ire)->ire_refcnt, 1);		\
2125 	ASSERT((ire)->ire_refcnt != 0);			\
2126 }
2127 
2128 #define	IRE_UNTRACE_REF(ire)	ire_untrace_ref(ire);
2129 #define	IRE_TRACE_REF(ire)	ire_trace_ref(ire);
2130 #endif
2131 
2132 #define	IRE_REFHOLD(ire) {				\
2133 	atomic_add_32(&(ire)->ire_refcnt, 1);		\
2134 	ASSERT((ire)->ire_refcnt != 0);			\
2135 	IRE_TRACE_REF(ire);				\
2136 }
2137 
2138 #define	IRE_REFHOLD_LOCKED(ire)	{			\
2139 	IRE_TRACE_REF(ire);				\
2140 	(ire)->ire_refcnt++;				\
2141 }
2142 
2143 /*
2144  * Decrement the reference count on the IRE.
2145  * In architectures e.g sun4u, where atomic_add_32_nv is just
2146  * a cas, we need to maintain the right memory barrier semantics
2147  * as that of mutex_exit i.e all the loads and stores should complete
2148  * before the cas is executed. membar_exit() does that here.
2149  *
2150  * NOTE : This macro is used only in places where we want performance.
2151  *	  To avoid bloating the code, we use the function "ire_refrele"
2152  *	  which essentially calls the macro.
2153  */
2154 #ifndef IRE_DEBUG
2155 #define	IRE_REFRELE(ire) {					\
2156 	ASSERT((ire)->ire_refcnt != 0);				\
2157 	membar_exit();						\
2158 	if (atomic_add_32_nv(&(ire)->ire_refcnt, -1) == 0)	\
2159 		ire_inactive(ire);				\
2160 }
2161 #define	IRE_REFRELE_NOTR(ire)	IRE_REFRELE(ire)
2162 #else
2163 #define	IRE_REFRELE(ire) {					\
2164 	if (ire->ire_bucket != NULL)				\
2165 		ire_untrace_ref(ire);				\
2166 	ASSERT((ire)->ire_refcnt != 0);				\
2167 	membar_exit();						\
2168 	if (atomic_add_32_nv(&(ire)->ire_refcnt, -1) == 0)	\
2169 		ire_inactive(ire);				\
2170 }
2171 #define	IRE_REFRELE_NOTR(ire) {					\
2172 	ASSERT((ire)->ire_refcnt != 0);				\
2173 	membar_exit();						\
2174 	if (atomic_add_32_nv(&(ire)->ire_refcnt, -1) == 0)	\
2175 		ire_inactive(ire);				\
2176 }
2177 #endif
2178 
2179 /*
2180  * Bump up the reference count on the hash bucket - IRB to
2181  * prevent ires from being deleted in this bucket.
2182  */
2183 #define	IRB_REFHOLD(irb) {				\
2184 	rw_enter(&(irb)->irb_lock, RW_WRITER);		\
2185 	(irb)->irb_refcnt++;				\
2186 	ASSERT((irb)->irb_refcnt != 0);			\
2187 	rw_exit(&(irb)->irb_lock);			\
2188 }
2189 
2190 #define	IRB_REFRELE(irb) {				\
2191 	rw_enter(&(irb)->irb_lock, RW_WRITER);		\
2192 	ASSERT((irb)->irb_refcnt != 0);			\
2193 	if (--(irb)->irb_refcnt	== 0 &&			\
2194 	    ((irb)->irb_marks & IRE_MARK_CONDEMNED)) {	\
2195 		ire_t *ire_list;			\
2196 							\
2197 		ire_list = ire_unlink(irb);		\
2198 		rw_exit(&(irb)->irb_lock);		\
2199 		ASSERT(ire_list != NULL);		\
2200 		ire_cleanup(ire_list);			\
2201 	} else {					\
2202 		rw_exit(&(irb)->irb_lock);		\
2203 	}						\
2204 }
2205 
2206 /*
2207  * Lock the fast path mp for access, since the ire_fp_mp can be deleted
2208  * due a DL_NOTE_FASTPATH_FLUSH in the case of IRE_BROADCAST and IRE_MIPRTUN
2209  */
2210 
2211 #define	LOCK_IRE_FP_MP(ire) {				\
2212 		if ((ire)->ire_type == IRE_BROADCAST ||	\
2213 		    (ire)->ire_type == IRE_MIPRTUN)	\
2214 			mutex_enter(&ire->ire_lock);	\
2215 	}
2216 #define	UNLOCK_IRE_FP_MP(ire) {				\
2217 		if ((ire)->ire_type == IRE_BROADCAST ||	\
2218 		    (ire)->ire_type == IRE_MIPRTUN)	\
2219 			mutex_exit(&ire->ire_lock);	\
2220 	}
2221 
2222 typedef struct ire4 {
2223 	ipaddr_t ire4_src_addr;		/* Source address to use. */
2224 	ipaddr_t ire4_mask;		/* Mask for matching this IRE. */
2225 	ipaddr_t ire4_addr;		/* Address this IRE represents. */
2226 	ipaddr_t ire4_gateway_addr;	/* Gateway if IRE_CACHE/IRE_OFFSUBNET */
2227 	ipaddr_t ire4_cmask;		/* Mask from parent prefix route */
2228 } ire4_t;
2229 
2230 typedef struct ire6 {
2231 	in6_addr_t ire6_src_addr;	/* Source address to use. */
2232 	in6_addr_t ire6_mask;		/* Mask for matching this IRE. */
2233 	in6_addr_t ire6_addr;		/* Address this IRE represents. */
2234 	in6_addr_t ire6_gateway_addr;	/* Gateway if IRE_CACHE/IRE_OFFSUBNET */
2235 	in6_addr_t ire6_cmask;		/* Mask from parent prefix route */
2236 } ire6_t;
2237 
2238 typedef union ire_addr {
2239 	ire6_t	ire6_u;
2240 	ire4_t	ire4_u;
2241 } ire_addr_u_t;
2242 
2243 /* Internet Routing Entry */
2244 typedef struct ire_s {
2245 	struct	ire_s	*ire_next;	/* The hash chain must be first. */
2246 	struct	ire_s	**ire_ptpn;	/* Pointer to previous next. */
2247 	uint32_t	ire_refcnt;	/* Number of references */
2248 	mblk_t		*ire_mp;	/* Non-null if allocated as mblk */
2249 	mblk_t		*ire_fp_mp;	/* Fast path header */
2250 	queue_t		*ire_rfq;	/* recv from this queue */
2251 	queue_t		*ire_stq;	/* send to this queue */
2252 	union {
2253 		uint_t	*max_fragp;	/* Used only during ire creation */
2254 		uint_t	max_frag;	/* MTU (next hop or path). */
2255 	} imf_u;
2256 #define	ire_max_frag	imf_u.max_frag
2257 #define	ire_max_fragp	imf_u.max_fragp
2258 	uint32_t	ire_frag_flag;	/* IPH_DF or zero. */
2259 	uint32_t	ire_ident;	/* Per IRE IP ident. */
2260 	uint32_t	ire_tire_mark;	/* Used for reclaim of unused. */
2261 	uchar_t		ire_ipversion;	/* IPv4/IPv6 version */
2262 	uchar_t		ire_marks;	/* IRE_MARK_CONDEMNED etc. */
2263 	ushort_t	ire_type;	/* Type of IRE */
2264 	uint_t	ire_ib_pkt_count;	/* Inbound packets for ire_addr */
2265 	uint_t	ire_ob_pkt_count;	/* Outbound packets to ire_addr */
2266 	uint_t	ire_ll_hdr_length;	/* Non-zero if we do M_DATA prepends */
2267 	time_t	ire_create_time;	/* Time (in secs) IRE was created. */
2268 	mblk_t		*ire_dlureq_mp;	/* DL_UNIT_DATA_REQ/RESOLVER mp */
2269 	uint32_t	ire_phandle;	/* Associate prefix IREs to cache */
2270 	uint32_t	ire_ihandle;	/* Associate interface IREs to cache */
2271 	ipif_t		*ire_ipif;	/* the interface that this ire uses */
2272 	uint32_t	ire_flags;	/* flags related to route (RTF_*) */
2273 	uint_t	ire_ipsec_overhead;	/* IPSEC overhead */
2274 	struct	nce_s	*ire_nce;	/* Neighbor Cache Entry for IPv6 */
2275 	uint_t		ire_masklen;	/* # bits in ire_mask{,_v6} */
2276 	ire_addr_u_t	ire_u;		/* IPv4/IPv6 address info. */
2277 
2278 	irb_t		*ire_bucket;	/* Hash bucket when ire_ptphn is set */
2279 	iulp_t		ire_uinfo;	/* Upper layer protocol info. */
2280 	/*
2281 	 * Protects ire_uinfo, ire_max_frag, and ire_frag_flag.
2282 	 */
2283 	kmutex_t	ire_lock;
2284 	uint_t		ire_ipif_seqid; /* ipif_seqid of ire_ipif */
2285 	/*
2286 	 * For regular routes in forwarding table and cache table the
2287 	 * the following entries are NULL/zero. Only reverse tunnel
2288 	 * table and interface based forwarding table use these fields.
2289 	 * Routes added with RTA_SRCIFP and RTA_SRC respectively have
2290 	 * non-zero values for the following fields.
2291 	 */
2292 	ill_t		*ire_in_ill;	/* Incoming ill interface */
2293 	ipaddr_t	ire_in_src_addr;
2294 					/* source ip-addr of incoming packet */
2295 	clock_t		ire_last_used_time;	/* Last used time */
2296 	struct ire_s 	*ire_fastpath;	/* Pointer to next ire in fastpath */
2297 	zoneid_t	ire_zoneid;	/* for local address discrimination */
2298 #ifdef IRE_DEBUG
2299 	th_trace_t	*ire_trace[IP_TR_HASH_MAX];
2300 	boolean_t	ire_trace_disable;	/* True when alloc fails */
2301 #endif
2302 } ire_t;
2303 
2304 /* IPv4 compatiblity macros */
2305 #define	ire_src_addr		ire_u.ire4_u.ire4_src_addr
2306 #define	ire_mask		ire_u.ire4_u.ire4_mask
2307 #define	ire_addr		ire_u.ire4_u.ire4_addr
2308 #define	ire_gateway_addr	ire_u.ire4_u.ire4_gateway_addr
2309 #define	ire_cmask		ire_u.ire4_u.ire4_cmask
2310 
2311 #define	ire_src_addr_v6		ire_u.ire6_u.ire6_src_addr
2312 #define	ire_mask_v6		ire_u.ire6_u.ire6_mask
2313 #define	ire_addr_v6		ire_u.ire6_u.ire6_addr
2314 #define	ire_gateway_addr_v6	ire_u.ire6_u.ire6_gateway_addr
2315 #define	ire_cmask_v6		ire_u.ire6_u.ire6_cmask
2316 
2317 /* Convenient typedefs for sockaddrs */
2318 typedef	struct sockaddr_in	sin_t;
2319 typedef	struct sockaddr_in6	sin6_t;
2320 
2321 /* Address structure used for internal bind with IP */
2322 typedef struct ipa_conn_s {
2323 	ipaddr_t	ac_laddr;
2324 	ipaddr_t	ac_faddr;
2325 	uint16_t	ac_fport;
2326 	uint16_t	ac_lport;
2327 } ipa_conn_t;
2328 
2329 typedef struct ipa6_conn_s {
2330 	in6_addr_t	ac6_laddr;
2331 	in6_addr_t	ac6_faddr;
2332 	uint16_t	ac6_fport;
2333 	uint16_t	ac6_lport;
2334 } ipa6_conn_t;
2335 
2336 /*
2337  * Using ipa_conn_x_t or ipa6_conn_x_t allows us to modify the behavior of IP's
2338  * bind handler.
2339  */
2340 typedef struct ipa_conn_extended_s {
2341 	uint64_t	acx_flags;
2342 	ipa_conn_t	acx_conn;
2343 } ipa_conn_x_t;
2344 
2345 typedef struct ipa6_conn_extended_s {
2346 	uint64_t	ac6x_flags;
2347 	ipa6_conn_t	ac6x_conn;
2348 } ipa6_conn_x_t;
2349 
2350 /* flag values for ipa_conn_x_t and ipa6_conn_x_t. */
2351 #define	ACX_VERIFY_DST	0x1ULL	/* verify destination address is reachable */
2352 
2353 /* Name/Value Descriptor. */
2354 typedef struct nv_s {
2355 	uint64_t nv_value;
2356 	char	*nv_name;
2357 } nv_t;
2358 
2359 /* IP Forwarding Ticket */
2360 typedef	struct ipftk_s {
2361 	queue_t	*ipftk_queue;
2362 	ipaddr_t ipftk_dst;
2363 } ipftk_t;
2364 
2365 typedef struct ipt_s {
2366 	pfv_t	func;		/* Routine to call */
2367 	uchar_t	*arg;		/* ire or nce passed in */
2368 } ipt_t;
2369 
2370 #define	ILL_FRAG_HASH(s, i) \
2371 	((ntohl(s) ^ ((i) ^ ((i) >> 8))) % ILL_FRAG_HASH_TBL_COUNT)
2372 
2373 /*
2374  * The MAX number of allowed fragmented packets per hash bucket
2375  * calculation is based on the most common mtu size of 1500. This limit
2376  * will work well for other mtu sizes as well.
2377  */
2378 #define	COMMON_IP_MTU 1500
2379 #define	MAX_FRAG_MIN 10
2380 #define	MAX_FRAG_PKTS	\
2381 	MAX(MAX_FRAG_MIN, (2 * (ip_reass_queue_bytes / \
2382 	    (COMMON_IP_MTU * ILL_FRAG_HASH_TBL_COUNT))))
2383 
2384 /*
2385  * Maximum dups allowed per packet.
2386  */
2387 extern uint_t ip_max_frag_dups;
2388 
2389 /*
2390  * Per-packet information for received packets and transmitted.
2391  * Used by the transport protocols when converting between the packet
2392  * and ancillary data and socket options.
2393  *
2394  * Note: This private data structure and related IPPF_* constant
2395  * definitions are exposed to enable compilation of some debugging tools
2396  * like lsof which use struct tcp_t in <inet/tcp.h>. This is intended to be
2397  * a temporary hack and long term alternate interfaces should be defined
2398  * to support the needs of such tools and private definitions moved to
2399  * private headers.
2400  */
2401 struct ip6_pkt_s {
2402 	uint_t		ipp_fields;		/* Which fields are valid */
2403 	uint_t		ipp_sticky_ignored;	/* sticky fields to ignore */
2404 	uint_t		ipp_ifindex;		/* pktinfo ifindex */
2405 	in6_addr_t	ipp_addr;		/* pktinfo src/dst addr */
2406 	uint_t		ipp_unicast_hops;	/* IPV6_UNICAST_HOPS */
2407 	uint_t		ipp_multicast_hops;	/* IPV6_MULTICAST_HOPS */
2408 	uint_t		ipp_hoplimit;		/* IPV6_HOPLIMIT */
2409 	uint_t		ipp_hopoptslen;
2410 	uint_t		ipp_rtdstoptslen;
2411 	uint_t		ipp_rthdrlen;
2412 	uint_t		ipp_dstoptslen;
2413 	uint_t		ipp_pathmtulen;
2414 	ip6_hbh_t	*ipp_hopopts;
2415 	ip6_dest_t	*ipp_rtdstopts;
2416 	ip6_rthdr_t	*ipp_rthdr;
2417 	ip6_dest_t	*ipp_dstopts;
2418 	struct ip6_mtuinfo *ipp_pathmtu;
2419 	in6_addr_t	ipp_nexthop;		/* Transmit only */
2420 	uint8_t		ipp_tclass;
2421 	int8_t		ipp_use_min_mtu;
2422 };
2423 typedef struct ip6_pkt_s ip6_pkt_t;
2424 
2425 /*
2426  * This structure is used to convey information from IP and the ULP.
2427  * Currently used for the IP_RECVSLLA and IP_RECVIF options. The
2428  * type of information field is set to IN_PKTINFO (i.e inbound pkt info)
2429  */
2430 typedef struct in_pktinfo {
2431 	uint32_t		in_pkt_ulp_type;	/* type of info sent */
2432 							/* to UDP */
2433 	uint32_t		in_pkt_flags;	/* what is sent up by IP */
2434 	uint32_t		in_pkt_ifindex;	/* inbound interface index */
2435 	struct sockaddr_dl	in_pkt_slla;	/* has source link layer addr */
2436 } in_pktinfo_t;
2437 
2438 /*
2439  * flags to tell UDP what IP is sending
2440  */
2441 #define	IPF_RECVIF	0x01	/* inbound interface index */
2442 #define	IPF_RECVSLLA	0x02	/* source link layer address */
2443 
2444 /* ipp_fields values */
2445 #define	IPPF_IFINDEX	0x0001	/* Part of in6_pktinfo: ifindex */
2446 #define	IPPF_ADDR	0x0002	/* Part of in6_pktinfo: src/dst addr */
2447 #define	IPPF_SCOPE_ID	0x0004	/* Add xmit ip6i_t for sin6_scope_id */
2448 #define	IPPF_NO_CKSUM	0x0008	/* Add xmit ip6i_t for IP6I_NO_*_CKSUM */
2449 
2450 #define	IPPF_RAW_CKSUM	0x0010	/* Add xmit ip6i_t for IP6I_RAW_CHECKSUM */
2451 #define	IPPF_HOPLIMIT	0x0020
2452 #define	IPPF_HOPOPTS	0x0040
2453 #define	IPPF_RTHDR	0x0080
2454 
2455 #define	IPPF_RTDSTOPTS	0x0100
2456 #define	IPPF_DSTOPTS	0x0200
2457 #define	IPPF_NEXTHOP	0x0400
2458 #define	IPPF_PATHMTU	0x0800
2459 
2460 #define	IPPF_TCLASS	0x1000
2461 #define	IPPF_DONTFRAG	0x2000
2462 #define	IPPF_USE_MIN_MTU	0x04000
2463 #define	IPPF_MULTICAST_HOPS	0x08000
2464 #define	IPPF_UNICAST_HOPS	0x10000
2465 
2466 #define	IPPF_HAS_IP6I \
2467 	(IPPF_IFINDEX|IPPF_ADDR|IPPF_NEXTHOP|IPPF_SCOPE_ID| \
2468 	IPPF_NO_CKSUM|IPPF_RAW_CKSUM|IPPF_HOPLIMIT|IPPF_DONTFRAG| \
2469 	IPPF_USE_MIN_MTU|IPPF_MULTICAST_HOPS|IPPF_UNICAST_HOPS)
2470 
2471 #define	TCP_PORTS_OFFSET	0
2472 #define	UDP_PORTS_OFFSET	0
2473 
2474 /*
2475  * lookups return the ill/ipif only if the flags are clear OR Iam writer.
2476  * ill / ipif lookup functions increment the refcnt on the ill / ipif only
2477  * after calling these macros. This ensures that the refcnt on the ipif or
2478  * ill will eventually drop down to zero.
2479  */
2480 #define	ILL_LOOKUP_FAILED	1	/* Used as error code */
2481 #define	IPIF_LOOKUP_FAILED	2	/* Used as error code */
2482 
2483 #define	ILL_CAN_LOOKUP(ill) 						\
2484 	(!((ill)->ill_state_flags & (ILL_CONDEMNED | ILL_CHANGING)) ||	\
2485 	IAM_WRITER_ILL(ill))
2486 
2487 #define	ILL_CAN_WAIT(ill, q)	\
2488 	(((q) != NULL) && !((ill)->ill_state_flags & (ILL_CONDEMNED)))
2489 
2490 #define	ILL_CAN_LOOKUP_WALKER(ill)	\
2491 	(!((ill)->ill_state_flags & ILL_CONDEMNED))
2492 
2493 #define	IPIF_CAN_LOOKUP(ipif)						\
2494 	(!((ipif)->ipif_state_flags & (IPIF_CONDEMNED | IPIF_CHANGING)) || \
2495 	IAM_WRITER_IPIF(ipif))
2496 
2497 /*
2498  * If the parameter 'q' is NULL, the caller is not interested in wait and
2499  * restart of the operation if the ILL or IPIF cannot be looked up when it is
2500  * marked as 'CHANGING'. Typically a thread that tries to send out data  will
2501  * end up passing NULLs as the last 4 parameters to ill_lookup_on_ifindex and
2502  * in this case 'q' is NULL
2503  */
2504 #define	IPIF_CAN_WAIT(ipif, q)	\
2505 	(((q) != NULL) && !((ipif)->ipif_state_flags & (IPIF_CONDEMNED)))
2506 
2507 #define	IPIF_CAN_LOOKUP_WALKER(ipif)					\
2508 	(!((ipif)->ipif_state_flags & (IPIF_CONDEMNED)) ||		\
2509 	IAM_WRITER_IPIF(ipif))
2510 
2511 /*
2512  * These macros are used by critical set ioctls and failover ioctls to
2513  * mark the ipif appropriately before starting the operation and to clear the
2514  * marks after completing the operation.
2515  */
2516 #define	IPIF_UNMARK_MOVING(ipif)                                \
2517 	(ipif)->ipif_state_flags &= ~IPIF_MOVING & ~IPIF_CHANGING;
2518 
2519 #define	ILL_UNMARK_CHANGING(ill)                                \
2520 	(ill)->ill_state_flags &= ~ILL_CHANGING;
2521 
2522 /* Macros used to assert that this thread is a writer  */
2523 #define	IAM_WRITER_IPSQ(ipsq)	((ipsq)->ipsq_writer == curthread)
2524 #define	IAM_WRITER_ILL(ill)					\
2525 	((ill)->ill_phyint->phyint_ipsq->ipsq_writer == curthread)
2526 #define	IAM_WRITER_IPIF(ipif)					\
2527 	((ipif)->ipif_ill->ill_phyint->phyint_ipsq->ipsq_writer == curthread)
2528 
2529 /*
2530  * Grab ill locks in the proper order. The order is highest addressed
2531  * ill is locked first.
2532  */
2533 #define	GRAB_ILL_LOCKS(ill_1, ill_2)				\
2534 {								\
2535 	if ((ill_1) > (ill_2)) {				\
2536 		if (ill_1 != NULL)				\
2537 			mutex_enter(&(ill_1)->ill_lock);	\
2538 		if (ill_2 != NULL)				\
2539 			mutex_enter(&(ill_2)->ill_lock);	\
2540 	} else {						\
2541 		if (ill_2 != NULL)				\
2542 			mutex_enter(&(ill_2)->ill_lock);	\
2543 		if (ill_1 != NULL && ill_1 != ill_2)		\
2544 			mutex_enter(&(ill_1)->ill_lock);	\
2545 	}							\
2546 }
2547 
2548 #define	RELEASE_ILL_LOCKS(ill_1, ill_2)		\
2549 {						\
2550 	if (ill_1 != NULL)			\
2551 		mutex_exit(&(ill_1)->ill_lock);	\
2552 	if (ill_2 != NULL && ill_2 != ill_1)	\
2553 		mutex_exit(&(ill_2)->ill_lock);	\
2554 }
2555 
2556 /* Get the other protocol instance ill */
2557 #define	ILL_OTHER(ill)						\
2558 	((ill)->ill_isv6 ? (ill)->ill_phyint->phyint_illv4 :	\
2559 	    (ill)->ill_phyint->phyint_illv6)
2560 
2561 #define	MATCH_V4_ONLY	0x1
2562 #define	MATCH_V6_ONLY	0x2
2563 #define	MATCH_ILL_ONLY	0x4
2564 
2565 /* ioctl command info: Ioctl properties extracted and stored in here */
2566 typedef struct cmd_info_s
2567 {
2568 	char    ci_groupname[LIFNAMSIZ + 1];	/* SIOCSLIFGROUPNAME */
2569 	ipif_t  *ci_ipif;	/* ipif associated with [l]ifreq ioctl's */
2570 	sin_t	*ci_sin;	/* the sin struct passed down */
2571 	sin6_t	*ci_sin6;	/* the sin6_t struct passed down */
2572 	struct lifreq *ci_lifr;	/* the lifreq struct passed down */
2573 } cmd_info_t;
2574 
2575 extern krwlock_t ill_g_lock;
2576 extern kmutex_t ip_addr_avail_lock;
2577 extern ipsq_t	*ipsq_g_head;
2578 
2579 extern ill_t	*ip_timer_ill;		/* ILL for IRE expiration timer. */
2580 extern timeout_id_t ip_ire_expire_id;	/* IRE expiration timeout id. */
2581 extern timeout_id_t ip_ire_reclaim_id;	/* IRE recalaim timeout id. */
2582 
2583 extern kmutex_t	ip_mi_lock;
2584 extern krwlock_t ip_g_nd_lock;		/* For adding/removing nd variables */
2585 extern kmutex_t ip_trash_timer_lock;	/* Protects ip_ire_expire_id */
2586 
2587 extern kmutex_t igmp_timer_lock;	/* Protects the igmp timer */
2588 extern kmutex_t mld_timer_lock;		/* Protects the mld timer */
2589 
2590 extern krwlock_t ill_g_usesrc_lock;	/* Protects usesrc related fields */
2591 
2592 extern struct kmem_cache *ire_cache;
2593 
2594 extern uint_t	ip_ire_default_count;	/* Number of IPv4 IRE_DEFAULT entries */
2595 extern uint_t	ip_ire_default_index;	/* Walking index used to mod in */
2596 
2597 extern ipaddr_t	ip_g_all_ones;
2598 extern caddr_t	ip_g_nd;		/* Named Dispatch List Head */
2599 
2600 extern uint_t	ip_loopback_mtu;
2601 
2602 extern ipparam_t	*ip_param_arr;
2603 
2604 extern int ip_g_forward;
2605 extern int ipv6_forward;
2606 extern vmem_t *ip_minor_arena;
2607 
2608 #define	ip_respond_to_address_mask_broadcast ip_param_arr[0].ip_param_value
2609 #define	ip_g_send_redirects		ip_param_arr[5].ip_param_value
2610 #define	ip_debug			ip_param_arr[7].ip_param_value
2611 #define	ip_mrtdebug			ip_param_arr[8].ip_param_value
2612 #define	ip_timer_interval		ip_param_arr[9].ip_param_value
2613 #define	ip_ire_arp_interval		ip_param_arr[10].ip_param_value
2614 #define	ip_def_ttl			ip_param_arr[12].ip_param_value
2615 #define	ip_wroff_extra			ip_param_arr[14].ip_param_value
2616 #define	ip_path_mtu_discovery		ip_param_arr[17].ip_param_value
2617 #define	ip_ignore_delete_time		ip_param_arr[18].ip_param_value
2618 #define	ip_output_queue			ip_param_arr[20].ip_param_value
2619 #define	ip_broadcast_ttl		ip_param_arr[21].ip_param_value
2620 #define	ip_icmp_err_interval		ip_param_arr[22].ip_param_value
2621 #define	ip_icmp_err_burst		ip_param_arr[23].ip_param_value
2622 #define	ip_reass_queue_bytes		ip_param_arr[24].ip_param_value
2623 #define	ip_addrs_per_if			ip_param_arr[26].ip_param_value
2624 #define	ipsec_override_persocket_policy	ip_param_arr[27].ip_param_value
2625 #define	icmp_accept_clear_messages	ip_param_arr[28].ip_param_value
2626 #define	delay_first_probe_time		ip_param_arr[30].ip_param_value
2627 #define	max_unicast_solicit		ip_param_arr[31].ip_param_value
2628 #define	ipv6_def_hops			ip_param_arr[32].ip_param_value
2629 #define	ipv6_icmp_return		ip_param_arr[33].ip_param_value
2630 #define	ipv6_forward_src_routed		ip_param_arr[34].ip_param_value
2631 #define	ipv6_resp_echo_mcast		ip_param_arr[35].ip_param_value
2632 #define	ipv6_send_redirects		ip_param_arr[36].ip_param_value
2633 #define	ipv6_ignore_redirect		ip_param_arr[37].ip_param_value
2634 #define	ipv6_strict_dst_multihoming	ip_param_arr[38].ip_param_value
2635 #define	ip_ire_reclaim_fraction		ip_param_arr[39].ip_param_value
2636 #define	ipsec_policy_log_interval	ip_param_arr[40].ip_param_value
2637 #define	ip_ndp_unsolicit_interval	ip_param_arr[42].ip_param_value
2638 #define	ip_ndp_unsolicit_count		ip_param_arr[43].ip_param_value
2639 #define	ipv6_ignore_home_address_opt	ip_param_arr[44].ip_param_value
2640 #define	ip_policy_mask			ip_param_arr[45].ip_param_value
2641 #define	ip_multirt_resolution_interval	ip_param_arr[46].ip_param_value
2642 #define	ip_multirt_ttl			ip_param_arr[47].ip_param_value
2643 #define	ip_multidata_outbound		ip_param_arr[48].ip_param_value
2644 #ifdef DEBUG
2645 #define	ipv6_drop_inbound_icmpv6	ip_param_arr[49].ip_param_value
2646 #else
2647 #define	ipv6_drop_inbound_icmpv6	0
2648 #endif
2649 
2650 extern hrtime_t	ipsec_policy_failure_last;
2651 
2652 extern int	dohwcksum;	/* use h/w cksum if supported by the h/w */
2653 #ifdef ZC_TEST
2654 extern int	noswcksum;
2655 #endif
2656 
2657 extern char	ipif_loopback_name[];
2658 
2659 extern nv_t	*ire_nv_tbl;
2660 
2661 extern time_t	ip_g_frag_timeout;
2662 extern clock_t	ip_g_frag_timo_ms;
2663 
2664 extern mib2_ip_t	ip_mib;	/* For tcpInErrs and udpNoPorts */
2665 
2666 extern struct module_info ip_mod_info;
2667 
2668 extern timeout_id_t	igmp_slowtimeout_id;
2669 extern timeout_id_t	mld_slowtimeout_id;
2670 
2671 extern uint_t	loopback_packets;
2672 
2673 /*
2674  * Network byte order macros
2675  */
2676 #ifdef	_BIG_ENDIAN
2677 #define	N_IN_CLASSD_NET		IN_CLASSD_NET
2678 #define	N_INADDR_UNSPEC_GROUP	INADDR_UNSPEC_GROUP
2679 #else /* _BIG_ENDIAN */
2680 #define	N_IN_CLASSD_NET		(ipaddr_t)0x000000f0U
2681 #define	N_INADDR_UNSPEC_GROUP	(ipaddr_t)0x000000e0U
2682 #endif /* _BIG_ENDIAN */
2683 #define	CLASSD(addr)	(((addr) & N_IN_CLASSD_NET) == N_INADDR_UNSPEC_GROUP)
2684 
2685 #ifdef DEBUG
2686 /* IPsec HW acceleration debugging support */
2687 
2688 #define	IPSECHW_CAPAB		0x0001	/* capability negotiation */
2689 #define	IPSECHW_SADB		0x0002	/* SADB exchange */
2690 #define	IPSECHW_PKT		0x0004	/* general packet flow */
2691 #define	IPSECHW_PKTIN		0x0008	/* driver in pkt processing details */
2692 #define	IPSECHW_PKTOUT		0x0010	/* driver out pkt processing details */
2693 
2694 #define	IPSECHW_DEBUG(f, x)	if (ipsechw_debug & (f)) { (void) printf x; }
2695 #define	IPSECHW_CALL(f, r, x)	if (ipsechw_debug & (f)) { (void) r x; }
2696 
2697 extern uint32_t ipsechw_debug;
2698 #else
2699 #define	IPSECHW_DEBUG(f, x)	{}
2700 #define	IPSECHW_CALL(f, r, x)	{}
2701 #endif
2702 
2703 #ifdef IP_DEBUG
2704 #include <sys/debug.h>
2705 #include <sys/promif.h>
2706 
2707 #define	ip0dbg(a)	printf a
2708 #define	ip1dbg(a)	if (ip_debug > 2) printf a
2709 #define	ip2dbg(a)	if (ip_debug > 3) printf a
2710 #define	ip3dbg(a)	if (ip_debug > 4) printf a
2711 #else
2712 #define	ip0dbg(a)	/* */
2713 #define	ip1dbg(a)	/* */
2714 #define	ip2dbg(a)	/* */
2715 #define	ip3dbg(a)	/* */
2716 #endif	/* IP_DEBUG */
2717 
2718 extern const char *dlpi_prim_str(int);
2719 extern const char *dlpi_err_str(int);
2720 extern void	ill_frag_timer(void *);
2721 extern ill_t	*ill_first(int, int, ill_walk_context_t *);
2722 extern ill_t	*ill_next(ill_walk_context_t *, ill_t *);
2723 extern void	ill_frag_timer_start(ill_t *);
2724 extern mblk_t	*ip_carve_mp(mblk_t **, ssize_t);
2725 extern mblk_t	*ip_dlpi_alloc(size_t, t_uscalar_t);
2726 extern char	*ip_dot_addr(ipaddr_t, char *);
2727 extern void	ip_lwput(queue_t *, mblk_t *);
2728 extern boolean_t icmp_err_rate_limit(void);
2729 extern void	icmp_time_exceeded(queue_t *, mblk_t *, uint8_t);
2730 extern void	icmp_unreachable(queue_t *, mblk_t *, uint8_t);
2731 extern mblk_t	*ip_add_info(mblk_t *, ill_t *, uint_t);
2732 extern mblk_t	*ip_bind_v4(queue_t *, mblk_t *, conn_t *);
2733 extern int	ip_bind_connected(conn_t *, mblk_t *, ipaddr_t *, uint16_t,
2734     ipaddr_t, uint16_t, boolean_t, boolean_t, boolean_t,
2735     boolean_t);
2736 extern boolean_t ip_bind_ipsec_policy_set(conn_t *, mblk_t *);
2737 extern int	ip_bind_laddr(conn_t *, mblk_t *, ipaddr_t, uint16_t,
2738     boolean_t, boolean_t, boolean_t);
2739 extern uint_t	ip_cksum(mblk_t *, int, uint32_t);
2740 extern int	ip_close(queue_t *, int);
2741 extern uint16_t	ip_csum_hdr(ipha_t *);
2742 extern void	ip_proto_not_sup(queue_t *, mblk_t *, uint_t, zoneid_t);
2743 extern void	ip_ire_fini(void);
2744 extern void	ip_ire_init(void);
2745 extern int	ip_open(queue_t *, dev_t *, int, int, cred_t *);
2746 extern int	ip_reassemble(mblk_t *, ipf_t *, uint_t, boolean_t, ill_t *,
2747     size_t);
2748 extern int	ip_opt_set_ill(conn_t *, int, boolean_t, boolean_t,
2749     int, int, mblk_t *);
2750 extern void	ip_rput(queue_t *, mblk_t *);
2751 extern void	ip_input(ill_t *, ill_rx_ring_t *, mblk_t *, size_t);
2752 extern void	ip_rput_dlpi(queue_t *, mblk_t *);
2753 extern void	ip_rput_forward(ire_t *, ipha_t *, mblk_t *, ill_t *);
2754 extern void	ip_rput_forward_multicast(ipaddr_t, mblk_t *, ipif_t *);
2755 
2756 extern int	ip_snmpmod_close(queue_t *);
2757 extern void	ip_snmpmod_wput(queue_t *, mblk_t *);
2758 extern void	ip_udp_input(queue_t *, mblk_t *, ipha_t *, ire_t *, ill_t *);
2759 extern void	ip_proto_input(queue_t *, mblk_t *, ipha_t *, ire_t *, ill_t *);
2760 extern void	ip_rput_other(ipsq_t *, queue_t *, mblk_t *, void *);
2761 extern void	ip_setqinfo(queue_t *, minor_t, boolean_t);
2762 extern void	ip_trash_ire_reclaim(void *);
2763 extern void	ip_trash_timer_expire(void *);
2764 extern void	ip_wput(queue_t *, mblk_t *);
2765 extern void	ip_output(void *, mblk_t *, void *, int);
2766 extern void	ip_wput_md(queue_t *, mblk_t *, conn_t *);
2767 
2768 extern void	ip_wput_ire(queue_t *, mblk_t *, ire_t *, conn_t *, int);
2769 extern void	ip_wput_local(queue_t *, ill_t *, ipha_t *, mblk_t *, ire_t *,
2770     int, zoneid_t);
2771 extern void	ip_wput_multicast(queue_t *, mblk_t *, ipif_t *);
2772 extern void	ip_wput_nondata(ipsq_t *, queue_t *, mblk_t *, void *);
2773 extern void	ip_wsrv(queue_t *);
2774 extern char	*ip_nv_lookup(nv_t *, int);
2775 extern boolean_t ip_local_addr_ok_v6(const in6_addr_t *, const in6_addr_t *);
2776 extern boolean_t ip_remote_addr_ok_v6(const in6_addr_t *, const in6_addr_t *);
2777 extern ipaddr_t ip_massage_options(ipha_t *);
2778 extern ipaddr_t ip_net_mask(ipaddr_t);
2779 extern void	ip_newroute(queue_t *, mblk_t *, ipaddr_t, ill_t *, conn_t *);
2780 
2781 extern struct qinit rinit_ipv6;
2782 extern struct qinit winit_ipv6;
2783 extern struct qinit rinit_tcp;
2784 extern struct qinit rinit_tcp6;
2785 extern struct qinit winit_tcp;
2786 extern struct qinit rinit_acceptor_tcp;
2787 extern struct qinit winit_acceptor_tcp;
2788 
2789 extern void	conn_drain_insert(conn_t *connp);
2790 extern	int	conn_ipsec_length(conn_t *connp);
2791 extern void	ip_wput_ipsec_out(queue_t *, mblk_t *, ipha_t *, ill_t *,
2792     ire_t *);
2793 extern ipaddr_t	ip_get_dst(ipha_t *);
2794 extern int	ipsec_out_extra_length(mblk_t *);
2795 extern int	ipsec_in_extra_length(mblk_t *);
2796 extern mblk_t	*ipsec_in_alloc();
2797 extern boolean_t ipsec_in_is_secure(mblk_t *);
2798 extern void	ipsec_out_process(queue_t *, mblk_t *, ire_t *, uint_t);
2799 extern void	ipsec_out_to_in(mblk_t *);
2800 extern int	ill_forward_set(queue_t *, mblk_t *, boolean_t, caddr_t);
2801 extern void	ip_fanout_proto_again(mblk_t *, ill_t *, ill_t *, ire_t *);
2802 
2803 extern void	ire_cleanup(ire_t *);
2804 extern void	ire_inactive(ire_t *);
2805 extern ire_t	*ire_unlink(irb_t *);
2806 #ifdef IRE_DEBUG
2807 extern	void	ire_trace_ref(ire_t *ire);
2808 extern	void	ire_untrace_ref(ire_t *ire);
2809 extern	void	ire_thread_exit(ire_t *ire, caddr_t);
2810 #endif
2811 #ifdef ILL_DEBUG
2812 extern	void	ill_trace_cleanup(ill_t *);
2813 extern	void	ipif_trace_cleanup(ipif_t *);
2814 #endif
2815 
2816 extern int	ip_srcid_insert(const in6_addr_t *, zoneid_t);
2817 extern int	ip_srcid_remove(const in6_addr_t *, zoneid_t);
2818 extern void	ip_srcid_find_id(uint_t, in6_addr_t *, zoneid_t);
2819 extern uint_t	ip_srcid_find_addr(const in6_addr_t *, zoneid_t);
2820 extern int	ip_srcid_report(queue_t *, mblk_t *, caddr_t, cred_t *);
2821 
2822 extern uint8_t	ipoptp_next(ipoptp_t *);
2823 extern uint8_t	ipoptp_first(ipoptp_t *, ipha_t *);
2824 extern ill_t	*ip_grab_attach_ill(ill_t *, mblk_t *, int, boolean_t);
2825 extern ire_t	*conn_set_outgoing_ill(conn_t *, ire_t *, ill_t **);
2826 extern int	ipsec_req_from_conn(conn_t *, ipsec_req_t *, int);
2827 extern int	ip_snmp_get(queue_t *q, mblk_t *mctl);
2828 extern int	ip_snmp_set(queue_t *q, int, int, uchar_t *, int);
2829 extern void	ip_process_ioctl(ipsq_t *, queue_t *, mblk_t *, void *);
2830 extern void	ip_quiesce_conn(conn_t *);
2831 extern  void    ip_reprocess_ioctl(ipsq_t *, queue_t *, mblk_t *, void *);
2832 extern void	ip_restart_optmgmt(ipsq_t *, queue_t *, mblk_t *, void *);
2833 extern void	ip_ioctl_finish(queue_t *, mblk_t *, int, int, ipif_t *,
2834     ipsq_t *);
2835 
2836 extern boolean_t	ipsq_pending_mp_cleanup(ill_t *, conn_t *);
2837 extern void	conn_ioctl_cleanup(conn_t *);
2838 extern ill_t	*conn_get_held_ill(conn_t *, ill_t **, int *);
2839 
2840 struct multidata_s;
2841 struct pdesc_s;
2842 
2843 extern mblk_t	*ip_mdinfo_alloc(ill_mdt_capab_t *);
2844 extern mblk_t	*ip_mdinfo_return(ire_t *, conn_t *, char *, ill_mdt_capab_t *);
2845 extern uint_t	ip_md_cksum(struct pdesc_s *, int, uint_t);
2846 extern boolean_t ip_md_addr_attr(struct multidata_s *, struct pdesc_s *,
2847 			const mblk_t *);
2848 extern boolean_t ip_md_hcksum_attr(struct multidata_s *, struct pdesc_s *,
2849 			uint32_t, uint32_t, uint32_t, uint32_t);
2850 extern boolean_t ip_md_zcopy_attr(struct multidata_s *, struct pdesc_s *,
2851 			uint_t);
2852 extern mblk_t	*ip_unbind(queue_t *, mblk_t *);
2853 
2854 /* Hooks for CGTP (multirt routes) filtering module */
2855 #define	CGTP_FILTER_REV_1	1
2856 #define	CGTP_FILTER_REV_2	2
2857 #define	CGTP_FILTER_REV		CGTP_FILTER_REV_2
2858 
2859 /* cfo_filter, cfo_filter_fp, cfo_filter_v6 hooks return values */
2860 #define	CGTP_IP_PKT_NOT_CGTP	0
2861 #define	CGTP_IP_PKT_PREMIUM	1
2862 #define	CGTP_IP_PKT_DUPLICATE	2
2863 
2864 typedef struct cgtp_filter_ops {
2865 	int	cfo_filter_rev;
2866 	int	(*cfo_change_state)(int);
2867 	int	(*cfo_add_dest_v4)(ipaddr_t, ipaddr_t, ipaddr_t, ipaddr_t);
2868 	int	(*cfo_del_dest_v4)(ipaddr_t, ipaddr_t);
2869 	int	(*cfo_add_dest_v6)(in6_addr_t *, in6_addr_t *, in6_addr_t *,
2870 		    in6_addr_t *);
2871 	int	(*cfo_del_dest_v6)(in6_addr_t *, in6_addr_t *);
2872 	int	(*cfo_filter)(queue_t *, mblk_t *);
2873 	int	(*cfo_filter_fp)(queue_t *, mblk_t *);
2874 	int	(*cfo_filter_v6)(queue_t *, ip6_t *, ip6_frag_t *);
2875 } cgtp_filter_ops_t;
2876 
2877 #define	CGTP_MCAST_SUCCESS	1
2878 
2879 extern cgtp_filter_ops_t *ip_cgtp_filter_ops;
2880 extern boolean_t ip_cgtp_filter;
2881 
2882 extern int	ip_cgtp_filter_supported(void);
2883 extern int	ip_cgtp_filter_register(cgtp_filter_ops_t *);
2884 
2885 /* Flags for ire_multirt_lookup() */
2886 
2887 #define	MULTIRT_USESTAMP	0x0001
2888 #define	MULTIRT_SETSTAMP	0x0002
2889 #define	MULTIRT_CACHEGW		0x0004
2890 
2891 /* Debug stuff for multirt route resolution. */
2892 #if defined(DEBUG) && !defined(__lint)
2893 /* Our "don't send, rather drop" flag. */
2894 #define	MULTIRT_DEBUG_FLAG	0x8000
2895 
2896 #define	MULTIRT_TRACE(x)	ip2dbg(x)
2897 
2898 #define	MULTIRT_DEBUG_TAG(mblk)	\
2899 	do { \
2900 		ASSERT(mblk != NULL); \
2901 		MULTIRT_TRACE(("%s[%d]: tagging mblk %p, tag was %d\n", \
2902 		__FILE__, __LINE__, \
2903 		(void *)(mblk), (mblk)->b_flag & MULTIRT_DEBUG_FLAG)); \
2904 		(mblk)->b_flag |= MULTIRT_DEBUG_FLAG; \
2905 	} while (0)
2906 
2907 #define	MULTIRT_DEBUG_UNTAG(mblk) \
2908 	do { \
2909 		ASSERT(mblk != NULL); \
2910 		MULTIRT_TRACE(("%s[%d]: untagging mblk %p, tag was %d\n", \
2911 		__FILE__, __LINE__, \
2912 		(void *)(mblk), (mblk)->b_flag & MULTIRT_DEBUG_FLAG)); \
2913 		(mblk)->b_flag &= ~MULTIRT_DEBUG_FLAG; \
2914 	} while (0)
2915 
2916 #define	MULTIRT_DEBUG_TAGGED(mblk) \
2917 	(((mblk)->b_flag & MULTIRT_DEBUG_FLAG) ? B_TRUE : B_FALSE)
2918 #else
2919 #define	MULTIRT_DEBUG_TAG(mblk)		ASSERT(mblk != NULL)
2920 #define	MULTIRT_DEBUG_UNTAG(mblk)	ASSERT(mblk != NULL)
2921 #define	MULTIRT_DEBUG_TAGGED(mblk)	B_FALSE
2922 #endif
2923 
2924 /*
2925  * Per-ILL Multidata Transmit capabilities.
2926  */
2927 struct ill_mdt_capab_s {
2928 	uint_t ill_mdt_version;  /* interface version */
2929 	uint_t ill_mdt_on;	 /* on/off switch for MDT on this ILL */
2930 	uint_t ill_mdt_hdr_head; /* leading header fragment extra space */
2931 	uint_t ill_mdt_hdr_tail; /* trailing header fragment extra space */
2932 	uint_t ill_mdt_max_pld;	 /* maximum payload buffers per Multidata */
2933 	uint_t ill_mdt_span_limit; /* maximum payload span per packet */
2934 };
2935 
2936 struct ill_hcksum_capab_s {
2937 	uint_t	ill_hcksum_version;	/* interface version */
2938 	uint_t	ill_hcksum_txflags;	/* capabilities on transmit */
2939 };
2940 
2941 struct ill_zerocopy_capab_s {
2942 	uint_t	ill_zerocopy_version;	/* interface version */
2943 	uint_t	ill_zerocopy_flags;	/* capabilities */
2944 };
2945 
2946 /* Possible ill_states */
2947 #define	ILL_RING_INPROC		3	/* Being assigned to squeue */
2948 #define	ILL_RING_INUSE		2	/* Already Assigned to Rx Ring */
2949 #define	ILL_RING_BEING_FREED	1	/* Being Unassigned */
2950 #define	ILL_RING_FREE		0	/* Available to be assigned to Ring */
2951 
2952 #define	ILL_MAX_RINGS		256	/* Max num of rx rings we can manage */
2953 #define	ILL_POLLING		0x01	/* Polling in use */
2954 
2955 /*
2956  * This function pointer type is exported by the mac layer.
2957  * we need to duplicate the definition here because we cannot
2958  * include mac.h in this file.
2959  */
2960 typedef void	(*ip_mac_blank_t)(void *, time_t, uint_t);
2961 
2962 struct ill_rx_ring {
2963 	ip_mac_blank_t		rr_blank; /* Driver interrupt blanking func */
2964 	void			*rr_handle; /* Handle for Rx ring */
2965 	squeue_t		*rr_sqp; /* Squeue the ring is bound to */
2966 	ill_t			*rr_ill; /* back pointer to ill */
2967 	clock_t			rr_poll_time; /* Last lbolt polling was used */
2968 	uint32_t		rr_poll_state; /* polling state flags */
2969 	uint32_t		rr_max_blank_time; /* Max interrupt blank */
2970 	uint32_t		rr_min_blank_time; /* Min interrupt blank */
2971 	uint32_t		rr_max_pkt_cnt; /* Max pkts before interrupt */
2972 	uint32_t		rr_min_pkt_cnt; /* Mix pkts before interrupt */
2973 	uint32_t		rr_normal_blank_time; /* Normal intr freq */
2974 	uint32_t		rr_normal_pkt_cnt; /* Normal intr pkt cnt */
2975 	uint32_t		rr_ring_state; /* State of this ring */
2976 };
2977 
2978 /*
2979  * This is exported by dld and is meant to be invoked from a ULP.
2980  */
2981 typedef void	(*ip_dld_tx_t)(void *, mblk_t *);
2982 
2983 struct ill_poll_capab_s {
2984 	ip_dld_tx_t		ill_tx;		/* dld-supplied tx routine */
2985 	void			*ill_tx_handle;	/* dld-supplied tx handle */
2986 	ill_rx_ring_t		*ill_ring_tbl; /* Ring to Sqp mapping table */
2987 	conn_t			*ill_unbind_conn; /* Conn used during unplumb */
2988 };
2989 
2990 /*
2991  * IP squeues exports
2992  */
2993 extern int 		ip_squeue_profile;
2994 extern int 		ip_squeue_bind;
2995 extern boolean_t 	ip_squeue_fanout;
2996 
2997 typedef struct squeue_set_s {
2998 	kmutex_t	sqs_lock;
2999 	struct squeue_s	**sqs_list;
3000 	int		sqs_size;
3001 	int		sqs_max_size;
3002 	processorid_t	sqs_bind;
3003 } squeue_set_t;
3004 
3005 #define	IP_SQUEUE_GET(hint) 						\
3006 	(!ip_squeue_fanout ?						\
3007 	(CPU->cpu_squeue_set->sqs_list[hint %				\
3008 					CPU->cpu_squeue_set->sqs_size]) : \
3009 	ip_squeue_random(hint))
3010 
3011 typedef void (*squeue_func_t)(squeue_t *, mblk_t *, sqproc_t, void *, uint8_t);
3012 
3013 extern void ip_squeue_init(void (*)(squeue_t *));
3014 extern squeue_t	*ip_squeue_random(uint_t);
3015 extern squeue_t *ip_squeue_get(ill_rx_ring_t *);
3016 extern void ip_squeue_get_pkts(squeue_t *);
3017 extern int ip_squeue_bind_set(queue_t *, mblk_t *, char *, caddr_t, cred_t *);
3018 extern int ip_squeue_bind_get(queue_t *, mblk_t *, caddr_t, cred_t *);
3019 extern void ip_squeue_clean(void *, mblk_t *, void *);
3020 extern void ip_resume_tcp_bind(void *, mblk_t *, void *);
3021 
3022 extern void tcp_wput(queue_t *, mblk_t *);
3023 
3024 extern int	ip_fill_mtuinfo(struct in6_addr *, in_port_t,
3025 	struct ip6_mtuinfo *);
3026 extern	ipif_t *conn_get_held_ipif(conn_t *, ipif_t **, int *);
3027 
3028 typedef void    (*ipsq_func_t)(ipsq_t *, queue_t *, mblk_t *, void *);
3029 
3030 /*
3031  * Squeue tags. Tags only need to be unique when the callback function is the
3032  * same to distinguish between different calls, but we use unique tags for
3033  * convenience anyway.
3034  */
3035 #define	SQTAG_IP_INPUT			1
3036 #define	SQTAG_TCP_INPUT_ICMP_ERR	2
3037 #define	SQTAG_TCP6_INPUT_ICMP_ERR	3
3038 #define	SQTAG_IP_TCP_INPUT		4
3039 #define	SQTAG_IP6_TCP_INPUT		5
3040 #define	SQTAG_IP_TCP_CLOSE		6
3041 #define	SQTAG_TCP_OUTPUT		7
3042 #define	SQTAG_TCP_TIMER			8
3043 #define	SQTAG_TCP_TIMEWAIT		9
3044 #define	SQTAG_TCP_ACCEPT_FINISH		10
3045 #define	SQTAG_TCP_ACCEPT_FINISH_Q0	11
3046 #define	SQTAG_TCP_ACCEPT_PENDING	12
3047 #define	SQTAG_TCP_LISTEN_DISCON		13
3048 #define	SQTAG_TCP_CONN_REQ		14
3049 #define	SQTAG_TCP_EAGER_BLOWOFF		15
3050 #define	SQTAG_TCP_EAGER_CLEANUP		16
3051 #define	SQTAG_TCP_EAGER_CLEANUP_Q0	17
3052 #define	SQTAG_TCP_CONN_IND		18
3053 #define	SQTAG_TCP_RSRV			19
3054 #define	SQTAG_TCP_ABORT_BUCKET		20
3055 #define	SQTAG_TCP_REINPUT		21
3056 #define	SQTAG_TCP_REINPUT_EAGER		22
3057 #define	SQTAG_TCP_INPUT_MCTL		23
3058 #define	SQTAG_TCP_RPUTOTHER		24
3059 #define	SQTAG_IP_PROTO_AGAIN		25
3060 #define	SQTAG_IP_FANOUT_TCP		26
3061 #define	SQTAG_IPSQ_CLEAN_RING		27
3062 #define	SQTAG_TCP_WPUT_OTHER		28
3063 #define	SQTAG_TCP_CONN_REQ_UNBOUND	29
3064 #define	SQTAG_TCP_SEND_PENDING		30
3065 #define	SQTAG_BIND_RETRY		31
3066 #define	SQTAG_UDP_FANOUT		32
3067 #define	SQTAG_UDP_INPUT			33
3068 #define	SQTAG_UDP_WPUT			34
3069 #define	SQTAG_UDP_OUTPUT		35
3070 #define	SQTAG_TCP_KSSL_INPUT		36
3071 
3072 #endif	/* _KERNEL */
3073 
3074 #ifdef	__cplusplus
3075 }
3076 #endif
3077 
3078 #endif	/* _INET_IP_H */
3079