usr/src/uts/common/sys/stream.h

   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 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  27 /*        All Rights Reserved   */
  28
  29
  30 #ifndef _SYS_STREAM_H
  31 #define _SYS_STREAM_H
  32
  33 /*
  34  * For source compatibility
  35  */
  36 #include <sys/isa_defs.h>
  37 #ifdef _KERNEL
  38 #include <sys/vnode.h>
  39 #endif
  40 #include <sys/poll.h>
  41 #include <sys/strmdep.h>
  42 #include <sys/cred.h>
  43 #include <sys/t_lock.h>
  44 #include <sys/model.h>
  45
  46 #ifdef  __cplusplus
  47 extern "C" {
  48 #endif
  49
  50 /*
  51  * Data queue.
  52  *
  53  * NOTE: The *only* public fields are documented in queue(9S).
  54  *       Everything else is implementation-private.
  55  *
  56  * The locking rules for the queue_t structure are extremely subtle and vary
  57  * widely depending on the field in question.  As such, each field is
  58  * annotated according to the following legend:
  59  *
  60  *   Q9S: The field is documented in queue(9S) and may be accessed without
  61  *        locks by a STREAMS module when inside an entry point (e.g., put(9E)).
  62  *        However, no fields can be directly modified unless q_lock is held
  63  *        (which is not possible in a DDI compliant STREAMS module), with the
  64  *        following exceptions:
  65  *
  66  *         - q_ptr: can be modified as per the rules of the STREAMS module.
  67  *                  The STREAMS framework ignores q_ptr and thus imposes *no*
  68  *                  locking rules on it.
  69  *         - q_qinfo: can be modified before qprocson().
  70  *
  71  *         - q_minpsz, q_maxpsz, q_hiwat, q_lowat: can be modified as per the
  72  *                  rules of the STREAMS module.  The STREAMS framework never
  73  *                  modifies these fields, and is tolerant of temporarily
  74  *                  stale field values.
  75  *
  76  *        In general, the STREAMS framework employs one of the following
  77  *        techniques to ensure STREAMS modules can safely access Q9S fields:
  78  *
  79  *         - The field is only modified by the framework when the stream is
  80  *           locked with strlock() (q_next).
  81  *
  82  *         - The field is modified by the framework, but the modifies are
  83  *           atomic, and temporarily stale values are harmless (q_count,
  84  *           q_first, q_last).
  85  *
  86  *         - The field is modified by the framework, but the field's visible
  87  *           values are either constant or directly under the control
  88  *           of the STREAMS module itself (q_flag).
  89  *
  90  *   QLK: The field must be accessed or modified under q_lock, except when
  91  *        the stream has been locked with strlock().  If multiple q_locks must
  92  *        be acquired, q_locks at higher addresses must be taken first.
  93  *
  94  *   STR: The field can be accessed without a lock, but must be modified under
  95  *        strlock().
  96  *
  97  *   SQLK: The field must be accessed or modified under SQLOCK().
  98  *
  99  *   NOLK: The field can be accessed without a lock, but can only be modified
 100  *         when the queue_t is not known to any other threads.
 101  *
 102  *   SVLK: The field must be accessed or modified under the service_queue lock.
 103  *         Note that service_lock must be taken after any needed q_locks,
 104  *         and that no other lock should be taken while service_lock is held.
 105  *
 106  * In addition, it is always acceptable to modify a field that is not yet
 107  * known to any other threads -- and other special case exceptions exist in
 108  * the code.  Also, q_lock is used with q_wait to implement a stream head
 109  * monitor for reads and writes.
 110  */
 111 typedef struct queue {
 112         struct qinit    *q_qinfo;       /* Q9S: Q processing procedure  */
 113         struct msgb     *q_first;       /* Q9S: first message in Q      */
 114         struct msgb     *q_last;        /* Q9S: last message in Q       */
 115         struct queue    *q_next;        /* Q9S: next Q in stream        */
 116         struct queue    *q_link;        /* SVLK: next Q for scheduling  */
 117         void            *q_ptr;         /* Q9S: module-specific data    */
 118         size_t          q_count;        /* Q9S: number of bytes on Q    */
 119         uint_t          q_flag;         /* Q9S: Q state                 */
 120         ssize_t         q_minpsz;       /* Q9S: smallest packet OK on Q */
 121         ssize_t         q_maxpsz;       /* Q9S: largest packet OK on Q  */
 122         size_t          q_hiwat;        /* Q9S: Q high water mark       */
 123         size_t          q_lowat;        /* Q9S: Q low water mark        */
 124         struct qband    *q_bandp;       /* QLK: band flow information   */
 125         kmutex_t        q_lock;         /* NOLK: structure lock         */
 126         struct stdata   *q_stream;      /* NOLK: stream backpointer     */
 127         struct syncq    *q_syncq;       /* NOLK: associated syncq       */
 128         unsigned char   q_nband;        /* QLK: number of bands         */
 129         kcondvar_t      q_wait;         /* NOLK: read/write sleep CV    */
 130         struct queue    *q_nfsrv;       /* STR: next Q with svc routine */
 131         ushort_t        q_draining;     /* QLK: Q is draining           */
 132         short           q_struiot;      /* QLK: sync streams Q UIO mode */
 133         clock_t         q_qtstamp;      /* QLK: when Q was enabled      */
 134         size_t          q_mblkcnt;      /* QLK: mblk count              */
 135         uint_t          q_syncqmsgs;    /* QLK: syncq message count     */
 136         size_t          q_rwcnt;        /* QLK: # threads in rwnext()   */
 137         pri_t           q_spri;         /* QLK: Q scheduling priority   */
 138
 139         /*
 140          * Syncq scheduling
 141          */
 142         struct msgb     *q_sqhead;      /* QLK: first syncq message     */
 143         struct msgb     *q_sqtail;      /* QLK: last syncq message      */
 144         struct queue    *q_sqnext;      /* SQLK: next Q on syncq list   */
 145         struct queue    *q_sqprev;      /* SQLK: prev Q on syncq list   */
 146         uint_t          q_sqflags;      /* SQLK: syncq flags            */
 147         clock_t         q_sqtstamp;     /* SQLK: when Q was scheduled for sq */
 148
 149         /*
 150          * NOLK: Reference to the queue's module's implementation
 151          * structure. This will be NULL for queues associated with drivers.
 152          */
 153         struct fmodsw_impl      *q_fp;
 154 } queue_t;
 155
 156 /*
 157  * Queue flags; unused flags not documented in queue(9S) can be recycled.
 158  */
 159 #define QENAB           0x00000001      /* Queue is already enabled to run */
 160 #define QWANTR          0x00000002      /* Someone wants to read Q      */
 161 #define QWANTW          0x00000004      /* Someone wants to write Q     */
 162 #define QFULL           0x00000008      /* Q is considered full         */
 163 #define QREADR          0x00000010      /* This is the reader (first) Q */
 164 #define QUSE            0x00000020      /* This queue in use (allocation) */
 165 #define QNOENB          0x00000040      /* Don't enable Q via putq      */
 166 #define QWANTRMQSYNC    0x00000080      /* Want to remove sync stream Q */
 167 #define QBACK           0x00000100      /* queue has been back-enabled  */
 168 /*      UNUSED          0x00000200         was QHLIST                   */
 169 /*      UNUSED          0x00000400         was QUNSAFE                  */
 170 #define QPAIR           0x00000800      /* per queue-pair syncq         */
 171 #define QPERQ           0x00001000      /* per queue-instance syncq     */
 172 #define QPERMOD         0x00002000      /* per module syncq             */
 173 #define QMTSAFE         0x00004000      /* stream module is MT-safe     */
 174 #define QMTOUTPERIM     0x00008000      /* Has outer perimeter          */
 175 #define QMT_TYPEMASK    (QPAIR|QPERQ|QPERMOD|QMTSAFE|QMTOUTPERIM)
 176                                         /* all MT type flags            */
 177 #define QINSERVICE      0x00010000      /* service routine executing    */
 178 #define QWCLOSE         0x00020000      /* will not be enabled          */
 179 #define QEND            0x00040000      /* last queue in stream         */
 180 #define QWANTWSYNC      0x00080000      /* Streamhead wants to write Q  */
 181 #define QSYNCSTR        0x00100000      /* Q supports Synchronous STREAMS */
 182 #define QISDRV          0x00200000      /* the Queue is attached to a driver */
 183 /*      UNUSED          0x00400000         was QHOT                     */
 184 /*      UNUSED          0x00800000         was QNEXTHOT                 */
 185 /*      UNUSED          0x01000000         was _QNEXTLESS               */
 186 #define _QINSERTING     0x04000000      /* Private, module is being inserted */
 187 #define _QREMOVING      0x08000000      /* Private, module is being removed */
 188 #define _QASSOCIATED    0x10000000      /* queue is associated with a device */
 189 #define _QDIRECT        0x20000000      /* Private; transport module uses */
 190                                         /* direct interface to/from sockfs */
 191 #define _QSODIRECT      0x40000000      /* Private, transport module shares */
 192                                         /* an sodirect_t with sockfs */
 193
 194 /* queue sqflags (protected by SQLOCK). */
 195 #define Q_SQQUEUED      0x01            /* Queue is in the syncq list */
 196 #define Q_SQDRAINING    0x02            /* Servicing syncq msgs.        */
 197                                         /* This is also noted by the    */
 198                                         /* q_draining field, but this one is */
 199                                         /* protected by SQLOCK */
 200
 201 /*
 202  * Structure that describes the separate information
 203  * for each priority band in the queue.
 204  */
 205 typedef struct qband {
 206         struct qband    *qb_next;       /* next band's info */
 207         size_t          qb_count;       /* number of bytes in band */
 208         struct msgb     *qb_first;      /* beginning of band's data */
 209         struct msgb     *qb_last;       /* end of band's data */
 210         size_t          qb_hiwat;       /* high water mark for band */
 211         size_t          qb_lowat;       /* low water mark for band */
 212         uint_t          qb_flag;        /* see below */
 213         size_t          qb_mblkcnt;     /* mblk counter for runaway msgs */
 214 } qband_t;
 215
 216 /*
 217  * qband flags
 218  */
 219 #define QB_FULL         0x01            /* band is considered full */
 220 #define QB_WANTW        0x02            /* Someone wants to write to band */
 221 #define QB_BACK         0x04            /* queue has been back-enabled */
 222
 223 /*
 224  * Maximum number of bands.
 225  */
 226 #define NBAND   256
 227
 228 /*
 229  * Fields that can be manipulated through strqset() and strqget().
 230  */
 231 typedef enum qfields {
 232         QHIWAT  = 0,            /* q_hiwat or qb_hiwat */
 233         QLOWAT  = 1,            /* q_lowat or qb_lowat */
 234         QMAXPSZ = 2,            /* q_maxpsz */
 235         QMINPSZ = 3,            /* q_minpsz */
 236         QCOUNT  = 4,            /* q_count or qb_count */
 237         QFIRST  = 5,            /* q_first or qb_first */
 238         QLAST   = 6,            /* q_last or qb_last */
 239         QFLAG   = 7,            /* q_flag or qb_flag */
 240         QSTRUIOT = 8,           /* q_struiot */
 241         QBAD    = 9
 242 } qfields_t;
 243
 244 /*
 245  * Module information structure
 246  */
 247 struct module_info {
 248         ushort_t mi_idnum;              /* module id number */
 249         char    *mi_idname;             /* module name */
 250         ssize_t mi_minpsz;              /* min packet size accepted */
 251         ssize_t mi_maxpsz;              /* max packet size accepted */
 252         size_t  mi_hiwat;               /* hi-water mark */
 253         size_t  mi_lowat;               /* lo-water mark */
 254 };
 255
 256 /*
 257  * queue information structure (with Synchronous STREAMS extensions)
 258  */
 259 struct  qinit {
 260         int     (*qi_putp)();           /* put procedure */
 261         int     (*qi_srvp)();           /* service procedure */
 262         int     (*qi_qopen)();          /* called on startup */
 263         int     (*qi_qclose)();         /* called on finish */
 264         int     (*qi_qadmin)();         /* for future use */
 265         struct module_info *qi_minfo;   /* module information structure */
 266         struct module_stat *qi_mstat;   /* module statistics structure */
 267         int     (*qi_rwp)();            /* r/w procedure */
 268         int     (*qi_infop)();          /* information procedure */
 269         int     qi_struiot;             /* stream uio type for struio() */
 270 };
 271
 272 /*
 273  * Values for qi_struiot and q_struiot:
 274  */
 275 #define STRUIOT_NONE            -1      /* doesn't support struio() */
 276 #define STRUIOT_DONTCARE        0       /* use current uiomove() (default) */
 277 #define STRUIOT_STANDARD        1       /* use standard uiomove() */
 278
 279 /*
 280  * Streamtab (used in cdevsw and fmodsw to point to module or driver)
 281  */
 282 struct streamtab {
 283         struct qinit *st_rdinit;
 284         struct qinit *st_wrinit;
 285         struct qinit *st_muxrinit;
 286         struct qinit *st_muxwinit;
 287 };
 288
 289 /*
 290  * Structure sent to mux drivers to indicate a link.
 291  */
 292 struct linkblk {
 293         queue_t *l_qtop;        /* lowest level write queue of upper stream */
 294                                 /* (set to NULL for persistent links) */
 295         queue_t *l_qbot;        /* highest level write queue of lower stream */
 296         int     l_index;        /* index for lower stream. */
 297 };
 298
 299 /*
 300  * Esballoc data buffer freeing routine
 301  */
 302 typedef struct free_rtn {
 303         void    (*free_func)();
 304         caddr_t free_arg;
 305 } frtn_t;
 306
 307 /*
 308  * Data block descriptor
 309  *
 310  * NOTE: db_base, db_lim, db_ref and db_type are the *only* public fields,
 311  * as described in datab(9S).  Everything else is implementation-private.
 312  */
 313
 314 #define DBLK_REFMAX     255U
 315
 316 typedef struct datab {
 317         frtn_t          *db_frtnp;
 318         unsigned char   *db_base;
 319         unsigned char   *db_lim;
 320         unsigned char   db_ref;
 321         unsigned char   db_type;
 322         unsigned char   db_flags;
 323         unsigned char   db_struioflag;
 324         pid_t           db_cpid;        /* cached pid, needs verification */
 325         void            *db_cache;      /* kmem cache descriptor */
 326         struct msgb     *db_mblk;
 327         void            (*db_free)(struct msgb *, struct datab *);
 328         void            (*db_lastfree)(struct msgb *, struct datab *);
 329         intptr_t        db_cksumstart;
 330         intptr_t        db_cksumend;
 331         intptr_t        db_cksumstuff;
 332         union {
 333                 double enforce_alignment;
 334                 unsigned char data[8];
 335                 struct {
 336                         union {
 337                                 uint32_t u32;
 338                                 uint16_t u16;
 339                         } cksum_val;    /* used to store calculated cksum */
 340                         uint16_t flags;
 341                         uint16_t pad;
 342                 } cksum;
 343                 /*
 344                  * Union used for future extensions (pointer to data ?).
 345                  */
 346         } db_struioun;
 347         struct fthdr    *db_fthdr;
 348         cred_t          *db_credp;      /* credential */
 349 } dblk_t;
 350
 351 #define db_cksum16      db_struioun.cksum.cksum_val.u16
 352 #define db_cksum32      db_struioun.cksum.cksum_val.u32
 353
 354 /*
 355  * Accessor macros for private dblk_t fields (the rest are in <sys/strsun.h>).
 356  */
 357 #define DB_CPID(mp)             ((mp)->b_datap->db_cpid)
 358 #define DB_CRED(mp)             ((mp)->b_datap->db_credp)
 359 #define DB_FTHDR(mp)            ((mp)->b_datap->db_fthdr)
 360 /*
 361  * Used by GLDv2 to store the TCI information.
 362  */
 363 #define DB_TCI(mp)              ((mp)->b_datap->db_struioun.cksum.pad)
 364
 365 /*
 366  * Message block descriptor
 367  */
 368 typedef struct  msgb {
 369         struct  msgb    *b_next;
 370         struct  msgb    *b_prev;
 371         struct  msgb    *b_cont;
 372         unsigned char   *b_rptr;
 373         unsigned char   *b_wptr;
 374         struct datab    *b_datap;
 375         unsigned char   b_band;
 376         unsigned char   b_tag;
 377         unsigned short  b_flag;
 378         queue_t         *b_queue;       /* for sync queues */
 379 } mblk_t;
 380
 381 /*
 382  * bcache descriptor
 383  */
 384 typedef struct  bcache {
 385         kmutex_t                mutex;
 386         struct kmem_cache       *buffer_cache;
 387         struct kmem_cache       *dblk_cache;
 388         int                     alloc;
 389         int                     destroy;
 390         size_t                  size;
 391         uint_t                  align;
 392 } bcache_t;
 393
 394 /*
 395  * db_flags values (all implementation private!)
 396  */
 397 #define DBLK_REFMIN             0x01    /* min refcnt stored in low bit */
 398 #define DBLK_COOKED             0x02    /* message has been processed once */
 399 #define DBLK_UIOA               0x04    /* uioamove() is pending */
 400
 401 /*
 402  * db_struioflag values:
 403  */
 404 #define STRUIO_SPEC     0x01    /* struio{get,put}() special mblk */
 405 #define STRUIO_DONE     0x02    /* struio done (could be partial) */
 406 #define STRUIO_IP       0x04    /* IP checksum stored in db_struioun */
 407 #define STRUIO_ZC       0x08    /* mblk eligible for zero-copy */
 408 #define STRUIO_ZCNOTIFY 0x10    /* notify stream head when mblk acked */
 409 #define STRUIO_EAGER    0x20    /* new eager; db_cksumstart has squeue to use */
 410 #define STRUIO_POLICY   0x40    /* new eager when IPsec is enabled */
 411 #define STRUIO_CONNECT  0x80    /* conn did a connect */
 412
 413 /*
 414  * Message flags.  These are interpreted by the stream head.
 415  */
 416 #define MSGMARK         0x01    /* last byte of message is "marked" */
 417 #define MSGNOLOOP       0x02    /* don't loop message around to */
 418                                 /* write side of stream */
 419 #define MSGDELIM        0x04    /* message is delimited */
 420 /*      UNUSED          0x08       was MSGNOGET (can be recycled) */
 421 #define MSGMARKNEXT     0x10    /* Private: first byte of next msg marked */
 422 #define MSGNOTMARKNEXT  0x20    /* Private: ... not marked */
 423 #define MSGHASREF       0x40    /* Private: message has reference to owner */
 424 #define MSGWAITSYNC     0x80    /* Private: waiting for sync squeue enter */
 425
 426 /*
 427  * Streams message types.
 428  */
 429
 430 /*
 431  * Data and protocol messages (regular and priority)
 432  */
 433 #define M_DATA          0x00            /* regular data */
 434 #define M_PROTO         0x01            /* protocol control */
 435 #define M_MULTIDATA     0x02            /* reserved for Multidata use only */
 436
 437 /*
 438  * Control messages (regular and priority)
 439  */
 440 #define M_BREAK         0x08            /* line break */
 441 #define M_PASSFP        0x09            /* pass file pointer */
 442 #define M_EVENT         0x0a            /* Obsoleted: do not use */
 443 #define M_SIG           0x0b            /* generate process signal */
 444 #define M_DELAY         0x0c            /* real-time xmit delay (1 param) */
 445 #define M_CTL           0x0d            /* device-specific control message */
 446 #define M_IOCTL         0x0e            /* ioctl; set/get params */
 447 #define M_SETOPTS       0x10            /* set various stream head options */
 448 #define M_RSE           0x11            /* reserved for RSE use only */
 449
 450 /*
 451  * Control messages (high priority; go to head of queue)
 452  */
 453 #define M_IOCACK        0x81            /* acknowledge ioctl */
 454 #define M_IOCNAK        0x82            /* negative ioctl acknowledge */
 455 #define M_PCPROTO       0x83            /* priority proto message */
 456 #define M_PCSIG         0x84            /* generate process signal */
 457 #define M_READ          0x85            /* generate read notification */
 458 #define M_FLUSH         0x86            /* flush your queues */
 459 #define M_STOP          0x87            /* stop transmission immediately */
 460 #define M_START         0x88            /* restart transmission after stop */
 461 #define M_HANGUP        0x89            /* line disconnect */
 462 #define M_ERROR         0x8a            /* send error to stream head */
 463 #define M_COPYIN        0x8b            /* request to copyin data */
 464 #define M_COPYOUT       0x8c            /* request to copyout data */
 465 #define M_IOCDATA       0x8d            /* response to M_COPYIN and M_COPYOUT */
 466 #define M_PCRSE         0x8e            /* reserved for RSE use only */
 467 #define M_STOPI         0x8f            /* stop reception immediately */
 468 #define M_STARTI        0x90            /* restart reception after stop */
 469 #define M_PCEVENT       0x91            /* Obsoleted: do not use */
 470 #define M_UNHANGUP      0x92            /* line reconnect, sigh */
 471 #define M_CMD           0x93            /* out-of-band ioctl command */
 472
 473 /*
 474  * Queue message class definitions.
 475  */
 476 #define QNORM           0x00            /* normal priority messages */
 477 #define QPCTL           0x80            /* high priority cntrl messages */
 478
 479 /*
 480  *  IOCTL structure - this structure is the format of the M_IOCTL message type.
 481  */
 482 #if     defined(_LP64)
 483 struct iocblk {
 484         int     ioc_cmd;                /* ioctl command type */
 485         cred_t  *ioc_cr;                /* full credentials */
 486         uint_t  ioc_id;                 /* ioctl id */
 487         uint_t  ioc_flag;               /* see below */
 488         size_t  ioc_count;              /* count of bytes in data field */
 489         int     ioc_rval;               /* return value  */
 490         int     ioc_error;              /* error code */
 491 };
 492 #else
 493 struct iocblk {
 494         int     ioc_cmd;                /* ioctl command type */
 495         cred_t  *ioc_cr;                /* full credentials */
 496         uint_t  ioc_id;                 /* ioctl id */
 497         size_t  ioc_count;              /* count of bytes in data field */
 498         int     ioc_error;              /* error code */
 499         int     ioc_rval;               /* return value  */
 500         int     ioc_fill1;
 501         uint_t  ioc_flag;               /* see below */
 502         int     ioc_filler[2];          /* reserved for future use */
 503 };
 504 #endif  /* _LP64 */
 505
 506 typedef struct iocblk   *IOCP;
 507
 508 /* {ioc,cp}_flags values */
 509
 510 #define IOC_MODELS      DATAMODEL_MASK  /* Note: 0x0FF00000 */
 511 #define IOC_ILP32       DATAMODEL_ILP32 /* ioctl origin is ILP32 */
 512 #define IOC_LP64        DATAMODEL_LP64  /* ioctl origin is LP64 */
 513 #define IOC_NATIVE      DATAMODEL_NATIVE
 514 #define IOC_NONE        DATAMODEL_NONE  /* dummy comparison value */
 515
 516 /*
 517  *      Is the ioctl data formatted for our native model?
 518  */
 519 #define IOC_CONVERT_FROM(iocp)  ddi_model_convert_from( \
 520                                     ((struct iocblk *)iocp)->ioc_flag)
 521
 522 /*
 523  * structure for the M_COPYIN and M_COPYOUT message types.
 524  */
 525 #if     defined(_LP64)
 526 struct copyreq {
 527         int     cq_cmd;                 /* ioctl command (from ioc_cmd) */
 528         cred_t  *cq_cr;                 /* full credentials (from ioc_cmd) */
 529         uint_t  cq_id;                  /* ioctl id (from ioc_id) */
 530         uint_t  cq_flag;                /* must be zero */
 531         mblk_t  *cq_private;            /* private state information */
 532         caddr_t cq_addr;                /* address to copy data to/from */
 533         size_t  cq_size;                /* number of bytes to copy */
 534 };
 535 #else
 536 struct copyreq {
 537         int     cq_cmd;                 /* ioctl command (from ioc_cmd) */
 538         cred_t  *cq_cr;                 /* full credentials */
 539         uint_t  cq_id;                  /* ioctl id (from ioc_id) */
 540         caddr_t cq_addr;                /* address to copy data to/from */
 541         size_t  cq_size;                /* number of bytes to copy */
 542         uint_t  cq_flag;                /* must be zero */
 543         mblk_t  *cq_private;            /* private state information */
 544         int     cq_filler[4];           /* reserved for future use */
 545 };
 546 #endif  /* _LP64 */
 547
 548 /*
 549  * structure for the M_IOCDATA message type.
 550  */
 551 #if     defined(_LP64)
 552 struct copyresp {
 553         int     cp_cmd;                 /* ioctl command (from ioc_cmd) */
 554         cred_t  *cp_cr;                 /* full credentials (from ioc_cmd) */
 555         uint_t  cp_id;                  /* ioctl id (from ioc_id) */
 556         uint_t  cp_flag;                /* datamodel IOC_ flags; see above */
 557         mblk_t *cp_private;             /* private state information */
 558         caddr_t cp_rval;                /* status of request: 0 -> success */
 559                                         /*              non-zero -> failure */
 560 };
 561 #else
 562 struct copyresp {
 563         int     cp_cmd;                 /* ioctl command (from ioc_cmd) */
 564         cred_t  *cp_cr;                 /* full credentials */
 565         uint_t  cp_id;                  /* ioctl id (from ioc_id) */
 566         caddr_t cp_rval;                /* status of request: 0 -> success */
 567                                         /*              non-zero -> failure */
 568         size_t  cp_pad1;
 569         uint_t  cp_pad2;
 570         mblk_t *cp_private;             /* private state information */
 571         uint_t  cp_flag;                /* datamodel IOC_ flags; see above */
 572         int     cp_filler[3];
 573 };
 574 #endif  /* _LP64 */
 575
 576 /*
 577  * Since these structures are all intended to travel in the same message
 578  * at different stages of a STREAMS ioctl, this union is used to determine
 579  * the message size in strdoioctl().
 580  */
 581 union ioctypes {
 582         struct iocblk   iocblk;
 583         struct copyreq  copyreq;
 584         struct copyresp copyresp;
 585 };
 586
 587 /*
 588  * Options structure for M_SETOPTS message.  This is sent upstream
 589  * by a module or driver to set stream head options.
 590  */
 591 struct stroptions {
 592         uint_t  so_flags;               /* options to set */
 593         short   so_readopt;             /* read option */
 594         ushort_t so_wroff;              /* write offset */
 595         ssize_t so_minpsz;              /* minimum read packet size */
 596         ssize_t so_maxpsz;              /* maximum read packet size */
 597         size_t  so_hiwat;               /* read queue high water mark */
 598         size_t  so_lowat;               /* read queue low water mark */
 599         unsigned char so_band;          /* band for water marks */
 600         ushort_t so_erropt;             /* error option */
 601         ssize_t so_maxblk;              /* maximum message block size */
 602         ushort_t so_copyopt;            /* copy options (see stropts.h) */
 603         ushort_t so_tail;               /* space available at the end */
 604 };
 605
 606 /* flags for stream options set message */
 607
 608 #define SO_ALL          0x003f  /* set all old options */
 609 #define SO_READOPT      0x0001  /* set read option */
 610 #define SO_WROFF        0x0002  /* set write offset */
 611 #define SO_MINPSZ       0x0004  /* set min packet size */
 612 #define SO_MAXPSZ       0x0008  /* set max packet size */
 613 #define SO_HIWAT        0x0010  /* set high water mark */
 614 #define SO_LOWAT        0x0020  /* set low water mark */
 615 #define SO_MREADON      0x0040  /* set read notification ON */
 616 #define SO_MREADOFF     0x0080  /* set read notification OFF */
 617 #define SO_NDELON       0x0100  /* old TTY semantics for NDELAY reads/writes */
 618 #define SO_NDELOFF      0x0200  /* STREAMS semantics for NDELAY reads/writes */
 619 #define SO_ISTTY        0x0400  /* the stream is acting as a terminal */
 620 #define SO_ISNTTY       0x0800  /* the stream is not acting as a terminal */
 621 #define SO_TOSTOP       0x1000  /* stop on background writes to this stream */
 622 #define SO_TONSTOP      0x2000  /* do not stop on background writes to stream */
 623 #define SO_BAND         0x4000  /* water marks affect band */
 624 #define SO_DELIM        0x8000  /* messages are delimited */
 625 #define SO_NODELIM      0x010000        /* turn off delimiters */
 626 #define SO_STRHOLD      0x020000        /* No longer implemented */
 627 #define SO_ERROPT       0x040000        /* set error option */
 628 #define SO_COPYOPT      0x080000        /* copy option(s) present */
 629 #define SO_MAXBLK       0x100000        /* set maximum message block size */
 630 #define SO_TAIL         0x200000        /* set the extra allocated space */
 631
 632 #ifdef _KERNEL
 633 /*
 634  * Structure for rw (read/write) procedure calls. A pointer
 635  * to a struiod_t is passed as a parameter to the rwnext() call.
 636  *
 637  * Note: DEF_IOV_MAX is defined and used as it is in "fs/vncalls.c"
 638  *       as there isn't a formal definition of IOV_MAX ???
 639  */
 640 #define DEF_IOV_MAX     16
 641
 642 typedef struct struiod {
 643         mblk_t          *d_mp;          /* pointer to mblk (chain) */
 644         uio_t           d_uio;          /* uio info */
 645         iovec_t d_iov[DEF_IOV_MAX];     /* iov referenced by uio */
 646 } struiod_t;
 647
 648 /*
 649  * Structure for information procedure calls.
 650  */
 651 typedef struct infod {
 652         unsigned char   d_cmd;          /* info info request command */
 653         unsigned char   d_res;          /* info info command results */
 654         int             d_bytes;        /* mblk(s) byte count */
 655         int             d_count;        /* count of mblk(s) */
 656         uio_t           *d_uiop;        /* pointer to uio struct */
 657 } infod_t;
 658 /*
 659  * Values for d_cmd & d_res.
 660  */
 661 #define INFOD_FIRSTBYTES        0x02    /* return msgbsize() of first mblk */
 662 #define INFOD_BYTES             0x04    /* return msgbsize() of all mblk(s) */
 663 #define INFOD_COUNT             0x08    /* return count of mblk(s) */
 664 #define INFOD_COPYOUT           0x10    /* copyout any M_DATA mblk(s) */
 665
 666 /*
 667  * Structure used by _I_CMD mechanism, similar in spirit to iocblk.
 668  */
 669 typedef struct cmdblk {
 670         int             cb_cmd;         /* ioctl command type */
 671         cred_t          *cb_cr;         /* full credentials */
 672         uint_t          cb_len;         /* payload size */
 673         int             cb_error;       /* error code */
 674 } cmdblk_t;
 675
 676 #endif /* _KERNEL */
 677
 678 /*
 679  * Miscellaneous parameters and flags.
 680  */
 681
 682 /*
 683  * Values for stream flag in open to indicate module open, clone open,
 684  * and the return value for failure.
 685  */
 686 #define MODOPEN         0x1             /* open as a module */
 687 #define CLONEOPEN       0x2             /* clone open; pick own minor dev */
 688 #define OPENFAIL        -1              /* returned for open failure */
 689
 690 /*
 691  * Priority definitions for block allocation.
 692  */
 693 #define BPRI_LO         1
 694 #define BPRI_MED        2
 695 #define BPRI_HI         3
 696
 697 /*
 698  * Value for packet size that denotes infinity
 699  */
 700 #define INFPSZ          -1
 701
 702 /*
 703  * Flags for flushq()
 704  */
 705 #define FLUSHALL        1       /* flush all messages */
 706 #define FLUSHDATA       0       /* don't flush control messages */
 707
 708 /*
 709  * Flag for transparent ioctls
 710  */
 711 #define TRANSPARENT     (unsigned int)(-1)
 712
 713 /*
 714  * Stream head default high/low water marks
 715  */
 716 #define STRHIGH 5120
 717 #define STRLOW  1024
 718
 719 /*
 720  * qwriter perimeter types
 721  */
 722 #define PERIM_INNER     1               /* The inner perimeter */
 723 #define PERIM_OUTER     2               /* The outer perimeter */
 724
 725 /*
 726  * Definitions of Streams macros and function interfaces.
 727  */
 728
 729 /*
 730  * canenable - check if queue can be enabled by putq().
 731  */
 732 #define canenable(q)    !((q)->q_flag & QNOENB)
 733
 734 /*
 735  * Test if data block type is one of the data messages (i.e. not a control
 736  * message).
 737  */
 738 #define datamsg(type) \
 739                 ((type) == M_DATA || \
 740                     (type) == M_MULTIDATA || \
 741                     (type) == M_PROTO || \
 742                     (type) == M_PCPROTO || \
 743                     (type) == M_DELAY)
 744
 745 /*
 746  * Extract queue class of message block.
 747  */
 748 #define queclass(bp) (((bp)->b_datap->db_type >= QPCTL) ? QPCTL : QNORM)
 749
 750 /*
 751  * Align address on next lower word boundary.
 752  */
 753 #define straln(a)       (caddr_t)((intptr_t)(a) & -(sizeof (int)-1))
 754
 755 /*
 756  * Find the max size of data block.
 757  */
 758 #define bpsize(bp) ((unsigned int)(bp->b_datap->db_lim - bp->b_datap->db_base))
 759
 760 #ifdef _KERNEL
 761
 762 /*
 763  * For two-byte M_ERROR messages: indication that a side does not have an error
 764  */
 765 #define NOERROR ((unsigned char)-1)
 766
 767 /*
 768  * declarations of common routines
 769  */
 770
 771 extern mblk_t *allocb(size_t, uint_t);
 772 extern mblk_t *desballoc(unsigned char *, size_t, uint_t, frtn_t *);
 773 extern mblk_t *esballoc(unsigned char *, size_t, uint_t, frtn_t *);
 774 extern bcache_t *bcache_create(char *, size_t, uint_t);
 775 extern void bcache_destroy(bcache_t *);
 776 extern mblk_t *bcache_allocb(bcache_t *, uint_t);
 777 extern mblk_t *mkiocb(uint_t);
 778 extern int testb(size_t, uint_t);
 779 extern bufcall_id_t bufcall(size_t, uint_t, void (*)(void *), void *);
 780 extern bufcall_id_t esbbcall(uint_t, void (*)(void *), void *);
 781 extern void freeb(struct msgb *);
 782 extern void freemsg(mblk_t *);
 783 extern mblk_t *dupb(mblk_t *);
 784 extern mblk_t *dupmsg(mblk_t *);
 785 extern mblk_t *dupmsg_noloan(mblk_t *);
 786 extern mblk_t *copyb(mblk_t *);
 787 extern mblk_t *copymsg(mblk_t *);
 788 extern void linkb(mblk_t *, mblk_t *);
 789 extern mblk_t *unlinkb(mblk_t *);
 790 extern mblk_t *reallocb(mblk_t *, size_t, uint_t);      /* private */
 791 extern mblk_t *rmvb(mblk_t *, mblk_t *);
 792 extern int pullupmsg(struct msgb *, ssize_t);
 793 extern mblk_t *msgpullup(struct msgb *, ssize_t);
 794 extern int adjmsg(struct msgb *, ssize_t);
 795 extern size_t msgdsize(struct msgb *);
 796 extern mblk_t *getq(queue_t *);
 797 extern void rmvq(queue_t *, mblk_t *);
 798 extern void flushq(queue_t *, int);
 799 extern void flushq_common(queue_t *, int, int);
 800 extern void flushband(queue_t *, unsigned char, int);
 801 extern int canput(queue_t *);
 802 extern int bcanput(queue_t *, unsigned char);
 803 extern int canputnext(queue_t *);
 804 extern int bcanputnext(queue_t *, unsigned char);
 805 extern int putq(queue_t *, mblk_t *);
 806 extern int putbq(queue_t *, mblk_t *);
 807 extern int insq(queue_t *, mblk_t *, mblk_t *);
 808 extern void put(queue_t *, mblk_t *);
 809 extern void putnext(queue_t *, mblk_t *);
 810 extern int putctl(queue_t *, int);
 811 extern int putctl1(queue_t *, int, int);
 812 extern int putnextctl(queue_t *, int);
 813 extern int putnextctl1(queue_t *, int, int);
 814 extern queue_t *backq(queue_t *);
 815 extern void qreply(queue_t *, mblk_t *);
 816 extern void qenable(queue_t *);
 817 extern int qsize(queue_t *);
 818 extern void noenable(queue_t *);
 819 extern void enableok(queue_t *);
 820 extern int strqset(queue_t *, qfields_t, unsigned char, intptr_t);
 821 extern int strqget(queue_t *, qfields_t, unsigned char, void *);
 822 extern void unbufcall(bufcall_id_t);
 823 extern void qprocson(queue_t *);
 824 extern void qprocsoff(queue_t *);
 825 extern void freezestr(queue_t *);
 826 extern void unfreezestr(queue_t *);
 827 extern void qwait(queue_t *);
 828 extern int qwait_sig(queue_t *);
 829 extern boolean_t qwait_rw(queue_t *);
 830 extern void qwriter(queue_t *, mblk_t *, void (*func)(), int);
 831 extern timeout_id_t qtimeout(queue_t *, void (*func)(void *), void *, clock_t);
 832 extern bufcall_id_t qbufcall(queue_t *, size_t, uint_t,
 833     void (*)(void *), void *);
 834 extern clock_t quntimeout(queue_t *, timeout_id_t);
 835 extern void qunbufcall(queue_t *, bufcall_id_t);
 836 extern void strwakeq(queue_t *, int);
 837 extern int struioget(queue_t *, mblk_t *, struiod_t *, int);
 838 extern int rwnext(queue_t *, struiod_t *);
 839 extern int infonext(queue_t *, infod_t *);
 840 extern int isuioq(queue_t *);
 841 extern void create_putlocks(queue_t *, int);
 842 extern int mp_cont_len(mblk_t *, int *);
 843
 844 /*
 845  * shared or externally configured data structures
 846  */
 847 extern int nstrpush;                    /* maximum number of pushes allowed */
 848
 849 #endif /* _KERNEL */
 850
 851 #ifdef  __cplusplus
 852 }
 853 #endif
 854
 855 #endif  /* _SYS_STREAM_H */