![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to strmlib.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 / kernel|
Return to strmlib.h CVS log | Up to [MW Coherent from dump] / coherent / f / usr / include / kernel |
1.1 root 1: #ifndef __KERNEL_STRMLIB_H__
2: #define __KERNEL_STRMLIB_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: * This file contains definitions that are be used for the implementation of
13: * the STREAMS standard library routines and scheduling code. Some details
14: * of the interfaces between STREAMS and the rest of the system will also
15: * be dealt with here so as to insulate the STREAMS implementation from the
16: * details of that interface.
17: *
18: * Note that as the contents of this header are for private, system internal
19: * use only, names do not begin with underscores.
20: */
21:
22: /*
23: *-IMPORTS:
24: * <common/ccompat.h>
25: * __EXTERN_C_BEGIN__
26: * __EXTERN_C_END__
27: * __PROTO ()
28: * <common/xdebug.h>
29: * __LOCAL__
30: * <common/__size.h>
31: * __size_t
32: * <common/__clock.h>
33: * __clock_t
34: * <common/__pid.h>
35: * __pid_t
36: * <kernel/st_alloc.h>
37: * _ST_HEAP_CONTROL
38: * <kernel/defer.h>
39: * defer_int_any ()
40: * <sys/ksynch.h>
41: * lock_t
42: * sv_t
43: * <sys/uio.h>
44: * uio_t
45: */
46:
47: #include <common/ccompat.h>
48: #include <common/xdebug.h>
49: #include <common/__size.h>
50: #include <common/__clock.h>
51: #include <common/__pid.h>
52: #include <kernel/st_alloc.h>
53: #include <kernel/defer.h>
54: #include <sys/inline.h>
55: #include <sys/ksynch.h>
56: #include <sys/uio.h>
57:
58: #include <common/_stream.h>
59: #include <kernel/ddi_lock.h>
60: #include <kernel/ddi_glob.h>
61:
62: /*
63: * In order to be able to declare prototypes that refer to structures that are
64: * declared in other headers, we supply incomplete declarations at top-level
65: * to avoid some scoping problems.
66: */
67:
68: struct stroptions;
69: struct strbuf;
70:
71:
72: /*
73: * In onder for freezestr () to work as defined in the Multiprocessor DDI/DKI,
74: * it cannot simply be implemented in terms of the high-level locking
75: * operations defined in <sys/ksynch.h> (the reason being that it is specified
76: * as raising the processor priority level, whereas the "pl" parameter to the
77: * high-level locking functions is specified as setting the level, with a
78: * caution that it not cause the level to be lowered).
79: *
80: * Stream queue freezing cannot really be implemented in terms of high-level
81: * basic locks because of the hierarchy mechanism; the relative priority of
82: * stream head locks is determined by relative position in a stream so that
83: * following the "q_next" member yields increasing (virtual) hierarchy values,
84: * with the additional constraint that a given context may only hold a lock on
85: * one side of a stream at a time.
86: */
87:
88: #define SFREEZE_INIT(q) ((void) ATOMIC_CLEAR_UCHAR ((q)->q_locked))
89: #define SFREEZE_DESTROY(q) ((void) 0)
90: #define SFREEZE_LOCK(q,name) TEST_AND_SET_LOCK ((q)->q_locked, plstr, \
91: (name))
92: #define SFREEZE_UNLOCK(q,pl) (ATOMIC_CLEAR_UCHAR ((q)->q_locked), \
93: (void) splx (pl))
94: #define SFREEZE_ASSERT_FROZEN(q) ASSERT (ATOMIC_FETCH_UCHAR ((q)->q_locked))
95:
96:
97: /*
98: * The implementation of allocb () and freeb () deals in terms of "triples"
99: * consisting of an mblk_t, a dblk_t, and the actual data being managed.
100: * (Of course, under esballoc () the data belongs to another subsystem, but
101: * such a double should also be managed by the same system).
102: *
103: * Be aware that changing the definition of any of these things may
104: * invalidate assumptions made by the code in allocb (), freeb (), dupb ()
105: * and esballoc ().
106: */
107:
108: /*
109: * Various ways to map between the components of a triple.
110: */
111:
112: #define MB_TO_DB(mp) ((dblk_t *) (mp + 1))
113: #define DB_TO_MB(db) (((mblk_t *) db) - 1)
114: #define DB_TO_DATA(db) ((unsigned char *) (db + 1))
115: #define DATA_TO_DB(d) (((dblk_t *) d)) - 1)
116:
117:
118: /*
119: * Some useful predicates for determining whether various items are actually
120: * parts of triples or not, since there are exceptional cases where the
121: * individual elements of a triple have been scattered to the four winds.
122: *
123: * Note that the SET_MB_TRIPLE () and SET_MB_FREE () exist as a pair, since
124: * they only relate to message blocks that are part of a triple.
125: * SET_MB_TRIPLE () is used when a message block is instantiated, and
126: * SET_MB_FREE () is used when a message block is deallocated but the rest
127: * of the triple is still in use.
128: */
129:
130: #define IS_DB_USER_DATA(db) (db->db_base != DB_TO_DATA (db))
131: /*
132: * Test to see whether the
133: * data referenced by this
134: * block is user-controlled.
135: */
136:
137: #define IS_TRIPLE_TOGETHER(mp) (mp->b_datap == MB_TO_DB (mp))
138: /*
139: * Test to see whether the
140: * data block referenced by
141: * this message block forms
142: * part of the same triple.
143: */
144:
145: #define SET_MB_TRIPLE(mp) (void) ((mp)->b_flags =\
146: ((mp)->b_flags | MSGTRIPLE) & ~ MSGFREE)
147: /*
148: * Mark the message block as
149: * part of a triple.
150: */
151:
152: #define IS_MB_TRIPLE(mp) (((mp)->b_flags & MSGTRIPLE) != 0)
153: /*
154: * Test whether the message
155: * block is part of a triple
156: * or is a floating block.
157: */
158:
159: #define SET_MB_FREE(mp) (void) ((mp)->b_flags |= MSGFREE)
160: /*
161: * Indicate that the message
162: * block is no longer in
163: * use. Only for message
164: * blocks in triples.
165: */
166:
167: #define IS_MB_FREE(mp) ((mp->b_flags & MSGFREE) != 0)
168: /*
169: * Test whether the message
170: * block is free or not.
171: */
172:
173: /*
174: * STREAMS Local extension: scheduling
175: */
176:
177: /*
178: * The methods used in the multiplexing examples in the STREAMS Programmer's
179: * Guide for System V Release 2 are quite inefficient. The following general
180: * STREAMS queue scheduling structures and routines were defined in a visible
181: * manner since
182: *
183: * (i) It served to better-document the way in which queues are serviced
184: * within this STREAMS implementation,
185: *
186: * (ii) Multiplexing drivers (and device drivers which multiplex several
187: * minor numbers on a single I/O bus, such as an Ethernet or SCSI
188: * driver) need effcient mechanisms for managing multiple request
189: * channels,
190: *
191: * (iii) It allows drivers to leverage the multiprocessor locking that is
192: * built into these primitives.
193: *
194: * Note that allowing drivers access to this facility causes a significant
195: * departure from the standard version of STREAMS, but that driver use of the
196: * macros and data structures below permits other implementations.
197: *
198: * As this system is used internally by this STREAMS implementation, it can
199: * use the "q_link" member of a queue to hold a link to the next STREAM on
200: * a schedule. In addition, some "q_flag" bits can be used to control
201: * whether or not a queue is currently threaded on any schedule. A portable
202: * implementation that does not depend on any reserved parts of STREAMS
203: * data structures may not use these fields, and so may operate under a
204: * different set of constraints. However, since in this case the drivers and
205: * STREAMS itself share common scheduling code, the following restrictions
206: * must be observed:
207: *
208: * (i) A queue may be requested to be scheduled more than once with no
209: * effect. If a queue is requested to be scheduled on different
210: * schedules, then this is probably an error, most likely to occur
211: * if you define both a STREAMS service routine and a schedule for
212: * a driver queue; this should not be done under the common scheme.
213: *
214: * (ii) A queue which has noenable () set on it will still be scheduled.
215: * The manner in which qenable ()/noenable () work has no bearing on
216: * this mechanism.
217: *
218: * (iii) Schedules should only be created or destroyed with the schedule
219: * allocation/deallocation routines in order to guarantee that the
220: * schedule is multi-processor addressable and is the correct size for
221: * the selected run-time environment.
222: *
223: * (iv) When a driver is closed, the queue must not be on any schedule in
224: * order to prevent list corruption and the dire effects that can
225: * result from such corruption. A portable implementation of scheduling
226: * has no way to do this automatically for the driver since the
227: * close () call is managed by STREAMS.
228: *
229: * Note that in this common implementation, conditions (i), (iii), and (iv)
230: * can be checked by the scheduling system if compiled such that debugging
231: * code is inserted.
232: */
233:
234: /*
235: * STREAMS scheduler private per-schedule global data structure.
236: */
237:
238: struct __streams_schedule {
239: queue_t * ss_head; /* head of list of scheduled queues */
240: queue_t * ss_tail; /* tail of list of scheduled queues */
241:
242: lock_t * ss_locked; /* lock for schedule */
243: };
244:
245:
246: extern lkinfo_t __stream_schedule_lkinfo;
247:
248: #define SCHLOCK_INIT(s,flag) \
249: ((s)->ss_locked = LOCK_ALLOC (stream_schedule_hierarchy, plstr, \
250: & __stream_schedule_lkinfo, (flag)))
251:
252: #define SCHLOCK_DESTROY(s) LOCK_DEALLOC ((s)->ss_locked)
253:
254: #define SCHLOCK_LOCK(s,n) LOCK ((s)->ss_locked, plstr)
255:
256: #define SCHLOCK_UNLOCK(s,p) UNLOCK ((s)->ss_locked, p)
257:
258: #define SCHLOCK_ASSERT_LOCKED(s) \
259: ASSERT (TRYLOCK ((s)->ss_locked, plstr) == invpl)
260:
261: #define SCHED_INIT(s,flag) ((s)->ss_head = (s)->ss_tail = NULL, \
262: SCHLOCK_INIT (s, flag))
263:
264:
265: /*
266: * I use these everywhere that I know which queue side I've got. These
267: * macros duplicate the old-style RD () and WR () functionality, which has
268: * been changed along the path from System V Release 3.2 to System V Release
269: * 4 Multi-Processor. When compiling under the DDI/DKI, these macros are also
270: * converted to functions.
271: */
272:
273: #define W(q) ((q) + 1)
274: #define R(q) ((q) - 1)
275:
276:
277: /*
278: * A utility function, for use with STRMEM_ALLOC (), to calculate the size
279: * required for a message triple with "n" bytes of associated data buffer.
280: */
281:
282: #define MSGB_SIZE(n) ((n) + sizeof (mblk_t) + sizeof (dblk_t))
283:
284:
285: /*
286: * The following data type is used to hold registration information for the
287: * SIGPOLL signal. Every process that registers for SIGPOLL signals allocates
288: * one of these structures and threads it on the stream head.
289: */
290:
291: typedef struct sigpoll sigpoll_t;
292:
293:
294: /*
295: * The following is the internal structure (an "event cell" in STREAMS)
296: * used by the bufcall ()/esbbcall () mechanism to record the necessary
297: * information for calling the user back.
298: *
299: * Note that the real System V bufcall ()/esbbcall () takes a a pointer to
300: * a function with undefined parameters, yet also accepts a parameter which
301: * it will then pass on to the callback. The only way to implement this at
302: * all portably is to use some version of the ISO <stdarg.h> mechanism to
303: * allow bufcall () to take any argument in it's "natural" form and then
304: * pass a maximum-sized chunk of stack into the callback in order to capture
305: * all of the information that the client wanted to pass.
306: *
307: * Of course, doing this is opening a wide door to all kinds of problems,
308: * since while there are some sleazy ways to restrict the size of the extra
309: * argument to something reasonable, there is no way that we can make sure
310: * that the shapes of the argument and the callback parameter really do
311: * match (eg, the callback takes a long but bufcall () is given an int).
312: *
313: * Of course, this is all no worse than the situation AT&T have under the
314: * DDI/DKI, where bufcall () is required to take the callback parameter as
315: * a "long" and clients assume that pointers have the same shape as longs
316: * (if you look at the example in bufcall (D3DK) that is exactly what A&T
317: * seem to be suggesting - blech).
318: *
319: * There is no entirely satisfactory way to get around this evil in plain C,
320: * although we can get at least a partial solution through supplying a range
321: * of supplementary definitions that (at least in an ISO environment) ensure
322: * that the function argument types and argument types will be coerced to
323: * something reasonable.
324: *
325: * Event management is made a little more complex by the availability of the
326: * unbufcall () procedure, which requires us to assign a numeric ID code to
327: * each event cell. It would be nice if this ID code also included some kind
328: * of generation field, and mapped instantly to the desired value.
329: *
330: * Note that this is exactly the same problem faced by the timeout () routine
331: * in implementing untimeout (), and there are numerous possible solutions,
332: * each of which maximizes some desirable property at the cost of losing some
333: * other property.
334: */
335:
336: #define _TOID_MEMBER 1
337:
338: typedef void (* se_funcptr_t) __PROTO ((long _arg));
339:
340: typedef struct __stream_event sevent_t;
341:
342: struct __stream_event {
343: sevent_t * se_next; /* next event in chain */
344: sevent_t * se_prev; /* previous event in chain */
345: long se_arg; /* argument for function */
346: se_funcptr_t se_func; /* function to call */
347: unsigned int se_size; /* optional size information */
348: #if _TOID_MEMBER
349: toid_t se_id; /* timeout id for item */
350: #endif
351: };
352:
353:
354: /*
355: * Of course, we have to thread the above events on a list. We'll create a
356: * structure for this to abstract the details of the locking scheme we'll use
357: * for maintaining the consistency of the event lists.
358: *
359: * We store a generator for the timeout ID codes in the list header so that
360: * the ID generation step can be protected by the same lock as the list
361: * manipulation code. This means that at initialisation time each list header
362: * should have the initial ID code set to its number and that the increment
363: * value used to step between codes is one greater than the total number of
364: * list headers (so that code 0 never appears).
365: *
366: * We have a wide range of possible policies for managing event cells. We need
367: * to get some performance data on each to make a final decision.
368: */
369:
370: #define _FIFO_BUFCALL 1
371:
372: typedef struct __stream_event_list selist_t;
373:
374: struct __stream_event_list {
375: lock_t * sl_locked;
376: sevent_t * sl_head;
377: #if _FIFO_BUFCALL
378: sevent_t * sl_tail;
379: #endif
380: #if _TOID_MEMBER
381: toid_t sl_id;
382: #endif
383: };
384:
385:
386: extern lkinfo_t __stream_event_lkinfo;
387:
388: #define SELIST_INIT(s,flag) \
389: ((s)->sl_head = NULL, \
390: (s)->sl_locked = LOCK_ALLOC (stream_event_hierarchy, plstr, \
391: & __stream_event_lkinfo, (flag)))
392:
393: #define SELIST_DESTROY(s) LOCK_DEALLOC ((s)->sl_locked)
394:
395: #define SELIST_LOCK(s) LOCK ((s)->sl_locked, plstr)
396:
397: #define SELIST_UNLOCK(s,pl) UNLOCK ((s)->sl_locked, (pl))
398:
399: #define SELIST_ASSERT_LOCKED(s) \
400: ASSERT (TRYLOCK ((s)->sl_locked, plstr) == invpl)
401:
402:
403: /*
404: * Some handy requirements for timeout ID generation. We have to define these
405: * numbers such that each list above generates a non-overlapping sequence that
406: * overflows into the same sequence, eg.
407: * 1, k + 1, 2k + 1, ... ik + 1, 1, ...
408: * 2, k + 2, 2k + 2, ... ik + 2, 2, ...
409: *
410: * Since each list generates a distinct and identifiable sequence we can map
411: * from the ID to the list in one step, which somewhat ameliorates the cost
412: * of having to search the list to find the given event.
413: */
414:
415: #define TOID_INCREMENT (N_PRI_LEVELS + 1)
416: #define TOID_MODULUS (TOID_MAX - TOID_MAX % TOID_INCREMENT)
417: #define TOID_TO_PRI(id) ((id) % TOID_INCREMENT - 1)
418:
419:
420: /*
421: * Watermark control structures:
422: *
423: * We record here the amount of memory held by each allocation band and the
424: * maximum amount we will permit it to hold. In addition, we record a thread
425: * of structures used by bufcall () and esbbcall () to record information
426: * for callbacks to drivers when memory becomes available.
427: */
428: /*
429: * A note on bufcall ()/esbbcall () structures;
430: *
431: * I am not able to conceive of a comprehensive strategy for dealing with
432: * these things that works well under all circumstances. For now, it seems
433: * that keeping a few around in preallocated event cells is a good idea for
434: * when we run out of memory. However, as long as possible the system will
435: * always attempt to satisfy a request for an event cell with a newly
436: * allocated cell, since we expect the usual reason for being unable to
437: * satisfy a request is that memory is merely fragmented rather than fully
438: * occupied.
439: *
440: * Of course, allocating bufcall cells within the heap may increase the
441: * level of fragmentation - which is why we prefer to allocate them from
442: * the "long-term" heap (and indeed, why we have two heaps at all).
443: */
444:
445: #define N_PRI_LEVELS 3 /*
446: * Number of buffer priority levels
447: */
448: #define MAP_PRI_LEVEL(p) p /*
449: * Map from BPRI_xxx to index.
450: */
451:
452: /* #define SPLIT_STREAMS_MEMORY */ /*
453: * Control whether there are separate
454: * arenas for messages and other
455: * allocations.
456: */
457:
458: /*
459: * We keep several lists of stream heads according to the category of the
460: * stream; device, pipe, and possibly FIFO. Various general operations require
461: * iterating over several of the lists, and so we define an array of list
462: * head pointers to simplify things since we don't have the C++ "pointer to
463: * member" types and operations available.
464: */
465:
466: typedef struct __stream_head shead_t;
467:
468: typedef enum slist_id {
469: DEV_SLIST,
470: PIPE_SLIST,
471: SLIST_MAX
472: } slist_id_t;
473:
474: typedef int muxid_t;
475:
476:
477: /*
478: * This structure grew to its present form before the <kernel/ddi_glob.h>
479: * header took shape. Most of it should eventually be moved there, with
480: * appropriate thought given to what should be fixed and what should be
481: * variable allocations.
482: */
483:
484:
485: struct streams_mem {
486: atomic_uchar_t sm_init; /* primitive lock for startup */
487:
488: __size_t sm_used; /* memory used in the message heap */
489: __size_t sm_max [N_PRI_LEVELS];
490: /*
491: * Maximum memory we let a level use
492: */
493:
494: toid_t sm_bcid; /* id generator for bufcall events */
495: selist_t sm_bcevents [N_PRI_LEVELS];
496: /*
497: * Bufcall event linked-list head.
498: */
499: ssched_t sm_sched [1]; /* List of enabled queues. */
500:
501: lock_t * sm_seq_lock; /* Lock sequence number registers. */
502: unsigned long sm_err_seq; /* error log sequence number */
503: unsigned long sm_trc_seq; /* trace log sequence number */
504: unsigned long sm_con_seq; /* console log sequence number */
505:
506: queue_t * sm_log_rq; /* STREAMS logger device */
507:
508: lock_t * sm_proc_lock; /* Basic lock for qprocsoff (). */
509: sv_t * sm_proc_sv; /*
510: * Synchronization variable for
511: * qprocsoff ().
512: */
513: queue_t * sm_log_drvr; /* Log-driver read side. */
514:
515: rwlock_t * sm_head_lock; /* Lock for stream head list */
516: shead_t * sm_streams [SLIST_MAX];
517: /* Chains of stream heads */
518:
519: __size_t sm_maxctlsize; /* max. size of control message */
520: __size_t sm_maxdatasize; /* max. size of data message part */
521:
522:
523: /*---------- Locked by sm_msg_lock ------------*/
524: lock_t * sm_msg_lock; /* basic lock for message heap */
525: _ST_HEAP_CONTROL_P sm_msg_heap; /* Memory heap for STREAMS messages */
526: sv_t * sm_msg_sv; /*
527: * synchronization variable for
528: * waiting for free memory.
529: */
530: __size_t sm_msg_needed; /* Level of free memory required */
531:
532: #ifdef SPLIT_STREAMS_MEMORY
533: /*---------- Locked by sm_other_lock ------------*/
534:
535: lock_t * sm_other_lock; /* basic lock for "other" heap */
536:
537: _ST_HEAP_CONTROL_P sm_other_heap;/* Memory heap for long-term info */
538:
539: sv_t * sm_other_sv; /*
540: * synchronization variable for
541: * waiting for free memory.
542: */
543: __size_t sm_other_needed;/* Level of free memory required */
544: #else
545: # define sm_other_heap sm_msg_heap
546: # define sm_other_lock sm_msg_lock
547: # define sm_other_sv sm_msg_sv
548: # define sm_other_needed sm_msg_needed
549: #endif
550: };
551:
552:
553: /*
554: * These should be the standard priorities to be used with the locks for
555: * controlling access to the various memory pools.
556: */
557:
558: #ifdef SPLIT_STREAMS_MEMORY
559:
560: # define str_msg_pl plstr
561: # define str_other_pl plhi
562:
563: #else
564:
565: # define str_msg_pl plhi
566: # define str_other_pl plhi
567:
568: #endif
569:
570:
571: /*
572: * When someone thinks it might be a good idea to see about running some of
573: * the bufcall routines, we defer a routine to deal with the checking. A
574: * global flag bit protects
575: */
576:
577: #define SCHEDULE_BUFCALLS() \
578: (ATOMIC_FETCH_AND_STORE_UCHAR (ddi_global_data ()->dg_run_bufcalls, 1) \
579: == 1 ? (void) 0 : (void) defer_int_any (RUN_BUFCALLS))
580:
581:
582: /*
583: * If all allocations are coming from the same pool, non-message allocations
584: * need to be counted in with the allocation-priority information.
585: *
586: * The "other" pool (which will really be the message pool) should be locked
587: * when these functions are called.
588: */
589:
590: #ifdef SPLIT_STREAMS_MEMORY
591:
592: # define OTHER_ALLOCED(size)
593: # define OTHER_FREED(size)
594:
595: #else
596:
597: # define OTHER_ALLOCED(size) (void) (str_mem->sm_used += size)
598: # define OTHER_FREED(size) ((void) (str_mem->sm_used -= size), \
599: SCHEDULE_BUFCALLS ())
600:
601: #endif
602:
603:
604: /*
605: * We need access to a global instance of the above for managing STREAMS
606: * memory in a consistent manner.
607: */
608:
609: extern struct streams_mem str_mem [];
610:
611:
612: /*
613: * Category flags for the sh_lock_mask member. This is a collection of flag
614: * bits which correspond to operations on the "sh_wait_sv" synchronization
615: * variable.
616: */
617:
618: typedef enum category {
619: SH_NONE = 0, /* use for paranoid checking */
620: SH_OPENCLOSE = 1,
621: SH_IOCTL_LOCK = 2,
622: SH_READ_LOCK = 4, /* NOT NORMALLY USED */
623: SH_WRITE_LOCK = 8, /* NOT NORMALLY USED */
624: SH_PEEK_LOCK = 16,
625:
626: SH_LOCK_MASK = 31, /* Mask for lock bits */
627:
628:
629: SH_READ_WAIT = 32,
630: SH_WRITE_WAIT = 64,
631: SH_IOCTL_WAIT = 128,
632: SH_DRAIN_WAIT = 256,
633: SH_PEEK_WAIT = 512,
634:
635: SH_WAIT_MASK = 992, /* Mask for wait bits */
636:
637:
638: /*
639: * Not a lock mask; just use the extra flag space.
640: */
641:
642: SH_TIMEFLAG = 8192
643: } cat_t;
644:
645:
646: /*
647: * Stream head control structure.
648: *
649: * Be careful with locking the stream head; for many operations, it may be
650: * sufficient to freeze the stream head.
651: */
652:
653: struct __stream_head {
654: n_dev_t sh_dev; /* key for lookup */
655: shead_t * sh_next; /* next stream head on chain */
656:
657: queue_t * sh_head; /* read queue of stream head */
658: struct streamtab
659: * sh_tab; /* initialisation data for driver */
660:
661: __clock_t sh_cltime; /* time to wait for close to drain */
662:
663: struct pollhead
664: * sh_pollhead; /* for polling support */
665:
666: pid_t sh_pgrp; /* foreground TTY process group */
667: __VOID__ * sh_controller; /* reference to controlling process */
668:
669: int sh_rerrcode; /* error code from M_ERROR */
670: int sh_werrcode; /* error code from M_ERROR */
671:
672: unsigned short sh_flags; /* miscellaneous flags */
673:
674: short sh_readopt; /* read options */
675: short sh_wropt; /* write options */
676:
677: unsigned short sh_wroff; /* write offset */
678:
679: sigpoll_t * sh_sigs; /* processes registered for SIGPOLL */
680:
681: toid_t sh_read_bufcall;/* ID for read bufcall () */
682:
683: shead_t * sh_linked; /* head of stream we are linked to */
684: muxid_t sh_muxid; /* our ID below that stream */
685:
686:
687: lock_t * sh_basic_lockp; /* */
688:
689: /*---- For process-level locking and timeout operations ----*/
690:
691: sv_t * sh_wait_sv; /* for process lock operations */
692:
693: int sh_lock_mask; /* which categories are locked */
694:
695: short sh_ref_count; /* references to stream memory */
696: short sh_open_count; /* successful open count */
697: short sh_attach_count;/* attachments to stream */
698: short sh_lock_count; /* processes queued or locked */
699: short sh_time_count; /* count of timeout checks */
700:
701: __clock_t sh_timeout_tick;/* current soonest timeout */
702: toid_t sh_timeout_id; /* ID of current active timeout */
703:
704: int sh_ioc_seq; /* ioctl () sequence number */
705: mblk_t * sh_ioc_msg; /* ioctl () messages */
706: };
707:
708:
709: /*
710: * A collection of functions for dealing with the stream head basic lock.
711: */
712:
713: #define SHEAD_LOCK(sheadp) LOCK ((sheadp)->sh_basic_lockp, plstr)
714: #define SHEAD_UNLOCK(sheadp,pl) UNLOCK ((sheadp)->sh_basic_lockp, pl)
715: #define SHEAD_ASSERT_LOCKED(sheadp) \
716: ASSERT ((sheadp) != NULL && \
717: TRYLOCK ((sheadp)->sh_basic_lockp, plstr) == invpl)
718:
719:
720: /*
721: * Masks for use with the "sh_flags" member.
722: */
723:
724: enum {
725: SH_READMSG = 0x0001, /* generate M_READ messages */
726: SH_NDELAY = 0x0002, /* non-STREAMS O_NDELAY semantics */
727: SH_TTY = 0x0004, /* stream is acting as a tty */
728: SH_TOSTOP = 0x0008, /* job control on background writes */
729:
730:
731: SH_HANGUP = 0x0010, /* stream has been hung up */
732:
733: SH_PLINK = 0x0020, /* stream is permanently linked */
734:
735: /*
736: * Permanent flags set when the stream is created. We do not need a
737: * flag to indicate a pipe, because pipes have a NULL "sh_tab" entry
738: * to mark them.
739: */
740:
741: SH_MASTER = 0x0100, /* master end of stream pipe */
742:
743:
744: /*
745: * This flag enables serialization of reads and writes. This is a
746: * local, experimental extension to STREAMS.
747: */
748:
749: SH_RWLOCKING = 0x0200
750: };
751:
752:
753: /*
754: * For stream pipes there is a master/slave relationship between the stream
755: * heads at each end. The following macros define some handy relationships
756: * between them to allow quick mapping from one to another.
757: */
758:
759: #define SHEAD_M2SLAVE(m) ((m) + 1)
760: #define SHEAD_SLAVE2M(s) ((s) - 1)
761: #define SHEAD_MASTER(sheadp) (((sheadp)->sh_flags & SH_MASTER) == 0 ? \
762: SHEAD_SLAVE2M (sheadp) : (sheadp))
763: #define SHEAD_OTHER(sheadp) (((sheadp)->sh_flags & SH_MASTER) == 0 ? \
764: SHEAD_SLAVE2M (sheadp) : \
765: SHEAD_M2SLAVE (sheadp))
766:
767: #define SHEAD_IS_PIPE(sheadp) ((sheadp)->sh_tab == NULL)
768:
769: #define SHEAD_HANGUP(sheadp) (((sheadp)->sh_flags & SH_HANGUP) != 0)
770:
771: #define SHEAD_READMSG(sheadp) (((sheadp)->sh_flags & SH_READMSG) != 0)
772:
773:
774: /*
775: * For working in with the abstract filesystem layer, we define a format for
776: * our opaque information.
777: */
778:
779: typedef struct {
780: shead_t * sheadp;
781: } scookie_t;
782:
783:
784:
785: __EXTERN_C_BEGIN__
786:
787: ssched_t * QSCHED_ALLOC __PROTO ((void));
788: void SSCHED_FREE __PROTO ((ssched_t * _sched));
789: int QSCHED_SCHEDULE __PROTO ((queue_t * _q, ssched_t * _sched));
790: void QSCHED_UNSCHEDULE
791: __PROTO ((queue_t * _q, ssched_t * _sched));
792: queue_t * QSCHED_GETFIRST __PROTO ((ssched_t * _sched));
793:
794: pl_t QFREEZE_TRACE __PROTO ((queue_t * _q,
795: __CONST__ char * _name));
796: void QFROZEN_TRACE __PROTO ((queue_t * _q,
797: __CONST__ char * _name));
798: void QUEUE_TRACE __PROTO ((queue_t * _q,
799: __CONST__ char * _name));
800: void QUNFREEZE_TRACE __PROTO ((queue_t * _q, pl_t _pl));
801:
802: void QUEUE_BACKENAB __PROTO ((queue_t * _q));
803: queue_t * QUEUE_NEXT __PROTO ((queue_t * _q));
804:
805: mblk_t * STRMEM_ALLOC __PROTO ((__size_t _size, int _pri,
806: int _flag));
807: void STRMEM_FREE __PROTO ((mblk_t * _bp, __size_t _size));
808:
809: mblk_t * MSGB_ALLOC __PROTO ((__size_t _size, int _pri,
810: int _flag));
811:
812: void SHEAD_WAKE __PROTO ((shead_t * _sheadp, cat_t _flag));
813: void SHEAD_SIGNAL __PROTO ((shead_t * _sheadp, uchar_t _sig));
814: int SHEAD_SRDOPT __PROTO ((shead_t * _sheadp, int _flag));
815: void QBAND_SETOPT __PROTO ((queue_t * _q,
816: struct stroptions * _so));
817:
818: qband_t * QUEUE_BAND __PROTO ((queue_t * _q, uchar_t _pri));
819: qband_t * QBAND_PREV __PROTO ((queue_t * _q, qband_t * _qbandp));
820:
821: void RUN_BUFCALLS __PROTO ((void));
822: void RUN_STREAMS __PROTO ((void));
823:
824: shead_t * SHEAD_FIND __PROTO ((n_dev_t _dev, slist_id_t _id));
825:
826: int STREAMS_OPEN __PROTO ((n_dev_t * _devp,
827: struct streamtab * _stabp,
828: int _mode, cred_t * _credp));
829: int STREAMS_CLOSE __PROTO ((shead_t * _sheadp, int _mode,
830: cred_t * _credp));
831:
832: int STREAMS_READ __PROTO ((shead_t * _sheadp, uio_t * _uiop));
833: int STREAMS_WRITE __PROTO ((shead_t * _sheadp, uio_t * _uiop));
834: int STREAMS_IOCTL __PROTO ((shead_t * _sheadp, int _cmd,
835: _VOID * _arg, int _mode,
836: cred_t * _credp, int * _rvalp));
837:
838: int STREAMS_CHPOLL __PROTO ((shead_t * _sheadp, short _events,
839: int _anyyet, short * _reventsp,
840: struct pollhead ** _phpp));
841:
842: int STREAMS_GETPMSG __PROTO ((shead_t * _sheadp,
843: struct strbuf * _ctlbuf,
844: struct strbuf * _databuf,
845: int * _bandp, int * _flagsp,
846: int _mode, int * _rvalp));
847: int STREAMS_PUTPMSG __PROTO ((shead_t * _sheadp,
848: struct strbuf * _ctlbuf,
849: struct strbuf * _databuf, int _band,
850: int _flags, int _mode,
851: int * _rvalp));
852:
853: __EXTERN_C_END__
854:
855:
856: /*
857: * This internal definition is the dual to QFREEZE_TRACE (), being the
858: * internal implementation of unfreezestr ().
859: */
860:
861: #define QUNFREEZE_TRACE(q,pl) SFREEZE_UNLOCK (q, pl)
862:
863:
864: /*
865: * Dealing with queue priority bands can be a little tricky; in particular,
866: * the definition of the linked-list structure of priority bands has some
867: * characteristics that may be unsuitable for some implementations.
868: * Specifically, the "qband" structure apparently is designed to function as
869: * a member of a singly-linked list rooted in the "queue" structure. This is
870: * flexible, but if there are several priority bands the time spent in
871: * dereferencing the link pointers might outweigh any extra cost involved in
872: * keeping the "band" structures in a vector [While the allocation cost is
873: * neglible in terms of time, there is a potentially high cost in terms of
874: * increasing the likelihood of a failure to allocate a band structure].
875: *
876: * The following internal functions have been defined to abstract away the
877: * details of how band structures are accessed from the queue, allowing a
878: * more time-efficient vector scheme to be used, or even a hybrid scheme
879: * where vectors are preferred but a linked-list fallback is available.
880: *
881: * The SVR4 DDI/DKI used to document the band structure, but that structure is
882: * no longer documented as of the SVR4 MP DDI/DKI.
883: */
884:
885: #define VECTOR_BANDS
886: #define VECTOR_BANDS_TEST /* test mode for VECTOR_BANDS */
887:
888: #ifdef VECTOR_BANDS
889:
890: #define QUEUE_BAND(q,pri) ((pri) > (q)->q_nband ? NULL : \
891: & (q)->q_bandp [pri - 1])
892:
893: #define QBAND_PREV(q,bandp) ((bandp) > (q)->q_bandp ? (bandp) - 1 : NULL)
894:
895: #endif /* defined (VECTOR_BANDS) */
896:
897:
898: #endif /* ! __KERNEL_STRMLIB_H__ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.