Print this page
9042 multiples of tty streams modules cause weirdness
Reviewed by: Randy Fishel <randyf@sibernet.com>
Reviewed by: Carlos Neira <cneirabustos@gmail.com>
Approved by: Hans Rosenfeld <rosenfeld@grumpf.hope-2000.org>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/os/streamio.c
+++ new/usr/src/uts/common/os/streamio.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
22 22 /* All Rights Reserved */
23 23
24 24
25 25 /*
26 26 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
27 27 * Copyright 2017 Joyent, Inc.
28 + * Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
28 29 */
29 30
30 31 #include <sys/types.h>
31 32 #include <sys/sysmacros.h>
32 33 #include <sys/param.h>
33 34 #include <sys/errno.h>
34 35 #include <sys/signal.h>
35 36 #include <sys/stat.h>
36 37 #include <sys/proc.h>
37 38 #include <sys/cred.h>
38 39 #include <sys/user.h>
39 40 #include <sys/vnode.h>
40 41 #include <sys/file.h>
41 42 #include <sys/stream.h>
42 43 #include <sys/strsubr.h>
43 44 #include <sys/stropts.h>
44 45 #include <sys/tihdr.h>
45 46 #include <sys/var.h>
46 47 #include <sys/poll.h>
47 48 #include <sys/termio.h>
48 49 #include <sys/ttold.h>
49 50 #include <sys/systm.h>
50 51 #include <sys/uio.h>
51 52 #include <sys/cmn_err.h>
52 53 #include <sys/sad.h>
53 54 #include <sys/netstack.h>
54 55 #include <sys/priocntl.h>
55 56 #include <sys/jioctl.h>
56 57 #include <sys/procset.h>
57 58 #include <sys/session.h>
58 59 #include <sys/kmem.h>
59 60 #include <sys/filio.h>
60 61 #include <sys/vtrace.h>
61 62 #include <sys/debug.h>
62 63 #include <sys/strredir.h>
63 64 #include <sys/fs/fifonode.h>
64 65 #include <sys/fs/snode.h>
65 66 #include <sys/strlog.h>
66 67 #include <sys/strsun.h>
67 68 #include <sys/project.h>
68 69 #include <sys/kbio.h>
69 70 #include <sys/msio.h>
70 71 #include <sys/tty.h>
71 72 #include <sys/ptyvar.h>
72 73 #include <sys/vuid_event.h>
73 74 #include <sys/modctl.h>
74 75 #include <sys/sunddi.h>
75 76 #include <sys/sunldi_impl.h>
76 77 #include <sys/autoconf.h>
77 78 #include <sys/policy.h>
78 79 #include <sys/dld.h>
79 80 #include <sys/zone.h>
80 81 #include <c2/audit.h>
81 82
82 83 /*
83 84 * This define helps improve the readability of streams code while
84 85 * still maintaining a very old streams performance enhancement. The
85 86 * performance enhancement basically involved having all callers
86 87 * of straccess() perform the first check that straccess() will do
87 88 * locally before actually calling straccess(). (There by reducing
88 89 * the number of unnecessary calls to straccess().)
89 90 */
90 91 #define i_straccess(x, y) ((stp->sd_sidp == NULL) ? 0 : \
91 92 (stp->sd_vnode->v_type == VFIFO) ? 0 : \
92 93 straccess((x), (y)))
93 94
94 95 /*
95 96 * what is mblk_pull_len?
96 97 *
97 98 * If a streams message consists of many short messages,
98 99 * a performance degradation occurs from copyout overhead.
99 100 * To decrease the per mblk overhead, messages that are
100 101 * likely to consist of many small mblks are pulled up into
101 102 * one continuous chunk of memory.
102 103 *
103 104 * To avoid the processing overhead of examining every
104 105 * mblk, a quick heuristic is used. If the first mblk in
105 106 * the message is shorter than mblk_pull_len, it is likely
106 107 * that the rest of the mblk will be short.
107 108 *
108 109 * This heuristic was decided upon after performance tests
109 110 * indicated that anything more complex slowed down the main
110 111 * code path.
111 112 */
112 113 #define MBLK_PULL_LEN 64
113 114 uint32_t mblk_pull_len = MBLK_PULL_LEN;
114 115
115 116 /*
116 117 * The sgttyb_handling flag controls the handling of the old BSD
117 118 * TIOCGETP, TIOCSETP, and TIOCSETN ioctls as follows:
118 119 *
119 120 * 0 - Emit no warnings at all and retain old, broken behavior.
120 121 * 1 - Emit no warnings and silently handle new semantics.
121 122 * 2 - Send cmn_err(CE_NOTE) when either TIOCSETP or TIOCSETN is used
122 123 * (once per system invocation). Handle with new semantics.
123 124 * 3 - Send SIGSYS when any TIOCGETP, TIOCSETP, or TIOCSETN call is
124 125 * made (so that offenders drop core and are easy to debug).
125 126 *
126 127 * The "new semantics" are that TIOCGETP returns B38400 for
127 128 * sg_[io]speed if the corresponding value is over B38400, and that
128 129 * TIOCSET[PN] accept B38400 in these cases to mean "retain current
129 130 * bit rate."
130 131 */
131 132 int sgttyb_handling = 1;
132 133 static boolean_t sgttyb_complaint;
133 134
134 135 /* don't push drcompat module by default on Style-2 streams */
135 136 static int push_drcompat = 0;
136 137
137 138 /*
138 139 * id value used to distinguish between different ioctl messages
139 140 */
140 141 static uint32_t ioc_id;
141 142
142 143 static void putback(struct stdata *, queue_t *, mblk_t *, int);
143 144 static void strcleanall(struct vnode *);
144 145 static int strwsrv(queue_t *);
145 146 static int strdocmd(struct stdata *, struct strcmd *, cred_t *);
146 147
147 148 /*
148 149 * qinit and module_info structures for stream head read and write queues
149 150 */
150 151 struct module_info strm_info = { 0, "strrhead", 0, INFPSZ, STRHIGH, STRLOW };
151 152 struct module_info stwm_info = { 0, "strwhead", 0, 0, 0, 0 };
152 153 struct qinit strdata = { strrput, NULL, NULL, NULL, NULL, &strm_info };
153 154 struct qinit stwdata = { NULL, strwsrv, NULL, NULL, NULL, &stwm_info };
154 155 struct module_info fiform_info = { 0, "fifostrrhead", 0, PIPE_BUF, FIFOHIWAT,
155 156 FIFOLOWAT };
156 157 struct module_info fifowm_info = { 0, "fifostrwhead", 0, 0, 0, 0 };
157 158 struct qinit fifo_strdata = { strrput, NULL, NULL, NULL, NULL, &fiform_info };
158 159 struct qinit fifo_stwdata = { NULL, strwsrv, NULL, NULL, NULL, &fifowm_info };
159 160
160 161 extern kmutex_t strresources; /* protects global resources */
161 162 extern kmutex_t muxifier; /* single-threads multiplexor creation */
162 163
163 164 static boolean_t msghasdata(mblk_t *bp);
164 165 #define msgnodata(bp) (!msghasdata(bp))
165 166
166 167 /*
167 168 * Stream head locking notes:
168 169 * There are four monitors associated with the stream head:
169 170 * 1. v_stream monitor: in stropen() and strclose() v_lock
170 171 * is held while the association of vnode and stream
171 172 * head is established or tested for.
172 173 * 2. open/close/push/pop monitor: sd_lock is held while each
173 174 * thread bids for exclusive access to this monitor
174 175 * for opening or closing a stream. In addition, this
175 176 * monitor is entered during pushes and pops. This
176 177 * guarantees that during plumbing operations there
177 178 * is only one thread trying to change the plumbing.
178 179 * Any other threads present in the stream are only
179 180 * using the plumbing.
180 181 * 3. read/write monitor: in the case of read, a thread holds
181 182 * sd_lock while trying to get data from the stream
182 183 * head queue. if there is none to fulfill a read
183 184 * request, it sets RSLEEP and calls cv_wait_sig() down
184 185 * in strwaitq() to await the arrival of new data.
185 186 * when new data arrives in strrput(), sd_lock is acquired
186 187 * before testing for RSLEEP and calling cv_broadcast().
187 188 * the behavior of strwrite(), strwsrv(), and WSLEEP
188 189 * mirror this.
189 190 * 4. ioctl monitor: sd_lock is gotten to ensure that only one
190 191 * thread is doing an ioctl at a time.
191 192 */
192 193
193 194 static int
194 195 push_mod(queue_t *qp, dev_t *devp, struct stdata *stp, const char *name,
195 196 int anchor, cred_t *crp, uint_t anchor_zoneid)
196 197 {
197 198 int error;
198 199 fmodsw_impl_t *fp;
199 200
200 201 if (stp->sd_flag & (STRHUP|STRDERR|STWRERR)) {
201 202 error = (stp->sd_flag & STRHUP) ? ENXIO : EIO;
202 203 return (error);
203 204 }
204 205 if (stp->sd_pushcnt >= nstrpush) {
205 206 return (EINVAL);
206 207 }
207 208
208 209 if ((fp = fmodsw_find(name, FMODSW_HOLD | FMODSW_LOAD)) == NULL) {
209 210 stp->sd_flag |= STREOPENFAIL;
210 211 return (EINVAL);
211 212 }
212 213
213 214 /*
214 215 * push new module and call its open routine via qattach
215 216 */
216 217 if ((error = qattach(qp, devp, 0, crp, fp, B_FALSE)) != 0)
217 218 return (error);
218 219
219 220 /*
220 221 * Check to see if caller wants a STREAMS anchor
221 222 * put at this place in the stream, and add if so.
222 223 */
223 224 mutex_enter(&stp->sd_lock);
224 225 if (anchor == stp->sd_pushcnt) {
225 226 stp->sd_anchor = stp->sd_pushcnt;
226 227 stp->sd_anchorzone = anchor_zoneid;
227 228 }
228 229 mutex_exit(&stp->sd_lock);
229 230
230 231 return (0);
231 232 }
232 233
233 234 /*
234 235 * Open a stream device.
235 236 */
236 237 int
237 238 stropen(vnode_t *vp, dev_t *devp, int flag, cred_t *crp)
238 239 {
239 240 struct stdata *stp;
240 241 queue_t *qp;
241 242 int s;
242 243 dev_t dummydev, savedev;
243 244 struct autopush *ap;
244 245 struct dlautopush dlap;
245 246 int error = 0;
246 247 ssize_t rmin, rmax;
247 248 int cloneopen;
248 249 queue_t *brq;
249 250 major_t major;
250 251 str_stack_t *ss;
251 252 zoneid_t zoneid;
252 253 uint_t anchor;
253 254
254 255 /*
255 256 * If the stream already exists, wait for any open in progress
256 257 * to complete, then call the open function of each module and
257 258 * driver in the stream. Otherwise create the stream.
258 259 */
259 260 TRACE_1(TR_FAC_STREAMS_FR, TR_STROPEN, "stropen:%p", vp);
260 261 retry:
261 262 mutex_enter(&vp->v_lock);
262 263 if ((stp = vp->v_stream) != NULL) {
263 264
264 265 /*
265 266 * Waiting for stream to be created to device
266 267 * due to another open.
267 268 */
268 269 mutex_exit(&vp->v_lock);
269 270
270 271 if (STRMATED(stp)) {
271 272 struct stdata *strmatep = stp->sd_mate;
272 273
273 274 STRLOCKMATES(stp);
274 275 if (strmatep->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
275 276 if (flag & (FNDELAY|FNONBLOCK)) {
276 277 error = EAGAIN;
277 278 mutex_exit(&strmatep->sd_lock);
278 279 goto ckreturn;
279 280 }
280 281 mutex_exit(&stp->sd_lock);
281 282 if (!cv_wait_sig(&strmatep->sd_monitor,
282 283 &strmatep->sd_lock)) {
283 284 error = EINTR;
284 285 mutex_exit(&strmatep->sd_lock);
285 286 mutex_enter(&stp->sd_lock);
286 287 goto ckreturn;
287 288 }
288 289 mutex_exit(&strmatep->sd_lock);
289 290 goto retry;
290 291 }
291 292 if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
292 293 if (flag & (FNDELAY|FNONBLOCK)) {
293 294 error = EAGAIN;
294 295 mutex_exit(&strmatep->sd_lock);
295 296 goto ckreturn;
296 297 }
297 298 mutex_exit(&strmatep->sd_lock);
298 299 if (!cv_wait_sig(&stp->sd_monitor,
299 300 &stp->sd_lock)) {
300 301 error = EINTR;
301 302 goto ckreturn;
302 303 }
303 304 mutex_exit(&stp->sd_lock);
304 305 goto retry;
305 306 }
306 307
307 308 if (stp->sd_flag & (STRDERR|STWRERR)) {
308 309 error = EIO;
309 310 mutex_exit(&strmatep->sd_lock);
310 311 goto ckreturn;
311 312 }
312 313
313 314 stp->sd_flag |= STWOPEN;
314 315 STRUNLOCKMATES(stp);
315 316 } else {
316 317 mutex_enter(&stp->sd_lock);
317 318 if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
318 319 if (flag & (FNDELAY|FNONBLOCK)) {
319 320 error = EAGAIN;
320 321 goto ckreturn;
321 322 }
322 323 if (!cv_wait_sig(&stp->sd_monitor,
323 324 &stp->sd_lock)) {
324 325 error = EINTR;
325 326 goto ckreturn;
326 327 }
327 328 mutex_exit(&stp->sd_lock);
328 329 goto retry; /* could be clone! */
329 330 }
330 331
331 332 if (stp->sd_flag & (STRDERR|STWRERR)) {
332 333 error = EIO;
333 334 goto ckreturn;
334 335 }
335 336
336 337 stp->sd_flag |= STWOPEN;
337 338 mutex_exit(&stp->sd_lock);
338 339 }
339 340
340 341 /*
341 342 * Open all modules and devices down stream to notify
342 343 * that another user is streaming. For modules, set the
343 344 * last argument to MODOPEN and do not pass any open flags.
344 345 * Ignore dummydev since this is not the first open.
345 346 */
346 347 claimstr(stp->sd_wrq);
347 348 qp = stp->sd_wrq;
348 349 while (_SAMESTR(qp)) {
349 350 qp = qp->q_next;
350 351 if ((error = qreopen(_RD(qp), devp, flag, crp)) != 0)
351 352 break;
352 353 }
353 354 releasestr(stp->sd_wrq);
354 355 mutex_enter(&stp->sd_lock);
355 356 stp->sd_flag &= ~(STRHUP|STWOPEN|STRDERR|STWRERR);
356 357 stp->sd_rerror = 0;
357 358 stp->sd_werror = 0;
358 359 ckreturn:
359 360 cv_broadcast(&stp->sd_monitor);
360 361 mutex_exit(&stp->sd_lock);
361 362 return (error);
362 363 }
363 364
364 365 /*
365 366 * This vnode isn't streaming. SPECFS already
366 367 * checked for multiple vnodes pointing to the
367 368 * same stream, so create a stream to the driver.
368 369 */
369 370 qp = allocq();
370 371 stp = shalloc(qp);
371 372
372 373 /*
373 374 * Initialize stream head. shalloc() has given us
374 375 * exclusive access, and we have the vnode locked;
375 376 * we can do whatever we want with stp.
376 377 */
377 378 stp->sd_flag = STWOPEN;
378 379 stp->sd_siglist = NULL;
379 380 stp->sd_pollist.ph_list = NULL;
380 381 stp->sd_sigflags = 0;
381 382 stp->sd_mark = NULL;
382 383 stp->sd_closetime = STRTIMOUT;
383 384 stp->sd_sidp = NULL;
384 385 stp->sd_pgidp = NULL;
385 386 stp->sd_vnode = vp;
386 387 stp->sd_rerror = 0;
387 388 stp->sd_werror = 0;
388 389 stp->sd_wroff = 0;
389 390 stp->sd_tail = 0;
390 391 stp->sd_iocblk = NULL;
391 392 stp->sd_cmdblk = NULL;
392 393 stp->sd_pushcnt = 0;
393 394 stp->sd_qn_minpsz = 0;
394 395 stp->sd_qn_maxpsz = INFPSZ - 1; /* used to check for initialization */
395 396 stp->sd_maxblk = INFPSZ;
396 397 qp->q_ptr = _WR(qp)->q_ptr = stp;
397 398 STREAM(qp) = STREAM(_WR(qp)) = stp;
398 399 vp->v_stream = stp;
399 400 mutex_exit(&vp->v_lock);
400 401 if (vp->v_type == VFIFO) {
401 402 stp->sd_flag |= OLDNDELAY;
402 403 /*
403 404 * This means, both for pipes and fifos
404 405 * strwrite will send SIGPIPE if the other
405 406 * end is closed. For putmsg it depends
406 407 * on whether it is a XPG4_2 application
407 408 * or not
408 409 */
409 410 stp->sd_wput_opt = SW_SIGPIPE;
410 411
411 412 /* setq might sleep in kmem_alloc - avoid holding locks. */
412 413 setq(qp, &fifo_strdata, &fifo_stwdata, NULL, QMTSAFE,
413 414 SQ_CI|SQ_CO, B_FALSE);
414 415
415 416 set_qend(qp);
416 417 stp->sd_strtab = fifo_getinfo();
417 418 _WR(qp)->q_nfsrv = _WR(qp);
418 419 qp->q_nfsrv = qp;
419 420 /*
420 421 * Wake up others that are waiting for stream to be created.
421 422 */
422 423 mutex_enter(&stp->sd_lock);
423 424 /*
424 425 * nothing is be pushed on stream yet, so
425 426 * optimized stream head packetsizes are just that
426 427 * of the read queue
427 428 */
428 429 stp->sd_qn_minpsz = qp->q_minpsz;
429 430 stp->sd_qn_maxpsz = qp->q_maxpsz;
430 431 stp->sd_flag &= ~STWOPEN;
431 432 goto fifo_opendone;
432 433 }
433 434 /* setq might sleep in kmem_alloc - avoid holding locks. */
434 435 setq(qp, &strdata, &stwdata, NULL, QMTSAFE, SQ_CI|SQ_CO, B_FALSE);
435 436
436 437 set_qend(qp);
437 438
438 439 /*
439 440 * Open driver and create stream to it (via qattach).
440 441 */
441 442 savedev = *devp;
442 443 cloneopen = (getmajor(*devp) == clone_major);
443 444 if ((error = qattach(qp, devp, flag, crp, NULL, B_FALSE)) != 0) {
444 445 mutex_enter(&vp->v_lock);
445 446 vp->v_stream = NULL;
446 447 mutex_exit(&vp->v_lock);
447 448 mutex_enter(&stp->sd_lock);
448 449 cv_broadcast(&stp->sd_monitor);
449 450 mutex_exit(&stp->sd_lock);
450 451 freeq(_RD(qp));
451 452 shfree(stp);
452 453 return (error);
453 454 }
454 455 /*
455 456 * Set sd_strtab after open in order to handle clonable drivers
456 457 */
457 458 stp->sd_strtab = STREAMSTAB(getmajor(*devp));
458 459
459 460 /*
460 461 * Historical note: dummydev used to be be prior to the initial
461 462 * open (via qattach above), which made the value seen
462 463 * inconsistent between an I_PUSH and an autopush of a module.
463 464 */
464 465 dummydev = *devp;
465 466
466 467 /*
467 468 * For clone open of old style (Q not associated) network driver,
468 469 * push DRMODNAME module to handle DL_ATTACH/DL_DETACH
469 470 */
470 471 brq = _RD(_WR(qp)->q_next);
471 472 major = getmajor(*devp);
472 473 if (push_drcompat && cloneopen && NETWORK_DRV(major) &&
473 474 ((brq->q_flag & _QASSOCIATED) == 0)) {
474 475 if (push_mod(qp, &dummydev, stp, DRMODNAME, 0, crp, 0) != 0)
475 476 cmn_err(CE_WARN, "cannot push " DRMODNAME
476 477 " streams module");
477 478 }
478 479
479 480 if (!NETWORK_DRV(major)) {
480 481 savedev = *devp;
481 482 } else {
482 483 /*
483 484 * For network devices, process differently based on the
484 485 * return value from dld_autopush():
485 486 *
486 487 * 0: the passed-in device points to a GLDv3 datalink with
487 488 * per-link autopush configuration; use that configuration
488 489 * and ignore any per-driver autopush configuration.
489 490 *
490 491 * 1: the passed-in device points to a physical GLDv3
491 492 * datalink without per-link autopush configuration. The
492 493 * passed in device was changed to refer to the actual
493 494 * physical device (if it's not already); we use that new
494 495 * device to look up any per-driver autopush configuration.
495 496 *
496 497 * -1: neither of the above cases applied; use the initial
497 498 * device to look up any per-driver autopush configuration.
498 499 */
499 500 switch (dld_autopush(&savedev, &dlap)) {
500 501 case 0:
501 502 zoneid = crgetzoneid(crp);
502 503 for (s = 0; s < dlap.dap_npush; s++) {
503 504 error = push_mod(qp, &dummydev, stp,
504 505 dlap.dap_aplist[s], dlap.dap_anchor, crp,
505 506 zoneid);
506 507 if (error != 0)
507 508 break;
508 509 }
509 510 goto opendone;
510 511 case 1:
511 512 break;
512 513 case -1:
513 514 savedev = *devp;
514 515 break;
515 516 }
516 517 }
517 518 /*
518 519 * Find the autopush configuration based on "savedev". Start with the
519 520 * global zone. If not found check in the local zone.
520 521 */
521 522 zoneid = GLOBAL_ZONEID;
522 523 retryap:
523 524 ss = netstack_find_by_stackid(zoneid_to_netstackid(zoneid))->
524 525 netstack_str;
525 526 if ((ap = sad_ap_find_by_dev(savedev, ss)) == NULL) {
526 527 netstack_rele(ss->ss_netstack);
527 528 if (zoneid == GLOBAL_ZONEID) {
528 529 /*
529 530 * None found. Also look in the zone's autopush table.
530 531 */
531 532 zoneid = crgetzoneid(crp);
532 533 if (zoneid != GLOBAL_ZONEID)
533 534 goto retryap;
534 535 }
535 536 goto opendone;
536 537 }
537 538 anchor = ap->ap_anchor;
538 539 zoneid = crgetzoneid(crp);
539 540 for (s = 0; s < ap->ap_npush; s++) {
540 541 error = push_mod(qp, &dummydev, stp, ap->ap_list[s],
541 542 anchor, crp, zoneid);
542 543 if (error != 0)
543 544 break;
544 545 }
545 546 sad_ap_rele(ap, ss);
546 547 netstack_rele(ss->ss_netstack);
547 548
548 549 opendone:
549 550
550 551 /*
551 552 * let specfs know that open failed part way through
552 553 */
553 554 if (error) {
554 555 mutex_enter(&stp->sd_lock);
555 556 stp->sd_flag |= STREOPENFAIL;
556 557 mutex_exit(&stp->sd_lock);
557 558 }
558 559
559 560 /*
560 561 * Wake up others that are waiting for stream to be created.
561 562 */
562 563 mutex_enter(&stp->sd_lock);
563 564 stp->sd_flag &= ~STWOPEN;
564 565
565 566 /*
566 567 * As a performance concern we are caching the values of
567 568 * q_minpsz and q_maxpsz of the module below the stream
568 569 * head in the stream head.
569 570 */
570 571 mutex_enter(QLOCK(stp->sd_wrq->q_next));
571 572 rmin = stp->sd_wrq->q_next->q_minpsz;
572 573 rmax = stp->sd_wrq->q_next->q_maxpsz;
573 574 mutex_exit(QLOCK(stp->sd_wrq->q_next));
574 575
575 576 /* do this processing here as a performance concern */
576 577 if (strmsgsz != 0) {
577 578 if (rmax == INFPSZ)
578 579 rmax = strmsgsz;
579 580 else
580 581 rmax = MIN(strmsgsz, rmax);
581 582 }
582 583
583 584 mutex_enter(QLOCK(stp->sd_wrq));
584 585 stp->sd_qn_minpsz = rmin;
585 586 stp->sd_qn_maxpsz = rmax;
586 587 mutex_exit(QLOCK(stp->sd_wrq));
587 588
588 589 fifo_opendone:
589 590 cv_broadcast(&stp->sd_monitor);
590 591 mutex_exit(&stp->sd_lock);
591 592 return (error);
592 593 }
593 594
594 595 static int strsink(queue_t *, mblk_t *);
595 596 static struct qinit deadrend = {
596 597 strsink, NULL, NULL, NULL, NULL, &strm_info, NULL
597 598 };
598 599 static struct qinit deadwend = {
599 600 NULL, NULL, NULL, NULL, NULL, &stwm_info, NULL
600 601 };
601 602
602 603 /*
603 604 * Close a stream.
604 605 * This is called from closef() on the last close of an open stream.
605 606 * Strclean() will already have removed the siglist and pollist
606 607 * information, so all that remains is to remove all multiplexor links
607 608 * for the stream, pop all the modules (and the driver), and free the
608 609 * stream structure.
609 610 */
610 611
611 612 int
612 613 strclose(struct vnode *vp, int flag, cred_t *crp)
613 614 {
614 615 struct stdata *stp;
615 616 queue_t *qp;
616 617 int rval;
617 618 int freestp = 1;
618 619 queue_t *rmq;
619 620
620 621 TRACE_1(TR_FAC_STREAMS_FR,
621 622 TR_STRCLOSE, "strclose:%p", vp);
622 623 ASSERT(vp->v_stream);
623 624
624 625 stp = vp->v_stream;
625 626 ASSERT(!(stp->sd_flag & STPLEX));
626 627 qp = stp->sd_wrq;
627 628
628 629 /*
629 630 * Needed so that strpoll will return non-zero for this fd.
630 631 * Note that with POLLNOERR STRHUP does still cause POLLHUP.
631 632 */
632 633 mutex_enter(&stp->sd_lock);
633 634 stp->sd_flag |= STRHUP;
634 635 mutex_exit(&stp->sd_lock);
635 636
636 637 /*
637 638 * If the registered process or process group did not have an
638 639 * open instance of this stream then strclean would not be
639 640 * called. Thus at the time of closing all remaining siglist entries
640 641 * are removed.
641 642 */
642 643 if (stp->sd_siglist != NULL)
643 644 strcleanall(vp);
644 645
645 646 ASSERT(stp->sd_siglist == NULL);
646 647 ASSERT(stp->sd_sigflags == 0);
647 648
648 649 if (STRMATED(stp)) {
649 650 struct stdata *strmatep = stp->sd_mate;
650 651 int waited = 1;
651 652
652 653 STRLOCKMATES(stp);
653 654 while (waited) {
654 655 waited = 0;
655 656 while (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
656 657 mutex_exit(&strmatep->sd_lock);
657 658 cv_wait(&stp->sd_monitor, &stp->sd_lock);
658 659 mutex_exit(&stp->sd_lock);
659 660 STRLOCKMATES(stp);
660 661 waited = 1;
661 662 }
662 663 while (strmatep->sd_flag &
663 664 (STWOPEN|STRCLOSE|STRPLUMB)) {
664 665 mutex_exit(&stp->sd_lock);
665 666 cv_wait(&strmatep->sd_monitor,
666 667 &strmatep->sd_lock);
667 668 mutex_exit(&strmatep->sd_lock);
668 669 STRLOCKMATES(stp);
669 670 waited = 1;
670 671 }
671 672 }
672 673 stp->sd_flag |= STRCLOSE;
673 674 STRUNLOCKMATES(stp);
674 675 } else {
675 676 mutex_enter(&stp->sd_lock);
676 677 stp->sd_flag |= STRCLOSE;
677 678 mutex_exit(&stp->sd_lock);
678 679 }
679 680
680 681 ASSERT(qp->q_first == NULL); /* No more delayed write */
681 682
682 683 /* Check if an I_LINK was ever done on this stream */
683 684 if (stp->sd_flag & STRHASLINKS) {
684 685 netstack_t *ns;
685 686 str_stack_t *ss;
686 687
687 688 ns = netstack_find_by_cred(crp);
688 689 ASSERT(ns != NULL);
689 690 ss = ns->netstack_str;
690 691 ASSERT(ss != NULL);
691 692
692 693 (void) munlinkall(stp, LINKCLOSE|LINKNORMAL, crp, &rval, ss);
693 694 netstack_rele(ss->ss_netstack);
694 695 }
695 696
696 697 while (_SAMESTR(qp)) {
697 698 /*
698 699 * Holding sd_lock prevents q_next from changing in
699 700 * this stream.
700 701 */
701 702 mutex_enter(&stp->sd_lock);
702 703 if (!(flag & (FNDELAY|FNONBLOCK)) && (stp->sd_closetime > 0)) {
703 704
704 705 /*
705 706 * sleep until awakened by strwsrv() or timeout
706 707 */
707 708 for (;;) {
708 709 mutex_enter(QLOCK(qp->q_next));
709 710 if (!(qp->q_next->q_mblkcnt)) {
710 711 mutex_exit(QLOCK(qp->q_next));
711 712 break;
712 713 }
713 714 stp->sd_flag |= WSLEEP;
714 715
715 716 /* ensure strwsrv gets enabled */
716 717 qp->q_next->q_flag |= QWANTW;
717 718 mutex_exit(QLOCK(qp->q_next));
718 719 /* get out if we timed out or recv'd a signal */
719 720 if (str_cv_wait(&qp->q_wait, &stp->sd_lock,
720 721 stp->sd_closetime, 0) <= 0) {
721 722 break;
722 723 }
723 724 }
724 725 stp->sd_flag &= ~WSLEEP;
725 726 }
726 727 mutex_exit(&stp->sd_lock);
727 728
728 729 rmq = qp->q_next;
729 730 if (rmq->q_flag & QISDRV) {
730 731 ASSERT(!_SAMESTR(rmq));
731 732 wait_sq_svc(_RD(qp)->q_syncq);
732 733 }
733 734
734 735 qdetach(_RD(rmq), 1, flag, crp, B_FALSE);
735 736 }
736 737
737 738 /*
738 739 * Since we call pollwakeup in close() now, the poll list should
739 740 * be empty in most cases. The only exception is the layered devices
740 741 * (e.g. the console drivers with redirection modules pushed on top
741 742 * of it). We have to do this after calling qdetach() because
742 743 * the redirection module won't have torn down the console
743 744 * redirection until after qdetach() has been invoked.
744 745 */
745 746 if (stp->sd_pollist.ph_list != NULL) {
746 747 pollwakeup(&stp->sd_pollist, POLLERR);
747 748 pollhead_clean(&stp->sd_pollist);
748 749 }
749 750 ASSERT(stp->sd_pollist.ph_list == NULL);
750 751 ASSERT(stp->sd_sidp == NULL);
751 752 ASSERT(stp->sd_pgidp == NULL);
752 753
753 754 /* Prevent qenable from re-enabling the stream head queue */
754 755 disable_svc(_RD(qp));
755 756
756 757 /*
757 758 * Wait until service procedure of each queue is
758 759 * run, if QINSERVICE is set.
759 760 */
760 761 wait_svc(_RD(qp));
761 762
762 763 /*
763 764 * Now, flush both queues.
764 765 */
765 766 flushq(_RD(qp), FLUSHALL);
766 767 flushq(qp, FLUSHALL);
767 768
768 769 /*
769 770 * If the write queue of the stream head is pointing to a
770 771 * read queue, we have a twisted stream. If the read queue
771 772 * is alive, convert the stream head queues into a dead end.
772 773 * If the read queue is dead, free the dead pair.
773 774 */
774 775 if (qp->q_next && !_SAMESTR(qp)) {
775 776 if (qp->q_next->q_qinfo == &deadrend) { /* half-closed pipe */
776 777 flushq(qp->q_next, FLUSHALL); /* ensure no message */
777 778 shfree(qp->q_next->q_stream);
778 779 freeq(qp->q_next);
779 780 freeq(_RD(qp));
780 781 } else if (qp->q_next == _RD(qp)) { /* fifo */
781 782 freeq(_RD(qp));
782 783 } else { /* pipe */
783 784 freestp = 0;
784 785 /*
785 786 * The q_info pointers are never accessed when
786 787 * SQLOCK is held.
787 788 */
788 789 ASSERT(qp->q_syncq == _RD(qp)->q_syncq);
789 790 mutex_enter(SQLOCK(qp->q_syncq));
790 791 qp->q_qinfo = &deadwend;
791 792 _RD(qp)->q_qinfo = &deadrend;
792 793 mutex_exit(SQLOCK(qp->q_syncq));
793 794 }
794 795 } else {
795 796 freeq(_RD(qp)); /* free stream head queue pair */
796 797 }
797 798
798 799 mutex_enter(&vp->v_lock);
799 800 if (stp->sd_iocblk) {
800 801 if (stp->sd_iocblk != (mblk_t *)-1) {
801 802 freemsg(stp->sd_iocblk);
802 803 }
803 804 stp->sd_iocblk = NULL;
804 805 }
805 806 stp->sd_vnode = NULL;
806 807 vp->v_stream = NULL;
807 808 mutex_exit(&vp->v_lock);
808 809 mutex_enter(&stp->sd_lock);
809 810 freemsg(stp->sd_cmdblk);
810 811 stp->sd_cmdblk = NULL;
811 812 stp->sd_flag &= ~STRCLOSE;
812 813 cv_broadcast(&stp->sd_monitor);
813 814 mutex_exit(&stp->sd_lock);
814 815
815 816 if (freestp)
816 817 shfree(stp);
817 818 return (0);
818 819 }
819 820
820 821 static int
821 822 strsink(queue_t *q, mblk_t *bp)
822 823 {
823 824 struct copyresp *resp;
824 825
825 826 switch (bp->b_datap->db_type) {
826 827 case M_FLUSH:
827 828 if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
828 829 *bp->b_rptr &= ~FLUSHR;
829 830 bp->b_flag |= MSGNOLOOP;
830 831 /*
831 832 * Protect against the driver passing up
832 833 * messages after it has done a qprocsoff.
833 834 */
834 835 if (_OTHERQ(q)->q_next == NULL)
835 836 freemsg(bp);
836 837 else
837 838 qreply(q, bp);
838 839 } else {
839 840 freemsg(bp);
840 841 }
841 842 break;
842 843
843 844 case M_COPYIN:
844 845 case M_COPYOUT:
845 846 if (bp->b_cont) {
846 847 freemsg(bp->b_cont);
847 848 bp->b_cont = NULL;
848 849 }
849 850 bp->b_datap->db_type = M_IOCDATA;
850 851 bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
851 852 resp = (struct copyresp *)bp->b_rptr;
852 853 resp->cp_rval = (caddr_t)1; /* failure */
853 854 /*
854 855 * Protect against the driver passing up
855 856 * messages after it has done a qprocsoff.
856 857 */
857 858 if (_OTHERQ(q)->q_next == NULL)
858 859 freemsg(bp);
859 860 else
860 861 qreply(q, bp);
861 862 break;
862 863
863 864 case M_IOCTL:
864 865 if (bp->b_cont) {
865 866 freemsg(bp->b_cont);
866 867 bp->b_cont = NULL;
867 868 }
868 869 bp->b_datap->db_type = M_IOCNAK;
869 870 /*
870 871 * Protect against the driver passing up
871 872 * messages after it has done a qprocsoff.
872 873 */
873 874 if (_OTHERQ(q)->q_next == NULL)
874 875 freemsg(bp);
875 876 else
876 877 qreply(q, bp);
877 878 break;
878 879
879 880 default:
880 881 freemsg(bp);
881 882 break;
882 883 }
883 884
884 885 return (0);
885 886 }
886 887
887 888 /*
888 889 * Clean up after a process when it closes a stream. This is called
889 890 * from closef for all closes, whereas strclose is called only for the
890 891 * last close on a stream. The siglist is scanned for entries for the
891 892 * current process, and these are removed.
892 893 */
893 894 void
894 895 strclean(struct vnode *vp)
895 896 {
896 897 strsig_t *ssp, *pssp, *tssp;
897 898 stdata_t *stp;
898 899 int update = 0;
899 900
900 901 TRACE_1(TR_FAC_STREAMS_FR,
901 902 TR_STRCLEAN, "strclean:%p", vp);
902 903 stp = vp->v_stream;
903 904 pssp = NULL;
904 905 mutex_enter(&stp->sd_lock);
905 906 ssp = stp->sd_siglist;
906 907 while (ssp) {
907 908 if (ssp->ss_pidp == curproc->p_pidp) {
908 909 tssp = ssp->ss_next;
909 910 if (pssp)
910 911 pssp->ss_next = tssp;
911 912 else
912 913 stp->sd_siglist = tssp;
913 914 mutex_enter(&pidlock);
914 915 PID_RELE(ssp->ss_pidp);
915 916 mutex_exit(&pidlock);
916 917 kmem_free(ssp, sizeof (strsig_t));
917 918 update = 1;
918 919 ssp = tssp;
919 920 } else {
920 921 pssp = ssp;
921 922 ssp = ssp->ss_next;
922 923 }
923 924 }
924 925 if (update) {
925 926 stp->sd_sigflags = 0;
926 927 for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
927 928 stp->sd_sigflags |= ssp->ss_events;
928 929 }
929 930 mutex_exit(&stp->sd_lock);
930 931 }
931 932
932 933 /*
933 934 * Used on the last close to remove any remaining items on the siglist.
934 935 * These could be present on the siglist due to I_ESETSIG calls that
935 936 * use process groups or processed that do not have an open file descriptor
936 937 * for this stream (Such entries would not be removed by strclean).
937 938 */
938 939 static void
939 940 strcleanall(struct vnode *vp)
940 941 {
941 942 strsig_t *ssp, *nssp;
942 943 stdata_t *stp;
943 944
944 945 stp = vp->v_stream;
945 946 mutex_enter(&stp->sd_lock);
946 947 ssp = stp->sd_siglist;
947 948 stp->sd_siglist = NULL;
948 949 while (ssp) {
949 950 nssp = ssp->ss_next;
950 951 mutex_enter(&pidlock);
951 952 PID_RELE(ssp->ss_pidp);
952 953 mutex_exit(&pidlock);
953 954 kmem_free(ssp, sizeof (strsig_t));
954 955 ssp = nssp;
955 956 }
956 957 stp->sd_sigflags = 0;
957 958 mutex_exit(&stp->sd_lock);
958 959 }
959 960
960 961 /*
961 962 * Retrieve the next message from the logical stream head read queue
962 963 * using either rwnext (if sync stream) or getq_noenab.
963 964 * It is the callers responsibility to call qbackenable after
964 965 * it is finished with the message. The caller should not call
965 966 * qbackenable until after any putback calls to avoid spurious backenabling.
966 967 */
967 968 mblk_t *
968 969 strget(struct stdata *stp, queue_t *q, struct uio *uiop, int first,
969 970 int *errorp)
970 971 {
971 972 mblk_t *bp;
972 973 int error;
973 974 ssize_t rbytes = 0;
974 975
975 976 /* Holding sd_lock prevents the read queue from changing */
976 977 ASSERT(MUTEX_HELD(&stp->sd_lock));
977 978
978 979 if (uiop != NULL && stp->sd_struiordq != NULL &&
979 980 q->q_first == NULL &&
980 981 (!first || (stp->sd_wakeq & RSLEEP))) {
981 982 /*
982 983 * Stream supports rwnext() for the read side.
983 984 * If this is the first time we're called by e.g. strread
984 985 * only do the downcall if there is a deferred wakeup
985 986 * (registered in sd_wakeq).
986 987 */
987 988 struiod_t uiod;
988 989
989 990 if (first)
990 991 stp->sd_wakeq &= ~RSLEEP;
991 992
992 993 (void) uiodup(uiop, &uiod.d_uio, uiod.d_iov,
993 994 sizeof (uiod.d_iov) / sizeof (*uiod.d_iov));
994 995 uiod.d_mp = 0;
995 996 /*
996 997 * Mark that a thread is in rwnext on the read side
997 998 * to prevent strrput from nacking ioctls immediately.
998 999 * When the last concurrent rwnext returns
999 1000 * the ioctls are nack'ed.
1000 1001 */
1001 1002 ASSERT(MUTEX_HELD(&stp->sd_lock));
1002 1003 stp->sd_struiodnak++;
1003 1004 /*
1004 1005 * Note: rwnext will drop sd_lock.
1005 1006 */
1006 1007 error = rwnext(q, &uiod);
1007 1008 ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
1008 1009 mutex_enter(&stp->sd_lock);
1009 1010 stp->sd_struiodnak--;
1010 1011 while (stp->sd_struiodnak == 0 &&
1011 1012 ((bp = stp->sd_struionak) != NULL)) {
1012 1013 stp->sd_struionak = bp->b_next;
1013 1014 bp->b_next = NULL;
1014 1015 bp->b_datap->db_type = M_IOCNAK;
1015 1016 /*
1016 1017 * Protect against the driver passing up
1017 1018 * messages after it has done a qprocsoff.
1018 1019 */
1019 1020 if (_OTHERQ(q)->q_next == NULL)
1020 1021 freemsg(bp);
1021 1022 else {
1022 1023 mutex_exit(&stp->sd_lock);
1023 1024 qreply(q, bp);
1024 1025 mutex_enter(&stp->sd_lock);
1025 1026 }
1026 1027 }
1027 1028 ASSERT(MUTEX_HELD(&stp->sd_lock));
1028 1029 if (error == 0 || error == EWOULDBLOCK) {
1029 1030 if ((bp = uiod.d_mp) != NULL) {
1030 1031 *errorp = 0;
1031 1032 ASSERT(MUTEX_HELD(&stp->sd_lock));
1032 1033 return (bp);
1033 1034 }
1034 1035 error = 0;
1035 1036 } else if (error == EINVAL) {
1036 1037 /*
1037 1038 * The stream plumbing must have
1038 1039 * changed while we were away, so
1039 1040 * just turn off rwnext()s.
1040 1041 */
1041 1042 error = 0;
1042 1043 } else if (error == EBUSY) {
1043 1044 /*
1044 1045 * The module might have data in transit using putnext
1045 1046 * Fall back on waiting + getq.
1046 1047 */
1047 1048 error = 0;
1048 1049 } else {
1049 1050 *errorp = error;
1050 1051 ASSERT(MUTEX_HELD(&stp->sd_lock));
1051 1052 return (NULL);
1052 1053 }
1053 1054 /*
1054 1055 * Try a getq in case a rwnext() generated mblk
1055 1056 * has bubbled up via strrput().
1056 1057 */
1057 1058 }
1058 1059 *errorp = 0;
1059 1060 ASSERT(MUTEX_HELD(&stp->sd_lock));
1060 1061
1061 1062 /*
1062 1063 * If we have a valid uio, try and use this as a guide for how
1063 1064 * many bytes to retrieve from the queue via getq_noenab().
1064 1065 * Doing this can avoid unneccesary counting of overlong
1065 1066 * messages in putback(). We currently only do this for sockets
1066 1067 * and only if there is no sd_rputdatafunc hook.
1067 1068 *
1068 1069 * The sd_rputdatafunc hook transforms the entire message
1069 1070 * before any bytes in it can be given to a client. So, rbytes
1070 1071 * must be 0 if there is a hook.
1071 1072 */
1072 1073 if ((uiop != NULL) && (stp->sd_vnode->v_type == VSOCK) &&
1073 1074 (stp->sd_rputdatafunc == NULL))
1074 1075 rbytes = uiop->uio_resid;
1075 1076
1076 1077 return (getq_noenab(q, rbytes));
1077 1078 }
1078 1079
1079 1080 /*
1080 1081 * Copy out the message pointed to by `bp' into the uio pointed to by `uiop'.
1081 1082 * If the message does not fit in the uio the remainder of it is returned;
1082 1083 * otherwise NULL is returned. Any embedded zero-length mblk_t's are
1083 1084 * consumed, even if uio_resid reaches zero. On error, `*errorp' is set to
1084 1085 * the error code, the message is consumed, and NULL is returned.
1085 1086 */
1086 1087 static mblk_t *
1087 1088 struiocopyout(mblk_t *bp, struct uio *uiop, int *errorp)
1088 1089 {
1089 1090 int error;
1090 1091 ptrdiff_t n;
1091 1092 mblk_t *nbp;
1092 1093
1093 1094 ASSERT(bp->b_wptr >= bp->b_rptr);
1094 1095
1095 1096 do {
1096 1097 if ((n = MIN(uiop->uio_resid, MBLKL(bp))) != 0) {
1097 1098 ASSERT(n > 0);
1098 1099
1099 1100 error = uiomove(bp->b_rptr, n, UIO_READ, uiop);
1100 1101 if (error != 0) {
1101 1102 freemsg(bp);
1102 1103 *errorp = error;
1103 1104 return (NULL);
1104 1105 }
1105 1106 }
1106 1107
1107 1108 bp->b_rptr += n;
1108 1109 while (bp != NULL && (bp->b_rptr >= bp->b_wptr)) {
1109 1110 nbp = bp;
1110 1111 bp = bp->b_cont;
1111 1112 freeb(nbp);
1112 1113 }
1113 1114 } while (bp != NULL && uiop->uio_resid > 0);
1114 1115
1115 1116 *errorp = 0;
1116 1117 return (bp);
1117 1118 }
1118 1119
1119 1120 /*
1120 1121 * Read a stream according to the mode flags in sd_flag:
1121 1122 *
1122 1123 * (default mode) - Byte stream, msg boundaries are ignored
1123 1124 * RD_MSGDIS (msg discard) - Read on msg boundaries and throw away
1124 1125 * any data remaining in msg
1125 1126 * RD_MSGNODIS (msg non-discard) - Read on msg boundaries and put back
1126 1127 * any remaining data on head of read queue
1127 1128 *
1128 1129 * Consume readable messages on the front of the queue until
1129 1130 * ttolwp(curthread)->lwp_count
1130 1131 * is satisfied, the readable messages are exhausted, or a message
1131 1132 * boundary is reached in a message mode. If no data was read and
1132 1133 * the stream was not opened with the NDELAY flag, block until data arrives.
1133 1134 * Otherwise return the data read and update the count.
1134 1135 *
1135 1136 * In default mode a 0 length message signifies end-of-file and terminates
1136 1137 * a read in progress. The 0 length message is removed from the queue
1137 1138 * only if it is the only message read (no data is read).
1138 1139 *
1139 1140 * An attempt to read an M_PROTO or M_PCPROTO message results in an
1140 1141 * EBADMSG error return, unless either RD_PROTDAT or RD_PROTDIS are set.
1141 1142 * If RD_PROTDAT is set, M_PROTO and M_PCPROTO messages are read as data.
1142 1143 * If RD_PROTDIS is set, the M_PROTO and M_PCPROTO parts of the message
1143 1144 * are unlinked from and M_DATA blocks in the message, the protos are
1144 1145 * thrown away, and the data is read.
1145 1146 */
1146 1147 /* ARGSUSED */
1147 1148 int
1148 1149 strread(struct vnode *vp, struct uio *uiop, cred_t *crp)
1149 1150 {
1150 1151 struct stdata *stp;
1151 1152 mblk_t *bp, *nbp;
1152 1153 queue_t *q;
1153 1154 int error = 0;
1154 1155 uint_t old_sd_flag;
1155 1156 int first;
1156 1157 char rflg;
1157 1158 uint_t mark; /* Contains MSG*MARK and _LASTMARK */
1158 1159 #define _LASTMARK 0x8000 /* Distinct from MSG*MARK */
1159 1160 short delim;
1160 1161 unsigned char pri = 0;
1161 1162 char waitflag;
1162 1163 unsigned char type;
1163 1164
1164 1165 TRACE_1(TR_FAC_STREAMS_FR,
1165 1166 TR_STRREAD_ENTER, "strread:%p", vp);
1166 1167 ASSERT(vp->v_stream);
1167 1168 stp = vp->v_stream;
1168 1169
1169 1170 mutex_enter(&stp->sd_lock);
1170 1171
1171 1172 if ((error = i_straccess(stp, JCREAD)) != 0) {
1172 1173 mutex_exit(&stp->sd_lock);
1173 1174 return (error);
1174 1175 }
1175 1176
1176 1177 if (stp->sd_flag & (STRDERR|STPLEX)) {
1177 1178 error = strgeterr(stp, STRDERR|STPLEX, 0);
1178 1179 if (error != 0) {
1179 1180 mutex_exit(&stp->sd_lock);
1180 1181 return (error);
1181 1182 }
1182 1183 }
1183 1184
1184 1185 /*
1185 1186 * Loop terminates when uiop->uio_resid == 0.
1186 1187 */
1187 1188 rflg = 0;
1188 1189 waitflag = READWAIT;
1189 1190 q = _RD(stp->sd_wrq);
1190 1191 for (;;) {
1191 1192 ASSERT(MUTEX_HELD(&stp->sd_lock));
1192 1193 old_sd_flag = stp->sd_flag;
1193 1194 mark = 0;
1194 1195 delim = 0;
1195 1196 first = 1;
1196 1197 while ((bp = strget(stp, q, uiop, first, &error)) == NULL) {
1197 1198 int done = 0;
1198 1199
1199 1200 ASSERT(MUTEX_HELD(&stp->sd_lock));
1200 1201
1201 1202 if (error != 0)
1202 1203 goto oops;
1203 1204
1204 1205 if (stp->sd_flag & (STRHUP|STREOF)) {
1205 1206 goto oops;
1206 1207 }
1207 1208 if (rflg && !(stp->sd_flag & STRDELIM)) {
1208 1209 goto oops;
1209 1210 }
1210 1211 /*
1211 1212 * If a read(fd,buf,0) has been done, there is no
1212 1213 * need to sleep. We always have zero bytes to
1213 1214 * return.
1214 1215 */
1215 1216 if (uiop->uio_resid == 0) {
1216 1217 goto oops;
1217 1218 }
1218 1219
1219 1220 qbackenable(q, 0);
1220 1221
1221 1222 TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_WAIT,
1222 1223 "strread calls strwaitq:%p, %p, %p",
1223 1224 vp, uiop, crp);
1224 1225 if ((error = strwaitq(stp, waitflag, uiop->uio_resid,
1225 1226 uiop->uio_fmode, -1, &done)) != 0 || done) {
1226 1227 TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_DONE,
1227 1228 "strread error or done:%p, %p, %p",
1228 1229 vp, uiop, crp);
1229 1230 if ((uiop->uio_fmode & FNDELAY) &&
1230 1231 (stp->sd_flag & OLDNDELAY) &&
1231 1232 (error == EAGAIN))
1232 1233 error = 0;
1233 1234 goto oops;
1234 1235 }
1235 1236 TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_AWAKE,
1236 1237 "strread awakes:%p, %p, %p", vp, uiop, crp);
1237 1238 if ((error = i_straccess(stp, JCREAD)) != 0) {
1238 1239 goto oops;
1239 1240 }
1240 1241 first = 0;
1241 1242 }
1242 1243
1243 1244 ASSERT(MUTEX_HELD(&stp->sd_lock));
1244 1245 ASSERT(bp);
1245 1246 pri = bp->b_band;
1246 1247 /*
1247 1248 * Extract any mark information. If the message is not
1248 1249 * completely consumed this information will be put in the mblk
1249 1250 * that is putback.
1250 1251 * If MSGMARKNEXT is set and the message is completely consumed
1251 1252 * the STRATMARK flag will be set below. Likewise, if
1252 1253 * MSGNOTMARKNEXT is set and the message is
1253 1254 * completely consumed STRNOTATMARK will be set.
1254 1255 *
1255 1256 * For some unknown reason strread only breaks the read at the
1256 1257 * last mark.
1257 1258 */
1258 1259 mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
1259 1260 ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
1260 1261 (MSGMARKNEXT|MSGNOTMARKNEXT));
1261 1262 if (mark != 0 && bp == stp->sd_mark) {
1262 1263 if (rflg) {
1263 1264 putback(stp, q, bp, pri);
1264 1265 goto oops;
1265 1266 }
1266 1267 mark |= _LASTMARK;
1267 1268 stp->sd_mark = NULL;
1268 1269 }
1269 1270 if ((stp->sd_flag & STRDELIM) && (bp->b_flag & MSGDELIM))
1270 1271 delim = 1;
1271 1272 mutex_exit(&stp->sd_lock);
1272 1273
1273 1274 if (STREAM_NEEDSERVICE(stp))
1274 1275 stream_runservice(stp);
1275 1276
1276 1277 type = bp->b_datap->db_type;
1277 1278
1278 1279 switch (type) {
1279 1280
1280 1281 case M_DATA:
1281 1282 ismdata:
1282 1283 if (msgnodata(bp)) {
1283 1284 if (mark || delim) {
1284 1285 freemsg(bp);
1285 1286 } else if (rflg) {
1286 1287
1287 1288 /*
1288 1289 * If already read data put zero
1289 1290 * length message back on queue else
1290 1291 * free msg and return 0.
1291 1292 */
1292 1293 bp->b_band = pri;
1293 1294 mutex_enter(&stp->sd_lock);
1294 1295 putback(stp, q, bp, pri);
1295 1296 mutex_exit(&stp->sd_lock);
1296 1297 } else {
1297 1298 freemsg(bp);
1298 1299 }
1299 1300 error = 0;
1300 1301 goto oops1;
1301 1302 }
1302 1303
1303 1304 rflg = 1;
1304 1305 waitflag |= NOINTR;
1305 1306 bp = struiocopyout(bp, uiop, &error);
1306 1307 if (error != 0)
1307 1308 goto oops1;
1308 1309
1309 1310 mutex_enter(&stp->sd_lock);
1310 1311 if (bp) {
1311 1312 /*
1312 1313 * Have remaining data in message.
1313 1314 * Free msg if in discard mode.
1314 1315 */
1315 1316 if (stp->sd_read_opt & RD_MSGDIS) {
1316 1317 freemsg(bp);
1317 1318 } else {
1318 1319 bp->b_band = pri;
1319 1320 if ((mark & _LASTMARK) &&
1320 1321 (stp->sd_mark == NULL))
1321 1322 stp->sd_mark = bp;
1322 1323 bp->b_flag |= mark & ~_LASTMARK;
1323 1324 if (delim)
1324 1325 bp->b_flag |= MSGDELIM;
1325 1326 if (msgnodata(bp))
1326 1327 freemsg(bp);
1327 1328 else
1328 1329 putback(stp, q, bp, pri);
1329 1330 }
1330 1331 } else {
1331 1332 /*
1332 1333 * Consumed the complete message.
1333 1334 * Move the MSG*MARKNEXT information
1334 1335 * to the stream head just in case
1335 1336 * the read queue becomes empty.
1336 1337 *
1337 1338 * If the stream head was at the mark
1338 1339 * (STRATMARK) before we dropped sd_lock above
1339 1340 * and some data was consumed then we have
1340 1341 * moved past the mark thus STRATMARK is
1341 1342 * cleared. However, if a message arrived in
1342 1343 * strrput during the copyout above causing
1343 1344 * STRATMARK to be set we can not clear that
1344 1345 * flag.
1345 1346 */
1346 1347 if (mark &
1347 1348 (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
1348 1349 if (mark & MSGMARKNEXT) {
1349 1350 stp->sd_flag &= ~STRNOTATMARK;
1350 1351 stp->sd_flag |= STRATMARK;
1351 1352 } else if (mark & MSGNOTMARKNEXT) {
1352 1353 stp->sd_flag &= ~STRATMARK;
1353 1354 stp->sd_flag |= STRNOTATMARK;
1354 1355 } else {
1355 1356 stp->sd_flag &=
1356 1357 ~(STRATMARK|STRNOTATMARK);
1357 1358 }
1358 1359 } else if (rflg && (old_sd_flag & STRATMARK)) {
1359 1360 stp->sd_flag &= ~STRATMARK;
1360 1361 }
1361 1362 }
1362 1363
1363 1364 /*
1364 1365 * Check for signal messages at the front of the read
1365 1366 * queue and generate the signal(s) if appropriate.
1366 1367 * The only signal that can be on queue is M_SIG at
1367 1368 * this point.
1368 1369 */
1369 1370 while ((((bp = q->q_first)) != NULL) &&
1370 1371 (bp->b_datap->db_type == M_SIG)) {
1371 1372 bp = getq_noenab(q, 0);
1372 1373 /*
1373 1374 * sd_lock is held so the content of the
1374 1375 * read queue can not change.
1375 1376 */
1376 1377 ASSERT(bp != NULL && DB_TYPE(bp) == M_SIG);
1377 1378 strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
1378 1379 mutex_exit(&stp->sd_lock);
1379 1380 freemsg(bp);
1380 1381 if (STREAM_NEEDSERVICE(stp))
1381 1382 stream_runservice(stp);
1382 1383 mutex_enter(&stp->sd_lock);
1383 1384 }
1384 1385
1385 1386 if ((uiop->uio_resid == 0) || (mark & _LASTMARK) ||
1386 1387 delim ||
1387 1388 (stp->sd_read_opt & (RD_MSGDIS|RD_MSGNODIS))) {
1388 1389 goto oops;
1389 1390 }
1390 1391 continue;
1391 1392
1392 1393 case M_SIG:
1393 1394 strsignal(stp, *bp->b_rptr, (int32_t)bp->b_band);
1394 1395 freemsg(bp);
1395 1396 mutex_enter(&stp->sd_lock);
1396 1397 continue;
1397 1398
1398 1399 case M_PROTO:
1399 1400 case M_PCPROTO:
1400 1401 /*
1401 1402 * Only data messages are readable.
1402 1403 * Any others generate an error, unless
1403 1404 * RD_PROTDIS or RD_PROTDAT is set.
1404 1405 */
1405 1406 if (stp->sd_read_opt & RD_PROTDAT) {
1406 1407 for (nbp = bp; nbp; nbp = nbp->b_next) {
1407 1408 if ((nbp->b_datap->db_type ==
1408 1409 M_PROTO) ||
1409 1410 (nbp->b_datap->db_type ==
1410 1411 M_PCPROTO)) {
1411 1412 nbp->b_datap->db_type = M_DATA;
1412 1413 } else {
1413 1414 break;
1414 1415 }
1415 1416 }
1416 1417 /*
1417 1418 * clear stream head hi pri flag based on
1418 1419 * first message
1419 1420 */
1420 1421 if (type == M_PCPROTO) {
1421 1422 mutex_enter(&stp->sd_lock);
1422 1423 stp->sd_flag &= ~STRPRI;
1423 1424 mutex_exit(&stp->sd_lock);
1424 1425 }
1425 1426 goto ismdata;
1426 1427 } else if (stp->sd_read_opt & RD_PROTDIS) {
1427 1428 /*
1428 1429 * discard non-data messages
1429 1430 */
1430 1431 while (bp &&
1431 1432 ((bp->b_datap->db_type == M_PROTO) ||
1432 1433 (bp->b_datap->db_type == M_PCPROTO))) {
1433 1434 nbp = unlinkb(bp);
1434 1435 freeb(bp);
1435 1436 bp = nbp;
1436 1437 }
1437 1438 /*
1438 1439 * clear stream head hi pri flag based on
1439 1440 * first message
1440 1441 */
1441 1442 if (type == M_PCPROTO) {
1442 1443 mutex_enter(&stp->sd_lock);
1443 1444 stp->sd_flag &= ~STRPRI;
1444 1445 mutex_exit(&stp->sd_lock);
1445 1446 }
1446 1447 if (bp) {
1447 1448 bp->b_band = pri;
1448 1449 goto ismdata;
1449 1450 } else {
1450 1451 break;
1451 1452 }
1452 1453 }
1453 1454 /* FALLTHRU */
1454 1455 case M_PASSFP:
1455 1456 if ((bp->b_datap->db_type == M_PASSFP) &&
1456 1457 (stp->sd_read_opt & RD_PROTDIS)) {
1457 1458 freemsg(bp);
1458 1459 break;
1459 1460 }
1460 1461 mutex_enter(&stp->sd_lock);
1461 1462 putback(stp, q, bp, pri);
1462 1463 mutex_exit(&stp->sd_lock);
1463 1464 if (rflg == 0)
1464 1465 error = EBADMSG;
1465 1466 goto oops1;
1466 1467
1467 1468 default:
1468 1469 /*
1469 1470 * Garbage on stream head read queue.
1470 1471 */
1471 1472 cmn_err(CE_WARN, "bad %x found at stream head\n",
1472 1473 bp->b_datap->db_type);
1473 1474 freemsg(bp);
1474 1475 goto oops1;
1475 1476 }
1476 1477 mutex_enter(&stp->sd_lock);
1477 1478 }
1478 1479 oops:
1479 1480 mutex_exit(&stp->sd_lock);
1480 1481 oops1:
1481 1482 qbackenable(q, pri);
1482 1483 return (error);
1483 1484 #undef _LASTMARK
1484 1485 }
1485 1486
1486 1487 /*
1487 1488 * Default processing of M_PROTO/M_PCPROTO messages.
1488 1489 * Determine which wakeups and signals are needed.
1489 1490 * This can be replaced by a user-specified procedure for kernel users
1490 1491 * of STREAMS.
1491 1492 */
1492 1493 /* ARGSUSED */
1493 1494 mblk_t *
1494 1495 strrput_proto(vnode_t *vp, mblk_t *mp,
1495 1496 strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
1496 1497 strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
1497 1498 {
1498 1499 *wakeups = RSLEEP;
1499 1500 *allmsgsigs = 0;
1500 1501
1501 1502 switch (mp->b_datap->db_type) {
1502 1503 case M_PROTO:
1503 1504 if (mp->b_band == 0) {
1504 1505 *firstmsgsigs = S_INPUT | S_RDNORM;
1505 1506 *pollwakeups = POLLIN | POLLRDNORM;
1506 1507 } else {
1507 1508 *firstmsgsigs = S_INPUT | S_RDBAND;
1508 1509 *pollwakeups = POLLIN | POLLRDBAND;
1509 1510 }
1510 1511 break;
1511 1512 case M_PCPROTO:
1512 1513 *firstmsgsigs = S_HIPRI;
1513 1514 *pollwakeups = POLLPRI;
1514 1515 break;
1515 1516 }
1516 1517 return (mp);
1517 1518 }
1518 1519
1519 1520 /*
1520 1521 * Default processing of everything but M_DATA, M_PROTO, M_PCPROTO and
1521 1522 * M_PASSFP messages.
1522 1523 * Determine which wakeups and signals are needed.
1523 1524 * This can be replaced by a user-specified procedure for kernel users
1524 1525 * of STREAMS.
1525 1526 */
1526 1527 /* ARGSUSED */
1527 1528 mblk_t *
1528 1529 strrput_misc(vnode_t *vp, mblk_t *mp,
1529 1530 strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
1530 1531 strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
1531 1532 {
1532 1533 *wakeups = 0;
1533 1534 *firstmsgsigs = 0;
1534 1535 *allmsgsigs = 0;
1535 1536 *pollwakeups = 0;
1536 1537 return (mp);
1537 1538 }
1538 1539
1539 1540 /*
1540 1541 * Stream read put procedure. Called from downstream driver/module
1541 1542 * with messages for the stream head. Data, protocol, and in-stream
1542 1543 * signal messages are placed on the queue, others are handled directly.
1543 1544 */
1544 1545 int
1545 1546 strrput(queue_t *q, mblk_t *bp)
1546 1547 {
1547 1548 struct stdata *stp;
1548 1549 ulong_t rput_opt;
1549 1550 strwakeup_t wakeups;
1550 1551 strsigset_t firstmsgsigs; /* Signals if first message on queue */
1551 1552 strsigset_t allmsgsigs; /* Signals for all messages */
1552 1553 strsigset_t signals; /* Signals events to generate */
1553 1554 strpollset_t pollwakeups;
1554 1555 mblk_t *nextbp;
1555 1556 uchar_t band = 0;
1556 1557 int hipri_sig;
1557 1558
1558 1559 stp = (struct stdata *)q->q_ptr;
1559 1560 /*
1560 1561 * Use rput_opt for optimized access to the SR_ flags except
1561 1562 * SR_POLLIN. That flag has to be checked under sd_lock since it
1562 1563 * is modified by strpoll().
1563 1564 */
1564 1565 rput_opt = stp->sd_rput_opt;
1565 1566
1566 1567 ASSERT(qclaimed(q));
1567 1568 TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_ENTER,
1568 1569 "strrput called with message type:q %p bp %p", q, bp);
1569 1570
1570 1571 /*
1571 1572 * Perform initial processing and pass to the parameterized functions.
1572 1573 */
1573 1574 ASSERT(bp->b_next == NULL);
1574 1575
1575 1576 switch (bp->b_datap->db_type) {
1576 1577 case M_DATA:
1577 1578 /*
1578 1579 * sockfs is the only consumer of STREOF and when it is set,
1579 1580 * it implies that the receiver is not interested in receiving
1580 1581 * any more data, hence the mblk is freed to prevent unnecessary
1581 1582 * message queueing at the stream head.
1582 1583 */
1583 1584 if (stp->sd_flag == STREOF) {
1584 1585 freemsg(bp);
1585 1586 return (0);
1586 1587 }
1587 1588 if ((rput_opt & SR_IGN_ZEROLEN) &&
1588 1589 bp->b_rptr == bp->b_wptr && msgnodata(bp)) {
1589 1590 /*
1590 1591 * Ignore zero-length M_DATA messages. These might be
1591 1592 * generated by some transports.
1592 1593 * The zero-length M_DATA messages, even if they
1593 1594 * are ignored, should effect the atmark tracking and
1594 1595 * should wake up a thread sleeping in strwaitmark.
1595 1596 */
1596 1597 mutex_enter(&stp->sd_lock);
1597 1598 if (bp->b_flag & MSGMARKNEXT) {
1598 1599 /*
1599 1600 * Record the position of the mark either
1600 1601 * in q_last or in STRATMARK.
1601 1602 */
1602 1603 if (q->q_last != NULL) {
1603 1604 q->q_last->b_flag &= ~MSGNOTMARKNEXT;
1604 1605 q->q_last->b_flag |= MSGMARKNEXT;
1605 1606 } else {
1606 1607 stp->sd_flag &= ~STRNOTATMARK;
1607 1608 stp->sd_flag |= STRATMARK;
1608 1609 }
1609 1610 } else if (bp->b_flag & MSGNOTMARKNEXT) {
1610 1611 /*
1611 1612 * Record that this is not the position of
1612 1613 * the mark either in q_last or in
1613 1614 * STRNOTATMARK.
1614 1615 */
1615 1616 if (q->q_last != NULL) {
1616 1617 q->q_last->b_flag &= ~MSGMARKNEXT;
1617 1618 q->q_last->b_flag |= MSGNOTMARKNEXT;
1618 1619 } else {
1619 1620 stp->sd_flag &= ~STRATMARK;
1620 1621 stp->sd_flag |= STRNOTATMARK;
1621 1622 }
1622 1623 }
1623 1624 if (stp->sd_flag & RSLEEP) {
1624 1625 stp->sd_flag &= ~RSLEEP;
1625 1626 cv_broadcast(&q->q_wait);
1626 1627 }
1627 1628 mutex_exit(&stp->sd_lock);
1628 1629 freemsg(bp);
1629 1630 return (0);
1630 1631 }
1631 1632 wakeups = RSLEEP;
1632 1633 if (bp->b_band == 0) {
1633 1634 firstmsgsigs = S_INPUT | S_RDNORM;
1634 1635 pollwakeups = POLLIN | POLLRDNORM;
1635 1636 } else {
1636 1637 firstmsgsigs = S_INPUT | S_RDBAND;
1637 1638 pollwakeups = POLLIN | POLLRDBAND;
1638 1639 }
1639 1640 if (rput_opt & SR_SIGALLDATA)
1640 1641 allmsgsigs = firstmsgsigs;
1641 1642 else
1642 1643 allmsgsigs = 0;
1643 1644
1644 1645 mutex_enter(&stp->sd_lock);
1645 1646 if ((rput_opt & SR_CONSOL_DATA) &&
1646 1647 (q->q_last != NULL) &&
1647 1648 (bp->b_flag & (MSGMARK|MSGDELIM)) == 0) {
1648 1649 /*
1649 1650 * Consolidate an M_DATA message onto an M_DATA,
1650 1651 * M_PROTO, or M_PCPROTO by merging it with q_last.
1651 1652 * The consolidation does not take place if
1652 1653 * the old message is marked with either of the
1653 1654 * marks or the delim flag or if the new
1654 1655 * message is marked with MSGMARK. The MSGMARK
1655 1656 * check is needed to handle the odd semantics of
1656 1657 * MSGMARK where essentially the whole message
1657 1658 * is to be treated as marked.
1658 1659 * Carry any MSGMARKNEXT and MSGNOTMARKNEXT from the
1659 1660 * new message to the front of the b_cont chain.
1660 1661 */
1661 1662 mblk_t *lbp = q->q_last;
1662 1663 unsigned char db_type = lbp->b_datap->db_type;
1663 1664
1664 1665 if ((db_type == M_DATA || db_type == M_PROTO ||
1665 1666 db_type == M_PCPROTO) &&
1666 1667 !(lbp->b_flag & (MSGDELIM|MSGMARK|MSGMARKNEXT))) {
1667 1668 rmvq_noenab(q, lbp);
1668 1669 /*
1669 1670 * The first message in the b_cont list
1670 1671 * tracks MSGMARKNEXT and MSGNOTMARKNEXT.
1671 1672 * We need to handle the case where we
1672 1673 * are appending:
1673 1674 *
1674 1675 * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT.
1675 1676 * 2) a MSGMARKNEXT to a plain message.
1676 1677 * 3) a MSGNOTMARKNEXT to a plain message
1677 1678 * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT
1678 1679 * message.
1679 1680 *
1680 1681 * Thus we never append a MSGMARKNEXT or
1681 1682 * MSGNOTMARKNEXT to a MSGMARKNEXT message.
1682 1683 */
1683 1684 if (bp->b_flag & MSGMARKNEXT) {
1684 1685 lbp->b_flag |= MSGMARKNEXT;
1685 1686 lbp->b_flag &= ~MSGNOTMARKNEXT;
1686 1687 bp->b_flag &= ~MSGMARKNEXT;
1687 1688 } else if (bp->b_flag & MSGNOTMARKNEXT) {
1688 1689 lbp->b_flag |= MSGNOTMARKNEXT;
1689 1690 bp->b_flag &= ~MSGNOTMARKNEXT;
1690 1691 }
1691 1692
1692 1693 linkb(lbp, bp);
1693 1694 bp = lbp;
1694 1695 /*
1695 1696 * The new message logically isn't the first
1696 1697 * even though the q_first check below thinks
1697 1698 * it is. Clear the firstmsgsigs to make it
1698 1699 * not appear to be first.
1699 1700 */
1700 1701 firstmsgsigs = 0;
1701 1702 }
1702 1703 }
1703 1704 break;
1704 1705
1705 1706 case M_PASSFP:
1706 1707 wakeups = RSLEEP;
1707 1708 allmsgsigs = 0;
1708 1709 if (bp->b_band == 0) {
1709 1710 firstmsgsigs = S_INPUT | S_RDNORM;
1710 1711 pollwakeups = POLLIN | POLLRDNORM;
1711 1712 } else {
1712 1713 firstmsgsigs = S_INPUT | S_RDBAND;
1713 1714 pollwakeups = POLLIN | POLLRDBAND;
1714 1715 }
1715 1716 mutex_enter(&stp->sd_lock);
1716 1717 break;
1717 1718
1718 1719 case M_PROTO:
1719 1720 case M_PCPROTO:
1720 1721 ASSERT(stp->sd_rprotofunc != NULL);
1721 1722 bp = (stp->sd_rprotofunc)(stp->sd_vnode, bp,
1722 1723 &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
1723 1724 #define ALLSIG (S_INPUT|S_HIPRI|S_OUTPUT|S_MSG|S_ERROR|S_HANGUP|S_RDNORM|\
1724 1725 S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)
1725 1726 #define ALLPOLL (POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLWRNORM|POLLRDBAND|\
1726 1727 POLLWRBAND)
1727 1728
1728 1729 ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
1729 1730 ASSERT((firstmsgsigs & ~ALLSIG) == 0);
1730 1731 ASSERT((allmsgsigs & ~ALLSIG) == 0);
1731 1732 ASSERT((pollwakeups & ~ALLPOLL) == 0);
1732 1733
1733 1734 mutex_enter(&stp->sd_lock);
1734 1735 break;
1735 1736
1736 1737 default:
1737 1738 ASSERT(stp->sd_rmiscfunc != NULL);
1738 1739 bp = (stp->sd_rmiscfunc)(stp->sd_vnode, bp,
1739 1740 &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
1740 1741 ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
1741 1742 ASSERT((firstmsgsigs & ~ALLSIG) == 0);
1742 1743 ASSERT((allmsgsigs & ~ALLSIG) == 0);
1743 1744 ASSERT((pollwakeups & ~ALLPOLL) == 0);
1744 1745 #undef ALLSIG
1745 1746 #undef ALLPOLL
1746 1747 mutex_enter(&stp->sd_lock);
1747 1748 break;
1748 1749 }
1749 1750 ASSERT(MUTEX_HELD(&stp->sd_lock));
1750 1751
1751 1752 /* By default generate superset of signals */
1752 1753 signals = (firstmsgsigs | allmsgsigs);
1753 1754
1754 1755 /*
1755 1756 * The proto and misc functions can return multiple messages
1756 1757 * as a b_next chain. Such messages are processed separately.
1757 1758 */
1758 1759 one_more:
1759 1760 hipri_sig = 0;
1760 1761 if (bp == NULL) {
1761 1762 nextbp = NULL;
1762 1763 } else {
1763 1764 nextbp = bp->b_next;
1764 1765 bp->b_next = NULL;
1765 1766
1766 1767 switch (bp->b_datap->db_type) {
1767 1768 case M_PCPROTO:
1768 1769 /*
1769 1770 * Only one priority protocol message is allowed at the
1770 1771 * stream head at a time.
1771 1772 */
1772 1773 if (stp->sd_flag & STRPRI) {
1773 1774 TRACE_0(TR_FAC_STREAMS_FR, TR_STRRPUT_PROTERR,
1774 1775 "M_PCPROTO already at head");
1775 1776 freemsg(bp);
1776 1777 mutex_exit(&stp->sd_lock);
1777 1778 goto done;
1778 1779 }
1779 1780 stp->sd_flag |= STRPRI;
1780 1781 hipri_sig = 1;
1781 1782 /* FALLTHRU */
1782 1783 case M_DATA:
1783 1784 case M_PROTO:
1784 1785 case M_PASSFP:
1785 1786 band = bp->b_band;
1786 1787 /*
1787 1788 * Marking doesn't work well when messages
1788 1789 * are marked in more than one band. We only
1789 1790 * remember the last message received, even if
1790 1791 * it is placed on the queue ahead of other
1791 1792 * marked messages.
1792 1793 */
1793 1794 if (bp->b_flag & MSGMARK)
1794 1795 stp->sd_mark = bp;
1795 1796 (void) putq(q, bp);
1796 1797
1797 1798 /*
1798 1799 * If message is a PCPROTO message, always use
1799 1800 * firstmsgsigs to determine if a signal should be
1800 1801 * sent as strrput is the only place to send
1801 1802 * signals for PCPROTO. Other messages are based on
1802 1803 * the STRGETINPROG flag. The flag determines if
1803 1804 * strrput or (k)strgetmsg will be responsible for
1804 1805 * sending the signals, in the firstmsgsigs case.
1805 1806 */
1806 1807 if ((hipri_sig == 1) ||
1807 1808 (((stp->sd_flag & STRGETINPROG) == 0) &&
1808 1809 (q->q_first == bp)))
1809 1810 signals = (firstmsgsigs | allmsgsigs);
1810 1811 else
1811 1812 signals = allmsgsigs;
1812 1813 break;
1813 1814
1814 1815 default:
1815 1816 mutex_exit(&stp->sd_lock);
1816 1817 (void) strrput_nondata(q, bp);
1817 1818 mutex_enter(&stp->sd_lock);
1818 1819 break;
1819 1820 }
1820 1821 }
1821 1822 ASSERT(MUTEX_HELD(&stp->sd_lock));
1822 1823 /*
1823 1824 * Wake sleeping read/getmsg and cancel deferred wakeup
1824 1825 */
1825 1826 if (wakeups & RSLEEP)
1826 1827 stp->sd_wakeq &= ~RSLEEP;
1827 1828
1828 1829 wakeups &= stp->sd_flag;
1829 1830 if (wakeups & RSLEEP) {
1830 1831 stp->sd_flag &= ~RSLEEP;
1831 1832 cv_broadcast(&q->q_wait);
1832 1833 }
1833 1834 if (wakeups & WSLEEP) {
1834 1835 stp->sd_flag &= ~WSLEEP;
1835 1836 cv_broadcast(&_WR(q)->q_wait);
1836 1837 }
1837 1838
1838 1839 if (pollwakeups != 0) {
1839 1840 if (pollwakeups == (POLLIN | POLLRDNORM)) {
1840 1841 /*
1841 1842 * Can't use rput_opt since it was not
1842 1843 * read when sd_lock was held and SR_POLLIN is changed
1843 1844 * by strpoll() under sd_lock.
1844 1845 */
1845 1846 if (!(stp->sd_rput_opt & SR_POLLIN))
1846 1847 goto no_pollwake;
1847 1848 stp->sd_rput_opt &= ~SR_POLLIN;
1848 1849 }
1849 1850 mutex_exit(&stp->sd_lock);
1850 1851 pollwakeup(&stp->sd_pollist, pollwakeups);
1851 1852 mutex_enter(&stp->sd_lock);
1852 1853 }
1853 1854 no_pollwake:
1854 1855
1855 1856 /*
1856 1857 * strsendsig can handle multiple signals with a
1857 1858 * single call.
1858 1859 */
1859 1860 if (stp->sd_sigflags & signals)
1860 1861 strsendsig(stp->sd_siglist, signals, band, 0);
1861 1862 mutex_exit(&stp->sd_lock);
1862 1863
1863 1864
1864 1865 done:
1865 1866 if (nextbp == NULL)
1866 1867 return (0);
1867 1868
1868 1869 /*
1869 1870 * Any signals were handled the first time.
1870 1871 * Wakeups and pollwakeups are redone to avoid any race
1871 1872 * conditions - all the messages are not queued until the
1872 1873 * last message has been processed by strrput.
1873 1874 */
1874 1875 bp = nextbp;
1875 1876 signals = firstmsgsigs = allmsgsigs = 0;
1876 1877 mutex_enter(&stp->sd_lock);
1877 1878 goto one_more;
1878 1879 }
1879 1880
1880 1881 static void
1881 1882 log_dupioc(queue_t *rq, mblk_t *bp)
1882 1883 {
1883 1884 queue_t *wq, *qp;
1884 1885 char *modnames, *mnp, *dname;
1885 1886 size_t maxmodstr;
1886 1887 boolean_t islast;
1887 1888
1888 1889 /*
1889 1890 * Allocate a buffer large enough to hold the names of nstrpush modules
1890 1891 * and one driver, with spaces between and NUL terminator. If we can't
1891 1892 * get memory, then we'll just log the driver name.
1892 1893 */
1893 1894 maxmodstr = nstrpush * (FMNAMESZ + 1);
1894 1895 mnp = modnames = kmem_alloc(maxmodstr, KM_NOSLEEP);
1895 1896
1896 1897 /* march down write side to print log message down to the driver */
1897 1898 wq = WR(rq);
1898 1899
1899 1900 /* make sure q_next doesn't shift around while we're grabbing data */
1900 1901 claimstr(wq);
1901 1902 qp = wq->q_next;
1902 1903 do {
1903 1904 dname = Q2NAME(qp);
1904 1905 islast = !SAMESTR(qp) || qp->q_next == NULL;
1905 1906 if (modnames == NULL) {
1906 1907 /*
1907 1908 * If we don't have memory, then get the driver name in
1908 1909 * the log where we can see it. Note that memory
1909 1910 * pressure is a possible cause of these sorts of bugs.
1910 1911 */
1911 1912 if (islast) {
1912 1913 modnames = dname;
1913 1914 maxmodstr = 0;
1914 1915 }
1915 1916 } else {
1916 1917 mnp += snprintf(mnp, FMNAMESZ + 1, "%s", dname);
1917 1918 if (!islast)
1918 1919 *mnp++ = ' ';
1919 1920 }
1920 1921 qp = qp->q_next;
1921 1922 } while (!islast);
1922 1923 releasestr(wq);
1923 1924 /* Cannot happen unless stream head is corrupt. */
1924 1925 ASSERT(modnames != NULL);
1925 1926 (void) strlog(rq->q_qinfo->qi_minfo->mi_idnum, 0, 1,
1926 1927 SL_CONSOLE|SL_TRACE|SL_ERROR,
1927 1928 "Warning: stream %p received duplicate %X M_IOC%s; module list: %s",
1928 1929 rq->q_ptr, ((struct iocblk *)bp->b_rptr)->ioc_cmd,
1929 1930 (DB_TYPE(bp) == M_IOCACK ? "ACK" : "NAK"), modnames);
1930 1931 if (maxmodstr != 0)
1931 1932 kmem_free(modnames, maxmodstr);
1932 1933 }
1933 1934
1934 1935 int
1935 1936 strrput_nondata(queue_t *q, mblk_t *bp)
1936 1937 {
1937 1938 struct stdata *stp;
1938 1939 struct iocblk *iocbp;
1939 1940 struct stroptions *sop;
1940 1941 struct copyreq *reqp;
1941 1942 struct copyresp *resp;
1942 1943 unsigned char bpri;
1943 1944 unsigned char flushed_already = 0;
1944 1945
1945 1946 stp = (struct stdata *)q->q_ptr;
1946 1947
1947 1948 ASSERT(!(stp->sd_flag & STPLEX));
1948 1949 ASSERT(qclaimed(q));
1949 1950
1950 1951 switch (bp->b_datap->db_type) {
1951 1952 case M_ERROR:
1952 1953 /*
1953 1954 * An error has occurred downstream, the errno is in the first
1954 1955 * bytes of the message.
1955 1956 */
1956 1957 if ((bp->b_wptr - bp->b_rptr) == 2) { /* New flavor */
1957 1958 unsigned char rw = 0;
1958 1959
1959 1960 mutex_enter(&stp->sd_lock);
1960 1961 if (*bp->b_rptr != NOERROR) { /* read error */
1961 1962 if (*bp->b_rptr != 0) {
1962 1963 if (stp->sd_flag & STRDERR)
1963 1964 flushed_already |= FLUSHR;
1964 1965 stp->sd_flag |= STRDERR;
1965 1966 rw |= FLUSHR;
1966 1967 } else {
1967 1968 stp->sd_flag &= ~STRDERR;
1968 1969 }
1969 1970 stp->sd_rerror = *bp->b_rptr;
1970 1971 }
1971 1972 bp->b_rptr++;
1972 1973 if (*bp->b_rptr != NOERROR) { /* write error */
1973 1974 if (*bp->b_rptr != 0) {
1974 1975 if (stp->sd_flag & STWRERR)
1975 1976 flushed_already |= FLUSHW;
1976 1977 stp->sd_flag |= STWRERR;
1977 1978 rw |= FLUSHW;
1978 1979 } else {
1979 1980 stp->sd_flag &= ~STWRERR;
1980 1981 }
1981 1982 stp->sd_werror = *bp->b_rptr;
1982 1983 }
1983 1984 if (rw) {
1984 1985 TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_WAKE,
1985 1986 "strrput cv_broadcast:q %p, bp %p",
1986 1987 q, bp);
1987 1988 cv_broadcast(&q->q_wait); /* readers */
1988 1989 cv_broadcast(&_WR(q)->q_wait); /* writers */
1989 1990 cv_broadcast(&stp->sd_monitor); /* ioctllers */
1990 1991
1991 1992 mutex_exit(&stp->sd_lock);
1992 1993 pollwakeup(&stp->sd_pollist, POLLERR);
1993 1994 mutex_enter(&stp->sd_lock);
1994 1995
1995 1996 if (stp->sd_sigflags & S_ERROR)
1996 1997 strsendsig(stp->sd_siglist, S_ERROR, 0,
1997 1998 ((rw & FLUSHR) ? stp->sd_rerror :
1998 1999 stp->sd_werror));
1999 2000 mutex_exit(&stp->sd_lock);
2000 2001 /*
2001 2002 * Send the M_FLUSH only
2002 2003 * for the first M_ERROR
2003 2004 * message on the stream
2004 2005 */
2005 2006 if (flushed_already == rw) {
2006 2007 freemsg(bp);
2007 2008 return (0);
2008 2009 }
2009 2010
2010 2011 bp->b_datap->db_type = M_FLUSH;
2011 2012 *bp->b_rptr = rw;
2012 2013 bp->b_wptr = bp->b_rptr + 1;
2013 2014 /*
2014 2015 * Protect against the driver
2015 2016 * passing up messages after
2016 2017 * it has done a qprocsoff
2017 2018 */
2018 2019 if (_OTHERQ(q)->q_next == NULL)
2019 2020 freemsg(bp);
2020 2021 else
2021 2022 qreply(q, bp);
2022 2023 return (0);
2023 2024 } else
2024 2025 mutex_exit(&stp->sd_lock);
2025 2026 } else if (*bp->b_rptr != 0) { /* Old flavor */
2026 2027 if (stp->sd_flag & (STRDERR|STWRERR))
2027 2028 flushed_already = FLUSHRW;
2028 2029 mutex_enter(&stp->sd_lock);
2029 2030 stp->sd_flag |= (STRDERR|STWRERR);
2030 2031 stp->sd_rerror = *bp->b_rptr;
2031 2032 stp->sd_werror = *bp->b_rptr;
2032 2033 TRACE_2(TR_FAC_STREAMS_FR,
2033 2034 TR_STRRPUT_WAKE2,
2034 2035 "strrput wakeup #2:q %p, bp %p", q, bp);
2035 2036 cv_broadcast(&q->q_wait); /* the readers */
2036 2037 cv_broadcast(&_WR(q)->q_wait); /* the writers */
2037 2038 cv_broadcast(&stp->sd_monitor); /* ioctllers */
2038 2039
2039 2040 mutex_exit(&stp->sd_lock);
2040 2041 pollwakeup(&stp->sd_pollist, POLLERR);
2041 2042 mutex_enter(&stp->sd_lock);
2042 2043
2043 2044 if (stp->sd_sigflags & S_ERROR)
2044 2045 strsendsig(stp->sd_siglist, S_ERROR, 0,
2045 2046 (stp->sd_werror ? stp->sd_werror :
2046 2047 stp->sd_rerror));
2047 2048 mutex_exit(&stp->sd_lock);
2048 2049
2049 2050 /*
2050 2051 * Send the M_FLUSH only
2051 2052 * for the first M_ERROR
2052 2053 * message on the stream
2053 2054 */
2054 2055 if (flushed_already != FLUSHRW) {
2055 2056 bp->b_datap->db_type = M_FLUSH;
2056 2057 *bp->b_rptr = FLUSHRW;
2057 2058 /*
2058 2059 * Protect against the driver passing up
2059 2060 * messages after it has done a
2060 2061 * qprocsoff.
2061 2062 */
2062 2063 if (_OTHERQ(q)->q_next == NULL)
2063 2064 freemsg(bp);
2064 2065 else
2065 2066 qreply(q, bp);
2066 2067 return (0);
2067 2068 }
2068 2069 }
2069 2070 freemsg(bp);
2070 2071 return (0);
2071 2072
2072 2073 case M_HANGUP:
2073 2074
2074 2075 freemsg(bp);
2075 2076 mutex_enter(&stp->sd_lock);
2076 2077 stp->sd_werror = ENXIO;
2077 2078 stp->sd_flag |= STRHUP;
2078 2079 stp->sd_flag &= ~(WSLEEP|RSLEEP);
2079 2080
2080 2081 /*
2081 2082 * send signal if controlling tty
2082 2083 */
2083 2084
2084 2085 if (stp->sd_sidp) {
2085 2086 prsignal(stp->sd_sidp, SIGHUP);
2086 2087 if (stp->sd_sidp != stp->sd_pgidp)
2087 2088 pgsignal(stp->sd_pgidp, SIGTSTP);
2088 2089 }
2089 2090
2090 2091 /*
2091 2092 * wake up read, write, and exception pollers and
2092 2093 * reset wakeup mechanism.
2093 2094 */
2094 2095 cv_broadcast(&q->q_wait); /* the readers */
2095 2096 cv_broadcast(&_WR(q)->q_wait); /* the writers */
2096 2097 cv_broadcast(&stp->sd_monitor); /* the ioctllers */
2097 2098 strhup(stp);
2098 2099 mutex_exit(&stp->sd_lock);
2099 2100 return (0);
2100 2101
2101 2102 case M_UNHANGUP:
2102 2103 freemsg(bp);
2103 2104 mutex_enter(&stp->sd_lock);
2104 2105 stp->sd_werror = 0;
2105 2106 stp->sd_flag &= ~STRHUP;
2106 2107 mutex_exit(&stp->sd_lock);
2107 2108 return (0);
2108 2109
2109 2110 case M_SIG:
2110 2111 /*
2111 2112 * Someone downstream wants to post a signal. The
2112 2113 * signal to post is contained in the first byte of the
2113 2114 * message. If the message would go on the front of
2114 2115 * the queue, send a signal to the process group
2115 2116 * (if not SIGPOLL) or to the siglist processes
2116 2117 * (SIGPOLL). If something is already on the queue,
2117 2118 * OR if we are delivering a delayed suspend (*sigh*
2118 2119 * another "tty" hack) and there's no one sleeping already,
2119 2120 * just enqueue the message.
2120 2121 */
2121 2122 mutex_enter(&stp->sd_lock);
2122 2123 if (q->q_first || (*bp->b_rptr == SIGTSTP &&
2123 2124 !(stp->sd_flag & RSLEEP))) {
2124 2125 (void) putq(q, bp);
2125 2126 mutex_exit(&stp->sd_lock);
2126 2127 return (0);
2127 2128 }
2128 2129 mutex_exit(&stp->sd_lock);
2129 2130 /* FALLTHRU */
2130 2131
2131 2132 case M_PCSIG:
2132 2133 /*
2133 2134 * Don't enqueue, just post the signal.
2134 2135 */
2135 2136 strsignal(stp, *bp->b_rptr, 0L);
2136 2137 freemsg(bp);
2137 2138 return (0);
2138 2139
2139 2140 case M_CMD:
2140 2141 if (MBLKL(bp) != sizeof (cmdblk_t)) {
2141 2142 freemsg(bp);
2142 2143 return (0);
2143 2144 }
2144 2145
2145 2146 mutex_enter(&stp->sd_lock);
2146 2147 if (stp->sd_flag & STRCMDWAIT) {
2147 2148 ASSERT(stp->sd_cmdblk == NULL);
2148 2149 stp->sd_cmdblk = bp;
2149 2150 cv_broadcast(&stp->sd_monitor);
2150 2151 mutex_exit(&stp->sd_lock);
2151 2152 } else {
2152 2153 mutex_exit(&stp->sd_lock);
2153 2154 freemsg(bp);
2154 2155 }
2155 2156 return (0);
2156 2157
2157 2158 case M_FLUSH:
2158 2159 /*
2159 2160 * Flush queues. The indication of which queues to flush
2160 2161 * is in the first byte of the message. If the read queue
2161 2162 * is specified, then flush it. If FLUSHBAND is set, just
2162 2163 * flush the band specified by the second byte of the message.
2163 2164 *
2164 2165 * If a module has issued a M_SETOPT to not flush hi
2165 2166 * priority messages off of the stream head, then pass this
2166 2167 * flag into the flushq code to preserve such messages.
2167 2168 */
2168 2169
2169 2170 if (*bp->b_rptr & FLUSHR) {
2170 2171 mutex_enter(&stp->sd_lock);
2171 2172 if (*bp->b_rptr & FLUSHBAND) {
2172 2173 ASSERT((bp->b_wptr - bp->b_rptr) >= 2);
2173 2174 flushband(q, *(bp->b_rptr + 1), FLUSHALL);
2174 2175 } else
2175 2176 flushq_common(q, FLUSHALL,
2176 2177 stp->sd_read_opt & RFLUSHPCPROT);
2177 2178 if ((q->q_first == NULL) ||
2178 2179 (q->q_first->b_datap->db_type < QPCTL))
2179 2180 stp->sd_flag &= ~STRPRI;
2180 2181 else {
2181 2182 ASSERT(stp->sd_flag & STRPRI);
2182 2183 }
2183 2184 mutex_exit(&stp->sd_lock);
2184 2185 }
2185 2186 if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
2186 2187 *bp->b_rptr &= ~FLUSHR;
2187 2188 bp->b_flag |= MSGNOLOOP;
2188 2189 /*
2189 2190 * Protect against the driver passing up
2190 2191 * messages after it has done a qprocsoff.
2191 2192 */
2192 2193 if (_OTHERQ(q)->q_next == NULL)
2193 2194 freemsg(bp);
2194 2195 else
2195 2196 qreply(q, bp);
2196 2197 return (0);
2197 2198 }
2198 2199 freemsg(bp);
2199 2200 return (0);
2200 2201
2201 2202 case M_IOCACK:
2202 2203 case M_IOCNAK:
2203 2204 iocbp = (struct iocblk *)bp->b_rptr;
2204 2205 /*
2205 2206 * If not waiting for ACK or NAK then just free msg.
2206 2207 * If incorrect id sequence number then just free msg.
2207 2208 * If already have ACK or NAK for user then this is a
2208 2209 * duplicate, display a warning and free the msg.
2209 2210 */
2210 2211 mutex_enter(&stp->sd_lock);
2211 2212 if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
2212 2213 (stp->sd_iocid != iocbp->ioc_id)) {
2213 2214 /*
2214 2215 * If the ACK/NAK is a dup, display a message
2215 2216 * Dup is when sd_iocid == ioc_id, and
2216 2217 * sd_iocblk == <valid ptr> or -1 (the former
2217 2218 * is when an ioctl has been put on the stream
2218 2219 * head, but has not yet been consumed, the
2219 2220 * later is when it has been consumed).
2220 2221 */
2221 2222 if ((stp->sd_iocid == iocbp->ioc_id) &&
2222 2223 (stp->sd_iocblk != NULL)) {
2223 2224 log_dupioc(q, bp);
2224 2225 }
2225 2226 freemsg(bp);
2226 2227 mutex_exit(&stp->sd_lock);
2227 2228 return (0);
2228 2229 }
2229 2230
2230 2231 /*
2231 2232 * Assign ACK or NAK to user and wake up.
2232 2233 */
2233 2234 stp->sd_iocblk = bp;
2234 2235 cv_broadcast(&stp->sd_monitor);
2235 2236 mutex_exit(&stp->sd_lock);
2236 2237 return (0);
2237 2238
2238 2239 case M_COPYIN:
2239 2240 case M_COPYOUT:
2240 2241 reqp = (struct copyreq *)bp->b_rptr;
2241 2242
2242 2243 /*
2243 2244 * If not waiting for ACK or NAK then just fail request.
2244 2245 * If already have ACK, NAK, or copy request, then just
2245 2246 * fail request.
2246 2247 * If incorrect id sequence number then just fail request.
2247 2248 */
2248 2249 mutex_enter(&stp->sd_lock);
2249 2250 if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
2250 2251 (stp->sd_iocid != reqp->cq_id)) {
2251 2252 if (bp->b_cont) {
2252 2253 freemsg(bp->b_cont);
2253 2254 bp->b_cont = NULL;
2254 2255 }
2255 2256 bp->b_datap->db_type = M_IOCDATA;
2256 2257 bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
2257 2258 resp = (struct copyresp *)bp->b_rptr;
2258 2259 resp->cp_rval = (caddr_t)1; /* failure */
2259 2260 mutex_exit(&stp->sd_lock);
2260 2261 putnext(stp->sd_wrq, bp);
2261 2262 return (0);
2262 2263 }
2263 2264
2264 2265 /*
2265 2266 * Assign copy request to user and wake up.
2266 2267 */
2267 2268 stp->sd_iocblk = bp;
2268 2269 cv_broadcast(&stp->sd_monitor);
2269 2270 mutex_exit(&stp->sd_lock);
2270 2271 return (0);
2271 2272
2272 2273 case M_SETOPTS:
2273 2274 /*
2274 2275 * Set stream head options (read option, write offset,
2275 2276 * min/max packet size, and/or high/low water marks for
2276 2277 * the read side only).
2277 2278 */
2278 2279
2279 2280 bpri = 0;
2280 2281 sop = (struct stroptions *)bp->b_rptr;
2281 2282 mutex_enter(&stp->sd_lock);
2282 2283 if (sop->so_flags & SO_READOPT) {
2283 2284 switch (sop->so_readopt & RMODEMASK) {
2284 2285 case RNORM:
2285 2286 stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
2286 2287 break;
2287 2288
2288 2289 case RMSGD:
2289 2290 stp->sd_read_opt =
2290 2291 ((stp->sd_read_opt & ~RD_MSGNODIS) |
2291 2292 RD_MSGDIS);
2292 2293 break;
2293 2294
2294 2295 case RMSGN:
2295 2296 stp->sd_read_opt =
2296 2297 ((stp->sd_read_opt & ~RD_MSGDIS) |
2297 2298 RD_MSGNODIS);
2298 2299 break;
2299 2300 }
2300 2301 switch (sop->so_readopt & RPROTMASK) {
2301 2302 case RPROTNORM:
2302 2303 stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
2303 2304 break;
2304 2305
2305 2306 case RPROTDAT:
2306 2307 stp->sd_read_opt =
2307 2308 ((stp->sd_read_opt & ~RD_PROTDIS) |
2308 2309 RD_PROTDAT);
2309 2310 break;
2310 2311
2311 2312 case RPROTDIS:
2312 2313 stp->sd_read_opt =
2313 2314 ((stp->sd_read_opt & ~RD_PROTDAT) |
2314 2315 RD_PROTDIS);
2315 2316 break;
2316 2317 }
2317 2318 switch (sop->so_readopt & RFLUSHMASK) {
2318 2319 case RFLUSHPCPROT:
2319 2320 /*
2320 2321 * This sets the stream head to NOT flush
2321 2322 * M_PCPROTO messages.
2322 2323 */
2323 2324 stp->sd_read_opt |= RFLUSHPCPROT;
2324 2325 break;
2325 2326 }
2326 2327 }
2327 2328 if (sop->so_flags & SO_ERROPT) {
2328 2329 switch (sop->so_erropt & RERRMASK) {
2329 2330 case RERRNORM:
2330 2331 stp->sd_flag &= ~STRDERRNONPERSIST;
2331 2332 break;
2332 2333 case RERRNONPERSIST:
2333 2334 stp->sd_flag |= STRDERRNONPERSIST;
2334 2335 break;
2335 2336 }
2336 2337 switch (sop->so_erropt & WERRMASK) {
2337 2338 case WERRNORM:
2338 2339 stp->sd_flag &= ~STWRERRNONPERSIST;
2339 2340 break;
2340 2341 case WERRNONPERSIST:
2341 2342 stp->sd_flag |= STWRERRNONPERSIST;
2342 2343 break;
2343 2344 }
2344 2345 }
2345 2346 if (sop->so_flags & SO_COPYOPT) {
2346 2347 if (sop->so_copyopt & ZCVMSAFE) {
2347 2348 stp->sd_copyflag |= STZCVMSAFE;
2348 2349 stp->sd_copyflag &= ~STZCVMUNSAFE;
2349 2350 } else if (sop->so_copyopt & ZCVMUNSAFE) {
2350 2351 stp->sd_copyflag |= STZCVMUNSAFE;
2351 2352 stp->sd_copyflag &= ~STZCVMSAFE;
2352 2353 }
2353 2354
2354 2355 if (sop->so_copyopt & COPYCACHED) {
2355 2356 stp->sd_copyflag |= STRCOPYCACHED;
2356 2357 }
2357 2358 }
2358 2359 if (sop->so_flags & SO_WROFF)
2359 2360 stp->sd_wroff = sop->so_wroff;
2360 2361 if (sop->so_flags & SO_TAIL)
2361 2362 stp->sd_tail = sop->so_tail;
2362 2363 if (sop->so_flags & SO_MINPSZ)
2363 2364 q->q_minpsz = sop->so_minpsz;
2364 2365 if (sop->so_flags & SO_MAXPSZ)
2365 2366 q->q_maxpsz = sop->so_maxpsz;
2366 2367 if (sop->so_flags & SO_MAXBLK)
2367 2368 stp->sd_maxblk = sop->so_maxblk;
2368 2369 if (sop->so_flags & SO_HIWAT) {
2369 2370 if (sop->so_flags & SO_BAND) {
2370 2371 if (strqset(q, QHIWAT,
2371 2372 sop->so_band, sop->so_hiwat)) {
2372 2373 cmn_err(CE_WARN, "strrput: could not "
2373 2374 "allocate qband\n");
2374 2375 } else {
2375 2376 bpri = sop->so_band;
2376 2377 }
2377 2378 } else {
2378 2379 q->q_hiwat = sop->so_hiwat;
2379 2380 }
2380 2381 }
2381 2382 if (sop->so_flags & SO_LOWAT) {
2382 2383 if (sop->so_flags & SO_BAND) {
2383 2384 if (strqset(q, QLOWAT,
2384 2385 sop->so_band, sop->so_lowat)) {
2385 2386 cmn_err(CE_WARN, "strrput: could not "
2386 2387 "allocate qband\n");
2387 2388 } else {
2388 2389 bpri = sop->so_band;
2389 2390 }
2390 2391 } else {
2391 2392 q->q_lowat = sop->so_lowat;
2392 2393 }
2393 2394 }
2394 2395 if (sop->so_flags & SO_MREADON)
2395 2396 stp->sd_flag |= SNDMREAD;
2396 2397 if (sop->so_flags & SO_MREADOFF)
2397 2398 stp->sd_flag &= ~SNDMREAD;
2398 2399 if (sop->so_flags & SO_NDELON)
2399 2400 stp->sd_flag |= OLDNDELAY;
2400 2401 if (sop->so_flags & SO_NDELOFF)
2401 2402 stp->sd_flag &= ~OLDNDELAY;
2402 2403 if (sop->so_flags & SO_ISTTY)
2403 2404 stp->sd_flag |= STRISTTY;
2404 2405 if (sop->so_flags & SO_ISNTTY)
2405 2406 stp->sd_flag &= ~STRISTTY;
2406 2407 if (sop->so_flags & SO_TOSTOP)
2407 2408 stp->sd_flag |= STRTOSTOP;
2408 2409 if (sop->so_flags & SO_TONSTOP)
2409 2410 stp->sd_flag &= ~STRTOSTOP;
2410 2411 if (sop->so_flags & SO_DELIM)
2411 2412 stp->sd_flag |= STRDELIM;
2412 2413 if (sop->so_flags & SO_NODELIM)
2413 2414 stp->sd_flag &= ~STRDELIM;
2414 2415
2415 2416 mutex_exit(&stp->sd_lock);
2416 2417 freemsg(bp);
2417 2418
2418 2419 /* Check backenable in case the water marks changed */
2419 2420 qbackenable(q, bpri);
2420 2421 return (0);
2421 2422
2422 2423 /*
2423 2424 * The following set of cases deal with situations where two stream
2424 2425 * heads are connected to each other (twisted streams). These messages
2425 2426 * have no meaning at the stream head.
2426 2427 */
2427 2428 case M_BREAK:
2428 2429 case M_CTL:
2429 2430 case M_DELAY:
2430 2431 case M_START:
2431 2432 case M_STOP:
2432 2433 case M_IOCDATA:
2433 2434 case M_STARTI:
2434 2435 case M_STOPI:
2435 2436 freemsg(bp);
2436 2437 return (0);
2437 2438
2438 2439 case M_IOCTL:
2439 2440 /*
2440 2441 * Always NAK this condition
2441 2442 * (makes no sense)
2442 2443 * If there is one or more threads in the read side
2443 2444 * rwnext we have to defer the nacking until that thread
2444 2445 * returns (in strget).
2445 2446 */
2446 2447 mutex_enter(&stp->sd_lock);
2447 2448 if (stp->sd_struiodnak != 0) {
2448 2449 /*
2449 2450 * Defer NAK to the streamhead. Queue at the end
2450 2451 * the list.
2451 2452 */
2452 2453 mblk_t *mp = stp->sd_struionak;
2453 2454
2454 2455 while (mp && mp->b_next)
2455 2456 mp = mp->b_next;
2456 2457 if (mp)
2457 2458 mp->b_next = bp;
2458 2459 else
2459 2460 stp->sd_struionak = bp;
2460 2461 bp->b_next = NULL;
2461 2462 mutex_exit(&stp->sd_lock);
2462 2463 return (0);
2463 2464 }
2464 2465 mutex_exit(&stp->sd_lock);
2465 2466
2466 2467 bp->b_datap->db_type = M_IOCNAK;
2467 2468 /*
2468 2469 * Protect against the driver passing up
2469 2470 * messages after it has done a qprocsoff.
2470 2471 */
2471 2472 if (_OTHERQ(q)->q_next == NULL)
2472 2473 freemsg(bp);
2473 2474 else
2474 2475 qreply(q, bp);
2475 2476 return (0);
2476 2477
2477 2478 default:
2478 2479 #ifdef DEBUG
2479 2480 cmn_err(CE_WARN,
2480 2481 "bad message type %x received at stream head\n",
2481 2482 bp->b_datap->db_type);
2482 2483 #endif
2483 2484 freemsg(bp);
2484 2485 return (0);
2485 2486 }
2486 2487
2487 2488 /* NOTREACHED */
2488 2489 }
2489 2490
2490 2491 /*
2491 2492 * Check if the stream pointed to by `stp' can be written to, and return an
2492 2493 * error code if not. If `eiohup' is set, then return EIO if STRHUP is set.
2493 2494 * If `sigpipeok' is set and the SW_SIGPIPE option is enabled on the stream,
2494 2495 * then always return EPIPE and send a SIGPIPE to the invoking thread.
2495 2496 */
2496 2497 static int
2497 2498 strwriteable(struct stdata *stp, boolean_t eiohup, boolean_t sigpipeok)
2498 2499 {
2499 2500 int error;
2500 2501
2501 2502 ASSERT(MUTEX_HELD(&stp->sd_lock));
2502 2503
2503 2504 /*
2504 2505 * For modem support, POSIX states that on writes, EIO should
2505 2506 * be returned if the stream has been hung up.
2506 2507 */
2507 2508 if (eiohup && (stp->sd_flag & (STPLEX|STRHUP)) == STRHUP)
2508 2509 error = EIO;
2509 2510 else
2510 2511 error = strgeterr(stp, STRHUP|STPLEX|STWRERR, 0);
2511 2512
2512 2513 if (error != 0) {
2513 2514 if (!(stp->sd_flag & STPLEX) &&
2514 2515 (stp->sd_wput_opt & SW_SIGPIPE) && sigpipeok) {
2515 2516 tsignal(curthread, SIGPIPE);
2516 2517 error = EPIPE;
2517 2518 }
2518 2519 }
2519 2520
2520 2521 return (error);
2521 2522 }
2522 2523
2523 2524 /*
2524 2525 * Copyin and send data down a stream.
2525 2526 * The caller will allocate and copyin any control part that precedes the
2526 2527 * message and pass that in as mctl.
2527 2528 *
2528 2529 * Caller should *not* hold sd_lock.
2529 2530 * When EWOULDBLOCK is returned the caller has to redo the canputnext
2530 2531 * under sd_lock in order to avoid missing a backenabling wakeup.
2531 2532 *
2532 2533 * Use iosize = -1 to not send any M_DATA. iosize = 0 sends zero-length M_DATA.
2533 2534 *
2534 2535 * Set MSG_IGNFLOW in flags to ignore flow control for hipri messages.
2535 2536 * For sync streams we can only ignore flow control by reverting to using
2536 2537 * putnext.
2537 2538 *
2538 2539 * If sd_maxblk is less than *iosize this routine might return without
2539 2540 * transferring all of *iosize. In all cases, on return *iosize will contain
2540 2541 * the amount of data that was transferred.
2541 2542 */
2542 2543 static int
2543 2544 strput(struct stdata *stp, mblk_t *mctl, struct uio *uiop, ssize_t *iosize,
2544 2545 int b_flag, int pri, int flags)
2545 2546 {
2546 2547 struiod_t uiod;
2547 2548 mblk_t *mp;
2548 2549 queue_t *wqp = stp->sd_wrq;
2549 2550 int error = 0;
2550 2551 ssize_t count = *iosize;
2551 2552
2552 2553 ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
2553 2554
2554 2555 if (uiop != NULL && count >= 0)
2555 2556 flags |= stp->sd_struiowrq ? STRUIO_POSTPONE : 0;
2556 2557
2557 2558 if (!(flags & STRUIO_POSTPONE)) {
2558 2559 /*
2559 2560 * Use regular canputnext, strmakedata, putnext sequence.
2560 2561 */
2561 2562 if (pri == 0) {
2562 2563 if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
2563 2564 freemsg(mctl);
2564 2565 return (EWOULDBLOCK);
2565 2566 }
2566 2567 } else {
2567 2568 if (!(flags & MSG_IGNFLOW) && !bcanputnext(wqp, pri)) {
2568 2569 freemsg(mctl);
2569 2570 return (EWOULDBLOCK);
2570 2571 }
2571 2572 }
2572 2573
2573 2574 if ((error = strmakedata(iosize, uiop, stp, flags,
2574 2575 &mp)) != 0) {
2575 2576 freemsg(mctl);
2576 2577 /*
2577 2578 * need to change return code to ENOMEM
2578 2579 * so that this is not confused with
2579 2580 * flow control, EAGAIN.
2580 2581 */
2581 2582
2582 2583 if (error == EAGAIN)
2583 2584 return (ENOMEM);
2584 2585 else
2585 2586 return (error);
2586 2587 }
2587 2588 if (mctl != NULL) {
2588 2589 if (mctl->b_cont == NULL)
2589 2590 mctl->b_cont = mp;
2590 2591 else if (mp != NULL)
2591 2592 linkb(mctl, mp);
2592 2593 mp = mctl;
2593 2594 } else if (mp == NULL)
2594 2595 return (0);
2595 2596
2596 2597 mp->b_flag |= b_flag;
2597 2598 mp->b_band = (uchar_t)pri;
2598 2599
2599 2600 if (flags & MSG_IGNFLOW) {
2600 2601 /*
2601 2602 * XXX Hack: Don't get stuck running service
2602 2603 * procedures. This is needed for sockfs when
2603 2604 * sending the unbind message out of the rput
2604 2605 * procedure - we don't want a put procedure
2605 2606 * to run service procedures.
2606 2607 */
2607 2608 putnext(wqp, mp);
2608 2609 } else {
2609 2610 stream_willservice(stp);
2610 2611 putnext(wqp, mp);
2611 2612 stream_runservice(stp);
2612 2613 }
2613 2614 return (0);
2614 2615 }
2615 2616 /*
2616 2617 * Stream supports rwnext() for the write side.
2617 2618 */
2618 2619 if ((error = strmakedata(iosize, uiop, stp, flags, &mp)) != 0) {
2619 2620 freemsg(mctl);
2620 2621 /*
2621 2622 * map EAGAIN to ENOMEM since EAGAIN means "flow controlled".
2622 2623 */
2623 2624 return (error == EAGAIN ? ENOMEM : error);
2624 2625 }
2625 2626 if (mctl != NULL) {
2626 2627 if (mctl->b_cont == NULL)
2627 2628 mctl->b_cont = mp;
2628 2629 else if (mp != NULL)
2629 2630 linkb(mctl, mp);
2630 2631 mp = mctl;
2631 2632 } else if (mp == NULL) {
2632 2633 return (0);
2633 2634 }
2634 2635
2635 2636 mp->b_flag |= b_flag;
2636 2637 mp->b_band = (uchar_t)pri;
2637 2638
2638 2639 (void) uiodup(uiop, &uiod.d_uio, uiod.d_iov,
2639 2640 sizeof (uiod.d_iov) / sizeof (*uiod.d_iov));
2640 2641 uiod.d_uio.uio_offset = 0;
2641 2642 uiod.d_mp = mp;
2642 2643 error = rwnext(wqp, &uiod);
2643 2644 if (! uiod.d_mp) {
2644 2645 uioskip(uiop, *iosize);
2645 2646 return (error);
2646 2647 }
2647 2648 ASSERT(mp == uiod.d_mp);
2648 2649 if (error == EINVAL) {
2649 2650 /*
2650 2651 * The stream plumbing must have changed while
2651 2652 * we were away, so just turn off rwnext()s.
2652 2653 */
2653 2654 error = 0;
2654 2655 } else if (error == EBUSY || error == EWOULDBLOCK) {
2655 2656 /*
2656 2657 * Couldn't enter a perimeter or took a page fault,
2657 2658 * so fall-back to putnext().
2658 2659 */
2659 2660 error = 0;
2660 2661 } else {
2661 2662 freemsg(mp);
2662 2663 return (error);
2663 2664 }
2664 2665 /* Have to check canput before consuming data from the uio */
2665 2666 if (pri == 0) {
2666 2667 if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
2667 2668 freemsg(mp);
2668 2669 return (EWOULDBLOCK);
2669 2670 }
2670 2671 } else {
2671 2672 if (!bcanputnext(wqp, pri) && !(flags & MSG_IGNFLOW)) {
2672 2673 freemsg(mp);
2673 2674 return (EWOULDBLOCK);
2674 2675 }
2675 2676 }
2676 2677 ASSERT(mp == uiod.d_mp);
2677 2678 /* Copyin data from the uio */
2678 2679 if ((error = struioget(wqp, mp, &uiod, 0)) != 0) {
2679 2680 freemsg(mp);
2680 2681 return (error);
2681 2682 }
2682 2683 uioskip(uiop, *iosize);
2683 2684 if (flags & MSG_IGNFLOW) {
2684 2685 /*
2685 2686 * XXX Hack: Don't get stuck running service procedures.
2686 2687 * This is needed for sockfs when sending the unbind message
2687 2688 * out of the rput procedure - we don't want a put procedure
2688 2689 * to run service procedures.
2689 2690 */
2690 2691 putnext(wqp, mp);
2691 2692 } else {
2692 2693 stream_willservice(stp);
2693 2694 putnext(wqp, mp);
2694 2695 stream_runservice(stp);
2695 2696 }
2696 2697 return (0);
2697 2698 }
2698 2699
2699 2700 /*
2700 2701 * Write attempts to break the write request into messages conforming
2701 2702 * with the minimum and maximum packet sizes set downstream.
2702 2703 *
2703 2704 * Write will not block if downstream queue is full and
2704 2705 * O_NDELAY is set, otherwise it will block waiting for the queue to get room.
2705 2706 *
2706 2707 * A write of zero bytes gets packaged into a zero length message and sent
2707 2708 * downstream like any other message.
2708 2709 *
2709 2710 * If buffers of the requested sizes are not available, the write will
2710 2711 * sleep until the buffers become available.
2711 2712 *
2712 2713 * Write (if specified) will supply a write offset in a message if it
2713 2714 * makes sense. This can be specified by downstream modules as part of
2714 2715 * a M_SETOPTS message. Write will not supply the write offset if it
2715 2716 * cannot supply any data in a buffer. In other words, write will never
2716 2717 * send down an empty packet due to a write offset.
2717 2718 */
2718 2719 /* ARGSUSED2 */
2719 2720 int
2720 2721 strwrite(struct vnode *vp, struct uio *uiop, cred_t *crp)
2721 2722 {
2722 2723 return (strwrite_common(vp, uiop, crp, 0));
2723 2724 }
2724 2725
2725 2726 /* ARGSUSED2 */
2726 2727 int
2727 2728 strwrite_common(struct vnode *vp, struct uio *uiop, cred_t *crp, int wflag)
2728 2729 {
2729 2730 struct stdata *stp;
2730 2731 struct queue *wqp;
2731 2732 ssize_t rmin, rmax;
2732 2733 ssize_t iosize;
2733 2734 int waitflag;
2734 2735 int tempmode;
2735 2736 int error = 0;
2736 2737 int b_flag;
2737 2738
2738 2739 ASSERT(vp->v_stream);
2739 2740 stp = vp->v_stream;
2740 2741
2741 2742 mutex_enter(&stp->sd_lock);
2742 2743
2743 2744 if ((error = i_straccess(stp, JCWRITE)) != 0) {
2744 2745 mutex_exit(&stp->sd_lock);
2745 2746 return (error);
2746 2747 }
2747 2748
2748 2749 if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
2749 2750 error = strwriteable(stp, B_TRUE, B_TRUE);
2750 2751 if (error != 0) {
2751 2752 mutex_exit(&stp->sd_lock);
2752 2753 return (error);
2753 2754 }
2754 2755 }
2755 2756
2756 2757 mutex_exit(&stp->sd_lock);
2757 2758
2758 2759 wqp = stp->sd_wrq;
2759 2760
2760 2761 /* get these values from them cached in the stream head */
2761 2762 rmin = stp->sd_qn_minpsz;
2762 2763 rmax = stp->sd_qn_maxpsz;
2763 2764
2764 2765 /*
2765 2766 * Check the min/max packet size constraints. If min packet size
2766 2767 * is non-zero, the write cannot be split into multiple messages
2767 2768 * and still guarantee the size constraints.
2768 2769 */
2769 2770 TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_IN, "strwrite in:q %p", wqp);
2770 2771
2771 2772 ASSERT((rmax >= 0) || (rmax == INFPSZ));
2772 2773 if (rmax == 0) {
2773 2774 return (0);
2774 2775 }
2775 2776 if (rmin > 0) {
2776 2777 if (uiop->uio_resid < rmin) {
2777 2778 TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
2778 2779 "strwrite out:q %p out %d error %d",
2779 2780 wqp, 0, ERANGE);
2780 2781 return (ERANGE);
2781 2782 }
2782 2783 if ((rmax != INFPSZ) && (uiop->uio_resid > rmax)) {
2783 2784 TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
2784 2785 "strwrite out:q %p out %d error %d",
2785 2786 wqp, 1, ERANGE);
2786 2787 return (ERANGE);
2787 2788 }
2788 2789 }
2789 2790
2790 2791 /*
2791 2792 * Do until count satisfied or error.
2792 2793 */
2793 2794 waitflag = WRITEWAIT | wflag;
2794 2795 if (stp->sd_flag & OLDNDELAY)
2795 2796 tempmode = uiop->uio_fmode & ~FNDELAY;
2796 2797 else
2797 2798 tempmode = uiop->uio_fmode;
2798 2799
2799 2800 if (rmax == INFPSZ)
2800 2801 rmax = uiop->uio_resid;
2801 2802
2802 2803 /*
2803 2804 * Note that tempmode does not get used in strput/strmakedata
2804 2805 * but only in strwaitq. The other routines use uio_fmode
2805 2806 * unmodified.
2806 2807 */
2807 2808
2808 2809 /* LINTED: constant in conditional context */
2809 2810 while (1) { /* breaks when uio_resid reaches zero */
2810 2811 /*
2811 2812 * Determine the size of the next message to be
2812 2813 * packaged. May have to break write into several
2813 2814 * messages based on max packet size.
2814 2815 */
2815 2816 iosize = MIN(uiop->uio_resid, rmax);
2816 2817
2817 2818 /*
2818 2819 * Put block downstream when flow control allows it.
2819 2820 */
2820 2821 if ((stp->sd_flag & STRDELIM) && (uiop->uio_resid == iosize))
2821 2822 b_flag = MSGDELIM;
2822 2823 else
2823 2824 b_flag = 0;
2824 2825
2825 2826 for (;;) {
2826 2827 int done = 0;
2827 2828
2828 2829 error = strput(stp, NULL, uiop, &iosize, b_flag, 0, 0);
2829 2830 if (error == 0)
2830 2831 break;
2831 2832 if (error != EWOULDBLOCK)
2832 2833 goto out;
2833 2834
2834 2835 mutex_enter(&stp->sd_lock);
2835 2836 /*
2836 2837 * Check for a missed wakeup.
2837 2838 * Needed since strput did not hold sd_lock across
2838 2839 * the canputnext.
2839 2840 */
2840 2841 if (canputnext(wqp)) {
2841 2842 /* Try again */
2842 2843 mutex_exit(&stp->sd_lock);
2843 2844 continue;
2844 2845 }
2845 2846 TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAIT,
2846 2847 "strwrite wait:q %p wait", wqp);
2847 2848 if ((error = strwaitq(stp, waitflag, (ssize_t)0,
2848 2849 tempmode, -1, &done)) != 0 || done) {
2849 2850 mutex_exit(&stp->sd_lock);
2850 2851 if ((vp->v_type == VFIFO) &&
2851 2852 (uiop->uio_fmode & FNDELAY) &&
2852 2853 (error == EAGAIN))
2853 2854 error = 0;
2854 2855 goto out;
2855 2856 }
2856 2857 TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAKE,
2857 2858 "strwrite wake:q %p awakes", wqp);
2858 2859 if ((error = i_straccess(stp, JCWRITE)) != 0) {
2859 2860 mutex_exit(&stp->sd_lock);
2860 2861 goto out;
2861 2862 }
2862 2863 mutex_exit(&stp->sd_lock);
2863 2864 }
2864 2865 waitflag |= NOINTR;
2865 2866 TRACE_2(TR_FAC_STREAMS_FR, TR_STRWRITE_RESID,
2866 2867 "strwrite resid:q %p uiop %p", wqp, uiop);
2867 2868 if (uiop->uio_resid) {
2868 2869 /* Recheck for errors - needed for sockets */
2869 2870 if ((stp->sd_wput_opt & SW_RECHECK_ERR) &&
2870 2871 (stp->sd_flag & (STWRERR|STRHUP|STPLEX))) {
2871 2872 mutex_enter(&stp->sd_lock);
2872 2873 error = strwriteable(stp, B_FALSE, B_TRUE);
2873 2874 mutex_exit(&stp->sd_lock);
2874 2875 if (error != 0)
2875 2876 return (error);
2876 2877 }
2877 2878 continue;
2878 2879 }
2879 2880 break;
2880 2881 }
2881 2882 out:
2882 2883 /*
2883 2884 * For historical reasons, applications expect EAGAIN when a data
2884 2885 * mblk_t cannot be allocated, so change ENOMEM back to EAGAIN.
2885 2886 */
2886 2887 if (error == ENOMEM)
2887 2888 error = EAGAIN;
2888 2889 TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
2889 2890 "strwrite out:q %p out %d error %d", wqp, 2, error);
2890 2891 return (error);
2891 2892 }
2892 2893
2893 2894 /*
2894 2895 * Stream head write service routine.
2895 2896 * Its job is to wake up any sleeping writers when a queue
2896 2897 * downstream needs data (part of the flow control in putq and getq).
2897 2898 * It also must wake anyone sleeping on a poll().
2898 2899 * For stream head right below mux module, it must also invoke put procedure
2899 2900 * of next downstream module.
2900 2901 */
2901 2902 int
2902 2903 strwsrv(queue_t *q)
2903 2904 {
2904 2905 struct stdata *stp;
2905 2906 queue_t *tq;
2906 2907 qband_t *qbp;
2907 2908 int i;
2908 2909 qband_t *myqbp;
2909 2910 int isevent;
2910 2911 unsigned char qbf[NBAND]; /* band flushing backenable flags */
2911 2912
2912 2913 TRACE_1(TR_FAC_STREAMS_FR,
2913 2914 TR_STRWSRV, "strwsrv:q %p", q);
2914 2915 stp = (struct stdata *)q->q_ptr;
2915 2916 ASSERT(qclaimed(q));
2916 2917 mutex_enter(&stp->sd_lock);
2917 2918 ASSERT(!(stp->sd_flag & STPLEX));
2918 2919
2919 2920 if (stp->sd_flag & WSLEEP) {
2920 2921 stp->sd_flag &= ~WSLEEP;
2921 2922 cv_broadcast(&q->q_wait);
2922 2923 }
2923 2924 mutex_exit(&stp->sd_lock);
2924 2925
2925 2926 /* The other end of a stream pipe went away. */
2926 2927 if ((tq = q->q_next) == NULL) {
2927 2928 return (0);
2928 2929 }
2929 2930
2930 2931 /* Find the next module forward that has a service procedure */
2931 2932 claimstr(q);
2932 2933 tq = q->q_nfsrv;
2933 2934 ASSERT(tq != NULL);
2934 2935
2935 2936 if ((q->q_flag & QBACK)) {
2936 2937 if ((tq->q_flag & QFULL)) {
2937 2938 mutex_enter(QLOCK(tq));
2938 2939 if (!(tq->q_flag & QFULL)) {
2939 2940 mutex_exit(QLOCK(tq));
2940 2941 goto wakeup;
2941 2942 }
2942 2943 /*
2943 2944 * The queue must have become full again. Set QWANTW
2944 2945 * again so strwsrv will be back enabled when
2945 2946 * the queue becomes non-full next time.
2946 2947 */
2947 2948 tq->q_flag |= QWANTW;
2948 2949 mutex_exit(QLOCK(tq));
2949 2950 } else {
2950 2951 wakeup:
2951 2952 pollwakeup(&stp->sd_pollist, POLLWRNORM);
2952 2953 mutex_enter(&stp->sd_lock);
2953 2954 if (stp->sd_sigflags & S_WRNORM)
2954 2955 strsendsig(stp->sd_siglist, S_WRNORM, 0, 0);
2955 2956 mutex_exit(&stp->sd_lock);
2956 2957 }
2957 2958 }
2958 2959
2959 2960 isevent = 0;
2960 2961 i = 1;
2961 2962 bzero((caddr_t)qbf, NBAND);
2962 2963 mutex_enter(QLOCK(tq));
2963 2964 if ((myqbp = q->q_bandp) != NULL)
2964 2965 for (qbp = tq->q_bandp; qbp && myqbp; qbp = qbp->qb_next) {
2965 2966 ASSERT(myqbp);
2966 2967 if ((myqbp->qb_flag & QB_BACK)) {
2967 2968 if (qbp->qb_flag & QB_FULL) {
2968 2969 /*
2969 2970 * The band must have become full again.
2970 2971 * Set QB_WANTW again so strwsrv will
2971 2972 * be back enabled when the band becomes
2972 2973 * non-full next time.
2973 2974 */
2974 2975 qbp->qb_flag |= QB_WANTW;
2975 2976 } else {
2976 2977 isevent = 1;
2977 2978 qbf[i] = 1;
2978 2979 }
2979 2980 }
2980 2981 myqbp = myqbp->qb_next;
2981 2982 i++;
2982 2983 }
2983 2984 mutex_exit(QLOCK(tq));
2984 2985
2985 2986 if (isevent) {
2986 2987 for (i = tq->q_nband; i; i--) {
2987 2988 if (qbf[i]) {
2988 2989 pollwakeup(&stp->sd_pollist, POLLWRBAND);
2989 2990 mutex_enter(&stp->sd_lock);
2990 2991 if (stp->sd_sigflags & S_WRBAND)
2991 2992 strsendsig(stp->sd_siglist, S_WRBAND,
2992 2993 (uchar_t)i, 0);
2993 2994 mutex_exit(&stp->sd_lock);
2994 2995 }
2995 2996 }
2996 2997 }
2997 2998
2998 2999 releasestr(q);
2999 3000 return (0);
3000 3001 }
3001 3002
3002 3003 /*
3003 3004 * Special case of strcopyin/strcopyout for copying
3004 3005 * struct strioctl that can deal with both data
3005 3006 * models.
3006 3007 */
3007 3008
3008 3009 #ifdef _LP64
3009 3010
3010 3011 static int
3011 3012 strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
3012 3013 {
3013 3014 struct strioctl32 strioc32;
3014 3015 struct strioctl *striocp;
3015 3016
3016 3017 if (copyflag & U_TO_K) {
3017 3018 ASSERT((copyflag & K_TO_K) == 0);
3018 3019
3019 3020 if ((flag & FMODELS) == DATAMODEL_ILP32) {
3020 3021 if (copyin(from, &strioc32, sizeof (strioc32)))
3021 3022 return (EFAULT);
3022 3023
3023 3024 striocp = (struct strioctl *)to;
3024 3025 striocp->ic_cmd = strioc32.ic_cmd;
3025 3026 striocp->ic_timout = strioc32.ic_timout;
3026 3027 striocp->ic_len = strioc32.ic_len;
3027 3028 striocp->ic_dp = (char *)(uintptr_t)strioc32.ic_dp;
3028 3029
3029 3030 } else { /* NATIVE data model */
3030 3031 if (copyin(from, to, sizeof (struct strioctl))) {
3031 3032 return (EFAULT);
3032 3033 } else {
3033 3034 return (0);
3034 3035 }
3035 3036 }
3036 3037 } else {
3037 3038 ASSERT(copyflag & K_TO_K);
3038 3039 bcopy(from, to, sizeof (struct strioctl));
3039 3040 }
3040 3041 return (0);
3041 3042 }
3042 3043
3043 3044 static int
3044 3045 strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
3045 3046 {
3046 3047 struct strioctl32 strioc32;
3047 3048 struct strioctl *striocp;
3048 3049
3049 3050 if (copyflag & U_TO_K) {
3050 3051 ASSERT((copyflag & K_TO_K) == 0);
3051 3052
3052 3053 if ((flag & FMODELS) == DATAMODEL_ILP32) {
3053 3054 striocp = (struct strioctl *)from;
3054 3055 strioc32.ic_cmd = striocp->ic_cmd;
3055 3056 strioc32.ic_timout = striocp->ic_timout;
3056 3057 strioc32.ic_len = striocp->ic_len;
3057 3058 strioc32.ic_dp = (caddr32_t)(uintptr_t)striocp->ic_dp;
3058 3059 ASSERT((char *)(uintptr_t)strioc32.ic_dp ==
3059 3060 striocp->ic_dp);
3060 3061
3061 3062 if (copyout(&strioc32, to, sizeof (strioc32)))
3062 3063 return (EFAULT);
3063 3064
3064 3065 } else { /* NATIVE data model */
3065 3066 if (copyout(from, to, sizeof (struct strioctl))) {
3066 3067 return (EFAULT);
3067 3068 } else {
3068 3069 return (0);
3069 3070 }
3070 3071 }
3071 3072 } else {
3072 3073 ASSERT(copyflag & K_TO_K);
3073 3074 bcopy(from, to, sizeof (struct strioctl));
3074 3075 }
3075 3076 return (0);
3076 3077 }
3077 3078
3078 3079 #else /* ! _LP64 */
3079 3080
3080 3081 /* ARGSUSED2 */
3081 3082 static int
3082 3083 strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
3083 3084 {
3084 3085 return (strcopyin(from, to, sizeof (struct strioctl), copyflag));
3085 3086 }
3086 3087
3087 3088 /* ARGSUSED2 */
3088 3089 static int
3089 3090 strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
3090 3091 {
3091 3092 return (strcopyout(from, to, sizeof (struct strioctl), copyflag));
3092 3093 }
3093 3094
3094 3095 #endif /* _LP64 */
3095 3096
3096 3097 /*
3097 3098 * Determine type of job control semantics expected by user. The
3098 3099 * possibilities are:
3099 3100 * JCREAD - Behaves like read() on fd; send SIGTTIN
3100 3101 * JCWRITE - Behaves like write() on fd; send SIGTTOU if TOSTOP set
3101 3102 * JCSETP - Sets a value in the stream; send SIGTTOU, ignore TOSTOP
3102 3103 * JCGETP - Gets a value in the stream; no signals.
3103 3104 * See straccess in strsubr.c for usage of these values.
3104 3105 *
3105 3106 * This routine also returns -1 for I_STR as a special case; the
3106 3107 * caller must call again with the real ioctl number for
3107 3108 * classification.
3108 3109 */
3109 3110 static int
3110 3111 job_control_type(int cmd)
3111 3112 {
3112 3113 switch (cmd) {
3113 3114 case I_STR:
3114 3115 return (-1);
3115 3116
3116 3117 case I_RECVFD:
3117 3118 case I_E_RECVFD:
3118 3119 return (JCREAD);
3119 3120
3120 3121 case I_FDINSERT:
3121 3122 case I_SENDFD:
3122 3123 return (JCWRITE);
3123 3124
3124 3125 case TCSETA:
3125 3126 case TCSETAW:
3126 3127 case TCSETAF:
3127 3128 case TCSBRK:
3128 3129 case TCXONC:
3129 3130 case TCFLSH:
3130 3131 case TCDSET: /* Obsolete */
3131 3132 case TIOCSWINSZ:
3132 3133 case TCSETS:
3133 3134 case TCSETSW:
3134 3135 case TCSETSF:
3135 3136 case TIOCSETD:
3136 3137 case TIOCHPCL:
3137 3138 case TIOCSETP:
3138 3139 case TIOCSETN:
3139 3140 case TIOCEXCL:
3140 3141 case TIOCNXCL:
3141 3142 case TIOCFLUSH:
3142 3143 case TIOCSETC:
3143 3144 case TIOCLBIS:
3144 3145 case TIOCLBIC:
3145 3146 case TIOCLSET:
3146 3147 case TIOCSBRK:
3147 3148 case TIOCCBRK:
3148 3149 case TIOCSDTR:
3149 3150 case TIOCCDTR:
3150 3151 case TIOCSLTC:
3151 3152 case TIOCSTOP:
3152 3153 case TIOCSTART:
3153 3154 case TIOCSTI:
3154 3155 case TIOCSPGRP:
3155 3156 case TIOCMSET:
3156 3157 case TIOCMBIS:
3157 3158 case TIOCMBIC:
3158 3159 case TIOCREMOTE:
3159 3160 case TIOCSIGNAL:
3160 3161 case LDSETT:
3161 3162 case LDSMAP: /* Obsolete */
3162 3163 case DIOCSETP:
3163 3164 case I_FLUSH:
3164 3165 case I_SRDOPT:
3165 3166 case I_SETSIG:
3166 3167 case I_SWROPT:
3167 3168 case I_FLUSHBAND:
3168 3169 case I_SETCLTIME:
3169 3170 case I_SERROPT:
3170 3171 case I_ESETSIG:
3171 3172 case FIONBIO:
3172 3173 case FIOASYNC:
3173 3174 case FIOSETOWN:
3174 3175 case JBOOT: /* Obsolete */
3175 3176 case JTERM: /* Obsolete */
3176 3177 case JTIMOM: /* Obsolete */
3177 3178 case JZOMBOOT: /* Obsolete */
3178 3179 case JAGENT: /* Obsolete */
3179 3180 case JTRUN: /* Obsolete */
3180 3181 case JXTPROTO: /* Obsolete */
3181 3182 return (JCSETP);
3182 3183 }
3183 3184
3184 3185 return (JCGETP);
3185 3186 }
3186 3187
3187 3188 /*
3188 3189 * ioctl for streams
3189 3190 */
3190 3191 int
3191 3192 strioctl(struct vnode *vp, int cmd, intptr_t arg, int flag, int copyflag,
3192 3193 cred_t *crp, int *rvalp)
3193 3194 {
3194 3195 struct stdata *stp;
3195 3196 struct strcmd *scp;
3196 3197 struct strioctl strioc;
3197 3198 struct uio uio;
3198 3199 struct iovec iov;
3199 3200 int access;
3200 3201 mblk_t *mp;
3201 3202 int error = 0;
3202 3203 int done = 0;
3203 3204 ssize_t rmin, rmax;
3204 3205 queue_t *wrq;
3205 3206 queue_t *rdq;
3206 3207 boolean_t kioctl = B_FALSE;
3207 3208 uint32_t auditing = AU_AUDITING();
3208 3209
3209 3210 if (flag & FKIOCTL) {
3210 3211 copyflag = K_TO_K;
3211 3212 kioctl = B_TRUE;
3212 3213 }
3213 3214 ASSERT(vp->v_stream);
3214 3215 ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
3215 3216 stp = vp->v_stream;
3216 3217
3217 3218 TRACE_3(TR_FAC_STREAMS_FR, TR_IOCTL_ENTER,
3218 3219 "strioctl:stp %p cmd %X arg %lX", stp, cmd, arg);
3219 3220
3220 3221 /*
3221 3222 * If the copy is kernel to kernel, make sure that the FNATIVE
3222 3223 * flag is set. After this it would be a serious error to have
3223 3224 * no model flag.
3224 3225 */
3225 3226 if (copyflag == K_TO_K)
3226 3227 flag = (flag & ~FMODELS) | FNATIVE;
3227 3228
3228 3229 ASSERT((flag & FMODELS) != 0);
3229 3230
3230 3231 wrq = stp->sd_wrq;
3231 3232 rdq = _RD(wrq);
3232 3233
3233 3234 access = job_control_type(cmd);
3234 3235
3235 3236 /* We should never see these here, should be handled by iwscn */
3236 3237 if (cmd == SRIOCSREDIR || cmd == SRIOCISREDIR)
3237 3238 return (EINVAL);
3238 3239
3239 3240 mutex_enter(&stp->sd_lock);
3240 3241 if ((access != -1) && ((error = i_straccess(stp, access)) != 0)) {
3241 3242 mutex_exit(&stp->sd_lock);
3242 3243 return (error);
3243 3244 }
3244 3245 mutex_exit(&stp->sd_lock);
3245 3246
3246 3247 /*
3247 3248 * Check for sgttyb-related ioctls first, and complain as
3248 3249 * necessary.
3249 3250 */
3250 3251 switch (cmd) {
3251 3252 case TIOCGETP:
3252 3253 case TIOCSETP:
3253 3254 case TIOCSETN:
3254 3255 if (sgttyb_handling >= 2 && !sgttyb_complaint) {
3255 3256 sgttyb_complaint = B_TRUE;
3256 3257 cmn_err(CE_NOTE,
3257 3258 "application used obsolete TIOC[GS]ET");
3258 3259 }
3259 3260 if (sgttyb_handling >= 3) {
3260 3261 tsignal(curthread, SIGSYS);
3261 3262 return (EIO);
3262 3263 }
3263 3264 break;
3264 3265 }
3265 3266
3266 3267 mutex_enter(&stp->sd_lock);
3267 3268
3268 3269 switch (cmd) {
3269 3270 case I_RECVFD:
3270 3271 case I_E_RECVFD:
3271 3272 case I_PEEK:
3272 3273 case I_NREAD:
3273 3274 case FIONREAD:
3274 3275 case FIORDCHK:
3275 3276 case I_ATMARK:
3276 3277 case FIONBIO:
3277 3278 case FIOASYNC:
3278 3279 if (stp->sd_flag & (STRDERR|STPLEX)) {
3279 3280 error = strgeterr(stp, STRDERR|STPLEX, 0);
3280 3281 if (error != 0) {
3281 3282 mutex_exit(&stp->sd_lock);
3282 3283 return (error);
3283 3284 }
3284 3285 }
3285 3286 break;
3286 3287
3287 3288 default:
3288 3289 if (stp->sd_flag & (STRDERR|STWRERR|STPLEX)) {
3289 3290 error = strgeterr(stp, STRDERR|STWRERR|STPLEX, 0);
3290 3291 if (error != 0) {
3291 3292 mutex_exit(&stp->sd_lock);
3292 3293 return (error);
3293 3294 }
3294 3295 }
3295 3296 }
3296 3297
3297 3298 mutex_exit(&stp->sd_lock);
3298 3299
3299 3300 switch (cmd) {
3300 3301 default:
3301 3302 /*
3302 3303 * The stream head has hardcoded knowledge of a
3303 3304 * miscellaneous collection of terminal-, keyboard- and
3304 3305 * mouse-related ioctls, enumerated below. This hardcoded
3305 3306 * knowledge allows the stream head to automatically
3306 3307 * convert transparent ioctl requests made by userland
3307 3308 * programs into I_STR ioctls which many old STREAMS
3308 3309 * modules and drivers require.
3309 3310 *
3310 3311 * No new ioctls should ever be added to this list.
3311 3312 * Instead, the STREAMS module or driver should be written
3312 3313 * to either handle transparent ioctls or require any
3313 3314 * userland programs to use I_STR ioctls (by returning
3314 3315 * EINVAL to any transparent ioctl requests).
3315 3316 *
3316 3317 * More importantly, removing ioctls from this list should
3317 3318 * be done with the utmost care, since our STREAMS modules
3318 3319 * and drivers *count* on the stream head performing this
3319 3320 * conversion, and thus may panic while processing
3320 3321 * transparent ioctl request for one of these ioctls (keep
3321 3322 * in mind that third party modules and drivers may have
3322 3323 * similar problems).
3323 3324 */
3324 3325 if (((cmd & IOCTYPE) == LDIOC) ||
3325 3326 ((cmd & IOCTYPE) == tIOC) ||
3326 3327 ((cmd & IOCTYPE) == TIOC) ||
3327 3328 ((cmd & IOCTYPE) == KIOC) ||
3328 3329 ((cmd & IOCTYPE) == MSIOC) ||
3329 3330 ((cmd & IOCTYPE) == VUIOC)) {
3330 3331 /*
3331 3332 * The ioctl is a tty ioctl - set up strioc buffer
3332 3333 * and call strdoioctl() to do the work.
3333 3334 */
3334 3335 if (stp->sd_flag & STRHUP)
3335 3336 return (ENXIO);
3336 3337 strioc.ic_cmd = cmd;
3337 3338 strioc.ic_timout = INFTIM;
3338 3339
3339 3340 switch (cmd) {
3340 3341
3341 3342 case TCXONC:
3342 3343 case TCSBRK:
3343 3344 case TCFLSH:
3344 3345 case TCDSET:
3345 3346 {
3346 3347 int native_arg = (int)arg;
3347 3348 strioc.ic_len = sizeof (int);
3348 3349 strioc.ic_dp = (char *)&native_arg;
3349 3350 return (strdoioctl(stp, &strioc, flag,
3350 3351 K_TO_K, crp, rvalp));
3351 3352 }
3352 3353
3353 3354 case TCSETA:
3354 3355 case TCSETAW:
3355 3356 case TCSETAF:
3356 3357 strioc.ic_len = sizeof (struct termio);
3357 3358 strioc.ic_dp = (char *)arg;
3358 3359 return (strdoioctl(stp, &strioc, flag,
3359 3360 copyflag, crp, rvalp));
3360 3361
3361 3362 case TCSETS:
3362 3363 case TCSETSW:
3363 3364 case TCSETSF:
3364 3365 strioc.ic_len = sizeof (struct termios);
3365 3366 strioc.ic_dp = (char *)arg;
3366 3367 return (strdoioctl(stp, &strioc, flag,
3367 3368 copyflag, crp, rvalp));
3368 3369
3369 3370 case LDSETT:
3370 3371 strioc.ic_len = sizeof (struct termcb);
3371 3372 strioc.ic_dp = (char *)arg;
3372 3373 return (strdoioctl(stp, &strioc, flag,
3373 3374 copyflag, crp, rvalp));
3374 3375
3375 3376 case TIOCSETP:
3376 3377 strioc.ic_len = sizeof (struct sgttyb);
3377 3378 strioc.ic_dp = (char *)arg;
3378 3379 return (strdoioctl(stp, &strioc, flag,
3379 3380 copyflag, crp, rvalp));
3380 3381
3381 3382 case TIOCSTI:
3382 3383 if ((flag & FREAD) == 0 &&
3383 3384 secpolicy_sti(crp) != 0) {
3384 3385 return (EPERM);
3385 3386 }
3386 3387 mutex_enter(&stp->sd_lock);
3387 3388 mutex_enter(&curproc->p_splock);
3388 3389 if (stp->sd_sidp != curproc->p_sessp->s_sidp &&
3389 3390 secpolicy_sti(crp) != 0) {
3390 3391 mutex_exit(&curproc->p_splock);
3391 3392 mutex_exit(&stp->sd_lock);
3392 3393 return (EACCES);
3393 3394 }
3394 3395 mutex_exit(&curproc->p_splock);
3395 3396 mutex_exit(&stp->sd_lock);
3396 3397
3397 3398 strioc.ic_len = sizeof (char);
3398 3399 strioc.ic_dp = (char *)arg;
3399 3400 return (strdoioctl(stp, &strioc, flag,
3400 3401 copyflag, crp, rvalp));
3401 3402
3402 3403 case TIOCSWINSZ:
3403 3404 strioc.ic_len = sizeof (struct winsize);
3404 3405 strioc.ic_dp = (char *)arg;
3405 3406 return (strdoioctl(stp, &strioc, flag,
3406 3407 copyflag, crp, rvalp));
3407 3408
3408 3409 case TIOCSSIZE:
3409 3410 strioc.ic_len = sizeof (struct ttysize);
3410 3411 strioc.ic_dp = (char *)arg;
3411 3412 return (strdoioctl(stp, &strioc, flag,
3412 3413 copyflag, crp, rvalp));
3413 3414
3414 3415 case TIOCSSOFTCAR:
3415 3416 case KIOCTRANS:
3416 3417 case KIOCTRANSABLE:
3417 3418 case KIOCCMD:
3418 3419 case KIOCSDIRECT:
3419 3420 case KIOCSCOMPAT:
3420 3421 case KIOCSKABORTEN:
3421 3422 case KIOCSRPTDELAY:
3422 3423 case KIOCSRPTRATE:
3423 3424 case VUIDSFORMAT:
3424 3425 case TIOCSPPS:
3425 3426 strioc.ic_len = sizeof (int);
3426 3427 strioc.ic_dp = (char *)arg;
3427 3428 return (strdoioctl(stp, &strioc, flag,
3428 3429 copyflag, crp, rvalp));
3429 3430
3430 3431 case KIOCSETKEY:
3431 3432 case KIOCGETKEY:
3432 3433 strioc.ic_len = sizeof (struct kiockey);
3433 3434 strioc.ic_dp = (char *)arg;
3434 3435 return (strdoioctl(stp, &strioc, flag,
3435 3436 copyflag, crp, rvalp));
3436 3437
3437 3438 case KIOCSKEY:
3438 3439 case KIOCGKEY:
3439 3440 strioc.ic_len = sizeof (struct kiockeymap);
3440 3441 strioc.ic_dp = (char *)arg;
3441 3442 return (strdoioctl(stp, &strioc, flag,
3442 3443 copyflag, crp, rvalp));
3443 3444
3444 3445 case KIOCSLED:
3445 3446 /* arg is a pointer to char */
3446 3447 strioc.ic_len = sizeof (char);
3447 3448 strioc.ic_dp = (char *)arg;
3448 3449 return (strdoioctl(stp, &strioc, flag,
3449 3450 copyflag, crp, rvalp));
3450 3451
3451 3452 case MSIOSETPARMS:
3452 3453 strioc.ic_len = sizeof (Ms_parms);
3453 3454 strioc.ic_dp = (char *)arg;
3454 3455 return (strdoioctl(stp, &strioc, flag,
3455 3456 copyflag, crp, rvalp));
3456 3457
3457 3458 case VUIDSADDR:
3458 3459 case VUIDGADDR:
3459 3460 strioc.ic_len = sizeof (struct vuid_addr_probe);
3460 3461 strioc.ic_dp = (char *)arg;
3461 3462 return (strdoioctl(stp, &strioc, flag,
3462 3463 copyflag, crp, rvalp));
3463 3464
3464 3465 /*
3465 3466 * These M_IOCTL's don't require any data to be sent
3466 3467 * downstream, and the driver will allocate and link
3467 3468 * on its own mblk_t upon M_IOCACK -- thus we set
3468 3469 * ic_len to zero and set ic_dp to arg so we know
3469 3470 * where to copyout to later.
3470 3471 */
3471 3472 case TIOCGSOFTCAR:
3472 3473 case TIOCGWINSZ:
3473 3474 case TIOCGSIZE:
3474 3475 case KIOCGTRANS:
3475 3476 case KIOCGTRANSABLE:
3476 3477 case KIOCTYPE:
3477 3478 case KIOCGDIRECT:
3478 3479 case KIOCGCOMPAT:
3479 3480 case KIOCLAYOUT:
3480 3481 case KIOCGLED:
3481 3482 case MSIOGETPARMS:
3482 3483 case MSIOBUTTONS:
3483 3484 case VUIDGFORMAT:
3484 3485 case TIOCGPPS:
3485 3486 case TIOCGPPSEV:
3486 3487 case TCGETA:
3487 3488 case TCGETS:
3488 3489 case LDGETT:
3489 3490 case TIOCGETP:
3490 3491 case KIOCGRPTDELAY:
3491 3492 case KIOCGRPTRATE:
3492 3493 strioc.ic_len = 0;
3493 3494 strioc.ic_dp = (char *)arg;
3494 3495 return (strdoioctl(stp, &strioc, flag,
3495 3496 copyflag, crp, rvalp));
3496 3497 }
3497 3498 }
3498 3499
3499 3500 /*
3500 3501 * Unknown cmd - send it down as a transparent ioctl.
3501 3502 */
3502 3503 strioc.ic_cmd = cmd;
3503 3504 strioc.ic_timout = INFTIM;
3504 3505 strioc.ic_len = TRANSPARENT;
3505 3506 strioc.ic_dp = (char *)&arg;
3506 3507
3507 3508 return (strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp));
3508 3509
3509 3510 case I_STR:
3510 3511 /*
3511 3512 * Stream ioctl. Read in an strioctl buffer from the user
3512 3513 * along with any data specified and send it downstream.
3513 3514 * Strdoioctl will wait allow only one ioctl message at
3514 3515 * a time, and waits for the acknowledgement.
3515 3516 */
3516 3517
3517 3518 if (stp->sd_flag & STRHUP)
3518 3519 return (ENXIO);
3519 3520
3520 3521 error = strcopyin_strioctl((void *)arg, &strioc, flag,
3521 3522 copyflag);
3522 3523 if (error != 0)
3523 3524 return (error);
3524 3525
3525 3526 if ((strioc.ic_len < 0) || (strioc.ic_timout < -1))
3526 3527 return (EINVAL);
3527 3528
3528 3529 access = job_control_type(strioc.ic_cmd);
3529 3530 mutex_enter(&stp->sd_lock);
3530 3531 if ((access != -1) &&
3531 3532 ((error = i_straccess(stp, access)) != 0)) {
3532 3533 mutex_exit(&stp->sd_lock);
3533 3534 return (error);
3534 3535 }
3535 3536 mutex_exit(&stp->sd_lock);
3536 3537
3537 3538 /*
3538 3539 * The I_STR facility provides a trap door for malicious
3539 3540 * code to send down bogus streamio(7I) ioctl commands to
3540 3541 * unsuspecting STREAMS modules and drivers which expect to
3541 3542 * only get these messages from the stream head.
3542 3543 * Explicitly prohibit any streamio ioctls which can be
3543 3544 * passed downstream by the stream head. Note that we do
3544 3545 * not block all streamio ioctls because the ioctl
3545 3546 * numberspace is not well managed and thus it's possible
3546 3547 * that a module or driver's ioctl numbers may accidentally
3547 3548 * collide with them.
3548 3549 */
3549 3550 switch (strioc.ic_cmd) {
3550 3551 case I_LINK:
3551 3552 case I_PLINK:
3552 3553 case I_UNLINK:
3553 3554 case I_PUNLINK:
3554 3555 case _I_GETPEERCRED:
3555 3556 case _I_PLINK_LH:
3556 3557 return (EINVAL);
3557 3558 }
3558 3559
3559 3560 error = strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp);
3560 3561 if (error == 0) {
3561 3562 error = strcopyout_strioctl(&strioc, (void *)arg,
3562 3563 flag, copyflag);
3563 3564 }
3564 3565 return (error);
3565 3566
3566 3567 case _I_CMD:
3567 3568 /*
3568 3569 * Like I_STR, but without using M_IOC* messages and without
3569 3570 * copyins/copyouts beyond the passed-in argument.
3570 3571 */
3571 3572 if (stp->sd_flag & STRHUP)
3572 3573 return (ENXIO);
3573 3574
3574 3575 if ((scp = kmem_alloc(sizeof (strcmd_t), KM_NOSLEEP)) == NULL)
3575 3576 return (ENOMEM);
3576 3577
3577 3578 if (copyin((void *)arg, scp, sizeof (strcmd_t))) {
3578 3579 kmem_free(scp, sizeof (strcmd_t));
3579 3580 return (EFAULT);
3580 3581 }
3581 3582
3582 3583 access = job_control_type(scp->sc_cmd);
3583 3584 mutex_enter(&stp->sd_lock);
3584 3585 if (access != -1 && (error = i_straccess(stp, access)) != 0) {
3585 3586 mutex_exit(&stp->sd_lock);
3586 3587 kmem_free(scp, sizeof (strcmd_t));
3587 3588 return (error);
3588 3589 }
3589 3590 mutex_exit(&stp->sd_lock);
3590 3591
3591 3592 *rvalp = 0;
3592 3593 if ((error = strdocmd(stp, scp, crp)) == 0) {
3593 3594 if (copyout(scp, (void *)arg, sizeof (strcmd_t)))
3594 3595 error = EFAULT;
3595 3596 }
3596 3597 kmem_free(scp, sizeof (strcmd_t));
3597 3598 return (error);
3598 3599
3599 3600 case I_NREAD:
3600 3601 /*
3601 3602 * Return number of bytes of data in first message
3602 3603 * in queue in "arg" and return the number of messages
3603 3604 * in queue in return value.
3604 3605 */
3605 3606 {
3606 3607 size_t size;
3607 3608 int retval;
3608 3609 int count = 0;
3609 3610
3610 3611 mutex_enter(QLOCK(rdq));
3611 3612
3612 3613 size = msgdsize(rdq->q_first);
3613 3614 for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
3614 3615 count++;
3615 3616
3616 3617 mutex_exit(QLOCK(rdq));
3617 3618 if (stp->sd_struiordq) {
3618 3619 infod_t infod;
3619 3620
3620 3621 infod.d_cmd = INFOD_COUNT;
3621 3622 infod.d_count = 0;
3622 3623 if (count == 0) {
3623 3624 infod.d_cmd |= INFOD_FIRSTBYTES;
3624 3625 infod.d_bytes = 0;
3625 3626 }
3626 3627 infod.d_res = 0;
3627 3628 (void) infonext(rdq, &infod);
3628 3629 count += infod.d_count;
3629 3630 if (infod.d_res & INFOD_FIRSTBYTES)
3630 3631 size = infod.d_bytes;
3631 3632 }
3632 3633
3633 3634 /*
3634 3635 * Drop down from size_t to the "int" required by the
3635 3636 * interface. Cap at INT_MAX.
3636 3637 */
3637 3638 retval = MIN(size, INT_MAX);
3638 3639 error = strcopyout(&retval, (void *)arg, sizeof (retval),
3639 3640 copyflag);
3640 3641 if (!error)
3641 3642 *rvalp = count;
3642 3643 return (error);
3643 3644 }
3644 3645
3645 3646 case FIONREAD:
3646 3647 /*
3647 3648 * Return number of bytes of data in all data messages
3648 3649 * in queue in "arg".
3649 3650 */
3650 3651 {
3651 3652 size_t size = 0;
3652 3653 int retval;
3653 3654
3654 3655 mutex_enter(QLOCK(rdq));
3655 3656 for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
3656 3657 size += msgdsize(mp);
3657 3658 mutex_exit(QLOCK(rdq));
3658 3659
3659 3660 if (stp->sd_struiordq) {
3660 3661 infod_t infod;
3661 3662
3662 3663 infod.d_cmd = INFOD_BYTES;
3663 3664 infod.d_res = 0;
3664 3665 infod.d_bytes = 0;
3665 3666 (void) infonext(rdq, &infod);
3666 3667 size += infod.d_bytes;
3667 3668 }
3668 3669
3669 3670 /*
3670 3671 * Drop down from size_t to the "int" required by the
3671 3672 * interface. Cap at INT_MAX.
3672 3673 */
3673 3674 retval = MIN(size, INT_MAX);
3674 3675 error = strcopyout(&retval, (void *)arg, sizeof (retval),
3675 3676 copyflag);
3676 3677
3677 3678 *rvalp = 0;
3678 3679 return (error);
3679 3680 }
3680 3681 case FIORDCHK:
3681 3682 /*
3682 3683 * FIORDCHK does not use arg value (like FIONREAD),
3683 3684 * instead a count is returned. I_NREAD value may
3684 3685 * not be accurate but safe. The real thing to do is
3685 3686 * to add the msgdsizes of all data messages until
3686 3687 * a non-data message.
3687 3688 */
3688 3689 {
3689 3690 size_t size = 0;
3690 3691
3691 3692 mutex_enter(QLOCK(rdq));
3692 3693 for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
3693 3694 size += msgdsize(mp);
3694 3695 mutex_exit(QLOCK(rdq));
3695 3696
3696 3697 if (stp->sd_struiordq) {
3697 3698 infod_t infod;
3698 3699
3699 3700 infod.d_cmd = INFOD_BYTES;
3700 3701 infod.d_res = 0;
3701 3702 infod.d_bytes = 0;
3702 3703 (void) infonext(rdq, &infod);
3703 3704 size += infod.d_bytes;
3704 3705 }
3705 3706
3706 3707 /*
3707 3708 * Since ioctl returns an int, and memory sizes under
3708 3709 * LP64 may not fit, we return INT_MAX if the count was
3709 3710 * actually greater.
3710 3711 */
3711 3712 *rvalp = MIN(size, INT_MAX);
3712 3713 return (0);
3713 3714 }
3714 3715
3715 3716 case I_FIND:
3716 3717 /*
3717 3718 * Get module name.
3718 3719 */
3719 3720 {
3720 3721 char mname[FMNAMESZ + 1];
3721 3722 queue_t *q;
3722 3723
3723 3724 error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
3724 3725 mname, FMNAMESZ + 1, NULL);
3725 3726 if (error)
3726 3727 return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
3727 3728
3728 3729 /*
3729 3730 * Return EINVAL if we're handed a bogus module name.
3730 3731 */
3731 3732 if (fmodsw_find(mname, FMODSW_LOAD) == NULL) {
3732 3733 TRACE_0(TR_FAC_STREAMS_FR,
3733 3734 TR_I_CANT_FIND, "couldn't I_FIND");
3734 3735 return (EINVAL);
3735 3736 }
3736 3737
3737 3738 *rvalp = 0;
3738 3739
3739 3740 /* Look downstream to see if module is there. */
3740 3741 claimstr(stp->sd_wrq);
3741 3742 for (q = stp->sd_wrq->q_next; q; q = q->q_next) {
3742 3743 if (q->q_flag & QREADR) {
3743 3744 q = NULL;
3744 3745 break;
3745 3746 }
3746 3747 if (strcmp(mname, Q2NAME(q)) == 0)
3747 3748 break;
3748 3749 }
3749 3750 releasestr(stp->sd_wrq);
3750 3751
3751 3752 *rvalp = (q ? 1 : 0);
3752 3753 return (error);
3753 3754 }
3754 3755
3755 3756 case I_PUSH:
3756 3757 case __I_PUSH_NOCTTY:
3757 3758 /*
3758 3759 * Push a module.
3759 3760 * For the case __I_PUSH_NOCTTY push a module but
3760 3761 * do not allocate controlling tty. See bugid 4025044
3761 3762 */
3762 3763
3763 3764 {
3764 3765 char mname[FMNAMESZ + 1];
3765 3766 fmodsw_impl_t *fp;
3766 3767 dev_t dummydev;
3767 3768
3768 3769 if (stp->sd_flag & STRHUP)
3769 3770 return (ENXIO);
3770 3771
3771 3772 /*
3772 3773 * Get module name and look up in fmodsw.
3773 3774 */
3774 3775 error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
3775 3776 mname, FMNAMESZ + 1, NULL);
|
↓ open down ↓ |
3738 lines elided |
↑ open up ↑ |
3776 3777 if (error)
3777 3778 return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
3778 3779
3779 3780 if ((fp = fmodsw_find(mname, FMODSW_HOLD | FMODSW_LOAD)) ==
3780 3781 NULL)
3781 3782 return (EINVAL);
3782 3783
3783 3784 TRACE_2(TR_FAC_STREAMS_FR, TR_I_PUSH,
3784 3785 "I_PUSH:fp %p stp %p", fp, stp);
3785 3786
3787 + /*
3788 + * If the module is flagged as single-instance, then check
3789 + * to see if the module is already pushed. If it is, return
3790 + * as if the push was successful.
3791 + */
3792 + if (fp->f_qflag & _QSINGLE_INSTANCE) {
3793 + queue_t *q;
3794 +
3795 + claimstr(stp->sd_wrq);
3796 + for (q = stp->sd_wrq->q_next; q; q = q->q_next) {
3797 + if (q->q_flag & QREADR) {
3798 + q = NULL;
3799 + break;
3800 + }
3801 + if (strcmp(mname, Q2NAME(q)) == 0)
3802 + break;
3803 + }
3804 + releasestr(stp->sd_wrq);
3805 + if (q != NULL) {
3806 + fmodsw_rele(fp);
3807 + return (0);
3808 + }
3809 + }
3810 +
3786 3811 if (error = strstartplumb(stp, flag, cmd)) {
3787 3812 fmodsw_rele(fp);
3788 3813 return (error);
3789 3814 }
3790 3815
3791 3816 /*
3792 3817 * See if any more modules can be pushed on this stream.
3793 3818 * Note that this check must be done after strstartplumb()
3794 3819 * since otherwise multiple threads issuing I_PUSHes on
3795 3820 * the same stream will be able to exceed nstrpush.
3796 3821 */
3797 3822 mutex_enter(&stp->sd_lock);
3798 3823 if (stp->sd_pushcnt >= nstrpush) {
3799 3824 fmodsw_rele(fp);
3800 3825 strendplumb(stp);
3801 3826 mutex_exit(&stp->sd_lock);
3802 3827 return (EINVAL);
3803 3828 }
3804 3829 mutex_exit(&stp->sd_lock);
3805 3830
3806 3831 /*
3807 3832 * Push new module and call its open routine
3808 3833 * via qattach(). Modules don't change device
3809 3834 * numbers, so just ignore dummydev here.
3810 3835 */
3811 3836 dummydev = vp->v_rdev;
3812 3837 if ((error = qattach(rdq, &dummydev, 0, crp, fp,
3813 3838 B_FALSE)) == 0) {
3814 3839 if (vp->v_type == VCHR && /* sorry, no pipes allowed */
3815 3840 (cmd == I_PUSH) && (stp->sd_flag & STRISTTY)) {
3816 3841 /*
3817 3842 * try to allocate it as a controlling terminal
3818 3843 */
3819 3844 (void) strctty(stp);
3820 3845 }
3821 3846 }
3822 3847
3823 3848 mutex_enter(&stp->sd_lock);
3824 3849
3825 3850 /*
3826 3851 * As a performance concern we are caching the values of
3827 3852 * q_minpsz and q_maxpsz of the module below the stream
3828 3853 * head in the stream head.
3829 3854 */
3830 3855 mutex_enter(QLOCK(stp->sd_wrq->q_next));
3831 3856 rmin = stp->sd_wrq->q_next->q_minpsz;
3832 3857 rmax = stp->sd_wrq->q_next->q_maxpsz;
3833 3858 mutex_exit(QLOCK(stp->sd_wrq->q_next));
3834 3859
3835 3860 /* Do this processing here as a performance concern */
3836 3861 if (strmsgsz != 0) {
3837 3862 if (rmax == INFPSZ)
3838 3863 rmax = strmsgsz;
3839 3864 else {
3840 3865 if (vp->v_type == VFIFO)
3841 3866 rmax = MIN(PIPE_BUF, rmax);
3842 3867 else rmax = MIN(strmsgsz, rmax);
3843 3868 }
3844 3869 }
3845 3870
3846 3871 mutex_enter(QLOCK(wrq));
3847 3872 stp->sd_qn_minpsz = rmin;
3848 3873 stp->sd_qn_maxpsz = rmax;
3849 3874 mutex_exit(QLOCK(wrq));
3850 3875
3851 3876 strendplumb(stp);
3852 3877 mutex_exit(&stp->sd_lock);
3853 3878 return (error);
3854 3879 }
3855 3880
3856 3881 case I_POP:
3857 3882 {
3858 3883 queue_t *q;
3859 3884
3860 3885 if (stp->sd_flag & STRHUP)
3861 3886 return (ENXIO);
3862 3887 if (!wrq->q_next) /* for broken pipes */
3863 3888 return (EINVAL);
3864 3889
3865 3890 if (error = strstartplumb(stp, flag, cmd))
3866 3891 return (error);
3867 3892
3868 3893 /*
3869 3894 * If there is an anchor on this stream and popping
3870 3895 * the current module would attempt to pop through the
3871 3896 * anchor, then disallow the pop unless we have sufficient
3872 3897 * privileges; take the cheapest (non-locking) check
3873 3898 * first.
3874 3899 */
3875 3900 if (secpolicy_ip_config(crp, B_TRUE) != 0 ||
3876 3901 (stp->sd_anchorzone != crgetzoneid(crp))) {
3877 3902 mutex_enter(&stp->sd_lock);
3878 3903 /*
3879 3904 * Anchors only apply if there's at least one
3880 3905 * module on the stream (sd_pushcnt > 0).
3881 3906 */
3882 3907 if (stp->sd_pushcnt > 0 &&
3883 3908 stp->sd_pushcnt == stp->sd_anchor &&
3884 3909 stp->sd_vnode->v_type != VFIFO) {
3885 3910 strendplumb(stp);
3886 3911 mutex_exit(&stp->sd_lock);
3887 3912 if (stp->sd_anchorzone != crgetzoneid(crp))
3888 3913 return (EINVAL);
3889 3914 /* Audit and report error */
3890 3915 return (secpolicy_ip_config(crp, B_FALSE));
3891 3916 }
3892 3917 mutex_exit(&stp->sd_lock);
3893 3918 }
3894 3919
3895 3920 q = wrq->q_next;
3896 3921 TRACE_2(TR_FAC_STREAMS_FR, TR_I_POP,
3897 3922 "I_POP:%p from %p", q, stp);
3898 3923 if (q->q_next == NULL || (q->q_flag & (QREADR|QISDRV))) {
3899 3924 error = EINVAL;
3900 3925 } else {
3901 3926 qdetach(_RD(q), 1, flag, crp, B_FALSE);
3902 3927 error = 0;
3903 3928 }
3904 3929 mutex_enter(&stp->sd_lock);
3905 3930
3906 3931 /*
3907 3932 * As a performance concern we are caching the values of
3908 3933 * q_minpsz and q_maxpsz of the module below the stream
3909 3934 * head in the stream head.
3910 3935 */
3911 3936 mutex_enter(QLOCK(wrq->q_next));
3912 3937 rmin = wrq->q_next->q_minpsz;
3913 3938 rmax = wrq->q_next->q_maxpsz;
3914 3939 mutex_exit(QLOCK(wrq->q_next));
3915 3940
3916 3941 /* Do this processing here as a performance concern */
3917 3942 if (strmsgsz != 0) {
3918 3943 if (rmax == INFPSZ)
3919 3944 rmax = strmsgsz;
3920 3945 else {
3921 3946 if (vp->v_type == VFIFO)
3922 3947 rmax = MIN(PIPE_BUF, rmax);
3923 3948 else rmax = MIN(strmsgsz, rmax);
3924 3949 }
3925 3950 }
3926 3951
3927 3952 mutex_enter(QLOCK(wrq));
3928 3953 stp->sd_qn_minpsz = rmin;
3929 3954 stp->sd_qn_maxpsz = rmax;
3930 3955 mutex_exit(QLOCK(wrq));
3931 3956
3932 3957 /* If we popped through the anchor, then reset the anchor. */
3933 3958 if (stp->sd_pushcnt < stp->sd_anchor) {
3934 3959 stp->sd_anchor = 0;
3935 3960 stp->sd_anchorzone = 0;
3936 3961 }
3937 3962 strendplumb(stp);
3938 3963 mutex_exit(&stp->sd_lock);
3939 3964 return (error);
3940 3965 }
3941 3966
3942 3967 case _I_MUXID2FD:
3943 3968 {
3944 3969 /*
3945 3970 * Create a fd for a I_PLINK'ed lower stream with a given
3946 3971 * muxid. With the fd, application can send down ioctls,
3947 3972 * like I_LIST, to the previously I_PLINK'ed stream. Note
3948 3973 * that after getting the fd, the application has to do an
3949 3974 * I_PUNLINK on the muxid before it can do any operation
3950 3975 * on the lower stream. This is required by spec1170.
3951 3976 *
3952 3977 * The fd used to do this ioctl should point to the same
3953 3978 * controlling device used to do the I_PLINK. If it uses
3954 3979 * a different stream or an invalid muxid, I_MUXID2FD will
3955 3980 * fail. The error code is set to EINVAL.
3956 3981 *
3957 3982 * The intended use of this interface is the following.
3958 3983 * An application I_PLINK'ed a stream and exits. The fd
3959 3984 * to the lower stream is gone. Another application
3960 3985 * wants to get a fd to the lower stream, it uses I_MUXID2FD.
3961 3986 */
3962 3987 int muxid = (int)arg;
3963 3988 int fd;
3964 3989 linkinfo_t *linkp;
3965 3990 struct file *fp;
3966 3991 netstack_t *ns;
3967 3992 str_stack_t *ss;
3968 3993
3969 3994 /*
3970 3995 * Do not allow the wildcard muxid. This ioctl is not
3971 3996 * intended to find arbitrary link.
3972 3997 */
3973 3998 if (muxid == 0) {
3974 3999 return (EINVAL);
3975 4000 }
3976 4001
3977 4002 ns = netstack_find_by_cred(crp);
3978 4003 ASSERT(ns != NULL);
3979 4004 ss = ns->netstack_str;
3980 4005 ASSERT(ss != NULL);
3981 4006
3982 4007 mutex_enter(&muxifier);
3983 4008 linkp = findlinks(vp->v_stream, muxid, LINKPERSIST, ss);
3984 4009 if (linkp == NULL) {
3985 4010 mutex_exit(&muxifier);
3986 4011 netstack_rele(ss->ss_netstack);
3987 4012 return (EINVAL);
3988 4013 }
3989 4014
3990 4015 if ((fd = ufalloc(0)) == -1) {
3991 4016 mutex_exit(&muxifier);
3992 4017 netstack_rele(ss->ss_netstack);
3993 4018 return (EMFILE);
3994 4019 }
3995 4020 fp = linkp->li_fpdown;
3996 4021 mutex_enter(&fp->f_tlock);
3997 4022 fp->f_count++;
3998 4023 mutex_exit(&fp->f_tlock);
3999 4024 mutex_exit(&muxifier);
4000 4025 setf(fd, fp);
4001 4026 *rvalp = fd;
4002 4027 netstack_rele(ss->ss_netstack);
4003 4028 return (0);
4004 4029 }
4005 4030
4006 4031 case _I_INSERT:
4007 4032 {
4008 4033 /*
4009 4034 * To insert a module to a given position in a stream.
4010 4035 * In the first release, only allow privileged user
4011 4036 * to use this ioctl. Furthermore, the insert is only allowed
4012 4037 * below an anchor if the zoneid is the same as the zoneid
4013 4038 * which created the anchor.
4014 4039 *
4015 4040 * Note that we do not plan to support this ioctl
4016 4041 * on pipes in the first release. We want to learn more
4017 4042 * about the implications of these ioctls before extending
4018 4043 * their support. And we do not think these features are
4019 4044 * valuable for pipes.
4020 4045 */
4021 4046 STRUCT_DECL(strmodconf, strmodinsert);
4022 4047 char mod_name[FMNAMESZ + 1];
4023 4048 fmodsw_impl_t *fp;
4024 4049 dev_t dummydev;
4025 4050 queue_t *tmp_wrq;
4026 4051 int pos;
4027 4052 boolean_t is_insert;
4028 4053
4029 4054 STRUCT_INIT(strmodinsert, flag);
4030 4055 if (stp->sd_flag & STRHUP)
4031 4056 return (ENXIO);
4032 4057 if (STRMATED(stp))
4033 4058 return (EINVAL);
4034 4059 if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
4035 4060 return (error);
4036 4061 if (stp->sd_anchor != 0 &&
4037 4062 stp->sd_anchorzone != crgetzoneid(crp))
4038 4063 return (EINVAL);
4039 4064
4040 4065 error = strcopyin((void *)arg, STRUCT_BUF(strmodinsert),
4041 4066 STRUCT_SIZE(strmodinsert), copyflag);
4042 4067 if (error)
4043 4068 return (error);
4044 4069
4045 4070 /*
4046 4071 * Get module name and look up in fmodsw.
4047 4072 */
4048 4073 error = (copyflag & U_TO_K ? copyinstr :
4049 4074 copystr)(STRUCT_FGETP(strmodinsert, mod_name),
4050 4075 mod_name, FMNAMESZ + 1, NULL);
4051 4076 if (error)
4052 4077 return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
4053 4078
4054 4079 if ((fp = fmodsw_find(mod_name, FMODSW_HOLD | FMODSW_LOAD)) ==
4055 4080 NULL)
4056 4081 return (EINVAL);
4057 4082
4058 4083 if (error = strstartplumb(stp, flag, cmd)) {
4059 4084 fmodsw_rele(fp);
4060 4085 return (error);
4061 4086 }
4062 4087
4063 4088 /*
4064 4089 * Is this _I_INSERT just like an I_PUSH? We need to know
4065 4090 * this because we do some optimizations if this is a
4066 4091 * module being pushed.
4067 4092 */
4068 4093 pos = STRUCT_FGET(strmodinsert, pos);
4069 4094 is_insert = (pos != 0);
4070 4095
4071 4096 /*
4072 4097 * Make sure pos is valid. Even though it is not an I_PUSH,
4073 4098 * we impose the same limit on the number of modules in a
4074 4099 * stream.
4075 4100 */
4076 4101 mutex_enter(&stp->sd_lock);
4077 4102 if (stp->sd_pushcnt >= nstrpush || pos < 0 ||
4078 4103 pos > stp->sd_pushcnt) {
4079 4104 fmodsw_rele(fp);
4080 4105 strendplumb(stp);
4081 4106 mutex_exit(&stp->sd_lock);
4082 4107 return (EINVAL);
4083 4108 }
4084 4109 if (stp->sd_anchor != 0) {
4085 4110 /*
4086 4111 * Is this insert below the anchor?
4087 4112 * Pushcnt hasn't been increased yet hence
4088 4113 * we test for greater than here, and greater or
4089 4114 * equal after qattach.
4090 4115 */
4091 4116 if (pos > (stp->sd_pushcnt - stp->sd_anchor) &&
4092 4117 stp->sd_anchorzone != crgetzoneid(crp)) {
4093 4118 fmodsw_rele(fp);
4094 4119 strendplumb(stp);
4095 4120 mutex_exit(&stp->sd_lock);
4096 4121 return (EPERM);
4097 4122 }
4098 4123 }
4099 4124
4100 4125 mutex_exit(&stp->sd_lock);
4101 4126
4102 4127 /*
4103 4128 * First find the correct position this module to
4104 4129 * be inserted. We don't need to call claimstr()
4105 4130 * as the stream should not be changing at this point.
4106 4131 *
4107 4132 * Insert new module and call its open routine
4108 4133 * via qattach(). Modules don't change device
4109 4134 * numbers, so just ignore dummydev here.
4110 4135 */
4111 4136 for (tmp_wrq = stp->sd_wrq; pos > 0;
4112 4137 tmp_wrq = tmp_wrq->q_next, pos--) {
4113 4138 ASSERT(SAMESTR(tmp_wrq));
4114 4139 }
4115 4140 dummydev = vp->v_rdev;
4116 4141 if ((error = qattach(_RD(tmp_wrq), &dummydev, 0, crp,
4117 4142 fp, is_insert)) != 0) {
4118 4143 mutex_enter(&stp->sd_lock);
4119 4144 strendplumb(stp);
4120 4145 mutex_exit(&stp->sd_lock);
4121 4146 return (error);
4122 4147 }
4123 4148
4124 4149 mutex_enter(&stp->sd_lock);
4125 4150
4126 4151 /*
4127 4152 * As a performance concern we are caching the values of
4128 4153 * q_minpsz and q_maxpsz of the module below the stream
4129 4154 * head in the stream head.
4130 4155 */
4131 4156 if (!is_insert) {
4132 4157 mutex_enter(QLOCK(stp->sd_wrq->q_next));
4133 4158 rmin = stp->sd_wrq->q_next->q_minpsz;
4134 4159 rmax = stp->sd_wrq->q_next->q_maxpsz;
4135 4160 mutex_exit(QLOCK(stp->sd_wrq->q_next));
4136 4161
4137 4162 /* Do this processing here as a performance concern */
4138 4163 if (strmsgsz != 0) {
4139 4164 if (rmax == INFPSZ) {
4140 4165 rmax = strmsgsz;
4141 4166 } else {
4142 4167 rmax = MIN(strmsgsz, rmax);
4143 4168 }
4144 4169 }
4145 4170
4146 4171 mutex_enter(QLOCK(wrq));
4147 4172 stp->sd_qn_minpsz = rmin;
4148 4173 stp->sd_qn_maxpsz = rmax;
4149 4174 mutex_exit(QLOCK(wrq));
4150 4175 }
4151 4176
4152 4177 /*
4153 4178 * Need to update the anchor value if this module is
4154 4179 * inserted below the anchor point.
4155 4180 */
4156 4181 if (stp->sd_anchor != 0) {
4157 4182 pos = STRUCT_FGET(strmodinsert, pos);
4158 4183 if (pos >= (stp->sd_pushcnt - stp->sd_anchor))
4159 4184 stp->sd_anchor++;
4160 4185 }
4161 4186
4162 4187 strendplumb(stp);
4163 4188 mutex_exit(&stp->sd_lock);
4164 4189 return (0);
4165 4190 }
4166 4191
4167 4192 case _I_REMOVE:
4168 4193 {
4169 4194 /*
4170 4195 * To remove a module with a given name in a stream. The
4171 4196 * caller of this ioctl needs to provide both the name and
4172 4197 * the position of the module to be removed. This eliminates
4173 4198 * the ambiguity of removal if a module is inserted/pushed
4174 4199 * multiple times in a stream. In the first release, only
4175 4200 * allow privileged user to use this ioctl.
4176 4201 * Furthermore, the remove is only allowed
4177 4202 * below an anchor if the zoneid is the same as the zoneid
4178 4203 * which created the anchor.
4179 4204 *
4180 4205 * Note that we do not plan to support this ioctl
4181 4206 * on pipes in the first release. We want to learn more
4182 4207 * about the implications of these ioctls before extending
4183 4208 * their support. And we do not think these features are
4184 4209 * valuable for pipes.
4185 4210 *
4186 4211 * Also note that _I_REMOVE cannot be used to remove a
4187 4212 * driver or the stream head.
4188 4213 */
4189 4214 STRUCT_DECL(strmodconf, strmodremove);
4190 4215 queue_t *q;
4191 4216 int pos;
4192 4217 char mod_name[FMNAMESZ + 1];
4193 4218 boolean_t is_remove;
4194 4219
4195 4220 STRUCT_INIT(strmodremove, flag);
4196 4221 if (stp->sd_flag & STRHUP)
4197 4222 return (ENXIO);
4198 4223 if (STRMATED(stp))
4199 4224 return (EINVAL);
4200 4225 if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
4201 4226 return (error);
4202 4227 if (stp->sd_anchor != 0 &&
4203 4228 stp->sd_anchorzone != crgetzoneid(crp))
4204 4229 return (EINVAL);
4205 4230
4206 4231 error = strcopyin((void *)arg, STRUCT_BUF(strmodremove),
4207 4232 STRUCT_SIZE(strmodremove), copyflag);
4208 4233 if (error)
4209 4234 return (error);
4210 4235
4211 4236 error = (copyflag & U_TO_K ? copyinstr :
4212 4237 copystr)(STRUCT_FGETP(strmodremove, mod_name),
4213 4238 mod_name, FMNAMESZ + 1, NULL);
4214 4239 if (error)
4215 4240 return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
4216 4241
4217 4242 if ((error = strstartplumb(stp, flag, cmd)) != 0)
4218 4243 return (error);
4219 4244
4220 4245 /*
4221 4246 * Match the name of given module to the name of module at
4222 4247 * the given position.
4223 4248 */
4224 4249 pos = STRUCT_FGET(strmodremove, pos);
4225 4250
4226 4251 is_remove = (pos != 0);
4227 4252 for (q = stp->sd_wrq->q_next; SAMESTR(q) && pos > 0;
4228 4253 q = q->q_next, pos--)
4229 4254 ;
4230 4255 if (pos > 0 || !SAMESTR(q) ||
4231 4256 strcmp(Q2NAME(q), mod_name) != 0) {
4232 4257 mutex_enter(&stp->sd_lock);
4233 4258 strendplumb(stp);
4234 4259 mutex_exit(&stp->sd_lock);
4235 4260 return (EINVAL);
4236 4261 }
4237 4262
4238 4263 /*
4239 4264 * If the position is at or below an anchor, then the zoneid
4240 4265 * must match the zoneid that created the anchor.
4241 4266 */
4242 4267 if (stp->sd_anchor != 0) {
4243 4268 pos = STRUCT_FGET(strmodremove, pos);
4244 4269 if (pos >= (stp->sd_pushcnt - stp->sd_anchor) &&
4245 4270 stp->sd_anchorzone != crgetzoneid(crp)) {
4246 4271 mutex_enter(&stp->sd_lock);
4247 4272 strendplumb(stp);
4248 4273 mutex_exit(&stp->sd_lock);
4249 4274 return (EPERM);
4250 4275 }
4251 4276 }
4252 4277
4253 4278
4254 4279 ASSERT(!(q->q_flag & QREADR));
4255 4280 qdetach(_RD(q), 1, flag, crp, is_remove);
4256 4281
4257 4282 mutex_enter(&stp->sd_lock);
4258 4283
4259 4284 /*
4260 4285 * As a performance concern we are caching the values of
4261 4286 * q_minpsz and q_maxpsz of the module below the stream
4262 4287 * head in the stream head.
4263 4288 */
4264 4289 if (!is_remove) {
4265 4290 mutex_enter(QLOCK(wrq->q_next));
4266 4291 rmin = wrq->q_next->q_minpsz;
4267 4292 rmax = wrq->q_next->q_maxpsz;
4268 4293 mutex_exit(QLOCK(wrq->q_next));
4269 4294
4270 4295 /* Do this processing here as a performance concern */
4271 4296 if (strmsgsz != 0) {
4272 4297 if (rmax == INFPSZ)
4273 4298 rmax = strmsgsz;
4274 4299 else {
4275 4300 if (vp->v_type == VFIFO)
4276 4301 rmax = MIN(PIPE_BUF, rmax);
4277 4302 else rmax = MIN(strmsgsz, rmax);
4278 4303 }
4279 4304 }
4280 4305
4281 4306 mutex_enter(QLOCK(wrq));
4282 4307 stp->sd_qn_minpsz = rmin;
4283 4308 stp->sd_qn_maxpsz = rmax;
4284 4309 mutex_exit(QLOCK(wrq));
4285 4310 }
4286 4311
4287 4312 /*
4288 4313 * Need to update the anchor value if this module is removed
4289 4314 * at or below the anchor point. If the removed module is at
4290 4315 * the anchor point, remove the anchor for this stream if
4291 4316 * there is no module above the anchor point. Otherwise, if
4292 4317 * the removed module is below the anchor point, decrement the
4293 4318 * anchor point by 1.
4294 4319 */
4295 4320 if (stp->sd_anchor != 0) {
4296 4321 pos = STRUCT_FGET(strmodremove, pos);
4297 4322 if (pos == stp->sd_pushcnt - stp->sd_anchor + 1)
4298 4323 stp->sd_anchor = 0;
4299 4324 else if (pos > (stp->sd_pushcnt - stp->sd_anchor + 1))
4300 4325 stp->sd_anchor--;
4301 4326 }
4302 4327
4303 4328 strendplumb(stp);
4304 4329 mutex_exit(&stp->sd_lock);
4305 4330 return (0);
4306 4331 }
4307 4332
4308 4333 case I_ANCHOR:
4309 4334 /*
4310 4335 * Set the anchor position on the stream to reside at
4311 4336 * the top module (in other words, the top module
4312 4337 * cannot be popped). Anchors with a FIFO make no
4313 4338 * obvious sense, so they're not allowed.
4314 4339 */
4315 4340 mutex_enter(&stp->sd_lock);
4316 4341
4317 4342 if (stp->sd_vnode->v_type == VFIFO) {
4318 4343 mutex_exit(&stp->sd_lock);
4319 4344 return (EINVAL);
4320 4345 }
4321 4346 /* Only allow the same zoneid to update the anchor */
4322 4347 if (stp->sd_anchor != 0 &&
4323 4348 stp->sd_anchorzone != crgetzoneid(crp)) {
4324 4349 mutex_exit(&stp->sd_lock);
4325 4350 return (EINVAL);
4326 4351 }
4327 4352 stp->sd_anchor = stp->sd_pushcnt;
4328 4353 stp->sd_anchorzone = crgetzoneid(crp);
4329 4354 mutex_exit(&stp->sd_lock);
4330 4355 return (0);
4331 4356
4332 4357 case I_LOOK:
4333 4358 /*
4334 4359 * Get name of first module downstream.
4335 4360 * If no module, return an error.
4336 4361 */
4337 4362 claimstr(wrq);
4338 4363 if (_SAMESTR(wrq) && wrq->q_next->q_next != NULL) {
4339 4364 char *name = Q2NAME(wrq->q_next);
4340 4365
4341 4366 error = strcopyout(name, (void *)arg, strlen(name) + 1,
4342 4367 copyflag);
4343 4368 releasestr(wrq);
4344 4369 return (error);
4345 4370 }
4346 4371 releasestr(wrq);
4347 4372 return (EINVAL);
4348 4373
4349 4374 case I_LINK:
4350 4375 case I_PLINK:
4351 4376 /*
4352 4377 * Link a multiplexor.
4353 4378 */
4354 4379 return (mlink(vp, cmd, (int)arg, crp, rvalp, 0));
4355 4380
4356 4381 case _I_PLINK_LH:
4357 4382 /*
4358 4383 * Link a multiplexor: Call must originate from kernel.
4359 4384 */
4360 4385 if (kioctl)
4361 4386 return (ldi_mlink_lh(vp, cmd, arg, crp, rvalp));
4362 4387
4363 4388 return (EINVAL);
4364 4389 case I_UNLINK:
4365 4390 case I_PUNLINK:
4366 4391 /*
4367 4392 * Unlink a multiplexor.
4368 4393 * If arg is -1, unlink all links for which this is the
4369 4394 * controlling stream. Otherwise, arg is an index number
4370 4395 * for a link to be removed.
4371 4396 */
4372 4397 {
4373 4398 struct linkinfo *linkp;
4374 4399 int native_arg = (int)arg;
4375 4400 int type;
4376 4401 netstack_t *ns;
4377 4402 str_stack_t *ss;
4378 4403
4379 4404 TRACE_1(TR_FAC_STREAMS_FR,
4380 4405 TR_I_UNLINK, "I_UNLINK/I_PUNLINK:%p", stp);
4381 4406 if (vp->v_type == VFIFO) {
4382 4407 return (EINVAL);
4383 4408 }
4384 4409 if (cmd == I_UNLINK)
4385 4410 type = LINKNORMAL;
4386 4411 else /* I_PUNLINK */
4387 4412 type = LINKPERSIST;
4388 4413 if (native_arg == 0) {
4389 4414 return (EINVAL);
4390 4415 }
4391 4416 ns = netstack_find_by_cred(crp);
4392 4417 ASSERT(ns != NULL);
4393 4418 ss = ns->netstack_str;
4394 4419 ASSERT(ss != NULL);
4395 4420
4396 4421 if (native_arg == MUXID_ALL)
4397 4422 error = munlinkall(stp, type, crp, rvalp, ss);
4398 4423 else {
4399 4424 mutex_enter(&muxifier);
4400 4425 if (!(linkp = findlinks(stp, (int)arg, type, ss))) {
4401 4426 /* invalid user supplied index number */
4402 4427 mutex_exit(&muxifier);
4403 4428 netstack_rele(ss->ss_netstack);
4404 4429 return (EINVAL);
4405 4430 }
4406 4431 /* munlink drops the muxifier lock */
4407 4432 error = munlink(stp, linkp, type, crp, rvalp, ss);
4408 4433 }
4409 4434 netstack_rele(ss->ss_netstack);
4410 4435 return (error);
4411 4436 }
4412 4437
4413 4438 case I_FLUSH:
4414 4439 /*
4415 4440 * send a flush message downstream
4416 4441 * flush message can indicate
4417 4442 * FLUSHR - flush read queue
4418 4443 * FLUSHW - flush write queue
4419 4444 * FLUSHRW - flush read/write queue
4420 4445 */
4421 4446 if (stp->sd_flag & STRHUP)
4422 4447 return (ENXIO);
4423 4448 if (arg & ~FLUSHRW)
4424 4449 return (EINVAL);
4425 4450
4426 4451 for (;;) {
4427 4452 if (putnextctl1(stp->sd_wrq, M_FLUSH, (int)arg)) {
4428 4453 break;
4429 4454 }
4430 4455 if (error = strwaitbuf(1, BPRI_HI)) {
4431 4456 return (error);
4432 4457 }
4433 4458 }
4434 4459
4435 4460 /*
4436 4461 * Send down an unsupported ioctl and wait for the nack
4437 4462 * in order to allow the M_FLUSH to propagate back
4438 4463 * up to the stream head.
4439 4464 * Replaces if (qready()) runqueues();
4440 4465 */
4441 4466 strioc.ic_cmd = -1; /* The unsupported ioctl */
4442 4467 strioc.ic_timout = 0;
4443 4468 strioc.ic_len = 0;
4444 4469 strioc.ic_dp = NULL;
4445 4470 (void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
4446 4471 *rvalp = 0;
4447 4472 return (0);
4448 4473
4449 4474 case I_FLUSHBAND:
4450 4475 {
4451 4476 struct bandinfo binfo;
4452 4477
4453 4478 error = strcopyin((void *)arg, &binfo, sizeof (binfo),
4454 4479 copyflag);
4455 4480 if (error)
4456 4481 return (error);
4457 4482 if (stp->sd_flag & STRHUP)
4458 4483 return (ENXIO);
4459 4484 if (binfo.bi_flag & ~FLUSHRW)
4460 4485 return (EINVAL);
4461 4486 while (!(mp = allocb(2, BPRI_HI))) {
4462 4487 if (error = strwaitbuf(2, BPRI_HI))
4463 4488 return (error);
4464 4489 }
4465 4490 mp->b_datap->db_type = M_FLUSH;
4466 4491 *mp->b_wptr++ = binfo.bi_flag | FLUSHBAND;
4467 4492 *mp->b_wptr++ = binfo.bi_pri;
4468 4493 putnext(stp->sd_wrq, mp);
4469 4494 /*
4470 4495 * Send down an unsupported ioctl and wait for the nack
4471 4496 * in order to allow the M_FLUSH to propagate back
4472 4497 * up to the stream head.
4473 4498 * Replaces if (qready()) runqueues();
4474 4499 */
4475 4500 strioc.ic_cmd = -1; /* The unsupported ioctl */
4476 4501 strioc.ic_timout = 0;
4477 4502 strioc.ic_len = 0;
4478 4503 strioc.ic_dp = NULL;
4479 4504 (void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
4480 4505 *rvalp = 0;
4481 4506 return (0);
4482 4507 }
4483 4508
4484 4509 case I_SRDOPT:
4485 4510 /*
4486 4511 * Set read options
4487 4512 *
4488 4513 * RNORM - default stream mode
4489 4514 * RMSGN - message no discard
4490 4515 * RMSGD - message discard
4491 4516 * RPROTNORM - fail read with EBADMSG for M_[PC]PROTOs
4492 4517 * RPROTDAT - convert M_[PC]PROTOs to M_DATAs
4493 4518 * RPROTDIS - discard M_[PC]PROTOs and retain M_DATAs
4494 4519 */
4495 4520 if (arg & ~(RMODEMASK | RPROTMASK))
4496 4521 return (EINVAL);
4497 4522
4498 4523 if ((arg & (RMSGD|RMSGN)) == (RMSGD|RMSGN))
4499 4524 return (EINVAL);
4500 4525
4501 4526 mutex_enter(&stp->sd_lock);
4502 4527 switch (arg & RMODEMASK) {
4503 4528 case RNORM:
4504 4529 stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
4505 4530 break;
4506 4531 case RMSGD:
4507 4532 stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGNODIS) |
4508 4533 RD_MSGDIS;
4509 4534 break;
4510 4535 case RMSGN:
4511 4536 stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGDIS) |
4512 4537 RD_MSGNODIS;
4513 4538 break;
4514 4539 }
4515 4540
4516 4541 switch (arg & RPROTMASK) {
4517 4542 case RPROTNORM:
4518 4543 stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
4519 4544 break;
4520 4545
4521 4546 case RPROTDAT:
4522 4547 stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDIS) |
4523 4548 RD_PROTDAT);
4524 4549 break;
4525 4550
4526 4551 case RPROTDIS:
4527 4552 stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDAT) |
4528 4553 RD_PROTDIS);
4529 4554 break;
4530 4555 }
4531 4556 mutex_exit(&stp->sd_lock);
4532 4557 return (0);
4533 4558
4534 4559 case I_GRDOPT:
4535 4560 /*
4536 4561 * Get read option and return the value
4537 4562 * to spot pointed to by arg
4538 4563 */
4539 4564 {
4540 4565 int rdopt;
4541 4566
4542 4567 rdopt = ((stp->sd_read_opt & RD_MSGDIS) ? RMSGD :
4543 4568 ((stp->sd_read_opt & RD_MSGNODIS) ? RMSGN : RNORM));
4544 4569 rdopt |= ((stp->sd_read_opt & RD_PROTDAT) ? RPROTDAT :
4545 4570 ((stp->sd_read_opt & RD_PROTDIS) ? RPROTDIS : RPROTNORM));
4546 4571
4547 4572 return (strcopyout(&rdopt, (void *)arg, sizeof (int),
4548 4573 copyflag));
4549 4574 }
4550 4575
4551 4576 case I_SERROPT:
4552 4577 /*
4553 4578 * Set error options
4554 4579 *
4555 4580 * RERRNORM - persistent read errors
4556 4581 * RERRNONPERSIST - non-persistent read errors
4557 4582 * WERRNORM - persistent write errors
4558 4583 * WERRNONPERSIST - non-persistent write errors
4559 4584 */
4560 4585 if (arg & ~(RERRMASK | WERRMASK))
4561 4586 return (EINVAL);
4562 4587
4563 4588 mutex_enter(&stp->sd_lock);
4564 4589 switch (arg & RERRMASK) {
4565 4590 case RERRNORM:
4566 4591 stp->sd_flag &= ~STRDERRNONPERSIST;
4567 4592 break;
4568 4593 case RERRNONPERSIST:
4569 4594 stp->sd_flag |= STRDERRNONPERSIST;
4570 4595 break;
4571 4596 }
4572 4597 switch (arg & WERRMASK) {
4573 4598 case WERRNORM:
4574 4599 stp->sd_flag &= ~STWRERRNONPERSIST;
4575 4600 break;
4576 4601 case WERRNONPERSIST:
4577 4602 stp->sd_flag |= STWRERRNONPERSIST;
4578 4603 break;
4579 4604 }
4580 4605 mutex_exit(&stp->sd_lock);
4581 4606 return (0);
4582 4607
4583 4608 case I_GERROPT:
4584 4609 /*
4585 4610 * Get error option and return the value
4586 4611 * to spot pointed to by arg
4587 4612 */
4588 4613 {
4589 4614 int erropt = 0;
4590 4615
4591 4616 erropt |= (stp->sd_flag & STRDERRNONPERSIST) ? RERRNONPERSIST :
4592 4617 RERRNORM;
4593 4618 erropt |= (stp->sd_flag & STWRERRNONPERSIST) ? WERRNONPERSIST :
4594 4619 WERRNORM;
4595 4620 return (strcopyout(&erropt, (void *)arg, sizeof (int),
4596 4621 copyflag));
4597 4622 }
4598 4623
4599 4624 case I_SETSIG:
4600 4625 /*
4601 4626 * Register the calling proc to receive the SIGPOLL
4602 4627 * signal based on the events given in arg. If
4603 4628 * arg is zero, remove the proc from register list.
4604 4629 */
4605 4630 {
4606 4631 strsig_t *ssp, *pssp;
4607 4632 struct pid *pidp;
4608 4633
4609 4634 pssp = NULL;
4610 4635 pidp = curproc->p_pidp;
4611 4636 /*
4612 4637 * Hold sd_lock to prevent traversal of sd_siglist while
4613 4638 * it is modified.
4614 4639 */
4615 4640 mutex_enter(&stp->sd_lock);
4616 4641 for (ssp = stp->sd_siglist; ssp && (ssp->ss_pidp != pidp);
4617 4642 pssp = ssp, ssp = ssp->ss_next)
4618 4643 ;
4619 4644
4620 4645 if (arg) {
4621 4646 if (arg & ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
4622 4647 S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
4623 4648 mutex_exit(&stp->sd_lock);
4624 4649 return (EINVAL);
4625 4650 }
4626 4651 if ((arg & S_BANDURG) && !(arg & S_RDBAND)) {
4627 4652 mutex_exit(&stp->sd_lock);
4628 4653 return (EINVAL);
4629 4654 }
4630 4655
4631 4656 /*
4632 4657 * If proc not already registered, add it
4633 4658 * to list.
4634 4659 */
4635 4660 if (!ssp) {
4636 4661 ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
4637 4662 ssp->ss_pidp = pidp;
4638 4663 ssp->ss_pid = pidp->pid_id;
4639 4664 ssp->ss_next = NULL;
4640 4665 if (pssp)
4641 4666 pssp->ss_next = ssp;
4642 4667 else
4643 4668 stp->sd_siglist = ssp;
4644 4669 mutex_enter(&pidlock);
4645 4670 PID_HOLD(pidp);
4646 4671 mutex_exit(&pidlock);
4647 4672 }
4648 4673
4649 4674 /*
4650 4675 * Set events.
4651 4676 */
4652 4677 ssp->ss_events = (int)arg;
4653 4678 } else {
4654 4679 /*
4655 4680 * Remove proc from register list.
4656 4681 */
4657 4682 if (ssp) {
4658 4683 mutex_enter(&pidlock);
4659 4684 PID_RELE(pidp);
4660 4685 mutex_exit(&pidlock);
4661 4686 if (pssp)
4662 4687 pssp->ss_next = ssp->ss_next;
4663 4688 else
4664 4689 stp->sd_siglist = ssp->ss_next;
4665 4690 kmem_free(ssp, sizeof (strsig_t));
4666 4691 } else {
4667 4692 mutex_exit(&stp->sd_lock);
4668 4693 return (EINVAL);
4669 4694 }
4670 4695 }
4671 4696
4672 4697 /*
4673 4698 * Recalculate OR of sig events.
4674 4699 */
4675 4700 stp->sd_sigflags = 0;
4676 4701 for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
4677 4702 stp->sd_sigflags |= ssp->ss_events;
4678 4703 mutex_exit(&stp->sd_lock);
4679 4704 return (0);
4680 4705 }
4681 4706
4682 4707 case I_GETSIG:
4683 4708 /*
4684 4709 * Return (in arg) the current registration of events
4685 4710 * for which the calling proc is to be signaled.
4686 4711 */
4687 4712 {
4688 4713 struct strsig *ssp;
4689 4714 struct pid *pidp;
4690 4715
4691 4716 pidp = curproc->p_pidp;
4692 4717 mutex_enter(&stp->sd_lock);
4693 4718 for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
4694 4719 if (ssp->ss_pidp == pidp) {
4695 4720 error = strcopyout(&ssp->ss_events, (void *)arg,
4696 4721 sizeof (int), copyflag);
4697 4722 mutex_exit(&stp->sd_lock);
4698 4723 return (error);
4699 4724 }
4700 4725 mutex_exit(&stp->sd_lock);
4701 4726 return (EINVAL);
4702 4727 }
4703 4728
4704 4729 case I_ESETSIG:
4705 4730 /*
4706 4731 * Register the ss_pid to receive the SIGPOLL
4707 4732 * signal based on the events is ss_events arg. If
4708 4733 * ss_events is zero, remove the proc from register list.
4709 4734 */
4710 4735 {
4711 4736 struct strsig *ssp, *pssp;
4712 4737 struct proc *proc;
4713 4738 struct pid *pidp;
4714 4739 pid_t pid;
4715 4740 struct strsigset ss;
4716 4741
4717 4742 error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
4718 4743 if (error)
4719 4744 return (error);
4720 4745
4721 4746 pid = ss.ss_pid;
4722 4747
4723 4748 if (ss.ss_events != 0) {
4724 4749 /*
4725 4750 * Permissions check by sending signal 0.
4726 4751 * Note that when kill fails it does a set_errno
4727 4752 * causing the system call to fail.
4728 4753 */
4729 4754 error = kill(pid, 0);
4730 4755 if (error) {
4731 4756 return (error);
4732 4757 }
4733 4758 }
4734 4759 mutex_enter(&pidlock);
4735 4760 if (pid == 0)
4736 4761 proc = curproc;
4737 4762 else if (pid < 0)
4738 4763 proc = pgfind(-pid);
4739 4764 else
4740 4765 proc = prfind(pid);
4741 4766 if (proc == NULL) {
4742 4767 mutex_exit(&pidlock);
4743 4768 return (ESRCH);
4744 4769 }
4745 4770 if (pid < 0)
4746 4771 pidp = proc->p_pgidp;
4747 4772 else
4748 4773 pidp = proc->p_pidp;
4749 4774 ASSERT(pidp);
4750 4775 /*
4751 4776 * Get a hold on the pid structure while referencing it.
4752 4777 * There is a separate PID_HOLD should it be inserted
4753 4778 * in the list below.
4754 4779 */
4755 4780 PID_HOLD(pidp);
4756 4781 mutex_exit(&pidlock);
4757 4782
4758 4783 pssp = NULL;
4759 4784 /*
4760 4785 * Hold sd_lock to prevent traversal of sd_siglist while
4761 4786 * it is modified.
4762 4787 */
4763 4788 mutex_enter(&stp->sd_lock);
4764 4789 for (ssp = stp->sd_siglist; ssp && (ssp->ss_pid != pid);
4765 4790 pssp = ssp, ssp = ssp->ss_next)
4766 4791 ;
4767 4792
4768 4793 if (ss.ss_events) {
4769 4794 if (ss.ss_events &
4770 4795 ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
4771 4796 S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
4772 4797 mutex_exit(&stp->sd_lock);
4773 4798 mutex_enter(&pidlock);
4774 4799 PID_RELE(pidp);
4775 4800 mutex_exit(&pidlock);
4776 4801 return (EINVAL);
4777 4802 }
4778 4803 if ((ss.ss_events & S_BANDURG) &&
4779 4804 !(ss.ss_events & S_RDBAND)) {
4780 4805 mutex_exit(&stp->sd_lock);
4781 4806 mutex_enter(&pidlock);
4782 4807 PID_RELE(pidp);
4783 4808 mutex_exit(&pidlock);
4784 4809 return (EINVAL);
4785 4810 }
4786 4811
4787 4812 /*
4788 4813 * If proc not already registered, add it
4789 4814 * to list.
4790 4815 */
4791 4816 if (!ssp) {
4792 4817 ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
4793 4818 ssp->ss_pidp = pidp;
4794 4819 ssp->ss_pid = pid;
4795 4820 ssp->ss_next = NULL;
4796 4821 if (pssp)
4797 4822 pssp->ss_next = ssp;
4798 4823 else
4799 4824 stp->sd_siglist = ssp;
4800 4825 mutex_enter(&pidlock);
4801 4826 PID_HOLD(pidp);
4802 4827 mutex_exit(&pidlock);
4803 4828 }
4804 4829
4805 4830 /*
4806 4831 * Set events.
4807 4832 */
4808 4833 ssp->ss_events = ss.ss_events;
4809 4834 } else {
4810 4835 /*
4811 4836 * Remove proc from register list.
4812 4837 */
4813 4838 if (ssp) {
4814 4839 mutex_enter(&pidlock);
4815 4840 PID_RELE(pidp);
4816 4841 mutex_exit(&pidlock);
4817 4842 if (pssp)
4818 4843 pssp->ss_next = ssp->ss_next;
4819 4844 else
4820 4845 stp->sd_siglist = ssp->ss_next;
4821 4846 kmem_free(ssp, sizeof (strsig_t));
4822 4847 } else {
4823 4848 mutex_exit(&stp->sd_lock);
4824 4849 mutex_enter(&pidlock);
4825 4850 PID_RELE(pidp);
4826 4851 mutex_exit(&pidlock);
4827 4852 return (EINVAL);
4828 4853 }
4829 4854 }
4830 4855
4831 4856 /*
4832 4857 * Recalculate OR of sig events.
4833 4858 */
4834 4859 stp->sd_sigflags = 0;
4835 4860 for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
4836 4861 stp->sd_sigflags |= ssp->ss_events;
4837 4862 mutex_exit(&stp->sd_lock);
4838 4863 mutex_enter(&pidlock);
4839 4864 PID_RELE(pidp);
4840 4865 mutex_exit(&pidlock);
4841 4866 return (0);
4842 4867 }
4843 4868
4844 4869 case I_EGETSIG:
4845 4870 /*
4846 4871 * Return (in arg) the current registration of events
4847 4872 * for which the calling proc is to be signaled.
4848 4873 */
4849 4874 {
4850 4875 struct strsig *ssp;
4851 4876 struct proc *proc;
4852 4877 pid_t pid;
4853 4878 struct pid *pidp;
4854 4879 struct strsigset ss;
4855 4880
4856 4881 error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
4857 4882 if (error)
4858 4883 return (error);
4859 4884
4860 4885 pid = ss.ss_pid;
4861 4886 mutex_enter(&pidlock);
4862 4887 if (pid == 0)
4863 4888 proc = curproc;
4864 4889 else if (pid < 0)
4865 4890 proc = pgfind(-pid);
4866 4891 else
4867 4892 proc = prfind(pid);
4868 4893 if (proc == NULL) {
4869 4894 mutex_exit(&pidlock);
4870 4895 return (ESRCH);
4871 4896 }
4872 4897 if (pid < 0)
4873 4898 pidp = proc->p_pgidp;
4874 4899 else
4875 4900 pidp = proc->p_pidp;
4876 4901
4877 4902 /* Prevent the pidp from being reassigned */
4878 4903 PID_HOLD(pidp);
4879 4904 mutex_exit(&pidlock);
4880 4905
4881 4906 mutex_enter(&stp->sd_lock);
4882 4907 for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
4883 4908 if (ssp->ss_pid == pid) {
4884 4909 ss.ss_pid = ssp->ss_pid;
4885 4910 ss.ss_events = ssp->ss_events;
4886 4911 error = strcopyout(&ss, (void *)arg,
4887 4912 sizeof (struct strsigset), copyflag);
4888 4913 mutex_exit(&stp->sd_lock);
4889 4914 mutex_enter(&pidlock);
4890 4915 PID_RELE(pidp);
4891 4916 mutex_exit(&pidlock);
4892 4917 return (error);
4893 4918 }
4894 4919 mutex_exit(&stp->sd_lock);
4895 4920 mutex_enter(&pidlock);
4896 4921 PID_RELE(pidp);
4897 4922 mutex_exit(&pidlock);
4898 4923 return (EINVAL);
4899 4924 }
4900 4925
4901 4926 case I_PEEK:
4902 4927 {
4903 4928 STRUCT_DECL(strpeek, strpeek);
4904 4929 size_t n;
4905 4930 mblk_t *fmp, *tmp_mp = NULL;
4906 4931
4907 4932 STRUCT_INIT(strpeek, flag);
4908 4933
4909 4934 error = strcopyin((void *)arg, STRUCT_BUF(strpeek),
4910 4935 STRUCT_SIZE(strpeek), copyflag);
4911 4936 if (error)
4912 4937 return (error);
4913 4938
4914 4939 mutex_enter(QLOCK(rdq));
4915 4940 /*
4916 4941 * Skip the invalid messages
4917 4942 */
4918 4943 for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
4919 4944 if (mp->b_datap->db_type != M_SIG)
4920 4945 break;
4921 4946
4922 4947 /*
4923 4948 * If user has requested to peek at a high priority message
4924 4949 * and first message is not, return 0
4925 4950 */
4926 4951 if (mp != NULL) {
4927 4952 if ((STRUCT_FGET(strpeek, flags) & RS_HIPRI) &&
4928 4953 queclass(mp) == QNORM) {
4929 4954 *rvalp = 0;
4930 4955 mutex_exit(QLOCK(rdq));
4931 4956 return (0);
4932 4957 }
4933 4958 } else if (stp->sd_struiordq == NULL ||
4934 4959 (STRUCT_FGET(strpeek, flags) & RS_HIPRI)) {
4935 4960 /*
4936 4961 * No mblks to look at at the streamhead and
4937 4962 * 1). This isn't a synch stream or
4938 4963 * 2). This is a synch stream but caller wants high
4939 4964 * priority messages which is not supported by
4940 4965 * the synch stream. (it only supports QNORM)
4941 4966 */
4942 4967 *rvalp = 0;
4943 4968 mutex_exit(QLOCK(rdq));
4944 4969 return (0);
4945 4970 }
4946 4971
4947 4972 fmp = mp;
4948 4973
4949 4974 if (mp && mp->b_datap->db_type == M_PASSFP) {
4950 4975 mutex_exit(QLOCK(rdq));
4951 4976 return (EBADMSG);
4952 4977 }
4953 4978
4954 4979 ASSERT(mp == NULL || mp->b_datap->db_type == M_PCPROTO ||
4955 4980 mp->b_datap->db_type == M_PROTO ||
4956 4981 mp->b_datap->db_type == M_DATA);
4957 4982
4958 4983 if (mp && mp->b_datap->db_type == M_PCPROTO) {
4959 4984 STRUCT_FSET(strpeek, flags, RS_HIPRI);
4960 4985 } else {
4961 4986 STRUCT_FSET(strpeek, flags, 0);
4962 4987 }
4963 4988
4964 4989
4965 4990 if (mp && ((tmp_mp = dupmsg(mp)) == NULL)) {
4966 4991 mutex_exit(QLOCK(rdq));
4967 4992 return (ENOSR);
4968 4993 }
4969 4994 mutex_exit(QLOCK(rdq));
4970 4995
4971 4996 /*
4972 4997 * set mp = tmp_mp, so that I_PEEK processing can continue.
4973 4998 * tmp_mp is used to free the dup'd message.
4974 4999 */
4975 5000 mp = tmp_mp;
4976 5001
4977 5002 uio.uio_fmode = 0;
4978 5003 uio.uio_extflg = UIO_COPY_CACHED;
4979 5004 uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
4980 5005 UIO_SYSSPACE;
4981 5006 uio.uio_limit = 0;
4982 5007 /*
4983 5008 * First process PROTO blocks, if any.
4984 5009 * If user doesn't want to get ctl info by setting maxlen <= 0,
4985 5010 * then set len to -1/0 and skip control blocks part.
4986 5011 */
4987 5012 if (STRUCT_FGET(strpeek, ctlbuf.maxlen) < 0)
4988 5013 STRUCT_FSET(strpeek, ctlbuf.len, -1);
4989 5014 else if (STRUCT_FGET(strpeek, ctlbuf.maxlen) == 0)
4990 5015 STRUCT_FSET(strpeek, ctlbuf.len, 0);
4991 5016 else {
4992 5017 int ctl_part = 0;
4993 5018
4994 5019 iov.iov_base = STRUCT_FGETP(strpeek, ctlbuf.buf);
4995 5020 iov.iov_len = STRUCT_FGET(strpeek, ctlbuf.maxlen);
4996 5021 uio.uio_iov = &iov;
4997 5022 uio.uio_resid = iov.iov_len;
4998 5023 uio.uio_loffset = 0;
4999 5024 uio.uio_iovcnt = 1;
5000 5025 while (mp && mp->b_datap->db_type != M_DATA &&
5001 5026 uio.uio_resid >= 0) {
5002 5027 ASSERT(STRUCT_FGET(strpeek, flags) == 0 ?
5003 5028 mp->b_datap->db_type == M_PROTO :
5004 5029 mp->b_datap->db_type == M_PCPROTO);
5005 5030
5006 5031 if ((n = MIN(uio.uio_resid,
5007 5032 mp->b_wptr - mp->b_rptr)) != 0 &&
5008 5033 (error = uiomove((char *)mp->b_rptr, n,
5009 5034 UIO_READ, &uio)) != 0) {
5010 5035 freemsg(tmp_mp);
5011 5036 return (error);
5012 5037 }
5013 5038 ctl_part = 1;
5014 5039 mp = mp->b_cont;
5015 5040 }
5016 5041 /* No ctl message */
5017 5042 if (ctl_part == 0)
5018 5043 STRUCT_FSET(strpeek, ctlbuf.len, -1);
5019 5044 else
5020 5045 STRUCT_FSET(strpeek, ctlbuf.len,
5021 5046 STRUCT_FGET(strpeek, ctlbuf.maxlen) -
5022 5047 uio.uio_resid);
5023 5048 }
5024 5049
5025 5050 /*
5026 5051 * Now process DATA blocks, if any.
5027 5052 * If user doesn't want to get data info by setting maxlen <= 0,
5028 5053 * then set len to -1/0 and skip data blocks part.
5029 5054 */
5030 5055 if (STRUCT_FGET(strpeek, databuf.maxlen) < 0)
5031 5056 STRUCT_FSET(strpeek, databuf.len, -1);
5032 5057 else if (STRUCT_FGET(strpeek, databuf.maxlen) == 0)
5033 5058 STRUCT_FSET(strpeek, databuf.len, 0);
5034 5059 else {
5035 5060 int data_part = 0;
5036 5061
5037 5062 iov.iov_base = STRUCT_FGETP(strpeek, databuf.buf);
5038 5063 iov.iov_len = STRUCT_FGET(strpeek, databuf.maxlen);
5039 5064 uio.uio_iov = &iov;
5040 5065 uio.uio_resid = iov.iov_len;
5041 5066 uio.uio_loffset = 0;
5042 5067 uio.uio_iovcnt = 1;
5043 5068 while (mp && uio.uio_resid) {
5044 5069 if (mp->b_datap->db_type == M_DATA) {
5045 5070 if ((n = MIN(uio.uio_resid,
5046 5071 mp->b_wptr - mp->b_rptr)) != 0 &&
5047 5072 (error = uiomove((char *)mp->b_rptr,
5048 5073 n, UIO_READ, &uio)) != 0) {
5049 5074 freemsg(tmp_mp);
5050 5075 return (error);
5051 5076 }
5052 5077 data_part = 1;
5053 5078 }
5054 5079 ASSERT(data_part == 0 ||
5055 5080 mp->b_datap->db_type == M_DATA);
5056 5081 mp = mp->b_cont;
5057 5082 }
5058 5083 /* No data message */
5059 5084 if (data_part == 0)
5060 5085 STRUCT_FSET(strpeek, databuf.len, -1);
5061 5086 else
5062 5087 STRUCT_FSET(strpeek, databuf.len,
5063 5088 STRUCT_FGET(strpeek, databuf.maxlen) -
5064 5089 uio.uio_resid);
5065 5090 }
5066 5091 freemsg(tmp_mp);
5067 5092
5068 5093 /*
5069 5094 * It is a synch stream and user wants to get
5070 5095 * data (maxlen > 0).
5071 5096 * uio setup is done by the codes that process DATA
5072 5097 * blocks above.
5073 5098 */
5074 5099 if ((fmp == NULL) && STRUCT_FGET(strpeek, databuf.maxlen) > 0) {
5075 5100 infod_t infod;
5076 5101
5077 5102 infod.d_cmd = INFOD_COPYOUT;
5078 5103 infod.d_res = 0;
5079 5104 infod.d_uiop = &uio;
5080 5105 error = infonext(rdq, &infod);
5081 5106 if (error == EINVAL || error == EBUSY)
5082 5107 error = 0;
5083 5108 if (error)
5084 5109 return (error);
5085 5110 STRUCT_FSET(strpeek, databuf.len, STRUCT_FGET(strpeek,
5086 5111 databuf.maxlen) - uio.uio_resid);
5087 5112 if (STRUCT_FGET(strpeek, databuf.len) == 0) {
5088 5113 /*
5089 5114 * No data found by the infonext().
5090 5115 */
5091 5116 STRUCT_FSET(strpeek, databuf.len, -1);
5092 5117 }
5093 5118 }
5094 5119 error = strcopyout(STRUCT_BUF(strpeek), (void *)arg,
5095 5120 STRUCT_SIZE(strpeek), copyflag);
5096 5121 if (error) {
5097 5122 return (error);
5098 5123 }
5099 5124 /*
5100 5125 * If there is no message retrieved, set return code to 0
5101 5126 * otherwise, set it to 1.
5102 5127 */
5103 5128 if (STRUCT_FGET(strpeek, ctlbuf.len) == -1 &&
5104 5129 STRUCT_FGET(strpeek, databuf.len) == -1)
5105 5130 *rvalp = 0;
5106 5131 else
5107 5132 *rvalp = 1;
5108 5133 return (0);
5109 5134 }
5110 5135
5111 5136 case I_FDINSERT:
5112 5137 {
5113 5138 STRUCT_DECL(strfdinsert, strfdinsert);
5114 5139 struct file *resftp;
5115 5140 struct stdata *resstp;
5116 5141 t_uscalar_t ival;
5117 5142 ssize_t msgsize;
5118 5143 struct strbuf mctl;
5119 5144
5120 5145 STRUCT_INIT(strfdinsert, flag);
5121 5146 if (stp->sd_flag & STRHUP)
5122 5147 return (ENXIO);
5123 5148 /*
5124 5149 * STRDERR, STWRERR and STPLEX tested above.
5125 5150 */
5126 5151 error = strcopyin((void *)arg, STRUCT_BUF(strfdinsert),
5127 5152 STRUCT_SIZE(strfdinsert), copyflag);
5128 5153 if (error)
5129 5154 return (error);
5130 5155
5131 5156 if (STRUCT_FGET(strfdinsert, offset) < 0 ||
5132 5157 (STRUCT_FGET(strfdinsert, offset) %
5133 5158 sizeof (t_uscalar_t)) != 0)
5134 5159 return (EINVAL);
5135 5160 if ((resftp = getf(STRUCT_FGET(strfdinsert, fildes))) != NULL) {
5136 5161 if ((resstp = resftp->f_vnode->v_stream) == NULL) {
5137 5162 releasef(STRUCT_FGET(strfdinsert, fildes));
5138 5163 return (EINVAL);
5139 5164 }
5140 5165 } else
5141 5166 return (EINVAL);
5142 5167
5143 5168 mutex_enter(&resstp->sd_lock);
5144 5169 if (resstp->sd_flag & (STRDERR|STWRERR|STRHUP|STPLEX)) {
5145 5170 error = strgeterr(resstp,
5146 5171 STRDERR|STWRERR|STRHUP|STPLEX, 0);
5147 5172 if (error != 0) {
5148 5173 mutex_exit(&resstp->sd_lock);
5149 5174 releasef(STRUCT_FGET(strfdinsert, fildes));
5150 5175 return (error);
5151 5176 }
5152 5177 }
5153 5178 mutex_exit(&resstp->sd_lock);
5154 5179
5155 5180 #ifdef _ILP32
5156 5181 {
5157 5182 queue_t *q;
5158 5183 queue_t *mate = NULL;
5159 5184
5160 5185 /* get read queue of stream terminus */
5161 5186 claimstr(resstp->sd_wrq);
5162 5187 for (q = resstp->sd_wrq->q_next; q->q_next != NULL;
5163 5188 q = q->q_next)
5164 5189 if (!STRMATED(resstp) && STREAM(q) != resstp &&
5165 5190 mate == NULL) {
5166 5191 ASSERT(q->q_qinfo->qi_srvp);
5167 5192 ASSERT(_OTHERQ(q)->q_qinfo->qi_srvp);
5168 5193 claimstr(q);
5169 5194 mate = q;
5170 5195 }
5171 5196 q = _RD(q);
5172 5197 if (mate)
5173 5198 releasestr(mate);
5174 5199 releasestr(resstp->sd_wrq);
5175 5200 ival = (t_uscalar_t)q;
5176 5201 }
5177 5202 #else
5178 5203 ival = (t_uscalar_t)getminor(resftp->f_vnode->v_rdev);
5179 5204 #endif /* _ILP32 */
5180 5205
5181 5206 if (STRUCT_FGET(strfdinsert, ctlbuf.len) <
5182 5207 STRUCT_FGET(strfdinsert, offset) + sizeof (t_uscalar_t)) {
5183 5208 releasef(STRUCT_FGET(strfdinsert, fildes));
5184 5209 return (EINVAL);
5185 5210 }
5186 5211
5187 5212 /*
5188 5213 * Check for legal flag value.
5189 5214 */
5190 5215 if (STRUCT_FGET(strfdinsert, flags) & ~RS_HIPRI) {
5191 5216 releasef(STRUCT_FGET(strfdinsert, fildes));
5192 5217 return (EINVAL);
5193 5218 }
5194 5219
5195 5220 /* get these values from those cached in the stream head */
5196 5221 mutex_enter(QLOCK(stp->sd_wrq));
5197 5222 rmin = stp->sd_qn_minpsz;
5198 5223 rmax = stp->sd_qn_maxpsz;
5199 5224 mutex_exit(QLOCK(stp->sd_wrq));
5200 5225
5201 5226 /*
5202 5227 * Make sure ctl and data sizes together fall within
5203 5228 * the limits of the max and min receive packet sizes
5204 5229 * and do not exceed system limit. A negative data
5205 5230 * length means that no data part is to be sent.
5206 5231 */
5207 5232 ASSERT((rmax >= 0) || (rmax == INFPSZ));
5208 5233 if (rmax == 0) {
5209 5234 releasef(STRUCT_FGET(strfdinsert, fildes));
5210 5235 return (ERANGE);
5211 5236 }
5212 5237 if ((msgsize = STRUCT_FGET(strfdinsert, databuf.len)) < 0)
5213 5238 msgsize = 0;
5214 5239 if ((msgsize < rmin) ||
5215 5240 ((msgsize > rmax) && (rmax != INFPSZ)) ||
5216 5241 (STRUCT_FGET(strfdinsert, ctlbuf.len) > strctlsz)) {
5217 5242 releasef(STRUCT_FGET(strfdinsert, fildes));
5218 5243 return (ERANGE);
5219 5244 }
5220 5245
5221 5246 mutex_enter(&stp->sd_lock);
5222 5247 while (!(STRUCT_FGET(strfdinsert, flags) & RS_HIPRI) &&
5223 5248 !canputnext(stp->sd_wrq)) {
5224 5249 if ((error = strwaitq(stp, WRITEWAIT, (ssize_t)0,
5225 5250 flag, -1, &done)) != 0 || done) {
5226 5251 mutex_exit(&stp->sd_lock);
5227 5252 releasef(STRUCT_FGET(strfdinsert, fildes));
5228 5253 return (error);
5229 5254 }
5230 5255 if ((error = i_straccess(stp, access)) != 0) {
5231 5256 mutex_exit(&stp->sd_lock);
5232 5257 releasef(
5233 5258 STRUCT_FGET(strfdinsert, fildes));
5234 5259 return (error);
5235 5260 }
5236 5261 }
5237 5262 mutex_exit(&stp->sd_lock);
5238 5263
5239 5264 /*
5240 5265 * Copy strfdinsert.ctlbuf into native form of
5241 5266 * ctlbuf to pass down into strmakemsg().
5242 5267 */
5243 5268 mctl.maxlen = STRUCT_FGET(strfdinsert, ctlbuf.maxlen);
5244 5269 mctl.len = STRUCT_FGET(strfdinsert, ctlbuf.len);
5245 5270 mctl.buf = STRUCT_FGETP(strfdinsert, ctlbuf.buf);
5246 5271
5247 5272 iov.iov_base = STRUCT_FGETP(strfdinsert, databuf.buf);
5248 5273 iov.iov_len = STRUCT_FGET(strfdinsert, databuf.len);
5249 5274 uio.uio_iov = &iov;
5250 5275 uio.uio_iovcnt = 1;
5251 5276 uio.uio_loffset = 0;
5252 5277 uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
5253 5278 UIO_SYSSPACE;
5254 5279 uio.uio_fmode = 0;
5255 5280 uio.uio_extflg = UIO_COPY_CACHED;
5256 5281 uio.uio_resid = iov.iov_len;
5257 5282 if ((error = strmakemsg(&mctl,
5258 5283 &msgsize, &uio, stp,
5259 5284 STRUCT_FGET(strfdinsert, flags), &mp)) != 0 || !mp) {
5260 5285 STRUCT_FSET(strfdinsert, databuf.len, msgsize);
5261 5286 releasef(STRUCT_FGET(strfdinsert, fildes));
5262 5287 return (error);
5263 5288 }
5264 5289
5265 5290 STRUCT_FSET(strfdinsert, databuf.len, msgsize);
5266 5291
5267 5292 /*
5268 5293 * Place the possibly reencoded queue pointer 'offset' bytes
5269 5294 * from the start of the control portion of the message.
5270 5295 */
5271 5296 *((t_uscalar_t *)(mp->b_rptr +
5272 5297 STRUCT_FGET(strfdinsert, offset))) = ival;
5273 5298
5274 5299 /*
5275 5300 * Put message downstream.
5276 5301 */
5277 5302 stream_willservice(stp);
5278 5303 putnext(stp->sd_wrq, mp);
5279 5304 stream_runservice(stp);
5280 5305 releasef(STRUCT_FGET(strfdinsert, fildes));
5281 5306 return (error);
5282 5307 }
5283 5308
5284 5309 case I_SENDFD:
5285 5310 {
5286 5311 struct file *fp;
5287 5312
5288 5313 if ((fp = getf((int)arg)) == NULL)
5289 5314 return (EBADF);
5290 5315 error = do_sendfp(stp, fp, crp);
5291 5316 if (auditing) {
5292 5317 audit_fdsend((int)arg, fp, error);
5293 5318 }
5294 5319 releasef((int)arg);
5295 5320 return (error);
5296 5321 }
5297 5322
5298 5323 case I_RECVFD:
5299 5324 case I_E_RECVFD:
5300 5325 {
5301 5326 struct k_strrecvfd *srf;
5302 5327 int i, fd;
5303 5328
5304 5329 mutex_enter(&stp->sd_lock);
5305 5330 while (!(mp = getq(rdq))) {
5306 5331 if (stp->sd_flag & (STRHUP|STREOF)) {
5307 5332 mutex_exit(&stp->sd_lock);
5308 5333 return (ENXIO);
5309 5334 }
5310 5335 if ((error = strwaitq(stp, GETWAIT, (ssize_t)0,
5311 5336 flag, -1, &done)) != 0 || done) {
5312 5337 mutex_exit(&stp->sd_lock);
5313 5338 return (error);
5314 5339 }
5315 5340 if ((error = i_straccess(stp, access)) != 0) {
5316 5341 mutex_exit(&stp->sd_lock);
5317 5342 return (error);
5318 5343 }
5319 5344 }
5320 5345 if (mp->b_datap->db_type != M_PASSFP) {
5321 5346 putback(stp, rdq, mp, mp->b_band);
5322 5347 mutex_exit(&stp->sd_lock);
5323 5348 return (EBADMSG);
5324 5349 }
5325 5350 mutex_exit(&stp->sd_lock);
5326 5351
5327 5352 srf = (struct k_strrecvfd *)mp->b_rptr;
5328 5353 if ((fd = ufalloc(0)) == -1) {
5329 5354 mutex_enter(&stp->sd_lock);
5330 5355 putback(stp, rdq, mp, mp->b_band);
5331 5356 mutex_exit(&stp->sd_lock);
5332 5357 return (EMFILE);
5333 5358 }
5334 5359 if (cmd == I_RECVFD) {
5335 5360 struct o_strrecvfd ostrfd;
5336 5361
5337 5362 /* check to see if uid/gid values are too large. */
5338 5363
5339 5364 if (srf->uid > (o_uid_t)USHRT_MAX ||
5340 5365 srf->gid > (o_gid_t)USHRT_MAX) {
5341 5366 mutex_enter(&stp->sd_lock);
5342 5367 putback(stp, rdq, mp, mp->b_band);
5343 5368 mutex_exit(&stp->sd_lock);
5344 5369 setf(fd, NULL); /* release fd entry */
5345 5370 return (EOVERFLOW);
5346 5371 }
5347 5372
5348 5373 ostrfd.fd = fd;
5349 5374 ostrfd.uid = (o_uid_t)srf->uid;
5350 5375 ostrfd.gid = (o_gid_t)srf->gid;
5351 5376
5352 5377 /* Null the filler bits */
5353 5378 for (i = 0; i < 8; i++)
5354 5379 ostrfd.fill[i] = 0;
5355 5380
5356 5381 error = strcopyout(&ostrfd, (void *)arg,
5357 5382 sizeof (struct o_strrecvfd), copyflag);
5358 5383 } else { /* I_E_RECVFD */
5359 5384 struct strrecvfd strfd;
5360 5385
5361 5386 strfd.fd = fd;
5362 5387 strfd.uid = srf->uid;
5363 5388 strfd.gid = srf->gid;
5364 5389
5365 5390 /* null the filler bits */
5366 5391 for (i = 0; i < 8; i++)
5367 5392 strfd.fill[i] = 0;
5368 5393
5369 5394 error = strcopyout(&strfd, (void *)arg,
5370 5395 sizeof (struct strrecvfd), copyflag);
5371 5396 }
5372 5397
5373 5398 if (error) {
5374 5399 setf(fd, NULL); /* release fd entry */
5375 5400 mutex_enter(&stp->sd_lock);
5376 5401 putback(stp, rdq, mp, mp->b_band);
5377 5402 mutex_exit(&stp->sd_lock);
5378 5403 return (error);
5379 5404 }
5380 5405 if (auditing) {
5381 5406 audit_fdrecv(fd, srf->fp);
5382 5407 }
5383 5408
5384 5409 /*
5385 5410 * Always increment f_count since the freemsg() below will
5386 5411 * always call free_passfp() which performs a closef().
5387 5412 */
5388 5413 mutex_enter(&srf->fp->f_tlock);
5389 5414 srf->fp->f_count++;
5390 5415 mutex_exit(&srf->fp->f_tlock);
5391 5416 setf(fd, srf->fp);
5392 5417 freemsg(mp);
5393 5418 return (0);
5394 5419 }
5395 5420
5396 5421 case I_SWROPT:
5397 5422 /*
5398 5423 * Set/clear the write options. arg is a bit
5399 5424 * mask with any of the following bits set...
5400 5425 * SNDZERO - send zero length message
5401 5426 * SNDPIPE - send sigpipe to process if
5402 5427 * sd_werror is set and process is
5403 5428 * doing a write or putmsg.
5404 5429 * The new stream head write options should reflect
5405 5430 * what is in arg.
5406 5431 */
5407 5432 if (arg & ~(SNDZERO|SNDPIPE))
5408 5433 return (EINVAL);
5409 5434
5410 5435 mutex_enter(&stp->sd_lock);
5411 5436 stp->sd_wput_opt &= ~(SW_SIGPIPE|SW_SNDZERO);
5412 5437 if (arg & SNDZERO)
5413 5438 stp->sd_wput_opt |= SW_SNDZERO;
5414 5439 if (arg & SNDPIPE)
5415 5440 stp->sd_wput_opt |= SW_SIGPIPE;
5416 5441 mutex_exit(&stp->sd_lock);
5417 5442 return (0);
5418 5443
5419 5444 case I_GWROPT:
5420 5445 {
5421 5446 int wropt = 0;
5422 5447
5423 5448 if (stp->sd_wput_opt & SW_SNDZERO)
5424 5449 wropt |= SNDZERO;
5425 5450 if (stp->sd_wput_opt & SW_SIGPIPE)
5426 5451 wropt |= SNDPIPE;
5427 5452 return (strcopyout(&wropt, (void *)arg, sizeof (wropt),
5428 5453 copyflag));
5429 5454 }
5430 5455
5431 5456 case I_LIST:
5432 5457 /*
5433 5458 * Returns all the modules found on this stream,
5434 5459 * upto the driver. If argument is NULL, return the
5435 5460 * number of modules (including driver). If argument
5436 5461 * is not NULL, copy the names into the structure
5437 5462 * provided.
5438 5463 */
5439 5464
5440 5465 {
5441 5466 queue_t *q;
5442 5467 char *qname;
5443 5468 int i, nmods;
5444 5469 struct str_mlist *mlist;
5445 5470 STRUCT_DECL(str_list, strlist);
5446 5471
5447 5472 if (arg == NULL) { /* Return number of modules plus driver */
5448 5473 if (stp->sd_vnode->v_type == VFIFO)
5449 5474 *rvalp = stp->sd_pushcnt;
5450 5475 else
5451 5476 *rvalp = stp->sd_pushcnt + 1;
5452 5477 return (0);
5453 5478 }
5454 5479
5455 5480 STRUCT_INIT(strlist, flag);
5456 5481
5457 5482 error = strcopyin((void *)arg, STRUCT_BUF(strlist),
5458 5483 STRUCT_SIZE(strlist), copyflag);
5459 5484 if (error != 0)
5460 5485 return (error);
5461 5486
5462 5487 mlist = STRUCT_FGETP(strlist, sl_modlist);
5463 5488 nmods = STRUCT_FGET(strlist, sl_nmods);
5464 5489 if (nmods <= 0)
5465 5490 return (EINVAL);
5466 5491
5467 5492 claimstr(stp->sd_wrq);
5468 5493 q = stp->sd_wrq;
5469 5494 for (i = 0; i < nmods && _SAMESTR(q); i++, q = q->q_next) {
5470 5495 qname = Q2NAME(q->q_next);
5471 5496 error = strcopyout(qname, &mlist[i], strlen(qname) + 1,
5472 5497 copyflag);
5473 5498 if (error != 0) {
5474 5499 releasestr(stp->sd_wrq);
5475 5500 return (error);
5476 5501 }
5477 5502 }
5478 5503 releasestr(stp->sd_wrq);
5479 5504 return (strcopyout(&i, (void *)arg, sizeof (int), copyflag));
5480 5505 }
5481 5506
5482 5507 case I_CKBAND:
5483 5508 {
5484 5509 queue_t *q;
5485 5510 qband_t *qbp;
5486 5511
5487 5512 if ((arg < 0) || (arg >= NBAND))
5488 5513 return (EINVAL);
5489 5514 q = _RD(stp->sd_wrq);
5490 5515 mutex_enter(QLOCK(q));
5491 5516 if (arg > (int)q->q_nband) {
5492 5517 *rvalp = 0;
5493 5518 } else {
5494 5519 if (arg == 0) {
5495 5520 if (q->q_first)
5496 5521 *rvalp = 1;
5497 5522 else
5498 5523 *rvalp = 0;
5499 5524 } else {
5500 5525 qbp = q->q_bandp;
5501 5526 while (--arg > 0)
5502 5527 qbp = qbp->qb_next;
5503 5528 if (qbp->qb_first)
5504 5529 *rvalp = 1;
5505 5530 else
5506 5531 *rvalp = 0;
5507 5532 }
5508 5533 }
5509 5534 mutex_exit(QLOCK(q));
5510 5535 return (0);
5511 5536 }
5512 5537
5513 5538 case I_GETBAND:
5514 5539 {
5515 5540 int intpri;
5516 5541 queue_t *q;
5517 5542
5518 5543 q = _RD(stp->sd_wrq);
5519 5544 mutex_enter(QLOCK(q));
5520 5545 mp = q->q_first;
5521 5546 if (!mp) {
5522 5547 mutex_exit(QLOCK(q));
5523 5548 return (ENODATA);
5524 5549 }
5525 5550 intpri = (int)mp->b_band;
5526 5551 error = strcopyout(&intpri, (void *)arg, sizeof (int),
5527 5552 copyflag);
5528 5553 mutex_exit(QLOCK(q));
5529 5554 return (error);
5530 5555 }
5531 5556
5532 5557 case I_ATMARK:
5533 5558 {
5534 5559 queue_t *q;
5535 5560
5536 5561 if (arg & ~(ANYMARK|LASTMARK))
5537 5562 return (EINVAL);
5538 5563 q = _RD(stp->sd_wrq);
5539 5564 mutex_enter(&stp->sd_lock);
5540 5565 if ((stp->sd_flag & STRATMARK) && (arg == ANYMARK)) {
5541 5566 *rvalp = 1;
5542 5567 } else {
5543 5568 mutex_enter(QLOCK(q));
5544 5569 mp = q->q_first;
5545 5570
5546 5571 if (mp == NULL)
5547 5572 *rvalp = 0;
5548 5573 else if ((arg == ANYMARK) && (mp->b_flag & MSGMARK))
5549 5574 *rvalp = 1;
5550 5575 else if ((arg == LASTMARK) && (mp == stp->sd_mark))
5551 5576 *rvalp = 1;
5552 5577 else
5553 5578 *rvalp = 0;
5554 5579 mutex_exit(QLOCK(q));
5555 5580 }
5556 5581 mutex_exit(&stp->sd_lock);
5557 5582 return (0);
5558 5583 }
5559 5584
5560 5585 case I_CANPUT:
5561 5586 {
5562 5587 char band;
5563 5588
5564 5589 if ((arg < 0) || (arg >= NBAND))
5565 5590 return (EINVAL);
5566 5591 band = (char)arg;
5567 5592 *rvalp = bcanputnext(stp->sd_wrq, band);
5568 5593 return (0);
5569 5594 }
5570 5595
5571 5596 case I_SETCLTIME:
5572 5597 {
5573 5598 int closetime;
5574 5599
5575 5600 error = strcopyin((void *)arg, &closetime, sizeof (int),
5576 5601 copyflag);
5577 5602 if (error)
5578 5603 return (error);
5579 5604 if (closetime < 0)
5580 5605 return (EINVAL);
5581 5606
5582 5607 stp->sd_closetime = closetime;
5583 5608 return (0);
5584 5609 }
5585 5610
5586 5611 case I_GETCLTIME:
5587 5612 {
5588 5613 int closetime;
5589 5614
5590 5615 closetime = stp->sd_closetime;
5591 5616 return (strcopyout(&closetime, (void *)arg, sizeof (int),
5592 5617 copyflag));
5593 5618 }
5594 5619
5595 5620 case TIOCGSID:
5596 5621 {
5597 5622 pid_t sid;
5598 5623
5599 5624 mutex_enter(&stp->sd_lock);
5600 5625 if (stp->sd_sidp == NULL) {
5601 5626 mutex_exit(&stp->sd_lock);
5602 5627 return (ENOTTY);
5603 5628 }
5604 5629 sid = stp->sd_sidp->pid_id;
5605 5630 mutex_exit(&stp->sd_lock);
5606 5631 return (strcopyout(&sid, (void *)arg, sizeof (pid_t),
5607 5632 copyflag));
5608 5633 }
5609 5634
5610 5635 case TIOCSPGRP:
5611 5636 {
5612 5637 pid_t pgrp;
5613 5638 proc_t *q;
5614 5639 pid_t sid, fg_pgid, bg_pgid;
5615 5640
5616 5641 if (error = strcopyin((void *)arg, &pgrp, sizeof (pid_t),
5617 5642 copyflag))
5618 5643 return (error);
5619 5644 mutex_enter(&stp->sd_lock);
5620 5645 mutex_enter(&pidlock);
5621 5646 if (stp->sd_sidp != ttoproc(curthread)->p_sessp->s_sidp) {
5622 5647 mutex_exit(&pidlock);
5623 5648 mutex_exit(&stp->sd_lock);
5624 5649 return (ENOTTY);
5625 5650 }
5626 5651 if (pgrp == stp->sd_pgidp->pid_id) {
5627 5652 mutex_exit(&pidlock);
5628 5653 mutex_exit(&stp->sd_lock);
5629 5654 return (0);
5630 5655 }
5631 5656 if (pgrp <= 0 || pgrp >= maxpid) {
5632 5657 mutex_exit(&pidlock);
5633 5658 mutex_exit(&stp->sd_lock);
5634 5659 return (EINVAL);
5635 5660 }
5636 5661 if ((q = pgfind(pgrp)) == NULL ||
5637 5662 q->p_sessp != ttoproc(curthread)->p_sessp) {
5638 5663 mutex_exit(&pidlock);
5639 5664 mutex_exit(&stp->sd_lock);
5640 5665 return (EPERM);
5641 5666 }
5642 5667 sid = stp->sd_sidp->pid_id;
5643 5668 fg_pgid = q->p_pgrp;
5644 5669 bg_pgid = stp->sd_pgidp->pid_id;
5645 5670 CL_SET_PROCESS_GROUP(curthread, sid, bg_pgid, fg_pgid);
5646 5671 PID_RELE(stp->sd_pgidp);
5647 5672 ctty_clear_sighuped();
5648 5673 stp->sd_pgidp = q->p_pgidp;
5649 5674 PID_HOLD(stp->sd_pgidp);
5650 5675 mutex_exit(&pidlock);
5651 5676 mutex_exit(&stp->sd_lock);
5652 5677 return (0);
5653 5678 }
5654 5679
5655 5680 case TIOCGPGRP:
5656 5681 {
5657 5682 pid_t pgrp;
5658 5683
5659 5684 mutex_enter(&stp->sd_lock);
5660 5685 if (stp->sd_sidp == NULL) {
5661 5686 mutex_exit(&stp->sd_lock);
5662 5687 return (ENOTTY);
5663 5688 }
5664 5689 pgrp = stp->sd_pgidp->pid_id;
5665 5690 mutex_exit(&stp->sd_lock);
5666 5691 return (strcopyout(&pgrp, (void *)arg, sizeof (pid_t),
5667 5692 copyflag));
5668 5693 }
5669 5694
5670 5695 case TIOCSCTTY:
5671 5696 {
5672 5697 return (strctty(stp));
5673 5698 }
5674 5699
5675 5700 case TIOCNOTTY:
5676 5701 {
5677 5702 /* freectty() always assumes curproc. */
5678 5703 if (freectty(B_FALSE) != 0)
5679 5704 return (0);
5680 5705 return (ENOTTY);
5681 5706 }
5682 5707
5683 5708 case FIONBIO:
5684 5709 case FIOASYNC:
5685 5710 return (0); /* handled by the upper layer */
5686 5711 }
5687 5712 }
5688 5713
5689 5714 /*
5690 5715 * Custom free routine used for M_PASSFP messages.
5691 5716 */
5692 5717 static void
5693 5718 free_passfp(struct k_strrecvfd *srf)
5694 5719 {
5695 5720 (void) closef(srf->fp);
5696 5721 kmem_free(srf, sizeof (struct k_strrecvfd) + sizeof (frtn_t));
5697 5722 }
5698 5723
5699 5724 /* ARGSUSED */
5700 5725 int
5701 5726 do_sendfp(struct stdata *stp, struct file *fp, struct cred *cr)
5702 5727 {
5703 5728 queue_t *qp, *nextqp;
5704 5729 struct k_strrecvfd *srf;
5705 5730 mblk_t *mp;
5706 5731 frtn_t *frtnp;
5707 5732 size_t bufsize;
5708 5733 queue_t *mate = NULL;
5709 5734 syncq_t *sq = NULL;
5710 5735 int retval = 0;
5711 5736
5712 5737 if (stp->sd_flag & STRHUP)
5713 5738 return (ENXIO);
5714 5739
5715 5740 claimstr(stp->sd_wrq);
5716 5741
5717 5742 /* Fastpath, we have a pipe, and we are already mated, use it. */
5718 5743 if (STRMATED(stp)) {
5719 5744 qp = _RD(stp->sd_mate->sd_wrq);
5720 5745 claimstr(qp);
5721 5746 mate = qp;
5722 5747 } else { /* Not already mated. */
5723 5748
5724 5749 /*
5725 5750 * Walk the stream to the end of this one.
5726 5751 * assumes that the claimstr() will prevent
5727 5752 * plumbing between the stream head and the
5728 5753 * driver from changing
5729 5754 */
5730 5755 qp = stp->sd_wrq;
5731 5756
5732 5757 /*
5733 5758 * Loop until we reach the end of this stream.
5734 5759 * On completion, qp points to the write queue
5735 5760 * at the end of the stream, or the read queue
5736 5761 * at the stream head if this is a fifo.
5737 5762 */
5738 5763 while (((qp = qp->q_next) != NULL) && _SAMESTR(qp))
5739 5764 ;
5740 5765
5741 5766 /*
5742 5767 * Just in case we get a q_next which is NULL, but
5743 5768 * not at the end of the stream. This is actually
5744 5769 * broken, so we set an assert to catch it in
5745 5770 * debug, and set an error and return if not debug.
5746 5771 */
5747 5772 ASSERT(qp);
5748 5773 if (qp == NULL) {
5749 5774 releasestr(stp->sd_wrq);
5750 5775 return (EINVAL);
5751 5776 }
5752 5777
5753 5778 /*
5754 5779 * Enter the syncq for the driver, so (hopefully)
5755 5780 * the queue values will not change on us.
5756 5781 * XXXX - This will only prevent the race IFF only
5757 5782 * the write side modifies the q_next member, and
5758 5783 * the put procedure is protected by at least
5759 5784 * MT_PERQ.
5760 5785 */
5761 5786 if ((sq = qp->q_syncq) != NULL)
5762 5787 entersq(sq, SQ_PUT);
5763 5788
5764 5789 /* Now get the q_next value from this qp. */
5765 5790 nextqp = qp->q_next;
5766 5791
5767 5792 /*
5768 5793 * If nextqp exists and the other stream is different
5769 5794 * from this one claim the stream, set the mate, and
5770 5795 * get the read queue at the stream head of the other
5771 5796 * stream. Assumes that nextqp was at least valid when
5772 5797 * we got it. Hopefully the entersq of the driver
5773 5798 * will prevent it from changing on us.
5774 5799 */
5775 5800 if ((nextqp != NULL) && (STREAM(nextqp) != stp)) {
5776 5801 ASSERT(qp->q_qinfo->qi_srvp);
5777 5802 ASSERT(_OTHERQ(qp)->q_qinfo->qi_srvp);
5778 5803 ASSERT(_OTHERQ(qp->q_next)->q_qinfo->qi_srvp);
5779 5804 claimstr(nextqp);
5780 5805
5781 5806 /* Make sure we still have a q_next */
5782 5807 if (nextqp != qp->q_next) {
5783 5808 releasestr(stp->sd_wrq);
5784 5809 releasestr(nextqp);
5785 5810 return (EINVAL);
5786 5811 }
5787 5812
5788 5813 qp = _RD(STREAM(nextqp)->sd_wrq);
5789 5814 mate = qp;
5790 5815 }
5791 5816 /* If we entered the synq above, leave it. */
5792 5817 if (sq != NULL)
5793 5818 leavesq(sq, SQ_PUT);
5794 5819 } /* STRMATED(STP) */
5795 5820
5796 5821 /* XXX prevents substitution of the ops vector */
5797 5822 if (qp->q_qinfo != &strdata && qp->q_qinfo != &fifo_strdata) {
5798 5823 retval = EINVAL;
5799 5824 goto out;
5800 5825 }
5801 5826
5802 5827 if (qp->q_flag & QFULL) {
5803 5828 retval = EAGAIN;
5804 5829 goto out;
5805 5830 }
5806 5831
5807 5832 /*
5808 5833 * Since M_PASSFP messages include a file descriptor, we use
5809 5834 * esballoc() and specify a custom free routine (free_passfp()) that
5810 5835 * will close the descriptor as part of freeing the message. For
5811 5836 * convenience, we stash the frtn_t right after the data block.
5812 5837 */
5813 5838 bufsize = sizeof (struct k_strrecvfd) + sizeof (frtn_t);
5814 5839 srf = kmem_alloc(bufsize, KM_NOSLEEP);
5815 5840 if (srf == NULL) {
5816 5841 retval = EAGAIN;
5817 5842 goto out;
5818 5843 }
5819 5844
5820 5845 frtnp = (frtn_t *)(srf + 1);
5821 5846 frtnp->free_arg = (caddr_t)srf;
5822 5847 frtnp->free_func = free_passfp;
5823 5848
5824 5849 mp = esballoc((uchar_t *)srf, bufsize, BPRI_MED, frtnp);
5825 5850 if (mp == NULL) {
5826 5851 kmem_free(srf, bufsize);
5827 5852 retval = EAGAIN;
5828 5853 goto out;
5829 5854 }
5830 5855 mp->b_wptr += sizeof (struct k_strrecvfd);
5831 5856 mp->b_datap->db_type = M_PASSFP;
5832 5857
5833 5858 srf->fp = fp;
5834 5859 srf->uid = crgetuid(curthread->t_cred);
5835 5860 srf->gid = crgetgid(curthread->t_cred);
5836 5861 mutex_enter(&fp->f_tlock);
5837 5862 fp->f_count++;
5838 5863 mutex_exit(&fp->f_tlock);
5839 5864
5840 5865 put(qp, mp);
5841 5866 out:
5842 5867 releasestr(stp->sd_wrq);
5843 5868 if (mate)
5844 5869 releasestr(mate);
5845 5870 return (retval);
5846 5871 }
5847 5872
5848 5873 /*
5849 5874 * Send an ioctl message downstream and wait for acknowledgement.
5850 5875 * flags may be set to either U_TO_K or K_TO_K and a combination
5851 5876 * of STR_NOERROR or STR_NOSIG
5852 5877 * STR_NOSIG: Signals are essentially ignored or held and have
5853 5878 * no effect for the duration of the call.
5854 5879 * STR_NOERROR: Ignores stream head read, write and hup errors.
5855 5880 * Additionally, if an existing ioctl times out, it is assumed
5856 5881 * lost and and this ioctl will continue as if the previous ioctl had
5857 5882 * finished. ETIME may be returned if this ioctl times out (i.e.
5858 5883 * ic_timout is not INFTIM). Non-stream head errors may be returned if
5859 5884 * the ioc_error indicates that the driver/module had problems,
5860 5885 * an EFAULT was found when accessing user data, a lack of
5861 5886 * resources, etc.
5862 5887 */
5863 5888 int
5864 5889 strdoioctl(
5865 5890 struct stdata *stp,
5866 5891 struct strioctl *strioc,
5867 5892 int fflags, /* file flags with model info */
5868 5893 int flag,
5869 5894 cred_t *crp,
5870 5895 int *rvalp)
5871 5896 {
5872 5897 mblk_t *bp;
5873 5898 struct iocblk *iocbp;
5874 5899 struct copyreq *reqp;
5875 5900 struct copyresp *resp;
5876 5901 int id;
5877 5902 int transparent = 0;
5878 5903 int error = 0;
5879 5904 int len = 0;
5880 5905 caddr_t taddr;
5881 5906 int copyflag = (flag & (U_TO_K | K_TO_K));
5882 5907 int sigflag = (flag & STR_NOSIG);
5883 5908 int errs;
5884 5909 uint_t waitflags;
5885 5910 boolean_t set_iocwaitne = B_FALSE;
5886 5911
5887 5912 ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
5888 5913 ASSERT((fflags & FMODELS) != 0);
5889 5914
5890 5915 TRACE_2(TR_FAC_STREAMS_FR,
5891 5916 TR_STRDOIOCTL,
5892 5917 "strdoioctl:stp %p strioc %p", stp, strioc);
5893 5918 if (strioc->ic_len == TRANSPARENT) { /* send arg in M_DATA block */
5894 5919 transparent = 1;
5895 5920 strioc->ic_len = sizeof (intptr_t);
5896 5921 }
5897 5922
5898 5923 if (strioc->ic_len < 0 || (strmsgsz > 0 && strioc->ic_len > strmsgsz))
5899 5924 return (EINVAL);
5900 5925
5901 5926 if ((bp = allocb_cred_wait(sizeof (union ioctypes), sigflag, &error,
5902 5927 crp, curproc->p_pid)) == NULL)
5903 5928 return (error);
5904 5929
5905 5930 bzero(bp->b_wptr, sizeof (union ioctypes));
5906 5931
5907 5932 iocbp = (struct iocblk *)bp->b_wptr;
5908 5933 iocbp->ioc_count = strioc->ic_len;
5909 5934 iocbp->ioc_cmd = strioc->ic_cmd;
5910 5935 iocbp->ioc_flag = (fflags & FMODELS);
5911 5936
5912 5937 crhold(crp);
5913 5938 iocbp->ioc_cr = crp;
5914 5939 DB_TYPE(bp) = M_IOCTL;
5915 5940 bp->b_wptr += sizeof (struct iocblk);
5916 5941
5917 5942 if (flag & STR_NOERROR)
5918 5943 errs = STPLEX;
5919 5944 else
5920 5945 errs = STRHUP|STRDERR|STWRERR|STPLEX;
5921 5946
5922 5947 /*
5923 5948 * If there is data to copy into ioctl block, do so.
5924 5949 */
5925 5950 if (iocbp->ioc_count > 0) {
5926 5951 if (transparent)
5927 5952 /*
5928 5953 * Note: STR_NOERROR does not have an effect
5929 5954 * in putiocd()
5930 5955 */
5931 5956 id = K_TO_K | sigflag;
5932 5957 else
5933 5958 id = flag;
5934 5959 if ((error = putiocd(bp, strioc->ic_dp, id, crp)) != 0) {
5935 5960 freemsg(bp);
5936 5961 crfree(crp);
5937 5962 return (error);
5938 5963 }
5939 5964
5940 5965 /*
5941 5966 * We could have slept copying in user pages.
5942 5967 * Recheck the stream head state (the other end
5943 5968 * of a pipe could have gone away).
5944 5969 */
5945 5970 if (stp->sd_flag & errs) {
5946 5971 mutex_enter(&stp->sd_lock);
5947 5972 error = strgeterr(stp, errs, 0);
5948 5973 mutex_exit(&stp->sd_lock);
5949 5974 if (error != 0) {
5950 5975 freemsg(bp);
5951 5976 crfree(crp);
5952 5977 return (error);
5953 5978 }
5954 5979 }
5955 5980 }
5956 5981 if (transparent)
5957 5982 iocbp->ioc_count = TRANSPARENT;
5958 5983
5959 5984 /*
5960 5985 * Block for up to STRTIMOUT milliseconds if there is an outstanding
5961 5986 * ioctl for this stream already running. All processes
5962 5987 * sleeping here will be awakened as a result of an ACK
5963 5988 * or NAK being received for the outstanding ioctl, or
5964 5989 * as a result of the timer expiring on the outstanding
5965 5990 * ioctl (a failure), or as a result of any waiting
5966 5991 * process's timer expiring (also a failure).
5967 5992 */
5968 5993
5969 5994 error = 0;
5970 5995 mutex_enter(&stp->sd_lock);
5971 5996 while ((stp->sd_flag & IOCWAIT) ||
5972 5997 (!set_iocwaitne && (stp->sd_flag & IOCWAITNE))) {
5973 5998 clock_t cv_rval;
5974 5999
5975 6000 TRACE_0(TR_FAC_STREAMS_FR,
5976 6001 TR_STRDOIOCTL_WAIT,
5977 6002 "strdoioctl sleeps - IOCWAIT");
5978 6003 cv_rval = str_cv_wait(&stp->sd_iocmonitor, &stp->sd_lock,
5979 6004 STRTIMOUT, sigflag);
5980 6005 if (cv_rval <= 0) {
5981 6006 if (cv_rval == 0) {
5982 6007 error = EINTR;
5983 6008 } else {
5984 6009 if (flag & STR_NOERROR) {
5985 6010 /*
5986 6011 * Terminating current ioctl in
5987 6012 * progress -- assume it got lost and
5988 6013 * wake up the other thread so that the
5989 6014 * operation completes.
5990 6015 */
5991 6016 if (!(stp->sd_flag & IOCWAITNE)) {
5992 6017 set_iocwaitne = B_TRUE;
5993 6018 stp->sd_flag |= IOCWAITNE;
5994 6019 cv_broadcast(&stp->sd_monitor);
5995 6020 }
5996 6021 /*
5997 6022 * Otherwise, there's a running
5998 6023 * STR_NOERROR -- we have no choice
5999 6024 * here but to wait forever (or until
6000 6025 * interrupted).
6001 6026 */
6002 6027 } else {
6003 6028 /*
6004 6029 * pending ioctl has caused
6005 6030 * us to time out
6006 6031 */
6007 6032 error = ETIME;
6008 6033 }
6009 6034 }
6010 6035 } else if ((stp->sd_flag & errs)) {
6011 6036 error = strgeterr(stp, errs, 0);
6012 6037 }
6013 6038 if (error) {
6014 6039 mutex_exit(&stp->sd_lock);
6015 6040 freemsg(bp);
6016 6041 crfree(crp);
6017 6042 return (error);
6018 6043 }
6019 6044 }
6020 6045
6021 6046 /*
6022 6047 * Have control of ioctl mechanism.
6023 6048 * Send down ioctl packet and wait for response.
6024 6049 */
6025 6050 if (stp->sd_iocblk != (mblk_t *)-1) {
6026 6051 freemsg(stp->sd_iocblk);
6027 6052 }
6028 6053 stp->sd_iocblk = NULL;
6029 6054
6030 6055 /*
6031 6056 * If this is marked with 'noerror' (internal; mostly
6032 6057 * I_{P,}{UN,}LINK), then make sure nobody else is able to get
6033 6058 * in here by setting IOCWAITNE.
6034 6059 */
6035 6060 waitflags = IOCWAIT;
6036 6061 if (flag & STR_NOERROR)
6037 6062 waitflags |= IOCWAITNE;
6038 6063
6039 6064 stp->sd_flag |= waitflags;
6040 6065
6041 6066 /*
6042 6067 * Assign sequence number.
6043 6068 */
6044 6069 iocbp->ioc_id = stp->sd_iocid = getiocseqno();
6045 6070
6046 6071 mutex_exit(&stp->sd_lock);
6047 6072
6048 6073 TRACE_1(TR_FAC_STREAMS_FR,
6049 6074 TR_STRDOIOCTL_PUT, "strdoioctl put: stp %p", stp);
6050 6075 stream_willservice(stp);
6051 6076 putnext(stp->sd_wrq, bp);
6052 6077 stream_runservice(stp);
6053 6078
6054 6079 /*
6055 6080 * Timed wait for acknowledgment. The wait time is limited by the
6056 6081 * timeout value, which must be a positive integer (number of
6057 6082 * milliseconds) to wait, or 0 (use default value of STRTIMOUT
6058 6083 * milliseconds), or -1 (wait forever). This will be awakened
6059 6084 * either by an ACK/NAK message arriving, the timer expiring, or
6060 6085 * the timer expiring on another ioctl waiting for control of the
6061 6086 * mechanism.
6062 6087 */
6063 6088 waitioc:
6064 6089 mutex_enter(&stp->sd_lock);
6065 6090
6066 6091
6067 6092 /*
6068 6093 * If the reply has already arrived, don't sleep. If awakened from
6069 6094 * the sleep, fail only if the reply has not arrived by then.
6070 6095 * Otherwise, process the reply.
6071 6096 */
6072 6097 while (!stp->sd_iocblk) {
6073 6098 clock_t cv_rval;
6074 6099
6075 6100 if (stp->sd_flag & errs) {
6076 6101 error = strgeterr(stp, errs, 0);
6077 6102 if (error != 0) {
6078 6103 stp->sd_flag &= ~waitflags;
6079 6104 cv_broadcast(&stp->sd_iocmonitor);
6080 6105 mutex_exit(&stp->sd_lock);
6081 6106 crfree(crp);
6082 6107 return (error);
6083 6108 }
6084 6109 }
6085 6110
6086 6111 TRACE_0(TR_FAC_STREAMS_FR,
6087 6112 TR_STRDOIOCTL_WAIT2,
6088 6113 "strdoioctl sleeps awaiting reply");
6089 6114 ASSERT(error == 0);
6090 6115
6091 6116 cv_rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock,
6092 6117 (strioc->ic_timout ?
6093 6118 strioc->ic_timout * 1000 : STRTIMOUT), sigflag);
6094 6119
6095 6120 /*
6096 6121 * There are four possible cases here: interrupt, timeout,
6097 6122 * wakeup by IOCWAITNE (above), or wakeup by strrput_nondata (a
6098 6123 * valid M_IOCTL reply).
6099 6124 *
6100 6125 * If we've been awakened by a STR_NOERROR ioctl on some other
6101 6126 * thread, then sd_iocblk will still be NULL, and IOCWAITNE
6102 6127 * will be set. Pretend as if we just timed out. Note that
6103 6128 * this other thread waited at least STRTIMOUT before trying to
6104 6129 * awaken our thread, so this is indistinguishable (even for
6105 6130 * INFTIM) from the case where we failed with ETIME waiting on
6106 6131 * IOCWAIT in the prior loop.
6107 6132 */
6108 6133 if (cv_rval > 0 && !(flag & STR_NOERROR) &&
6109 6134 stp->sd_iocblk == NULL && (stp->sd_flag & IOCWAITNE)) {
6110 6135 cv_rval = -1;
6111 6136 }
6112 6137
6113 6138 /*
6114 6139 * note: STR_NOERROR does not protect
6115 6140 * us here.. use ic_timout < 0
6116 6141 */
6117 6142 if (cv_rval <= 0) {
6118 6143 if (cv_rval == 0) {
6119 6144 error = EINTR;
6120 6145 } else {
6121 6146 error = ETIME;
6122 6147 }
6123 6148 /*
6124 6149 * A message could have come in after we were scheduled
6125 6150 * but before we were actually run.
6126 6151 */
6127 6152 bp = stp->sd_iocblk;
6128 6153 stp->sd_iocblk = NULL;
6129 6154 if (bp != NULL) {
6130 6155 if ((bp->b_datap->db_type == M_COPYIN) ||
6131 6156 (bp->b_datap->db_type == M_COPYOUT)) {
6132 6157 mutex_exit(&stp->sd_lock);
6133 6158 if (bp->b_cont) {
6134 6159 freemsg(bp->b_cont);
6135 6160 bp->b_cont = NULL;
6136 6161 }
6137 6162 bp->b_datap->db_type = M_IOCDATA;
6138 6163 bp->b_wptr = bp->b_rptr +
6139 6164 sizeof (struct copyresp);
6140 6165 resp = (struct copyresp *)bp->b_rptr;
6141 6166 resp->cp_rval =
6142 6167 (caddr_t)1; /* failure */
6143 6168 stream_willservice(stp);
6144 6169 putnext(stp->sd_wrq, bp);
6145 6170 stream_runservice(stp);
6146 6171 mutex_enter(&stp->sd_lock);
6147 6172 } else {
6148 6173 freemsg(bp);
6149 6174 }
6150 6175 }
6151 6176 stp->sd_flag &= ~waitflags;
6152 6177 cv_broadcast(&stp->sd_iocmonitor);
6153 6178 mutex_exit(&stp->sd_lock);
6154 6179 crfree(crp);
6155 6180 return (error);
6156 6181 }
6157 6182 }
6158 6183 bp = stp->sd_iocblk;
6159 6184 /*
6160 6185 * Note: it is strictly impossible to get here with sd_iocblk set to
6161 6186 * -1. This is because the initial loop above doesn't allow any new
6162 6187 * ioctls into the fray until all others have passed this point.
6163 6188 */
6164 6189 ASSERT(bp != NULL && bp != (mblk_t *)-1);
6165 6190 TRACE_1(TR_FAC_STREAMS_FR,
6166 6191 TR_STRDOIOCTL_ACK, "strdoioctl got reply: bp %p", bp);
6167 6192 if ((bp->b_datap->db_type == M_IOCACK) ||
6168 6193 (bp->b_datap->db_type == M_IOCNAK)) {
6169 6194 /* for detection of duplicate ioctl replies */
6170 6195 stp->sd_iocblk = (mblk_t *)-1;
6171 6196 stp->sd_flag &= ~waitflags;
6172 6197 cv_broadcast(&stp->sd_iocmonitor);
6173 6198 mutex_exit(&stp->sd_lock);
6174 6199 } else {
6175 6200 /*
6176 6201 * flags not cleared here because we're still doing
6177 6202 * copy in/out for ioctl.
6178 6203 */
6179 6204 stp->sd_iocblk = NULL;
6180 6205 mutex_exit(&stp->sd_lock);
6181 6206 }
6182 6207
6183 6208
6184 6209 /*
6185 6210 * Have received acknowledgment.
6186 6211 */
6187 6212
6188 6213 switch (bp->b_datap->db_type) {
6189 6214 case M_IOCACK:
6190 6215 /*
6191 6216 * Positive ack.
6192 6217 */
6193 6218 iocbp = (struct iocblk *)bp->b_rptr;
6194 6219
6195 6220 /*
6196 6221 * Set error if indicated.
6197 6222 */
6198 6223 if (iocbp->ioc_error) {
6199 6224 error = iocbp->ioc_error;
6200 6225 break;
6201 6226 }
6202 6227
6203 6228 /*
6204 6229 * Set return value.
6205 6230 */
6206 6231 *rvalp = iocbp->ioc_rval;
6207 6232
6208 6233 /*
6209 6234 * Data may have been returned in ACK message (ioc_count > 0).
6210 6235 * If so, copy it out to the user's buffer.
6211 6236 */
6212 6237 if (iocbp->ioc_count && !transparent) {
6213 6238 if (error = getiocd(bp, strioc->ic_dp, copyflag))
6214 6239 break;
6215 6240 }
6216 6241 if (!transparent) {
6217 6242 if (len) /* an M_COPYOUT was used with I_STR */
6218 6243 strioc->ic_len = len;
6219 6244 else
6220 6245 strioc->ic_len = (int)iocbp->ioc_count;
6221 6246 }
6222 6247 break;
6223 6248
6224 6249 case M_IOCNAK:
6225 6250 /*
6226 6251 * Negative ack.
6227 6252 *
6228 6253 * The only thing to do is set error as specified
6229 6254 * in neg ack packet.
6230 6255 */
6231 6256 iocbp = (struct iocblk *)bp->b_rptr;
6232 6257
6233 6258 error = (iocbp->ioc_error ? iocbp->ioc_error : EINVAL);
6234 6259 break;
6235 6260
6236 6261 case M_COPYIN:
6237 6262 /*
6238 6263 * Driver or module has requested user ioctl data.
6239 6264 */
6240 6265 reqp = (struct copyreq *)bp->b_rptr;
6241 6266
6242 6267 /*
6243 6268 * M_COPYIN should *never* have a message attached, though
6244 6269 * it's harmless if it does -- thus, panic on a DEBUG
6245 6270 * kernel and just free it on a non-DEBUG build.
6246 6271 */
6247 6272 ASSERT(bp->b_cont == NULL);
6248 6273 if (bp->b_cont != NULL) {
6249 6274 freemsg(bp->b_cont);
6250 6275 bp->b_cont = NULL;
6251 6276 }
6252 6277
6253 6278 error = putiocd(bp, reqp->cq_addr, flag, crp);
6254 6279 if (error && bp->b_cont) {
6255 6280 freemsg(bp->b_cont);
6256 6281 bp->b_cont = NULL;
6257 6282 }
6258 6283
6259 6284 bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
6260 6285 bp->b_datap->db_type = M_IOCDATA;
6261 6286
6262 6287 mblk_setcred(bp, crp, curproc->p_pid);
6263 6288 resp = (struct copyresp *)bp->b_rptr;
6264 6289 resp->cp_rval = (caddr_t)(uintptr_t)error;
6265 6290 resp->cp_flag = (fflags & FMODELS);
6266 6291
6267 6292 stream_willservice(stp);
6268 6293 putnext(stp->sd_wrq, bp);
6269 6294 stream_runservice(stp);
6270 6295
6271 6296 if (error) {
6272 6297 mutex_enter(&stp->sd_lock);
6273 6298 stp->sd_flag &= ~waitflags;
6274 6299 cv_broadcast(&stp->sd_iocmonitor);
6275 6300 mutex_exit(&stp->sd_lock);
6276 6301 crfree(crp);
6277 6302 return (error);
6278 6303 }
6279 6304
6280 6305 goto waitioc;
6281 6306
6282 6307 case M_COPYOUT:
6283 6308 /*
6284 6309 * Driver or module has ioctl data for a user.
6285 6310 */
6286 6311 reqp = (struct copyreq *)bp->b_rptr;
6287 6312 ASSERT(bp->b_cont != NULL);
6288 6313
6289 6314 /*
6290 6315 * Always (transparent or non-transparent )
6291 6316 * use the address specified in the request
6292 6317 */
6293 6318 taddr = reqp->cq_addr;
6294 6319 if (!transparent)
6295 6320 len = (int)reqp->cq_size;
6296 6321
6297 6322 /* copyout data to the provided address */
6298 6323 error = getiocd(bp, taddr, copyflag);
6299 6324
6300 6325 freemsg(bp->b_cont);
6301 6326 bp->b_cont = NULL;
6302 6327
6303 6328 bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
6304 6329 bp->b_datap->db_type = M_IOCDATA;
6305 6330
6306 6331 mblk_setcred(bp, crp, curproc->p_pid);
6307 6332 resp = (struct copyresp *)bp->b_rptr;
6308 6333 resp->cp_rval = (caddr_t)(uintptr_t)error;
6309 6334 resp->cp_flag = (fflags & FMODELS);
6310 6335
6311 6336 stream_willservice(stp);
6312 6337 putnext(stp->sd_wrq, bp);
6313 6338 stream_runservice(stp);
6314 6339
6315 6340 if (error) {
6316 6341 mutex_enter(&stp->sd_lock);
6317 6342 stp->sd_flag &= ~waitflags;
6318 6343 cv_broadcast(&stp->sd_iocmonitor);
6319 6344 mutex_exit(&stp->sd_lock);
6320 6345 crfree(crp);
6321 6346 return (error);
6322 6347 }
6323 6348 goto waitioc;
6324 6349
6325 6350 default:
6326 6351 ASSERT(0);
6327 6352 mutex_enter(&stp->sd_lock);
6328 6353 stp->sd_flag &= ~waitflags;
6329 6354 cv_broadcast(&stp->sd_iocmonitor);
6330 6355 mutex_exit(&stp->sd_lock);
6331 6356 break;
6332 6357 }
6333 6358
6334 6359 freemsg(bp);
6335 6360 crfree(crp);
6336 6361 return (error);
6337 6362 }
6338 6363
6339 6364 /*
6340 6365 * Send an M_CMD message downstream and wait for a reply. This is a ptools
6341 6366 * special used to retrieve information from modules/drivers a stream without
6342 6367 * being subjected to flow control or interfering with pending messages on the
6343 6368 * stream (e.g. an ioctl in flight).
6344 6369 */
6345 6370 int
6346 6371 strdocmd(struct stdata *stp, struct strcmd *scp, cred_t *crp)
6347 6372 {
6348 6373 mblk_t *mp;
6349 6374 struct cmdblk *cmdp;
6350 6375 int error = 0;
6351 6376 int errs = STRHUP|STRDERR|STWRERR|STPLEX;
6352 6377 clock_t rval, timeout = STRTIMOUT;
6353 6378
6354 6379 if (scp->sc_len < 0 || scp->sc_len > sizeof (scp->sc_buf) ||
6355 6380 scp->sc_timeout < -1)
6356 6381 return (EINVAL);
6357 6382
6358 6383 if (scp->sc_timeout > 0)
6359 6384 timeout = scp->sc_timeout * MILLISEC;
6360 6385
6361 6386 if ((mp = allocb_cred(sizeof (struct cmdblk), crp,
6362 6387 curproc->p_pid)) == NULL)
6363 6388 return (ENOMEM);
6364 6389
6365 6390 crhold(crp);
6366 6391
6367 6392 cmdp = (struct cmdblk *)mp->b_wptr;
6368 6393 cmdp->cb_cr = crp;
6369 6394 cmdp->cb_cmd = scp->sc_cmd;
6370 6395 cmdp->cb_len = scp->sc_len;
6371 6396 cmdp->cb_error = 0;
6372 6397 mp->b_wptr += sizeof (struct cmdblk);
6373 6398
6374 6399 DB_TYPE(mp) = M_CMD;
6375 6400 DB_CPID(mp) = curproc->p_pid;
6376 6401
6377 6402 /*
6378 6403 * Copy in the payload.
6379 6404 */
6380 6405 if (cmdp->cb_len > 0) {
6381 6406 mp->b_cont = allocb_cred(sizeof (scp->sc_buf), crp,
6382 6407 curproc->p_pid);
6383 6408 if (mp->b_cont == NULL) {
6384 6409 error = ENOMEM;
6385 6410 goto out;
6386 6411 }
6387 6412
6388 6413 /* cb_len comes from sc_len, which has already been checked */
6389 6414 ASSERT(cmdp->cb_len <= sizeof (scp->sc_buf));
6390 6415 (void) bcopy(scp->sc_buf, mp->b_cont->b_wptr, cmdp->cb_len);
6391 6416 mp->b_cont->b_wptr += cmdp->cb_len;
6392 6417 DB_CPID(mp->b_cont) = curproc->p_pid;
6393 6418 }
6394 6419
6395 6420 /*
6396 6421 * Since this mechanism is strictly for ptools, and since only one
6397 6422 * process can be grabbed at a time, we simply fail if there's
6398 6423 * currently an operation pending.
6399 6424 */
6400 6425 mutex_enter(&stp->sd_lock);
6401 6426 if (stp->sd_flag & STRCMDWAIT) {
6402 6427 mutex_exit(&stp->sd_lock);
6403 6428 error = EBUSY;
6404 6429 goto out;
6405 6430 }
6406 6431 stp->sd_flag |= STRCMDWAIT;
6407 6432 ASSERT(stp->sd_cmdblk == NULL);
6408 6433 mutex_exit(&stp->sd_lock);
6409 6434
6410 6435 putnext(stp->sd_wrq, mp);
6411 6436 mp = NULL;
6412 6437
6413 6438 /*
6414 6439 * Timed wait for acknowledgment. If the reply has already arrived,
6415 6440 * don't sleep. If awakened from the sleep, fail only if the reply
6416 6441 * has not arrived by then. Otherwise, process the reply.
6417 6442 */
6418 6443 mutex_enter(&stp->sd_lock);
6419 6444 while (stp->sd_cmdblk == NULL) {
6420 6445 if (stp->sd_flag & errs) {
6421 6446 if ((error = strgeterr(stp, errs, 0)) != 0)
6422 6447 goto waitout;
6423 6448 }
6424 6449
6425 6450 rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock, timeout, 0);
6426 6451 if (stp->sd_cmdblk != NULL)
6427 6452 break;
6428 6453
6429 6454 if (rval <= 0) {
6430 6455 error = (rval == 0) ? EINTR : ETIME;
6431 6456 goto waitout;
6432 6457 }
6433 6458 }
6434 6459
6435 6460 /*
6436 6461 * We received a reply.
6437 6462 */
6438 6463 mp = stp->sd_cmdblk;
6439 6464 stp->sd_cmdblk = NULL;
6440 6465 ASSERT(mp != NULL && DB_TYPE(mp) == M_CMD);
6441 6466 ASSERT(stp->sd_flag & STRCMDWAIT);
6442 6467 stp->sd_flag &= ~STRCMDWAIT;
6443 6468 mutex_exit(&stp->sd_lock);
6444 6469
6445 6470 cmdp = (struct cmdblk *)mp->b_rptr;
6446 6471 if ((error = cmdp->cb_error) != 0)
6447 6472 goto out;
6448 6473
6449 6474 /*
6450 6475 * Data may have been returned in the reply (cb_len > 0).
6451 6476 * If so, copy it out to the user's buffer.
6452 6477 */
6453 6478 if (cmdp->cb_len > 0) {
6454 6479 if (mp->b_cont == NULL || MBLKL(mp->b_cont) < cmdp->cb_len) {
6455 6480 error = EPROTO;
6456 6481 goto out;
6457 6482 }
6458 6483
6459 6484 cmdp->cb_len = MIN(cmdp->cb_len, sizeof (scp->sc_buf));
6460 6485 (void) bcopy(mp->b_cont->b_rptr, scp->sc_buf, cmdp->cb_len);
6461 6486 }
6462 6487 scp->sc_len = cmdp->cb_len;
6463 6488 out:
6464 6489 freemsg(mp);
6465 6490 crfree(crp);
6466 6491 return (error);
6467 6492 waitout:
6468 6493 ASSERT(stp->sd_cmdblk == NULL);
6469 6494 stp->sd_flag &= ~STRCMDWAIT;
6470 6495 mutex_exit(&stp->sd_lock);
6471 6496 crfree(crp);
6472 6497 return (error);
6473 6498 }
6474 6499
6475 6500 /*
6476 6501 * For the SunOS keyboard driver.
6477 6502 * Return the next available "ioctl" sequence number.
6478 6503 * Exported, so that streams modules can send "ioctl" messages
6479 6504 * downstream from their open routine.
6480 6505 */
6481 6506 int
6482 6507 getiocseqno(void)
6483 6508 {
6484 6509 int i;
6485 6510
6486 6511 mutex_enter(&strresources);
6487 6512 i = ++ioc_id;
6488 6513 mutex_exit(&strresources);
6489 6514 return (i);
6490 6515 }
6491 6516
6492 6517 /*
6493 6518 * Get the next message from the read queue. If the message is
6494 6519 * priority, STRPRI will have been set by strrput(). This flag
6495 6520 * should be reset only when the entire message at the front of the
6496 6521 * queue as been consumed.
6497 6522 *
6498 6523 * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
6499 6524 */
6500 6525 int
6501 6526 strgetmsg(
6502 6527 struct vnode *vp,
6503 6528 struct strbuf *mctl,
6504 6529 struct strbuf *mdata,
6505 6530 unsigned char *prip,
6506 6531 int *flagsp,
6507 6532 int fmode,
6508 6533 rval_t *rvp)
6509 6534 {
6510 6535 struct stdata *stp;
6511 6536 mblk_t *bp, *nbp;
6512 6537 mblk_t *savemp = NULL;
6513 6538 mblk_t *savemptail = NULL;
6514 6539 uint_t old_sd_flag;
6515 6540 int flg;
6516 6541 int more = 0;
6517 6542 int error = 0;
6518 6543 char first = 1;
6519 6544 uint_t mark; /* Contains MSG*MARK and _LASTMARK */
6520 6545 #define _LASTMARK 0x8000 /* Distinct from MSG*MARK */
6521 6546 unsigned char pri = 0;
6522 6547 queue_t *q;
6523 6548 int pr = 0; /* Partial read successful */
6524 6549 struct uio uios;
6525 6550 struct uio *uiop = &uios;
6526 6551 struct iovec iovs;
6527 6552 unsigned char type;
6528 6553
6529 6554 TRACE_1(TR_FAC_STREAMS_FR, TR_STRGETMSG_ENTER,
6530 6555 "strgetmsg:%p", vp);
6531 6556
6532 6557 ASSERT(vp->v_stream);
6533 6558 stp = vp->v_stream;
6534 6559 rvp->r_val1 = 0;
6535 6560
6536 6561 mutex_enter(&stp->sd_lock);
6537 6562
6538 6563 if ((error = i_straccess(stp, JCREAD)) != 0) {
6539 6564 mutex_exit(&stp->sd_lock);
6540 6565 return (error);
6541 6566 }
6542 6567
6543 6568 if (stp->sd_flag & (STRDERR|STPLEX)) {
6544 6569 error = strgeterr(stp, STRDERR|STPLEX, 0);
6545 6570 if (error != 0) {
6546 6571 mutex_exit(&stp->sd_lock);
6547 6572 return (error);
6548 6573 }
6549 6574 }
6550 6575 mutex_exit(&stp->sd_lock);
6551 6576
6552 6577 switch (*flagsp) {
6553 6578 case MSG_HIPRI:
6554 6579 if (*prip != 0)
6555 6580 return (EINVAL);
6556 6581 break;
6557 6582
6558 6583 case MSG_ANY:
6559 6584 case MSG_BAND:
6560 6585 break;
6561 6586
6562 6587 default:
6563 6588 return (EINVAL);
6564 6589 }
6565 6590 /*
6566 6591 * Setup uio and iov for data part
6567 6592 */
6568 6593 iovs.iov_base = mdata->buf;
6569 6594 iovs.iov_len = mdata->maxlen;
6570 6595 uios.uio_iov = &iovs;
6571 6596 uios.uio_iovcnt = 1;
6572 6597 uios.uio_loffset = 0;
6573 6598 uios.uio_segflg = UIO_USERSPACE;
6574 6599 uios.uio_fmode = 0;
6575 6600 uios.uio_extflg = UIO_COPY_CACHED;
6576 6601 uios.uio_resid = mdata->maxlen;
6577 6602 uios.uio_offset = 0;
6578 6603
6579 6604 q = _RD(stp->sd_wrq);
6580 6605 mutex_enter(&stp->sd_lock);
6581 6606 old_sd_flag = stp->sd_flag;
6582 6607 mark = 0;
6583 6608 for (;;) {
6584 6609 int done = 0;
6585 6610 mblk_t *q_first = q->q_first;
6586 6611
6587 6612 /*
6588 6613 * Get the next message of appropriate priority
6589 6614 * from the stream head. If the caller is interested
6590 6615 * in band or hipri messages, then they should already
6591 6616 * be enqueued at the stream head. On the other hand
6592 6617 * if the caller wants normal (band 0) messages, they
6593 6618 * might be deferred in a synchronous stream and they
6594 6619 * will need to be pulled up.
6595 6620 *
6596 6621 * After we have dequeued a message, we might find that
6597 6622 * it was a deferred M_SIG that was enqueued at the
6598 6623 * stream head. It must now be posted as part of the
6599 6624 * read by calling strsignal_nolock().
6600 6625 *
6601 6626 * Also note that strrput does not enqueue an M_PCSIG,
6602 6627 * and there cannot be more than one hipri message,
6603 6628 * so there was no need to have the M_PCSIG case.
6604 6629 *
6605 6630 * At some time it might be nice to try and wrap the
6606 6631 * functionality of kstrgetmsg() and strgetmsg() into
6607 6632 * a common routine so to reduce the amount of replicated
6608 6633 * code (since they are extremely similar).
6609 6634 */
6610 6635 if (!(*flagsp & (MSG_HIPRI|MSG_BAND))) {
6611 6636 /* Asking for normal, band0 data */
6612 6637 bp = strget(stp, q, uiop, first, &error);
6613 6638 ASSERT(MUTEX_HELD(&stp->sd_lock));
6614 6639 if (bp != NULL) {
6615 6640 if (DB_TYPE(bp) == M_SIG) {
6616 6641 strsignal_nolock(stp, *bp->b_rptr,
6617 6642 bp->b_band);
6618 6643 freemsg(bp);
6619 6644 continue;
6620 6645 } else {
6621 6646 break;
6622 6647 }
6623 6648 }
6624 6649 if (error != 0)
6625 6650 goto getmout;
6626 6651
6627 6652 /*
6628 6653 * We can't depend on the value of STRPRI here because
6629 6654 * the stream head may be in transit. Therefore, we
6630 6655 * must look at the type of the first message to
6631 6656 * determine if a high priority messages is waiting
6632 6657 */
6633 6658 } else if ((*flagsp & MSG_HIPRI) && q_first != NULL &&
6634 6659 DB_TYPE(q_first) >= QPCTL &&
6635 6660 (bp = getq_noenab(q, 0)) != NULL) {
6636 6661 /* Asked for HIPRI and got one */
6637 6662 ASSERT(DB_TYPE(bp) >= QPCTL);
6638 6663 break;
6639 6664 } else if ((*flagsp & MSG_BAND) && q_first != NULL &&
6640 6665 ((q_first->b_band >= *prip) || DB_TYPE(q_first) >= QPCTL) &&
6641 6666 (bp = getq_noenab(q, 0)) != NULL) {
6642 6667 /*
6643 6668 * Asked for at least band "prip" and got either at
6644 6669 * least that band or a hipri message.
6645 6670 */
6646 6671 ASSERT(bp->b_band >= *prip || DB_TYPE(bp) >= QPCTL);
6647 6672 if (DB_TYPE(bp) == M_SIG) {
6648 6673 strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
6649 6674 freemsg(bp);
6650 6675 continue;
6651 6676 } else {
6652 6677 break;
6653 6678 }
6654 6679 }
6655 6680
6656 6681 /* No data. Time to sleep? */
6657 6682 qbackenable(q, 0);
6658 6683
6659 6684 /*
6660 6685 * If STRHUP or STREOF, return 0 length control and data.
6661 6686 * If resid is 0, then a read(fd,buf,0) was done. Do not
6662 6687 * sleep to satisfy this request because by default we have
6663 6688 * zero bytes to return.
6664 6689 */
6665 6690 if ((stp->sd_flag & (STRHUP|STREOF)) || (mctl->maxlen == 0 &&
6666 6691 mdata->maxlen == 0)) {
6667 6692 mctl->len = mdata->len = 0;
6668 6693 *flagsp = 0;
6669 6694 mutex_exit(&stp->sd_lock);
6670 6695 return (0);
6671 6696 }
6672 6697 TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_WAIT,
6673 6698 "strgetmsg calls strwaitq:%p, %p",
6674 6699 vp, uiop);
6675 6700 if (((error = strwaitq(stp, GETWAIT, (ssize_t)0, fmode, -1,
6676 6701 &done)) != 0) || done) {
6677 6702 TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_DONE,
6678 6703 "strgetmsg error or done:%p, %p",
6679 6704 vp, uiop);
6680 6705 mutex_exit(&stp->sd_lock);
6681 6706 return (error);
6682 6707 }
6683 6708 TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_AWAKE,
6684 6709 "strgetmsg awakes:%p, %p", vp, uiop);
6685 6710 if ((error = i_straccess(stp, JCREAD)) != 0) {
6686 6711 mutex_exit(&stp->sd_lock);
6687 6712 return (error);
6688 6713 }
6689 6714 first = 0;
6690 6715 }
6691 6716 ASSERT(bp != NULL);
6692 6717 /*
6693 6718 * Extract any mark information. If the message is not completely
6694 6719 * consumed this information will be put in the mblk
6695 6720 * that is putback.
6696 6721 * If MSGMARKNEXT is set and the message is completely consumed
6697 6722 * the STRATMARK flag will be set below. Likewise, if
6698 6723 * MSGNOTMARKNEXT is set and the message is
6699 6724 * completely consumed STRNOTATMARK will be set.
6700 6725 */
6701 6726 mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
6702 6727 ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
6703 6728 (MSGMARKNEXT|MSGNOTMARKNEXT));
6704 6729 if (mark != 0 && bp == stp->sd_mark) {
6705 6730 mark |= _LASTMARK;
6706 6731 stp->sd_mark = NULL;
6707 6732 }
6708 6733 /*
6709 6734 * keep track of the original message type and priority
6710 6735 */
6711 6736 pri = bp->b_band;
6712 6737 type = bp->b_datap->db_type;
6713 6738 if (type == M_PASSFP) {
6714 6739 if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
6715 6740 stp->sd_mark = bp;
6716 6741 bp->b_flag |= mark & ~_LASTMARK;
6717 6742 putback(stp, q, bp, pri);
6718 6743 qbackenable(q, pri);
6719 6744 mutex_exit(&stp->sd_lock);
6720 6745 return (EBADMSG);
6721 6746 }
6722 6747 ASSERT(type != M_SIG);
6723 6748
6724 6749 /*
6725 6750 * Set this flag so strrput will not generate signals. Need to
6726 6751 * make sure this flag is cleared before leaving this routine
6727 6752 * else signals will stop being sent.
6728 6753 */
6729 6754 stp->sd_flag |= STRGETINPROG;
6730 6755 mutex_exit(&stp->sd_lock);
6731 6756
6732 6757 if (STREAM_NEEDSERVICE(stp))
6733 6758 stream_runservice(stp);
6734 6759
6735 6760 /*
6736 6761 * Set HIPRI flag if message is priority.
6737 6762 */
6738 6763 if (type >= QPCTL)
6739 6764 flg = MSG_HIPRI;
6740 6765 else
6741 6766 flg = MSG_BAND;
6742 6767
6743 6768 /*
6744 6769 * First process PROTO or PCPROTO blocks, if any.
6745 6770 */
6746 6771 if (mctl->maxlen >= 0 && type != M_DATA) {
6747 6772 size_t n, bcnt;
6748 6773 char *ubuf;
6749 6774
6750 6775 bcnt = mctl->maxlen;
6751 6776 ubuf = mctl->buf;
6752 6777 while (bp != NULL && bp->b_datap->db_type != M_DATA) {
6753 6778 if ((n = MIN(bcnt, bp->b_wptr - bp->b_rptr)) != 0 &&
6754 6779 copyout(bp->b_rptr, ubuf, n)) {
6755 6780 error = EFAULT;
6756 6781 mutex_enter(&stp->sd_lock);
6757 6782 /*
6758 6783 * clear stream head pri flag based on
6759 6784 * first message type
6760 6785 */
6761 6786 if (type >= QPCTL) {
6762 6787 ASSERT(type == M_PCPROTO);
6763 6788 stp->sd_flag &= ~STRPRI;
6764 6789 }
6765 6790 more = 0;
6766 6791 freemsg(bp);
6767 6792 goto getmout;
6768 6793 }
6769 6794 ubuf += n;
6770 6795 bp->b_rptr += n;
6771 6796 if (bp->b_rptr >= bp->b_wptr) {
6772 6797 nbp = bp;
6773 6798 bp = bp->b_cont;
6774 6799 freeb(nbp);
6775 6800 }
6776 6801 ASSERT(n <= bcnt);
6777 6802 bcnt -= n;
6778 6803 if (bcnt == 0)
6779 6804 break;
6780 6805 }
6781 6806 mctl->len = mctl->maxlen - bcnt;
6782 6807 } else
6783 6808 mctl->len = -1;
6784 6809
6785 6810 if (bp && bp->b_datap->db_type != M_DATA) {
6786 6811 /*
6787 6812 * More PROTO blocks in msg.
6788 6813 */
6789 6814 more |= MORECTL;
6790 6815 savemp = bp;
6791 6816 while (bp && bp->b_datap->db_type != M_DATA) {
6792 6817 savemptail = bp;
6793 6818 bp = bp->b_cont;
6794 6819 }
6795 6820 savemptail->b_cont = NULL;
6796 6821 }
6797 6822
6798 6823 /*
6799 6824 * Now process DATA blocks, if any.
6800 6825 */
6801 6826 if (mdata->maxlen >= 0 && bp) {
6802 6827 /*
6803 6828 * struiocopyout will consume a potential zero-length
6804 6829 * M_DATA even if uio_resid is zero.
6805 6830 */
6806 6831 size_t oldresid = uiop->uio_resid;
6807 6832
6808 6833 bp = struiocopyout(bp, uiop, &error);
6809 6834 if (error != 0) {
6810 6835 mutex_enter(&stp->sd_lock);
6811 6836 /*
6812 6837 * clear stream head hi pri flag based on
6813 6838 * first message
6814 6839 */
6815 6840 if (type >= QPCTL) {
6816 6841 ASSERT(type == M_PCPROTO);
6817 6842 stp->sd_flag &= ~STRPRI;
6818 6843 }
6819 6844 more = 0;
6820 6845 freemsg(savemp);
6821 6846 goto getmout;
6822 6847 }
6823 6848 /*
6824 6849 * (pr == 1) indicates a partial read.
6825 6850 */
6826 6851 if (oldresid > uiop->uio_resid)
6827 6852 pr = 1;
6828 6853 mdata->len = mdata->maxlen - uiop->uio_resid;
6829 6854 } else
6830 6855 mdata->len = -1;
6831 6856
6832 6857 if (bp) { /* more data blocks in msg */
6833 6858 more |= MOREDATA;
6834 6859 if (savemp)
6835 6860 savemptail->b_cont = bp;
6836 6861 else
6837 6862 savemp = bp;
6838 6863 }
6839 6864
6840 6865 mutex_enter(&stp->sd_lock);
6841 6866 if (savemp) {
6842 6867 if (pr && (savemp->b_datap->db_type == M_DATA) &&
6843 6868 msgnodata(savemp)) {
6844 6869 /*
6845 6870 * Avoid queuing a zero-length tail part of
6846 6871 * a message. pr=1 indicates that we read some of
6847 6872 * the message.
6848 6873 */
6849 6874 freemsg(savemp);
6850 6875 more &= ~MOREDATA;
6851 6876 /*
6852 6877 * clear stream head hi pri flag based on
6853 6878 * first message
6854 6879 */
6855 6880 if (type >= QPCTL) {
6856 6881 ASSERT(type == M_PCPROTO);
6857 6882 stp->sd_flag &= ~STRPRI;
6858 6883 }
6859 6884 } else {
6860 6885 savemp->b_band = pri;
6861 6886 /*
6862 6887 * If the first message was HIPRI and the one we're
6863 6888 * putting back isn't, then clear STRPRI, otherwise
6864 6889 * set STRPRI again. Note that we must set STRPRI
6865 6890 * again since the flush logic in strrput_nondata()
6866 6891 * may have cleared it while we had sd_lock dropped.
6867 6892 */
6868 6893 if (type >= QPCTL) {
6869 6894 ASSERT(type == M_PCPROTO);
6870 6895 if (queclass(savemp) < QPCTL)
6871 6896 stp->sd_flag &= ~STRPRI;
6872 6897 else
6873 6898 stp->sd_flag |= STRPRI;
6874 6899 } else if (queclass(savemp) >= QPCTL) {
6875 6900 /*
6876 6901 * The first message was not a HIPRI message,
6877 6902 * but the one we are about to putback is.
6878 6903 * For simplicitly, we do not allow for HIPRI
6879 6904 * messages to be embedded in the message
6880 6905 * body, so just force it to same type as
6881 6906 * first message.
6882 6907 */
6883 6908 ASSERT(type == M_DATA || type == M_PROTO);
6884 6909 ASSERT(savemp->b_datap->db_type == M_PCPROTO);
6885 6910 savemp->b_datap->db_type = type;
6886 6911 }
6887 6912 if (mark != 0) {
6888 6913 savemp->b_flag |= mark & ~_LASTMARK;
6889 6914 if ((mark & _LASTMARK) &&
6890 6915 (stp->sd_mark == NULL)) {
6891 6916 /*
6892 6917 * If another marked message arrived
6893 6918 * while sd_lock was not held sd_mark
6894 6919 * would be non-NULL.
6895 6920 */
6896 6921 stp->sd_mark = savemp;
6897 6922 }
6898 6923 }
6899 6924 putback(stp, q, savemp, pri);
6900 6925 }
6901 6926 } else {
6902 6927 /*
6903 6928 * The complete message was consumed.
6904 6929 *
6905 6930 * If another M_PCPROTO arrived while sd_lock was not held
6906 6931 * it would have been discarded since STRPRI was still set.
6907 6932 *
6908 6933 * Move the MSG*MARKNEXT information
6909 6934 * to the stream head just in case
6910 6935 * the read queue becomes empty.
6911 6936 * clear stream head hi pri flag based on
6912 6937 * first message
6913 6938 *
6914 6939 * If the stream head was at the mark
6915 6940 * (STRATMARK) before we dropped sd_lock above
6916 6941 * and some data was consumed then we have
6917 6942 * moved past the mark thus STRATMARK is
6918 6943 * cleared. However, if a message arrived in
6919 6944 * strrput during the copyout above causing
6920 6945 * STRATMARK to be set we can not clear that
6921 6946 * flag.
6922 6947 */
6923 6948 if (type >= QPCTL) {
6924 6949 ASSERT(type == M_PCPROTO);
6925 6950 stp->sd_flag &= ~STRPRI;
6926 6951 }
6927 6952 if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
6928 6953 if (mark & MSGMARKNEXT) {
6929 6954 stp->sd_flag &= ~STRNOTATMARK;
6930 6955 stp->sd_flag |= STRATMARK;
6931 6956 } else if (mark & MSGNOTMARKNEXT) {
6932 6957 stp->sd_flag &= ~STRATMARK;
6933 6958 stp->sd_flag |= STRNOTATMARK;
6934 6959 } else {
6935 6960 stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
6936 6961 }
6937 6962 } else if (pr && (old_sd_flag & STRATMARK)) {
6938 6963 stp->sd_flag &= ~STRATMARK;
6939 6964 }
6940 6965 }
6941 6966
6942 6967 *flagsp = flg;
6943 6968 *prip = pri;
6944 6969
6945 6970 /*
6946 6971 * Getmsg cleanup processing - if the state of the queue has changed
6947 6972 * some signals may need to be sent and/or poll awakened.
6948 6973 */
6949 6974 getmout:
6950 6975 qbackenable(q, pri);
6951 6976
6952 6977 /*
6953 6978 * We dropped the stream head lock above. Send all M_SIG messages
6954 6979 * before processing stream head for SIGPOLL messages.
6955 6980 */
6956 6981 ASSERT(MUTEX_HELD(&stp->sd_lock));
6957 6982 while ((bp = q->q_first) != NULL &&
6958 6983 (bp->b_datap->db_type == M_SIG)) {
6959 6984 /*
6960 6985 * sd_lock is held so the content of the read queue can not
6961 6986 * change.
6962 6987 */
6963 6988 bp = getq(q);
6964 6989 ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
6965 6990
6966 6991 strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
6967 6992 mutex_exit(&stp->sd_lock);
6968 6993 freemsg(bp);
6969 6994 if (STREAM_NEEDSERVICE(stp))
6970 6995 stream_runservice(stp);
6971 6996 mutex_enter(&stp->sd_lock);
6972 6997 }
6973 6998
6974 6999 /*
6975 7000 * stream head cannot change while we make the determination
6976 7001 * whether or not to send a signal. Drop the flag to allow strrput
6977 7002 * to send firstmsgsigs again.
6978 7003 */
6979 7004 stp->sd_flag &= ~STRGETINPROG;
6980 7005
6981 7006 /*
6982 7007 * If the type of message at the front of the queue changed
6983 7008 * due to the receive the appropriate signals and pollwakeup events
6984 7009 * are generated. The type of changes are:
6985 7010 * Processed a hipri message, q_first is not hipri.
6986 7011 * Processed a band X message, and q_first is band Y.
6987 7012 * The generated signals and pollwakeups are identical to what
6988 7013 * strrput() generates should the message that is now on q_first
6989 7014 * arrive to an empty read queue.
6990 7015 *
6991 7016 * Note: only strrput will send a signal for a hipri message.
6992 7017 */
6993 7018 if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
6994 7019 strsigset_t signals = 0;
6995 7020 strpollset_t pollwakeups = 0;
6996 7021
6997 7022 if (flg & MSG_HIPRI) {
6998 7023 /*
6999 7024 * Removed a hipri message. Regular data at
7000 7025 * the front of the queue.
7001 7026 */
7002 7027 if (bp->b_band == 0) {
7003 7028 signals = S_INPUT | S_RDNORM;
7004 7029 pollwakeups = POLLIN | POLLRDNORM;
7005 7030 } else {
7006 7031 signals = S_INPUT | S_RDBAND;
7007 7032 pollwakeups = POLLIN | POLLRDBAND;
7008 7033 }
7009 7034 } else if (pri != bp->b_band) {
7010 7035 /*
7011 7036 * The band is different for the new q_first.
7012 7037 */
7013 7038 if (bp->b_band == 0) {
7014 7039 signals = S_RDNORM;
7015 7040 pollwakeups = POLLIN | POLLRDNORM;
7016 7041 } else {
7017 7042 signals = S_RDBAND;
7018 7043 pollwakeups = POLLIN | POLLRDBAND;
7019 7044 }
7020 7045 }
7021 7046
7022 7047 if (pollwakeups != 0) {
7023 7048 if (pollwakeups == (POLLIN | POLLRDNORM)) {
7024 7049 if (!(stp->sd_rput_opt & SR_POLLIN))
7025 7050 goto no_pollwake;
7026 7051 stp->sd_rput_opt &= ~SR_POLLIN;
7027 7052 }
7028 7053 mutex_exit(&stp->sd_lock);
7029 7054 pollwakeup(&stp->sd_pollist, pollwakeups);
7030 7055 mutex_enter(&stp->sd_lock);
7031 7056 }
7032 7057 no_pollwake:
7033 7058
7034 7059 if (stp->sd_sigflags & signals)
7035 7060 strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
7036 7061 }
7037 7062 mutex_exit(&stp->sd_lock);
7038 7063
7039 7064 rvp->r_val1 = more;
7040 7065 return (error);
7041 7066 #undef _LASTMARK
7042 7067 }
7043 7068
7044 7069 /*
7045 7070 * Get the next message from the read queue. If the message is
7046 7071 * priority, STRPRI will have been set by strrput(). This flag
7047 7072 * should be reset only when the entire message at the front of the
7048 7073 * queue as been consumed.
7049 7074 *
7050 7075 * If uiop is NULL all data is returned in mctlp.
7051 7076 * Note that a NULL uiop implies that FNDELAY and FNONBLOCK are assumed
7052 7077 * not enabled.
7053 7078 * The timeout parameter is in milliseconds; -1 for infinity.
7054 7079 * This routine handles the consolidation private flags:
7055 7080 * MSG_IGNERROR Ignore any stream head error except STPLEX.
7056 7081 * MSG_DELAYERROR Defer the error check until the queue is empty.
7057 7082 * MSG_HOLDSIG Hold signals while waiting for data.
7058 7083 * MSG_IPEEK Only peek at messages.
7059 7084 * MSG_DISCARDTAIL Discard the tail M_DATA part of the message
7060 7085 * that doesn't fit.
7061 7086 * MSG_NOMARK If the message is marked leave it on the queue.
7062 7087 *
7063 7088 * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
7064 7089 */
7065 7090 int
7066 7091 kstrgetmsg(
7067 7092 struct vnode *vp,
7068 7093 mblk_t **mctlp,
7069 7094 struct uio *uiop,
7070 7095 unsigned char *prip,
7071 7096 int *flagsp,
7072 7097 clock_t timout,
7073 7098 rval_t *rvp)
7074 7099 {
7075 7100 struct stdata *stp;
7076 7101 mblk_t *bp, *nbp;
7077 7102 mblk_t *savemp = NULL;
7078 7103 mblk_t *savemptail = NULL;
7079 7104 int flags;
7080 7105 uint_t old_sd_flag;
7081 7106 int flg;
7082 7107 int more = 0;
7083 7108 int error = 0;
7084 7109 char first = 1;
7085 7110 uint_t mark; /* Contains MSG*MARK and _LASTMARK */
7086 7111 #define _LASTMARK 0x8000 /* Distinct from MSG*MARK */
7087 7112 unsigned char pri = 0;
7088 7113 queue_t *q;
7089 7114 int pr = 0; /* Partial read successful */
7090 7115 unsigned char type;
7091 7116
7092 7117 TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_ENTER,
7093 7118 "kstrgetmsg:%p", vp);
7094 7119
7095 7120 ASSERT(vp->v_stream);
7096 7121 stp = vp->v_stream;
7097 7122 rvp->r_val1 = 0;
7098 7123
7099 7124 mutex_enter(&stp->sd_lock);
7100 7125
7101 7126 if ((error = i_straccess(stp, JCREAD)) != 0) {
7102 7127 mutex_exit(&stp->sd_lock);
7103 7128 return (error);
7104 7129 }
7105 7130
7106 7131 flags = *flagsp;
7107 7132 if (stp->sd_flag & (STRDERR|STPLEX)) {
7108 7133 if ((stp->sd_flag & STPLEX) ||
7109 7134 (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == 0) {
7110 7135 error = strgeterr(stp, STRDERR|STPLEX,
7111 7136 (flags & MSG_IPEEK));
7112 7137 if (error != 0) {
7113 7138 mutex_exit(&stp->sd_lock);
7114 7139 return (error);
7115 7140 }
7116 7141 }
7117 7142 }
7118 7143 mutex_exit(&stp->sd_lock);
7119 7144
7120 7145 switch (flags & (MSG_HIPRI|MSG_ANY|MSG_BAND)) {
7121 7146 case MSG_HIPRI:
7122 7147 if (*prip != 0)
7123 7148 return (EINVAL);
7124 7149 break;
7125 7150
7126 7151 case MSG_ANY:
7127 7152 case MSG_BAND:
7128 7153 break;
7129 7154
7130 7155 default:
7131 7156 return (EINVAL);
7132 7157 }
7133 7158
7134 7159 retry:
7135 7160 q = _RD(stp->sd_wrq);
7136 7161 mutex_enter(&stp->sd_lock);
7137 7162 old_sd_flag = stp->sd_flag;
7138 7163 mark = 0;
7139 7164 for (;;) {
7140 7165 int done = 0;
7141 7166 int waitflag;
7142 7167 int fmode;
7143 7168 mblk_t *q_first = q->q_first;
7144 7169
7145 7170 /*
7146 7171 * This section of the code operates just like the code
7147 7172 * in strgetmsg(). There is a comment there about what
7148 7173 * is going on here.
7149 7174 */
7150 7175 if (!(flags & (MSG_HIPRI|MSG_BAND))) {
7151 7176 /* Asking for normal, band0 data */
7152 7177 bp = strget(stp, q, uiop, first, &error);
7153 7178 ASSERT(MUTEX_HELD(&stp->sd_lock));
7154 7179 if (bp != NULL) {
7155 7180 if (DB_TYPE(bp) == M_SIG) {
7156 7181 strsignal_nolock(stp, *bp->b_rptr,
7157 7182 bp->b_band);
7158 7183 freemsg(bp);
7159 7184 continue;
7160 7185 } else {
7161 7186 break;
7162 7187 }
7163 7188 }
7164 7189 if (error != 0) {
7165 7190 goto getmout;
7166 7191 }
7167 7192 /*
7168 7193 * We can't depend on the value of STRPRI here because
7169 7194 * the stream head may be in transit. Therefore, we
7170 7195 * must look at the type of the first message to
7171 7196 * determine if a high priority messages is waiting
7172 7197 */
7173 7198 } else if ((flags & MSG_HIPRI) && q_first != NULL &&
7174 7199 DB_TYPE(q_first) >= QPCTL &&
7175 7200 (bp = getq_noenab(q, 0)) != NULL) {
7176 7201 ASSERT(DB_TYPE(bp) >= QPCTL);
7177 7202 break;
7178 7203 } else if ((flags & MSG_BAND) && q_first != NULL &&
7179 7204 ((q_first->b_band >= *prip) || DB_TYPE(q_first) >= QPCTL) &&
7180 7205 (bp = getq_noenab(q, 0)) != NULL) {
7181 7206 /*
7182 7207 * Asked for at least band "prip" and got either at
7183 7208 * least that band or a hipri message.
7184 7209 */
7185 7210 ASSERT(bp->b_band >= *prip || DB_TYPE(bp) >= QPCTL);
7186 7211 if (DB_TYPE(bp) == M_SIG) {
7187 7212 strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
7188 7213 freemsg(bp);
7189 7214 continue;
7190 7215 } else {
7191 7216 break;
7192 7217 }
7193 7218 }
7194 7219
7195 7220 /* No data. Time to sleep? */
7196 7221 qbackenable(q, 0);
7197 7222
7198 7223 /*
7199 7224 * Delayed error notification?
7200 7225 */
7201 7226 if ((stp->sd_flag & (STRDERR|STPLEX)) &&
7202 7227 (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == MSG_DELAYERROR) {
7203 7228 error = strgeterr(stp, STRDERR|STPLEX,
7204 7229 (flags & MSG_IPEEK));
7205 7230 if (error != 0) {
7206 7231 mutex_exit(&stp->sd_lock);
7207 7232 return (error);
7208 7233 }
7209 7234 }
7210 7235
7211 7236 /*
7212 7237 * If STRHUP or STREOF, return 0 length control and data.
7213 7238 * If a read(fd,buf,0) has been done, do not sleep, just
7214 7239 * return.
7215 7240 *
7216 7241 * If mctlp == NULL and uiop == NULL, then the code will
7217 7242 * do the strwaitq. This is an understood way of saying
7218 7243 * sleep "polling" until a message is received.
7219 7244 */
7220 7245 if ((stp->sd_flag & (STRHUP|STREOF)) ||
7221 7246 (uiop != NULL && uiop->uio_resid == 0)) {
7222 7247 if (mctlp != NULL)
7223 7248 *mctlp = NULL;
7224 7249 *flagsp = 0;
7225 7250 mutex_exit(&stp->sd_lock);
7226 7251 return (0);
7227 7252 }
7228 7253
7229 7254 waitflag = GETWAIT;
7230 7255 if (flags &
7231 7256 (MSG_HOLDSIG|MSG_IGNERROR|MSG_IPEEK|MSG_DELAYERROR)) {
7232 7257 if (flags & MSG_HOLDSIG)
7233 7258 waitflag |= STR_NOSIG;
7234 7259 if (flags & MSG_IGNERROR)
7235 7260 waitflag |= STR_NOERROR;
7236 7261 if (flags & MSG_IPEEK)
7237 7262 waitflag |= STR_PEEK;
7238 7263 if (flags & MSG_DELAYERROR)
7239 7264 waitflag |= STR_DELAYERR;
7240 7265 }
7241 7266 if (uiop != NULL)
7242 7267 fmode = uiop->uio_fmode;
7243 7268 else
7244 7269 fmode = 0;
7245 7270
7246 7271 TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_WAIT,
7247 7272 "kstrgetmsg calls strwaitq:%p, %p",
7248 7273 vp, uiop);
7249 7274 if (((error = strwaitq(stp, waitflag, (ssize_t)0,
7250 7275 fmode, timout, &done))) != 0 || done) {
7251 7276 TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_DONE,
7252 7277 "kstrgetmsg error or done:%p, %p",
7253 7278 vp, uiop);
7254 7279 mutex_exit(&stp->sd_lock);
7255 7280 return (error);
7256 7281 }
7257 7282 TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_AWAKE,
7258 7283 "kstrgetmsg awakes:%p, %p", vp, uiop);
7259 7284 if ((error = i_straccess(stp, JCREAD)) != 0) {
7260 7285 mutex_exit(&stp->sd_lock);
7261 7286 return (error);
7262 7287 }
7263 7288 first = 0;
7264 7289 }
7265 7290 ASSERT(bp != NULL);
7266 7291 /*
7267 7292 * Extract any mark information. If the message is not completely
7268 7293 * consumed this information will be put in the mblk
7269 7294 * that is putback.
7270 7295 * If MSGMARKNEXT is set and the message is completely consumed
7271 7296 * the STRATMARK flag will be set below. Likewise, if
7272 7297 * MSGNOTMARKNEXT is set and the message is
7273 7298 * completely consumed STRNOTATMARK will be set.
7274 7299 */
7275 7300 mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
7276 7301 ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
7277 7302 (MSGMARKNEXT|MSGNOTMARKNEXT));
7278 7303 pri = bp->b_band;
7279 7304 if (mark != 0) {
7280 7305 /*
7281 7306 * If the caller doesn't want the mark return.
7282 7307 * Used to implement MSG_WAITALL in sockets.
7283 7308 */
7284 7309 if (flags & MSG_NOMARK) {
7285 7310 putback(stp, q, bp, pri);
7286 7311 qbackenable(q, pri);
7287 7312 mutex_exit(&stp->sd_lock);
7288 7313 return (EWOULDBLOCK);
7289 7314 }
7290 7315 if (bp == stp->sd_mark) {
7291 7316 mark |= _LASTMARK;
7292 7317 stp->sd_mark = NULL;
7293 7318 }
7294 7319 }
7295 7320
7296 7321 /*
7297 7322 * keep track of the first message type
7298 7323 */
7299 7324 type = bp->b_datap->db_type;
7300 7325
7301 7326 if (bp->b_datap->db_type == M_PASSFP) {
7302 7327 if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
7303 7328 stp->sd_mark = bp;
7304 7329 bp->b_flag |= mark & ~_LASTMARK;
7305 7330 putback(stp, q, bp, pri);
7306 7331 qbackenable(q, pri);
7307 7332 mutex_exit(&stp->sd_lock);
7308 7333 return (EBADMSG);
7309 7334 }
7310 7335 ASSERT(type != M_SIG);
7311 7336
7312 7337 if (flags & MSG_IPEEK) {
7313 7338 /*
7314 7339 * Clear any struioflag - we do the uiomove over again
7315 7340 * when peeking since it simplifies the code.
7316 7341 *
7317 7342 * Dup the message and put the original back on the queue.
7318 7343 * If dupmsg() fails, try again with copymsg() to see if
7319 7344 * there is indeed a shortage of memory. dupmsg() may fail
7320 7345 * if db_ref in any of the messages reaches its limit.
7321 7346 */
7322 7347
7323 7348 if ((nbp = dupmsg(bp)) == NULL && (nbp = copymsg(bp)) == NULL) {
7324 7349 /*
7325 7350 * Restore the state of the stream head since we
7326 7351 * need to drop sd_lock (strwaitbuf is sleeping).
7327 7352 */
7328 7353 size_t size = msgdsize(bp);
7329 7354
7330 7355 if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
7331 7356 stp->sd_mark = bp;
7332 7357 bp->b_flag |= mark & ~_LASTMARK;
7333 7358 putback(stp, q, bp, pri);
7334 7359 mutex_exit(&stp->sd_lock);
7335 7360 error = strwaitbuf(size, BPRI_HI);
7336 7361 if (error) {
7337 7362 /*
7338 7363 * There is no net change to the queue thus
7339 7364 * no need to qbackenable.
7340 7365 */
7341 7366 return (error);
7342 7367 }
7343 7368 goto retry;
7344 7369 }
7345 7370
7346 7371 if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
7347 7372 stp->sd_mark = bp;
7348 7373 bp->b_flag |= mark & ~_LASTMARK;
7349 7374 putback(stp, q, bp, pri);
7350 7375 bp = nbp;
7351 7376 }
7352 7377
7353 7378 /*
7354 7379 * Set this flag so strrput will not generate signals. Need to
7355 7380 * make sure this flag is cleared before leaving this routine
7356 7381 * else signals will stop being sent.
7357 7382 */
7358 7383 stp->sd_flag |= STRGETINPROG;
7359 7384 mutex_exit(&stp->sd_lock);
7360 7385
7361 7386 if ((stp->sd_rputdatafunc != NULL) && (DB_TYPE(bp) == M_DATA)) {
7362 7387 mblk_t *tmp, *prevmp;
7363 7388
7364 7389 /*
7365 7390 * Put first non-data mblk back to stream head and
7366 7391 * cut the mblk chain so sd_rputdatafunc only sees
7367 7392 * M_DATA mblks. We can skip the first mblk since it
7368 7393 * is M_DATA according to the condition above.
7369 7394 */
7370 7395 for (prevmp = bp, tmp = bp->b_cont; tmp != NULL;
7371 7396 prevmp = tmp, tmp = tmp->b_cont) {
7372 7397 if (DB_TYPE(tmp) != M_DATA) {
7373 7398 prevmp->b_cont = NULL;
7374 7399 mutex_enter(&stp->sd_lock);
7375 7400 putback(stp, q, tmp, tmp->b_band);
7376 7401 mutex_exit(&stp->sd_lock);
7377 7402 break;
7378 7403 }
7379 7404 }
7380 7405
7381 7406 bp = (stp->sd_rputdatafunc)(stp->sd_vnode, bp,
7382 7407 NULL, NULL, NULL, NULL);
7383 7408
7384 7409 if (bp == NULL)
7385 7410 goto retry;
7386 7411 }
7387 7412
7388 7413 if (STREAM_NEEDSERVICE(stp))
7389 7414 stream_runservice(stp);
7390 7415
7391 7416 /*
7392 7417 * Set HIPRI flag if message is priority.
7393 7418 */
7394 7419 if (type >= QPCTL)
7395 7420 flg = MSG_HIPRI;
7396 7421 else
7397 7422 flg = MSG_BAND;
7398 7423
7399 7424 /*
7400 7425 * First process PROTO or PCPROTO blocks, if any.
7401 7426 */
7402 7427 if (mctlp != NULL && type != M_DATA) {
7403 7428 mblk_t *nbp;
7404 7429
7405 7430 *mctlp = bp;
7406 7431 while (bp->b_cont && bp->b_cont->b_datap->db_type != M_DATA)
7407 7432 bp = bp->b_cont;
7408 7433 nbp = bp->b_cont;
7409 7434 bp->b_cont = NULL;
7410 7435 bp = nbp;
7411 7436 }
7412 7437
7413 7438 if (bp && bp->b_datap->db_type != M_DATA) {
7414 7439 /*
7415 7440 * More PROTO blocks in msg. Will only happen if mctlp is NULL.
7416 7441 */
7417 7442 more |= MORECTL;
7418 7443 savemp = bp;
7419 7444 while (bp && bp->b_datap->db_type != M_DATA) {
7420 7445 savemptail = bp;
7421 7446 bp = bp->b_cont;
7422 7447 }
7423 7448 savemptail->b_cont = NULL;
7424 7449 }
7425 7450
7426 7451 /*
7427 7452 * Now process DATA blocks, if any.
7428 7453 */
7429 7454 if (uiop == NULL) {
7430 7455 /* Append data to tail of mctlp */
7431 7456
7432 7457 if (mctlp != NULL) {
7433 7458 mblk_t **mpp = mctlp;
7434 7459
7435 7460 while (*mpp != NULL)
7436 7461 mpp = &((*mpp)->b_cont);
7437 7462 *mpp = bp;
7438 7463 bp = NULL;
7439 7464 }
7440 7465 } else if (uiop->uio_resid >= 0 && bp) {
7441 7466 size_t oldresid = uiop->uio_resid;
7442 7467
7443 7468 /*
7444 7469 * If a streams message is likely to consist
7445 7470 * of many small mblks, it is pulled up into
7446 7471 * one continuous chunk of memory.
7447 7472 * The size of the first mblk may be bogus because
7448 7473 * successive read() calls on the socket reduce
7449 7474 * the size of this mblk until it is exhausted
7450 7475 * and then the code walks on to the next. Thus
7451 7476 * the size of the mblk may not be the original size
7452 7477 * that was passed up, it's simply a remainder
7453 7478 * and hence can be very small without any
7454 7479 * implication that the packet is badly fragmented.
7455 7480 * So the size of the possible second mblk is
7456 7481 * used to spot a badly fragmented packet.
7457 7482 * see longer comment at top of page
7458 7483 * by mblk_pull_len declaration.
7459 7484 */
7460 7485
7461 7486 if (bp->b_cont != NULL && MBLKL(bp->b_cont) < mblk_pull_len) {
7462 7487 (void) pullupmsg(bp, -1);
7463 7488 }
7464 7489
7465 7490 bp = struiocopyout(bp, uiop, &error);
7466 7491 if (error != 0) {
7467 7492 if (mctlp != NULL) {
7468 7493 freemsg(*mctlp);
7469 7494 *mctlp = NULL;
7470 7495 } else
7471 7496 freemsg(savemp);
7472 7497 mutex_enter(&stp->sd_lock);
7473 7498 /*
7474 7499 * clear stream head hi pri flag based on
7475 7500 * first message
7476 7501 */
7477 7502 if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
7478 7503 ASSERT(type == M_PCPROTO);
7479 7504 stp->sd_flag &= ~STRPRI;
7480 7505 }
7481 7506 more = 0;
7482 7507 goto getmout;
7483 7508 }
7484 7509 /*
7485 7510 * (pr == 1) indicates a partial read.
7486 7511 */
7487 7512 if (oldresid > uiop->uio_resid)
7488 7513 pr = 1;
7489 7514 }
7490 7515
7491 7516 if (bp) { /* more data blocks in msg */
7492 7517 more |= MOREDATA;
7493 7518 if (savemp)
7494 7519 savemptail->b_cont = bp;
7495 7520 else
7496 7521 savemp = bp;
7497 7522 }
7498 7523
7499 7524 mutex_enter(&stp->sd_lock);
7500 7525 if (savemp) {
7501 7526 if (flags & (MSG_IPEEK|MSG_DISCARDTAIL)) {
7502 7527 /*
7503 7528 * When MSG_DISCARDTAIL is set or
7504 7529 * when peeking discard any tail. When peeking this
7505 7530 * is the tail of the dup that was copied out - the
7506 7531 * message has already been putback on the queue.
7507 7532 * Return MOREDATA to the caller even though the data
7508 7533 * is discarded. This is used by sockets (to
7509 7534 * set MSG_TRUNC).
7510 7535 */
7511 7536 freemsg(savemp);
7512 7537 if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
7513 7538 ASSERT(type == M_PCPROTO);
7514 7539 stp->sd_flag &= ~STRPRI;
7515 7540 }
7516 7541 } else if (pr && (savemp->b_datap->db_type == M_DATA) &&
7517 7542 msgnodata(savemp)) {
7518 7543 /*
7519 7544 * Avoid queuing a zero-length tail part of
7520 7545 * a message. pr=1 indicates that we read some of
7521 7546 * the message.
7522 7547 */
7523 7548 freemsg(savemp);
7524 7549 more &= ~MOREDATA;
7525 7550 if (type >= QPCTL) {
7526 7551 ASSERT(type == M_PCPROTO);
7527 7552 stp->sd_flag &= ~STRPRI;
7528 7553 }
7529 7554 } else {
7530 7555 savemp->b_band = pri;
7531 7556 /*
7532 7557 * If the first message was HIPRI and the one we're
7533 7558 * putting back isn't, then clear STRPRI, otherwise
7534 7559 * set STRPRI again. Note that we must set STRPRI
7535 7560 * again since the flush logic in strrput_nondata()
7536 7561 * may have cleared it while we had sd_lock dropped.
7537 7562 */
7538 7563
7539 7564 if (type >= QPCTL) {
7540 7565 ASSERT(type == M_PCPROTO);
7541 7566 if (queclass(savemp) < QPCTL)
7542 7567 stp->sd_flag &= ~STRPRI;
7543 7568 else
7544 7569 stp->sd_flag |= STRPRI;
7545 7570 } else if (queclass(savemp) >= QPCTL) {
7546 7571 /*
7547 7572 * The first message was not a HIPRI message,
7548 7573 * but the one we are about to putback is.
7549 7574 * For simplicitly, we do not allow for HIPRI
7550 7575 * messages to be embedded in the message
7551 7576 * body, so just force it to same type as
7552 7577 * first message.
7553 7578 */
7554 7579 ASSERT(type == M_DATA || type == M_PROTO);
7555 7580 ASSERT(savemp->b_datap->db_type == M_PCPROTO);
7556 7581 savemp->b_datap->db_type = type;
7557 7582 }
7558 7583 if (mark != 0) {
7559 7584 if ((mark & _LASTMARK) &&
7560 7585 (stp->sd_mark == NULL)) {
7561 7586 /*
7562 7587 * If another marked message arrived
7563 7588 * while sd_lock was not held sd_mark
7564 7589 * would be non-NULL.
7565 7590 */
7566 7591 stp->sd_mark = savemp;
7567 7592 }
7568 7593 savemp->b_flag |= mark & ~_LASTMARK;
7569 7594 }
7570 7595 putback(stp, q, savemp, pri);
7571 7596 }
7572 7597 } else if (!(flags & MSG_IPEEK)) {
7573 7598 /*
7574 7599 * The complete message was consumed.
7575 7600 *
7576 7601 * If another M_PCPROTO arrived while sd_lock was not held
7577 7602 * it would have been discarded since STRPRI was still set.
7578 7603 *
7579 7604 * Move the MSG*MARKNEXT information
7580 7605 * to the stream head just in case
7581 7606 * the read queue becomes empty.
7582 7607 * clear stream head hi pri flag based on
7583 7608 * first message
7584 7609 *
7585 7610 * If the stream head was at the mark
7586 7611 * (STRATMARK) before we dropped sd_lock above
7587 7612 * and some data was consumed then we have
7588 7613 * moved past the mark thus STRATMARK is
7589 7614 * cleared. However, if a message arrived in
7590 7615 * strrput during the copyout above causing
7591 7616 * STRATMARK to be set we can not clear that
7592 7617 * flag.
7593 7618 * XXX A "perimeter" would help by single-threading strrput,
7594 7619 * strread, strgetmsg and kstrgetmsg.
7595 7620 */
7596 7621 if (type >= QPCTL) {
7597 7622 ASSERT(type == M_PCPROTO);
7598 7623 stp->sd_flag &= ~STRPRI;
7599 7624 }
7600 7625 if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
7601 7626 if (mark & MSGMARKNEXT) {
7602 7627 stp->sd_flag &= ~STRNOTATMARK;
7603 7628 stp->sd_flag |= STRATMARK;
7604 7629 } else if (mark & MSGNOTMARKNEXT) {
7605 7630 stp->sd_flag &= ~STRATMARK;
7606 7631 stp->sd_flag |= STRNOTATMARK;
7607 7632 } else {
7608 7633 stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
7609 7634 }
7610 7635 } else if (pr && (old_sd_flag & STRATMARK)) {
7611 7636 stp->sd_flag &= ~STRATMARK;
7612 7637 }
7613 7638 }
7614 7639
7615 7640 *flagsp = flg;
7616 7641 *prip = pri;
7617 7642
7618 7643 /*
7619 7644 * Getmsg cleanup processing - if the state of the queue has changed
7620 7645 * some signals may need to be sent and/or poll awakened.
7621 7646 */
7622 7647 getmout:
7623 7648 qbackenable(q, pri);
7624 7649
7625 7650 /*
7626 7651 * We dropped the stream head lock above. Send all M_SIG messages
7627 7652 * before processing stream head for SIGPOLL messages.
7628 7653 */
7629 7654 ASSERT(MUTEX_HELD(&stp->sd_lock));
7630 7655 while ((bp = q->q_first) != NULL &&
7631 7656 (bp->b_datap->db_type == M_SIG)) {
7632 7657 /*
7633 7658 * sd_lock is held so the content of the read queue can not
7634 7659 * change.
7635 7660 */
7636 7661 bp = getq(q);
7637 7662 ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
7638 7663
7639 7664 strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
7640 7665 mutex_exit(&stp->sd_lock);
7641 7666 freemsg(bp);
7642 7667 if (STREAM_NEEDSERVICE(stp))
7643 7668 stream_runservice(stp);
7644 7669 mutex_enter(&stp->sd_lock);
7645 7670 }
7646 7671
7647 7672 /*
7648 7673 * stream head cannot change while we make the determination
7649 7674 * whether or not to send a signal. Drop the flag to allow strrput
7650 7675 * to send firstmsgsigs again.
7651 7676 */
7652 7677 stp->sd_flag &= ~STRGETINPROG;
7653 7678
7654 7679 /*
7655 7680 * If the type of message at the front of the queue changed
7656 7681 * due to the receive the appropriate signals and pollwakeup events
7657 7682 * are generated. The type of changes are:
7658 7683 * Processed a hipri message, q_first is not hipri.
7659 7684 * Processed a band X message, and q_first is band Y.
7660 7685 * The generated signals and pollwakeups are identical to what
7661 7686 * strrput() generates should the message that is now on q_first
7662 7687 * arrive to an empty read queue.
7663 7688 *
7664 7689 * Note: only strrput will send a signal for a hipri message.
7665 7690 */
7666 7691 if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
7667 7692 strsigset_t signals = 0;
7668 7693 strpollset_t pollwakeups = 0;
7669 7694
7670 7695 if (flg & MSG_HIPRI) {
7671 7696 /*
7672 7697 * Removed a hipri message. Regular data at
7673 7698 * the front of the queue.
7674 7699 */
7675 7700 if (bp->b_band == 0) {
7676 7701 signals = S_INPUT | S_RDNORM;
7677 7702 pollwakeups = POLLIN | POLLRDNORM;
7678 7703 } else {
7679 7704 signals = S_INPUT | S_RDBAND;
7680 7705 pollwakeups = POLLIN | POLLRDBAND;
7681 7706 }
7682 7707 } else if (pri != bp->b_band) {
7683 7708 /*
7684 7709 * The band is different for the new q_first.
7685 7710 */
7686 7711 if (bp->b_band == 0) {
7687 7712 signals = S_RDNORM;
7688 7713 pollwakeups = POLLIN | POLLRDNORM;
7689 7714 } else {
7690 7715 signals = S_RDBAND;
7691 7716 pollwakeups = POLLIN | POLLRDBAND;
7692 7717 }
7693 7718 }
7694 7719
7695 7720 if (pollwakeups != 0) {
7696 7721 if (pollwakeups == (POLLIN | POLLRDNORM)) {
7697 7722 if (!(stp->sd_rput_opt & SR_POLLIN))
7698 7723 goto no_pollwake;
7699 7724 stp->sd_rput_opt &= ~SR_POLLIN;
7700 7725 }
7701 7726 mutex_exit(&stp->sd_lock);
7702 7727 pollwakeup(&stp->sd_pollist, pollwakeups);
7703 7728 mutex_enter(&stp->sd_lock);
7704 7729 }
7705 7730 no_pollwake:
7706 7731
7707 7732 if (stp->sd_sigflags & signals)
7708 7733 strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
7709 7734 }
7710 7735 mutex_exit(&stp->sd_lock);
7711 7736
7712 7737 rvp->r_val1 = more;
7713 7738 return (error);
7714 7739 #undef _LASTMARK
7715 7740 }
7716 7741
7717 7742 /*
7718 7743 * Put a message downstream.
7719 7744 *
7720 7745 * NOTE: strputmsg and kstrputmsg have much of the logic in common.
7721 7746 */
7722 7747 int
7723 7748 strputmsg(
7724 7749 struct vnode *vp,
7725 7750 struct strbuf *mctl,
7726 7751 struct strbuf *mdata,
7727 7752 unsigned char pri,
7728 7753 int flag,
7729 7754 int fmode)
7730 7755 {
7731 7756 struct stdata *stp;
7732 7757 queue_t *wqp;
7733 7758 mblk_t *mp;
7734 7759 ssize_t msgsize;
7735 7760 ssize_t rmin, rmax;
7736 7761 int error;
7737 7762 struct uio uios;
7738 7763 struct uio *uiop = &uios;
7739 7764 struct iovec iovs;
7740 7765 int xpg4 = 0;
7741 7766
7742 7767 ASSERT(vp->v_stream);
7743 7768 stp = vp->v_stream;
7744 7769 wqp = stp->sd_wrq;
7745 7770
7746 7771 /*
7747 7772 * If it is an XPG4 application, we need to send
7748 7773 * SIGPIPE below
7749 7774 */
7750 7775
7751 7776 xpg4 = (flag & MSG_XPG4) ? 1 : 0;
7752 7777 flag &= ~MSG_XPG4;
7753 7778
7754 7779 if (AU_AUDITING())
7755 7780 audit_strputmsg(vp, mctl, mdata, pri, flag, fmode);
7756 7781
7757 7782 mutex_enter(&stp->sd_lock);
7758 7783
7759 7784 if ((error = i_straccess(stp, JCWRITE)) != 0) {
7760 7785 mutex_exit(&stp->sd_lock);
7761 7786 return (error);
7762 7787 }
7763 7788
7764 7789 if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
7765 7790 error = strwriteable(stp, B_FALSE, xpg4);
7766 7791 if (error != 0) {
7767 7792 mutex_exit(&stp->sd_lock);
7768 7793 return (error);
7769 7794 }
7770 7795 }
7771 7796
7772 7797 mutex_exit(&stp->sd_lock);
7773 7798
7774 7799 /*
7775 7800 * Check for legal flag value.
7776 7801 */
7777 7802 switch (flag) {
7778 7803 case MSG_HIPRI:
7779 7804 if ((mctl->len < 0) || (pri != 0))
7780 7805 return (EINVAL);
7781 7806 break;
7782 7807 case MSG_BAND:
7783 7808 break;
7784 7809
7785 7810 default:
7786 7811 return (EINVAL);
7787 7812 }
7788 7813
7789 7814 TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_IN,
7790 7815 "strputmsg in:stp %p", stp);
7791 7816
7792 7817 /* get these values from those cached in the stream head */
7793 7818 rmin = stp->sd_qn_minpsz;
7794 7819 rmax = stp->sd_qn_maxpsz;
7795 7820
7796 7821 /*
7797 7822 * Make sure ctl and data sizes together fall within the
7798 7823 * limits of the max and min receive packet sizes and do
7799 7824 * not exceed system limit.
7800 7825 */
7801 7826 ASSERT((rmax >= 0) || (rmax == INFPSZ));
7802 7827 if (rmax == 0) {
7803 7828 return (ERANGE);
7804 7829 }
7805 7830 /*
7806 7831 * Use the MAXIMUM of sd_maxblk and q_maxpsz.
7807 7832 * Needed to prevent partial failures in the strmakedata loop.
7808 7833 */
7809 7834 if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
7810 7835 rmax = stp->sd_maxblk;
7811 7836
7812 7837 if ((msgsize = mdata->len) < 0) {
7813 7838 msgsize = 0;
7814 7839 rmin = 0; /* no range check for NULL data part */
7815 7840 }
7816 7841 if ((msgsize < rmin) ||
7817 7842 ((msgsize > rmax) && (rmax != INFPSZ)) ||
7818 7843 (mctl->len > strctlsz)) {
7819 7844 return (ERANGE);
7820 7845 }
7821 7846
7822 7847 /*
7823 7848 * Setup uio and iov for data part
7824 7849 */
7825 7850 iovs.iov_base = mdata->buf;
7826 7851 iovs.iov_len = msgsize;
7827 7852 uios.uio_iov = &iovs;
7828 7853 uios.uio_iovcnt = 1;
7829 7854 uios.uio_loffset = 0;
7830 7855 uios.uio_segflg = UIO_USERSPACE;
7831 7856 uios.uio_fmode = fmode;
7832 7857 uios.uio_extflg = UIO_COPY_DEFAULT;
7833 7858 uios.uio_resid = msgsize;
7834 7859 uios.uio_offset = 0;
7835 7860
7836 7861 /* Ignore flow control in strput for HIPRI */
7837 7862 if (flag & MSG_HIPRI)
7838 7863 flag |= MSG_IGNFLOW;
7839 7864
7840 7865 for (;;) {
7841 7866 int done = 0;
7842 7867
7843 7868 /*
7844 7869 * strput will always free the ctl mblk - even when strput
7845 7870 * fails.
7846 7871 */
7847 7872 if ((error = strmakectl(mctl, flag, fmode, &mp)) != 0) {
7848 7873 TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
7849 7874 "strputmsg out:stp %p out %d error %d",
7850 7875 stp, 1, error);
7851 7876 return (error);
7852 7877 }
7853 7878 /*
7854 7879 * Verify that the whole message can be transferred by
7855 7880 * strput.
7856 7881 */
7857 7882 ASSERT(stp->sd_maxblk == INFPSZ ||
7858 7883 stp->sd_maxblk >= mdata->len);
7859 7884
7860 7885 msgsize = mdata->len;
7861 7886 error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
7862 7887 mdata->len = msgsize;
7863 7888
7864 7889 if (error == 0)
7865 7890 break;
7866 7891
7867 7892 if (error != EWOULDBLOCK)
7868 7893 goto out;
7869 7894
7870 7895 mutex_enter(&stp->sd_lock);
7871 7896 /*
7872 7897 * Check for a missed wakeup.
7873 7898 * Needed since strput did not hold sd_lock across
7874 7899 * the canputnext.
7875 7900 */
7876 7901 if (bcanputnext(wqp, pri)) {
7877 7902 /* Try again */
7878 7903 mutex_exit(&stp->sd_lock);
7879 7904 continue;
7880 7905 }
7881 7906 TRACE_2(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAIT,
7882 7907 "strputmsg wait:stp %p waits pri %d", stp, pri);
7883 7908 if (((error = strwaitq(stp, WRITEWAIT, (ssize_t)0, fmode, -1,
7884 7909 &done)) != 0) || done) {
7885 7910 mutex_exit(&stp->sd_lock);
7886 7911 TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
7887 7912 "strputmsg out:q %p out %d error %d",
7888 7913 stp, 0, error);
7889 7914 return (error);
7890 7915 }
7891 7916 TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAKE,
7892 7917 "strputmsg wake:stp %p wakes", stp);
7893 7918 if ((error = i_straccess(stp, JCWRITE)) != 0) {
7894 7919 mutex_exit(&stp->sd_lock);
7895 7920 return (error);
7896 7921 }
7897 7922 mutex_exit(&stp->sd_lock);
7898 7923 }
7899 7924 out:
7900 7925 /*
7901 7926 * For historic reasons, applications expect EAGAIN
7902 7927 * when data mblk could not be allocated. so change
7903 7928 * ENOMEM back to EAGAIN
7904 7929 */
7905 7930 if (error == ENOMEM)
7906 7931 error = EAGAIN;
7907 7932 TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
7908 7933 "strputmsg out:stp %p out %d error %d", stp, 2, error);
7909 7934 return (error);
7910 7935 }
7911 7936
7912 7937 /*
7913 7938 * Put a message downstream.
7914 7939 * Can send only an M_PROTO/M_PCPROTO by passing in a NULL uiop.
7915 7940 * The fmode flag (NDELAY, NONBLOCK) is the or of the flags in the uio
7916 7941 * and the fmode parameter.
7917 7942 *
7918 7943 * This routine handles the consolidation private flags:
7919 7944 * MSG_IGNERROR Ignore any stream head error except STPLEX.
7920 7945 * MSG_HOLDSIG Hold signals while waiting for data.
7921 7946 * MSG_IGNFLOW Don't check streams flow control.
7922 7947 *
7923 7948 * NOTE: strputmsg and kstrputmsg have much of the logic in common.
7924 7949 */
7925 7950 int
7926 7951 kstrputmsg(
7927 7952 struct vnode *vp,
7928 7953 mblk_t *mctl,
7929 7954 struct uio *uiop,
7930 7955 ssize_t msgsize,
7931 7956 unsigned char pri,
7932 7957 int flag,
7933 7958 int fmode)
7934 7959 {
7935 7960 struct stdata *stp;
7936 7961 queue_t *wqp;
7937 7962 ssize_t rmin, rmax;
7938 7963 int error;
7939 7964
7940 7965 ASSERT(vp->v_stream);
7941 7966 stp = vp->v_stream;
7942 7967 wqp = stp->sd_wrq;
7943 7968 if (AU_AUDITING())
7944 7969 audit_strputmsg(vp, NULL, NULL, pri, flag, fmode);
7945 7970 if (mctl == NULL)
7946 7971 return (EINVAL);
7947 7972
7948 7973 mutex_enter(&stp->sd_lock);
7949 7974
7950 7975 if ((error = i_straccess(stp, JCWRITE)) != 0) {
7951 7976 mutex_exit(&stp->sd_lock);
7952 7977 freemsg(mctl);
7953 7978 return (error);
7954 7979 }
7955 7980
7956 7981 if ((stp->sd_flag & STPLEX) || !(flag & MSG_IGNERROR)) {
7957 7982 if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
7958 7983 error = strwriteable(stp, B_FALSE, B_TRUE);
7959 7984 if (error != 0) {
7960 7985 mutex_exit(&stp->sd_lock);
7961 7986 freemsg(mctl);
7962 7987 return (error);
7963 7988 }
7964 7989 }
7965 7990 }
7966 7991
7967 7992 mutex_exit(&stp->sd_lock);
7968 7993
7969 7994 /*
7970 7995 * Check for legal flag value.
7971 7996 */
7972 7997 switch (flag & (MSG_HIPRI|MSG_BAND|MSG_ANY)) {
7973 7998 case MSG_HIPRI:
7974 7999 if (pri != 0) {
7975 8000 freemsg(mctl);
7976 8001 return (EINVAL);
7977 8002 }
7978 8003 break;
7979 8004 case MSG_BAND:
7980 8005 break;
7981 8006 default:
7982 8007 freemsg(mctl);
7983 8008 return (EINVAL);
7984 8009 }
7985 8010
7986 8011 TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_IN,
7987 8012 "kstrputmsg in:stp %p", stp);
7988 8013
7989 8014 /* get these values from those cached in the stream head */
7990 8015 rmin = stp->sd_qn_minpsz;
7991 8016 rmax = stp->sd_qn_maxpsz;
7992 8017
7993 8018 /*
7994 8019 * Make sure ctl and data sizes together fall within the
7995 8020 * limits of the max and min receive packet sizes and do
7996 8021 * not exceed system limit.
7997 8022 */
7998 8023 ASSERT((rmax >= 0) || (rmax == INFPSZ));
7999 8024 if (rmax == 0) {
8000 8025 freemsg(mctl);
8001 8026 return (ERANGE);
8002 8027 }
8003 8028 /*
8004 8029 * Use the MAXIMUM of sd_maxblk and q_maxpsz.
8005 8030 * Needed to prevent partial failures in the strmakedata loop.
8006 8031 */
8007 8032 if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
8008 8033 rmax = stp->sd_maxblk;
8009 8034
8010 8035 if (uiop == NULL) {
8011 8036 msgsize = -1;
8012 8037 rmin = -1; /* no range check for NULL data part */
8013 8038 } else {
8014 8039 /* Use uio flags as well as the fmode parameter flags */
8015 8040 fmode |= uiop->uio_fmode;
8016 8041
8017 8042 if ((msgsize < rmin) ||
8018 8043 ((msgsize > rmax) && (rmax != INFPSZ))) {
8019 8044 freemsg(mctl);
8020 8045 return (ERANGE);
8021 8046 }
8022 8047 }
8023 8048
8024 8049 /* Ignore flow control in strput for HIPRI */
8025 8050 if (flag & MSG_HIPRI)
8026 8051 flag |= MSG_IGNFLOW;
8027 8052
8028 8053 for (;;) {
8029 8054 int done = 0;
8030 8055 int waitflag;
8031 8056 mblk_t *mp;
8032 8057
8033 8058 /*
8034 8059 * strput will always free the ctl mblk - even when strput
8035 8060 * fails. If MSG_IGNFLOW is set then any error returned
8036 8061 * will cause us to break the loop, so we don't need a copy
8037 8062 * of the message. If MSG_IGNFLOW is not set, then we can
8038 8063 * get hit by flow control and be forced to try again. In
8039 8064 * this case we need to have a copy of the message. We
8040 8065 * do this using copymsg since the message may get modified
8041 8066 * by something below us.
8042 8067 *
8043 8068 * We've observed that many TPI providers do not check db_ref
8044 8069 * on the control messages but blindly reuse them for the
8045 8070 * T_OK_ACK/T_ERROR_ACK. Thus using copymsg is more
8046 8071 * friendly to such providers than using dupmsg. Also, note
8047 8072 * that sockfs uses MSG_IGNFLOW for all TPI control messages.
8048 8073 * Only data messages are subject to flow control, hence
8049 8074 * subject to this copymsg.
8050 8075 */
8051 8076 if (flag & MSG_IGNFLOW) {
8052 8077 mp = mctl;
8053 8078 mctl = NULL;
8054 8079 } else {
8055 8080 do {
8056 8081 /*
8057 8082 * If a message has a free pointer, the message
8058 8083 * must be dupmsg to maintain this pointer.
8059 8084 * Code using this facility must be sure
8060 8085 * that modules below will not change the
8061 8086 * contents of the dblk without checking db_ref
8062 8087 * first. If db_ref is > 1, then the module
8063 8088 * needs to do a copymsg first. Otherwise,
8064 8089 * the contents of the dblk may become
8065 8090 * inconsistent because the freesmg/freeb below
8066 8091 * may end up calling atomic_add_32_nv.
8067 8092 * The atomic_add_32_nv in freeb (accessing
8068 8093 * all of db_ref, db_type, db_flags, and
8069 8094 * db_struioflag) does not prevent other threads
8070 8095 * from concurrently trying to modify e.g.
8071 8096 * db_type.
8072 8097 */
8073 8098 if (mctl->b_datap->db_frtnp != NULL)
8074 8099 mp = dupmsg(mctl);
8075 8100 else
8076 8101 mp = copymsg(mctl);
8077 8102
8078 8103 if (mp != NULL)
8079 8104 break;
8080 8105
8081 8106 error = strwaitbuf(msgdsize(mctl), BPRI_MED);
8082 8107 if (error) {
8083 8108 freemsg(mctl);
8084 8109 return (error);
8085 8110 }
8086 8111 } while (mp == NULL);
8087 8112 }
8088 8113 /*
8089 8114 * Verify that all of msgsize can be transferred by
8090 8115 * strput.
8091 8116 */
8092 8117 ASSERT(stp->sd_maxblk == INFPSZ || stp->sd_maxblk >= msgsize);
8093 8118 error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
8094 8119 if (error == 0)
8095 8120 break;
8096 8121
8097 8122 if (error != EWOULDBLOCK)
8098 8123 goto out;
8099 8124
8100 8125 /*
8101 8126 * IF MSG_IGNFLOW is set we should have broken out of loop
8102 8127 * above.
8103 8128 */
8104 8129 ASSERT(!(flag & MSG_IGNFLOW));
8105 8130 mutex_enter(&stp->sd_lock);
8106 8131 /*
8107 8132 * Check for a missed wakeup.
8108 8133 * Needed since strput did not hold sd_lock across
8109 8134 * the canputnext.
8110 8135 */
8111 8136 if (bcanputnext(wqp, pri)) {
8112 8137 /* Try again */
8113 8138 mutex_exit(&stp->sd_lock);
8114 8139 continue;
8115 8140 }
8116 8141 TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAIT,
8117 8142 "kstrputmsg wait:stp %p waits pri %d", stp, pri);
8118 8143
8119 8144 waitflag = WRITEWAIT;
8120 8145 if (flag & (MSG_HOLDSIG|MSG_IGNERROR)) {
8121 8146 if (flag & MSG_HOLDSIG)
8122 8147 waitflag |= STR_NOSIG;
8123 8148 if (flag & MSG_IGNERROR)
8124 8149 waitflag |= STR_NOERROR;
8125 8150 }
8126 8151 if (((error = strwaitq(stp, waitflag,
8127 8152 (ssize_t)0, fmode, -1, &done)) != 0) || done) {
8128 8153 mutex_exit(&stp->sd_lock);
8129 8154 TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
8130 8155 "kstrputmsg out:stp %p out %d error %d",
8131 8156 stp, 0, error);
8132 8157 freemsg(mctl);
8133 8158 return (error);
8134 8159 }
8135 8160 TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAKE,
8136 8161 "kstrputmsg wake:stp %p wakes", stp);
8137 8162 if ((error = i_straccess(stp, JCWRITE)) != 0) {
8138 8163 mutex_exit(&stp->sd_lock);
8139 8164 freemsg(mctl);
8140 8165 return (error);
8141 8166 }
8142 8167 mutex_exit(&stp->sd_lock);
8143 8168 }
8144 8169 out:
8145 8170 freemsg(mctl);
8146 8171 /*
8147 8172 * For historic reasons, applications expect EAGAIN
8148 8173 * when data mblk could not be allocated. so change
8149 8174 * ENOMEM back to EAGAIN
8150 8175 */
8151 8176 if (error == ENOMEM)
8152 8177 error = EAGAIN;
8153 8178 TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
8154 8179 "kstrputmsg out:stp %p out %d error %d", stp, 2, error);
8155 8180 return (error);
8156 8181 }
8157 8182
8158 8183 /*
8159 8184 * Determines whether the necessary conditions are set on a stream
8160 8185 * for it to be readable, writeable, or have exceptions.
8161 8186 *
8162 8187 * strpoll handles the consolidation private events:
8163 8188 * POLLNOERR Do not return POLLERR even if there are stream
8164 8189 * head errors.
8165 8190 * Used by sockfs.
8166 8191 * POLLRDDATA Do not return POLLIN unless at least one message on
8167 8192 * the queue contains one or more M_DATA mblks. Thus
8168 8193 * when this flag is set a queue with only
8169 8194 * M_PROTO/M_PCPROTO mblks does not return POLLIN.
8170 8195 * Used by sockfs to ignore T_EXDATA_IND messages.
8171 8196 *
8172 8197 * Note: POLLRDDATA assumes that synch streams only return messages with
8173 8198 * an M_DATA attached (i.e. not messages consisting of only
8174 8199 * an M_PROTO/M_PCPROTO part).
8175 8200 */
8176 8201 int
8177 8202 strpoll(struct stdata *stp, short events_arg, int anyyet, short *reventsp,
8178 8203 struct pollhead **phpp)
8179 8204 {
8180 8205 int events = (ushort_t)events_arg;
8181 8206 int retevents = 0;
8182 8207 mblk_t *mp;
8183 8208 qband_t *qbp;
8184 8209 long sd_flags = stp->sd_flag;
8185 8210 int headlocked = 0;
8186 8211
8187 8212 /*
8188 8213 * For performance, a single 'if' tests for most possible edge
8189 8214 * conditions in one shot
8190 8215 */
8191 8216 if (sd_flags & (STPLEX | STRDERR | STWRERR)) {
8192 8217 if (sd_flags & STPLEX) {
8193 8218 *reventsp = POLLNVAL;
8194 8219 return (EINVAL);
8195 8220 }
8196 8221 if (((events & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) &&
8197 8222 (sd_flags & STRDERR)) ||
8198 8223 ((events & (POLLOUT | POLLWRNORM | POLLWRBAND)) &&
8199 8224 (sd_flags & STWRERR))) {
8200 8225 if (!(events & POLLNOERR)) {
8201 8226 *reventsp = POLLERR;
8202 8227 return (0);
8203 8228 }
8204 8229 }
8205 8230 }
8206 8231 if (sd_flags & STRHUP) {
8207 8232 retevents |= POLLHUP;
8208 8233 } else if (events & (POLLWRNORM | POLLWRBAND)) {
8209 8234 queue_t *tq;
8210 8235 queue_t *qp = stp->sd_wrq;
8211 8236
8212 8237 claimstr(qp);
8213 8238 /* Find next module forward that has a service procedure */
8214 8239 tq = qp->q_next->q_nfsrv;
8215 8240 ASSERT(tq != NULL);
8216 8241
8217 8242 if (polllock(&stp->sd_pollist, QLOCK(tq)) != 0) {
8218 8243 releasestr(qp);
8219 8244 *reventsp = POLLNVAL;
8220 8245 return (0);
8221 8246 }
8222 8247 if (events & POLLWRNORM) {
8223 8248 queue_t *sqp;
8224 8249
8225 8250 if (tq->q_flag & QFULL)
8226 8251 /* ensure backq svc procedure runs */
8227 8252 tq->q_flag |= QWANTW;
8228 8253 else if ((sqp = stp->sd_struiowrq) != NULL) {
8229 8254 /* Check sync stream barrier write q */
8230 8255 mutex_exit(QLOCK(tq));
8231 8256 if (polllock(&stp->sd_pollist,
8232 8257 QLOCK(sqp)) != 0) {
8233 8258 releasestr(qp);
8234 8259 *reventsp = POLLNVAL;
8235 8260 return (0);
8236 8261 }
8237 8262 if (sqp->q_flag & QFULL)
8238 8263 /* ensure pollwakeup() is done */
8239 8264 sqp->q_flag |= QWANTWSYNC;
8240 8265 else
8241 8266 retevents |= POLLOUT;
8242 8267 /* More write events to process ??? */
8243 8268 if (! (events & POLLWRBAND)) {
8244 8269 mutex_exit(QLOCK(sqp));
8245 8270 releasestr(qp);
8246 8271 goto chkrd;
8247 8272 }
8248 8273 mutex_exit(QLOCK(sqp));
8249 8274 if (polllock(&stp->sd_pollist,
8250 8275 QLOCK(tq)) != 0) {
8251 8276 releasestr(qp);
8252 8277 *reventsp = POLLNVAL;
8253 8278 return (0);
8254 8279 }
8255 8280 } else
8256 8281 retevents |= POLLOUT;
8257 8282 }
8258 8283 if (events & POLLWRBAND) {
8259 8284 qbp = tq->q_bandp;
8260 8285 if (qbp) {
8261 8286 while (qbp) {
8262 8287 if (qbp->qb_flag & QB_FULL)
8263 8288 qbp->qb_flag |= QB_WANTW;
8264 8289 else
8265 8290 retevents |= POLLWRBAND;
8266 8291 qbp = qbp->qb_next;
8267 8292 }
8268 8293 } else {
8269 8294 retevents |= POLLWRBAND;
8270 8295 }
8271 8296 }
8272 8297 mutex_exit(QLOCK(tq));
8273 8298 releasestr(qp);
8274 8299 }
8275 8300 chkrd:
8276 8301 if (sd_flags & STRPRI) {
8277 8302 retevents |= (events & POLLPRI);
8278 8303 } else if (events & (POLLRDNORM | POLLRDBAND | POLLIN)) {
8279 8304 queue_t *qp = _RD(stp->sd_wrq);
8280 8305 int normevents = (events & (POLLIN | POLLRDNORM));
8281 8306
8282 8307 /*
8283 8308 * Note: Need to do polllock() here since ps_lock may be
8284 8309 * held. See bug 4191544.
8285 8310 */
8286 8311 if (polllock(&stp->sd_pollist, &stp->sd_lock) != 0) {
8287 8312 *reventsp = POLLNVAL;
8288 8313 return (0);
8289 8314 }
8290 8315 headlocked = 1;
8291 8316 mp = qp->q_first;
8292 8317 while (mp) {
8293 8318 /*
8294 8319 * For POLLRDDATA we scan b_cont and b_next until we
8295 8320 * find an M_DATA.
8296 8321 */
8297 8322 if ((events & POLLRDDATA) &&
8298 8323 mp->b_datap->db_type != M_DATA) {
8299 8324 mblk_t *nmp = mp->b_cont;
8300 8325
8301 8326 while (nmp != NULL &&
8302 8327 nmp->b_datap->db_type != M_DATA)
8303 8328 nmp = nmp->b_cont;
8304 8329 if (nmp == NULL) {
8305 8330 mp = mp->b_next;
8306 8331 continue;
8307 8332 }
8308 8333 }
8309 8334 if (mp->b_band == 0)
8310 8335 retevents |= normevents;
8311 8336 else
8312 8337 retevents |= (events & (POLLIN | POLLRDBAND));
8313 8338 break;
8314 8339 }
8315 8340 if (!(retevents & normevents) && (stp->sd_wakeq & RSLEEP)) {
8316 8341 /*
8317 8342 * Sync stream barrier read queue has data.
8318 8343 */
8319 8344 retevents |= normevents;
8320 8345 }
8321 8346 /* Treat eof as normal data */
8322 8347 if (sd_flags & STREOF)
8323 8348 retevents |= normevents;
8324 8349 }
8325 8350
8326 8351 /*
8327 8352 * Pass back a pollhead if no events are pending or if edge-triggering
8328 8353 * has been configured on this resource.
8329 8354 */
8330 8355 if ((retevents == 0 && !anyyet) || (events & POLLET)) {
8331 8356 *phpp = &stp->sd_pollist;
8332 8357 if (headlocked == 0) {
8333 8358 if (polllock(&stp->sd_pollist, &stp->sd_lock) != 0) {
8334 8359 *reventsp = POLLNVAL;
8335 8360 return (0);
8336 8361 }
8337 8362 headlocked = 1;
8338 8363 }
8339 8364 stp->sd_rput_opt |= SR_POLLIN;
8340 8365 }
8341 8366
8342 8367 *reventsp = (short)retevents;
8343 8368 if (headlocked)
8344 8369 mutex_exit(&stp->sd_lock);
8345 8370 return (0);
8346 8371 }
8347 8372
8348 8373 /*
8349 8374 * The purpose of putback() is to assure sleeping polls/reads
8350 8375 * are awakened when there are no new messages arriving at the,
8351 8376 * stream head, and a message is placed back on the read queue.
8352 8377 *
8353 8378 * sd_lock must be held when messages are placed back on stream
8354 8379 * head. (getq() holds sd_lock when it removes messages from
8355 8380 * the queue)
8356 8381 */
8357 8382
8358 8383 static void
8359 8384 putback(struct stdata *stp, queue_t *q, mblk_t *bp, int band)
8360 8385 {
8361 8386 mblk_t *qfirst;
8362 8387 ASSERT(MUTEX_HELD(&stp->sd_lock));
8363 8388
8364 8389 /*
8365 8390 * As a result of lock-step ordering around q_lock and sd_lock,
8366 8391 * it's possible for function calls like putnext() and
8367 8392 * canputnext() to get an inaccurate picture of how much
8368 8393 * data is really being processed at the stream head.
8369 8394 * We only consolidate with existing messages on the queue
8370 8395 * if the length of the message we want to put back is smaller
8371 8396 * than the queue hiwater mark.
8372 8397 */
8373 8398 if ((stp->sd_rput_opt & SR_CONSOL_DATA) &&
8374 8399 (DB_TYPE(bp) == M_DATA) && ((qfirst = q->q_first) != NULL) &&
8375 8400 (DB_TYPE(qfirst) == M_DATA) &&
8376 8401 ((qfirst->b_flag & (MSGMARK|MSGDELIM)) == 0) &&
8377 8402 ((bp->b_flag & (MSGMARK|MSGDELIM|MSGMARKNEXT)) == 0) &&
8378 8403 (mp_cont_len(bp, NULL) < q->q_hiwat)) {
8379 8404 /*
8380 8405 * We use the same logic as defined in strrput()
8381 8406 * but in reverse as we are putting back onto the
8382 8407 * queue and want to retain byte ordering.
8383 8408 * Consolidate M_DATA messages with M_DATA ONLY.
8384 8409 * strrput() allows the consolidation of M_DATA onto
8385 8410 * M_PROTO | M_PCPROTO but not the other way round.
8386 8411 *
8387 8412 * The consolidation does not take place if the message
8388 8413 * we are returning to the queue is marked with either
8389 8414 * of the marks or the delim flag or if q_first
8390 8415 * is marked with MSGMARK. The MSGMARK check is needed to
8391 8416 * handle the odd semantics of MSGMARK where essentially
8392 8417 * the whole message is to be treated as marked.
8393 8418 * Carry any MSGMARKNEXT and MSGNOTMARKNEXT from q_first
8394 8419 * to the front of the b_cont chain.
8395 8420 */
8396 8421 rmvq_noenab(q, qfirst);
8397 8422
8398 8423 /*
8399 8424 * The first message in the b_cont list
8400 8425 * tracks MSGMARKNEXT and MSGNOTMARKNEXT.
8401 8426 * We need to handle the case where we
8402 8427 * are appending:
8403 8428 *
8404 8429 * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT.
8405 8430 * 2) a MSGMARKNEXT to a plain message.
8406 8431 * 3) a MSGNOTMARKNEXT to a plain message
8407 8432 * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT
8408 8433 * message.
8409 8434 *
8410 8435 * Thus we never append a MSGMARKNEXT or
8411 8436 * MSGNOTMARKNEXT to a MSGMARKNEXT message.
8412 8437 */
8413 8438 if (qfirst->b_flag & MSGMARKNEXT) {
8414 8439 bp->b_flag |= MSGMARKNEXT;
8415 8440 bp->b_flag &= ~MSGNOTMARKNEXT;
8416 8441 qfirst->b_flag &= ~MSGMARKNEXT;
8417 8442 } else if (qfirst->b_flag & MSGNOTMARKNEXT) {
8418 8443 bp->b_flag |= MSGNOTMARKNEXT;
8419 8444 qfirst->b_flag &= ~MSGNOTMARKNEXT;
8420 8445 }
8421 8446
8422 8447 linkb(bp, qfirst);
8423 8448 }
8424 8449 (void) putbq(q, bp);
8425 8450
8426 8451 /*
8427 8452 * A message may have come in when the sd_lock was dropped in the
8428 8453 * calling routine. If this is the case and STR*ATMARK info was
8429 8454 * received, need to move that from the stream head to the q_last
8430 8455 * so that SIOCATMARK can return the proper value.
8431 8456 */
8432 8457 if (stp->sd_flag & (STRATMARK | STRNOTATMARK)) {
8433 8458 unsigned short *flagp = &q->q_last->b_flag;
8434 8459 uint_t b_flag = (uint_t)*flagp;
8435 8460
8436 8461 if (stp->sd_flag & STRATMARK) {
8437 8462 b_flag &= ~MSGNOTMARKNEXT;
8438 8463 b_flag |= MSGMARKNEXT;
8439 8464 stp->sd_flag &= ~STRATMARK;
8440 8465 } else {
8441 8466 b_flag &= ~MSGMARKNEXT;
8442 8467 b_flag |= MSGNOTMARKNEXT;
8443 8468 stp->sd_flag &= ~STRNOTATMARK;
8444 8469 }
8445 8470 *flagp = (unsigned short) b_flag;
8446 8471 }
8447 8472
8448 8473 #ifdef DEBUG
8449 8474 /*
8450 8475 * Make sure that the flags are not messed up.
8451 8476 */
8452 8477 {
8453 8478 mblk_t *mp;
8454 8479 mp = q->q_last;
8455 8480 while (mp != NULL) {
8456 8481 ASSERT((mp->b_flag & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
8457 8482 (MSGMARKNEXT|MSGNOTMARKNEXT));
8458 8483 mp = mp->b_cont;
8459 8484 }
8460 8485 }
8461 8486 #endif
8462 8487 if (q->q_first == bp) {
8463 8488 short pollevents;
8464 8489
8465 8490 if (stp->sd_flag & RSLEEP) {
8466 8491 stp->sd_flag &= ~RSLEEP;
8467 8492 cv_broadcast(&q->q_wait);
8468 8493 }
8469 8494 if (stp->sd_flag & STRPRI) {
8470 8495 pollevents = POLLPRI;
8471 8496 } else {
8472 8497 if (band == 0) {
8473 8498 if (!(stp->sd_rput_opt & SR_POLLIN))
8474 8499 return;
8475 8500 stp->sd_rput_opt &= ~SR_POLLIN;
8476 8501 pollevents = POLLIN | POLLRDNORM;
8477 8502 } else {
8478 8503 pollevents = POLLIN | POLLRDBAND;
8479 8504 }
8480 8505 }
8481 8506 mutex_exit(&stp->sd_lock);
8482 8507 pollwakeup(&stp->sd_pollist, pollevents);
8483 8508 mutex_enter(&stp->sd_lock);
8484 8509 }
8485 8510 }
8486 8511
8487 8512 /*
8488 8513 * Return the held vnode attached to the stream head of a
8489 8514 * given queue
8490 8515 * It is the responsibility of the calling routine to ensure
8491 8516 * that the queue does not go away (e.g. pop).
8492 8517 */
8493 8518 vnode_t *
8494 8519 strq2vp(queue_t *qp)
8495 8520 {
8496 8521 vnode_t *vp;
8497 8522 vp = STREAM(qp)->sd_vnode;
8498 8523 ASSERT(vp != NULL);
8499 8524 VN_HOLD(vp);
8500 8525 return (vp);
8501 8526 }
8502 8527
8503 8528 /*
8504 8529 * return the stream head write queue for the given vp
8505 8530 * It is the responsibility of the calling routine to ensure
8506 8531 * that the stream or vnode do not close.
8507 8532 */
8508 8533 queue_t *
8509 8534 strvp2wq(vnode_t *vp)
8510 8535 {
8511 8536 ASSERT(vp->v_stream != NULL);
8512 8537 return (vp->v_stream->sd_wrq);
8513 8538 }
8514 8539
8515 8540 /*
8516 8541 * pollwakeup stream head
8517 8542 * It is the responsibility of the calling routine to ensure
8518 8543 * that the stream or vnode do not close.
8519 8544 */
8520 8545 void
8521 8546 strpollwakeup(vnode_t *vp, short event)
8522 8547 {
8523 8548 ASSERT(vp->v_stream);
8524 8549 pollwakeup(&vp->v_stream->sd_pollist, event);
8525 8550 }
8526 8551
8527 8552 /*
8528 8553 * Mate the stream heads of two vnodes together. If the two vnodes are the
8529 8554 * same, we just make the write-side point at the read-side -- otherwise,
8530 8555 * we do a full mate. Only works on vnodes associated with streams that are
8531 8556 * still being built and thus have only a stream head.
8532 8557 */
8533 8558 void
8534 8559 strmate(vnode_t *vp1, vnode_t *vp2)
8535 8560 {
8536 8561 queue_t *wrq1 = strvp2wq(vp1);
8537 8562 queue_t *wrq2 = strvp2wq(vp2);
8538 8563
8539 8564 /*
8540 8565 * Verify that there are no modules on the stream yet. We also
8541 8566 * rely on the stream head always having a service procedure to
8542 8567 * avoid tweaking q_nfsrv.
8543 8568 */
8544 8569 ASSERT(wrq1->q_next == NULL && wrq2->q_next == NULL);
8545 8570 ASSERT(wrq1->q_qinfo->qi_srvp != NULL);
8546 8571 ASSERT(wrq2->q_qinfo->qi_srvp != NULL);
8547 8572
8548 8573 /*
8549 8574 * If the queues are the same, just twist; otherwise do a full mate.
8550 8575 */
8551 8576 if (wrq1 == wrq2) {
8552 8577 wrq1->q_next = _RD(wrq1);
8553 8578 } else {
8554 8579 wrq1->q_next = _RD(wrq2);
8555 8580 wrq2->q_next = _RD(wrq1);
8556 8581 STREAM(wrq1)->sd_mate = STREAM(wrq2);
8557 8582 STREAM(wrq1)->sd_flag |= STRMATE;
8558 8583 STREAM(wrq2)->sd_mate = STREAM(wrq1);
8559 8584 STREAM(wrq2)->sd_flag |= STRMATE;
8560 8585 }
8561 8586 }
8562 8587
8563 8588 /*
8564 8589 * XXX will go away when console is correctly fixed.
8565 8590 * Clean up the console PIDS, from previous I_SETSIG,
8566 8591 * called only for cnopen which never calls strclean().
8567 8592 */
8568 8593 void
8569 8594 str_cn_clean(struct vnode *vp)
8570 8595 {
8571 8596 strsig_t *ssp, *pssp, *tssp;
8572 8597 struct stdata *stp;
8573 8598 struct pid *pidp;
8574 8599 int update = 0;
8575 8600
8576 8601 ASSERT(vp->v_stream);
8577 8602 stp = vp->v_stream;
8578 8603 pssp = NULL;
8579 8604 mutex_enter(&stp->sd_lock);
8580 8605 ssp = stp->sd_siglist;
8581 8606 while (ssp) {
8582 8607 mutex_enter(&pidlock);
8583 8608 pidp = ssp->ss_pidp;
8584 8609 /*
8585 8610 * Get rid of PID if the proc is gone.
8586 8611 */
8587 8612 if (pidp->pid_prinactive) {
8588 8613 tssp = ssp->ss_next;
8589 8614 if (pssp)
8590 8615 pssp->ss_next = tssp;
8591 8616 else
8592 8617 stp->sd_siglist = tssp;
8593 8618 ASSERT(pidp->pid_ref <= 1);
8594 8619 PID_RELE(ssp->ss_pidp);
8595 8620 mutex_exit(&pidlock);
8596 8621 kmem_free(ssp, sizeof (strsig_t));
8597 8622 update = 1;
8598 8623 ssp = tssp;
8599 8624 continue;
8600 8625 } else
8601 8626 mutex_exit(&pidlock);
8602 8627 pssp = ssp;
8603 8628 ssp = ssp->ss_next;
8604 8629 }
8605 8630 if (update) {
8606 8631 stp->sd_sigflags = 0;
8607 8632 for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
8608 8633 stp->sd_sigflags |= ssp->ss_events;
8609 8634 }
8610 8635 mutex_exit(&stp->sd_lock);
8611 8636 }
8612 8637
8613 8638 /*
8614 8639 * Return B_TRUE if there is data in the message, B_FALSE otherwise.
8615 8640 */
8616 8641 static boolean_t
8617 8642 msghasdata(mblk_t *bp)
8618 8643 {
8619 8644 for (; bp; bp = bp->b_cont)
8620 8645 if (bp->b_datap->db_type == M_DATA) {
8621 8646 ASSERT(bp->b_wptr >= bp->b_rptr);
8622 8647 if (bp->b_wptr > bp->b_rptr)
8623 8648 return (B_TRUE);
8624 8649 }
8625 8650 return (B_FALSE);
8626 8651 }
|
↓ open down ↓ |
4831 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX