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