![[BACK]](/icons/back.gif){kind=icon}
Return to tty_pty.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern|
Return to tty_pty.c CVS log | Up to [local] / sys / kern |
1.1 nbrk 1: /* $OpenBSD: tty_pty.c,v 1.34 2007/05/29 00:17:32 thib Exp $ */
2: /* $NetBSD: tty_pty.c,v 1.33.4.1 1996/06/02 09:08:11 mrg Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1989, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the University nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: *
32: * @(#)tty_pty.c 8.4 (Berkeley) 2/20/95
33: */
34:
35: /*
36: * Pseudo-teletype Driver
37: * (Actually two drivers, requiring two entries in 'cdevsw')
38: */
39:
40: #include <sys/param.h>
41: #include <sys/systm.h>
42: #include <sys/namei.h>
43: #include <sys/mount.h>
44: #include <sys/ioctl.h>
45: #include <sys/proc.h>
46: #include <sys/tty.h>
47: #include <sys/file.h>
48: #include <sys/filedesc.h>
49: #include <sys/uio.h>
50: #include <sys/kernel.h>
51: #include <sys/malloc.h>
52: #include <sys/vnode.h>
53: #include <sys/signalvar.h>
54: #include <sys/uio.h>
55: #include <sys/conf.h>
56: #include <sys/stat.h>
57: #include <sys/sysctl.h>
58: #include <sys/poll.h>
59: #include <sys/rwlock.h>
60:
61: #define BUFSIZ 100 /* Chunk size iomoved to/from user */
62:
63: /*
64: * pts == /dev/tty[p-zP-T][0-9a-zA-Z]
65: * ptc == /dev/pty[p-zP-T][0-9a-zA-Z]
66: */
67:
68: /* XXX this needs to come from somewhere sane, and work with MAKEDEV */
69: #define TTY_LETTERS "pqrstuvwxyzPQRST"
70: #define TTY_SUFFIX "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
71:
72: static int pts_major;
73:
74: struct pt_softc {
75: struct tty *pt_tty;
76: int pt_flags;
77: struct selinfo pt_selr, pt_selw;
78: u_char pt_send;
79: u_char pt_ucntl;
80: char pty_pn[11];
81: char pty_sn[11];
82: };
83:
84: #define NPTY_MIN 8 /* number of initial ptys */
85: #define NPTY_MAX 992 /* maximum number of ptys supported */
86:
87: static struct pt_softc **pt_softc = NULL; /* pty array */
88: static int npty = 0; /* size of pty array */
89: static int maxptys = NPTY_MAX; /* maximum number of ptys */
90: /* for pty array */
91: struct rwlock pt_softc_lock = RWLOCK_INITIALIZER("ptarrlk");
92:
93: #define PF_PKT 0x08 /* packet mode */
94: #define PF_STOPPED 0x10 /* user told stopped */
95: #define PF_REMOTE 0x20 /* remote and flow controlled input */
96: #define PF_NOSTOP 0x40
97: #define PF_UCNTL 0x80 /* user control mode */
98:
99: void ptyattach(int);
100: void ptcwakeup(struct tty *, int);
101: struct tty *ptytty(dev_t);
102: void ptsstart(struct tty *);
103: int sysctl_pty(int *, u_int, void *, size_t *, void *, size_t);
104:
105: void filt_ptcrdetach(struct knote *);
106: int filt_ptcread(struct knote *, long);
107: void filt_ptcwdetach(struct knote *);
108: int filt_ptcwrite(struct knote *, long);
109:
110: static struct pt_softc **ptyarralloc(int);
111: static int check_pty(int);
112:
113: static gid_t tty_gid = TTY_GID;
114:
115: void ptydevname(int, struct pt_softc *);
116: dev_t pty_getfree(void);
117:
118: void ptmattach(int);
119: int ptmopen(dev_t, int, int, struct proc *);
120: int ptmclose(dev_t, int, int, struct proc *);
121: int ptmread(dev_t, struct uio *, int);
122: int ptmwrite(dev_t, struct uio *, int);
123: int ptmwrite(dev_t, struct uio *, int);
124: int ptmioctl(dev_t, u_long, caddr_t, int, struct proc *p);
125: int ptmpoll(dev_t, int, struct proc *p);
126: static int ptm_vn_open(struct nameidata *);
127:
128: void
129: ptydevname(int minor, struct pt_softc *pti)
130: {
131: char buf[11] = "/dev/XtyXX";
132: int i, j;
133:
134: i = minor / (sizeof(TTY_SUFFIX) - 1);
135: j = minor % (sizeof(TTY_SUFFIX) - 1);
136: if (i >= sizeof(TTY_LETTERS) - 1) {
137: pti->pty_pn[0] = '\0';
138: pti->pty_sn[0] = '\0';
139: return;
140: }
141: buf[5] = 'p';
142: buf[8] = TTY_LETTERS[i];
143: buf[9] = TTY_SUFFIX[j];
144: memcpy(pti->pty_pn, buf, sizeof(buf));
145: buf[5] = 't';
146: memcpy(pti->pty_sn, buf, sizeof(buf));
147: }
148:
149: /*
150: * Allocate and zero array of nelem elements.
151: */
152: struct pt_softc **
153: ptyarralloc(int nelem)
154: {
155: struct pt_softc **pt;
156:
157: pt = malloc(nelem * sizeof(struct pt_softc *), M_DEVBUF, M_WAITOK);
158: bzero(pt, nelem * sizeof(struct pt_softc *));
159: return pt;
160: }
161:
162: /*
163: * Check if the minor is correct and ensure necessary structures
164: * are properly allocated.
165: */
166: int
167: check_pty(int minor)
168: {
169: struct pt_softc *pti;
170:
171: rw_enter_write(&pt_softc_lock);
172: if (minor >= npty) {
173: struct pt_softc **newpt;
174: int newnpty;
175:
176: /* check if the requested pty can be granted */
177: if (minor >= maxptys)
178: goto limit_reached;
179:
180: /* grow pty array by powers of two, up to maxptys */
181: for (newnpty = npty; newnpty <= minor; newnpty *= 2)
182: ;
183:
184: if (newnpty > maxptys)
185: newnpty = maxptys;
186: newpt = ptyarralloc(newnpty);
187:
188: if (maxptys == npty) {
189: goto limit_reached;
190: }
191:
192: memcpy(newpt, pt_softc, npty * sizeof(struct pt_softc *));
193: free(pt_softc, M_DEVBUF);
194: pt_softc = newpt;
195: npty = newnpty;
196: }
197:
198: /*
199: * If the entry is not yet allocated, allocate one.
200: */
201: if (!pt_softc[minor]) {
202: MALLOC(pti, struct pt_softc *, sizeof(struct pt_softc),
203: M_DEVBUF, M_WAITOK);
204: bzero(pti, sizeof(struct pt_softc));
205: pti->pt_tty = ttymalloc();
206: ptydevname(minor, pti);
207: pt_softc[minor] = pti;
208: }
209: rw_exit_write(&pt_softc_lock);
210: return (0);
211: limit_reached:
212: rw_exit_write(&pt_softc_lock);
213: tablefull("pty");
214: return (ENXIO);
215: }
216:
217: /*
218: * Establish n (or default if n is 1) ptys in the system.
219: */
220: void
221: ptyattach(int n)
222: {
223: /* maybe should allow 0 => none? */
224: if (n <= 1)
225: n = NPTY_MIN;
226: pt_softc = ptyarralloc(n);
227: npty = n;
228:
229: /*
230: * If we have pty, we need ptm too.
231: */
232: ptmattach(1);
233: }
234:
235: /*ARGSUSED*/
236: int
237: ptsopen(dev_t dev, int flag, int devtype, struct proc *p)
238: {
239: struct pt_softc *pti;
240: struct tty *tp;
241: int error;
242:
243: if ((error = check_pty(minor(dev))))
244: return (error);
245:
246: pti = pt_softc[minor(dev)];
247: if (!pti->pt_tty) {
248: tp = pti->pt_tty = ttymalloc();
249: } else
250: tp = pti->pt_tty;
251: if ((tp->t_state & TS_ISOPEN) == 0) {
252: tp->t_state |= TS_WOPEN;
253: ttychars(tp); /* Set up default chars */
254: tp->t_iflag = TTYDEF_IFLAG;
255: tp->t_oflag = TTYDEF_OFLAG;
256: tp->t_lflag = TTYDEF_LFLAG;
257: tp->t_cflag = TTYDEF_CFLAG;
258: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
259: ttsetwater(tp); /* would be done in xxparam() */
260: } else if (tp->t_state&TS_XCLUDE && p->p_ucred->cr_uid != 0)
261: return (EBUSY);
262: if (tp->t_oproc) /* Ctrlr still around. */
263: tp->t_state |= TS_CARR_ON;
264: while ((tp->t_state & TS_CARR_ON) == 0) {
265: tp->t_state |= TS_WOPEN;
266: if (flag&FNONBLOCK)
267: break;
268: error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
269: ttopen, 0);
270: if (error)
271: return (error);
272: }
273: error = (*linesw[tp->t_line].l_open)(dev, tp);
274: ptcwakeup(tp, FREAD|FWRITE);
275: return (error);
276: }
277:
278: int
279: ptsclose(dev_t dev, int flag, int mode, struct proc *p)
280: {
281: struct pt_softc *pti = pt_softc[minor(dev)];
282: struct tty *tp = pti->pt_tty;
283: int error;
284:
285: error = (*linesw[tp->t_line].l_close)(tp, flag);
286: error |= ttyclose(tp);
287: ptcwakeup(tp, FREAD|FWRITE);
288: return (error);
289: }
290:
291: int
292: ptsread(dev_t dev, struct uio *uio, int flag)
293: {
294: struct proc *p = curproc;
295: struct pt_softc *pti = pt_softc[minor(dev)];
296: struct tty *tp = pti->pt_tty;
297: int error = 0;
298:
299: again:
300: if (pti->pt_flags & PF_REMOTE) {
301: while (isbackground(p, tp)) {
302: if ((p->p_sigignore & sigmask(SIGTTIN)) ||
303: (p->p_sigmask & sigmask(SIGTTIN)) ||
304: p->p_pgrp->pg_jobc == 0 ||
305: p->p_flag & P_PPWAIT)
306: return (EIO);
307: pgsignal(p->p_pgrp, SIGTTIN, 1);
308: error = ttysleep(tp, &lbolt,
309: TTIPRI | PCATCH, ttybg, 0);
310: if (error)
311: return (error);
312: }
313: if (tp->t_canq.c_cc == 0) {
314: if (flag & IO_NDELAY)
315: return (EWOULDBLOCK);
316: error = ttysleep(tp, &tp->t_canq,
317: TTIPRI | PCATCH, ttyin, 0);
318: if (error)
319: return (error);
320: goto again;
321: }
322: while (tp->t_canq.c_cc > 1 && uio->uio_resid > 0)
323: if (ureadc(getc(&tp->t_canq), uio) < 0) {
324: error = EFAULT;
325: break;
326: }
327: if (tp->t_canq.c_cc == 1)
328: (void) getc(&tp->t_canq);
329: if (tp->t_canq.c_cc)
330: return (error);
331: } else
332: if (tp->t_oproc)
333: error = (*linesw[tp->t_line].l_read)(tp, uio, flag);
334: ptcwakeup(tp, FWRITE);
335: return (error);
336: }
337:
338: /*
339: * Write to pseudo-tty.
340: * Wakeups of controlling tty will happen
341: * indirectly, when tty driver calls ptsstart.
342: */
343: int
344: ptswrite(dev_t dev, struct uio *uio, int flag)
345: {
346: struct pt_softc *pti = pt_softc[minor(dev)];
347: struct tty *tp = pti->pt_tty;
348:
349: if (tp->t_oproc == 0)
350: return (EIO);
351: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
352: }
353:
354: /*
355: * Start output on pseudo-tty.
356: * Wake up process polling or sleeping for input from controlling tty.
357: */
358: void
359: ptsstart(struct tty *tp)
360: {
361: struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
362:
363: if (tp->t_state & TS_TTSTOP)
364: return;
365: if (pti->pt_flags & PF_STOPPED) {
366: pti->pt_flags &= ~PF_STOPPED;
367: pti->pt_send = TIOCPKT_START;
368: }
369: ptcwakeup(tp, FREAD);
370: }
371:
372: int
373: ptsstop(struct tty *tp, int flush)
374: {
375: struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
376: int flag;
377:
378: /* note: FLUSHREAD and FLUSHWRITE already ok */
379: if (flush == 0) {
380: flush = TIOCPKT_STOP;
381: pti->pt_flags |= PF_STOPPED;
382: } else
383: pti->pt_flags &= ~PF_STOPPED;
384: pti->pt_send |= flush;
385: /* change of perspective */
386: flag = 0;
387: if (flush & FREAD)
388: flag |= FWRITE;
389: if (flush & FWRITE)
390: flag |= FREAD;
391: ptcwakeup(tp, flag);
392: return 0;
393: }
394:
395: void
396: ptcwakeup(struct tty *tp, int flag)
397: {
398: struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
399:
400: if (flag & FREAD) {
401: selwakeup(&pti->pt_selr);
402: wakeup(&tp->t_outq.c_cf);
403: KNOTE(&pti->pt_selr.si_note, 0);
404: }
405: if (flag & FWRITE) {
406: selwakeup(&pti->pt_selw);
407: wakeup(&tp->t_rawq.c_cf);
408: KNOTE(&pti->pt_selw.si_note, 0);
409: }
410: }
411:
412: int ptcopen(dev_t, int, int, struct proc *);
413:
414: /*ARGSUSED*/
415: int
416: ptcopen(dev_t dev, int flag, int devtype, struct proc *p)
417: {
418: struct pt_softc *pti;
419: struct tty *tp;
420: int error;
421:
422: if ((error = check_pty(minor(dev))))
423: return (error);
424:
425: pti = pt_softc[minor(dev)];
426: if (!pti->pt_tty) {
427: tp = pti->pt_tty = ttymalloc();
428: } else
429: tp = pti->pt_tty;
430: if (tp->t_oproc)
431: return (EIO);
432: tp->t_oproc = ptsstart;
433: (void)(*linesw[tp->t_line].l_modem)(tp, 1);
434: tp->t_lflag &= ~EXTPROC;
435: pti->pt_flags = 0;
436: pti->pt_send = 0;
437: pti->pt_ucntl = 0;
438: return (0);
439: }
440:
441: /*ARGSUSED*/
442: int
443: ptcclose(dev_t dev, int flag, int devtype, struct proc *p)
444: {
445: struct pt_softc *pti = pt_softc[minor(dev)];
446: struct tty *tp = pti->pt_tty;
447:
448: (void)(*linesw[tp->t_line].l_modem)(tp, 0);
449: tp->t_state &= ~TS_CARR_ON;
450: tp->t_oproc = 0; /* mark closed */
451: return (0);
452: }
453:
454: int
455: ptcread(dev_t dev, struct uio *uio, int flag)
456: {
457: struct pt_softc *pti = pt_softc[minor(dev)];
458: struct tty *tp = pti->pt_tty;
459: char buf[BUFSIZ];
460: int error = 0, cc;
461:
462: /*
463: * We want to block until the slave
464: * is open, and there's something to read;
465: * but if we lost the slave or we're NBIO,
466: * then return the appropriate error instead.
467: */
468: for (;;) {
469: if (tp->t_state&TS_ISOPEN) {
470: if (pti->pt_flags&PF_PKT && pti->pt_send) {
471: error = ureadc((int)pti->pt_send, uio);
472: if (error)
473: return (error);
474: if (pti->pt_send & TIOCPKT_IOCTL) {
475: cc = min(uio->uio_resid,
476: sizeof(tp->t_termios));
477: uiomove(&tp->t_termios, cc, uio);
478: }
479: pti->pt_send = 0;
480: return (0);
481: }
482: if (pti->pt_flags&PF_UCNTL && pti->pt_ucntl) {
483: error = ureadc((int)pti->pt_ucntl, uio);
484: if (error)
485: return (error);
486: pti->pt_ucntl = 0;
487: return (0);
488: }
489: if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0)
490: break;
491: }
492: if ((tp->t_state&TS_CARR_ON) == 0)
493: return (0); /* EOF */
494: if (flag & IO_NDELAY)
495: return (EWOULDBLOCK);
496: error = tsleep(&tp->t_outq.c_cf, TTIPRI | PCATCH,
497: ttyin, 0);
498: if (error)
499: return (error);
500: }
501: if (pti->pt_flags & (PF_PKT|PF_UCNTL))
502: error = ureadc(0, uio);
503: while (uio->uio_resid > 0 && error == 0) {
504: cc = q_to_b(&tp->t_outq, buf, min(uio->uio_resid, BUFSIZ));
505: if (cc <= 0)
506: break;
507: error = uiomove(buf, cc, uio);
508: }
509: if (tp->t_outq.c_cc <= tp->t_lowat) {
510: if (tp->t_state&TS_ASLEEP) {
511: tp->t_state &= ~TS_ASLEEP;
512: wakeup(&tp->t_outq);
513: }
514: selwakeup(&tp->t_wsel);
515: }
516: return (error);
517: }
518:
519:
520: int
521: ptcwrite(dev_t dev, struct uio *uio, int flag)
522: {
523: struct pt_softc *pti = pt_softc[minor(dev)];
524: struct tty *tp = pti->pt_tty;
525: u_char *cp = NULL;
526: int cc = 0;
527: u_char locbuf[BUFSIZ];
528: int cnt = 0;
529: int error = 0;
530:
531: again:
532: if ((tp->t_state&TS_ISOPEN) == 0)
533: goto block;
534: if (pti->pt_flags & PF_REMOTE) {
535: if (tp->t_canq.c_cc)
536: goto block;
537: while (uio->uio_resid > 0 && tp->t_canq.c_cc < TTYHOG - 1) {
538: if (cc == 0) {
539: cc = min(uio->uio_resid, BUFSIZ);
540: cc = min(cc, TTYHOG - 1 - tp->t_canq.c_cc);
541: cp = locbuf;
542: error = uiomove(cp, cc, uio);
543: if (error)
544: return (error);
545: /* check again for safety */
546: if ((tp->t_state&TS_ISOPEN) == 0)
547: return (EIO);
548: }
549: if (cc)
550: (void) b_to_q((char *)cp, cc, &tp->t_canq);
551: cc = 0;
552: }
553: (void) putc(0, &tp->t_canq);
554: ttwakeup(tp);
555: wakeup(&tp->t_canq);
556: return (0);
557: }
558: while (uio->uio_resid > 0) {
559: if (cc == 0) {
560: cc = min(uio->uio_resid, BUFSIZ);
561: cp = locbuf;
562: error = uiomove(cp, cc, uio);
563: if (error)
564: return (error);
565: /* check again for safety */
566: if ((tp->t_state&TS_ISOPEN) == 0)
567: return (EIO);
568: }
569: while (cc > 0) {
570: if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 &&
571: (tp->t_canq.c_cc > 0 || !ISSET(tp->t_lflag, ICANON))) {
572: wakeup(&tp->t_rawq);
573: goto block;
574: }
575: (*linesw[tp->t_line].l_rint)(*cp++, tp);
576: cnt++;
577: cc--;
578: }
579: cc = 0;
580: }
581: return (0);
582: block:
583: /*
584: * Come here to wait for slave to open, for space
585: * in outq, or space in rawq.
586: */
587: if ((tp->t_state&TS_CARR_ON) == 0)
588: return (EIO);
589: if (flag & IO_NDELAY) {
590: /* adjust for data copied in but not written */
591: uio->uio_resid += cc;
592: if (cnt == 0)
593: return (EWOULDBLOCK);
594: return (0);
595: }
596: error = tsleep(&tp->t_rawq.c_cf, TTOPRI | PCATCH,
597: ttyout, 0);
598: if (error) {
599: /* adjust for data copied in but not written */
600: uio->uio_resid += cc;
601: return (error);
602: }
603: goto again;
604: }
605:
606: int
607: ptcpoll(dev_t dev, int events, struct proc *p)
608: {
609: struct pt_softc *pti = pt_softc[minor(dev)];
610: struct tty *tp = pti->pt_tty;
611: int revents = 0, s;
612:
613: if (!ISSET(tp->t_state, TS_CARR_ON))
614: return (POLLHUP);
615:
616: if (!ISSET(tp->t_state, TS_ISOPEN))
617: goto notopen;
618:
619: if (events & (POLLIN | POLLRDNORM)) {
620: /*
621: * Need to protect access to t_outq
622: */
623: s = spltty();
624: if ((tp->t_outq.c_cc && !ISSET(tp->t_state, TS_TTSTOP)) ||
625: ((pti->pt_flags & PF_PKT) && pti->pt_send) ||
626: ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))
627: revents |= events & (POLLIN | POLLRDNORM);
628: splx(s);
629: }
630: if (events & (POLLOUT | POLLWRNORM)) {
631: if ((pti->pt_flags & PF_REMOTE) ?
632: (tp->t_canq.c_cc == 0) :
633: ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG - 2) ||
634: (tp->t_canq.c_cc == 0 && ISSET(tp->t_lflag, ICANON))))
635: revents |= events & (POLLOUT | POLLWRNORM);
636: }
637: if (events & (POLLPRI | POLLRDBAND)) {
638: /* If in packet or user control mode, check for data. */
639: if (((pti->pt_flags & PF_PKT) && pti->pt_send) ||
640: ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))
641: revents |= events & (POLLPRI | POLLRDBAND);
642: }
643:
644: if (revents == 0) {
645: notopen:
646: if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND))
647: selrecord(p, &pti->pt_selr);
648: if (events & (POLLOUT | POLLWRNORM))
649: selrecord(p, &pti->pt_selw);
650: }
651:
652: return (revents);
653: }
654:
655: void
656: filt_ptcrdetach(struct knote *kn)
657: {
658: struct pt_softc *pti = (struct pt_softc *)kn->kn_hook;
659: int s;
660:
661: s = spltty();
662: SLIST_REMOVE(&pti->pt_selr.si_note, kn, knote, kn_selnext);
663: splx(s);
664: }
665:
666: int
667: filt_ptcread(struct knote *kn, long hint)
668: {
669: struct pt_softc *pti = (struct pt_softc *)kn->kn_hook;
670: struct tty *tp;
671:
672: tp = pti->pt_tty;
673: kn->kn_data = 0;
674:
675: if (ISSET(tp->t_state, TS_ISOPEN)) {
676: if (!ISSET(tp->t_state, TS_TTSTOP))
677: kn->kn_data = tp->t_outq.c_cc;
678: if (((pti->pt_flags & PF_PKT) && pti->pt_send) ||
679: ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))
680: kn->kn_data++;
681: }
682: return (kn->kn_data > 0);
683: }
684:
685: void
686: filt_ptcwdetach(struct knote *kn)
687: {
688: struct pt_softc *pti = (struct pt_softc *)kn->kn_hook;
689: int s;
690:
691: s = spltty();
692: SLIST_REMOVE(&pti->pt_selw.si_note, kn, knote, kn_selnext);
693: splx(s);
694: }
695:
696: int
697: filt_ptcwrite(struct knote *kn, long hint)
698: {
699: struct pt_softc *pti = (struct pt_softc *)kn->kn_hook;
700: struct tty *tp;
701:
702: tp = pti->pt_tty;
703: kn->kn_data = 0;
704:
705: if (ISSET(tp->t_state, TS_ISOPEN)) {
706: if (ISSET(pti->pt_flags, PF_REMOTE)) {
707: if (tp->t_canq.c_cc == 0)
708: kn->kn_data = tp->t_canq.c_cn;
709: } else if (tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG-2)
710: kn->kn_data = tp->t_canq.c_cn -
711: (tp->t_rawq.c_cc + tp->t_canq.c_cc);
712: }
713:
714: return (kn->kn_data > 0);
715: }
716:
717: struct filterops ptcread_filtops =
718: { 1, NULL, filt_ptcrdetach, filt_ptcread };
719: struct filterops ptcwrite_filtops =
720: { 1, NULL, filt_ptcwdetach, filt_ptcwrite };
721:
722: int
723: ptckqfilter(dev_t dev, struct knote *kn)
724: {
725: struct pt_softc *pti = pt_softc[minor(dev)];
726: struct klist *klist;
727: int s;
728:
729: switch (kn->kn_filter) {
730: case EVFILT_READ:
731: klist = &pti->pt_selr.si_note;
732: kn->kn_fop = &ptcread_filtops;
733: break;
734: case EVFILT_WRITE:
735: klist = &pti->pt_selw.si_note;
736: kn->kn_fop = &ptcwrite_filtops;
737: break;
738: default:
739: return (1);
740: }
741:
742: kn->kn_hook = (caddr_t)pti;
743:
744: s = spltty();
745: SLIST_INSERT_HEAD(klist, kn, kn_selnext);
746: splx(s);
747:
748: return (0);
749: }
750:
751: struct tty *
752: ptytty(dev_t dev)
753: {
754: struct pt_softc *pti = pt_softc[minor(dev)];
755: struct tty *tp = pti->pt_tty;
756:
757: return (tp);
758: }
759:
760: /*ARGSUSED*/
761: int
762: ptyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
763: {
764: struct pt_softc *pti = pt_softc[minor(dev)];
765: struct tty *tp = pti->pt_tty;
766: u_char *cc = tp->t_cc;
767: int stop, error;
768:
769: /*
770: * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG.
771: * ttywflush(tp) will hang if there are characters in the outq.
772: */
773: if (cmd == TIOCEXT) {
774: /*
775: * When the EXTPROC bit is being toggled, we need
776: * to send an TIOCPKT_IOCTL if the packet driver
777: * is turned on.
778: */
779: if (*(int *)data) {
780: if (pti->pt_flags & PF_PKT) {
781: pti->pt_send |= TIOCPKT_IOCTL;
782: ptcwakeup(tp, FREAD);
783: }
784: tp->t_lflag |= EXTPROC;
785: } else {
786: if ((tp->t_lflag & EXTPROC) &&
787: (pti->pt_flags & PF_PKT)) {
788: pti->pt_send |= TIOCPKT_IOCTL;
789: ptcwakeup(tp, FREAD);
790: }
791: tp->t_lflag &= ~EXTPROC;
792: }
793: return(0);
794: } else
795: if (cdevsw[major(dev)].d_open == ptcopen)
796: switch (cmd) {
797:
798: case TIOCGPGRP:
799: #ifdef COMPAT_SUNOS
800: {
801: /*
802: * I'm not sure about SunOS TIOCGPGRP semantics
803: * on PTYs, but it's something like this:
804: */
805: extern struct emul emul_sunos;
806: if (p->p_emul == &emul_sunos) {
807: if (tp->t_pgrp == 0)
808: return (EIO);
809: *(int *)data = tp->t_pgrp->pg_id;
810: return (0);
811: }
812: }
813: #endif
814: /*
815: * We avoid calling ttioctl on the controller since,
816: * in that case, tp must be the controlling terminal.
817: */
818: *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;
819: return (0);
820:
821: case TIOCPKT:
822: if (*(int *)data) {
823: if (pti->pt_flags & PF_UCNTL)
824: return (EINVAL);
825: pti->pt_flags |= PF_PKT;
826: } else
827: pti->pt_flags &= ~PF_PKT;
828: return (0);
829:
830: case TIOCUCNTL:
831: if (*(int *)data) {
832: if (pti->pt_flags & PF_PKT)
833: return (EINVAL);
834: pti->pt_flags |= PF_UCNTL;
835: } else
836: pti->pt_flags &= ~PF_UCNTL;
837: return (0);
838:
839: case TIOCREMOTE:
840: if (*(int *)data)
841: pti->pt_flags |= PF_REMOTE;
842: else
843: pti->pt_flags &= ~PF_REMOTE;
844: ttyflush(tp, FREAD|FWRITE);
845: return (0);
846:
847: #ifdef COMPAT_OLDTTY
848: case TIOCSETP:
849: case TIOCSETN:
850: #endif
851: case TIOCSETD:
852: case TIOCSETA:
853: case TIOCSETAW:
854: case TIOCSETAF:
855: ndflush(&tp->t_outq, tp->t_outq.c_cc);
856: break;
857:
858: case TIOCSIG:
859: if (*(unsigned int *)data >= NSIG)
860: return(EINVAL);
861: if ((tp->t_lflag&NOFLSH) == 0)
862: ttyflush(tp, FREAD|FWRITE);
863: pgsignal(tp->t_pgrp, *(unsigned int *)data, 1);
864: if ((*(unsigned int *)data == SIGINFO) &&
865: ((tp->t_lflag&NOKERNINFO) == 0))
866: ttyinfo(tp);
867: return(0);
868: }
869: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
870: if (error < 0)
871: error = ttioctl(tp, cmd, data, flag, p);
872: if (error < 0) {
873: if (pti->pt_flags & PF_UCNTL &&
874: (cmd & ~0xff) == UIOCCMD(0)) {
875: if (cmd & 0xff) {
876: pti->pt_ucntl = (u_char)cmd;
877: ptcwakeup(tp, FREAD);
878: }
879: return (0);
880: }
881: error = ENOTTY;
882: }
883: /*
884: * If external processing and packet mode send ioctl packet.
885: */
886: if ((tp->t_lflag&EXTPROC) && (pti->pt_flags & PF_PKT)) {
887: switch (cmd) {
888: case TIOCSETA:
889: case TIOCSETAW:
890: case TIOCSETAF:
891: #ifdef COMPAT_OLDTTY
892: case TIOCSETP:
893: case TIOCSETN:
894: case TIOCSETC:
895: case TIOCSLTC:
896: case TIOCLBIS:
897: case TIOCLBIC:
898: case TIOCLSET:
899: #endif
900: pti->pt_send |= TIOCPKT_IOCTL;
901: ptcwakeup(tp, FREAD);
902: default:
903: break;
904: }
905: }
906: stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s')) &&
907: CCEQ(cc[VSTART], CTRL('q'));
908: if (pti->pt_flags & PF_NOSTOP) {
909: if (stop) {
910: pti->pt_send &= ~TIOCPKT_NOSTOP;
911: pti->pt_send |= TIOCPKT_DOSTOP;
912: pti->pt_flags &= ~PF_NOSTOP;
913: ptcwakeup(tp, FREAD);
914: }
915: } else {
916: if (!stop) {
917: pti->pt_send &= ~TIOCPKT_DOSTOP;
918: pti->pt_send |= TIOCPKT_NOSTOP;
919: pti->pt_flags |= PF_NOSTOP;
920: ptcwakeup(tp, FREAD);
921: }
922: }
923: return (error);
924: }
925:
926: /*
927: * Return pty-related information.
928: */
929: int
930: sysctl_pty(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
931: size_t newlen)
932: {
933: int error, oldmax;
934:
935: if (namelen != 1)
936: return (ENOTDIR);
937:
938: switch (name[0]) {
939: case KERN_TTY_MAXPTYS:
940: if (!newp)
941: return (sysctl_rdint(oldp, oldlenp, newp, maxptys));
942: rw_enter_write(&pt_softc_lock);
943: oldmax = maxptys;
944: error = sysctl_int(oldp, oldlenp, newp, newlen, &maxptys);
945: /*
946: * We can't set the max lower than the current active
947: * value or to a value bigger than NPTY_MAX.
948: */
949: if (error == 0 && (maxptys > NPTY_MAX || maxptys < npty)) {
950: maxptys = oldmax;
951: error = ERANGE;
952: }
953: rw_exit_write(&pt_softc_lock);
954: return (error);
955: case KERN_TTY_NPTYS:
956: return (sysctl_rdint(oldp, oldlenp, newp, npty));
957: #ifdef notyet
958: case KERN_TTY_GID:
959: return (sysctl_int(oldp, oldlenp, newp, newlen, &tty_gid));
960: #endif
961: default:
962: return (EOPNOTSUPP);
963: }
964: /* NOTREACHED */
965: }
966:
967: /*
968: * Check if a pty is free to use.
969: */
970: static __inline int
971: pty_isfree_locked(int minor)
972: {
973: struct pt_softc *pt = pt_softc[minor];
974: return (pt == NULL || pt->pt_tty == NULL ||
975: pt->pt_tty->t_oproc == NULL);
976: }
977:
978: static int
979: pty_isfree(int minor)
980: {
981: int isfree;
982:
983: rw_enter_read(&pt_softc_lock);
984: isfree = pty_isfree_locked(minor);
985: rw_exit_read(&pt_softc_lock);
986: return(isfree);
987: }
988:
989: dev_t
990: pty_getfree(void)
991: {
992: int i;
993:
994: rw_enter_read(&pt_softc_lock);
995: for (i = 0; i < npty; i++) {
996: if (pty_isfree_locked(i))
997: break;
998: }
999: rw_exit_read(&pt_softc_lock);
1000: return (makedev(pts_major, i));
1001: }
1002:
1003: /*
1004: * Hacked up version of vn_open. We _only_ handle ptys and only open
1005: * them with FREAD|FWRITE and never deal with creat or stuff like that.
1006: *
1007: * We need it because we have to fake up root credentials to open the pty.
1008: */
1009: static int
1010: ptm_vn_open(struct nameidata *ndp)
1011: {
1012: struct proc *p = ndp->ni_cnd.cn_proc;
1013: struct ucred *cred;
1014: struct vattr vattr;
1015: struct vnode *vp;
1016: int error;
1017:
1018: if ((error = namei(ndp)) != 0)
1019: return (error);
1020: vp = ndp->ni_vp;
1021: if (vp->v_type != VCHR) {
1022: error = EINVAL;
1023: goto bad;
1024: }
1025:
1026: /*
1027: * Get us a fresh cred with root privileges.
1028: */
1029: cred = crget();
1030: error = VOP_OPEN(vp, FREAD|FWRITE, cred, p);
1031: if (!error) {
1032: /* update atime/mtime */
1033: VATTR_NULL(&vattr);
1034: getnanotime(&vattr.va_atime);
1035: vattr.va_mtime = vattr.va_atime;
1036: vattr.va_vaflags |= VA_UTIMES_NULL;
1037: (void)VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1038: }
1039: crfree(cred);
1040:
1041: if (error)
1042: goto bad;
1043:
1044: vp->v_writecount++;
1045:
1046: return (0);
1047: bad:
1048: vput(vp);
1049: return (error);
1050: }
1051:
1052: void
1053: ptmattach(int n)
1054: {
1055: /* find the major and minor of the pty devices */
1056: int i;
1057:
1058: for (i = 0; i < nchrdev; i++)
1059: if (cdevsw[i].d_open == ptsopen)
1060: break;
1061:
1062: if (i == nchrdev)
1063: panic("ptmattach: Can't find pty slave in cdevsw");
1064:
1065: pts_major = i;
1066: }
1067:
1068: int
1069: ptmopen(dev_t dev, int flag, int mode, struct proc *p)
1070: {
1071: return(0);
1072: }
1073:
1074:
1075: int
1076: ptmclose(dev_t dev, int flag, int mode, struct proc *p)
1077: {
1078: return (0);
1079: }
1080:
1081: int
1082: ptmread(dev_t dev, struct uio *uio, int ioflag)
1083: {
1084: return (EIO);
1085: }
1086:
1087: int
1088: ptmwrite(dev_t dev, struct uio *uio, int ioflag)
1089: {
1090: return (EIO);
1091: }
1092:
1093: int
1094: ptmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
1095: {
1096: dev_t newdev, error;
1097: struct pt_softc * pti;
1098: struct nameidata cnd, snd;
1099: struct filedesc *fdp = p->p_fd;
1100: struct file *cfp = NULL, *sfp = NULL;
1101: int cindx, sindx;
1102: uid_t uid;
1103: gid_t gid;
1104: struct vattr vattr;
1105: struct ucred *cred;
1106: struct ptmget *ptm = (struct ptmget *)data;
1107:
1108: error = 0;
1109: switch (cmd) {
1110: case PTMGET:
1111: fdplock(fdp);
1112: /* Grab two filedescriptors. */
1113: if ((error = falloc(p, &cfp, &cindx)) != 0) {
1114: fdpunlock(fdp);
1115: break;
1116: }
1117: if ((error = falloc(p, &sfp, &sindx)) != 0) {
1118: fdremove(fdp, cindx);
1119: closef(cfp, p);
1120: fdpunlock(fdp);
1121: break;
1122: }
1123:
1124: retry:
1125: /* Find and open a free master pty. */
1126: newdev = pty_getfree();
1127: if ((error = check_pty(minor(newdev))))
1128: goto bad;
1129: pti = pt_softc[minor(newdev)];
1130: NDINIT(&cnd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE,
1131: pti->pty_pn, p);
1132: if ((error = ptm_vn_open(&cnd)) != 0) {
1133: /*
1134: * Check if the master open failed because we lost
1135: * the race to grab it.
1136: */
1137: if (error == EIO && !pty_isfree(minor(newdev)))
1138: goto retry;
1139: goto bad;
1140: }
1141: cfp->f_flag = FREAD|FWRITE;
1142: cfp->f_type = DTYPE_VNODE;
1143: cfp->f_ops = &vnops;
1144: cfp->f_data = (caddr_t) cnd.ni_vp;
1145: VOP_UNLOCK(cnd.ni_vp, 0, p);
1146:
1147: /*
1148: * Open the slave.
1149: * namei -> setattr -> unlock -> revoke -> vrele ->
1150: * namei -> open -> unlock
1151: * Three stage rocket:
1152: * 1. Change the owner and permissions on the slave.
1153: * 2. Revoke all the users of the slave.
1154: * 3. open the slave.
1155: */
1156: NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE,
1157: pti->pty_sn, p);
1158: if ((error = namei(&snd)) != 0)
1159: goto bad;
1160: if ((snd.ni_vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
1161: gid = tty_gid;
1162: /* get real uid */
1163: uid = p->p_cred->p_ruid;
1164:
1165: VATTR_NULL(&vattr);
1166: vattr.va_uid = uid;
1167: vattr.va_gid = gid;
1168: vattr.va_mode = (S_IRUSR|S_IWUSR|S_IWGRP) & ALLPERMS;
1169: /* Get a fake cred to pretend we're root. */
1170: cred = crget();
1171: error = VOP_SETATTR(snd.ni_vp, &vattr, cred, p);
1172: crfree(cred);
1173: if (error) {
1174: vput(snd.ni_vp);
1175: goto bad;
1176: }
1177: }
1178: VOP_UNLOCK(snd.ni_vp, 0, p);
1179: if (snd.ni_vp->v_usecount > 1 ||
1180: (snd.ni_vp->v_flag & (VALIASED)))
1181: VOP_REVOKE(snd.ni_vp, REVOKEALL);
1182:
1183: /*
1184: * The vnode is useless after the revoke, we need to
1185: * namei again.
1186: */
1187: vrele(snd.ni_vp);
1188:
1189: NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE,
1190: pti->pty_sn, p);
1191: /* now open it */
1192: if ((error = ptm_vn_open(&snd)) != 0)
1193: goto bad;
1194: sfp->f_flag = FREAD|FWRITE;
1195: sfp->f_type = DTYPE_VNODE;
1196: sfp->f_ops = &vnops;
1197: sfp->f_data = (caddr_t) snd.ni_vp;
1198: VOP_UNLOCK(snd.ni_vp, 0, p);
1199:
1200: /* now, put the indexen and names into struct ptmget */
1201: ptm->cfd = cindx;
1202: ptm->sfd = sindx;
1203: memcpy(ptm->cn, pti->pty_pn, sizeof(pti->pty_pn));
1204: memcpy(ptm->sn, pti->pty_sn, sizeof(pti->pty_sn));
1205:
1206: /* mark the files mature now that we've passed all errors */
1207: FILE_SET_MATURE(cfp);
1208: FILE_SET_MATURE(sfp);
1209:
1210: fdpunlock(fdp);
1211: break;
1212: default:
1213: error = EINVAL;
1214: break;
1215: }
1216: return (error);
1217: bad:
1218: fdremove(fdp, cindx);
1219: closef(cfp, p);
1220: fdremove(fdp, sindx);
1221: closef(sfp, p);
1222: fdpunlock(fdp);
1223: return (error);
1224: }
1225:
1226: int
1227: ptmpoll(dev_t dev, int events, struct proc *p)
1228: {
1229: return (seltrue(dev, events, p));
1230: }