1/* 2 * Copyright (c) 1982, 1986, 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)tty_pty.c 8.4 (Berkeley) 2/20/95 30 */ 31 32#include <sys/cdefs.h>
| 1/* 2 * Copyright (c) 1982, 1986, 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)tty_pty.c 8.4 (Berkeley) 2/20/95 30 */ 31 32#include <sys/cdefs.h>
|
33__FBSDID("$FreeBSD: head/sys/kern/tty_pty.c 130259 2004-06-09 09:09:54Z phk $");
| 33__FBSDID("$FreeBSD: head/sys/kern/tty_pty.c 130262 2004-06-09 10:16:14Z phk $");
|
34 35/* 36 * Pseudo-teletype Driver 37 * (Actually two drivers, requiring two entries in 'cdevsw') 38 */ 39#include "opt_compat.h" 40#include "opt_tty.h" 41#include <sys/param.h> 42#include <sys/systm.h> 43#include <sys/lock.h> 44#include <sys/mutex.h> 45#include <sys/sx.h> 46#if defined(COMPAT_43) || defined(COMPAT_SUNOS) 47#include <sys/ioctl_compat.h> 48#endif 49#include <sys/proc.h> 50#include <sys/tty.h> 51#include <sys/conf.h> 52#include <sys/fcntl.h> 53#include <sys/poll.h> 54#include <sys/kernel.h> 55#include <sys/vnode.h> 56#include <sys/signalvar.h> 57#include <sys/malloc.h> 58 59static MALLOC_DEFINE(M_PTY, "ptys", "pty data structures"); 60 61static void ptsstart(struct tty *tp); 62static void ptsstop(struct tty *tp, int rw); 63static void ptcwakeup(struct tty *tp, int flag); 64static dev_t ptyinit(dev_t cdev); 65 66static d_open_t ptsopen; 67static d_close_t ptsclose; 68static d_read_t ptsread; 69static d_write_t ptswrite; 70static d_ioctl_t ptyioctl; 71static d_open_t ptcopen; 72static d_close_t ptcclose; 73static d_read_t ptcread; 74static d_write_t ptcwrite; 75static d_poll_t ptcpoll; 76 77#define CDEV_MAJOR_S 5 78static struct cdevsw pts_cdevsw = { 79 .d_version = D_VERSION, 80 .d_open = ptsopen, 81 .d_close = ptsclose, 82 .d_read = ptsread, 83 .d_write = ptswrite, 84 .d_ioctl = ptyioctl, 85 .d_name = "pts", 86 .d_maj = CDEV_MAJOR_S, 87 .d_flags = D_TTY | D_NEEDGIANT, 88}; 89 90#define CDEV_MAJOR_C 6 91static struct cdevsw ptc_cdevsw = { 92 .d_version = D_VERSION, 93 .d_open = ptcopen, 94 .d_close = ptcclose, 95 .d_read = ptcread, 96 .d_write = ptcwrite, 97 .d_ioctl = ptyioctl, 98 .d_poll = ptcpoll, 99 .d_name = "ptc", 100 .d_maj = CDEV_MAJOR_C, 101 .d_flags = D_TTY | D_NEEDGIANT, 102}; 103 104#define BUFSIZ 100 /* Chunk size iomoved to/from user */ 105 106struct pt_ioctl { 107 int pt_flags; 108 struct selinfo pt_selr, pt_selw; 109 u_char pt_send; 110 u_char pt_ucntl; 111 struct tty *pt_tty; 112 dev_t devs, devc; 113 struct prison *pt_prison; 114}; 115 116#define PF_PKT 0x08 /* packet mode */ 117#define PF_STOPPED 0x10 /* user told stopped */ 118#define PF_REMOTE 0x20 /* remote and flow controlled input */ 119#define PF_NOSTOP 0x40 120#define PF_UCNTL 0x80 /* user control mode */ 121 122#define TSA_PTC_READ(tp) ((void *)&(tp)->t_outq.c_cf) 123#define TSA_PTC_WRITE(tp) ((void *)&(tp)->t_rawq.c_cl) 124#define TSA_PTS_READ(tp) ((void *)&(tp)->t_canq) 125 126static char *names = "pqrsPQRS"; 127/* 128 * This function creates and initializes a pts/ptc pair 129 * 130 * pts == /dev/tty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 131 * ptc == /dev/pty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 132 * 133 * XXX: define and add mapping of upper minor bits to allow more 134 * than 256 ptys. 135 */ 136static dev_t 137ptyinit(dev_t devc) 138{ 139 dev_t devs; 140 struct pt_ioctl *pt; 141 int n; 142 143 n = minor(devc); 144 /* For now we only map the lower 8 bits of the minor */ 145 if (n & ~0xff) 146 return (NODEV); 147 148 devc->si_flags &= ~SI_CHEAPCLONE; 149 150 pt = malloc(sizeof(*pt), M_PTY, M_WAITOK | M_ZERO); 151 pt->devs = devs = make_dev(&pts_cdevsw, n, 152 UID_ROOT, GID_WHEEL, 0666, "tty%c%r", names[n / 32], n % 32); 153 pt->devc = devc; 154 155 pt->pt_tty = ttymalloc(pt->pt_tty); 156 devs->si_drv1 = devc->si_drv1 = pt; 157 devs->si_tty = devc->si_tty = pt->pt_tty; 158 pt->pt_tty->t_dev = devs; 159 return (devc); 160} 161 162/*ARGSUSED*/ 163static int
| 34 35/* 36 * Pseudo-teletype Driver 37 * (Actually two drivers, requiring two entries in 'cdevsw') 38 */ 39#include "opt_compat.h" 40#include "opt_tty.h" 41#include <sys/param.h> 42#include <sys/systm.h> 43#include <sys/lock.h> 44#include <sys/mutex.h> 45#include <sys/sx.h> 46#if defined(COMPAT_43) || defined(COMPAT_SUNOS) 47#include <sys/ioctl_compat.h> 48#endif 49#include <sys/proc.h> 50#include <sys/tty.h> 51#include <sys/conf.h> 52#include <sys/fcntl.h> 53#include <sys/poll.h> 54#include <sys/kernel.h> 55#include <sys/vnode.h> 56#include <sys/signalvar.h> 57#include <sys/malloc.h> 58 59static MALLOC_DEFINE(M_PTY, "ptys", "pty data structures"); 60 61static void ptsstart(struct tty *tp); 62static void ptsstop(struct tty *tp, int rw); 63static void ptcwakeup(struct tty *tp, int flag); 64static dev_t ptyinit(dev_t cdev); 65 66static d_open_t ptsopen; 67static d_close_t ptsclose; 68static d_read_t ptsread; 69static d_write_t ptswrite; 70static d_ioctl_t ptyioctl; 71static d_open_t ptcopen; 72static d_close_t ptcclose; 73static d_read_t ptcread; 74static d_write_t ptcwrite; 75static d_poll_t ptcpoll; 76 77#define CDEV_MAJOR_S 5 78static struct cdevsw pts_cdevsw = { 79 .d_version = D_VERSION, 80 .d_open = ptsopen, 81 .d_close = ptsclose, 82 .d_read = ptsread, 83 .d_write = ptswrite, 84 .d_ioctl = ptyioctl, 85 .d_name = "pts", 86 .d_maj = CDEV_MAJOR_S, 87 .d_flags = D_TTY | D_NEEDGIANT, 88}; 89 90#define CDEV_MAJOR_C 6 91static struct cdevsw ptc_cdevsw = { 92 .d_version = D_VERSION, 93 .d_open = ptcopen, 94 .d_close = ptcclose, 95 .d_read = ptcread, 96 .d_write = ptcwrite, 97 .d_ioctl = ptyioctl, 98 .d_poll = ptcpoll, 99 .d_name = "ptc", 100 .d_maj = CDEV_MAJOR_C, 101 .d_flags = D_TTY | D_NEEDGIANT, 102}; 103 104#define BUFSIZ 100 /* Chunk size iomoved to/from user */ 105 106struct pt_ioctl { 107 int pt_flags; 108 struct selinfo pt_selr, pt_selw; 109 u_char pt_send; 110 u_char pt_ucntl; 111 struct tty *pt_tty; 112 dev_t devs, devc; 113 struct prison *pt_prison; 114}; 115 116#define PF_PKT 0x08 /* packet mode */ 117#define PF_STOPPED 0x10 /* user told stopped */ 118#define PF_REMOTE 0x20 /* remote and flow controlled input */ 119#define PF_NOSTOP 0x40 120#define PF_UCNTL 0x80 /* user control mode */ 121 122#define TSA_PTC_READ(tp) ((void *)&(tp)->t_outq.c_cf) 123#define TSA_PTC_WRITE(tp) ((void *)&(tp)->t_rawq.c_cl) 124#define TSA_PTS_READ(tp) ((void *)&(tp)->t_canq) 125 126static char *names = "pqrsPQRS"; 127/* 128 * This function creates and initializes a pts/ptc pair 129 * 130 * pts == /dev/tty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 131 * ptc == /dev/pty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 132 * 133 * XXX: define and add mapping of upper minor bits to allow more 134 * than 256 ptys. 135 */ 136static dev_t 137ptyinit(dev_t devc) 138{ 139 dev_t devs; 140 struct pt_ioctl *pt; 141 int n; 142 143 n = minor(devc); 144 /* For now we only map the lower 8 bits of the minor */ 145 if (n & ~0xff) 146 return (NODEV); 147 148 devc->si_flags &= ~SI_CHEAPCLONE; 149 150 pt = malloc(sizeof(*pt), M_PTY, M_WAITOK | M_ZERO); 151 pt->devs = devs = make_dev(&pts_cdevsw, n, 152 UID_ROOT, GID_WHEEL, 0666, "tty%c%r", names[n / 32], n % 32); 153 pt->devc = devc; 154 155 pt->pt_tty = ttymalloc(pt->pt_tty); 156 devs->si_drv1 = devc->si_drv1 = pt; 157 devs->si_tty = devc->si_tty = pt->pt_tty; 158 pt->pt_tty->t_dev = devs; 159 return (devc); 160} 161 162/*ARGSUSED*/ 163static int
|
164ptsopen(dev, flag, devtype, td) 165 dev_t dev; 166 int flag, devtype; 167 struct thread *td;
| 164ptsopen(dev_t dev, int flag, int devtype, struct thread *td)
|
168{ 169 struct tty *tp; 170 int error; 171 struct pt_ioctl *pti; 172 173 if (!dev->si_drv1) 174 return(ENXIO); 175 pti = dev->si_drv1; 176 tp = dev->si_tty; 177 if ((tp->t_state & TS_ISOPEN) == 0) { 178 ttychars(tp); /* Set up default chars */ 179 tp->t_iflag = TTYDEF_IFLAG; 180 tp->t_oflag = TTYDEF_OFLAG; 181 tp->t_lflag = TTYDEF_LFLAG; 182 tp->t_cflag = TTYDEF_CFLAG; 183 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; 184 } else if (tp->t_state & TS_XCLUDE && suser(td)) 185 return (EBUSY); 186 else if (pti->pt_prison != td->td_ucred->cr_prison) 187 return (EBUSY); 188 if (tp->t_oproc) /* Ctrlr still around. */ 189 (void)ttyld_modem(tp, 1); 190 while ((tp->t_state & TS_CARR_ON) == 0) { 191 if (flag&FNONBLOCK) 192 break; 193 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH, 194 "ptsopn", 0); 195 if (error) 196 return (error); 197 } 198 error = ttyld_open(tp, dev); 199 if (error == 0) 200 ptcwakeup(tp, FREAD|FWRITE); 201 return (error); 202} 203 204static int
| 165{ 166 struct tty *tp; 167 int error; 168 struct pt_ioctl *pti; 169 170 if (!dev->si_drv1) 171 return(ENXIO); 172 pti = dev->si_drv1; 173 tp = dev->si_tty; 174 if ((tp->t_state & TS_ISOPEN) == 0) { 175 ttychars(tp); /* Set up default chars */ 176 tp->t_iflag = TTYDEF_IFLAG; 177 tp->t_oflag = TTYDEF_OFLAG; 178 tp->t_lflag = TTYDEF_LFLAG; 179 tp->t_cflag = TTYDEF_CFLAG; 180 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; 181 } else if (tp->t_state & TS_XCLUDE && suser(td)) 182 return (EBUSY); 183 else if (pti->pt_prison != td->td_ucred->cr_prison) 184 return (EBUSY); 185 if (tp->t_oproc) /* Ctrlr still around. */ 186 (void)ttyld_modem(tp, 1); 187 while ((tp->t_state & TS_CARR_ON) == 0) { 188 if (flag&FNONBLOCK) 189 break; 190 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH, 191 "ptsopn", 0); 192 if (error) 193 return (error); 194 } 195 error = ttyld_open(tp, dev); 196 if (error == 0) 197 ptcwakeup(tp, FREAD|FWRITE); 198 return (error); 199} 200 201static int
|
205ptsclose(dev, flag, mode, td) 206 dev_t dev; 207 int flag, mode; 208 struct thread *td;
| 202ptsclose(dev_t dev, int flag, int mode, struct thread *td)
|
209{ 210 struct tty *tp; 211 int err; 212 213 tp = dev->si_tty; 214 err = ttyld_close(tp, flag); 215 (void) ttyclose(tp); 216 return (err); 217} 218 219static int
| 203{ 204 struct tty *tp; 205 int err; 206 207 tp = dev->si_tty; 208 err = ttyld_close(tp, flag); 209 (void) ttyclose(tp); 210 return (err); 211} 212 213static int
|
220ptsread(dev, uio, flag) 221 dev_t dev; 222 struct uio *uio; 223 int flag;
| 214ptsread(dev_t dev, struct uio *uio, int flag)
|
224{ 225 struct thread *td = curthread; 226 struct proc *p = td->td_proc; 227 struct tty *tp = dev->si_tty; 228 struct pt_ioctl *pti = dev->si_drv1; 229 struct pgrp *pg; 230 int error = 0; 231 232again: 233 if (pti->pt_flags & PF_REMOTE) { 234 while (isbackground(p, tp)) { 235 sx_slock(&proctree_lock); 236 PROC_LOCK(p); 237 if (SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTIN) || 238 SIGISMEMBER(td->td_sigmask, SIGTTIN) || 239 p->p_pgrp->pg_jobc == 0 || p->p_flag & P_PPWAIT) { 240 PROC_UNLOCK(p); 241 sx_sunlock(&proctree_lock); 242 return (EIO); 243 } 244 pg = p->p_pgrp; 245 PROC_UNLOCK(p); 246 PGRP_LOCK(pg); 247 sx_sunlock(&proctree_lock); 248 pgsignal(pg, SIGTTIN, 1); 249 PGRP_UNLOCK(pg); 250 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ptsbg", 251 0); 252 if (error) 253 return (error); 254 } 255 if (tp->t_canq.c_cc == 0) { 256 if (flag & IO_NDELAY) 257 return (EWOULDBLOCK); 258 error = ttysleep(tp, TSA_PTS_READ(tp), TTIPRI | PCATCH, 259 "ptsin", 0); 260 if (error) 261 return (error); 262 goto again; 263 } 264 while (tp->t_canq.c_cc > 1 && uio->uio_resid > 0) 265 if (ureadc(getc(&tp->t_canq), uio) < 0) { 266 error = EFAULT; 267 break; 268 } 269 if (tp->t_canq.c_cc == 1) 270 (void) getc(&tp->t_canq); 271 if (tp->t_canq.c_cc) 272 return (error); 273 } else 274 if (tp->t_oproc) 275 error = ttyld_read(tp, uio, flag); 276 ptcwakeup(tp, FWRITE); 277 return (error); 278} 279 280/* 281 * Write to pseudo-tty. 282 * Wakeups of controlling tty will happen 283 * indirectly, when tty driver calls ptsstart. 284 */ 285static int
| 215{ 216 struct thread *td = curthread; 217 struct proc *p = td->td_proc; 218 struct tty *tp = dev->si_tty; 219 struct pt_ioctl *pti = dev->si_drv1; 220 struct pgrp *pg; 221 int error = 0; 222 223again: 224 if (pti->pt_flags & PF_REMOTE) { 225 while (isbackground(p, tp)) { 226 sx_slock(&proctree_lock); 227 PROC_LOCK(p); 228 if (SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTIN) || 229 SIGISMEMBER(td->td_sigmask, SIGTTIN) || 230 p->p_pgrp->pg_jobc == 0 || p->p_flag & P_PPWAIT) { 231 PROC_UNLOCK(p); 232 sx_sunlock(&proctree_lock); 233 return (EIO); 234 } 235 pg = p->p_pgrp; 236 PROC_UNLOCK(p); 237 PGRP_LOCK(pg); 238 sx_sunlock(&proctree_lock); 239 pgsignal(pg, SIGTTIN, 1); 240 PGRP_UNLOCK(pg); 241 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ptsbg", 242 0); 243 if (error) 244 return (error); 245 } 246 if (tp->t_canq.c_cc == 0) { 247 if (flag & IO_NDELAY) 248 return (EWOULDBLOCK); 249 error = ttysleep(tp, TSA_PTS_READ(tp), TTIPRI | PCATCH, 250 "ptsin", 0); 251 if (error) 252 return (error); 253 goto again; 254 } 255 while (tp->t_canq.c_cc > 1 && uio->uio_resid > 0) 256 if (ureadc(getc(&tp->t_canq), uio) < 0) { 257 error = EFAULT; 258 break; 259 } 260 if (tp->t_canq.c_cc == 1) 261 (void) getc(&tp->t_canq); 262 if (tp->t_canq.c_cc) 263 return (error); 264 } else 265 if (tp->t_oproc) 266 error = ttyld_read(tp, uio, flag); 267 ptcwakeup(tp, FWRITE); 268 return (error); 269} 270 271/* 272 * Write to pseudo-tty. 273 * Wakeups of controlling tty will happen 274 * indirectly, when tty driver calls ptsstart. 275 */ 276static int
|
286ptswrite(dev, uio, flag) 287 dev_t dev; 288 struct uio *uio; 289 int flag;
| 277ptswrite(dev_t dev, struct uio *uio, int flag)
|
290{ 291 struct tty *tp; 292 293 tp = dev->si_tty; 294 if (tp->t_oproc == 0) 295 return (EIO); 296 return (ttyld_write(tp, uio, flag)); 297} 298 299/* 300 * Start output on pseudo-tty. 301 * Wake up process selecting or sleeping for input from controlling tty. 302 */ 303static void
| 278{ 279 struct tty *tp; 280 281 tp = dev->si_tty; 282 if (tp->t_oproc == 0) 283 return (EIO); 284 return (ttyld_write(tp, uio, flag)); 285} 286 287/* 288 * Start output on pseudo-tty. 289 * Wake up process selecting or sleeping for input from controlling tty. 290 */ 291static void
|
304ptsstart(tp) 305 struct tty *tp;
| 292ptsstart(struct tty *tp)
|
306{ 307 struct pt_ioctl *pti = tp->t_dev->si_drv1; 308 309 if (tp->t_state & TS_TTSTOP) 310 return; 311 if (pti->pt_flags & PF_STOPPED) { 312 pti->pt_flags &= ~PF_STOPPED; 313 pti->pt_send = TIOCPKT_START; 314 } 315 ptcwakeup(tp, FREAD); 316} 317 318static void
| 293{ 294 struct pt_ioctl *pti = tp->t_dev->si_drv1; 295 296 if (tp->t_state & TS_TTSTOP) 297 return; 298 if (pti->pt_flags & PF_STOPPED) { 299 pti->pt_flags &= ~PF_STOPPED; 300 pti->pt_send = TIOCPKT_START; 301 } 302 ptcwakeup(tp, FREAD); 303} 304 305static void
|
319ptcwakeup(tp, flag) 320 struct tty *tp; 321 int flag;
| 306ptcwakeup(struct tty *tp, int flag)
|
322{ 323 struct pt_ioctl *pti = tp->t_dev->si_drv1; 324 325 if (flag & FREAD) { 326 selwakeuppri(&pti->pt_selr, TTIPRI); 327 wakeup(TSA_PTC_READ(tp)); 328 } 329 if (flag & FWRITE) { 330 selwakeuppri(&pti->pt_selw, TTOPRI); 331 wakeup(TSA_PTC_WRITE(tp)); 332 } 333} 334 335static int
| 307{ 308 struct pt_ioctl *pti = tp->t_dev->si_drv1; 309 310 if (flag & FREAD) { 311 selwakeuppri(&pti->pt_selr, TTIPRI); 312 wakeup(TSA_PTC_READ(tp)); 313 } 314 if (flag & FWRITE) { 315 selwakeuppri(&pti->pt_selw, TTOPRI); 316 wakeup(TSA_PTC_WRITE(tp)); 317 } 318} 319 320static int
|
336ptcopen(dev, flag, devtype, td) 337 dev_t dev; 338 int flag, devtype; 339 struct thread *td;
| 321ptcopen(dev_t dev, int flag, int devtype, struct thread *td)
|
340{ 341 struct tty *tp; 342 struct pt_ioctl *pti; 343 344 if (!dev->si_drv1) 345 ptyinit(dev); 346 if (!dev->si_drv1) 347 return(ENXIO); 348 tp = dev->si_tty; 349 if (tp->t_oproc) 350 return (EIO); 351 tp->t_timeout = -1; 352 tp->t_oproc = ptsstart; 353 tp->t_stop = ptsstop; 354 (void)ttyld_modem(tp, 1); 355 tp->t_lflag &= ~EXTPROC; 356 pti = dev->si_drv1; 357 pti->pt_prison = td->td_ucred->cr_prison; 358 pti->pt_flags = 0; 359 pti->pt_send = 0; 360 pti->pt_ucntl = 0; 361 return (0); 362} 363 364static int
| 322{ 323 struct tty *tp; 324 struct pt_ioctl *pti; 325 326 if (!dev->si_drv1) 327 ptyinit(dev); 328 if (!dev->si_drv1) 329 return(ENXIO); 330 tp = dev->si_tty; 331 if (tp->t_oproc) 332 return (EIO); 333 tp->t_timeout = -1; 334 tp->t_oproc = ptsstart; 335 tp->t_stop = ptsstop; 336 (void)ttyld_modem(tp, 1); 337 tp->t_lflag &= ~EXTPROC; 338 pti = dev->si_drv1; 339 pti->pt_prison = td->td_ucred->cr_prison; 340 pti->pt_flags = 0; 341 pti->pt_send = 0; 342 pti->pt_ucntl = 0; 343 return (0); 344} 345 346static int
|
365ptcclose(dev, flags, fmt, td) 366 dev_t dev; 367 int flags; 368 int fmt; 369 struct thread *td;
| 347ptcclose(dev_t dev, int flags, int fmt, struct thread *td)
|
370{ 371 struct tty *tp; 372 373 tp = dev->si_tty; 374 (void)ttyld_modem(tp, 0); 375 376 /* 377 * XXX MDMBUF makes no sense for ptys but would inhibit the above 378 * l_modem(). CLOCAL makes sense but isn't supported. Special 379 * l_modem()s that ignore carrier drop make no sense for ptys but 380 * may be in use because other parts of the line discipline make 381 * sense for ptys. Recover by doing everything that a normal 382 * ttymodem() would have done except for sending a SIGHUP. 383 */ 384 if (tp->t_state & TS_ISOPEN) { 385 tp->t_state &= ~(TS_CARR_ON | TS_CONNECTED); 386 tp->t_state |= TS_ZOMBIE; 387 ttyflush(tp, FREAD | FWRITE); 388 } 389 390 tp->t_oproc = 0; /* mark closed */ 391 return (0); 392} 393 394static int
| 348{ 349 struct tty *tp; 350 351 tp = dev->si_tty; 352 (void)ttyld_modem(tp, 0); 353 354 /* 355 * XXX MDMBUF makes no sense for ptys but would inhibit the above 356 * l_modem(). CLOCAL makes sense but isn't supported. Special 357 * l_modem()s that ignore carrier drop make no sense for ptys but 358 * may be in use because other parts of the line discipline make 359 * sense for ptys. Recover by doing everything that a normal 360 * ttymodem() would have done except for sending a SIGHUP. 361 */ 362 if (tp->t_state & TS_ISOPEN) { 363 tp->t_state &= ~(TS_CARR_ON | TS_CONNECTED); 364 tp->t_state |= TS_ZOMBIE; 365 ttyflush(tp, FREAD | FWRITE); 366 } 367 368 tp->t_oproc = 0; /* mark closed */ 369 return (0); 370} 371 372static int
|
395ptcread(dev, uio, flag) 396 dev_t dev; 397 struct uio *uio; 398 int flag;
| 373ptcread(dev_t dev, struct uio *uio, int flag)
|
399{ 400 struct tty *tp = dev->si_tty; 401 struct pt_ioctl *pti = dev->si_drv1; 402 char buf[BUFSIZ]; 403 int error = 0, cc; 404 405 /* 406 * We want to block until the slave 407 * is open, and there's something to read; 408 * but if we lost the slave or we're NBIO, 409 * then return the appropriate error instead. 410 */ 411 for (;;) { 412 if (tp->t_state&TS_ISOPEN) { 413 if (pti->pt_flags&PF_PKT && pti->pt_send) { 414 error = ureadc((int)pti->pt_send, uio); 415 if (error) 416 return (error); 417 if (pti->pt_send & TIOCPKT_IOCTL) { 418 cc = min(uio->uio_resid, 419 sizeof(tp->t_termios)); 420 uiomove(&tp->t_termios, cc, uio); 421 } 422 pti->pt_send = 0; 423 return (0); 424 } 425 if (pti->pt_flags&PF_UCNTL && pti->pt_ucntl) { 426 error = ureadc((int)pti->pt_ucntl, uio); 427 if (error) 428 return (error); 429 pti->pt_ucntl = 0; 430 return (0); 431 } 432 if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0) 433 break; 434 } 435 if ((tp->t_state & TS_CONNECTED) == 0) 436 return (0); /* EOF */ 437 if (flag & IO_NDELAY) 438 return (EWOULDBLOCK); 439 error = tsleep(TSA_PTC_READ(tp), TTIPRI | PCATCH, "ptcin", 0); 440 if (error) 441 return (error); 442 } 443 if (pti->pt_flags & (PF_PKT|PF_UCNTL)) 444 error = ureadc(0, uio); 445 while (uio->uio_resid > 0 && error == 0) { 446 cc = q_to_b(&tp->t_outq, buf, min(uio->uio_resid, BUFSIZ)); 447 if (cc <= 0) 448 break; 449 error = uiomove(buf, cc, uio); 450 } 451 ttwwakeup(tp); 452 return (error); 453} 454 455static void
| 374{ 375 struct tty *tp = dev->si_tty; 376 struct pt_ioctl *pti = dev->si_drv1; 377 char buf[BUFSIZ]; 378 int error = 0, cc; 379 380 /* 381 * We want to block until the slave 382 * is open, and there's something to read; 383 * but if we lost the slave or we're NBIO, 384 * then return the appropriate error instead. 385 */ 386 for (;;) { 387 if (tp->t_state&TS_ISOPEN) { 388 if (pti->pt_flags&PF_PKT && pti->pt_send) { 389 error = ureadc((int)pti->pt_send, uio); 390 if (error) 391 return (error); 392 if (pti->pt_send & TIOCPKT_IOCTL) { 393 cc = min(uio->uio_resid, 394 sizeof(tp->t_termios)); 395 uiomove(&tp->t_termios, cc, uio); 396 } 397 pti->pt_send = 0; 398 return (0); 399 } 400 if (pti->pt_flags&PF_UCNTL && pti->pt_ucntl) { 401 error = ureadc((int)pti->pt_ucntl, uio); 402 if (error) 403 return (error); 404 pti->pt_ucntl = 0; 405 return (0); 406 } 407 if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0) 408 break; 409 } 410 if ((tp->t_state & TS_CONNECTED) == 0) 411 return (0); /* EOF */ 412 if (flag & IO_NDELAY) 413 return (EWOULDBLOCK); 414 error = tsleep(TSA_PTC_READ(tp), TTIPRI | PCATCH, "ptcin", 0); 415 if (error) 416 return (error); 417 } 418 if (pti->pt_flags & (PF_PKT|PF_UCNTL)) 419 error = ureadc(0, uio); 420 while (uio->uio_resid > 0 && error == 0) { 421 cc = q_to_b(&tp->t_outq, buf, min(uio->uio_resid, BUFSIZ)); 422 if (cc <= 0) 423 break; 424 error = uiomove(buf, cc, uio); 425 } 426 ttwwakeup(tp); 427 return (error); 428} 429 430static void
|
456ptsstop(tp, flush) 457 struct tty *tp; 458 int flush;
| 431ptsstop(struct tty *tp, int flush)
|
459{ 460 struct pt_ioctl *pti = tp->t_dev->si_drv1; 461 int flag; 462 463 /* note: FLUSHREAD and FLUSHWRITE already ok */ 464 if (flush == 0) { 465 flush = TIOCPKT_STOP; 466 pti->pt_flags |= PF_STOPPED; 467 } else 468 pti->pt_flags &= ~PF_STOPPED; 469 pti->pt_send |= flush; 470 /* change of perspective */ 471 flag = 0; 472 if (flush & FREAD) 473 flag |= FWRITE; 474 if (flush & FWRITE) 475 flag |= FREAD; 476 ptcwakeup(tp, flag); 477} 478 479static int
| 432{ 433 struct pt_ioctl *pti = tp->t_dev->si_drv1; 434 int flag; 435 436 /* note: FLUSHREAD and FLUSHWRITE already ok */ 437 if (flush == 0) { 438 flush = TIOCPKT_STOP; 439 pti->pt_flags |= PF_STOPPED; 440 } else 441 pti->pt_flags &= ~PF_STOPPED; 442 pti->pt_send |= flush; 443 /* change of perspective */ 444 flag = 0; 445 if (flush & FREAD) 446 flag |= FWRITE; 447 if (flush & FWRITE) 448 flag |= FREAD; 449 ptcwakeup(tp, flag); 450} 451 452static int
|
480ptcpoll(dev, events, td) 481 dev_t dev; 482 int events; 483 struct thread *td;
| 453ptcpoll(dev_t dev, int events, struct thread *td)
|
484{ 485 struct tty *tp = dev->si_tty; 486 struct pt_ioctl *pti = dev->si_drv1; 487 int revents = 0; 488 int s; 489 490 if ((tp->t_state & TS_CONNECTED) == 0) 491 return (events & 492 (POLLHUP | POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)); 493 494 /* 495 * Need to block timeouts (ttrstart). 496 */ 497 s = spltty(); 498 499 if (events & (POLLIN | POLLRDNORM)) 500 if ((tp->t_state & TS_ISOPEN) && 501 ((tp->t_outq.c_cc && (tp->t_state & TS_TTSTOP) == 0) || 502 ((pti->pt_flags & PF_PKT) && pti->pt_send) || 503 ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))) 504 revents |= events & (POLLIN | POLLRDNORM); 505 506 if (events & (POLLOUT | POLLWRNORM)) 507 if (tp->t_state & TS_ISOPEN && 508 ((pti->pt_flags & PF_REMOTE) ? 509 (tp->t_canq.c_cc == 0) : 510 ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG - 2) || 511 (tp->t_canq.c_cc == 0 && (tp->t_lflag & ICANON))))) 512 revents |= events & (POLLOUT | POLLWRNORM); 513 514 if (events & POLLHUP) 515 if ((tp->t_state & TS_CARR_ON) == 0) 516 revents |= POLLHUP; 517 518 if (revents == 0) { 519 if (events & (POLLIN | POLLRDNORM)) 520 selrecord(td, &pti->pt_selr); 521 522 if (events & (POLLOUT | POLLWRNORM)) 523 selrecord(td, &pti->pt_selw); 524 } 525 splx(s); 526 527 return (revents); 528} 529 530static int
| 454{ 455 struct tty *tp = dev->si_tty; 456 struct pt_ioctl *pti = dev->si_drv1; 457 int revents = 0; 458 int s; 459 460 if ((tp->t_state & TS_CONNECTED) == 0) 461 return (events & 462 (POLLHUP | POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)); 463 464 /* 465 * Need to block timeouts (ttrstart). 466 */ 467 s = spltty(); 468 469 if (events & (POLLIN | POLLRDNORM)) 470 if ((tp->t_state & TS_ISOPEN) && 471 ((tp->t_outq.c_cc && (tp->t_state & TS_TTSTOP) == 0) || 472 ((pti->pt_flags & PF_PKT) && pti->pt_send) || 473 ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))) 474 revents |= events & (POLLIN | POLLRDNORM); 475 476 if (events & (POLLOUT | POLLWRNORM)) 477 if (tp->t_state & TS_ISOPEN && 478 ((pti->pt_flags & PF_REMOTE) ? 479 (tp->t_canq.c_cc == 0) : 480 ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG - 2) || 481 (tp->t_canq.c_cc == 0 && (tp->t_lflag & ICANON))))) 482 revents |= events & (POLLOUT | POLLWRNORM); 483 484 if (events & POLLHUP) 485 if ((tp->t_state & TS_CARR_ON) == 0) 486 revents |= POLLHUP; 487 488 if (revents == 0) { 489 if (events & (POLLIN | POLLRDNORM)) 490 selrecord(td, &pti->pt_selr); 491 492 if (events & (POLLOUT | POLLWRNORM)) 493 selrecord(td, &pti->pt_selw); 494 } 495 splx(s); 496 497 return (revents); 498} 499 500static int
|
531ptcwrite(dev, uio, flag) 532 dev_t dev; 533 struct uio *uio; 534 int flag;
| 501ptcwrite(dev_t dev, struct uio *uio, int flag)
|
535{ 536 struct tty *tp = dev->si_tty; 537 u_char *cp = 0; 538 int cc = 0; 539 u_char locbuf[BUFSIZ]; 540 int cnt = 0; 541 struct pt_ioctl *pti = dev->si_drv1; 542 int error = 0; 543 544again: 545 if ((tp->t_state&TS_ISOPEN) == 0) 546 goto block; 547 if (pti->pt_flags & PF_REMOTE) { 548 if (tp->t_canq.c_cc) 549 goto block; 550 while ((uio->uio_resid > 0 || cc > 0) && 551 tp->t_canq.c_cc < TTYHOG - 1) { 552 if (cc == 0) { 553 cc = min(uio->uio_resid, BUFSIZ); 554 cc = min(cc, TTYHOG - 1 - tp->t_canq.c_cc); 555 cp = locbuf; 556 error = uiomove(cp, cc, uio); 557 if (error) 558 return (error); 559 /* check again for safety */ 560 if ((tp->t_state & TS_ISOPEN) == 0) { 561 /* adjust as usual */ 562 uio->uio_resid += cc; 563 return (EIO); 564 } 565 } 566 if (cc > 0) { 567 cc = b_to_q((char *)cp, cc, &tp->t_canq); 568 /* 569 * XXX we don't guarantee that the canq size 570 * is >= TTYHOG, so the above b_to_q() may 571 * leave some bytes uncopied. However, space 572 * is guaranteed for the null terminator if 573 * we don't fail here since (TTYHOG - 1) is 574 * not a multiple of CBSIZE. 575 */ 576 if (cc > 0) 577 break; 578 } 579 } 580 /* adjust for data copied in but not written */ 581 uio->uio_resid += cc; 582 (void) putc(0, &tp->t_canq); 583 ttwakeup(tp); 584 wakeup(TSA_PTS_READ(tp)); 585 return (0); 586 } 587 while (uio->uio_resid > 0 || cc > 0) { 588 if (cc == 0) { 589 cc = min(uio->uio_resid, BUFSIZ); 590 cp = locbuf; 591 error = uiomove(cp, cc, uio); 592 if (error) 593 return (error); 594 /* check again for safety */ 595 if ((tp->t_state & TS_ISOPEN) == 0) { 596 /* adjust for data copied in but not written */ 597 uio->uio_resid += cc; 598 return (EIO); 599 } 600 } 601 while (cc > 0) { 602 if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 && 603 (tp->t_canq.c_cc > 0 || !(tp->t_lflag&ICANON))) { 604 wakeup(TSA_HUP_OR_INPUT(tp)); 605 goto block; 606 } 607 ttyld_rint(tp, *cp++); 608 cnt++; 609 cc--; 610 } 611 cc = 0; 612 } 613 return (0); 614block: 615 /* 616 * Come here to wait for slave to open, for space 617 * in outq, or space in rawq, or an empty canq. 618 */ 619 if ((tp->t_state & TS_CONNECTED) == 0) { 620 /* adjust for data copied in but not written */ 621 uio->uio_resid += cc; 622 return (EIO); 623 } 624 if (flag & IO_NDELAY) { 625 /* adjust for data copied in but not written */ 626 uio->uio_resid += cc; 627 if (cnt == 0) 628 return (EWOULDBLOCK); 629 return (0); 630 } 631 error = tsleep(TSA_PTC_WRITE(tp), TTOPRI | PCATCH, "ptcout", 0); 632 if (error) { 633 /* adjust for data copied in but not written */ 634 uio->uio_resid += cc; 635 return (error); 636 } 637 goto again; 638} 639 640/*ARGSUSED*/ 641static int
| 502{ 503 struct tty *tp = dev->si_tty; 504 u_char *cp = 0; 505 int cc = 0; 506 u_char locbuf[BUFSIZ]; 507 int cnt = 0; 508 struct pt_ioctl *pti = dev->si_drv1; 509 int error = 0; 510 511again: 512 if ((tp->t_state&TS_ISOPEN) == 0) 513 goto block; 514 if (pti->pt_flags & PF_REMOTE) { 515 if (tp->t_canq.c_cc) 516 goto block; 517 while ((uio->uio_resid > 0 || cc > 0) && 518 tp->t_canq.c_cc < TTYHOG - 1) { 519 if (cc == 0) { 520 cc = min(uio->uio_resid, BUFSIZ); 521 cc = min(cc, TTYHOG - 1 - tp->t_canq.c_cc); 522 cp = locbuf; 523 error = uiomove(cp, cc, uio); 524 if (error) 525 return (error); 526 /* check again for safety */ 527 if ((tp->t_state & TS_ISOPEN) == 0) { 528 /* adjust as usual */ 529 uio->uio_resid += cc; 530 return (EIO); 531 } 532 } 533 if (cc > 0) { 534 cc = b_to_q((char *)cp, cc, &tp->t_canq); 535 /* 536 * XXX we don't guarantee that the canq size 537 * is >= TTYHOG, so the above b_to_q() may 538 * leave some bytes uncopied. However, space 539 * is guaranteed for the null terminator if 540 * we don't fail here since (TTYHOG - 1) is 541 * not a multiple of CBSIZE. 542 */ 543 if (cc > 0) 544 break; 545 } 546 } 547 /* adjust for data copied in but not written */ 548 uio->uio_resid += cc; 549 (void) putc(0, &tp->t_canq); 550 ttwakeup(tp); 551 wakeup(TSA_PTS_READ(tp)); 552 return (0); 553 } 554 while (uio->uio_resid > 0 || cc > 0) { 555 if (cc == 0) { 556 cc = min(uio->uio_resid, BUFSIZ); 557 cp = locbuf; 558 error = uiomove(cp, cc, uio); 559 if (error) 560 return (error); 561 /* check again for safety */ 562 if ((tp->t_state & TS_ISOPEN) == 0) { 563 /* adjust for data copied in but not written */ 564 uio->uio_resid += cc; 565 return (EIO); 566 } 567 } 568 while (cc > 0) { 569 if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 && 570 (tp->t_canq.c_cc > 0 || !(tp->t_lflag&ICANON))) { 571 wakeup(TSA_HUP_OR_INPUT(tp)); 572 goto block; 573 } 574 ttyld_rint(tp, *cp++); 575 cnt++; 576 cc--; 577 } 578 cc = 0; 579 } 580 return (0); 581block: 582 /* 583 * Come here to wait for slave to open, for space 584 * in outq, or space in rawq, or an empty canq. 585 */ 586 if ((tp->t_state & TS_CONNECTED) == 0) { 587 /* adjust for data copied in but not written */ 588 uio->uio_resid += cc; 589 return (EIO); 590 } 591 if (flag & IO_NDELAY) { 592 /* adjust for data copied in but not written */ 593 uio->uio_resid += cc; 594 if (cnt == 0) 595 return (EWOULDBLOCK); 596 return (0); 597 } 598 error = tsleep(TSA_PTC_WRITE(tp), TTOPRI | PCATCH, "ptcout", 0); 599 if (error) { 600 /* adjust for data copied in but not written */ 601 uio->uio_resid += cc; 602 return (error); 603 } 604 goto again; 605} 606 607/*ARGSUSED*/ 608static int
|
642ptyioctl(dev, cmd, data, flag, td) 643 dev_t dev; 644 u_long cmd; 645 caddr_t data; 646 int flag; 647 struct thread *td;
| 609ptyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)
|
648{ 649 struct tty *tp = dev->si_tty; 650 struct pt_ioctl *pti = dev->si_drv1; 651 u_char *cc = tp->t_cc; 652 int stop, error; 653 654 if (devsw(dev)->d_open == ptcopen) { 655 switch (cmd) { 656 657 case TIOCGPGRP: 658 /* 659 * We avoid calling ttioctl on the controller since, 660 * in that case, tp must be the controlling terminal. 661 */ 662 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0; 663 return (0); 664 665 case TIOCPKT: 666 if (*(int *)data) { 667 if (pti->pt_flags & PF_UCNTL) 668 return (EINVAL); 669 pti->pt_flags |= PF_PKT; 670 } else 671 pti->pt_flags &= ~PF_PKT; 672 return (0); 673 674 case TIOCUCNTL: 675 if (*(int *)data) { 676 if (pti->pt_flags & PF_PKT) 677 return (EINVAL); 678 pti->pt_flags |= PF_UCNTL; 679 } else 680 pti->pt_flags &= ~PF_UCNTL; 681 return (0); 682 683 case TIOCREMOTE: 684 if (*(int *)data) 685 pti->pt_flags |= PF_REMOTE; 686 else 687 pti->pt_flags &= ~PF_REMOTE; 688 ttyflush(tp, FREAD|FWRITE); 689 return (0); 690 } 691 692 /* 693 * The rest of the ioctls shouldn't be called until 694 * the slave is open. 695 */ 696 if ((tp->t_state & TS_ISOPEN) == 0) 697 return (EAGAIN); 698 699 switch (cmd) { 700#ifdef COMPAT_43 701 case TIOCSETP: 702 case TIOCSETN: 703#endif 704 case TIOCSETD: 705 case TIOCSETA: 706 case TIOCSETAW: 707 case TIOCSETAF: 708 /* 709 * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG. 710 * ttywflush(tp) will hang if there are characters in 711 * the outq. 712 */ 713 ndflush(&tp->t_outq, tp->t_outq.c_cc); 714 break; 715 716 case TIOCSIG: 717 if (*(unsigned int *)data >= NSIG || 718 *(unsigned int *)data == 0) 719 return(EINVAL); 720 if ((tp->t_lflag&NOFLSH) == 0) 721 ttyflush(tp, FREAD|FWRITE); 722 if (tp->t_pgrp != NULL) { 723 PGRP_LOCK(tp->t_pgrp); 724 pgsignal(tp->t_pgrp, *(unsigned int *)data, 1); 725 PGRP_UNLOCK(tp->t_pgrp); 726 } 727 if ((*(unsigned int *)data == SIGINFO) && 728 ((tp->t_lflag&NOKERNINFO) == 0)) 729 ttyinfo(tp); 730 return(0); 731 } 732 } 733 if (cmd == TIOCEXT) { 734 /* 735 * When the EXTPROC bit is being toggled, we need 736 * to send an TIOCPKT_IOCTL if the packet driver 737 * is turned on. 738 */ 739 if (*(int *)data) { 740 if (pti->pt_flags & PF_PKT) { 741 pti->pt_send |= TIOCPKT_IOCTL; 742 ptcwakeup(tp, FREAD); 743 } 744 tp->t_lflag |= EXTPROC; 745 } else { 746 if ((tp->t_lflag & EXTPROC) && 747 (pti->pt_flags & PF_PKT)) { 748 pti->pt_send |= TIOCPKT_IOCTL; 749 ptcwakeup(tp, FREAD); 750 } 751 tp->t_lflag &= ~EXTPROC; 752 } 753 return(0); 754 } 755 error = ttyioctl(dev, cmd, data, flag, td); 756 if (error == ENOTTY) { 757 if (pti->pt_flags & PF_UCNTL && 758 (cmd & ~0xff) == UIOCCMD(0)) { 759 if (cmd & 0xff) { 760 pti->pt_ucntl = (u_char)cmd; 761 ptcwakeup(tp, FREAD); 762 } 763 return (0); 764 } 765 error = ENOTTY; 766 } 767 /* 768 * If external processing and packet mode send ioctl packet. 769 */ 770 if ((tp->t_lflag&EXTPROC) && (pti->pt_flags & PF_PKT)) { 771 switch(cmd) { 772 case TIOCSETA: 773 case TIOCSETAW: 774 case TIOCSETAF: 775#ifdef COMPAT_43 776 case TIOCSETP: 777 case TIOCSETN: 778#endif 779#if defined(COMPAT_43) || defined(COMPAT_SUNOS) 780 case TIOCSETC: 781 case TIOCSLTC: 782 case TIOCLBIS: 783 case TIOCLBIC: 784 case TIOCLSET: 785#endif 786 pti->pt_send |= TIOCPKT_IOCTL; 787 ptcwakeup(tp, FREAD); 788 break; 789 default: 790 break; 791 } 792 } 793 stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s')) 794 && CCEQ(cc[VSTART], CTRL('q')); 795 if (pti->pt_flags & PF_NOSTOP) { 796 if (stop) { 797 pti->pt_send &= ~TIOCPKT_NOSTOP; 798 pti->pt_send |= TIOCPKT_DOSTOP; 799 pti->pt_flags &= ~PF_NOSTOP; 800 ptcwakeup(tp, FREAD); 801 } 802 } else { 803 if (!stop) { 804 pti->pt_send &= ~TIOCPKT_DOSTOP; 805 pti->pt_send |= TIOCPKT_NOSTOP; 806 pti->pt_flags |= PF_NOSTOP; 807 ptcwakeup(tp, FREAD); 808 } 809 } 810 return (error); 811} 812
| 610{ 611 struct tty *tp = dev->si_tty; 612 struct pt_ioctl *pti = dev->si_drv1; 613 u_char *cc = tp->t_cc; 614 int stop, error; 615 616 if (devsw(dev)->d_open == ptcopen) { 617 switch (cmd) { 618 619 case TIOCGPGRP: 620 /* 621 * We avoid calling ttioctl on the controller since, 622 * in that case, tp must be the controlling terminal. 623 */ 624 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0; 625 return (0); 626 627 case TIOCPKT: 628 if (*(int *)data) { 629 if (pti->pt_flags & PF_UCNTL) 630 return (EINVAL); 631 pti->pt_flags |= PF_PKT; 632 } else 633 pti->pt_flags &= ~PF_PKT; 634 return (0); 635 636 case TIOCUCNTL: 637 if (*(int *)data) { 638 if (pti->pt_flags & PF_PKT) 639 return (EINVAL); 640 pti->pt_flags |= PF_UCNTL; 641 } else 642 pti->pt_flags &= ~PF_UCNTL; 643 return (0); 644 645 case TIOCREMOTE: 646 if (*(int *)data) 647 pti->pt_flags |= PF_REMOTE; 648 else 649 pti->pt_flags &= ~PF_REMOTE; 650 ttyflush(tp, FREAD|FWRITE); 651 return (0); 652 } 653 654 /* 655 * The rest of the ioctls shouldn't be called until 656 * the slave is open. 657 */ 658 if ((tp->t_state & TS_ISOPEN) == 0) 659 return (EAGAIN); 660 661 switch (cmd) { 662#ifdef COMPAT_43 663 case TIOCSETP: 664 case TIOCSETN: 665#endif 666 case TIOCSETD: 667 case TIOCSETA: 668 case TIOCSETAW: 669 case TIOCSETAF: 670 /* 671 * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG. 672 * ttywflush(tp) will hang if there are characters in 673 * the outq. 674 */ 675 ndflush(&tp->t_outq, tp->t_outq.c_cc); 676 break; 677 678 case TIOCSIG: 679 if (*(unsigned int *)data >= NSIG || 680 *(unsigned int *)data == 0) 681 return(EINVAL); 682 if ((tp->t_lflag&NOFLSH) == 0) 683 ttyflush(tp, FREAD|FWRITE); 684 if (tp->t_pgrp != NULL) { 685 PGRP_LOCK(tp->t_pgrp); 686 pgsignal(tp->t_pgrp, *(unsigned int *)data, 1); 687 PGRP_UNLOCK(tp->t_pgrp); 688 } 689 if ((*(unsigned int *)data == SIGINFO) && 690 ((tp->t_lflag&NOKERNINFO) == 0)) 691 ttyinfo(tp); 692 return(0); 693 } 694 } 695 if (cmd == TIOCEXT) { 696 /* 697 * When the EXTPROC bit is being toggled, we need 698 * to send an TIOCPKT_IOCTL if the packet driver 699 * is turned on. 700 */ 701 if (*(int *)data) { 702 if (pti->pt_flags & PF_PKT) { 703 pti->pt_send |= TIOCPKT_IOCTL; 704 ptcwakeup(tp, FREAD); 705 } 706 tp->t_lflag |= EXTPROC; 707 } else { 708 if ((tp->t_lflag & EXTPROC) && 709 (pti->pt_flags & PF_PKT)) { 710 pti->pt_send |= TIOCPKT_IOCTL; 711 ptcwakeup(tp, FREAD); 712 } 713 tp->t_lflag &= ~EXTPROC; 714 } 715 return(0); 716 } 717 error = ttyioctl(dev, cmd, data, flag, td); 718 if (error == ENOTTY) { 719 if (pti->pt_flags & PF_UCNTL && 720 (cmd & ~0xff) == UIOCCMD(0)) { 721 if (cmd & 0xff) { 722 pti->pt_ucntl = (u_char)cmd; 723 ptcwakeup(tp, FREAD); 724 } 725 return (0); 726 } 727 error = ENOTTY; 728 } 729 /* 730 * If external processing and packet mode send ioctl packet. 731 */ 732 if ((tp->t_lflag&EXTPROC) && (pti->pt_flags & PF_PKT)) { 733 switch(cmd) { 734 case TIOCSETA: 735 case TIOCSETAW: 736 case TIOCSETAF: 737#ifdef COMPAT_43 738 case TIOCSETP: 739 case TIOCSETN: 740#endif 741#if defined(COMPAT_43) || defined(COMPAT_SUNOS) 742 case TIOCSETC: 743 case TIOCSLTC: 744 case TIOCLBIS: 745 case TIOCLBIC: 746 case TIOCLSET: 747#endif 748 pti->pt_send |= TIOCPKT_IOCTL; 749 ptcwakeup(tp, FREAD); 750 break; 751 default: 752 break; 753 } 754 } 755 stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s')) 756 && CCEQ(cc[VSTART], CTRL('q')); 757 if (pti->pt_flags & PF_NOSTOP) { 758 if (stop) { 759 pti->pt_send &= ~TIOCPKT_NOSTOP; 760 pti->pt_send |= TIOCPKT_DOSTOP; 761 pti->pt_flags &= ~PF_NOSTOP; 762 ptcwakeup(tp, FREAD); 763 } 764 } else { 765 if (!stop) { 766 pti->pt_send &= ~TIOCPKT_DOSTOP; 767 pti->pt_send |= TIOCPKT_NOSTOP; 768 pti->pt_flags |= PF_NOSTOP; 769 ptcwakeup(tp, FREAD); 770 } 771 } 772 return (error); 773} 774
|
813 814static void ptc_drvinit(void *unused); 815 816static void pty_clone(void *arg, char *name, int namelen, dev_t *dev); 817
| |
818static void
| 775static void
|
819pty_clone(arg, name, namelen, dev) 820 void *arg; 821 char *name; 822 int namelen; 823 dev_t *dev;
| 776pty_clone(void *arg, char *name, int namelen, dev_t *dev)
|
824{ 825 int u; 826 827 if (*dev != NODEV) 828 return; 829 if (bcmp(name, "pty", 3) != 0) 830 return; 831 if (name[5] != '\0') 832 return; 833 switch (name[3]) { 834 case 'p': u = 0; break; 835 case 'q': u = 32; break; 836 case 'r': u = 64; break; 837 case 's': u = 96; break; 838 case 'P': u = 128; break; 839 case 'Q': u = 160; break; 840 case 'R': u = 192; break; 841 case 'S': u = 224; break; 842 default: return; 843 } 844 if (name[4] >= '0' && name[4] <= '9') 845 u += name[4] - '0'; 846 else if (name[4] >= 'a' && name[4] <= 'v') 847 u += name[4] - 'a' + 10; 848 else 849 return; 850 *dev = make_dev(&ptc_cdevsw, u, 851 UID_ROOT, GID_WHEEL, 0666, "pty%c%r", names[u / 32], u % 32); 852 (*dev)->si_flags |= SI_CHEAPCLONE; 853 return; 854} 855 856static void
| 777{ 778 int u; 779 780 if (*dev != NODEV) 781 return; 782 if (bcmp(name, "pty", 3) != 0) 783 return; 784 if (name[5] != '\0') 785 return; 786 switch (name[3]) { 787 case 'p': u = 0; break; 788 case 'q': u = 32; break; 789 case 'r': u = 64; break; 790 case 's': u = 96; break; 791 case 'P': u = 128; break; 792 case 'Q': u = 160; break; 793 case 'R': u = 192; break; 794 case 'S': u = 224; break; 795 default: return; 796 } 797 if (name[4] >= '0' && name[4] <= '9') 798 u += name[4] - '0'; 799 else if (name[4] >= 'a' && name[4] <= 'v') 800 u += name[4] - 'a' + 10; 801 else 802 return; 803 *dev = make_dev(&ptc_cdevsw, u, 804 UID_ROOT, GID_WHEEL, 0666, "pty%c%r", names[u / 32], u % 32); 805 (*dev)->si_flags |= SI_CHEAPCLONE; 806 return; 807} 808 809static void
|
857ptc_drvinit(unused) 858 void *unused;
| 810ptc_drvinit(void *unused)
|
859{ 860 861 EVENTHANDLER_REGISTER(dev_clone, pty_clone, 0, 1000); 862} 863 864SYSINIT(ptcdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR_C,ptc_drvinit,NULL)
| 811{ 812 813 EVENTHANDLER_REGISTER(dev_clone, pty_clone, 0, 1000); 814} 815 816SYSINIT(ptcdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR_C,ptc_drvinit,NULL)
|