![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stream.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / usr / include / sys|
Return to stream.h CVS log | Up to [MW Coherent from dump] / coherent / f / usr / include / sys |
1.1 root 1: #ifndef __SYS_STREAM_H__
2: #define __SYS_STREAM_H__
3:
4: /*
5: * This ^^^^^^^^^^^^^^^^ symbol is used in the DDI/DKI header <sys/ddi.h> to
6: * determine which #undef directives it is required to perform, on the basis
7: * that it should avoid touching namespaces unless they have been reserved
8: * by the inclusion of a header which reserves such classes of names.
9: */
10:
11: /*
12: *-IMPORTS:
13: * <common/ccompat.h>
14: * __PROTO ()
15: * __EXTERN_C_BEGIN__
16: * __EXTERN_C_END__
17: * __VOID__
18: * <common/_cred.h>
19: * cred_t
20: * <kernel/_toid.h>
21: * toid_t
22: * <kernel/x86lock.h>
23: * atomic_uchar_t
24: * <sys/types.h>
25: * caddr_t
26: */
27:
28: #include <common/ccompat.h>
29: #include <common/_cred.h>
30: #include <kernel/_toid.h>
31: #include <kernel/x86lock.h>
32: #include <sys/types.h>
33:
34: #include <common/_stream.h>
35:
36: /*
37: * Public section of the <sys/stream.h> file, for consumption by user
38: * application code using access to the STREAMS messaging system, and
39: * by STREAMS drivers.
40: *
41: * The information in this header is directly related to the information
42: * published in the System V, Release 4 STREAMS Programmer's Guide,
43: * Appendices A and B.
44: */
45:
46:
47: /*
48: * Message types. The particular values here may have some significance
49: * to some macros defined later, particularly datamsg ().
50: */
51:
52: #define M_PRI 0x80
53: #define QPCTL M_PRI
54:
55: /* regular messages */
56:
57: #define M_DATA 0
58: #define M_PROTO 1
59: #define M_DELAY 2
60:
61: #define M_IOCTL 3
62: #define M_SETOPTS 4
63: #define M_SIG 5
64: #define M_CTL 6
65: #define M_BREAK 7
66: #define M_PASSFP 8
67: #define M_RSE 9
68:
69: /* priority messages */
70:
71: #define M_PCPROTO (1 + M_PRI)
72: #define M_IOCACK (3 + M_PRI)
73: #define M_IOCNAK (4 + M_PRI)
74: #define M_PCSIG (5 + M_PRI)
75: #define M_ERROR (6 + M_PRI)
76: #define M_FLUSH (7 + M_PRI)
77: #define M_HANGUP (8 + M_PRI)
78: #define M_START (9 + M_PRI)
79: #define M_STOP (10 + M_PRI)
80: #define M_COPYIN (11 + M_PRI)
81: #define M_COPYOUT (12 + M_PRI)
82: #define M_IOCDATA (13 + M_PRI)
83: #define M_PCRSE (14 + M_PRI)
84: #define M_READ (15 + M_PRI)
85: #define M_STARTI (16 + M_PRI)
86: #define M_STOPI (17 + M_PRI)
87:
88:
89: struct streamtab {
90: struct qinit * st_rdinit; /* defines read QUEUE */
91: struct qinit * st_wrinit; /* defines write QUEUE */
92: struct qinit * st_muxrinit; /* for multiplexing drivers only */
93: struct qinit * st_muxwinit; /* for multiplexing drivers only */
94: };
95:
96:
97: /*
98: * Private type definitions.
99: */
100:
101: typedef atomic_uchar_t __str_lock_t;
102:
103:
104: /*
105: * QUEUE structures - these structures are used to build streams.
106: *
107: * Note that "queue_t" structures occur in pairs, first the write queue, then
108: * the read queue. The QREADR flag distinguishes them for the RD (q), WR (q)
109: * and OTHERQ (q) macros.
110: *
111: * The System V DDI/DKI adds multiprocessor support to STREAMS via the notion
112: * of "freezing" a stream, something mostly analagous to a basic lock. We can
113: * implement this facility either in terms of the primitive machine-specific
114: * atomic operations, or in terms of the DDI/DKI high-level lock operations.
115: *
116: * For now, we choose the latter.
117: */
118:
119: struct queue {
120: struct qinit * q_qinfo; /* procedures and limits for queue */
121: mblk_t * q_first; /* head of message queue for QUEUE */
122: mblk_t * q_last; /* tail of message queue for QUEUE */
123: queue_t * q_next; /* next QUEUE in stream */
124: queue_t * q_link; /* next on STEAMS scheduling list */
125: __VOID__ * q_ptr; /* to private data structure */
126: unsigned long q_count; /* number of characters in queue */
127: unsigned long q_flag; /* QUEUE state */
128: long q_minpsz; /* minimum packet size accepted */
129: long q_maxpsz; /* maximum packet size accepted */
130: unsigned long q_hiwat; /* message queue high water mark */
131: unsigned long q_lowat; /* message queue low water mark */
132: qband_t * q_bandp; /* separate flow information */
133: unsigned char q_nband; /* number of priority bands */
134: unsigned char q_pad1 [3]; /* reserved for future use */
135: long q_pad2 [2]; /* reserved for future use */
136:
137: /*
138: * Data from this point are MWC extensions for multiprocessing. The
139: * DDI/DKI revokes user's right to know about the size of the
140: * structure, among other things.
141: */
142:
143: unsigned char q_active; /* count of active put/srv routines */
144: unsigned char q_lastband; /* band of last retrieved message */
145: __str_lock_t q_locked; /* hack implementation of freezing */
146: };
147:
148: /*
149: * Hack around the union above. This field should only be referred to by some
150: * layering macros in <sys/strmlib.h> anyway, but we try and keep it clean.
151: */
152:
153: #define q_lock x.q_lock
154:
155:
156: /*
157: * Queue flag definitions : these are internal to the system, and the values
158: * bear no relation to any definitions in System V. Drivers use these flags at
159: * their own risk...
160: */
161:
162: #define QENAB 0x0001 /* queue is on qenable () schedule */
163: #define QWANTR 0x0002 /* someone wants to read from the queue */
164: #define QWANTW 0x0004 /* someone wants to write to the queue */
165: #define QFULL 0x0008 /* queue is full */
166: #define QREADR 0x0010 /* set for read queues */
167: #define QNOENB 0x0020 /* prevent queue from being enabled */
168: #define QBACK 0x0040 /* queue has been back-enabled */
169: #define QOLD 0x0080 /* pre-SVR4 open/close interface */
170: #define QPROCSOFF 0x0100 /* put/service routines disabled */
171: #define QDRAIN 0x0200 /* waiting for queue to drain */
172: #define QSRVACTIVE 0x0400 /* service routine is active */
173:
174: /* #define QUSE ????? queue has been allocated */
175: /* #define QHLIST ????? SVR4, not used by this implementation */
176:
177:
178: /*
179: * queue priority-band information.
180: */
181:
182: struct qband {
183: struct qband * qb_next; /* next band's info */
184: unsigned long qb_count; /* count of bytes in band */
185: struct msgb * qb_first; /* beginning of band's data */
186: struct msgb * qb_last; /* end of band's data */
187: unsigned long qb_hiwat; /* high water mark for band */
188: unsigned long qb_lowat; /* low water mark for band */
189: unsigned long qb_flag; /* flags, see below */
190: unsigned long qb_pad1; /* reserved for future use */
191: };
192:
193:
194:
195: /* Flags used in band structure */
196:
197: #define QB_FULL 0x0001 /* band is considered full */
198: #define QB_WANTW 0x0002 /* someone wants to write to band */
199: #define QB_BACK 0x0004 /* queue has been back-enabled */
200:
201: /* non-SVR4 flag */
202: #define QB_FIRST 0x0100 /* first entry in allocation unit */
203:
204:
205: /*
206: * Message structures - the format of STREAMS messages and message data
207: * blocks.
208: */
209:
210: struct msgb {
211: struct msgb * b_next; /* next message on queue */
212: struct msgb * b_prev; /* previous message on queue */
213: struct msgb * b_cont; /* next message block of message */
214: unsigned char * b_rptr; /* first unread data byte in buffer */
215: unsigned char * b_wptr; /* first unwritten data byte in buffer */
216: struct datab * b_datap; /* data block */
217:
218: unsigned char b_band; /* message priority */
219: unsigned char b_pad1;
220: unsigned short b_flag; /* message flags */
221: long b_pad2;
222: };
223:
224:
225: /* Flag definitions for message blocks */
226:
227: #define MSGMARK 0x0001 /* last byte of message is "marked" */
228: #define MSGNOLOOP 0x0002 /* don't loop message to write-side of stream */
229: #define MSGDELIM 0x0004 /* message is delimited */
230:
231: /* Extra flag definitions, for STREAMS private use only */
232:
233: #define MSGTRIPLE 0x0100 /* message block is part of triple */
234: #define MSGFREE 0x0200 /* message block is free */
235:
236: #define MSGMASK_SYSTEM 0x0300 /* system-private flags */
237:
238:
239: /*
240: * Data structure used to control freeing of user-defined STREAMS buffer
241: * memory (such as user memory that is temporarily mapped to kernel space
242: * to avoid copying, or driver-dependent shared memory from an I/O space).
243: */
244:
245: struct free_rtn {
246: void (* free_func) /* driver-dependent free routine */
247: __PROTO ((__VOID__ * _arg));
248: __VOID__ * free_arg; /* argument for free_rtn */
249: };
250:
251: typedef struct free_rtn frtn_t;
252:
253:
254: /*
255: * Data block descriptors - several mblk_t's may refer to the same section
256: * of STREAMS buffer memory to avoid copying.
257: *
258: * Note that this data structure is NOT identical to it's System V
259: * counterpart.
260: */
261:
262: struct datab {
263: frtn_t * db_frtnp; /* internal use */
264: unsigned char * db_base; /* first byte of buffer */
265: unsigned char * db_lim; /* last+1 byte of buffer */
266: unsigned char db_ref; /* count of messages pointing here */
267: unsigned char db_type; /* message type */
268: short db_pad1; /* reserved for future use */
269: long db_pad2; /* reserved for future use */
270: };
271:
272:
273: /*
274: * Define one of these structures with external visibility to publish the
275: * entry points to your STREAMS driver.
276: */
277:
278: typedef void (* __putp_t) /* put procedure */
279: __PROTO ((queue_t * _q, mblk_t * _mp));
280: typedef void (* __srvp_t) /* service procedure */
281: __PROTO ((queue_t * _q));
282: typedef int (* __qopen_t) /* open procedure */
283: __PROTO ((queue_t * _q, n_dev_t * _devp, int _flag,
284: int _sflag, cred_t * _credp));
285: typedef int (* __qclose_t) /* called on last close/pop */
286: __PROTO ((queue_t * _q, int _flag, cred_t * _credp));
287: typedef int (* __qadmin_t) /* reserved for future use */
288: __PROTO ((void));
289:
290: struct qinit {
291: __putp_t qi_putp; /* put procedure */
292: __srvp_t qi_srvp; /* service procedure */
293: __qopen_t qi_qopen; /* called on each open */
294: __qclose_t qi_qclose; /* called on last close/pop */
295: __qadmin_t qu_qadmin; /* reserved for future use */
296: struct module_info
297: * qi_minfo; /* information structure */
298: struct module_stat
299: * qi_mstat; /* statistics - optional */
300: };
301:
302:
303: /*
304: * General STREAMS "module information", mainly used by SysV configuration
305: * utilities, although it also provides defaults for the queues at open time.
306: */
307:
308: struct module_info {
309: unsigned short mi_idnum; /* module ID number */
310: char * mi_idname; /* module name */
311: long mi_minpsz; /* min packet size accepted */
312: long mi_maxpsz; /* max packet size accepted */
313: unsigned long mi_hiwat; /* hi-water mark, for flow control */
314: unsigned long mi_lowat; /* lo-water mark, for flow control */
315: };
316:
317:
318: /* Infinite message size, for use in module_info mi_minpsz/mi_maxpsz */
319:
320: #define INFPSZ 0x7FFFFFFF
321:
322:
323: /*
324: * General statistics structure, useful for profiling module/driver
325: * activity.
326: */
327:
328: struct module_stat {
329: long ms_pcnt; /* count of calls to put proc */
330: long ms_scnt; /* count of calls to service proc */
331: long ms_ocnt; /* count of calls to open proc */
332: long ms_ccnt; /* count of calls to close proc */
333: long ms_acnt; /* count of calls to admin proc */
334: char * ms_xptr; /* pointer to private statistics */
335: short ms_xsize; /* length of private stats buffer */
336: };
337:
338:
339: /*
340: * link block for multiplexed streams... this structure appears in the data
341: * portion of I_LINK and I_UNLINK M_IOCTL messages.
342: *
343: * Note that the STREAMS manual documents the type of "l_index" as an "int",
344: * but for our purposes an "n_dev_t" (which is a long) is more appropriate.
345: */
346:
347: typedef n_dev_t __muxid_t;
348:
349: struct linkblk {
350: queue_t * l_qtop; /* lowest write queue of upper stream */
351: queue_t * l_qbot; /* highest write queue of lower stream */
352: __muxid_t l_index; /* unique index for lower stream */
353: long l_pad [5]; /* reserved for future use */
354: };
355:
356:
357: /*
358: * Stream head options control message format, used as the data part of an
359: * M_SETOPTS message set from a driver or module to the stream head. The
360: * values for the "so_readopt" member can be found in <stropts.h> as well
361: * as below.
362: */
363:
364: struct stroptions {
365: unsigned long so_flags; /* options to set */
366: short so_readopt; /* read option */
367: unsigned short so_wroff; /* write offset */
368: long so_minpsz; /* min packet size */
369: long so_maxpsz; /* max packet size */
370: unsigned long so_hiwat; /* read queue high-water mark */
371: unsigned long so_lowat; /* read queue low-water mark */
372: unsigned char so_band; /* band for water marks */
373: };
374:
375:
376: /*
377: * Flag values for the "so_flags" member,
378: */
379:
380: #define SO_ALL 0x3F /* set all options */
381: #define SO_READOPT 0x0001 /* set read option */
382: #define SO_WROFF 0x0002 /* set write offset */
383: #define SO_MINPSZ 0x0004 /* set min packet size */
384: #define SO_MAXPSZ 0x0008 /* set max packet size */
385: #define SO_HIWAT 0x0010 /* set read queue high-water mark */
386: #define SO_LOWAT 0x0020 /* set read queue low-water mark */
387:
388: /* Flags above control which members to look at, below are R4 extensions */
389:
390: #define SO_MREADON 0x0040 /* set read notification on */
391: #define SO_MREADOFF 0x0080 /* set read notification off */
392: #define SO_NDELON 0x0100 /* old TTY semantics for NDELAY */
393: #define SO_NDELOFF 0x0200 /* STREAMS semantics for NDELAY */
394: #define SO_ISTTY 0x0400 /* stream is acting as a terminal */
395: #define SO_ISNTTY 0x0800 /* stream is not acting as a terminal */
396: #define SO_TOSTOP 0x1000 /* stop on background writes to stream */
397: #define SO_TONSTOP 0x2000 /* don't stop on background writes */
398: #define SO_BAND 0x4000 /* water marks that affect band */
399:
400: /*
401: * Other flags relevant to the above structure are defined in <sys/stropts.h>.
402: */
403:
404:
405: /*
406: * Structure of data block found at head of M_IOCTL message, usually reused
407: * for replying to M_IOCTL with an M_IOCACK or M_IOCNAK message.
408: */
409:
410: struct iocblk {
411: int ioc_cmd; /* ioctl () command type */
412: cred_t * ioc_cr; /* user's full credentials */
413: unsigned int ioc_id; /* M_IOCTL sequence number */
414: unsigned int ioc_count; /* bytes in data field */
415: int ioc_error; /* error code */
416: int ioc_rval; /* return value */
417:
418: long ioc_filler [4]; /* reserved for future use */
419: };
420:
421:
422: /*
423: * For compatibility with SVR3 sources
424: */
425:
426: #define ioc_uid ioc_cr->cr_uid
427: #define ioc_gid ioc_cr->cr_gid
428:
429:
430: /*
431: * This special value of "ioc_count" is used to indicate that the stream
432: * head has passed us a "transparent" ioctl rather than an I_STR ioctl.
433: */
434:
435: #define TRANSPARENT ((unsigned int) -1)
436:
437:
438: /*
439: * This structure defines the data format used in an M_COPYIN/M_COPYOUT
440: * message (used to request data copying from user process space during
441: * an ioctl ()). Note that the first three members of the "copyreq" structure
442: * match the first three fields of the "iocblk" structure. It is intended
443: * that drivers be able to use this property to simply use the intial message
444: * block from M_IOCTL for all the transparent IOCTL messages.
445: */
446:
447: struct copyreq {
448: int cq_cmd; /* ioctl command (from ioc_cmd) */
449: cred_t * cq_cr; /* full credentials (from ioc_cr) */
450: unsigned int cq_id; /* ioctl id (from ioc_id) */
451: caddr_t cq_addr; /* user address to copy data to/from */
452: unsigned int cq_size; /* number of bytes to copy */
453: int cq_flag; /* flags, see below */
454: mblk_t * cq_private; /* private state information */
455: long cq_filler [4]; /* reserved for future use */
456: };
457:
458: /* For compatibility with old sources. */
459:
460: #define cq_uid cq_cr->cr_uid
461: #define cq_gid cq_cr->cr_gid
462:
463: /* cq_flag values */
464:
465: #define STRCANON 0x0001 /* b_cont data block contains canonical format specifier */
466: #define RECOPY 0x0002 /* perform I_STR copyin again using canonical format specifier */
467:
468:
469: /*
470: * This structure is used in the M_IOCDATA response to an M_COPYIN/M_COPYOUT,
471: * and is laid out so that equivalent fields from the "struct copyreq"
472: * structure remain at the same offset, ie we expect the stream head to
473: * simply turn around our request, although it is not required to do so.
474: */
475:
476: struct copyresp {
477: int cp_cmd; /* ioctl command (from cq_cmd) */
478: cred_t * cp_cr; /* full credentials (from cq_cr) */
479: unsigned int cp_id; /* ioctl id (from cq_id) */
480: caddr_t cp_rval; /* request status: 0 success, non-zero failure */
481: unsigned int cp_pad1; /* reserved */
482: unsigned int cp_pad2; /* reserved */
483: mblk_t * cp_private; /* private state information */
484: long cp_filler [4]; /* reserved for future use */
485: };
486:
487: /* for compatibility with old sources */
488:
489: #define cp_uid cp_cr->cr_uid
490: #define cp_gid cp_cr->cr_gid
491:
492:
493: /*
494: * LOCAL EXTENSIONS : The methods used in the multiplexing examples in the
495: * STREAMS V.2 manual are slightly inefficient. The following general STREAMS
496: * queue schedling routines were defined for multiplexing drivers and device
497: * drivers (such as Ethernet drivers) that must consume data from several
498: * queues.
499: *
500: * In the STREAMS code supplied, these routines are also used for the main
501: * streams queue scheduling, so we define them here. A consequence of this is
502: * that a given queue may not be queued for both STREAMS execution and
503: * multiplexing at the same time.
504: *
505: * The basic idea is to use qschedule () and qunschedule () to add and remove
506: * a queue from the scheduling list. Lower queues may then getq () from the
507: * "s_head" of the scheduling list to consume the data. Since by default this
508: * will simply attempt to drain each scheduled queue of data before moving to
509: * the next, the muxrobin () call adjusts the head/tail pointers to effect
510: * a round-robin of the queues that have data.
511: */
512:
513: struct strsched {
514: queue_t * s_head; /* next queue to read data from */
515: queue_t * s_tail; /* last queue to read data from */
516: };
517:
518:
519: /*
520: * Message allocation priorities, used with allocb () and bufcall ()
521: */
522:
523: enum {
524: BPRI_LO,
525: BPRI_MED,
526: BPRI_HI
527: };
528:
529:
530: /*
531: * Flag values used with flushq () and flushband ().
532: */
533:
534: enum {
535: FLUSHDATA, /* flush M_DATA, M_PROTO, M_PCPROTO, M_DELAY */
536: FLUSHALL /* flush all messages from queue */
537: };
538:
539:
540: /*
541: * queue field numbers to be used with strqget ()/strqset ().
542: */
543:
544: typedef enum qfields {
545: QHIWAT = 0, /* q_hiwat or qb_hiwat */
546: QLOWAT = 1, /* q_lowat or qb_lowat */
547: QMAXPSZ = 2, /* q_maxpsz */
548: QMINPSZ = 3, /* q_minpsz */
549: QCOUNT = 4, /* q_count or qb_count */
550: QFIRST = 5, /* q_first or qb_first */
551: QLAST = 6, /* q_last or qb_last */
552: QFLAG = 7, /* q_flag or qb_flag */
553: QBAD = 8
554: } qfields_t;
555:
556:
557: /*
558: * External function definitions for the STREAMS library.
559: *
560: * Note that prototypes are also provided for those STREAMS functions that
561: * are available as macros. This is since this header is a more appropriate
562: * place to encode this knowledge than the DDI/DKI required header
563: * <sys/ddi.h>
564: *
565: * The System V Release 4 Multi-Processor DDI/DKI defines some extra versions
566: * of some common STREAMS library functions so that STREAMS driver code does
567: * not reference the q->q_next member, since this may not be safe in a multi-
568: * processor environment. These functions are included in this implementation
569: * and are prototyped below to help device drivers anticipate the multi-
570: * processor environment.
571: */
572:
573: __EXTERN_C_BEGIN__
574:
575: int adjmsg __PROTO ((mblk_t * _mp, int _len));
576: mblk_t * allocb __PROTO ((int _size, unsigned int _pri));
577: queue_t * backq __PROTO ((queue_t * _q));
578: int bcanput __PROTO ((queue_t * _q, unsigned char _pri));
579: int bcanputnext __PROTO ((queue_t * _q, unsigned char _pri));
580: /* see <sys/bufcall.h> for a discussion of this declaration for bufcall () */
581: #define __STDARG_BUFCALL__
582: toid_t bufcall __PROTO ((unsigned int _size, int _pri, ...));
583: int canput __PROTO ((queue_t * _q));
584: int canputnext __PROTO ((queue_t * _q));
585: mblk_t * copyb __PROTO ((mblk_t * _bp));
586: mblk_t * copymsg __PROTO ((mblk_t * _mp));
587: int datamsg __PROTO ((unsigned char _type));
588: mblk_t * dupb __PROTO ((mblk_t * _bp));
589: mblk_t * dupmsg __PROTO ((mblk_t * _mp));
590: void enableok __PROTO ((queue_t * _q));
591: mblk_t * esballoc __PROTO ((unsigned char * _base, int _size,
592: int _pri, frtn_t * _fr_rtn));
593: /* The following assumes __STDARG_BUFCALL__ as above */
594: toid_t esbbcall __PROTO ((int _pri, ...));
595: void flushband __PROTO ((queue_t * _q, unsigned char _pri,
596: int _flag));
597: void flushq __PROTO ((queue_t * _q, int _flag));
598: pl_t freezestr __PROTO ((queue_t * _q));
599: void freeb __PROTO ((mblk_t * _bp));
600: void freemsg __PROTO ((mblk_t * _mp));
601: int (* getadmin __PROTO ((unsigned short _mid)))
602: __PROTO ((void));
603: unsigned short getmid __PROTO ((char * _name));
604: mblk_t * getq __PROTO ((queue_t * _q));
605: int insq __PROTO ((queue_t * _q, mblk_t * _emp,
606: mblk_t * _nmp));
607: void linkb __PROTO ((mblk_t * _mp, mblk_t * _bp));
608: int msgdsize __PROTO ((mblk_t * _mp));
609: mblk_t * msgpullup __PROTO ((mblk_t * _mp, int _len));
610: void noenable __PROTO ((queue_t * _q));
611: queue_t * OTHERQ __PROTO ((queue_t * _q));
612: int pcmsg __PROTO ((uchar_t _type));
613: int pullupmsg __PROTO ((mblk_t * _mp, int _len));
614: void put __PROTO ((queue_t * _q, mblk_t * _mp));
615: int putbq __PROTO ((queue_t * _q, mblk_t * _mp));
616: int putctl __PROTO ((queue_t * _q, int _type));
617: int putctl1 __PROTO ((queue_t * _q, int _type,
618: int _param));
619: int putnext __PROTO ((queue_t * _q, mblk_t * _mp));
620: int putnextctl __PROTO ((queue_t * _q, int _type));
621: int putnextctl1 __PROTO ((queue_t * _q, int _type,
622: int _param));
623: int putq __PROTO ((queue_t * _q, mblk_t * _mp));
624: void qenable __PROTO ((queue_t * _q));
625: void qprocsoff __PROTO ((queue_t * _rq));
626: void qprocson __PROTO ((queue_t * _rq));
627: void qreply __PROTO ((queue_t * _q, mblk_t * _mp));
628: int qsize __PROTO ((queue_t * _q));
629: queue_t * RD __PROTO ((queue_t * _q));
630: mblk_t * rmvb __PROTO ((mblk_t * _mp, mblk_t * _bp));
631: void rmvq __PROTO ((queue_t * _q, mblk_t * _mp));
632: int strlog __PROTO ((short _mid, short _sid, char _level,
633: unsigned short _flags, char * _fmt,
634: ...));
635: int strqget __PROTO ((queue_t * _q, qfields_t _what,
636: unsigned char _pri, long * _valp));
637: int strqset __PROTO ((queue_t * _q, qfields_t _what,
638: unsigned char _pri, long _val));
639: int testb __PROTO ((int _size, int _pri));
640: void unbufcall __PROTO ((toid_t _id));
641: void unfreezestr __PROTO ((queue_t * _q, pl_t _pl));
642: mblk_t * unlinkb __PROTO ((mblk_t * _mp));
643: queue_t * WR __PROTO ((queue_t * _q));
644:
645: __EXTERN_C_END__
646:
647:
648: /*
649: * Possible values for the stream open flag "sflag" in a module or driver
650: * open (0 implies a normal driver open)
651: */
652:
653: enum {
654: MODOPEN = 1, /* normal module open */
655: CLONEOPEN /* clone device open */
656: };
657:
658:
659: /*
660: * Special value for the two-byte form of the M_ERROR message.
661: */
662:
663: enum {
664: NOERROR = 0xFF
665: };
666:
667:
668: /*
669: * Functions that are normally implemented as macros (although the function
670: * versions which are prototyped above are available by including the
671: * <sys/ddi.h> header.
672: */
673: /*
674: * NB: Borland C++ 3.1 in 'C' mode insists that if a pointer is derived from
675: * a ternary where the arms are calculated from lvalues then dereferencing
676: * that pointer does not yield a valid lvalue, e.g.
677: * WR (q)->q_ptr = NULL;
678: * it thinks is invalid, which is untrue. To fix this, the pointer value from
679: * the ternary seems to need massaging to turn it into a proper rvalue... the
680: * easiest way to do this is add 0 to the *result* of the ternary. This is
681: * optimized away by basic constant-folding in even simple compilers.
682: */
683:
684: #define __HACK(exp) ((exp) + 0)
685:
686: #define datamsg(type) ((unsigned char) ((type) & (M_PRI - 1)) <= M_DELAY)
687: /* There is no multiprocessor macro implementation of enableok () */
688: /* There is no multiprocessor macro implementation of noenable () */
689: #define OTHERQ(q) __HACK (((q)->q_flag & QREADR) != 0 ? (q) + 1 : (q) - 1)
690: #define pcmsg(type) ((type) >= QPCTL)
691: #define RD(q) __HACK (((q)->q_flag & QREADR) != 0 ? (q) : (q) - 1)
692: #define WR(q) __HACK (((q)->q_flag & QREADR) != 0 ? (q) + 1 : (q))
693:
694: #endif /* ! defined (__SYS_STREAM_H__) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.