![[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 [WindowsNT SDKs] / ntddk / src / network / streams / inc / sys|
Return to stream.h CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / streams / inc / sys |
1.1 root 1: /*++
2:
3: Copyright (c) 1991 Microsoft Corporation
4:
5: Module Name:
6:
7: stream.h
8:
9: Abstract:
10:
11: This module declares the data types and functions available to
12: STREAMS drivers and modules.
13:
14: Author:
15:
16: Eric Chin (ericc) August 9, 1991
17:
18: Revision History:
19:
20: Who When What
21: -------- -------- -----------------------------------------------------
22: sampa 09-19-91 pulled kernel level stuff from stream.h
23: mikemas 01-18-92 removed redefinition of STREAMS functions and
24: reorganized file.
25: mikemas 01-20-92 integrated private\inc\stream.h into this file.
26: moved to streams\inc\stream.h from ntstream.h
27:
28: --*/
29:
30: /******************************************************************
31: *
32: * SpiderSTREAMS - STREAMS Package
33: *
34: * Copyright 1987 Spider Systems Limited
35: *
36: * STREAM.H
37: *
38: * Main STREAMS definitions
39: *
40: ******************************************************************/
41:
42: /*
43: * /usr/projects/spare/PBRAIN/SCCS/pbrainG/dev/stremul/include/sys/114/s.stream.h
44: * @(#)stream.h 1.36
45: *
46: * Last delta created 12:37:24 12/4/91
47: * This file extracted 16:45:56 12/23/91
48: *
49: * Modifications:
50: *
51: */
52:
53:
54: #ifndef _SYS_STREAM_INCLUDED
55: #define _SYS_STREAM_INCLUDED
56:
57:
58:
59: /********************************************************/
60: /* Streams message and queue types */
61: /********************************************************/
62:
63: /*
64: * Message block descriptor
65: */
66: struct msgb {
67: struct msgb *b_next; /* next message on queue */
68: struct msgb *b_prev; /* previous message on queue */
69: struct msgb *b_cont; /* next message block of message */
70: unsigned char *b_rptr; /* first unread data byte in buffer */
71: unsigned char *b_wptr; /* first unwritten data byte in buffer */
72: struct datab *b_datap; /* data block */
73: unsigned char b_rsvd; /* in SVR4, this is b_band */
74: unsigned char b_pad1;
75: unsigned short b_flag; /* message flag field */
76: long b_pad2;
77: };
78:
79:
80: /*
81: * Message flags. These are interpreted by the Stream Head.
82: */
83: #define MSGMARK 0x01 /* marked block - for I_ATMARK */
84: #define MSGNLOOP 0x02 /* don't loop message to write queue */
85: #define MSGDELIM 0x04 /* message is delimited */
86:
87:
88: /*
89: * structure containing function to call and argument when freeing
90: * an extended buffer
91: */
92: struct free_rtn {
93: void (*free_func)(char *); /* free routine of user */
94: char *free_arg; /* argument to free routine */
95: };
96:
97:
98: /*
99: * Data block descriptor
100: *
101: */
102: struct datab {
103: struct datab *db_freep; /* used internally */
104: unsigned char *db_base; /* first byte of buffer */
105: unsigned char *db_lim; /* last byte + 1 of buffer */
106: unsigned long db_ref; /* count of msgs pointing to block */
107: unsigned char db_type; /* message type */
108: unsigned char db_class; /* used internally. In SVR4, is db_iswhat */
109: KSPIN_LOCK db_lock; /* protects db_ref */
110:
111: /* unused SVR4 fields, for future expansion */
112: unsigned int db_rsvd1; /* db_size */
113: char *db_rsvd2; /* db_msgaddr */
114: long db_filler; /* reserved for future use */
115:
116: /* unique to SpiderSTREAMS */
117: struct free_rtn db_discard; /* call routine & arg to free buffer */
118: };
119:
120:
121: struct queue; // define queue name so the MIPS compiler will recognize it
122: // in the following definition as being the same as the
123: // queue structure definition that will follow later.
124:
125:
126: /*
127: * Queue Information Structure
128: *
129: */
130: struct qinit { /* declares a queue */
131: int (*qi_putp)( /* put procedure */
132: struct queue *q,
133: struct msgb *mp
134: );
135: int (*qi_srvp)( /* service procedure */
136: struct queue *
137: );
138: int (*qi_qopen)( /* open procedure */
139: struct queue *,
140: dev_t *,
141: int,
142: int,
143: void *
144: );
145: int (*qi_qclose)( /* close procedure */
146: struct queue *,
147: int,
148: void *
149: );
150: int (*qi_qadmin)(); /* unused */
151: struct module_info *qi_minfo; /* module information */
152: struct module_stat *qi_mstat; /* module statistics */
153: int qi_mplevel; /* level of parallelism */
154: };
155:
156:
157: #define FULL_PARALLEL -1 /* fully parallelised */
158: #define STREAM_PARALLEL -2 /* streams parallel: NOT SUPPORTED */
159:
160:
161: /*
162: * Module information structure
163: */
164: struct module_info {
165: unsigned short mi_idnum; /* module id number */
166: char *mi_idname; /* module name */
167: long mi_minpsz; /* min packet size accepted */
168: long mi_maxpsz; /* max packet size accepted */
169: unsigned long mi_hiwat; /* hi-water mark */
170: unsigned long mi_lowat; /* lo-water mark */
171: };
172:
173:
174: /*
175: * Module statistics structure (not used in current implementation)
176: */
177: struct module_stat {
178: long ms_pcnt; /* count of calls to put proc */
179: long ms_scnt; /* count of calls to service proc */
180: long ms_ocnt; /* count of calls to open proc */
181: long ms_ccnt; /* count of calls to close proc */
182: long ms_acnt; /* count of calls to admin proc */
183: char *ms_xptr; /* pointer to private statistics */
184: short ms_xsize; /* length of private statistics buffer */
185: };
186:
187:
188: /*
189: * Streamtab (used in cdevsw and fmodsw to point to module or driver)
190: */
191: struct streamtab {
192: struct qinit *st_rdinit; /* defines read QUEUE */
193: struct qinit *st_wrinit; /* defines write QUEUE */
194: struct qinit *st_muxrinit; /* for multiplexing drivers only */
195: struct qinit *st_muxwinit; /* for multiplexing drivers only */
196: };
197:
198:
199: struct mpctl; /* for ANSI c */
200:
201:
202: /*
203: * data queue
204: */
205: struct queue { /* internal representation */
206: struct queue *q_next; /* next in stream */
207: struct qinit *q_qinfo; /* queue procedures, limits */
208: struct msgb *q_first; /* first data block */
209: struct msgb *q_last; /* last data block */
210: struct queue *q_link; /* next queue for scheduling */
211: char *q_ptr; /* private data */
212: unsigned long q_count; /* bytes of data on queue */
213: unsigned long q_flag; /* queue state */
214: long q_minpsz; /* min packet size accepted */
215: long q_maxpsz; /* max packet size accepted */
216: unsigned long q_hiwat; /* queue high water mark */
217: unsigned long q_lowat; /* queue low water mark */
218:
219: /* unique to SpiderSTREAMS */
220: struct queue *q_other; /* other queue of pair */
221: struct queue *q_can; /* queue canput() looks at */
222: struct queue *q_back; /* queue to back-enable */
223: struct mpctl *q_mpctl; /* multiprocessor queue info */
224: int q_active; /* # srv/put procs running */
225: KEVENT q_disableproc; /* for disable_procs() */
226: char *q_strmptr; /* at stream head only */
227:
228: /* unused SVR4 fields */
229: void *q_rsvd1; /* q_bandp */
230: unsigned char q_rsvd2; /* q_nband */
231: unsigned char q_pad1[3]; /* reserved for future use */
232: long q_pad2[2]; /* reserved for future use */
233: };
234:
235:
236: /*
237: * Typedefs for important structures
238: */
239: typedef struct msgb mblk_t;
240: typedef struct datab dblk_t;
241: typedef struct free_rtn frtn_t;
242: typedef struct queue queue_t;
243:
244:
245: /*
246: * Priority definitions for block allocation.
247: */
248: #define NPRI 3 /* Number of priority values */
249:
250: #define BPRI_LO 0
251: #define BPRI_MED 1
252: #define BPRI_HI 2
253:
254:
255: /*
256: * Queue flags
257: */
258: #define QSTATE 0x000F /* Queue state mask (see below for values) */
259: #define QREADR 0x0010 /* This is the reader (first) Q */
260: #define QSERV 0x0020 /* This queue has a service proc */
261: #define QEND 0x0040 /* This queue is this stream side end */
262: #define QENABL 0x0100 /* Queue is already enabled to run */
263: #define QNOENB 0x0200 /* Don't enable Q via putq */
264: #define QUSE 0x0400 /* Queue is used */
265: #define QDISABL 0x0800 /* Disable procs can be called */
266:
267: /*
268: * Queue state values (in LS 4 bits of flags)
269: */
270: #define QPRIMED 0x0000 /* Queue was read when empty */
271: #define QEMPTY 0x0001 /* Queue empty but not primed */
272: #define QACTIVE 0x0002 /* Queue not empty and not blocked */
273: #define QBLOCKED 0x0003 /* Queue blocked (canput failed) */
274: #define QFULL QBLOCKED /* Just so it's defined */
275:
276: /*
277: * Finding related queues
278: */
279: #define OTHERQ(Q) ((Q)->q_other)
280: #define WR(Q) ((Q)->q_other)
281: #define RD(Q) ((Q)->q_other)
282:
283:
284: /*
285: * IOCTL structure - this structure is the format of the M_IOCTL message type.
286: *
287: */
288: struct iocblk {
289: int ioc_cmd; /* ioctl command type */
290: unsigned short ioc_uid; /* effective uid of user { *ioc_cr } */
291: unsigned short ioc_gid; /* effective gid of user { in SVR4 } */
292: unsigned int ioc_id; /* ioctl id */
293: unsigned int ioc_count; /* count of bytes in data field */
294: int ioc_error; /* error code */
295: int ioc_rval; /* return value */
296: };
297: /* unprovided SVR4 fields */
298: /* ioc_filler[4] */
299:
300:
301: /*
302: * Link structure for I_LINK and I_UNLINK ioctl's
303: *
304: */
305: struct linkblk {
306: queue_t *l_qtop; /* lowest level write queue of upper stream */
307: queue_t *l_qbot; /* highest level write queue of lower stream */
308: int l_index; /* link index for lower stream */
309: };
310: /* unprovided SVR4 fields */
311: /* l_pad[5] */
312:
313:
314: /*
315: * Options structure for M_SETOPTS message. This is sent upstream
316: * by driver to set stream head options.
317: */
318: struct stroptions {
319: unsigned long so_flags; /* options to set */
320: short so_readopt; /* read option */
321: unsigned short so_wroff; /* write offset */
322: long so_minpsz; /* minimum read packet size */
323: long so_maxpsz; /* maximum read packet size */
324: unsigned long so_hiwat; /* read queue high water mark */
325: unsigned long so_lowat; /* read queue low water mark */
326: unsigned char so_band; /* update water marks for this band */
327: };
328:
329:
330: /*
331: * enumeration for strqset/strqget
332: */
333: typedef enum qfields {
334: QHIWAT = 0, /* q_hiwat or qb_hiwat */
335: QLOWAT = 1, /* q_lowat or qb_lowat */
336: QMAXPSZ = 2, /* q_maxpsz */
337: QMINPSZ = 3, /* q_minpsz */
338: QCOUNT = 4, /* q_count or qb_count */
339: QFIRST = 5, /* q_first or qb_first */
340: QLAST = 6, /* q_last or qb_last */
341: QFLAG = 7, /* q_flag or qb_flag */
342: QBAD = 8
343: } qfields_t;
344:
345:
346: /*
347: * Flags for stream options set message
348: */
349: #define SO_ALL 077 /* set all options */
350: #define SO_READOPT 01 /* set read option */
351: #define SO_WROFF 02 /* set write offset */
352: #define SO_MINPSZ 04 /* set min packet size */
353: #define SO_MAXPSZ 010 /* set max packet size */
354: #define SO_HIWAT 020 /* set high water mark */
355: #define SO_LOWAT 040 /* set low water mark */
356: #define SO_MREADON 0100 /* enable M_READ generation */
357: #define SO_MREADOFF 0200 /* disable M_READ generation */
358: #define SO_NDELON 0400 /* select non-STREAMS tty O_NDELAY semantics */
359: #define SO_NDELOFF 01000 /* select STREAMS O_NDELAY semantics */
360: #define SO_BAND 02000 /* set water marks in a band (unsupported) */
361: #define SO_ISTTY 04000 /* acting as a controlling terminal */
362: #define SO_ISNTTY 010000 /* not acting as a controlling terminal */
363: #define SO_TOSTOP 020000 /* stop on background writes (unsupported) */
364: #define SO_TONSTOP 040000 /* no stop on background writes (unsupported) */
365:
366:
367: /*
368: * SpiderStreams Specific flag - to enable the sending down of an
369: * I_CLOSE ioctl just before calling a drivers close routine
370: */
371: #define SO_I_CLOSE 0100000 /* send I_CLOSE */
372:
373:
374: /*
375: * Data and protocol messages (regular priority)
376: */
377: #define M_DATA 00 /* regular data */
378: #define M_PROTO 01 /* protocol control */
379: #define M_DELAY 014 /* real-time xmit delay (1 param) */
380:
381:
382: /*
383: * Control messages (regular priority)
384: */
385: #define M_BREAK 010 /* line break */
386: #define M_PASSFP 011 /* pass file pointer */
387: #define M_SIG 013 /* generate process signal */
388: #define M_CTL 015 /* device-specific control message */
389: #define M_IOCTL 016 /* ioctl; set/get params */
390: #define M_SETOPTS 020 /* set various stream head options */
391: #define M_RSE 021 /* reserved for internal use */
392:
393:
394: /*
395: * Control messages (high priority; go to head of queue)
396: */
397: #define M_IOCACK 0201 /* acknowledge ioctl */
398: #define M_IOCNAK 0202 /* negative ioctl acknowledge */
399: #define M_PCPROTO 0203 /* priority proto message */
400: #define M_PCSIG 0204 /* generate process signal */
401: #define M_FLUSH 0206 /* flush your queues */
402: #define M_STOP 0207 /* stop transmission immediately */
403: #define M_START 0210 /* restart transmission after stop */
404: #define M_HANGUP 0211 /* line disconnect */
405: #define M_ERROR 0212 /* fatal error used to set u.u_error */
406: #define M_READ 0213 /* sent on read call, if no messages waiting */
407: #define M_STOPI 0214 /* stop input request */
408: #define M_STARTI 0215 /* start input request */
409: #define M_PCRSE 0216 /* reserved for internel use */
410:
411:
412: /*
413: * Queue message class definitions.
414: */
415: #define QNORM 0 /* normal messages */
416: #define QPCTL 0200 /* priority cntrl messages */
417:
418:
419: /*
420: * Define for 2-byte M_ERROR message
421: */
422: #define NOERROR 255
423:
424: /************************************************************/
425: /* Miscellaneous parameters and flags */
426: /************************************************************/
427:
428: /*
429: * Stream head default high/low water marks
430: */
431:
432: #define STRHIGH 5120
433: #define STRLOW 1024
434:
435:
436: /*
437: * Block allocation parameters
438: */
439: #define QBSIZE 65 /* min size for block allocation retries */
440: #define MAXBSIZE 4096 /* max block size */
441: #define MAXIOCBSZ 1024 /* max ioctl data block size */
442:
443:
444: /*
445: * Values for stream flag in open to indicate module open, clone open;
446: * return value for failure.
447: */
448: #define MODOPEN 1 /* open as a module */
449: #define CLONEOPEN 2 /* open for clone, pick own minor device */
450: #define OPENFAIL -1 /* returned for open failure */
451:
452:
453: /*
454: * Value for packet size that denotes infinity
455: */
456: #define INFPSZ -1
457:
458:
459: /*
460: * Flags for flushq()
461: */
462: #define FLUSHALL 1 /* flush all messages */
463: #define FLUSHDATA 0 /* don't flush control messages */
464:
465:
466: /*
467: * Default ioctl/close timeout (seconds)
468: */
469:
470: #define STRTIMOUT 15
471:
472:
473: /************************************************************************/
474: /* Definitions of Streams macros and function interfaces. */
475: /************************************************************************/
476:
477: /*
478: * extract queue class of message block
479: */
480: #define queclass(bp) (bp->b_datap->db_type & QPCTL)
481:
482:
483: /*
484: * Align address on next lower word boundary
485: */
486: #define straln(a) (char *)((long)(a) & ~(sizeof(int)-1))
487:
488:
489:
490: /*
491: * NT-specific definitions for STREAMS Drivers
492: */
493: typedef struct {
494: KSPIN_LOCK spinlock;
495: KIRQL oldlevel;
496: } lock_t;
497:
498:
499: /*
500: * STREAMS <-> TDI interface variable types
501: */
502:
503: #define SHTDI_ADDRESS_COMPARE_BIND 0
504: #define SHTDI_ADDRESS_COMPARE_RECEIVE 1
505:
506: typedef struct {
507: long ADDR_length; // length of broadcast address for this type
508: USHORT AddressType; // Tdi address type
509: BOOLEAN DirectedRouted; // TRUE if a directed message will go farther
510: // than a broadcast or multicast message.
511: PVOID ADDR_ptr; // pointer to broadcast address. NULL if there
512: // isn't one.
513: BOOLEAN (*AddressCompare)(char *, int, char *, int, int);
514: // Function to call to compare two addresses to
515: // see if the provider treats them as equal.
516: // returns TRUE if the addresses are equal.
517: } STREAMS_TDI_ADDRESS_INFO, *PSTREAMS_TDI_ADDRESS_INFO;
518:
519: typedef struct {
520: long SERV_type;
521: struct streamtab * Partner;
522: long PSERV_type;
523: long OPT_length; // length of option string to pass to turn
524: // on TO_REUSE_ADDR
525: PVOID OPT_ptr; // ptr to option string
526: BOOLEAN ReuseAddr; // TRUE if TO_REUSE_ADDR is on by default
527: int AddressInfoCount; // Number of address info structures in the
528: // AddressInfo array.
529:
530: PSTREAMS_TDI_ADDRESS_INFO AddressInfo;
531: // Pointer to the AddressInfo array. There is
532: // one for each address type the provider
533: // supports.
534:
535: } STREAMS_TDI_INFO, *PSTREAMS_TDI_INFO;
536:
537:
538:
539: /*
540: * Definitions for Unix system call and kernel variable emulation
541: *
542: */
543:
544: //
545: // In SVR4, HZ is defined in <sys/param.h> and lbolt declared in <sys\systm.h>.
546: //
547: // However, on NT, we define it here since the value of HZ is intimately tied
548: // to the function, StrmQuerySecondsSince1970Time().
549: //
550: #define HZ 100
551: #define lbolt StrmQueryLbolt()
552:
553:
554:
555: #define bcopy(src, dest, bcount) RtlMoveMemory( \
556: (PVOID) (dest), \
557: (PVOID) (src), \
558: (ULONG) (bcount) \
559: )
560:
561: #define bzero(addr, bcount) RtlZeroMemory( \
562: (PVOID) (addr), \
563: (ULONG) (bcount) \
564: )
565:
566:
567: //
568: // SAMESTR() is not defined in the SVR4 STREAMS Programmer's Guide, but is
569: // a macro in SVR4's <sys/streams.h>. In SpiderSTREAMS it is a function.
570: //
571: int
572: SAMESTR(
573: IN queue_t *q
574: );
575:
576:
577: /*
578: * Definitions for the STREAMS error logging facility
579: */
580: #include <ntiologc.h>
581:
582: /*
583: * Maximum amount of data (binary dump data plus insertion strings) that
584: * can be added to an error log entry.
585: */
586: #define STRM_MAX_ERROR_LOG_DATA_SIZE \
587: ( (ERROR_LOG_MAXIMUM_SIZE - sizeof(IO_ERROR_LOG_PACKET) + 4) & 0xFFFFFFFC )
588:
589:
590:
591: //
592: // NT STREAMS Extensions to the Regular SVR4 STREAMS Utilities
593: //
594:
595: typedef struct _U_UERROR {
596: LIST_ENTRY p_list;
597: struct _KTHREAD * ThreadHandle;
598: char u_error;
599:
600: } U_UERROR, *PU_UERROR;
601:
602:
603: LARGE_INTEGER
604: StrmConvertCentisecondsToRelativeTimeout(
605: unsigned long Centiseconds
606: );
607:
608:
609: NTSTATUS
610: StrmDeregisterDriver(
611: IN PDRIVER_OBJECT driverobject,
612: IN struct streamtab *streamtab
613: );
614:
615: NTSTATUS
616: StrmDeregisterModule(
617: IN PDRIVER_OBJECT driverobject,
618: IN struct streamtab *streamtab
619: );
620:
621: dev_t
622: StrmFindDevno(
623: IN struct streamtab *stab
624: );
625:
626: char
627: StrmGetError(
628: void
629: );
630:
631: time_t
632: StrmQueryLbolt(
633: void
634: );
635:
636: time_t
637: StrmQuerySecondsSince1970Time(
638: void
639: );
640:
641: NTSTATUS
642: StrmRegisterDriver(
643: IN PDRIVER_OBJECT driverobject,
644: IN struct streamtab *streamtab,
645: IN char *subysname OPTIONAL,
646: IN PSTREAMS_TDI_INFO ptdiinfo OPTIONAL
647: );
648:
649: NTSTATUS
650: StrmRegisterModule(
651: IN PDRIVER_OBJECT driverobject,
652: IN struct streamtab *streamtab,
653: IN char *subysname OPTIONAL
654: );
655:
656: VOID
657: StrmSetError(
658: char
659: );
660:
661: int
662: suser(
663: void
664: );
665:
666: NTSTATUS
667: StrmLogEvent(
668: IN PDRIVER_OBJECT DriverObject OPTIONAL,
669: IN NTSTATUS EventCode,
670: IN ULONG UniqueEventValue,
671: IN USHORT NumStrings,
672: IN PCHAR *Strings OPTIONAL,
673: IN ULONG DataSize,
674: IN PVOID Data OPTIONAL
675: );
676:
677: NTSTATUS
678: StrmWaitForMultipleObjects(
679: IN queue_t *Queue,
680: IN CCHAR Count,
681: IN PVOID Object[],
682: IN WAIT_TYPE WaitType,
683: IN KWAIT_REASON WaitReason,
684: IN KPROCESSOR_MODE WaitMode,
685: IN BOOLEAN Alertable,
686: IN PLARGE_INTEGER Timeout OPTIONAL,
687: IN PKWAIT_BLOCK WaitBlockArray OPTIONAL
688: );
689:
690: NTSTATUS
691: StrmWaitForMutexObject(
692: IN queue_t *Queue,
693: IN PKMUTEX Mutex,
694: IN KWAIT_REASON WaitReason,
695: IN KPROCESSOR_MODE WaitMode,
696: IN BOOLEAN Alertable,
697: IN PLARGE_INTEGER Timeout OPTIONAL
698: );
699:
700: NTSTATUS
701: StrmWaitForSingleObject(
702: IN queue_t *Queue,
703: IN PVOID Object,
704: IN KWAIT_REASON WaitReason,
705: IN KPROCESSOR_MODE WaitMode,
706: IN BOOLEAN Alertable,
707: IN PLARGE_INTEGER Timeout OPTIONAL
708: );
709:
710:
711: NTSTATUS
712: StrmOpenRegKey(
713: PHANDLE HandlePtr,
714: PUCHAR KeyName
715: );
716:
717: NTSTATUS
718: StrmGetRegValue(
719: HANDLE KeyHandle,
720: PUCHAR ValueName,
721: PUCHAR ValueData,
722: ULONG ValueLength,
723: PULONG ValueType
724: );
725:
726:
727:
728: /*
729: * General STREAMS functions exported for use by drivers.
730: *
731: * Some of these functions have been renamed and redefined with additional
732: * parameters for debugging purposes. Macros which call the new functions
733: * appear in place of the old ones.
734: */
735:
736: int
737: adjmsg(
738: IN mblk_t *mp,
739: IN int len
740: );
741:
742: mblk_t *
743: allocb(
744: IN int size,
745: IN unsigned int pri
746: );
747:
748: queue_t *
749: backq(
750: IN queue_t *q
751: );
752:
753: int
754: bufcall(
755: IN int size,
756: IN int pri,
757: IN int (*func)(long),
758: IN long arg
759: );
760:
761: int
762: canput(
763: IN queue_t *q
764: );
765:
766: int
767: canputnext(
768: IN queue_t *q
769: );
770:
771: mblk_t *
772: copyb(
773: IN mblk_t *bp
774: );
775:
776: mblk_t *
777: copymsg(
778: IN mblk_t *bp
779: );
780:
781: //
782: // Test if data block type is one of the data messages (i.e. not a
783: // control message).
784: //
785: #define datamsg(type) ((type) == M_DATA || (type) == M_PROTO || \
786: (type) == M_PCPROTO || (type) == M_DELAY)
787:
788: int
789: disable_procs(
790: IN queue_t *q
791: );
792:
793: mblk_t *
794: dupb(
795: IN mblk_t *bp
796: );
797:
798: mblk_t *
799: dupmsg(
800: IN mblk_t *bp
801: );
802:
803: int
804: enable_procs(
805: IN queue_t *q
806: );
807:
808: void
809: enableok(
810: IN queue_t *q
811: );
812:
813: mblk_t *
814: esballoc(
815: IN unsigned char *base,
816: IN int size,
817: IN int pri,
818: IN frtn_t *fr_rtn
819: );
820:
821: int
822: esbbcall(
823: IN int pri,
824: IN int (*func)(long),
825: IN long arg
826: );
827:
828: void
829: flushq(
830: IN queue_t *q,
831: IN int flag
832: );
833:
834: void
835: freeb(
836: IN mblk_t *bp
837: );
838:
839: void
840: freemsg(
841: IN mblk_t *bp
842: );
843:
844: int (*
845: getadmin(
846: IN unsigned short mid
847: ))();
848:
849: unsigned short
850: getmid(
851: IN char *name
852: );
853:
854: mblk_t *
855: getq(
856: IN queue_t *q
857: );
858:
859: /*
860: * void
861: * init_lock(
862: * IN lock_t *lockp
863: * );
864: */
865:
866: #define init_lock(lockp) KeInitializeSpinLock(&((lockp)->spinlock))
867:
868:
869: int
870: insq(
871: IN queue_t *q,
872: IN mblk_t *emp,
873: IN mblk_t *mp
874: );
875:
876: void
877: linkb(
878: IN mblk_t *mp,
879: IN mblk_t *bp
880: );
881:
882: int
883: msgdsize(
884: IN mblk_t *bp
885: );
886:
887: void
888: noenable(
889: IN queue_t *q
890: );
891:
892: /*
893: * int
894: * p_lock (
895: * IN lock_t *lockp,
896: * IN int level
897: * );
898: */
899:
900: #define p_lock(lockp, ignored) \
901: ( KeAcquireSpinLock( \
902: &((lockp)->spinlock), \
903: &((lockp)->oldlevel) \
904: ), \
905: ((int) (lockp)->oldlevel) \
906: )
907:
908: int
909: pullupmsg(
910: IN mblk_t *mp,
911: IN int len
912: );
913:
914: int
915: put(
916: IN queue_t *q,
917: IN mblk_t *mp
918: );
919:
920: int
921: putbq(
922: IN queue_t *q,
923: IN mblk_t *bp
924: );
925:
926: int
927: putctl(
928: IN queue_t *q,
929: IN int type
930: );
931:
932: int
933: putctl1(
934: IN queue_t *q,
935: IN int type,
936: IN int param
937: );
938:
939: int
940: putnext(
941: IN queue_t *q,
942: IN mblk_t *mp
943: );
944:
945: int
946: putnextctl(
947: IN queue_t *q,
948: IN int type
949: );
950:
951: int
952: putnextctl1(
953: IN queue_t *q,
954: IN int type,
955: IN int p
956: );
957:
958: int
959: putq(
960: IN queue_t *q,
961: IN mblk_t *bp
962: );
963:
964: void
965: qenable(
966: IN queue_t *q
967: );
968:
969: void
970: qreply(
971: IN queue_t *q,
972: IN mblk_t *bp
973: );
974:
975: int
976: qsize(
977: IN queue_t *qp
978: );
979:
980: mblk_t *
981: rmvb(
982: IN mblk_t *mp,
983: IN mblk_t *bp
984: );
985:
986: void
987: rmvq(
988: IN queue_t *q,
989: IN mblk_t *mp
990: );
991:
992: int
993: strlog(
994: IN short mid,
995: IN short sid,
996: IN char level,
997: IN unsigned short flags,
998: IN char *fmt,
999: ...
1000: );
1001:
1002: int
1003: strqget(
1004: IN queue_t *q,
1005: IN qfields_t what,
1006: IN unsigned char band,
1007: IN long *valp
1008: );
1009:
1010: int
1011: strqset(
1012: IN queue_t *q,
1013: IN qfields_t what,
1014: IN unsigned char band,
1015: IN long *val
1016: );
1017:
1018: int
1019: testb(
1020: IN int size,
1021: IN unsigned int pri
1022: );
1023:
1024: int
1025: timeout(
1026: IN int (*ftn)(char *),
1027: IN char *arg,
1028: IN long tim
1029: );
1030:
1031: int
1032: unbufcall(
1033: IN int id
1034: );
1035:
1036: mblk_t *
1037: unlinkb(
1038: IN mblk_t *mp
1039: );
1040:
1041: int
1042: untimeout(
1043: IN int seq
1044: );
1045:
1046: /* void
1047: * v_lock (
1048: * IN lock_t *lockp,
1049: * IN int level
1050: * );
1051: *
1052: */
1053:
1054: #define v_lock(lockp, level) \
1055: KeReleaseSpinLock(&((lockp)->spinlock), (KIRQL) (level))
1056:
1057:
1058:
1059: //
1060: // BUGBUG - this include needs to be removed for the final product.
1061: //
1062: #include <debugapi.h>
1063:
1064:
1065:
1066: #endif // _SYS_STREAM_INCLUDED
1067:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.