usr/src/uts/common/io/sysmsg.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26
  27 /*
  28  * System message redirection driver for Sun.
  29  *
  30  * Redirects system message output to the device designated as the underlying
  31  * "hardware" console, as given by the value of sysmvp.  The implementation
  32  * assumes that sysmvp denotes a STREAMS device; the assumption is justified
  33  * since consoles must be capable of effecting tty semantics.
  34  */
  35
  36 #include <sys/types.h>
  37 #include <sys/kmem.h>
  38 #include <sys/open.h>
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/signal.h>
  42 #include <sys/cred.h>
  43 #include <sys/user.h>
  44 #include <sys/proc.h>
  45 #include <sys/vnode.h>
  46 #include <sys/uio.h>
  47 #include <sys/stat.h>
  48 #include <sys/file.h>
  49 #include <sys/session.h>
  50 #include <sys/stream.h>
  51 #include <sys/strsubr.h>
  52 #include <sys/poll.h>
  53 #include <sys/debug.h>
  54 #include <sys/sysmsg_impl.h>
  55 #include <sys/conf.h>
  56 #include <sys/termios.h>
  57 #include <sys/errno.h>
  58 #include <sys/modctl.h>
  59 #include <sys/pathname.h>
  60 #include <sys/ddi.h>
  61 #include <sys/sunddi.h>
  62 #include <sys/consdev.h>
  63 #include <sys/policy.h>
  64
  65 /*
  66  * internal functions
  67  */
  68 static int sysmopen(dev_t *, int, int, cred_t *);
  69 static int sysmclose(dev_t, int, int, cred_t *);
  70 static int sysmread(dev_t, struct uio *, cred_t *);
  71 static int sysmwrite(dev_t, struct uio *, cred_t *);
  72 static int sysmioctl(dev_t, int, intptr_t, int, cred_t *, int *);
  73 static int sysmpoll(dev_t, short, int, short *, struct pollhead **);
  74 static int sysm_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
  75 static int sysm_attach(dev_info_t *, ddi_attach_cmd_t);
  76 static int sysm_detach(dev_info_t *, ddi_detach_cmd_t);
  77 static void bind_consadm_conf(char *);
  78 static int checkarg(dev_t);
  79
  80 static dev_info_t *sysm_dip;            /* private copy of devinfo pointer */
  81
  82 static struct cb_ops sysm_cb_ops = {
  83
  84         sysmopen,               /* open */
  85         sysmclose,              /* close */
  86         nodev,                  /* strategy */
  87         nodev,                  /* print */
  88         nodev,                  /* dump */
  89         sysmread,               /* read */
  90         sysmwrite,              /* write */
  91         sysmioctl,              /* ioctl */
  92         nodev,                  /* devmap */
  93         nodev,                  /* mmap */
  94         nodev,                  /* segmap */
  95         sysmpoll,               /* poll */
  96         ddi_prop_op,            /* cb_prop_op */
  97         NULL,                   /* streamtab  */
  98         D_NEW | D_MP,           /* Driver compatibility flag */
  99         CB_REV,                 /* cb_rev */
 100         nodev,                  /* aread */
 101         nodev                   /* awrite */
 102 };
 103
 104 static struct dev_ops sysm_ops = {
 105
 106         DEVO_REV,               /* devo_rev, */
 107         0,                      /* refcnt  */
 108         sysm_info,              /* info */
 109         nulldev,                /* identify */
 110         nulldev,                /* probe */
 111         sysm_attach,            /* attach */
 112         sysm_detach,            /* detach */
 113         nodev,                  /* reset */
 114         &sysm_cb_ops,           /* driver operations */
 115         (struct bus_ops *)0,    /* bus operations */
 116         nulldev,                /* power */
 117         ddi_quiesce_not_needed,         /* quiesce */
 118
 119 };
 120
 121 /*
 122  * Global variables associated with the console device:
 123  */
 124
 125 #define SYS_SYSMIN      0       /* sysmsg minor number */
 126 #define SYS_MSGMIN      1       /* msglog minor number */
 127 #define SYSPATHLEN      255     /* length of device path */
 128
 129 /*
 130  * Private driver state:
 131  */
 132
 133 #define MAXDEVS 5
 134
 135 typedef struct {
 136         dev_t   dca_devt;
 137         int     dca_flags;
 138         vnode_t *dca_vp;
 139         krwlock_t       dca_lock;
 140         char    dca_name[SYSPATHLEN];
 141 } devicecache_t;
 142
 143 /* list of dyn. + persist. config'ed dev's */
 144 static devicecache_t sysmcache[MAXDEVS];
 145 static kmutex_t dcvp_mutex;
 146 static vnode_t  *dcvp = NULL;
 147 static boolean_t sysmsg_opened;
 148 static boolean_t msglog_opened;
 149
 150 /* flags for device cache */
 151 #define SYSM_DISABLED   0x0
 152 #define SYSM_ENABLED    0x1
 153
 154 /*
 155  * Module linkage information for the kernel.
 156  */
 157
 158 static struct modldrv modldrv = {
 159         &mod_driverops, /* Type of module.  This one is a pseudo driver */
 160         "System message redirection (fanout) driver",
 161         &sysm_ops,      /* driver ops */
 162 };
 163
 164 static struct modlinkage modlinkage = {
 165         MODREV_1,
 166         &modldrv,
 167         NULL
 168 };
 169
 170 int
 171 _init(void)
 172 {
 173         return (mod_install(&modlinkage));
 174 }
 175
 176 int
 177 _fini(void)
 178 {
 179         return (mod_remove(&modlinkage));
 180 }
 181
 182 int
 183 _info(struct modinfo *modinfop)
 184 {
 185         return (mod_info(&modlinkage, modinfop));
 186 }
 187
 188 /*
 189  * DDI glue routines
 190  */
 191 static int
 192 sysm_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
 193 {
 194         int i;
 195
 196         switch (cmd) {
 197         case DDI_ATTACH:
 198                 ASSERT(sysm_dip == NULL);
 199
 200                 if (ddi_create_minor_node(devi, "sysmsg", S_IFCHR,
 201                     SYS_SYSMIN, DDI_PSEUDO, NULL) == DDI_FAILURE ||
 202                     ddi_create_minor_node(devi, "msglog", S_IFCHR,
 203                     SYS_MSGMIN, DDI_PSEUDO, NULL) == DDI_FAILURE) {
 204                         ddi_remove_minor_node(devi, NULL);
 205                         return (DDI_FAILURE);
 206                 }
 207
 208                 for (i = 0; i < MAXDEVS; i++) {
 209                         rw_init(&sysmcache[i].dca_lock, NULL, RW_DRIVER, NULL);
 210                 }
 211
 212                 sysm_dip = devi;
 213                 return (DDI_SUCCESS);
 214         case DDI_SUSPEND:
 215         case DDI_PM_SUSPEND:
 216                 return (DDI_SUCCESS);
 217         default:
 218                 return (DDI_FAILURE);
 219         }
 220 }
 221
 222 static int
 223 sysm_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
 224 {
 225         int i;
 226
 227         switch (cmd) {
 228         case DDI_DETACH:
 229                 ASSERT(sysm_dip == devi);
 230
 231                 for (i = 0; i < MAXDEVS; i++)
 232                         rw_destroy(&sysmcache[i].dca_lock);
 233
 234                 ddi_remove_minor_node(devi, NULL);
 235                 sysm_dip = NULL;
 236                 return (DDI_SUCCESS);
 237
 238         case DDI_SUSPEND:
 239         case DDI_PM_SUSPEND:
 240                 return (DDI_SUCCESS);
 241         default:
 242                 return (DDI_FAILURE);
 243         }
 244
 245 }
 246
 247 /* ARGSUSED */
 248 static int
 249 sysm_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
 250 {
 251         int rval = DDI_FAILURE;
 252         minor_t instance;
 253
 254         instance = getminor((dev_t)arg);
 255
 256         switch (infocmd) {
 257         case DDI_INFO_DEVT2DEVINFO:
 258                 if (sysm_dip != NULL &&
 259                     (instance == SYS_SYSMIN || instance == SYS_MSGMIN)) {
 260                         *result = sysm_dip;
 261                         rval = DDI_SUCCESS;
 262                 }
 263                 break;
 264
 265         case DDI_INFO_DEVT2INSTANCE:
 266                 if (instance == SYS_SYSMIN || instance == SYS_MSGMIN) {
 267                         *result = NULL;
 268                         rval = DDI_SUCCESS;
 269                 }
 270                 break;
 271
 272         default:
 273                 break;
 274         }
 275
 276         return (rval);
 277 }
 278
 279 /*
 280  * Parse the contents of the buffer, and bind the named
 281  * devices as auxiliary consoles using our own ioctl routine.
 282  *
 283  * Comments begin with '#' and are terminated only by a newline
 284  * Device names begin with a '/', and are terminated by a newline,
 285  * space, '#' or tab.
 286  */
 287 static void
 288 parse_buffer(char *buf, ssize_t fsize)
 289 {
 290         char *ebuf = buf + fsize;
 291         char *devname = NULL;
 292         int eatcomments = 0;
 293
 294         while (buf < ebuf) {
 295                 if (eatcomments) {
 296                         if (*buf++ == '\n')
 297                                 eatcomments = 0;
 298                         continue;
 299                 }
 300                 switch (*buf) {
 301                 case '/':
 302                         if (devname == NULL)
 303                                 devname = buf;
 304                         break;
 305                 case '#':
 306                         eatcomments = 1;
 307                         /*FALLTHROUGH*/
 308                 case ' ':
 309                 case '\t':
 310                 case '\n':
 311                         *buf = '\0';
 312                         if (devname == NULL)
 313                                 break;
 314                         (void) sysmioctl(NODEV, CIOCSETCONSOLE,
 315                             (intptr_t)devname, FNATIVE|FKIOCTL|FREAD|FWRITE,
 316                             kcred, NULL);
 317                         devname = NULL;
 318                         break;
 319                 default:
 320                         break;
 321                 }
 322                 buf++;
 323         }
 324 }
 325
 326 #define CNSADM_BYTES_MAX        2000    /* XXX  nasty fixed size */
 327
 328 static void
 329 bind_consadm_conf(char *path)
 330 {
 331         struct vattr vattr;
 332         vnode_t *vp;
 333         void *buf;
 334         size_t size;
 335         ssize_t resid;
 336         int err = 0;
 337
 338         if (vn_open(path, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0) != 0)
 339                 return;
 340         vattr.va_mask = AT_SIZE;
 341         if ((err = VOP_GETATTR(vp, &vattr, 0, kcred, NULL)) != 0) {
 342                 cmn_err(CE_WARN, "sysmsg: getattr: '%s': error %d",
 343                     path, err);
 344                 goto closevp;
 345         }
 346
 347         size = vattr.va_size > CNSADM_BYTES_MAX ?
 348             CNSADM_BYTES_MAX : (ssize_t)vattr.va_size;
 349         buf = kmem_alloc(size, KM_SLEEP);
 350
 351         if ((err = vn_rdwr(UIO_READ, vp, buf, size, (offset_t)0,
 352             UIO_SYSSPACE, 0, (rlim64_t)0, kcred, &resid)) != 0)
 353                 cmn_err(CE_WARN, "sysmsg: vn_rdwr: '%s': error %d",
 354                     path, err);
 355         else
 356                 parse_buffer(buf, size - resid);
 357
 358         kmem_free(buf, size);
 359 closevp:
 360         (void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, kcred, NULL);
 361         VN_RELE(vp);
 362 }
 363
 364 /* ARGSUSED */
 365 static int
 366 sysmopen(dev_t *dev, int flag, int state, cred_t *cred)
 367 {
 368         int     i;
 369         vnode_t *vp;
 370         minor_t instance;
 371         static boolean_t initialized;
 372
 373         instance = getminor(*dev);
 374
 375         if (state != OTYP_CHR || (instance != 0 && instance != 1))
 376                 return (ENXIO);
 377
 378         mutex_enter(&dcvp_mutex);
 379         if ((dcvp == NULL) && (vn_open("/dev/console",
 380             UIO_SYSSPACE, FWRITE, 0, &dcvp, 0, 0) != 0)) {
 381                 mutex_exit(&dcvp_mutex);
 382                 return (ENXIO);
 383         }
 384
 385         if (instance == SYS_SYSMIN)
 386                 sysmsg_opened = B_TRUE;
 387         else
 388                 msglog_opened = B_TRUE;
 389
 390         if (!initialized) {
 391                 bind_consadm_conf("/etc/consadm.conf");
 392                 initialized = B_TRUE;
 393         }
 394         mutex_exit(&dcvp_mutex);
 395
 396         for (i = 0; i < MAXDEVS; i++) {
 397                 rw_enter(&sysmcache[i].dca_lock, RW_WRITER);
 398                 if ((sysmcache[i].dca_flags & SYSM_ENABLED) &&
 399                     sysmcache[i].dca_vp == NULL) {
 400                         /*
 401                          * 4196476 - FTRUNC was causing E10K to return EINVAL
 402                          * on open
 403                          */
 404                         flag = flag & ~FTRUNC;
 405                         /*
 406                          * Open failures on the auxiliary consoles are
 407                          * not returned because we don't care if some
 408                          * subset get an error. We know the default console
 409                          * is okay, and preserve the semantics of the
 410                          * open for the default console.
 411                          * Set NONBLOCK|NDELAY in case there's no carrier.
 412                          */
 413                         if (vn_open(sysmcache[i].dca_name, UIO_SYSSPACE,
 414                             flag | FNONBLOCK | FNDELAY, 0, &vp, 0, 0) == 0)
 415                                 sysmcache[i].dca_vp = vp;
 416                 }
 417                 rw_exit(&sysmcache[i].dca_lock);
 418         }
 419
 420         return (0);
 421 }
 422
 423 /* ARGSUSED */
 424 static int
 425 sysmclose(dev_t dev, int flag, int state, cred_t *cred)
 426 {
 427         int     i;
 428         minor_t instance;
 429
 430         ASSERT(dcvp != NULL);
 431
 432         if (state != OTYP_CHR)
 433                 return (ENXIO);
 434
 435         instance = getminor(dev);
 436
 437         mutex_enter(&dcvp_mutex);
 438         if (instance == SYS_SYSMIN)
 439                 sysmsg_opened = B_FALSE;
 440         else
 441                 msglog_opened = B_FALSE;
 442
 443         if (sysmsg_opened || msglog_opened) {
 444                 mutex_exit(&dcvp_mutex);
 445                 return (0);
 446         }
 447
 448         (void) VOP_CLOSE(dcvp, FWRITE, 1, (offset_t)0, kcred, NULL);
 449         VN_RELE(dcvp);
 450         dcvp = NULL;
 451         mutex_exit(&dcvp_mutex);
 452
 453         /*
 454          * Close the auxiliary consoles, we're not concerned with
 455          * passing up the errors.
 456          */
 457         for (i = 0; i < MAXDEVS; i++) {
 458                 rw_enter(&sysmcache[i].dca_lock, RW_WRITER);
 459                 if (sysmcache[i].dca_vp != NULL) {
 460                         (void) VOP_CLOSE(sysmcache[i].dca_vp, flag,
 461                             1, (offset_t)0, cred, NULL);
 462                         VN_RELE(sysmcache[i].dca_vp);
 463                         sysmcache[i].dca_vp = NULL;
 464                 }
 465                 rw_exit(&sysmcache[i].dca_lock);
 466         }
 467
 468         return (0);
 469 }
 470
 471 /* Reads occur only on the default console */
 472
 473 /* ARGSUSED */
 474 static int
 475 sysmread(dev_t dev, struct uio *uio, cred_t *cred)
 476 {
 477         ASSERT(dcvp != NULL);
 478         return (VOP_READ(dcvp, uio, 0, cred, NULL));
 479 }
 480
 481 /* ARGSUSED */
 482 static int
 483 sysmwrite(dev_t dev, struct uio *uio, cred_t *cred)
 484 {
 485         int     i = 0;
 486         iovec_t uio_iov;
 487         struct uio      tuio;
 488
 489         ASSERT(dcvp != NULL);
 490         ASSERT(uio != NULL);
 491
 492         for (i = 0; i < MAXDEVS; i++) {
 493                 rw_enter(&sysmcache[i].dca_lock, RW_READER);
 494                 if (sysmcache[i].dca_vp != NULL &&
 495                     (sysmcache[i].dca_flags & SYSM_ENABLED)) {
 496                         tuio = *uio;
 497                         uio_iov = *(uio->uio_iov);
 498                         tuio.uio_iov = &uio_iov;
 499                         (void) VOP_WRITE(sysmcache[i].dca_vp, &tuio, 0, cred,
 500                             NULL);
 501                 }
 502                 rw_exit(&sysmcache[i].dca_lock);
 503         }
 504         return (VOP_WRITE(dcvp, uio, 0, cred, NULL));
 505 }
 506
 507 /* ARGSUSED */
 508 static int
 509 sysmioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred, int *rvalp)
 510 {
 511         int     rval = 0;
 512         int     error = 0;
 513         size_t  size = 0;
 514         int     i;
 515         char    *infop;
 516         char    found = 0;
 517         dev_t   newdevt = (dev_t)NODEV; /* because 0 == /dev/console */
 518         vnode_t *vp;
 519
 520         switch (cmd) {
 521         case CIOCGETCONSOLE:
 522                 /* Sum over the number of enabled devices */
 523                 for (i = 0; i < MAXDEVS; i++) {
 524                         if (sysmcache[i].dca_flags & SYSM_ENABLED)
 525                                 /* list is space separated, followed by NULL */
 526                                 size += strlen(sysmcache[i].dca_name) + 1;
 527                 }
 528                 if (size == 0)
 529                         return (0);
 530                 break;
 531         case CIOCSETCONSOLE:
 532         case CIOCRMCONSOLE:
 533                 size = sizeof (sysmcache[0].dca_name);
 534                 break;
 535         case CIOCTTYCONSOLE:
 536         {
 537                 dev_t   d;
 538                 dev32_t d32;
 539                 extern dev_t rwsconsdev, rconsdev, uconsdev;
 540                 proc_t  *p;
 541
 542                 if (drv_getparm(UPROCP, &p) != 0)
 543                         return (ENODEV);
 544                 else
 545                         d = cttydev(p);
 546                 /*
 547                  * If the controlling terminal is the real
 548                  * or workstation console device, map to what the
 549                  * user thinks is the console device.
 550                  */
 551                 if (d == rwsconsdev || d == rconsdev)
 552                         d = uconsdev;
 553                 if ((flag & FMODELS) != FNATIVE) {
 554                         if (!cmpldev(&d32, d))
 555                                 return (EOVERFLOW);
 556                         if (ddi_copyout(&d32, (caddr_t)arg, sizeof (d32),
 557                             flag))
 558                                 return (EFAULT);
 559                 } else {
 560                         if (ddi_copyout(&d, (caddr_t)arg, sizeof (d), flag))
 561                                 return (EFAULT);
 562                 }
 563                 return (0);
 564         }
 565         default:
 566                 /* everything else is sent to the console device */
 567                 return (VOP_IOCTL(dcvp, cmd, arg, flag, cred, rvalp, NULL));
 568         }
 569
 570         if ((rval = secpolicy_console(cred)) != 0)
 571                 return (EPERM);
 572
 573         infop = kmem_alloc(size, KM_SLEEP);
 574         if (flag & FKIOCTL)
 575                 error = copystr((caddr_t)arg, infop, size, NULL);
 576         else
 577                 error = copyinstr((caddr_t)arg, infop, size, NULL);
 578
 579         if (error) {
 580                 switch (cmd) {
 581                 case CIOCGETCONSOLE:
 582                         /*
 583                          * If the buffer is null, then return a byte count
 584                          * to user land.
 585                          */
 586                         *rvalp = size;
 587                         goto err_exit;
 588                 default:
 589                         rval = EFAULT;
 590                         goto err_exit;
 591                 }
 592         }
 593
 594         if (infop[0] != NULL) {
 595                 if ((rval = lookupname(infop, UIO_SYSSPACE, FOLLOW,
 596                     NULLVPP, &vp)) == 0) {
 597                         if (vp->v_type != VCHR) {
 598                                 VN_RELE(vp);
 599                                 rval = EINVAL;
 600                                 goto err_exit;
 601                         }
 602                         newdevt = vp->v_rdev;
 603                         VN_RELE(vp);
 604                 } else
 605                         goto err_exit;
 606         }
 607
 608         switch (cmd) {
 609         case CIOCGETCONSOLE:
 610                 /*
 611                  * Return the list of device names that are enabled.
 612                  */
 613                 for (i = 0; i < MAXDEVS; i++) {
 614                         rw_enter(&sysmcache[i].dca_lock, RW_READER);
 615                         if (sysmcache[i].dca_flags & SYSM_ENABLED) {
 616                                 if (infop[0] != NULL)
 617                                         (void) strcat(infop, " ");
 618                                 (void) strcat(infop, sysmcache[i].dca_name);
 619                         }
 620                         rw_exit(&sysmcache[i].dca_lock);
 621                 }
 622                 if (rval == 0 && copyoutstr(infop, (void *)arg, size, NULL))
 623                         rval = EFAULT;
 624                 break;
 625
 626         case CIOCSETCONSOLE:
 627                 if ((rval = checkarg(newdevt)) != 0)
 628                         break;
 629                 /*
 630                  * The device does not have to be open or disabled to
 631                  * perform the set console.
 632                  */
 633                 for (i = 0; i < MAXDEVS; i++) {
 634                         rw_enter(&sysmcache[i].dca_lock, RW_WRITER);
 635                         if (sysmcache[i].dca_devt == newdevt &&
 636                             (sysmcache[i].dca_flags & SYSM_ENABLED)) {
 637                                 (void) strcpy(sysmcache[i].dca_name, infop);
 638                                 rval = EEXIST;
 639                                 rw_exit(&sysmcache[i].dca_lock);
 640                                 break;
 641                         } else if (sysmcache[i].dca_devt == newdevt &&
 642                             sysmcache[i].dca_flags == SYSM_DISABLED) {
 643                                 sysmcache[i].dca_flags |= SYSM_ENABLED;
 644                                 (void) strcpy(sysmcache[i].dca_name, infop);
 645                                 rw_exit(&sysmcache[i].dca_lock);
 646                                 found = 1;
 647                                 break;
 648                         } else if (sysmcache[i].dca_devt == 0) {
 649                                 ASSERT(sysmcache[i].dca_vp == NULL &&
 650                                     sysmcache[i].dca_flags == SYSM_DISABLED);
 651                                 (void) strcpy(sysmcache[i].dca_name, infop);
 652                                 sysmcache[i].dca_flags = SYSM_ENABLED;
 653                                 sysmcache[i].dca_devt = newdevt;
 654                                 rw_exit(&sysmcache[i].dca_lock);
 655                                 found = 1;
 656                                 break;
 657                         }
 658                         rw_exit(&sysmcache[i].dca_lock);
 659                 }
 660                 if (found == 0 && rval == 0)
 661                         rval = ENOENT;
 662                 break;
 663
 664         case CIOCRMCONSOLE:
 665                 for (i = 0; i < MAXDEVS; i++) {
 666                         rw_enter(&sysmcache[i].dca_lock, RW_WRITER);
 667                         if (sysmcache[i].dca_devt == newdevt) {
 668                                 sysmcache[i].dca_flags = SYSM_DISABLED;
 669                                 sysmcache[i].dca_name[0] = '\0';
 670                                 rw_exit(&sysmcache[i].dca_lock);
 671                                 found = 1;
 672                                 break;
 673                         }
 674                         rw_exit(&sysmcache[i].dca_lock);
 675                 }
 676                 if (found == 0)
 677                         rval = ENOENT;
 678                 break;
 679
 680         default:
 681                 break;
 682         }
 683
 684 err_exit:
 685         kmem_free(infop, size);
 686         return (rval);
 687 }
 688
 689 /* As with the read, we poll only the default console */
 690
 691 /* ARGSUSED */
 692 static int
 693 sysmpoll(dev_t dev, short events, int anyyet, short *reventsp,
 694         struct pollhead **phpp)
 695 {
 696         return (VOP_POLL(dcvp, events, anyyet, reventsp, phpp, NULL));
 697 }
 698
 699 /* Sanity check that the device is good */
 700 static int
 701 checkarg(dev_t devt)
 702 {
 703         int rval = 0;
 704         dev_t sysmsg_dev, msglog_dev;
 705         extern dev_t rwsconsdev, rconsdev, uconsdev;
 706
 707         if (devt == rconsdev || devt == rwsconsdev || devt == uconsdev) {
 708                 rval = EBUSY;
 709         } else {
 710                 sysmsg_dev = makedevice(ddi_driver_major(sysm_dip), SYS_SYSMIN);
 711                 msglog_dev = makedevice(ddi_driver_major(sysm_dip), SYS_MSGMIN);
 712                 if (devt == sysmsg_dev || devt == msglog_dev)
 713                         rval = EINVAL;
 714         }
 715
 716         return (rval);
 717 }