1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23 * Use is subject to license terms.
24 */
25
26#ifndef	_INET_NCA_H
27#define	_INET_NCA_H
28
29#ifdef	__cplusplus
30extern "C" {
31#endif
32
33#include <sys/thread.h>
34#include <sys/door.h>
35#include <sys/disp.h>
36#include <sys/systm.h>
37#include <sys/processor.h>
38#include <sys/socket.h>
39#include <inet/common.h>
40#include <inet/ip.h>
41#include <inet/tcp.h>
42#include <inet/nca/ncadoorhdr.h>
43
44/*
45 * The NCA debugging facilities provided via ADB and MDB depend on a
46 * number of NCA implementation details.  In particular, note that:
47 *
48 *	* ADB macros *must* be revised whenever members are added or
49 *	  removed from the following structures:
50 *
51 *		nca_conn_t connf_t nca_cpu_t dcb_t hcb_t nca_if_t nca_io2_t
52 *		node_t nodef_t sqfan_t nca_squeue_t tb_t te_t ti_t tw_t
53 *
54 *	* ADB macros should be added when new core data structures are
55 *	  added to NCA.  Generally, if you had to put it in here, you
56 *	  need to write a macro for it.
57 *
58 *	* MDB has many dependencies on the way core data structures
59 *	  are connected.  In general, if you break these dependencies,
60 *	  the MDB NCA module will fail to build.  However, breakage
61 *	  may go undetected (for instance, changing a linked list
62 *	  into a circularly linked list).  If you have any doubts,
63 *	  inspect the NCA module source before committing your changes.
64 *
65 *	* MDB depends on the following variables (and their current
66 *	  semantics) in order to function correctly:
67 *
68 *		nca_conn_fanout nca_conn_fanout_size nca_gv nca_lru
69 *		urihash filehash
70 *
71 *	  If you change the names or *semantics* of these variables,
72 *	  you must modify the MDB module accordingly.
73 *
74 *	  In addition, you should consider whether the changes you've
75 *	  made should be reflected in the MDB dcmds themselves.
76 */
77
78/* The queue to make upcall on for NCAfs */
79extern queue_t *ncaupcallq;
80extern kmutex_t ncaupcallq_lock;
81
82extern int nca_logging_on;
83extern int nca_conn_fanout_size;
84extern boolean_t nca_deferred_oq_if;
85extern boolean_t nca_fanout_iq_if;
86
87/* Checksum pointer for no checksum */
88
89#define	NO_CKSUM (void *)-1
90
91/* undef any tcp.h:tcp_t members overloaded by the Solaris 8 tcp.h */
92
93#undef	tcp_last_rcv_lbolt
94#undef	tcp_state
95#undef	tcp_rto
96#undef	tcp_snd_ts_ok
97#undef	tcp_snd_ws_ok
98#undef	tcp_snxt
99#undef	tcp_swnd
100#undef	tcp_mss
101#undef	tcp_iss
102#undef	tcp_rnxt
103#undef	tcp_rwnd
104#undef	tcp_lport
105#undef	tcp_fport
106#undef	tcp_ports
107
108/* the iph_t is no longer defined in ip.h for Solaris 8 ? */
109
110/* Unaligned IP header */
111typedef struct iph_s {
112	uchar_t	iph_version_and_hdr_length;
113	uchar_t	iph_type_of_service;
114	uchar_t	iph_length[2];
115	uchar_t	iph_ident[2];
116	uchar_t	iph_fragment_offset_and_flags[2];
117	uchar_t	iph_ttl;
118	uchar_t	iph_protocol;
119	uchar_t	iph_hdr_checksum[2];
120	uchar_t	iph_src[4];
121	uchar_t	iph_dst[4];
122} iph_t;
123
124
125#define	true	B_TRUE			/* used with type boolean_t */
126#define	false	B_FALSE			/* used with type boolean_t */
127
128/*
129 * Power of 2^N Primes useful for hashing for N of 0-28,
130 * these primes are the nearest prime <= 2^N - 2^(N-2).
131 */
132
133#define	P2Ps() {0, 0, 0, 5, 11, 23, 47, 89, 191, 383, 761, 1531, 3067,	\
134		6143, 12281, 24571, 49139, 98299, 196597, 393209,	\
135		786431, 1572853, 3145721, 6291449, 12582893, 25165813,	\
136		50331599, 100663291, 201326557, 0}
137
138/*
139 * Serialization queue type (move to strsubr.h (stream.h?) as a general
140 * purpose lightweight mechanism for mblk_t serialization ?).
141 */
142typedef struct nca_squeue_s {
143	uint16_t	sq_state;	/* state flags */
144	uint16_t	sq_count;	/* message count */
145	uint32_t	sq_type;	/* type flags */
146	processorid_t	sq_bind;	/* processor to bind to */
147	ddi_softintr_t	sq_softid;	/* softintr() id */
148	void		(*sq_init)();	/* initialize function */
149	void		*sq_init_arg;	/* initialize argument */
150	void		(*sq_proc)();	/* process function */
151	mblk_t		*sq_first;	/* first mblk chain or NULL */
152	mblk_t		*sq_last;	/* last mblk chain or NULL */
153	clock_t		sq_wait;	/* lbolts to wait after a fill() */
154	clock_t		sq_iwait;	/* lbolt after nointr() */
155	clock_t		sq_pwait;	/* lbolt after pause() */
156	int		sq_isintr;	/* is being or was serviced by */
157	timeout_id_t	sq_tid;		/* timer id of pending timeout() */
158	kcondvar_t	sq_async;	/* async thread blocks on */
159	kmutex_t	sq_lock;	/* lock before using any member */
160	clock_t		sq_awaken;	/* time async thread was awakened */
161	void		*sq_priv;	/* user defined private */
162	kt_did_t	sq_ktid;	/* kernel thread id */
163} nca_squeue_t;
164
165/*
166 * State flags and message count (i.e. properties that change)
167 * Note: The MDB NCA module depends on the values of these flags.
168 */
169
170#define	SQS_CNT_TOOMANY	0x8000	/* message count toomany */
171
172/* nca_squeue_t state flags now only 16 bits */
173
174#define	SQS_PROC	0x0001	/* being processed */
175#define	SQS_WORKER	0x0002	/* worker thread */
176#define	SQS_ENTER	0x0004	/* enter thread */
177#define	SQS_FAST	0x0008	/* enter-fast thread */
178#define	SQS_PROXY	0x0010	/* proxy thread */
179#define	SQS_SOFTINTR	0x0020	/* softint thread */
180				/* 0x00C0 bits not used */
181
182#define	SQS_NOINTR	0x0100	/* no interrupt processing */
183#define	SQS_PAUSE	0x0200	/* paused */
184#define	SQS_INTRWAIT	0x0400	/* interrupt waiting */
185#define	SQS_NOPROC	0x0800	/* no processing */
186				/* 0x7000 bits not used */
187#define	SQS_EXIT	0x8000	/* worker(s) exit */
188
189/*
190 * Type flags (i.e. properties that don't change).
191 * Note: The MDB NCA module depends on the values of these flags.
192 */
193
194#define	SQT_BIND_MASK	0xFF000000	/* bind flags mask */
195
196#define	SQT_KMEM	0x00000001	/* was kmem_alloc()ed */
197#define	SQT_DEFERRED	0x00000002	/* deferred processing */
198#define	SQT_SOFTINTR	0x00000004	/* use softintr() */
199
200#define	SQT_BIND_ANY	0x01000000	/* bind worker thread to any CPU */
201#define	SQT_BIND_TO	0x02000000	/* bind worker thread to speced CPU */
202
203#define	SQ_STATE_IS(sqp, flags) ((sqp)->sq_state & (flags))
204#define	SQ_TYPE_IS(sqp, flags) ((sqp)->sq_type & (flags))
205
206
207typedef struct sqfan_s {
208	uint32_t	flg;		/* flags only */
209	uint32_t	cnt;		/* vector count */
210	uint32_t	ix;		/* next sqv[] to process */
211	uint32_t	drain;		/* max mblk(s) draind per */
212	nca_squeue_t	**sqv;	/* pointer to nca_squeue_t pointer vector */
213} sqfan_t;
214
215#define	SQF_DIST_CNT	0x0001	/* sqfan_t dist by queue count */
216#define	SQF_DIST_IPv4	0x0002	/* sqfan_t dist by IPv4 src addr */
217
218/*
219 * A multiphase timer is implemented using the te_t, tb_t, and ti_t structs.
220 *
221 * The multiple phases of timer entry execution are:
222 *
223 * 1) resource, execution is done from resource reclaim when the timer event
224 *    is the freeing of the timed resource.
225 *
226 * 2) process, execution is done from process thread yield (idle/return).
227 *
228 * 3) time, execution is done from a timeout callback thread.
229 *
230 * Each of the phases have a seperate timer fire time represented by the
231 * the ti_t members lbolt1, lbolt2, and lbolt3. Each lbolt is an absolute
232 * lbolt value with lbolt1 <= lbolt2 <= lbolt3.
233 */
234
235/*
236 * te_t - timer entry.
237 */
238
239typedef struct te_s {
240	struct te_s *prev;	/* prev te_t */
241	struct te_s *next;	/* next te_t */
242	struct tb_s *tbp;	/* pointer to timer bucket */
243	void	*ep;		/* pointer to encapsulating struct */
244} te_t;
245
246/*
247 * tb_t - timer bucket.
248 */
249
250typedef struct tb_s {
251	struct tb_s *next;	/* next tb_t in ascending time order */
252	clock_t	exec;		/* te_t lbolt exec value for bucket */
253	te_t	*head;		/* head of te_t list (first timer) */
254	te_t	*tail;		/* tail of te_t list (last timer) */
255} tb_t;
256
257/*
258 * ti_t - timer state.
259 */
260
261typedef struct ti_s {
262	clock_t	exec;		/* next te_t exec value (0 = NONE) */
263	clock_t	lbolt1;		/* phase1 lbolt1 (0 = NONE) */
264	clock_t	lbolt2;		/* phase2 lbolt2 (0 = NONE) */
265	clock_t	lbolt3;		/* phase3 lbolt3 (0 = NONE) */
266	tb_t	*head;		/* head of tb_t list (first timer bucket) */
267	tb_t	*tail;		/* tail of tb_t list (last timer bucket) */
268	timeout_id_t tid;	/* timer id of pending timeout() (0 = NONE) */
269	void	*ep;		/* pointer to encapsulating struct */
270} ti_t;
271
272#define	NCA_TI_INPROC	-1	/* Processing going on */
273#define	NCA_TI_NONE	0	/* no lbolt */
274
275/*
276 * TIME_WAIT grounded doubly linked list of nca_conn_t's awaiting TIME_WAIT
277 * expiration for. This list is used for reclaim, reap, and timer based
278 * processing.
279 *
280 * A multiphase timer is used:
281 *
282 * phase 1) reclaim of connections during connection allocation
283 *
284 * phase 2) reaping of connections during nca_squeue_t inq thread unwind
285 *
286 * phase 3) timeout of connections as a result of a timeout().
287 *
288 * Each of the phases have a seperate timer fire lbolt represented by the
289 * the members lbolt1, lbolt2, and lbolt3, each is an absolute lbolt value
290 * with lbolt1 <= lbolt2 <= lbolt3.
291 */
292
293typedef struct tw_s {
294	clock_t	lbolt1;		/* phase1 lbolt value (0 = NONE) */
295	clock_t	lbolt2;		/* phase2 lbolt value  */
296	clock_t	lbolt3;		/* phase3 lbolt value  */
297	struct nca_conn_s *head;	/* Head of nca_conn_t list */
298	struct nca_conn_s *tail;	/* Tail of nca_conn_t list */
299	timeout_id_t tid;	/* Timer id of pending timeout() (0 = NONE) */
300	void	*ep;		/* pointer to encapsulating struct */
301} tw_t;
302
303#define	NCA_TW_NONE	0	/* no lbolt */
304
305#define	NCA_TW_MS	1000
306
307#define	NCA_TW_LBOLT MSEC_TO_TICK(NCA_TW_MS)
308
309#define	NCA_TW_LBOLTS(twp, future) {					\
310	clock_t	_lbolt = (future);					\
311	clock_t	_mod = _lbolt % NCA_TW_LBOLT;				\
312									\
313	if (_mod) {							\
314		/* Roundup to next TIME_WAIT bucket */			\
315		_lbolt += NCA_TW_LBOLT - _mod;				\
316	}								\
317	if ((twp)->lbolt1 != _lbolt) {					\
318		(twp)->lbolt1 = _lbolt;					\
319		_lbolt += NCA_TW_LBOLT;					\
320		(twp)->lbolt2 = _lbolt;					\
321		_lbolt += NCA_TW_LBOLT;					\
322		(twp)->lbolt3 = _lbolt;					\
323		if ((twp)->tid != 0) {					\
324			(void) untimeout((twp)->tid);			\
325			(twp)->tid = 0;					\
326		}							\
327		if ((_lbolt) != NCA_TW_NONE) {				\
328			(twp)->tid = timeout((pfv_t)nca_tw_fire, (twp),	\
329			    (twp)->lbolt3 - ddi_get_lbolt());		\
330		}							\
331	}								\
332}
333
334/*
335 * The Node Fanout structure.
336 *
337 * The hash tables and their linkage (hashnext) are protected by the
338 * per-bucket lock. Each node_t inserted in the list points back at
339 * the nodef_t that heads the bucket (hashfanout).
340 */
341
342typedef struct nodef_s {
343	struct node_s	*head;
344	kmutex_t	lock;
345} nodef_t;
346
347/*
348 * A node_t is used to represent a cached byte-stream object. A node_t is
349 * in one of four active states:
350 *
351 * 1) path != NULL, member of a node_t hash list with an object description
352 *    (hashnext, size, path, pathsz members valid).
353 *
354 * 2) pp != NULL, 1) + phys pages allocated (pp, plrupn, plrunn members valid).
355 *
356 * 3) data != NULL, 2) + virt mapping allocated (data, datasz, vlrupn, vlrunn
357 *    members valid).
358 *
359 * 4) cksum != NULL 3) + checksum mapping allocated
360 */
361
362typedef struct node_s {
363	uint32_t 	ref;		/* ref (see below) state */
364	uint32_t 	cnt;		/* ref count */
365	int32_t		size;		/* object size (-1 = UNKNOWN) */
366	uint32_t	mss;		/* mblk(s) in size mss */
367	uint64_t	ctag;		/* usr defined cache tag, 0 => no tag */
368	ipaddr_t	laddr;		/* local IP, for virtual hosting */
369	uint16_t	lport;		/* local port, for virtual hosting */
370
371	struct node_s	*plrunn;	/* Phys LRU list next node_t */
372	struct node_s	*plrupn;	/* Phys LRU list previous node_t */
373	struct node_s	*vlrunn;	/* Virt LRU list next node_t */
374	struct node_s	*vlrupn;	/* Virt LRU list previous node_t */
375
376	nodef_t	*hashfanout;		/* hash bucket we're part of */
377	nodef_t	*ctaghashfanout;	/* ctaghash bucket we're part off */
378	struct node_s *hashnext;	/* hash list next node_t */
379	struct node_s *ctaghashnext;	/* ctaghash list next node_t */
380	struct nca_conn_s *connhead;	/* head of list of conn(s) in miss */
381	struct nca_conn_s *conntail;	/* tail of list of conn(s) in miss */
382	struct node_s *next;		/* needed if data is in chunks */
383	struct node_s *back;		/* needed if data is in chunks */
384
385	clock_t	expire;		/* lbolt node_t expires (0 = NOW, -1 = NEVER) */
386	time_t	lastmod;	/* HTTP "Last-Modified:" value */
387
388	mblk_t	*req;		/* whole HTTP request (including headers) */
389	int	reqsz;		/* size of above */
390	int	reqcontl;	/* HTTP "Content-Length:" value */
391	uint32_t rcv_cnt;	/* rcv_list byte count */
392	mblk_t	*rcv_head;	/* rcv_list head */
393	mblk_t	*rcv_tail;	/* rcv_list tail */
394	mblk_t	*rcv_ptr;	/* rcv_list pointer */
395
396	nca_squeue_t *sqp;	/* squeue node_t is being processed from */
397	char	*path;		/* URI path component */
398	int	pathsz;		/* size of above */
399	uint_t	method;		/* HTTP request method */
400	uint_t	version;	/* HTTP request version */
401	char	*reqhdr;	/* HTTP request header(s) */
402	int	reqhdrsz;	/* size of above */
403	char	*reqhost;	/* HTTP "Host:" string */
404	int	reqhostsz;	/* size of above */
405	char	*reqaccept;	/* HTTP "Accept:" string */
406	int	reqacceptsz;	/* size of above */
407	char	*reqacceptl;	/* HTTP "Accept-Language:" string */
408	int	reqacceptlsz;	/* size of above */
409
410	page_t	**pp;		/* page pointer vector for data */
411	char	*data;		/* data buffer */
412	int	datasz;		/* size of above */
413	uint16_t *cksum;	/* cksum() vector for data by mss */
414	size_t	cksumlen;	/* length of memory block for above vector */
415	uint_t	resbody;	/* HTTP response body at &data[resbody] */
416
417	int	hlen;		/* data buffer split header len */
418	int	fileoff;	/* file include offset */
419	int	filelen;	/* length of file */
420	struct node_s *fileback; /* head node_t of a file list (-1 for death) */
421	struct node_s *filenext; /* next node_t of a file list */
422	struct node_s *ctagback; /* head node_t of a ctag list */
423	struct node_s *ctagnext; /* next node_t of a ctag list */
424	vnode_t	*filevp;	/* vnode for the file */
425
426	kmutex_t lock;		/* serializes access to node_t */
427	frtn_t	frtn;		/* STREAMS free routine; always node_freeb() */
428	boolean_t headchunk;	/* true if this node is the head chunk */
429
430	/*
431	 * The following 4 fields are used to record node states when
432	 * upcalls are preempted. When preempted upcalls are not relevant,
433	 * these fields should have default value 0.
434	 */
435	uint8_t advise;		/* an interpreted advise from http */
436	boolean_t last_advisory; /* preempted upcall state -- advisory bit */
437	boolean_t advisory;	/* need advisory from httpd before use */
438	boolean_t first_upcall;	/* node in first upcall, a internal state */
439
440	kcondvar_t cv;		/* sync upcall/downcall process on a node */
441	int	onqueue;	/* == 1 if on miss_queue, debug aid */
442} node_t;
443
444/* Note: The MDB NCA module depends on the values of these flags. */
445
446#define	REF_URI		0x80000000 /* & ref = node_t URI hashed */
447#define	REF_PHYS	0x40000000 /* & ref = phys mapping in-use */
448#define	REF_VIRT	0x20000000 /* & ref = virt mapping in-use */
449#define	REF_CKSUM	0x10000000 /* & ref = checksum mapping in-use */
450#define	REF_KMEM	0x08000000 /* & ref = kmem mapped (PHYS|VIRT) */
451#define	REF_DONE	0x04000000 /* & ref = node_t fill is done */
452#define	REF_SAFED	0x02000000 /* & ref = node_t not safe for use */
453#define	REF_FILE	0x01000000 /* & ref = node_t filename hashed */
454#define	REF_RESP	0x00800000 /* & ref = node_t response header parsed */
455#define	REF_NOLRU	0x00400000 /* & ref = node_t not safe for lru reclaim */
456#define	REF_MISS	0x00200000 /* & ref = node_t is/will missed() proc */
457#define	REF_ONPLRU	0x00100000 /* & ref = node_t is on Phys LRU */
458#define	REF_ONVLRU	0x00080000 /* & ref = node_t is on Virt LRU */
459#define	REF_PREEMPT	0x00040000 /* & ref = node_t processing preempted */
460#define	REF_CTAG	0x00020000 /* & ref = node_t CTAG hashed */
461#define	REF_UPCALL	0x00010000 /* & ref = node_t upcall not yet complete */
462#define	REF_OWNED	0x00008000 /* & ref = node_t owned (won't be freed) */
463#define	REF_ERROR	0x00004000 /* & ref = node_t errored */
464#define	REF_VNODE	0x00002000 /* & ref = node_t vnode hashed */
465#define	REF_NCAFS	0x00001000 /* & ref = node_t is NCAfs required */
466#define	REF_SEGMAP	0x00000800 /* & ref = segmapped (PHYS|VIRT) */
467#define	REF_UNUSED	0x000007FF /* & ref = UNUSED */
468/*
469 * Mappings where no seperate PHYS and VIRT, i.e. single mapping with a
470 * virtual address e.g. REF_KMEM and REF_SEGMAP.
471 */
472#define	REF_NOVIRT	(REF_KMEM | REF_SEGMAP)
473
474/* Is this node safe for reclaim ? */
475#define	REF_RECLAIM	(REF_SAFED | REF_NOLRU | REF_MISS)
476
477/*
478 * NCA node_t reference counting is more complicated than nca_conn_t reference
479 * counting because we pass parts of node_t's (masquerading as dblk
480 * buffers) into the STREAMS subsystem which eventually get freed by
481 * network drivers just like regular dblk buffers.  Also, unlike nca_conn_t's,
482 * we may wish to keep a node_t around even after there are no outstanding
483 * references, since it's possible that it will be requested again.
484 *
485 * Thus, the node_t reference count reflects the number of active codepaths
486 * in Solaris making use of a given node_t -- each codepath that requires
487 * that the node_t stick around once it drops the node_t lock must acquire
488 * a reference via NODE_REFHOLD and drop that reference via NODE_REFRELE
489 * when done.  Note that following a NODE_REFRELE the node that was
490 * released may no longer exist and thus it should not be referenced unless
491 * the codepath has another outstanding reference.  When a node_t is passed
492 * into the STREAMS subsystem via desballoc() and related interfaces, a
493 * NODE_REFHOLD should be placed on the node_t and the free routine should
494 * be set to node_freeb(), which will in turn call NODE_REFRELE.
495 *
496 * The concept of node ownership allows NCA to express that it would like
497 * this node to hang around, even if there are no "explicit" references to
498 * it (the ownership counts as an implicit reference).  All "headchunk"
499 * hashed nodes are owned when they are created.  If they subsequently
500 * become disowned (currently via nca_node_del() or nca_reclaim_vlru()),
501 * they may have some or all their resources freed (via node_fr()) as soon
502 * as the last reference to them is removed.  Note that it's possible that
503 * a disowned node may become of interest again before some or all of its
504 * resources were reclaimed -- in this case, it must be reowned via
505 * NODE_OWN.  Note that an unhashed node should never be owned, though it
506 * of course may be held and released; this is because there is no sense
507 * in owning a node which is merely temporary (i.e., not hashed somewhere).
508 * Note that the corollary of this statement is not true -- that is, just
509 * because a node is hashed does not mean it is owned (it may have been
510 * disowned via nca_reclaim_vlru()) -- this is why code must always reown
511 * hashed nodes if it's desirable to have them stick around.
512 *
513 * All four macros *must* be called with the node lock held.  However,
514 * NODE_DISOWN and NODE_REFRELE return with the lock unlocked (if there is
515 * still a lock at all), because the operation may have just removed the
516 * final reference to a node and it may no longer exist.
517 *
518 * A version of NODE_REFRELE is provided which doesn't unlock the lock but
519 * can only be used when the caller can gaurantee that it's not the last ref
520 * (e.g. the caller has another outstanding reference) as if it's the last
521 * ref the node_t may no longer exist. The new macro is NODE_REFRELE_LOCKED.
522 */
523
524#define	NODE_DISOWN(np) {						\
525									\
526	NODE_T_TRACE((np), NODE_T_TRACE_DISOWN);			\
527	ASSERT(mutex_owned(&(np)->lock));				\
528									\
529	if ((np)->ref & REF_OWNED) {					\
530		if ((np)->cnt == 0)	{				\
531			panic("nca NODE_DISOWN: %p has no references",	\
532			    (void *)(np));				\
533		}							\
534		(np)->ref &= ~REF_OWNED;				\
535		NODE_REFRELE(np);					\
536	} else {							\
537		mutex_exit(&(np)->lock);				\
538	}								\
539}
540
541#define	NODE_OWN(np) {							\
542									\
543	NODE_T_TRACE((np), NODE_T_TRACE_OWN);				\
544	ASSERT(mutex_owned(&(np)->lock));				\
545									\
546	if (!((np)->ref & REF_OWNED)) {					\
547		if ((np)->cnt == UINT_MAX)				\
548			panic(						\
549			    "nca NODE_OWN: %p has too many references",	\
550			    (void *)(np));				\
551		(np)->ref |= REF_OWNED;					\
552		(np)->cnt++;						\
553	}								\
554}
555
556#define	NODE_REFHOLD(np) {						\
557									\
558	NODE_T_TRACE((np), NODE_T_TRACE_REFHOLD | ((np)->cnt + 1));	\
559	ASSERT(mutex_owned(&(np)->lock));				\
560									\
561	if ((np)->cnt == UINT_MAX)					\
562		panic("nca NODE_REFHOLD: %p has too many references",	\
563		    (void *)(np));					\
564	(np)->cnt++;							\
565}
566
567#define	NODE_REFRELE(np) {						\
568									\
569	NODE_T_TRACE((np), NODE_T_TRACE_REFRELE | ((np)->cnt - 1));	\
570	ASSERT(mutex_owned(&(np)->lock));				\
571									\
572	if (((np)->ref & REF_OWNED) && (np)->cnt == 1)			\
573		panic(							\
574		    "nca NODE_REFRELE: %p has only OWNED reference",	\
575		    (void *)(np));					\
576	if ((np)->cnt == 0)						\
577		panic("nca NODE_REFRELE: %p has no references",		\
578		    (void *)(np));					\
579	(np)->cnt--;							\
580	if ((np)->cnt == 0) {						\
581		ASSERT(((np)->ref & REF_OWNED) == 0);			\
582		node_fr(np);		/* node_fr unlocks the lock */	\
583	} else {							\
584		mutex_exit(&(np)->lock);				\
585	}								\
586}
587
588#define	NODE_REFRELE_LOCKED(np) {					\
589	uint_t	_cnt = (np)->cnt;					\
590									\
591	NODE_T_TRACE((np), NODE_T_TRACE_REFRELE | (_cnt - 1));		\
592	ASSERT(mutex_owned(&(np)->lock));				\
593									\
594	if ((np)->ref & REF_OWNED)					\
595		_cnt--;							\
596	if (((np)->ref & REF_OWNED) && _cnt == 0)			\
597		panic("nca NODE_REFRELE_LOCKED: "			\
598		    "%p has only OWNED reference", (void *)(np));	\
599	if (_cnt == 0)							\
600		panic("nca NODE_REFRELEL_LOCKED: "			\
601		    "%p has no references", (void *)(np));		\
602	if (_cnt == 1)							\
603		panic("nca NODE_REFRELEL_LOCKED: "			\
604		    "%p has only one reference", (void *)(np));		\
605	(np)->cnt--;							\
606}
607
608
609/*
610 * NODE_T_TRACE - trace node_t events.
611 *
612 * adb:
613 * 32 bit
614 *	*node_tp,0t8192-(((*node_tp)-node_tv)%0t48)/PXXDDnPnPnPnPnPnPnPnn
615 *	node_tv,((*node_tp)-node_tv)%0t48/PXXDDnPnPnPnPnPnPnPnn
616 *
617 * 64 bit
618 *	*node_tp,0t8192-(((*node_tp)-node_tv)%0t56)/PXXDDnXnXnXnXnXnXnXnn
619 *	node_tv,((*node_tp)-node_tv)%0t56/PXXDDnXnXnXnXnXnXnXnn
620 *
621 * For incremental node tracing, note the value of node_tp (node_tp/X) after
622 * a run, then replace that in the 2nd line for node_tv.
623 */
624
625#define	NODE_T_STK_DEPTH	6
626
627struct node_ts {
628	node_t	*node;
629	unsigned action;
630	unsigned ref;
631	unsigned cnt;
632	int	cpu;
633	pc_t	stk[NODE_T_STK_DEPTH + 1];
634};
635
636#undef	NODE_T_TRACE_ON
637
638#ifdef	NODE_T_TRACE_ON
639
640#define	NODE_T_TRACE_ALLOC	0xFF000000	/* kmem_alloc() of */
641#define	NODE_T_TRACE_ADD	0xFE000000	/* node_add() */
642
643#define	NODE_T_TRACE_OWN	0xEF000000	/* node has been owned */
644#define	NODE_T_TRACE_DISOWN	0xEE000000	/* node has been disowned */
645#define	NODE_T_TRACE_DESBALLOC	0xED000000	/* desballoc() */
646#define	NODE_T_TRACE_REFRELE	0xEC000000	/* refrele */
647#define	NODE_T_TRACE_REFHOLD	0xEB000000	/* refhold */
648#define	NODE_T_TRACE_NODE_FR	0xEA000000	/* node_fr() */
649
650#define	NODE_T_TRACE_TEMPNODE	0xDF000000	/* node_temp() */
651#define	NODE_T_TRACE_REPLACE	0xDE000000	/* node_replace() */
652#define	NODE_T_TRACE_FLUSH	0xDD000000	/* node_flush() */
653#define	NODE_T_TRACE_DOWNCALL	0xDC000000	/* downcall_service() */
654#define	NODE_T_TRACE_DOWNCALL_2	0xDB000000	/* dcall_service->httpd_data */
655
656#define	NODE_T_TRACE_DATA	0xCF000000	/* httpd_data() */
657
658#define	NODE_T_TRACE_LRU	0xAF000000	/* nca_lru insert */
659#define	NODE_T_TRACE_HTTPD	0xAE000000	/* call nca_httpd() */
660#define	NODE_T_TRACE_MISS	0xAD000000	/* http_miss() */
661#define	NODE_T_TRACE_TEMP	0xAC000000	/* np != *npp */
662#define	NODE_T_TRACE_XMIT	0xAB000000	/* tcp_xmit() */
663#define	NODE_T_TRACE_MISSED	0xAA000000	/* nca_missed() */
664
665#define	NODE_T_TRACE_DEL	0x00000000	/* node_del() */
666
667#if defined(__i386) || defined(__amd64)
668#define	NODE_T_TRACE_STK() {						\
669	_ix = getpcstack(&_p->stk[0], NODE_T_STK_DEPTH + 1);		\
670	if (_ix < NODE_T_STK_DEPTH + 1) {				\
671		_p->stk[_ix + 1] = 0;					\
672	}								\
673}
674#else
675#define	NODE_T_TRACE_STK() {						\
676	_p->stk[0] = (pc_t)callee();					\
677	_ix = getpcstack(&_p->stk[1], NODE_T_STK_DEPTH);		\
678	if (_ix < NODE_T_STK_DEPTH) {					\
679		_p->stk[_ix + 1] = 0;					\
680	}								\
681}
682#endif
683
684#define	NODE_TV_SZ 8192
685
686extern struct node_ts node_tv[NODE_TV_SZ];
687extern struct node_ts *node_tp;
688
689#define	NODE_T_TRACE(p, a) {						\
690	struct node_ts *_p;						\
691	struct node_ts *_np;						\
692	int    _ix;							\
693									\
694	do {								\
695		_p = node_tp;						\
696		if ((_np = _p + 1) == &node_tv[NODE_TV_SZ])		\
697			_np = node_tv;					\
698	} while (atomic_cas_ptr(&node_tp, _p, _np) != _p);		\
699	_p->node = (p);							\
700	_p->action = (a);						\
701	_p->ref = (p) ? (p)->ref : 0;					\
702	_p->cnt = (p) ? (p)->cnt : 0;					\
703	_p->cpu = CPU->cpu_seqid;					\
704	NODE_T_TRACE_STK();						\
705}
706
707#else	/* NODE_T_TRACE_ON */
708
709#define	NODE_T_TRACE(p, a)
710
711#endif	/* NODE_T_TRACE_ON */
712
713/*
714 * DOOR_TRACE - trace door node_t events.
715 *
716 * adb:
717 * 32 bit
718 *	*door_tp,0t8192-(((*door_tp)-door_tv)%0t112)/5XnPnPnPnPnPnPnPn64cnn
719 *	door_tv,((*door_tp)-door_tv)%0t112/5XnPnPnPnPnPnPnPn64cnn
720 * 64 bit
721 *	*door_tp,0t8192-(((*door_tp)-door_tv)%0t128)/PXPXXnXnXnXnXnXnXnXn64cnn
722 *	door_tv,((*door_tp)-door_tv)%0t128/PXPXXnXnXnXnXnXnXnXn64cnn
723 */
724
725#define	DOOR_STK_DEPTH	6
726
727struct door_ts {
728	struct nca_conn_s *cp;
729	unsigned action;
730	node_t	*np;
731	int	ref;
732	unsigned state;
733	pc_t	stk[DOOR_STK_DEPTH + 1];
734	char	data[64];
735};
736
737#undef	DOOR_TRACE_ON
738
739#ifdef	DOOR_TRACE_ON
740
741#define	DOOR_TRACE_UPCALL	0xF0000000	/* upcall() */
742#define	DOOR_TRACE_UPCALL_RAW	0xF1000000	/* upcall() RAW ? */
743#define	DOOR_TRACE_UPCALL_RET	0xFF000000	/* upcall() return */
744
745#define	DOOR_TRACE_DOWNCALL	0xE0000000	/* downcall() */
746#define	DOOR_TRACE_CONNECT	0xE1000000	/* connect() */
747#define	DOOR_TRACE_CONNECT_DATA	0xE2000000	/* connect() */
748#define	DOOR_TRACE_DIRECTFROM	0xE3000000	/* tee_splice() from */
749#define	DOOR_TRACE_DIRECTTO	0xE4000000	/* tee_splice() to */
750#define	DOOR_TRACE_DOWNCALL_RET	0xEF000000	/* downcall() return */
751
752#define	DOOR_TRACE_INIT		0x80000000	/* doorcall_init() */
753#define	DOOR_TRACE_INIT_RET	0x88000000	/* doorcall_init() return */
754
755#if defined(__i386) || defined(__amd64)
756#define	DOOR_TRACE_STK() {						\
757	_ix = getpcstack(&_p->stk[0], DOOR_STK_DEPTH + 1);		\
758	if (_ix < DOOR_STK_DEPTH + 1) {					\
759		_p->stk[_ix] = 0;					\
760	}								\
761}
762#else
763#define	DOOR_TRACE_STK() {						\
764	_p->stk[0] = (pc_t)callee();					\
765	_ix = getpcstack(&_p->stk[1], DOOR_STK_DEPTH);			\
766	if (_ix < DOOR_STK_DEPTH) {					\
767		_p->stk[_ix + 1] = 0;					\
768	}								\
769}
770#endif
771
772#define	DOOR_TV_SZ 8192
773
774extern struct door_ts door_tv[DOOR_TV_SZ];
775extern struct door_ts *door_tp;
776
777#define	DOOR_TRACE(io, d, d_sz, a) {				\
778	nca_conn_t *_cp = (io) ? (nca_conn_t *)(io)->cid : (nca_conn_t *)NULL; \
779	node_t *_req_np = _cp ? _cp->req_np : (node_t *)NULL;		\
780	struct door_ts *_p;						\
781	struct door_ts *_np;						\
782	int    _ix;							\
783									\
784	do {								\
785		_p = door_tp;						\
786		if ((_np = _p + 1) == &door_tv[DOOR_TV_SZ])		\
787			_np = door_tv;					\
788	} while (atomic_cas_ptr(&door_tp, _p, _np) != _p);		\
789	_p->cp = _cp;							\
790	_p->np = _req_np;						\
791	_p->action = (a);						\
792	_p->ref = _req_np ? _req_np->ref : 0;				\
793	if ((io)) {							\
794		_p->state = ((io)->op == http_op ? 0x80000000 : 0) |	\
795			    ((io)->more ? 0x40000000 : 0) |		\
796			    ((io)->first ? 0x20000000 : 0) |		\
797			    ((io)->advisory ? 0x10000000 : 0) |		\
798			    ((io)->nocache ? 0x08000000 : 0) |		\
799			    ((io)->preempt ? 0x04000000 : 0) |		\
800			    ((io)->peer_len ? 0x02000000 : 0) |		\
801			    ((io)->local_len ? 0x01000000 : 0) |	\
802			    ((io)->data_len ? 0x00800000 : 0) |		\
803			    (((io)->direct_type << 20) & 0x00700000) |	\
804			    ((io)->direct_len ? 0x00080000 : 0) |	\
805			    ((io)->trailer_len ? 0x00040000 : 0) |	\
806			    (((io)->peer_len + (io)->local_len +	\
807			    (io)->data_len + (io)->direct_len +		\
808			    (io)->trailer_len) & 0x3FFFF);		\
809	} else {							\
810		_p->state = 0;						\
811	}								\
812	if ((d_sz)) {							\
813		int _n = MIN((d_sz), 63);				\
814									\
815		bcopy((d), _p->data, _n);				\
816		bzero(&_p->data[_n], 64 - _n);				\
817	} else {							\
818		bzero(_p->data, 64);					\
819	}								\
820	DOOR_TRACE_STK();						\
821}
822
823#else	/* DOOR_TRACE_ON */
824
825#define	DOOR_TRACE(io, d, d_sz, a)
826
827#endif	/* DOOR_TRACE_ON */
828
829/*
830 * NCA node LRU cache.  Defined here so that the NCA mdb module can use it.
831 */
832typedef struct lru_s {
833	node_t		*phead;	/* Phys LRU list head (MRU) */
834	node_t		*ptail;	/* Phys LRU list tail (LRU) */
835	node_t		*vhead;	/* Virt LRU list head (MRU) */
836	node_t 		*vtail;	/* Virt LRU list tail (LRU) */
837
838	uint32_t	pcount;	/* Phys count of node_t members */
839	uint32_t	vcount;	/* Virt count of node_t members */
840
841	kmutex_t	lock;	/* Guarantee atomic access of above */
842} lru_t;
843
844/*
845 * Per CPU instance structure.
846 *
847 * 32-bit adb: XXXnnDnnXXnnXXnnXDnnXXnn228+na
848 * 64-bit adb: PPPnnD4+nnPPnnPPnnJDnnJ180+na
849 */
850
851typedef struct nca_cpu_s {
852
853	node_t *persist_hdr_none;
854	node_t *persist_hdr_close;
855	node_t *persist_hdr_ka;
856
857	uint32_t dcb_readers;	/* count of dcb_list readers for this CPU */
858
859	nca_squeue_t *if_inq;	/* if_t input nca_squeue_t */
860	nca_squeue_t *if_ouq;	/* if_t output nca_squeue_t */
861
862	ti_t	*tcp_ti;	/* TCP TIMER list */
863	tw_t	*tcp_tw;	/* TCP TIME_WAIT list */
864
865	ddi_softintr_t soft_id;	/* soft interrupt id for if_inq worker */
866	int	if_inq_cnt;	/* count of if_t.inq references */
867
868	char	pad[256 - sizeof (node_t *) - sizeof (node_t *) -
869		    sizeof (node_t *) - sizeof (uint32_t) -
870		    sizeof (nca_squeue_t *) - sizeof (nca_squeue_t *) -
871		    sizeof (ti_t *) - sizeof (tw_t *) -
872		    sizeof (ddi_softintr_t) - sizeof (int)];
873} nca_cpu_t;
874
875extern nca_cpu_t *nca_gv;	/* global per CPU state indexed by cpu_seqid */
876
877/*
878 * hcb_t - host control block.
879 *
880 * Used early on in packet switching to select packets to be serviced by NCA
881 * and optionally later on by the HTTP protocol layer to further select HTTP
882 * request to be serviced.
883 *
884 * dcb_t - door control block.
885 *
886 * Used to associate one or more hcb_t(s) with a given httpd door instance.
887 *
888 * dcb_list - dcb_t global list, a singly linked grounded list of dcb_t's.
889 *
890 * Used to search for a hcb_t match, currently a singly linked grounded list
891 * of dcb_t's with a linear walk of the list. While this is adequate for the
892 * current httpd support (i.e. a single door) a move to either a hash or tree
893 * will be required for multiple httpd instance support (i.e. multiple doors).
894 *
895 * The dcb_list is protected by a custom reader/writer lock, the motivation
896 * for using a custom lock instead of a krwlock_t is that this lock is the
897 * single hot spot in NCA (i.e. all in-bound packets must acquire this lock)
898 * and a nonlocking atomic readers count scheme is used in the common case
899 * (i.e. reader lock) with a fall-back to a conventional kmutex_t for writer
900 * (i.e. ndd list add/delete).
901 */
902
903typedef struct hcb_s {
904	struct hcb_s	*next;		/* Next hcb_t (none: NULL) */
905	ipaddr_t	addr;		/* IP address (any: INADDR_ANY or 0) */
906	uint16_t	port;		/* TCP port number */
907	char		*host;		/* Host: name (any: NULL) */
908	ssize_t		hostsz;		/* Size of above */
909	char		*root;		/* Document root ("/": NULL) */
910	ssize_t		rootsz;		/* Size of above */
911} hcb_t;
912
913typedef struct dcb_s {
914	struct dcb_s	*next;		/* Next dcb_t (none: NULL) */
915	char		*door;		/* Door file (default: NULL) */
916	ssize_t		doorsz;		/* Size of above */
917	door_handle_t	hand;		/* Door handle (default: NULL) */
918	hcb_t		list;		/* Head of a hcb_t list (any: NULL) */
919} dcb_t;
920
921extern dcb_t dcb_list;
922extern kmutex_t nca_dcb_lock;
923extern kcondvar_t nca_dcb_wait;
924extern kmutex_t nca_dcb_readers;
925
926#define	NOHANDLE ((door_handle_t)-1)
927
928#define	DCB_COUNT_USELOCK	0x80000000
929#define	DCB_COUNT_MASK		0x3FFFFFFF
930
931#define	DCB_RD_ENTER(cpu) {						\
932	uint32_t *rp;							\
933									\
934	cpu = CPU->cpu_seqid;						\
935	rp = &nca_gv[cpu].dcb_readers;					\
936	while (atomic_add_32_nv(rp, 1) & DCB_COUNT_USELOCK) {		\
937		/* Need to use the lock, so do the dance */		\
938		mutex_enter(&nca_dcb_lock);				\
939		if (atomic_add_32_nv(rp, -1) == DCB_COUNT_USELOCK &&	\
940		    CV_HAS_WAITERS(&nca_dcb_wait)) {			\
941			/* May be the last reader for this CPU */	\
942			cv_signal(&nca_dcb_wait);			\
943		}							\
944		mutex_exit(&nca_dcb_lock);				\
945		mutex_enter(&nca_dcb_readers);				\
946		/*							\
947		 * We block above waiting for the writer to exit the	\
948		 * readers lock, if we didn't block then while we were	\
949		 * away in the nca_dcb_lock enter the writer exited,	\
950		 * we could optimize for this case by checking USELOCK	\
951		 * after the decrement, but as this is an exceptional	\
952		 * case not in the fast-path we'll just take the hit	\
953		 * of a needless readers enter/exit.			\
954		 */							\
955		mutex_exit(&nca_dcb_readers);				\
956	}								\
957}
958
959#define	DCB_RD_EXIT(cpu) {						\
960	uint32_t *rp = &nca_gv[cpu].dcb_readers;			\
961									\
962	if (atomic_dec_32_nv(rp) == DCB_COUNT_USELOCK) {		\
963		mutex_enter(&nca_dcb_lock);				\
964		if (CV_HAS_WAITERS(&nca_dcb_wait)) {			\
965			/* May be the last reader for this CPU */	\
966			cv_signal(&nca_dcb_wait);			\
967		}							\
968		mutex_exit(&nca_dcb_lock);				\
969	}								\
970}
971
972#define	DCB_WR_ENTER() {						\
973	int cpu;							\
974	int readers;							\
975									\
976	mutex_enter(&nca_dcb_readers);					\
977	mutex_enter(&nca_dcb_lock);					\
978	for (;;) {							\
979		readers = 0;						\
980		for (cpu = 0; cpu < max_ncpus; cpu++) {			\
981			int new;					\
982			uint32_t *rp = &nca_gv[cpu].dcb_readers;	\
983			int old = *rp;					\
984									\
985			if (old & DCB_COUNT_USELOCK) {			\
986				readers += old & DCB_COUNT_MASK;	\
987				continue;				\
988			}						\
989			new = old | DCB_COUNT_USELOCK;			\
990			while (atomic_cas_32(rp, old, new) != old) {	\
991				old = *rp;				\
992				new = old | DCB_COUNT_USELOCK;		\
993			}						\
994			readers += (new & DCB_COUNT_MASK);		\
995		}							\
996		if (readers == 0)					\
997			break;						\
998		cv_wait(&nca_dcb_wait, &nca_dcb_lock);			\
999	}								\
1000	mutex_exit(&nca_dcb_lock);					\
1001}
1002
1003#define	DCB_WR_EXIT() {							\
1004	int cpu;							\
1005									\
1006	mutex_enter(&nca_dcb_lock);					\
1007	for (cpu = 0; cpu < max_ncpus; cpu++) {				\
1008		int new;						\
1009		uint32_t *rp = &nca_gv[cpu].dcb_readers;		\
1010		int old = *rp;						\
1011									\
1012		new = old & ~DCB_COUNT_USELOCK;				\
1013		while (atomic_cas_32(rp, old, new) != old) {		\
1014			old = *rp;					\
1015			new = old & ~DCB_COUNT_USELOCK;			\
1016		}							\
1017	}								\
1018	mutex_exit(&nca_dcb_lock);					\
1019	mutex_exit(&nca_dcb_readers);					\
1020}
1021
1022typedef struct nca_door_s {
1023	door_handle_t	handle;		/* The door handle */
1024	char		*name;		/* The door name */
1025	kmutex_t	lock;		/* The door lock */
1026	kcondvar_t	cv_writer;	/* condvar for thread waiting */
1027					/* to do door_init */
1028	kcondvar_t	cv_reader;	/* condvar for thread waiting */
1029					/* for a door_init to finish */
1030	uint32_t	upcalls;	/* Number of upcalls in progress */
1031	boolean_t	init_waiting;	/* door_init thread wanting to */
1032					/* be exclusive */
1033} nca_door_t;
1034
1035/*
1036 * if_t - interface per instance data.
1037 */
1038
1039typedef struct if_s {
1040
1041	boolean_t dev;		/* is a device instance */
1042
1043	queue_t	*rqp;		/* our read-side STREAMS queue */
1044	queue_t	*wqp;		/* our write-side STREAMS queue */
1045
1046	/* DLPI M_DATA IP fastpath template */
1047	size_t	mac_length;
1048	mblk_t	*mac_mp;
1049	int32_t	mac_mtu;
1050	int32_t	mac_addr_len;
1051
1052	uint32_t ip_ident;	/* our IP ident value */
1053
1054	boolean_t hwcksum;	/* underlying NIC supports checksum offload */
1055
1056	nca_squeue_t *inq;		/* in-bound nca_squeue_t */
1057	nca_squeue_t *ouq;		/* out-bound nca_squeue_t */
1058
1059	/*
1060	 * All if_t are associated with a CPU and have a default
1061	 * router on link are chained in a circular linked list.
1062	 */
1063	struct if_s *next_if;
1064	struct if_s *prev_if;
1065	ipaddr_t local_addr;	/* This interface's IP address. */
1066	uchar_t router_ether_addr[6];
1067
1068	uint_t	hdr_ioc_id;	/* id of DL_IOC_HDR_INFO M_IOCTL sent down */
1069	boolean_t info_req_pending;
1070
1071	int32_t	capab_state;	/* Capability probe state */
1072
1073	/* Bound local address of a NCAfs instance. */
1074	struct sockaddr_in	bound_addr;
1075} if_t;
1076
1077/*
1078 * connf_t - connection fanout data.
1079 *
1080 * The hash tables and their linkage (hashnextp, hashprevp) are protected
1081 * by the per-bucket lock. Each nca_conn_t inserted in the list points back at
1082 * the connf_t that heads the bucket.
1083 */
1084
1085typedef struct connf_s {
1086	uint32_t	max;
1087	struct nca_conn_s	*head;
1088	kmutex_t	lock;
1089} connf_t;
1090
1091#ifdef	CONNP_T_TRACE_ON
1092
1093#define	CONNP_TV_SZ 32
1094
1095/*
1096 * Per nca_conn_t packet tracing.
1097 */
1098typedef struct connp_s {
1099	clock_t		lbolt;
1100	clock_t		tcp_ti;
1101	int32_t		len : 16,
1102			dir : 1,
1103			state : 4,
1104			flags : 6,
1105			xmit_np : 1,
1106			xmit_head : 1,
1107			unsent : 1,
1108			tail_unsent : 1,
1109			direct : 1;
1110	uint32_t	state1;
1111	uint32_t	state2;
1112	uint32_t	seq;
1113	uint32_t	ack;
1114	uint32_t	snxt;
1115	uint32_t	swnd;
1116} connp_t;
1117
1118#endif	/* CONNP_T_TRACE_ON */
1119
1120/*
1121 * nca_conn_t - connection per instance data.
1122 *
1123 * Note: hashlock is used to provide atomic access to all nca_conn_t members
1124 * above it. All other members are protected by the per CPU inq nca_squeue_t
1125 * which is used to serialize access to all nca_conn_t's per interface.
1126 *
1127 * Note: the nca_conn_t can have up to 3 NODE_REFHOLDs:
1128 *
1129 *	1) if req_np != NULL then a NODE_REFHOLD(req_np) was done:
1130 *
1131 *	    1.1) if http_refed then a NODE_REFHOLD(req_np) was done
1132 *
1133 *	    1.2) if http_frefed then a NODE_REFHOLD(req_np->fileback) was done
1134 *
1135 *
1136 * TODO: reorder elements in fast-path code access order.
1137 *
1138 * Dnn4XnXXDnnDnnXXXnnXXXnnUXnnXXXnnXXnnDDXXXDXDXDXnnDnnXXDDnXXXDDnnXXXDDnn
1139 * XXXDDnnXXXDDnnXXXDDnnXXnnDXXnn
1140 * b+++DDnAnDDDDDnnDnnUnnUUDXDUnnDnn20xnnXnnddnnUUUnnXXUnXXnnUUUnn
1141 * DDDDDDnnUUnnXXUXUnn4UD4Unn4UnUUnn
1142 * 64-bit: Xnn4+4pnnppEnEnn3pnn3pnnEJnnXXnnuunn4+ppnnXX3pD4+pD4+pD4+pnnEnnppnnD
1143 */
1144
1145#define	TCP_XMIT_MAX_IX	5		/* Max xmit descriptors */
1146
1147typedef struct nca_conn_s {
1148
1149	int32_t ref;			/* Reference counter */
1150
1151	te_t	tcp_ti;			/* TCP TIMER timer entry */
1152
1153	struct nca_conn_s	*twnext;	/* TIME_WAIT next */
1154	struct nca_conn_s	*twprev;	/* TIME_WAIT prev */
1155	clock_t	twlbolt;		/* TIME_WAIT lbolt */
1156
1157	clock_t create;			/* Create lbolt time */
1158
1159	connf_t	*hashfanout;		/* Hash bucket we're part of */
1160	struct nca_conn_s	*hashnext;	/* Hash chain next */
1161	struct nca_conn_s	*hashprev;	/* Hash chain prev */
1162
1163	struct nca_conn_s	*bindnext;	/* Next conn_s in bind list. */
1164	struct nca_conn_s	*bindprev;	/* Prev conn_s in bind list. */
1165	void		*tbf;		/* Pointer to bind hash list struct. */
1166	/*
1167	 * Note: atomic access of memebers above is guaranteed by the
1168	 * hashfanout->lock of the hash bucket that the nca_conn_t is in.
1169	 */
1170
1171	size_t	mac_length;		/* MAC prepend length */
1172	mblk_t	*mac_mp;		/* MAC prepend data */
1173
1174	ipaddr_t	laddr;		/* Local address */
1175	ipaddr_t	faddr;		/* Remote address. 0 => not connected */
1176
1177	union {
1178		struct {
1179			uint16_t u_fport; /* Remote port */
1180			uint16_t u_lport; /* Local port */
1181		} u_ports1;
1182		uint32_t u_ports2;	/* Rem port, local port */
1183					/* Used for TCP_MATCH performance */
1184	} u_port;
1185#define	conn_lport	u_port.u_ports1.u_lport
1186#define	conn_fport	u_port.u_ports1.u_fport
1187#define	conn_ports	u_port.u_ports2
1188
1189	if_t	*ifp;			/* Interface for this connection */
1190	nca_squeue_t *inq;		/* Per CPU inq for this connection */
1191
1192	uint32_t req_tag;		/* nca_io_t request tag (0 == NONE) */
1193	int	req_parse;		/* HTTP request parse state */
1194	node_t	*req_np;		/* HTTP request node_t */
1195	mblk_t	*req_mp;		/* HTTP request mblk_t */
1196	char	*reqpath;		/* HTTP request URI path component */
1197	int	reqpathsz;		/* size of above */
1198	char	*reqrefer;		/* HTTP "Referer:" string */
1199	int	reqrefersz;		/* size of above */
1200	char	*requagent;		/* HTTP "User-Agent:" string */
1201	int	requagentsz;		/* size of above */
1202	struct nca_conn_s *nodenext;	/* Node_t nca_conn_t list */
1203
1204	clock_t	http_count;		/* HTTP Keep-Alive request count */
1205
1206	/*
1207	 * req_np xmit state used accross calls to tcp_xmit(). A reference
1208	 * to the req_np and to any inderect node_t (i.e. file/ctag) ...
1209	 */
1210	node_t	*xmit_refed;		/* have a ref to the uri node_t */
1211	node_t	*xmit_cur;		/* current node to transmit */
1212
1213	int	xmit_ix;		/* current xmit[] index */
1214	int	xmit_pix;		/* past end xmit[] index */
1215
1216	struct {
1217		node_t	*np;		/* node_t pointer for ref */
1218		char	*dp;		/* data pointer */
1219		uint16_t *cp;		/* cksum array */
1220		int	sz;		/* remaining data to xmit */
1221		int	iso;		/* initial segment offset (if any) */
1222		node_t	*refed;		/* have a ref to the node_t */
1223		int	dsz;		/* remaining data for current segment */
1224		caddr_t	*dvp;		/* data segment virtual pointer */
1225	} xmit[TCP_XMIT_MAX_IX];
1226
1227	/*
1228	 * Connection NCA_IO_DIRECT_SPLICE & NCA_IO_DIRECT_TEE reference,
1229	 * see direct_splice and direct_tee below for type of send too.
1230	 */
1231	struct nca_conn_s	*direct; /* nca_conn_t to send recv data too */
1232	mblk_t		*direct_mp;	 /* mblk_t to use for tcp_close() */
1233
1234	/*
1235	 * nca_conn_t state.
1236	 */
1237
1238	int32_t	tcp_state;
1239
1240	uint32_t
1241		tcp_urp_last_valid : 1,	/* Is tcp_urp_last valid? */
1242		tcp_hard_binding : 1,	/* If we've started a full bind */
1243		tcp_hard_bound : 1,	/* If we've done a full bind with IP */
1244		tcp_fin_acked : 1,	/* Has our FIN been acked? */
1245
1246		tcp_fin_rcvd : 1,	/* Have we seen a FIN? */
1247		tcp_fin_sent : 1,	/* Have we sent our FIN yet? */
1248		tcp_ordrel_done : 1,	/* Have we sent the ord_rel upstream? */
1249		tcp_flow_stopped : 1,	/* Have we flow controlled xmitter? */
1250
1251		tcp_debug : 1,		/* SO_DEBUG "socket" option. */
1252		tcp_dontroute : 1,	/* SO_DONTROUTE "socket" option. */
1253		tcp_broadcast : 1,	/* SO_BROADCAST "socket" option. */
1254		tcp_useloopback : 1,	/* SO_USELOOPBACK "socket" option. */
1255
1256		tcp_oobinline : 1,	/* SO_OOBINLINE "socket" option. */
1257		tcp_dgram_errind : 1,	/* SO_DGRAM_ERRIND option */
1258		tcp_detached : 1,	/* If we're detached from a stream */
1259		tcp_bind_pending : 1,	/* Client is waiting for bind ack */
1260
1261		tcp_unbind_pending : 1, /* Client sent T_UNBIND_REQ */
1262		tcp_deferred_clean_death : 1,
1263					/* defer tcp endpoint cleanup etc. */
1264		tcp_co_wakeq_done : 1,	/* A strwakeq() has been done */
1265		tcp_co_wakeq_force : 1,	/* A strwakeq() must be done */
1266
1267		tcp_co_norm : 1,	/* In normal mode, putnext() done */
1268		tcp_co_wakeq_need : 1,	/* A strwakeq() needs to be done */
1269		tcp_snd_ws_ok : 1,	/* Received WSCALE from peer */
1270		tcp_snd_ts_ok : 1,	/* Received TSTAMP from peer */
1271
1272		tcp_linger : 1,		/* SO_LINGER turned on */
1273		tcp_zero_win_probe: 1,	/* Zero win probing is in progress */
1274		tcp_loopback: 1,	/* src and dst are the same machine */
1275		tcp_localnet: 1,	/* src and dst are on the same subnet */
1276
1277		tcp_syn_defense: 1,	/* For defense against SYN attack */
1278#define	tcp_dontdrop	tcp_syn_defense
1279		tcp_set_timer : 1,
1280		tcp_1_junk_fill_thru_bit_31 : 2;
1281
1282	uint32_t
1283		tcp_active_open: 1,	/* This is a active open */
1284		tcp_timeout : 1,	/* qbufcall failed, qtimeout pending */
1285		tcp_rexmit : 1,		/* TCP is retransmitting */
1286		tcp_snd_sack_ok : 1,	/* Can use SACK for this connection */
1287
1288		tcp_bind_proxy_addr : 1,	/* proxy addr is being used */
1289		tcp_recvdstaddr : 1,	/* return T_EXTCONN_IND with dst addr */
1290		tcp_refed : 1,		/* nca_conn_t refed by TCP */
1291		tcp_time_wait_comp : 1, /* TIME_WAIT compressed nca_conn_t */
1292
1293		tcp_close : 1,		/* nca_conn_t close */
1294		http_persist : 3,	/* HTTP persistent connection state */
1295
1296		deferred_xmit_end : 1,	/* xmit_end() deferred to xmit() */
1297		http_direct_splice : 1,	/* have a connection to splice too */
1298		http_direct_tee : 1,	/* have a connection to tee too */
1299
1300		tcp_2_junk_fill_thru_bit_31 : 17;
1301/*
1302 * Note: all nca_conn_t members to be accessed by a tcp_time_wait_comp
1303 * nca_conn_t must be above this point !!!
1304 */
1305
1306	uchar_t	tcp_timer_backoff;	/* Backoff shift count. */
1307	clock_t tcp_last_recv_time;	/* Last time we receive a segment. */
1308	clock_t	tcp_dack_set_time;	/* When delayed ACK timer is set. */
1309
1310	int	tcp_ip_hdr_len;		/* Byte len of our current IP header */
1311	clock_t	tcp_first_timer_threshold;  /* When to prod IP */
1312	clock_t	tcp_second_timer_threshold; /* When to give up completely */
1313	clock_t	tcp_first_ctimer_threshold; /* 1st threshold while connecting */
1314	clock_t tcp_second_ctimer_threshold; /* 2nd ... while connecting */
1315
1316	clock_t	tcp_last_rcv_lbolt; /* lbolt on last packet, used for PAWS */
1317
1318
1319	uint32_t tcp_obsegs;		/* Outbound segments on this stream */
1320
1321	uint32_t tcp_mss;		/* Max segment size */
1322	uint32_t tcp_naglim;		/* Tunable nagle limit */
1323	int32_t	tcp_hdr_len;		/* Byte len of combined TCP/IP hdr */
1324	tcph_t	*tcp_tcph;		/* tcp header within combined hdr */
1325	int32_t	tcp_tcp_hdr_len;	/* tcp header len within combined */
1326	uint32_t	tcp_valid_bits;
1327#define	TCP_ISS_VALID	0x1	/* Is the tcp_iss seq num active? */
1328#define	TCP_FSS_VALID	0x2	/* Is the tcp_fss seq num active? */
1329#define	TCP_URG_VALID	0x4	/* If the tcp_urg seq num active? */
1330
1331	int32_t	tcp_xmit_hiwater;	/* Send buffer high water mark. */
1332
1333	union {				/* template ip header */
1334		ipha_t	tcp_u_ipha;
1335		char	tcp_u_buf[IP_SIMPLE_HDR_LENGTH+TCP_MIN_HEADER_LENGTH];
1336		double	tcp_u_aligner;
1337	} tcp_u;
1338#define	tcp_ipha	tcp_u.tcp_u_ipha
1339#define	tcp_iphc	tcp_u.tcp_u_buf
1340
1341	uint32_t tcp_sum;		/* checksum to compensate for source */
1342					/* routed packets. Host byte order */
1343
1344	uint16_t tcp_last_sent_len;	/* Record length for nagle */
1345	uint16_t tcp_dupack_cnt;	/* # of consequtive duplicate acks */
1346
1347	uint32_t tcp_rnxt;		/* Seq we expect to recv next */
1348	uint32_t tcp_rwnd;		/* Current receive window */
1349	uint32_t tcp_rwnd_max;		/* Maximum receive window */
1350
1351	mblk_t	*tcp_rcv_head;		/* Queued until push, urgent data or */
1352	mblk_t	*tcp_rcv_tail;		/* the count exceeds */
1353	uint32_t tcp_rcv_cnt;		/* tcp_rcv_push_wait. */
1354
1355	mblk_t	*tcp_reass_head;	/* Out of order reassembly list head */
1356	mblk_t	*tcp_reass_tail;	/* Out of order reassembly list tail */
1357
1358	uint32_t tcp_cwnd_ssthresh;	/* Congestion window */
1359	uint32_t tcp_cwnd_max;
1360	uint32_t tcp_csuna;		/* Clear (no rexmits in window) suna */
1361
1362	int	tcp_rttv_updates;
1363	clock_t	tcp_rto;		/* Round trip timeout */
1364	clock_t	tcp_rtt_sa;		/* Round trip smoothed average */
1365	clock_t	tcp_rtt_sd;		/* Round trip smoothed deviation */
1366	clock_t	tcp_rtt_update;		/* Round trip update(s) */
1367	clock_t tcp_ms_we_have_waited;	/* Total retrans time */
1368
1369	uint32_t tcp_swl1;		/* These help us avoid using stale */
1370	uint32_t tcp_swl2;		/*  packets to update state */
1371
1372	mblk_t	*tcp_xmit_head;		/* Head of rexmit list */
1373	mblk_t	*tcp_xmit_last;		/* last valid data seen by tcp_wput */
1374	uint32_t tcp_unsent;		/* # of bytes in hand that are unsent */
1375	mblk_t	*tcp_xmit_tail;		/* Last rexmit data sent */
1376	uint32_t tcp_xmit_tail_unsent;	/* # of unsent bytes in xmit_tail */
1377
1378	uint32_t tcp_snxt;		/* Senders next seq num */
1379	uint32_t tcp_suna;		/* Sender unacknowledged */
1380	uint32_t tcp_rexmit_nxt;	/* Next rexmit seq num */
1381	uint32_t tcp_rexmit_max;	/* Max retran seq num */
1382	int32_t	tcp_snd_burst;		/* Send burst factor */
1383	uint32_t tcp_swnd;		/* Senders window (relative to suna) */
1384	uint32_t tcp_cwnd;		/* Congestion window */
1385	int32_t tcp_cwnd_cnt;		/* cwnd cnt in congestion avoidance */
1386	uint32_t tcp_ackonly;		/* Senders last ack seq num */
1387
1388	uint32_t tcp_irs;		/* Initial recv seq num */
1389	uint32_t tcp_iss;		/* Initial send seq num */
1390	uint32_t tcp_fss;		/* Final/fin send seq num */
1391	uint32_t tcp_urg;		/* Urgent data seq num */
1392
1393	uint32_t tcp_rack;		/* Seq # we have acked */
1394	uint32_t tcp_rack_cnt;		/* # of bytes we have deferred ack */
1395
1396	uint32_t tcp_max_swnd;		/* Maximum swnd we have seen */
1397	int64_t	tcp_rexmit_fire_time;
1398	int64_t	tcp_dack_fire_time;
1399	int64_t tcp_ka_fire_time;
1400	int64_t	tcp_http_ka_fire_time;
1401
1402	int32_t	tcp_keepalive_intrvl;	/* Zero means don't bother */
1403	int32_t	tcp_ka_probe_sent;
1404	int32_t tcp_ka_last_intrvl;
1405
1406#define	TCP_DACK_TIMER		0x1
1407#define	TCP_REXMIT_TIMER	0x2
1408#define	TCP_KA_TIMER		0x4
1409#define	TCP_HTTP_KA_TIMER	0x8
1410	int16_t		tcp_running_timer;
1411	int16_t		tcp_pending_timer;
1412
1413#ifdef	CONNP_T_TRACE_ON
1414	connp_t *pkt_tp;		/* Packet tracing pointer */
1415	connp_t	pkt_tv[CONNP_TV_SZ];	/* Packet tracing vector */
1416#endif	/* CONNP_T_TRACE_ON */
1417
1418} nca_conn_t;
1419
1420/*
1421 * Active stack support parameters to control what ports NCA can use.
1422 * They are declared in ncaproto.c
1423 */
1424extern struct nca_tbf_s *nca_tcp_port;
1425extern in_port_t tcp_lo_port;
1426extern in_port_t tcp_hi_port;
1427
1428/*
1429 * nca_conn_t.http_persist values and corresponding HTTP header strings are
1430 * used to determine the connection persistent state of a connection and
1431 * any HTTP header which needs to be sent.
1432 */
1433
1434#define	PERSIST_NONE		0	/* Not persistent */
1435
1436#define	PERSIST_CLOSE		1	/* Was persistent, send close header */
1437#define	PERSIST_TRUE		2	/* Connection is HTTP persistent */
1438#define	PERSIST_KA		3	/* Persistent, send Keep-Alive header */
1439#define	PERSIST_UPCALL		4	/* Insert "Connection: close" on */
1440					/* upcall and clear flag */
1441
1442#define	PERSIST_HDR_NONE	"\r\n"
1443#define	PERSIST_HDR_CLOSE	"Connection: close\r\n\r\n"
1444#define	PERSIST_HDR_KA		"Connection: Keep-Alive\r\n\r\n"
1445
1446/*
1447 * nca_conn_t nca_squeue_ctl() flag values:
1448 */
1449
1450#define	CONN_MISS_DONE		0x0001	/* The conn miss processing is done */
1451#define	IF_TIME_WAIT		0x0002	/* A TIME_WAIT has fired */
1452#define	IF_TCP_TIMER		0x0003	/* A TCP TIMER has fired */
1453#define	NCA_CONN_TCP_TIMER	0x0004	/* A TCP TIMER needs to be execed */
1454#define	IF_TCP_CONNECT		0x0005	/* TCP connection request */
1455#define	IF_TCP_SEND		0x0006	/* A new send request. */
1456
1457#define	IF_TCP_DIRECT_TO	0x0010	/* A TCP direct i/o, step 1 */
1458#define	IF_TCP_DIRECT_FROM	0x0012	/* A TCP direct i/o, step 2 */
1459#define	IF_TCP_DIRECT_TEE	0x0001	/* If a tee else a splice */
1460#define	IF_TCP_DIRECT_CLOSE	0x001F	/* A TCP direct i/o close */
1461
1462#define	NCA_CONN_T_STK_DEPTH	7	/* max stack backtrace depth */
1463
1464struct conn_ts {
1465	nca_conn_t	*conn;
1466	unsigned action;
1467	int	ref;
1468	int	cpu;
1469	pc_t	stk[NCA_CONN_T_STK_DEPTH + 1];
1470};
1471
1472#undef	NCA_CONN_T_TRACE_ON
1473
1474#ifdef	NCA_CONN_T_TRACE_ON
1475
1476/*
1477 * adb:
1478 * 32 bit
1479 *	*conn_tp,0t4096-(((*conn_tp)-con_tv)%0t48)/PXDDnPnPnPnPnPnPnPnPnn
1480 *	con_tv,((*conn_tp)-con_tv)%0t48/PXDDnPnPnPnPnPnPnPnPnn
1481 * 64 bit
1482 *	*conn_tp,0t4096-(((*conn_tp)-con_tv)%0t56)/PXDDnXnXnXnXnXnXnXnXnn
1483 *	con_tv,((*conn_tp)-con_tv)%0t56/PXDDnXnXnXnXnXnXnXnXnn
1484 */
1485
1486#define	NCA_CONN_T_REFINIT	0x10000000	/* CONN_REF init() |ref value */
1487#define	NCA_CONN_T_REFINIT1	0x11000000	/* CONN_REF init() |ref value */
1488#define	NCA_CONN_T_REFINIT2	0x12000000	/* CONN_REF init() |ref value */
1489#define	NCA_CONN_T_REFNOTCP	0x13000000 /* CONN_REF no longer tcp_refed */
1490#define	NCA_CONN_T_REFHOLD	0x1A000000	/* CONN_REFHOLD() | ref value */
1491#define	NCA_CONN_T_REFRELE	0x1F000000	/* CONN_REFRELE() | ref value */
1492
1493#define	NCA_CONN_T_HTTPCALL	0x20000000	/* call http() | rbytes */
1494#define	NCA_CONN_T_HTTPRET1	0x21000000	/* return http() */
1495#define	NCA_CONN_T_HTTPRET2	0x22000000	/* return ! http() */
1496
1497#define	NCA_CONN_T_MISSDONE	0x30000000	/* CONN_MISS_DONE */
1498#define	NCA_CONN_T_TCPTIMER	0x31000000	/* NCA_CONN_TCP_TIMER */
1499#define	NCA_CONN_T_XMIT_END	0x32000000	/* xmit_end() | tcp_unsent */
1500#define	NCA_CONN_T_XMIT_BAD	0x33000000 /* xmit_end() bad state |tcp_state */
1501#define	NCA_CONN_T_XMIT_DEF	0x34000000	/* xmit_end() deferred */
1502#define	NCA_CONN_T_TIME_WAIT 0x35000000	/* done: tcp_state == TCPS_TIME_WAIT */
1503#define	NCA_CONN_T_PKT_IN	0x36000000	/* tcp_input() | flags */
1504#define	NCA_CONN_T_PKT_OUT	0x37000000	/* tcp_input() | flags */
1505
1506#define	NCA_CONN_T_DIRECT	0x40000000	/* tcp_direct() from conn_t */
1507#define	NCA_CONN_T_DIRECT1	0x41000000	/* tcp_direct() to conn_t */
1508#define	NCA_CONN_T_DIRECT2	0x42000000	/* IF_TCP_DIRECT_TO | TEE */
1509#define	NCA_CONN_T_DIRECT3	0x43000000	/* IF_TCP_DIRECT_FROM | TEE */
1510#define	NCA_CONN_T_DIRECT4	0x44000000	/* tcp_close() */
1511#define	NCA_CONN_T_DIRECT5	0x45000000	/* IF_TCP_DIRECT_CLOSE */
1512						/* from|tcp_state */
1513#define	NCA_CONN_T_DIRECT6	0x46000000	/* IF_TCP_DIRECT_CLOSE to */
1514
1515#if defined(__i386) || defined(__amd64)
1516#define	NCA_CONN_T_TRACE_STK() {					\
1517	_ix = getpcstack(&_p->stk[0], NCA_CONN_T_STK_DEPTH + 1);	\
1518	if (_ix < NCA_CONN_T_STK_DEPTH + 1) {				\
1519		_p->stk[_ix + 1] = 0;					\
1520	}								\
1521}
1522#else
1523#define	NCA_CONN_T_TRACE_STK() {					\
1524	_p->stk[0] = (pc_t)callee();					\
1525	_ix = getpcstack(&_p->stk[1], NCA_CONN_T_STK_DEPTH);		\
1526	if (_ix < NCA_CONN_T_STK_DEPTH) {				\
1527		_p->stk[_ix + 1] = 0;					\
1528	}								\
1529}
1530#endif
1531
1532#define	CON_TV_SZ 4096
1533
1534extern struct conn_ts con_tv[CON_TV_SZ];
1535extern struct conn_ts *conn_tp;
1536
1537#define	NCA_CONN_T_TRACE(p, a) {					\
1538	struct conn_ts *_p;						\
1539	struct conn_ts *_np;						\
1540	int    _ix;							\
1541									\
1542	do {								\
1543		_p = conn_tp;					\
1544		if ((_np = _p + 1) == &con_tv[CON_TV_SZ])	\
1545			_np = con_tv;				\
1546	} while (atomic_cas_ptr(&conn_tp, _p, _np) != _p);		\
1547	_p->conn = (p);							\
1548	_p->action = (a);						\
1549	_p->ref = (p)->ref;						\
1550	_p->cpu = CPU->cpu_seqid;					\
1551	NCA_CONN_T_TRACE_STK();						\
1552}
1553
1554#else	/* NCA_CONN_T_TRACE_ON */
1555
1556#define	NCA_CONN_T_TRACE(p, a)
1557
1558#endif	/* NCA_CONN_T_TRACE_ON */
1559
1560
1561#define	CONN_REFHOLD(connp) {						\
1562									\
1563	NCA_CONN_T_TRACE((connp), NCA_CONN_T_REFHOLD | ((connp)->ref + 1)); \
1564									\
1565	if ((connp)->ref <= 0)						\
1566		panic("nca CONN_REFHOLD: %p has no references",		\
1567		    (void *)(connp));					\
1568	(connp)->ref++;							\
1569}
1570
1571#define	CONN_REFRELE(connp) {						\
1572									\
1573	NCA_CONN_T_TRACE((connp), NCA_CONN_T_REFRELE | ((connp)->ref - 1)); \
1574									\
1575	if ((connp)->tcp_refed) {					\
1576		if ((connp)->ref == 1)					\
1577			panic("nca CONN_REFRELE: %p "			\
1578			    "has only tcp_refed reference",		\
1579			    (void *)(connp));				\
1580		if ((connp)->ref < 1)					\
1581			panic("nca CONN_REFRELE: %p has no references",	\
1582			    (void *)(connp));				\
1583	} else {							\
1584		if ((connp)->ref <= 0)					\
1585			panic("nca CONN_REFRELE: %p has no references",	\
1586			    (void *)(connp));				\
1587	}								\
1588	(connp)->ref--;							\
1589	if ((connp)->ref == 0) {					\
1590		/* Last ref of a nca_conn_t, so free it */		\
1591		kmutex_t *lock = &(connp)->hashfanout->lock;		\
1592		mutex_enter(lock);					\
1593		nca_conn_free(connp);					\
1594		/* Note: nca_conn_free exits lock */			\
1595	}								\
1596}
1597
1598/*
1599 * The nca_io2_shadow_t is used by the kernel to contian a copy of a user-
1600 * land nca_io2_t and the the user-land nca_io2_t address and size.
1601 */
1602
1603typedef struct nca_io2_shadow_s {
1604	nca_io2_t	io;		/* copy of user-land nca_io2_t */
1605	void		*data_ptr;	/* copy of door_arg_t.data_ptr */
1606	size_t		data_size;	/* copy of door_arg_t.data_size */
1607} nca_io2_shadow_t;
1608
1609#define	SHADOW_NONE	0x00		/* nca_io2_t.shadow NONE */
1610#define	SHADOW_DOORSRV	0x01		/* nca_io2_t.shadow door_srv() */
1611#define	SHADOW_NCAFS	0x02		/* nca_io2_t.shadow NCAfs */
1612
1613
1614/*
1615 * Given a ptr to a nca_io2_t, a field and the field_length, write data
1616 * into buffer (Note: word aligned offsets).
1617 */
1618#define	NCA_IO_WDATA(val, vsize, p, n_used, len, off)		\
1619	/*CONSTCOND*/						\
1620	if ((val) == NULL) {					\
1621		(p)->len = vsize;				\
1622		(p)->off = 0;					\
1623	} else {						\
1624		(p)->len = (vsize);				\
1625		(p)->off = ((n_used) + sizeof (uint32_t) - 1) &	\
1626				(~(sizeof (uint32_t) - 1));	\
1627		bcopy((char *)(val),				\
1628		    ((char *)(p) + (p)->off), (vsize));		\
1629		(n_used) = (p)->off + (p)->len;			\
1630	}
1631
1632/*
1633 * Given a ptr to an nca_io2_t, a field length member name, append data to
1634 * it in the buffer. Note: must be the last field a WDATA() was done for.
1635 *
1636 * Note: a NULL NCA_IO_WDATA() can be followed by a NCA_IO_ADATA() only if
1637 *		vsize was == -1.
1638 *
1639 */
1640#define	NCA_IO_ADATA(val, vsize, p, n_used, len, off)		\
1641	if ((p)->len == -1) {					\
1642		(p)->len = 0;					\
1643		(p)->off = ((n_used) + sizeof (uint32_t) - 1) &	\
1644		(~(sizeof (uint32_t) - 1));			\
1645	}							\
1646	bcopy((char *)(val), ((char *)(p) + \
1647	    (p)->off + (p)->len), (vsize));			\
1648	(p)->len += (vsize);					\
1649	(n_used) += (vsize);
1650
1651/*
1652 * Given a ptr to a nca_io2_t and a field construct a pointer.
1653 */
1654#define	NCA_IO_PDATA(p, off) ((char *)(p) + (p)->off)
1655
1656
1657#ifndef	isdigit
1658#define	isdigit(c) ((c) >= '0' && (c) <= '9')
1659#endif
1660
1661#ifndef	tolower
1662#define	tolower(c) ((c) >= 'A' && (c) <= 'Z' ? (c) | 0x20 : (c))
1663#endif
1664
1665#ifndef	isalpha
1666#define	isalpha(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
1667#endif
1668
1669#ifndef	isspace
1670#define	isspace(c) ((c) == ' ' || (c) == '\t' || (c) == '\n' || \
1671		    (c) == '\r' || (c) == '\f' || (c) == '\013')
1672#endif
1673
1674extern char *strnchr(const char *, int, size_t);
1675extern char *strnstr(const char *, const char *, size_t);
1676extern char *strncasestr(const char *, const char *, size_t);
1677extern char *strrncasestr(const char *, const char *, size_t);
1678extern int atoin(const char *, size_t);
1679extern int digits(int);
1680
1681extern void nca_conn_free(nca_conn_t *);
1682extern void nca_logit_off(void);
1683extern void node_fr(node_t *);
1684
1685extern nca_squeue_t *nca_squeue_init(nca_squeue_t *, uint32_t,
1686    processorid_t, void (*)(), void *, void (*)(), clock_t, pri_t);
1687extern void nca_squeue_fini(nca_squeue_t *);
1688extern void nca_squeue_enter(nca_squeue_t *, mblk_t *, void *);
1689extern void nca_squeue_fill(nca_squeue_t *, mblk_t *, void *);
1690extern mblk_t *nca_squeue_remove(nca_squeue_t *);
1691extern void nca_squeue_worker(nca_squeue_t *);
1692extern mblk_t *nca_squeue_ctl(mblk_t *, void *, unsigned short);
1693extern void nca_squeue_signal(nca_squeue_t *);
1694extern void nca_squeue_exit(nca_squeue_t *);
1695extern void sqfan_init(sqfan_t *, uint32_t, uint32_t, uint32_t);
1696extern nca_squeue_t *sqfan_ixinit(sqfan_t *, uint32_t, nca_squeue_t *, uint32_t,
1697    processorid_t, void (*)(), void *, void (*)(), clock_t, pri_t);
1698extern void sqfan_fini(sqfan_t *);
1699extern void sqfan_fill(sqfan_t *, mblk_t *, void *);
1700extern mblk_t *sqfan_remove(sqfan_t *);
1701extern void nca_squeue_nointr(nca_squeue_t *, mblk_t *, void *, int);
1702extern void nca_squeue_pause(nca_squeue_t *, mblk_t *, void *, int, boolean_t);
1703extern void nca_squeue_willproxy(nca_squeue_t *);
1704extern void nca_squeue_proxy(nca_squeue_t *, nca_squeue_t *);
1705extern void nca_squeue_bind(nca_squeue_t *, uint32_t, processorid_t);
1706
1707extern int nca_tcp_clean_death(nca_conn_t *, int);
1708extern nca_conn_t *nca_tcp_connect(ipaddr_t, in_port_t, boolean_t);
1709extern void nca_tcp_send(nca_conn_t *, mblk_t *);
1710extern void nca_tcp_direct(nca_conn_t *, nca_conn_t *, uint32_t);
1711
1712/* Functions prototypes from ncadoorsrv.c */
1713extern node_t *nca_node_flush(node_t *);
1714extern void nca_downcall_service(void *, door_arg_t *, void (**)(void *,
1715    void *), void **, int *);
1716extern node_t *ctag_lookup(uint64_t, unsigned *);
1717extern node_t *node_replace(node_t *, nca_conn_t *);
1718extern node_t *node_temp(node_t *, nca_conn_t *);
1719extern void find_ctags(node_t *, nca_io2_t *, int *);
1720extern void nca_ncafs_srv(nca_io2_t *, struct uio *, queue_t *);
1721extern boolean_t nca_reclaim_vlru(void);
1722extern boolean_t nca_reclaim_plru(boolean_t, boolean_t);
1723
1724/*
1725 * NCA_COUNTER() is used to add a signed long value to a unsigned long
1726 * counter, in general these counters are used to maintain NCA state.
1727 *
1728 * NCA_DEBUG_COUNTER() is used like NCA_COUNTER() but for counters used
1729 * to maintain additional debug state, by default these counters aren't
1730 * updated unless the global value nca_debug_counter is set to a value
1731 * other then zero.
1732 *
1733 * Also, if NCA_COUNTER_TRACE is defined a time ordered wrapping trace
1734 * buffer is maintained with hrtime_t stamps, counter address, value to
1735 * add, and new value entries for all NCA_COUNTER() and NCA_DEBUG_COUNTER()
1736 * use.
1737 */
1738
1739#undef	NCA_COUNTER_TRACE
1740
1741#ifdef	NCA_COUNTER_TRACE
1742
1743#define	NCA_COUNTER_TRACE_SZ	1024
1744
1745typedef struct nca_counter_s {
1746	hrtime_t	t;
1747	unsigned long	*p;
1748	unsigned long	v;
1749	unsigned long	nv;
1750} nca_counter_t;
1751
1752extern nca_counter_t nca_counter_tv[];
1753extern nca_counter_t *nca_counter_tp;
1754
1755#define	NCA_COUNTER(_p, _v) {						\
1756	unsigned long	*p = _p;					\
1757	long		v = _v;						\
1758	unsigned long	_nv;						\
1759	nca_counter_t	*_otp;						\
1760	nca_counter_t	*_ntp;						\
1761									\
1762	_nv = atomic_add_long_nv(p, v);					\
1763	do {								\
1764		_otp = nca_counter_tp;					\
1765		_ntp = _otp + 1;					\
1766		if (_ntp == &nca_counter_tv[NCA_COUNTER_TRACE_SZ])	\
1767			_ntp = nca_counter_tv;				\
1768	} while (atomic_cas_ptr((void *)&nca_counter_tp, (void *)_otp,	\
1769	    (void *)_ntp) != (void *)_otp);				\
1770	_ntp->t = gethrtime();						\
1771	_ntp->p = p;							\
1772	_ntp->v = v;							\
1773	_ntp->nv = _nv;							\
1774}
1775
1776#else	/* NCA_COUNTER_TRACE */
1777
1778#define	NCA_COUNTER(p, v) atomic_add_long((p), (v))
1779
1780#endif	/* NCA_COUNTER_TRACE */
1781
1782
1783/*
1784 * This is the buf used in upcall to httpd.
1785 */
1786typedef struct {
1787	uintptr_t	tid;
1788	char		*buf;
1789} http_buf_table_t;
1790
1791/*
1792 * URI and filename hash, a simple static hash bucket array of singly
1793 * linked grounded lists is used with a hashing algorithm which has
1794 * proven to have good distribution properities for strings of ...
1795 *
1796 * Note: NCA_HASH_SZ must be a prime number.
1797 */
1798
1799#define	NCA_HASH_SZ	8053
1800#define	NCA_HASH_MASK	0xFFFFFF
1801#define	HASH_IX(s, l, hix, hsz) { \
1802	char *cp = (s); \
1803	int len = (l); \
1804			\
1805	(hix) = 0; \
1806	while (len-- > 0) { \
1807		(hix) = (hix) * 33 + *cp++; \
1808		(hix) &= NCA_HASH_MASK; \
1809	} \
1810	(hix) %= (hsz); \
1811}
1812
1813/*
1814 * CTAG hash.
1815 */
1816#define	NCA_CTAGHASH_SZ	4096
1817#define	CTAGHASH_IX(t, ix) ((ix) = (t) % NCA_CTAGHASH_SZ)
1818
1819/*
1820 * VNODE hash.
1821 *
1822 * Note: NCA_VNODEHASH_SZ must be a P2Ps() value.
1823 */
1824#define	NCA_VNODEHASH_SZ 12281
1825#define	VNODEHASH_IX(p, ix) ((ix) = (((uintptr_t)p >> 27) ^ \
1826	((uintptr_t)p >> 17) ^ ((uintptr_t)p >> 11) ^ (uintptr_t)p) % \
1827	ncavnodehash_sz)
1828
1829extern pgcnt_t nca_ppmax;
1830extern pgcnt_t nca_vpmax;
1831extern pgcnt_t nca_pplim;
1832extern pgcnt_t nca_vplim;
1833extern pgcnt_t nca_ppmem;
1834extern pgcnt_t nca_vpmem;
1835extern ssize_t nca_kbmem;
1836extern ssize_t nca_spmem;
1837extern ssize_t nca_ckmem;
1838extern ssize_t nca_mbmem;
1839extern ssize_t nca_cbmem;
1840extern ssize_t nca_lbmem;
1841extern size_t  nca_maxkmem;
1842extern uint32_t nca_use_segmap;
1843
1844extern ulong_t nca_hits;
1845extern ulong_t nca_file;
1846extern ulong_t nca_ctag;
1847extern ulong_t nca_miss;
1848
1849extern ulong_t nca_hit304;
1850extern ulong_t nca_hitnoV;
1851extern ulong_t nca_hitnoVfast;
1852extern ulong_t nca_hitnoVtemp;
1853
1854extern ulong_t nca_filehits;
1855extern ulong_t nca_filenoV;
1856extern ulong_t nca_filenoVfast;
1857extern ulong_t nca_filemiss;
1858
1859extern ulong_t nca_missURI;
1860extern ulong_t nca_missQ;
1861extern ulong_t nca_missSAFE;
1862extern ulong_t nca_missnoV;
1863extern ulong_t nca_missnotcp;
1864extern ulong_t nca_missfail;
1865extern ulong_t nca_misstemp;
1866extern ulong_t nca_missnohash;
1867extern ulong_t nca_missclean;
1868extern ulong_t nca_missadvisory;
1869extern ulong_t nca_missadvNoA;
1870extern ulong_t nca_missERROR;
1871
1872extern ulong_t nca_ERROR;
1873extern ulong_t nca_flushnode;
1874extern ulong_t nca_replacenode;
1875extern ulong_t nca_tempnode;
1876
1877extern ulong_t nca_fail304;
1878
1879extern ulong_t nca_nocache1;
1880extern ulong_t nca_nocache2;
1881extern ulong_t nca_nocache3;
1882extern ulong_t nca_nocache4;
1883extern ulong_t nca_nocache5;
1884extern ulong_t nca_nocache6;
1885extern ulong_t nca_nocache6nomp;
1886extern ulong_t nca_nocache7;
1887extern ulong_t nca_nocache8;
1888extern ulong_t nca_nocache9;
1889extern ulong_t nca_nocache10;
1890extern ulong_t nca_nocache11;
1891extern ulong_t nca_nocache12;
1892extern ulong_t nca_nocache13;
1893extern ulong_t nca_nocache14;
1894extern ulong_t nca_nocache15;
1895extern ulong_t nca_nodes;
1896extern ulong_t nca_desballoc;
1897
1898extern ulong_t nca_plrucnt;
1899extern ulong_t nca_vlrucnt;
1900extern ulong_t nca_rpcall;
1901extern ulong_t nca_rvcall;
1902extern ulong_t nca_rpbusy;
1903extern ulong_t nca_rvbusy;
1904extern ulong_t nca_rpfail;
1905extern ulong_t nca_rpempty;
1906extern ulong_t nca_rvempty;
1907extern ulong_t nca_rpdone;
1908extern ulong_t nca_rvdone;
1909extern ulong_t nca_rmdone;
1910extern ulong_t nca_rkdone;
1911extern ulong_t nca_rsdone;
1912extern ulong_t nca_rndone;
1913extern ulong_t nca_rpnone;
1914extern ulong_t nca_rvnone;
1915extern ulong_t nca_rmnone;
1916extern ulong_t nca_rknone;
1917extern ulong_t nca_rsnone;
1918extern ulong_t nca_rnh;
1919extern ulong_t nca_ref[];
1920extern ulong_t nca_vmap_rpcall;
1921
1922extern ulong_t nca_node_kmem_fail1;
1923extern ulong_t nca_node_kmem_fail2;
1924
1925extern ulong_t doorsrv_nopreempt;
1926extern ulong_t doorsrv_badconnect;
1927extern ulong_t doorsrv_invaladvise;
1928extern ulong_t doorsrv_notupcall;
1929extern ulong_t doorsrv_badadvise;
1930extern ulong_t doorsrv_cksum;
1931extern ulong_t doorsrv_error;
1932extern ulong_t doorsrv_op;
1933extern ulong_t doorsrv_badtee;
1934extern ulong_t doorsrv_badio;
1935extern ulong_t doorsrv_sz;
1936
1937extern ulong_t nca_allocfail;
1938extern ulong_t nca_mapinfail;
1939extern ulong_t nca_mapinfail1;
1940extern ulong_t nca_mapinfail2;
1941extern ulong_t nca_mapinfail3;
1942
1943extern ulong_t nca_httpd_http;
1944extern ulong_t nca_httpd_badsz;
1945extern ulong_t nca_httpd_nosz;
1946extern ulong_t nca_httpd_filename;
1947extern ulong_t nca_httpd_filename1;
1948extern ulong_t nca_httpd_filename2;
1949extern ulong_t nca_httpd_trailer;
1950extern ulong_t nca_httpd_preempt;
1951extern ulong_t nca_httpd_downcall;
1952extern ulong_t nca_early_downcall;
1953extern ulong_t nca_httpd_more;
1954
1955ulong_t nca_logit_noupcall;
1956
1957ulong_t nca_logit;
1958ulong_t nca_logit_nomp;
1959ulong_t nca_logit_no;
1960ulong_t nca_logit_NULL;
1961ulong_t nca_logit_fail;
1962
1963ulong_t nca_logit_flush_NULL1;
1964ulong_t nca_logit_flush_NULL2;
1965
1966ulong_t nca_logger_NULL1;
1967ulong_t nca_logger_NULL2;
1968
1969ulong_t nca_log_buf_alloc_NULL;
1970ulong_t nca_log_buf_alloc_fail;
1971ulong_t nca_log_buf_alloc_part;
1972
1973ulong_t nca_log_buf_dup;
1974
1975extern ulong_t nca_upcalls;
1976extern ulong_t nca_ncafs_upcalls;
1977
1978extern ulong_t nca_conn_count;
1979extern ulong_t nca_conn_kmem;
1980extern ulong_t nca_conn_kmem_fail;
1981extern ulong_t nca_conn_allocb_fail;
1982extern ulong_t nca_conn_tw;
1983extern ulong_t nca_conn_tw1;
1984extern ulong_t nca_conn_tw2;
1985extern ulong_t nca_conn_reinit_cnt;
1986extern ulong_t nca_conn_NULL1;
1987extern ulong_t nca_conn_Q0;
1988extern ulong_t nca_conn_FLAGS;
1989
1990extern ulong_t tcpwronginq;
1991extern ulong_t ipsendup;
1992extern ulong_t ipwrongcpu;
1993extern ulong_t iponcpu;
1994
1995extern ulong_t nca_tcp_xmit_null;
1996extern ulong_t nca_tcp_xmit_null1;
1997
1998extern ulong_t tw_on;
1999extern ulong_t tw_fire;
2000extern ulong_t tw_fire1;
2001extern ulong_t tw_fire2;
2002extern ulong_t tw_fire3;
2003extern ulong_t tw_add;
2004extern ulong_t tw_add1;
2005extern ulong_t tw_delete;
2006extern ulong_t tw_reclaim;
2007extern ulong_t tw_reap;
2008extern ulong_t tw_reap1;
2009extern ulong_t tw_reap2;
2010extern ulong_t tw_reap3;
2011extern ulong_t tw_reap4;
2012extern ulong_t tw_reap5;
2013extern ulong_t tw_timer;
2014extern ulong_t tw_timer1;
2015extern ulong_t tw_timer2;
2016extern ulong_t tw_timer3;
2017extern ulong_t tw_timer4;
2018extern ulong_t tw_timer5;
2019
2020extern ulong_t ti_on;
2021extern ulong_t ti_fire;
2022extern ulong_t ti_fire1;
2023extern ulong_t ti_fire2;
2024extern ulong_t ti_fire3;
2025extern ulong_t ti_fire4;
2026extern ulong_t ti_add;
2027extern ulong_t ti_add1;
2028extern ulong_t ti_add2;
2029extern ulong_t ti_add3;
2030extern ulong_t ti_add4;
2031extern ulong_t ti_add5;
2032extern ulong_t ti_add_reuse;
2033extern ulong_t ti_delete;
2034extern ulong_t ti_delete1;
2035extern ulong_t ti_delete2;
2036extern ulong_t ti_reap;
2037extern ulong_t ti_reap1;
2038extern ulong_t ti_reap2;
2039extern ulong_t ti_reap3;
2040extern ulong_t ti_reap4;
2041extern ulong_t ti_reap5;
2042extern ulong_t ti_timer;
2043extern ulong_t ti_timer1;
2044extern ulong_t ti_timer2;
2045extern ulong_t ti_timer3;
2046extern ulong_t ti_timer4;
2047extern ulong_t ti_timer5;
2048extern ulong_t ti_timer6;
2049
2050extern uint32_t nca_conn_q;
2051extern uint32_t nca_conn_q0;
2052extern uint32_t nca_conn_req_max_q;
2053extern uint32_t nca_conn_req_max_q0;
2054
2055extern char nca_resp_500[];
2056extern ssize_t nca_resp_500_sz;
2057
2058extern uint32_t ncaurihash_sz;
2059extern uint32_t ncafilehash_sz;
2060extern uint32_t ncactaghash_sz;
2061extern uint32_t ncavnodehash_sz;
2062extern nodef_t *ncaurihash;
2063extern nodef_t *ncafilehash;
2064extern nodef_t *ncavnodehash;
2065extern nodef_t *ncactaghash;
2066extern char nca_httpd_door_path[];
2067extern char nca_httpd_downdoor_path[];
2068extern door_handle_t nca_downcall_door_hand;
2069extern uint32_t n_http_buf_size;
2070extern door_handle_t nca_httpd_door_hand;
2071extern sqfan_t nca_miss_fanout1;
2072extern sqfan_t nca_miss_fanout2;
2073extern nca_door_t nca_httpd_door;
2074extern int nca_downdoor_created;
2075extern int n_http_buf_table;
2076extern http_buf_table_t *g_http_buf_table;
2077extern struct kmem_cache *node_cache;
2078#ifdef DEBUG
2079extern node_t *nca_http_response(nca_conn_t *, const char *, int, char *, int,
2080		    uint_t, const char *);
2081extern node_t *nca_http_response_node(nca_conn_t *, const char *, int, node_t *,
2082		    const char *);
2083#else
2084extern node_t *nca_http_response(nca_conn_t *, const char *, int, char *, int,
2085		    uint_t);
2086extern node_t *nca_http_response_node(nca_conn_t *, const char *, int,
2087    node_t *);
2088#endif
2089extern void nca_node_del(node_t *);
2090extern void nca_node_uncache(node_t *);
2091extern node_t *nca_node_add(char *, int, nodef_t *, int);
2092extern node_t *node_create(int, boolean_t, char *, int);
2093extern void nca_reclaim_phys(node_t *, boolean_t, boolean_t);
2094extern boolean_t nca_http_pmap(node_t *);
2095extern boolean_t nca_http_vmap(node_t *, int);
2096extern time_t nca_http_date(char *);
2097extern node_t *nca_httpd_data(node_t *, nca_conn_t *, nca_io2_t *, int);
2098extern void nca_missed(node_t *, mblk_t *, nca_squeue_t *);
2099extern void nca_miss_conn_mv(node_t *, nca_conn_t *);
2100extern void nca_miss_conn_fr(node_t *, nca_conn_t *);
2101extern void nca_http_logit(nca_conn_t *);
2102extern void nca_http_error(nca_conn_t *);
2103extern void nca_node_xmit(node_t *, nca_conn_t *);
2104
2105/*
2106 * It contains data for forwarding data to application programs.
2107 * For door case, doorhandle is the upcall door handle and listenerq
2108 * is NULL; for ncafs, listenerq is the upcall listener queue and
2109 * doorhandle is NULL. listenning is always B_TRUE for door and it is
2110 * B_TRUE for ncafs only after the listen system call has been issued.
2111 */
2112typedef struct nca_listener_s {
2113	boolean_t	listenning;	/* is ready for accepting connection */
2114	door_handle_t	doorhandle;	/* door handle or NULL for ncafs */
2115	queue_t		*listenerq;	/* upcall queue or NULL for door */
2116} nca_listener_t;
2117
2118/*
2119 * Returned values of nca_isnca_data.
2120 * NOT_NCA_DATA:	not NCA data.
2121 * NCA_DATA_ANY_ADDR:	NCA data, matches INADDR_ANY.
2122 * NCA_DATA_ADDR:	NCA data, match an IP address.
2123 */
2124#define	NOT_NCA_DATA		0
2125#define	NCA_DATA_ANY_ADDR	1
2126#define	NCA_DATA_ADDR		2
2127
2128extern uint32_t ipportrehashcount1;
2129extern uint32_t ipportrehashcount2;
2130extern uint32_t ipportbucketcnt;
2131extern uint32_t ipporttablesize;
2132extern uint32_t ncafscount;
2133extern uint32_t doorcount;
2134extern int	ip_virtual_hosting;
2135
2136extern nca_listener_t *nca_listener_find(ipaddr_t, uint16_t);
2137extern nca_listener_t *nca_listener_find2(ipaddr_t, uint16_t);
2138extern int		nca_isnca_data(ipaddr_t, uint16_t);
2139extern int		nca_listener_add(ipaddr_t, uint16_t, void *, boolean_t);
2140extern int		nca_listener_del(ipaddr_t, uint16_t);
2141extern void		nca_listener_report(mblk_t *);
2142
2143#ifdef	__cplusplus
2144}
2145#endif
2146
2147#endif	/* _INET_NCA_H */
2148