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