pty.c revision 130892
1214501Srpaulo/* 2214501Srpaulo * Copyright (c) 1982, 1986, 1989, 1993 3214501Srpaulo * The Regents of the University of California. All rights reserved. 4214501Srpaulo * 5214501Srpaulo * Redistribution and use in source and binary forms, with or without 6214501Srpaulo * modification, are permitted provided that the following conditions 7214501Srpaulo * are met: 8214501Srpaulo * 1. Redistributions of source code must retain the above copyright 9214501Srpaulo * notice, this list of conditions and the following disclaimer. 10214501Srpaulo * 2. Redistributions in binary form must reproduce the above copyright 11214501Srpaulo * notice, this list of conditions and the following disclaimer in the 12214501Srpaulo * documentation and/or other materials provided with the distribution. 13214501Srpaulo * 4. Neither the name of the University nor the names of its contributors 14214501Srpaulo * may be used to endorse or promote products derived from this software 15214501Srpaulo * without specific prior written permission. 16214501Srpaulo * 17214501Srpaulo * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18214501Srpaulo * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19214501Srpaulo * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20214501Srpaulo * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21214501Srpaulo * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22214501Srpaulo * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23214501Srpaulo * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24214501Srpaulo * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25214501Srpaulo * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26214501Srpaulo * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27214501Srpaulo * SUCH DAMAGE. 28214501Srpaulo * 29214501Srpaulo * @(#)tty_pty.c 8.4 (Berkeley) 2/20/95 30214501Srpaulo */ 31214501Srpaulo 32214501Srpaulo#include <sys/cdefs.h> 33214501Srpaulo__FBSDID("$FreeBSD: head/sys/kern/tty_pty.c 130892 2004-06-21 22:57:16Z phk $"); 34214501Srpaulo 35214501Srpaulo/* 36214501Srpaulo * Pseudo-teletype Driver 37214501Srpaulo * (Actually two drivers, requiring two entries in 'cdevsw') 38214501Srpaulo */ 39214501Srpaulo#include "opt_compat.h" 40214501Srpaulo#include "opt_tty.h" 41214501Srpaulo#include <sys/param.h> 42214501Srpaulo#include <sys/systm.h> 43214501Srpaulo#include <sys/lock.h> 44214501Srpaulo#include <sys/mutex.h> 45214501Srpaulo#include <sys/sx.h> 46214501Srpaulo#ifndef BURN_BRIDGES 47214501Srpaulo#if defined(COMPAT_43) 48214501Srpaulo#include <sys/ioctl_compat.h> 49214501Srpaulo#endif 50214501Srpaulo#endif 51214501Srpaulo#include <sys/proc.h> 52214501Srpaulo#include <sys/tty.h> 53214501Srpaulo#include <sys/conf.h> 54214501Srpaulo#include <sys/fcntl.h> 55214501Srpaulo#include <sys/poll.h> 56214501Srpaulo#include <sys/kernel.h> 57214501Srpaulo#include <sys/vnode.h> 58214501Srpaulo#include <sys/signalvar.h> 59214501Srpaulo#include <sys/malloc.h> 60214501Srpaulo 61214501Srpaulostatic MALLOC_DEFINE(M_PTY, "ptys", "pty data structures"); 62214501Srpaulo 63214501Srpaulostatic void ptsstart(struct tty *tp); 64214501Srpaulostatic void ptsstop(struct tty *tp, int rw); 65214501Srpaulostatic void ptcwakeup(struct tty *tp, int flag); 66214501Srpaulostatic struct cdev *ptyinit(struct cdev *cdev); 67214501Srpaulo 68214501Srpaulostatic d_open_t ptsopen; 69214501Srpaulostatic d_close_t ptsclose; 70214501Srpaulostatic d_read_t ptsread; 71214501Srpaulostatic d_write_t ptswrite; 72214501Srpaulostatic d_ioctl_t ptyioctl; 73214501Srpaulostatic d_open_t ptcopen; 74214501Srpaulostatic d_close_t ptcclose; 75214501Srpaulostatic d_read_t ptcread; 76214501Srpaulostatic d_write_t ptcwrite; 77214501Srpaulostatic d_poll_t ptcpoll; 78214501Srpaulo 79214501Srpaulo#define CDEV_MAJOR_S 5 80214501Srpaulostatic struct cdevsw pts_cdevsw = { 81214501Srpaulo .d_version = D_VERSION, 82214501Srpaulo .d_open = ptsopen, 83214501Srpaulo .d_close = ptsclose, 84214501Srpaulo .d_read = ptsread, 85214501Srpaulo .d_write = ptswrite, 86214501Srpaulo .d_ioctl = ptyioctl, 87214501Srpaulo .d_name = "pts", 88214501Srpaulo .d_maj = CDEV_MAJOR_S, 89214501Srpaulo .d_flags = D_TTY | D_NEEDGIANT, 90214501Srpaulo}; 91214501Srpaulo 92214501Srpaulo#define CDEV_MAJOR_C 6 93214501Srpaulostatic struct cdevsw ptc_cdevsw = { 94214501Srpaulo .d_version = D_VERSION, 95214501Srpaulo .d_open = ptcopen, 96214501Srpaulo .d_close = ptcclose, 97214501Srpaulo .d_read = ptcread, 98214501Srpaulo .d_write = ptcwrite, 99214501Srpaulo .d_ioctl = ptyioctl, 100214501Srpaulo .d_poll = ptcpoll, 101214501Srpaulo .d_name = "ptc", 102214501Srpaulo .d_maj = CDEV_MAJOR_C, 103214501Srpaulo .d_flags = D_TTY | D_NEEDGIANT, 104214501Srpaulo}; 105214501Srpaulo 106214501Srpaulo#define BUFSIZ 100 /* Chunk size iomoved to/from user */ 107214501Srpaulo 108214501Srpaulostruct ptsc { 109214501Srpaulo int pt_flags; 110214501Srpaulo struct selinfo pt_selr, pt_selw; 111214501Srpaulo u_char pt_send; 112214501Srpaulo u_char pt_ucntl; 113214501Srpaulo struct tty *pt_tty; 114214501Srpaulo struct cdev *devs, *devc; 115214501Srpaulo struct prison *pt_prison; 116214501Srpaulo}; 117214501Srpaulo 118214501Srpaulo#define PF_PKT 0x08 /* packet mode */ 119214501Srpaulo#define PF_STOPPED 0x10 /* user told stopped */ 120214501Srpaulo#define PF_REMOTE 0x20 /* remote and flow controlled input */ 121214501Srpaulo#define PF_NOSTOP 0x40 122214501Srpaulo#define PF_UCNTL 0x80 /* user control mode */ 123214501Srpaulo 124214501Srpaulo#define TSA_PTC_READ(tp) ((void *)&(tp)->t_outq.c_cf) 125214501Srpaulo#define TSA_PTC_WRITE(tp) ((void *)&(tp)->t_rawq.c_cl) 126214501Srpaulo#define TSA_PTS_READ(tp) ((void *)&(tp)->t_canq) 127214501Srpaulo 128214501Srpaulostatic char *names = "pqrsPQRS"; 129214501Srpaulo/* 130214501Srpaulo * This function creates and initializes a pts/ptc pair 131214501Srpaulo * 132214501Srpaulo * pts == /dev/tty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 133214501Srpaulo * ptc == /dev/pty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 134214501Srpaulo * 135214501Srpaulo * XXX: define and add mapping of upper minor bits to allow more 136214501Srpaulo * than 256 ptys. 137214501Srpaulo */ 138214501Srpaulostatic struct cdev * 139214501Srpauloptyinit(struct cdev *devc) 140214501Srpaulo{ 141214501Srpaulo struct cdev *devs; 142214501Srpaulo struct ptsc *pt; 143214501Srpaulo int n; 144214501Srpaulo 145214501Srpaulo n = minor(devc); 146214501Srpaulo /* For now we only map the lower 8 bits of the minor */ 147214501Srpaulo if (n & ~0xff) 148214501Srpaulo return (NULL); 149214501Srpaulo 150214501Srpaulo devc->si_flags &= ~SI_CHEAPCLONE; 151214501Srpaulo 152214501Srpaulo pt = malloc(sizeof(*pt), M_PTY, M_WAITOK | M_ZERO); 153214501Srpaulo pt->devs = devs = make_dev(&pts_cdevsw, n, 154214501Srpaulo UID_ROOT, GID_WHEEL, 0666, "tty%c%r", names[n / 32], n % 32); 155214501Srpaulo pt->devc = devc; 156214501Srpaulo 157214501Srpaulo pt->pt_tty = ttymalloc(pt->pt_tty); 158214501Srpaulo devs->si_drv1 = devc->si_drv1 = pt; 159214501Srpaulo devs->si_tty = devc->si_tty = pt->pt_tty; 160214501Srpaulo pt->pt_tty->t_dev = devs; 161214501Srpaulo return (devc); 162214501Srpaulo} 163214501Srpaulo 164214501Srpaulo/*ARGSUSED*/ 165214501Srpaulostatic int 166214501Srpauloptsopen(struct cdev *dev, int flag, int devtype, struct thread *td) 167214501Srpaulo{ 168214501Srpaulo struct tty *tp; 169214501Srpaulo int error; 170214501Srpaulo struct ptsc *pt; 171214501Srpaulo 172214501Srpaulo if (!dev->si_drv1) 173214501Srpaulo return(ENXIO); 174214501Srpaulo pt = dev->si_drv1; 175214501Srpaulo tp = dev->si_tty; 176214501Srpaulo if ((tp->t_state & TS_ISOPEN) == 0) { 177214501Srpaulo ttychars(tp); /* Set up default chars */ 178214501Srpaulo tp->t_iflag = TTYDEF_IFLAG; 179214501Srpaulo tp->t_oflag = TTYDEF_OFLAG; 180214501Srpaulo tp->t_lflag = TTYDEF_LFLAG; 181214501Srpaulo tp->t_cflag = TTYDEF_CFLAG; 182214501Srpaulo tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; 183214501Srpaulo } else if (tp->t_state & TS_XCLUDE && suser(td)) 184214501Srpaulo return (EBUSY); 185214501Srpaulo else if (pt->pt_prison != td->td_ucred->cr_prison) 186214501Srpaulo return (EBUSY); 187214501Srpaulo if (tp->t_oproc) /* Ctrlr still around. */ 188214501Srpaulo (void)ttyld_modem(tp, 1); 189214501Srpaulo while ((tp->t_state & TS_CARR_ON) == 0) { 190214501Srpaulo if (flag&FNONBLOCK) 191214501Srpaulo break; 192214501Srpaulo error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH, 193214501Srpaulo "ptsopn", 0); 194214501Srpaulo if (error) 195214501Srpaulo return (error); 196214501Srpaulo } 197214501Srpaulo error = ttyld_open(tp, dev); 198214501Srpaulo if (error == 0) 199214501Srpaulo ptcwakeup(tp, FREAD|FWRITE); 200214501Srpaulo return (error); 201214501Srpaulo} 202214501Srpaulo 203214501Srpaulostatic int 204214501Srpauloptsclose(struct cdev *dev, int flag, int mode, struct thread *td) 205214501Srpaulo{ 206214501Srpaulo struct tty *tp; 207214501Srpaulo int err; 208214501Srpaulo 209214501Srpaulo tp = dev->si_tty; 210214501Srpaulo err = ttyld_close(tp, flag); 211214501Srpaulo (void) ttyclose(tp); 212214501Srpaulo return (err); 213214501Srpaulo} 214214501Srpaulo 215214501Srpaulostatic int 216214501Srpauloptsread(struct cdev *dev, struct uio *uio, int flag) 217214501Srpaulo{ 218214501Srpaulo struct thread *td = curthread; 219214501Srpaulo struct proc *p = td->td_proc; 220214501Srpaulo struct tty *tp = dev->si_tty; 221214501Srpaulo struct ptsc *pt = dev->si_drv1; 222214501Srpaulo struct pgrp *pg; 223214501Srpaulo int error = 0; 224214501Srpaulo 225214501Srpauloagain: 226214501Srpaulo if (pt->pt_flags & PF_REMOTE) { 227214501Srpaulo while (isbackground(p, tp)) { 228214501Srpaulo sx_slock(&proctree_lock); 229214501Srpaulo PROC_LOCK(p); 230214501Srpaulo if (SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTIN) || 231214501Srpaulo SIGISMEMBER(td->td_sigmask, SIGTTIN) || 232214501Srpaulo p->p_pgrp->pg_jobc == 0 || p->p_flag & P_PPWAIT) { 233214501Srpaulo PROC_UNLOCK(p); 234214501Srpaulo sx_sunlock(&proctree_lock); 235214501Srpaulo return (EIO); 236214501Srpaulo } 237214501Srpaulo pg = p->p_pgrp; 238214501Srpaulo PROC_UNLOCK(p); 239214501Srpaulo PGRP_LOCK(pg); 240214501Srpaulo sx_sunlock(&proctree_lock); 241214501Srpaulo pgsignal(pg, SIGTTIN, 1); 242214501Srpaulo PGRP_UNLOCK(pg); 243214501Srpaulo error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ptsbg", 244214501Srpaulo 0); 245214501Srpaulo if (error) 246214501Srpaulo return (error); 247214501Srpaulo } 248214501Srpaulo if (tp->t_canq.c_cc == 0) { 249214501Srpaulo if (flag & IO_NDELAY) 250214501Srpaulo return (EWOULDBLOCK); 251214501Srpaulo error = ttysleep(tp, TSA_PTS_READ(tp), TTIPRI | PCATCH, 252214501Srpaulo "ptsin", 0); 253214501Srpaulo if (error) 254214501Srpaulo return (error); 255214501Srpaulo goto again; 256214501Srpaulo } 257214501Srpaulo while (tp->t_canq.c_cc > 1 && uio->uio_resid > 0) 258214501Srpaulo if (ureadc(getc(&tp->t_canq), uio) < 0) { 259214501Srpaulo error = EFAULT; 260214501Srpaulo break; 261214501Srpaulo } 262214501Srpaulo if (tp->t_canq.c_cc == 1) 263214501Srpaulo (void) getc(&tp->t_canq); 264214501Srpaulo if (tp->t_canq.c_cc) 265214501Srpaulo return (error); 266214501Srpaulo } else 267214501Srpaulo if (tp->t_oproc) 268214501Srpaulo error = ttyld_read(tp, uio, flag); 269214501Srpaulo ptcwakeup(tp, FWRITE); 270214501Srpaulo return (error); 271214501Srpaulo} 272214501Srpaulo 273214501Srpaulo/* 274214501Srpaulo * Write to pseudo-tty. 275214501Srpaulo * Wakeups of controlling tty will happen 276214501Srpaulo * indirectly, when tty driver calls ptsstart. 277214501Srpaulo */ 278214501Srpaulostatic int 279214501Srpauloptswrite(struct cdev *dev, struct uio *uio, int flag) 280214501Srpaulo{ 281214501Srpaulo struct tty *tp; 282214501Srpaulo 283214501Srpaulo tp = dev->si_tty; 284214501Srpaulo if (tp->t_oproc == 0) 285214501Srpaulo return (EIO); 286214501Srpaulo return (ttyld_write(tp, uio, flag)); 287214501Srpaulo} 288214501Srpaulo 289214501Srpaulo/* 290214501Srpaulo * Start output on pseudo-tty. 291214501Srpaulo * Wake up process selecting or sleeping for input from controlling tty. 292214501Srpaulo */ 293214501Srpaulostatic void 294214501Srpauloptsstart(struct tty *tp) 295214501Srpaulo{ 296214501Srpaulo struct ptsc *pt = tp->t_dev->si_drv1; 297214501Srpaulo 298214501Srpaulo if (tp->t_state & TS_TTSTOP) 299214501Srpaulo return; 300214501Srpaulo if (pt->pt_flags & PF_STOPPED) { 301214501Srpaulo pt->pt_flags &= ~PF_STOPPED; 302214501Srpaulo pt->pt_send = TIOCPKT_START; 303214501Srpaulo } 304214501Srpaulo ptcwakeup(tp, FREAD); 305214501Srpaulo} 306214501Srpaulo 307214501Srpaulostatic void 308214501Srpauloptcwakeup(struct tty *tp, int flag) 309214501Srpaulo{ 310214501Srpaulo struct ptsc *pt = tp->t_dev->si_drv1; 311214501Srpaulo 312214501Srpaulo if (flag & FREAD) { 313214501Srpaulo selwakeuppri(&pt->pt_selr, TTIPRI); 314214501Srpaulo wakeup(TSA_PTC_READ(tp)); 315214501Srpaulo } 316214501Srpaulo if (flag & FWRITE) { 317214501Srpaulo selwakeuppri(&pt->pt_selw, TTOPRI); 318214501Srpaulo wakeup(TSA_PTC_WRITE(tp)); 319214501Srpaulo } 320214501Srpaulo} 321214501Srpaulo 322214501Srpaulostatic int 323214501Srpauloptcopen(struct cdev *dev, int flag, int devtype, struct thread *td) 324214501Srpaulo{ 325214501Srpaulo struct tty *tp; 326214501Srpaulo struct ptsc *pt; 327214501Srpaulo 328214501Srpaulo if (!dev->si_drv1) 329214501Srpaulo ptyinit(dev); 330214501Srpaulo if (!dev->si_drv1) 331214501Srpaulo return(ENXIO); 332214501Srpaulo tp = dev->si_tty; 333214501Srpaulo if (tp->t_oproc) 334214501Srpaulo return (EIO); 335214501Srpaulo tp->t_timeout = -1; 336214501Srpaulo tp->t_oproc = ptsstart; 337214501Srpaulo tp->t_stop = ptsstop; 338214501Srpaulo (void)ttyld_modem(tp, 1); 339214501Srpaulo tp->t_lflag &= ~EXTPROC; 340214501Srpaulo pt = dev->si_drv1; 341214501Srpaulo pt->pt_prison = td->td_ucred->cr_prison; 342214501Srpaulo pt->pt_flags = 0; 343214501Srpaulo pt->pt_send = 0; 344214501Srpaulo pt->pt_ucntl = 0; 345214501Srpaulo return (0); 346214501Srpaulo} 347214501Srpaulo 348214501Srpaulostatic int 349214501Srpauloptcclose(struct cdev *dev, int flags, int fmt, struct thread *td) 350214501Srpaulo{ 351214501Srpaulo struct tty *tp; 352214501Srpaulo 353214501Srpaulo tp = dev->si_tty; 354214501Srpaulo (void)ttyld_modem(tp, 0); 355214501Srpaulo 356214501Srpaulo /* 357214501Srpaulo * XXX MDMBUF makes no sense for ptys but would inhibit the above 358214501Srpaulo * l_modem(). CLOCAL makes sense but isn't supported. Special 359214501Srpaulo * l_modem()s that ignore carrier drop make no sense for ptys but 360214501Srpaulo * may be in use because other parts of the line discipline make 361214501Srpaulo * sense for ptys. Recover by doing everything that a normal 362214501Srpaulo * ttymodem() would have done except for sending a SIGHUP. 363214501Srpaulo */ 364214501Srpaulo if (tp->t_state & TS_ISOPEN) { 365214501Srpaulo tp->t_state &= ~(TS_CARR_ON | TS_CONNECTED); 366214501Srpaulo tp->t_state |= TS_ZOMBIE; 367214501Srpaulo ttyflush(tp, FREAD | FWRITE); 368214501Srpaulo } 369214501Srpaulo 370214501Srpaulo tp->t_oproc = 0; /* mark closed */ 371214501Srpaulo return (0); 372214501Srpaulo} 373214501Srpaulo 374214501Srpaulostatic int 375214501Srpauloptcread(struct cdev *dev, struct uio *uio, int flag) 376214501Srpaulo{ 377214501Srpaulo struct tty *tp = dev->si_tty; 378214501Srpaulo struct ptsc *pt = dev->si_drv1; 379214501Srpaulo char buf[BUFSIZ]; 380214501Srpaulo int error = 0, cc; 381214501Srpaulo 382214501Srpaulo /* 383214501Srpaulo * We want to block until the slave 384214501Srpaulo * is open, and there's something to read; 385214501Srpaulo * but if we lost the slave or we're NBIO, 386214501Srpaulo * then return the appropriate error instead. 387214501Srpaulo */ 388214501Srpaulo for (;;) { 389214501Srpaulo if (tp->t_state&TS_ISOPEN) { 390214501Srpaulo if (pt->pt_flags&PF_PKT && pt->pt_send) { 391214501Srpaulo error = ureadc((int)pt->pt_send, uio); 392214501Srpaulo if (error) 393214501Srpaulo return (error); 394214501Srpaulo if (pt->pt_send & TIOCPKT_IOCTL) { 395214501Srpaulo cc = min(uio->uio_resid, 396214501Srpaulo sizeof(tp->t_termios)); 397214501Srpaulo uiomove(&tp->t_termios, cc, uio); 398214501Srpaulo } 399214501Srpaulo pt->pt_send = 0; 400214501Srpaulo return (0); 401214501Srpaulo } 402214501Srpaulo if (pt->pt_flags&PF_UCNTL && pt->pt_ucntl) { 403214501Srpaulo error = ureadc((int)pt->pt_ucntl, uio); 404214501Srpaulo if (error) 405214501Srpaulo return (error); 406214501Srpaulo pt->pt_ucntl = 0; 407214501Srpaulo return (0); 408214501Srpaulo } 409214501Srpaulo if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0) 410214501Srpaulo break; 411214501Srpaulo } 412214501Srpaulo if ((tp->t_state & TS_CONNECTED) == 0) 413214501Srpaulo return (0); /* EOF */ 414214501Srpaulo if (flag & IO_NDELAY) 415214501Srpaulo return (EWOULDBLOCK); 416214501Srpaulo error = tsleep(TSA_PTC_READ(tp), TTIPRI | PCATCH, "ptcin", 0); 417214501Srpaulo if (error) 418214501Srpaulo return (error); 419214501Srpaulo } 420214501Srpaulo if (pt->pt_flags & (PF_PKT|PF_UCNTL)) 421214501Srpaulo error = ureadc(0, uio); 422214501Srpaulo while (uio->uio_resid > 0 && error == 0) { 423214501Srpaulo cc = q_to_b(&tp->t_outq, buf, min(uio->uio_resid, BUFSIZ)); 424214501Srpaulo if (cc <= 0) 425214501Srpaulo break; 426214501Srpaulo error = uiomove(buf, cc, uio); 427214501Srpaulo } 428214501Srpaulo ttwwakeup(tp); 429214501Srpaulo return (error); 430214501Srpaulo} 431214501Srpaulo 432214501Srpaulostatic void 433214501Srpauloptsstop(struct tty *tp, int flush) 434214501Srpaulo{ 435214501Srpaulo struct ptsc *pt = tp->t_dev->si_drv1; 436214501Srpaulo int flag; 437214501Srpaulo 438214501Srpaulo /* note: FLUSHREAD and FLUSHWRITE already ok */ 439214501Srpaulo if (flush == 0) { 440214501Srpaulo flush = TIOCPKT_STOP; 441214501Srpaulo pt->pt_flags |= PF_STOPPED; 442214501Srpaulo } else 443214501Srpaulo pt->pt_flags &= ~PF_STOPPED; 444214501Srpaulo pt->pt_send |= flush; 445214501Srpaulo /* change of perspective */ 446214501Srpaulo flag = 0; 447214501Srpaulo if (flush & FREAD) 448214501Srpaulo flag |= FWRITE; 449214501Srpaulo if (flush & FWRITE) 450214501Srpaulo flag |= FREAD; 451214501Srpaulo ptcwakeup(tp, flag); 452214501Srpaulo} 453214501Srpaulo 454214501Srpaulostatic int 455214501Srpauloptcpoll(struct cdev *dev, int events, struct thread *td) 456214501Srpaulo{ 457214501Srpaulo struct tty *tp = dev->si_tty; 458214501Srpaulo struct ptsc *pt = dev->si_drv1; 459214501Srpaulo int revents = 0; 460214501Srpaulo int s; 461214501Srpaulo 462214501Srpaulo if ((tp->t_state & TS_CONNECTED) == 0) 463214501Srpaulo return (events & 464214501Srpaulo (POLLHUP | POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)); 465214501Srpaulo 466214501Srpaulo /* 467214501Srpaulo * Need to block timeouts (ttrstart). 468214501Srpaulo */ 469214501Srpaulo s = spltty(); 470214501Srpaulo 471214501Srpaulo if (events & (POLLIN | POLLRDNORM)) 472214501Srpaulo if ((tp->t_state & TS_ISOPEN) && 473214501Srpaulo ((tp->t_outq.c_cc && (tp->t_state & TS_TTSTOP) == 0) || 474214501Srpaulo ((pt->pt_flags & PF_PKT) && pt->pt_send) || 475214501Srpaulo ((pt->pt_flags & PF_UCNTL) && pt->pt_ucntl))) 476214501Srpaulo revents |= events & (POLLIN | POLLRDNORM); 477214501Srpaulo 478214501Srpaulo if (events & (POLLOUT | POLLWRNORM)) 479214501Srpaulo if (tp->t_state & TS_ISOPEN && 480214501Srpaulo ((pt->pt_flags & PF_REMOTE) ? 481214501Srpaulo (tp->t_canq.c_cc == 0) : 482214501Srpaulo ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG - 2) || 483214501Srpaulo (tp->t_canq.c_cc == 0 && (tp->t_lflag & ICANON))))) 484214501Srpaulo revents |= events & (POLLOUT | POLLWRNORM); 485214501Srpaulo 486214501Srpaulo if (events & POLLHUP) 487214501Srpaulo if ((tp->t_state & TS_CARR_ON) == 0) 488214501Srpaulo revents |= POLLHUP; 489214501Srpaulo 490214501Srpaulo if (revents == 0) { 491214501Srpaulo if (events & (POLLIN | POLLRDNORM)) 492214501Srpaulo selrecord(td, &pt->pt_selr); 493214501Srpaulo 494214501Srpaulo if (events & (POLLOUT | POLLWRNORM)) 495214501Srpaulo selrecord(td, &pt->pt_selw); 496214501Srpaulo } 497214501Srpaulo splx(s); 498214501Srpaulo 499214501Srpaulo return (revents); 500214501Srpaulo} 501214501Srpaulo 502214501Srpaulostatic int 503214501Srpauloptcwrite(struct cdev *dev, struct uio *uio, int flag) 504214501Srpaulo{ 505214501Srpaulo struct tty *tp = dev->si_tty; 506214501Srpaulo u_char *cp = 0; 507214501Srpaulo int cc = 0; 508214501Srpaulo u_char locbuf[BUFSIZ]; 509214501Srpaulo int cnt = 0; 510214501Srpaulo struct ptsc *pt = dev->si_drv1; 511214501Srpaulo int error = 0; 512214501Srpaulo 513214501Srpauloagain: 514214501Srpaulo if ((tp->t_state&TS_ISOPEN) == 0) 515214501Srpaulo goto block; 516214501Srpaulo if (pt->pt_flags & PF_REMOTE) { 517214501Srpaulo if (tp->t_canq.c_cc) 518214501Srpaulo goto block; 519214501Srpaulo while ((uio->uio_resid > 0 || cc > 0) && 520214501Srpaulo tp->t_canq.c_cc < TTYHOG - 1) { 521214501Srpaulo if (cc == 0) { 522214501Srpaulo cc = min(uio->uio_resid, BUFSIZ); 523214501Srpaulo cc = min(cc, TTYHOG - 1 - tp->t_canq.c_cc); 524214501Srpaulo cp = locbuf; 525 error = uiomove(cp, cc, uio); 526 if (error) 527 return (error); 528 /* check again for safety */ 529 if ((tp->t_state & TS_ISOPEN) == 0) { 530 /* adjust as usual */ 531 uio->uio_resid += cc; 532 return (EIO); 533 } 534 } 535 if (cc > 0) { 536 cc = b_to_q((char *)cp, cc, &tp->t_canq); 537 /* 538 * XXX we don't guarantee that the canq size 539 * is >= TTYHOG, so the above b_to_q() may 540 * leave some bytes uncopied. However, space 541 * is guaranteed for the null terminator if 542 * we don't fail here since (TTYHOG - 1) is 543 * not a multiple of CBSIZE. 544 */ 545 if (cc > 0) 546 break; 547 } 548 } 549 /* adjust for data copied in but not written */ 550 uio->uio_resid += cc; 551 (void) putc(0, &tp->t_canq); 552 ttwakeup(tp); 553 wakeup(TSA_PTS_READ(tp)); 554 return (0); 555 } 556 while (uio->uio_resid > 0 || cc > 0) { 557 if (cc == 0) { 558 cc = min(uio->uio_resid, BUFSIZ); 559 cp = locbuf; 560 error = uiomove(cp, cc, uio); 561 if (error) 562 return (error); 563 /* check again for safety */ 564 if ((tp->t_state & TS_ISOPEN) == 0) { 565 /* adjust for data copied in but not written */ 566 uio->uio_resid += cc; 567 return (EIO); 568 } 569 } 570 while (cc > 0) { 571 if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 && 572 (tp->t_canq.c_cc > 0 || !(tp->t_lflag&ICANON))) { 573 wakeup(TSA_HUP_OR_INPUT(tp)); 574 goto block; 575 } 576 ttyld_rint(tp, *cp++); 577 cnt++; 578 cc--; 579 } 580 cc = 0; 581 } 582 return (0); 583block: 584 /* 585 * Come here to wait for slave to open, for space 586 * in outq, or space in rawq, or an empty canq. 587 */ 588 if ((tp->t_state & TS_CONNECTED) == 0) { 589 /* adjust for data copied in but not written */ 590 uio->uio_resid += cc; 591 return (EIO); 592 } 593 if (flag & IO_NDELAY) { 594 /* adjust for data copied in but not written */ 595 uio->uio_resid += cc; 596 if (cnt == 0) 597 return (EWOULDBLOCK); 598 return (0); 599 } 600 error = tsleep(TSA_PTC_WRITE(tp), TTOPRI | PCATCH, "ptcout", 0); 601 if (error) { 602 /* adjust for data copied in but not written */ 603 uio->uio_resid += cc; 604 return (error); 605 } 606 goto again; 607} 608 609/*ARGSUSED*/ 610static int 611ptyioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td) 612{ 613 struct tty *tp = dev->si_tty; 614 struct ptsc *pt = dev->si_drv1; 615 u_char *cc = tp->t_cc; 616 int stop, error; 617 618 if (devsw(dev)->d_open == ptcopen) { 619 switch (cmd) { 620 621 case TIOCGPGRP: 622 /* 623 * We avoid calling ttioctl on the controller since, 624 * in that case, tp must be the controlling terminal. 625 */ 626 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0; 627 return (0); 628 629 case TIOCPKT: 630 if (*(int *)data) { 631 if (pt->pt_flags & PF_UCNTL) 632 return (EINVAL); 633 pt->pt_flags |= PF_PKT; 634 } else 635 pt->pt_flags &= ~PF_PKT; 636 return (0); 637 638 case TIOCUCNTL: 639 if (*(int *)data) { 640 if (pt->pt_flags & PF_PKT) 641 return (EINVAL); 642 pt->pt_flags |= PF_UCNTL; 643 } else 644 pt->pt_flags &= ~PF_UCNTL; 645 return (0); 646 647 case TIOCREMOTE: 648 if (*(int *)data) 649 pt->pt_flags |= PF_REMOTE; 650 else 651 pt->pt_flags &= ~PF_REMOTE; 652 ttyflush(tp, FREAD|FWRITE); 653 return (0); 654 } 655 656 /* 657 * The rest of the ioctls shouldn't be called until 658 * the slave is open. 659 */ 660 if ((tp->t_state & TS_ISOPEN) == 0) 661 return (EAGAIN); 662 663 switch (cmd) { 664#ifndef BURN_BRIDGES 665#ifdef COMPAT_43 666 case TIOCSETP: 667 case TIOCSETN: 668#endif 669#endif 670 case TIOCSETD: 671 case TIOCSETA: 672 case TIOCSETAW: 673 case TIOCSETAF: 674 /* 675 * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG. 676 * ttywflush(tp) will hang if there are characters in 677 * the outq. 678 */ 679 ndflush(&tp->t_outq, tp->t_outq.c_cc); 680 break; 681 682 case TIOCSIG: 683 if (*(unsigned int *)data >= NSIG || 684 *(unsigned int *)data == 0) 685 return(EINVAL); 686 if ((tp->t_lflag&NOFLSH) == 0) 687 ttyflush(tp, FREAD|FWRITE); 688 if (tp->t_pgrp != NULL) { 689 PGRP_LOCK(tp->t_pgrp); 690 pgsignal(tp->t_pgrp, *(unsigned int *)data, 1); 691 PGRP_UNLOCK(tp->t_pgrp); 692 } 693 if ((*(unsigned int *)data == SIGINFO) && 694 ((tp->t_lflag&NOKERNINFO) == 0)) 695 ttyinfo(tp); 696 return(0); 697 } 698 } 699 if (cmd == TIOCEXT) { 700 /* 701 * When the EXTPROC bit is being toggled, we need 702 * to send an TIOCPKT_IOCTL if the packet driver 703 * is turned on. 704 */ 705 if (*(int *)data) { 706 if (pt->pt_flags & PF_PKT) { 707 pt->pt_send |= TIOCPKT_IOCTL; 708 ptcwakeup(tp, FREAD); 709 } 710 tp->t_lflag |= EXTPROC; 711 } else { 712 if ((tp->t_lflag & EXTPROC) && 713 (pt->pt_flags & PF_PKT)) { 714 pt->pt_send |= TIOCPKT_IOCTL; 715 ptcwakeup(tp, FREAD); 716 } 717 tp->t_lflag &= ~EXTPROC; 718 } 719 return(0); 720 } 721 error = ttyioctl(dev, cmd, data, flag, td); 722 if (error == ENOTTY) { 723 if (pt->pt_flags & PF_UCNTL && 724 (cmd & ~0xff) == UIOCCMD(0)) { 725 if (cmd & 0xff) { 726 pt->pt_ucntl = (u_char)cmd; 727 ptcwakeup(tp, FREAD); 728 } 729 return (0); 730 } 731 error = ENOTTY; 732 } 733 /* 734 * If external processing and packet mode send ioctl packet. 735 */ 736 if ((tp->t_lflag&EXTPROC) && (pt->pt_flags & PF_PKT)) { 737 switch(cmd) { 738 case TIOCSETA: 739 case TIOCSETAW: 740 case TIOCSETAF: 741#ifndef BURN_BRIDGES 742#ifdef COMPAT_43 743 case TIOCSETP: 744 case TIOCSETN: 745 case TIOCSETC: 746 case TIOCSLTC: 747 case TIOCLBIS: 748 case TIOCLBIC: 749 case TIOCLSET: 750#endif 751#endif 752 pt->pt_send |= TIOCPKT_IOCTL; 753 ptcwakeup(tp, FREAD); 754 break; 755 default: 756 break; 757 } 758 } 759 stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s')) 760 && CCEQ(cc[VSTART], CTRL('q')); 761 if (pt->pt_flags & PF_NOSTOP) { 762 if (stop) { 763 pt->pt_send &= ~TIOCPKT_NOSTOP; 764 pt->pt_send |= TIOCPKT_DOSTOP; 765 pt->pt_flags &= ~PF_NOSTOP; 766 ptcwakeup(tp, FREAD); 767 } 768 } else { 769 if (!stop) { 770 pt->pt_send &= ~TIOCPKT_DOSTOP; 771 pt->pt_send |= TIOCPKT_NOSTOP; 772 pt->pt_flags |= PF_NOSTOP; 773 ptcwakeup(tp, FREAD); 774 } 775 } 776 return (error); 777} 778 779static void 780pty_clone(void *arg, char *name, int namelen, struct cdev **dev) 781{ 782 int u; 783 784 if (*dev != NULL) 785 return; 786 if (bcmp(name, "pty", 3) != 0) 787 return; 788 if (name[5] != '\0') 789 return; 790 switch (name[3]) { 791 case 'p': u = 0; break; 792 case 'q': u = 32; break; 793 case 'r': u = 64; break; 794 case 's': u = 96; break; 795 case 'P': u = 128; break; 796 case 'Q': u = 160; break; 797 case 'R': u = 192; break; 798 case 'S': u = 224; break; 799 default: return; 800 } 801 if (name[4] >= '0' && name[4] <= '9') 802 u += name[4] - '0'; 803 else if (name[4] >= 'a' && name[4] <= 'v') 804 u += name[4] - 'a' + 10; 805 else 806 return; 807 *dev = make_dev(&ptc_cdevsw, u, 808 UID_ROOT, GID_WHEEL, 0666, "pty%c%r", names[u / 32], u % 32); 809 (*dev)->si_flags |= SI_CHEAPCLONE; 810 return; 811} 812 813static void 814ptc_drvinit(void *unused) 815{ 816 817 EVENTHANDLER_REGISTER(dev_clone, pty_clone, 0, 1000); 818} 819 820SYSINIT(ptcdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR_C,ptc_drvinit,NULL) 821