![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to strmlib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / streams / src|
Return to strmlib.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / conf / streams / src |
1.1 root 1: #define _DDI_DKI 1
2: #define _SYSV4 1
3:
4: /*
5: * This file contains the fundamental STREAMS routines defined in Appendix
6: * C of the STREAMS Programmer's Guide for System V Release 4. Note that
7: * additional information about the definition of these routines has been
8: * taken from the System V Release 4 Multi-Processor DDI/DKI For Intel CPU's.
9: *
10: * Later documents significantly redefine the semantics of many STREAMS
11: * routines. If there is a conflict, the normal System V Release 4 version
12: * is preferred, and the conflict is noted. However, where possible the later
13: * semantics have been incorporated or anticipated.
14: */
15:
16: /*
17: *-IMPORTS:
18: * <common/ccompat.h>
19: * __USE_PROTO__
20: * __ARGS ()
21: * <kernel/defer.h>
22: * defer_int_any ()
23: * <sys/debug.h>
24: * ASSERT ()
25: * <sys/types.h>
26: * uchar_t
27: * uint_t
28: * ushort_t
29: * toid_t
30: * <sys/kmem.h>
31: * KM_NOSLEEP
32: * kmem_alloc ()
33: * kmem_free ()
34: * <sys/cmn_err.h>
35: * CE_WARN
36: * cmn_err ()
37: * <sys/strlog.h>
38: * SL_ERROR
39: * SL_TRACE
40: * SL_CONSOLE
41: * SL_NOTIFY
42: * SL_FATAL
43: * SL_WARN
44: * SL_NOTE
45: * SL_LEVEL_MASK
46: * NLOGARGS
47: * struct log_ctl
48: * <sys/errno.h>
49: * EINVAL
50: * ENOMEM
51: * EPERM
52: * <stdarg.h>
53: * va_start ()
54: * va_arg ()
55: * va_end ()
56: * <string.h>
57: * memcpy ()
58: */
59:
60: #include <common/ccompat.h>
61: #include <kernel/defer.h>
62: #include <sys/debug.h>
63: #include <sys/types.h>
64: #include <sys/kmem.h>
65: #include <sys/cmn_err.h>
66: #include <sys/strlog.h>
67: #include <sys/errno.h>
68: #include <stdarg.h>
69: #include <string.h>
70:
71: #include <sys/stream.h>
72: #include <kernel/strmlib.h>
73:
74:
75: /*
76: * The pre-SVR4 STREAMS system used a marker bit to determine when putq () and
77: * putbq () should enable a queue. This flag, documented as QWANTR in the SVR4
78: * STREAMS documentation, is no longer sufficient to deal with scheduling with
79: * priority bands. The DDI/DKI and STREAMS documentation in SVR4 do not
80: * contain detailed new rules for dealing with exactly when a queue should be
81: * enabled automatically.
82: *
83: * The rules that we have adopted to deal with band flow control use our own
84: * member of the queue structure, "q_lastband". The idea is for getq () and
85: * rmvq () to record the band of the last message that was dequeued (or to
86: * set QWANTR), so that when a message in a higher band is queued the stream
87: * will be enabled to process it. If the last message retrieved is returned
88: * to the queue because of a flow-control blockage, putq () will see that the
89: * message is not a member of a higher band that the last read, and thus will
90: * know not to enable the queue.
91: */
92:
93:
94: /*
95: * Simple helper macro: is this message a priority message?
96: */
97:
98: #define IS_PRI_MSG(mp) pcmsg ((mp)->b_datap->db_type)
99:
100:
101: /*
102: * Simple realloc () function for memory allocated with kmem_alloc ()
103: * (assuming that it is our kmem_alloc (), that is).
104: */
105:
106: #if __USE_PROTO__
107: __LOCAL__ _VOID * (kmem_realloc) (_VOID * mem, size_t newsize, size_t oldsize)
108: #else
109: __LOCAL__ _VOID *
110: kmem_realloc __ARGS ((mem, newsize, oldsize))
111: _VOID * mem;
112: size_t newsize;
113: size_t oldsize;
114: #endif
115: {
116: pl_t prev_pl;
117:
118: ASSERT (mem != NULL && newsize > 0 && oldsize > 0);
119:
120: prev_pl = LOCK (str_mem->sm_other_lock, str_other_pl);
121:
122: mem = st_realloc (str_mem->sm_other_heap, mem, newsize, oldsize);
123:
124: OTHER_ALLOCED (newsize - oldsize);
125:
126: UNLOCK (str_mem->sm_other_lock, prev_pl);
127:
128: return mem;
129: }
130:
131:
132: /*
133: * This internal function actually implements the queue freezing; in addition,
134: * it asserts that the queue is non-NULL, traces who froze the queue, and
135: * so forth. If a queue monitoring facility is introduced, this would be the
136: * place to do it.
137: */
138:
139: #if __USE_PROTO__
140: pl_t (QFREEZE_TRACE) (queue_t * q, __CONST__ char * name)
141: #else
142: pl_t
143: QFREEZE_TRACE __ARGS ((q, name))
144: queue_t * q;
145: __CONST__ char * name;
146: #endif
147: {
148: if (q == NULL)
149: cmn_err (CE_PANIC, "NULL queue passed to STREAMS utility %s",
150: name);
151:
152: return SFREEZE_LOCK (q, name);
153: }
154:
155:
156: /*
157: * This internal function is similar to QFREEZE_TRACE (), but performs the
158: * assertions and tracing functions for routines that require that the queue
159: * already be frozen on entry.
160: */
161:
162: #if __USE_PROTO__
163: void (QFROZEN_TRACE) (queue_t * q, __CONST__ char * name)
164: #else
165: void
166: QFROZEN_TRACE __ARGS ((q, name))
167: queue_t * q;
168: __CONST__ char * name;
169: #endif
170: {
171: if (q == NULL)
172: cmn_err (CE_PANIC, "NULL queue passed to STREAMS utility %s",
173: name);
174:
175: SFREEZE_ASSERT_FROZEN (q);
176: }
177:
178:
179: /*
180: * This internal function is for utility routines that walk over various
181: * queues (and hence perform multiple freeze/unfreeze operations in local
182: * procedures such as QUEUE_NEXT).
183: */
184:
185: #if __USE_PROTO__
186: void (QUEUE_TRACE) (queue_t * q, __CONST__ char * name)
187: #else
188: void
189: QUEUE_TRACE __ARGS ((q, name))
190: queue_t * q;
191: __CONST__ char * name;
192: #endif
193: {
194: if (q == NULL)
195: cmn_err (CE_PANIC, "NULL queue passed to STREAMS utility %s",
196: name);
197: }
198:
199:
200: /*
201: * This internal function follows the singly-threaded lists of priority band
202: * structures to find the "pri"th priority band attached to the queue. It
203: * returns NULL if no such band has been allocated.
204: *
205: * The queue passed to this function must be frozen.
206: */
207:
208: #if ! defined (VECTOR_BANDS) || defined (VECTOR_BANDS_TEST)
209:
210: #if __USE_PROTO__
211: qband_t * (QUEUE_BAND) (queue_t * q, uchar_t pri)
212: #else
213: qband_t *
214: QUEUE_BAND __ARGS ((q, pri))
215: queue_t * q;
216: uchar_t pri;
217: #endif
218: {
219: qband_t * qbandp;
220: uchar_t count = pri;
221:
222:
223: ASSERT (pri > 0);
224: QFROZEN_TRACE (q, "QUEUE_BAND");
225:
226: /*
227: * Just iterate through the list of band structures.
228: */
229:
230: if ((qbandp = q->q_bandp) != NULL)
231: while (-- count > 0)
232: if ((qbandp = qbandp->qb_next) == NULL)
233: break;
234:
235: ASSERT (pri > q->q_nband ? qbandp == NULL : qbandp != NULL);
236:
237: #ifdef VECTOR_BANDS_TEST
238: /*
239: * For extra fun, we define a mode where we work everything out both
240: * ways to ensure correctness. The #undef makes all the later uses
241: * of the QUEUE_BAND name map to this function version so that the
242: * test gets included.
243: */
244:
245: ASSERT (qbandp == QUEUE_BAND (q, pri));
246: # undef QUEUE_BAND
247: #endif
248:
249: return qbandp;
250: }
251:
252:
253: /*
254: * This internal function gets the predecessor to a band structure from a
255: * queue, or NULL if there is no such predecessor.
256: *
257: * The definition of the "qband" structure was public from its introduction in
258: * SVR4, but was made private in the SVR4 MP release. We could reasonably
259: * change the definition of this structure to include a back-link, but for
260: * now we'll do it the hard way and stay with the structure as defined.
261: *
262: * The queue passed to this function must be frozen.
263: */
264:
265: #if __USE_PROTO__
266: qband_t * (QBAND_PREV) (queue_t * q, qband_t * qbandp)
267: #else
268: qband_t *
269: QBAND_PREV __ARGS ((q, qbandp))
270: queue_t * q;
271: qband_t * qbandp;
272: #endif
273: {
274: qband_t * scan;
275:
276: ASSERT (qbandp != NULL);
277: QFROZEN_TRACE (q, "QBAND_PREV");
278:
279: if ((scan = q->q_bandp) == qbandp)
280: return NULL;
281:
282: while (scan->qb_next != qbandp) {
283: scan = scan->qb_next;
284:
285: ASSERT (scan != NULL);
286: }
287:
288: #ifdef VECTOR_BANDS_TEST
289: ASSERT (scan == QBAND_PREV (q, qbandp));
290:
291: # undef QBAND_PREV
292: #endif
293:
294: return scan;
295: }
296:
297: #endif /* ! defined (VECTOR_BANDS) || defined (VECTOR_BANDS_TEST) */
298:
299:
300: /*
301: * This local function attempts to allocate new storage for a priority-band
302: * structure associated with a queue. Since for a given band "n", band
303: * structures 1 through "n-1" must also be present, this function may attempt
304: * to acquire several structures simultaneously.
305: *
306: * The caller must have the queue frozen.
307: */
308:
309: #if __USE_PROTO__
310: __LOCAL__ qband_t * (QBAND_ALLOC) (queue_t * q, uchar_t pri)
311: #else
312: __LOCAL__ qband_t *
313: QBAND_ALLOC __ARGS ((q, pri))
314: queue_t * q;
315: uchar_t pri;
316: #endif
317: {
318: qband_t * newband;
319: int nbands;
320:
321: QFROZEN_TRACE (q, "QBAND_ALLOC");
322: ASSERT (pri > 0);
323: ASSERT (pri > q->q_nband);
324:
325: /*
326: * We want to allocate band structures "q->q_nband + 1" ... "pri".
327: *
328: * Since the caller has the stream frozen, we want to do this fairly
329: * quickly, so we allocate the new structures as a vector. In order
330: * to speed up other operations, we may also try to reallocate any
331: * existing information so that the entire set of band structures is
332: * kept in a single block of memory.
333: */
334:
335: #ifdef VECTOR_BANDS
336: if (q->q_bandp != NULL) {
337: /*
338: * There are some existing band structures to be moved around
339: * (note that this will require that all the "qb_next"
340: * pointers be rethreaded).
341: */
342:
343: if ((newband = (qband_t *)
344: kmem_realloc (q->q_bandp, pri * sizeof (qband_t),
345: q->q_nband * sizeof (qband_t))) == NULL)
346: return NULL;
347:
348: q->q_bandp = newband;
349:
350: for (nbands = 0 ; nbands < q->q_nband ; newband ++, nbands ++)
351: newband->qb_next = newband + 1;
352:
353: /*
354: * Now we have rethreaded the relocated version of the old
355: * band structures, "newband" is set correctly to initialize
356: * the new band structures.
357: *
358: * We zero the remaining memory to ease initialization.
359: */
360:
361: memset (newband, 0, (pri - q->q_nband) * sizeof (qband_t));
362: } else
363: #endif
364:
365: if ((newband = (qband_t *)
366: kmem_zalloc ((pri - q->q_nband) * sizeof (qband_t),
367: KM_NOSLEEP)) == NULL)
368: return NULL;
369:
370: #ifndef VECTOR_BANDS
371: newband->qb_flag = QB_FIRST;
372:
373: /*
374: * Special-case update the "qb_next" pointer of the previously highest
375: * band.
376: */
377:
378: if (q->q_nbands > 0)
379: QUEUE_BAND (q, q->q_nbands)->qb_next = newband;
380: #endif
381:
382: /*
383: * Thread the "qb_next" pointers of the new structures together.
384: */
385:
386: for (nbands = q->q_nband ; nbands < pri - 1 ; newband ++, nbands ++)
387: newband->qb_next = newband + 1;
388:
389: return newband;
390: }
391:
392:
393: /*
394: * This internal function performs an atomic read of the "q_next" member of
395: * the queue passed to it, skipping over queues that are hidden from the
396: * STREAMS system.
397: *
398: * The queue passed to this function must be frozen. After this function, the
399: * passed queue is unfrozen and the returned queue is frozen (unless it is
400: * NULL).
401: *
402: * Note that this function illustrates a problem with using a fixed-hierarchy
403: * basic lock scheme; this code can't deadlock with itself because of the
404: * relationship expressed by the "q_next" member. Locks are only acquired in
405: * one direction along a stream axis, so each queue lock has an implicit
406: * hierarchy value lower that its successor.
407: */
408:
409: #if __USE_PROTO__
410: queue_t * (QUEUE_NEXT) (queue_t * q)
411: #else
412: queue_t *
413: QUEUE_NEXT __ARGS ((q))
414: queue_t * q;
415: #endif
416: {
417: QFROZEN_TRACE (q, "QUEUE_NEXT");
418:
419: do {
420: queue_t * next;
421:
422: if ((next = q->q_next) != NULL)
423: (void) QFREEZE_TRACE (next, "QUEUE_NEXT");
424:
425: QUNFREEZE_TRACE (q, plstr);
426:
427: q = next;
428: } while (q != NULL && (q->q_flag & QPROCSOFF) != 0);
429:
430: return q;
431: }
432:
433:
434: /*
435: * This internal function attempts to schedule a queue. It will fail if the
436: * queue has no service procedure or if the service procedure has been
437: * disabled. It will do nothing, but return success, if the queue is currently
438: * scheduled for service.
439: */
440:
441: #if __USE_PROTO__
442: __LOCAL__ int (QUEUE_TRYSCHED) (queue_t * q)
443: #else
444: __LOCAL__ int
445: QUEUE_TRYSCHED __ARGS ((q))
446: queue_t * q;
447: #endif
448: {
449: QFROZEN_TRACE (q, "QUEUE_TRYSCHED");
450:
451: if (q->q_qinfo->qi_srvp == NULL || (q->q_flag & QPROCSOFF) != 0)
452: return 0;
453:
454: if ((q->q_flag & QENAB) != 0 ||
455: QSCHED_SCHEDULE (q, str_mem->sm_sched) != 0)
456: return 1;
457:
458: /*
459: * Mark the queue as having been scheduled, and if the STREAMS service
460: * procedure scheduler has not been deferred, do so.
461: */
462:
463: q->q_flag |= QENAB;
464:
465: if (ATOMIC_FETCH_AND_STORE_UCHAR (ddi_global_data ()->dg_run_strsched,
466: 1) == 0)
467: defer_int_any (RUN_STREAMS);
468:
469: return 1;
470: }
471:
472:
473: /*
474: * QUEUE_BACKENAB () is an internal function used to unblock a queue which
475: * has been blocked by flow control. When a queue with a service procedure
476: * becomes full, and a queue "behind" it finds that it cannot put into it
477: * with bcanput (), bcanputnext (), canput (), or canputnext (), the target
478: * queue is marked so that this procedure will be called when it is ready to
479: * receive more data.
480: *
481: * Since the "behind" queue should have a service procedure (otherwise, the
482: * flow-control tests would have no point), we scan the queues behind the
483: * passed queue "q" and enable the first one which has a service procedure.
484: *
485: * The queue passed to this function must *not* be frozen. To avoid deadlock,
486: * a single function cannot hold both sides of a queue frozen; this is the
487: * only function in the STREAMS library that might plausibly want to do so.
488: *
489: * This function is normally called as a result of action in QBAND_REDUCE ()
490: * or QUEUE_REDUCE (), and under normal circumstances this would not cause an
491: * inconvenience. However, the action of rvmq () means that we use a condition
492: * in the "q_flags" member of the queue to indirectly schedule this function
493: * at a safe time. We only need to test the flag in a path that includes one
494: * of the above named functions or in user calls to unfreezestr ().
495: */
496:
497: #if __USE_PROTO__
498: void (QUEUE_BACKENAB) (queue_t * q)
499: #else
500: void
501: QUEUE_BACKENAB __ARGS ((q))
502: queue_t * q;
503: #endif
504: {
505: int done;
506: queue_t * other;
507: pl_t prev_pl;
508:
509: ASSERT (q != NULL);
510:
511: /*
512: * To walk backwards along the queue list, we must first move to the
513: * other kind of queue and walk along that, which effectively moves us
514: * in the reverse direction with respect to the original queue type.
515: */
516:
517: other = OTHERQ (q);
518:
519: prev_pl = QFREEZE_TRACE (other, "QUEUE_BACKENAB");
520:
521: do {
522: /*
523: * Atomically read the "q_next" member of the queue.
524: */
525:
526: if ((other = QUEUE_NEXT (other)) == NULL) {
527: /*
528: * Cannot search further.
529: */
530:
531: (void) splx (prev_pl);
532: break;
533: }
534:
535:
536: /*
537: * To avoid deadlock, we have to unfreeze "other" before we
538: * look at freezing its partner. We ensure that it won't go
539: * away on us after we unfreeze it by incrementing the
540: * "active" count.
541: */
542:
543: other->q_active ++;
544:
545: QUNFREEZE_TRACE (other, prev_pl);
546:
547:
548: /*
549: * We might be attempting to schedule an empty queue, which
550: * we should allow.
551: */
552:
553: q = OTHERQ (other);
554:
555: prev_pl = QFREEZE_TRACE (q, "QUEUE_BACKENAB");
556:
557: done = QUEUE_TRYSCHED (q);
558:
559: QUNFREEZE_TRACE (q, prev_pl);
560:
561:
562: /*
563: * Now we go back and remove our reference to the partner
564: * queue after relocking it.
565: */
566:
567: prev_pl = QFREEZE_TRACE (other, "QUEUE_BACKENAB");
568:
569: ASSERT (other->q_active > 0);
570:
571: other->q_active --;
572:
573: if ((q->q_flag & QPROCSOFF) != 0 && q->q_active == 0) {
574: /*
575: * Time to wake up the sleepers waiting for the put
576: * and service routines on a queue to exit. See
577: * qprocsoff () for a discussion of the locking
578: * protocol.
579: */
580:
581: (void) LOCK (str_mem->sm_proc_lock, plstr);
582: SV_BROADCAST (str_mem->sm_proc_sv, 0);
583: UNLOCK (str_mem->sm_proc_lock, plstr);
584: }
585: } while (! done);
586:
587: QUNFREEZE_TRACE (other, prev_pl);
588: }
589:
590:
591: /*
592: * This local function is called whenever a queue's last message has been
593: * dequeued, and will wake up any function waiting for the queue to drain.
594: *
595: * The caller must have the stream frozen.
596: */
597:
598: #if __USE_PROTO__
599: __LOCAL__ void (QUEUE_DRAINED) (queue_t * q)
600: #else
601: __LOCAL__ void
602: QUEUE_DRAINED __ARGS ((q))
603: queue_t * q;
604: #endif
605: {
606: pl_t prev_pl;
607:
608: QFROZEN_TRACE (q, "QUEUE_DRAINED");
609:
610: if ((q->q_flag & QDRAIN) != 0) {
611: shead_t * sheadp;
612:
613: /*
614: * Under normal circumstances, a call to SV_BROADCAST () would
615: * be all we needed to do. However, since we allow ourself to
616: * use a more primitive kind of lock that a basic lock to
617: * implement freezing a queue, the process that waits for us
618: * to drain cannot use the frozen queue as the lock to pass to
619: * SV_WAIT (). By making us wait for the lock, we make
620: * the wakeup multiprocessor-safe; otherwise, we might be able
621: * to try and wake the process before it has actually slept,
622: * causing infinite sleep.
623: *
624: * Since the synchronization variable we are going to
625: * broadcast to is part of the stream head, we ensure that
626: * this code is only executed for the module or driver which
627: * is immediately below the stream head, or the stream head
628: * write queue itself.
629: */
630:
631: ASSERT (RD (q)->q_next == NULL ||
632: RD (q)->q_next->q_next == NULL);
633:
634: sheadp = (shead_t *)
635: (RD (q)->q_next == NULL ? q->q_ptr :
636: RD (q)->q_next->q_ptr);
637:
638: prev_pl = SHEAD_LOCK (sheadp);
639:
640: SV_BROADCAST (sheadp->sh_wait_sv, 0);
641:
642: q->q_flag &= ~ QDRAIN;
643:
644: SHEAD_UNLOCK (sheadp, prev_pl);
645: }
646: }
647:
648:
649: /*
650: * This local function updates the flow-control information for a priority
651: * band when the band current level is increasing.
652: *
653: * The queue passed to this function must be frozen.
654: */
655:
656: #if __USE_PROTO__
657: __LOCAL__ void (QBAND_INCREASE) (queue_t * q, qband_t * qbandp, ulong_t adjust)
658: #else
659: __LOCAL__ void
660: QBAND_INCREASE __ARGS ((q, qbandp, adjust))
661: queue_t * q;
662: qband_t * qbandp;
663: ulong_t adjust;
664: #endif
665: {
666: ASSERT (qbandp != NULL);
667: QFROZEN_TRACE (q, "QBAND_INCREASE");
668:
669: /*
670: * If the band we are dealing with is already flow-controlled, just
671: * get out of here.
672: */
673:
674: qbandp->qb_count += adjust;
675:
676: if ((qbandp->qb_flag & QB_FULL) != 0)
677: return;
678:
679: /*
680: * If we are over the high-water mark, then we must mark ourself and
681: * all the bands below us (including the normal messages) as full as
682: * well.
683: */
684:
685: if (qbandp->qb_count >= qbandp->qb_hiwat) {
686:
687: do
688: qbandp->qb_flag |= QB_FULL;
689: while ((qbandp = QBAND_PREV (q, qbandp)) != NULL);
690:
691:
692: /*
693: * According to the way I read the STREAMS
694: * programmer's guide, band flow control
695: * should affect normal messages as well (ie,
696: * as if they are band 0).
697: *
698: * We deal with this as a special case.
699: */
700:
701: if (q->q_count >= q->q_hiwat)
702: q->q_flag |= QFULL;
703: }
704: }
705:
706:
707: /*
708: * This local function updates the flow-control information for a priority
709: * band when the band current level is decreasing.
710: *
711: * The queue passed to this function must be frozen.
712: */
713:
714: #if __USE_PROTO__
715: __LOCAL__ void (QBAND_REDUCE) (queue_t * q, qband_t * qbandp, ulong_t adjust)
716: #else
717: __LOCAL__ void
718: QBAND_REDUCE __ARGS ((q, qbandp, adjust))
719: queue_t * q;
720: qband_t * qbandp;
721: ulong_t adjust;
722: #endif
723: {
724:
725: ASSERT (qbandp != NULL);
726: ASSERT (qbandp->qb_count >= adjust);
727: QFROZEN_TRACE (q, "QBAND_REDUCE");
728:
729: /*
730: * If this band wasn't flow-controlled anyway, then we don't need to
731: * do anything other than adjust the count.
732: */
733:
734: qbandp->qb_count -= adjust;
735:
736: if ((qbandp->qb_flag & QB_FULL) == 0)
737: return;
738:
739:
740: /*
741: * If we are under the low-water mark, then we can release any pending
742: * writes to this band and our hold on lower bands if and only if the
743: * bands above us are not controlled.
744: *
745: * We can test the bands above us in one step since we require that a
746: * band which has become full also mark all lower bands as full. If
747: * our immediate upper neighbour is full then we cannot proceed.
748: */
749:
750: if (qbandp->qb_count <= qbandp->qb_lowat &&
751: (qbandp->qb_next == NULL ||
752: (qbandp->qb_next->qb_flag & QB_FULL) == 0)) {
753:
754: /*
755: * We release lower bands as long as they are under their low-
756: * water marks. It seems pointless to resume bands that are
757: * too close to entering a controlled state anyway.
758: */
759:
760: do {
761: qbandp->qb_flag &= ~ QB_FULL;
762:
763: if ((qbandp->qb_flag & QB_WANTW) != 0) {
764: /*
765: * Propagate a back-enable request to the
766: * queue.
767: */
768:
769: qbandp->qb_flag &= ~ QB_WANTW;
770: q->q_flag |= QBACK;
771: }
772:
773: if ((qbandp = QBAND_PREV (q, qbandp)) == NULL) {
774: /*
775: * According to the way I read the STREAMS
776: * programmer's guide, band flow control
777: * should affect normal messages as well (ie,
778: * as if they are band 0).
779: *
780: * We deal with this as a special case.
781: */
782:
783: if (q->q_count <= q->q_lowat) {
784: q->q_flag &= ~ QFULL;
785:
786: if ((q->q_flag & QWANTW) != 0) {
787:
788: q->q_flag &= ~ QWANTW;
789: q->q_flag |= QBACK;
790: }
791: }
792:
793: break;
794: }
795: } while (qbandp->qb_count <= qbandp->qb_lowat);
796: }
797: }
798:
799:
800: /*
801: * This local function factors out the computation of the total number of
802: * data bytes in a message from the routines that manipulate flow-control
803: * parameters. Since this is often the only loop in such routines, factoring
804: * this out might help inlining in some cases.
805: */
806:
807: #if __USE_PROTO__
808: __LOCAL__ ulong_t (MSG_SIZE) (mblk_t * mp)
809: #else
810: __LOCAL__ ulong_t
811: MSG_SIZE __ARGS ((mp))
812: mblk_t * mp;
813: #endif
814: {
815: ulong_t total = 0;
816:
817: ASSERT (mp != NULL);
818:
819: do
820: total += mp->b_wptr - mp->b_rptr;
821: while ((mp = mp->b_cont) != NULL);
822:
823: return total;
824: }
825:
826:
827: /*
828: * This internal function wraps up the check for whether a newly queued
829: * message is of sufficient priority to cause the queue to be enabled.
830: *
831: * The queue passed to this function must be frozen.
832: */
833:
834: #if __USE_PROTO__
835: __LOCAL__ int (QUEUE_CHECK_SCHED) (queue_t * q, mblk_t * mp,
836: qband_t * qbandp)
837: #else
838: __LOCAL__ int
839: QUEUE_CHECK_SCHED __ARGS ((q, mp, qbandp))
840: queue_t * q;
841: mblk_t * mp;
842: qband_t * qbandp;
843: #endif
844: {
845: ulong_t msgsize;
846:
847: QFROZEN_TRACE (q, "QUEUE_CHECK_SCHED");
848:
849: if ((q->q_flag & QNOENB) == 0 &&
850: ((q->q_flag & QWANTR) != 0 || q->q_lastband < mp->b_band)) {
851: /*
852: * The new message is part of a higher-priority band than the
853: * last message that was retrieved, so we need to enable the
854: * queue.
855: */
856:
857: q->q_lastband = mp->b_band;
858: (void) QUEUE_TRYSCHED (q);
859: }
860:
861:
862: /*
863: * As a convenience to the callers, all of whom are queueing the new
864: * message, update the flow control parameters.
865: */
866:
867: msgsize = MSG_SIZE (mp);
868:
869: if (mp->b_band > 0) {
870:
871: ASSERT (qbandp != NULL);
872:
873: QBAND_INCREASE (q, qbandp, msgsize);
874:
875: return 1;
876: } else {
877: /*
878: * Just deal with the base flow-control stuff.
879: */
880:
881: if ((q->q_count += msgsize) > q->q_hiwat)
882: q->q_flag |= QFULL;
883:
884: return 0;
885: }
886: }
887:
888:
889: /*
890: * This internal function collects the details of dequeuing a message from
891: * a priority-band structure.
892: *
893: * The queue on which "mp" was queued must be frozen.
894: */
895:
896: #if __USE_PROTO__
897: __LOCAL__ void (QBAND_DEQUEUE) (qband_t * qbandp, mblk_t * mp)
898: #else
899: __LOCAL__ void
900: QBAND_DEQUEUE __ARGS ((qbandp, mp))
901: qband_t * qbandp;
902: mblk_t * mp;
903: #endif
904: {
905: ASSERT (qbandp != NULL);
906: ASSERT (mp != NULL);
907: ASSERT (mp->b_band > 0);
908:
909: if (qbandp->qb_first == mp) {
910:
911: if (qbandp->qb_last == mp) {
912: /*
913: * The band has become empty.
914: */
915:
916: ASSERT (mp->b_next == NULL ||
917: mp->b_next->b_band < mp->b_band);
918:
919: qbandp->qb_last = qbandp->qb_first = NULL;
920: } else {
921: /*
922: * There is more data in the band.
923: */
924:
925: ASSERT (mp->b_next != NULL);
926: ASSERT (mp->b_next->b_band == mp->b_band);
927:
928: qbandp->qb_first = mp->b_next;
929: }
930: } else if (qbandp->qb_last == mp) {
931: /*
932: * The band is non-empty, but we have to move the end up.
933: */
934:
935: ASSERT (mp->b_prev != NULL);
936: ASSERT (mp->b_prev->b_band == mp->b_band);
937:
938: qbandp->qb_last = mp->b_prev;
939: }
940: }
941:
942:
943: /*
944: * This internal function tests to see whether a stream wanting to write to
945: * this queue should block to honour the flow-control scheme. The return
946: * value is 1 if the caller can write to this queue, 0 otherwise.
947: *
948: * The queue passed to this function must be frozen.
949: */
950:
951: #if __USE_PROTO__
952: __LOCAL__ int (QBAND_CANPUT) (queue_t * q, uchar_t pri)
953: #else
954: __LOCAL__ int
955: QBAND_CANPUT __ARGS ((q, pri))
956: queue_t * q;
957: uchar_t pri;
958: #endif
959: {
960: qband_t * qbandp;
961:
962: QFROZEN_TRACE (q, "QBAND_CANPUT");
963:
964: if (pri > 0) {
965:
966: qbandp = QUEUE_BAND (q, pri);
967:
968: if (qbandp != NULL && (qbandp->qb_flag & QB_FULL) != 0) {
969: /*
970: * We must set the following flag to indicate that
971: * back-enabling is desired for this priority band.
972: *
973: * We'll set the global QWANTW flag as well, to make
974: * testing simpler for qprocson ().
975: */
976:
977: qbandp->qb_flag |= QB_WANTW;
978: q->q_flag |= QWANTW;
979: return 0;
980: }
981: } else
982: if ((q->q_flag & QFULL) != 0) {
983: /*
984: * We must set the following flag to indicate that the
985: * queue has a writer who has made a failed write
986: * attempt.
987: */
988:
989: q->q_flag |= QWANTW;
990: return 0;
991: }
992:
993: return 1;
994: }
995:
996:
997: /*
998: * This internal function collects the non-priority-band flow-control actions
999: * from flushq () and getq ().
1000: *
1001: * The queue passed to this function must be frozen.
1002: */
1003:
1004: #if __USE_PROTO__
1005: __LOCAL__ void (QUEUE_REDUCE) (queue_t * q, ulong_t adjust)
1006: #else
1007: __LOCAL__ void
1008: QUEUE_REDUCE __ARGS ((q, adjust))
1009: queue_t * q;
1010: ulong_t adjust;
1011: #endif
1012: {
1013: QFROZEN_TRACE (q, "QUEUE_REDUCE");
1014:
1015: ASSERT (q->q_count >= adjust);
1016:
1017: /*
1018: * If the queue was not previously full, then we don't need to do
1019: * anything other than tweak the count.
1020: */
1021:
1022: q->q_count -= adjust;
1023:
1024: if ((q->q_flag & QFULL) != 0 && q->q_count <= q->q_lowat) {
1025:
1026: q->q_flag &= ~ QFULL;
1027:
1028: if ((q->q_flag & QWANTW) != 0) {
1029:
1030: q->q_flag &= ~ QWANTW;
1031: q->q_flag |= QBACK;
1032: }
1033: }
1034: }
1035:
1036:
1037: /*
1038: * This function contains part of the M_SETOPTS processing; specifically, here
1039: * we deal with changing the watermarks of a band. The caller should test the
1040: * QBACK flag when unfreezing the stream.
1041: */
1042:
1043: #if __USE_PROTO__
1044: void (QBAND_SETOPT) (queue_t * q, struct stroptions * so)
1045: #else
1046: void
1047: QBAND_SETOPT __ARGS ((q, so))
1048: queue_t * q;
1049: struct stroptions
1050: * so;
1051: #endif
1052: {
1053: qband_t * qbandp;
1054: pl_t prev_pl;
1055:
1056: prev_pl = QFREEZE_TRACE (q, "QBAND_SETOPTS");
1057:
1058: if ((so->so_flags & (SO_LOWAT | SO_HIWAT)) == 0)
1059: return;
1060:
1061: if ((so->so_flags & SO_BAND) != 0 && so->so_band > 0) {
1062:
1063: if ((qbandp = QUEUE_BAND (q, so->so_band)) == NULL &&
1064: (qbandp = QBAND_ALLOC (q, so->so_band)) == NULL) {
1065: /*
1066: * We cannot allocate space for the band accounting
1067: * structures. Give up.
1068: */
1069:
1070: QUNFREEZE_TRACE (q, prev_pl);
1071: return;
1072: }
1073:
1074: if ((so->so_flags & SO_LOWAT) != 0) {
1075:
1076: qbandp->qb_lowat = so->so_lowat;
1077: QBAND_REDUCE (q, qbandp, 0L);
1078: }
1079:
1080: if ((so->so_flags & SO_HIWAT) != 0) {
1081:
1082: qbandp->qb_hiwat = so->so_hiwat;
1083: QBAND_INCREASE (q, qbandp, 0L);
1084: }
1085: } else {
1086:
1087: if ((so->so_flags & SO_LOWAT) != 0) {
1088:
1089: q->q_lowat = so->so_lowat;
1090: QUEUE_REDUCE (q, 0L);
1091: }
1092:
1093: if ((so->so_flags & SO_HIWAT) != 0) {
1094:
1095: q->q_hiwat = so->so_hiwat;
1096: if (q->q_count > q->q_hiwat)
1097: q->q_flag |= QFULL;
1098: }
1099: }
1100:
1101:
1102: /*
1103: * Since we are in a path with QBAND_REDUCE (), check for QBACK before
1104: * unfreezing the stream.
1105: */
1106:
1107: {
1108: unsigned long back;
1109:
1110: if ((back = q->q_flag & QBACK) != 0)
1111: q->q_flag &= ~ QBACK;
1112:
1113: QUNFREEZE_TRACE (q, prev_pl);
1114:
1115: if (back)
1116: QUEUE_BACKENAB (q);
1117: }
1118: }
1119:
1120:
1121: /*
1122: * This internal function is used by bufcall () and esbbcall () to queue a
1123: * STREAMS event cell on the queue for eventual processing once memory
1124: * becomes available.
1125: */
1126:
1127: #if __USE_PROTO__
1128: __LOCAL__ toid_t (STORE_EVENT) (sevent_t * seventp, int pri)
1129: #else
1130: __LOCAL__ toid_t
1131: STORE_EVENT __ARGS ((seventp, pri))
1132: sevent_t * seventp;
1133: int pri;
1134: #endif
1135: {
1136: pl_t prev_pl;
1137: selist_t * selistp;
1138: sevent_t * sprev;
1139:
1140: /*
1141: * Let's lock the list that we are going to thread the new event on.
1142: */
1143:
1144: selistp = & str_mem->sm_bcevents [MAP_PRI_LEVEL (pri)];
1145:
1146: prev_pl = SELIST_LOCK (selistp);
1147:
1148:
1149: #if _TOID_MEMBER
1150: /*
1151: * Before we perform the insertion of the event cell, we use the above
1152: * lock to make our ID code generation multiprocessor-safe.
1153: */
1154:
1155: selistp->sl_id = (((seventp->se_id = selistp->sl_id) +
1156: TOID_INCREMENT) % TOID_MODULUS);
1157:
1158: ASSERT (seventp->se_id != 0);
1159: ASSERT (TOID_TO_PRI (seventp->se_id) == pri);
1160: #endif
1161:
1162: /*
1163: * RESEARCH NOTE: There doesn't seem to be any compelling reason to
1164: * choose a particular policy for managing event cells. Try getting
1165: * some data of performance effects for low->high, high->low and FIFO
1166: * queueing.
1167: */
1168: #if _FIFO_BUFCALL
1169: /*
1170: * FIFO queueing is nice and simple.
1171: */
1172:
1173: if ((sprev = selistp->sl_tail) == NULL) {
1174:
1175: ASSERT (selistp->sl_head == NULL);
1176:
1177: selistp->sl_head = selistp->sl_tail = seventp;
1178: seventp->se_prev = seventp->se_next = NULL;
1179: } else {
1180:
1181: sprev->se_next = seventp;
1182: seventp->se_prev = sprev;
1183: seventp->se_next = NULL;
1184: selistp->sl_tail = seventp;
1185: }
1186: #else
1187: /*
1188: * Now insert the event cell in the event list, keeping it sorted from
1189: * low size to high size.
1190: */
1191:
1192: {
1193: sevent_t * sscan;
1194:
1195: for (sscan = selistp->sl_head, sprev = NULL ; sscan != NULL ;
1196: sscan = (sprev = sscan)->se_next) {
1197:
1198: if (sscan->se_size > seventp->se_size)
1199: break;
1200: }
1201:
1202: if (sprev == NULL)
1203: selistp->sl_head = seventp;
1204: else
1205: sprev->se_next = seventp;
1206:
1207: if (sscan != NULL)
1208: sscan->se_prev = seventp;
1209:
1210: seventp->se_prev = sprev;
1211: seventp->se_next = sscan;
1212: }
1213: #endif
1214:
1215: SELIST_UNLOCK (selistp, prev_pl);
1216:
1217: #if _TOID_MEMBER
1218: return seventp->se_id;
1219: #endif
1220: }
1221:
1222:
1223: /*
1224: * This local function factors out the common code in put () and
1225: * QUEUE_PUTNEXT () [used to implement the putnext (), putnextctl () and
1226: * similar functions].
1227: *
1228: * The queue must be frozen on entry to this function.
1229: */
1230:
1231: #if __USE_PROTO__
1232: __LOCAL__ void (QUEUE_PUT) (queue_t * q, mblk_t * mp, pl_t prev_pl)
1233: #else
1234: __LOCAL__ void
1235: QUEUE_PUT __ARGS ((q, mp, prev_pl))
1236: queue_t * q;
1237: mblk_t * mp;
1238: pl_t prev_pl;
1239: #endif
1240: {
1241: QFROZEN_TRACE (q, "QUEUE_PUT");
1242:
1243: q->q_active ++;
1244:
1245: if (q->q_qinfo->qi_mstat != NULL)
1246: q->q_qinfo->qi_mstat->ms_pcnt ++;
1247:
1248: QUNFREEZE_TRACE (q, prev_pl);
1249:
1250:
1251: (* q->q_qinfo->qi_putp) (q, mp);
1252:
1253:
1254: (void) QFREEZE_TRACE (q, "QUEUE_PUT");
1255:
1256: q->q_active --;
1257:
1258: if ((q->q_flag & QPROCSOFF) != 0 && q->q_active == 0) {
1259: /*
1260: * Time to wake up the sleepers waiting for the put and
1261: * service routines on a queue to exit. See qprocsoff () for
1262: * a discussion of the locking protocol.
1263: */
1264:
1265: (void) LOCK (str_mem->sm_proc_lock, plstr);
1266: SV_BROADCAST (str_mem->sm_proc_sv, 0);
1267: UNLOCK (str_mem->sm_proc_lock, plstr);
1268: }
1269: }
1270:
1271:
1272: /*
1273: * This local function factors out most of the interesting part of putnext ()
1274: * into a common block that can be called from any of the related group of
1275: * functions putnext (), putnextctl (), putnextctl1 (), and qreply ().
1276: */
1277:
1278: #if __USE_PROTO__
1279: __LOCAL__ void (QUEUE_PUTNEXT) (queue_t * q, mblk_t * mp)
1280: #else
1281: __LOCAL__ void
1282: QUEUE_PUTNEXT __ARGS ((q, mp))
1283: queue_t * q;
1284: mblk_t * mp;
1285: #endif
1286: {
1287: pl_t prev_pl;
1288:
1289: /*
1290: * We call QUEUE_NEXT () to find the next queue on the stream that has
1291: * not been disabled via qprocsoff (). It may be that there is no
1292: * such queue. This can happen on a uniprocessor or multiprocessor if
1293: * a device's interrupt routine begins generating data before the
1294: * queue open () entry point has issued qprocson (). Since this is
1295: * really an error, we complain about it.
1296: */
1297:
1298: prev_pl = QFREEZE_TRACE (q, "QUEUE_PUTNEXT");
1299:
1300: q = QUEUE_NEXT (q);
1301:
1302: if (q != NULL) {
1303: /*
1304: * We have found a queue we are allowed to put to.
1305: */
1306:
1307: QUEUE_PUT (q, mp, prev_pl);
1308: } else {
1309: /*
1310: * We have run off the end of the stream... we can
1311: * either wait, put the message anyway, or discard
1312: * the message. Either way, a warning is appropriate.
1313: */
1314:
1315: cmn_err (CE_WARN, "putnext () ran off end of stream");
1316: freemsg (mp);
1317: }
1318:
1319: QUNFREEZE_TRACE (q, prev_pl);
1320: }
1321:
1322:
1323: /*
1324: * This internal function is similar in spirit to QUEUE_PUTNEXT (), above, but
1325: * instead factors out the process of looking for a queue with a service
1326: * procedure that can be enabled from the bcanputnext () and canputnext ()
1327: * routines.
1328: *
1329: * Determines whether the caller can legitimately put downstream in the
1330: * indicated priority band.
1331: *
1332: * The queue passed to this function cannot be frozen.
1333: */
1334:
1335: #if __USE_PROTO__
1336: __LOCAL__ int (QBAND_SRVNEXT) (queue_t * q, uchar_t pri)
1337: #else
1338: __LOCAL__ int
1339: QBAND_SRVNEXT __ARGS ((q, pri))
1340: queue_t * q;
1341: uchar_t pri;
1342: #endif
1343: {
1344: int retval;
1345: pl_t prev_pl;
1346:
1347: /*
1348: * Scan through the stream for a queue with a service procedure that
1349: * we can enable.
1350: */
1351:
1352: prev_pl = QFREEZE_TRACE (q, "QBAND_SRVNEXT");
1353:
1354: for (;;) {
1355:
1356: q = QUEUE_NEXT (q);
1357:
1358: if (q == NULL) {
1359: /*
1360: * We have run off the end of the stream, so return
1361: * true to the caller.
1362: */
1363:
1364: retval = 1;
1365: break;
1366:
1367: } else if (q->q_qinfo->qi_srvp != NULL) {
1368:
1369: retval = QBAND_CANPUT (q, pri);
1370: break;
1371: }
1372:
1373: /*
1374: * No service procedure, try next queue in line.
1375: */
1376: }
1377:
1378: QUNFREEZE_TRACE (q, prev_pl);
1379:
1380:
1381: /*
1382: * If there are no queues with service procedures, the caller is
1383: * allowed to put by default; the special case above is an exception.
1384: */
1385:
1386: return retval;
1387: }
1388:
1389:
1390: /*
1391: * This function deals with allocating and initializing a message block from
1392: * the message memory; unlike allocb (), an extra parameter can be used to
1393: * cause this function to block if there is insufficient memory available to
1394: * satisfy the request immediately.
1395: */
1396:
1397: #if __USE_PROTO__
1398: mblk_t * (MSGB_ALLOC) (size_t size, int pri, int flag)
1399: #else
1400: mblk_t *
1401: MSGB_ALLOC __ARGS ((size, pri, flag))
1402: size_t size;
1403: int pri;
1404: int flag;
1405: #endif
1406: {
1407: mblk_t * mblkp;
1408:
1409: ASSERT (flag == KM_SLEEP || flag == KM_NOSLEEP);
1410: ASSERT (pri == BPRI_LO || pri == BPRI_MED || pri == BPRI_HI);
1411:
1412: if ((mblkp = STRMEM_ALLOC (MSGB_SIZE (size), pri, flag)) != NULL) {
1413: /*
1414: * Note that we don't bother setting up the b_prev and
1415: * b_next members of the message block.
1416: */
1417:
1418: mblkp->b_cont = NULL;
1419: mblkp->b_datap = MB_TO_DB (mblkp);
1420: mblkp->b_rptr = DB_TO_DATA (mblkp->b_datap);
1421: mblkp->b_wptr = mblkp->b_rptr;
1422:
1423: /*
1424: * We specially flag this message block as part of
1425: * a triple. While there are other ways we could test
1426: * this, for now we permit the possibility that a
1427: * client might change the attachments of data blocks
1428: * and message blocks perversely.
1429: */
1430:
1431: mblkp->b_flag = MSGTRIPLE;
1432: mblkp->b_band = 0;
1433:
1434: mblkp->b_datap->db_base = mblkp->b_rptr;
1435: mblkp->b_datap->db_lim = mblkp->b_rptr + size;
1436: mblkp->b_datap->db_type = M_DATA;
1437: mblkp->b_datap->db_ref = 1;
1438:
1439: mblkp->b_datap->db_frtnp = NULL;
1440: }
1441:
1442: return mblkp;
1443: }
1444:
1445:
1446: /*
1447: * This local helper function factors out some code in strlog () common to
1448: * building the "struct log_ctl" headers for the log messages.
1449: */
1450:
1451: #if __USE_PROTO__
1452: __LOCAL__ mblk_t * (STRLOG_MAKE) (short mid, short sid, char level,
1453: ushort_t flags, ulong_t seq, ushort_t whoami,
1454: int * copies, int * failures, mblk_t * data)
1455: #else
1456: __LOCAL__ mblk_t *
1457: STRLOG_MAKE __ARGS ((mid, sid, level, flags, seq, whoami, copies, failures, data))
1458: short mid;
1459: short sid;
1460: char level;
1461: ushort_t flags;
1462: ulong_t seq;
1463: ushort_t whoami;
1464: int * copies;
1465: int * failures;
1466: mblk_t * data;
1467: #endif
1468: {
1469: mblk_t * ctl;
1470: struct log_ctl * lcp;
1471: int alloc_pri;
1472: int log_pri;
1473:
1474: if ((flags & whoami) == 0)
1475: return NULL;
1476:
1477: /*
1478: * Work out an allocation priority for the M_PROTO message block that
1479: * will contain the "log_ctl" description structure, and also
1480: * work out a priority for the "mwc_pri" member of the "log_ctl"
1481: * structure.
1482: *
1483: * This code is pretty funky; the real rules might be much simpler,
1484: * but this is what I get from the docs. The "log_pri" rules go from
1485: * low to high priority, so this code should match the order defined
1486: * for the
1487: */
1488:
1489: if (whoami == SL_ERROR || (flags & SL_FATAL) != 0)
1490: alloc_pri = BPRI_HI;
1491: else if ((flags & SL_WARN) != 0)
1492: alloc_pri = BPRI_MED;
1493: else
1494: alloc_pri = BPRI_LO;
1495:
1496:
1497: /*
1498: * if (whoami == SL_CONSOLE)
1499: */
1500: log_pri = LOG_INFO;
1501:
1502: if ((flags & SL_NOTE) != 0)
1503: log_pri = LOG_NOTICE;
1504:
1505: if (whoami == SL_TRACE)
1506: log_pri = LOG_DEBUG;
1507:
1508: if ((flags & SL_WARN) != 0)
1509: log_pri = LOG_WARNING;
1510:
1511: if (whoami == SL_ERROR)
1512: log_pri = LOG_ERR;
1513:
1514: if ((flags & SL_FATAL) != 0)
1515: log_pri = LOG_CRIT;
1516:
1517:
1518: /*
1519: * Allocate the necessary structures and fill them in.
1520: */
1521:
1522: if ((ctl = MSGB_ALLOC (sizeof (struct log_ctl), alloc_pri,
1523: KM_NOSLEEP)) == NULL) {
1524:
1525: (* failures) ++;
1526: return NULL; /* return failure */
1527: }
1528:
1529: if (* copies == 0)
1530: ctl->b_cont = data;
1531: else if ((ctl->b_cont = dupb (data)) == NULL) {
1532:
1533: freeb (ctl);
1534:
1535: (* failures) ++;
1536: return NULL;
1537: }
1538:
1539: (* copies) ++;
1540:
1541: ctl->b_datap->db_type = M_PROTO;
1542: lcp = (struct log_ctl *) ctl->b_rptr;
1543: ctl->b_wptr = (uchar_t *) (lcp + 1);
1544:
1545: lcp->mwc_mid = mid;
1546: lcp->mwc_sid = sid;
1547: lcp->level = level;
1548: lcp->flags = flags;
1549: lcp->mwc_seqno = seq;
1550: lcp->mwc_pri = log_pri | LOG_KERN;
1551:
1552: return ctl;
1553: }
1554:
1555:
1556: /*
1557: * This function factors out common code from putbq () and putq () for finding
1558: * the insertion point for a message. The original routines differed only in
1559: * whether the search was for the end of a band or the front of a band. By
1560: * passing in an appropriately adjusted band parameter, the same code can be
1561: * made to do double duty.
1562: *
1563: * The queue passed to this function must be frozen.
1564: */
1565:
1566: #if __USE_PROTO__
1567: __LOCAL__ void (QUEUE_PLACE_MSG) (queue_t * q, mblk_t * mp, uchar_t band)
1568: #else
1569: __LOCAL__ void
1570: QUEUE_PLACE_MSG __ARGS ((q, mp, band))
1571: queue_t * q;
1572: mblk_t * mp;
1573: uchar_t band;
1574: #endif
1575: {
1576: mblk_t * scan;
1577:
1578: /*
1579: * The first stage is to skip over all the high-priority messages, and \
1580: * then to find the right band location.
1581: */
1582:
1583: for (scan = q->q_first ; scan != NULL ; scan = scan->b_next)
1584: if (! IS_PRI_MSG (scan))
1585: break;
1586:
1587: while (scan != NULL && scan->b_band > band)
1588: scan = scan->b_next;
1589:
1590: /*
1591: * Now we know where the message goes, do it.
1592: */
1593:
1594: if ((mp->b_next = scan) == NULL) {
1595:
1596: if ((mp->b_prev = q->q_last) == NULL)
1597: q->q_first = mp;
1598: else
1599: mp->b_prev->b_next = mp;
1600:
1601: q->q_last = mp;
1602: } else {
1603:
1604: if ((mp->b_prev = scan->b_prev) == NULL)
1605: q->q_first = mp;
1606: else
1607: mp->b_prev->b_next = mp;
1608:
1609: scan->b_prev = mp;
1610: }
1611: }
1612:
1613:
1614: /*
1615: *-STATUS:
1616: * DDI/DKI
1617: *
1618: *-NAME:
1619: * adjmsg Trim bytes from a message
1620: *
1621: *-SYNOPSIS:
1622: * #include <sys/streams.h>
1623: *
1624: * int adjmsg (mblk_t * mp, int len);
1625: *
1626: *-ARGUMENTS:
1627: * mp Pointer to the message to be trimmed.
1628: *
1629: * len The number of bytes to be removed.
1630: *
1631: *-DESCRIPTION:
1632: * adjmsg () removes bytes from a message. |"len"| (the absolute value of
1633: * "len") specifies the how many bytes are to be removed. If "len" is
1634: * greater than 0, bytes are removed from the head of the message. If
1635: * "len" is less than 0, bytes are removed from the tail. adjmsg () fails
1636: * if |"len"| is greater than the number of bytes in "mp". If "len" spans
1637: * more than one message block in the message, the message blocks must be
1638: * the same type, or else adjmsg () will fail.
1639: *
1640: *-RETURN VALUE:
1641: * If the message can be trimmed successfully, 1 is returned. Otherwise,
1642: * 0 is returned.
1643: *
1644: *-LEVEL:
1645: * Base or interrupt.
1646: *
1647: *-NOTES:
1648: * Does not sleep.
1649: *
1650: * Driver-defined basic locks, read/write locks, and sleep locks may be
1651: * held across calls to this function.
1652: *
1653: * If "len" is greater than the amount of data in a single message block,
1654: * that message block is not freed. Rather, it is left linked in the
1655: * message, and its read and write pointers are set equal to each other,
1656: * indicating no data present in the block.
1657: *
1658: *-SEE ALSO:
1659: * msgb
1660: */
1661:
1662: #if __USE_PROTO__
1663: int (adjmsg) (mblk_t * mp, int len)
1664: #else
1665: int
1666: adjmsg __ARGS ((mp, len))
1667: mblk_t * mp;
1668: int len;
1669: #endif
1670: {
1671: uchar_t msgtype = mp->b_datap->db_type;
1672: int result = 1;
1673:
1674: ASSERT (mp != NULL);
1675:
1676: /*
1677: * The DDI/DKI does not specify whether the message blocks are to be
1678: * left unmodified in the case of failure. For now, we interpret the
1679: * semantics of the routine such that a failure leaves all the
1680: * requested data removed, with the return value supplying an
1681: * indication that overflow occurred.
1682: */
1683:
1684: if (len >= 0) {
1685: /*
1686: * Remove bytes forward from the head of the message.
1687: */
1688:
1689: while (len != 0) {
1690: mblk_t * next;
1691:
1692: if (mp->b_wptr - mp->b_rptr >= len) {
1693: /*
1694: * We are only comsuming part of the message.
1695: */
1696:
1697: mp->b_rptr += len;
1698:
1699: return 1;
1700: } else if ((next = mp->b_cont) == NULL) {
1701: /*
1702: * All the message blocks in the message have
1703: * been totally consumed, so return failure.
1704: */
1705:
1706: mp->b_rptr = mp->b_wptr;
1707:
1708: return 0;
1709: }
1710:
1711: /*
1712: * This message block has been consumed, so leave it
1713: * empty.
1714: */
1715:
1716: len -= mp->b_wptr - mp->b_rptr;
1717:
1718: mp->b_wptr = mp->b_rptr = mp->b_datap->db_base;
1719:
1720: mp = next;
1721:
1722: if (mp->b_datap->db_type != msgtype)
1723: return 0; /* wrong types */
1724: }
1725:
1726: } else {
1727: mblk_t * span = mp;
1728: int size = 0;
1729:
1730: /*
1731: * Since message blocks only have forward links, we have to
1732: * employ some subterfuge to implement this efficiently. We
1733: * first scan forward to discover the size and start of the
1734: * last span of message blocks with the same type.
1735: */
1736:
1737: for (;;) {
1738: size += mp->b_wptr - mp->b_rptr;
1739:
1740: if ((mp = mp->b_cont) == NULL)
1741: break;
1742:
1743: if (mp->b_datap->db_type != msgtype) {
1744: /*
1745: * The type has changed, so we reset our count
1746: * and start pointers to begin a new span.
1747: */
1748:
1749: size = 0;
1750: msgtype = mp->b_datap->db_type;
1751: span = mp;
1752: }
1753: }
1754:
1755:
1756: if (size < len) {
1757: /*
1758: * The user has requested too many bytes be removed,
1759: * so we return a failure indication and remove as
1760: * many as we are able.
1761: */
1762:
1763: result = 0;
1764: len = size;
1765: }
1766:
1767:
1768: /*
1769: * Now we have the last span, we can scan forward for the
1770: * point where we must begin emptying messages.
1771: */
1772:
1773: while (size > 0) {
1774:
1775: size -= span->b_wptr - span->b_rptr;
1776:
1777: if (size < len) {
1778: /*
1779: * The count of bytes remaining in the span
1780: * is less than the threshold, so we start to
1781: * remove data.
1782: */
1783:
1784: span->b_wptr -= (len - size);
1785:
1786: len = size;
1787: }
1788:
1789: span = span->b_next;
1790: }
1791: }
1792:
1793: return result;
1794: }
1795:
1796:
1797: /*
1798: *-STATUS:
1799: * DDI/DKI
1800: *
1801: *-NAME:
1802: * allocb Allocate a message block
1803: *
1804: *-SYNOPSIS:
1805: * #include <sys/types.h>
1806: * #include <sys/stream.h>
1807: *
1808: * mblk_t * allocb (int size, uint_t pri);
1809: *
1810: *-ARGUMENTS:
1811: * size The number of bytes in the message block.
1812: *
1813: * pri Priority of the request. This can take on one of three
1814: * values: BPRI_LO, BPRI_MED, or BPRI_HI.
1815: *
1816: *-DESCRIPTION:
1817: * allocb () tries to allocate a STREAMS message block. Buffer allocation
1818: * fails only when the system is out of memory. If no buffer is
1819: * available, the bufcall () function can help a module recover from an
1820: * allocation failure.
1821: *
1822: * The "pri" argument is a hint to the allocator indicating how badly the
1823: * message is needed. BPRI_LO should be used for normal data allocations,
1824: * BPRI_MED should be used for other non-critical allocations. BPRI_HI
1825: * should be used for allocations that absolutely must succeed, even
1826: * though success is not guaranteed. Some implementations may choose to
1827: * ignore this parameter.
1828: *
1829: *-RETURN VALUE:
1830: * If successful, allocb () returns a pointer to the allocated message
1831: * block of type M_DATA (defined in <sys/stream.h>). If a block cannot be
1832: * allocated, a NULL pointer is returned.
1833: *
1834: *-LEVEL:
1835: * Base or Interrupt.
1836: *
1837: *-NOTES:
1838: * Does not sleep.
1839: *
1840: * Driver-defined basic locks, read/write locks, and sleep locks may be
1841: * held across calls to this function.
1842: *
1843: *-SEE ALSO:
1844: * bufcall (), esballoc (), esbbcall (), freeb (), msgb
1845: */
1846:
1847: #if __USE_PROTO__
1848: mblk_t * (allocb) (int size, uint_t pri)
1849: #else
1850: mblk_t *
1851: allocb __ARGS ((size, pri))
1852: uint_t size;
1853: uint_t pri;
1854: #endif
1855: {
1856: ASSERT (size >= 0);
1857: ASSERT (ATOMIC_FETCH_UCHAR (str_mem->sm_init) &&
1858: str_mem->sm_msg_lock != NULL);
1859:
1860: /*
1861: * Since we allocate things in triples, "allocb (0)" could be legal if
1862: * we wanted. There aren't any compelling reasons either way, but for
1863: * simplicity I'll permit it.
1864: */
1865:
1866: #if 0
1867: if (size == 0)
1868: return NULL;
1869: #endif
1870:
1871: return MSGB_ALLOC (size, pri, KM_NOSLEEP);
1872: }
1873:
1874:
1875: /*
1876: *-STATUS:
1877: * DDI/DKI
1878: *
1879: *-NAME:
1880: * bcanput Test for flow control in specified priority band.
1881: *
1882: *-SYNOPSIS:
1883: * #include <sys/types.h>
1884: * #include <sys/stream.h>
1885: *
1886: * int bcanput (queue_t * q, uchar_t pri);
1887: *
1888: *-ARGUMENTS:
1889: * q Pointer to the message queue.
1890: *
1891: * pri Message priority.
1892: *
1893: *-DESCRIPTION:
1894: * bcanput () tests if there is room for a message in priority band "pri"
1895: * of the queue pointed to by "q". The queue _must_ have a service
1896: * procedure.
1897: *
1898: * If "pri" is 0, the bcanput () call is equivalent to a call to
1899: * canput ().
1900: *
1901: * It is possible because of race conditions to test for room using
1902: * bcanput () and get an indication that there is room for a message, and
1903: * then have the queue fill up before subsequently enqueuing the message,
1904: * causing a violation of flow control. This is not a problem, since the
1905: * violation of flow control in this case is bounded.
1906: *
1907: *-RETURN VALUE:
1908: * bcanput () returns 1 if a message of priority "pri" can be placed on
1909: * the queue. 0 is returned if a message of priority "pri" cannot be
1910: * enqueued because of flow control within the priority band.
1911: *
1912: *-LEVEL:
1913: * Base or interrupt.
1914: *
1915: *-NOTES:
1916: * Does not sleep.
1917: *
1918: * The driver writer is responsible for both testing a queue with
1919: * bcanput () and refraining from placing a message if bcanput () fails.
1920: *
1921: * The caller cannot have the stream frozen [see freezestr ()] when
1922: * calling this function.
1923: *
1924: * Driver-defined basic locks, read/write locks, and sleep locks may be
1925: * held across calls to this function.
1926: *
1927: * The "q" argument may not reference "q_next" (for example, an argument
1928: * of "q->q_next" is erroneous on a multiprocessor and is disallowed by
1929: * the DDI/DKI). "bcanputnext (q)" is provided as a multiprocessor-safe
1930: * equivalent to the common call "bcanput (q->q_next)", which is no
1931: * longer allowed [see bcanputnext ()].
1932: *
1933: *-SEE ALSO:
1934: * bcanputnext (), canput (), canputnext (), putbq (), putnext ()
1935: */
1936:
1937: #if __USE_PROTO__
1938: int (bcanput) (queue_t * q, uchar_t pri)
1939: #else
1940: int
1941: bcanput __ARGS ((q, pri))
1942: queue_t * q;
1943: uchar_t pri;
1944: #endif
1945: {
1946: pl_t prev_pl;
1947: int result = 1;
1948:
1949: prev_pl = QFREEZE_TRACE (q, "bcanput");
1950:
1951: result = QBAND_CANPUT (q, pri);
1952:
1953: QUNFREEZE_TRACE (q, prev_pl);
1954:
1955: return result;
1956: }
1957:
1958:
1959: /*
1960: *-STATUS:
1961: * DDI/DKI
1962: *
1963: *-NAME:
1964: * bcanputnext Test for flow control in specified priority band.
1965: *
1966: *-SYNOPSIS:
1967: * #include <sys/types.h>
1968: * #include <sys/stream.h>
1969: *
1970: * int bcanputnext (queue_t * q, uchar_t pri);
1971: *
1972: *-ARGUMENTS:
1973: * q Pointer to the message queue.
1974: *
1975: * pri Message priority.
1976: *
1977: *-DESCRIPTION:
1978: * bcanputnext () searches through the stream (starting at "q->q_next")
1979: * until it finds a queue containing a service routine, or until it
1980: * reaches the end of the stream. If found, the queue containing the
1981: * service routine is tested to see if a message in priority band "pri"
1982: * can be enqueued. If the band is full, bcanputnext () marks the queue
1983: * to automatically back-enable the caller's service routine when the
1984: * amount of data in messages on the queue has reached its low water
1985: * mark.
1986: *
1987: * If "pri" is 0, the bcanputnext () call is equivalent to a call to
1988: * canputnext ().
1989: *
1990: * It is possible because of race conditions to test for room using
1991: * bcanputnext () and get an indication that there is room for a message,
1992: * and then have the queue fill up before subsequently enqueuing the
1993: * message, causing a violation of flow control. This is not a problem,
1994: * since the violation of flow control in this case is bounded.
1995: *
1996: *-RETURN VALUE:
1997: * bcanputnext () returns 1 if a message of priority "pri" can be sent in
1998: * the stream, or 0 if the stream is flow-controlled. If bcanputnext ()
1999: * reaches the end of the stream without finding a queue with a service
2000: * procedure, then it returns 1.
2001: *
2002: *-LEVEL:
2003: * Base or interrupt.
2004: *
2005: *-NOTES:
2006: * Does not sleep.
2007: *
2008: * The driver writer is responsible for both testing a queue with
2009: * bcanputnext () and refraining from placing a message if bcanputnext ()
2010: * fails.
2011: *
2012: * The caller cannot have the stream frozen [see freezestr ()] when
2013: * calling this function.
2014: *
2015: * Driver-defined basic locks, read/write locks, and sleep locks may be
2016: * held across calls to this function.
2017: *
2018: * The "q" argument may not reference "q_next" (for example, an argument
2019: * of "q->q_next" is erroneous on a multiprocessor and is disallowed by
2020: * the DDI/DKI). "bcanputnext (q)" is provided as a multiprocessor-safe
2021: * equivalent to the common call "bcanput (q->q_next)", which is no
2022: * longer allowed [see bcanputnext ()].
2023: *
2024: *-SEE ALSO:
2025: * bcanput (), canput (), canputnext (), putbq (), putnext ()
2026: */
2027:
2028: #if __USE_PROTO__
2029: int (bcanputnext) (queue_t * q, uchar_t pri)
2030: #else
2031: int
2032: bcanputnext __ARGS ((q, pri))
2033: queue_t * q;
2034: uchar_t pri;
2035: #endif
2036: {
2037: QUEUE_TRACE (q, "bcanputnext");
2038:
2039: return QBAND_SRVNEXT (q, pri);
2040: }
2041:
2042:
2043: /*
2044: * Note: backq () is not present in the System V DDI/DKI For Intel Processors
2045: * with Multiprocessing reference, and is listed in one of the appendices of
2046: * that volume as having been removed in the R3.2 to R4 transition. However,
2047: * the function is present in the regular generic System V DDI/DKI.
2048: */
2049:
2050: #if 0
2051: /*
2052: *-STATUS:
2053: * DDI/DKI
2054: *
2055: *-NAME:
2056: * backq Get pointer to the queue behind the current queue.
2057: *
2058: *-SYNOPSIS:
2059: * #include <sys/stream.h>
2060: *
2061: * queue_t * backq (queue_t * q);
2062: *
2063: *-ARGUMENTS:
2064: * q Pointer to the current queue.
2065: *
2066: *-DESCRIPTION:
2067: * backq () returns a pointer to the queue preceding "q". If "q" is a
2068: * read queue, backq () returns a pointer to the queue downstream from
2069: * "q", unless it is the stream end. If "q" is a write queue, backq ()
2070: * returns a pointer to the next queue upstream from "q", unless it is
2071: * the stream head.
2072: *
2073: *-RETURN VALUE:
2074: * If successful, backq () returns a pointer to the queue preceding the
2075: * current queue. Otherwise, it returns NULL.
2076: *
2077: *-LEVEL:
2078: * Base or interrupt.
2079: *
2080: *-NOTES:
2081: * Does not sleep.
2082: *
2083: * The caller cannot have the stream frozen [see freezestr ()] when
2084: * calling this function.
2085: *
2086: * Driver-defined basic locks, read/write locks, and sleep locks may be
2087: * held across calls to this function.
2088: *
2089: * If the case of a STREAMS-based fifo, this function takes no special
2090: * action at the midpoint of the stream where the read and write sides
2091: * interchange.
2092: */
2093:
2094: #if __USE_PROTO__
2095: queue_t * (backq) (queue_t * q)
2096: #else
2097: queue_t *
2098: backq __ARGS ((q))
2099: queue_t * q;
2100: #endif
2101: {
2102: q = OTHERQ (q);
2103:
2104: q = QUEUE_NEXT (q);
2105:
2106: if (q == NULL)
2107: return NULL;
2108:
2109: return OTHERQ (q);
2110: }
2111: #endif
2112:
2113:
2114: /*
2115: *-STATUS:
2116: * DDI/DKI
2117: *
2118: *-NAME:
2119: * bufcall Call a function when a buffer becomes available.
2120: *
2121: *-SYNOPSIS:
2122: * #include <sys/types.h>
2123: * #include <sys/stream.h>
2124: *
2125: * toid_t bufcall (uint_t size, int pri, void (* func) (), long arg);
2126: *
2127: *-ARGUMENTS:
2128: * size Number of bytes in the buffer to be allocated (from
2129: * the failed allocb () request).
2130: *
2131: * pri Priority of the allocb () allocation request (BPRI_LO,
2132: * BPRI_MED, or BPRI_HI).
2133: *
2134: * func Fuction or driver routine to be called when a buffer
2135: * becomes available.
2136: *
2137: * arg Argument to the function to be called when a buffer
2138: * becomes available.
2139: *
2140: *-DESCRIPTION:
2141: * bufcall () serves as a timeout call of indeterminate length. When a
2142: * buffer allocation request fails, bufcall () can be used to schedule
2143: * the routine "func" to be called with the argument "arg" when a buffer
2144: * of at least "size" bytes becomes available.
2145: *
2146: * When "func" runs, all interrupts from STREAMS devices will be blocked
2147: * on the processor on which it is running. "func" will have no user
2148: * context and may not call any function that sleeps.
2149: *
2150: *-RETURN VALUE:
2151: * If successful, bufcall () returns a non-zero value that identifies the
2152: * scheduling request. This non-zero identifier may be passed to
2153: * unbufcall () to cancel the request. If any failure occurs, bufcall ()
2154: * returns 0.
2155: *
2156: *-LEVEL:
2157: * Base or interrupt.
2158: *
2159: *-NOTES:
2160: * Does not sleep.
2161: *
2162: * Driver-defined basic locks, read/write locks, and sleep locks may be
2163: * held across calls to this function.
2164: *
2165: * Even when "func" is called, allocb () can still fail if another
2166: * module or driver had allocated the memory before "func" was able to
2167: * call allocb ().
2168: *
2169: *-SEE ALSO:
2170: * allocb (), esballoc (), esbbcall (), itimeout (), unbufcall ().
2171: */
2172:
2173: #if __USE_PROTO__
2174: toid_t (bufcall) (uint_t size, int pri, ...)
2175: #else
2176: toid_t
2177: bufcall __ARGS ((size, pri))
2178: uint_t size;
2179: int pri;
2180: #endif
2181: {
2182: se_funcptr_t func;
2183: long arg;
2184: va_list arglist;
2185: sevent_t * seventp;
2186:
2187:
2188: /*
2189: * Before we do anything, we fetch the two other arguments. We use
2190: * the variable-argument function convention to get around problems
2191: * with implicit conversions introduced by having a prototype for
2192: * this function visible.
2193: *
2194: * This is a generic problem with callbacks, since the shape of a
2195: * function type includes the shapes of the function arguments, and
2196: * because we want to pass some argument to the user-supplied function
2197: * without knowing its type (and hence, we must not cause any implicit
2198: * conversions on its value).
2199: */
2200:
2201: va_start (arglist, pri);
2202:
2203: func = va_arg (arglist, se_funcptr_t);
2204: arg = va_arg (arglist, long);
2205:
2206: va_end (arglist);
2207:
2208:
2209: /*
2210: * It may be that NULL is defined in such a way that it is not
2211: * meaningful to compare it with a function pointer, so we just cast
2212: * a zero to get the right kind of effect.
2213: *
2214: * We add some extra assertions below to check that "long" is of
2215: * sufficient size to contain all likely parameter data items. For
2216: * C, "likely" means the fundamental types, which has to include
2217: * pointers to functions, pointers to void, and also pointers to
2218: * structures since under C++ there is currently no guarantee to match
2219: * the ISO C requirement that a pointer of type "void *" be able to
2220: * hold the value of any pointer type without loss of information.
2221: * [We don't consider member pointers here; they are pathological]
2222: */
2223:
2224: ASSERT (sizeof (se_funcptr_t) <= sizeof (long) &&
2225: sizeof (_VOID *) <= sizeof (long) &&
2226: sizeof (selist_t *) <= sizeof (long));
2227:
2228: ASSERT (func != (se_funcptr_t) 0);
2229: ASSERT (pri == BPRI_LO || pri == BPRI_HI || pri == BPRI_LO);
2230:
2231:
2232: /*
2233: * Here we *could* lock and test the available space in the STREAMS
2234: * message heap to see whether sufficient space to satisfy the
2235: * request has become available between the failed allocb () and
2236: * the bufcall () request.
2237: *
2238: * The question is whether the extra time that the heap is locked is
2239: * worth overcoming a delay for a freemsg () to trigger the bufcall ()
2240: * later, especially given the fact that we'll have to unlock the
2241: * heap to call the user's callback (introducing the opportunity for
2242: * the newly-discovered space to vanish).
2243: *
2244: * All in all, once things get to the bufcall () stage there seems
2245: * little reason to keep pushing the system, so we don't bother.
2246: */
2247:
2248: /*
2249: * First off, let's get ourselves an event cell. This is mutually
2250: * dependent with the ID generation policy; if ID codes are stored in
2251: * the event cells, we are free to allocate and discard from a general
2252: * memory pool; if ID codes are not stored, then they must reflect
2253: * some persistent attribute of the cell, which usually implies that
2254: * cells come from some nonshrinking managed pool.
2255: *
2256: * Of course, a generative ID code scheme requires extra locking in
2257: * the absence of atomic FETCH_AND_INCREMENT () operations. In this
2258: * implementation, we get around this by using the list-head locks
2259: * to guard the counter operations. [This has interesting implications
2260: * for the design of a generic list-manipulation facility.]
2261: */
2262:
2263: #if _TOID_MEMBER
2264: if ((seventp = (sevent_t *) kmem_alloc (sizeof (sevent_t),
2265: KM_NOSLEEP)) == NULL)
2266: return 0;
2267: #else
2268: #error Need an allocator for event cells that matches the ID policy
2269: #endif
2270:
2271: /*
2272: * Fill in the event cell. Note that the size member includes the
2273: * memory space required for the message block and data block!
2274: */
2275:
2276: seventp->se_arg = arg;
2277: seventp->se_func = func;
2278: seventp->se_size = MSGB_SIZE (size);
2279:
2280:
2281: return STORE_EVENT (seventp, pri);
2282: }
2283:
2284:
2285: /*
2286: *-STATUS:
2287: * DDI/DKI
2288: *
2289: *-NAME:
2290: * canput Test for room in a message queue.
2291: *
2292: *-SYNOPSIS:
2293: * #include <sys/stream.h>
2294: *
2295: * int canput (queue_t * q);
2296: *
2297: *-ARGUMENTS:
2298: * q Pointer to the message queue.
2299: *
2300: *-DESCRIPTION:
2301: * canput () tests if there is room for a message in the queue pointed to
2302: * by "q". The queue _must_ have a service procedure.
2303: *
2304: * It is possivle because of race conditions to test for room using
2305: * canput () and get an indication that there is room for a message, and
2306: * then have the queue fill up before subsequently enqueuing the message,
2307: * causing a violation of flow control. This is not a problem, since the
2308: * violation of flow control in this case is bounded.
2309: *
2310: *-RETURN VALUE:
2311: * canput () returns 1 if a message can be placed on the queue. 0 is
2312: * returned if a message cannot be enqueued because of flow control.
2313: *
2314: *-LEVEL:
2315: * Base or interrupt.
2316: *
2317: *-NOTES:
2318: * Does not sleep.
2319: *
2320: * The driver writer is responsible for both testing a queue with
2321: * canput () and refraining from placing a message if canput () fails.
2322: *
2323: * The caller cannot have the stream frozen [see freezestr ()] when
2324: * calling this function.
2325: *
2326: * Driver-defined basic locks, read/write locks, and sleep locks may be
2327: * held across calls to this function.
2328: *
2329: * The "q" argument may not reference "q_next" (for example, an argument
2330: * of "q->q_next" is erroneous on a multiprocessor and is disallowed by
2331: * the DDI/DKI). "canputnext (q)" is provided as a multiprocessor-safe
2332: * equivalent to the common call "canput (q->q_next)", which is no
2333: * longer allowed [see canputnext ()].
2334: *
2335: *-SEE ALSO:
2336: * bcanputnext (), bcanput (), canputnext (), putbq (), putnext ()
2337: */
2338:
2339: #if __USE_PROTO__
2340: int (canput) (queue_t * q)
2341: #else
2342: int
2343: canput __ARGS ((q))
2344: queue_t * q;
2345: #endif
2346: {
2347: pl_t prev_pl;
2348: int result = 1;
2349:
2350: prev_pl = QFREEZE_TRACE (q, "canput");
2351:
2352: if ((q->q_flag & QFULL) != 0) {
2353: /*
2354: * We must set the following flag to indicate that the
2355: * queue has a writer who has made a failed write
2356: * attempt.
2357: */
2358:
2359: q->q_flag |= QWANTW;
2360:
2361: result = 0;
2362: }
2363:
2364: QUNFREEZE_TRACE (q, prev_pl);
2365:
2366: return result;
2367: }
2368:
2369:
2370: /*
2371: *-STATUS:
2372: * DDI/DKI
2373: *
2374: *-NAME:
2375: * canputnext Test for flow control in a stream.
2376: *
2377: *-SYNOPSIS:
2378: * #include <sys/stream.h>
2379: *
2380: * int bcanputnext (queue_t * q);
2381: *
2382: *-ARGUMENTS:
2383: * q Pointer to the message queue.
2384: *
2385: *-DESCRIPTION:
2386: * canputnext () searches through the stream (starting at "q->q_next")
2387: * until it finds a queue containing a service routine, or until it
2388: * reaches the end of the stream. If found, the queue containing the
2389: * service routine is tested to see if there is room for a message in the
2390: * queue. If the band is full, canputnext () marks the queue to
2391: * automatically back-enable the caller's service routine when the amount
2392: * of data in messages on the queue has reached its low water mark.
2393: *
2394: * It is possible because of race conditions to test for room using
2395: * canputnext () and get an indication that there is room for a message,
2396: * and then have the queue fill up before subsequently enqueuing the
2397: * message, causing a violation of flow control. This is not a problem,
2398: * since the violation of flow control in this case is bounded.
2399: *
2400: *-RETURN VALUE:
2401: * canputnext () returns 1 if a message can be sent in the stream, or 0
2402: * if the stream is flow-controlled. If canputnext () reaches the end of
2403: * the stream without finding a queue with a service procedure, then it
2404: * returns 1.
2405: *
2406: *-LEVEL:
2407: * Base or interrupt.
2408: *
2409: *-NOTES:
2410: * Does not sleep.
2411: *
2412: * The driver writer is responsible for both testing a queue with
2413: * bcanputnext () and refraining from placing a message if bcanputnext ()
2414: * fails.
2415: *
2416: * The caller cannot have the stream frozen [see freezestr ()] when
2417: * calling this function.
2418: *
2419: * Driver-defined basic locks, read/write locks, and sleep locks may be
2420: * held across calls to this function.
2421: *
2422: * The "q" argument may not reference "q_next" (for example, an argument
2423: * of "q->q_next" is erroneous on a multiprocessor and is disallowed by
2424: * the DDI/DKI). "bcanputnext (q)" is provided as a multiprocessor-safe
2425: * equivalent to the common call "bcanput (q->q_next)", which is no
2426: * longer allowed [see bcanputnext ()].
2427: *
2428: *-SEE ALSO:
2429: * bcanput (), bcanputnext (), canput (), putbq (), putnext ()
2430: */
2431:
2432: #if __USE_PROTO__
2433: int (canputnext) (queue_t * q)
2434: #else
2435: int
2436: canputnext __ARGS ((q))
2437: queue_t * q;
2438: #endif
2439: {
2440: QUEUE_TRACE (q, "canputnext");
2441:
2442: /*
2443: * Rather than depend on canput () above, we'll use the band-capable
2444: * function QBAND_SRVNEXT () and depend on its ability to handle
2445: * band 0. The mechanics of iterating through a stream are much more
2446: * complex now than in the old SVR3.2 days due to both freezestr ()
2447: * and qprocsoff ().
2448: */
2449:
2450: return QBAND_SRVNEXT (q, 0);
2451: }
2452:
2453:
2454: /*
2455: *-STATUS:
2456: * DDI/DKI
2457: *
2458: *-NAME:
2459: * copyb Copy a message block.
2460: *
2461: *-SYNOPSIS:
2462: * #include <sys/stream.h>
2463: *
2464: * mblk_t * copyb (mblk_t * bp);
2465: *
2466: *-ARGUMENTS:
2467: * bp Pointer to the message block from which data are
2468: * copied.
2469: *
2470: *-DESCRIPTION:
2471: * copyb () allocates a new message block, and copies into it the data
2472: * from the block pointed to by "bp". The new block will be at least as
2473: * large as the block being copied. The "b_rptr" and "b_wptr" members of
2474: * the message block pointed to by "bp" are used to determine how many
2475: * bytes to copy.
2476: *
2477: *-RETURN VALUE:
2478: * If successful, copyb () returns a pointer to the newly allocated
2479: * message block containing the copied data. Otherwise, it returns a NULL
2480: * pointer.
2481: *
2482: *-LEVEL:
2483: * Base or interrupt.
2484: *
2485: *-NOTES:
2486: * Does not sleep.
2487: *
2488: * Driver-defined basic locks, read/write locks, and sleep locks may be
2489: * held across calls to this function.
2490: *
2491: *-SEE ALSO:
2492: * allocb (), copymsg (), msgb
2493: */
2494:
2495: #define ALLOW_EMPTY_COPIES
2496:
2497: #if __USE_PROTO__
2498: mblk_t * (copyb) (mblk_t * bp)
2499: #else
2500: mblk_t *
2501: copyb __ARGS ((bp))
2502: mblk_t * bp;
2503: #endif
2504: {
2505: mblk_t * newmsg;
2506: size_t size;
2507:
2508: ASSERT (bp != NULL && bp->b_datap != NULL);
2509:
2510: /*
2511: * What to do if there is no real data in the original message?
2512: *
2513: * Copy it anyway, I guess.
2514: */
2515:
2516: size = bp->b_wptr - bp->b_rptr;
2517:
2518: if (size == 0)
2519: return MSGB_ALLOC (0, BPRI_LO, KM_NOSLEEP);
2520:
2521:
2522: /*
2523: * In this implementation we only allocate exactly as much space as
2524: * we require (thus opening the zero-length issue). It is possible to
2525: * interpret the wording of the manual-page as implying that the size
2526: * of the new block is at least the size of the old block including
2527: * unused space, but that doesn't seem reasonable. I read that
2528: * requirement as merely pointing out that the allocator can give
2529: * more memory to the new block that is strictly necessary.
2530: */
2531:
2532: if ((newmsg = MSGB_ALLOC (size, BPRI_LO, KM_NOSLEEP)) != NULL) {
2533:
2534: newmsg->b_datap->db_type = bp->b_datap->db_type;
2535:
2536: memcpy (newmsg->b_rptr, bp->b_rptr, size);
2537:
2538: newmsg->b_wptr += size;
2539: }
2540:
2541: return newmsg;
2542: }
2543:
2544:
2545: /*
2546: *-STATUS:
2547: * DDI/DKI
2548: *
2549: *-NAME:
2550: * copymsg Copy a message.
2551: *
2552: *-SYNOPSIS:
2553: * #include <sys/stream.h>
2554: *
2555: * mblk_t * copymsg (mblk_t * mp);
2556: *
2557: *-ARGUMENTS:
2558: * mp Pointer to the message to be copied.
2559: *
2560: *-DESCRIPTION:
2561: * copymsg () forms a new message by allocating message blocks, copies
2562: * the conents of the message referred to by "mp" (using the copyb ()
2563: * function) and returns a pointer to the new message.
2564: *
2565: *-RETURN VALUE:
2566: * If successful, copymsg () returns a pointer to the new message.
2567: * Otherwise, it returns a NULL pointer.
2568: *
2569: *-LEVEL:
2570: * Base or interrupt.
2571: *
2572: *-NOTES:
2573: * Does not sleep.
2574: *
2575: * Driver-defined basic locks, read/write locks, and sleep locks may be
2576: * held across calls to this function.
2577: *
2578: *-SEE ALSO:
2579: * allocb (), copyb (), msgb
2580: */
2581:
2582: #if __USE_PROTO__
2583: mblk_t * (copymsg) (mblk_t * mp)
2584: #else
2585: mblk_t *
2586: copymsg __ARGS ((mp))
2587: mblk_t * mp;
2588: #endif
2589: {
2590: mblk_t * oldscan;
2591: mblk_t * msg;
2592: mblk_t * newblk;
2593:
2594: ASSERT (mp != NULL && mp->b_datap != NULL);
2595:
2596: /*
2597: * Rather than simply layering on top of copyb (), we can make this
2598: * function be more friendly in situations where memory is scarce by
2599: * trying the allocations before the copies, so that we don't spend
2600: * time copying data that is going to be discarded.
2601: */
2602:
2603: if ((newblk = msg = MSGB_ALLOC (mp->b_wptr - mp->b_rptr, BPRI_LO,
2604: KM_NOSLEEP)) == NULL)
2605: return NULL;
2606:
2607: for (oldscan = mp->b_cont ; oldscan != NULL ;
2608: newblk = newblk->b_cont, oldscan = oldscan->b_cont) {
2609:
2610: if ((newblk->b_cont =
2611: MSGB_ALLOC (oldscan->b_wptr - oldscan->b_rptr,
2612: BPRI_LO, KM_NOSLEEP)) == NULL) {
2613: freemsg (msg);
2614: return NULL;
2615: }
2616: }
2617:
2618: /*
2619: * Now we have the memory, do the copy. Like copyb (), we have have to
2620: * remember to dance around zero-length blocks in the original, which
2621: * we will be preserve as copied zero-length blocks.
2622: */
2623:
2624: oldscan = mp;
2625: newblk = msg;
2626:
2627: do {
2628: size_t size;
2629:
2630: ASSERT (oldscan != NULL);
2631:
2632: if ((size = oldscan->b_wptr - oldscan->b_rptr) > 0)
2633: memcpy (newblk->b_rptr, oldscan->b_rptr, size);
2634: newblk->b_wptr += size;
2635:
2636: oldscan = oldscan->b_cont;
2637: } while ((newblk = newblk->b_cont) != NULL);
2638:
2639: ASSERT (oldscan == NULL);
2640:
2641: #if 0
2642: if ((msg = newblk = copyb (mp)) != NULL)
2643: while ((mp = mp->b_cont) != NULL)
2644: if ((newblk = (newblk->b_cont = copyb (mp))) == NULL) {
2645: /*
2646: * If a given block in the message cannot be
2647: * copied, undo all the work done so far.
2648: */
2649:
2650: freemsg (msg);
2651: return NULL;
2652: }
2653: #endif
2654:
2655: return msg;
2656: }
2657:
2658:
2659: /*
2660: *-STATUS:
2661: * DDI/DKI
2662: *
2663: *-NAME:
2664: * datamsg Test whether a message is a data message.
2665: *
2666: *-SYNOPSIS:
2667: * #include <sys/types.h>
2668: * #include <sys/stream.h>
2669: * #include <sys/ddi.h>
2670: *
2671: * int datamsg (uchar_t type);
2672: *
2673: *-ARGUMENTS:
2674: * type The type of message to be tested. The "db_type" field
2675: * of the "datab" structure contains the message type.
2676: * This field may be accessed through the message block
2677: * using "mp->b_datap->db_type".
2678: *
2679: *-DESCRIPTION:
2680: * The datamsg () function tests the type of message to determine if it
2681: * is a data message type (M_DATA, M_DELAY, M_PROTO or M_PCPROTO).
2682: *
2683: *-RETURN VALUE:
2684: * datamsg () returns 1 if the message is a data message and 0 if the
2685: * message is any other type.
2686: *
2687: *-LEVEL:
2688: * Base or interrupt.
2689: *
2690: *-NOTES:
2691: * Does not sleep.
2692: *
2693: * Driver-defined basic locks, read/write locks, and sleep locks may be
2694: * held across calls to this function.
2695: *
2696: *-SEE ALSO:
2697: * allocb (), datab, msgb, messages
2698: */
2699:
2700: #if __USE_PROTO__
2701: int (datamsg) (uchar_t type)
2702: #else
2703: int
2704: datamsg __ARGS ((type))
2705: uchar_t type;
2706: #endif
2707: {
2708: return datamsg (type); /* appeal to the macro version */
2709: }
2710:
2711:
2712: /*
2713: *-STATUS:
2714: * DDI/DKI
2715: *
2716: *-NAME:
2717: * dupb Duplicate a message block.
2718: *
2719: *-SYNOPSIS:
2720: * #include <sys/stream.h>
2721: *
2722: * mblk_t * dupb (mblk_t * bp);
2723: *
2724: *-ARGUMENTS:
2725: * bp Pointer to the message block to be duplicated.
2726: *
2727: *-DESCRIPTION:
2728: * dupb () creates a new message block structure to reference the message
2729: * block pointed to by "bp". Unlike copyb (), dupb () does not copy the
2730: * information in the data block, but creates a new structure to point to
2731: * it.
2732: *
2733: *-RETURN VALUE:
2734: * If successful, dupb () returns a pointer to the new message block.
2735: * Otherwise, it returns a NULL pointer.
2736: *
2737: *-LEVEL:
2738: * Base or interrupt.
2739: *
2740: *-NOTES:
2741: * Does not sleep.
2742: *
2743: * Driver-defined basic locks, read/write locks, and sleep locks may be
2744: * held across calls to this function.
2745: *
2746: *-SEE ALSO:
2747: * copyb (), dupmsg (), datab, msgb
2748: */
2749:
2750: #if __USE_PROTO__
2751: mblk_t * (dupb) (mblk_t * bp)
2752: #else
2753: mblk_t *
2754: dupb __ARGS ((bp))
2755: mblk_t * bp;
2756: #endif
2757: {
2758: mblk_t * newblk;
2759:
2760: ASSERT (bp != NULL);
2761:
2762: if ((newblk = STRMEM_ALLOC (sizeof (mblk_t), BPRI_HI,
2763: KM_NOSLEEP)) != NULL) {
2764: /*
2765: * Note that we do not initialize the "b_prev" and "b_next"
2766: * members, and that the "b_cont" member is NULL rather than
2767: * a copy of the original.
2768: */
2769:
2770: newblk->b_cont = NULL;
2771: newblk->b_datap = bp->b_datap;
2772: newblk->b_rptr = bp->b_rptr;
2773: newblk->b_wptr = bp->b_wptr;
2774: ++ newblk->b_datap->db_ref;
2775: }
2776:
2777: return newblk;
2778: }
2779:
2780:
2781: /*
2782: *-STATUS:
2783: * DDI/DKI
2784: *
2785: *-NAME:
2786: * dupmsg Duplicate a message.
2787: *
2788: *-SYNOPSIS:
2789: * #include <sys/stream.h>
2790: *
2791: * mblk_t * dupmsg (mblk_t * mp);
2792: *
2793: *-ARGUMENTS:
2794: * mp Pointer to the message to be duplicated.
2795: *
2796: *-DESCRIPTION:
2797: * dupmsg () forms a new message by duplicating the message blocks in the
2798: * message pointed to by "mp" and linking them via their "b_cont"
2799: * pointers.
2800: *
2801: *-RETURN VALUE:
2802: * If successful, dupmsg () returns a pointer to the new message.
2803: * Otherwise it returns a NULL pointer.
2804: *
2805: *-LEVEL:
2806: * Base or interrupt.
2807: *
2808: *-NOTES:
2809: * Does not sleep.
2810: *
2811: * Driver-defined basic locks, read/write locks, and sleep locks may be
2812: * held across calls to this function.
2813: *
2814: *-SEE ALSO:
2815: * copyb (), copymsg (), dupb (), datab, msgb
2816: */
2817:
2818: #if __USE_PROTO__
2819: mblk_t * (dupmsg) (mblk_t * mp)
2820: #else
2821: mblk_t *
2822: dupmsg __ARGS ((mp))
2823: mblk_t * mp;
2824: #endif
2825: {
2826: mblk_t * msg;
2827: mblk_t * newblk;
2828:
2829: ASSERT (mp != NULL);
2830:
2831: if ((msg = newblk = dupb (mp)) != NULL)
2832: while ((mp = mp->b_cont) != NULL)
2833: if ((newblk = (newblk->b_cont = dupb (mp))) == NULL) {
2834: /*
2835: * Discard the work we have done so far.
2836: */
2837:
2838: freemsg (msg);
2839: return NULL;
2840: }
2841:
2842: return msg;
2843: }
2844:
2845:
2846: /*
2847: *-STATUS:
2848: * DDI/DKI
2849: *
2850: *-NAME:
2851: * enableok Enable a queue to be serviced.
2852: *
2853: *-SYNOPSIS:
2854: * #include <sys/stream.h>
2855: * #include <sys/ddi.h>
2856: *
2857: * void enableok (queue_t * q);
2858: *
2859: *-ARGUMENTS:
2860: * q Pointer to the queue.
2861: *
2862: *-DESCRIPTION:
2863: * The enableok () function allows the service routine of the queue
2864: * pointed to by "q" to be rescheduled for service. It cancels the effect
2865: * of a previous use of the noenable () function on "q".
2866: *
2867: *-RETURN VALUE:
2868: * None.
2869: *
2870: *-LEVEL:
2871: * Base or interrupt.
2872: *
2873: *-NOTES:
2874: * Does not sleep.
2875: *
2876: * The caller cannot have the stream frozen [see freezestr ()] when
2877: * calling this function.
2878: *
2879: * Driver-defined basic locks, read/write locks, and sleep locks may be
2880: * held across calls to this function.
2881: *
2882: *-SEE ALSO:
2883: * noenable (), qenable (), queue
2884: */
2885:
2886: #if __USE_PROTO__
2887: void (enableok) (queue_t * q)
2888: #else
2889: void
2890: enableok __ARGS ((q))
2891: queue_t * q;
2892: #endif
2893: {
2894: pl_t prev_pl;
2895:
2896: prev_pl = QFREEZE_TRACE (q, "enableok");
2897:
2898: q->q_flag &= ~ QNOENB;
2899:
2900: QUNFREEZE_TRACE (q, prev_pl);
2901: }
2902:
2903:
2904: /*
2905: *-STATUS:
2906: * DDI/DKI
2907: *
2908: *-NAME:
2909: * esballoc Allocate a message block using an externally supplied
2910: * buffer.
2911: *
2912: *-SYNOPSIS:
2913: * #include <sys/stream.h>
2914: *
2915: * mblk_t * esballoc (uchar_t * base, int size, int pri,
2916: * frtn_t * fr_rtnp);
2917: *
2918: *-ARGUMENTS:
2919: * base Address of driver-supplied data buffer.
2920: *
2921: * size Number of bytes in data buffer.
2922: *
2923: * pri Priority of allocation request (used to allocate the
2924: * message and data blocks). Valid values are BPRI_LO,
2925: * BPRI_MED, and BPRI_HI.
2926: *
2927: * fr_rtnp Pointer to the free-routine data structure.
2928: *
2929: *-DESCRIPTION:
2930: * esballoc () creates a STREAMS message and attaches a driver-supplied
2931: * data buffer in place of a STREAMS data buffer. It allocates a message
2932: * and data block header only. The driver-supplied data buffer, pointed
2933: * to by "base", is used as the data buffer for the message.
2934: *
2935: * When freeb () is called to free the message, on the last reference to
2936: * the message the driver's free-routine specified by the "free_func"
2937: * field in the "free_rtn" structure is called with one argument
2938: * (specified by the "free_arg" field) to free the data buffer.
2939: *
2940: * Instead of requiring a specific number of arguments, the "free_arg"
2941: * field is defined as type "char *". This way, the driver can pass a
2942: * pointer to a structure if more than one argument is needed.
2943: *
2944: * When the "free_func" function runs, interrupts from all STREAMS
2945: * devices will be blocked. It has no user context and may not call any
2946: * routine that sleeps. The function may not access any dynamically
2947: * allocated data structures that might no longer exist when it runs.
2948: *
2949: *-RETURN VALUE:
2950: * On success, a pointer to the newly allocated message block is
2951: * returned. On failure, a NULL pointer is returned.
2952: *
2953: *-LEVEL:
2954: * Base or interrupt.
2955: *
2956: *-NOTES:
2957: * Does not sleep.
2958: *
2959: * Driver-defined basic locks, read/write locks, and sleep locks may be
2960: * held across calls to this function.
2961: *
2962: *-SEE ALSO:
2963: * allocb (), freeb (), free_rtn
2964: */
2965:
2966: #if __USE_PROTO__
2967: mblk_t * (esballoc) (uchar_t * base, int size, int pri, frtn_t * fr_rtnp)
2968: #else
2969: mblk_t *
2970: esballoc __ARGS ((base, size, pri, fr_rtnp))
2971: uchar_t * base;
2972: int size;
2973: int pri;
2974: frtn_t * fr_rtnp;
2975: #endif
2976: {
2977: mblk_t * mblkp;
2978:
2979: ASSERT (base != NULL);
2980: ASSERT (size >= 0);
2981: ASSERT (pri == BPRI_LO || pri == BPRI_HI || pri == BPRI_LO);
2982: ASSERT (ATOMIC_FETCH_UCHAR (str_mem->sm_init) &&
2983: str_mem->sm_msg_lock != NULL);
2984:
2985: /*
2986: * Is it permissible for a driver to specify a NULL fr_rtnp?
2987: *
2988: * I think that it seems entirely logical, but neither the DDI/DKI
2989: * nor the STREAMS Programmer's Guide say anything about this.
2990: */
2991:
2992: if ((mblkp = STRMEM_ALLOC (MSGB_SIZE (0), pri, KM_NOSLEEP)) != NULL) {
2993: /*
2994: * Note that we don't bother setting up the "b_prev" and
2995: * "b_next" members of the message block.
2996: */
2997:
2998: mblkp->b_cont = NULL;
2999: mblkp->b_datap = MB_TO_DB (mblkp);
3000: mblkp->b_rptr = base;
3001: mblkp->b_wptr = base;
3002:
3003: /*
3004: * We specially flag this message block as part of
3005: * a triple. While there are other ways we could test
3006: * this, for now we permit the possibility that a
3007: * client might change the attachments of data blocks
3008: * and message blocks perversely.
3009: */
3010:
3011: mblkp->b_flag = MSGTRIPLE;
3012: mblkp->b_band = 0;
3013:
3014: mblkp->b_datap->db_base = base;
3015: mblkp->b_datap->db_lim = base + size;
3016: mblkp->b_datap->db_type = M_DATA;
3017: mblkp->b_datap->db_ref = 1;
3018:
3019: mblkp->b_datap->db_frtnp = fr_rtnp;
3020: }
3021:
3022: return mblkp;
3023: }
3024:
3025:
3026: /*
3027: *-STATUS:
3028: * DDI/DKI
3029: *
3030: *-NAME:
3031: * esbbcall Call a function when an externally-supplied buffer
3032: * can be allocated.
3033: *
3034: *-SYNOPSIS:
3035: * #include <sys/types.h>
3036: * #include <sys/stream.h>
3037: *
3038: * toid_t esbbcall (int pri, int (* func) (), long arg);
3039: *
3040: *-ARGUMENTS:
3041: * pri Priority of the esballoc () allocation request
3042: * (BPRI_LO, BPRI_MED or BPRI_HI).
3043: *
3044: * func Function to be called when a buffer becomes available.
3045: *
3046: * arg Argument to the function to be called when a buffer
3047: * becomes available.
3048: *
3049: *-DESCRIPTION:
3050: * esbbcall (), like bufcall (), serves as a timeout call of
3051: * indeterminate duration. If esballoc () is unable to allocate a message
3052: * block header and a data block header to go with the externally
3053: * supplied data buffer, esbbcall () can be used to schedule the routine
3054: * "func", to be called with the argument "arg" when memory becomes
3055: * available.
3056: *
3057: * When "func" runs, all interrupts from STREAMS devices will be blocked
3058: * on the processor on which it is running. "func" will have no user
3059: * context and may not call any function that sleeps.
3060: *
3061: *-RETURN VALUE:
3062: * If successful, esbbcall () returns a non-zero value that identifies
3063: * the scheduling request. This non-zero identifier may be passed to
3064: * unbufcall () to cancel the request. If any failure occurs, esbbcall ()
3065: * returns 0.
3066: *
3067: *-LEVEL:
3068: * Base or interrupt.
3069: *
3070: *-NOTES:
3071: * Does not sleep.
3072: *
3073: * Driver-defined basic locks, read/write locks, and sleep locks may be
3074: * held across calls to this function.
3075: *
3076: * Even when "func" is called, esballoc () can still fail if another
3077: * module or driver had allocated the memory before "func" was able to
3078: * call esballoc ().
3079: *
3080: *-SEE ALSO:
3081: * allocb (), bufcall (), esballoc (), itimeout (), unbufcall ()
3082: */
3083:
3084: #if __USE_PROTO__
3085: toid_t (esbbcall) (int pri, ...)
3086: #else
3087: toid_t
3088: esbbcall __ARGS ((pri))
3089: int pri;
3090: #endif
3091: {
3092: se_funcptr_t func;
3093: long arg;
3094: va_list arglist;
3095: sevent_t * seventp;
3096:
3097:
3098: /*
3099: * Before we do anything, we fetch the two other arguments. We use
3100: * the variable-argument function convention to get around problems
3101: * with implicit conversions introduced by having a prototype for
3102: * this function visible.
3103: *
3104: * This is a generic problem with callbacks, since the shape of a
3105: * function type includes the shapes of the function arguments, and
3106: * because we want to pass some argument to the user-supplied function
3107: * without knowing its type (and hence, we must not cause any implicit
3108: * conversions on its value).
3109: */
3110:
3111: va_start (arglist, pri);
3112:
3113: func = va_arg (arglist, se_funcptr_t);
3114: arg = va_arg (arglist, long);
3115:
3116: va_end (arglist);
3117:
3118:
3119: /*
3120: * It may be that NULL is defined in such a way that it is not
3121: * meaningful to compare it with a function pointer, so we just cast
3122: * a zero to get the right kind of effect.
3123: *
3124: * We add some extra assertions below to check that "long" is of
3125: * sufficient size to contain all likely parameter data items. For
3126: * C, "likely" means the fundamental types, which has to include
3127: * pointers to functions, pointers to void, and also pointers to
3128: * structures since under C++ there is currently no guarantee to match
3129: * the ISO C requirement that a pointer of type "void *" be able to
3130: * hold the value of any pointer type without loss of information.
3131: * [We don't consider member pointers here; they are pathological]
3132: */
3133:
3134: ASSERT (sizeof (se_funcptr_t) <= sizeof (long) &&
3135: sizeof (_VOID *) <= sizeof (long) &&
3136: sizeof (selist_t *) <= sizeof (long));
3137:
3138: ASSERT (func != (se_funcptr_t) 0);
3139: ASSERT (pri == BPRI_LO || pri == BPRI_HI || pri == BPRI_LO);
3140:
3141:
3142: /*
3143: * Here we *could* lock and test the available space in the STREAMS
3144: * message heap to see whether sufficient space to satisfy the
3145: * request has become available between the failed allocb () and
3146: * the bufcall () request.
3147: *
3148: * The question is whether the extra time that the heap is locked is
3149: * worth overcoming a delay for a freemsg () to trigger the bufcall ()
3150: * later, especially given the fact that we'll have to unlock the
3151: * heap to call the user's callback (introducing the opportunity for
3152: * the newly-discovered space to vanish).
3153: *
3154: * All in all, once things get to the bufcall () stage there seems
3155: * little reason to keep pushing the system, so we don't bother.
3156: */
3157:
3158: /*
3159: * First off, let's get ourselves an event cell. This is mutually
3160: * dependent with the ID generation policy; if ID codes are stored in
3161: * the event cells, we are free to allocate and discard from a general
3162: * memory pool; if ID codes are not stored, then they must reflect
3163: * some persistent attribute of the cell, which usually implies that
3164: * cells come from some nonshrinking managed pool.
3165: *
3166: * Of course, a generative ID code scheme requires extra locking in
3167: * the absence of atomic FETCH_AND_INCREMENT () operations. In this
3168: * implementation, we get around this by using the list-head locks
3169: * to guard the counter operations. [This has interesting implications
3170: * for the design of a generic list-manipulation facility.]
3171: */
3172:
3173: #if _TOID_MEMBER
3174: if ((seventp = (sevent_t *) kmem_alloc (sizeof (sevent_t),
3175: KM_NOSLEEP)) == NULL)
3176: return 0;
3177: #else
3178: #error Need an allocator for event cells that matches the ID policy
3179: #endif
3180:
3181: seventp->se_arg = arg;
3182: seventp->se_func = func;
3183: seventp->se_size = MSGB_SIZE (0);
3184:
3185: return STORE_EVENT (seventp, pri);
3186: }
3187:
3188:
3189: /*
3190: *-STATUS:
3191: * DDI/DKI
3192: *
3193: *-NAME:
3194: * flushband Flush messages in a specified priority band.
3195: *
3196: *-SYNOPSIS:
3197: * #include <sys/types.h>
3198: * #include <sys/stream.h>
3199: *
3200: * void flushband (queue_t * q, uchar_t pri, int flag);
3201: *
3202: *-ARGUMENTS:
3203: * q Pointer to the queue.
3204: *
3205: * pri Priority band of messages to be flushed.
3206: *
3207: * flag Determines messages to flush. Valid "flag" values are:
3208: *
3209: * FLUSHDATA Flush only data messages (types
3210: * M_DATA, M_DELAY, M_PROTO, and
3211: * M_PCPROTO).
3212: *
3213: * FLUSHALL Flush all messages.
3214: *
3215: *-DESCRIPTION:
3216: * The flushband () function flushes messages associated with the
3217: * priority band specified by "pri". If "pri" is 0, only normal and high
3218: * priority messages are flushed. Otherwise, messages are flushed from
3219: * the band "pri" according to the value of "flag".
3220: *
3221: *-RETURN VALUE:
3222: * None.
3223: *
3224: *-LEVEL:
3225: * Base or interrupt.
3226: *
3227: *-NOTES:
3228: * Does not sleep.
3229: *
3230: * The caller cannot have the stream frozen [see freezestr ()] when
3231: * calling this function.
3232: *
3233: * Driver-defined basic locks, read/write locks, and sleep locks may be
3234: * held across calls to this function.
3235: *
3236: *-SEE ALSO:
3237: * put (), flushq (), queue
3238: */
3239:
3240: #if __USE_PROTO__
3241: void (flushband) (queue_t * q, uchar_t pri, int flag)
3242: #else
3243: void
3244: flushband __ARGS ((q, pri, flag))
3245: queue_t * q;
3246: uchar_t pri;
3247: int flag;
3248: #endif
3249: {
3250: pl_t prev_pl;
3251: qband_t * qbandp;
3252: mblk_t * mp;
3253: mblk_t * next;
3254: ulong_t flushsize;
3255:
3256: ASSERT (flag == FLUSHDATA || flag == FLUSHALL);
3257:
3258: if (pri == 0) {
3259: /*
3260: * Since the priority-band flush algorithm is necessarily
3261: * different from the regular one (due to flow control
3262: * handling), we'll just forward this on to the regular
3263: * version.
3264: */
3265:
3266: flushq (q, flag);
3267: return;
3268: }
3269:
3270: prev_pl = QFREEZE_TRACE (q, "flushband");
3271:
3272: if ((qbandp = QUEUE_BAND (q, pri)) != NULL &&
3273: (mp = qbandp->qb_first) != NULL) {
3274:
3275: flushsize = 0;
3276:
3277: do {
3278: /*
3279: * Read the "b_next" member now in case we unlink this message
3280: * from the queue.
3281: */
3282:
3283: next = mp->b_next;
3284:
3285: ASSERT (mp->b_band == pri);
3286:
3287: if (flag == FLUSHALL || datamsg (mp->b_datap->db_type)) {
3288:
3289: if (mp->b_prev == NULL)
3290: q->q_first = next;
3291: else
3292: mp->b_prev->b_next = next;
3293:
3294: if (next == NULL)
3295: q->q_last = mp->b_prev;
3296: else
3297: next->b_prev = mp->b_prev;
3298:
3299: QBAND_DEQUEUE (qbandp, mp);
3300:
3301:
3302: /*
3303: * Free the message, accumulating the total
3304: * size of the data referred to by the
3305: * message.
3306: */
3307:
3308: flushsize += MSG_SIZE (mp);
3309: freemsg (mp);
3310: }
3311: } while ((mp = next) != qbandp->qb_last);
3312:
3313:
3314: /*
3315: * Here we update the flow control parameters for the band
3316: * now that we have accumulated all the necessary changes.
3317: */
3318:
3319: QBAND_REDUCE (q, qbandp, flushsize);
3320: }
3321:
3322:
3323: /*
3324: * Since we are in a path with QBAND_REDUCE (), check for QBACK before
3325: * unfreezing the stream.
3326: */
3327:
3328: {
3329: unsigned long back;
3330:
3331: if ((back = q->q_flag & QBACK) != 0)
3332: q->q_flag &= ~ QBACK;
3333:
3334: QUNFREEZE_TRACE (q, prev_pl);
3335:
3336: if (back)
3337: QUEUE_BACKENAB (q);
3338: }
3339: }
3340:
3341:
3342: /*
3343: *-STATUS:
3344: * DDI/DKI
3345: *
3346: *-NAME:
3347: * flushq Flush messages on a queue.
3348: *
3349: *-SYNOPSIS:
3350: * #include <sys/stream.h>
3351: *
3352: * void flushq (queue_t * q, int flag);
3353: *
3354: *-ARGUMENTS:
3355: * q Pointer to the queue.
3356: *
3357: * flag Determines messages to flush. Valid "flag" values are:
3358: *
3359: * FLUSHDATA Flush only data messages (types
3360: * M_DATA, M_DELAY, M_PROTO, and
3361: * M_PCPROTO).
3362: *
3363: * FLUSHALL Flush all messages.
3364: *
3365: *-DESCRIPTION:
3366: * flushq () frees messages on a queue by calling freemsg () for each
3367: * message. If the queue's count falls below the low water mark and
3368: * someone wants to write to the queue, the nearest upstream or
3369: * downstream (as approriate) service procedure is enabled.
3370: *
3371: *-RETURN VALUE:
3372: * None.
3373: *
3374: *-LEVEL:
3375: * Base or interrupt.
3376: *
3377: *-NOTES:
3378: * Does not sleep.
3379: *
3380: * The caller cannot have the stream frozen [see freezestr ()] when
3381: * calling this function.
3382: *
3383: * Driver-defined basic locks, read/write locks, and sleep locks may be
3384: * held across calls to this function.
3385: *
3386: *-SEE ALSO:
3387: * put (), flushband (), freemsg (), putq (), queue
3388: */
3389:
3390: #if __USE_PROTO__
3391: void (flushq) (queue_t * q, int flag)
3392: #else
3393: void
3394: flushq __ARGS ((q, flag))
3395: queue_t * q;
3396: int flag;
3397: #endif
3398: {
3399: pl_t prev_pl;
3400: mblk_t * mp;
3401: mblk_t * next;
3402: ulong_t flushsize;
3403:
3404: ASSERT (flag == FLUSHDATA || flag == FLUSHALL);
3405:
3406: flushsize = 0;
3407:
3408: prev_pl = QFREEZE_TRACE (q, "flushq");
3409:
3410: /*
3411: * High-priority messages are flushed as well as low-priority messages
3412: * so we could presumably split this function into a two-part scan
3413: * since the high-priority messages are at the front of the message
3414: * list while the low-priority messages are at the end.
3415: *
3416: * However, this function is not called very often, and we expect
3417: * band usage to be rare.
3418: */
3419:
3420: for (mp = q->q_first ; mp != NULL ; mp = next) {
3421: /*
3422: * Read the "b_next" member now in case we unlink this message
3423: * from the queue.
3424: */
3425:
3426: next = mp->b_next;
3427:
3428: if (mp->b_band == 0 &&
3429: (flag == FLUSHALL || datamsg (mp->b_datap->db_type))) {
3430:
3431: if (mp->b_prev == NULL)
3432: q->q_first = next;
3433: else
3434: mp->b_prev->b_next = next;
3435:
3436: if (next == NULL)
3437: q->q_last = mp->b_prev;
3438: else
3439: next->b_prev = mp->b_prev;
3440:
3441: /*
3442: * If the message is high-priority, then we skip the
3443: * accumulation of the size.
3444: */
3445:
3446: if (IS_PRI_MSG (mp)) {
3447: freemsg (mp);
3448: continue;
3449: }
3450:
3451: /*
3452: * Free the message, accumulating the total size of
3453: * the data referred to by the message.
3454: */
3455:
3456: flushsize += MSG_SIZE (mp);
3457: freemsg (mp);
3458: }
3459: }
3460:
3461: QUEUE_REDUCE (q, flushsize);
3462:
3463:
3464: /*
3465: * Since we are in a path with QUEUE_REDUCE (), check for QBACK before
3466: * unfreezing the stream.
3467: */
3468:
3469: {
3470: unsigned long back;
3471:
3472: if ((back = q->q_flag & QBACK) != 0)
3473: q->q_flag &= ~ QBACK;
3474:
3475: QUNFREEZE_TRACE (q, prev_pl);
3476:
3477: if (back)
3478: QUEUE_BACKENAB (q);
3479: }
3480: }
3481:
3482:
3483: /*
3484: *-STATUS:
3485: * DDI/DKI
3486: *
3487: *-NAME:
3488: * freeb Free a message block.
3489: *
3490: *-SYNOPSIS:
3491: * #include <sys/stream.h>
3492: *
3493: * void freeb (mblk_t * bp);
3494: *
3495: *-ARGUMENTS:
3496: * bp Pointer to the message block to be deallocated.
3497: *
3498: *-DESCRIPTION:
3499: * freeb () deallocates a message block. If the reference count of the
3500: * "db_ref" member of the "datab" structure is greater than 1, freeb ()
3501: * decrements the count and returns. Otherwise, if "db_ref" equals 1, it
3502: * deallocates the message block and the corresponding data block and the
3503: * corresponding data block and buffer.
3504: *
3505: * If the data buffer to be freed was allocated with esballoc (), the
3506: * driver is notified that the attached data buffer needs to be freed by
3507: * calling the free-routine [see free_rtn] associated with the data
3508: * buffer. Once this is accomplished, freeb () releases the STREAMS
3509: * resources associated with the buffer.
3510: *
3511: *-RETURN VALUE:
3512: * None.
3513: *
3514: *-LEVEL:
3515: * Base or interrupt.
3516: *
3517: *-NOTES:
3518: * Does not sleep.
3519: *
3520: * Driver-defined basic locks, read/write locks, and sleep locks may be
3521: * held across calls to this function.
3522: *
3523: *-SEE ALSO:
3524: * allocb (), dupb (), esballoc (), datab, free_rtn, msgb
3525: */
3526:
3527: #if __USE_PROTO__
3528: void (freeb) (mblk_t * bp)
3529: #else
3530: void
3531: freeb __ARGS ((bp))
3532: mblk_t * bp;
3533: #endif
3534: {
3535: size_t size;
3536: pl_t prev_pl;
3537: dblk_t * datap;
3538: frtn_t * frtnp = NULL;
3539:
3540:
3541: ASSERT (bp != NULL && bp->b_datap != NULL);
3542: ASSERT (bp->b_datap->db_ref > 0);
3543:
3544: datap = bp->b_datap;
3545:
3546: /*
3547: * It is expected that almost all of the calls to freeb () will result
3548: * in some memory being returned to the free pool, so to save space
3549: * and ensure correctness we lock the heap now.
3550: *
3551: * This has the advantage of serializing some of the tests below for
3552: * dealing with which parts of a message triple are free. Since the
3553: * message and data parts of a triple could be being freed
3554: * simultaneously by different contexts, this will guarantee that the
3555: * data will be freed by exactly one of the contexts.
3556: *
3557: * Another note about memory management: if the message and other
3558: * heaps are not kept separate, then some extra work needs to be done
3559: * to wake up processes sleeping for memory and for calling the
3560: * scheduled buffer events. Essentially, the systems need to map to
3561: * some common code that correctly prioritizes access and runs at an
3562: * appropriate time (possibly when some processor is about to return
3563: * to user mode from the kernel, or is totally idle).
3564: */
3565:
3566: prev_pl = LOCK (str_mem->sm_msg_lock, str_msg_pl);
3567:
3568: -- datap->db_ref;
3569:
3570: if (datap->db_ref > 0) {
3571: /*
3572: * Ok, we don't need to free the data block and buffer, but
3573: * we may still need to free the message block. This gets a
3574: * little convoluted since we might be deallocating only part
3575: * of a structure that was actually allocated as a whole by
3576: * allocb () or esballoc ().
3577: */
3578:
3579: if ((bp->b_flag & MSGTRIPLE) == 0) {
3580:
3581: STRMEM_FREE (bp, sizeof (mblk_t));
3582: goto free_done;
3583: }
3584:
3585: if ((datap = MB_TO_DB (bp))->db_ref > 0) {
3586: /*
3587: * The data block part of the triple is not free,
3588: * so we set a flag (tested when the data block is
3589: * freed).
3590: */
3591:
3592: bp->b_flag |= MSGFREE;
3593:
3594: goto free_done;
3595: }
3596:
3597: /*
3598: * If the test above was false, it arranged for the message
3599: * block to be associated with its triple partner so that
3600: * we can proceed with the freeing process.
3601: */
3602:
3603: } else if ((bp->b_flag & MSGTRIPLE) == 0) {
3604: /*
3605: * The message block isn't from the same triple as the data
3606: * block. We free the message block and then see whether the
3607: * message block from the triple with the data block is free.
3608: */
3609:
3610:
3611: STRMEM_FREE (bp, sizeof (mblk_t));
3612:
3613: bp = DB_TO_MB (datap);
3614:
3615: if ((bp->b_flag & MSGFREE) == 0) {
3616: /*
3617: * The data block part of the triple is free but the
3618: * message block isn't. The triple will be freed when
3619: * the message block is freed.
3620: */
3621:
3622: goto free_done;
3623: }
3624: }
3625:
3626:
3627: /*
3628: * Now we deal with freeing the data portion of the message. First off
3629: * we check whether or not the data block holds a user-supplied buffer
3630: * or not.
3631: */
3632:
3633: if (datap->db_base != DB_TO_DATA (datap)) {
3634: /*
3635: * Calling the user-supplied free function now would be a
3636: * really bad idea, since while all the conditions that are
3637: * guaranteed to true while the function is called are true,
3638: * we are still holding the lock on the heap. We record the
3639: * information we need and do the job later.
3640: */
3641:
3642: ASSERT (datap->db_frtnp != NULL);
3643:
3644: frtnp = datap->db_frtnp;
3645: size = 0;
3646:
3647: } else {
3648: ASSERT (datap->db_frtnp == NULL);
3649:
3650: size = datap->db_lim - datap->db_base;
3651: }
3652:
3653:
3654: /*
3655: * At this point we know we have a message block and a data block to
3656: * free, plus "size" bytes of data buffer.
3657: */
3658:
3659: STRMEM_FREE (bp, MSGB_SIZE (size));
3660:
3661: free_done:
3662: UNLOCK (str_mem->sm_msg_lock, plstr);
3663:
3664: /*
3665: * Here we call any deferred user data buffer free function
3666: */
3667:
3668: if (frtnp != NULL)
3669: (* frtnp->free_func) (frtnp->free_arg);
3670:
3671: (void) splx (prev_pl);
3672: }
3673:
3674:
3675: /*
3676: *-STATUS:
3677: * DDI/DKI
3678: *
3679: *-NAME:
3680: * freemsg Free a message.
3681: *
3682: *-SYNOPSIS:
3683: * #include <sys/stream.h>
3684: *
3685: * void freemsg (mblk_t * mp);
3686: *
3687: *-ARGUMENTS:
3688: * mp Pointer to the message to be freed.
3689: *
3690: *-DESCRIPTION:
3691: * freemsg () frees all message blocks, data blocks, and data buffers
3692: * associated with the message pointed to by "mp". freemsg () walks down
3693: * the "b_cont" list [see msgb], calling freeb () for every message block
3694: * in the message.
3695: *
3696: *-RETURN VALUE:
3697: * None.
3698: *
3699: *-LEVEL:
3700: * Base or interrupt.
3701: *
3702: *-NOTES:
3703: * Does not sleep.
3704: *
3705: * Driver-defined basic locks, read/write locks, and sleep locks may be
3706: * held across calls to this function.
3707: *
3708: *-SEE ALSO:
3709: * freeb (), msgb
3710: */
3711:
3712: #if __USE_PROTO__
3713: void (freemsg) (mblk_t * mp)
3714: #else
3715: void
3716: freemsg __ARGS ((mp))
3717: mblk_t * mp;
3718: #endif
3719: {
3720: mblk_t * next;
3721:
3722: ASSERT (mp != NULL);
3723:
3724: do {
3725: next = mp->b_cont;
3726: freeb (mp);
3727: } while ((mp = next) != NULL);
3728: }
3729:
3730:
3731: /*
3732: *-STATUS:
3733: * DDI/DKI
3734: *
3735: *-NAME:
3736: * freezestr Freeze the state of a stream.
3737: *
3738: *-SYNOPSIS:
3739: * #include <sys/types.h>
3740: * #include <sys/stream.h>
3741: *
3742: * pl_t freezestr (queue_t * q);
3743: *
3744: *-ARGUMENTS:
3745: * q Pointer to a message queue.
3746: *
3747: *-DESCRIPTION:
3748: * freezestr () sets the interrupt priority to "plstr" (if the current
3749: * level is lower than "plstr" and the implementation requires that
3750: * interrupts be blocked while the stream is frozen) and freezes the
3751: * state of the stream containing the queue specified by "q". Freezing
3752: * the stream prevents any further entries into open, close, put or
3753: * service procedures on the stream and prevents any messages from being
3754: * taken on or taken off any queues in the stream (except by the caller
3755: * of freezestr ()). Freezing the stream does not automatically stop all
3756: * functions that are running within the stream; functions will continue
3757: * to run until they attempt to perform some operation which changes the
3758: * state of the stream, at while point they will be forced to wait for
3759: * the stream to be unfrozen by a call to unfreezestr ().
3760: *
3761: * Drivers and modules must freeze the stream while they manipulate its
3762: * queues directly. This includes searching the queues and for the
3763: * duration of any calls to insq (), rmvq (), strqset (), and strqget ().
3764: *
3765: *-RETURN VALUE:
3766: * freezestr () returns the previous interrupt priority level which is
3767: * typically used in a subsequent call to unfreezestr ().
3768: *
3769: *-LEVEL:
3770: * Base or interrupt.
3771: *
3772: *-NOTES:
3773: * Does not sleep.
3774: *
3775: * Calling freezestr () to freeze a stream that is already frozen by the
3776: * caller will result in deadlock.
3777: *
3778: * Driver-defined basic locks, read/write locks, and sleep locks may be
3779: * held across calls to this function.
3780: *
3781: * freezestr () should be used sparingly as it is rarely necessary to
3782: * freeze a stream (most modules do not need to manipulate their queues
3783: * directly) and freezing a stream can have a significant negative impact
3784: * on performance.
3785: *
3786: *-SEE ALSO:
3787: * unfreezestr ()
3788: */
3789:
3790: #if __USE_PROTO__
3791: pl_t (freezestr) (queue_t * q)
3792: #else
3793: pl_t
3794: freezestr __ARGS ((q))
3795: queue_t * q;
3796: #endif
3797: {
3798: return QFREEZE_TRACE (q, "freezestr");
3799: }
3800:
3801:
3802: /*
3803: *-STATUS:
3804: * DDI/DKI
3805: *
3806: *-NAME:
3807: * getq Get the next message from a queue.
3808: *
3809: *-SYNOPSIS:
3810: * #include <sys/stream.h>
3811: *
3812: * mblk_t * getq (queue_t * q);
3813: *
3814: *-ARGUMENTS:
3815: * q Pointer to the queue from which the message is to be
3816: * retrieved.
3817: *
3818: *-DESCRIPTION:
3819: * getq () is used by service routines to retrieve queue messages. It
3820: * gets the next available message from the top of the queue pointed to
3821: * by "q". getq () handles flow control, restarting I/O that was blocked
3822: * as needed.
3823: *
3824: *-RETURN VALUE:
3825: * If there is a message to retrieve, getq () returns a pointer to it. If
3826: * no message is queued, getq () returns a NULL pointer.
3827: *
3828: *-LEVEL:
3829: * Base or interrupt.
3830: *
3831: *-NOTES:
3832: * Does not sleep.
3833: *
3834: * The caller cannot have the stream frozen [see freezestr ()] when
3835: * calling this function.
3836: *
3837: * Driver-defined basic locks, read/write locks, and sleep locks may be
3838: * held across calls to this function.
3839: *
3840: *-SEE ALSO:
3841: * bcanput (), canput (), putbq (), putq (), qenable (), rmvq ()
3842: */
3843:
3844: #if __USE_PROTO__
3845: mblk_t * (getq) (queue_t * q)
3846: #else
3847: mblk_t *
3848: getq __ARGS ((q))
3849: queue_t * q;
3850: #endif
3851: {
3852: pl_t prev_pl;
3853: mblk_t * mp;
3854:
3855: prev_pl = QFREEZE_TRACE (q, "getq");
3856:
3857: if ((mp = q->q_first) != NULL) {
3858: ulong_t msgsize;
3859:
3860: /*
3861: * There is a message. Dequeue it and adjust the flow-control
3862: * parameters appropriately depending on whether the message
3863: * is a priority message and also on the band of the message.
3864: */
3865:
3866: if ((q->q_first = mp->b_next) == NULL) {
3867:
3868: q->q_last = NULL;
3869: QUEUE_DRAINED (q);
3870: } else
3871: mp->b_next->b_prev = NULL;
3872:
3873: /*
3874: * Record the message band for the putq () enabling mechanism.
3875: */
3876:
3877: q->q_lastband = mp->b_band;
3878:
3879:
3880: /*
3881: * If the message is a priority-band message, we have to
3882: * finish up the dequeueing operation by adjusting the
3883: * "qb_first" and "qb_last" members of the "qband" structure.
3884: *
3885: * We do this below with the band flow-control management.
3886: */
3887:
3888: ASSERT (mp->b_datap != NULL);
3889:
3890: if (! IS_PRI_MSG (mp)) {
3891:
3892: msgsize = MSG_SIZE (mp);
3893:
3894: if (mp->b_band > 0) {
3895: qband_t * qbandp = QUEUE_BAND (q, mp->b_band);
3896:
3897: ASSERT (qbandp->qb_first == mp);
3898:
3899: QBAND_DEQUEUE (qbandp, mp);
3900:
3901: QBAND_REDUCE (q, qbandp, msgsize);
3902: } else
3903: QUEUE_REDUCE (q, msgsize);
3904: }
3905: } else {
3906: /*
3907: * The queue is empty; we set a flag to indicate to putq ()
3908: * that it should enable the queue when a message is put.
3909: */
3910:
3911: q->q_flag |= QWANTR;
3912: }
3913:
3914:
3915: /*
3916: * Since we are in a path with QUEUE_REDUCE (), check for QBACK before
3917: * unfreezing the stream.
3918: */
3919:
3920: {
3921: unsigned long back;
3922:
3923: if ((back = q->q_flag & QBACK) != 0)
3924: q->q_flag &= ~ QBACK;
3925:
3926: QUNFREEZE_TRACE (q, prev_pl);
3927:
3928: if (back)
3929: QUEUE_BACKENAB (q);
3930: }
3931:
3932: return mp;
3933: }
3934:
3935:
3936: /*
3937: *-STATUS:
3938: * DDI/DKI
3939: *
3940: *-NAME:
3941: * insq Insert a message into a queue.
3942: *
3943: *-SYNOPSIS:
3944: * #include <sys/stream.h>
3945: *
3946: * int insq (queue_t * q, mblk_t * emp, mblk_t * nmp);
3947: *
3948: *-ARGUMENTS:
3949: * q Pointer to the queue containing message "emp".
3950: *
3951: * emp Pointer to the existing message before which the new
3952: * message is to be inserted.
3953: *
3954: * nmp Pointer to the new message to be inserted.
3955: *
3956: *-DESCRIPTION:
3957: * insq () inserts a message into a queue. The message to be inserted,
3958: * "nmp", is placed in the queue pointer to by "q", immediately before
3959: * the message "emp". If "emp" is NULL, the new message is placed at the
3960: * end of the queue. All flow control parameters are updated. The service
3961: * procedure is scheduled to run unless disabled by a previous call to
3962: * noenable ().
3963: *
3964: * Messages are ordered in the queue based on their priority. If an
3965: * attempt is made to insert a message out of order in the queue, then
3966: * "nmp" is not enqueued.
3967: *
3968: *-RETURN VALUE:
3969: * If "nmp" was successfully enqueued, insq () returns 1. Otherwise,
3970: * insq () returns 0.
3971: *
3972: *-LEVEL:
3973: * Base or interrupt.
3974: *
3975: *-NOTES:
3976: * Does not sleep.
3977: *
3978: * The caller must have the stream frozen [see freezestr ()] when calling
3979: * this function.
3980: *
3981: * Driver-defined basic locks, read/write locks, and sleep locks may be
3982: * held across calls to this function.
3983: *
3984: * The insertion can fail if there is not enough memory to allocate the
3985: * accounting data structures used with messages whose priority bands are
3986: * greater than zero.
3987: *
3988: * If "emp" is non-NULL, it must point to a message in the queue pointed
3989: * to by "q", or a system panic could result.
3990: *
3991: *-SEE ALSO:
3992: * freezestr (), getq (), putbq (), putq (), rmvq (), unfreezestr ()
3993: */
3994:
3995: #if __USE_PROTO__
3996: int (insq) (queue_t * q, mblk_t * emp, mblk_t * nmp)
3997: #else
3998: int
3999: insq __ARGS ((q, emp, nmp))
4000: queue_t * q;
4001: mblk_t * emp;
4002: mblk_t * nmp;
4003: #endif
4004: {
4005: qband_t * qbandp;
4006:
4007: ASSERT (nmp != NULL);
4008: QFROZEN_TRACE (q, "insq");
4009:
4010:
4011: /*
4012: * The code for high-priority messages has been factored out into a
4013: * completely separate path since the legality tests are incompatible
4014: * with the regular sequence, and in addition because such messages do
4015: * not have their size accumulated in the flow control-parameters at
4016: * all, at all. The execution path here is torturous enough without
4017: * folding all the checks into a sequence with a common exit.
4018: */
4019:
4020: if (IS_PRI_MSG (nmp)) {
4021: /*
4022: * Since putq () is defined as forcing b_band to 0 for high-
4023: * priority messages, we do the same.
4024: */
4025:
4026: nmp->b_band = 0;
4027:
4028: if ((nmp->b_next = emp) == NULL) {
4029:
4030: if ((nmp->b_prev = q->q_last) == NULL) {
4031:
4032: q->q_first = nmp;
4033: } else {
4034:
4035: if (! IS_PRI_MSG (nmp->b_prev))
4036: return 0;
4037:
4038: nmp->b_prev->b_next = nmp;
4039: }
4040:
4041: q->q_last = nmp;
4042: } else {
4043:
4044: if ((nmp->b_prev = emp->b_prev) == NULL) {
4045:
4046: q->q_first = nmp;
4047: } else {
4048:
4049: if (! IS_PRI_MSG (nmp->b_prev))
4050: return 0;
4051:
4052: nmp->b_prev->b_next = nmp;
4053: }
4054:
4055: emp->b_prev = nmp;
4056:
4057: }
4058:
4059:
4060: /*
4061: * A high-priority message causes a queue to be scheduled,
4062: * even if a noenable () has been done. If we cannot schedule
4063: * the queue for some reason (it is disabled with qprocsoff ()
4064: * or has no service routine) that is not our concern.
4065: */
4066:
4067: (void) QUEUE_TRYSCHED (q);
4068: return 1;
4069: }
4070:
4071:
4072: qbandp = NULL; /* paranoia */
4073:
4074: if (nmp->b_band > 0 &&
4075: (qbandp = QUEUE_BAND (q, nmp->b_band)) == NULL &&
4076: (qbandp = QBAND_ALLOC (q, nmp->b_band)) == NULL) {
4077: /*
4078: * Return failure if we were unable to allocate a necessary
4079: * extra band structure.
4080: */
4081:
4082: return 0;
4083: }
4084:
4085:
4086: if ((nmp->b_next = emp) == NULL) {
4087:
4088: if ((nmp->b_prev = q->q_last) == NULL) {
4089:
4090: q->q_first = nmp;
4091: } else {
4092:
4093: if (nmp->b_prev->b_band < nmp->b_band)
4094: return 0;
4095:
4096: nmp->b_prev->b_next = nmp;
4097:
4098: }
4099:
4100: q->q_last = nmp;
4101:
4102: } else {
4103: /*
4104: * The check against "emp" isn't sufficient, since this
4105: * request could be attempting to insert a message in the
4106: * middle of a sequence of messages with a lower band.
4107: */
4108:
4109: if (emp->b_band > nmp->b_band || IS_PRI_MSG (emp))
4110: return 0;
4111:
4112: if ((nmp->b_prev = emp->b_prev) == NULL) {
4113:
4114: q->q_first = nmp;
4115: } else {
4116:
4117: if (nmp->b_prev->b_band < nmp->b_band)
4118: return 0;
4119:
4120: emp->b_prev->b_next = nmp;
4121: }
4122:
4123: emp->b_prev = nmp;
4124: }
4125:
4126:
4127: /*
4128: * Now update the flow control information and priority-band pointers
4129: * after possibly scheduling the queue.
4130: */
4131:
4132: if (QUEUE_CHECK_SCHED (q, nmp, qbandp)) {
4133: /*
4134: * Keep the band pointers updated.
4135: */
4136:
4137: if (qbandp->qb_first == emp)
4138: qbandp->qb_first = nmp;
4139:
4140: if (qbandp->qb_last == NULL || (qbandp->qb_last->b_next == emp))
4141: qbandp->qb_last = nmp;
4142: }
4143:
4144: return 1; /* success ! */
4145: }
4146:
4147:
4148: /*
4149: *-STATUS:
4150: * DDI/DKI
4151: *
4152: *-NAME:
4153: * linkb Concatenate two message blocks.
4154: *
4155: *-SYNOPSIS:
4156: * #include <sys/stream.h>
4157: *
4158: * void linkb (mblk_t * mp1, mblk_t * mp2);
4159: *
4160: *-ARGUMENTS:
4161: * mp1 Pointer to the message block to which "mp2" is to be
4162: * added.
4163: *
4164: * mp2 Pointer to the message to be added.
4165: *
4166: *-DESCRIPTION:
4167: * linkb () appends the message "mp2" to the tail of message "mp1". The
4168: * continuation pointer "b_cont" of the last message block in the first
4169: * message is set to point to the second message.
4170: *
4171: *-RETURN VALUE:
4172: * None.
4173: *
4174: *-LEVEL:
4175: * Base or interrupt.
4176: *
4177: *-NOTES:
4178: * Does not sleep.
4179: *
4180: * Driver-defined basic locks, read/write locks, and sleep locks may be
4181: * held across calls to this function.
4182: *
4183: *-SEE ALSO:
4184: * unlinkb (), msgb
4185: */
4186:
4187: #if __USE_PROTO__
4188: void (linkb) (mblk_t * mp1, mblk_t * mp2)
4189: #else
4190: void
4191: linkb __ARGS ((mp1, mp2))
4192: mblk_t * mp1;
4193: mblk_t * mp2;
4194: #endif
4195: {
4196: ASSERT (mp1 != NULL && mp2 != NULL);
4197:
4198: while (mp1->b_cont != NULL)
4199: mp1 = mp1->b_cont;
4200:
4201: mp1->b_cont = mp2;
4202: }
4203:
4204:
4205: /*
4206: *-STATUS:
4207: * DDI/DKI
4208: *
4209: *-NAME:
4210: * msgdsize Return number of bytes of data in a message.
4211: *
4212: *-SYNOPSIS:
4213: * #include <sys/stream.h>
4214: *
4215: * int msgdsize (mblk_t * mp);
4216: *
4217: *-ARGUMENTS:
4218: * mp Pointer to the message to be evaluated.
4219: *
4220: *-DESCRIPTION:
4221: * msgdsize () counts the number of bytes of data in the message pointed
4222: * to by "mp". Only bytes included in message blocks of type "M_DATA" are
4223: * included in the count.
4224: *
4225: *-RETURN VALUE:
4226: * The number of bytes of data in the message.
4227: *
4228: *-LEVEL:
4229: * Base or interrupt.
4230: *
4231: *-NOTES:
4232: * Does not sleep.
4233: *
4234: * Driver-defined basic locks, read/write locks, and sleep locks may be
4235: * held across calls to this function.
4236: *
4237: *-SEE ALSO:
4238: * msgb
4239: */
4240:
4241: #if __USE_PROTO__
4242: int (msgdsize) (mblk_t * mp)
4243: #else
4244: int
4245: msgdsize __ARGS ((mp))
4246: mblk_t * mp;
4247: #endif
4248: {
4249: int sum = 0;
4250:
4251: ASSERT (mp != NULL);
4252:
4253: do
4254: if (mp->b_datap->db_type == M_DATA)
4255: sum += mp->b_wptr - mp->b_rptr;
4256: while ((mp = mp->b_cont) != NULL);
4257:
4258: return sum;
4259: }
4260:
4261:
4262: /*
4263: *-STATUS:
4264: * DDI/DKI
4265: *
4266: *-NAME:
4267: * msgpullup Concatenate bytes in a message,
4268: *
4269: *-SYNOPSIS:
4270: * #include <sys/stream.h>
4271: *
4272: * mblk_t * msgpullup (mblk_t * mp, int len);
4273: *
4274: *-ARGUMENTS:
4275: * mp Pointer to the message whose blocks are to be
4276: * concatenated.
4277: *
4278: * len Number of bytes to concatenate,
4279: *
4280: *-DESCRIPTION:
4281: * msgpullup () concatenates and aligns the first "len" data bytes of the
4282: * message pointed to by "mp", copying the data into a new message. The
4283: * original message is unaltered. If "len" equals -1, all data are
4284: * concatenated. If "len" bytes of the same message type cannot be found,
4285: * msgpullup () fails and returns NULL.
4286: *
4287: *-RETURN VALUE:
4288: * On success, a pointer to the new message is returned; on failure a
4289: * NULL pointer is returned.
4290: *
4291: *-LEVEL:
4292: * Base or interrupt.
4293: *
4294: *-NOTES:
4295: * Does not sleep.
4296: *
4297: * Driver-defined basic locks, read/write locks, and sleep locks may be
4298: * held across calls to this function.
4299: *
4300: *-SEE ALSO:
4301: * allocb (), msgb
4302: */
4303:
4304: #if __USE_PROTO__
4305: mblk_t * (msgpullup) (mblk_t * mp, int len)
4306: #else
4307: mblk_t *
4308: msgpullup __ARGS ((mp, len))
4309: mblk_t * mp;
4310: int len;
4311: #endif
4312: {
4313: size_t size;
4314: uchar_t msgtype;
4315: mblk_t * scan;
4316:
4317: ASSERT (mp != NULL);
4318: ASSERT (mp->b_datap != NULL);
4319:
4320: /*
4321: * Something that is now particularly well-specified about this new
4322: * routine (intended to replace pullupmsg () from SVR3.2 STREAMS and
4323: * the SVR4 DDI/DKI) is what happens to the message data in the
4324: * original message *after* the "len" bytes to be pulled up?
4325: *
4326: * Basically, without a usage example (which I haven't been able to
4327: * find in the new SVR4 MP STREAMS programmer's guide) I can't tell
4328: * whether the remaining data in the message should be duplicated for
4329: * the new message or not. In order to make this routine a closer
4330: * functional replacement for pullupmsg (), I'm tempted to say "yes",
4331: * but it could be that the new message is a single standalone message
4332: * block. Hence, I'm putting in a switch to select between the two
4333: * interpretations I consider most likely.
4334: *
4335: * This is particularly important for "msgpullup (mp, 0)", which I'd
4336: * like to make an error.
4337: */
4338:
4339: #define MSGPULLUP_DUPMSG
4340:
4341: if (len == 0) {
4342: #ifdef MSGPULLUP_DUPMSG
4343: return dupmsg (mp);
4344: #else
4345: return MSG_ALLOC (0, BPRI_MED, KM_NOSLEEP);
4346: #endif
4347: }
4348:
4349: /*
4350: * Begin by calculating the amount of data of the same message type
4351: * that is present in the message.
4352: */
4353:
4354: msgtype = mp->b_datap->db_type;
4355: size = 0;
4356: scan = mp;
4357:
4358: do
4359: size += scan->b_wptr - scan->b_rptr;
4360: while ((scan = scan->b_cont) != NULL &&
4361: scan->b_datap->db_type == msgtype);
4362:
4363: if (len == -1)
4364: len = size;
4365: else if (len > size)
4366: return NULL;
4367:
4368: /*
4369: * Note that it may be reasonable to interpret the definition of this
4370: * function as implying that data can be shared between the old and
4371: * new message blocks if the old data block does not need to be
4372: * altered (ie, if the previous data was aligned and contiguous up to
4373: * the length "len").
4374: */
4375:
4376: /* #define MSGPULLUP_SHARE */
4377:
4378: #ifdef MSGPULLUP_SHARE
4379: if ((mp->b_wptr - mp->b_rptr) >= len &&
4380: ((ulong_t) mp->b_rptr) & (sizeof (int) - 1)) == 0)
4381: return dupmsg (mp);
4382: #endif /* defined (MSGPULLUP_SHARE) */
4383:
4384:
4385: if ((scan = MSGB_ALLOC (len, BPRI_MED, KM_NOSLEEP)) == NULL)
4386: return NULL;
4387:
4388: /*
4389: * There are some message attributes other than data that need to be
4390: * copied from the source to the new message.
4391: */
4392:
4393: scan->b_band = mp->b_band;
4394: scan->b_flag |= mp->b_flag & ~ MSGMASK_SYSTEM;
4395:
4396:
4397: /*
4398: * Now transfer the data from the old space to the new space.
4399: *
4400: * More unspecified behaviour deals with how zero-length blocks are
4401: * to be treated. The following loop is coded specifically to skip
4402: * over zero-length message blocks in the source that follow the
4403: * "len" copied bytes of data.
4404: */
4405:
4406: #define MSGPULLUP_DUPMSG
4407:
4408: while (mp != NULL) {
4409: size_t blklen = mp->b_wptr - mp->b_rptr;
4410:
4411: if (blklen > 0)
4412: memcpy (scan->b_wptr, mp->b_rptr, blklen);
4413:
4414: scan->b_wptr += blklen;
4415: len -= blklen;
4416:
4417:
4418: if (blklen > len) {
4419: /*
4420: * Copy a partial block. Since this must also be the
4421: * last message block in the source message whose
4422: * data are being moved to the new message, here is a
4423: * good place to decide on the dispensation of the
4424: * remaining data.
4425: */
4426:
4427: #ifdef MSGPULLUP_DUPMSG
4428: if ((scan->b_cont = dupmsg (mp)) == NULL) {
4429: /*
4430: * The remaining data could not be duplicated,
4431: * so we have to fail the call overall.
4432: */
4433:
4434: freeb (scan);
4435: return NULL;
4436: }
4437: #endif
4438: break;
4439: }
4440:
4441: mp = mp->b_cont;
4442: }
4443:
4444:
4445: return scan;
4446: }
4447:
4448:
4449: /*
4450: *-STATUS:
4451: * DDI/DKI
4452: *
4453: *-NAME:
4454: * noenable Prevent a queue from being scheduled.
4455: *
4456: *-SYNOPSIS:
4457: * #include <sys/stream.h>
4458: *
4459: * void noenable (queue_t * q);
4460: *
4461: *-ARGUMENTS:
4462: * q Pointer to the queue.
4463: *
4464: *-DESCRIPTION:
4465: * The noenable () function prevents the service routine of the queue
4466: * pointed to by "q" from being scheduled for service by insq (),
4467: * putbq (), or putq () when enqueuing a message that is not a high
4468: * priority message. This restriction can be lifted with the enableok ()
4469: * function.
4470: *
4471: * noenable () does not prevent the queue's service routine from being
4472: * scheduled when a high priority message is enqueued, or by an explicit
4473: * call to qenable ().
4474: *
4475: *-RETURN VALUE:
4476: * None.
4477: *
4478: *-LEVEL:
4479: * Base or interrupt.
4480: *
4481: *-NOTES:
4482: * Does not sleep.
4483: *
4484: * The caller cannot have the stream frozen [see freezestr ()] when
4485: * calling this function.
4486: *
4487: * Driver-defined basic locks, read/write locks, and sleep locks may be
4488: * held across calls to this function.
4489: *
4490: *-SEE ALSO:
4491: * enableok (), insq (), putbq (), putq (), qenable (), queue
4492: */
4493:
4494: #if __USE_PROTO__
4495: void (noenable) (queue_t * q)
4496: #else
4497: void
4498: noenable __ARGS ((q))
4499: queue_t * q;
4500: #endif
4501: {
4502: pl_t prev_pl;
4503:
4504: prev_pl = QFREEZE_TRACE (q, "noenable");
4505:
4506: q->q_flag |= QNOENB;
4507:
4508: QUNFREEZE_TRACE (q, prev_pl);
4509: }
4510:
4511:
4512: /*
4513: *-STATUS:
4514: * DDI/DKI
4515: *
4516: *-NAME:
4517: * OTHERQ Get pointer to queue's partner queue.
4518: *
4519: *-SYNOPSIS:
4520: * #include <sys/stream.h>
4521: *
4522: * queue_t * OTHERQ (queue_t * q);
4523: *
4524: *-ARGUMENTS:
4525: * q Pointer to the queue.
4526: *
4527: *-DESCRIPTION:
4528: * The OTHERQ () function returns a pointer to the other of the two
4529: * queue structures that make up an instance of a STREAMS module or
4530: * driver. If "q" points to the read queue the write queue will be
4531: * returned, and vice versa.
4532: *
4533: *-RETURN VALUE:
4534: * OTHERQ () returns a pointer to the queue's partner.
4535: *
4536: *-LEVEL:
4537: * Base or interrupt.
4538: *
4539: *-NOTES:
4540: * Does not sleep.
4541: *
4542: * Driver-defined basic locks, read/write locks, and sleep locks may be
4543: * held across calls to this function.
4544: *
4545: *-SEE ALSO:
4546: * RD (), WR ()
4547: */
4548:
4549: #if __USE_PROTO__
4550: queue_t * (OTHERQ) (queue_t * q)
4551: #else
4552: queue_t *
4553: OTHERQ __ARGS ((q))
4554: queue_t * q;
4555: #endif
4556: {
4557: return OTHERQ (q);
4558: }
4559:
4560:
4561: /*
4562: *-STATUS:
4563: * DDI/DKI
4564: *
4565: *-NAME:
4566: * pcmsg Test whether a message is a priority control message.
4567: *
4568: *-SYNOPSIS:
4569: * #include <sys/types.h>
4570: * #include <sys/stream.h>
4571: * #include <sys/ddi.h>
4572: *
4573: * int pcmsg (uchar_t type);
4574: *
4575: *-ARGUMENTS:
4576: * type The type of message to be tested.
4577: *
4578: *-DESCRIPTION:
4579: * The pcmsg () function tests the type of message to determine if it is
4580: * a priority control message (also known as a high priority message).
4581: * The "db_type" field of the "datab" structure contains the message
4582: * type. This field may be accessed through the message block using
4583: * "mp->b_datap->db_type".
4584: *
4585: *-RETURN VALUE:
4586: * pcmsg () returns 1 if the message is a priority control message and
4587: * 0 if the message is any other type.
4588: *
4589: *-LEVEL:
4590: * Base or interrupt.
4591: *
4592: *-NOTES:
4593: * Does not sleep.
4594: *
4595: * Driver-defined basic locks, read/write locks, and sleep locks may be
4596: * held across calls to this function.
4597: *
4598: *-SEE ALSO:
4599: * allocb (), datab, msgb, messages
4600: */
4601:
4602: #if __USE_PROTO__
4603: int (pcmsg) (uchar_t type)
4604: #else
4605: int
4606: pcmsg __ARGS ((type))
4607: uchar_t type;
4608: #endif
4609: {
4610: return pcmsg (type);
4611: }
4612:
4613:
4614: /*
4615: *-STATUS:
4616: * Compatibility (pre-MP DDI/DKI)
4617: *
4618: *-NAME:
4619: * pullupmsg Concatenate bytes in a message.
4620: *
4621: *-SYNOPSIS:
4622: * #include <sys/stream.h>
4623: *
4624: * int pullupmsg (mblk_t * mp, int len);
4625: *
4626: *-ARGUMENTS:
4627: * mp Pointer to the message whose blocks are to be
4628: * concatenated.
4629: *
4630: * len Number of bytes to concatenate.
4631: *
4632: *-DESCRIPTION:
4633: * pullupmsg () tries to combine multiple data blocks into a single
4634: * block. pullupmsg () concatenates and aligns the first "len" data bytes
4635: * of the message pointed to by "mp". If "len" equals -1, all data is
4636: * concatenated. If "len" bytes of the same message type cannot be found,
4637: * pullupmsg () fails and returns 0.
4638: *
4639: *-RETURN VALUE:
4640: * On success, 1 is returned; on failure, 0 is returned.
4641: *
4642: *-LEVEL:
4643: * Base or interrupt.
4644: *
4645: *-NOTES:
4646: * Does not sleep.
4647: *
4648: * Driver-defined basic locks, read/write locks, and sleep locks may be
4649: * held across calls to this function.
4650: *
4651: * This function is provided for compatibility with versions of the
4652: * DDI/DKI prior to the System V, Release 4 Multiprocessor edition. Calls
4653: * to this function should be replaced by calls to the msgpullup ()
4654: * function instead.
4655: *
4656: *-SEE ALSO:
4657: * allocb (), msgpullup ()
4658: */
4659:
4660: #if __USE_PROTO__
4661: int (pullupmsg) (mblk_t * mp, int len)
4662: #else
4663: int
4664: pullupmsg __ARGS ((mp, len))
4665: mblk_t * mp;
4666: int len;
4667: #endif
4668: {
4669: mblk_t * newmsg;
4670:
4671: ASSERT (mp != NULL);
4672: ASSERT (mp->b_datap != NULL);
4673:
4674: /*
4675: * If the first block of the old message is sufficiently large to
4676: * encompass the pullup request, then we need do no work. It is not
4677: * clear whether the new msgpullup () function allows this simple
4678: * optimisation, so we test for this here to guarantee it.
4679: */
4680:
4681: if (((mp->b_wptr - mp->b_rptr) > len ||
4682: (len == -1 && mp->b_cont == NULL)) &&
4683: ((ulong_t) mp->b_rptr & (sizeof (int) - 1)) == 0) {
4684: /*
4685: * Do nothing and return success. Note that the alignment test
4686: * above is specific to the i386 implementation.
4687: */
4688:
4689: return 1;
4690: }
4691:
4692:
4693: /*
4694: * Now use the new msgpullup () function to perform the harder task
4695: * of concatenating the message, and then perform some subterfuge to
4696: * ensure that the new message replaces the old message's storage.
4697: *
4698: * This requires some delicate manipulations to avoid disrupting
4699: * the flags and whatnot that support the message-triple storage
4700: * system.
4701: */
4702:
4703: if ((newmsg = msgpullup (mp, len)) == NULL)
4704: return 0;
4705:
4706:
4707: {
4708: dblk_t * temp = mp->b_datap;
4709: mp->b_datap = newmsg->b_datap;
4710: newmsg->b_datap = temp;
4711: } {
4712: mblk_t * temp = mp->b_cont;
4713: mp->b_cont = newmsg->b_cont;
4714: newmsg->b_cont = temp;
4715: }
4716:
4717: mp->b_rptr = newmsg->b_rptr;
4718: mp->b_wptr = newmsg->b_wptr;
4719:
4720: /*
4721: * Since we exchanged the "b_datap" and "b_cont" members of the
4722: * message blocks, freeing the "new" message pointer will free those
4723: * elements of the original message that have been made redundant by
4724: * the pull-up operation, leaving the original message block intact
4725: * but pointing to the rearranged data.
4726: */
4727:
4728: freemsg (newmsg);
4729: return 1;
4730: }
4731:
4732:
4733: /*
4734: *-STATUS:
4735: * DDI/DKI
4736: *
4737: *-NAME:
4738: * put Call a put procedure.
4739: *
4740: *-SYNOPSIS:
4741: * #include <sys/stream.h>
4742: *
4743: * void put (queue_t * q, mblk_t * mp);
4744: *
4745: *-ARGUMENTS:
4746: * q Pointer to a message queue.
4747: *
4748: * mp Pointer to the message block being passed.
4749: *
4750: *-DESCRIPTION:
4751: * put () calls the "put" procedure for the queue specified by "q",
4752: * passing it the arguments "q" and "mp". It is typically used by a
4753: * driver or module to call its own "put" procedure so that the proper
4754: * accounting is done in the stream.
4755: *
4756: *-RETURN VALUE:
4757: * None.
4758: *
4759: *-LEVEL:
4760: * Base or interrupt.
4761: *
4762: *-NOTES:
4763: * Does not sleep.
4764: *
4765: * The caller cannot have the stream frozen [see freezestr ()] when
4766: * calling this function.
4767: *
4768: * Driver-defined basic locks, read/write locks, and sleep locks may be
4769: * held across calls to this function.
4770: *
4771: * DDI/DKI conforming drivers and modules are no longer permitted to call
4772: * "put" procedures directly, but must call through the appropriate
4773: * STREAMS utility function - for example, put (), putnext (), putctl (),
4774: * putnextctl (), or qreply (). "put (q, mp)" is provided as a DDI/DKI-
4775: * conforming equivalent to a direct call to a "put" procedure, which is
4776: * no longer allowed.
4777: *
4778: *-SEE ALSO:
4779: * putctl (), putctl1 (), putnext (), putnextctl (), putnextctl1 (),
4780: * qreply ()
4781: */
4782:
4783: #if __USE_PROTO__
4784: void (put) (queue_t * q, mblk_t * mp)
4785: #else
4786: void
4787: put __ARGS ((q, mp))
4788: queue_t * q;
4789: mblk_t * mp;
4790: #endif
4791: {
4792: pl_t prev_pl;
4793:
4794: ASSERT (mp != NULL);
4795: ASSERT (mp->b_datap != NULL);
4796:
4797: /*
4798: * If a message is put to a queue that either has no put procedure at
4799: * all, or has been disabled with qprocsoff (), then we discard the
4800: * message and return without doing anything.
4801: */
4802:
4803: prev_pl = QFREEZE_TRACE (q, "put");
4804:
4805: if ((q->q_active == 0 && (q->q_flag & QPROCSOFF) != 0) ||
4806: q->q_qinfo->qi_putp == NULL)
4807: cmn_err (CE_WARN, "put () to disabled queue/NULL putp");
4808: else
4809: QUEUE_PUT (q, mp, prev_pl);
4810:
4811: QUNFREEZE_TRACE (q, prev_pl);
4812: }
4813:
4814:
4815: /*
4816: *-STATUS:
4817: * DDI/DKI
4818: *
4819: *-NAME:
4820: * putbq Place a message at the head of a queue.
4821: *
4822: *-SYNOPSIS:
4823: * #include <sys/stream.h>
4824: *
4825: * int putbq (queue_t * q, mblk_t * mp);
4826: *
4827: *-ARGUMENTS:
4828: * q Pointer to the queue.
4829: *
4830: * mp Pointer to the message.
4831: *
4832: *-DESCRIPTION:
4833: * putbq () puts a message back at the head of the queue. If messages of
4834: * a higher priority are present on the queue, then "bp" is placed at the
4835: * head of its corresponding priority band.
4836: *
4837: * All flow control parameters are updated. The queue's service routine
4838: * is scheduled if it has not been disabled by a previous call to
4839: * noenable ().
4840: *
4841: * putbq () is usually called when bcanputnext () or canputnext ()
4842: * determines that the message cannot be passed on to the next stream
4843: * component.
4844: *
4845: *-RETURN VALUE:
4846: * putbq () returns 1 on success and 0 on failure.
4847: *
4848: *-LEVEL:
4849: * Base or interrupt.
4850: *
4851: *-NOTES:
4852: * Does not sleep.
4853: *
4854: * The caller cannot have the stream frozen [see freezestr ()] when
4855: * calling this function.
4856: *
4857: * Driver-defined basic locks, read/write locks, and sleep locks may be
4858: * held across calls to this function.
4859: *
4860: * putbq () can fail if there is not enough memory to allocate the
4861: * accounting data structures used with messages whose priority bands are
4862: * greater than zero.
4863: *
4864: * High priority messages should never be put back on a queue from within
4865: * a service routine.
4866: *
4867: *-SEE ALSO:
4868: * bcanputnext (), canputnext (), getq (), insq (), putq (), rmvq (),
4869: * msgb, queue
4870: */
4871:
4872: #if __USE_PROTO__
4873: int (putbq) (queue_t * q, mblk_t * mp)
4874: #else
4875: int
4876: putbq __ARGS ((q, mp))
4877: queue_t * q;
4878: mblk_t * mp;
4879: #endif
4880: {
4881: pl_t prev_pl;
4882: qband_t * qbandp;
4883:
4884: ASSERT (mp != NULL);
4885: ASSERT (mp->b_datap != NULL);
4886: ASSERT (! pcmsg (mp->b_datap->db_type));
4887:
4888: prev_pl = QFREEZE_TRACE (q, "putbq");
4889:
4890: /*
4891: * The code for high-priority messages has been factored out into a
4892: * completely separate path because such messages do not have their
4893: * size accumulated in the flow control-parameters at all, at all, and
4894: * because the location where such messages are to be queued is
4895: * determined in one step without search.
4896: */
4897:
4898: if (IS_PRI_MSG (mp)) {
4899: /*
4900: * Since putq () is defined as forcing b_band to 0 for high-
4901: * priority messages, we do the same.
4902: */
4903:
4904: if ((mp->b_next = q->q_first) == NULL)
4905: q->q_last = mp;
4906: else
4907: mp->b_next->b_prev = mp;
4908:
4909: mp->b_prev = NULL;
4910: mp->b_band = 0;
4911: q->q_first = mp;
4912:
4913:
4914: /*
4915: * A high-priority message causes a queue to be scheduled
4916: * even if a noenable () has been performed. For putbq (),
4917: * this is true whether or not the condition set by getq ()
4918: * returning null is true or not, which is the reason for the
4919: * proscription against calling this routine for a high-
4920: * priority message within a service procedure.
4921: */
4922:
4923: /*
4924: *!!! We need help from the STREAMS service-routine scheduler
4925: *!!! to build a testable assertion for detecting when we are
4926: *!!! called within the context of a service routine.
4927: */
4928:
4929: (void) QUEUE_TRYSCHED (q);
4930: goto alldone;
4931: }
4932:
4933:
4934: qbandp = NULL; /* paranoia */
4935:
4936: if (mp->b_band > 0 &&
4937: (qbandp = QUEUE_BAND (q, mp->b_band)) == NULL &&
4938: (qbandp = QBAND_ALLOC (q, mp->b_band)) == NULL)
4939: return 0;
4940: else if (QUEUE_CHECK_SCHED (q, mp, qbandp)) {
4941: /*
4942: * Deal with band pointer maintenance now.
4943: */
4944:
4945: if ((mp->b_next = qbandp->qb_first) != NULL) {
4946: /*
4947: * We directly know where we want to put the message.
4948: */
4949:
4950: if ((mp->b_prev = mp->b_next->b_prev) == NULL)
4951: q->q_first = mp;
4952: else
4953: mp->b_prev->b_next = mp;
4954:
4955: mp->b_next->b_prev = mp;
4956:
4957: qbandp->qb_first = mp;
4958:
4959: goto alldone;
4960: }
4961:
4962:
4963: /*
4964: * This is the only message in this band. We will need to
4965: * search for the correct position to queue this message.
4966: */
4967:
4968: qbandp->qb_last = qbandp->qb_first = mp;
4969: }
4970:
4971:
4972: /*
4973: * Now use a brute-force search for the position. We could use the
4974: * band structures to speed this up, but we anticipate that there will
4975: * be few band or high-priority messages, so that a brute-force search
4976: * will be suitably short.
4977: */
4978:
4979: QUEUE_PLACE_MSG (q, mp, mp->b_band);
4980:
4981: alldone:
4982: QUNFREEZE_TRACE (q, prev_pl);
4983: return 1;
4984: }
4985:
4986:
4987: /*
4988: *-STATUS:
4989: * DDI/DKI
4990: *
4991: *-NAME:
4992: * putctl Send a control message to a queue.
4993: *
4994: *-SYNOPSIS:
4995: * #include <sys/stream.h>
4996: *
4997: * int putctl (queue_t * q, int type);
4998: *
4999: *-ARGUMENTS:
5000: * q Pointer to the queue to which the message is to be
5001: * sent.
5002: *
5003: * type Message type (must be control).
5004: *
5005: *-DESCRIPTION:
5006: * putctl () tests the "type" argument to make sure a data type has not
5007: * been specified, and then attempts to allocate a message block.
5008: * putctl () fails if "type" is M_DATA, M_PROTO, or M_PCPROTO, or if a
5009: * message block cannot be allocated. If successful, putctl () calls the
5010: * "put" routine of the queue pointed to by "q", passing it the allocated
5011: * message.
5012: *
5013: *-RETURN VALUE:
5014: * On success, 1 is returned. Otherwise, if "type" is a data type, or if
5015: * a message block cannot be allocated, 0 is returned.
5016: *
5017: *-LEVEL:
5018: * Base or interrupt.
5019: *
5020: *-NOTES:
5021: * Does not sleep.
5022: *
5023: * The caller cannot have the stream frozen [see freezestr ()] when
5024: * calling this function.
5025: *
5026: * Driver-defined basic locks, read/write locks, and sleep locks may be
5027: * held across calls to this function.
5028: *
5029: * The "q" argument to putctl () and putnextctl () may not reference
5030: * "q_next" (eg, an argument of "q->q_next" is erroneous on a
5031: * multiprocessor and is disallowed by the DDI/DKI).
5032: * "putnextctl (q, type)" is provided as a multiprocessor-safe equivalent
5033: * to the common call "putctl (q->q_next, type)" which is no longer
5034: * allowed.
5035: *
5036: *-SEE ALSO:
5037: * put (), putctl1 (), putnextctl (), putnextctl1 ()
5038: */
5039:
5040: #if __USE_PROTO__
5041: int (putctl) (queue_t * q, int type)
5042: #else
5043: int
5044: putctl __ARGS ((q, type))
5045: queue_t * q;
5046: int type;
5047: #endif
5048: {
5049: mblk_t * ctlmsg;
5050:
5051: QUEUE_TRACE (q, "putctl");
5052:
5053: /*
5054: * We cannot use datamsg () to test the type because datamsg () is
5055: * specified as testing for M_DATA in addition to M_DATA, M_PROTO, and
5056: * M_PCPROTO.
5057: */
5058:
5059: if ((type & (M_PRI - 1)) <= M_PROTO ||
5060: (ctlmsg = MSGB_ALLOC (0, BPRI_HI, KM_NOSLEEP)) == NULL)
5061: return 0;
5062:
5063: ctlmsg->b_datap->db_type = type;
5064: put (q, ctlmsg);
5065:
5066: return 1;
5067: }
5068:
5069:
5070: /*
5071: *-STATUS:
5072: * DDI/DKI
5073: *
5074: *-NAME:
5075: * putctl1 Send a control message with a one-byte parameter to a
5076: * queue.
5077: *
5078: *-SYNOPSIS:
5079: * #include <sys/stream.h>
5080: *
5081: * int putctl1 (queue_t * q, int type, int param);
5082: *
5083: *-ARGUMENTS:
5084: * q Pointer to the queue to which the message is to be
5085: * sent.
5086: *
5087: * type Message type (must be control).
5088: *
5089: * param One-byte parameter.
5090: *
5091: *-DESCRIPTION:
5092: * putctl1 (), like putctl (), tests the "type" argument to make sure a
5093: * data type has not been specified, and attempts to allocate a message
5094: * block. The "param" parameter can be used, for example, to specify the
5095: * signal number when an "M_PCSIG" message is being sent. putctl1 ()
5096: * fails if "type" is M_DATA, M_PROTO, or M_PCPROTO, or if a message
5097: * block cannot be allocated. If successful, putctl1 () calls the "put"
5098: * routine of the queue pointed to by "q", passing it the allocated
5099: * message.
5100: *
5101: *-RETURN VALUE:
5102: * On success, 1 is returned. Otherwise, if "type" is a data type, or if
5103: * a message block cannot be allocated, 0 is returned.
5104: *
5105: *-LEVEL:
5106: * Base or interrupt.
5107: *
5108: *-NOTES:
5109: * Does not sleep.
5110: *
5111: * The caller cannot have the stream frozen [see freezestr ()] when
5112: * calling this function.
5113: *
5114: * Driver-defined basic locks, read/write locks, and sleep locks may be
5115: * held across calls to this function.
5116: *
5117: * The "q" argument to putctl1 () and putnextctl1 () may not reference
5118: * "q_next" (eg, an argument of "q->q_next" is erroneous on a
5119: * multiprocessor and is disallowed by the DDI/DKI).
5120: * "putnextctl1 (q, type)" is provided as a multiprocessor-safe
5121: * equivalent to the common call "putctl1 (q->q_next, type)" which is no
5122: * longer allowed.
5123: *
5124: *-SEE ALSO:
5125: * put (), putctl (), putnextctl (), putnextctl1 ()
5126: */
5127:
5128: #if __USE_PROTO__
5129: int (putctl1) (queue_t * q, int type, int param)
5130: #else
5131: int
5132: putctl1 __ARGS ((q, type, param))
5133: queue_t * q;
5134: int type;
5135: int param;
5136: #endif
5137: {
5138: mblk_t * ctlmsg;
5139:
5140: QUEUE_TRACE (q, "putctl1");
5141:
5142: /*
5143: * We cannot use datamsg () to test the type because datamsg () is
5144: * specified as testing for M_DATA in addition to M_DATA, M_PROTO, and
5145: * M_PCPROTO.
5146: */
5147:
5148: if ((type & (M_PRI - 1)) <= M_PROTO ||
5149: (ctlmsg = MSGB_ALLOC (1, BPRI_HI, KM_NOSLEEP)) == NULL)
5150: return 0;
5151:
5152: ctlmsg->b_datap->db_type = type;
5153: * ctlmsg->b_wptr ++ = (unsigned char) param;
5154:
5155: put (q, ctlmsg);
5156:
5157: return 1;
5158: }
5159:
5160:
5161: /*
5162: *-STATUS:
5163: * DDI/DKI
5164: *
5165: *-NAME:
5166: * putnext Send a message to the next queue.
5167: *
5168: *-SYNOPSIS:
5169: * #include <sys/stream.h>
5170: *
5171: * int putnext (queue_t * q, mblk_t * mp);
5172: *
5173: *-ARGUMENTS:
5174: * q Pointer to the queue from which the message "mp" will
5175: * be sent.
5176: *
5177: * mp Pointer to the message to be passed.
5178: *
5179: *-DESCRIPTION:
5180: * The putnext () function is used to pass a message to the "put" routine
5181: * of the next queue ("q->q_next") in the stream.
5182: *
5183: *-RETURN VALUE:
5184: * Ignored.
5185: *
5186: *-LEVEL:
5187: * Base or interrupt.
5188: *
5189: *-NOTES:
5190: * Does not sleep.
5191: *
5192: * The caller cannot have the stream frozen [see freezestr ()] when
5193: * calling this function.
5194: *
5195: * Driver-defined basic locks, read/write locks, and sleep locks may be
5196: * held across calls to this function.
5197: *
5198: *-SEE ALSO:
5199: * putnextctl (), putnextctl1 ()
5200: */
5201:
5202: #if __USE_PROTO__
5203: int (putnext) (queue_t * q, mblk_t * mp)
5204: #else
5205: int
5206: putnext __ARGS ((q, mp))
5207: queue_t * q;
5208: mblk_t * mp;
5209: #endif
5210: {
5211: QUEUE_TRACE (q, "putnext");
5212:
5213: QUEUE_PUTNEXT (q, mp);
5214:
5215: return 0;
5216: }
5217:
5218:
5219: /*
5220: *-STATUS:
5221: * DDI/DKI
5222: *
5223: *-NAME:
5224: * putnextctl Send a control message to a queue.
5225: *
5226: *-SYNOPSIS:
5227: * #include <sys/stream.h>
5228: *
5229: * int putnextctl (queue_t * q, int type);
5230: *
5231: *-ARGUMENTS:
5232: * q Pointer to the queue from which the message is to be
5233: * sent.
5234: *
5235: * type Message type (must be control type).
5236: *
5237: *-DESCRIPTION:
5238: * putnextctl () tests the "type" argument to make sure a data type has
5239: * been specified, and then attempts to allocate a message block.
5240: * putnextctl () fails if "type" is M_DATA, M_PROTO, or M_PCPROTO, or
5241: * if a message block cannot be allocated. If successful, putnextctl ()
5242: * calls the "put" procedure of the queue pointed to by "q->q_next",
5243: * passing it the allocated message.
5244: *
5245: *-RETURN VALUE:
5246: * Upon successful completion, putnextctl () returns 1. If "type" is a
5247: * data type, or if a message block cannot be allocated, 0 is returned.
5248: *
5249: *-LEVEL:
5250: * Base or interrupt.
5251: *
5252: *-NOTES:
5253: * Does not sleep.
5254: *
5255: * The caller cannot have the stream frozen [see freezestr ()] when
5256: * calling this function.
5257: *
5258: * Driver-defined basic locks, read/write locks, and sleep locks may be
5259: * held across calls to this function.
5260: *
5261: * The "q" argument to putctl () and putnextctl () may not reference
5262: * "q_next" (eg, an argument of "q->q_next" is erroneous on a
5263: * multiprocessor and is disallowed by the DDI/DKI).
5264: * "putnextctl (q, type)" is provided as a multiprocessor-safe equivalent
5265: * to the common call "putctl (q->q_next, type)" which is no longer
5266: * allowed.
5267: *
5268: *-SEE ALSO:
5269: * put (), putctl (), putctl1 (), putnextctl1 ()
5270: */
5271:
5272: #if __USE_PROTO__
5273: int (putnextctl) (queue_t * q, int type)
5274: #else
5275: int
5276: putnextctl __ARGS ((q, type))
5277: queue_t * q;
5278: int type;
5279: #endif
5280: {
5281: mblk_t * ctlmsg;
5282:
5283: QUEUE_TRACE (q, "putnextctl");
5284:
5285: /*
5286: * We cannot use datamsg () to test the type because datamsg () is
5287: * specified as testing for M_DATA in addition to M_DATA, M_PROTO, and
5288: * M_PCPROTO.
5289: */
5290:
5291: if ((type & (M_PRI - 1)) <= M_PROTO ||
5292: (ctlmsg = MSGB_ALLOC (0, BPRI_HI, KM_NOSLEEP)) == NULL)
5293: return 0;
5294:
5295: ctlmsg->b_datap->db_type = type;
5296:
5297: QUEUE_PUTNEXT (q, ctlmsg);
5298:
5299: return 1;
5300: }
5301:
5302:
5303: /*
5304: *-STATUS:
5305: * DDI/DKI
5306: *
5307: *-NAME:
5308: * putnextctl1 Send a control message with a one-byte parameter to a
5309: * queue.
5310: *
5311: *-SYNOPSIS:
5312: * #include <sys/stream.h>
5313: *
5314: * int putctl1 (queue_t * q, int type, int param);
5315: *
5316: *-ARGUMENTS:
5317: * q Pointer to the queue from which the message is to be
5318: * sent.
5319: *
5320: * type Message type (must be control).
5321: *
5322: * param One-byte parameter.
5323: *
5324: *-DESCRIPTION:
5325: * putnextctl1 () tests the "type" argument to make sure a data type has
5326: * not been specified, and attempts to allocate a message block.
5327: * putnext ctl1 () fails if "type" is M_DATA, M_PROTO, or M_PCPROTO, or
5328: * if a message block cannot be allocated. If successful, putctl1 ()
5329: * calls the "put" routine of the queue pointed to by "q->q_next",
5330: * passing it the allocated message with the one byte parameter specified
5331: * by "param".
5332: *
5333: *-RETURN VALUE:
5334: * Upon successful completion, putnextctl1 () returns 1. If "type" is a
5335: & data type, or if a message block cannot be allocated, 0 is returned.
5336: *
5337: *-LEVEL:
5338: * Base or interrupt.
5339: *
5340: *-NOTES:
5341: * Does not sleep.
5342: *
5343: * The caller cannot have the stream frozen [see freezestr ()] when
5344: * calling this function.
5345: *
5346: * Driver-defined basic locks, read/write locks, and sleep locks may be
5347: * held across calls to this function.
5348: *
5349: * The "q" argument to putctl1 () and putnextctl1 () may not reference
5350: * "q_next" (eg, an argument of "q->q_next" is erroneous on a
5351: * multiprocessor and is disallowed by the DDI/DKI).
5352: * "putnextctl1 (q, type)" is provided as a multiprocessor-safe
5353: * equivalent to the common call "putctl1 (q->q_next, type)" which is no
5354: * longer allowed.
5355: *
5356: *-SEE ALSO:
5357: * put (), putctl (), putctl1 (), putnextctl ()
5358: */
5359:
5360: #if __USE_PROTO__
5361: int (putnextctl1) (queue_t * q, int type, int param)
5362: #else
5363: int
5364: putnextctl1 __ARGS ((q, type, param))
5365: queue_t * q;
5366: int type;
5367: int param;
5368: #endif
5369: {
5370: mblk_t * ctlmsg;
5371:
5372: QUEUE_TRACE (q, "putnextctl1");
5373:
5374: /*
5375: * We cannot use datamsg () to test the type because datamsg () is
5376: * specified as testing for M_DATA in addition to M_DATA, M_PROTO, and
5377: * M_PCPROTO.
5378: */
5379:
5380: if ((type & (M_PRI - 1)) <= M_PROTO ||
5381: (ctlmsg = MSGB_ALLOC (1, BPRI_HI, KM_NOSLEEP)) == NULL)
5382: return 0;
5383:
5384: ctlmsg->b_datap->db_type = type;
5385: * ctlmsg->b_wptr ++ = (unsigned char) param;
5386:
5387: QUEUE_PUTNEXT (q, ctlmsg);
5388:
5389: return 1;
5390: }
5391:
5392:
5393: /*
5394: *-STATUS:
5395: * DDI/DKI
5396: *
5397: *-NAME:
5398: * putq Put a message to a queue.
5399: *
5400: *-SYNOPSIS:
5401: * #include <sys/stream.h>
5402: *
5403: * int putq (queue_t * q, mblk_t * mp);
5404: *
5405: *-ARGUMENTS:
5406: * q Pointer to the queue.
5407: *
5408: * mp Pointer to the message.
5409: *
5410: *-DESCRIPTION:
5411: * putq () is used to put messages on a queue after the "put" routine has
5412: * finished processing the message. The message is placed after any other
5413: * messages of the same priority, and flow control parameters are
5414: * updated. The queue's service routine is scheduled if it has not been
5415: * disabled by a previous call to noenable ().
5416: *
5417: *-RETURN VALUE:
5418: * putq () returns 1 on success and 0 on failure.
5419: *
5420: *-LEVEL:
5421: * Base or interrupt.
5422: *
5423: *-NOTES:
5424: * Does not sleep.
5425: *
5426: * The caller cannot have the stream frozen [see freezestr ()] when
5427: * calling this function.
5428: *
5429: * Driver-defined basic locks, read/write locks, and sleep locks may be
5430: * held across calls to this function.
5431: *
5432: * putq () can fail if there is not enough memory to allocate the
5433: * accounting data structures used with messages whose priority bands are
5434: * greater than zero.
5435: *
5436: *-SEE ALSO:
5437: * getq (), insq (), putbq (), rmvq (), msgb, queue
5438: */
5439:
5440: #if __USE_PROTO__
5441: int (putq) (queue_t * q, mblk_t * mp)
5442: #else
5443: int
5444: putq __ARGS ((q, mp))
5445: queue_t * q;
5446: mblk_t * mp;
5447: #endif
5448: {
5449: pl_t prev_pl;
5450: qband_t * qbandp;
5451:
5452: ASSERT (mp != NULL);
5453: ASSERT (mp->b_datap != NULL);
5454:
5455: prev_pl = QFREEZE_TRACE (q, "putq");
5456:
5457: if (IS_PRI_MSG (mp)) {
5458: /*
5459: * Since putq () is defined as forcing b_band to 0 for high-
5460: * priority messages, we do the same. In addition, we also
5461: * always schedule the queue. No flow-control parameters are
5462: * updated for high-priority messages.
5463: */
5464:
5465: mp->b_band = 0;
5466: (void) QUEUE_TRYSCHED (q);
5467:
5468: /*
5469: * We need to flow into the code that finds the correct
5470: * insertion point for high-priority and band messages.
5471: */
5472: } else if (qbandp = NULL, mp->b_band > 0 &&
5473: (qbandp = QUEUE_BAND (q, mp->b_band)) == NULL &&
5474: (qbandp = QBAND_ALLOC (q, mp->b_band)) == NULL)
5475: return 0;
5476: else if (QUEUE_CHECK_SCHED (q, mp, qbandp)) {
5477: /*
5478: * Deal with band pointer maintenance now.
5479: */
5480:
5481: if ((mp->b_next = qbandp->qb_first) != NULL) {
5482: /*
5483: * We directly know where we want to put the message.
5484: */
5485:
5486: if ((mp->b_prev = mp->b_next->b_prev) == NULL)
5487: q->q_first = mp;
5488: else
5489: mp->b_prev->b_next = mp;
5490:
5491: mp->b_next->b_prev = mp;
5492:
5493: qbandp->qb_first = mp;
5494:
5495: goto alldone;
5496: }
5497:
5498: /*
5499: * This is the only message in this band. We will need to
5500: * search for the correct position to queue this message.
5501: */
5502:
5503: qbandp->qb_last = qbandp->qb_first = mp;
5504: } else {
5505: /*
5506: * Since we will always be inserting at the end of the queue,
5507: * we directly know where we will be inserting the new
5508: * message.
5509: */
5510:
5511: mp->b_next = NULL;
5512:
5513: if ((mp->b_prev = q->q_last) == NULL)
5514: q->q_first = mp;
5515: else
5516: mp->b_prev->b_next = mp;
5517:
5518: q->q_last = mp;
5519:
5520: goto alldone;
5521: }
5522:
5523:
5524: /*
5525: * Since we want to insert after other messages with the same band
5526: * number, we adjust the band down by one. This introduces a special
5527: * case for high-priority messages, which we want to queue before all
5528: * normal messages. Since we define high-priority messages as having
5529: * a band number of 0, subtracting one makes the band value wrap
5530: * around, yielding the desired behaviour.
5531: */
5532:
5533: QUEUE_PLACE_MSG (q, mp, mp->b_band - 1);
5534:
5535: alldone:
5536: QUNFREEZE_TRACE (q, prev_pl);
5537: return 1;
5538: }
5539:
5540:
5541: /*
5542: *-STATUS:
5543: * DDI/DKI
5544: *
5545: *-NAME:
5546: * qenable Schedule a queue's service routine to be run.
5547: *
5548: *-SYNOPSIS:
5549: * #include <sys/stream.h>
5550: *
5551: * void qenable (queue_t * q);
5552: *
5553: *-ARGUMENTS:
5554: * q Pointer to the queue.
5555: *
5556: *-DESCRIPTION:
5557: * qenable () puts the queue pointed to by "q" on the linked list of
5558: * STREAMS routines that are ready to be called by the STREAMS scheduler.
5559: * qenable () works regardless of whether the service routine has been
5560: * disabled by a previous call to noenable ().
5561: *
5562: *-RETURN VALUE:
5563: * None.
5564: *
5565: *-LEVEL:
5566: * Base or interrupt.
5567: *
5568: *-NOTES:
5569: * Does not sleep.
5570: *
5571: * The caller cannot have the stream frozen [see freezestr ()] when
5572: * calling this function.
5573: *
5574: * Driver-defined basic locks, read/write locks, and sleep locks may be
5575: * held across calls to this function.
5576: *
5577: *-SEE ALSO:
5578: * enableok (), noenable (), queue
5579: */
5580:
5581: #if __USE_PROTO__
5582: void (qenable) (queue_t * q)
5583: #else
5584: void
5585: qenable __ARGS ((q))
5586: queue_t * q;
5587: #endif
5588: {
5589: pl_t prev_pl;
5590:
5591: prev_pl = QFREEZE_TRACE (q, "qenable");
5592:
5593: (void) QUEUE_TRYSCHED (q);
5594:
5595: QUNFREEZE_TRACE (q, prev_pl);
5596: }
5597:
5598:
5599: /*
5600: *-STATUS:
5601: * DDI/DKI
5602: *
5603: *-NAME:
5604: * qprocsoff Disable put and service procedures.
5605: *
5606: *-SYNOPSIS:
5607: * #include <sys/stream.h>
5608: *
5609: * void qprocsoff (queue_t * rq);
5610: *
5611: *-ARGUMENTS:
5612: * rq Pointer to a read queue.
5613: *
5614: *-DESCRIPTION:
5615: * qprocsoff () disables the "put" and "service" routines of the driver
5616: * or module whose read queue is pointed to by "rq". When the routines
5617: * are disabled in a module, messages flow around the module as if it
5618: * were not present in the stream.
5619: *
5620: * qprocsoff () must be called by the "close" routine of a driver or
5621: * module before deallocating any resources on which the driver/module's
5622: * put and service procedures depend.
5623: *
5624: * qprocsoff () will remove the queue's service routines from the list of
5625: * service routines to be run and waits until any concurrent "put" or
5626: & "service" routines are finished.
5627: *
5628: *-RETURN VALUE:
5629: * None.
5630: *
5631: *-LEVEL:
5632: * Base level only.
5633: *
5634: *-NOTES:
5635: * May sleep.
5636: *
5637: * The caller cannot have the stream frozen [see freezestr ()] when
5638: * calling this function.
5639: *
5640: * Driver-defined basic locks and read/write locks may not be held across
5641: * calls to this function.
5642: *
5643: * Driver-defined sleep locks may be held across calls to this function.
5644: *
5645: *-SEE ALSO:
5646: * qprocson ()
5647: */
5648:
5649: #if __USE_PROTO__
5650: void (qprocsoff) (queue_t * rq)
5651: #else
5652: void
5653: qprocsoff __ARGS ((rq))
5654: queue_t * rq;
5655: #endif
5656: {
5657: pl_t prev_pl;
5658: int dosleep;
5659: queue_t * wq;
5660:
5661:
5662: try_rprocsoff:
5663: prev_pl = QFREEZE_TRACE (rq, "qprocsoff");
5664:
5665: rq->q_flag |= QPROCSOFF;
5666: if ((dosleep = rq->q_active > 0) != 0)
5667: (void) LOCK (str_mem->sm_proc_lock, plstr);
5668:
5669: QUNFREEZE_TRACE (rq, prev_pl);
5670:
5671: if (dosleep) {
5672: SV_WAIT (str_mem->sm_proc_sv, prilo, str_mem->sm_proc_lock);
5673:
5674: goto try_rprocsoff;
5675: }
5676:
5677: /*
5678: * Now do the same for the write side.
5679: */
5680:
5681: ASSERT ((rq->q_flag & QREADR) != 0);
5682:
5683: wq = W (rq);
5684:
5685: try_wprocsoff:
5686: prev_pl = QFREEZE_TRACE (wq, "qprocsoff");
5687:
5688: wq->q_flag |= QPROCSOFF;
5689: if ((dosleep = wq->q_active > 0) != 0)
5690: (void) LOCK (str_mem->sm_proc_lock, plstr);
5691:
5692:
5693: QUNFREEZE_TRACE (wq, prev_pl);
5694:
5695: if (dosleep) {
5696: SV_WAIT (str_mem->sm_proc_sv, prilo, str_mem->sm_proc_lock);
5697:
5698: goto try_wprocsoff;
5699: }
5700: }
5701:
5702:
5703: /*
5704: *-STATUS:
5705: * DDI/DKI
5706: *
5707: *-NAME:
5708: * qprocson Enable put and service routines.
5709: *
5710: *-SYNOPSIS:
5711: * #include <sys/stream.h>
5712: *
5713: * void qprocson (queue_t * rq);
5714: *
5715: *-ARGUMENTS:
5716: * rq Pointer to a read queue.
5717: *
5718: *-DESCRIPTION:
5719: * qprocson () enables the "put" and "service" routines of the driver or
5720: * module whose read queue is pointed to by "rq". Prior to the call to
5721: * qprocson (), the put and service routines of a newly pushed module or
5722: * driver are disabled. For the module, messages flow around it as if it
5723: * were not present in the stream.
5724: *
5725: * qprocson () must be called by the first open of a module or driver
5726: * after allocation and initialization of any resources on which the put
5727: * and service routines depend.
5728: *
5729: *-RETURN VALUE:
5730: * None.
5731: *
5732: *-LEVEL:
5733: * Base level only.
5734: *
5735: *-NOTES:
5736: * May sleep.
5737: *
5738: * The caller cannot have the stream frozen [see freezestr ()] when
5739: * calling this function.
5740: *
5741: * Driver-defined basic locks and read/write locks may not be held across
5742: * calls to this function.
5743: *
5744: * Driver-defined sleep locks may be held across calls to this function.
5745: *
5746: *-SEE ALSO:
5747: * qprocsoff ()
5748: */
5749:
5750: #if __USE_PROTO__
5751: void (qprocson) (queue_t * rq)
5752: #else
5753: void
5754: qprocson __ARGS ((rq))
5755: queue_t * rq;
5756: #endif
5757: {
5758: pl_t prev_pl;
5759: queue_t * wq;
5760:
5761: /*
5762: * Actually, this implementation of qprocsoff () busy-waits rather
5763: * than sleeping, but don't count on that.
5764: */
5765:
5766: prev_pl = QFREEZE_TRACE (rq, "qprocson");
5767:
5768: ASSERT ((rq->q_flag & QREADR) != 0);
5769:
5770: wq = W (rq);
5771:
5772: (void) QFREEZE_TRACE (wq, "qprocson");
5773:
5774: rq->q_flag &= ~ QPROCSOFF;
5775: wq->q_flag &= ~ QPROCSOFF;
5776:
5777: ASSERT (rq->q_active == 0 && wq->q_active == 0);
5778:
5779:
5780: /*
5781: * If there are any messages on the queues, the service procedures
5782: * should be run. If the QWANTW flag is set, we'll back-enable the
5783: * queues.
5784: */
5785:
5786: if (rq->q_first != NULL && (rq->q_flag & QNOENB) != 0)
5787: (void) QUEUE_TRYSCHED (rq);
5788:
5789: if (wq->q_first != NULL && (wq->q_flag & QNOENB) != 0)
5790: (void) QUEUE_TRYSCHED (wq);
5791:
5792: if ((rq->q_flag & QWANTW) != 0) {
5793:
5794: rq->q_flag &= ~ QWANTW;
5795: QUEUE_BACKENAB (rq);
5796: }
5797:
5798: if ((wq->q_flag & QWANTW) != 0) {
5799:
5800: wq->q_flag &= ~ QWANTW;
5801: QUEUE_BACKENAB (wq);
5802: }
5803:
5804: QUNFREEZE_TRACE (wq, plstr);
5805: QUNFREEZE_TRACE (rq, prev_pl);
5806: }
5807:
5808:
5809: /*
5810: *-STATUS:
5811: * DDI/DKI
5812: *
5813: *-NAME:
5814: * qreply Send a message in the opposite direction on a stream.
5815: *
5816: *-SYNOPSIS:
5817: * #include <sys/stream.h>
5818: *
5819: * void qreply (queue_t * q, mblk_t * mp);
5820: *
5821: *-ARGUMENTS:
5822: * q Pointer to the queue from which the message is being
5823: * sent.
5824: *
5825: * mp Pointer to the message to be sent in the opposite
5826: * direction.
5827: *
5828: *-DESCRIPTION:
5829: * qreply () sends a message in the opposite direction from that which
5830: * "q" is pointing. It calls the OTHERQ () function to find "q"'s
5831: * partner, and passes the message by calling the "put" routine of the
5832: * next queue in the stream after "q"'s partner.
5833: *
5834: *-RETURN VALUE:
5835: * None.
5836: *
5837: *-LEVEL:
5838: * Base or interrupt.
5839: *
5840: *-NOTES:
5841: * Does not sleep.
5842: *
5843: * The caller cannot have the stream frozen [see freezestr ()] when
5844: * calling this function.
5845: *
5846: * Driver-defined basic locks, read/write locks, and sleep locks may be
5847: * held across calls to this function.
5848: *
5849: *-SEE ALSO:
5850: */
5851:
5852: #if __USE_PROTO__
5853: void (qreply) (queue_t * q, mblk_t * mp)
5854: #else
5855: void
5856: qreply __ARGS ((q, mp))
5857: queue_t * q;
5858: mblk_t * mp;
5859: #endif
5860: {
5861: /*
5862: * The DDI/DKI says the caller cannot have the stream frozen, but we
5863: * don't actually need to do anything that would freeze the stream.
5864: * The proscription arises because we need to freeze the other queue
5865: * temporarily, and for one context to freeze both sides of a stream
5866: * may induce deadlock.
5867: */
5868:
5869: #ifndef NDEBUG
5870: pl_t prev_pl;
5871:
5872: prev_pl = QFREEZE_TRACE (q, "qreply");
5873: QUNFREEZE_TRACE (q, prev_pl);
5874: #endif
5875:
5876: ASSERT (mp != NULL);
5877: ASSERT (mp->b_datap != NULL);
5878:
5879: q = OTHERQ (q);
5880:
5881: QUEUE_PUTNEXT (q, mp);
5882: }
5883:
5884:
5885: /*
5886: *-STATUS:
5887: * DDI/DKI
5888: *
5889: *-NAME:
5890: * qsize Find the number of messages on a queue.
5891: *
5892: *-SYNOPSIS:
5893: * #include <sys/stream.h>
5894: *
5895: * int qsize (queue_t * q);
5896: *
5897: *-ARGUMENTS:
5898: * q Pointer to the queue to be evaluated.
5899: *
5900: *-DESCRIPTION:
5901: * qsize () evaluates the queue pointed to by "q" and returns the number
5902: * of messages it contains.
5903: *
5904: *-RETURN VALUE:
5905: * If there are no messages on the queue, "qsize" returns 0. Otherwise,
5906: * it returns the number of messages on the queue.
5907: *
5908: *-LEVEL:
5909: * Base or interrupt.
5910: *
5911: *-NOTES:
5912: * Does not sleep.
5913: *
5914: * The caller cannot have the stream frozen [see freezestr ()] when
5915: * calling this function.
5916: *
5917: * Driver-defined basic locks, read/write locks, and sleep locks may be
5918: * held across calls to this function.
5919: *
5920: *-SEE ALSO:
5921: * msgb, queue
5922: */
5923:
5924: #if __USE_PROTO__
5925: int (qsize) (queue_t * q)
5926: #else
5927: int
5928: qsize __ARGS ((q))
5929: queue_t * q;
5930: #endif
5931: {
5932: pl_t prev_pl;
5933: mblk_t * scan;
5934: int count = 0;
5935:
5936: prev_pl = QFREEZE_TRACE (q, "qsize");
5937:
5938: for (scan = q->q_first ; scan != NULL ; scan = scan->b_next)
5939: count ++;
5940:
5941: QUNFREEZE_TRACE (q, prev_pl);
5942:
5943: return count;
5944: }
5945:
5946:
5947: /*
5948: *-STATUS:
5949: * DDI/DKI
5950: *
5951: *-NAME:
5952: * RD Get a pointer to the read queue.
5953: *
5954: *-SYNOPSIS:
5955: * #include <sys/stream.h>
5956: *
5957: * queue_t * RD (queue_t * q);
5958: *
5959: *-ARGUMENTS:
5960: * q Pointer to the queue whose read queue is to be
5961: * returned.
5962: *
5963: *-DESCRIPTION:
5964: * The RD () function accepts a queue pointer as an argument and returns
5965: * a pointer to the read queue of the same module or driver.
5966: *
5967: *-RETURN VALUE:
5968: * The pointer to the read queue.
5969: *
5970: *-LEVEL:
5971: * Base or interrupt.
5972: *
5973: *-NOTES:
5974: * Does not sleep.
5975: *
5976: * Driver-defined basic locks, read/write locks, and sleep locks may be
5977: * held across calls to this function.
5978: *
5979: *-SEE ALSO:
5980: * OTHERQ (), WR ()
5981: */
5982:
5983: #if __USE_PROTO__
5984: queue_t * (RD) (queue_t * q)
5985: #else
5986: queue_t *
5987: RD __ARGS ((q))
5988: queue_t * q;
5989: #endif
5990: {
5991: QUEUE_TRACE (q, "RD");
5992:
5993: return RD (q);
5994: }
5995:
5996:
5997: /*
5998: *-STATUS:
5999: * DDI/DKI
6000: *
6001: *-NAME:
6002: * rmvb Remove a message block from a message.
6003: *
6004: *-SYNOPSIS:
6005: * #include <sys/stream.h>
6006: *
6007: * mblk_t * rmvb (mblk_t * mp, mblk_t * bp);
6008: *
6009: *-ARGUMENTS:
6010: * mp Message from which a message block is to be removed.
6011: *
6012: * bp Message block to be removed.
6013: *
6014: *-DESCRIPTION:
6015: * rmvb () removes a message block ("bp") from a message ("mp"), and
6016: * returns a pointer to the altered message. The message block is not
6017: * freed, merely removed from the message. It is the caller's
6018: * responsibility to free the message block.
6019: *
6020: *-RETURN VALUE:
6021: * If successful, a pointer to the message (minus the removed block) is
6022: * returned. If "bp" was the only block in the message before rmvb ()
6023: * was called, NULL is returned. If the designated message block ("bp")
6024: * was not in the message, -1 is returned.
6025: *
6026: *-LEVEL:
6027: * Base or interrupt.
6028: *
6029: *-NOTES:
6030: * Does not sleep.
6031: *
6032: * Driver-defined basic locks, read/write locks, and sleep locks may be
6033: * held across calls to this function.
6034: */
6035:
6036: #if __USE_PROTO__
6037: mblk_t * (rmvb) (mblk_t * mp, mblk_t * bp)
6038: #else
6039: mblk_t *
6040: rmvb __ARGS ((mp, bp))
6041: mblk_t * mp;
6042: mblk_t * bp;
6043: #endif
6044: {
6045: mblk_t * scan;
6046:
6047: ASSERT (mp != NULL);
6048: ASSERT (bp != NULL);
6049:
6050: if (mp == bp)
6051: return mp->b_cont;
6052:
6053: for (scan = mp ; scan != NULL ; scan = scan->b_cont)
6054: if (scan->b_cont == bp) {
6055:
6056: scan->b_cont = bp->b_cont;
6057: return mp;
6058: }
6059:
6060: return (mblk_t *) -1;
6061: }
6062:
6063:
6064: /*
6065: *-STATUS:
6066: * DDI/DKI
6067: *
6068: *-NAME:
6069: * rmvq Remove a message from a queue.
6070: *
6071: *-SYNOPSIS:
6072: * #include <sys/stream.h>
6073: *
6074: * void rmvq (queue_t * q, mblk_t * mp);
6075: *
6076: *-ARGUMENTS:
6077: * q Pointer to the queue containing the message to be
6078: * removed.
6079: *
6080: * mp Pointer to the message to be removed.
6081: *
6082: *-DESCRIPTION:
6083: * rmvq () removes a message from a queue. A message can be removed from
6084: * anywhere in a queue. To prevent modules and drivers from having to
6085: * deal with the internals of message linkage on a queue, either rmvq ()
6086: * or getq () should be used to remove a message from a queue.
6087: *
6088: *-RETURN VALUE:
6089: * None.
6090: *
6091: *-LEVEL:
6092: * Base or interrupt.
6093: *
6094: *-NOTES:
6095: * Does not sleep.
6096: *
6097: * The caller must have the stream frozen [see freezestr ()] when calling
6098: * this function.
6099: *
6100: * Driver-defined basic locks, read/write locks, and sleep locks may be
6101: * held across calls to this function.
6102: *
6103: * "mp" must point to an existing message in the queue pointed to by "q",
6104: * or a system panic will occur.
6105: *
6106: *-SEE ALSO:
6107: * freezestr (), getq (), insq (), unfreezestr ().
6108: */
6109:
6110: #if __USE_PROTO__
6111: void (rmvq) (queue_t * q, mblk_t * mp)
6112: #else
6113: void
6114: rmvq __ARGS ((q, mp))
6115: queue_t * q;
6116: mblk_t * mp;
6117: #endif
6118: {
6119: ASSERT (mp != NULL);
6120:
6121: QFROZEN_TRACE (q, "rmvq");
6122:
6123: /*
6124: * First, simply dequeue the message based on mp's "b_next" and
6125: * "b_prev" members.
6126: */
6127:
6128: if (mp->b_next == NULL) {
6129:
6130: ASSERT (q->q_last == mp);
6131: if ((q->q_last = mp->b_prev) == NULL)
6132: QUEUE_DRAINED (q);
6133: } else
6134: mp->b_next->b_prev = mp->b_prev;
6135:
6136: if (mp->b_prev == NULL) {
6137:
6138: ASSERT (q->q_first == mp);
6139: q->q_first = mp->b_next;
6140:
6141: /*
6142: * Since we are dequeueing a message from the front of the
6143: * queue, record the message band.
6144: */
6145:
6146: q->q_lastband = mp->b_band;
6147: } else
6148: mp->b_prev->b_next = mp->b_next;
6149:
6150: /*
6151: * Now we adjust the flow-control parameters and band information.
6152: */
6153:
6154: if (! IS_PRI_MSG (mp)) {
6155: ulong_t msgsize = MSG_SIZE (mp);
6156:
6157: if (mp->b_band > 0) {
6158: qband_t * qbandp = QUEUE_BAND (q, mp->b_band);
6159:
6160: ASSERT (qbandp->qb_first == mp);
6161:
6162: QBAND_DEQUEUE (qbandp, mp);
6163:
6164: QBAND_REDUCE (q, qbandp, msgsize);
6165: } else
6166: QUEUE_REDUCE (q, msgsize);
6167: }
6168: }
6169:
6170:
6171: /*
6172: *-STATUS:
6173: * DDI/DKI
6174: *
6175: *-NAME:
6176: * SAMESTR Test if next queue is same type.
6177: *
6178: *-SYNOPSIS:
6179: * #include <sys/stream.h>
6180: *
6181: * int SAMESTR (queue_t * q);
6182: *
6183: *-ARGUMENTS:
6184: * q Pointer to the queue.
6185: *
6186: *-DESCRIPTION:
6187: * The SAMESTR () function is used to see if the next queue in a stream
6188: * (if it exists) is the same type as the current queue (that is, both
6189: * are read queues or both are write queues). This can be used to
6190: * determine the point in a STREAMS-based pipe where a read queue is
6191: * linked to a write queue.
6192: *
6193: *-RETURN VALUE:
6194: * SAMESTR () returns 1 if the next queue is the same type as the current
6195: * queue. It returns 0 if the next queue does not exist or if it is not
6196: * the same type.
6197: *
6198: *-LEVEL:
6199: * Base or interrupt.
6200: *
6201: *-NOTES:
6202: * Does not sleep.
6203: *
6204: * The caller cannot have the stream frozen [see freezestr ()] when
6205: * calling this function.
6206: *
6207: * Driver-defined basic locks, read/write locks, and sleep locks may be
6208: * held across calls to this function.
6209: *
6210: * The argument "q" may not reference "q_next" (for example, an argument
6211: * of "q->q_next" is erroneous on a multiprocessor and is disallowed by
6212: * the DDI/DKI).
6213: *
6214: *-SEE ALSO:
6215: * OTHERQ ()
6216: */
6217:
6218: #if __USE_PROTO__
6219: int (SAMESTR) (queue_t * q)
6220: #else
6221: int
6222: SAMESTR __ARGS ((q))
6223: queue_t * q;
6224: #endif
6225: {
6226: int retval;
6227: pl_t prev_pl;
6228:
6229: prev_pl = QFREEZE_TRACE (q, "SAMESTR");
6230:
6231: retval = q->q_next == NULL ? 0 :
6232: (q->q_next->q_flag & QREADR) == (q->q_flag & QREADR);
6233:
6234: QUNFREEZE_TRACE (q, prev_pl);
6235:
6236: return retval;
6237: }
6238:
6239:
6240: /*
6241: *-STATUS:
6242: * DDI/DKI
6243: *
6244: *-NAME:
6245: * strlog Submit messages to the log driver.
6246: *
6247: *-SYNOPSIS:
6248: * #include <sys/types.h>
6249: * #include <sys/stream.h>
6250: * #include <sys/strlog.h>
6251: * #include <sys/log.h>
6252: *
6253: * int strlog (short mid, short sid, char level, uchar_t flags,
6254: * char * fmt, ...);
6255: *
6256: *-ARGUMENTS:
6257: * mid Identification number of the module or driver
6258: * submitting the message.
6259: *
6260: * sid Identification number for a particular minor device.
6261: *
6262: * flags Bitmask of flags indicating message purpose. Valid
6263: * flags are:
6264: * SL_ERROR Message is for error logger.
6265: * SL_TRACE Message is for tracing.
6266: * SL_CONSOLE Message is for console logger.
6267: * SL_NOTIFY If SL_ERROR is also set, mail copy of
6268: * message to system administrator.
6269: * SL_FATAL Modifier indicating error is fatal.
6270: * SL_WARN Modifier indicating error is a
6271: * warning.
6272: * SL_NOTE Modifier indicating error is a notice.
6273: *
6274: * fmt printf () style format string. %s, %e, %g and %G
6275: * formats are not allowed.
6276: *
6277: * ... Zero or more arguments to printf () (maximum of
6278: * NLOGARGS, currently three).
6279: *
6280: *-DESCRIPTION:
6281: * strlog () submits formatted messages to the "log" driver. The messages
6282: * can be retrieved with the getmsg () system call. The "flags" argument
6283: * specifies the type of the message and where it is to be sent.
6284: *
6285: *-RETURN VALUE:
6286: * strlog () returns 0 if the message is not seen by all the readers, 1
6287: * otherwise.
6288: *
6289: *-LEVEL:
6290: * Base or interrupt.
6291: *
6292: *-NOTES:
6293: * Does not sleep.
6294: *
6295: * Driver-defined basic locks, read/write locks, and sleep locks may be
6296: * held across calls to this function.
6297: *
6298: *-SEE ALSO:
6299: * log (7) in the "Programmer's Guide: STREAMS"
6300: */
6301:
6302: #if __USE_PROTO__
6303: int (strlog) (short mid, short sid, char level, ushort_t flags, char * fmt,
6304: ...)
6305: #else
6306: int
6307: strlog __ARGS ((mid, sid, level, flags, fmt))
6308: short mid;
6309: short sid;
6310: char level;
6311: ushort_t flags;
6312: char * fmt;
6313: #endif
6314: {
6315: mblk_t * data;
6316: ulong_t err_seq, trc_seq, con_seq;
6317: mblk_t * errmsg, * trcmsg, * conmsg;
6318: int failures;
6319: int copies;
6320: int pri;
6321:
6322: # define SL_ALL (SL_ERROR | SL_TRACE | SL_CONSOLE | SL_NOTIFY |\
6323: SL_FATAL | SL_WARN | SL_NOTE)
6324:
6325: ASSERT ((flags & SL_ALL) != 0);
6326: ASSERT ((flags & ~ SL_ALL) == 0);
6327: ASSERT (fmt != NULL);
6328:
6329: /*
6330: * The first thing we do is assign a sequence number to this log item
6331: * so that we can correctly detect when log items have been discarded
6332: * due to lack of available resources. In addition, there are several
6333: * sequence-number spaces available, depending on the destination of
6334: * the log message. We acquire numbers from all the spaces now, and
6335: * write them into the actual log messages later.
6336: */
6337:
6338: {
6339: pl_t prev_pl;
6340: int temp;
6341:
6342: prev_pl = LOCK (str_mem->sm_seq_lock, plstr);
6343:
6344: err_seq = trc_seq = con_seq = 0; /* paranoia */
6345:
6346: if ((flags & SL_ERROR) != 0)
6347: err_seq = str_mem->sm_err_seq ++;
6348: if ((flags & SL_TRACE) != 0)
6349: trc_seq = str_mem->sm_trc_seq ++;
6350: if ((flags & SL_CONSOLE) != 0)
6351: con_seq = str_mem->sm_con_seq ++;
6352:
6353: temp = str_mem->sm_log_rq == NULL;
6354:
6355: UNLOCK (str_mem->sm_seq_lock, prev_pl);
6356:
6357:
6358: /*
6359: * If the log driver isn't installed yet, don't bother with
6360: * the rest of this routine.
6361: */
6362:
6363: if (temp)
6364: return 0;
6365: }
6366:
6367: /*
6368: * While the documentation for this function doesn't spell it out,
6369: * the log (7) driver traffics in error, trace and console messages,
6370: * with the others being variations on that theme.
6371: *
6372: * Somehow the "flags" have to be mapped into a priority/facility code
6373: * according to some rules that are alluded to in the log (7) manual
6374: * pages.
6375: */
6376:
6377: {
6378: size_t size;
6379: va_list args;
6380: uchar_t * dest;
6381: int temp;
6382:
6383: if ((flags & (SL_ERROR | SL_FATAL)) != 0)
6384: pri = BPRI_HI;
6385: else if ((flags & SL_WARN) != 0)
6386: pri = BPRI_MED;
6387: else
6388: pri = BPRI_LO;
6389:
6390:
6391: /*
6392: * The data portion of a STREAMS logger message contains the
6393: * unexpanded text of the "fmt" string plus NLOGARGS worth of
6394: * data containing any extra arguments packed after the string
6395: * aligned to the next word address.
6396: *
6397: * We'll also need at least one control message section, which
6398: * we can copy as necessary later on.
6399: */
6400: /*
6401: * ALIGNMENT-DEPENDENT CODE.
6402: */
6403: size = ((strlen (fmt) + 4) & ~ (sizeof (int) - 1)) +
6404: NLOGARGS * sizeof (ulong_t);
6405:
6406: if ((data = MSGB_ALLOC (size, pri, KM_NOSLEEP)) == NULL) {
6407: /*
6408: * Return a failure indication. This is not a major
6409: * problem, as the gaps in the sequence space tell a
6410: * story...
6411: */
6412:
6413: return 0;
6414: }
6415:
6416: /*
6417: * Copy the format string and the argument data to the log
6418: * buffer.
6419: */
6420:
6421: dest = data->b_rptr;
6422: while ((* dest ++ = * (uchar_t *) fmt ++) != 0)
6423: ;
6424: dest += (sizeof (int) - 1) - (((unsigned long) dest - 1) &
6425: (sizeof (int) - 1));
6426:
6427: va_start (args, fmt);
6428: for (temp = 0 ; temp < NLOGARGS ; temp ++) {
6429: * (ulong_t *) dest = va_arg (args, ulong_t);
6430: dest += sizeof (ulong_t);
6431: }
6432: va_end (args);
6433:
6434: data->b_wptr += size;
6435:
6436: ASSERT (data->b_wptr == dest);
6437: }
6438:
6439:
6440: /*
6441: * Now send the log request to the read side of the log driver. This
6442: * is how we distinguish kernel log requests from user log requests,
6443: * since the user requests will arrive on the write side as usual.
6444: *
6445: * Since the various destinations for log messages expect to see
6446: * messages with sequence numbers tailored to them, we create
6447: * additional copies of the log message as needed. For this to work,
6448: * we work out the copies first, and then send them.
6449: *
6450: * This would be a lot easier if C had nested functions as standard.
6451: * Sadly, only GNU does this now.
6452: */
6453:
6454: failures = 0;
6455: copies = 0;
6456:
6457: errmsg = STRLOG_MAKE (mid, sid, level, flags, err_seq, SL_ERROR,
6458: & copies, & failures, data);
6459:
6460: trcmsg = STRLOG_MAKE (mid, sid, level, flags, trc_seq, SL_TRACE,
6461: & copies, & failures, data);
6462:
6463: conmsg = STRLOG_MAKE (mid, sid, level, flags, con_seq, SL_CONSOLE,
6464: & copies, & failures, data);
6465:
6466: if (errmsg != NULL)
6467: put (str_mem->sm_log_rq, errmsg);
6468: if (trcmsg != NULL)
6469: put (str_mem->sm_log_rq, trcmsg);
6470: if (conmsg != NULL)
6471: put (str_mem->sm_log_rq, conmsg);
6472:
6473: if (copies == 0)
6474: freemsg (data);
6475:
6476: return failures == 0;
6477: }
6478:
6479:
6480: /*
6481: *-STATUS:
6482: * DDI/DKI
6483: *
6484: *-NAME:
6485: * strqget Get information about a queue or band of the queue.
6486: *
6487: *-SYNOPSIS:
6488: * #include <sys/stream.h>
6489: *
6490: * int strqget (queue_t * q, qfields_t what, uchar_t pri, long * valp);
6491: *
6492: *-ARGUMENTS:
6493: * q Pointer to the queue.
6494: *
6495: * what The field of the queeu about which to return
6496: * information. Valid values are:
6497: *
6498: * QHIWAT High water mark of the specified priority
6499: * band.
6500: *
6501: * QLOWAT Low water mark of the specified priority band.
6502: *
6503: * QMAXPSZ Maximum packet size of the specified priority
6504: * band.
6505: *
6506: * QMINPSZ Minimum packet size of the specified priority
6507: * band.
6508: *
6509: * QCOUNT Number of bytes of data in messages in the
6510: * specified priority band.
6511: *
6512: * QFIRST Pointer to the first message in the specified
6513: * priority band.
6514: *
6515: * QLAST Pointer to the last message in the specified
6516: * priority band.
6517: *
6518: * QFLAG Flags for the specified priority band.
6519: *
6520: * pri Priority band of the queue about which to obtain
6521: * information.
6522: *
6523: * valp Pointer to the memory locatation where the value is
6524: * to be stored.
6525: *
6526: *-DESCRIPTION:
6527: * strqget () gives drivers and modules a way to get information about
6528: * a queue or a particular priority band of a queue without directly
6529: * accessing STREAMS data structures.
6530: *
6531: *-RETURN VALUE:
6532: * On success, 0 is returns. An error number is returned on failure. The
6533: * actual value of the requested field is returned through the reference
6534: * parameter "valp".
6535: *
6536: *-LEVEL:
6537: * Base or interrupt.
6538: *
6539: *-NOTES:
6540: * Does not sleep.
6541: *
6542: * The caller must have the stream frozen [see freezestr ()] when calling
6543: * this function.
6544: *
6545: * Driver-defined basic locks, read/write locks, and sleep locks may be
6546: * held across calls to this function.
6547: *
6548: *-SEE ALSO:
6549: * freezestr (), strqset (), unfreezestr (), queue
6550: */
6551:
6552: #if __USE_PROTO__
6553: int (strqget) (queue_t * q, qfields_t what, uchar_t pri, long * valp)
6554: #else
6555: int
6556: strqget __ARGS ((q, what, pri, valp))
6557: queue_t * q;
6558: qfields_t what;
6559: uchar_t pri;
6560: long * valp;
6561: #endif
6562: {
6563: QFROZEN_TRACE (q, "strqget");
6564:
6565: if (pri > 0)
6566: switch (what) {
6567:
6568: case QHIWAT:
6569: * valp = q->q_hiwat;
6570: break;
6571:
6572: case QLOWAT:
6573: * valp = q->q_lowat;
6574: break;
6575:
6576: case QMAXPSZ:
6577: * valp = q->q_maxpsz;
6578: break;
6579:
6580: case QMINPSZ:
6581: * valp = q->q_minpsz;
6582: break;
6583:
6584: case QCOUNT:
6585: * valp = q->q_count;
6586: break;
6587:
6588: case QFIRST:
6589: * valp = (long) q->q_first;
6590: break;
6591:
6592: case QLAST:
6593: * valp = (long) q->q_last;
6594: break;
6595:
6596: case QFLAG:
6597: * valp = q->q_flag;
6598: break;
6599:
6600: default:
6601: return EINVAL;
6602: }
6603: else {
6604: qband_t * qbandp;
6605:
6606: if ((qbandp = QUEUE_BAND (q, pri)) == NULL &&
6607: (qbandp = QBAND_ALLOC (q, pri)) == NULL)
6608: return ENOMEM;
6609:
6610: switch (what) {
6611:
6612: case QHIWAT:
6613: * valp = qbandp->qb_hiwat;
6614: break;
6615:
6616: case QLOWAT:
6617: * valp = qbandp->qb_lowat;
6618: break;
6619:
6620: case QCOUNT:
6621: * valp = qbandp->qb_count;
6622: break;
6623:
6624: case QFIRST:
6625: * valp = (long) qbandp->qb_first;
6626: break;
6627:
6628: case QLAST:
6629: * valp = (long) qbandp->qb_last;
6630: break;
6631:
6632: case QFLAG:
6633: * valp = qbandp->qb_flag;
6634: break;
6635:
6636: default:
6637: return EINVAL;
6638: }
6639: }
6640:
6641: return 0;
6642: }
6643:
6644:
6645: /*
6646: *-STATUS:
6647: * DDI/DKI
6648: *
6649: *-NAME:
6650: * strqset Change information about a queue or band of the queue.
6651: *
6652: *-SYNOPSIS:
6653: * #include <sys/types.h>
6654: * #include <sys/stream.h>
6655: *
6656: * int strqset (queue_t * q, qfields_t what, uchar_t pri, long val);
6657: *
6658: *-ARGUMENTS:
6659: * q Pointer to the queue.
6660: *
6661: * what The field of the queue to change. Value values are:
6662: *
6663: * QHIWAT High water mark of the specified priority
6664: * band.
6665: *
6666: * QLOWAT Low water mark of the specified priority band.
6667: *
6668: * QMAXPSZ Maximum packet size of the specified priority
6669: * band.
6670: *
6671: * QMINPSZ Minimum packet size of the specified priority
6672: * band.
6673: *
6674: * pri Priority band of the queue to be changed.
6675: *
6676: * val New value for the field to be changed.
6677: *
6678: *-DESCRIPTION:
6679: * strqset () gives drivers and modules a way to change information about
6680: * a queue or a particular priority band of a queue without directly
6681: * accessing STREAMS data structures.
6682: *
6683: *-RETURN VALUE:
6684: * On success, 0 is returned. An error number is returned on failure.
6685: *
6686: *-LEVEL:
6687: * Base or interrupt.
6688: *
6689: *-NOTES:
6690: * Does not sleep.
6691: *
6692: * The caller must have the stream frozen [see freezestr ()] when calling
6693: * this function.
6694: *
6695: * Driver-defined basic locks, read/write locks, and sleep locks may be
6696: * held across calls to this function.
6697: *
6698: *-SEE ALSO:
6699: */
6700:
6701: #if __USE_PROTO__
6702: int (strqset) (queue_t * q, qfields_t what, uchar_t pri, long val)
6703: #else
6704: int
6705: strqset __ARGS ((q, what, pri, val))
6706: queue_t * q;
6707: qfields_t what;
6708: uchar_t pri;
6709: long val;
6710: #endif
6711: {
6712: QFROZEN_TRACE (q, "strqset");
6713:
6714: if (pri > 0)
6715: switch (what) {
6716:
6717: case QHIWAT:
6718: q->q_hiwat = val;
6719: break;
6720:
6721: case QLOWAT:
6722: q->q_lowat = val;
6723: break;
6724:
6725: case QMAXPSZ:
6726: q->q_maxpsz = val;
6727: break;
6728:
6729: case QMINPSZ:
6730: q->q_minpsz = val;
6731: break;
6732:
6733: case QCOUNT:
6734: case QFIRST:
6735: case QLAST:
6736: case QFLAG:
6737: return EPERM;
6738:
6739: default:
6740: return EINVAL;
6741: }
6742: else {
6743: qband_t * qbandp;
6744:
6745: if ((qbandp = QUEUE_BAND (q, pri)) == NULL &&
6746: (qbandp = QBAND_ALLOC (q, pri)) == NULL)
6747: return ENOMEM;
6748:
6749: switch (what) {
6750:
6751: case QHIWAT:
6752: qbandp->qb_hiwat = val;
6753: break;
6754:
6755: case QLOWAT:
6756: qbandp->qb_lowat = val;
6757: break;
6758:
6759: case QCOUNT:
6760: case QFIRST:
6761: case QLAST:
6762: case QFLAG:
6763: return EPERM;
6764:
6765: default:
6766: return EINVAL;
6767: }
6768: }
6769:
6770: return 0;
6771: }
6772:
6773:
6774: /*
6775: *-STATUS:
6776: * Compatibility (pre-MP DDI/DKI)
6777: *
6778: *-NAME:
6779: * testb Check for an available buffer.
6780: *
6781: *-SYNOPSIS:
6782: * #include <sys/stream.h>
6783: *
6784: * int testb (int size, int pri);
6785: *
6786: *-ARGUMENTS:
6787: * size Size of the requested buffer.
6788: *
6789: * pri Priority of the allocb () request.
6790: *
6791: *-DESCRIPTION:
6792: * testb () checks to see if an allocb () call is likely to succeed if
6793: * a buffer of "size" bytes at priority "pri" is requested. Even if
6794: * testb () returns successfully, the call to allocb () can fail.
6795: *
6796: *-RETURN VALUE:
6797: * Returns 1 if a buffer of the requested size is available, and 0 if
6798: * one is not.
6799: *
6800: *-LEVEL:
6801: * Base or interrupt.
6802: *
6803: *-NOTES:
6804: * Does not sleep.
6805: *
6806: * Driver-defined basic locks, read/write locks, and sleep locks may be
6807: * held across calls to this function.
6808: *
6809: * This function is provided purely as a porting convenience for
6810: * developers working with drivers developed under earlier releases of
6811: * the System V DDI/DKI or under STREAMS from System V, Release 3. Calls
6812: * to this function should be replaced with calls to functions that do
6813: * the real work.
6814: *
6815: *-SEE ALSO:
6816: * allocb (), bufcall ().
6817: */
6818:
6819: #if __USE_PROTO__
6820: int (testb) (int size, int pri)
6821: #else
6822: int
6823: testb __ARGS ((size, pri))
6824: int size;
6825: int pri;
6826: #endif
6827: {
6828: pl_t prev_pl;
6829: int return_val;
6830:
6831: /*
6832: * This function is one of the most braindead peices of STREAMS. It
6833: * may not have been initially, but by the SVR4 DDI/DKI, it was
6834: * *totally* useless. The example code given in that DDI/DKI issue is
6835: * so bad it's unbelievable, and they admit it too...
6836: */
6837:
6838: ASSERT (size > 0);
6839: ASSERT (pri == BPRI_LO || pri == BPRI_HI || pri == BPRI_LO);
6840:
6841: pri = MAP_PRI_LEVEL (pri);
6842: size = MSGB_SIZE (pri);
6843:
6844:
6845: /*
6846: * Lock the basic lock protecting access to the memory pool
6847: * and attempt to acquire the memory we desire.
6848: */
6849:
6850: prev_pl = LOCK (str_mem->sm_msg_lock, str_msg_pl);
6851:
6852: /*
6853: * Before allocating any memory, we check to see that it makes sense
6854: * to give out that memory to the given priority level.
6855: */
6856:
6857: return_val = str_mem->sm_used + size < str_mem->sm_max [pri] &&
6858: st_maxavail (str_mem->sm_msg_heap) >= size;
6859:
6860: UNLOCK (str_mem->sm_msg_lock, prev_pl);
6861:
6862: return return_val;
6863: }
6864:
6865:
6866: /*
6867: *-STATUS:
6868: * DDI/DKI
6869: *
6870: *-NAME:
6871: * unbufcall Cancel a pending bufcall () request.
6872: *
6873: *-SYNOPSIS:
6874: * #include <sys/stream.h>
6875: *
6876: * void unbufcall (toid_t id);
6877: *
6878: *-ARGUMENTS:
6879: * id Identifier returned from bufcall () or esbbcall ().
6880: *
6881: *-DESCRIPTION:
6882: * unbufcall () cancels a pending bufcall () or esbbcall () request. The
6883: * argument "id" is a non-zero identifier for the request to be
6884: * cancelled. "id" is returned from the bufcall () or esbbcall ()
6885: * function used to issue the request.
6886: *
6887: *-RETURN VALUE:
6888: * None.
6889: *
6890: *-LEVEL:
6891: * Base or interrupt.
6892: *
6893: *-NOTES:
6894: * Does not sleep.
6895: *
6896: * Driver-defined basic locks, read/write locks, and sleep locks may be
6897: * held across calls to this function.
6898: *
6899: *-SEE ALSO:
6900: * bufcall (), esbbcall ()
6901: */
6902:
6903: #if __USE_PROTO__
6904: void (unbufcall) (toid_t id)
6905: #else
6906: void
6907: unbufcall __ARGS ((id))
6908: toid_t id;
6909: #endif
6910: {
6911: pl_t prev_pl;
6912: selist_t * selistp;
6913: sevent_t * sscan;
6914: sevent_t * sprev;
6915:
6916: ASSERT (id != 0);
6917:
6918: /*
6919: * Let's lock the list that we are going to search for the new event
6920: * on.
6921: */
6922:
6923: selistp = & str_mem->sm_bcevents [MAP_PRI_LEVEL (TOID_TO_PRI (id))];
6924:
6925: prev_pl = SELIST_LOCK (selistp);
6926:
6927: for (sscan = selistp->sl_head, sprev = NULL ; sscan != NULL ;
6928: sscan = (sprev = sscan)->se_next) {
6929: /*
6930: * If we find it, dequeue it.
6931: */
6932:
6933: if (sscan->se_id == id) {
6934: if (sprev == NULL)
6935: selistp->sl_head = sscan->se_next;
6936: else
6937: sprev->se_next = sscan->se_next;
6938: #if _FIFO_BUFCALL
6939: if (selistp->sl_tail == sscan) {
6940:
6941: ASSERT (sscan->se_next == NULL);
6942: selistp->sl_tail = sprev;
6943: } else
6944: ASSERT (sscan->se_next != NULL);
6945: #endif
6946: break;
6947: }
6948: }
6949:
6950: SELIST_UNLOCK (selistp, prev_pl);
6951: }
6952:
6953:
6954: /*
6955: *-STATUS:
6956: * DDI/DKI
6957: *
6958: *-NAME:
6959: * unfreezestr Unfreeze the state of a stream.
6960: *
6961: *-SYNOPSIS:
6962: * #include <sys/types.h>
6963: * #include <sys/stream.h>
6964: *
6965: * void unfreezestr (queue_t * q, pl_t prev_pl);
6966: *
6967: *-ARGUMENTS:
6968: * q Pointer to a message queue.
6969: *
6970: * pl The interrupt priority level to be set (if the
6971: * implementation requires that interrupts be blocked in
6972: * order to prevent deadlock) after unfreezing the
6973: * stream. See LOCK_ALLOC () for a list of valid values
6974: * for "pl". "pl" should be the value that was returned
6975: * from the corresponding call to freezestr () unless the
6976: * caller has a specific need to set some other interrupt
6977: * priority level. Although portable drivers must always
6978: * specify an appropriate "pl" argument, implementations
6979: * which do not require that the interrupt priority be
6980: * raised while the stream is frozen may choose to ignore
6981: * this argument.
6982: *
6983: *-DESCRIPTION:
6984: * unfreezestr () unfreezes the state of the stream containing the queue
6985: * specified by "q", and sets the interrupt priority level to the value
6986: * specified by "pl". Unfreezing the state of the stream allows
6987: * continuation of all activities that were forced to wait while the
6988: * stream was frozen.
6989: *
6990: *-RETURN VALUE:
6991: * None.
6992: *
6993: *-LEVEL:
6994: * Base or interrupt.
6995: *
6996: *-NOTES:
6997: * Does not sleep.
6998: *
6999: * The caller must have the stream frozen [see freezestr ()] when calling
7000: * this function.
7001: *
7002: * Driver-defined basic locks, read/write locks, and sleep locks may be
7003: * held across calls to this function.
7004: *
7005: *-SEE ALSO:
7006: * freezestr ()
7007: */
7008:
7009: #if __USE_PROTO__
7010: void (unfreezestr) (queue_t * q, pl_t pl)
7011: #else
7012: void
7013: unfreezestr __ARGS ((q, pl))
7014: queue_t * q;
7015: pl_t pl;
7016: #endif
7017: {
7018: unsigned long back;
7019:
7020: QFROZEN_TRACE (q, "unfreezestr");
7021:
7022: /*
7023: * Since the caller might have used rmvq () to cause a condition where
7024: * queues behind the current one need back-enabling, test for this.
7025: */
7026:
7027: if ((back = q->q_flag & QBACK) != 0)
7028: q->q_flag &= ~ QBACK;
7029:
7030: QUNFREEZE_TRACE (q, pl);
7031:
7032: if (back)
7033: QUEUE_BACKENAB (q);
7034: }
7035:
7036:
7037: /*
7038: *-STATUS:
7039: * DDI/DKI
7040: *
7041: *-NAME:
7042: * unlinkb Remove a message block from the head of a message.
7043: *
7044: *-SYNOPSIS:
7045: * #include <sys/stream.h>
7046: *
7047: * mblk_t * unlinkb (mblk_t * mp);
7048: *
7049: *-ARGUMENTS:
7050: * mp Pointer to the message.
7051: *
7052: *-DESCRIPTION:
7053: * unlinkb () removes the first message block from the message pointed to
7054: * by "mp". The removed message block is not freed. It is the caller's
7055: * responsibility to free it.
7056: *
7057: *-RETURN VALUE:
7058: * unlinkb () returns a pointer to the remainder of the message after the
7059: * first message block has been removed. If there is only one message
7060: * block in the message, NULL is returned.
7061: *
7062: *-LEVEL:
7063: * Base or interrupt.
7064: *
7065: *-NOTES:
7066: * Does not sleep.
7067: *
7068: * Driver-defined basic locks, read/write locks, and sleep locks may be
7069: * held across calls to this function.
7070: *
7071: *-SEE ALSO:
7072: * linkb ()
7073: */
7074:
7075: #if __USE_PROTO__
7076: mblk_t * (unlinkb) (mblk_t * mp)
7077: #else
7078: mblk_t *
7079: unlinkb __ARGS ((mp))
7080: mblk_t * mp;
7081: #endif
7082: {
7083: mblk_t * retval;
7084:
7085: ASSERT (mp != NULL);
7086:
7087: retval = mp->b_cont;
7088: mp->b_cont = NULL;
7089:
7090: return retval;
7091: }
7092:
7093:
7094: /*
7095: *-STATUS:
7096: * DDI/DKI
7097: *
7098: *-NAME:
7099: * WR Get a pointer to the write queue.
7100: *
7101: *-SYNOPSIS:
7102: * #include <sys/stream.h>
7103: *
7104: * queue_t * WR (queue_t * q);
7105: *
7106: *-ARGUMENTS:
7107: * q Pointer to the queue whose write queue is to be
7108: * returned.
7109: *
7110: *-DESCRIPTION:
7111: * The WR () function accepts a queue pointer as an argument and returns
7112: * a pointer to the write queue of the same module.
7113: *
7114: *-RETURN VALUE:
7115: * To pointer to the write queue.
7116: *
7117: *-LEVEL:
7118: * Base or interrupt.
7119: *
7120: *-NOTES:
7121: * Does not sleep.
7122: *
7123: * Driver-defined basic locks, read/write locks, and sleep locks may be
7124: * held across calls to this function.
7125: *
7126: *-SEE ALSO:
7127: * OTHERQ (), RD ().
7128: */
7129:
7130: #if __USE_PROTO__
7131: queue_t * (WR) (queue_t * q)
7132: #else
7133: queue_t *
7134: WR __ARGS ((q))
7135: queue_t * q;
7136: #endif
7137: {
7138: QUEUE_TRACE (q, "WR");
7139:
7140: return WR (q);
7141: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.