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