Print this page
7127 remove -Wno-missing-braces from Makefile.uts
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/ptm.c
+++ new/usr/src/uts/common/io/ptm.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]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 */
24 24 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
25 25 /* All Rights Reserved */
26 26
27 27
28 28
29 29 /*
30 30 * Pseudo Terminal Master Driver.
31 31 *
32 32 * The pseudo-tty subsystem simulates a terminal connection, where the master
33 33 * side represents the terminal and the slave represents the user process's
34 34 * special device end point. The master device is set up as a cloned device
35 35 * where its major device number is the major for the clone device and its minor
36 36 * device number is the major for the ptm driver. There are no nodes in the file
37 37 * system for master devices. The master pseudo driver is opened using the
38 38 * open(2) system call with /dev/ptmx as the device parameter. The clone open
39 39 * finds the next available minor device for the ptm major device.
40 40 *
41 41 * A master device is available only if it and its corresponding slave device
42 42 * are not already open. When the master device is opened, the corresponding
43 43 * slave device is automatically locked out. Only one open is allowed on a
44 44 * master device. Multiple opens are allowed on the slave device. After both
45 45 * the master and slave have been opened, the user has two file descriptors
46 46 * which are the end points of a full duplex connection composed of two streams
47 47 * which are automatically connected at the master and slave drivers. The user
48 48 * may then push modules onto either side of the stream pair.
49 49 *
50 50 * The master and slave drivers pass all messages to their adjacent queues.
51 51 * Only the M_FLUSH needs some processing. Because the read queue of one side
52 52 * is connected to the write queue of the other, the FLUSHR flag is changed to
53 53 * the FLUSHW flag and vice versa. When the master device is closed an M_HANGUP
54 54 * message is sent to the slave device which will render the device
55 55 * unusable. The process on the slave side gets the EIO when attempting to write
56 56 * on that stream but it will be able to read any data remaining on the stream
57 57 * head read queue. When all the data has been read, read() returns 0
58 58 * indicating that the stream can no longer be used. On the last close of the
59 59 * slave device, a 0-length message is sent to the master device. When the
60 60 * application on the master side issues a read() or getmsg() and 0 is returned,
61 61 * the user of the master device decides whether to issue a close() that
62 62 * dismantles the pseudo-terminal subsystem. If the master device is not closed,
63 63 * the pseudo-tty subsystem will be available to another user to open the slave
64 64 * device.
65 65 *
66 66 * If O_NONBLOCK or O_NDELAY is set, read on the master side returns -1 with
67 67 * errno set to EAGAIN if no data is available, and write returns -1 with errno
68 68 * set to EAGAIN if there is internal flow control.
69 69 *
70 70 * IOCTLS:
71 71 *
72 72 * ISPTM: determines whether the file descriptor is that of an open master
73 73 * device. Return code of zero indicates that the file descriptor
74 74 * represents master device.
75 75 *
76 76 * UNLKPT: unlocks the master and slave devices. It returns 0 on success. On
77 77 * failure, the errno is set to EINVAL indicating that the master
78 78 * device is not open.
79 79 *
80 80 * ZONEPT: sets the zone membership of the associated pts device.
81 81 *
82 82 * GRPPT: sets the group owner of the associated pts device.
83 83 *
84 84 * Synchronization:
85 85 *
86 86 * All global data synchronization between ptm/pts is done via global
87 87 * ptms_lock mutex which is initialized at system boot time from
88 88 * ptms_initspace (called from space.c).
89 89 *
90 90 * Individual fields of pt_ttys structure (except ptm_rdq, pts_rdq and
91 91 * pt_nullmsg) are protected by pt_ttys.pt_lock mutex.
92 92 *
93 93 * PT_ENTER_READ/PT_ENTER_WRITE are reference counter based read-write locks
94 94 * which allow reader locks to be reacquired by the same thread (usual
95 95 * reader/writer locks can't be used for that purpose since it is illegal for
96 96 * a thread to acquire a lock it already holds, even as a reader). The sole
97 97 * purpose of these macros is to guarantee that the peer queue will not
98 98 * disappear (due to closing peer) while it is used. It is safe to use
99 99 * PT_ENTER_READ/PT_EXIT_READ brackets across calls like putq/putnext (since
100 100 * they are not real locks but reference counts).
101 101 *
102 102 * PT_ENTER_WRITE/PT_EXIT_WRITE brackets are used ONLY in master/slave
103 103 * open/close paths to modify ptm_rdq and pts_rdq fields. These fields should
104 104 * be set to appropriate queues *after* qprocson() is called during open (to
105 105 * prevent peer from accessing the queue with incomplete plumbing) and set to
106 106 * NULL before qprocsoff() is called during close.
107 107 *
108 108 * The pt_nullmsg field is only used in open/close routines and it is also
109 109 * protected by PT_ENTER_WRITE/PT_EXIT_WRITE brackets to avoid extra mutex
110 110 * holds.
111 111 *
112 112 * Lock Ordering:
113 113 *
114 114 * If both ptms_lock and per-pty lock should be held, ptms_lock should always
115 115 * be entered first, followed by per-pty lock.
116 116 *
117 117 * See ptms.h, pts.c and ptms_conf.c for more information.
118 118 */
119 119
120 120 #include <sys/types.h>
121 121 #include <sys/param.h>
122 122 #include <sys/file.h>
123 123 #include <sys/sysmacros.h>
124 124 #include <sys/stream.h>
125 125 #include <sys/stropts.h>
126 126 #include <sys/proc.h>
127 127 #include <sys/errno.h>
128 128 #include <sys/debug.h>
129 129 #include <sys/cmn_err.h>
130 130 #include <sys/ptms.h>
131 131 #include <sys/stat.h>
132 132 #include <sys/strsun.h>
133 133 #include <sys/systm.h>
134 134 #include <sys/modctl.h>
135 135 #include <sys/conf.h>
136 136 #include <sys/ddi.h>
137 137 #include <sys/sunddi.h>
138 138 #include <sys/zone.h>
139 139
140 140 #ifdef DEBUG
141 141 int ptm_debug = 0;
142 142 #define DBG(a) if (ptm_debug) cmn_err(CE_NOTE, a)
143 143 #else
144 144 #define DBG(a)
145 145 #endif
146 146
147 147 static int ptmopen(queue_t *, dev_t *, int, int, cred_t *);
148 148 static int ptmclose(queue_t *, int, cred_t *);
149 149 static void ptmwput(queue_t *, mblk_t *);
150 150 static void ptmrsrv(queue_t *);
151 151 static void ptmwsrv(queue_t *);
152 152
153 153 /*
154 154 * Master Stream Pseudo Terminal Module: stream data structure definitions
155 155 */
156 156
157 157 static struct module_info ptm_info = {
158 158 0xdead,
159 159 "ptm",
160 160 0,
161 161 512,
162 162 512,
163 163 128
164 164 };
165 165
166 166 static struct qinit ptmrint = {
167 167 NULL,
168 168 (int (*)()) ptmrsrv,
169 169 ptmopen,
170 170 ptmclose,
171 171 NULL,
172 172 &ptm_info,
173 173 NULL
174 174 };
175 175
176 176 static struct qinit ptmwint = {
177 177 (int (*)()) ptmwput,
178 178 (int (*)()) ptmwsrv,
179 179 NULL,
180 180 NULL,
181 181 NULL,
182 182 &ptm_info,
183 183 NULL
184 184 };
185 185
186 186 static struct streamtab ptminfo = {
187 187 &ptmrint,
188 188 &ptmwint,
189 189 NULL,
190 190 NULL
191 191 };
192 192
193 193 static int ptm_attach(dev_info_t *, ddi_attach_cmd_t);
194 194 static int ptm_detach(dev_info_t *, ddi_detach_cmd_t);
195 195 static int ptm_devinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
196 196
197 197 static dev_info_t *ptm_dip; /* private devinfo pointer */
198 198
199 199 /*
200 200 * this will define (struct cb_ops cb_ptm_ops) and (struct dev_ops ptm_ops)
201 201 */
202 202 DDI_DEFINE_STREAM_OPS(ptm_ops, nulldev, nulldev, ptm_attach, ptm_detach,
203 203 nodev, ptm_devinfo, D_MP, &ptminfo, ddi_quiesce_not_supported);
204 204
205 205 /*
206 206 * Module linkage information for the kernel.
|
↓ open down ↓ |
206 lines elided |
↑ open up ↑ |
207 207 */
208 208
209 209 static struct modldrv modldrv = {
210 210 &mod_driverops, /* Type of module. This one is a pseudo driver */
211 211 "Master streams driver 'ptm'",
212 212 &ptm_ops, /* driver ops */
213 213 };
214 214
215 215 static struct modlinkage modlinkage = {
216 216 MODREV_1,
217 - &modldrv,
218 - NULL
217 + { &modldrv, NULL }
219 218 };
220 219
221 220 int
222 221 _init(void)
223 222 {
224 223 int rc;
225 224
226 225 if ((rc = mod_install(&modlinkage)) == 0)
227 226 ptms_init();
228 227 return (rc);
229 228 }
230 229
231 230 int
232 231 _fini(void)
233 232 {
234 233 return (mod_remove(&modlinkage));
235 234 }
236 235
237 236 int
238 237 _info(struct modinfo *modinfop)
239 238 {
240 239 return (mod_info(&modlinkage, modinfop));
241 240 }
242 241
243 242 static int
244 243 ptm_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
245 244 {
246 245 if (cmd != DDI_ATTACH)
247 246 return (DDI_FAILURE);
248 247
249 248 if (ddi_create_minor_node(devi, "ptmajor", S_IFCHR,
250 249 0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
251 250 ddi_remove_minor_node(devi, NULL);
252 251 return (DDI_FAILURE);
253 252 }
254 253 if (ddi_create_minor_node(devi, "ptmx", S_IFCHR,
255 254 0, DDI_PSEUDO, CLONE_DEV) == DDI_FAILURE) {
256 255 ddi_remove_minor_node(devi, NULL);
257 256 return (DDI_FAILURE);
258 257 }
259 258 ptm_dip = devi;
260 259
261 260 return (DDI_SUCCESS);
262 261 }
263 262
264 263 static int
265 264 ptm_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
266 265 {
267 266 if (cmd != DDI_DETACH)
268 267 return (DDI_FAILURE);
269 268
270 269 ddi_remove_minor_node(devi, NULL);
271 270 return (DDI_SUCCESS);
272 271 }
273 272
274 273 /*ARGSUSED*/
275 274 static int
276 275 ptm_devinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
277 276 void **result)
278 277 {
279 278 int error;
280 279
281 280 switch (infocmd) {
282 281 case DDI_INFO_DEVT2DEVINFO:
283 282 if (ptm_dip == NULL) {
284 283 error = DDI_FAILURE;
285 284 } else {
286 285 *result = (void *)ptm_dip;
287 286 error = DDI_SUCCESS;
288 287 }
289 288 break;
290 289 case DDI_INFO_DEVT2INSTANCE:
291 290 *result = (void *)0;
292 291 error = DDI_SUCCESS;
293 292 break;
294 293 default:
295 294 error = DDI_FAILURE;
296 295 }
297 296 return (error);
298 297 }
299 298
300 299
301 300 /* ARGSUSED */
302 301 /*
303 302 * Open a minor of the master device. Store the write queue pointer and set the
304 303 * pt_state field to (PTMOPEN | PTLOCK).
305 304 * This code will work properly with both clone opens and direct opens of the
306 305 * master device.
307 306 */
308 307 static int
309 308 ptmopen(
310 309 queue_t *rqp, /* pointer to the read side queue */
311 310 dev_t *devp, /* pointer to stream tail's dev */
312 311 int oflag, /* the user open(2) supplied flags */
313 312 int sflag, /* open state flag */
314 313 cred_t *credp) /* credentials */
315 314 {
316 315 struct pt_ttys *ptmp;
317 316 mblk_t *mop; /* ptr to a setopts message block */
318 317 struct stroptions *sop;
319 318 minor_t dminor = getminor(*devp);
320 319
321 320 /* Allow reopen */
322 321 if (rqp->q_ptr != NULL)
323 322 return (0);
324 323
325 324 if (sflag & MODOPEN)
326 325 return (ENXIO);
327 326
328 327 if (!(sflag & CLONEOPEN) && dminor != 0) {
329 328 /*
330 329 * This is a direct open to specific master device through an
331 330 * artificially created entry with specific minor in
332 331 * /dev/directory. Such behavior is not supported.
333 332 */
334 333 return (ENXIO);
335 334 }
336 335
337 336 /*
338 337 * The master open requires that the slave be attached
339 338 * before it returns so that attempts to open the slave will
340 339 * succeeed
341 340 */
342 341 if (ptms_attach_slave() != 0) {
343 342 return (ENXIO);
344 343 }
345 344
346 345 mop = allocb(sizeof (struct stroptions), BPRI_MED);
347 346 if (mop == NULL) {
348 347 DDBG("ptmopen(): mop allocation failed\n", 0);
349 348 return (ENOMEM);
350 349 }
351 350
352 351 if ((ptmp = pt_ttys_alloc()) == NULL) {
353 352 DDBG("ptmopen(): pty allocation failed\n", 0);
354 353 freemsg(mop);
355 354 return (ENOMEM);
356 355 }
357 356
358 357 dminor = ptmp->pt_minor;
359 358
360 359 DDBGP("ptmopen(): allocated ptmp %p\n", (uintptr_t)ptmp);
361 360 DDBG("ptmopen(): allocated minor %d\n", dminor);
362 361
363 362 WR(rqp)->q_ptr = rqp->q_ptr = ptmp;
364 363
365 364 qprocson(rqp);
366 365
367 366 /* Allow slave to send messages to master */
368 367 PT_ENTER_WRITE(ptmp);
369 368 ptmp->ptm_rdq = rqp;
370 369 PT_EXIT_WRITE(ptmp);
371 370
372 371 /*
373 372 * set up hi/lo water marks on stream head read queue
374 373 * and add controlling tty if not set
375 374 */
376 375 mop->b_datap->db_type = M_SETOPTS;
377 376 mop->b_wptr += sizeof (struct stroptions);
378 377 sop = (struct stroptions *)mop->b_rptr;
379 378 if (oflag & FNOCTTY)
380 379 sop->so_flags = SO_HIWAT | SO_LOWAT;
381 380 else
382 381 sop->so_flags = SO_HIWAT | SO_LOWAT | SO_ISTTY;
383 382 sop->so_hiwat = 512;
384 383 sop->so_lowat = 256;
385 384 putnext(rqp, mop);
386 385
387 386 /*
388 387 * The input, devp, is a major device number, the output is put
389 388 * into the same parm as a major,minor pair.
390 389 */
391 390 *devp = makedevice(getmajor(*devp), dminor);
392 391
393 392 return (0);
394 393 }
395 394
396 395
397 396 /*
398 397 * Find the address to private data identifying the slave's write queue.
399 398 * Send a hang-up message up the slave's read queue to designate the
400 399 * master/slave pair is tearing down. Uattach the master and slave by
401 400 * nulling out the write queue fields in the private data structure.
402 401 * Finally, unlock the master/slave pair and mark the master as closed.
403 402 */
404 403 /*ARGSUSED1*/
405 404 static int
406 405 ptmclose(queue_t *rqp, int flag, cred_t *credp)
407 406 {
408 407 struct pt_ttys *ptmp;
409 408 queue_t *pts_rdq;
410 409
411 410 ASSERT(rqp->q_ptr);
412 411
413 412 ptmp = (struct pt_ttys *)rqp->q_ptr;
414 413 PT_ENTER_READ(ptmp);
415 414 if (ptmp->pts_rdq) {
416 415 pts_rdq = ptmp->pts_rdq;
417 416 if (pts_rdq->q_next) {
418 417 DBG(("send hangup message to slave\n"));
419 418 (void) putnextctl(pts_rdq, M_HANGUP);
420 419 }
421 420 }
422 421 PT_EXIT_READ(ptmp);
423 422 /*
424 423 * ptm_rdq should be cleared before call to qprocsoff() to prevent pts
425 424 * write procedure to attempt using ptm_rdq after qprocsoff.
426 425 */
427 426 PT_ENTER_WRITE(ptmp);
428 427 ptmp->ptm_rdq = NULL;
429 428 freemsg(ptmp->pt_nullmsg);
430 429 ptmp->pt_nullmsg = NULL;
431 430 /*
432 431 * qenable slave side write queue so that it can flush
433 432 * its messages as master's read queue is going away
434 433 */
435 434 if (ptmp->pts_rdq)
436 435 qenable(WR(ptmp->pts_rdq));
437 436 PT_EXIT_WRITE(ptmp);
438 437
439 438 qprocsoff(rqp);
440 439
441 440 /* Finish the close */
442 441 rqp->q_ptr = NULL;
443 442 WR(rqp)->q_ptr = NULL;
444 443
445 444 ptms_close(ptmp, PTMOPEN | PTLOCK);
446 445
447 446 return (0);
448 447 }
449 448
450 449 /*
451 450 * The wput procedure will only handle ioctl and flush messages.
452 451 */
453 452 static void
454 453 ptmwput(queue_t *qp, mblk_t *mp)
455 454 {
456 455 struct pt_ttys *ptmp;
457 456 struct iocblk *iocp;
458 457
459 458 DBG(("entering ptmwput\n"));
460 459 ASSERT(qp->q_ptr);
461 460
462 461 ptmp = (struct pt_ttys *)qp->q_ptr;
463 462 PT_ENTER_READ(ptmp);
464 463
465 464 switch (mp->b_datap->db_type) {
466 465 /*
467 466 * if write queue request, flush master's write
468 467 * queue and send FLUSHR up slave side. If read
469 468 * queue request, convert to FLUSHW and putnext().
470 469 */
471 470 case M_FLUSH:
472 471 {
473 472 unsigned char flush_flg = 0;
474 473
475 474 DBG(("ptm got flush request\n"));
476 475 if (*mp->b_rptr & FLUSHW) {
477 476 DBG(("got FLUSHW, flush ptm write Q\n"));
478 477 if (*mp->b_rptr & FLUSHBAND)
479 478 /*
480 479 * if it is a FLUSHBAND, do flushband.
481 480 */
482 481 flushband(qp, *(mp->b_rptr + 1),
483 482 FLUSHDATA);
484 483 else
485 484 flushq(qp, FLUSHDATA);
486 485 flush_flg = (*mp->b_rptr & ~FLUSHW) | FLUSHR;
487 486 }
488 487 if (*mp->b_rptr & FLUSHR) {
489 488 DBG(("got FLUSHR, set FLUSHW\n"));
490 489 flush_flg |= (*mp->b_rptr & ~FLUSHR) | FLUSHW;
491 490 }
492 491 if (flush_flg != 0 && ptmp->pts_rdq &&
493 492 !(ptmp->pt_state & PTLOCK)) {
494 493 DBG(("putnext to pts\n"));
495 494 *mp->b_rptr = flush_flg;
496 495 putnext(ptmp->pts_rdq, mp);
497 496 } else
498 497 freemsg(mp);
499 498 break;
500 499 }
501 500
502 501 case M_IOCTL:
503 502 iocp = (struct iocblk *)mp->b_rptr;
504 503 switch (iocp->ioc_cmd) {
505 504 default:
506 505 if ((ptmp->pt_state & PTLOCK) ||
507 506 (ptmp->pts_rdq == NULL)) {
508 507 DBG(("got M_IOCTL but no slave\n"));
509 508 miocnak(qp, mp, 0, EINVAL);
510 509 PT_EXIT_READ(ptmp);
511 510 return;
512 511 }
513 512 (void) putq(qp, mp);
514 513 break;
515 514 case UNLKPT:
516 515 mutex_enter(&ptmp->pt_lock);
517 516 ptmp->pt_state &= ~PTLOCK;
518 517 mutex_exit(&ptmp->pt_lock);
519 518 /*FALLTHROUGH*/
520 519 case ISPTM:
521 520 DBG(("ack the UNLKPT/ISPTM\n"));
522 521 miocack(qp, mp, 0, 0);
523 522 break;
524 523 case ZONEPT:
525 524 {
526 525 zoneid_t z;
527 526 int error;
528 527
529 528 if ((error = drv_priv(iocp->ioc_cr)) != 0) {
530 529 miocnak(qp, mp, 0, error);
531 530 break;
532 531 }
533 532 if ((error = miocpullup(mp, sizeof (zoneid_t))) != 0) {
534 533 miocnak(qp, mp, 0, error);
535 534 break;
536 535 }
537 536 z = *((zoneid_t *)mp->b_cont->b_rptr);
538 537 if (z < MIN_ZONEID || z > MAX_ZONEID) {
539 538 miocnak(qp, mp, 0, EINVAL);
540 539 break;
541 540 }
542 541
543 542 mutex_enter(&ptmp->pt_lock);
544 543 ptmp->pt_zoneid = z;
545 544 mutex_exit(&ptmp->pt_lock);
546 545 miocack(qp, mp, 0, 0);
547 546 break;
548 547 }
549 548 case OWNERPT:
550 549 {
551 550 pt_own_t *ptop;
552 551 int error;
553 552 zone_t *zone;
554 553
555 554 if ((error = miocpullup(mp, sizeof (pt_own_t))) != 0) {
556 555 miocnak(qp, mp, 0, error);
557 556 break;
558 557 }
559 558
560 559 zone = zone_find_by_id(ptmp->pt_zoneid);
561 560 ptop = (pt_own_t *)mp->b_cont->b_rptr;
562 561
563 562 if (!VALID_UID(ptop->pto_ruid, zone) ||
564 563 !VALID_GID(ptop->pto_rgid, zone)) {
565 564 zone_rele(zone);
566 565 miocnak(qp, mp, 0, EINVAL);
567 566 break;
568 567 }
569 568 zone_rele(zone);
570 569 mutex_enter(&ptmp->pt_lock);
571 570 ptmp->pt_ruid = ptop->pto_ruid;
572 571 ptmp->pt_rgid = ptop->pto_rgid;
573 572 mutex_exit(&ptmp->pt_lock);
574 573 miocack(qp, mp, 0, 0);
575 574 break;
576 575 }
577 576 }
578 577 break;
579 578
580 579 case M_READ:
581 580 /* Caused by ldterm - can not pass to slave */
582 581 freemsg(mp);
583 582 break;
584 583
585 584 /*
586 585 * send other messages to slave
587 586 */
588 587 default:
589 588 if ((ptmp->pt_state & PTLOCK) || (ptmp->pts_rdq == NULL)) {
590 589 DBG(("got msg. but no slave\n"));
591 590 mp = mexchange(NULL, mp, 2, M_ERROR, -1);
592 591 if (mp != NULL) {
593 592 mp->b_rptr[0] = NOERROR;
594 593 mp->b_rptr[1] = EINVAL;
595 594 qreply(qp, mp);
596 595 }
597 596 PT_EXIT_READ(ptmp);
598 597 return;
599 598 }
600 599 DBG(("put msg on master's write queue\n"));
601 600 (void) putq(qp, mp);
602 601 break;
603 602 }
604 603 DBG(("return from ptmwput()\n"));
605 604 PT_EXIT_READ(ptmp);
606 605 }
607 606
608 607
609 608 /*
610 609 * enable the write side of the slave. This triggers the
611 610 * slave to send any messages queued on its write side to
612 611 * the read side of this master.
613 612 */
614 613 static void
615 614 ptmrsrv(queue_t *qp)
616 615 {
617 616 struct pt_ttys *ptmp;
618 617
619 618 DBG(("entering ptmrsrv\n"));
620 619 ASSERT(qp->q_ptr);
621 620
622 621 ptmp = (struct pt_ttys *)qp->q_ptr;
623 622 PT_ENTER_READ(ptmp);
624 623 if (ptmp->pts_rdq) {
625 624 qenable(WR(ptmp->pts_rdq));
626 625 }
627 626 PT_EXIT_READ(ptmp);
628 627 DBG(("leaving ptmrsrv\n"));
629 628 }
630 629
631 630
632 631 /*
633 632 * If there are messages on this queue that can be sent to
634 633 * slave, send them via putnext(). Else, if queued messages
635 634 * cannot be sent, leave them on this queue. If priority
636 635 * messages on this queue, send them to slave no matter what.
637 636 */
638 637 static void
639 638 ptmwsrv(queue_t *qp)
640 639 {
641 640 struct pt_ttys *ptmp;
642 641 mblk_t *mp;
643 642
644 643 DBG(("entering ptmwsrv\n"));
645 644 ASSERT(qp->q_ptr);
646 645
647 646 ptmp = (struct pt_ttys *)qp->q_ptr;
648 647
649 648 if ((mp = getq(qp)) == NULL) {
650 649 /* If there are no messages there's nothing to do. */
651 650 DBG(("leaving ptmwsrv (no messages)\n"));
652 651 return;
653 652 }
654 653
655 654 PT_ENTER_READ(ptmp);
656 655 if ((ptmp->pt_state & PTLOCK) || (ptmp->pts_rdq == NULL)) {
657 656 DBG(("in master write srv proc but no slave\n"));
658 657 /*
659 658 * Free messages on the write queue and send
660 659 * NAK for any M_IOCTL type messages to wakeup
661 660 * the user process waiting for ACK/NAK from
662 661 * the ioctl invocation
663 662 */
664 663 do {
665 664 if (mp->b_datap->db_type == M_IOCTL)
666 665 miocnak(qp, mp, 0, EINVAL);
667 666 else
668 667 freemsg(mp);
669 668 } while ((mp = getq(qp)) != NULL);
670 669 flushq(qp, FLUSHALL);
671 670
672 671 mp = mexchange(NULL, NULL, 2, M_ERROR, -1);
673 672 if (mp != NULL) {
674 673 mp->b_rptr[0] = NOERROR;
675 674 mp->b_rptr[1] = EINVAL;
676 675 qreply(qp, mp);
677 676 }
678 677 PT_EXIT_READ(ptmp);
679 678 return;
680 679 }
681 680 /*
682 681 * while there are messages on this write queue...
683 682 */
684 683 do {
685 684 /*
686 685 * if don't have control message and cannot put
687 686 * msg. on slave's read queue, put it back on
688 687 * this queue.
689 688 */
690 689 if (mp->b_datap->db_type <= QPCTL &&
691 690 !bcanputnext(ptmp->pts_rdq, mp->b_band)) {
692 691 DBG(("put msg. back on queue\n"));
693 692 (void) putbq(qp, mp);
694 693 break;
695 694 }
696 695 /*
697 696 * else send the message up slave's stream
698 697 */
699 698 DBG(("send message to slave\n"));
700 699 putnext(ptmp->pts_rdq, mp);
701 700 } while ((mp = getq(qp)) != NULL);
702 701 DBG(("leaving ptmwsrv\n"));
703 702 PT_EXIT_READ(ptmp);
704 703 }
|
↓ open down ↓ |
476 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX