![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to struser.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src|
Return to struser.c CVS log | Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src |
1.1 root 1: #define _DDI_DKI 1
2: #define _DDI_DKI_IMPL 1
3: #define _SYSV4 1
4:
5: /*
6: */
7:
8: #include <common/ccompat.h>
9: #include <kernel/fhsys.h>
10: #include <kernel/strmlib.h>
11: #include <sys/confinfo.h>
12: #include <sys/types.h>
13: #include <sys/kmem.h>
14: #include <sys/poll.h>
15: #include <sys/ksynch.h>
16: #include <sys/file.h>
17: #include <sys/uio.h>
18: #include <sys/cmn_err.h>
19: #include <sys/errno.h>
20: #include <sys/signal.h>
21: #include <stropts.h>
22: #include <string.h>
23: #include <poll.h>
24:
25: /*
26: * The following function (local to this module) is forward-referenced due to
27: * the mutual recursion between the final close process and the streams unlink
28: * code.
29: */
30:
31: __LOCAL__ int SHEAD_DO_CLOSE __PROTO ((shead_t * sheadp, int mode,
32: cred_t * credp));
33:
34:
35: lkinfo_t __stream_schedule_lkinfo = {
36: "STREAMS queue schedule", INTERNAL_LOCK
37: };
38:
39: lkinfo_t __stream_event_lkinfo = {
40: "STREAMS bufcall ()/esbbcall () event list", INTERNAL_LOCK
41: };
42:
43: __LOCAL__ lkinfo_t _stream_head_lkinfo = {
44: "stream head lock", INTERNAL_LOCK
45: };
46:
47:
48: /*
49: * Allocate and initialize a queue pair. This function only performs a partial
50: * initialization; many other fields are filled in by the caller, usually from
51: * fields supplied in the "streamtab" structure.
52: *
53: * Since at initial stream open time we we be allocating at least two queue
54: * pairs and one or two stream head structures, we try to satisfy all those
55: * allocations in one step here.
56: *
57: * The "npairs" argument indicates the number of queue pairs to be allocated.
58: * The "extra" argument is the number of additional bytes to allocate over and
59: * above the memory for the queue pairs.
60: *
61: * Call only from base level. This function may sleep.
62: */
63:
64: #if __USE_PROTO__
65: __LOCAL__ queue_t * (QUEUE_ALLOC) (int npairs, size_t extra)
66: #else
67: __LOCAL__ queue_t *
68: QUEUE_ALLOC __ARGS ((npairs, extra))
69: int npairs;
70: size_t extra;
71: #endif
72: {
73: queue_t * q;
74: queue_t * init;
75: int count;
76:
77: ASSERT (npairs > 0 && npairs < 3);
78:
79: /*
80: * We use kmem_zalloc () to allocate this space so we can sleaze our
81: * way out of most of the initialization work.
82: */
83:
84: if ((q = (queue_t *) kmem_zalloc (2 * npairs * sizeof (* q) + extra,
85: KM_SLEEP)) == NULL)
86: return NULL;
87:
88: init = q;
89: count = npairs;
90:
91: do {
92: /*
93: * First, initialise the read side of the queue. While we are
94: * at it, we link the "q_next" members of multiple queues for
95: * a read side; if we treat the value "q" that we are going to
96: * return to the caller as the stream head, the links run from
97: * the last entry we initialize towards the first one.
98: */
99:
100: if (count > 1)
101: (init + 2)->q_next = init;
102:
103: init->q_flag = QWANTR | QREADR | QPROCSOFF;
104:
105: SFREEZE_INIT (init);
106:
107: init ++;
108:
109:
110: /*
111: * Next, work on the write side. For multiple queues, the
112: * write size "q_next" links run from the "head" to the device.
113: */
114:
115: if (count > 1)
116: init->q_next = init + 2;
117:
118: init->q_flag = QWANTR | QPROCSOFF;
119:
120: SFREEZE_INIT (init);
121:
122: init ++;
123: } while (-- count > 0);
124:
125:
126: /*
127: * We put a pointer to any "extra" space that the caller requested in
128: * the "q_ptr" fields of the first two queues allocated, since they
129: * will almost always be the stream head queue pair.
130: */
131:
132: if (extra > 0) {
133:
134: q->q_ptr = (char *) q + 2 * sizeof (* q) * npairs;
135: W (q)->q_ptr = q->q_ptr;
136: }
137:
138: return q;
139: }
140:
141:
142: /*
143: * Set a queue's initial watermark data and some other stuff.
144: */
145:
146: #if __USE_PROTO__
147: __LOCAL__ void (QUEUE_INITOPT) (queue_t * q)
148: #else
149: __LOCAL__ void
150: QUEUE_INITOPT __ARGS ((q))
151: queue_t * q;
152: #endif
153: {
154: struct module_info
155: * mi = q->q_qinfo->qi_minfo;
156:
157: q->q_minpsz = mi->mi_minpsz;
158: q->q_maxpsz = mi->mi_maxpsz;
159: q->q_hiwat = mi->mi_hiwat;
160: q->q_lowat = mi->mi_lowat;
161: }
162:
163:
164: /*
165: * Set up a queue pair's initial options.
166: */
167:
168: typedef enum {
169: QI_NORMAL,
170: QI_MUX
171: } qiflag_t;
172:
173: #if __USE_PROTO__
174: __LOCAL__ void (QUEUE_INIT) (queue_t * q, struct streamtab * stab,
175: qiflag_t mux)
176: #else
177: void
178: QUEUE_INIT __ARGS ((q, stab, mux))
179: queue_t * q;
180: struct streamtab
181: * stab;
182: qiflag_t mux;
183: #endif
184: {
185: q->q_qinfo = mux == QI_NORMAL ? stab->st_rdinit : stab->st_muxrinit;
186: QUEUE_INITOPT (q);
187:
188: q = W (q);
189:
190: q->q_qinfo = mux == QI_NORMAL ? stab->st_wrinit : stab->st_muxwinit;
191: QUEUE_INITOPT (q);
192: }
193:
194:
195: /*
196: * This function is the dual to the QBAND_ALLOC () function, freeing any
197: * allocated "qband" structures associated with the given queue.
198: *
199: * The caller must have the queue frozen or not linked on any stream.
200: */
201:
202: #if __USE_PROTO__
203: void (QBAND_FREE) (queue_t * q)
204: #else
205: void
206: QBAND_FREE __ARGS ((q))
207: queue_t * q;
208: #endif
209: {
210: qband_t * scan;
211: qband_t * prev;
212: int nbands;
213:
214: QUEUE_TRACE (q, "QBAND_FREE");
215:
216: /*
217: * We use flags in the "qband" entries to locate allocation
218: * boundaries rather than trying to recover this information purely
219: * from comparing addresses (although since the address comparisons
220: * provide an extra check we do that too). In theory, an allocator
221: * might not need extra information stored in the arena yet might
222: * fail if adjacent allocations are coalesced into a single free ().
223: *
224: * I don't know of any allocators with this property, but one might
225: * exist.
226: *
227: * This code will work just fine under the allocation scheme which
228: * keeps the QBAND entries in a single vector, so we don't need to
229: * conditionalize this code at all.
230: */
231:
232: nbands = 0;
233:
234: for (prev = scan = q->q_bandp ; scan != NULL ; scan = scan->qb_next) {
235:
236: if ((scan->qb_flag & QB_FIRST) != 0) {
237:
238: ASSERT (nbands > 0);
239:
240: kmem_free (prev, sizeof (* prev) * nbands);
241:
242: nbands = 1;
243: prev = scan;
244: } else {
245:
246: ASSERT (scan == prev + nbands);
247: nbands ++;
248: }
249: }
250:
251: if (nbands > 0)
252: kmem_free (prev, sizeof (* prev) * nbands);
253: }
254:
255:
256: /*
257: * Destroy an individual queue.
258: */
259:
260: #if __USE_PROTO__
261: __LOCAL__ void (QUEUE_DESTROY) (queue_t * q)
262: #else
263: __LOCAL__ void
264: QUEUE_DESTROY __ARGS ((q))
265: queue_t * q;
266: #endif
267: {
268: mblk_t * mp;
269: mblk_t * next;
270:
271: QSCHED_UNSCHEDULE (q, str_mem->sm_sched);
272:
273: /*
274: * Free all the memory allocated to messages that remain on the queue.
275: */
276:
277: for (mp = q->q_first ; mp != NULL ; mp = next) {
278:
279: next = mp->b_next;
280: freemsg (mp);
281: }
282:
283: if ((q->q_flag & QWANTW) != 0)
284: QUEUE_BACKENAB (q);
285:
286: SFREEZE_DESTROY (q);
287:
288: if (q->q_nband > 0)
289: QBAND_FREE (q);
290: }
291:
292:
293: /*
294: * Destroy and release the memory for a queue pair or group of pairs. The
295: * arguments passed to this function should match those used to allocate a
296: * pair or group of pairs exactly. This can easily be done by recognising the
297: * various canonical forms for stream structures; modules are always lone
298: * queue pairs, regular streams match a driver and stream head (with
299: * associated extra data for the stream head), and stream pipes consist of
300: * two pairs of queue structures with two head structures.
301: */
302:
303: #if __USE_PROTO__
304: __LOCAL__ void (QUEUE_FREE) (queue_t * rq, int npairs, size_t extra)
305: #else
306: __LOCAL__ void
307: QUEUE_FREE __ARGS ((rq, npairs, extra))
308: queue_t * rq;
309: int npairs;
310: size_t extra;
311: #endif
312: {
313: queue_t * destroy;
314: int count;
315:
316: ASSERT (rq != NULL);
317: ASSERT (npairs > 0 && npairs < 3);
318:
319: destroy = rq;
320: count = npairs * 2;
321:
322: do {
323:
324: QUEUE_DESTROY (destroy);
325: destroy ++;
326: } while (-- count > 0);
327:
328: kmem_free (rq, 2 * sizeof (* rq) * npairs + extra);
329: }
330:
331:
332: /*
333: * STREAM HEAD MANAGEMENT NOTES:
334: *
335: * The management of stream head structures introduces some interesting
336: * synchronization problems arising from the interaction of the rules
337: * associated with driver close routines and the fact that stream head
338: * structures are dynamically allocated.
339: *
340: * The first problem is really one of specification; what does it mean for a
341: * driver close () entry point to return EINTR? System V does not talk about
342: * this case specifically, so we prohibit it by treating error returns from
343: * the close () entry point uniformly by still actually closing the device.
344: *
345: * The second problem is this; a driver should not be re-opened until the
346: * close process has completed. However, completion of the close process will
347: * normally involve deallocation of the stream head (where presumably the
348: * open routines are waiting).
349: *
350: * Our problem is that it is not possible to reliably determine whether there
351: * are any other contexts waiting on a sleep lock. While it might be possible
352: * to do so using SLEEP_LOCKAVAIL (), this would require that the calling
353: * context release the lock. Under a plausible implementation of SLEEP_LOCK ()
354: * where sleep locks are basically implemented with the sleep () and wakeup ()
355: * functions and a "locked" flag, there will be no way for a process to find
356: * out whether there are any functions waiting on the lock, since the unlock
357: * implementation could simply clear the "locked" flag and issue wakeup (),
358: * so that there could be any number of contexts waiting to run and test the
359: * "locked" flag, yet SLEEP_LOCKAVAIL () in the calling context would return
360: * true. Deallocating the lock at this time would be potentially disastrous.
361: *
362: * Actually, even a quality implementation of sleep locks (such as is provided
363: * with this STREAMS system) cannot be easily used this way, since it is very
364: * difficult to ensure that the information returned by SLEEP_LOCKAVAIL () is
365: * current.
366: *
367: * The situation can be resolved by maintaining a count of processes wishing
368: * to lock the item. The count can be maintained by using the basic-lock
369: * action associated with DDI/DKI synchronization variables, and the new
370: * SV_SIGNAL () operation can be used to pass the ownership of the lock to
371: * a waiting process reliably.
372: *
373: * Once this is in place, it becomes clear how the count of waiting processes
374: * can be used to simplify the destruction of stream heads; essentially,
375: * when a process wishes to release the "lock" on the stream head, if both
376: * the open count and the waiting count are 0, then the memory for the item
377: * can be safely released. Otherwise, control simply passes to the next
378: * waiting process.
379: *
380: * So, if a process is performing a final close on a stream, and some open
381: * requests are queued, the close will leave the stream's memory alone and
382: * simply pass it on to the waiting open (which can detect that the stream
383: * needs to be treated as new since the open count is 0). If the waiting open
384: * was interrupted by a signal, it would still have to decrement the count of
385: * waiting processes before it releases its lock, at which time it would know
386: * to remove the item from the directory and release the memory.
387: *
388: * For this to work properly takes some coordination in the policy for the
389: * directory; the basic lock used to guard lock operations should be held
390: * during searches of the directory to ensure that the count value is correct
391: * with respect to all processes; a process that has a pointer to the stream
392: * head (obtained from the directory) which it has not incremented the count
393: * for is an error. Note that this only applies to operations which might
394: * later affect the count, of course.
395: *
396: *
397: * STREAM OPERATIONS AND LOCKS:
398: *
399: * open () This operation cannot begin while there is a final close in
400: * progress. If this operation increments the "open count" before
401: * calling the device open routines, it is possible that it will
402: * also have to perform final close duties if a driver or module
403: * fails the open. This function may cause the creation of a new
404: * queue pair and directory entry.
405: *
406: * The multiprocessor DDI/DKI also mandates that a particular
407: * device number's open () routine only have one instance active
408: * at any given time.
409: *
410: * close () Normally, this does not require extended locking, but the case
411: * of beginning a final close is special, since only then will
412: * the queue drain and final close procedures begin. Since there
413: * cannot be outstanding ioctl ()s during final close, the timer
414: * code used to control ioctl ()s can be shared with this for
415: * timing out while waiting for a write queue to drain.
416: *
417: * read (), getmsg (), getpmsg ()
418: * Under normal circumstances, these functions require no special
419: * treatment. It would be desirable to support an extension to
420: * STREAMS which supported "safe" multiple readers, where the
421: * serialization of reads is guaranteed.
422: *
423: * write (), putmsg (), putpmsg ()
424: * These functions require little special treatment. It would be
425: * desirable to support an extension to STREAMS which guaranteed
426: * serialization of writes, for instance to guarantee unlimited-
427: * length atomic pipe writes.
428: *
429: * ioctl () Depending on the details of the operation, we may need
430: *
431: * a read lock on the stream head (eg. I_GETCLTIME).
432: * a write lock on the stream head (eg. I_SRDOPT).
433: * a block on open and pop (I_PUSH).
434: * a block on close and push (I_POP).
435: * a long-term lock on the message queue.
436: *
437: * The long-term lock operations revolve around the operations
438: * that send messages downstream : I_LINK, I_UNLINK, I_PLINK,
439: * I_PUNLINK, and I_STR. These operations are also special in
440: * that they are capable of timing out.
441: *
442: * Since the close or open routines invoked by an I_PUSH or I_POP
443: * operation may block, they require analagous locking to the
444: * open () and close () cases.
445: *
446: * LOCK SUMMARY:
447: * EXCLUSIVE LONG-TERM LOCK WITH OPTIONAL TIMEOUT:
448: * open/close category:
449: * open (), close (), I_PUSH, I_POP
450: * ioctl category:
451: * I_LINK, I_UNLINK, I_PLINK, I_PUNLINK, I_STR
452: *
453: * In theory, a single lock will do. However, once we take into
454: * account terminal behaviour w.r.t. CLOCAL and other similar
455: * situations, it seems that creating the subcategories above will
456: * suit us better.
457: *
458: * Final close is a special case that blocks all other cases, which
459: * can be distinguished fairly clearly.
460: *
461: * STREAM HEAD WRITE LOCK:
462: * I_SRDOPT, I_SETSIG, I_SWROPT, I_SETCLTIME
463: * Certain stream head message processing routines may also write
464: * lock the stream head, such as M_SETOPT processing.
465: *
466: * All other streams operations should acquire a stream head read lock
467: * before reading stream head variables.
468: */
469: /*
470: * STREAM HEAD WAIT NOTES:
471: *
472: * In addition to the above discussion about locking, there are other
473: * operations that may cause a process to block while at the stream head. For
474: * instance, read (), write (), I_RECVFD, and I_STR operations may cause the
475: * outer context to block until some kind of message arrives.
476: *
477: * The question we are immediately faced with is what level of specificity to
478: * provide in the arrangement of synchronization variables and basic locks.
479: * Until the implementation is complete and we can perform detailed
480: * measurements with a variety of (pathological) loads on a variety of
481: * systems, we really don't know. For simplicity, the current system performs
482: * all stream head blocking by sleeping on the "sh_wait_sv" synchronization
483: * variable that is also used by the above locking operations.
484: *
485: * However, to give some isolation from changes in this scheme, we mandate a
486: * generic layer to deal with this. Not only does this insulate operations
487: * from the details of synchronization, but it allows us to perform some
488: * simple optimizations that may allow this simple scheme to perform better.
489: */
490:
491:
492: /*
493: * Initialize a stream head structure, assuming that memory was allocated with
494: * kmem_zalloc () and so NULL pointers and 0-value fields need not be filled
495: * in.
496: *
497: * This function may sleep waiting for memory to become available to allocate
498: * the locks needed by the stream head.
499: */
500:
501: #if __USE_PROTO__
502: __LOCAL__ void (SHEAD_INIT) (shead_t * sheadp, struct streamtab * stabp,
503: n_dev_t dev, queue_t * rq)
504: #else
505: __LOCAL__ void
506: SHEAD_INIT __ARGS ((sheadp, stabp, dev, rq))
507: shead_t * sheadp;
508: struct streamtab
509: * stabp;
510: n_dev_t dev;
511: queue_t * rq;
512: #endif
513: {
514: ASSERT (sheadp != NULL);
515: ASSERT (rq != NULL);
516:
517: /*
518: * The sh_lock_count and sh_time_count members are initialized in the
519: * lock code.
520: */
521:
522: ASSERT (sheadp->sh_open_count == 0);
523: ASSERT (sheadp->sh_attach_count == 0);
524: ASSERT (sheadp->sh_lock_count == 0);
525: ASSERT (sheadp->sh_time_count == 0);
526: ASSERT (sheadp->sh_rerrcode == 0);
527: ASSERT (sheadp->sh_werrcode == 0);
528: ASSERT (sheadp->sh_wroff == 0);
529:
530: ASSERT (sheadp->sh_read_bufcall == 0);
531: ASSERT (sheadp->sh_timeout_id == 0);
532:
533: ASSERT (sheadp->sh_sigs == NULL);
534: ASSERT (sheadp->sh_linked == NULL);
535: ASSERT (sheadp->sh_ioc_msg == NULL);
536:
537: ASSERT (rq->q_ptr == sheadp);
538:
539: sheadp->sh_dev = dev;
540: sheadp->sh_tab = stabp;
541: sheadp->sh_head = rq;
542:
543: sheadp->sh_pollhead = phalloc (KM_SLEEP);
544: sheadp->sh_flags = SH_MASTER;
545: sheadp->sh_readopt = RNORM | RPROTNORM;
546:
547: sheadp->sh_basic_lockp = LOCK_ALLOC (stream_head_hierarchy, plstr,
548: & _stream_head_lkinfo, KM_SLEEP);
549: sheadp->sh_wait_sv = SV_ALLOC (KM_SLEEP);
550:
551: ASSERT (sheadp->sh_basic_lockp != NULL || sheadp->sh_wait_sv != NULL);
552:
553:
554: /*
555: * The default time to wait for a queue to drain while closing is 15s.
556: */
557:
558: sheadp->sh_cltime = drv_usectohz (15000000L);
559: }
560:
561:
562: /*
563: * Turn a stream head structure back into raw bits.
564: */
565:
566: #if __USE_PROTO__
567: __LOCAL__ void (SHEAD_DESTROY) (shead_t * sheadp)
568: #else
569: __LOCAL__ void
570: SHEAD_DESTROY __ARGS((sheadp))
571: shead_t * sheadp;
572: #endif
573: {
574: ASSERT (sheadp != NULL);
575: ASSERT (sheadp->sh_sigs == NULL);
576: ASSERT (sheadp->sh_linked == NULL);
577:
578: ASSERT (sheadp->sh_open_count == 0);
579: ASSERT (sheadp->sh_attach_count == 0);
580: ASSERT (sheadp->sh_lock_count == 0);
581:
582: ASSERT (sheadp->sh_timeout_id == 0);
583:
584: if (sheadp->sh_read_bufcall != 0)
585: unbufcall (sheadp->sh_read_bufcall);
586:
587: LOCK_DEALLOC (sheadp->sh_basic_lockp);
588: SV_DEALLOC (sheadp->sh_wait_sv);
589:
590: phfree (sheadp->sh_pollhead);
591: }
592:
593:
594: /*
595: * This function attempts to determine the appropriate id queue for a stream
596: * head based on cues in the stream head.
597: */
598:
599: #if __USE_PROTO__
600: __LOCAL__ slist_id_t (SHEAD_ID) (shead_t * sheadp)
601: #else
602: __LOCAL__ slist_id_t
603: SHEAD_ID __ARGS ((sheadp))
604: shead_t * sheadp;
605: #endif
606: {
607: ASSERT (sheadp != NULL);
608:
609: if (SHEAD_IS_PIPE (sheadp))
610: return PIPE_SLIST;
611:
612: return DEV_SLIST;
613: }
614:
615:
616: /*
617: * This function finds a stream head by looking up its device number, but
618: * nothing else. To call this function, the caller must have good reason to
619: * suspect that an open reference to the stream exists and isn't going to go
620: * away.
621: *
622: * If this routine returns NULL, then that is a serious error (which may be
623: * diagnosed by console messages), because it indicates that the caller has
624: * not got the claimed knowledge of the state of the system!
625: */
626:
627: #if __USE_PROTO__
628: shead_t * (SHEAD_FIND) (n_dev_t dev, slist_id_t id)
629: #else
630: shead_t *
631: SHEAD_FIND __ARGS ((dev, id))
632: n_dev_t dev;
633: slist_id_t id;
634: #endif
635: {
636: shead_t * scan;
637: pl_t prev_pl;
638:
639: prev_pl = RW_RDLOCK (str_mem->sm_head_lock, plstr);
640:
641: for (scan = str_mem->sm_streams [id] ; scan != NULL ;
642: scan = scan->sh_next) {
643:
644: if (scan->sh_dev == dev)
645: break;
646: }
647:
648: RW_UNLOCK (str_mem->sm_head_lock, prev_pl);
649:
650: if (scan == NULL)
651: cmn_err (CE_WARN, "Unable to locate stream in SHEAD_FIND ()");
652: else
653: ASSERT (SHEAD_ID (scan) == id);
654:
655: return scan;
656: }
657:
658:
659: /*
660: * This function attempts to locate an existing entry and increment its lock
661: * count atomically.
662: */
663:
664: #if __USE_PROTO__
665: __LOCAL__ shead_t * (SHEAD_FIND_AND_LOCK) (n_dev_t dev, slist_id_t id)
666: #else
667: __LOCAL__ shead_t *
668: SHEAD_FIND_AND_LOCK __ARGS ((dev, id))
669: n_dev_t dev;
670: slist_id_t id;
671: #endif
672: {
673: shead_t * scan;
674: pl_t prev_pl;
675:
676: prev_pl = RW_RDLOCK (str_mem->sm_head_lock, plstr);
677:
678: for (scan = str_mem->sm_streams [id] ; scan != NULL ;
679: scan = scan->sh_next) {
680:
681: if (scan->sh_dev == dev) {
682: /*
683: * Now we have found the entry we want, increment the
684: * reference count atomically. We know that it will
685: * not disappear because of the read lock we have on
686: * the containing list.
687: */
688:
689: (void) SHEAD_LOCK (scan);
690:
691: scan->sh_lock_count ++;
692: break;
693: }
694: }
695:
696: RW_UNLOCK (str_mem->sm_head_lock, prev_pl);
697: return scan;
698: }
699:
700:
701: /*
702: * This function adds a stream head to the global list. If an entry with the
703: * same ID is present on the list, this operation fails.
704: *
705: * The stream head should be locked against further opens at this point.
706: *
707: * The return value is 0 on success, -1 on error.
708: */
709:
710: #if __USE_PROTO__
711: __LOCAL__ int (SHEAD_ADD) (shead_t * sheadp)
712: #else
713: __LOCAL__ int
714: SHEAD_ADD __ARGS ((sheadp))
715: shead_t * sheadp;
716: #endif
717: {
718: pl_t prev_pl;
719: shead_t * scan;
720: slist_id_t id;
721:
722: id = SHEAD_ID (sheadp);
723:
724: ASSERT (sheadp->sh_ref_count == 1);
725: ASSERT ((sheadp->sh_lock_mask & SH_OPENCLOSE) != 0);
726:
727: prev_pl = RW_WRLOCK (str_mem->sm_head_lock, plstr);
728:
729: for (scan = str_mem->sm_streams [id] ; scan != NULL ;
730: scan = scan->sh_next) {
731:
732: if (scan->sh_dev == sheadp->sh_dev) {
733: /*
734: * We have found a conflict. Unlock the list and
735: * return an error.
736: */
737:
738: RW_UNLOCK (str_mem->sm_head_lock, prev_pl);
739: return -1;
740: }
741: }
742:
743: sheadp->sh_next = str_mem->sm_streams [id];
744: str_mem->sm_streams [id] = sheadp;
745:
746: RW_UNLOCK (str_mem->sm_head_lock, prev_pl);
747: return 0;
748: }
749:
750:
751: /*
752: * This function changes the device number of a stream head for a clone open
753: * situation. The "st_dev" field of the stream head has to be changed with
754: * the stream head list lock held for writing to avoid confusing anyone who
755: * is looking for the original device number.
756: *
757: * Furthermore, the rename can fail because the new number is already in use.
758: * The return value is -1 on error, or 0 on success.
759: */
760:
761: #if __USE_PROTO__
762: __LOCAL__ int (SHEAD_RENAME) (shead_t * sheadp, n_dev_t dev)
763: #else
764: __LOCAL__ int
765: SHEAD_RENAME __ARGS ((sheadp, dev))
766: shead_t * sheadp;
767: n_dev_t dev;
768: #endif
769: {
770: pl_t prev_pl;
771: shead_t * scan;
772: int ok = 0; /* flag whether stream is on list */
773: slist_id_t id;
774:
775: id = SHEAD_ID (sheadp);
776:
777: prev_pl = RW_WRLOCK (str_mem->sm_head_lock, plstr);
778:
779: for (scan = str_mem->sm_streams [id] ; scan != NULL ;
780: scan = scan->sh_next) {
781:
782: if (scan->sh_dev == dev) {
783: /*
784: * We have found a conflict. Unlock the list and
785: * return an error.
786: */
787:
788: RW_UNLOCK (str_mem->sm_head_lock, prev_pl);
789: return -1;
790: }
791:
792: if (scan == sheadp)
793: ok ++; /* Ok, we saw the item */
794: }
795:
796: /*
797: * All OK, now change the name of the original stream head.
798: */
799:
800: sheadp->sh_dev = dev;
801: RW_UNLOCK (str_mem->sm_head_lock, prev_pl);
802:
803: if (! ok)
804: cmn_err (CE_WARN, "SHEAD_RENAME () of unlisted stream head");
805:
806: return 0;
807: }
808:
809:
810: /*
811: * This function decrements the link count of the stream head; this may cause
812: * the stream head to become unreferened, which means that the memory will be
813: * reclaimed.
814: */
815:
816: #if __USE_PROTO__
817: __LOCAL__ void (SHEAD_UNREFERENCE) (shead_t * sheadp)
818: #else
819: __LOCAL__ void
820: SHEAD_UNREFERENCE __ARGS ((sheadp))
821: shead_t * sheadp;
822: #endif
823: {
824: slist_id_t id;
825: int unlink;
826:
827: SHEAD_ASSERT_LOCKED (sheadp);
828: ASSERT (sheadp == SHEAD_MASTER (sheadp));
829: ASSERT (sheadp->sh_lock_count > 0);
830:
831: id = SHEAD_ID (sheadp);
832:
833: /*
834: * We will delete a stream if there are no references holding it open,
835: * either pending locks or open references. If this is a stream pipe,
836: * then we need to check boths ends of the stream pipe. Because this
837: * function is called from the sleep-locking code, we know that
838: * "sheadp" points to the master end.
839: */
840:
841: unlink = sheadp->sh_open_count == 0 ||
842: (SHEAD_IS_PIPE (sheadp) &&
843: SHEAD_M2SLAVE (sheadp->sh_open_count) == 0);
844:
845: /*
846: * We normally assume that we won't be unlinking the stream, because
847: * to do that we need a lock on a global list (which is more expensive
848: * that a list on an individual stream).
849: *
850: * However, due to the relative hierarchy positions of the locks, if
851: * we discover we are likely to be the ones to dequeue the item, we
852: * take out a write lock then.
853: */
854:
855: if (sheadp->sh_lock_count > 1 && ! unlink) {
856: /*
857: * Take the short path out.
858: */
859:
860: sheadp->sh_lock_count --;
861: SHEAD_UNLOCK (sheadp, plbase);
862: return;
863: }
864:
865: /*
866: * Escalate to a write lock on the stream head; we will need
867: * to recheck to unlink condition after we escalate.
868: */
869:
870: SHEAD_UNLOCK (sheadp, plbase);
871:
872: (void) RW_WRLOCK (str_mem->sm_head_lock, plstr);
873: (void) SHEAD_LOCK (sheadp);
874:
875: unlink = -- sheadp->sh_lock_count == 0 &&
876: (sheadp->sh_open_count == 0 ||
877: (SHEAD_IS_PIPE (sheadp) &&
878: SHEAD_M2SLAVE (sheadp)->sh_open_count == 0));
879:
880: SHEAD_UNLOCK (sheadp, plstr);
881:
882: if (unlink) {
883: shead_t * scan;
884:
885: /*
886: * Remove from the singly-threaded list by searching for the
887: * immediate predecessor entry in the list (if any).
888: */
889:
890: if ((scan = str_mem->sm_streams [id]) == sheadp)
891: str_mem->sm_streams [id] = sheadp->sh_next;
892: else
893: do {
894: if (scan->sh_next == sheadp) {
895:
896: scan->sh_next = sheadp->sh_next;
897: break;
898: }
899: } while ((scan = scan->sh_next) != NULL);
900:
901: if (scan == NULL)
902: cmn_err (CE_WARN, "Failure unlinking stream from global directory");
903:
904: /*
905: * Note that stream pipes consist of four queues and
906: * two stream heads!
907: */
908:
909: SHEAD_DESTROY (sheadp);
910:
911: if (SHEAD_IS_PIPE (sheadp))
912: QUEUE_FREE (sheadp->sh_head, 4,
913: 2 * sizeof (* sheadp));
914: else
915: QUEUE_FREE (sheadp->sh_head, 2, sizeof (* sheadp));
916: }
917:
918: RW_UNLOCK (str_mem->sm_head_lock, plbase);
919: }
920:
921:
922: /*
923: * This function attempts to locate a stream linked below another stream based
924: * on the multiplexor ID. If the multiplexor ID is -1, then this function
925: * returns the first stream found linked below the given upper stream. In
926: * addition, the "cmd" value is used to distinguish between the persistent and
927: * regular multiplexor ID spaces.
928: */
929:
930: #if __USE_PROTO__
931: __LOCAL__ shead_t * (SHEAD_FIND_MUXID) (shead_t * upper, int cmd,
932: muxid_t muxid)
933: #else
934: __LOCAL__ shead_t *
935: SHEAD_FIND_MUXID __ARGS ((upper, cmd, muxid))
936: shead_t * upper;
937: int cmd;
938: muxid_t muxid;
939: #endif
940: {
941: shead_t * scan;
942: pl_t prev_pl;
943: int checklist;
944:
945: /*
946: * Precook "cmd" for easier testing below.
947: */
948:
949: cmd = (cmd == I_PLINK || cmd == I_PUNLINK) ? SH_PLINK : 0;
950:
951:
952: /*
953: * Now take out a lock to protect our list walking.
954: */
955:
956: prev_pl = RW_RDLOCK (str_mem->sm_head_lock, plstr);
957:
958: for (checklist = DEV_SLIST ; checklist < SLIST_MAX ; checklist ++) {
959:
960: for (scan = str_mem->sm_streams [checklist] ; scan != NULL ;
961: scan = scan->sh_next) {
962:
963: if (scan->sh_linked == upper &&
964: (scan->sh_flags & SH_PLINK) == cmd &&
965: ((scan->sh_muxid == muxid) || muxid == -1)) {
966:
967: goto done;
968: }
969: }
970: }
971:
972: done:
973: RW_UNLOCK (str_mem->sm_head_lock, prev_pl);
974:
975: return scan;
976: }
977:
978:
979: /*
980: * A local helper function for stream head timeouts.
981: */
982:
983: #if __USE_PROTO__
984: __LOCAL__ void shead_timer_func (_VOID * arg)
985: #else
986: __LOCAL__ void
987: shead_timer_func (arg)
988: _VOID * arg;
989: #endif
990: {
991: shead_t * sheadp = (shead_t *) arg;
992: unsigned locks;
993:
994: SHEAD_ASSERT_LOCKED (sheadp);
995:
996: SV_BROADCAST (sheadp->sh_wait_sv, 0);
997:
998: sheadp->sh_lock_mask &= ~ SH_TIMEFLAG;
999: sheadp->sh_timeout_id = 0;
1000: sheadp->sh_time_count = 0;
1001:
1002: /*
1003: * Note that we advance "sh_time_count" on behalf of the processes
1004: * that have the stream head locked.
1005: */
1006:
1007: locks = sheadp->sh_lock_mask & SH_LOCK_MASK;
1008:
1009: while (locks != 0) {
1010:
1011: if ((locks & 1) != 0)
1012: sheadp->sh_time_count ++;
1013: locks >>= 1;
1014: }
1015: }
1016:
1017:
1018: /*
1019: * This function is called when the time has come to actually initiate a
1020: * timeout.
1021: */
1022:
1023: #if __USE_PROTO__
1024: int (SHEAD_START_TIMEOUT) (shead_t * sheadp)
1025: #else
1026: int
1027: SHEAD_START_TIMEOUT __ARGS ((sheadp))
1028: shead_t * sheadp;
1029: #endif
1030: {
1031: __clock_t the_time;
1032:
1033: SHEAD_ASSERT_LOCKED (sheadp);
1034:
1035: if ((sheadp->sh_lock_mask & SH_TIMEFLAG) == 0 ||
1036: sheadp->sh_timeout_id != 0)
1037: return 1; /* do nothing */
1038:
1039: (void) drv_getparm (LBOLT, & the_time);
1040:
1041: sheadp->sh_timeout_id = ltimeout (shead_timer_func, sheadp,
1042: sheadp->sh_timeout_tick - the_time,
1043: sheadp->sh_basic_lockp, plstr);
1044:
1045: /*
1046: * If the timeout could not be scheduled, we return 0 to indicate to
1047: * the caller that it should timeout immediately, and run the timeout
1048: * function to fake a normal timeout.
1049: */
1050:
1051: if (sheadp->sh_timeout_id == 0) {
1052:
1053: shead_timer_func (sheadp);
1054: return 0;
1055: }
1056:
1057: return 1;
1058: }
1059:
1060:
1061: /*
1062: * Indicate that no timeout will be necessary for this lock item.
1063: */
1064:
1065: #if __USE_PROTO__
1066: void (SHEAD_NO_TIMEOUT) (shead_t * sheadp)
1067: #else
1068: void
1069: SHEAD_NO_TIMEOUT __ARGS ((sheadp))
1070: shead_t * sheadp;
1071: #endif
1072: {
1073: SHEAD_ASSERT_LOCKED (sheadp);
1074:
1075: ASSERT (sheadp->sh_time_count < sheadp->sh_lock_count);
1076:
1077: if (++ sheadp->sh_time_count == sheadp->sh_lock_count) {
1078: /*
1079: * Since we are the last process to register an end time, we
1080: * get to actually initiate a timeout for the stream head.
1081: */
1082:
1083: (void) SHEAD_START_TIMEOUT (sheadp);
1084: }
1085: }
1086:
1087:
1088: /*
1089: * Indicate that a timeout is desired for this lock item at the given clock
1090: * tick.
1091: */
1092:
1093: #if __USE_PROTO__
1094: int (SHEAD_LOCK_TIMEOUT) (shead_t * sheadp, __clock_t end_time)
1095: #else
1096: int
1097: SHEAD_LOCK_TIMEOUT __ARGS ((sheadp, end_time))
1098: shead_t * sheadp;
1099: __clock_t end_time;
1100: #endif
1101: {
1102: __clock_t the_time;
1103:
1104: SHEAD_ASSERT_LOCKED (sheadp);
1105:
1106: ASSERT (sheadp->sh_time_count < sheadp->sh_lock_count);
1107:
1108:
1109: /*
1110: * If our horizon falls before the current latest value (or if there
1111: * is no latest value), select our horizon time. If the horizon time
1112: * is *before* the current time, return 0.
1113: *
1114: * Comparing time values introduces the usual problems when dealing
1115: * with sequence spaces in C. While the following expression is not
1116: * as efficient as relying on the semantics of unsigned->signed
1117: * casting, avoiding implementation-defined behaviour is important.
1118: *
1119: * "clock_t" MUST be unsigned for this to work.
1120: */
1121:
1122: ASSERT ((__clock_t) -1 > 0);
1123:
1124: (void) drv_getparm (LBOLT, & the_time);
1125:
1126: if ((__clock_t) (the_time - end_time) < ((__clock_t) -1 >> 1)) {
1127: /*
1128: * The indicated time has already passed, so we return a
1129: * timeout indication directly.
1130: */
1131:
1132: sheadp->sh_time_count ++;
1133: return 0;
1134: }
1135:
1136:
1137: if ((sheadp->sh_lock_mask & SH_TIMEFLAG) == 0 ||
1138: (__clock_t) (sheadp->sh_timeout_tick - end_time) <
1139: ((__clock_t) -1 >> 1)) {
1140: /*
1141: * "end_time" will occur before the current latest time. If
1142: * a timeout has been scheduled, we cancel it because we want
1143: * to post a more recent one.
1144: */
1145:
1146: if (sheadp->sh_timeout_id != 0) {
1147:
1148: untimeout (sheadp->sh_timeout_id);
1149: sheadp->sh_timeout_id = 0;
1150: }
1151:
1152: sheadp->sh_lock_mask |= SH_TIMEFLAG;
1153: }
1154:
1155: if (++ sheadp->sh_time_count == sheadp->sh_lock_count) {
1156: /*
1157: * Since we are the last process to register an end time, we
1158: * get to actually initiate a timeout for the stream head.
1159: */
1160:
1161: return SHEAD_START_TIMEOUT (sheadp);
1162: } else {
1163: /*
1164: * We can go to sleep and rely on someone else to actually
1165: * intiate the timeout.
1166: */
1167:
1168: return 1;
1169: }
1170: }
1171:
1172:
1173: /*
1174: * This function is used when a process wants to cancel a timeout after having
1175: * registered one.
1176: */
1177:
1178: #if __USE_PROTO__
1179: void (SHEAD_END_TIMEOUT) (shead_t * sheadp)
1180: #else
1181: void
1182: SHEAD_END_TIMEOUT __ARGS ((sheadp))
1183: shead_t * sheadp;
1184: #endif
1185: {
1186: SHEAD_ASSERT_LOCKED (sheadp);
1187:
1188: if (sheadp->sh_timeout_id != 0) {
1189:
1190: ASSERT (sheadp->sh_time_count == sheadp->sh_lock_count + 1);
1191: sheadp->sh_time_count --;
1192: }
1193: }
1194:
1195:
1196: /*
1197: * This function is used when a lock holder wishes to sleep waiting for a
1198: * timeout.
1199: */
1200:
1201: #if __USE_PROTO__
1202: int (SHEAD_LOCKED_TIMEOUT) (shead_t * sheadp, __clock_t end_time)
1203: #else
1204: int
1205: SHEAD_LOCKED_TIMEOUT __ARGS ((sheadp, end_time))
1206: shead_t * sheadp;
1207: __clock_t end_time;
1208: #endif
1209: {
1210: SHEAD_ASSERT_LOCKED (sheadp);
1211:
1212: ASSERT (sheadp->sh_time_count > 0);
1213:
1214: sheadp->sh_time_count --;
1215:
1216: return SHEAD_LOCK_TIMEOUT (sheadp, end_time);
1217: }
1218:
1219:
1220: /*
1221: * Common code to test whether a stream has experienced an error condition.
1222: */
1223:
1224: #define _shead_error(sheadp,mode) \
1225: (SHEAD_ASSERT_LOCKED (sheadp), \
1226: sheadp->sh_linked != NULL ? EINVAL : \
1227: ((mode) & FWRITE) != 0 && sheadp->sh_werrcode != 0 ? \
1228: sheadp->sh_werrcode : \
1229: ((mode) & FREAD) != 0 ? sheadp->sh_rerrcode : 0)
1230:
1231: /*
1232: * This function tests for error or hangup conditions on the stream head given
1233: * by "sheadp". It assumes that the caller holds a basic lock on the stream
1234: * head. If an error or hangup condition exists then the basic lock is
1235: * unlocked and a non-zero error number is returned.
1236: */
1237:
1238: #if __USE_PROTO__
1239: __LOCAL__ int (SHEAD_ERRHUP_LOCKED) (shead_t * sheadp, int mode)
1240: #else
1241: __LOCAL__ int
1242: SHEAD_ERRHUP_LOCKED __ARGS ((sheadp, mode))
1243: shead_t * sheadp;
1244: int mode;
1245: #endif
1246: {
1247: int retval;
1248:
1249: SHEAD_ASSERT_LOCKED (sheadp);
1250:
1251: if ((retval = _shead_error (sheadp, mode)) != 0 ||
1252: ((mode & (FREAD | FWRITE)) != 0 &&
1253: (retval = ENXIO, SHEAD_HANGUP (sheadp) != 0))) {
1254:
1255: SHEAD_UNLOCK (sheadp, plbase);
1256: return retval;
1257: }
1258:
1259: return 0;
1260: }
1261:
1262:
1263: /*
1264: * Definitions use for the "interruptible" parameter to SHEAD_WAIT () and
1265: * SHEAD_LOCK ().
1266: */
1267:
1268: enum {
1269: DONT_SIGNAL = 0,
1270: CHECK_SIGNALS = 1
1271: };
1272:
1273:
1274: /*
1275: * This function is the common interface to waiting for an event at a stream
1276: * head. It borrows the same synchronization variable used by the stream head
1277: * locking code in this implementation.
1278: *
1279: * We return 0 on success or an error number on failure.
1280: */
1281:
1282: #if __USE_PROTO__
1283: __LOCAL__ int (SHEAD_WAIT) (shead_t * sheadp, int mode, cat_t category,
1284: int interruptible)
1285: #else
1286: __LOCAL__ int
1287: SHEAD_WAIT __ARGS ((sheadp, mode, category, interruptible))
1288: shead_t * sheadp;
1289: int mode;
1290: cat_t category;
1291: int interruptible;
1292: #endif
1293: {
1294: int retval;
1295:
1296: SHEAD_ASSERT_LOCKED (sheadp);
1297:
1298: /*
1299: * Test for error/hangup conditions before we sleep.
1300: */
1301:
1302: if ((retval = SHEAD_ERRHUP_LOCKED (sheadp, mode)) != 0)
1303: return retval;
1304:
1305: /*
1306: * Register our interest in the kind of event that we are waiting for.
1307: */
1308:
1309: sheadp->sh_lock_mask |= category;
1310:
1311: if (interruptible == CHECK_SIGNALS)
1312: return SV_WAIT_SIG (sheadp->sh_wait_sv, primed,
1313: sheadp->sh_basic_lockp) == 0 ? EINTR : 0;
1314: else {
1315: SV_WAIT (sheadp->sh_wait_sv, primed, sheadp->sh_basic_lockp);
1316: return 0;
1317: }
1318: }
1319:
1320:
1321: /*
1322: * This function is a slightly different interface to SHEAD_WAIT (), used when
1323: * the caller has been examining some property of a queue and wishes to go
1324: * to sleep atomically. A frozen queue is not suitable for passing to
1325: * SV_WAIT_SIG (), so we acquire the stream head global lock and then unfreeze
1326: * the queue on behalf of the caller. This yields correct behaviour because
1327: * SHEAD_WAKE () also attempts to acquire the stream head global lock; any
1328: * modification to a stream queue resulting in a wakeup request will follow
1329: * the same locking sequence.
1330: */
1331:
1332: #if __USE_PROTO__
1333: __LOCAL__ int (SHEAD_WAIT_NONBLOCK) (shead_t * sheadp, int mode,
1334: cat_t category, int interruptible)
1335: #else
1336: __LOCAL__ int
1337: SHEAD_WAIT_NONBLOCK __ARGS ((sheadp, mode, category, interruptible))
1338: shead_t * sheadp;
1339: int mode;
1340: cat_t category;
1341: int interruptible;
1342: #endif
1343: {
1344: SHEAD_ASSERT_LOCKED (sheadp);
1345:
1346: if ((mode & (FNDELAY | FNONBLOCK)) != 0) {
1347:
1348: SHEAD_UNLOCK (sheadp, plbase);
1349: return EAGAIN;
1350: }
1351:
1352: return SHEAD_WAIT (sheadp, mode, category, interruptible);
1353: }
1354:
1355:
1356: /*
1357: * This function is used by lower-level code to signal events to functions
1358: * that have waited via SHEAD_WAIT (), above.
1359: */
1360:
1361: #if __USE_PROTO__
1362: void (SHEAD_WAKE) (shead_t * sheadp, cat_t category)
1363: #else
1364: void
1365: SHEAD_WAKE __ARGS ((sheadp, category))
1366: shead_t * sheadp;
1367: cat_t category;
1368: #endif
1369: {
1370: pl_t prev_pl;
1371:
1372: prev_pl = SHEAD_LOCK (sheadp);
1373:
1374: if ((sheadp->sh_lock_mask & category) != 0) {
1375:
1376: sheadp->sh_lock_mask &= ~ category;
1377: SV_BROADCAST (sheadp->sh_wait_sv, 0);
1378: }
1379:
1380: SHEAD_UNLOCK (sheadp, prev_pl);
1381: }
1382:
1383:
1384: /*
1385: * Common code for locking stream head, shared between open-style locks (which
1386: * may need to allocate new head structures and need special coordination
1387: * with the stream head destruction code) and other kinds.
1388: *
1389: * We expect that the caller will have taken out a basic lock on the stream
1390: * head and that the caller will have incremented the lock count of the item
1391: * to prevent it from being deallocated while we wait.
1392: */
1393:
1394: #if __USE_PROTO__
1395: int (SHEAD_SLEEP_LOCKED) (shead_t * sheadp, cat_t category, __clock_t timeout,
1396: int interruptible)
1397: #else
1398: int
1399: SHEAD_SLEEP_LOCKED __ARGS ((sheadp, category, timeout, interruptible))
1400: shead_t * sheadp;
1401: cat_t category;
1402: __clock_t timeout;
1403: int interruptible;
1404: #endif
1405: {
1406: __clock_t end_time; /* LBOLT when we time out */
1407: n_dev_t devno;
1408: int retval;
1409:
1410: SHEAD_ASSERT_LOCKED (sheadp);
1411:
1412: /*
1413: * Since we expect the caller to have incremented the lock count, then
1414: * the caller must have selected the master end of the stream pipe.
1415: */
1416:
1417: ASSERT (sheadp == SHEAD_MASTER (sheadp));
1418:
1419: /*
1420: * If we are going to be (possibly) timing out, calculate the time
1421: * when that will happen.
1422: */
1423:
1424: if (timeout > 0) {
1425:
1426: (void) drv_getparm (LBOLT, & end_time);
1427: end_time += timeout;
1428: }
1429:
1430:
1431: /*
1432: * There is a special case that we have to note; in the case of a
1433: * clone open, the device number of a stream head may be altered by
1434: * the driver open routine. In this case, drivers waiting on the old
1435: * number will have to be notified and give up on their lock attempts.
1436: */
1437:
1438: devno = sheadp->sh_dev;
1439:
1440:
1441: /*
1442: * Now we begin the actual business of locking the stream head.
1443: */
1444:
1445: for (;;) {
1446: int sigflg;
1447:
1448: /*
1449: * Check to see whether our category is blocked. At this point
1450: * we hold "global_lock".
1451: *
1452: * An earlier verson of this code had an explicit check for
1453: * final close. I have no idea why, because if a stream is in
1454: * final close, what else can happen?
1455: */
1456:
1457: if ((sheadp->sh_lock_mask & category) == 0) {
1458: /*
1459: * We can acquire a lock on the stream head in our
1460: * chosen category, so we do so. Since we will not
1461: * need a timeout, we increment the timeout count.
1462: *
1463: * If during later processing we need a timeout, we
1464: * hook into this mechanism, but for simplicity we
1465: * assume we won't.
1466: */
1467:
1468: SHEAD_NO_TIMEOUT (sheadp);
1469:
1470: SHEAD_UNLOCK (sheadp, plbase);
1471:
1472: sheadp->sh_lock_mask |= category;
1473:
1474: return 0;
1475: }
1476:
1477:
1478: /*
1479: * We need to wait, interruptibly. We might also want to time
1480: * out at some stage.
1481: *
1482: * We (optionally) call a function to register the time we
1483: * want to expire; this function also takes care of checking
1484: * for timeout expiry.
1485: */
1486:
1487: if (timeout == 0)
1488: SHEAD_NO_TIMEOUT (sheadp);
1489: else if (SHEAD_LOCK_TIMEOUT (sheadp, end_time) == 0) {
1490: /*
1491: * Our horizon time has passed, so we return ETIME.
1492: */
1493:
1494: retval = ETIME;
1495: break;
1496: }
1497:
1498:
1499: /*
1500: * Now we can wait. No matter how we wake up, we will need
1501: * to relock the global basic lock.
1502: *
1503: * The caller may not want this wait to be interruptible; this
1504: * is reasonable when the lock is being acquired in some
1505: * nested context where things are difficult to back out.
1506: */
1507:
1508: if (interruptible != DONT_SIGNAL)
1509: sigflg = SV_WAIT_SIG (sheadp->sh_wait_sv, primed,
1510: sheadp->sh_basic_lockp);
1511: else {
1512: SV_WAIT (sheadp->sh_wait_sv, primed,
1513: sheadp->sh_basic_lockp);
1514: sigflg = 1;
1515: }
1516:
1517: (void) SHEAD_LOCK (sheadp);
1518:
1519: if (sigflg == 0) {
1520: /*
1521: * We have been interrupted by a signal, so bang out
1522: * to the caller with EINTR.
1523: */
1524:
1525: retval = EINTR;
1526: break;
1527: } else if (sheadp->sh_dev != devno) {
1528: /*
1529: * The device number has been altered. Flag the fact
1530: * to the caller and give up this lock attempt.
1531: */
1532:
1533: retval = ENODEV;
1534: break;
1535: }
1536:
1537:
1538: /*
1539: * Now we have the global basic lock, we can wrap around to
1540: * the start of the loop to recheck all our conditions.
1541: */
1542: }
1543:
1544:
1545: /*
1546: * For some reason we are aborting the lock attempt. The code which
1547: * make us take this exit path should have set "* retvalp" with an
1548: * error code.
1549: */
1550:
1551: if (sheadp->sh_time_count > sheadp->sh_lock_count) {
1552:
1553: sheadp->sh_time_count --;
1554: ASSERT (sheadp->sh_time_count == sheadp->sh_lock_count);
1555:
1556: SHEAD_START_TIMEOUT (sheadp);
1557: }
1558:
1559: SHEAD_UNREFERENCE (sheadp);
1560: return retval;
1561: }
1562:
1563:
1564: /*
1565: * Entry point for the stream head locking system for use by routines that
1566: * already have a reference to the stream head. This entry performs checks for
1567: * routine errors including linked streams.
1568: */
1569:
1570: #if __USE_PROTO__
1571: int (SHEAD_SLEEP_LOCK) (shead_t * sheadp, cat_t category, __clock_t timeout,
1572: int interruptible)
1573: #else
1574: int
1575: SHEAD_SLEEP_LOCK __ARGS ((sheadp, category, timeout, interruptible))
1576: shead_t * sheadp;
1577: cat_t category;
1578: __clock_t timeout;
1579: int interruptible;
1580: #endif
1581: {
1582: SHEAD_LOCK (sheadp);
1583:
1584: /*
1585: * The read and write lock modes are experimental. We have a mode bit
1586: * that says whether or not we are really interested in honouring
1587: * these lock types.
1588: */
1589:
1590: if (((sheadp->sh_flags & SH_RWLOCKING) == 0 &&
1591: (category & ~ (SH_READ_LOCK | SH_WRITE_LOCK)) == 0)) {
1592:
1593: SHEAD_UNLOCK (sheadp, plbase);
1594: return 0;
1595: }
1596:
1597:
1598: /*
1599: * If the caller wishes to lock a stream head that is part of a stream
1600: * pipe, we direct the lock attempt to the master stream head of the
1601: * pair that form the pipe. This ensures that any attempt to modify
1602: * the state of the pipe from either end will be properly single-
1603: * threaded.
1604: *
1605: * Note that we *must* perform a similar redirection in the unlock.
1606: */
1607:
1608: sheadp = SHEAD_MASTER (sheadp);
1609:
1610:
1611: /*
1612: * We have a pointer to the stream head and hold a global basic lock.
1613: *
1614: * With the protection of the basic lock, we increment the lock count.
1615: */
1616:
1617: sheadp->sh_lock_count ++;
1618:
1619: /*
1620: * Now we begin the actual business of locking the stream head.
1621: */
1622:
1623: return SHEAD_SLEEP_LOCKED (sheadp, category, timeout, interruptible);
1624: }
1625:
1626:
1627: /*
1628: * This is a special form of the stream head locking code for open () access,
1629: * which specially coordinates with the close code to discover when to
1630: * allocate a new stream head, and carefully avoids the problems that can
1631: * occur if the stream head were to be deallocated which we are waiting for
1632: * it to be unlocked.
1633: *
1634: * We also have to do some funky stuff here because of clone opens.
1635: */
1636:
1637: #if __USE_PROTO__
1638: shead_t * (SHEAD_OPEN_LOCK) (n_dev_t dev, struct streamtab * stabp,
1639: int * retvalp)
1640: #else
1641: shead_t *
1642: SHEAD_OPEN_LOCK __ARGS ((dev, stabp, retvalp))
1643: n_dev_t dev;
1644: struct streamtab
1645: * stabp;
1646: int * retvalp;
1647: #endif
1648: {
1649: shead_t * sheadp;
1650:
1651: ASSERT (retvalp != NULL);
1652:
1653: /*
1654: * PHASE 1: Locate the stream head. If the stream head did not
1655: * previously exist, we might be able to lock it immediately by virtue
1656: * of being able to create it that way. Of course, simultaneous open
1657: * attempts might result in this looping as only once of the created
1658: * stream heads will be entered in the stream directory.
1659: */
1660:
1661: * retvalp = 0;
1662:
1663: for (;;) {
1664: queue_t * q;
1665:
1666: /*
1667: * The first thing we need to do is *find* the stream. We call
1668: * a find routine that increments a reference count so that
1669: * we can be sure that the stream will not be deallocated
1670: * while we wait.
1671: */
1672:
1673: if ((sheadp = SHEAD_FIND_AND_LOCK (dev, DEV_SLIST)) != NULL) {
1674: /*
1675: * Sleep lock time; our call to SHEAD_FIND_AND_LOCK ()
1676: * will have incremented the lock count of the stream
1677: * head so it won't disappear underneath us.
1678: */
1679:
1680: * retvalp = SHEAD_SLEEP_LOCKED (sheadp, SH_OPENCLOSE,
1681: 0, CHECK_SIGNALS);
1682:
1683: if (retvalp != 0) {
1684: /*
1685: * If the lock attempt failed because of a
1686: * clone open changing the stream head's
1687: * device number, we need to try again.
1688: */
1689:
1690: sheadp = NULL;
1691:
1692: if (* retvalp == ENODEV)
1693: continue;
1694: }
1695:
1696: return sheadp;
1697: }
1698:
1699:
1700: /*
1701: * There ain't no such stream, so we have to allocate a queue
1702: * pair.
1703: */
1704:
1705: if ((q = QUEUE_ALLOC (2, sizeof (* sheadp))) == NULL) {
1706:
1707: * retvalp = ENFILE;
1708: return NULL;
1709: }
1710:
1711: sheadp = (shead_t *) q->q_ptr;
1712:
1713: SHEAD_INIT (sheadp, stabp, dev, q);
1714:
1715: sheadp->sh_ref_count = 1;
1716: sheadp->sh_lock_mask = SH_OPENCLOSE;
1717: sheadp->sh_time_count = sheadp->sh_lock_count = 1;
1718:
1719: if (SHEAD_ADD (sheadp) == 0)
1720: return sheadp;
1721:
1722: /*
1723: * The new queue could not be added to the stream
1724: * directory, presumably because of a nearly
1725: * simultaneous open attempt.
1726: *
1727: * We undo the allocation we wrought before retrying.
1728: */
1729:
1730: SHEAD_DESTROY (sheadp);
1731: QUEUE_FREE (q, 2, sizeof (* sheadp));
1732: }
1733: }
1734:
1735:
1736: /*
1737: * Unlock a stream head.
1738: */
1739:
1740: #if __USE_PROTO__
1741: void (SHEAD_SLEEP_UNLOCK) (shead_t * sheadp, cat_t category)
1742: #else
1743: void
1744: SHEAD_SLEEP_UNLOCK __ARGS ((sheadp, category))
1745: shead_t * sheadp;
1746: cat_t category;
1747: #endif
1748: {
1749: ASSERT (sheadp != NULL);
1750: ASSERT (category != 0);
1751:
1752: /*
1753: * See if locking is necessary for the read and write operations.
1754: */
1755:
1756: if ((sheadp->sh_flags & SH_RWLOCKING) == 0 &&
1757: (category & ~ (SH_READ_LOCK | SH_WRITE_LOCK)) == 0) {
1758: /*
1759: * Since we don't actually acquire any locks, we return early.
1760: */
1761:
1762: ASSERT (sheadp->sh_open_count > 0);
1763: return;
1764: }
1765:
1766: ASSERT (sheadp->sh_lock_count > 0);
1767: ASSERT ((sheadp->sh_lock_mask & category) == category);
1768:
1769:
1770: /*
1771: * We direct all locking operations on the slave part of a stream pipe
1772: * to the master end.
1773: */
1774:
1775: sheadp = SHEAD_MASTER (sheadp);
1776:
1777: (void) SHEAD_LOCK (sheadp);
1778:
1779:
1780: /*
1781: * Unlike SHEAD_WAKE (), we can assume that our category mask will not
1782: * be NULL because of the difference in interpretation between lock
1783: * flags (indicating a holder) and wait flags (indicating a waiter).
1784: */
1785:
1786: sheadp->sh_lock_mask &= ~ category;
1787: SV_BROADCAST (sheadp->sh_wait_sv, 0);
1788:
1789:
1790: /*
1791: * We don't use SHEAD_END_TIMEOUT () here since we are a lock holder
1792: * and shead_time_func () makes sure to keep our "sh_time_count" entry
1793: * greater than 0.
1794: */
1795:
1796: ASSERT (sheadp->sh_time_count > 0);
1797: sheadp->sh_time_count --;
1798:
1799: if (sheadp->sh_time_count == 0 && sheadp->sh_timeout_id != 0) {
1800: /*
1801: * Since there is no-one waiting for anything, cancel any
1802: * pending timeouts.
1803: */
1804:
1805: untimeout (sheadp->sh_timeout_id);
1806:
1807: sheadp->sh_lock_mask &= SH_TIMEFLAG;
1808: sheadp->sh_timeout_id = 0;
1809: }
1810:
1811:
1812: /*
1813: * Now that we have done everything that requires access to the stream
1814: * head, decrement the lock count.
1815: */
1816:
1817: SHEAD_UNREFERENCE (sheadp);
1818: }
1819:
1820:
1821: /*
1822: * This local function asserts that the caller holds a lock on the stream head.
1823: * Since we can't really determine that, we actually just assert that someone
1824: * has a lock on the stream head.
1825: */
1826:
1827: #if __USE_PROTO__
1828: __LOCAL__ void (ASSERT_SLEEP_LOCKED) (shead_t * sheadp, cat_t category)
1829: #else
1830: __LOCAL__ void
1831: ASSERT_SLEEP_LOCKED __ARGS ((sheadp, category))
1832: shead_t * sheadp;
1833: cat_t category;
1834: #endif
1835: {
1836: ASSERT (sheadp != NULL);
1837:
1838: if (SHEAD_IS_PIPE (sheadp))
1839: sheadp = SHEAD_MASTER (sheadp);
1840:
1841: ASSERT ((sheadp->sh_lock_mask & category) == category);
1842: }
1843:
1844:
1845: /*
1846: * Wait for a queue to drain. The caller must have the stream head locked when
1847: * calling this function.
1848: */
1849:
1850: #if __USE_PROTO__
1851: __LOCAL__ void (DRAIN_QUEUE) (shead_t * sheadp, queue_t * q)
1852: #else
1853: __LOCAL__ void
1854: DRAIN_QUEUE __ARGS ((sheadp, q))
1855: shead_t * sheadp;
1856: queue_t * q;
1857: #endif
1858: {
1859: __clock_t end_time;
1860:
1861: ASSERT_SLEEP_LOCKED (sheadp, SH_OPENCLOSE);
1862:
1863: /*
1864: * When we are in final close, the STREAMS specification says we
1865: * should wait for up to 15 seconds for the write-side queue to be
1866: * drained of data, unless we are in O_NONBLOCK mode.
1867: *
1868: * If we can't post the timeout, then don't wait.
1869: */
1870:
1871: if (sheadp->sh_cltime == 0)
1872: return;
1873:
1874: (void) drv_getparm (LBOLT, & end_time);
1875: end_time += sheadp->sh_cltime;
1876:
1877: for (;;) {
1878: /*
1879: * We need to acquire a basic lock to pass to SV_WAIT (), and
1880: * the code that wakes us up will attempt to acquire the same
1881: * lock (see QUEUE_DRAINED ()). Since the wakeup code must
1882: * acquire the lock while holding the stream frozen, we must
1883: * do things in the same order to prevent the possibility of
1884: * deadlock.
1885: */
1886:
1887: (void) QFREEZE_TRACE (q, "DRAIN_QUEUE");
1888:
1889: if (q->q_first == NULL) {
1890: /*
1891: * No messages on the queue => our job is done.
1892: */
1893:
1894: QUNFREEZE_TRACE (q, plbase);
1895: break;
1896: }
1897:
1898:
1899: /*
1900: * We are going to wait for this queue to become empty, so we
1901: * set a flag to indicate that we are interested in finding
1902: * out when that happens. Note that we don't ever clear the
1903: * flag in this routine; that is the responsibility of the
1904: * code which will wake us up.
1905: */
1906:
1907: q->q_flag |= QDRAIN;
1908:
1909:
1910: /*
1911: * We don't build on SHEAD_WAIT (), although we do expect to
1912: * be woken up via SHEAD_WAKE (). We transfer our lock from
1913: * the queue to the stream head.
1914: */
1915:
1916: (void) SHEAD_LOCK (sheadp);
1917:
1918: QUNFREEZE_TRACE (q, plstr);
1919:
1920:
1921: /*
1922: * Register when we want to time out. If that time has already
1923: * passed, then exit to the caller.
1924: */
1925:
1926: if (SHEAD_LOCKED_TIMEOUT (sheadp, end_time) == 0) {
1927:
1928: SHEAD_UNLOCK (sheadp, plbase);
1929: return;
1930: }
1931:
1932: sheadp->sh_lock_mask |= SH_DRAIN_WAIT;
1933:
1934: SV_WAIT (sheadp->sh_wait_sv, primed, sheadp->sh_basic_lockp);
1935:
1936: /*
1937: * We were signalled, so we try again.
1938: */
1939: }
1940: }
1941:
1942:
1943: /*
1944: * This function (used in the implementation of I_LIST ioctl ()) returns a
1945: * count of the number of modules on the stream, including the topmost driver.
1946: */
1947:
1948: #if __USE_PROTO__
1949: __LOCAL__ int (SHEAD_MODCOUNT) (shead_t * sheadp)
1950: #else
1951: __LOCAL__ int
1952: SHEAD_MODCOUNT __ARGS ((sheadp))
1953: shead_t * sheadp;
1954: #endif
1955: {
1956: pl_t prev_pl;
1957: int count;
1958: queue_t * scan;
1959:
1960: ASSERT (sheadp != NULL);
1961:
1962: /*
1963: * Note that we use SHEAD_MASTER () because this walk can be affected
1964: * by attempts to push or pop queues from either end of a stream pipe.
1965: * Using a single lock at the master end avoids problems with this.
1966: */
1967:
1968: prev_pl = SHEAD_LOCK (SHEAD_MASTER (sheadp));
1969:
1970: count = 0;
1971:
1972: for (scan = W (sheadp->sh_head)->q_next ; scan != NULL ;
1973: scan = scan->q_next) {
1974:
1975: if ((scan->q_flag & QPROCSOFF) == 0)
1976: count ++;
1977: }
1978:
1979: SHEAD_UNLOCK (SHEAD_MASTER (sheadp), prev_pl);
1980:
1981: return count;
1982: }
1983:
1984:
1985: /*
1986: * Utility routine to return the next write queue below the stream head. This
1987: * routine deals with locking the stream head for the duration of the walk and
1988: * also check whether the queue has been disabled with qprocsoff ().
1989: */
1990:
1991: #if __USE_PROTO__
1992: __LOCAL__ queue_t * (TOP_QUEUE) (shead_t * sheadp)
1993: #else
1994: __LOCAL__ queue_t *
1995: TOP_QUEUE __ARGS ((sheadp))
1996: shead_t * sheadp;
1997: #endif
1998: {
1999: pl_t prev_pl;
2000: queue_t * scan;
2001:
2002: ASSERT (sheadp != NULL);
2003:
2004: /*
2005: * Note that we use SHEAD_MASTER () because this walk can be affected
2006: * by attempts to push or pop queues from either end of a stream pipe.
2007: * Using a single lock at the master end avoids problems with this.
2008: */
2009:
2010: prev_pl = SHEAD_LOCK (SHEAD_MASTER (sheadp));
2011:
2012: scan = W (sheadp->sh_head)->q_next;
2013:
2014: while ((scan->q_flag & QPROCSOFF) != 0)
2015: if ((scan = scan->q_next) == NULL)
2016: cmn_err (CE_PANIC, "Off end of stream in TOP_QUEUE ()");
2017:
2018: SHEAD_UNLOCK (SHEAD_MASTER (sheadp), prev_pl);
2019:
2020: return scan;
2021: }
2022:
2023:
2024: /*
2025: * Utility routine for POP_MODULE () and the I_LOOK processing code that finds
2026: * the queue entry for the first module on the stream (if any).
2027: */
2028:
2029: #if __USE_PROTO__
2030: __LOCAL__ queue_t * (TOP_MODULE) (shead_t * sheadp)
2031: #else
2032: __LOCAL__ queue_t *
2033: TOP_MODULE __ARGS ((sheadp))
2034: shead_t * sheadp;
2035: #endif
2036: {
2037: queue_t * scan; /* module queue */
2038:
2039: /*
2040: * We return the queue pointer if and only if the thing below the
2041: * stream head is a module (not a driver) AND the module's read and
2042: * write queues are not interchanged (as they would be at the
2043: * crossover point of a STREAMS-based FIFO).
2044: */
2045:
2046: scan = TOP_QUEUE (sheadp);
2047:
2048: if ((scan->q_flag & QREADR) !=
2049: (W (sheadp->sh_head)->q_flag & QREADR))
2050: return NULL;
2051:
2052: /*
2053: * The test to see whether "scan" is a module or driver does not need
2054: * to involve QUEUE_NEXT (), since the exact value of 'q->q_next'
2055: * isn't important to us, just whether or not it's NULL.
2056: */
2057:
2058: {
2059: pl_t prev_pl;
2060: queue_t * next;
2061:
2062: prev_pl = QFREEZE_TRACE (scan, "TOP_MODULE");
2063:
2064: next = scan->q_next;
2065:
2066: QUNFREEZE_TRACE (scan, prev_pl);
2067:
2068: if (next == NULL)
2069: return NULL;
2070: }
2071:
2072: return R (scan);
2073: }
2074:
2075:
2076: /*
2077: * Code common to both POP_MODULE () and PUSH_MODULE () for removing and
2078: * deallocating a queue pair from a stream.
2079: */
2080:
2081: #if __USE_PROTO__
2082: __LOCAL__ void (POP_AND_FREE) (shead_t * sheadp, queue_t * module)
2083: #else
2084: __LOCAL__ void
2085: POP_AND_FREE __ARGS ((sheadp, module))
2086: shead_t * sheadp;
2087: queue_t * module;
2088: #endif
2089: {
2090: pl_t prev_pl;
2091: pl_t q_pl;
2092: queue_t * next;
2093:
2094:
2095: /*
2096: * Now we must unlink the module queue from the stream. To do this, we
2097: * freeze each queue before we change it. However, that is not enough
2098: * if we are on a stream pipe, since the stream head at the other end
2099: * of the pipe could be trying to modify the same stream, and thus the
2100: * same queue pointers that we are going to change.
2101: *
2102: * We work our way around this by defining a master/slave relationship
2103: * between the ends of a pipe, and requiring that the slave end
2104: * acquire an exclusive lock on the "sh_rwlockp" lock belonging to the
2105: * master. Since the master and slave contend for the same lock, we
2106: * can be confident no other concurrent modifications to the stream
2107: * are possible.
2108: */
2109:
2110: prev_pl = SHEAD_LOCK (SHEAD_MASTER (sheadp));
2111:
2112: next = W (sheadp->sh_head);
2113:
2114: ASSERT (next->q_next == W (module));
2115:
2116: q_pl = QFREEZE_TRACE (next, "POP_AND_FREE");
2117: next->q_next = W (module)->q_next;
2118: QUNFREEZE_TRACE (next, q_pl);
2119:
2120:
2121: next = OTHERQ (next->q_next);
2122:
2123: ASSERT (next->q_next == module);
2124:
2125: q_pl = QFREEZE_TRACE (next, "POP_AND_FREE");
2126: next->q_next = sheadp->sh_head;
2127: QUNFREEZE_TRACE (next, q_pl);
2128:
2129:
2130: SHEAD_UNLOCK (SHEAD_MASTER (sheadp), prev_pl);
2131:
2132:
2133: /*
2134: * Now we can de-initialize the queue pair and free the memory.
2135: */
2136:
2137: QUEUE_FREE (module, 1, 0);
2138: }
2139:
2140:
2141: /*
2142: * Pop a module from a stream. In order to request this, the caller must have
2143: * the stream head sleep-locked for modification (see SHEAD_SLEEP_LOCK ()
2144: * above).
2145: *
2146: * Returns 0 on success or an error number on failure.
2147: */
2148:
2149: #if __USE_PROTO__
2150: int (POP_MODULE) (shead_t * sheadp, queue_t * q, int mode, cred_t * credp)
2151: #else
2152: int
2153: POP_MODULE __ARGS ((sheadp, q, mode, credp))
2154: shead_t * sheadp;
2155: queue_t * q;
2156: int mode;
2157: cred_t * credp;
2158: #endif
2159: {
2160: int retval;
2161:
2162: ASSERT (q != NULL);
2163: ASSERT_SLEEP_LOCKED (sheadp, SH_OPENCLOSE);
2164:
2165: /*
2166: * When a module is popped, it is blown away. If the module needs to
2167: * be drained first (as in final close) then the caller has to do it.
2168: */
2169:
2170: retval = (* q->q_qinfo->qi_qclose) (q, mode, credp);
2171:
2172: if (retval != 0)
2173: cmn_err (CE_WARN, "module close returned %d in POP_MODULE",
2174: retval);
2175:
2176: /*
2177: * In case the module didn't turn off put and service routines.
2178: */
2179:
2180: if ((q->q_flag & QPROCSOFF) == 0) {
2181:
2182: cmn_err (CE_WARN, "Module %s did not call qprocsoff ()",
2183: q->q_qinfo->qi_minfo->mi_idname);
2184: qprocsoff (q);
2185: }
2186:
2187:
2188: /*
2189: * And now we can release the module. We do this whether or not the
2190: * caller returned an error.
2191: */
2192:
2193: POP_AND_FREE (sheadp, q);
2194:
2195: return retval;
2196: }
2197:
2198:
2199: /*
2200: * This function pushes the indicated module onto a stream. The caller must
2201: * have the stream head sleep-locked for modification.
2202: */
2203:
2204: #if __USE_PROTO__
2205: int (PUSH_MODULE) (shead_t * sheadp, int mode, cred_t * credp,
2206: modsw_t * module)
2207: #else
2208: int
2209: PUSH_MODULE __ARGS ((sheadp, mode, credp, module))
2210: shead_t * sheadp;
2211: int mode;
2212: cred_t * credp;
2213: modsw_t * module;
2214: #endif
2215: {
2216: queue_t * q;
2217: queue_t * prev;
2218: pl_t prev_pl;
2219: pl_t q_pl;
2220: int retval;
2221: n_dev_t dev;
2222: char * modname;
2223:
2224: ASSERT (module != NULL);
2225: ASSERT_SLEEP_LOCKED (sheadp, SH_OPENCLOSE);
2226:
2227: if ((q = QUEUE_ALLOC (1, 0)) == NULL)
2228: return ENOSR;
2229:
2230: QUEUE_INIT (q, module->mod_stream, QI_NORMAL);
2231:
2232: /*
2233: * First we have to link the module into the stream. The newly
2234: * allocated queues will have the QPROCSOFF flag set so that they are
2235: * ignored by other stream elements until the new module has been
2236: * opened.
2237: *
2238: * As above in POP_MODULE (), we acquire a write lock on the stream
2239: * head, which must be a master end if a stream pipe.
2240: */
2241:
2242: prev_pl = SHEAD_LOCK (SHEAD_MASTER (sheadp));
2243:
2244: prev = W (sheadp->sh_head);
2245: W (q)->q_next = prev->q_next;
2246:
2247: q_pl = QFREEZE_TRACE (prev, "PUSH_MODULE");
2248: prev->q_next = W (q);
2249: QUNFREEZE_TRACE (prev, q_pl);
2250:
2251: prev = OTHERQ (W (q)->q_next);
2252: q->q_next = sheadp->sh_head;
2253:
2254: ASSERT (prev->q_next == sheadp->sh_head);
2255:
2256: q_pl = QFREEZE_TRACE (prev, "PUSH_MODULE");
2257: prev->q_next = q;
2258: QUNFREEZE_TRACE (prev, q_pl);
2259:
2260: SHEAD_UNLOCK (SHEAD_MASTER (sheadp), prev_pl);
2261:
2262:
2263: /*
2264: * Ask the module to set itself up.
2265: */
2266:
2267: dev = sheadp->sh_dev;
2268:
2269: retval = (* q->q_qinfo->qi_qopen) (q, & dev, mode, MODOPEN,
2270: credp);
2271:
2272: modname = q->q_qinfo->qi_minfo->mi_idname;
2273:
2274: if (dev != sheadp->sh_dev)
2275: cmn_err (CE_WARN, "Module \"%s\" altered its \"dev\" parameter",
2276: modname);
2277:
2278: if (retval != 0) {
2279: /*
2280: * OK, don't really open this. The module should not have
2281: * turned on it's put and service routines.
2282: */
2283:
2284: if ((q->q_flag & QPROCSOFF) == 0) {
2285:
2286: cmn_err (CE_WARN, "PUSH_MODULE () : Module %s enabled queue!",
2287: modname);
2288: qprocson (q);
2289: }
2290:
2291: POP_AND_FREE (sheadp, q);
2292: } else if ((q->q_flag & QPROCSOFF) != 0) {
2293:
2294: cmn_err (CE_WARN, "PUSH_MODULE () : Module %s did not enable queue!",
2295: modname);
2296: qprocson (q);
2297: }
2298:
2299: return retval;
2300: }
2301:
2302:
2303: /*
2304: * This function sends an IOCTL message downstream, then blocks until either
2305: * a reply arrives at the stream head, the (optional) timeout has expired, or
2306: * a signal is received.
2307: *
2308: * The caller must have the stream head locked for ioctl () processing.
2309: */
2310:
2311: #if __USE_PROTO__
2312: mblk_t * (IOCTL_SEND) (shead_t * sheadp, int mode, mblk_t * msg,
2313: int * errretp, __clock_t timeout_time)
2314: #else
2315: mblk_t *
2316: IOCTL_SEND __ARGS ((sheadp, mode, msg, errretp, timeout_time))
2317: shead_t * sheadp;
2318: int mode;
2319: mblk_t * msg;
2320: int * errretp;
2321: __clock_t timeout_time;
2322: #endif
2323: {
2324: __clock_t end_time;
2325: int retval;
2326:
2327: ASSERT_SLEEP_LOCKED (sheadp, SH_IOCTL_LOCK);
2328: ASSERT (errretp != NULL);
2329: ASSERT (msg != NULL);
2330:
2331: /*
2332: * Set the optional timeout up first. If the timeout cannot be
2333: * allocated, we have to return failure.
2334: */
2335:
2336: if (timeout_time > 0) {
2337:
2338: (void) drv_getparm (LBOLT, & end_time);
2339: end_time += timeout_time;
2340: }
2341:
2342:
2343: /*
2344: * Now send the client's message downstream. We queue the message on
2345: * the write queue rather than directly putting it to avoid the
2346: * possibility of deadlock if an acknowledgement is sent back to us
2347: * while we are holding the basic lock below.
2348: *
2349: * We also have to check for the possibility that an error has occurred
2350: * on the stream.
2351: */
2352:
2353: (void) SHEAD_LOCK (sheadp);
2354:
2355: for (;;) {
2356: if (sheadp->sh_ioc_msg != NULL) {
2357: /*
2358: * If there is some stale ioctl () message lying
2359: * around, dispose of it.
2360: */
2361:
2362: freemsg (sheadp->sh_ioc_msg);
2363: sheadp->sh_ioc_msg = NULL;
2364: }
2365:
2366: if (msg != NULL)
2367: putq (W (sheadp->sh_head), msg);
2368:
2369: msg = NULL;
2370:
2371:
2372: /*
2373: * Before we go to sleep, we schedule our timeout.
2374: */
2375:
2376: if (timeout_time > 0 &&
2377: SHEAD_LOCKED_TIMEOUT (sheadp, end_time) == 0) {
2378: /*
2379: * We have timed out.
2380: */
2381:
2382: retval = ETIME;
2383: break;
2384: }
2385:
2386:
2387: if (sheadp->sh_open_count == 0) {
2388: /*
2389: * This is a kernel-generated ioctl () and signalling
2390: * is not allowed to interrupt us. We pass a NULL mode
2391: * to avoid detecting errors.
2392: */
2393:
2394: ASSERT_SLEEP_LOCKED (sheadp, SH_OPENCLOSE);
2395:
2396: retval = SHEAD_WAIT (sheadp, 0, SH_IOCTL_WAIT,
2397: DONT_SIGNAL);
2398: } else {
2399: /*
2400: * SHEAD_WAIT () checks for hangups as well, if the
2401: * mode includes read or write.
2402: */
2403:
2404: ASSERT ((mode & (FREAD | FWRITE)) != 0);
2405:
2406: retval = SHEAD_WAIT (sheadp, mode, SH_IOCTL_WAIT,
2407: CHECK_SIGNALS);
2408: }
2409:
2410:
2411: /*
2412: * We take out the basic lock here again so we can read
2413: * "sheadp->sh_ioc_msg" atomically.
2414: */
2415:
2416: (void) SHEAD_LOCK (sheadp);
2417:
2418: msg = sheadp->sh_ioc_msg;
2419: sheadp->sh_ioc_msg = NULL;
2420:
2421: if (retval != 0 || msg != NULL)
2422: break;
2423:
2424: /*
2425: * We have been woken up either by a timeout, or for some
2426: * activity at the stream head not related to us. We loop to
2427: * deal with this.
2428: */
2429: }
2430:
2431: if (retval != 0) {
2432:
2433: if (errretp != NULL)
2434: * errretp = retval;
2435:
2436: if (msg != NULL)
2437: freemsg (msg);
2438:
2439: msg = NULL;
2440: }
2441:
2442: SHEAD_UNLOCK (sheadp, plbase);
2443:
2444: return msg;
2445: }
2446:
2447:
2448: /*
2449: * This function manages transparent ioctl () processing; it sets itself up
2450: * to service M_COPYIN and M_COPYOUT requests from a driver until it sees an
2451: * M_IOCACK or M_IOCNAK.
2452: */
2453:
2454: typedef union {
2455: struct iocblk ioc;
2456: struct copyreq req;
2457: struct copyresp resp;
2458: } x_ioc_t;
2459:
2460: #if __USE_PROTO__
2461: __LOCAL__ int (TRANSPARENT_IOCTL) (shead_t * sheadp, int mode, int cmd,
2462: _VOID * arg, cred_t * credp, int * rvalp)
2463: #else
2464: __LOCAL__ int
2465: TRANSPARENT_IOCTL __ARGS ((sheadp, mode, cmd, arg, credp, rvalp))
2466: shead_t * sheadp;
2467: int mode;
2468: int cmd;
2469: _VOID * arg;
2470: cred_t * credp;
2471: int * rvalp;
2472: #endif
2473: {
2474: mblk_t * msg;
2475: mblk_t * data;
2476: int retval;
2477: x_ioc_t * ioc;
2478:
2479: ASSERT_SLEEP_LOCKED (sheadp, SH_IOCTL_LOCK);
2480:
2481: /*
2482: * The message block allocated for a transparent ioctl () must be
2483: * large enough to hold any of the ioctl-related message types so that
2484: * modules and drivers (and the stream head) can just change the
2485: * message type to reply to a message.
2486: */
2487:
2488: if ((msg = MSGB_ALLOC (sizeof (* ioc), BPRI_LO, KM_SLEEP)) == NULL)
2489: return ENOSR;
2490:
2491: ioc = (x_ioc_t *) msg->b_rptr;
2492: msg->b_wptr = (unsigned char *) (ioc + 1);
2493:
2494: msg->b_datap->db_type = M_IOCTL;
2495:
2496: ioc->ioc.ioc_cmd = cmd;
2497: ioc->ioc.ioc_cr = credp;
2498: ioc->ioc.ioc_id = ++ sheadp->sh_ioc_seq;
2499: ioc->ioc.ioc_count = TRANSPARENT;
2500: ioc->ioc.ioc_rval = ioc->ioc.ioc_error = 0;
2501:
2502:
2503: /*
2504: * A transparent ioctl () gets a single data block containing the
2505: * value of "arg".
2506: */
2507:
2508: if ((data = MSGB_ALLOC (sizeof (arg), BPRI_LO, KM_SLEEP)) == NULL) {
2509:
2510: retval = ENOSR;
2511: goto done;
2512: }
2513:
2514: * (_VOID **) data->b_rptr = arg;
2515: data->b_wptr += sizeof (arg);
2516:
2517:
2518: for (;;) {
2519: /*
2520: * Now we send the ioctl () and wait for the acknowledgement.
2521: * Transparent ioctl ()'s wait forever, but M_ERROR and
2522: * hangup events are interesting to us, so we can blow out.
2523: */
2524:
2525: if ((msg = IOCTL_SEND (sheadp, mode, msg, & retval,
2526: 0)) == NULL)
2527: return retval;
2528:
2529:
2530: /*
2531: * Transparent ioctl ()'s dont have to worry about data coming
2532: * back in the M_IOCACK message, they just have to process the
2533: * M_COPYIN and M_COPYOUT requests.
2534: */
2535:
2536: switch (msg->b_datap->db_type) {
2537:
2538: case M_IOCNAK:
2539: retval = ioc->ioc.ioc_error;
2540: goto done;
2541:
2542: case M_IOCACK:
2543: * rvalp = ioc->ioc.ioc_rval;
2544: retval = ioc->ioc.ioc_error;
2545:
2546: if (ioc->ioc.ioc_count > 0)
2547: cmn_err (CE_WARN, "Transparent ioctl () processing forbids data in M_IOCACK");
2548: goto done;
2549:
2550: case M_COPYIN:
2551: if ((data = msg->b_cont) != NULL)
2552: freemsg (data);
2553:
2554: /*
2555: * The STREAMS documentation is unclear as to whether
2556: * these blocks are split up or not, but it seems
2557: * unlikely.
2558: */
2559:
2560: if ((data = MSGB_ALLOC (ioc->req.cq_size, BPRI_LO,
2561: KM_SLEEP)) == NULL)
2562: retval = ENOSR;
2563: else if (copyin (ioc->req.cq_addr, data->b_rptr,
2564: ioc->req.cq_size) != 0) {
2565: freemsg (data);
2566: data = NULL;
2567: retval = EFAULT;
2568: } else {
2569:
2570: data->b_wptr = data->b_rptr +
2571: ioc->req.cq_size;
2572: retval = 0;
2573: }
2574:
2575: msg->b_cont = data;
2576: break;
2577:
2578: case M_COPYOUT:
2579: retval = 0;
2580:
2581: while (ioc->req.cq_size > 0 &&
2582: (data = msg->b_cont) != NULL) {
2583: size_t unit;
2584:
2585: /*
2586: * Copy a single M_DATA block at a time. After
2587: * copying, we free the block.
2588: */
2589:
2590: unit = data->b_wptr - data->b_rptr;
2591: if (unit > ioc->req.cq_size)
2592: unit = ioc->req.cq_size;
2593:
2594: if (copyout (data->b_rptr, ioc->req.cq_addr,
2595: unit) != 0) {
2596: retval = EFAULT;
2597: break;
2598: }
2599:
2600: ioc->req.cq_size -= unit;
2601: ioc->req.cq_addr += unit;
2602:
2603: msg->b_cont = data->b_cont;
2604: freeb (data);
2605: }
2606:
2607: /*
2608: * Throw away uncopied extra data.
2609: */
2610:
2611: if ((data = msg->b_cont) != NULL)
2612: freemsg (data);
2613:
2614: msg->b_cont = NULL;
2615: break;
2616:
2617: default:
2618: cmn_err (CE_WARN, "Invalid message type %d received during unlink processing",
2619: msg->b_datap->db_type);
2620: retval = ENXIO;
2621: goto done;
2622: }
2623:
2624: /*
2625: * In common code for M_COPYIN and M_COPYOUT, we turn around
2626: * the request message. If the request succeeded, we wrap
2627: * around to the top of the loop to serve the next request;
2628: * it there has been an error, we just put the message and
2629: * bail out.
2630: */
2631:
2632: msg->b_datap->db_type = M_IOCDATA;
2633: ioc->resp.cp_rval = (caddr_t) retval;
2634:
2635: if (retval != 0) {
2636:
2637: putq (W (sheadp->sh_head), msg);
2638: break;
2639: }
2640: }
2641:
2642: done:
2643: freemsg (msg);
2644:
2645: return retval;
2646: }
2647:
2648:
2649: /*
2650: * This function contains code common to the ioctl () message processing for
2651: * stream link and unlink commands. These ioctl ()s send messages downstream
2652: * which are all of a single common form.
2653: */
2654:
2655: #if __USE_PROTO__
2656: __LOCAL__ int (LINK_MESSAGE) (shead_t * upper, int mode, shead_t * lower,
2657: int cmd, int muxid, cred_t * credp,
2658: int * retvalp)
2659: #else
2660: __LOCAL__ int
2661: LINK_MESSAGE __ARGS ((upper, mode, lower, cmd, muxid, credp, retvalp))
2662: shead_t * upper;
2663: int mode;
2664: shead_t * lower;
2665: int cmd;
2666: int muxid;
2667: cred_t * credp;
2668: int * retvalp;
2669: #endif
2670: {
2671: mblk_t * msg;
2672: struct iocblk * ioc;
2673: struct linkblk * linkblk;
2674: int ackflag;
2675: queue_t * q;
2676:
2677: ASSERT_SLEEP_LOCKED (upper, SH_OPENCLOSE | SH_IOCTL_LOCK);
2678: ASSERT_SLEEP_LOCKED (lower, SH_OPENCLOSE | SH_IOCTL_LOCK);
2679: ASSERT (credp != NULL);
2680:
2681: /*
2682: * Set ourselves up for a STREAMS ioctl (). Note that since we keep
2683: * transparent ioctl () processing separate from normal I_STR code, we
2684: * don't have to allocate an initial message block that can be turned
2685: * into a "copyreq" or "copyresp" structure.
2686: */
2687:
2688:
2689: if ((msg = MSGB_ALLOC (sizeof (* ioc), BPRI_LO, KM_SLEEP)) == NULL)
2690: return ENOSR;
2691:
2692: ioc = (struct iocblk *) msg->b_rptr;
2693: msg->b_wptr = (unsigned char *) (ioc + 1);
2694:
2695: msg->b_datap->db_type = M_IOCTL;
2696:
2697: ioc->ioc_cmd = cmd;
2698: ioc->ioc_cr = credp;
2699: ioc->ioc_id = ++ upper->sh_ioc_seq;
2700: ioc->ioc_count = sizeof (struct linkblk);
2701: ioc->ioc_rval = ioc->ioc_error = 0;
2702:
2703:
2704: /*
2705: * Now we allocate and fill in the data part of the I_...LINK message.
2706: */
2707:
2708: if ((msg->b_cont = MSGB_ALLOC (sizeof (struct linkblk), BPRI_LO,
2709: KM_SLEEP)) == NULL) {
2710: freeb (msg);
2711: return ENOSR;
2712: }
2713:
2714: linkblk = (struct linkblk *) msg->b_cont->b_rptr;
2715: msg->b_cont->b_wptr = (unsigned char *) (linkblk + 1);
2716:
2717:
2718: /*
2719: * Find the bottom-most write queue on the upper stream. To make this
2720: * walk of the queue safe with respect to I_PUSH and I_POP, we take
2721: * out a read lock on the stream head. See the PUSH_MODULE () and
2722: * POP_MODULE () routines for more details on this.
2723: *
2724: * We don't use QUEUE_NEXT () because the intermediate modules are of
2725: * no interest to us; we just want the driver at the bottom.
2726: */
2727:
2728: {
2729: queue_t * next;
2730:
2731: (void) SHEAD_LOCK (upper);
2732:
2733: next = W (upper->sh_head);
2734:
2735: do {
2736: q = next;
2737:
2738: (void) QFREEZE_TRACE (q, "LINK_MESSAGE");
2739:
2740: next = q->q_next;
2741:
2742: QUNFREEZE_TRACE (q, plbase);
2743: } while (next != NULL);
2744:
2745: SHEAD_UNLOCK (upper, plbase);
2746: }
2747:
2748: linkblk->l_qtop = q;
2749: linkblk->l_qbot = lower->sh_head;
2750: linkblk->l_index = muxid;
2751:
2752:
2753: /*
2754: * Now we send the ioctl () and wait for the acknowledgement. Since
2755: * there is no mechanism for managing this timeout, we will use the
2756: * close timeout (which is appropriate given that this operation will
2757: * often be performed as the result of a close ()).
2758: */
2759:
2760: if ((msg = IOCTL_SEND (upper, mode, msg, retvalp,
2761: upper->sh_cltime)) == NULL)
2762: return 0; /* counts as a negative ack */
2763:
2764: /*
2765: * Now we see what kind of message the driver has send to us.
2766: */
2767:
2768: ioc = (struct iocblk *) msg->b_rptr;
2769:
2770: if (retvalp != NULL)
2771: * retvalp = ioc->ioc_error;
2772:
2773: switch (msg->b_datap->db_type) {
2774:
2775: case M_IOCNAK:
2776: ackflag = 0;
2777: break;
2778:
2779: case M_IOCACK:
2780: /*
2781: * We do not copy the "ioc_rval" member out because it is not
2782: * documented as forming the return value from such a link-
2783: * style ioctl () request.
2784: */
2785:
2786: /*
2787: * Since "arg" for an I_UNLINK or I_PUNLINK is not a pointer,
2788: * it makes no sense for a driver to attempt to return data
2789: * for the user. Since the canonical multiplexing driver code
2790: * clears ioc_count and simply turns around the message, it
2791: * is not a problem for there to be M_DATA messages following
2792: * the M_IOCACK, but it is a problem if "ioc_count" is greater
2793: * than 0.
2794: */
2795:
2796: ackflag = 1;
2797:
2798: if (ioc->ioc_count > 0)
2799: cmn_err (CE_WARN, "Driver %s returned data with link/unlink ioctl ()",
2800: q->q_qinfo->qi_minfo->mi_idname);
2801:
2802: break;
2803:
2804: default:
2805: cmn_err (CE_WARN, "Invalid message type %d received during link/unlink processing",
2806: msg->b_datap->db_type);
2807: * retvalp = ENXIO;
2808:
2809: ackflag = 0; /* treat as a negative ack */
2810: break;
2811: }
2812:
2813: freemsg (msg);
2814:
2815: return ackflag;
2816: }
2817:
2818:
2819: /*
2820: * Helper function for the link/unlink process to restore a stream to the
2821: * unlinked state.
2822: */
2823:
2824: #if __USE_PROTO__
2825: __LOCAL__ int (SHEAD_INIT_UNLINKED) (shead_t * sheadp)
2826: #else
2827: __LOCAL__ int
2828: SHEAD_INIT_UNLINKED __ARGS ((sheadp))
2829: shead_t * sheadp;
2830: #endif
2831: {
2832: pl_t prev_pl;
2833: int final_close;
2834:
2835: ASSERT_SLEEP_LOCKED (sheadp, SH_OPENCLOSE | SH_IOCTL_LOCK);
2836:
2837: /*
2838: * The driver is no longer using this stream; restore it to normal
2839: * operation. Note that we have to reset "q_ptr" back to point at the
2840: * stream head!
2841: */
2842:
2843: prev_pl = SHEAD_LOCK (sheadp);
2844:
2845: sheadp->sh_linked = NULL;
2846: sheadp->sh_flags &= ~ SH_PLINK;
2847:
2848: final_close = -- sheadp->sh_open_count == 0;
2849:
2850: SHEAD_UNLOCK (sheadp, prev_pl);
2851:
2852:
2853: prev_pl = QFREEZE_TRACE (sheadp->sh_head, "SHEAD_INIT_UNLINKED");
2854:
2855: sheadp->sh_head->q_ptr = sheadp;
2856: W (sheadp->sh_head)->q_ptr = sheadp;
2857:
2858: QUEUE_INIT (sheadp->sh_head, sheadp->sh_tab, QI_NORMAL);
2859:
2860: QUNFREEZE_TRACE (sheadp->sh_head, prev_pl);
2861:
2862: return final_close;
2863: }
2864:
2865:
2866: /*
2867: * This function takes care of unlinking a lower stream from an upper stream.
2868: *
2869: * The caller should have both the upper and lower stream heads locked for
2870: * open/close processing.
2871: */
2872:
2873: #if __USE_PROTO__
2874: __LOCAL__ int (LOCKED_UNLINK) (shead_t * upper, int mode, shead_t * lower,
2875: int cmd, cred_t * credp, int * retvalp)
2876: #else
2877: __LOCAL__ int
2878: LOCKED_UNLINK __ARGS ((upper, mode, lower, cmd, credp, retvalp))
2879: shead_t * upper;
2880: int mode;
2881: shead_t * lower;
2882: int cmd;
2883: cred_t * credp;
2884: int * retvalp;
2885: #endif
2886: {
2887: ASSERT_SLEEP_LOCKED (upper, SH_OPENCLOSE | SH_IOCTL_LOCK);
2888: ASSERT_SLEEP_LOCKED (lower, SH_OPENCLOSE | SH_IOCTL_LOCK);
2889:
2890: /*
2891: * Check that the right kind of unlink command is being issued.
2892: */
2893:
2894: if (lower->sh_linked != upper ||
2895: ((lower->sh_flags & SH_PLINK) != 0) == (cmd == I_PUNLINK))
2896: return EINVAL;
2897:
2898: /*
2899: * Send the message downstream and get the return result.
2900: */
2901:
2902: if (LINK_MESSAGE (upper, mode, lower, cmd, lower->sh_muxid, credp,
2903: retvalp)) {
2904: /*
2905: * The unlink was properly acknowledged. Note that this may
2906: * cause the lower stream to close.
2907: */
2908:
2909: if (SHEAD_INIT_UNLINKED (lower) != 0)
2910: SHEAD_DO_CLOSE (lower, mode, credp);
2911:
2912: return 1;
2913: }
2914:
2915: return 0;
2916: }
2917:
2918:
2919: /*
2920: * This function wraps up part of the required client functionality for
2921: * callers of SHEAD_UNLINK () by dealing with locking the lower stream head
2922: * and making appropriate calls to see if it needs closing.
2923: */
2924:
2925: #if __USE_PROTO__
2926: __LOCAL__ int (SHEAD_UNLINK) (shead_t * upper, shead_t * lower, int cmd,
2927: int mode, cred_t * credp, int * retvalp)
2928: #else
2929: __LOCAL__ int
2930: SHEAD_UNLINK __ARGS ((upper, lower, cmd, mode, credp, retvalp))
2931: shead_t * upper;
2932: shead_t * lower;
2933: int cmd;
2934: int mode;
2935: cred_t * credp;
2936: int * retvalp;
2937: #endif
2938: {
2939: int success;
2940:
2941: /*
2942: * In order to unlink this lower stream we first have to lock it. This
2943: * is necessary not only to ensure that we don't trip up other
2944: * operations affecting this stream (since there may be open file
2945: * descriptors referring to it, and/or it may be a stream pipe) but
2946: * since stream deallocations are checked for in the unlock code this
2947: * is necessary to ensure that an unlink of an otherwise unreferenced
2948: * stream does the right thing.
2949: */
2950:
2951: if ((* retvalp = SHEAD_SLEEP_LOCK (lower,
2952: SH_OPENCLOSE | SH_IOCTL_LOCK, 0,
2953: DONT_SIGNAL)) != 0) {
2954:
2955: cmn_err (CE_WARN, "Unable to lock stream in SHEAD_UNLINK (), error %d",
2956: * retvalp);
2957: return 1;
2958: }
2959:
2960:
2961: /*
2962: * OK, we unlink this lower stream, and do all the stuff we
2963: * need to do to ensure that the lower stream gets closed if
2964: * its time has come.
2965: */
2966:
2967: success = LOCKED_UNLINK (upper, mode, lower, cmd, credp, retvalp);
2968:
2969: SHEAD_SLEEP_UNLOCK (lower, SH_OPENCLOSE | SH_IOCTL_LOCK);
2970:
2971: return success;
2972: }
2973:
2974:
2975: /*
2976: * Loop-detection algorithm for use in SHEAD_LINK ().
2977: *
2978: * The STREAMS documentation is very vague about what constitutes a cycle in
2979: * the link graph, probably deliberately.
2980: *
2981: * For our purposes we consider a cycle to be caused by any path of links
2982: * which lead upwards (to user level) from the *device* indicated by "upper"
2983: * to the *device* indicated by "lower".
2984: *
2985: * Frankly, given the nature of multiplexing drivers in terms of routing
2986: * information, I really don't see much advantage in this; it is perfectly
2987: * easy for messages cycles to form other ways, and given the typical nature
2988: * of multiplexor services interfaces a cycle in the hierarchy need not cause
2989: * a loop. Still, that's the way it's specified.
2990: *
2991: * THIS IS A RECURSIVE ALGORITHM FOR DEPTH-FIRST SEARCH. This fact does not
2992: * really worry me in the slightest, because the depth of the recursion here
2993: * is no worse than the possible recursive depth of the multiplexor put ()
2994: * calls themselves.
2995: */
2996:
2997: #if __USE_PROTO__
2998: __LOCAL__ int (DETECT_LOOP) (shead_t * upper, shead_t * lower)
2999: #else
3000: __LOCAL__ int
3001: DETECT_LOOP __ARGS ((upper, lower))
3002: shead_t * upper;
3003: shead_t * lower;
3004: #endif
3005: {
3006: shead_t * scan;
3007:
3008: /*
3009: * We base our comparisons on the "sh_tab" member of the stream head
3010: * structure, since that is equivalent to the major part of the
3011: * (internal) device number.
3012: */
3013:
3014: if (upper->sh_tab == lower->sh_tab)
3015: return 1;
3016:
3017: /*
3018: * Now recursively work upward through the multiplexing configuration
3019: * calling DETECT_LOOP () for all the linked streams with the "sh_tab"
3020: * entry of the stream which "upper" is linked to (if "upper" is in
3021: * fact linked below another multiplexor).
3022: *
3023: * Since only device streams can be multiplexors, we only scan the
3024: * device stream list.
3025: */
3026:
3027: if ((upper = upper->sh_linked) == NULL)
3028: return 0;
3029:
3030: for (scan = str_mem->sm_streams [DEV_SLIST] ; scan != NULL ;
3031: scan = scan->sh_next) {
3032:
3033: if (scan->sh_tab == upper->sh_tab &&
3034: DETECT_LOOP (scan, lower))
3035: return 1;
3036: }
3037:
3038: return 0;
3039: }
3040:
3041:
3042: /*
3043: * This function deals with linking one stream below another. There are
3044: * numerous conditions which might prevent this from happening, including a
3045: * refusal from the multiplexing driver.
3046: *
3047: * The upper stream must be locked for open/close operations. The lower stream
3048: * will also be locked by this routine.
3049: */
3050:
3051: #if __USE_PROTO__
3052: int (SHEAD_LINK) (shead_t * upper, int mode, shead_t * lower, int cmd,
3053: cred_t * credp)
3054: #else
3055: int
3056: SHEAD_LINK __ARGS ((upper, mode, lower, cmd, credp))
3057: shead_t * upper;
3058: int mode;
3059: shead_t * lower;
3060: int cmd;
3061: cred_t * credp;
3062: #endif
3063: {
3064: int retval;
3065: muxid_t muxid;
3066:
3067: ASSERT (lower != NULL);
3068:
3069: ASSERT_SLEEP_LOCKED (upper, SH_OPENCLOSE | SH_IOCTL_LOCK);
3070:
3071: if (SHEAD_IS_PIPE (upper) ||
3072: upper->sh_tab->st_muxrinit == NULL ||
3073: upper->sh_tab->st_muxwinit == NULL)
3074: return EINVAL;
3075:
3076: /*
3077: * Perform some of the non-recursive setup (mainly locking) for the
3078: * cycle-detection algorithm. We use the read/write lock on the stream
3079: * head since the detection algorithm walks over the global stream
3080: * list many times. Note that this single-threads checking operations,
3081: * which we would also have to do if were were pushing marker bits
3082: * around in a non-recursive implementation.
3083: */
3084:
3085: (void) RW_WRLOCK (str_mem->sm_head_lock, plstr);
3086:
3087: retval = DETECT_LOOP (upper, lower);
3088:
3089: RW_UNLOCK (str_mem->sm_head_lock, plbase);
3090:
3091: if (retval != 0)
3092: return EINVAL;
3093:
3094: /*
3095: * Generate a suitable multiplexor ID for the link. We use the device
3096: * number of the lower stream as a suitable seed point.
3097: */
3098:
3099: for (muxid = (muxid_t) lower->sh_dev ;
3100: SHEAD_FIND_MUXID (upper, cmd, muxid) != NULL ; muxid ++)
3101: ; /* DO NOTHING */
3102:
3103: /*
3104: * We set up the lower now, before we send the I_LINK, so that by the
3105: * time the driver sees the I_LINK the stream is ready for use. We
3106: * NULL out the "q_ptr" member of the lower queue so that messages
3107: * arriving early can be correctly handled.
3108: *
3109: * We take a sleep lock on the lower stream. If we can't lock it,
3110: * return EINVAL since whatever error caused the failure isn't really
3111: * relevant to the stream the caller is dealing with.
3112: */
3113:
3114: if ((retval = SHEAD_SLEEP_LOCK (lower, SH_OPENCLOSE | SH_IOCTL_LOCK,
3115: 0, DONT_SIGNAL)) != 0)
3116: return EINVAL;
3117:
3118: /*
3119: * Note that the "q_ptr" field of the queue gets zeroed to avoid
3120: * communicating our state to the driver. In addition, we have to
3121: * count the link as an extra open now.
3122: *
3123: * Paranoia time; we check for errors, hangups and whether the lower
3124: * stream is linked at this late stage so the cutover is atomic. This
3125: * requires some cooperation from the stream head read side service
3126: * routine; look to see that it tests for "sh_linked" in the service
3127: * routine somewhere...
3128: */
3129:
3130: (void) SHEAD_LOCK (lower);
3131:
3132: if (SHEAD_HANGUP (lower) || _shead_error (lower, FREAD | FWRITE)) {
3133:
3134: SHEAD_UNLOCK (lower, plbase);
3135: SHEAD_SLEEP_UNLOCK (lower, SH_OPENCLOSE | SH_IOCTL_LOCK);
3136: return EINVAL;
3137: }
3138:
3139: lower->sh_open_count ++; /* duplicate reference */
3140:
3141: lower->sh_linked = upper;
3142: lower->sh_muxid = muxid;
3143:
3144: if (cmd == I_PLINK)
3145: lower->sh_flags |= SH_PLINK;
3146:
3147: SHEAD_UNLOCK (lower, plbase);
3148:
3149:
3150: (void) QFREEZE_TRACE (lower->sh_head, "LINK_STREAMS");
3151:
3152: lower->sh_head->q_ptr = NULL;
3153: W (lower->sh_head)->q_ptr = NULL;
3154:
3155: QUEUE_INIT (lower->sh_head, lower->sh_tab, QI_MUX);
3156:
3157: QUNFREEZE_TRACE (lower->sh_head, plbase);
3158:
3159:
3160: /*
3161: * Send the message downstream and get the return result.
3162: */
3163:
3164: if (LINK_MESSAGE (upper, mode, lower, cmd, muxid, credp,
3165: & retval) == 0) {
3166: int final;
3167:
3168: /*
3169: * The driver failed the link; restore the lower stream. This
3170: * won't cause the stream to close (because of our open
3171: * reference) but we take care to ensure that the counts are
3172: * properly maintained.
3173: */
3174:
3175: final = SHEAD_INIT_UNLINKED (lower);
3176:
3177: if (final != 0)
3178: cmn_err (CE_WARN, "Final close in SHEAD_LINK () ????");
3179: }
3180:
3181:
3182: /*
3183: * Unlock the lower stream for proper symmetry.
3184: */
3185:
3186: SHEAD_SLEEP_UNLOCK (lower, SH_OPENCLOSE | SH_IOCTL_LOCK);
3187: return retval;
3188: }
3189:
3190:
3191: /*
3192: * This function deals with a special case in SHEAD_DO_CLOSE () below where
3193: * the last close of a stream pipe end causes the other end to be detached
3194: * from all the filesystem entries it has been mounted over.
3195: */
3196:
3197: #if __USE_PROTO__
3198: __LOCAL__ void (SHEAD_PIPE_DETACH) (shead_t * __NOTUSED (other))
3199: #else
3200: __LOCAL__ void
3201: SHEAD_PIPE_DETACH __ARGS ((other))
3202: shead_t * other;
3203: #endif
3204: {
3205: /*
3206: * Until we know how attachments are going to be performed and what
3207: * kind of structure exists, we cannot implement this function.
3208: */
3209:
3210: cmn_err (CE_PANIC, "UNIMPLEMENTED : SHEAD_PIPE_DETACH ()");
3211: }
3212:
3213:
3214: /*
3215: * This module factors out some code from SHEAD_DO_CLOSE (). The final
3216: * close processing for a stream head is complicated a little because when a
3217: * stream pipe end is closed that side of the pipe is not actually closed
3218: * until the other end also closes.
3219: */
3220:
3221: #if __USE_PROTO__
3222: __LOCAL__ void (SHEAD_FINAL_CLOSE) (shead_t * sheadp, int mode,
3223: cred_t * credp)
3224: #else
3225: __LOCAL__ void
3226: SHEAD_FINAL_CLOSE __ARGS ((sheadp, mode, credp))
3227: shead_t * sheadp;
3228: int mode;
3229: cred_t * credp;
3230: #endif
3231: {
3232: shead_t * scan;
3233: queue_t * q;
3234: int retval;
3235:
3236: /*
3237: * Final close of a stream; the close steps are to be performed in
3238: * this order, as given in the DDI/DDK entry for close(D2DK).
3239: * Non-persistent multiplexor links are unlinked.
3240: * For each module and driver from the head to the driver:
3241: * Wait for the write queue to drain.
3242: * Call close () routine.
3243: * Remove module/driver from stream.
3244: * Free remaining messages.
3245: * Deallocate queue pair.
3246: *
3247: * Here we can behave as if we have an ioctl () lock on the stream
3248: * because during final close no other process can legitimately hold
3249: * another lock on the stream head (no other legal references to the
3250: * stream exist).
3251: */
3252:
3253: while ((scan = SHEAD_FIND_MUXID (sheadp, I_UNLINK, -1)) != NULL) {
3254:
3255: if (SHEAD_UNLINK (sheadp, scan, I_UNLINK, mode, credp,
3256: & retval) == 0) {
3257: /*
3258: * There is no good reason for a driver to fail an
3259: * I_UNLINK request.
3260: */
3261:
3262: cmn_err (CE_WARN, "Driver failed unlink () during final close (%d)",
3263: retval);
3264: scan->sh_linked = NULL;
3265: }
3266: }
3267:
3268:
3269: /*
3270: * Before draining the write side modules, drain the stream head.
3271: */
3272:
3273: DRAIN_QUEUE (sheadp, W (sheadp->sh_head));
3274:
3275:
3276: /*
3277: * Now pop all the modules from the stream.
3278: */
3279:
3280: while ((q = TOP_MODULE (sheadp)) != NULL) {
3281:
3282: DRAIN_QUEUE (sheadp, W (q));
3283:
3284: (void) POP_MODULE (sheadp, q, mode, credp);
3285: }
3286:
3287:
3288: /*
3289: * Now close the driver, unless this is a pipe. Once this has been
3290: * done there is no reason for any context to reference this object
3291: * except to unlock it.
3292: */
3293:
3294: if (! SHEAD_IS_PIPE (sheadp)) {
3295: q = TOP_QUEUE (sheadp);
3296:
3297: DRAIN_QUEUE (sheadp, q);
3298:
3299: q = R (q);
3300:
3301: retval = (* q->q_qinfo->qi_qclose) (q, mode, credp);
3302:
3303: if (retval != 0)
3304: cmn_err (CE_WARN, "Driver close returned %d", retval);
3305:
3306: if ((q->q_flag & QPROCSOFF) == 0) {
3307:
3308: cmn_err (CE_WARN, "Driver %s did not call qprocsoff ()",
3309: q->q_qinfo->qi_minfo->mi_idname);
3310: qprocsoff (q);
3311: }
3312: }
3313: }
3314:
3315:
3316: /*
3317: * This function does most of the close processing for a stream head. It is
3318: * used by regular stream close, and by stream open code if certain
3319: * irregularities are detected.
3320: *
3321: * The caller must have the stream head locked for close operations. If the
3322: * stream head being operated on is a pipe, that means both ends must be
3323: * locked (so that the caller can sequence the lock order on the basis of the
3324: * master/slave bits).
3325: */
3326:
3327: #if __USE_PROTO__
3328: __LOCAL__ int (SHEAD_DO_CLOSE) (shead_t * sheadp, int mode, cred_t * credp)
3329: #else
3330: __LOCAL__ int
3331: SHEAD_DO_CLOSE __ARGS ((sheadp, mode, credp))
3332: shead_t * sheadp;
3333: int mode;
3334: cred_t * credp;
3335: #endif
3336: {
3337: ASSERT (credp != NULL);
3338: ASSERT_SLEEP_LOCKED (sheadp, SH_OPENCLOSE | SH_IOCTL_LOCK);
3339:
3340: /*
3341: * If other processes have references to this stream head, then we can
3342: * just return doing no more work. Note that we keep the notion of
3343: * number of open references, number of filesystem attachments, and
3344: * multiplexor links completely separate, but any one qualifies as
3345: * a reason for keeping the stream around.
3346: *
3347: * Therefore, it follows that any code which manipulates any of these
3348: * quantities such that the next expression might become false needs
3349: * to call this function to ensure that the stream memory will be
3350: * properly reclaimed.
3351: */
3352:
3353: ASSERT (sheadp->sh_open_count == 0);
3354:
3355: if (SHEAD_IS_PIPE (sheadp)) {
3356: shead_t * other = SHEAD_OTHER (sheadp);
3357:
3358: /*
3359: * If this is a pipe, there are some extra things we should
3360: * worry about. First, the first end of a stream pipe to close
3361: * should send an M_HANGUP message to the other end rather
3362: * than actually closing. The other end then gets to destroy
3363: * both sides of the pipe when it finally closes.
3364: *
3365: * The second exception is that when an unattached end of a
3366: * streams pipe is closed, the other end is automatically
3367: * detached.
3368: *
3369: * Note that if the other end of the pipe is linked below a
3370: * multiplexor, we do not attempt to automatically unlink it.
3371: * This might seem entirely reasonable, but we cannot attempt
3372: * this without introducing a possibility of deadlock.
3373: */
3374:
3375: if (other->sh_attach_count > 0)
3376: SHEAD_PIPE_DETACH (other);
3377:
3378: if (other->sh_open_count > 0) {
3379: /*
3380: * The last close/detach/unlink of the other end will
3381: * clean everything up.
3382: */
3383:
3384: putctl (W (other->sh_head), M_HANGUP);
3385: return 0;
3386: }
3387:
3388: /*
3389: * Now we clean up the "other" end.
3390: */
3391:
3392: SHEAD_FINAL_CLOSE (other, mode, credp);
3393: }
3394:
3395: SHEAD_FINAL_CLOSE (sheadp, mode, credp);
3396:
3397: /*
3398: * We leave the last part of the cleanup (dallocating the queue pair
3399: * and any remaining messages) to the unlock call which the caller
3400: * will perform.
3401: */
3402:
3403: return 0;
3404: }
3405:
3406:
3407: /*
3408: * This function builds and send an M_FLUSH message down the stream.
3409: */
3410:
3411: #if __USE_PROTO__
3412: __LOCAL__ int (SHEAD_FLUSH) (shead_t * sheadp, int flag, uchar_t band)
3413: #else
3414: __LOCAL__ int
3415: SHEAD_FLUSH __ARGS ((sheadp, flag, band))
3416: shead_t * sheadp;
3417: int flag;
3418: uchar_t band;
3419: #endif
3420: {
3421: mblk_t * msg;
3422:
3423: if ((flag & FLUSHRW) == 0 || (flag & ~ FLUSHRW) != 0)
3424: return EINVAL;
3425: else if ((msg = MSGB_ALLOC (2, BPRI_LO, KM_SLEEP)) == NULL)
3426: return ENOSR;
3427: else {
3428: /*
3429: * Send the message downstream...
3430: */
3431:
3432: if (band > 0)
3433: flag |= FLUSHBAND;
3434:
3435: msg->b_datap->db_type = M_FLUSH;
3436: * msg->b_wptr ++ = (unsigned char) flag;
3437:
3438: if (band > 0)
3439: * msg->b_wptr ++ = band;
3440:
3441: put (W (sheadp->sh_head), msg);
3442: }
3443:
3444: return 0;
3445: }
3446:
3447:
3448: /*
3449: * This function locates a module's streamtab entry given the name. Only the
3450: * first FMNAMESZ characters are considered significant.
3451: */
3452:
3453: #if __USE_PROTO__
3454: modsw_t * (FIND_MODULE) (__CONST__ char * modname)
3455: #else
3456: modsw_t *
3457: FIND_MODULE __ARGS ((modname))
3458: __CONST__ char * modname;
3459: #endif
3460: {
3461: modsw_t * scan;
3462: modsw_t * end;
3463:
3464: for (scan = modsw, end = scan + nmodsw ; scan != end ; scan ++) {
3465: __CONST__ char * name;
3466:
3467: name = scan->mod_stream->st_rdinit->qi_minfo->mi_idname;
3468:
3469: if (name != NULL && strncmp (modname, name, FMNAMESZ) == 0)
3470: return scan;
3471: }
3472:
3473: return NULL;
3474: }
3475:
3476:
3477: /*
3478: * This function holds code to process an I_STR ioctl ().
3479: */
3480:
3481: #if __USE_PROTO__
3482: __LOCAL__ int (ISTR_IOCTL) (shead_t * sheadp, int mode,
3483: struct strioctl * strioc, cred_t * credp,
3484: int * rvalp)
3485: #else
3486: __LOCAL__ int
3487: ISTR_IOCTL __ARGS ((sheadp, mode, strioc, credp, rvalp))
3488: shead_t * sheadp;
3489: int mode;
3490: struct strioctl
3491: * strioc;
3492: cred_t * credp;
3493: int * rvalp;
3494: #endif
3495: {
3496: __clock_t ticks;
3497: mblk_t * msg;
3498: mblk_t * data;
3499: struct iocblk * ioc;
3500: int retval;
3501:
3502: ASSERT_SLEEP_LOCKED (sheadp, SH_IOCTL_LOCK);
3503:
3504: /*
3505: * Set up timeout; "ic_timeout" == -1 means infinite
3506: * timeout, while "ic_timeout" == 0 means default
3507: * (which is infinite).
3508: */
3509:
3510: if (strioc->ic_timeout != -1 && strioc->ic_timeout != 0) {
3511: /*
3512: * We take care to deal with overflow here.
3513: */
3514:
3515: if ((ticks = strioc->ic_timeout) > (__clock_t) -1 / 1000000L)
3516: ticks = (__clock_t) -1;
3517:
3518: ticks = drv_usectohz (ticks * 1000000L);
3519: } else
3520: ticks = 0;
3521:
3522: if ((msg = MSGB_ALLOC (sizeof (* ioc), BPRI_LO, KM_SLEEP)) == NULL)
3523: return ENOSR;
3524:
3525: ioc = (struct iocblk *) msg->b_rptr;
3526: msg->b_wptr = (unsigned char *) (ioc + 1);
3527:
3528: msg->b_datap->db_type = M_IOCTL;
3529:
3530: ioc->ioc_cmd = strioc->ic_cmd;
3531: ioc->ioc_cr = credp;
3532: ioc->ioc_id = ++ sheadp->sh_ioc_seq;
3533: ioc->ioc_count = strioc->ic_len;
3534: ioc->ioc_rval = ioc->ioc_error = 0;
3535:
3536:
3537: /*
3538: * If there is data to be sent downstream, we allocate a buffer to
3539: * hold it and copy the data into that buffer.
3540: */
3541:
3542: if (ioc->ioc_count > 0) {
3543:
3544: if ((data = MSGB_ALLOC (strioc->ic_len, BPRI_LO,
3545: KM_SLEEP)) == NULL) {
3546:
3547: retval = ENOSR;
3548: goto done;
3549: }
3550:
3551: msg->b_cont = data;
3552: data->b_wptr += strioc->ic_len;
3553:
3554: if (copyin (strioc->ic_dp, data->b_rptr,
3555: strioc->ic_len) != 0) {
3556:
3557: retval = EFAULT;
3558: goto done;
3559: }
3560: }
3561:
3562: /*
3563: * Now we send the ioctl () and wait for the acknowledgement.
3564: */
3565:
3566: if ((msg = IOCTL_SEND (sheadp, mode, msg, & retval, ticks)) == NULL)
3567: return retval;
3568:
3569:
3570: /*
3571: * What do we do with the results? We copy at most "ioc_count" bytes
3572: * of data back into the user's address space if this is M_IOCACK.
3573: */
3574:
3575: ioc = (struct iocblk *) msg->b_rptr;
3576:
3577: switch (msg->b_datap->db_type) {
3578:
3579: case M_IOCNAK:
3580: retval = ioc->ioc_error;
3581: break;
3582:
3583: case M_IOCACK:
3584: * rvalp = ioc->ioc_rval;
3585: retval = ioc->ioc_error;
3586:
3587: data = msg->b_cont;
3588:
3589: while (ioc->ioc_count > 0) {
3590: size_t len;
3591:
3592: if (data == NULL) {
3593:
3594: cmn_err (CE_WARN, "ISTR_IOCTL : Insufficient M_DATA blocks for ioc_count");
3595: break;
3596: }
3597:
3598: len = data->b_wptr - data->b_rptr;
3599:
3600: if (len > ioc->ioc_count)
3601: len = ioc->ioc_count;
3602:
3603: if (len > 0 &&
3604: copyout (data->b_rptr, strioc->ic_dp,
3605: len) != 0) {
3606:
3607: retval = EFAULT;
3608: goto done;
3609: }
3610:
3611: ioc->ioc_count -= len;
3612: data = data->b_cont;
3613: strioc->ic_dp += len;
3614: }
3615: break;
3616:
3617: default:
3618: cmn_err (CE_WARN, "Invalid message type %d received during unlink processing",
3619: msg->b_datap->db_type);
3620: retval = ENXIO;
3621: break;
3622: }
3623:
3624: done:
3625: freemsg (msg);
3626:
3627: return retval;
3628: }
3629:
3630:
3631: /*
3632: * Here are the details of the implementation of sigpoll_t.
3633: */
3634:
3635: struct sigpoll {
3636: sigpoll_t * sp_next; /* single-threaded */
3637: _VOID * sp_proc; /* from proc_ref () */
3638: short sp_events; /* events to signal per <stropts.h> */
3639: };
3640:
3641:
3642: /*
3643: * This function is used when an M_SIG or M_PCSIG message is processed at the
3644: * stream head.
3645: */
3646:
3647: #if __USE_PROTO__
3648: void (SHEAD_SIGNAL) (shead_t * sheadp, uchar_t signal)
3649: #else
3650: void
3651: SHEAD_SIGNAL __ARGS ((sheadp, signal))
3652: shead_t * sheadp;
3653: uchar_t signal;
3654: #endif
3655: {
3656: pl_t prev_pl;
3657:
3658: prev_pl = SHEAD_LOCK (sheadp);
3659:
3660: if (signal == SIGPOLL) {
3661: sigpoll_t * sigs;
3662:
3663: /*
3664: * SIGPOLL is only sent to those processes that have
3665: * registered to receive it with I_SETSIG.
3666: */
3667:
3668:
3669: for (sigs = sheadp->sh_sigs ; sigs != NULL ;
3670: sigs = sigs->sp_next) {
3671:
3672: if ((sigs->sp_events & S_MSG) != 0)
3673: proc_signal (sigs->sp_proc, signal);
3674: }
3675: } else {
3676: /*
3677: * Send a signal to the controlling process group for this
3678: * stream; if this stream is not a controlling tty, then no
3679: * signal is sent.
3680: */
3681:
3682: if (sheadp->sh_pgrp != 0)
3683: proc_kill_group (sheadp->sh_pgrp, signal);
3684: }
3685:
3686: SHEAD_UNLOCK (sheadp, prev_pl);
3687: }
3688:
3689:
3690: /*
3691: * This function encapsulates all user-level access to the front of the stream
3692: * head message queue. It deals with ensuring that the STREAMS scheduling
3693: * policy works (by managing QWANTR) and some other details such as dealing
3694: * with in-band processing of M_SIG messages.
3695: *
3696: * The stream head read queue should be frozen by the caller.
3697: */
3698:
3699: #if __USE_PROTO__
3700: __LOCAL__ mblk_t * (SHEAD_FIRSTMSG) (shead_t * sheadp)
3701: #else
3702: __LOCAL__ mblk_t *
3703: SHEAD_FIRSTMSG __ARGS ((sheadp))
3704: shead_t * sheadp;
3705: #endif
3706: {
3707: mblk_t * msg;
3708:
3709: QFROZEN_TRACE (sheadp->sh_head, "SHEAD_FIRSTMSG");
3710:
3711: while ((msg = sheadp->sh_head->q_first) != NULL) {
3712:
3713: if (msg->b_datap->db_type != M_SIG)
3714: return msg;
3715:
3716: rmvq (sheadp->sh_head, msg);
3717: SHEAD_SIGNAL (sheadp, * msg->b_rptr);
3718: freemsg (msg);
3719: }
3720:
3721: sheadp->sh_head->q_flag |= QWANTR;
3722:
3723: return NULL;
3724: }
3725:
3726:
3727: /*
3728: * This function does the necessary work to implement POLLWRBAND, which tests
3729: * to see if any of the previously written-to bands of flow in the next
3730: * downstream queue with a service procedure are not flow controlled.
3731: */
3732:
3733: #if __USE_PROTO__
3734: __LOCAL__ int (POLL_WRBAND) (queue_t * q)
3735: #else
3736: __LOCAL__ int
3737: POLL_WRBAND __ARGS ((q))
3738: queue_t * q;
3739: #endif
3740: {
3741: pl_t prev_pl;
3742: qband_t * qbandp;
3743:
3744: prev_pl = QFREEZE_TRACE (q, "POLL_WRBAND");
3745:
3746: do {
3747: q = QUEUE_NEXT (q);
3748:
3749: if (q == NULL)
3750: return 1;
3751:
3752: } while (q->q_qinfo->qi_srvp == NULL);
3753:
3754:
3755: /*
3756: * We have found a queue with a service procedure, and have it frozen.
3757: * If there are no bands, then we can write a band...
3758: */
3759:
3760: if (q->q_nband == 0) {
3761:
3762: QUNFREEZE_TRACE (q, prev_pl);
3763: return 1;
3764: }
3765:
3766: qbandp = QUEUE_BAND (q, q->q_nband);
3767:
3768: ASSERT (qbandp != NULL);
3769:
3770: /*
3771: * Since if a band is blocked implies lower bands are blocked, we can
3772: * simply test the highest-numbered band.
3773: */
3774:
3775: if ((qbandp->qb_flag & QB_FULL) != 0) {
3776:
3777: QUNFREEZE_TRACE (q, prev_pl);
3778: return 1;
3779: }
3780:
3781:
3782: /*
3783: * If all are full, request notification via back-enabling when the
3784: * highest band becomes writeable.
3785: */
3786:
3787: qbandp->qb_flag |= QB_WANTW;
3788:
3789: QUNFREEZE_TRACE (q, prev_pl);
3790: return 0;
3791: }
3792:
3793:
3794: /*
3795: * This function has responsibility for checking to see whether the event mask
3796: * for this SIGPOLL request is immediately satisfied.
3797: */
3798:
3799: #if __USE_PROTO__
3800: __LOCAL__ short (SHEAD_POLL_CHECK) (shead_t * sheadp, short events)
3801: #else
3802: __LOCAL__ short
3803: SHEAD_POLL_CHECK __ARGS ((sheadp, events))
3804: shead_t * sheadp;
3805: short events;
3806: #endif
3807: {
3808: short revents = 0;
3809: pl_t prev_pl;
3810: mblk_t * msg;
3811:
3812:
3813: /*
3814: * Check the conditions that do not depend on the status of the first
3815: * queued message (if any).
3816: *
3817: * For S_OUTPUT, using canputnext () is important because it sets the
3818: * back-enable flag so that we will be properly notified when the
3819: * condition becomes true.
3820: *
3821: * For S_WRBAND, things are a little more complex; this tests whether
3822: * *any* downstream priority band is writeable, which involves walking
3823: * over all the 'qband' structures allocated to the next stream with
3824: * a service procedure.
3825: */
3826:
3827: if ((events & __POLL_OUTPUT) != 0 && canputnext (W (sheadp->sh_head)))
3828: revents |= __POLL_OUTPUT;
3829:
3830: if ((events & __POLL_WRBAND) != 0 &&
3831: POLL_WRBAND (W (sheadp->sh_head)))
3832: revents |= __POLL_WRBAND;
3833:
3834:
3835: prev_pl = SHEAD_LOCK (sheadp);
3836:
3837: if ((events & S_ERROR) != 0 &&
3838: (sheadp->sh_rerrcode != 0 || sheadp->sh_werrcode != 0))
3839: revents |= POLLERR;
3840:
3841: if ((events & S_HANGUP) != 0 && (sheadp->sh_flags & SH_HANGUP) != 0)
3842: revents = (revents | POLLHUP) &
3843: ~ (__POLL_OUTPUT | __POLL_WRBAND);
3844:
3845: SHEAD_UNLOCK (sheadp, prev_pl);
3846:
3847:
3848: prev_pl = QFREEZE_TRACE (sheadp->sh_head, "SHEAD_POLL_CHECK");
3849:
3850: if ((msg = SHEAD_FIRSTMSG (sheadp)) != NULL &&
3851: datamsg (msg->b_datap->db_type)) {
3852:
3853: if (! pcmsg (msg->b_datap->db_type)) {
3854:
3855: if ((events & __POLL_INPUT) != 0)
3856: revents |= __POLL_INPUT;
3857:
3858: if ((events & __POLL_RDNORM) != 0 && msg->b_band == 0)
3859: revents |= __POLL_RDNORM;
3860:
3861: if ((events & __POLL_RDBAND) != 0 && msg->b_band > 0)
3862: revents |= __POLL_RDBAND;
3863: } else if ((events & __POLL_HIPRI) != 0)
3864: revents |= __POLL_HIPRI;
3865: }
3866:
3867: QUNFREEZE_TRACE (sheadp->sh_head, prev_pl);
3868:
3869: return revents;
3870: }
3871:
3872:
3873: /*
3874: * This function attempts to locate any sigpoll record for the current
3875: * process. The stream head needs to be locked out against modification of
3876: * the signal list, which means an IOCTL lock is sufficient.
3877: */
3878:
3879: #if __USE_PROTO__
3880: __LOCAL__ sigpoll_t * (FIND_SIGPOLL) (shead_t * sheadp)
3881: #else
3882: __LOCAL__ sigpoll_t *
3883: FIND_SIGPOLL __ARGS ((sheadp))
3884: shead_t * sheadp;
3885: #endif
3886: {
3887: _VOID * proc;
3888: sigpoll_t * scan;
3889:
3890: ASSERT_SLEEP_LOCKED (sheadp, SH_IOCTL_LOCK);
3891:
3892: /*
3893: * See if the process is already registered (so that we can modify or
3894: * free an existing record).
3895: */
3896:
3897: proc = proc_ref ();
3898:
3899: for (scan = sheadp->sh_sigs ; scan != NULL ; scan ++)
3900: if (scan->sp_proc == proc)
3901: break;
3902:
3903: proc_unref (proc);
3904:
3905: return scan;
3906: }
3907:
3908:
3909: /*
3910: * This function deals with (de)registering a process for SIGPOLL. The caller
3911: * should have an IOCTL lock on the stream head so that there are no other
3912: * contexts which could modify the list of registered signals.
3913: */
3914:
3915: #if __USE_PROTO__
3916: __LOCAL__ int (REGISTER_SIGPOLL) (shead_t * sheadp, short events)
3917: #else
3918: __LOCAL__ int
3919: REGISTER_SIGPOLL __ARGS ((sheadp, events))
3920: shead_t * sheadp;
3921: short events;
3922: #endif
3923: {
3924: _VOID * proc;
3925: sigpoll_t * scan;
3926: sigpoll_t * prev;
3927:
3928: ASSERT_SLEEP_LOCKED (sheadp, SH_IOCTL_LOCK);
3929:
3930: /*
3931: * See if the process is already registered (so that we can modify or
3932: * free an existing record). We don't use the FIND_SIGPOLL () routine
3933: * because we want to locate the previous record also.
3934: */
3935:
3936: proc = proc_ref ();
3937:
3938: for (prev = NULL, scan = sheadp->sh_sigs ; scan != NULL ;
3939: prev = scan, scan ++) {
3940:
3941: if (scan->sp_proc == proc) {
3942: /*
3943: * We have found a preexisting record... now modify
3944: * or free it.
3945: */
3946:
3947: proc_unref (proc);
3948:
3949: (void) SHEAD_LOCK (sheadp);
3950:
3951: if ((scan->sp_events = events) == 0) {
3952: /*
3953: * Free the cell after unlinking it from the
3954: * list of registered processes. We take out
3955: * a lock on the stream head to protect
3956: * against streams-level contexts walking the
3957: * list.
3958: */
3959:
3960: if (prev == NULL)
3961: sheadp->sh_sigs = scan->sp_next;
3962: else
3963: prev->sp_next = scan->sp_next;
3964:
3965: SHEAD_UNLOCK (sheadp, plbase);
3966:
3967: /*
3968: * We unlock the stream head before calling
3969: * the heap manager as a matter of courtesy.
3970: */
3971:
3972: kmem_free (scan, sizeof (* scan));
3973: proc_unref (proc);
3974: return 0;
3975: }
3976:
3977: SHEAD_UNLOCK (sheadp, plbase);
3978: goto sigcheck;
3979: }
3980: }
3981:
3982:
3983: if (events == 0) {
3984: /*
3985: * Not found, nothing to do. That is an error according to the
3986: * streamio (7) man pages.
3987: */
3988:
3989: return EINVAL;
3990: }
3991:
3992:
3993: /*
3994: * We need to make a new event.
3995: */
3996:
3997: if ((scan = (sigpoll_t *) kmem_alloc (sizeof (* scan),
3998: KM_SLEEP)) == NULL) {
3999:
4000: proc_unref (proc);
4001: return EAGAIN;
4002: }
4003:
4004: scan->sp_proc = proc;
4005: scan->sp_events = events;
4006: scan->sp_next = sheadp->sh_sigs;
4007:
4008: /*
4009: * Since we are the only process context modifying the list, we only
4010: * need to lock the last stage of the insert against interrupt-level
4011: * contexts walking the list.
4012: */
4013:
4014: (void) SHEAD_LOCK (sheadp);
4015:
4016: sheadp->sh_sigs = scan;
4017:
4018: SHEAD_UNLOCK (sheadp, plbase);
4019:
4020: sigcheck:
4021: if ((events = SHEAD_POLL_CHECK (sheadp, scan->sp_events)) != 0) {
4022: /*
4023: * We have a winner! Check for the SIGURG special case, and
4024: * otherwise/also send SIGPOLL via proc_signal ().
4025: */
4026:
4027: if ((events & __POLL_RDBAND) != 0 &&
4028: (scan->sp_events & S_BANDURG) != 0) {
4029:
4030: proc_signal (scan->sp_proc, SIGURG);
4031: events &= ~ __POLL_RDBAND;
4032: }
4033:
4034: if (events != 0)
4035: proc_signal (scan->sp_proc, SIGPOLL);
4036: }
4037:
4038: return 0;
4039: }
4040:
4041:
4042: /*
4043: * This function maps a file descriptor into a stream head by calling upon the
4044: * abstract file-description functions declared in <sys/fhsys.h>. The caller
4045: * must lock the stream somehow.
4046: */
4047:
4048: #if ! _NO_INSTALLABLE_FILESYSTEMS
4049:
4050: extern fprocs_t streams_fsys;
4051:
4052: #endif
4053:
4054:
4055: #if __USE_PROTO__
4056: __LOCAL__ shead_t * (FH_TO_STREAM) (int fd, int * retvalp)
4057: #else
4058: __LOCAL__ shead_t *
4059: FH_TO_STREAM __ARGS ((fd, retvalp))
4060: int fd;
4061: int * retvalp;
4062: #endif
4063: {
4064: fhandle_t * handle;
4065: scookie_t * cookie;
4066:
4067: ASSERT (retvalp != NULL);
4068:
4069: if ((handle = fd_get_handle (fd)) == NULL) {
4070:
4071: * retvalp = EBADF;
4072: return NULL;
4073: #if ! _NO_INSTALLABLE_FILESYSTEMS
4074: } else if (fh_procs (handle) == & streams_fsys) {
4075:
4076: * retvalp = EINVAL;
4077: return NULL;
4078: #endif
4079: }
4080:
4081: cookie = (scookie_t *) fh_get_cookie (handle);
4082:
4083: ASSERT (cookie != NULL);
4084:
4085: if (cookie->sheadp == NULL)
4086: cmn_err (CE_WARN, "Bad cookie in streams");
4087:
4088: return cookie->sheadp;
4089: }
4090:
4091:
4092: /*
4093: * The following structure is used by the routines below to deal with the
4094: * M_PASSFP message type. The structure of the data contained in that message
4095: * is completely opaque to STREAMS routines, so we keep the definition local.
4096: */
4097:
4098: struct passfp {
4099: sftab_t * sftab; /* system file table entry address */
4100: n_uid_t uid;
4101: n_gid_t gid;
4102: };
4103:
4104:
4105: /*
4106: * This function attempts to retrieve a file descriptor sent by an I_SENDFD
4107: * ioctl () and create a local file descriptor referring to the same file.
4108: */
4109:
4110: #if __USE_PROTO__
4111: __LOCAL__ int (FH_RECV) (shead_t * sheadp, int mode, struct strrecvfd * recvp)
4112: #else
4113: __LOCAL__ int
4114: FH_RECV __ARGS ((sheadp, mode, recvp))
4115: shead_t * sheadp;
4116: int mode;
4117: struct strrecvfd
4118: * recvp;
4119: #endif
4120: {
4121: mblk_t * msg;
4122: struct passfp * fp;
4123: int retval;
4124:
4125: ASSERT (sheadp != NULL);
4126: ASSERT (recvp != NULL);
4127:
4128: if (! SHEAD_IS_PIPE (sheadp))
4129: return EINVAL;
4130:
4131: if ((mode & FREAD) == 0)
4132: return EBADF;
4133:
4134: mode &= ~ FWRITE;
4135:
4136:
4137: /*
4138: * Look at the stream head to see if a message is present.
4139: */
4140:
4141: for (;;) {
4142: int retval;
4143:
4144: (void) QFREEZE_TRACE (sheadp->sh_head, "FH_RECV");
4145:
4146: if ((msg = SHEAD_FIRSTMSG (sheadp)) != NULL)
4147: break;
4148:
4149: /*
4150: * Use the STREAMS flag to indicate that we have found the
4151: * queue empty.
4152: */
4153:
4154: (void) SHEAD_LOCK (sheadp);
4155:
4156: QUNFREEZE_TRACE (sheadp->sh_head, plstr);
4157:
4158: /*
4159: * We need to wait (unless O_NDELAY or O_NONBLOCK has been
4160: * specified), or the stream has been hung up.
4161: */
4162:
4163: if ((retval = SHEAD_WAIT_NONBLOCK (sheadp, mode, SH_READ_WAIT,
4164: CHECK_SIGNALS)) != 0)
4165: return retval;
4166:
4167: /*
4168: * Check again...
4169: */
4170: }
4171:
4172: if (msg->b_datap->db_type != M_PASSFP)
4173: retval = EBADMSG;
4174: else if (! fd_can_add ())
4175: retval = EMFILE;
4176: else {
4177:
4178: retval = 0;
4179: rmvq (sheadp->sh_head, msg);
4180: }
4181:
4182: QUNFREEZE_TRACE (sheadp->sh_head, plbase);
4183:
4184: if (retval != 0)
4185: return retval;
4186:
4187: /*
4188: * After this point, "msg" is our responsibility and we either have to
4189: * free it or put it back if there is an error.
4190: */
4191:
4192: fp = (struct passfp *) msg->b_rptr;
4193:
4194: if ((retval = fd_add_sftab (fp->sftab, & recvp->fd)) == 0 &&
4195: ((recvp->uid = (o_uid_t) fp->uid) != fp->uid ||
4196: (recvp->gid = (o_gid_t) fp->gid) != fp->gid))
4197: retval = EOVERFLOW;
4198:
4199: freemsg (msg);
4200: return retval;
4201: }
4202:
4203:
4204: /*
4205: * This function attempts to send a file descriptor to another process at the
4206: * other end of a stream pipe.
4207: */
4208:
4209: #if __USE_PROTO__
4210: __LOCAL__ int (FH_SEND) (shead_t * sheadp, int fd, cred_t * credp)
4211: #else
4212: __LOCAL__ int
4213: FH_SEND __ARGS ((sheadp, fd, credp))
4214: shead_t * sheadp;
4215: int fd;
4216: cred_t * credp;
4217: #endif
4218: {
4219: mblk_t * msg;
4220: struct passfp * fp;
4221: sftab_t * sftab;
4222: shead_t * other;
4223: int retval;
4224:
4225: ASSERT (sheadp != NULL);
4226: ASSERT (credp != NULL);
4227:
4228: if (! SHEAD_IS_PIPE (sheadp))
4229: return EINVAL;
4230:
4231: /*
4232: * We are passed a file descriptor (a user-level abstract entity);
4233: * here we turn that into a kernel-level abstract entity.
4234: */
4235:
4236: if ((sftab = fd_get_sftab (fd)) == NULL)
4237: return EBADF;
4238:
4239: other = SHEAD_OTHER (sheadp);
4240:
4241: if (! canput (W (other->sh_head)) ||
4242: (msg = MSGB_ALLOC (sizeof (* fp), BPRI_LO, KM_SLEEP)) == NULL)
4243: return EAGAIN;
4244:
4245: /*
4246: * Fill in the new message block and put the message to the other
4247: * side. After this point we have to free the message block if there
4248: * is a problem.
4249: */
4250:
4251: fp = (struct passfp *) msg->b_rptr;
4252: msg->b_wptr = (unsigned char *) (fp + 1);
4253:
4254: msg->b_datap->db_type = M_PASSFP;
4255:
4256: fp->sftab = sftab;
4257: fp->uid = credp->cr_uid;
4258: fp->gid = credp->cr_gid;
4259:
4260: (void) SHEAD_LOCK (sheadp);
4261:
4262: if ((retval = SHEAD_ERRHUP_LOCKED (sheadp, FWRITE)) == 0) {
4263:
4264: putq (W (other->sh_head), msg);
4265:
4266: SHEAD_UNLOCK (sheadp, plbase);
4267: } else
4268: freemsg (msg);
4269:
4270: return retval;
4271: }
4272:
4273:
4274: /*
4275: * This function factors out the details of copying data out from kernel space
4276: * into a "strbuf" stream buffer structure in user space.
4277: *
4278: * The return value of this function is 0 on success or -1 on error.
4279: */
4280:
4281: enum {
4282: CONTROL_PART,
4283: DATA_PART
4284: };
4285:
4286: #if __USE_PROTO__
4287: __LOCAL__ int (COPYOUT_BUF) (struct strbuf * bufp, mblk_t ** mpp, int data)
4288: #else
4289: __LOCAL__ int
4290: COPYOUT_BUF __ARGS ((bufp, mpp, data))
4291: struct strbuf * bufp;
4292: mblk_t ** mpp;
4293: int data;
4294: #endif
4295: {
4296: mblk_t * prev;
4297: mblk_t * scan;
4298: int remaining;
4299: caddr_t outaddr;
4300:
4301: ASSERT (mpp != NULL);
4302:
4303: /*
4304: * The first thing we do is check some special values; if a "strbuf"
4305: * entry is NULL or has its "maxlen" member set to "-1", we do nothing
4306: * with the message.
4307: */
4308:
4309: if (bufp == NULL || bufp->maxlen == -1)
4310: return 0;
4311:
4312: /*
4313: * Next, if this is a data-part copy, skip any intial M_PROTO or
4314: * M_PCPROTO message blocks. There *should* only ever be one of these
4315: * at the front of a message, but we are required to effectively
4316: * coalesce multiple control blocks.
4317: */
4318:
4319: prev = NULL;
4320: scan = * mpp;
4321:
4322: if (data == DATA_PART) {
4323: /*
4324: * Find the data portion of the message, if any.
4325: */
4326:
4327: while (scan != NULL) {
4328:
4329: if (scan->b_datap->db_type == M_DATA)
4330: break;
4331: scan = (prev = scan)->b_cont;
4332: }
4333: } else
4334: if (scan->b_datap->db_type == M_DATA)
4335: scan = NULL;
4336:
4337: /*
4338: * If there is no control (or data, as appropriate) part to the
4339: * message, then we set the "len" member of the "strbuf" to -1.
4340: */
4341:
4342: if (scan == NULL) {
4343:
4344: bufp->len = -1;
4345: return 0;
4346: }
4347:
4348:
4349: /*
4350: * Now be do the actual copy; the form of this loop is organized so
4351: * that zero-length message blocks will be consumed if "maxlen" is
4352: * set to 0. This is important not only to comply with the manual page
4353: * for getmsg ()/getpmsg (), but also ensures that trailing zero-
4354: * length blocks at the end of a message get cleaned up properly.
4355: */
4356:
4357: bufp->len = 0;
4358: remaining = bufp->maxlen;
4359: outaddr = (caddr_t) bufp->buf;
4360:
4361: for (;;) {
4362: size_t copylen = scan->b_wptr - scan->b_rptr;
4363: mblk_t * next;
4364:
4365: if (copylen > remaining)
4366: copylen = remaining;
4367:
4368: if (copylen > 0) {
4369: /*
4370: * Copy the data to the user. Don't forget that
4371: * copyout () is like bcopy () in that the arguments
4372: * are src, dest, len !
4373: */
4374:
4375: if (copyout (scan->b_rptr, outaddr, copylen) != 0)
4376: return EFAULT;
4377:
4378: bufp->len += copylen;
4379: scan->b_rptr += copylen;
4380: remaining -= copylen;
4381: }
4382:
4383: if (scan->b_rptr != scan->b_wptr) {
4384: /*
4385: * Since this message block was not fully consumed, we
4386: * can infer that we have copied all the data we can.
4387: */
4388:
4389: ASSERT (remaining == 0);
4390: break;
4391: }
4392:
4393:
4394: /*
4395: * This message block has been consumed; unlink and free it.
4396: */
4397:
4398: next = scan->b_cont;
4399: if (prev == NULL)
4400: * mpp = next;
4401: else
4402: prev->b_cont = next;
4403: freeb (scan);
4404:
4405:
4406: /*
4407: * Get ready to go around the loop again; if we are copying
4408: * the control part of a message, we have to test for the end
4409: * of the control part here.
4410: */
4411:
4412: if ((scan = next) == NULL)
4413: break;
4414:
4415: if (data == CONTROL_PART && scan->b_datap->db_type == M_DATA)
4416: break;
4417: }
4418:
4419: return 0;
4420: }
4421:
4422:
4423: /*
4424: * This is a buffer callback function used by SHEAD_PEEK () to deal with
4425: * dupmsg () failures via bufcall ().
4426: */
4427:
4428: #if __USE_PROTO__
4429: __LOCAL__ void peek_bufcall_func (_VOID * arg)
4430: #else
4431: __LOCAL__ void
4432: peek_bufcall_func (arg)
4433: _VOID * arg;
4434: #endif
4435: {
4436: pl_t prev_pl;
4437: shead_t * sheadp = (shead_t *) arg;
4438:
4439: /*
4440: * We freeze the stream head read queue to synchronize ourselves with
4441: * the SHEAD_PEEK () and avoid race conditions where we try and wake
4442: * up the process that scheduled us before they have slept.
4443: */
4444:
4445: prev_pl = QFREEZE_TRACE (sheadp->sh_head, "peek_bufcall_func");
4446:
4447: sheadp->sh_read_bufcall = 0;
4448:
4449: SHEAD_WAKE (sheadp, SH_PEEK_WAIT);
4450:
4451: QUNFREEZE_TRACE (sheadp->sh_head, prev_pl);
4452: }
4453:
4454:
4455: /*
4456: * This is a helper function for I_PEEK and read ()-like functions who want
4457: * to recover from an out-of-memory situation by performing a short sleep.
4458: *
4459: * This function takes care of scheduling and cancelling the bufcall. The
4460: * caller must have the stream head locked when calling this function.
4461: *
4462: * This function returns with the stream head read queue unlocked, and with
4463: * the value 0 on success and an error number on error.
4464: */
4465:
4466: #if __USE_PROTO__
4467: __LOCAL__ int (SHEAD_READ_BUFCALL) (shead_t * sheadp, int __NOTUSED (mode))
4468: #else
4469: __LOCAL__ int
4470: SHEAD_READ_BUFCALL __ARGS ((sheadp, mode))
4471: shead_t * sheadp;
4472: int mode;
4473: #endif
4474: {
4475: SHEAD_ASSERT_LOCKED (sheadp);
4476:
4477: if (sheadp->sh_read_bufcall == 0 &&
4478: (sheadp->sh_read_bufcall = bufcall (1024, BPRI_LO,
4479: peek_bufcall_func,
4480: sheadp)) == 0) {
4481: SHEAD_UNLOCK (sheadp, plbase);
4482: return ENOSR;
4483: }
4484:
4485: return SHEAD_WAIT_NONBLOCK (sheadp, FREAD, SH_PEEK_WAIT,
4486: CHECK_SIGNALS);
4487: }
4488:
4489:
4490: /*
4491: * This function implements I_PEEK read-ahead for streams. The caller should
4492: * have the stream head locked for read/write access.
4493: */
4494:
4495: #if __USE_PROTO__
4496: __LOCAL__ int (SHEAD_PEEK) (shead_t * sheadp, struct strpeek * peek,
4497: int * rvalp)
4498: #else
4499: __LOCAL__ int
4500: SHEAD_PEEK __ARGS ((sheadp, peek, rvalp))
4501: shead_t * sheadp;
4502: struct strpeek * peek;
4503: int * rvalp;
4504: #endif
4505: {
4506: mblk_t * msg;
4507: int retval;
4508:
4509: ASSERT (sheadp != NULL);
4510: ASSERT (peek != NULL);
4511: ASSERT (rvalp != NULL);
4512:
4513: if (peek->flags != 0 && peek->flags != RS_HIPRI)
4514: return EINVAL;
4515:
4516: /*
4517: * Look at the stream head to see if there are any queued messages.
4518: *
4519: * Some notes about this are in order; as mentioned in the discussion
4520: * on locking elsewhere, the possibility of page fault resolution
4521: * during copies to user space complicates life, because copy routines
4522: * may sleep while a page is made resident.
4523: *
4524: * This affects routines which read from the stream head in various
4525: * ways, some of which are outlined in the general section on locking.
4526: * Other than data consistency, it also affects the way message are
4527: * deallocated; this routine wants to take a copy of the data in a
4528: * message, but we need to ensure that the message will not be
4529: * deallocated not just by other processes but also by actions at the
4530: * stream level such as M_FLUSH.
4531: *
4532: * Other than getting into a web of locking flags and reference counts
4533: * (there are already too many of those), the simplest ways of dealing
4534: * with this are a) create a duplicate reference to the message data
4535: * with dupmsg (), and b) simply dequeue the message and put it back
4536: * when we're done.
4537: *
4538: * Neither alternative is without unpleasant consequences; a) has to
4539: * deal with a lack of available storage to duplicate the message
4540: * blocks, and b) has to deal with such things as reads blocking while
4541: * the message is dequeued.
4542: *
4543: * a) and b) seem to have more-or-less equal implementation costs, but
4544: * while a) is guaranteed to maintain the semantics of all stream
4545: * operations, b) is not. Unless we can predict all the consequences
4546: * of b) and either work around them or determine that they are benign
4547: * then a) seems preferable.
4548: */
4549:
4550: for (;;) {
4551: (void) QFREEZE_TRACE (sheadp->sh_head, "SHEAD_PEEK");
4552:
4553: if ((msg = SHEAD_FIRSTMSG (sheadp)) == NULL) {
4554: no_message:
4555: /*
4556: * No go; arrange for the value 0 to be returned to
4557: * the caller of the ioctl ().
4558: */
4559:
4560: QUNFREEZE_TRACE (sheadp->sh_head, plbase);
4561: * rvalp = 0;
4562:
4563: return 0;
4564: }
4565:
4566: switch (msg->b_datap->db_type) {
4567:
4568: case M_DATA:
4569: case M_PROTO:
4570: /*
4571: * If the caller has asked for high-priority messages
4572: * only, then we arrange to return 0.
4573: */
4574:
4575: if ((peek->flags & RS_HIPRI) != 0)
4576: goto no_message;
4577: break;
4578:
4579: case M_PCPROTO:
4580: break;
4581:
4582: default:
4583: QUNFREEZE_TRACE (sheadp->sh_head, plbase);
4584: return EBADMSG;
4585: }
4586:
4587:
4588: /*
4589: * Attempt to obtain a duplicate reference to this message.
4590: */
4591:
4592: if ((msg = dupmsg (msg)) != NULL) {
4593:
4594: QUNFREEZE_TRACE (sheadp->sh_head, plbase);
4595: break;
4596: }
4597:
4598:
4599: /*
4600: * Wait a short time for buffers to be available. To do this,
4601: * we transfer our locking attention from the queue to the
4602: * stream head.
4603: */
4604:
4605: (void) SHEAD_LOCK (sheadp);
4606:
4607: QUNFREEZE_TRACE (sheadp->sh_head, plstr);
4608:
4609: if ((retval = SHEAD_READ_BUFCALL (sheadp, FREAD)) != 0)
4610: return retval;
4611: }
4612:
4613:
4614: /*
4615: * Now we have a duplicate copy of a message to transfer to user
4616: * space. From this point on, any attempt to exit from this routine
4617: * must take care of freeing this message. However, we don't have to
4618: * touch the queue again.
4619: */
4620:
4621: peek->flags = msg->b_datap->db_type == M_PCPROTO ? RS_HIPRI : 0;
4622:
4623: retval = (COPYOUT_BUF (& peek->ctlbuf, & msg, CONTROL_PART) != 0 ||
4624: COPYOUT_BUF (& peek->databuf, & msg,
4625: DATA_PART) != 0) ? EFAULT : 0;
4626:
4627: if (msg != NULL)
4628: freemsg (msg);
4629:
4630: * rvalp = 1;
4631:
4632: return retval;
4633: }
4634:
4635:
4636: /*
4637: * Helper function to atomically read the stream head write offset.
4638: */
4639:
4640: #if __USE_PROTO__
4641: __LOCAL__ short (SHEAD_WRITEOFFSET) (shead_t * sheadp)
4642: #else
4643: __LOCAL__ short
4644: SHEAD_WRITEOFFSET __ARGS ((sheadp))
4645: shead_t * sheadp;
4646: #endif
4647: {
4648: pl_t prev_pl;
4649: short opt;
4650:
4651: prev_pl = SHEAD_LOCK (sheadp);
4652:
4653: opt = sheadp->sh_readopt;
4654:
4655: SHEAD_UNLOCK (sheadp, prev_pl);
4656:
4657: return opt;
4658: }
4659:
4660:
4661: /*
4662: * This function tests for errors on a stream and optionally also waits for
4663: * flow control to be relieved.
4664: */
4665:
4666: #if __USE_PROTO__
4667: __LOCAL__ int (SHEAD_WRITE_TEST) (shead_t * sheadp, int mode, int band,
4668: int hipri)
4669: #else
4670: __LOCAL__ int
4671: SHEAD_WRITE_TEST __ARGS ((sheadp, mode, band, hipri))
4672: shead_t * sheadp;
4673: int mode;
4674: int band;
4675: int hipri;
4676: #endif
4677: {
4678: int retval;
4679:
4680: do {
4681: (void) SHEAD_LOCK (sheadp);
4682:
4683: if ((retval = SHEAD_ERRHUP_LOCKED (sheadp, mode)) != 0)
4684: break;
4685:
4686: if (hipri != 0 || bcanputnext (W (sheadp->sh_head), band)) {
4687:
4688: SHEAD_UNLOCK (sheadp, plbase);
4689: break;
4690: }
4691: } while ((retval = SHEAD_WAIT_NONBLOCK (sheadp, mode, SH_WRITE_WAIT,
4692: CHECK_SIGNALS)) == 0);
4693:
4694: return retval;
4695: }
4696:
4697:
4698: /*
4699: * This function deals with all the grunge of creating a message for sending
4700: * down a stream. There are many conditions that need to be checked, including
4701: * whether the message fits within the size limits given by the downstream
4702: * queue.
4703: *
4704: * Since the message is going to be written to the stream, we also deal with
4705: * waiting for flow control here. We only allocate memory for the user's data
4706: * when we have an indication that it will be valid to write it... this may
4707: * not be an optimal choice for a high-performance system with vast amounts
4708: * of STREAMS buffer space.
4709: */
4710:
4711: #if __USE_PROTO__
4712: __LOCAL__ mblk_t * (SHEAD_MAKEMSG) (shead_t * sheadp, int mode,
4713: struct strbuf * ctlbuf,
4714: struct strbuf * databuf,
4715: int flags, int band, int * retvalp)
4716: #else
4717: __LOCAL__ mblk_t *
4718: SHEAD_MAKEMSG __ARGS ((sheadp, mode, ctlbuf, databuf, flags, band, retvalp))
4719: shead_t * sheadp;
4720: int mode;
4721: struct strbuf * ctlbuf;
4722: struct strbuf * databuf;
4723: int flags;
4724: int band;
4725: int * retvalp;
4726: #endif
4727: {
4728: queue_t * q;
4729: int ctlsize;
4730: int datasize;
4731: int wroff;
4732: mblk_t * ctlmsg;
4733: mblk_t * datamsg;
4734:
4735: ASSERT (sheadp != NULL);
4736: ASSERT (retvalp != NULL);
4737:
4738: /*
4739: * The "flags" value specifies one of the constants MSG_BAND or
4740: * MSG_HIPRI. Despite being arranged as flags, only one is allowed to
4741: * be given.
4742: */
4743:
4744: if (flags != MSG_BAND && flags != MSG_HIPRI) {
4745:
4746: * retvalp = EINVAL;
4747: return NULL;
4748: }
4749:
4750: if ((mode & FWRITE) == 0) {
4751:
4752: * retvalp = EBADF;
4753: return NULL;
4754: }
4755:
4756: mode &= ~ FREAD;
4757:
4758:
4759: /*
4760: * The absolute maximum possible size for the control or data parts of
4761: * a STREAMS message are configured system-wide.
4762: */
4763:
4764: ctlsize = ctlbuf == NULL ? -1 : ctlbuf->len;
4765: datasize = databuf == NULL ? -1 : databuf->len;
4766: wroff = SHEAD_WRITEOFFSET (sheadp);
4767:
4768: q = TOP_QUEUE (sheadp);
4769:
4770: if (ctlsize > str_mem->sm_maxctlsize ||
4771: (datasize + wroff) > str_mem->sm_maxdatasize ||
4772: (datasize + wroff) < q->q_minpsz ||
4773: (datasize + wroff) > q->q_maxpsz) {
4774:
4775: * retvalp = ERANGE;
4776: return NULL;
4777: }
4778:
4779:
4780: /*
4781: * You can't send a high-priority message without a control part, or a
4782: * high-priority message with a non-zero band number.
4783: *
4784: * Otherwise, if no data at all is specified, then no message will be
4785: * sent.
4786: */
4787:
4788: if (flags == MSG_HIPRI) {
4789:
4790: if (ctlsize < 0 || band != 0) {
4791:
4792: * retvalp = EINVAL;
4793: return NULL;
4794: }
4795: } else if (datasize < 0 && ctlsize < 0) {
4796:
4797: * retvalp = 0;
4798: return NULL;
4799: }
4800:
4801:
4802: /*
4803: * Let's see if the stream is flow controlled; if it is, we either
4804: * block or return EAGAIN depending on the FNDELAY/FNONBLOCK setting.
4805: */
4806:
4807: if ((* retvalp = SHEAD_WRITE_TEST (sheadp, mode, band, flags)) != 0)
4808: return NULL;
4809:
4810: /*
4811: * Now we allocate data space for the messages. If the size of a
4812: * component is -1, then we don't allocate any space for that part,
4813: * otherwise we allocate a component of length 0.
4814: *
4815: * Don't forget that copyin () has arguments in the bcopy () order,
4816: * ie. src, dest, len
4817: */
4818:
4819: if (ctlsize >= 0) {
4820: /*
4821: * Special case; the stream head is required to ensure that
4822: * the control part of any message has at least 64 bytes of
4823: * space. This is specified in the putmsg (2) manual page!
4824: */
4825:
4826: if ((ctlmsg = MSGB_ALLOC (ctlsize < 64 ? 64 : ctlsize,
4827: BPRI_LO, KM_SLEEP)) == NULL) {
4828: * retvalp = ENOSR;
4829: return NULL;
4830: }
4831:
4832: ctlmsg->b_datap->db_type = flags == MSG_HIPRI ? M_PCPROTO :
4833: M_PROTO;
4834: ctlmsg->b_band = band;
4835:
4836: if (ctlsize > 0 &&
4837: copyin (ctlbuf->buf, ctlmsg->b_rptr, ctlsize) != 0) {
4838:
4839: freeb (ctlmsg);
4840: * retvalp = EFAULT;
4841: return NULL;
4842: }
4843:
4844: ctlmsg->b_wptr += ctlsize;
4845: } else
4846: ctlmsg = NULL; /* paranoia */
4847:
4848: if (datasize >= 0) {
4849:
4850: if ((datamsg = MSGB_ALLOC (datasize + wroff, BPRI_LO,
4851: KM_SLEEP)) == NULL) {
4852: if (ctlsize >= 0)
4853: freeb (ctlmsg);
4854:
4855: * retvalp = ENOSR;
4856: return NULL;
4857: }
4858:
4859: if (ctlsize < 0)
4860: ctlmsg = datamsg;
4861: else
4862: ctlmsg->b_cont = datamsg;
4863:
4864: datamsg->b_band = band;
4865: datamsg->b_wptr = datamsg->b_wptr = datamsg->b_rptr + wroff;
4866:
4867: if (datasize > 0 &&
4868: copyin (databuf->buf, datamsg->b_rptr, datasize) != 0) {
4869:
4870: freemsg (ctlmsg);
4871:
4872: * retvalp = EFAULT;
4873: return NULL;
4874: }
4875:
4876: datamsg->b_wptr += datasize;
4877: }
4878:
4879:
4880: /*
4881: * Since the allocation requests could have blocked for memory to
4882: * become available, and the copy requests could have blocked to
4883: * resolve page faults, we could actually be a fair way down the track
4884: * by now.
4885: *
4886: * If we were paranoid, we would recheck the flow control parameters
4887: * and a bunch of other stuff, but there doesn't seem to be a whole
4888: * lot of point to that. As long as we don't use data that could have
4889: * changed while we waited, we're fine.
4890: */
4891:
4892: * retvalp = 0;
4893: return ctlmsg;
4894: }
4895:
4896:
4897: /*
4898: * This function implements the I_FDINSERT ioctl ().
4899: */
4900:
4901: #if __USE_PROTO__
4902: __LOCAL__ int (SHEAD_FDINSERT) (shead_t * sheadp, int mode,
4903: struct strfdinsert * fdinsp)
4904: #else
4905: __LOCAL__ int
4906: SHEAD_FDINSERT __ARGS ((sheadp, mode, fdinsp))
4907: shead_t * sheadp;
4908: int mode;
4909: struct strfdinsert
4910: * fdinsp;
4911: #endif
4912: {
4913: int retval;
4914: shead_t * other;
4915: mblk_t * msg;
4916:
4917: ASSERT (sheadp != NULL);
4918: ASSERT (fdinsp != NULL);
4919:
4920: /*
4921: * There are a large number of error conditions to check for this
4922: * function. Don't lose sight of the fact that the big set of chained
4923: * conditions below computes "other" for us.
4924: */
4925: /*
4926: * ALIGNMENT-DEPENDENT CODE.
4927: */
4928:
4929: if ((fdinsp->flags != 0 && fdinsp->flags != RS_HIPRI) ||
4930: ((unsigned) fdinsp->offset & ~ sizeof (int)) != 0 ||
4931: fdinsp->offset + sizeof (queue_t *) > fdinsp->ctlbuf.len ||
4932: (other = FH_TO_STREAM (fdinsp->fildes, & retval)) != 0) {
4933: /*
4934: * A failure of any of the above returns EINVAL; according to
4935: * streamio (7) EINVAL rather than EBADF results from a bad
4936: * file descriptor.
4937: */
4938:
4939: return EINVAL;
4940: }
4941:
4942: /*
4943: * Make a band 0 message (possibly high-priority). This can fail if
4944: * the requested message is too large for the advertised limits set
4945: * by the next thing downstream.
4946: *
4947: * IMPORANT: we *rely* on this function making a message with a single
4948: * large control block at least as big as the advertised size. If we
4949: * cannot rely on this function we have to do lots of extra checking
4950: * which I'd rather avoid.
4951: */
4952:
4953: msg = SHEAD_MAKEMSG (sheadp, mode, & fdinsp->ctlbuf,
4954: & fdinsp->databuf,
4955: fdinsp->flags ? MSG_HIPRI : MSG_BAND, 0,
4956: & retval);
4957: if (msg == NULL)
4958: return retval;
4959:
4960: /*
4961: * Note that we don't recheck for hangups even though we could have
4962: * waited a poentially long time in SHEAD_MAKEMSG (). The hangup
4963: * condition has plenty of slop in it with the time it takes write
4964: * messages to move down the queue anyway; drivers and modules have to
4965: * be able to cope.
4966: */
4967:
4968: * (queue_t **) (msg->b_rptr + fdinsp->offset) = other->sh_head;
4969:
4970: putq (W (sheadp->sh_head), msg);
4971:
4972: return 0;
4973: }
4974:
4975:
4976: /*
4977: * This function implements the I_FIND ioctl ().
4978: */
4979:
4980: #if __USE_PROTO__
4981: __LOCAL__ int (SHEAD_FIND_MODINFO) (shead_t * sheadp, char * modname,
4982: int * rvalp)
4983: #else
4984: __LOCAL__ int
4985: SHEAD_FIND_MODINFO __ARGS ((sheadp, modname, rvalp))
4986: shead_t * sheadp;
4987: char * modname;
4988: int * rvalp;
4989: #endif
4990: {
4991: modsw_t * module;
4992:
4993: /*
4994: * First try to find the module in the global list of modules, then
4995: * attempt to find that module's info on the stream.
4996: */
4997:
4998: if ((module = FIND_MODULE (modname)) == NULL)
4999: return EINVAL;
5000: else {
5001: queue_t * scan;
5002: pl_t prev_pl;
5003:
5004: /*
5005: * Walk down the write side of the stream until either the
5006: * write side module info matches -or- a cross-point is found.
5007: */
5008:
5009: scan = W (sheadp->sh_head);
5010:
5011: prev_pl = SHEAD_LOCK (sheadp);
5012:
5013: while (scan->q_next != NULL) {
5014: if ((scan->q_flag & QREADR) !=
5015: (scan->q_next->q_flag & QREADR)) {
5016: /*
5017: * Set scan to NULL to flag an unsuccessful
5018: * search.
5019: */
5020:
5021: scan = NULL;
5022: break;
5023: }
5024:
5025: scan = scan->q_next;
5026:
5027: if ((scan->q_flag & QPROCSOFF) != 0)
5028: continue;
5029:
5030: if (scan->q_qinfo == module->mod_stream->st_wrinit)
5031: break;
5032: }
5033:
5034: SHEAD_UNLOCK (sheadp, prev_pl);
5035:
5036: * rvalp = scan != NULL;
5037: }
5038:
5039: return 0;
5040: }
5041:
5042:
5043: /*
5044: * This function implements the I_LIST ioctl () for the case where the user
5045: * supplies a buffer to copy the module/driver names into.
5046: */
5047:
5048: #if __USE_PROTO__
5049: __LOCAL__ int (SHEAD_LIST) (shead_t * sheadp, struct str_list * slistp,
5050: int * rvalp)
5051: #else
5052: __LOCAL__ int
5053: SHEAD_LIST __ARGS ((sheadp, slistp, rvalp))
5054: shead_t * sheadp;
5055: struct str_list
5056: * slistp;
5057: int * rvalp;
5058: #endif
5059: {
5060: queue_t * scan;
5061: int modcount;
5062: int i;
5063: struct str_mlist
5064: * buf;
5065: struct str_mlist
5066: * temp;
5067:
5068: if (slistp->sl_nmods < 1)
5069: return EINVAL;
5070:
5071: /*
5072: * The EAGAIN error documented for I_LIST in streamio (7) is
5073: * suggestive of how it is implemented; rather than get involved in
5074: * tricky synchronization issues, copy the module names into a kernel
5075: * buffer and then copy that to user level.
5076: */
5077:
5078: modcount = SHEAD_MODCOUNT (sheadp);
5079:
5080: if (modcount > slistp->sl_nmods)
5081: modcount = slistp->sl_nmods;
5082:
5083:
5084: /*
5085: * If we were paranoid, we'd user kmem_zalloc () to ensure that the
5086: * data we copy to user space contains no sensitive information. As it
5087: * happens, because of the fact we user strncpy () to fill the buffer
5088: * with data, we are guaranteed that we have overwritten all of the
5089: * contents.
5090: */
5091:
5092: if ((buf = (struct str_mlist *) kmem_alloc (modcount * sizeof (* buf),
5093: KM_SLEEP)) == NULL)
5094: return EAGAIN;
5095:
5096: /*
5097: * Now fill the buffer in by moving down the stream. We don't worry
5098: * about the race between the calculation of the buffer size and the
5099: * time we fill it in, because the problem also exists for the user;
5100: * in order to know how much space to allocate at user level, some
5101: * arrangement must have been made to ensure things are stable.
5102: */
5103:
5104: i = 0;
5105: scan = W (sheadp->sh_head);
5106: temp = buf;
5107:
5108: (void) SHEAD_LOCK (sheadp);
5109:
5110: while (scan->q_next != NULL &&
5111: ((scan->q_flag & QREADR) == (scan->q_next->q_flag & QREADR))) {
5112:
5113: scan = scan->q_next;
5114:
5115: if ((scan->q_flag & QPROCSOFF) != 0)
5116: continue;
5117:
5118: if (i ++ > modcount)
5119: break;
5120:
5121: /*
5122: * Now actually copy the module name. Note that we count on
5123: * strncpy () null-padding the target for security.
5124: */
5125:
5126: strncpy (temp->l_name, scan->q_qinfo->qi_minfo->mi_idname,
5127: sizeof (temp->l_name) - 1);
5128: temp->l_name [sizeof (temp->l_name) - 1] = 0;
5129: }
5130:
5131: SHEAD_UNLOCK (sheadp, plbase);
5132:
5133: /*
5134: * After unlocking we can safely call copyout (), which we could not
5135: * use inside the loop because it may sleep resolving a page fault.
5136: * Don't forget that copyout () is like bcopy (), not memcpy ()!
5137: */
5138:
5139: * rvalp = i;
5140:
5141: i = copyout (buf, slistp->sl_modlist, i * sizeof (* buf));
5142:
5143: kmem_free (buf, modcount * sizeof (* buf));
5144:
5145: return i == 0 ? 0 : EFAULT;
5146: }
5147:
5148:
5149: /*
5150: * This function deals with setting the stream head read mode flag bits in
5151: * M_SETOPT messages or from an I_SRDOPT ioctl ().
5152: */
5153:
5154: #if __USE_PROTO__
5155: int (SHEAD_SRDOPT) (shead_t * sheadp, int flag)
5156: #else
5157: int
5158: SHEAD_SRDOPT __ARGS ((sheadp, flag))
5159: shead_t * sheadp;
5160: int flag;
5161: #endif
5162: {
5163: int newflag;
5164:
5165: SHEAD_ASSERT_LOCKED (sheadp);
5166:
5167: if ((newflag = flag & RMODEMASK) == __RINVAL)
5168: return EINVAL;
5169:
5170: /*
5171: * The streamio (7) man pages seem ambiguous about whether an
5172: * application is permitted to, has to, or cannot diagnose a request
5173: * to set multiple read options.
5174: *
5175: * Arbitrarily, we choose not to.
5176: */
5177:
5178: newflag |= (flag & RPROTNORM) != 0 ? RPROTNORM :
5179: (flag & RPROTDAT) != 0 ? RPROTDAT :
5180: (flag & RPROTDIS) != 0 ? RPROTDIS :
5181: (sheadp->sh_readopt & ~ RMODEMASK);
5182:
5183: sheadp->sh_readopt = newflag;
5184:
5185: return 0;
5186: }
5187:
5188:
5189: /*
5190: * This table determines how many bytes to copy from user space at the start
5191: * of ioctl () processing and how many bytes to copy to user space at the end
5192: * of processing (presuming no other errors have occurred yet).
5193: */
5194:
5195: #define BADLEN ((unsigned short) -1)
5196:
5197: typedef enum {
5198: IO_NOLOCK = 0,
5199: IO_BASIC_LOCK,
5200: IO_READFREEZE,
5201: IO_SLEEP_LOCK
5202: } iolock_t;
5203:
5204: enum { NOHUP,
5205: HUP
5206: };
5207:
5208: static struct ioinfo {
5209: iolock_t lock; /* lock type */
5210: cat_t cat; /* category flag */
5211: unsigned short in_len; /* bytes to copy in */
5212: unsigned short out_len; /* bytes to copy out */
5213: unsigned char hup_chk; /* check for hangup */
5214: } _ioctl_table [] = {
5215: { IO_NOLOCK, SH_NONE, BADLEN, BADLEN, NOHUP },
5216: /* illegal */
5217: { IO_READFREEZE, SH_NONE, sizeof (size_t), NOHUP },
5218: /* I_NREAD */
5219: { IO_SLEEP_LOCK, SH_OPENCLOSE | SH_IOCTL_LOCK,
5220: FMNAMESZ + 1, 0, HUP }, /* I_PUSH */
5221: { IO_SLEEP_LOCK, SH_OPENCLOSE | SH_IOCTL_LOCK, 0, 0, HUP },
5222: /* I_POP */
5223: { IO_NOLOCK, SH_NONE, FMNAMESZ + 1, FMNAMESZ + 1, NOHUP },
5224: /* I_LOOK */
5225: { IO_NOLOCK, SH_NONE, 0, 0, HUP }, /* I_FLUSH */
5226: { IO_BASIC_LOCK, SH_NONE, 0, 0, NOHUP },/* I_SRDOPT */
5227: { IO_BASIC_LOCK, SH_NONE, 0, sizeof (int), NOHUP },
5228: /* I_GRDOPT */
5229: { IO_SLEEP_LOCK, SH_IOCTL_LOCK, sizeof (struct strioctl),
5230: sizeof (struct strioctl), HUP },/* I_STR */
5231: { IO_SLEEP_LOCK, SH_IOCTL_LOCK, 0, 0, NOHUP },
5232: /* I_SETSIG */
5233: { IO_SLEEP_LOCK, SH_IOCTL_LOCK, 0, sizeof (int), NOHUP },
5234: /* I_GETSIG */
5235: { IO_NOLOCK, SH_NONE, FMNAMESZ + 1, 0, NOHUP },
5236: /* I_FIND */
5237: { IO_SLEEP_LOCK, SH_IOCTL_LOCK, 0, 0, HUP },
5238: /* I_LINK */
5239: { IO_SLEEP_LOCK, SH_IOCTL_LOCK, 0, 0, HUP },
5240: /* I_UNLINK */
5241: { IO_SLEEP_LOCK, SH_READ_LOCK, 0, sizeof (struct strrecvfd), HUP },
5242: /* I_RECVFD */
5243: { IO_SLEEP_LOCK, SH_READ_LOCK, sizeof (struct strpeek),
5244: sizeof (struct strpeek), NOHUP },/* I_PEEK */
5245: { IO_NOLOCK, SH_NONE, sizeof (struct strfdinsert), 0, NOHUP },
5246: /* I_FDINSERT */
5247: { IO_NOLOCK, SH_NONE, 0, 0, HUP }, /* I_SENDFD */
5248: { IO_NOLOCK, SH_NONE, BADLEN, BADLEN, NOHUP },
5249: /* --- */
5250: { IO_BASIC_LOCK, SH_NONE, 0, 0, NOHUP },/* I_SWROPT */
5251: { IO_BASIC_LOCK, SH_NONE, 0, sizeof (int), NOHUP },
5252: /* I_GWROPT */
5253: { IO_NOLOCK, SH_NONE, 0, 0, NOHUP }, /* I_LIST */ /* special */
5254: { IO_BASIC_LOCK, SH_OPENCLOSE | SH_IOCTL_LOCK, 0, 0, HUP },
5255: /* I_PLINK */
5256: { IO_BASIC_LOCK, SH_OPENCLOSE | SH_IOCTL_LOCK, 0, 0, HUP },
5257: /* I_PUNLINK */
5258: { IO_NOLOCK, SH_NONE, BADLEN, BADLEN, NOHUP },
5259: /* I_SETEV */
5260: { IO_NOLOCK, SH_NONE, BADLEN, BADLEN, NOHUP },
5261: /* I_GETEV */
5262: { IO_NOLOCK, SH_NONE, BADLEN, BADLEN, NOHUP },
5263: /* I_STREV */
5264: { IO_NOLOCK, SH_NONE, BADLEN, BADLEN, NOHUP },
5265: /* I_UNSTREV */
5266: { IO_NOLOCK, SH_NONE, sizeof (struct bandinfo), 0, HUP },
5267: /* I_FLUSHBAND */
5268: { IO_READFREEZE, SH_NONE, 0, 0, NOHUP },/* I_CKBAND */
5269: { IO_READFREEZE, SH_NONE, 0, sizeof (int), NOHUP },
5270: /* I_GETBAND */
5271: { IO_READFREEZE, SH_NONE, 0, 0, NOHUP },/* I_ATMARK */
5272: { IO_BASIC_LOCK, SH_NONE, sizeof (__clock_t), 0, NOHUP },
5273: /* I_SETCLTIME */
5274: { IO_BASIC_LOCK, SH_NONE, 0, sizeof (__clock_t), NOHUP },
5275: /* I_GETCLTIME */
5276: { IO_NOLOCK, SH_NONE, 0, 0, HUP } /* I_CANPUT */
5277: };
5278:
5279: struct ioinfo _transparent = {
5280: IO_SLEEP_LOCK, SH_IOCTL_LOCK, 0, 0, HUP
5281: };
5282:
5283:
5284: /*
5285: * Symbol for accessing the default ioctl () and close timeouts. Consider
5286: * making this a static variable and initializing it at boot time.
5287: */
5288:
5289: #define IOCTL_TIMEOUT drv_usectohz ((__clock_t) 15000000L)
5290:
5291:
5292: /*
5293: * Main ioctl () processing for STREAMS files and pipes.
5294: *
5295: * This switch+table is an abomination, but trying to emulate C++ style in C
5296: * to subsume the switch and the above table would probably kill me. This
5297: * probably is about as short as it can really be.
5298: */
5299:
5300: #if __USE_PROTO__
5301: int (STREAMS_IOCTL) (shead_t * sheadp, int cmd, _VOID * arg, int mode,
5302: cred_t * credp, int * rvalp)
5303: #else
5304: int
5305: STREAMS_IOCTL (sheadp, cmd, arg, mode, credp, rvalp)
5306: shead_t * sheadp;
5307: int cmd;
5308: _VOID * arg;
5309: int mode;
5310: cred_t * credp;
5311: int * rvalp;
5312: #endif
5313: {
5314: union {
5315: int i_int;
5316: __clock_t i_clock;
5317: size_t i_size;
5318: char i_modname [FMNAMESZ + 1];
5319: struct strioctl i_strioc;
5320: struct strrecvfd i_recvfd;
5321: struct strbuf i_strbuf;
5322: struct strfdinsert
5323: i_fdinsert;
5324: struct str_list i_list;
5325: struct bandinfo i_band;
5326: struct strpeek i_peek;
5327: } iocbuf;
5328: int retval;
5329: struct ioinfo * info;
5330:
5331: ASSERT (sheadp != NULL);
5332:
5333: /*
5334: * We start out by copying in the data specified by the table, which
5335: * means we also get to range-check the ioctl entry if it has the
5336: * magic STREAMS id.
5337: */
5338:
5339: if ((cmd & ~ 0xFF) == STREAM_I) {
5340: int index = cmd & 0xFF;
5341:
5342: if (index >= sizeof (_ioctl_table) / sizeof (* info))
5343: return EINVAL;
5344:
5345: info = & _ioctl_table [index];
5346: } else
5347: info = & _transparent;
5348:
5349: if (info->in_len == BADLEN)
5350: return EINVAL;
5351:
5352: /*
5353: * We *must* do the copy before the lock! Never forget that
5354: * copyin ()/copyout () can block in page fault resolution.
5355: */
5356:
5357: if (info->in_len > 0 && copyin (arg, & iocbuf, info->in_len) != 0)
5358: return EFAULT;
5359:
5360: /*
5361: * We may wish to check for a hangup or error before proceeding.
5362: */
5363:
5364: (void) SHEAD_LOCK (sheadp);
5365:
5366: if (info->hup_chk == HUP &&
5367: (retval = SHEAD_ERRHUP_LOCKED (sheadp, mode)) != 0)
5368: return ENXIO;
5369:
5370: if (info->lock != IO_BASIC_LOCK)
5371: SHEAD_UNLOCK (sheadp, plbase);
5372:
5373: switch (info->lock) {
5374:
5375: case IO_BASIC_LOCK:
5376: /* stay holding on to the basic lock */
5377: break;
5378:
5379: case IO_READFREEZE:
5380: (void) QFREEZE_TRACE (sheadp->sh_head, "STREAMS_IOCTL");
5381: break;
5382:
5383: case IO_SLEEP_LOCK:
5384: if ((retval = SHEAD_SLEEP_LOCK (sheadp, info->cat,
5385: IOCTL_TIMEOUT,
5386: CHECK_SIGNALS)) != 0)
5387: return retval;
5388: break;
5389:
5390: default:
5391: break;
5392: }
5393:
5394: retval = 0;
5395:
5396: switch (cmd) {
5397:
5398: case I_NREAD: /* Get message length, count */
5399: {
5400: mblk_t * scan;
5401: mblk_t * first = NULL;
5402:
5403: * rvalp = 0;
5404:
5405: for (scan = SHEAD_FIRSTMSG (sheadp) ; scan != NULL ;
5406: scan = scan->b_next) {
5407:
5408: if (datamsg (scan->b_datap->db_type)) {
5409:
5410: if (first == NULL)
5411: first = scan;
5412: (* rvalp) ++;
5413: }
5414: }
5415:
5416: if (first != NULL)
5417: iocbuf.i_int = msgdsize (first);
5418: else
5419: iocbuf.i_int = 0;
5420: }
5421: break;
5422:
5423: case I_PUSH: /* push named module */
5424: {
5425: modsw_t * module;
5426:
5427: if ((module = FIND_MODULE (iocbuf.i_modname)) == NULL)
5428: retval = EINVAL;
5429: else
5430: retval = PUSH_MODULE (sheadp, mode, credp,
5431: module);
5432: }
5433: break;
5434:
5435: case I_POP: /* pop topmost module */
5436: {
5437: queue_t * q;
5438:
5439: if ((q = TOP_MODULE (sheadp)) == NULL)
5440: retval = EINVAL;
5441: else
5442: retval = POP_MODULE (sheadp, q, mode, credp);
5443: }
5444: break;
5445:
5446: case I_LOOK: /* get topmost module name */
5447: {
5448: queue_t * q;
5449:
5450: if ((q = TOP_MODULE (sheadp)) == NULL)
5451: retval = EINVAL;
5452: else {
5453: /*
5454: * Copy the module name, taking care to
5455: * 0-terminate it at FMNAMESZ bytes long.
5456: */
5457:
5458: strncpy (iocbuf.i_modname,
5459: q->q_qinfo->qi_minfo->mi_idname,
5460: FMNAMESZ);
5461: iocbuf.i_modname [FMNAMESZ] = 0;
5462: }
5463: }
5464: break;
5465:
5466: case I_FLUSH: /* flush read and/or write side */
5467: retval = SHEAD_FLUSH (sheadp, (int) arg, 0);
5468: break;
5469:
5470: case I_SRDOPT: /* set read options */
5471: retval = SHEAD_SRDOPT (sheadp, (int) arg);
5472: break;
5473:
5474: case I_GRDOPT: /* retrieve read options */
5475: iocbuf.i_int = sheadp->sh_readopt;
5476: break;
5477:
5478: case I_STR: /* send ioctl () data down a stream */
5479: if ((iocbuf.i_strioc.ic_cmd & ~ 0xFF) == STREAM_I ||
5480: (unsigned) iocbuf.i_strioc.ic_len == TRANSPARENT) {
5481: /*
5482: * We do not permit I_STR to send STREAMS ioctl ()
5483: * codes downstream; in certain cases such as I_LINK
5484: * this could produce disastrous results.
5485: *
5486: * We also do not permit TRANSPARENT length I_STR
5487: * messages. While the STREAMS documentation neither
5488: * explicitly permits or forbids this, we keep the
5489: * transparent ioctl () behaviour separate.
5490: */
5491:
5492: retval = EINVAL;
5493: break;
5494:
5495: }
5496:
5497: retval = ISTR_IOCTL (sheadp, mode, & iocbuf.i_strioc, credp,
5498: rvalp);
5499: break;
5500:
5501: case I_SETSIG: /* register events for SIGPOLL signal */
5502: {
5503: int events = (short) (ulong_t) arg;
5504:
5505: if ((events & ~ __POLL_MASK) != 0)
5506: retval = EINVAL;
5507: else
5508: retval = REGISTER_SIGPOLL (sheadp, events);
5509: }
5510: break;
5511:
5512: case I_GETSIG: /* return registered event mask */
5513: {
5514: sigpoll_t * sigs;
5515:
5516: if ((sigs = FIND_SIGPOLL (sheadp)) == NULL)
5517: retval = EINVAL;
5518: else
5519: * rvalp = sigs->sp_events;
5520: }
5521: break;
5522:
5523: case I_FIND: /* determine if module exists on stream */
5524: retval = SHEAD_FIND_MODINFO (sheadp, iocbuf.i_modname, rvalp);
5525: break;
5526:
5527: case I_LINK: /* link stream below another */
5528: case I_PLINK: /* create a persistent link */
5529: {
5530: shead_t * lower;
5531:
5532: if ((lower = FH_TO_STREAM ((int) arg,
5533: & retval)) != NULL) {
5534: retval = SHEAD_LINK (sheadp, mode, lower, cmd,
5535: credp);
5536:
5537: if (retval == 0)
5538: * rvalp = lower->sh_muxid;
5539: }
5540: }
5541: break;
5542:
5543: case I_UNLINK: /* remove a (or all) link(s) below a stream */
5544: case I_PUNLINK: /* undo a single or all persistent link(s) */
5545: do {
5546: shead_t * lower;
5547:
5548: if ((lower = SHEAD_FIND_MUXID (sheadp, cmd,
5549: (int) arg)) == NULL) {
5550: /*
5551: * We return EINVAL if a specific mux ID was
5552: * given, 0 otherwise.
5553: */
5554:
5555: retval = (int) arg == -1 ? 0 : EINVAL;
5556: break;
5557:
5558: }
5559:
5560: (void) SHEAD_UNLINK (sheadp, lower, cmd, mode, credp,
5561: & retval);
5562: } while ((int) arg == -1);
5563: break;
5564:
5565: case I_RECVFD: /* receive a file descriptor from stream */
5566: retval = FH_RECV (sheadp, mode, & iocbuf.i_recvfd);
5567: break;
5568:
5569: case I_PEEK: /* examine data at stream head */
5570: retval = SHEAD_PEEK (sheadp, & iocbuf.i_peek, rvalp);
5571: break;
5572:
5573: case I_FDINSERT: /* send read queue pointer down stream */
5574: retval = SHEAD_FDINSERT (sheadp, mode, & iocbuf.i_fdinsert);
5575: break;
5576:
5577: case I_SENDFD: /* send a file descriptor down a pipe */
5578: retval = FH_SEND (sheadp, (int) arg, credp);
5579: break;
5580:
5581: case I_SWROPT: /* set write options for stream */
5582: {
5583: int flag = (int) arg;
5584:
5585: if ((flag & ~ SNDZERO) != 0)
5586: retval = EINVAL;
5587: else
5588: sheadp->sh_wropt = flag;
5589: }
5590: break;
5591:
5592: case I_GWROPT: /* retrieve write options for stream */
5593: iocbuf.i_int = sheadp->sh_wropt;
5594: break;
5595:
5596: case I_LIST: /* get names of all modules/drivers */
5597: /*
5598: * The value of "arg" is a pointer to a structure for this
5599: * entry, but since a NULL value is legal we don't copy the
5600: * data in automatically.
5601: *
5602: * Here we select the call type and copy in the structure for
5603: * the non-NULL case.
5604: */
5605:
5606: if (arg == NULL)
5607: * rvalp = SHEAD_MODCOUNT (sheadp);
5608: else if (copyin (arg, & iocbuf, sizeof (iocbuf.i_list)) != 0)
5609: retval = EFAULT;
5610: else
5611: retval = SHEAD_LIST (sheadp, & iocbuf.i_list, rvalp);
5612: break;
5613:
5614: case I_SETEV: /* The meaning of these ioctl ()'s is not */
5615: case I_GETEV: /* documented, although their names and */
5616: case I_STREV: /* numeric values are given in the System */
5617: case I_UNSTREV: /* V ABI. */
5618: retval = EINVAL;
5619: break;
5620:
5621: case I_FLUSHBAND: /* flush messages in a priority band */
5622: retval = SHEAD_FLUSH (sheadp, iocbuf.i_band.bi_flag,
5623: iocbuf.i_band.bi_pri);
5624: break;
5625:
5626: case I_CKBAND: /* check for existence of band on stream */
5627: if ((uchar_t) (ulong_t) arg != (ulong_t) arg)
5628: retval = EINVAL;
5629: else {
5630: mblk_t * scan;
5631:
5632: for (scan = SHEAD_FIRSTMSG (sheadp) ; scan != NULL ;
5633: scan = scan->b_next)
5634: if (datamsg (scan->b_datap->db_type) &&
5635: scan->b_band == (uchar_t) (ulong_t) arg)
5636: break;
5637:
5638: * rvalp = scan != NULL;
5639: }
5640: break;
5641:
5642: case I_GETBAND: /* get the band number of the first message */
5643: {
5644: mblk_t * scan;
5645:
5646: for (scan = SHEAD_FIRSTMSG (sheadp) ; scan != NULL ;
5647: scan = scan->b_next) {
5648:
5649: if (datamsg (scan->b_datap->db_type))
5650: break;
5651: }
5652:
5653: if (scan == NULL)
5654: retval = ENODATA;
5655: else
5656: iocbuf.i_int = scan->b_band;
5657: }
5658: break;
5659:
5660: case I_ATMARK: /* test for (last) mark on messages */
5661: {
5662: mblk_t * scan = SHEAD_FIRSTMSG (sheadp);
5663:
5664: if ((ulong_t) arg != ANYMARK &&
5665: (ulong_t) arg != LASTMARK) {
5666:
5667: retval = EINVAL;
5668: break;
5669: }
5670:
5671: if (scan == NULL || (scan->b_flag & MSGMARK) == 0) {
5672:
5673: * rvalp = 0;
5674: break;
5675: }
5676:
5677: * rvalp = 1;
5678:
5679: if ((ulong_t) arg == LASTMARK)
5680: while ((scan = scan->b_next) != NULL)
5681: if ((scan->b_flag & MSGMARK) != 0) {
5682: * rvalp = 0;
5683: break;
5684: }
5685: }
5686: break;
5687:
5688: case I_SETCLTIME: /* set close timeout for stream */
5689: if (iocbuf.i_clock != 0)
5690: sheadp->sh_cltime = iocbuf.i_clock;
5691: else
5692: retval = EINVAL;
5693: break;
5694:
5695: case I_GETCLTIME: /* retrieve current close timeout */
5696: iocbuf.i_clock = sheadp->sh_cltime;
5697: break;
5698:
5699: case I_CANPUT: /* test if band is writeable */
5700: if ((uchar_t) (ulong_t) arg != (ulong_t) arg)
5701: retval = EINVAL;
5702: else
5703: * rvalp = bcanputnext (W (sheadp->sh_head),
5704: (uchar_t) (ulong_t) arg);
5705: break;
5706:
5707: default:
5708: ASSERT (info == & _transparent);
5709:
5710: retval = TRANSPARENT_IOCTL (sheadp, mode, cmd, arg, credp,
5711: rvalp);
5712: break;
5713: }
5714:
5715:
5716: /*
5717: * Perform any necessary unlocking operations and copy back any
5718: * results into the data area pointed to by "arg" (if this is a
5719: * STREAMS-specific ioctl ()).
5720: */
5721:
5722: switch (info->lock) {
5723:
5724: case IO_BASIC_LOCK:
5725: SHEAD_UNLOCK (sheadp, plbase);
5726: break;
5727:
5728: case IO_READFREEZE:
5729: (void) QUNFREEZE_TRACE (sheadp->sh_head, plbase);
5730: break;
5731:
5732: case IO_SLEEP_LOCK:
5733: SHEAD_SLEEP_UNLOCK (sheadp, info->cat);
5734: break;
5735:
5736: default:
5737: break;
5738: }
5739:
5740:
5741: /*
5742: * We only copy out results if there is no error. We have to
5743: * do this *after* unlocking, above; copyout () can block in
5744: * page fault resolution!
5745: */
5746:
5747: if (retval == 0 && info->out_len > 0 &&
5748: copyout (& iocbuf, arg, info->out_len) != 0)
5749: retval = EFAULT;
5750:
5751: return retval;
5752: }
5753:
5754:
5755: /*
5756: * Helper function to atomically read the stream head read options.
5757: */
5758:
5759: #if __USE_PROTO__
5760: __LOCAL__ short (SHEAD_READOPT) (shead_t * sheadp)
5761: #else
5762: __LOCAL__ short
5763: SHEAD_READOPT __ARGS ((sheadp))
5764: shead_t * sheadp;
5765: #endif
5766: {
5767: pl_t prev_pl;
5768: short opt;
5769:
5770: prev_pl = SHEAD_LOCK (sheadp);
5771:
5772: opt = sheadp->sh_readopt;
5773:
5774: SHEAD_UNLOCK (sheadp, prev_pl);
5775:
5776: return opt;
5777: }
5778:
5779:
5780: /*
5781: * Stream head user-level getmsg () processing.
5782: *
5783: * This is way too many parameters; this should be bundled into a block like
5784: * the "uio" structure is.
5785: */
5786:
5787: #if __USE_PROTO__
5788: int (STREAMS_GETPMSG) (shead_t * sheadp, struct strbuf * ctlbuf,
5789: struct strbuf * databuf, int * bandp, int * flagsp,
5790: int mode, int * rvalp)
5791: #else
5792: int
5793: STREAMS_GETPMSG __ARGS ((sheadp, ctlbuf, databuf, bandp, flagsp, mode, rvalp))
5794: shead_t * sheadp;
5795: int mode;
5796: struct strbuf * ctlbuf;
5797: struct strbuf * databuf;
5798: int * bandp;
5799: int * flagsp;
5800: int * rvalp;
5801: #endif
5802: {
5803: mblk_t * msg;
5804: mblk_t * scan;
5805: int retval;
5806:
5807: if ((mode & FREAD) == 0)
5808: return EBADF;
5809:
5810: mode &= ~ FWRITE;
5811:
5812:
5813: /*
5814: * As discussed in the general comment on read synchronization and in
5815: * the I_PEEK documentation, there are some warts when it comes to
5816: * read locking. Here we can solve things by dequeueing a message,
5817: * modifying at, and writing it back without worrying about any nasty
5818: * unintended effects.
5819: *
5820: * Because getmsg ()/getpmsg () always honours message boundaries,
5821: * there is no real value in single-threading this.
5822: */
5823:
5824: /*
5825: * Look at the stream head to see if a message is present. Note that
5826: * we freeze the read queue before acquiring the stream head basic
5827: * lock because that's our canonical ordering.
5828: */
5829:
5830: for (;;) {
5831: (void) QFREEZE_TRACE (sheadp->sh_head, "SHEAD_GETPMSG");
5832:
5833: (void) SHEAD_LOCK (sheadp);
5834:
5835: if ((retval = SHEAD_ERRHUP_LOCKED (sheadp, FREAD)) != 0) {
5836:
5837: QUNFREEZE_TRACE (sheadp->sh_head, plbase);
5838: return retval;
5839: }
5840:
5841:
5842: if ((msg = SHEAD_FIRSTMSG (sheadp)) != NULL) {
5843:
5844: switch (msg->b_datap->db_type) {
5845:
5846: case M_DATA:
5847: case M_PROTO:
5848:
5849: if (* flagsp == MSG_HIPRI ||
5850: (* flagsp == MSG_BAND &&
5851: msg->b_band < * bandp)) {
5852:
5853: sheadp->sh_head->q_lastband =
5854: msg->b_band;
5855: msg = NULL;
5856: break;
5857: }
5858:
5859: /* FALL THROUGH */
5860:
5861: case M_PCPROTO:
5862: rmvq (sheadp->sh_head, msg);
5863: break;
5864:
5865: default:
5866: retval = EBADMSG;
5867: break;
5868: }
5869: }
5870:
5871: QUNFREEZE_TRACE (sheadp->sh_head, plbase);
5872:
5873: if (retval != 0)
5874: return retval;
5875:
5876: if (msg != NULL)
5877: break;
5878:
5879: /*
5880: * We need to wait (unless O_NDELAY or O_NONBLOCK has been
5881: * specified). We don't wait any more if the stream has been
5882: * hung up.
5883: */
5884:
5885: if (SHEAD_HANGUP (sheadp)) {
5886: /*
5887: * Hangups are not an error for getpmsg ().
5888: */
5889:
5890: if (ctlbuf != NULL)
5891: ctlbuf->len = 0;
5892: if (databuf != NULL)
5893: databuf->len = 0;
5894:
5895: * rvalp = 0;
5896: return 0;
5897: }
5898:
5899: if ((retval = SHEAD_WAIT_NONBLOCK (sheadp, FREAD,
5900: SH_READ_WAIT,
5901: CHECK_SIGNALS)) != 0)
5902: return retval;
5903: }
5904:
5905:
5906: /*
5907: * After this point, "msg" is our responsibility and we either have to
5908: * free it or put it back if there is an error.
5909: */
5910:
5911: * bandp = msg->b_band;
5912: * flagsp = msg->b_datap->db_type == M_PCPROTO ? MSG_HIPRI : MSG_BAND;
5913:
5914: retval = (COPYOUT_BUF (ctlbuf, & msg, CONTROL_PART) != 0 ||
5915: COPYOUT_BUF (databuf, & msg,
5916: DATA_PART) != 0) ? EFAULT : 0;
5917:
5918: /*
5919: * Formulate a return mask indicating what components of the message
5920: * being transferred have not been fully consumed.
5921: */
5922:
5923: * rvalp = 0;
5924:
5925: for (scan = msg ; scan != NULL ; scan = scan->b_cont)
5926: * rvalp |= scan->b_datap->db_type == M_DATA ? MOREDATA
5927: : MORECTL;
5928:
5929: if (msg != NULL)
5930: putbq (sheadp->sh_head, msg);
5931:
5932: return retval;
5933: }
5934:
5935:
5936: /*
5937: * In order to keep the logic of SHEAD_READ () manageable, this section of
5938: * code has been factored into a separate function. Here we wait for data to
5939: * become available at the stream head for reading.
5940: *
5941: * We return 0 on success, or an error number on failure. The value of "mpp"
5942: * is only valid if 0 is returned.
5943: */
5944:
5945: #if __USE_PROTO__
5946: __LOCAL__ int (SHEAD_READ_DATA) (shead_t * sheadp, int mode, mblk_t ** mpp,
5947: int resid)
5948: #else
5949: __LOCAL__ int
5950: SHEAD_READ_DATA __ARGS ((sheadp, mode, mpp, resid))
5951: shead_t * sheadp;
5952: int mode;
5953: mblk_t ** mpp;
5954: int resid;
5955: #endif
5956: {
5957: int retval;
5958:
5959: for (;;) {
5960: (void) QFREEZE_TRACE (sheadp->sh_head, "SHEAD_READ");
5961:
5962: (void) SHEAD_LOCK (sheadp);
5963:
5964: if ((retval = SHEAD_ERRHUP_LOCKED (sheadp, FREAD)) != 0) {
5965:
5966: QUNFREEZE_TRACE (sheadp->sh_head, plbase);
5967: return retval;
5968: }
5969:
5970:
5971: if ((* mpp = SHEAD_FIRSTMSG (sheadp)) != NULL) {
5972:
5973: switch ((* mpp)->b_datap->db_type) {
5974:
5975: case M_PROTO:
5976: case M_PCPROTO:
5977: /*
5978: * These are valid depending on the read mode
5979: * of the stream.
5980: */
5981:
5982: if ((sheadp->sh_readopt & RPROTNORM) != 0) {
5983:
5984: retval = EBADMSG;
5985: break;
5986: }
5987:
5988: /* FALL THROUGH */
5989:
5990: case M_DATA:
5991: rmvq (sheadp->sh_head, * mpp);
5992: break;
5993:
5994: default:
5995: retval = EBADMSG;
5996: break;
5997: }
5998: }
5999:
6000: QUNFREEZE_TRACE (sheadp->sh_head, plbase);
6001:
6002: if (retval != 0 || * mpp != NULL) {
6003:
6004: SHEAD_UNLOCK (sheadp, plbase);
6005: return retval;
6006: }
6007:
6008:
6009: /*
6010: * Since we are going to sleep on a read (), this is the place
6011: * to generate M_READ messages if that is how this stream has
6012: * been configured.
6013: *
6014: * If we can't generate an M_READ message, schedule a bufcall.
6015: * If we can't do that, return EAGAIN???
6016: */
6017:
6018: if (SHEAD_READMSG (sheadp)) {
6019: mblk_t * msg;
6020:
6021: if ((msg = MSGB_ALLOC (sizeof (int), BPRI_LO,
6022: KM_NOSLEEP)) == NULL) {
6023: /*
6024: * Execute a short wait for buffer memory for
6025: * the M_READ, then retry the loop. Note that
6026: * SHEAD_READ_BUFCALL () unlocks the stream
6027: * head for us.
6028: */
6029:
6030: if ((retval = SHEAD_READ_BUFCALL (sheadp,
6031: mode)) != 0)
6032: return retval;
6033:
6034: continue;
6035: }
6036:
6037: msg->b_datap->db_type = M_READ;
6038: * (int *) msg->b_rptr = resid;
6039: msg->b_wptr += sizeof (int);
6040:
6041: putq (W (sheadp->sh_head), msg);
6042: }
6043:
6044: if ((retval = SHEAD_WAIT_NONBLOCK (sheadp, mode, SH_READ_WAIT,
6045: CHECK_SIGNALS)) != 0)
6046: return retval;
6047: }
6048:
6049: }
6050:
6051:
6052: /*
6053: * In order to keep the logic of SHEAD_READ () manageable, this section of
6054: * code has been factored into this routine, which manages the transfer of
6055: * message data to the user.
6056: *
6057: * We return EAGAIN to the user if more data needs to be read, 0 if the read
6058: * has successfully completed, or some other error number on failure.
6059: */
6060:
6061: #if __USE_PROTO__
6062: __LOCAL__ int (SHEAD_READ_MOVE) (shead_t * sheadp, uio_t * uiop,
6063: mblk_t * msg)
6064: #else
6065: __LOCAL__ int
6066: SHEAD_READ_MOVE __ARGS ((sheadp, uiop, msg))
6067: shead_t * sheadp;
6068: uio_t * uiop;
6069: mblk_t * msg;
6070: #endif
6071: {
6072: int readopt = SHEAD_READOPT (sheadp);
6073: mblk_t * scan;
6074:
6075: if ((readopt & RMODEMASK) == RNORM &&
6076: (msg->b_cont == NULL && msg->b_rptr == msg->b_wptr)) {
6077: /*
6078: * We have run into a zero-length message. Put it
6079: * back and terminate the read.
6080: */
6081:
6082: putbq (sheadp->sh_head, msg);
6083: return 0;
6084: }
6085:
6086: if ((readopt & RPROTDIS) != 0) {
6087:
6088: while (msg != NULL && msg->b_datap->db_type != M_DATA) {
6089: /*
6090: * Consume the control part of the message.
6091: */
6092:
6093: scan = msg->b_cont;
6094: freeb (msg);
6095: msg = scan;
6096: }
6097:
6098: if (msg == NULL)
6099: return EAGAIN;
6100: }
6101:
6102:
6103: /*
6104: * Actual data transfer time; copy each message segment to the user
6105: * with uiomove ().
6106: */
6107:
6108: do {
6109: size_t unit = msg->b_wptr - msg->b_rptr;
6110:
6111: if (unit > uiop->uio_resid)
6112: unit = uiop->uio_resid;
6113:
6114: if (unit > 0 &&
6115: uiomove (msg->b_rptr, unit, UIO_READ, uiop) != 0) {
6116: /*
6117: * Address fault time. But first, put back the data.
6118: */
6119:
6120: putbq (sheadp->sh_head, msg);
6121:
6122: return EFAULT;
6123: }
6124:
6125: msg->b_rptr += unit;
6126:
6127: if (msg->b_wptr != msg->b_rptr) {
6128: /*
6129: * Since we didn't finish this message block, we must
6130: * be finished with the read (). If we are in message-
6131: * discard mode we throw away the remaining data.
6132: */
6133:
6134: ASSERT (uiop->uio_resid == 0);
6135:
6136: if ((readopt & RMODEMASK) == RMSGD)
6137: freemsg (msg);
6138: else
6139: putbq (sheadp->sh_head, msg);
6140:
6141: return 0;
6142: }
6143:
6144: scan = msg->b_cont;
6145: freeb (msg);
6146: } while ((msg = scan) != NULL);
6147:
6148:
6149: /*
6150: * We have run out of message; what now? If in byte-stream mode, look
6151: * for more data, otherwise exit.
6152: */
6153:
6154: return (readopt & RMODEMASK) == RNORM ? EAGAIN : 0;
6155: }
6156:
6157:
6158: /*
6159: * Stream head user-level read processing.
6160: *
6161: * I apologise for the abysmal structure of this code; the gotos should be
6162: * replaced by proper loops and the major subsections factored into auxiliary
6163: * functions, but this code is the victim of time pressure and several
6164: * rewrites. By all means encourage the author to improve this in case he has
6165: * forgotten to come back and fix it.
6166: */
6167:
6168: #if __USE_PROTO__
6169: int (STREAMS_READ) (shead_t * sheadp, uio_t * uiop)
6170: #else
6171: int
6172: STREAMS_READ __ARGS ((sheadp, uiop))
6173: shead_t * sheadp;
6174: uio_t * uiop;
6175: #endif
6176: {
6177: mblk_t * msg;
6178: int retval;
6179: int mode;
6180: int readcount = uiop->uio_resid;
6181:
6182: if ((uiop->uio_fmode & FREAD) == 0)
6183: return EBADF;
6184:
6185: mode = uiop->uio_fmode & ~ FWRITE;
6186:
6187:
6188: /*
6189: * We (optionally) take out a lock on the stream head to single-thread
6190: * reads. This is important because in byte-stream mode we may want
6191: * to guarantee atomicity of reads. This is only relevant to byte-
6192: * stream mode because modes which honor message boundaries cannot
6193: * be protected against multiple readers anyway.
6194: */
6195:
6196: if ((retval = SHEAD_SLEEP_LOCK (sheadp, SH_READ_LOCK, 0,
6197: CHECK_SIGNALS)) != 0)
6198: return retval;
6199:
6200: do {
6201: if ((retval = SHEAD_READ_DATA (sheadp, mode, & msg,
6202: uiop->uio_resid)) != 0)
6203: break;
6204:
6205: /*
6206: * After this point, "msg" is our responsibility and we either
6207: * have to free it or put it back if there is an error.
6208: */
6209:
6210: } while ((retval = SHEAD_READ_MOVE (sheadp, uiop, msg)) == EAGAIN);
6211:
6212:
6213: /*
6214: * If a partial read has been done, we return a short read rather than
6215: * reporting an error immediately.
6216: */
6217:
6218: if (retval != 0 && readcount != uiop->uio_resid)
6219: retval = 0;
6220:
6221: SHEAD_SLEEP_UNLOCK (sheadp, SH_READ_LOCK);
6222: return retval;
6223: }
6224:
6225:
6226: /*
6227: * Helper function to atomically read the stream head write options.
6228: */
6229:
6230: #if __USE_PROTO__
6231: __LOCAL__ short (SHEAD_WRITEOPT) (shead_t * sheadp)
6232: #else
6233: __LOCAL__ short
6234: SHEAD_WRITEOPT __ARGS ((sheadp))
6235: shead_t * sheadp;
6236: #endif
6237: {
6238: pl_t prev_pl;
6239: short opt;
6240:
6241: prev_pl = SHEAD_LOCK (sheadp);
6242:
6243: opt = sheadp->sh_wropt;
6244:
6245: SHEAD_UNLOCK (sheadp, prev_pl);
6246:
6247: return opt;
6248: }
6249:
6250:
6251: /*
6252: * Stream head user level putpmsg () processing. As with getmsg (), there are
6253: * enough parameters being passed that this should be abstracted into a
6254: * structure like uio(D4DK).
6255: */
6256:
6257: #if __USE_PROTO__
6258: int (STREAMS_PUTPMSG) (shead_t * sheadp, struct strbuf * ctlbuf,
6259: struct strbuf * databuf, int band, int flags,
6260: int mode, int * rvalp)
6261: #else
6262: int
6263: STREAMS_PUTPMSG __ARGS ((sheadp, ctlbuf, databuf, band, flags, mode, rvalp))
6264: shead_t * sheadp;
6265: int mode;
6266: struct strbuf * ctlbuf;
6267: struct strbuf * databuf;
6268: int band;
6269: int flags;
6270: int * rvalp;
6271: #endif
6272: {
6273: mblk_t * msg;
6274: int retval;
6275:
6276: /*
6277: * Make a message (possibly high-priority). This can fail if the
6278: * requested message is too large for the advertised limits set by the
6279: * next thing downstream. SHEAD_MAKEMSG () also checks for error and
6280: * hangup conditions, FNDELAY/FNONBLOCK, and flow control.
6281: */
6282:
6283: msg = SHEAD_MAKEMSG (sheadp, mode, ctlbuf, databuf, flags, band,
6284: & retval);
6285:
6286: if (msg == NULL)
6287: return retval;
6288:
6289: /*
6290: * Note that we don't recheck for hangups even though we could have
6291: * waited a poentially long time in SHEAD_MAKEMSG (). The hangup
6292: * condition has plenty of slop in it with the time it takes write
6293: * messages to move down the queue anyway; drivers and modules have to
6294: * be able to cope.
6295: */
6296:
6297: putq (W (sheadp->sh_head), msg);
6298:
6299: * rvalp = 0;
6300: return 0;
6301: }
6302:
6303:
6304: /*
6305: * Stream head user-level write processing.
6306: *
6307: * I apologise for the abysmal structure of this code; the gotos should be
6308: * replaced by proper loops and the major subsections factored into auxiliary
6309: * functions, but this code is the victim of time pressure and several
6310: * rewrites. By all means encourage the author to improve this in case he has
6311: * forgotten to come back and fix it.
6312: */
6313:
6314: #if __USE_PROTO__
6315: int (STREAMS_WRITE) (shead_t * sheadp, uio_t * uiop)
6316: #else
6317: int
6318: STREAMS_WRITE __ARGS ((sheadp, uiop))
6319: shead_t * sheadp;
6320: uio_t * uiop;
6321: #endif
6322: {
6323: queue_t * q;
6324: short wropt = SHEAD_WRITEOPT (sheadp);
6325: mblk_t * datamsg;
6326: int datasize;
6327: int wroff;
6328: int retval;
6329: int mode;
6330: int writecount;
6331:
6332: if ((uiop->uio_fmode & FWRITE) == 0)
6333: return EBADF;
6334:
6335: mode = uiop->uio_fmode & ~ FREAD;
6336:
6337:
6338: /*
6339: * Deal with the zero-length-message special case.
6340: */
6341:
6342: if ((writecount = uiop->uio_resid) == 0 && (wropt & SNDZERO) == 0)
6343: return 0;
6344:
6345: /*
6346: * Unlike putmsg ()/putpmsg (), write () can potentially spread the
6347: * data it writes over multiple messages and take a considerable time
6348: * to do it, we allow for the possibility of locking the stream head
6349: * so that only one write () is in progress at any time.
6350: *
6351: * The primary purpose of this is to allow PIPE_BUF to be effectively
6352: * unlimited. This is an experimental idea, though.
6353: */
6354:
6355: if ((retval = SHEAD_SLEEP_LOCK (sheadp, SH_WRITE_LOCK, 0,
6356: CHECK_SIGNALS)) != 0)
6357: return retval;
6358:
6359: wroff = SHEAD_WRITEOFFSET (sheadp);
6360:
6361: q = TOP_QUEUE (sheadp);
6362:
6363: do {
6364:
6365: if ((datasize = uiop->uio_resid) + wroff > q->q_maxpsz) {
6366: /*
6367: * Special case (documented on the write (2) manual
6368: * page; if we can't fit within the max/min range and
6369: * the minimum is greater than 0, return ERANGE.
6370: */
6371:
6372: if (q->q_minpsz > 0) {
6373:
6374: retval = ERANGE;
6375: break;
6376: }
6377:
6378: datasize = q->q_maxpsz - wroff;
6379: } else if (datasize + wroff < q->q_minpsz) {
6380:
6381: retval = ERANGE;
6382: break;
6383: }
6384:
6385:
6386: /*
6387: * Let's see if the stream is flow controlled; if it is, we
6388: * either block or return EAGAIN depending on the
6389: * FNDELAY/FNONBLOCK setting.
6390: */
6391:
6392: if ((retval = SHEAD_WRITE_TEST (sheadp, mode, 0, 0)) != 0)
6393: break;
6394:
6395: if ((datamsg = MSGB_ALLOC (datasize + wroff, BPRI_LO,
6396: KM_SLEEP)) == NULL) {
6397: retval = ENOSR;
6398: break;
6399: }
6400:
6401: datamsg->b_wptr = datamsg->b_rptr = datamsg->b_rptr + wroff;
6402:
6403: if (datasize > 0 &&
6404: uiomove (datamsg->b_rptr, datasize, UIO_WRITE,
6405: uiop) != 0) {
6406:
6407: freemsg (datamsg);
6408:
6409: retval = EFAULT;
6410: break;
6411: }
6412:
6413: datamsg->b_wptr += datasize;
6414:
6415: /*
6416: * Now do the write, and see if there is more data.
6417: */
6418:
6419: putq (W (sheadp->sh_head), datamsg);
6420:
6421: } while (uiop->uio_resid > 0);
6422:
6423:
6424: /*
6425: * If there has been an error after some data was actually written
6426: * we return a short read rather than report the error immediately.
6427: */
6428:
6429: if (retval != 0 && uiop->uio_resid != writecount)
6430: retval = 0;
6431:
6432: SHEAD_SLEEP_UNLOCK (sheadp, SH_WRITE_LOCK);
6433: return retval;
6434: }
6435:
6436:
6437: /*
6438: * Stream head user-level open processing.
6439: */
6440:
6441: extern struct streamtab headinfo;
6442:
6443: #if __USE_PROTO__
6444: int (STREAMS_OPEN) (n_dev_t * devp, struct streamtab * stabp, int mode,
6445: cred_t * credp)
6446: #else
6447: int
6448: STREAMS_OPEN (devp, stabp, mode, credp)
6449: n_dev_t * devp;
6450: struct streamtab
6451: * stabp;
6452: int mode;
6453: cred_t * credp;
6454: #endif
6455: {
6456: shead_t * sheadp;
6457: queue_t * q;
6458: int retval;
6459: n_dev_t dev;
6460:
6461: ASSERT (devp != NULL);
6462: ASSERT (stabp != NULL);
6463: ASSERT (credp != NULL);
6464:
6465:
6466: dev = * devp;
6467:
6468: if ((sheadp = SHEAD_OPEN_LOCK (* devp, stabp, & retval)) == NULL)
6469: return retval;
6470:
6471: /*
6472: * If this is the first open of the stream, set up the stream head
6473: * entry points and the driver entry points.
6474: */
6475:
6476: q = W (sheadp->sh_head)->q_next;
6477:
6478: if (sheadp->sh_open_count == 0) {
6479:
6480: QUEUE_INIT (sheadp->sh_head, & headinfo, QI_NORMAL);
6481: qprocson (sheadp->sh_head);
6482:
6483: QUEUE_INIT (R (q), stabp, QI_NORMAL);
6484: }
6485:
6486:
6487: /*
6488: * Now we have a stream head (locked, no less), we can call the open
6489: * entry points of all the modules and the driver. In the special case
6490: * where the open count of the entry is 0, we allow the driver to
6491: * change the "dev_t" value to a previously unused number.
6492: */
6493:
6494: do {
6495: retval = (* R (q)->q_qinfo->qi_qopen)
6496: (R (q), & dev, mode,
6497: q->q_next == NULL ? 0 : MODOPEN, credp);
6498:
6499: if (dev != * devp && q->q_next != NULL) {
6500: /*
6501: * A module has changed the device number that we
6502: * passed a pointer to. This is not valid!
6503: */
6504:
6505: cmn_err (CE_WARN, "Module \"%s\" changed its device number",
6506: q->q_qinfo->qi_minfo->mi_idname);
6507: retval = ENXIO;
6508: }
6509:
6510: if (retval != 0)
6511: goto failure;
6512: } while ((q = q->q_next) != NULL);
6513:
6514:
6515: /*
6516: * The modules and driver have all OK'ed the open, so increment the
6517: * open count. Here we also check for the clone case.
6518: *
6519: * If we want to detect an error after this point, we should execute
6520: * a close.
6521: */
6522:
6523: sheadp->sh_open_count ++;
6524:
6525: if (dev != * devp) {
6526: /*
6527: * The driver has requested that the device number of the
6528: * queue be assigned differently than the initial device
6529: * number. This is only really valid if this is the first open
6530: * of the given queue.
6531: */
6532:
6533: if (sheadp->sh_open_count > 1) {
6534:
6535: cmn_err (CE_WARN, "Driver \"%s\" changed its device number after inital open",
6536: q->q_qinfo->qi_minfo->mi_idname);
6537:
6538: sheadp->sh_open_count --;
6539:
6540: retval = ENXIO;
6541: goto failure;
6542: }
6543:
6544:
6545: /*
6546: * Other open attempts may be waiting on the stream head for
6547: * the original device number; they need a wakeup.
6548: */
6549:
6550: if (SHEAD_RENAME (sheadp, dev) != 0) {
6551:
6552: cmn_err (CE_WARN, "Clone device number chosen by driver \"%s\"is in use",
6553: q->q_qinfo->qi_minfo->mi_idname);
6554:
6555: if (-- sheadp->sh_open_count == 0)
6556: SHEAD_DO_CLOSE (sheadp, mode, credp);
6557:
6558: retval = ENXIO;
6559: goto failure;
6560: }
6561:
6562: * devp = dev;
6563: }
6564:
6565: failure:
6566: /*
6567: * The module or driver has failed the open request. We unlock the
6568: * stream head, which may deallocate the stream head if the open count
6569: * is 0.
6570: */
6571:
6572: SHEAD_SLEEP_UNLOCK (sheadp, SH_OPENCLOSE);
6573: return retval;
6574: }
6575:
6576:
6577: /*
6578: * Stream head interface to generic polling.
6579: */
6580:
6581: #if __USE_PROTO__
6582: int (STREAMS_CHPOLL) (shead_t * sheadp, short events, int anyyet,
6583: short * reventsp, struct pollhead ** phpp)
6584: #else
6585: int
6586: STREAMS_CHPOLL __ARGS ((sheadp, events, anyyet, reventsp, phpp))
6587: shead_t * sheadp;
6588: short events;
6589: int anyyet;
6590: short * reventsp;
6591: struct pollhead
6592: ** phpp;
6593: #endif
6594: {
6595: short my_events;
6596:
6597: /*
6598: * The chpoll () entry point uses the POLL... constants rather than
6599: * the S_... constants that I_SETSIG uses. We convert to the S_...
6600: * form for our internal use... see <sys/poll.h>
6601: */
6602:
6603: my_events = (events & (__POLL_INPUT | __POLL_HIPRI | __POLL_OUTPUT |
6604: __POLL_RDNORM | __POLL_OUTPUT |
6605: __POLL_RDBAND | __POLL_WRBAND));
6606:
6607: if ((events & POLLERR) != 0)
6608: my_events = S_ERROR;
6609: if ((events & POLLHUP) != 0)
6610: my_events = S_HANGUP;
6611:
6612: if ((my_events = SHEAD_POLL_CHECK (sheadp, my_events)) == 0) {
6613:
6614: * reventsp = 0;
6615:
6616: if (anyyet == 0)
6617: * phpp = sheadp->sh_pollhead;
6618: } else
6619: * reventsp = my_events;
6620:
6621: return 0;
6622: }
6623:
6624:
6625: /*
6626: * Stream head user-level close processing.
6627: */
6628:
6629: #if __USE_PROTO__
6630: int (STREAMS_CLOSE) (shead_t * sheadp, int mode, cred_t * credp)
6631: #else
6632: int
6633: STREAMS_CLOSE __ARGS ((sheadp, mode, credp))
6634: shead_t * sheadp;
6635: int mode;
6636: cred_t * credp;
6637: #endif
6638: {
6639: int retval;
6640:
6641: if ((retval = SHEAD_SLEEP_LOCK (sheadp, SH_OPENCLOSE | SH_IOCTL_LOCK,
6642: 0, CHECK_SIGNALS)) != 0)
6643: return retval;
6644:
6645: if (-- sheadp->sh_open_count == 0)
6646: SHEAD_DO_CLOSE (sheadp, mode, credp);
6647:
6648: SHEAD_SLEEP_UNLOCK (sheadp, SH_OPENCLOSE | SH_IOCTL_LOCK);
6649:
6650: return 0;
6651: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.