sys/dev/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  * 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  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 /*
  35  * Pseudo-nulmodem driver
  36  * Mighty handy for use with serial console in Vmware
  37  */
  38
  39 #include "opt_compat.h"
  40 #include "opt_tty.h"
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/proc.h>
  45 #include <sys/tty.h>
  46 #include <sys/conf.h>
  47 #include <sys/fcntl.h>
  48 #include <sys/poll.h>
  49 #include <sys/kernel.h>
  50 #include <sys/module.h>
  51 #include <sys/serial.h>
  52 #include <sys/vnode.h>
  53 #include <sys/signalvar.h>
  54 #include <sys/malloc.h>
  55 #include <sys/taskqueue.h>
  56
  57 MALLOC_DEFINE(M_NLMDM, "nullmodem", "nullmodem data structures");
  58
  59 static void     nmdmstart(struct tty *tp);
  60 static void     nmdmstop(struct tty *tp, int rw);
  61 static void     nmdminit(struct cdev *dev);
  62 static t_modem_t        nmdmmodem;
  63
  64 static d_open_t         nmdmopen;
  65 static d_close_t        nmdmclose;
  66
  67 static struct cdevsw nmdm_cdevsw = {
  68         .d_version =    D_VERSION,
  69         .d_open =       nmdmopen,
  70         .d_close =      nmdmclose,
  71         .d_name =       "nmdn",
  72         .d_flags =      D_TTY | D_PSEUDO | D_NEEDGIANT,
  73 };
  74
  75 #define BUFSIZ          100             /* Chunk size iomoved to/from user */
  76 #define NMDM_MAX_NUM    128             /* Artificially limit # devices. */
  77 #define PF_STOPPED      0x10            /* user told stopped */
  78 #define BFLAG           CLONE_FLAG0
  79
  80 struct softpart {
  81         struct tty              *nm_tty;
  82         struct cdev             *dev;
  83         int                     nm_dcd;
  84         struct task             pt_task;
  85         struct softpart         *other;
  86 };
  87
  88 struct  nm_softc {
  89         TAILQ_ENTRY(nm_softc)   pt_list;
  90         int                     pt_flags;
  91         struct softpart         part1, part2;
  92         struct  prison          *pt_prison;
  93 };
  94
  95 static struct clonedevs *nmdmclones;
  96 static TAILQ_HEAD(,nm_softc) nmdmhead = TAILQ_HEAD_INITIALIZER(nmdmhead);
  97
  98 static void
  99 nmdm_clone(void *arg, char *name, int nameen, struct cdev **dev)
 100 {
 101         int i, unit;
 102         char *p;
 103         struct cdev *d1, *d2;
 104
 105         if (*dev != NULL)
 106                 return;
 107         if (strcmp(name, "nmdm") == 0) {
 108                 p = NULL;
 109                 unit = -1;
 110         } else {
 111                 i = dev_stdclone(name, &p, "nmdm", &unit);
 112                 if (i == 0)
 113                         return;
 114                 if (p[0] != '\0' && p[0] != 'A' && p[0] != 'B')
 115                         return;
 116                 else if (p[0] != '\0' && p[1] != '\0')
 117                         return;
 118         }
 119         i = clone_create(&nmdmclones, &nmdm_cdevsw, &unit, &d1, 0);
 120         if (i) {
 121                 d1 = make_dev(&nmdm_cdevsw, unit2minor(unit),
 122                      0, 0, 0666, "nmdm%dA", unit);
 123                 if (d1 == NULL)
 124                         return;
 125                 d2 = make_dev(&nmdm_cdevsw, unit2minor(unit) | BFLAG,
 126                      0, 0, 0666, "nmdm%dB", unit);
 127                 if (d2 == NULL) {
 128                         destroy_dev(d1);
 129                         return;
 130                 }
 131                 d2->si_drv2 = d1;
 132                 d1->si_drv2 = d2;
 133                 dev_depends(d1, d2);
 134                 dev_depends(d2, d1);
 135                 d1->si_flags |= SI_CHEAPCLONE;
 136                 d2->si_flags |= SI_CHEAPCLONE;
 137         }
 138         if (p != NULL && p[0] == 'B')
 139                 *dev = d1->si_drv2;
 140         else
 141                 *dev = d1;
 142 }
 143
 144 static void
 145 nmdm_task_tty(void *arg, int pending __unused)
 146 {
 147         struct tty *tp, *otp;
 148         struct softpart *sp;
 149         int c;
 150
 151         tp = arg;
 152         sp = tp->t_sc;
 153         otp = sp->other->nm_tty;
 154         KASSERT(otp != NULL, ("NULL otp in nmdmstart"));
 155         KASSERT(otp != tp, ("NULL otp == tp nmdmstart"));
 156         if (sp->other->nm_dcd) {
 157                 if (!(tp->t_state & TS_ISOPEN)) {
 158                         sp->other->nm_dcd = 0;
 159                         (void)ttyld_modem(otp, 0);
 160                 }
 161         } else {
 162                 if (tp->t_state & TS_ISOPEN) {
 163                         sp->other->nm_dcd = 1;
 164                         (void)ttyld_modem(otp, 1);
 165                 }
 166         }
 167         if (tp->t_state & TS_TTSTOP)
 168                 return;
 169         while (tp->t_outq.c_cc != 0) {
 170                 if (otp->t_state & TS_TBLOCK)
 171                         return;
 172                 c = getc(&tp->t_outq);
 173                 if (otp->t_state & TS_ISOPEN)
 174                         ttyld_rint(otp, c);
 175         }
 176         if (tp->t_outq.c_cc == 0)
 177                 ttwwakeup(tp);
 178 }
 179
 180 /*
 181  * This function creates and initializes a pair of ttys.
 182  */
 183 static void
 184 nmdminit(struct cdev *dev1)
 185 {
 186         struct cdev *dev2;
 187         struct nm_softc *pt;
 188
 189         dev2 = dev1->si_drv2;
 190
 191         dev1->si_flags &= ~SI_CHEAPCLONE;
 192         dev2->si_flags &= ~SI_CHEAPCLONE;
 193
 194         pt = malloc(sizeof(*pt), M_NLMDM, M_WAITOK | M_ZERO);
 195         TAILQ_INSERT_TAIL(&nmdmhead, pt, pt_list);
 196
 197         dev1->si_drv1 = dev2->si_drv1 = pt;
 198
 199         pt->part1.dev = dev1;
 200         pt->part2.dev = dev2;
 201
 202         pt->part1.nm_tty = ttymalloc(pt->part1.nm_tty);
 203         pt->part1.nm_tty->t_oproc = nmdmstart;
 204         pt->part1.nm_tty->t_stop = nmdmstop;
 205         pt->part1.nm_tty->t_modem = nmdmmodem;
 206         pt->part1.nm_tty->t_dev = dev1;
 207         pt->part1.nm_tty->t_sc = &pt->part1;
 208         TASK_INIT(&pt->part1.pt_task, 0, nmdm_task_tty, pt->part1.nm_tty);
 209
 210         pt->part2.nm_tty = ttymalloc(pt->part2.nm_tty);
 211         pt->part2.nm_tty->t_oproc = nmdmstart;
 212         pt->part2.nm_tty->t_stop = nmdmstop;
 213         pt->part2.nm_tty->t_modem = nmdmmodem;
 214         pt->part2.nm_tty->t_dev = dev2;
 215         pt->part2.nm_tty->t_sc = &pt->part2;
 216         TASK_INIT(&pt->part2.pt_task, 0, nmdm_task_tty, pt->part2.nm_tty);
 217
 218         pt->part1.other = &pt->part2;
 219         pt->part2.other = &pt->part1;
 220
 221         dev1->si_tty = pt->part1.nm_tty;
 222         dev1->si_drv1 = pt;
 223
 224         dev2->si_tty = pt->part2.nm_tty;
 225         dev2->si_drv1 = pt;
 226 }
 227
 228 /*
 229  * Device opened from userland
 230  */
 231 static  int
 232 nmdmopen(struct cdev *dev, int flag, int devtype, struct thread *td)
 233 {
 234         struct tty *tp, *tp2;
 235         int error;
 236         struct nm_softc *pti;
 237         struct softpart *sp;
 238
 239         if (dev->si_drv1 == NULL)
 240                 nmdminit(dev);
 241         pti = dev->si_drv1;
 242         if (pti->pt_prison != td->td_ucred->cr_prison)
 243                 return (EBUSY);
 244
 245         tp = dev->si_tty;
 246         sp = tp->t_sc;
 247         tp2 = sp->other->nm_tty;
 248
 249         if ((tp->t_state & TS_ISOPEN) == 0) {
 250                 ttychars(tp);           /* Set up default chars */
 251                 tp->t_iflag = TTYDEF_IFLAG;
 252                 tp->t_oflag = TTYDEF_OFLAG;
 253                 tp->t_lflag = TTYDEF_LFLAG;
 254                 tp->t_lflag = 0;
 255                 tp->t_cflag = TTYDEF_CFLAG;
 256                 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
 257                 ttsetwater(tp); /* XXX ? */
 258         } else if (tp->t_state & TS_XCLUDE && suser(td)) {
 259                 return (EBUSY);
 260         }
 261
 262         error = ttyld_open(tp, dev);
 263         return (error);
 264 }
 265
 266 static int
 267 nmdmmodem(struct tty *tp, int sigon, int sigoff)
 268 {
 269         struct softpart *sp;
 270         int i;
 271
 272         sp = tp->t_sc;
 273         if (sigon || sigoff) {
 274                 if (sigon & SER_DTR) {
 275                         sp->other->nm_dcd = 1;
 276                         ttyld_modem(sp->other->nm_tty, sp->other->nm_dcd);
 277                 }
 278                 if (sigoff & SER_DTR) {
 279                         sp->other->nm_dcd = 0;
 280                         ttyld_modem(sp->other->nm_tty, sp->other->nm_dcd);
 281                 }
 282                 return (0);
 283         } else {
 284                 i = 0;
 285                 if (sp->nm_dcd)
 286                         i |= SER_DCD;
 287                 if (sp->other->nm_dcd)
 288                         i |= SER_DTR;
 289                 return (i);
 290         }
 291 }
 292
 293 static int
 294 nmdmclose(struct cdev *dev, int flag, int mode, struct thread *td)
 295 {
 296
 297         return (tty_close(dev->si_tty));
 298 }
 299
 300 static void
 301 nmdmstart(struct tty *tp)
 302 {
 303         struct softpart *pt;
 304
 305         pt = tp->t_sc;
 306         taskqueue_enqueue(taskqueue_swi_giant, &pt->pt_task);
 307 }
 308
 309 static void
 310 nmdmstop(struct tty *tp, int flush)
 311 {
 312         struct softpart *pt;
 313
 314         pt = tp->t_sc;
 315         taskqueue_enqueue(taskqueue_swi_giant, &pt->pt_task);
 316 }
 317
 318 /*
 319  * Module handling
 320  */
 321 static int
 322 nmdm_modevent(module_t mod, int type, void *data)
 323 {
 324         static eventhandler_tag tag;
 325         struct nm_softc *pt, *tpt;
 326         int error = 0;
 327
 328         switch(type) {
 329         case MOD_LOAD:
 330                 clone_setup(&nmdmclones);
 331                 tag = EVENTHANDLER_REGISTER(dev_clone, nmdm_clone, 0, 1000);
 332                 if (tag == NULL)
 333                         return (ENOMEM);
 334                 break;
 335
 336         case MOD_SHUTDOWN:
 337                 /* FALLTHROUGH */
 338         case MOD_UNLOAD:
 339                 EVENTHANDLER_DEREGISTER(dev_clone, tag);
 340                 TAILQ_FOREACH_SAFE(pt, &nmdmhead, pt_list, tpt) {
 341                         destroy_dev(pt->part1.dev);
 342                         TAILQ_REMOVE(&nmdmhead, pt, pt_list);
 343                         free(pt, M_NLMDM);
 344                 }
 345                 clone_cleanup(&nmdmclones);
 346                 break;
 347         default:
 348                 error = EOPNOTSUPP;
 349         }
 350         return (error);
 351 }
 352
 353 DEV_MODULE(nmdm, nmdm_modevent, NULL);