1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
22 /* All Rights Reserved */
23
24
25 /*
26 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
27 * Use is subject to license terms.
28 */
29
30 #ifndef _SYS_STRSUBR_H
31 #define _SYS_STRSUBR_H
32
33 /*
34 * WARNING:
35 * Everything in this file is private, belonging to the
36 * STREAMS subsystem. The only guarantee made about the
37 * contents of this file is that if you include it, your
38 * code will not port to the next release.
39 */
40 #include <sys/stream.h>
41 #include <sys/stropts.h>
42 #include <sys/kstat.h>
43 #include <sys/uio.h>
44 #include <sys/proc.h>
45 #include <sys/netstack.h>
46 #include <sys/modhash.h>
47 #include <sys/pidnode.h>
48
49 #ifdef __cplusplus
50 extern "C" {
51 #endif
52
53 /*
54 * In general, the STREAMS locks are disjoint; they are only held
55 * locally, and not simultaneously by a thread. However, module
56 * code, including at the stream head, requires some locks to be
57 * acquired in order for its safety.
58 * 1. Stream level claim. This prevents the value of q_next
59 * from changing while module code is executing.
60 * 2. Queue level claim. This prevents the value of q_ptr
61 * from changing while put or service code is executing.
62 * In addition, it provides for queue single-threading
63 * for QPAIR and PERQ MT-safe modules.
64 * 3. Stream head lock. May be held by the stream head module
65 * to implement a read/write/open/close monitor.
66 * Note: that the only types of twisted stream supported are
67 * the pipe and transports which have read and write service
68 * procedures on both sides of the twist.
69 * 4. Queue lock. May be acquired by utility routines on
70 * behalf of a module.
71 */
72
73 /*
74 * In general, sd_lock protects the consistency of the stdata
75 * structure. Additionally, it is used with sd_monitor
76 * to implement an open/close monitor. In particular, it protects
77 * the following fields:
78 * sd_iocblk
79 * sd_flag
80 * sd_copyflag
81 * sd_iocid
82 * sd_iocwait
83 * sd_sidp
84 * sd_pgidp
85 * sd_wroff
86 * sd_tail
87 * sd_rerror
88 * sd_werror
89 * sd_pushcnt
90 * sd_sigflags
91 * sd_siglist
92 * sd_pollist
93 * sd_mark
94 * sd_closetime
95 * sd_wakeq
96 * sd_maxblk
97 *
98 * The following fields are modified only by the allocator, which
99 * has exclusive access to them at that time:
100 * sd_wrq
101 * sd_strtab
102 *
103 * The following field is protected by the overlying file system
104 * code, guaranteeing single-threading of opens:
105 * sd_vnode
106 *
107 * Stream-level locks should be acquired before any queue-level locks
108 * are acquired.
109 *
110 * The stream head write queue lock(sd_wrq) is used to protect the
111 * fields qn_maxpsz and qn_minpsz because freezestr() which is
112 * necessary for strqset() only gets the queue lock.
113 */
114
115 /*
116 * Function types for the parameterized stream head.
117 * The msgfunc_t takes the parameters:
118 * msgfunc(vnode_t *vp, mblk_t *mp, strwakeup_t *wakeups,
119 * strsigset_t *firstmsgsigs, strsigset_t *allmsgsigs,
120 * strpollset_t *pollwakeups);
121 * It returns an optional message to be processed by the stream head.
122 *
123 * The parameters for errfunc_t are:
124 * errfunc(vnode *vp, int ispeek, int *clearerr);
125 * It returns an errno and zero if there was no pending error.
126 */
127 typedef uint_t strwakeup_t;
128 typedef uint_t strsigset_t;
129 typedef short strpollset_t;
130 typedef uintptr_t callbparams_id_t;
131 typedef mblk_t *(*msgfunc_t)(vnode_t *, mblk_t *, strwakeup_t *,
132 strsigset_t *, strsigset_t *, strpollset_t *);
133 typedef int (*errfunc_t)(vnode_t *, int, int *);
134
135 /*
136 * Per stream sd_lock in putnext may be replaced by per cpu stream_putlocks
137 * each living in a separate cache line. putnext/canputnext grabs only one of
138 * stream_putlocks while strlock() (called on behalf of insertq()/removeq())
139 * acquires all stream_putlocks. Normally stream_putlocks are only employed
140 * for highly contended streams that have SQ_CIPUT queues in the critical path
141 * (e.g. NFS/UDP stream).
142 *
143 * stream_putlocks are dynamically assigned to stdata structure through
144 * sd_ciputctrl pointer possibly when a stream is already in use. Since
145 * strlock() uses stream_putlocks only under sd_lock acquiring sd_lock when
146 * assigning stream_putlocks to the stream ensures synchronization with
147 * strlock().
148 *
149 * For lock ordering purposes stream_putlocks are treated as the extension of
150 * sd_lock and are always grabbed right after grabbing sd_lock and released
151 * right before releasing sd_lock except putnext/canputnext where only one of
152 * stream_putlocks locks is used and where it is the first lock to grab.
153 */
154
155 typedef struct ciputctrl_str {
156 union _ciput_un {
157 uchar_t pad[64];
158 struct _ciput_str {
159 kmutex_t ciput_lck;
160 ushort_t ciput_cnt;
161 } ciput_str;
162 } ciput_un;
163 } ciputctrl_t;
164
165 #define ciputctrl_lock ciput_un.ciput_str.ciput_lck
166 #define ciputctrl_count ciput_un.ciput_str.ciput_cnt
167
168 /*
169 * Header for a stream: interface to rest of system.
170 *
171 * NOTE: While this is a consolidation-private structure, some unbundled and
172 * third-party products inappropriately make use of some of the fields.
173 * As such, please take care to not gratuitously change any offsets of
174 * existing members.
175 */
176 typedef struct stdata {
177 struct queue *sd_wrq; /* write queue */
178 struct msgb *sd_iocblk; /* return block for ioctl */
179 struct vnode *sd_vnode; /* pointer to associated vnode */
180 struct streamtab *sd_strtab; /* pointer to streamtab for stream */
181 uint_t sd_flag; /* state/flags */
182 uint_t sd_iocid; /* ioctl id */
183 struct pid *sd_sidp; /* controlling session info */
184 struct pid *sd_pgidp; /* controlling process group info */
185 ushort_t sd_tail; /* reserved space in written mblks */
186 ushort_t sd_wroff; /* write offset */
187 int sd_rerror; /* error to return on read ops */
188 int sd_werror; /* error to return on write ops */
189 int sd_pushcnt; /* number of pushes done on stream */
190 int sd_sigflags; /* logical OR of all siglist events */
191 struct strsig *sd_siglist; /* pid linked list to rcv SIGPOLL sig */
192 struct pollhead sd_pollist; /* list of all pollers to wake up */
193 struct msgb *sd_mark; /* "marked" message on read queue */
194 clock_t sd_closetime; /* time to wait to drain q in close */
195 kmutex_t sd_lock; /* protect head consistency */
196 kcondvar_t sd_monitor; /* open/close/push/pop monitor */
197 kcondvar_t sd_iocmonitor; /* ioctl single-threading */
198 kcondvar_t sd_refmonitor; /* sd_refcnt monitor */
199 ssize_t sd_qn_minpsz; /* These two fields are a performance */
200 ssize_t sd_qn_maxpsz; /* enhancements, cache the values in */
201 /* the stream head so we don't have */
202 /* to ask the module below the stream */
203 /* head to get this information. */
204 struct stdata *sd_mate; /* pointer to twisted stream mate */
205 kthread_id_t sd_freezer; /* thread that froze stream */
206 kmutex_t sd_reflock; /* Protects sd_refcnt */
207 int sd_refcnt; /* number of claimstr */
208 uint_t sd_wakeq; /* strwakeq()'s copy of sd_flag */
209 struct queue *sd_struiordq; /* sync barrier struio() read queue */
210 struct queue *sd_struiowrq; /* sync barrier struio() write queue */
211 char sd_struiodnak; /* defer NAK of M_IOCTL by rput() */
212 struct msgb *sd_struionak; /* pointer M_IOCTL mblk(s) to NAK */
213 caddr_t sd_t_audit_data; /* For audit purposes only */
214 ssize_t sd_maxblk; /* maximum message block size */
215 uint_t sd_rput_opt; /* options/flags for strrput */
216 uint_t sd_wput_opt; /* options/flags for write/putmsg */
217 uint_t sd_read_opt; /* options/flags for strread */
218 msgfunc_t sd_rprotofunc; /* rput M_*PROTO routine */
219 msgfunc_t sd_rputdatafunc; /* read M_DATA routine */
220 msgfunc_t sd_rmiscfunc; /* rput routine (non-data/proto) */
221 msgfunc_t sd_wputdatafunc; /* wput M_DATA routine */
222 errfunc_t sd_rderrfunc; /* read side error callback */
223 errfunc_t sd_wrerrfunc; /* write side error callback */
224 /*
225 * support for low contention concurrent putnext.
226 */
227 ciputctrl_t *sd_ciputctrl;
228 uint_t sd_nciputctrl;
229
230 int sd_anchor; /* position of anchor in stream */
231 /*
232 * Service scheduling at the stream head.
233 */
234 kmutex_t sd_qlock;
235 struct queue *sd_qhead; /* Head of queues to be serviced. */
236 struct queue *sd_qtail; /* Tail of queues to be serviced. */
237 void *sd_servid; /* Service ID for bckgrnd schedule */
238 ushort_t sd_svcflags; /* Servicing flags */
239 short sd_nqueues; /* Number of queues in the list */
240 kcondvar_t sd_qcv; /* Waiters for qhead to become empty */
241 kcondvar_t sd_zcopy_wait;
242 uint_t sd_copyflag; /* copy-related flags */
243 zoneid_t sd_anchorzone; /* Allow removal from same zone only */
244 struct msgb *sd_cmdblk; /* reply from _I_CMD */
245 /*
246 * pids associated with this stream head.
247 */
248 avl_tree_t sd_pid_tree;
249 kmutex_t sd_pid_tree_lock;
250 } stdata_t;
251
252 /*
253 * stdata servicing flags.
254 */
255 #define STRS_WILLSERVICE 0x01
256 #define STRS_SCHEDULED 0x02
257
258 #define STREAM_NEEDSERVICE(stp) ((stp)->sd_qhead != NULL)
259
260 /*
261 * stdata flag field defines
262 */
263 #define IOCWAIT 0x00000001 /* Someone is doing an ioctl */
264 #define RSLEEP 0x00000002 /* Someone wants to read/recv msg */
265 #define WSLEEP 0x00000004 /* Someone wants to write */
266 #define STRPRI 0x00000008 /* An M_PCPROTO is at stream head */
267 #define STRHUP 0x00000010 /* Device has vanished */
268 #define STWOPEN 0x00000020 /* waiting for 1st open */
269 #define STPLEX 0x00000040 /* stream is being multiplexed */
270 #define STRISTTY 0x00000080 /* stream is a terminal */
271 #define STRGETINPROG 0x00000100 /* (k)strgetmsg is running */
272 #define IOCWAITNE 0x00000200 /* STR_NOERROR ioctl running */
273 #define STRDERR 0x00000400 /* fatal read error from M_ERROR */
274 #define STWRERR 0x00000800 /* fatal write error from M_ERROR */
275 #define STRDERRNONPERSIST 0x00001000 /* nonpersistent read errors */
276 #define STWRERRNONPERSIST 0x00002000 /* nonpersistent write errors */
277 #define STRCLOSE 0x00004000 /* wait for a close to complete */
278 #define SNDMREAD 0x00008000 /* used for read notification */
279 #define OLDNDELAY 0x00010000 /* use old TTY semantics for */
280 /* NDELAY reads and writes */
281 /* 0x00020000 unused */
282 /* 0x00040000 unused */
283 #define STRTOSTOP 0x00080000 /* block background writes */
284 #define STRCMDWAIT 0x00100000 /* someone is doing an _I_CMD */
285 /* 0x00200000 unused */
286 #define STRMOUNT 0x00400000 /* stream is mounted */
287 #define STRNOTATMARK 0x00800000 /* Not at mark (when empty read q) */
288 #define STRDELIM 0x01000000 /* generate delimited messages */
289 #define STRATMARK 0x02000000 /* At mark (due to MSGMARKNEXT) */
290 #define STZCNOTIFY 0x04000000 /* wait for zerocopy mblk to be acked */
291 #define STRPLUMB 0x08000000 /* push/pop pending */
292 #define STREOF 0x10000000 /* End-of-file indication */
293 #define STREOPENFAIL 0x20000000 /* indicates if re-open has failed */
294 #define STRMATE 0x40000000 /* this stream is a mate */
295 #define STRHASLINKS 0x80000000 /* I_LINKs under this stream */
296
297 /*
298 * Copy-related flags (sd_copyflag), set by SO_COPYOPT.
299 */
300 #define STZCVMSAFE 0x00000001 /* safe to borrow file (segmapped) */
301 /* pages instead of bcopy */
302 #define STZCVMUNSAFE 0x00000002 /* unsafe to borrow file pages */
303 #define STRCOPYCACHED 0x00000004 /* copy should NOT bypass cache */
304
305 /*
306 * Options and flags for strrput (sd_rput_opt)
307 */
308 #define SR_POLLIN 0x00000001 /* pollwakeup needed for band0 data */
309 #define SR_SIGALLDATA 0x00000002 /* Send SIGPOLL for all M_DATA */
310 #define SR_CONSOL_DATA 0x00000004 /* Consolidate M_DATA onto q_last */
311 #define SR_IGN_ZEROLEN 0x00000008 /* Ignore zero-length M_DATA */
312
313 /*
314 * Options and flags for strwrite/strputmsg (sd_wput_opt)
315 */
316 #define SW_SIGPIPE 0x00000001 /* Send SIGPIPE for write error */
317 #define SW_RECHECK_ERR 0x00000002 /* Recheck errors in strwrite loop */
318 #define SW_SNDZERO 0x00000004 /* send 0-length msg down pipe/FIFO */
319
320 /*
321 * Options and flags for strread (sd_read_opt)
322 */
323 #define RD_MSGDIS 0x00000001 /* read msg discard */
324 #define RD_MSGNODIS 0x00000002 /* read msg no discard */
325 #define RD_PROTDAT 0x00000004 /* read M_[PC]PROTO contents as data */
326 #define RD_PROTDIS 0x00000008 /* discard M_[PC]PROTO blocks and */
327 /* retain data blocks */
328 /*
329 * Flags parameter for strsetrputhooks() and strsetwputhooks().
330 * These flags define the interface for setting the above internal
331 * flags in sd_rput_opt and sd_wput_opt.
332 */
333 #define SH_CONSOL_DATA 0x00000001 /* Consolidate M_DATA onto q_last */
334 #define SH_SIGALLDATA 0x00000002 /* Send SIGPOLL for all M_DATA */
335 #define SH_IGN_ZEROLEN 0x00000004 /* Drop zero-length M_DATA */
336
337 #define SH_SIGPIPE 0x00000100 /* Send SIGPIPE for write error */
338 #define SH_RECHECK_ERR 0x00000200 /* Recheck errors in strwrite loop */
339
340 /*
341 * Each queue points to a sync queue (the inner perimeter) which keeps
342 * track of the number of threads that are inside a given queue (sq_count)
343 * and also is used to implement the asynchronous putnext
344 * (by queuing messages if the queue can not be entered.)
345 *
346 * Messages are queued on sq_head/sq_tail including deferred qwriter(INNER)
347 * messages. The sq_head/sq_tail list is a singly-linked list with
348 * b_queue recording the queue and b_prev recording the function to
349 * be called (either the put procedure or a qwriter callback function.)
350 *
351 * The sq_count counter tracks the number of threads that are
352 * executing inside the perimeter or (in the case of outer perimeters)
353 * have some work queued for them relating to the perimeter. The sq_rmqcount
354 * counter tracks the subset which are in removeq() (usually invoked from
355 * qprocsoff(9F)).
356 *
357 * In addition a module writer can declare that the module has an outer
358 * perimeter (by setting D_MTOUTPERIM) in which case all inner perimeter
359 * syncq's for the module point (through sq_outer) to an outer perimeter
360 * syncq. The outer perimeter consists of the doubly linked list (sq_onext and
361 * sq_oprev) linking all the inner perimeter syncq's with out outer perimeter
362 * syncq. This is used to implement qwriter(OUTER) (an asynchronous way of
363 * getting exclusive access at the outer perimeter) and outer_enter/exit
364 * which are used by the framework to acquire exclusive access to the outer
365 * perimeter during open and close of modules that have set D_MTOUTPERIM.
366 *
367 * In the inner perimeter case sq_save is available for use by machine
368 * dependent code. sq_head/sq_tail are used to queue deferred messages on
369 * the inner perimeter syncqs and to queue become_writer requests on the
370 * outer perimeter syncqs.
371 *
372 * Note: machine dependent optimized versions of putnext may depend
373 * on the order of sq_flags and sq_count (so that they can e.g.
374 * read these two fields in a single load instruction.)
375 *
376 * Per perimeter SQLOCK/sq_count in putnext/put may be replaced by per cpu
377 * sq_putlocks/sq_putcounts each living in a separate cache line. Obviously
378 * sq_putlock[x] protects sq_putcount[x]. putnext/put routine will grab only 1
379 * of sq_putlocks and update only 1 of sq_putcounts. strlock() and many
380 * other routines in strsubr.c and ddi.c will grab all sq_putlocks (as well as
381 * SQLOCK) and figure out the count value as the sum of sq_count and all of
382 * sq_putcounts. The idea is to make critical fast path -- putnext -- much
383 * faster at the expense of much less often used slower path like
384 * strlock(). One known case where entersq/strlock is executed pretty often is
385 * SpecWeb but since IP is SQ_CIOC and socket TCP/IP stream is nextless
386 * there's no need to grab multiple sq_putlocks and look at sq_putcounts. See
387 * strsubr.c for more comments.
388 *
389 * Note regular SQLOCK and sq_count are still used in many routines
390 * (e.g. entersq(), rwnext()) in the same way as before sq_putlocks were
391 * introduced.
392 *
393 * To understand when all sq_putlocks need to be held and all sq_putcounts
394 * need to be added up one needs to look closely at putnext code. Basically if
395 * a routine like e.g. wait_syncq() needs to be sure that perimeter is empty
396 * all sq_putlocks/sq_putcounts need to be held/added up. On the other hand
397 * there's no need to hold all sq_putlocks and count all sq_putcounts in
398 * routines like leavesq()/dropsq() and etc. since the are usually exit
399 * counterparts of entersq/outer_enter() and etc. which have already either
400 * prevented put entry poins from executing or did not care about put
401 * entrypoints. entersq() doesn't need to care about sq_putlocks/sq_putcounts
402 * if the entry point has a shared access since put has the highest degree of
403 * concurrency and such entersq() does not intend to block out put
404 * entrypoints.
405 *
406 * Before sq_putcounts were introduced the standard way to wait for perimeter
407 * to become empty was:
408 *
409 * mutex_enter(SQLOCK(sq));
410 * while (sq->sq_count > 0) {
411 * sq->sq_flags |= SQ_WANTWAKEUP;
412 * cv_wait(&sq->sq_wait, SQLOCK(sq));
413 * }
414 * mutex_exit(SQLOCK(sq));
415 *
416 * The new way is:
417 *
418 * mutex_enter(SQLOCK(sq));
419 * count = sq->sq_count;
420 * SQ_PUTLOCKS_ENTER(sq);
421 * SUM_SQ_PUTCOUNTS(sq, count);
422 * while (count != 0) {
423 * sq->sq_flags |= SQ_WANTWAKEUP;
424 * SQ_PUTLOCKS_EXIT(sq);
425 * cv_wait(&sq->sq_wait, SQLOCK(sq));
426 * count = sq->sq_count;
427 * SQ_PUTLOCKS_ENTER(sq);
428 * SUM_SQ_PUTCOUNTS(sq, count);
429 * }
430 * SQ_PUTLOCKS_EXIT(sq);
431 * mutex_exit(SQLOCK(sq));
432 *
433 * Note that SQ_WANTWAKEUP is set before dropping SQ_PUTLOCKS. This makes sure
434 * putnext won't skip a wakeup.
435 *
436 * sq_putlocks are treated as the extension of SQLOCK for lock ordering
437 * purposes and are always grabbed right after grabbing SQLOCK and released
438 * right before releasing SQLOCK. This also allows dynamic creation of
439 * sq_putlocks while holding SQLOCK (by making sq_ciputctrl non null even when
440 * the stream is already in use). Only in putnext one of sq_putlocks
441 * is grabbed instead of SQLOCK. putnext return path remembers what counter it
442 * incremented and decrements the right counter on its way out.
443 */
444
445 struct syncq {
446 kmutex_t sq_lock; /* atomic access to syncq */
447 uint16_t sq_count; /* # threads inside */
448 uint16_t sq_flags; /* state and some type info */
449 /*
450 * Distributed syncq scheduling
451 * The list of queue's is handled by sq_head and
452 * sq_tail fields.
453 *
454 * The list of events is handled by the sq_evhead and sq_evtail
455 * fields.
456 */
457 queue_t *sq_head; /* queue of deferred messages */
458 queue_t *sq_tail; /* queue of deferred messages */
459 mblk_t *sq_evhead; /* Event message on the syncq */
460 mblk_t *sq_evtail;
461 uint_t sq_nqueues; /* # of queues on this sq */
462 /*
463 * Concurrency and condition variables
464 */
465 uint16_t sq_type; /* type (concurrency) of syncq */
466 uint16_t sq_rmqcount; /* # threads inside removeq() */
467 kcondvar_t sq_wait; /* block on this sync queue */
468 kcondvar_t sq_exitwait; /* waiting for thread to leave the */
469 /* inner perimeter */
470 /*
471 * Handling synchronous callbacks such as qtimeout and qbufcall
472 */
473 ushort_t sq_callbflags; /* flags for callback synchronization */
474 callbparams_id_t sq_cancelid; /* id of callback being cancelled */
475 struct callbparams *sq_callbpend; /* Pending callbacks */
476
477 /*
478 * Links forming an outer perimeter from one outer syncq and
479 * a set of inner sync queues.
480 */
481 struct syncq *sq_outer; /* Pointer to outer perimeter */
482 struct syncq *sq_onext; /* Linked list of syncq's making */
483 struct syncq *sq_oprev; /* up the outer perimeter. */
484 /*
485 * support for low contention concurrent putnext.
486 */
487 ciputctrl_t *sq_ciputctrl;
488 uint_t sq_nciputctrl;
489 /*
490 * Counter for the number of threads wanting to become exclusive.
491 */
492 uint_t sq_needexcl;
493 /*
494 * These two fields are used for scheduling a syncq for
495 * background processing. The sq_svcflag is protected by
496 * SQLOCK lock.
497 */
498 struct syncq *sq_next; /* for syncq scheduling */
499 void * sq_servid;
500 uint_t sq_servcount; /* # pending background threads */
501 uint_t sq_svcflags; /* Scheduling flags */
502 clock_t sq_tstamp; /* Time when was enabled */
503 /*
504 * Maximum priority of the queues on this syncq.
505 */
506 pri_t sq_pri;
507 };
508 typedef struct syncq syncq_t;
509
510 /*
511 * sync queue scheduling flags (for sq_svcflags).
512 */
513 #define SQ_SERVICE 0x1 /* being serviced */
514 #define SQ_BGTHREAD 0x2 /* awaiting service by bg thread */
515 #define SQ_DISABLED 0x4 /* don't put syncq in service list */
516
517 /*
518 * FASTPUT bit in sd_count/putcount.
519 */
520 #define SQ_FASTPUT 0x8000
521 #define SQ_FASTMASK 0x7FFF
522
523 /*
524 * sync queue state flags
525 */
526 #define SQ_EXCL 0x0001 /* exclusive access to inner */
527 /* perimeter */
528 #define SQ_BLOCKED 0x0002 /* qprocsoff */
529 #define SQ_FROZEN 0x0004 /* freezestr */
530 #define SQ_WRITER 0x0008 /* qwriter(OUTER) pending or running */
531 #define SQ_MESSAGES 0x0010 /* messages on syncq */
532 #define SQ_WANTWAKEUP 0x0020 /* do cv_broadcast on sq_wait */
533 #define SQ_WANTEXWAKEUP 0x0040 /* do cv_broadcast on sq_exitwait */
534 #define SQ_EVENTS 0x0080 /* Events pending */
535 #define SQ_QUEUED (SQ_MESSAGES | SQ_EVENTS)
536 #define SQ_FLAGMASK 0x00FF
537
538 /*
539 * Test a queue to see if inner perimeter is exclusive.
540 */
541 #define PERIM_EXCL(q) ((q)->q_syncq->sq_flags & SQ_EXCL)
542
543 /*
544 * If any of these flags are set it is not possible for a thread to
545 * enter a put or service procedure. Instead it must either block
546 * or put the message on the syncq.
547 */
548 #define SQ_GOAWAY (SQ_EXCL|SQ_BLOCKED|SQ_FROZEN|SQ_WRITER|\
549 SQ_QUEUED)
550 /*
551 * If any of these flags are set it not possible to drain the syncq
552 */
553 #define SQ_STAYAWAY (SQ_BLOCKED|SQ_FROZEN|SQ_WRITER)
554
555 /*
556 * Flags to trigger syncq tail processing.
557 */
558 #define SQ_TAIL (SQ_QUEUED|SQ_WANTWAKEUP|SQ_WANTEXWAKEUP)
559
560 /*
561 * Syncq types (stored in sq_type)
562 * The SQ_TYPES_IN_FLAGS (ciput) are also stored in sq_flags
563 * for performance reasons. Thus these type values have to be in the low
564 * 16 bits and not conflict with the sq_flags values above.
565 *
566 * Notes:
567 * - putnext() and put() assume that the put procedures have the highest
568 * degree of concurrency. Thus if any of the SQ_CI* are set then SQ_CIPUT
569 * has to be set. This restriction can be lifted by adding code to putnext
570 * and put that check that sq_count == 0 like entersq does.
571 * - putnext() and put() does currently not handle !SQ_COPUT
572 * - In order to implement !SQ_COCB outer_enter has to be fixed so that
573 * the callback can be cancelled while cv_waiting in outer_enter.
574 * - If SQ_CISVC needs to be implemented, qprocsoff() needs to wait
575 * for the currently running services to stop (wait for QINSERVICE
576 * to go off). disable_svc called from qprcosoff disables only
577 * services that will be run in future.
578 *
579 * All the SQ_CO flags are set when there is no outer perimeter.
580 */
581 #define SQ_CIPUT 0x0100 /* Concurrent inner put proc */
582 #define SQ_CISVC 0x0200 /* Concurrent inner svc proc */
583 #define SQ_CIOC 0x0400 /* Concurrent inner open/close */
584 #define SQ_CICB 0x0800 /* Concurrent inner callback */
585 #define SQ_COPUT 0x1000 /* Concurrent outer put proc */
586 #define SQ_COSVC 0x2000 /* Concurrent outer svc proc */
587 #define SQ_COOC 0x4000 /* Concurrent outer open/close */
588 #define SQ_COCB 0x8000 /* Concurrent outer callback */
589
590 /* Types also kept in sq_flags for performance */
591 #define SQ_TYPES_IN_FLAGS (SQ_CIPUT)
592
593 #define SQ_CI (SQ_CIPUT|SQ_CISVC|SQ_CIOC|SQ_CICB)
594 #define SQ_CO (SQ_COPUT|SQ_COSVC|SQ_COOC|SQ_COCB)
595 #define SQ_TYPEMASK (SQ_CI|SQ_CO)
596
597 /*
598 * Flag combinations passed to entersq and leavesq to specify the type
599 * of entry point.
600 */
601 #define SQ_PUT (SQ_CIPUT|SQ_COPUT)
602 #define SQ_SVC (SQ_CISVC|SQ_COSVC)
603 #define SQ_OPENCLOSE (SQ_CIOC|SQ_COOC)
604 #define SQ_CALLBACK (SQ_CICB|SQ_COCB)
605
606 /*
607 * Other syncq types which are not copied into flags.
608 */
609 #define SQ_PERMOD 0x01 /* Syncq is PERMOD */
610
611 /*
612 * Asynchronous callback qun*** flag.
613 * The mechanism these flags are used in is one where callbacks enter
614 * the perimeter thanks to framework support. To use this mechanism
615 * the q* and qun* flavors of the callback routines must be used.
616 * e.g. qtimeout and quntimeout. The synchronization provided by the flags
617 * avoids deadlocks between blocking qun* routines and the perimeter
618 * lock.
619 */
620 #define SQ_CALLB_BYPASSED 0x01 /* bypassed callback fn */
621
622 /*
623 * Cancel callback mask.
624 * The mask expands as the number of cancelable callback types grows
625 * Note - separate callback flag because different callbacks have
626 * overlapping id space.
627 */
628 #define SQ_CALLB_CANCEL_MASK (SQ_CANCEL_TOUT|SQ_CANCEL_BUFCALL)
629
630 #define SQ_CANCEL_TOUT 0x02 /* cancel timeout request */
631 #define SQ_CANCEL_BUFCALL 0x04 /* cancel bufcall request */
632
633 typedef struct callbparams {
634 syncq_t *cbp_sq;
635 void (*cbp_func)(void *);
636 void *cbp_arg;
637 callbparams_id_t cbp_id;
638 uint_t cbp_flags;
639 struct callbparams *cbp_next;
640 size_t cbp_size;
641 } callbparams_t;
642
643 typedef struct strbufcall {
644 void (*bc_func)(void *);
645 void *bc_arg;
646 size_t bc_size;
647 bufcall_id_t bc_id;
648 struct strbufcall *bc_next;
649 kthread_id_t bc_executor;
650 } strbufcall_t;
651
652 /*
653 * Structure of list of processes to be sent SIGPOLL/SIGURG signal
654 * on request. The valid S_* events are defined in stropts.h.
655 */
656 typedef struct strsig {
657 struct pid *ss_pidp; /* pid/pgrp pointer */
658 pid_t ss_pid; /* positive pid, negative pgrp */
659 int ss_events; /* S_* events */
660 struct strsig *ss_next;
661 } strsig_t;
662
663 /*
664 * bufcall list
665 */
666 struct bclist {
667 strbufcall_t *bc_head;
668 strbufcall_t *bc_tail;
669 };
670
671 /*
672 * Structure used to track mux links and unlinks.
673 */
674 struct mux_node {
675 major_t mn_imaj; /* internal major device number */
676 uint16_t mn_indegree; /* number of incoming edges */
677 struct mux_node *mn_originp; /* where we came from during search */
678 struct mux_edge *mn_startp; /* where search left off in mn_outp */
679 struct mux_edge *mn_outp; /* list of outgoing edges */
680 uint_t mn_flags; /* see below */
681 };
682
683 /*
684 * Flags for mux_nodes.
685 */
686 #define VISITED 1
687
688 /*
689 * Edge structure - a list of these is hung off the
690 * mux_node to represent the outgoing edges.
691 */
692 struct mux_edge {
693 struct mux_node *me_nodep; /* edge leads to this node */
694 struct mux_edge *me_nextp; /* next edge */
695 int me_muxid; /* id of link */
696 dev_t me_dev; /* dev_t - used for kernel PUNLINK */
697 };
698
699 /*
700 * Queue info
701 *
702 * The syncq is included here to reduce memory fragmentation
703 * for kernel memory allocators that only allocate in sizes that are
704 * powers of two. If the kernel memory allocator changes this should
705 * be revisited.
706 */
707 typedef struct queinfo {
708 struct queue qu_rqueue; /* read queue - must be first */
709 struct queue qu_wqueue; /* write queue - must be second */
710 struct syncq qu_syncq; /* syncq - must be third */
711 } queinfo_t;
712
713 /*
714 * Multiplexed streams info
715 */
716 typedef struct linkinfo {
717 struct linkblk li_lblk; /* must be first */
718 struct file *li_fpdown; /* file pointer for lower stream */
719 struct linkinfo *li_next; /* next in list */
720 struct linkinfo *li_prev; /* previous in list */
721 } linkinfo_t;
722
723 /*
724 * List of syncq's used by freeezestr/unfreezestr
725 */
726 typedef struct syncql {
727 struct syncql *sql_next;
728 syncq_t *sql_sq;
729 } syncql_t;
730
731 typedef struct sqlist {
732 syncql_t *sqlist_head;
733 size_t sqlist_size; /* structure size in bytes */
734 size_t sqlist_index; /* next free entry in array */
735 syncql_t sqlist_array[4]; /* 4 or more entries */
736 } sqlist_t;
737
738 typedef struct perdm {
739 struct perdm *dm_next;
740 syncq_t *dm_sq;
741 struct streamtab *dm_str;
742 uint_t dm_ref;
743 } perdm_t;
744
745 #define NEED_DM(dmp, qflag) \
746 (dmp == NULL && (qflag & (QPERMOD | QMTOUTPERIM)))
747
748 /*
749 * fmodsw_impl_t is used within the kernel. fmodsw is used by
750 * the modules/drivers. The information is copied from fmodsw
751 * defined in the module/driver into the fmodsw_impl_t structure
752 * during the module/driver initialization.
753 */
754 typedef struct fmodsw_impl fmodsw_impl_t;
755
756 struct fmodsw_impl {
757 fmodsw_impl_t *f_next;
758 char f_name[FMNAMESZ + 1];
759 struct streamtab *f_str;
760 uint32_t f_qflag;
761 uint32_t f_sqtype;
762 perdm_t *f_dmp;
763 uint32_t f_ref;
764 uint32_t f_hits;
765 };
766
767 typedef enum {
768 FMODSW_HOLD = 0x00000001,
769 FMODSW_LOAD = 0x00000002
770 } fmodsw_flags_t;
771
772 typedef struct cdevsw_impl {
773 struct streamtab *d_str;
774 uint32_t d_qflag;
775 uint32_t d_sqtype;
776 perdm_t *d_dmp;
777 } cdevsw_impl_t;
778
779 /*
780 * Enumeration of the types of access that can be requested for a
781 * controlling terminal under job control.
782 */
783 enum jcaccess {
784 JCREAD, /* read data on a ctty */
785 JCWRITE, /* write data to a ctty */
786 JCSETP, /* set ctty parameters */
787 JCGETP /* get ctty parameters */
788 };
789
790 struct str_stack {
791 netstack_t *ss_netstack; /* Common netstack */
792
793 kmutex_t ss_sad_lock; /* autopush lock */
794 mod_hash_t *ss_sad_hash;
795 size_t ss_sad_hash_nchains;
796 struct saddev *ss_saddev; /* sad device array */
797 int ss_sadcnt; /* number of sad devices */
798
799 int ss_devcnt; /* number of mux_nodes */
800 struct mux_node *ss_mux_nodes; /* mux info for cycle checking */
801 };
802 typedef struct str_stack str_stack_t;
803
804 /*
805 * Finding related queues
806 */
807 #define STREAM(q) ((q)->q_stream)
808 #define SQ(rq) ((syncq_t *)((rq) + 2))
809
810 /*
811 * Get the module/driver name for a queue. Since some queues don't have
812 * q_info structures (e.g., see log_makeq()), fall back to "?".
813 */
814 #define Q2NAME(q) \
815 (((q)->q_qinfo != NULL && (q)->q_qinfo->qi_minfo->mi_idname != NULL) ? \
816 (q)->q_qinfo->qi_minfo->mi_idname : "?")
817
818 /*
819 * Locking macros
820 */
821 #define QLOCK(q) (&(q)->q_lock)
822 #define SQLOCK(sq) (&(sq)->sq_lock)
823
824 #define STREAM_PUTLOCKS_ENTER(stp) { \
825 ASSERT(MUTEX_HELD(&(stp)->sd_lock)); \
826 if ((stp)->sd_ciputctrl != NULL) { \
827 int i; \
828 int nlocks = (stp)->sd_nciputctrl; \
829 ciputctrl_t *cip = (stp)->sd_ciputctrl; \
830 for (i = 0; i <= nlocks; i++) { \
831 mutex_enter(&cip[i].ciputctrl_lock); \
832 } \
833 } \
834 }
835
836 #define STREAM_PUTLOCKS_EXIT(stp) { \
837 ASSERT(MUTEX_HELD(&(stp)->sd_lock)); \
838 if ((stp)->sd_ciputctrl != NULL) { \
839 int i; \
840 int nlocks = (stp)->sd_nciputctrl; \
841 ciputctrl_t *cip = (stp)->sd_ciputctrl; \
842 for (i = 0; i <= nlocks; i++) { \
843 mutex_exit(&cip[i].ciputctrl_lock); \
844 } \
845 } \
846 }
847
848 #define SQ_PUTLOCKS_ENTER(sq) { \
849 ASSERT(MUTEX_HELD(SQLOCK(sq))); \
850 if ((sq)->sq_ciputctrl != NULL) { \
851 int i; \
852 int nlocks = (sq)->sq_nciputctrl; \
853 ciputctrl_t *cip = (sq)->sq_ciputctrl; \
854 ASSERT((sq)->sq_type & SQ_CIPUT); \
855 for (i = 0; i <= nlocks; i++) { \
856 mutex_enter(&cip[i].ciputctrl_lock); \
857 } \
858 } \
859 }
860
861 #define SQ_PUTLOCKS_EXIT(sq) { \
862 ASSERT(MUTEX_HELD(SQLOCK(sq))); \
863 if ((sq)->sq_ciputctrl != NULL) { \
864 int i; \
865 int nlocks = (sq)->sq_nciputctrl; \
866 ciputctrl_t *cip = (sq)->sq_ciputctrl; \
867 ASSERT((sq)->sq_type & SQ_CIPUT); \
868 for (i = 0; i <= nlocks; i++) { \
869 mutex_exit(&cip[i].ciputctrl_lock); \
870 } \
871 } \
872 }
873
874 #define SQ_PUTCOUNT_SETFAST(sq) { \
875 ASSERT(MUTEX_HELD(SQLOCK(sq))); \
876 if ((sq)->sq_ciputctrl != NULL) { \
877 int i; \
878 int nlocks = (sq)->sq_nciputctrl; \
879 ciputctrl_t *cip = (sq)->sq_ciputctrl; \
880 ASSERT((sq)->sq_type & SQ_CIPUT); \
881 for (i = 0; i <= nlocks; i++) { \
882 mutex_enter(&cip[i].ciputctrl_lock); \
883 cip[i].ciputctrl_count |= SQ_FASTPUT; \
884 mutex_exit(&cip[i].ciputctrl_lock); \
885 } \
886 } \
887 }
888
889 #define SQ_PUTCOUNT_CLRFAST(sq) { \
890 ASSERT(MUTEX_HELD(SQLOCK(sq))); \
891 if ((sq)->sq_ciputctrl != NULL) { \
892 int i; \
893 int nlocks = (sq)->sq_nciputctrl; \
894 ciputctrl_t *cip = (sq)->sq_ciputctrl; \
895 ASSERT((sq)->sq_type & SQ_CIPUT); \
896 for (i = 0; i <= nlocks; i++) { \
897 mutex_enter(&cip[i].ciputctrl_lock); \
898 cip[i].ciputctrl_count &= ~SQ_FASTPUT; \
899 mutex_exit(&cip[i].ciputctrl_lock); \
900 } \
901 } \
902 }
903
904
905 #ifdef DEBUG
906
907 #define SQ_PUTLOCKS_HELD(sq) { \
908 ASSERT(MUTEX_HELD(SQLOCK(sq))); \
909 if ((sq)->sq_ciputctrl != NULL) { \
910 int i; \
911 int nlocks = (sq)->sq_nciputctrl; \
912 ciputctrl_t *cip = (sq)->sq_ciputctrl; \
913 ASSERT((sq)->sq_type & SQ_CIPUT); \
914 for (i = 0; i <= nlocks; i++) { \
915 ASSERT(MUTEX_HELD(&cip[i].ciputctrl_lock)); \
916 } \
917 } \
918 }
919
920 #define SUMCHECK_SQ_PUTCOUNTS(sq, countcheck) { \
921 if ((sq)->sq_ciputctrl != NULL) { \
922 int i; \
923 uint_t count = 0; \
924 int ncounts = (sq)->sq_nciputctrl; \
925 ASSERT((sq)->sq_type & SQ_CIPUT); \
926 for (i = 0; i <= ncounts; i++) { \
927 count += \
928 (((sq)->sq_ciputctrl[i].ciputctrl_count) & \
929 SQ_FASTMASK); \
930 } \
931 ASSERT(count == (countcheck)); \
932 } \
933 }
934
935 #define SUMCHECK_CIPUTCTRL_COUNTS(ciput, nciput, countcheck) { \
936 int i; \
937 uint_t count = 0; \
938 ASSERT((ciput) != NULL); \
939 for (i = 0; i <= (nciput); i++) { \
940 count += (((ciput)[i].ciputctrl_count) & \
941 SQ_FASTMASK); \
942 } \
943 ASSERT(count == (countcheck)); \
944 }
945
946 #else /* DEBUG */
947
948 #define SQ_PUTLOCKS_HELD(sq)
949 #define SUMCHECK_SQ_PUTCOUNTS(sq, countcheck)
950 #define SUMCHECK_CIPUTCTRL_COUNTS(sq, nciput, countcheck)
951
952 #endif /* DEBUG */
953
954 #define SUM_SQ_PUTCOUNTS(sq, count) { \
955 if ((sq)->sq_ciputctrl != NULL) { \
956 int i; \
957 int ncounts = (sq)->sq_nciputctrl; \
958 ciputctrl_t *cip = (sq)->sq_ciputctrl; \
959 ASSERT((sq)->sq_type & SQ_CIPUT); \
960 for (i = 0; i <= ncounts; i++) { \
961 (count) += ((cip[i].ciputctrl_count) & \
962 SQ_FASTMASK); \
963 } \
964 } \
965 }
966
967 #define CLAIM_QNEXT_LOCK(stp) mutex_enter(&(stp)->sd_lock)
968 #define RELEASE_QNEXT_LOCK(stp) mutex_exit(&(stp)->sd_lock)
969
970 /*
971 * syncq message manipulation macros.
972 */
973 /*
974 * Put a message on the queue syncq.
975 * Assumes QLOCK held.
976 */
977 #define SQPUT_MP(qp, mp) \
978 { \
979 qp->q_syncqmsgs++; \
980 if (qp->q_sqhead == NULL) { \
981 qp->q_sqhead = qp->q_sqtail = mp; \
982 } else { \
983 qp->q_sqtail->b_next = mp; \
984 qp->q_sqtail = mp; \
985 } \
986 set_qfull(qp); \
987 }
988
989 /*
990 * Miscellaneous parameters and flags.
991 */
992
993 /*
994 * Default timeout in milliseconds for ioctls and close
995 */
996 #define STRTIMOUT 15000
997
998 /*
999 * Flag values for stream io
1000 */
1001 #define WRITEWAIT 0x1 /* waiting for write event */
1002 #define READWAIT 0x2 /* waiting for read event */
1003 #define NOINTR 0x4 /* error is not to be set for signal */
1004 #define GETWAIT 0x8 /* waiting for getmsg event */
1005
1006 /*
1007 * These flags need to be unique for stream io name space
1008 * and copy modes name space. These flags allow strwaitq
1009 * and strdoioctl to proceed as if signals or errors on the stream
1010 * head have not occurred; i.e. they will be detected by some other
1011 * means.
1012 * STR_NOSIG does not allow signals to interrupt the call
1013 * STR_NOERROR does not allow stream head read, write or hup errors to
1014 * affect the call. When used with strdoioctl(), if a previous ioctl
1015 * is pending and times out, STR_NOERROR will cause strdoioctl() to not
1016 * return ETIME. If, however, the requested ioctl times out, ETIME
1017 * will be returned (use ic_timout instead)
1018 * STR_PEEK is used to inform strwaitq that the reader is peeking at data
1019 * and that a non-persistent error should not be cleared.
1020 * STR_DELAYERR is used to inform strwaitq that it should not check errors
1021 * after being awoken since, in addition to an error, there might also be
1022 * data queued on the stream head read queue.
1023 */
1024 #define STR_NOSIG 0x10 /* Ignore signals during strdoioctl/strwaitq */
1025 #define STR_NOERROR 0x20 /* Ignore errors during strdoioctl/strwaitq */
1026 #define STR_PEEK 0x40 /* Peeking behavior on non-persistent errors */
1027 #define STR_DELAYERR 0x80 /* Do not check errors on return */
1028
1029 /*
1030 * Copy modes for tty and I_STR ioctls
1031 */
1032 #define U_TO_K 01 /* User to Kernel */
1033 #define K_TO_K 02 /* Kernel to Kernel */
1034
1035 /*
1036 * Mux defines.
1037 */
1038 #define LINKNORMAL 0x01 /* normal mux link */
1039 #define LINKPERSIST 0x02 /* persistent mux link */
1040 #define LINKTYPEMASK 0x03 /* bitmask of all link types */
1041 #define LINKCLOSE 0x04 /* unlink from strclose */
1042
1043 /*
1044 * Definitions of Streams macros and function interfaces.
1045 */
1046
1047 /*
1048 * Obsolete queue scheduling macros. They are not used anymore, but still kept
1049 * here for 3-d party modules and drivers who might still use them.
1050 */
1051 #define setqsched()
1052 #define qready() 1
1053
1054 #ifdef _KERNEL
1055 #define runqueues()
1056 #define queuerun()
1057 #endif
1058
1059 /* compatibility module for style 2 drivers with DR race condition */
1060 #define DRMODNAME "drcompat"
1061
1062 /*
1063 * Macros dealing with mux_nodes.
1064 */
1065 #define MUX_VISIT(X) ((X)->mn_flags |= VISITED)
1066 #define MUX_CLEAR(X) ((X)->mn_flags &= (~VISITED)); \
1067 ((X)->mn_originp = NULL)
1068 #define MUX_DIDVISIT(X) ((X)->mn_flags & VISITED)
1069
1070
1071 /*
1072 * Twisted stream macros
1073 */
1074 #define STRMATED(X) ((X)->sd_flag & STRMATE)
1075 #define STRLOCKMATES(X) if (&((X)->sd_lock) > &(((X)->sd_mate)->sd_lock)) { \
1076 mutex_enter(&((X)->sd_lock)); \
1077 mutex_enter(&(((X)->sd_mate)->sd_lock)); \
1078 } else { \
1079 mutex_enter(&(((X)->sd_mate)->sd_lock)); \
1080 mutex_enter(&((X)->sd_lock)); \
1081 }
1082 #define STRUNLOCKMATES(X) mutex_exit(&((X)->sd_lock)); \
1083 mutex_exit(&(((X)->sd_mate)->sd_lock))
1084
1085 #ifdef _KERNEL
1086
1087 extern void strinit(void);
1088 extern int strdoioctl(struct stdata *, struct strioctl *, int, int,
1089 cred_t *, int *);
1090 extern void strsendsig(struct strsig *, int, uchar_t, int);
1091 extern void str_sendsig(vnode_t *, int, uchar_t, int);
1092 extern void strhup(struct stdata *);
1093 extern int qattach(queue_t *, dev_t *, int, cred_t *, fmodsw_impl_t *,
1094 boolean_t);
1095 extern int qreopen(queue_t *, dev_t *, int, cred_t *);
1096 extern void qdetach(queue_t *, int, int, cred_t *, boolean_t);
1097 extern void enterq(queue_t *);
1098 extern void leaveq(queue_t *);
1099 extern int putiocd(mblk_t *, caddr_t, int, cred_t *);
1100 extern int getiocd(mblk_t *, caddr_t, int);
1101 extern struct linkinfo *alloclink(queue_t *, queue_t *, struct file *);
1102 extern void lbfree(struct linkinfo *);
1103 extern int linkcycle(stdata_t *, stdata_t *, str_stack_t *);
1104 extern struct linkinfo *findlinks(stdata_t *, int, int, str_stack_t *);
1105 extern queue_t *getendq(queue_t *);
1106 extern int mlink(vnode_t *, int, int, cred_t *, int *, int);
1107 extern int mlink_file(vnode_t *, int, struct file *, cred_t *, int *, int);
1108 extern int munlink(struct stdata *, struct linkinfo *, int, cred_t *, int *,
1109 str_stack_t *);
1110 extern int munlinkall(struct stdata *, int, cred_t *, int *, str_stack_t *);
1111 extern void mux_addedge(stdata_t *, stdata_t *, int, str_stack_t *);
1112 extern void mux_rmvedge(stdata_t *, int, str_stack_t *);
1113 extern int devflg_to_qflag(struct streamtab *, uint32_t, uint32_t *,
1114 uint32_t *);
1115 extern void setq(queue_t *, struct qinit *, struct qinit *, perdm_t *,
1116 uint32_t, uint32_t, boolean_t);
1117 extern perdm_t *hold_dm(struct streamtab *, uint32_t, uint32_t);
1118 extern void rele_dm(perdm_t *);
1119 extern int strmakectl(struct strbuf *, int32_t, int32_t, mblk_t **);
1120 extern int strmakedata(ssize_t *, struct uio *, stdata_t *, int32_t, mblk_t **);
1121 extern int strmakemsg(struct strbuf *, ssize_t *, struct uio *,
1122 struct stdata *, int32_t, mblk_t **);
1123 extern int strgetmsg(vnode_t *, struct strbuf *, struct strbuf *, uchar_t *,
1124 int *, int, rval_t *);
1125 extern int strputmsg(vnode_t *, struct strbuf *, struct strbuf *, uchar_t,
1126 int flag, int fmode);
1127 extern int strstartplumb(struct stdata *, int, int);
1128 extern void strendplumb(struct stdata *);
1129 extern int stropen(struct vnode *, dev_t *, int, cred_t *);
1130 extern int strclose(struct vnode *, int, cred_t *);
1131 extern int strpoll(register struct stdata *, short, int, short *,
1132 struct pollhead **);
1133 extern void strclean(struct vnode *);
1134 extern void str_cn_clean(); /* XXX hook for consoles signal cleanup */
1135 extern int strwrite(struct vnode *, struct uio *, cred_t *);
1136 extern int strwrite_common(struct vnode *, struct uio *, cred_t *, int);
1137 extern int strread(struct vnode *, struct uio *, cred_t *);
1138 extern int strioctl(struct vnode *, int, intptr_t, int, int, cred_t *, int *);
1139 extern int strrput(queue_t *, mblk_t *);
1140 extern int strrput_nondata(queue_t *, mblk_t *);
1141 extern mblk_t *strrput_proto(vnode_t *, mblk_t *,
1142 strwakeup_t *, strsigset_t *, strsigset_t *, strpollset_t *);
1143 extern mblk_t *strrput_misc(vnode_t *, mblk_t *,
1144 strwakeup_t *, strsigset_t *, strsigset_t *, strpollset_t *);
1145 extern int getiocseqno(void);
1146 extern int strwaitbuf(size_t, int);
1147 extern int strwaitq(stdata_t *, int, ssize_t, int, clock_t, int *);
1148 extern struct stdata *shalloc(queue_t *);
1149 extern void sh_insert_pid(struct stdata *, pid_t);
1150 extern void sh_remove_pid(struct stdata *, pid_t);
1151 extern mblk_t *sh_get_pid_mblk(struct stdata *);
1152 extern void shfree(struct stdata *s);
1153 extern queue_t *allocq(void);
1154 extern void freeq(queue_t *);
1155 extern qband_t *allocband(void);
1156 extern void freeband(qband_t *);
1157 extern void freebs_enqueue(mblk_t *, dblk_t *);
1158 extern void setqback(queue_t *, unsigned char);
1159 extern int strcopyin(void *, void *, size_t, int);
1160 extern int strcopyout(void *, void *, size_t, int);
1161 extern void strsignal(struct stdata *, int, int32_t);
1162 extern clock_t str_cv_wait(kcondvar_t *, kmutex_t *, clock_t, int);
1163 extern void disable_svc(queue_t *);
1164 extern void enable_svc(queue_t *);
1165 extern void remove_runlist(queue_t *);
1166 extern void wait_svc(queue_t *);
1167 extern void backenable(queue_t *, uchar_t);
1168 extern void set_qend(queue_t *);
1169 extern int strgeterr(stdata_t *, int32_t, int);
1170 extern void qenable_locked(queue_t *);
1171 extern mblk_t *getq_noenab(queue_t *, ssize_t);
1172 extern void rmvq_noenab(queue_t *, mblk_t *);
1173 extern void qbackenable(queue_t *, uchar_t);
1174 extern void set_qfull(queue_t *);
1175
1176 extern void strblock(queue_t *);
1177 extern void strunblock(queue_t *);
1178 extern int qclaimed(queue_t *);
1179 extern int straccess(struct stdata *, enum jcaccess);
1180
1181 extern void entersq(syncq_t *, int);
1182 extern void leavesq(syncq_t *, int);
1183 extern void claimq(queue_t *);
1184 extern void releaseq(queue_t *);
1185 extern void claimstr(queue_t *);
1186 extern void releasestr(queue_t *);
1187 extern void removeq(queue_t *);
1188 extern void insertq(struct stdata *, queue_t *);
1189 extern void drain_syncq(syncq_t *);
1190 extern void qfill_syncq(syncq_t *, queue_t *, mblk_t *);
1191 extern void qdrain_syncq(syncq_t *, queue_t *);
1192 extern int flush_syncq(syncq_t *, queue_t *);
1193 extern void wait_sq_svc(syncq_t *);
1194
1195 extern void outer_enter(syncq_t *, uint16_t);
1196 extern void outer_exit(syncq_t *);
1197 extern void qwriter_inner(queue_t *, mblk_t *, void (*)());
1198 extern void qwriter_outer(queue_t *, mblk_t *, void (*)());
1199
1200 extern callbparams_t *callbparams_alloc(syncq_t *, void (*)(void *),
1201 void *, int);
1202 extern void callbparams_free(syncq_t *, callbparams_t *);
1203 extern void callbparams_free_id(syncq_t *, callbparams_id_t, int32_t);
1204 extern void qcallbwrapper(void *);
1205
1206 extern mblk_t *esballoc_wait(unsigned char *, size_t, uint_t, frtn_t *);
1207 extern mblk_t *esballoca(unsigned char *, size_t, uint_t, frtn_t *);
1208 extern mblk_t *desballoca(unsigned char *, size_t, uint_t, frtn_t *);
1209 extern int do_sendfp(struct stdata *, struct file *, struct cred *);
1210 extern int frozenstr(queue_t *);
1211 extern size_t xmsgsize(mblk_t *);
1212
1213 extern void putnext_tail(syncq_t *, queue_t *, uint32_t);
1214 extern void stream_willservice(stdata_t *);
1215 extern void stream_runservice(stdata_t *);
1216
1217 extern void strmate(vnode_t *, vnode_t *);
1218 extern queue_t *strvp2wq(vnode_t *);
1219 extern vnode_t *strq2vp(queue_t *);
1220 extern mblk_t *allocb_wait(size_t, uint_t, uint_t, int *);
1221 extern mblk_t *allocb_cred(size_t, cred_t *, pid_t);
1222 extern mblk_t *allocb_cred_wait(size_t, uint_t, int *, cred_t *, pid_t);
1223 extern mblk_t *allocb_tmpl(size_t, const mblk_t *);
1224 extern mblk_t *allocb_tryhard(size_t);
1225 extern void mblk_copycred(mblk_t *, const mblk_t *);
1226 extern void mblk_setcred(mblk_t *, cred_t *, pid_t);
1227 extern cred_t *msg_getcred(const mblk_t *, pid_t *);
1228 extern struct ts_label_s *msg_getlabel(const mblk_t *);
1229 extern cred_t *msg_extractcred(mblk_t *, pid_t *);
1230 extern void strpollwakeup(vnode_t *, short);
1231 extern int putnextctl_wait(queue_t *, int);
1232
1233 extern int kstrputmsg(struct vnode *, mblk_t *, struct uio *, ssize_t,
1234 unsigned char, int, int);
1235 extern int kstrgetmsg(struct vnode *, mblk_t **, struct uio *,
1236 unsigned char *, int *, clock_t, rval_t *);
1237
1238 extern void strsetrerror(vnode_t *, int, int, errfunc_t);
1239 extern void strsetwerror(vnode_t *, int, int, errfunc_t);
1240 extern void strseteof(vnode_t *, int);
1241 extern void strflushrq(vnode_t *, int);
1242 extern void strsetrputhooks(vnode_t *, uint_t, msgfunc_t, msgfunc_t);
1243 extern void strsetwputhooks(vnode_t *, uint_t, clock_t);
1244 extern void strsetrwputdatahooks(vnode_t *, msgfunc_t, msgfunc_t);
1245 extern int strwaitmark(vnode_t *);
1246 extern void strsignal_nolock(stdata_t *, int, uchar_t);
1247
1248 struct multidata_s;
1249 struct pdesc_s;
1250 extern int hcksum_assoc(mblk_t *, struct multidata_s *, struct pdesc_s *,
1251 uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int);
1252 extern void hcksum_retrieve(mblk_t *, struct multidata_s *, struct pdesc_s *,
1253 uint32_t *, uint32_t *, uint32_t *, uint32_t *, uint32_t *);
1254 extern void lso_info_set(mblk_t *, uint32_t, uint32_t);
1255 extern void lso_info_cleanup(mblk_t *);
1256 extern unsigned int bcksum(uchar_t *, int, unsigned int);
1257 extern boolean_t is_vmloaned_mblk(mblk_t *, struct multidata_s *,
1258 struct pdesc_s *);
1259
1260 extern int fmodsw_register(const char *, struct streamtab *, int);
1261 extern int fmodsw_unregister(const char *);
1262 extern fmodsw_impl_t *fmodsw_find(const char *, fmodsw_flags_t);
1263 extern void fmodsw_rele(fmodsw_impl_t *);
1264
1265 extern void freemsgchain(mblk_t *);
1266 extern mblk_t *copymsgchain(mblk_t *);
1267
1268 extern mblk_t *mcopyinuio(struct stdata *, uio_t *, ssize_t, ssize_t, int *);
1269
1270 /*
1271 * shared or externally configured data structures
1272 */
1273 extern ssize_t strmsgsz; /* maximum stream message size */
1274 extern ssize_t strctlsz; /* maximum size of ctl message */
1275 extern int nstrpush; /* maximum number of pushes allowed */
1276
1277 /*
1278 * Bufcalls related variables.
1279 */
1280 extern struct bclist strbcalls; /* List of bufcalls */
1281 extern kmutex_t strbcall_lock; /* Protects the list of bufcalls */
1282 extern kcondvar_t strbcall_cv; /* Signaling when a bufcall is added */
1283 extern kcondvar_t bcall_cv; /* wait of executing bufcall completes */
1284
1285 extern frtn_t frnop;
1286
1287 extern struct kmem_cache *ciputctrl_cache;
1288 extern int n_ciputctrl;
1289 extern int max_n_ciputctrl;
1290 extern int min_n_ciputctrl;
1291
1292 extern cdevsw_impl_t *devimpl;
1293
1294 /*
1295 * esballoc queue for throttling
1296 */
1297 typedef struct esb_queue {
1298 kmutex_t eq_lock;
1299 uint_t eq_len; /* number of queued messages */
1300 mblk_t *eq_head; /* head of queue */
1301 mblk_t *eq_tail; /* tail of queue */
1302 uint_t eq_flags; /* esballoc queue flags */
1303 } esb_queue_t;
1304
1305 /*
1306 * esballoc flags for queue processing.
1307 */
1308 #define ESBQ_PROCESSING 0x01 /* queue is being processed */
1309 #define ESBQ_TIMER 0x02 /* timer is active */
1310
1311 extern void esballoc_queue_init(void);
1312
1313 #endif /* _KERNEL */
1314
1315 /*
1316 * Note: Use of these macros are restricted to kernel/unix and
1317 * intended for the STREAMS framework.
1318 * All modules/drivers should include sys/ddi.h.
1319 *
1320 * Finding related queues
1321 */
1322 #define _OTHERQ(q) ((q)->q_flag&QREADR? (q)+1: (q)-1)
1323 #define _WR(q) ((q)->q_flag&QREADR? (q)+1: (q))
1324 #define _RD(q) ((q)->q_flag&QREADR? (q): (q)-1)
1325 #define _SAMESTR(q) (!((q)->q_flag & QEND))
1326
1327 /*
1328 * These are also declared here for modules/drivers that erroneously
1329 * include strsubr.h after ddi.h or fail to include ddi.h at all.
1330 */
1331 extern struct queue *OTHERQ(queue_t *); /* stream.h */
1332 extern struct queue *RD(queue_t *);
1333 extern struct queue *WR(queue_t *);
1334 extern int SAMESTR(queue_t *);
1335
1336 /*
1337 * The following hardware checksum related macros are private
1338 * interfaces that are subject to change without notice.
1339 */
1340 #ifdef _KERNEL
1341 #define DB_CKSUMSTART(mp) ((mp)->b_datap->db_cksumstart)
1342 #define DB_CKSUMEND(mp) ((mp)->b_datap->db_cksumend)
1343 #define DB_CKSUMSTUFF(mp) ((mp)->b_datap->db_cksumstuff)
1344 #define DB_CKSUMFLAGS(mp) ((mp)->b_datap->db_struioun.cksum.flags)
1345 #define DB_CKSUM16(mp) ((mp)->b_datap->db_cksum16)
1346 #define DB_CKSUM32(mp) ((mp)->b_datap->db_cksum32)
1347 #define DB_LSOFLAGS(mp) ((mp)->b_datap->db_struioun.cksum.flags)
1348 #define DB_LSOMSS(mp) ((mp)->b_datap->db_struioun.cksum.pad)
1349 #endif /* _KERNEL */
1350
1351 #ifdef __cplusplus
1352 }
1353 #endif
1354
1355
1356 #endif /* _SYS_STRSUBR_H */