a0378fa2e4b355bfcb3b4a80a3f5d1bcb3c964ab
[dragonfly.git] / sys / kern / tty_pty.c
1 /*
2  * (MPSAFE)
3  *
4  * Copyright (c) 1982, 1986, 1989, 1993
5  *      The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  *      @(#)tty_pty.c   8.4 (Berkeley) 2/20/95
32  * $FreeBSD: src/sys/kern/tty_pty.c,v 1.74.2.4 2002/02/20 19:58:13 dillon Exp $
33  */
34
35 /*
36  * Most functions here could use a separate lock to deal with concurrent
37  * access to the 'pt's.
38  */
39
40 /*
41  * Pseudo-teletype Driver
42  * (Actually two drivers, requiring two dev_ops structures)
43  */
44
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/proc.h>
48 #include <sys/priv.h>
49 #include <sys/tty.h>
50 #include <sys/ttydefaults.h>    /* for TTYDEF_* */
51 #include <sys/conf.h>
52 #include <sys/fcntl.h>
53 #include <sys/kernel.h>
54 #include <sys/vnode.h>
55 #include <sys/signalvar.h>
56 #include <sys/malloc.h>
57 #include <sys/device.h>
58 #include <sys/thread2.h>
59 #include <sys/devfs.h>
60 #include <sys/stat.h>
61 #include <sys/sysctl.h>
62
63 MALLOC_DEFINE(M_PTY, "ptys", "pty data structures");
64
65 static void ptsstart (struct tty *tp);
66 static void ptsstop (struct tty *tp, int rw);
67 static void ptsunhold (struct tty *tp);
68 static void ptcwakeup (struct tty *tp, int flag);
69 static void ptyinit (int n);
70 static int  filt_ptcread (struct knote *kn, long hint);
71 static void filt_ptcrdetach (struct knote *kn);
72 static int  filt_ptcwrite (struct knote *kn, long hint);
73 static void filt_ptcwdetach (struct knote *kn);
74
75 static  d_open_t        ptsopen;
76 static  d_close_t       ptsclose;
77 static  d_read_t        ptsread;
78 static  d_write_t       ptswrite;
79 static  d_ioctl_t       ptyioctl;
80 static  d_open_t        ptcopen;
81 static  d_close_t       ptcclose;
82 static  d_read_t        ptcread;
83 static  d_write_t       ptcwrite;
84 static  d_kqfilter_t    ptckqfilter;
85
86 DEVFS_DEFINE_CLONE_BITMAP(pty);
87 static struct pt_ioctl **ptis;          /* keep pti's intact */
88
89 static  d_clone_t       ptyclone;
90
91 static int      pty_debug_level = 0;
92
93 static struct dev_ops pts98_ops = {
94         { "pts98", 0, D_TTY | D_MPSAFE },
95         .d_open =       ptsopen,
96         .d_close =      ptsclose,
97         .d_read =       ptsread,
98         .d_write =      ptswrite,
99         .d_ioctl =      ptyioctl,
100         .d_kqfilter =   ttykqfilter,
101         .d_revoke =     ttyrevoke
102 };
103
104 static struct dev_ops ptc98_ops = {
105         { "ptc98", 0, D_TTY | D_MASTER | D_MPSAFE },
106         .d_open =       ptcopen,
107         .d_close =      ptcclose,
108         .d_read =       ptcread,
109         .d_write =      ptcwrite,
110         .d_ioctl =      ptyioctl,
111         .d_kqfilter =   ptckqfilter,
112         .d_revoke =     ttyrevoke
113 };
114
115 static struct dev_ops pts_ops = {
116         { "pts", 0, D_TTY | D_MPSAFE },
117         .d_open =       ptsopen,
118         .d_close =      ptsclose,
119         .d_read =       ptsread,
120         .d_write =      ptswrite,
121         .d_ioctl =      ptyioctl,
122         .d_kqfilter =   ttykqfilter,
123         .d_revoke =     ttyrevoke
124 };
125
126 #define CDEV_MAJOR_C    6
127 static struct dev_ops ptc_ops = {
128         { "ptc", 0, D_TTY | D_MASTER | D_MPSAFE },
129         .d_open =       ptcopen,
130         .d_close =      ptcclose,
131         .d_read =       ptcread,
132         .d_write =      ptcwrite,
133         .d_ioctl =      ptyioctl,
134         .d_kqfilter =   ptckqfilter,
135         .d_revoke =     ttyrevoke
136 };
137
138 #define BUFSIZ  100             /* Chunk size iomoved to/from user */
139
140 #define MAXPTYS 1000            /* Maximum cloneable ptys */
141
142 struct  pt_ioctl {
143         int     pt_flags;
144         int     pt_refs;        /* Structural references interlock S/MOPEN */
145         int     pt_uminor;
146         struct  kqinfo pt_kqr, pt_kqw;
147         u_char  pt_send;
148         u_char  pt_ucntl;
149         struct tty pt_tty;
150         cdev_t  devs, devc;
151         struct  prison *pt_prison;
152 };
153
154 /*
155  * pt_flags ptc state
156  */
157 #define PF_PKT          0x0008          /* packet mode */
158 #define PF_STOPPED      0x0010          /* user told stopped */
159 #define PF_REMOTE       0x0020          /* remote and flow controlled input */
160 #define PF_NOSTOP       0x0040
161 #define PF_UCNTL        0x0080          /* user control mode */
162
163 #define PF_PTCSTATEMASK 0x00FF
164
165 /*
166  * pt_flags open state.  Note that PF_SCLOSED is used to activate
167  * read EOF on the ptc so it is only set after the slave has been
168  * opened and then closed, and cleared again if the slave is opened
169  * again.
170  */
171 #define PF_UNIX98       0x0100
172 #define PF_SOPEN        0x0200
173 #define PF_MOPEN        0x0400
174 #define PF_SCLOSED      0x0800
175 #define PF_TERMINATED   0x8000
176
177 /*
178  * This function creates and initializes a pts/ptc pair
179  *
180  * pts == /dev/tty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv]
181  * ptc == /dev/pty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv]
182  *
183  * XXX: define and add mapping of upper minor bits to allow more 
184  *      than 256 ptys.
185  */
186 static void
187 ptyinit(int n)
188 {
189         cdev_t devs, devc;
190         char *names = "pqrsPQRS";
191         struct pt_ioctl *pti;
192
193         /* For now we only map the lower 8 bits of the minor */
194         if (n & ~0xff)
195                 return;
196
197         pti = kmalloc(sizeof(*pti), M_PTY, M_WAITOK | M_ZERO);
198         pti->devs = devs = make_dev(&pts_ops, n, 0, 0, 0666,
199                                     "tty%c%c",
200                                     names[n / 32], hex2ascii(n % 32));
201         pti->devc = devc = make_dev(&ptc_ops, n, 0, 0, 0666,
202                                     "pty%c%c",
203                                     names[n / 32], hex2ascii(n % 32));
204
205         pti->pt_tty.t_dev = devs;
206         pti->pt_uminor = n;
207         devs->si_drv1 = devc->si_drv1 = pti;
208         devs->si_tty = devc->si_tty = &pti->pt_tty;
209         devs->si_flags |= SI_OVERRIDE;  /* uid, gid, perms from dev */
210         devc->si_flags |= SI_OVERRIDE;  /* uid, gid, perms from dev */
211         ttyinit(&pti->pt_tty);
212         ttyregister(&pti->pt_tty);
213 }
214
215 static int
216 ptyclone(struct dev_clone_args *ap)
217 {
218         int unit;
219         struct pt_ioctl *pti;
220
221         /*
222          * Limit the number of unix98 pty (slave) devices to 1000, as
223          * the utmp(5) format only allows for 8 bytes for the tty,
224          * "pts/XXX".
225          *
226          * If this limit is reached, we don't clone and return an error
227          * to devfs.
228          */
229         unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(pty), MAXPTYS);
230
231         if (unit < 0) {
232                 ap->a_dev = NULL;
233                 return 1;
234         }
235
236         /*
237          * pti structures must be persistent once allocated.
238          */
239         if ((pti = ptis[unit]) == NULL) {
240                 lwkt_gettoken(&tty_token);
241                 pti = kmalloc(sizeof(*pti), M_PTY, M_WAITOK | M_ZERO);
242                 if (ptis[unit] == NULL) {
243                         ptis[unit] = pti;
244                         ttyinit(&pti->pt_tty);
245                 } else {
246                         kfree(pti, M_PTY);
247                 }
248                 lwkt_reltoken(&tty_token);
249         }
250
251         /*
252          * The cloning bitmap should guarantee isolation during
253          * initialization.
254          */
255         pti->devc = make_only_dev(&ptc98_ops, unit,
256                                   ap->a_cred->cr_ruid,
257                                   0, 0600, "ptm/%d", unit);
258         pti->devs = make_dev(&pts98_ops, unit,
259                              ap->a_cred->cr_ruid,
260                              GID_TTY, 0620, "pts/%d", unit);
261         ap->a_dev = pti->devc;
262
263         pti->devs->si_flags |= SI_OVERRIDE;     /* uid, gid, perms from dev */
264         pti->devc->si_flags |= SI_OVERRIDE;     /* uid, gid, perms from dev */
265
266         pti->pt_tty.t_dev = pti->devs;
267         pti->pt_flags = PF_UNIX98;
268         pti->pt_uminor = unit;
269         pti->devs->si_drv1 = pti->devc->si_drv1 = pti;
270         pti->devs->si_tty = pti->devc->si_tty = &pti->pt_tty;
271         ttyregister(&pti->pt_tty);
272
273         return 0;
274 }
275
276 /*
277  * pti_hold() prevents the pti from being destroyed due to a termination
278  * while a pt*open() is blocked.
279  *
280  * This function returns non-zero if we cannot hold due to a termination
281  * interlock.
282  */
283 static int
284 pti_hold(struct pt_ioctl *pti)
285 {
286         if (pti->pt_flags & PF_TERMINATED)
287                 return(ENXIO);
288         ++pti->pt_refs;
289
290         return(0);
291 }
292
293 /*
294  * pti_done() releases the reference and checks to see if both sides have
295  * been closed on a unix98 pty, allowing us to destroy the device and
296  * release resources.
297  *
298  * We do not release resources on non-unix98 ptys.  Those are left
299  * statically allocated.
300  */
301 static void
302 pti_done(struct pt_ioctl *pti)
303 {
304         lwkt_gettoken(&pti->pt_tty.t_token);
305         if (--pti->pt_refs == 0) {
306                 cdev_t dev;
307                 int uminor_no;
308
309                 /*
310                  * Only unix09 ptys are freed up (the pti structure itself
311                  * is never freed, regardless).
312                  */
313                 if ((pti->pt_flags & PF_UNIX98) == 0) {
314                         lwkt_reltoken(&pti->pt_tty.t_token);
315                         return;
316                 }
317
318                 /*
319                  * Interlock open attempts against termination by setting
320                  * PF_TERMINATED.  This allows us to block while cleaning
321                  * out the device infrastructure.
322                  *
323                  * Do not terminate the tty if it still has a session
324                  * association (t_refs).
325                  */
326                 if ((pti->pt_flags & (PF_SOPEN|PF_MOPEN)) == 0 &&
327                     pti->pt_tty.t_refs == 0) {
328                         pti->pt_flags |= PF_TERMINATED;
329                         uminor_no = pti->pt_uminor;
330
331                         if ((dev = pti->devs) != NULL) {
332                                 dev->si_drv1 = NULL;
333                                 pti->devs = NULL;
334                                 destroy_dev(dev);
335                         }
336                         if ((dev = pti->devc) != NULL) {
337                                 dev->si_drv1 = NULL;
338                                 pti->devc = NULL;
339                                 destroy_dev(dev);
340                         }
341                         ttyunregister(&pti->pt_tty);
342                         pti->pt_tty.t_dev = NULL;
343
344                         devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(pty),
345                                                uminor_no);
346                         /* pti structure remains intact */
347                 }
348         }
349         lwkt_reltoken(&pti->pt_tty.t_token);
350 }
351
352 /*ARGSUSED*/
353 static  int
354 ptsopen(struct dev_open_args *ap)
355 {
356         cdev_t dev = ap->a_head.a_dev;
357         struct tty *tp;
358         int error;
359         struct pt_ioctl *pti;
360
361         /*
362          * The pti will already be assigned by the clone code or
363          * pre-created if a non-unix 98 pty.  If si_drv1 is NULL
364          * we are somehow racing a unix98 termination.
365          */
366         if (dev->si_drv1 == NULL)
367                 return(ENXIO);
368         pti = dev->si_drv1;
369
370         lwkt_gettoken(&pti->pt_tty.t_token);
371         if (pti_hold(pti)) {
372                 lwkt_reltoken(&pti->pt_tty.t_token);
373                 return(ENXIO);
374         }
375
376         tp = dev->si_tty;
377
378         /*
379          * Reinit most of the tty state if it isn't open.  Handle
380          * exclusive access.
381          */
382         if ((tp->t_state & TS_ISOPEN) == 0) {
383                 ttychars(tp);           /* Set up default chars */
384                 tp->t_iflag = TTYDEF_IFLAG;
385                 tp->t_oflag = TTYDEF_OFLAG;
386                 tp->t_lflag = TTYDEF_LFLAG;
387                 tp->t_cflag = TTYDEF_CFLAG;
388                 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
389         } else if ((tp->t_state & TS_XCLUDE) &&
390                    priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) {
391                 pti_done(pti);
392                 lwkt_reltoken(&pti->pt_tty.t_token);
393                 return (EBUSY);
394         } else if (pti->pt_prison != ap->a_cred->cr_prison) {
395                 pti_done(pti);
396                 lwkt_reltoken(&pti->pt_tty.t_token);
397                 return (EBUSY);
398         }
399
400         /*
401          * If the ptc is already present this will connect us up.  It
402          * is unclear if this is actually needed.
403          *
404          * If neither side is open be sure to clear any left over
405          * ZOMBIE state before continuing.
406          */
407         if (tp->t_oproc)
408                 (void)(*linesw[tp->t_line].l_modem)(tp, 1);
409         else if ((pti->pt_flags & PF_SOPEN) == 0)
410                 tp->t_state &= ~TS_ZOMBIE;
411
412         /*
413          * Wait for the carrier (ptc side)
414          */
415         while ((tp->t_state & TS_CARR_ON) == 0) {
416                 if (ap->a_oflags & FNONBLOCK)
417                         break;
418                 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ptsopn", 0);
419                 if (error) {
420                         pti_done(pti);
421                         lwkt_reltoken(&pti->pt_tty.t_token);
422                         return (error);
423                 }
424         }
425
426         /*
427          * Mark the tty open and mark the slave side as being open.
428          */
429         error = (*linesw[tp->t_line].l_open)(dev, tp);
430
431         if (error == 0) {
432                 pti->pt_flags |= PF_SOPEN;
433                 pti->pt_flags &= ~PF_SCLOSED;
434                 ptcwakeup(tp, FREAD|FWRITE);
435         }
436         pti_done(pti);
437         lwkt_reltoken(&pti->pt_tty.t_token);
438
439         return (error);
440 }
441
442 static  int
443 ptsclose(struct dev_close_args *ap)
444 {
445         cdev_t dev = ap->a_head.a_dev;
446         struct tty *tp;
447         struct pt_ioctl *pti = dev->si_drv1;
448         int err;
449
450         lwkt_gettoken(&pti->pt_tty.t_token);
451         if (pti_hold(pti))
452                 panic("ptsclose on terminated pti");
453
454         /*
455          * Disconnect the slave side
456          */
457         tp = dev->si_tty;
458         err = (*linesw[tp->t_line].l_close)(tp, ap->a_fflag);
459         ptsstop(tp, FREAD|FWRITE);
460         ttyclose(tp);                   /* clears t_state */
461
462         /*
463          * Mark the pts side closed and signal the ptc.  Do not mark the
464          * tty a zombie... that is, allow the tty to be re-opened as long
465          * as the ptc is still open.  The ptc will read() EOFs until the
466          * pts side is reopened or the ptc is closed.
467          *
468          * xterm() depends on this behavior as it will revoke() the pts
469          * and then reopen it after the (unnecessary old code) chmod.
470          */
471         pti->pt_flags &= ~PF_SOPEN;
472         pti->pt_flags |= PF_SCLOSED;
473         if (tp->t_oproc)
474                 ptcwakeup(tp, FREAD);
475         pti_done(pti);
476         lwkt_reltoken(&pti->pt_tty.t_token);
477         return (err);
478 }
479
480 static  int
481 ptsread(struct dev_read_args *ap)
482 {
483         cdev_t dev = ap->a_head.a_dev;
484         struct proc *p = curproc;
485         struct tty *tp = dev->si_tty;
486         struct pt_ioctl *pti = dev->si_drv1;
487         struct lwp *lp;
488
489         int error = 0;
490
491         lp = curthread->td_lwp;
492
493         lwkt_gettoken(&pti->pt_tty.t_token);
494 again:
495         if (pti->pt_flags & PF_REMOTE) {
496                 while (isbackground(p, tp)) {
497                         if (SIGISMEMBER(p->p_sigignore, SIGTTIN) ||
498                             SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
499                             p->p_pgrp->pg_jobc == 0 ||
500                             (p->p_flags & P_PPWAIT)) {
501                                 lwkt_reltoken(&pti->pt_tty.t_token);
502                                 return (EIO);
503                         }
504                         pgsignal(p->p_pgrp, SIGTTIN, 1);
505                         error = ttysleep(tp, &lbolt, PCATCH, "ptsbg", 0);
506                         if (error) {
507                                 lwkt_reltoken(&pti->pt_tty.t_token);
508                                 return (error);
509                         }
510                 }
511                 if (tp->t_canq.c_cc == 0) {
512                         if (ap->a_ioflag & IO_NDELAY) {
513                                 lwkt_reltoken(&pti->pt_tty.t_token);
514                                 return (EWOULDBLOCK);
515                         }
516                         error = ttysleep(tp, TSA_PTS_READ(tp), PCATCH,
517                                          "ptsin", 0);
518                         if (error) {
519                                 lwkt_reltoken(&pti->pt_tty.t_token);
520                                 return (error);
521                         }
522                         goto again;
523                 }
524                 while (tp->t_canq.c_cc > 1 && ap->a_uio->uio_resid > 0)
525                         if (ureadc(clist_getc(&tp->t_canq), ap->a_uio) < 0) {
526                                 error = EFAULT;
527                                 break;
528                         }
529                 if (tp->t_canq.c_cc == 1)
530                         clist_getc(&tp->t_canq);
531                 if (tp->t_canq.c_cc) {
532                         lwkt_reltoken(&pti->pt_tty.t_token);
533                         return (error);
534                 }
535         } else
536                 if (tp->t_oproc)
537                         error = (*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag);
538         ptcwakeup(tp, FWRITE);
539         lwkt_reltoken(&pti->pt_tty.t_token);
540
541         return (error);
542 }
543
544 /*
545  * Write to pseudo-tty.
546  * Wakeups of controlling tty will happen
547  * indirectly, when tty driver calls ptsstart.
548  */
549 static  int
550 ptswrite(struct dev_write_args *ap)
551 {
552         cdev_t dev = ap->a_head.a_dev;
553         struct tty *tp;
554         int ret;
555
556         tp = dev->si_tty;
557         lwkt_gettoken(&tp->t_token);
558         if (tp->t_oproc == NULL) {
559                 lwkt_reltoken(&tp->t_token);
560                 return (EIO);
561         }
562         ret = ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag));
563         lwkt_reltoken(&tp->t_token);
564
565         return ret;
566 }
567
568 /*
569  * Start output on pseudo-tty.
570  * Wake up process selecting or sleeping for input from controlling tty.
571  */
572 static void
573 ptsstart(struct tty *tp)
574 {
575         struct pt_ioctl *pti = tp->t_dev->si_drv1;
576
577         lwkt_gettoken(&pti->pt_tty.t_token);
578         lwkt_gettoken(&tp->t_token);
579         if (tp->t_state & TS_TTSTOP) {
580                 lwkt_reltoken(&tp->t_token);
581                 lwkt_reltoken(&pti->pt_tty.t_token);
582                 return;
583         }
584         if (pti) {
585                 if (pti->pt_flags & PF_STOPPED) {
586                         pti->pt_flags &= ~PF_STOPPED;
587                         pti->pt_send = TIOCPKT_START;
588                 }
589         }
590         ptcwakeup(tp, FREAD);
591         lwkt_reltoken(&tp->t_token);
592         lwkt_reltoken(&pti->pt_tty.t_token);
593 }
594
595 /*
596  * NOTE: Must be called with tp->t_token held
597  */
598 static void
599 ptcwakeup(struct tty *tp, int flag)
600 {
601         if (flag & FREAD) {
602                 wakeup(TSA_PTC_READ(tp));
603                 KNOTE(&tp->t_rkq.ki_note, 0);
604         }
605         if (flag & FWRITE) {
606                 wakeup(TSA_PTC_WRITE(tp));
607                 KNOTE(&tp->t_wkq.ki_note, 0);
608         }
609 }
610
611 static  int
612 ptcopen(struct dev_open_args *ap)
613 {
614         cdev_t dev = ap->a_head.a_dev;
615         struct tty *tp;
616         struct pt_ioctl *pti;
617
618         /*
619          * The pti will already be assigned by the clone code or
620          * pre-created if a non-unix 98 pty.  If si_drv1 is NULL
621          * we are somehow racing a unix98 termination.
622          */
623         pti = dev->si_drv1;
624         if (pti == NULL)
625                 return(ENXIO);
626
627         lwkt_gettoken(&pti->pt_tty.t_token);
628         if (pti_hold(pti)) {
629                 lwkt_reltoken(&pti->pt_tty.t_token);
630                 return(ENXIO);
631         }
632         if (pti->pt_prison && pti->pt_prison != ap->a_cred->cr_prison) {
633                 pti_done(pti);
634                 lwkt_reltoken(&pti->pt_tty.t_token);
635                 return(EBUSY);
636         }
637         tp = dev->si_tty;
638         lwkt_gettoken(&tp->t_token);
639         if (tp->t_oproc) {
640                 pti_done(pti);
641                 lwkt_reltoken(&tp->t_token);
642                 lwkt_reltoken(&pti->pt_tty.t_token);
643                 return (EIO);
644         }
645
646         /*
647          * If the slave side is not yet open clear any left over zombie
648          * state before doing our modem control.
649          */
650         if ((pti->pt_flags & PF_SOPEN) == 0)
651                 tp->t_state &= ~TS_ZOMBIE;
652
653         tp->t_oproc = ptsstart;
654         tp->t_stop = ptsstop;
655         tp->t_unhold = ptsunhold;
656
657         /*
658          * Carrier on!
659          */
660         (void)(*linesw[tp->t_line].l_modem)(tp, 1);
661
662         tp->t_lflag &= ~EXTPROC;
663         pti->pt_prison = ap->a_cred->cr_prison;
664         pti->pt_flags &= ~PF_PTCSTATEMASK;
665         pti->pt_send = 0;
666         pti->pt_ucntl = 0;
667
668         pti->devs->si_uid = ap->a_cred->cr_uid;
669         pti->devs->si_gid = 0;
670         pti->devs->si_perms = 0600;
671         pti->devc->si_uid = ap->a_cred->cr_uid;
672         pti->devc->si_gid = 0;
673         pti->devc->si_perms = 0600;
674
675         /*
676          * Mark master side open.  This does not cause any events
677          * on the slave side.
678          */
679         pti->pt_flags |= PF_MOPEN;
680         pti_done(pti);
681
682         lwkt_reltoken(&tp->t_token);
683         lwkt_reltoken(&pti->pt_tty.t_token);
684
685         return (0);
686 }
687
688 static  int
689 ptcclose(struct dev_close_args *ap)
690 {
691         cdev_t dev = ap->a_head.a_dev;
692         struct tty *tp;
693         struct pt_ioctl *pti = dev->si_drv1;
694
695         lwkt_gettoken(&pti->pt_tty.t_token);
696         if (pti_hold(pti)) {
697                 lwkt_reltoken(&pti->pt_tty.t_token);
698                 panic("ptcclose on terminated pti");
699         }
700         tp = dev->si_tty;
701         lwkt_gettoken(&tp->t_token);
702
703         (void)(*linesw[tp->t_line].l_modem)(tp, 0);
704
705         /*
706          * Mark the master side closed.  If the slave is still open
707          * mark the tty ZOMBIE, preventing any new action until both
708          * sides have closed.
709          *
710          * NOTE: The ttyflush() will wake up the slave once we've
711          *       set appropriate flags.  The ZOMBIE flag will be
712          *       cleared when the slave side is closed.
713          */
714         pti->pt_flags &= ~PF_MOPEN;
715         if (pti->pt_flags & PF_SOPEN)
716                 tp->t_state |= TS_ZOMBIE;
717
718         /*
719          * Turn off the carrier and disconnect.  This will notify the slave
720          * side.
721          */
722         if (tp->t_state & TS_ISOPEN) {
723                 tp->t_state &= ~(TS_CARR_ON | TS_CONNECTED);
724                 ttyflush(tp, FREAD | FWRITE);
725         }
726         tp->t_oproc = NULL;             /* mark closed */
727
728         pti->pt_prison = NULL;
729         pti->devs->si_uid = 0;
730         pti->devs->si_gid = 0;
731         pti->devs->si_perms = 0666;
732         pti->devc->si_uid = 0;
733         pti->devc->si_gid = 0;
734         pti->devc->si_perms = 0666;
735
736         pti_done(pti);
737         lwkt_reltoken(&tp->t_token);
738         lwkt_reltoken(&pti->pt_tty.t_token);
739
740         return (0);
741 }
742
743 static  int
744 ptcread(struct dev_read_args *ap)
745 {
746         cdev_t dev = ap->a_head.a_dev;
747         struct tty *tp = dev->si_tty;
748         struct pt_ioctl *pti = dev->si_drv1;
749         char buf[BUFSIZ];
750         int error = 0, cc;
751
752         lwkt_gettoken(&pti->pt_tty.t_token);
753         lwkt_gettoken(&tp->t_token);
754
755         /*
756          * We want to block until the slave
757          * is open, and there's something to read;
758          * but if we lost the slave or we're NBIO,
759          * then return the appropriate error instead.
760          */
761         for (;;) {
762                 if (tp->t_state&TS_ISOPEN) {
763                         if ((pti->pt_flags & PF_PKT) && pti->pt_send) {
764                                 error = ureadc((int)pti->pt_send, ap->a_uio);
765                                 if (error) {
766                                         lwkt_reltoken(&tp->t_token);
767                                         lwkt_reltoken(&pti->pt_tty.t_token);
768                                         return (error);
769                                 }
770                                 if (pti->pt_send & TIOCPKT_IOCTL) {
771                                         cc = (int)szmin(ap->a_uio->uio_resid,
772                                                         sizeof(tp->t_termios));
773                                         uiomove((caddr_t)&tp->t_termios, cc,
774                                                 ap->a_uio);
775                                 }
776                                 pti->pt_send = 0;
777                                 lwkt_reltoken(&tp->t_token);
778                                 lwkt_reltoken(&pti->pt_tty.t_token);
779
780                                 return (0);
781                         }
782                         if ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl) {
783                                 error = ureadc((int)pti->pt_ucntl, ap->a_uio);
784                                 if (error) {
785                                         lwkt_reltoken(&tp->t_token);
786                                         lwkt_reltoken(&pti->pt_tty.t_token);
787                                         return (error);
788                                 }
789                                 pti->pt_ucntl = 0;
790                                 lwkt_reltoken(&tp->t_token);
791                                 lwkt_reltoken(&pti->pt_tty.t_token);
792
793                                 return (0);
794                         }
795                         if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0)
796                                 break;
797                 }
798                 if ((tp->t_state & TS_CONNECTED) == 0) {
799                         lwkt_reltoken(&tp->t_token);
800                         lwkt_reltoken(&pti->pt_tty.t_token);
801                         return (0);     /* EOF */
802                 }
803                 if (ap->a_ioflag & IO_NDELAY) {
804                         lwkt_reltoken(&tp->t_token);
805                         lwkt_reltoken(&pti->pt_tty.t_token);
806                         return (EWOULDBLOCK);
807                 }
808                 error = tsleep(TSA_PTC_READ(tp), PCATCH, "ptcin", 0);
809                 if (error) {
810                         lwkt_reltoken(&tp->t_token);
811                         lwkt_reltoken(&pti->pt_tty.t_token);
812                         return (error);
813                 }
814         }
815         if (pti->pt_flags & (PF_PKT|PF_UCNTL))
816                 error = ureadc(0, ap->a_uio);
817         while (ap->a_uio->uio_resid > 0 && error == 0) {
818                 cc = q_to_b(&tp->t_outq, buf,
819                             (int)szmin(ap->a_uio->uio_resid, BUFSIZ));
820                 if (cc <= 0)
821                         break;
822                 error = uiomove(buf, (size_t)cc, ap->a_uio);
823         }
824         ttwwakeup(tp);
825         lwkt_reltoken(&tp->t_token);
826         lwkt_reltoken(&pti->pt_tty.t_token);
827
828         return (error);
829 }
830
831 static  void
832 ptsstop(struct tty *tp, int flush)
833 {
834         struct pt_ioctl *pti = tp->t_dev->si_drv1;
835         int flag;
836
837         lwkt_gettoken(&pti->pt_tty.t_token);
838         /* note: FLUSHREAD and FLUSHWRITE already ok */
839         if (pti) {
840                 if (flush == 0) {
841                         flush = TIOCPKT_STOP;
842                         pti->pt_flags |= PF_STOPPED;
843                 } else {
844                         pti->pt_flags &= ~PF_STOPPED;
845                 }
846                 pti->pt_send |= flush;
847                 /* change of perspective */
848         }
849         flag = 0;
850         if (flush & FREAD)
851                 flag |= FWRITE;
852         if (flush & FWRITE)
853                 flag |= FREAD;
854         ptcwakeup(tp, flag);
855
856         lwkt_reltoken(&pti->pt_tty.t_token);
857 }
858
859 /*
860  * ttyunhold() calls us instead of just decrementing tp->t_refs.  This
861  * is needed because a session can hold onto a pts (half closed state)
862  * even if there are no live file descriptors.  Without the callback
863  * we can't clean up.
864  */
865 static  void
866 ptsunhold(struct tty *tp)
867 {
868         struct pt_ioctl *pti = tp->t_dev->si_drv1;
869
870         lwkt_gettoken(&pti->pt_tty.t_token);
871         lwkt_gettoken(&tp->t_token);
872         pti_hold(pti);
873         --tp->t_refs;
874         pti_done(pti);
875         lwkt_reltoken(&tp->t_token);
876         lwkt_reltoken(&pti->pt_tty.t_token);
877 }
878
879 /*
880  * kqueue ops for pseudo-terminals.
881  */
882 static struct filterops ptcread_filtops =
883         { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ptcrdetach, filt_ptcread };
884 static struct filterops ptcwrite_filtops =
885         { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ptcwdetach, filt_ptcwrite };
886
887 static  int
888 ptckqfilter(struct dev_kqfilter_args *ap)
889 {
890         cdev_t dev = ap->a_head.a_dev;
891         struct knote *kn = ap->a_kn;
892         struct tty *tp = dev->si_tty;
893         struct klist *klist;
894
895         ap->a_result = 0;
896         switch (kn->kn_filter) {
897         case EVFILT_READ:
898                 klist = &tp->t_rkq.ki_note;
899                 kn->kn_fop = &ptcread_filtops;
900                 break;
901         case EVFILT_WRITE:
902                 klist = &tp->t_wkq.ki_note;
903                 kn->kn_fop = &ptcwrite_filtops;
904                 break;
905         default:
906                 ap->a_result = EOPNOTSUPP;
907                 return (0);
908         }
909
910         kn->kn_hook = (caddr_t)dev;
911         knote_insert(klist, kn);
912         return (0);
913 }
914
915 static int
916 filt_ptcread (struct knote *kn, long hint)
917 {
918         struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
919         struct pt_ioctl *pti = ((cdev_t)kn->kn_hook)->si_drv1;
920
921         lwkt_gettoken(&pti->pt_tty.t_token);
922         lwkt_gettoken(&tp->t_token);
923
924         if ((tp->t_state & TS_ZOMBIE) || (pti->pt_flags & PF_SCLOSED)) {
925                 kn->kn_flags |= (EV_EOF | EV_NODATA);
926                 lwkt_reltoken(&tp->t_token);
927                 lwkt_reltoken(&pti->pt_tty.t_token);
928                 return (1);
929         }
930
931         if ((tp->t_state & TS_ISOPEN) &&
932             ((tp->t_outq.c_cc && (tp->t_state & TS_TTSTOP) == 0) ||
933              ((pti->pt_flags & PF_PKT) && pti->pt_send) ||
934              ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))) {
935                 kn->kn_data = tp->t_outq.c_cc;
936                 lwkt_reltoken(&tp->t_token);
937                 lwkt_reltoken(&pti->pt_tty.t_token);
938                 return(1);
939         } else {
940                 lwkt_reltoken(&tp->t_token);
941                 lwkt_reltoken(&pti->pt_tty.t_token);
942                 return(0);
943         }
944 }
945
946 static int
947 filt_ptcwrite (struct knote *kn, long hint)
948 {
949         struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
950         struct pt_ioctl *pti = ((cdev_t)kn->kn_hook)->si_drv1;
951
952         lwkt_gettoken(&pti->pt_tty.t_token);
953         lwkt_gettoken(&tp->t_token);
954         if (tp->t_state & TS_ZOMBIE) {
955                 lwkt_reltoken(&tp->t_token);
956                 lwkt_reltoken(&pti->pt_tty.t_token);
957                 kn->kn_flags |= (EV_EOF | EV_NODATA);
958                 return (1);
959         }
960
961         if (tp->t_state & TS_ISOPEN &&
962             ((pti->pt_flags & PF_REMOTE) ?
963              (tp->t_canq.c_cc == 0) :
964              ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG - 2) ||
965               (tp->t_canq.c_cc == 0 && (tp->t_lflag & ICANON))))) {
966                 kn->kn_data = tp->t_canq.c_cc + tp->t_rawq.c_cc;
967                 lwkt_reltoken(&tp->t_token);
968                 lwkt_reltoken(&pti->pt_tty.t_token);
969                 return(1);
970         } else {
971                 lwkt_reltoken(&tp->t_token);
972                 lwkt_reltoken(&pti->pt_tty.t_token);
973                 return(0);
974         }
975         /* NOTREACHED */
976 }
977
978 static void
979 filt_ptcrdetach (struct knote *kn)
980 {
981         struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
982
983         knote_remove(&tp->t_rkq.ki_note, kn);
984 }
985
986 static void
987 filt_ptcwdetach (struct knote *kn)
988 {
989         struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
990
991         knote_remove(&tp->t_wkq.ki_note, kn);
992 }
993
994 /*
995  * I/O ops
996  */
997 static  int
998 ptcwrite(struct dev_write_args *ap)
999 {
1000         cdev_t dev = ap->a_head.a_dev;
1001         struct tty *tp = dev->si_tty;
1002         u_char *cp = NULL;
1003         int cc = 0;
1004         u_char locbuf[BUFSIZ];
1005         int cnt = 0;
1006         struct pt_ioctl *pti = dev->si_drv1;
1007         int error = 0;
1008
1009         lwkt_gettoken(&pti->pt_tty.t_token);
1010         lwkt_gettoken(&tp->t_token);
1011 again:
1012         if ((tp->t_state&TS_ISOPEN) == 0)
1013                 goto block;
1014         if (pti->pt_flags & PF_REMOTE) {
1015                 if (tp->t_canq.c_cc)
1016                         goto block;
1017                 while ((ap->a_uio->uio_resid > 0 || cc > 0) &&
1018                        tp->t_canq.c_cc < TTYHOG - 1) {
1019                         if (cc == 0) {
1020                                 cc = (int)szmin(ap->a_uio->uio_resid, BUFSIZ);
1021                                 cc = imin(cc, TTYHOG - 1 - tp->t_canq.c_cc);
1022                                 cp = locbuf;
1023                                 error = uiomove(cp, (size_t)cc, ap->a_uio);
1024                                 if (error) {
1025                                         lwkt_reltoken(&tp->t_token);
1026                                         lwkt_reltoken(&pti->pt_tty.t_token);
1027                                         return (error);
1028                                 }
1029                                 /* check again for safety */
1030                                 if ((tp->t_state & TS_ISOPEN) == 0) {
1031                                         /* adjust as usual */
1032                                         ap->a_uio->uio_resid += cc;
1033                                         lwkt_reltoken(&tp->t_token);
1034                                         lwkt_reltoken(&pti->pt_tty.t_token);
1035                                         return (EIO);
1036                                 }
1037                         }
1038                         if (cc > 0) {
1039                                 cc = b_to_q((char *)cp, cc, &tp->t_canq);
1040                                 /*
1041                                  * XXX we don't guarantee that the canq size
1042                                  * is >= TTYHOG, so the above b_to_q() may
1043                                  * leave some bytes uncopied.  However, space
1044                                  * is guaranteed for the null terminator if
1045                                  * we don't fail here since (TTYHOG - 1) is
1046                                  * not a multiple of CBSIZE.
1047                                  */
1048                                 if (cc > 0)
1049                                         break;
1050                         }
1051                 }
1052                 /* adjust for data copied in but not written */
1053                 ap->a_uio->uio_resid += cc;
1054                 clist_putc(0, &tp->t_canq);
1055                 ttwakeup(tp);
1056                 wakeup(TSA_PTS_READ(tp));
1057                 lwkt_reltoken(&tp->t_token);
1058                 lwkt_reltoken(&pti->pt_tty.t_token);
1059
1060                 return (0);
1061         }
1062         while (ap->a_uio->uio_resid > 0 || cc > 0) {
1063                 if (cc == 0) {
1064                         cc = (int)szmin(ap->a_uio->uio_resid, BUFSIZ);
1065                         cp = locbuf;
1066                         error = uiomove(cp, (size_t)cc, ap->a_uio);
1067                         if (error) {
1068                                 lwkt_reltoken(&tp->t_token);
1069                                 lwkt_reltoken(&pti->pt_tty.t_token);
1070                                 return (error);
1071                         }
1072                         /* check again for safety */
1073                         if ((tp->t_state & TS_ISOPEN) == 0) {
1074                                 /* adjust for data copied in but not written */
1075                                 ap->a_uio->uio_resid += cc;
1076                                 lwkt_reltoken(&tp->t_token);
1077                                 lwkt_reltoken(&pti->pt_tty.t_token);
1078                                 return (EIO);
1079                         }
1080                 }
1081                 while (cc > 0) {
1082                         if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 &&
1083                            (tp->t_canq.c_cc > 0 || !(tp->t_lflag&ICANON))) {
1084                                 wakeup(TSA_HUP_OR_INPUT(tp));
1085                                 goto block;
1086                         }
1087                         (*linesw[tp->t_line].l_rint)(*cp++, tp);
1088                         cnt++;
1089                         cc--;
1090                 }
1091                 cc = 0;
1092         }
1093         lwkt_reltoken(&tp->t_token);
1094         lwkt_reltoken(&pti->pt_tty.t_token);
1095         return (0);
1096 block:
1097         /*
1098          * Come here to wait for slave to open, for space
1099          * in outq, or space in rawq, or an empty canq.
1100          */
1101         if ((tp->t_state & TS_CONNECTED) == 0) {
1102                 /* adjust for data copied in but not written */
1103                 ap->a_uio->uio_resid += cc;
1104                 lwkt_reltoken(&tp->t_token);
1105                 lwkt_reltoken(&pti->pt_tty.t_token);
1106                 return (EIO);
1107         }
1108         if (ap->a_ioflag & IO_NDELAY) {
1109                 /* adjust for data copied in but not written */
1110                 ap->a_uio->uio_resid += cc;
1111                 if (cnt == 0) {
1112                         lwkt_reltoken(&tp->t_token);
1113                         lwkt_reltoken(&pti->pt_tty.t_token);
1114                         return (EWOULDBLOCK);
1115                 }
1116                 lwkt_reltoken(&tp->t_token);
1117                 lwkt_reltoken(&pti->pt_tty.t_token);
1118                 return (0);
1119         }
1120         error = tsleep(TSA_PTC_WRITE(tp), PCATCH, "ptcout", 0);
1121         if (error) {
1122                 /* adjust for data copied in but not written */
1123                 ap->a_uio->uio_resid += cc;
1124                 lwkt_reltoken(&tp->t_token);
1125                 lwkt_reltoken(&pti->pt_tty.t_token);
1126                 return (error);
1127         }
1128         goto again;
1129 }
1130
1131 /*ARGSUSED*/
1132 static  int
1133 ptyioctl(struct dev_ioctl_args *ap)
1134 {
1135         cdev_t dev = ap->a_head.a_dev;
1136         struct tty *tp = dev->si_tty;
1137         struct pt_ioctl *pti = dev->si_drv1;
1138         u_char *cc = tp->t_cc;
1139         int stop, error;
1140
1141         lwkt_gettoken(&pti->pt_tty.t_token);
1142         lwkt_gettoken(&tp->t_token);
1143
1144         if (dev_dflags(dev) & D_MASTER) {
1145                 switch (ap->a_cmd) {
1146
1147                 case TIOCGPGRP:
1148                         /*
1149                          * We avoid calling ttioctl on the controller since,
1150                          * in that case, tp must be the controlling terminal.
1151                          */
1152                         *(int *)ap->a_data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;
1153                         lwkt_reltoken(&tp->t_token);
1154                         lwkt_reltoken(&pti->pt_tty.t_token);
1155                         return (0);
1156
1157                 case TIOCPKT:
1158                         if (*(int *)ap->a_data) {
1159                                 if (pti->pt_flags & PF_UCNTL) {
1160                                         lwkt_reltoken(&tp->t_token);
1161                                         lwkt_reltoken(&pti->pt_tty.t_token);
1162                                         return (EINVAL);
1163                                 }
1164                                 pti->pt_flags |= PF_PKT;
1165                         } else {
1166                                 pti->pt_flags &= ~PF_PKT;
1167                         }
1168                         lwkt_reltoken(&tp->t_token);
1169                         lwkt_reltoken(&pti->pt_tty.t_token);
1170                         return (0);
1171
1172                 case TIOCUCNTL:
1173                         if (*(int *)ap->a_data) {
1174                                 if (pti->pt_flags & PF_PKT) {
1175                                         lwkt_reltoken(&tp->t_token);
1176                                         lwkt_reltoken(&pti->pt_tty.t_token);
1177                                         return (EINVAL);
1178                                 }
1179                                 pti->pt_flags |= PF_UCNTL;
1180                         } else {
1181                                 pti->pt_flags &= ~PF_UCNTL;
1182                         }
1183                         lwkt_reltoken(&tp->t_token);
1184                         lwkt_reltoken(&pti->pt_tty.t_token);
1185                         return (0);
1186
1187                 case TIOCREMOTE:
1188                         if (*(int *)ap->a_data)
1189                                 pti->pt_flags |= PF_REMOTE;
1190                         else
1191                                 pti->pt_flags &= ~PF_REMOTE;
1192                         ttyflush(tp, FREAD|FWRITE);
1193                         lwkt_reltoken(&tp->t_token);
1194                         lwkt_reltoken(&pti->pt_tty.t_token);
1195                         return (0);
1196
1197                 case TIOCISPTMASTER:
1198                         if ((pti->pt_flags & PF_UNIX98) &&
1199                             (pti->devc == dev)) {
1200                                 lwkt_reltoken(&tp->t_token);
1201                                 lwkt_reltoken(&pti->pt_tty.t_token);
1202                                 return (0);
1203                         } else {
1204                                 lwkt_reltoken(&tp->t_token);
1205                                 lwkt_reltoken(&pti->pt_tty.t_token);
1206                                 return (EINVAL);
1207                         }
1208                 }
1209
1210                 /*
1211                  * The rest of the ioctls shouldn't be called until 
1212                  * the slave is open.
1213                  */
1214                 if ((tp->t_state & TS_ISOPEN) == 0) {
1215                         lwkt_reltoken(&tp->t_token);
1216                         lwkt_reltoken(&pti->pt_tty.t_token);
1217                         return (EAGAIN);
1218                 }
1219
1220                 switch (ap->a_cmd) {
1221                 case TIOCSETD:
1222                 case TIOCSETA:
1223                 case TIOCSETAW:
1224                 case TIOCSETAF:
1225                         /*
1226                          * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG.
1227                          * ttywflush(tp) will hang if there are characters in
1228                          * the outq.
1229                          */
1230                         ndflush(&tp->t_outq, tp->t_outq.c_cc);
1231                         break;
1232
1233                 case TIOCSIG:
1234                         if (*(unsigned int *)ap->a_data >= NSIG ||
1235                             *(unsigned int *)ap->a_data == 0) {
1236                                 lwkt_reltoken(&tp->t_token);
1237                                 lwkt_reltoken(&pti->pt_tty.t_token);
1238                                 return(EINVAL);
1239                         }
1240                         if ((tp->t_lflag&NOFLSH) == 0)
1241                                 ttyflush(tp, FREAD|FWRITE);
1242                         pgsignal(tp->t_pgrp, *(unsigned int *)ap->a_data, 1);
1243                         if ((*(unsigned int *)ap->a_data == SIGINFO) &&
1244                             ((tp->t_lflag&NOKERNINFO) == 0))
1245                                 ttyinfo(tp);
1246                         lwkt_reltoken(&tp->t_token);
1247                         lwkt_reltoken(&pti->pt_tty.t_token);
1248                         return(0);
1249                 }
1250         }
1251         if (ap->a_cmd == TIOCEXT) {
1252                 /*
1253                  * When the EXTPROC bit is being toggled, we need
1254                  * to send an TIOCPKT_IOCTL if the packet driver
1255                  * is turned on.
1256                  */
1257                 if (*(int *)ap->a_data) {
1258                         if (pti->pt_flags & PF_PKT) {
1259                                 pti->pt_send |= TIOCPKT_IOCTL;
1260                                 ptcwakeup(tp, FREAD);
1261                         }
1262                         tp->t_lflag |= EXTPROC;
1263                 } else {
1264                         if ((tp->t_lflag & EXTPROC) &&
1265                             (pti->pt_flags & PF_PKT)) {
1266                                 pti->pt_send |= TIOCPKT_IOCTL;
1267                                 ptcwakeup(tp, FREAD);
1268                         }
1269                         tp->t_lflag &= ~EXTPROC;
1270                 }
1271                 lwkt_reltoken(&tp->t_token);
1272                 lwkt_reltoken(&pti->pt_tty.t_token);
1273                 return(0);
1274         }
1275         error = (*linesw[tp->t_line].l_ioctl)(tp, ap->a_cmd, ap->a_data,
1276                                               ap->a_fflag, ap->a_cred);
1277         if (error == ENOIOCTL)
1278                  error = ttioctl(tp, ap->a_cmd, ap->a_data, ap->a_fflag);
1279         if (error == ENOIOCTL) {
1280                 if (pti->pt_flags & PF_UCNTL &&
1281                     (ap->a_cmd & ~0xff) == UIOCCMD(0)) {
1282                         if (ap->a_cmd & 0xff) {
1283                                 pti->pt_ucntl = (u_char)ap->a_cmd;
1284                                 ptcwakeup(tp, FREAD);
1285                         }
1286                         lwkt_reltoken(&tp->t_token);
1287                         lwkt_reltoken(&pti->pt_tty.t_token);
1288                         return (0);
1289                 }
1290                 error = ENOTTY;
1291         }
1292         /*
1293          * If external processing and packet mode send ioctl packet.
1294          */
1295         if ((tp->t_lflag&EXTPROC) && (pti->pt_flags & PF_PKT)) {
1296                 switch(ap->a_cmd) {
1297                 case TIOCSETA:
1298                 case TIOCSETAW:
1299                 case TIOCSETAF:
1300                         pti->pt_send |= TIOCPKT_IOCTL;
1301                         ptcwakeup(tp, FREAD);
1302                 default:
1303                         break;
1304                 }
1305         }
1306         stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s'))
1307                 && CCEQ(cc[VSTART], CTRL('q'));
1308         if (pti->pt_flags & PF_NOSTOP) {
1309                 if (stop) {
1310                         pti->pt_send &= ~TIOCPKT_NOSTOP;
1311                         pti->pt_send |= TIOCPKT_DOSTOP;
1312                         pti->pt_flags &= ~PF_NOSTOP;
1313                         ptcwakeup(tp, FREAD);
1314                 }
1315         } else {
1316                 if (!stop) {
1317                         pti->pt_send &= ~TIOCPKT_DOSTOP;
1318                         pti->pt_send |= TIOCPKT_NOSTOP;
1319                         pti->pt_flags |= PF_NOSTOP;
1320                         ptcwakeup(tp, FREAD);
1321                 }
1322         }
1323         lwkt_reltoken(&tp->t_token);
1324         lwkt_reltoken(&pti->pt_tty.t_token);
1325
1326         return (error);
1327 }
1328
1329
1330 static void ptc_drvinit (void *unused);
1331
1332 SYSCTL_INT(_kern, OID_AUTO, pty_debug, CTLFLAG_RW, &pty_debug_level,
1333                 0, "Change pty debug level");
1334
1335 static void
1336 ptc_drvinit(void *unused)
1337 {
1338         int i;
1339
1340         /*
1341          * Unix98 pty stuff.
1342          * Create the clonable base device.
1343          */
1344         make_autoclone_dev(&ptc_ops, &DEVFS_CLONE_BITMAP(pty), ptyclone,
1345                            0, 0, 0666, "ptmx");
1346         ptis = kmalloc(sizeof(struct pt_ioctl *) * MAXPTYS, M_PTY,
1347                        M_WAITOK | M_ZERO);
1348
1349         for (i = 0; i < 256; i++) {
1350                 ptyinit(i);
1351         }
1352 }
1353
1354 SYSINIT(ptcdev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE + CDEV_MAJOR_C,
1355         ptc_drvinit, NULL);