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