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 * Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
25 * Copyright 2015 Joyent, Inc.  All rights reserved.
26 */
27
28/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
29/*	  All Rights Reserved	*/
30
31
32#ifndef _SYS_STREAM_H
33#define	_SYS_STREAM_H
34
35/*
36 * For source compatibility
37 */
38#include <sys/isa_defs.h>
39#if defined(_KERNEL) || defined(_FAKE_KERNEL)
40#include <sys/kmem.h>
41#include <sys/uio.h>
42#endif
43#include <sys/poll.h>
44#include <sys/strmdep.h>
45#include <sys/cred.h>
46#include <sys/t_lock.h>
47#include <sys/model.h>
48
49#ifdef	__cplusplus
50extern "C" {
51#endif
52
53/*
54 * Data queue.
55 *
56 * NOTE: The *only* public fields are documented in queue(9S).
57 *       Everything else is implementation-private.
58 *
59 * The locking rules for the queue_t structure are extremely subtle and vary
60 * widely depending on the field in question.  As such, each field is
61 * annotated according to the following legend:
62 *
63 *   Q9S: The field is documented in queue(9S) and may be accessed without
64 *        locks by a STREAMS module when inside an entry point (e.g., put(9E)).
65 *        However, no fields can be directly modified unless q_lock is held
66 *        (which is not possible in a DDI compliant STREAMS module), with the
67 *        following exceptions:
68 *
69 *	   - q_ptr: can be modified as per the rules of the STREAMS module.
70 *		    The STREAMS framework ignores q_ptr and thus imposes *no*
71 *		    locking rules on it.
72 *         - q_qinfo: can be modified before qprocson().
73 *
74 *	   - q_minpsz, q_maxpsz, q_hiwat, q_lowat: can be modified as per the
75 *		    rules of the STREAMS module.  The STREAMS framework never
76 *		    modifies these fields, and is tolerant of temporarily
77 *		    stale field values.
78 *
79 *	  In general, the STREAMS framework employs one of the following
80 *	  techniques to ensure STREAMS modules can safely access Q9S fields:
81 *
82 *	   - The field is only modified by the framework when the stream is
83 *	     locked with strlock() (q_next).
84 *
85 *	   - The field is modified by the framework, but the modifies are
86 *	     atomic, and temporarily stale values are harmless (q_count,
87 *	     q_first, q_last).
88 *
89 *	   - The field is modified by the framework, but the field's visible
90 *	     values are either constant or directly under the control
91 *	     of the STREAMS module itself (q_flag).
92 *
93 *   QLK: The field must be accessed or modified under q_lock, except when
94 *        the stream has been locked with strlock().  If multiple q_locks must
95 *        be acquired, q_locks at higher addresses must be taken first.
96 *
97 *   STR: The field can be accessed without a lock, but must be modified under
98 *	  strlock().
99 *
100 *   SQLK: The field must be accessed or modified under SQLOCK().
101 *
102 *   NOLK: The field can be accessed without a lock, but can only be modified
103 *	   when the queue_t is not known to any other threads.
104 *
105 *   SVLK: The field must be accessed or modified under the service_queue lock.
106 *         Note that service_lock must be taken after any needed q_locks,
107 *	   and that no other lock should be taken while service_lock is held.
108 *
109 * In addition, it is always acceptable to modify a field that is not yet
110 * known to any other threads -- and other special case exceptions exist in
111 * the code.  Also, q_lock is used with q_wait to implement a stream head
112 * monitor for reads and writes.
113 */
114typedef struct queue {
115	struct qinit	*q_qinfo;	/* Q9S: Q processing procedure  */
116	struct msgb	*q_first;	/* Q9S: first message in Q	*/
117	struct msgb	*q_last;	/* Q9S: last message in Q	*/
118	struct queue	*q_next;	/* Q9S: next Q in stream	*/
119	struct queue	*q_link;	/* SVLK: next Q for scheduling	*/
120	void		*q_ptr;		/* Q9S: module-specific data	*/
121	size_t		q_count;	/* Q9S: number of bytes on Q	*/
122	uint_t		q_flag;		/* Q9S: Q state			*/
123	ssize_t		q_minpsz;	/* Q9S: smallest packet OK on Q */
124	ssize_t		q_maxpsz;	/* Q9S: largest packet OK on Q	*/
125	size_t		q_hiwat;	/* Q9S: Q high water mark	*/
126	size_t		q_lowat;	/* Q9S: Q low water mark	*/
127	struct qband	*q_bandp;	/* QLK: band flow information	*/
128	kmutex_t	q_lock;		/* NOLK: structure lock		*/
129	struct stdata	*q_stream;	/* NOLK: stream backpointer	*/
130	struct syncq	*q_syncq;	/* NOLK: associated syncq	*/
131	unsigned char	q_nband;	/* QLK: number of bands		*/
132	kcondvar_t	q_wait;		/* NOLK: read/write sleep CV	*/
133	struct queue	*q_nfsrv;	/* STR: next Q with svc routine */
134	ushort_t	q_draining;	/* QLK: Q is draining		*/
135	short		q_struiot;	/* QLK: sync streams Q UIO mode	*/
136	clock_t		q_qtstamp;	/* QLK: when Q was enabled	*/
137	size_t		q_mblkcnt;	/* QLK: mblk count		*/
138	uint_t		q_syncqmsgs;	/* QLK: syncq message count	*/
139	size_t		q_rwcnt;	/* QLK: # threads in rwnext()	*/
140	pri_t		q_spri;		/* QLK: Q scheduling priority	*/
141
142	/*
143	 * Syncq scheduling
144	 */
145	struct msgb	*q_sqhead;	/* QLK: first syncq message	*/
146	struct msgb	*q_sqtail;	/* QLK: last syncq message	*/
147	struct queue	*q_sqnext;	/* SQLK: next Q on syncq list	*/
148	struct queue	*q_sqprev;	/* SQLK: prev Q on syncq list	*/
149	uint_t		q_sqflags;	/* SQLK: syncq flags		*/
150	clock_t		q_sqtstamp;	/* SQLK: when Q was scheduled for sq */
151
152	/*
153	 * NOLK: Reference to the queue's module's implementation
154	 * structure. This will be NULL for queues associated with drivers.
155	 */
156	struct fmodsw_impl	*q_fp;
157} queue_t;
158
159/*
160 * Queue flags; unused flags not documented in queue(9S) can be recycled.
161 */
162#define	QENAB		0x00000001	/* Queue is already enabled to run */
163#define	QWANTR		0x00000002	/* Someone wants to read Q	*/
164#define	QWANTW		0x00000004	/* Someone wants to write Q	*/
165#define	QFULL		0x00000008	/* Q is considered full		*/
166#define	QREADR		0x00000010	/* This is the reader (first) Q	*/
167#define	QUSE		0x00000020	/* This queue in use (allocation) */
168#define	QNOENB		0x00000040	/* Don't enable Q via putq	*/
169#define	QWANTRMQSYNC	0x00000080	/* Want to remove sync stream Q */
170#define	QBACK		0x00000100	/* queue has been back-enabled	*/
171/*	UNUSED		0x00000200	   was QHLIST			*/
172/*	UNUSED		0x00000400	   was QUNSAFE			*/
173#define	QPAIR		0x00000800	/* per queue-pair syncq		*/
174#define	QPERQ		0x00001000	/* per queue-instance syncq	*/
175#define	QPERMOD		0x00002000	/* per module syncq		*/
176#define	QMTSAFE		0x00004000	/* stream module is MT-safe	*/
177#define	QMTOUTPERIM	0x00008000	/* Has outer perimeter		*/
178#define	QMT_TYPEMASK	(QPAIR|QPERQ|QPERMOD|QMTSAFE|QMTOUTPERIM)
179					/* all MT type flags		*/
180#define	QINSERVICE	0x00010000	/* service routine executing	*/
181#define	QWCLOSE		0x00020000	/* will not be enabled		*/
182#define	QEND		0x00040000	/* last queue in stream		*/
183#define	QWANTWSYNC	0x00080000	/* Streamhead wants to write Q	*/
184#define	QSYNCSTR	0x00100000	/* Q supports Synchronous STREAMS */
185#define	QISDRV		0x00200000	/* the Queue is attached to a driver */
186/*	UNUSED		0x00400000	   was QHOT			*/
187/*	UNUSED		0x00800000	   was QNEXTHOT			*/
188/*	UNUSED		0x01000000	   was _QNEXTLESS		*/
189#define	_QINSERTING	0x04000000	/* Private, module is being inserted */
190#define	_QREMOVING	0x08000000	/* Private, module is being removed */
191#define	_QASSOCIATED	0x10000000	/* queue is associated with a device */
192#define	_QDIRECT	0x20000000	/* Private; transport module uses */
193					/* direct interface to/from sockfs */
194#define	_QSINGLE_INSTANCE	0x40000000	/* Private; module may only */
195						/* be pushed once */
196
197/* queue sqflags (protected by SQLOCK). */
198#define	Q_SQQUEUED	0x01		/* Queue is in the syncq list */
199#define	Q_SQDRAINING	0x02		/* Servicing syncq msgs.	*/
200					/* This is also noted by the	*/
201					/* q_draining field, but this one is */
202					/* protected by SQLOCK */
203
204/*
205 * Structure that describes the separate information
206 * for each priority band in the queue.
207 */
208typedef struct qband {
209	struct qband	*qb_next;	/* next band's info */
210	size_t		qb_count;	/* number of bytes in band */
211	struct msgb	*qb_first;	/* beginning of band's data */
212	struct msgb	*qb_last;	/* end of band's data */
213	size_t		qb_hiwat;	/* high water mark for band */
214	size_t		qb_lowat;	/* low water mark for band */
215	uint_t		qb_flag;	/* see below */
216	size_t		qb_mblkcnt;	/* mblk counter for runaway msgs */
217} qband_t;
218
219/*
220 * qband flags
221 */
222#define	QB_FULL		0x01		/* band is considered full */
223#define	QB_WANTW	0x02		/* Someone wants to write to band */
224#define	QB_BACK		0x04		/* queue has been back-enabled */
225
226/*
227 * Maximum number of bands.
228 */
229#define	NBAND	256
230
231/*
232 * Fields that can be manipulated through strqset() and strqget().
233 */
234typedef enum qfields {
235	QHIWAT	= 0,		/* q_hiwat or qb_hiwat */
236	QLOWAT	= 1,		/* q_lowat or qb_lowat */
237	QMAXPSZ	= 2,		/* q_maxpsz */
238	QMINPSZ	= 3,		/* q_minpsz */
239	QCOUNT	= 4,		/* q_count or qb_count */
240	QFIRST	= 5,		/* q_first or qb_first */
241	QLAST	= 6,		/* q_last or qb_last */
242	QFLAG	= 7,		/* q_flag or qb_flag */
243	QSTRUIOT = 8,		/* q_struiot */
244	QBAD	= 9
245} qfields_t;
246
247/*
248 * Module information structure
249 */
250struct module_info {
251	ushort_t mi_idnum;		/* module id number */
252	char	*mi_idname;		/* module name */
253	ssize_t	mi_minpsz;		/* min packet size accepted */
254	ssize_t	mi_maxpsz;		/* max packet size accepted */
255	size_t	mi_hiwat;		/* hi-water mark */
256	size_t	mi_lowat;		/* lo-water mark */
257};
258
259/*
260 * queue information structure (with Synchronous STREAMS extensions)
261 */
262
263typedef struct msgb mblk_t;
264typedef struct struiod struiod_t;
265typedef struct infod infod_t;
266
267typedef	int (*qi_putp_t)(queue_t *, mblk_t *);
268typedef	int (*qi_srvp_t)(queue_t *);
269typedef	int (*qi_qopen_t)(queue_t *, dev_t *, int, int, cred_t *);
270typedef	int (*qi_qclose_t)(queue_t *, int, cred_t *);
271typedef	int (*qi_qadmin_t)(void);
272typedef	int (*qi_rwp_t)(queue_t *, struiod_t *);
273typedef	int (*qi_infop_t)(queue_t *, infod_t *);
274
275struct	qinit {
276	qi_putp_t	qi_putp;	/* put procedure */
277	qi_srvp_t	qi_srvp;	/* service procedure */
278	qi_qopen_t	qi_qopen;	/* called on startup */
279	qi_qclose_t	qi_qclose;	/* called on finish */
280	qi_qadmin_t	qi_qadmin;	/* for future use */
281	struct module_info *qi_minfo;	/* module information structure */
282	struct module_stat *qi_mstat;	/* module statistics structure */
283	qi_rwp_t	qi_rwp;		/* r/w procedure */
284	qi_infop_t	qi_infop;	/* information procedure */
285	int		qi_struiot;	/* stream uio type for struio() */
286};
287
288/*
289 * Values for qi_struiot and q_struiot:
290 */
291#define	STRUIOT_NONE		-1	/* doesn't support struio() */
292#define	STRUIOT_DONTCARE	0	/* use current uiomove() (default) */
293#define	STRUIOT_STANDARD	1	/* use standard uiomove() */
294
295/*
296 * Streamtab (used in cdevsw and fmodsw to point to module or driver)
297 */
298struct streamtab {
299	struct qinit *st_rdinit;
300	struct qinit *st_wrinit;
301	struct qinit *st_muxrinit;
302	struct qinit *st_muxwinit;
303};
304
305/*
306 * Structure sent to mux drivers to indicate a link.
307 */
308struct linkblk {
309	queue_t *l_qtop;	/* lowest level write queue of upper stream */
310				/* (set to NULL for persistent links) */
311	queue_t *l_qbot;	/* highest level write queue of lower stream */
312	int	l_index;	/* index for lower stream. */
313};
314
315/*
316 * Esballoc data buffer freeing routine
317 */
318typedef struct free_rtn {
319	void	(*free_func)();
320	caddr_t	free_arg;
321} frtn_t;
322
323/*
324 * Data block descriptor
325 *
326 * NOTE: db_base, db_lim, db_ref and db_type are the *only* public fields,
327 * as described in datab(9S).  Everything else is implementation-private.
328 */
329
330#define	DBLK_REFMAX	255U
331
332typedef struct datab {
333	frtn_t		*db_frtnp;
334	unsigned char	*db_base;
335	unsigned char	*db_lim;
336	unsigned char	db_ref;
337	unsigned char	db_type;
338	unsigned char	db_flags;
339	unsigned char	db_struioflag;
340	pid_t		db_cpid;	/* cached pid, needs verification */
341	void		*db_cache;	/* kmem cache descriptor */
342	struct msgb	*db_mblk;
343	void		(*db_free)(struct msgb *, struct datab *);
344	void		(*db_lastfree)(struct msgb *, struct datab *);
345	intptr_t	db_cksumstart;
346	intptr_t	db_cksumend;
347	intptr_t	db_cksumstuff;
348	union {
349		double enforce_alignment;
350		unsigned char data[8];
351		struct {
352			union {
353				uint32_t u32;
354				uint16_t u16;
355			} cksum_val;    /* used to store calculated cksum */
356			uint16_t flags;
357			uint16_t pad;
358		} cksum;
359		/*
360		 * Union used for future extensions (pointer to data ?).
361		 */
362	} db_struioun;
363	struct fthdr	*db_fthdr;
364	cred_t		*db_credp;	/* credential */
365} dblk_t;
366
367#define	db_cksum16	db_struioun.cksum.cksum_val.u16
368#define	db_cksum32	db_struioun.cksum.cksum_val.u32
369
370/*
371 * Accessor macros for private dblk_t fields (the rest are in <sys/strsun.h>).
372 */
373#define	DB_CPID(mp)		((mp)->b_datap->db_cpid)
374#define	DB_CRED(mp)		((mp)->b_datap->db_credp)
375#define	DB_FTHDR(mp)		((mp)->b_datap->db_fthdr)
376/*
377 * Used by GLDv2 to store the TCI information.
378 */
379#define	DB_TCI(mp)		((mp)->b_datap->db_struioun.cksum.pad)
380
381/*
382 * Message block descriptor
383 */
384struct	msgb {
385	struct	msgb	*b_next;
386	struct  msgb	*b_prev;
387	struct	msgb	*b_cont;
388	unsigned char	*b_rptr;
389	unsigned char	*b_wptr;
390	struct datab	*b_datap;
391	unsigned char	b_band;
392	unsigned char	b_tag;
393	unsigned short	b_flag;
394	queue_t		*b_queue;	/* for sync queues */
395};
396
397/*
398 * bcache descriptor
399 */
400typedef	struct	bcache {
401	kmutex_t		mutex;
402	struct kmem_cache	*buffer_cache;
403	struct kmem_cache	*dblk_cache;
404	int			alloc;
405	int			destroy;
406	size_t			size;
407	uint_t			align;
408} bcache_t;
409
410/*
411 * db_flags values (all implementation private!)
412 */
413#define	DBLK_REFMIN		0x01	/* min refcnt stored in low bit */
414#define	DBLK_COOKED		0x02	/* message has been processed once */
415#define	DBLK_UIOA		0x04	/* uioamove() is pending */
416
417/*
418 * db_struioflag values:
419 */
420#define	STRUIO_SPEC	0x01	/* struio{get,put}() special mblk */
421#define	STRUIO_DONE	0x02	/* struio done (could be partial) */
422#define	STRUIO_IP	0x04	/* IP checksum stored in db_struioun */
423#define	STRUIO_ZC	0x08	/* mblk eligible for zero-copy */
424#define	STRUIO_ZCNOTIFY	0x10	/* notify stream head when mblk acked */
425
426/*
427 * Message flags.  These are interpreted by the stream head.
428 */
429#define	MSGMARK		0x01	/* last byte of message is "marked" */
430#define	MSGNOLOOP	0x02	/* don't loop message around to */
431				/* write side of stream */
432#define	MSGDELIM	0x04	/* message is delimited */
433/*	UNUSED		0x08	   was MSGNOGET (can be recycled) */
434#define	MSGMARKNEXT	0x10	/* Private: first byte of next msg marked */
435#define	MSGNOTMARKNEXT	0x20	/* Private: ... not marked */
436#define	MSGWAITSYNC	0x40	/* Private: waiting for sync squeue enter */
437
438/*
439 * Streams message types.
440 */
441
442/*
443 * Data and protocol messages (regular and priority)
444 */
445#define	M_DATA		0x00		/* regular data */
446#define	M_PROTO		0x01		/* protocol control */
447#define	M_MULTIDATA	0x02		/* reserved for Multidata use only */
448
449/*
450 * Control messages (regular and priority)
451 */
452#define	M_BREAK		0x08		/* line break */
453#define	M_PASSFP	0x09		/* pass file pointer */
454#define	M_EVENT		0x0a		/* Obsoleted: do not use */
455#define	M_SIG		0x0b		/* generate process signal */
456#define	M_DELAY		0x0c		/* real-time xmit delay (1 param) */
457#define	M_CTL		0x0d		/* device-specific control message */
458#define	M_IOCTL		0x0e		/* ioctl; set/get params */
459#define	M_SETOPTS	0x10		/* set various stream head options */
460#define	M_RSE		0x11		/* reserved for RSE use only */
461
462/*
463 * Control messages (high priority; go to head of queue)
464 */
465#define	M_IOCACK	0x81		/* acknowledge ioctl */
466#define	M_IOCNAK	0x82		/* negative ioctl acknowledge */
467#define	M_PCPROTO	0x83		/* priority proto message */
468#define	M_PCSIG		0x84		/* generate process signal */
469#define	M_READ		0x85		/* generate read notification */
470#define	M_FLUSH		0x86		/* flush your queues */
471#define	M_STOP		0x87		/* stop transmission immediately */
472#define	M_START		0x88		/* restart transmission after stop */
473#define	M_HANGUP	0x89		/* line disconnect */
474#define	M_ERROR		0x8a		/* send error to stream head */
475#define	M_COPYIN	0x8b		/* request to copyin data */
476#define	M_COPYOUT	0x8c		/* request to copyout data */
477#define	M_IOCDATA	0x8d		/* response to M_COPYIN and M_COPYOUT */
478#define	M_PCRSE		0x8e		/* reserved for RSE use only */
479#define	M_STOPI		0x8f		/* stop reception immediately */
480#define	M_STARTI	0x90		/* restart reception after stop */
481#define	M_PCEVENT	0x91		/* Obsoleted: do not use */
482#define	M_UNHANGUP	0x92		/* line reconnect, sigh */
483#define	M_CMD		0x93		/* out-of-band ioctl command */
484
485/*
486 * Queue message class definitions.
487 */
488#define	QNORM		0x00		/* normal priority messages */
489#define	QPCTL		0x80		/* high priority cntrl messages */
490
491/*
492 *  IOCTL structure - this structure is the format of the M_IOCTL message type.
493 */
494#if	defined(_LP64)
495struct iocblk {
496	int	ioc_cmd;		/* ioctl command type */
497	cred_t	*ioc_cr;		/* full credentials */
498	uint_t	ioc_id;			/* ioctl id */
499	uint_t	ioc_flag;		/* see below */
500	size_t	ioc_count;		/* count of bytes in data field */
501	int	ioc_rval;		/* return value  */
502	int	ioc_error;		/* error code */
503};
504#else
505struct iocblk {
506	int	ioc_cmd;		/* ioctl command type */
507	cred_t	*ioc_cr;		/* full credentials */
508	uint_t	ioc_id;			/* ioctl id */
509	size_t	ioc_count;		/* count of bytes in data field */
510	int	ioc_error;		/* error code */
511	int	ioc_rval;		/* return value  */
512	int	ioc_fill1;
513	uint_t	ioc_flag;		/* see below */
514	int	ioc_filler[2];		/* reserved for future use */
515};
516#endif	/* _LP64 */
517
518typedef	struct iocblk	*IOCP;
519
520/* {ioc,cp}_flags values */
521
522#define	IOC_MODELS	DATAMODEL_MASK	/* Note: 0x0FF00000 */
523#define	IOC_ILP32	DATAMODEL_ILP32	/* ioctl origin is ILP32 */
524#define	IOC_LP64	DATAMODEL_LP64	/* ioctl origin is LP64 */
525#define	IOC_NATIVE	DATAMODEL_NATIVE
526#define	IOC_NONE	DATAMODEL_NONE	/* dummy comparison value */
527
528/*
529 *	Is the ioctl data formatted for our native model?
530 */
531#define	IOC_CONVERT_FROM(iocp)	ddi_model_convert_from( \
532				    ((struct iocblk *)iocp)->ioc_flag)
533
534/*
535 * structure for the M_COPYIN and M_COPYOUT message types.
536 */
537#if	defined(_LP64)
538struct copyreq {
539	int	cq_cmd;			/* ioctl command (from ioc_cmd) */
540	cred_t	*cq_cr;			/* full credentials (from ioc_cmd) */
541	uint_t	cq_id;			/* ioctl id (from ioc_id) */
542	uint_t	cq_flag;		/* must be zero */
543	mblk_t	*cq_private;		/* private state information */
544	caddr_t	cq_addr;		/* address to copy data to/from */
545	size_t	cq_size;		/* number of bytes to copy */
546};
547#else
548struct copyreq {
549	int	cq_cmd;			/* ioctl command (from ioc_cmd) */
550	cred_t	*cq_cr;			/* full credentials */
551	uint_t	cq_id;			/* ioctl id (from ioc_id) */
552	caddr_t	cq_addr;		/* address to copy data to/from */
553	size_t	cq_size;		/* number of bytes to copy */
554	uint_t	cq_flag;		/* must be zero */
555	mblk_t	*cq_private;		/* private state information */
556	int	cq_filler[4];		/* reserved for future use */
557};
558#endif	/* _LP64 */
559
560/*
561 * structure for the M_IOCDATA message type.
562 */
563#if	defined(_LP64)
564struct copyresp {
565	int	cp_cmd;			/* ioctl command (from ioc_cmd) */
566	cred_t	*cp_cr;			/* full credentials (from ioc_cmd) */
567	uint_t	cp_id;			/* ioctl id (from ioc_id) */
568	uint_t	cp_flag;		/* datamodel IOC_ flags; see above */
569	mblk_t *cp_private;		/* private state information */
570	caddr_t	cp_rval;		/* status of request: 0 -> success */
571					/*		non-zero -> failure */
572};
573#else
574struct copyresp {
575	int	cp_cmd;			/* ioctl command (from ioc_cmd) */
576	cred_t	*cp_cr;			/* full credentials */
577	uint_t	cp_id;			/* ioctl id (from ioc_id) */
578	caddr_t	cp_rval;		/* status of request: 0 -> success */
579					/*		non-zero -> failure */
580	size_t	cp_pad1;
581	uint_t	cp_pad2;
582	mblk_t *cp_private;		/* private state information */
583	uint_t	cp_flag;		/* datamodel IOC_ flags; see above */
584	int	cp_filler[3];
585};
586#endif	/* _LP64 */
587
588/*
589 * Since these structures are all intended to travel in the same message
590 * at different stages of a STREAMS ioctl, this union is used to determine
591 * the message size in strdoioctl().
592 */
593union ioctypes {
594	struct iocblk	iocblk;
595	struct copyreq	copyreq;
596	struct copyresp	copyresp;
597};
598
599/*
600 * Options structure for M_SETOPTS message.  This is sent upstream
601 * by a module or driver to set stream head options.
602 */
603struct stroptions {
604	uint_t	so_flags;		/* options to set */
605	short	so_readopt;		/* read option */
606	ushort_t so_wroff;		/* write offset */
607	ssize_t	so_minpsz;		/* minimum read packet size */
608	ssize_t	so_maxpsz;		/* maximum read packet size */
609	size_t	so_hiwat;		/* read queue high water mark */
610	size_t	so_lowat;		/* read queue low water mark */
611	unsigned char so_band;		/* band for water marks */
612	ushort_t so_erropt;		/* error option */
613	ssize_t	so_maxblk;		/* maximum message block size */
614	ushort_t so_copyopt;		/* copy options (see stropts.h) */
615	ushort_t so_tail;		/* space available at the end */
616};
617
618/* flags for stream options set message */
619
620#define	SO_ALL		0x003f	/* set all old options */
621#define	SO_READOPT	0x0001	/* set read option */
622#define	SO_WROFF	0x0002	/* set write offset */
623#define	SO_MINPSZ	0x0004	/* set min packet size */
624#define	SO_MAXPSZ	0x0008	/* set max packet size */
625#define	SO_HIWAT	0x0010	/* set high water mark */
626#define	SO_LOWAT	0x0020	/* set low water mark */
627#define	SO_MREADON	0x0040	/* set read notification ON */
628#define	SO_MREADOFF	0x0080	/* set read notification OFF */
629#define	SO_NDELON	0x0100	/* old TTY semantics for NDELAY reads/writes */
630#define	SO_NDELOFF	0x0200	/* STREAMS semantics for NDELAY reads/writes */
631#define	SO_ISTTY	0x0400	/* the stream is acting as a terminal */
632#define	SO_ISNTTY	0x0800	/* the stream is not acting as a terminal */
633#define	SO_TOSTOP	0x1000	/* stop on background writes to this stream */
634#define	SO_TONSTOP	0x2000	/* do not stop on background writes to stream */
635#define	SO_BAND		0x4000	/* water marks affect band */
636#define	SO_DELIM	0x8000	/* messages are delimited */
637#define	SO_NODELIM	0x010000	/* turn off delimiters */
638#define	SO_STRHOLD	0x020000	/* No longer implemented */
639#define	SO_ERROPT	0x040000	/* set error option */
640#define	SO_COPYOPT	0x080000	/* copy option(s) present */
641#define	SO_MAXBLK	0x100000	/* set maximum message block size */
642#define	SO_TAIL		0x200000	/* set the extra allocated space */
643
644#if defined(_KERNEL) || defined(_FAKE_KERNEL)
645/*
646 * Structure for rw (read/write) procedure calls. A pointer
647 * to a struiod_t is passed as a parameter to the rwnext() call.
648 */
649struct struiod {
650	mblk_t		*d_mp;		/* pointer to mblk (chain) */
651	uio_t		d_uio;		/* uio info */
652	iovec_t		*d_iov;		/* iov referenced by uio */
653};
654
655/*
656 * Structure for information procedure calls.
657 */
658struct infod {
659	unsigned char	d_cmd;		/* info info request command */
660	unsigned char	d_res;		/* info info command results */
661	int		d_bytes;	/* mblk(s) byte count */
662	int		d_count;	/* count of mblk(s) */
663	uio_t		*d_uiop;	/* pointer to uio struct */
664};
665/*
666 * Values for d_cmd & d_res.
667 */
668#define	INFOD_FIRSTBYTES	0x02	/* return msgbsize() of first mblk */
669#define	INFOD_BYTES		0x04	/* return msgbsize() of all mblk(s) */
670#define	INFOD_COUNT		0x08	/* return count of mblk(s) */
671#define	INFOD_COPYOUT		0x10	/* copyout any M_DATA mblk(s) */
672
673/*
674 * Structure used by _I_CMD mechanism, similar in spirit to iocblk.
675 */
676typedef struct cmdblk {
677	int		cb_cmd;		/* ioctl command type */
678	cred_t		*cb_cr;		/* full credentials */
679	uint_t		cb_len;		/* payload size */
680	int		cb_error;	/* error code */
681} cmdblk_t;
682
683#endif /* _KERNEL */
684
685/*
686 * Miscellaneous parameters and flags.
687 */
688
689/*
690 * Values for stream flag in open to indicate module open, clone open,
691 * and the return value for failure.
692 */
693#define	MODOPEN		0x1		/* open as a module */
694#define	CLONEOPEN	0x2		/* clone open; pick own minor dev */
695#define	OPENFAIL	-1		/* returned for open failure */
696
697/*
698 * Priority definitions for block allocation.
699 */
700#define	BPRI_LO		1
701#define	BPRI_MED	2
702#define	BPRI_HI		3
703
704/*
705 * Value for packet size that denotes infinity
706 */
707#define	INFPSZ		-1
708
709/*
710 * Flags for flushq()
711 */
712#define	FLUSHALL	1	/* flush all messages */
713#define	FLUSHDATA	0	/* don't flush control messages */
714
715/*
716 * Flag for transparent ioctls
717 */
718#define	TRANSPARENT	(unsigned int)(-1)
719
720/*
721 * Stream head default high/low water marks
722 */
723#define	STRHIGH 5120
724#define	STRLOW	1024
725
726/*
727 * qwriter perimeter types
728 */
729#define	PERIM_INNER	1		/* The inner perimeter */
730#define	PERIM_OUTER	2		/* The outer perimeter */
731
732/*
733 * Definitions of Streams macros and function interfaces.
734 */
735
736/*
737 * canenable - check if queue can be enabled by putq().
738 */
739#define	canenable(q)	!((q)->q_flag & QNOENB)
740
741/*
742 * Test if data block type is one of the data messages (i.e. not a control
743 * message).
744 */
745#define	datamsg(type) \
746		((type) == M_DATA || \
747		    (type) == M_MULTIDATA || \
748		    (type) == M_PROTO || \
749		    (type) == M_PCPROTO || \
750		    (type) == M_DELAY)
751
752/*
753 * Extract queue class of message block.
754 */
755#define	queclass(bp) (((bp)->b_datap->db_type >= QPCTL) ? QPCTL : QNORM)
756
757/*
758 * Align address on next lower word boundary.
759 */
760#define	straln(a)	(caddr_t)((intptr_t)(a) & -(sizeof (int)-1))
761
762/*
763 * Find the max size of data block.
764 */
765#define	bpsize(bp) ((unsigned int)(bp->b_datap->db_lim - bp->b_datap->db_base))
766
767#if defined(_KERNEL) || defined(_FAKE_KERNEL)
768
769/*
770 * For two-byte M_ERROR messages: indication that a side does not have an error
771 */
772#define	NOERROR	((unsigned char)-1)
773
774/*
775 * declarations of common routines
776 */
777
778extern mblk_t *allocb(size_t, uint_t);
779extern mblk_t *desballoc(unsigned char *, size_t, uint_t, frtn_t *);
780extern mblk_t *esballoc(unsigned char *, size_t, uint_t, frtn_t *);
781extern bcache_t *bcache_create(char *, size_t, uint_t);
782extern void bcache_destroy(bcache_t *);
783extern mblk_t *bcache_allocb(bcache_t *, uint_t);
784extern mblk_t *mkiocb(uint_t);
785extern int testb(size_t, uint_t);
786extern bufcall_id_t bufcall(size_t, uint_t, void (*)(void *), void *);
787extern bufcall_id_t esbbcall(uint_t, void (*)(void *), void *);
788extern void freeb(struct msgb *);
789extern void freemsg(mblk_t *);
790extern mblk_t *dupb(mblk_t *);
791extern mblk_t *dupmsg(mblk_t *);
792extern mblk_t *dupmsg_noloan(mblk_t *);
793extern mblk_t *copyb(mblk_t *);
794extern mblk_t *copymsg(mblk_t *);
795extern void linkb(mblk_t *, mblk_t *);
796extern mblk_t *unlinkb(mblk_t *);
797extern mblk_t *reallocb(mblk_t *, size_t, uint_t);	/* private */
798extern mblk_t *rmvb(mblk_t *, mblk_t *);
799extern int pullupmsg(struct msgb *, ssize_t);
800extern mblk_t *msgpullup(struct msgb *, ssize_t);
801extern int adjmsg(struct msgb *, ssize_t);
802extern size_t msgdsize(struct msgb *);
803extern mblk_t *getq(queue_t *);
804extern void rmvq(queue_t *, mblk_t *);
805extern void flushq(queue_t *, int);
806extern void flushq_common(queue_t *, int, int);
807extern void flushband(queue_t *, unsigned char, int);
808extern int canput(queue_t *);
809extern int bcanput(queue_t *, unsigned char);
810extern int canputnext(queue_t *);
811extern int bcanputnext(queue_t *, unsigned char);
812extern int putq(queue_t *, mblk_t *);
813extern int putbq(queue_t *, mblk_t *);
814extern int insq(queue_t *, mblk_t *, mblk_t *);
815extern void put(queue_t *, mblk_t *);
816extern void putnext(queue_t *, mblk_t *);
817extern int putctl(queue_t *, int);
818extern int putctl1(queue_t *, int, int);
819extern int putnextctl(queue_t *, int);
820extern int putnextctl1(queue_t *, int, int);
821extern queue_t *backq(queue_t *);
822extern void qreply(queue_t *, mblk_t *);
823extern void qenable(queue_t *);
824extern int qsize(queue_t *);
825extern void noenable(queue_t *);
826extern void enableok(queue_t *);
827extern int strqset(queue_t *, qfields_t, unsigned char, intptr_t);
828extern int strqget(queue_t *, qfields_t, unsigned char, void *);
829extern void unbufcall(bufcall_id_t);
830extern void qprocson(queue_t *);
831extern void qprocsoff(queue_t *);
832extern void freezestr(queue_t *);
833extern void unfreezestr(queue_t *);
834extern void qwait(queue_t *);
835extern int qwait_sig(queue_t *);
836extern boolean_t qwait_rw(queue_t *);
837extern void qwriter(queue_t *, mblk_t *, void (*func)(), int);
838extern timeout_id_t qtimeout(queue_t *, void (*func)(void *), void *, clock_t);
839extern bufcall_id_t qbufcall(queue_t *, size_t, uint_t,
840    void (*)(void *), void *);
841extern clock_t quntimeout(queue_t *, timeout_id_t);
842extern void qunbufcall(queue_t *, bufcall_id_t);
843extern void strwakeq(queue_t *, int);
844extern int struioget(queue_t *, mblk_t *, struiod_t *, int);
845extern int rwnext(queue_t *, struiod_t *);
846extern int infonext(queue_t *, infod_t *);
847extern int isuioq(queue_t *);
848extern void create_putlocks(queue_t *, int);
849extern int mp_cont_len(mblk_t *, int *);
850
851/*
852 * shared or externally configured data structures
853 */
854extern int nstrpush;			/* maximum number of pushes allowed */
855
856#endif /* _KERNEL */
857
858#ifdef	__cplusplus
859}
860#endif
861
862#endif	/* _SYS_STREAM_H */
863