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