proc->thread stage 4: rework the VFS and DEVICE subsystems to take thread
[dragonfly.git] / sys / dev / misc / nmdm / nmdm.c
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  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * $FreeBSD: src/sys/dev/nmdm/nmdm.c,v 1.5.2.1 2001/08/11 00:54:14 mp Exp $
34  * $DragonFly: src/sys/dev/misc/nmdm/nmdm.c,v 1.4 2003/06/25 03:55:47 dillon Exp $
35  */
36
37 /*
38  * Pseudo-nulmodem Driver
39  */
40 #include "opt_compat.h"
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
44 #include <sys/ioctl_compat.h>
45 #endif
46 #include <sys/proc.h>
47 #include <sys/tty.h>
48 #include <sys/conf.h>
49 #include <sys/fcntl.h>
50 #include <sys/poll.h>
51 #include <sys/kernel.h>
52 #include <sys/vnode.h>
53 #include <sys/signalvar.h>
54 #include <sys/malloc.h>
55
56 MALLOC_DEFINE(M_NLMDM, "nullmodem", "nullmodem data structures");
57
58 static void nmdmstart __P((struct tty *tp));
59 static void nmdmstop __P((struct tty *tp, int rw));
60 static void wakeup_other __P((struct tty *tp, int flag));
61 static void nmdminit __P((int n));
62
63 static  d_open_t        nmdmopen;
64 static  d_close_t       nmdmclose;
65 static  d_read_t        nmdmread;
66 static  d_write_t       nmdmwrite;
67 static  d_ioctl_t       nmdmioctl;
68
69 #define CDEV_MAJOR      18
70 static struct cdevsw nmdm_cdevsw = {
71         /* open */      nmdmopen,
72         /* close */     nmdmclose,
73         /* read */      nmdmread,
74         /* write */     nmdmwrite,
75         /* ioctl */     nmdmioctl,
76         /* poll */      ttypoll,
77         /* mmap */      nommap,
78         /* strategy */  nostrategy,
79         /* name */      "pts",
80         /* maj */       CDEV_MAJOR,
81         /* dump */      nodump,
82         /* psize */     nopsize,
83         /* flags */     D_TTY,
84         /* bmaj */      -1
85 };
86
87 #define BUFSIZ 100              /* Chunk size iomoved to/from user */
88
89 struct softpart {
90         struct tty nm_tty;
91         dev_t   dev;
92         int     modemsignals;   /* bits defined in sys/ttycom.h */
93         int     gotbreak;
94 };
95
96 struct  nm_softc {
97         int     pt_flags;
98         struct softpart part1, part2;
99         struct  prison *pt_prison;
100 };
101
102 #define PF_STOPPED      0x10            /* user told stopped */
103
104 static void
105 nmdm_crossover(struct nm_softc *pti,
106                 struct softpart *ourpart,
107                 struct softpart *otherpart);
108
109 #define GETPARTS(tp, ourpart, otherpart) \
110 do {    \
111         struct nm_softc *pti = tp->t_dev->si_drv1; \
112         if (tp == &pti->part1.nm_tty) { \
113                 ourpart = &pti->part1; \
114                 otherpart = &pti->part2; \
115         } else { \
116                 ourpart = &pti->part2; \
117                 otherpart = &pti->part1; \
118         }  \
119 } while (0)
120
121 /*
122  * This function creates and initializes a pair of ttys.
123  */
124 static void
125 nmdminit(n)
126         int n;
127 {
128         dev_t dev1, dev2;
129         struct nm_softc *pt;
130
131         /* For now we only map the lower 8 bits of the minor */
132         if (n & ~0xff)
133                 return;
134
135         pt = malloc(sizeof(*pt), M_NLMDM, M_WAITOK);
136         bzero(pt, sizeof(*pt));
137         pt->part1.dev = dev1 = make_dev(&nmdm_cdevsw, n+n,
138             0, 0, 0666, "nmdm%dA", n);
139         pt->part2.dev = dev2 = make_dev(&nmdm_cdevsw, n+n+1,
140             0, 0, 0666, "nmdm%dB", n);
141
142         dev1->si_drv1 = dev2->si_drv1 = pt;
143         dev1->si_tty = &pt->part1.nm_tty;
144         dev2->si_tty = &pt->part2.nm_tty;
145         ttyregister(&pt->part1.nm_tty);
146         ttyregister(&pt->part2.nm_tty);
147         pt->part1.nm_tty.t_oproc = nmdmstart;
148         pt->part2.nm_tty.t_oproc = nmdmstart;
149         pt->part1.nm_tty.t_stop = nmdmstop;
150         pt->part2.nm_tty.t_dev = dev1;
151         pt->part1.nm_tty.t_dev = dev2;
152         pt->part2.nm_tty.t_stop = nmdmstop;
153 }
154
155 /*ARGSUSED*/
156 static  int
157 nmdmopen(dev_t dev, int flag, int devtype, struct thread *td)
158 {
159         struct proc *p = td->td_proc;
160         struct tty *tp, *tp2;
161         int error;
162         int minr;
163         dev_t nextdev;
164         struct nm_softc *pti;
165         int is_b;
166         int     pair;
167         struct  softpart *ourpart, *otherpart;
168
169         KKASSERT(p != NULL);
170
171         /*
172          * XXX: Gross hack for DEVFS:
173          * If we openned this device, ensure we have the
174          * next one too, so people can open it.
175          */
176         minr = lminor(dev);
177         pair = minr >> 1;
178         is_b = minr & 1;
179         
180         if (pair < 127) {
181                 nextdev = makedev(major(dev), (pair+pair) + 1);
182                 if (!nextdev->si_drv1) {
183                         nmdminit(pair + 1);
184                 }
185         }
186         if (!dev->si_drv1)
187                 nmdminit(pair);
188
189         if (!dev->si_drv1)
190                 return(ENXIO);  
191
192         pti = dev->si_drv1;
193         if (is_b) 
194                 tp = &pti->part2.nm_tty;
195         else 
196                 tp = &pti->part1.nm_tty;
197         GETPARTS(tp, ourpart, otherpart);
198         tp2 = &otherpart->nm_tty;
199         ourpart->modemsignals |= TIOCM_LE;
200
201         if ((tp->t_state & TS_ISOPEN) == 0) {
202                 ttychars(tp);           /* Set up default chars */
203                 tp->t_iflag = TTYDEF_IFLAG;
204                 tp->t_oflag = TTYDEF_OFLAG;
205                 tp->t_lflag = TTYDEF_LFLAG;
206                 tp->t_cflag = TTYDEF_CFLAG;
207                 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
208         } else if (tp->t_state & TS_XCLUDE && suser(td)) {
209                 return (EBUSY);
210         } else if (pti->pt_prison != p->p_ucred->cr_prison) {
211                 return (EBUSY);
212         }
213
214         /*
215          * If the other side is open we have carrier
216          */
217         if (tp2->t_state & TS_ISOPEN) {
218                 (void)(*linesw[tp->t_line].l_modem)(tp, 1);
219         }
220
221         /*
222          * And the other side gets carrier as we are now open.
223          */
224         (void)(*linesw[tp2->t_line].l_modem)(tp2, 1);
225
226         /* External processing makes no sense here */
227         tp->t_lflag &= ~EXTPROC;
228
229         /* 
230          * Wait here if we don't have carrier.
231          */
232 #if 0
233         while ((tp->t_state & TS_CARR_ON) == 0) {
234                 if (flag & FNONBLOCK)
235                         break;
236                 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH,
237                                  "nmdopn", 0);
238                 if (error)
239                         return (error);
240         }
241 #endif
242
243         /*
244          * Give the line disciplin a chance to set this end up.
245          */
246         error = (*linesw[tp->t_line].l_open)(dev, tp);
247
248         /*
249          * Wake up the other side.
250          * Theoretically not needed.
251          */
252         ourpart->modemsignals |= TIOCM_DTR;
253         nmdm_crossover(pti, ourpart, otherpart);
254         if (error == 0)
255                 wakeup_other(tp, FREAD|FWRITE); /* XXX */
256         return (error);
257 }
258
259 static  int
260 nmdmclose(dev_t dev, int flag, int mode, struct thread *td)
261 {
262         register struct tty *tp, *tp2;
263         int err;
264         struct softpart *ourpart, *otherpart;
265
266         /*
267          * let the other end know that the game is up
268          */
269         tp = dev->si_tty;
270         GETPARTS(tp, ourpart, otherpart);
271         tp2 = &otherpart->nm_tty;
272         (void)(*linesw[tp2->t_line].l_modem)(tp2, 0);
273
274         /*
275          * XXX MDMBUF makes no sense for nmdms but would inhibit the above
276          * l_modem().  CLOCAL makes sense but isn't supported.   Special
277          * l_modem()s that ignore carrier drop make no sense for nmdms but
278          * may be in use because other parts of the line discipline make
279          * sense for nmdms.  Recover by doing everything that a normal
280          * ttymodem() would have done except for sending a SIGHUP.
281          */
282         if (tp2->t_state & TS_ISOPEN) {
283                 tp2->t_state &= ~(TS_CARR_ON | TS_CONNECTED);
284                 tp2->t_state |= TS_ZOMBIE;
285                 ttyflush(tp2, FREAD | FWRITE);
286         }
287
288         err = (*linesw[tp->t_line].l_close)(tp, flag);
289         ourpart->modemsignals &= ~TIOCM_DTR;
290         nmdm_crossover(dev->si_drv1, ourpart, otherpart);
291         nmdmstop(tp, FREAD|FWRITE);
292         (void) ttyclose(tp);
293         return (err);
294 }
295
296 static  int
297 nmdmread(dev, uio, flag)
298         dev_t dev;
299         struct uio *uio;
300         int flag;
301 {
302         int error = 0;
303         struct tty *tp, *tp2;
304         struct softpart *ourpart, *otherpart;
305
306         tp = dev->si_tty;
307         GETPARTS(tp, ourpart, otherpart);
308         tp2 = &otherpart->nm_tty;
309
310 #if 0
311         if (tp2->t_state & TS_ISOPEN) {
312                 error = (*linesw[tp->t_line].l_read)(tp, uio, flag);
313                 wakeup_other(tp, FWRITE);
314         } else {
315                 if (flag & IO_NDELAY) {
316                         return (EWOULDBLOCK);
317                 }
318                 error = tsleep(TSA_PTC_READ(tp),
319                                 TTIPRI | PCATCH, "nmdout", 0);
320                 }
321         }
322 #else
323         if ((error = (*linesw[tp->t_line].l_read)(tp, uio, flag)) == 0)
324                 wakeup_other(tp, FWRITE);
325 #endif
326         return (error);
327 }
328
329 /*
330  * Write to pseudo-tty.
331  * Wakeups of controlling tty will happen
332  * indirectly, when tty driver calls nmdmstart.
333  */
334 static  int
335 nmdmwrite(dev, uio, flag)
336         dev_t dev;
337         struct uio *uio;
338         int flag;
339 {
340         register u_char *cp = 0;
341         register int cc = 0;
342         u_char locbuf[BUFSIZ];
343         int cnt = 0;
344         int error = 0;
345         struct tty *tp1, *tp;
346         struct softpart *ourpart, *otherpart;
347
348         tp1 = dev->si_tty;
349         /*
350          * Get the other tty struct.
351          * basically we are writing into the INPUT side of the other device.
352          */
353         GETPARTS(tp1, ourpart, otherpart);
354         tp = &otherpart->nm_tty;
355
356 again:
357         if ((tp->t_state & TS_ISOPEN) == 0) 
358                 return (EIO);
359         while (uio->uio_resid > 0 || cc > 0) {
360                 /*
361                  * Fill up the buffer if it's empty
362                  */
363                 if (cc == 0) {
364                         cc = min(uio->uio_resid, BUFSIZ);
365                         cp = locbuf;
366                         error = uiomove((caddr_t)cp, cc, uio);
367                         if (error)
368                                 return (error);
369                         /* check again for safety */
370                         if ((tp->t_state & TS_ISOPEN) == 0) {
371                                 /* adjust for data copied in but not written */
372                                 uio->uio_resid += cc;
373                                 return (EIO);
374                         }
375                 }
376                 while (cc > 0) {
377                         if (((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= (TTYHOG-2))
378                         && ((tp->t_canq.c_cc > 0) || !(tp->t_iflag&ICANON))) {
379                                 /*
380                                  * Come here to wait for space in outq,
381                                  * or space in rawq, or an empty canq.
382                                  */
383                                 wakeup(TSA_HUP_OR_INPUT(tp));
384                                 if ((tp->t_state & TS_CONNECTED) == 0) {
385                                         /*
386                                          * Data piled up because not connected.
387                                          * Adjust for data copied in but
388                                          * not written.
389                                          */
390                                         uio->uio_resid += cc;
391                                         return (EIO);
392                                 }
393                                 if (flag & IO_NDELAY) {
394                                         /*
395                                          * Don't wait if asked not to.
396                                          * Adjust for data copied in but
397                                          * not written.
398                                          */
399                                         uio->uio_resid += cc;
400                                         if (cnt == 0)
401                                                 return (EWOULDBLOCK);
402                                         return (0);
403                                 }
404                                 error = tsleep(TSA_PTC_WRITE(tp),
405                                                 TTOPRI | PCATCH, "nmdout", 0);
406                                 if (error) {
407                                         /*
408                                          * Tsleep returned (signal?).
409                                          * Go find out what the user wants.
410                                          * adjust for data copied in but
411                                          * not written
412                                          */
413                                         uio->uio_resid += cc;
414                                         return (error);
415                                 }
416                                 goto again;
417                         }
418                         (*linesw[tp->t_line].l_rint)(*cp++, tp);
419                         cnt++;
420                         cc--;
421                 }
422                 cc = 0;
423         }
424         return (0);
425 }
426
427 /*
428  * Start output on pseudo-tty.
429  * Wake up process selecting or sleeping for input from controlling tty.
430  */
431 static void
432 nmdmstart(tp)
433         struct tty *tp;
434 {
435         register struct nm_softc *pti = tp->t_dev->si_drv1;
436
437         if (tp->t_state & TS_TTSTOP)
438                 return;
439         pti->pt_flags &= ~PF_STOPPED;
440         wakeup_other(tp, FREAD);
441 }
442
443 /* Wakes up the OTHER tty;*/
444 static void
445 wakeup_other(tp, flag)
446         struct tty *tp;
447         int flag;
448 {
449         struct softpart *ourpart, *otherpart;
450
451         GETPARTS(tp, ourpart, otherpart);
452         if (flag & FREAD) {
453                 selwakeup(&otherpart->nm_tty.t_rsel);
454                 wakeup(TSA_PTC_READ((&otherpart->nm_tty)));
455         }
456         if (flag & FWRITE) {
457                 selwakeup(&otherpart->nm_tty.t_wsel);
458                 wakeup(TSA_PTC_WRITE((&otherpart->nm_tty)));
459         }
460 }
461
462 static  void
463 nmdmstop(tp, flush)
464         register struct tty *tp;
465         int flush;
466 {
467         struct nm_softc *pti = tp->t_dev->si_drv1;
468         int flag;
469
470         /* note: FLUSHREAD and FLUSHWRITE already ok */
471         if (flush == 0) {
472                 flush = TIOCPKT_STOP;
473                 pti->pt_flags |= PF_STOPPED;
474         } else
475                 pti->pt_flags &= ~PF_STOPPED;
476         /* change of perspective */
477         flag = 0;
478         if (flush & FREAD)
479                 flag |= FWRITE;
480         if (flush & FWRITE)
481                 flag |= FREAD;
482         wakeup_other(tp, flag);
483 }
484
485 /*ARGSUSED*/
486 static  int
487 nmdmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)
488 {
489         register struct tty *tp = dev->si_tty;
490         struct nm_softc *pti = dev->si_drv1;
491         int error, s;
492         register struct tty *tp2;
493         struct softpart *ourpart, *otherpart;
494
495         s = spltty();
496         GETPARTS(tp, ourpart, otherpart);
497         tp2 = &otherpart->nm_tty;
498
499         error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, td);
500         if (error == ENOIOCTL)
501                  error = ttioctl(tp, cmd, data, flag);
502         if (error == ENOIOCTL) {
503                 switch (cmd) {
504                 case TIOCSBRK:
505                         otherpart->gotbreak = 1;
506                         break;
507                 case TIOCCBRK:
508                         break;
509                 case TIOCSDTR:
510                         ourpart->modemsignals |= TIOCM_DTR;
511                         break;
512                 case TIOCCDTR:
513                         ourpart->modemsignals &= TIOCM_DTR;
514                         break;
515                 case TIOCMSET:
516                         ourpart->modemsignals = *(int *)data;
517                         otherpart->modemsignals = *(int *)data;
518                         break;
519                 case TIOCMBIS:
520                         ourpart->modemsignals |= *(int *)data;
521                         break;
522                 case TIOCMBIC:
523                         ourpart->modemsignals &= ~(*(int *)data);
524                         otherpart->modemsignals &= ~(*(int *)data);
525                         break;
526                 case TIOCMGET:
527                         *(int *)data = ourpart->modemsignals;
528                         break;
529                 case TIOCMSDTRWAIT:
530                         break;
531                 case TIOCMGDTRWAIT:
532                         *(int *)data = 0;
533                         break;
534                 case TIOCTIMESTAMP:
535                 case TIOCDCDTIMESTAMP:
536                 default:
537                         splx(s);
538                         error = ENOTTY;
539                         return (error);
540                 }
541                 error = 0;
542                 nmdm_crossover(pti, ourpart, otherpart);
543         }
544         splx(s);
545         return (error);
546 }
547
548 static void
549 nmdm_crossover(struct nm_softc *pti,
550                 struct softpart *ourpart,
551                 struct softpart *otherpart)
552 {
553         otherpart->modemsignals &= ~(TIOCM_CTS|TIOCM_CAR);
554         if (ourpart->modemsignals & TIOCM_RTS)
555                 otherpart->modemsignals |= TIOCM_CTS;
556         if (ourpart->modemsignals & TIOCM_DTR)
557                 otherpart->modemsignals |= TIOCM_CAR;
558 }
559
560
561
562 static void nmdm_drvinit __P((void *unused));
563
564 static void
565 nmdm_drvinit(unused)
566         void *unused;
567 {
568         cdevsw_add(&nmdm_cdevsw);
569         /* XXX: Gross hack for DEVFS */
570         nmdminit(0);
571 }
572
573 SYSINIT(nmdmdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,nmdm_drvinit,NULL)