usr/src/uts/common/io/sysevent.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 (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25
  26 /*
  27  * Sysevent Driver for GPEC
  28  */
  29
  30 #include <sys/types.h>
  31 #include <sys/param.h>
  32 #include <sys/cred.h>
  33 #include <sys/file.h>
  34 #include <sys/stat.h>
  35 #include <sys/conf.h>
  36 #include <sys/ddi.h>
  37 #include <sys/sunddi.h>
  38 #include <sys/modctl.h>
  39 #include <sys/open.h>           /* OTYP_CHR definition */
  40 #include <sys/sysmacros.h>      /* L_BITSMINOR definition */
  41 #include <sys/bitmap.h>
  42 #include <sys/sysevent.h>
  43 #include <sys/sysevent_impl.h>
  44
  45 static dev_info_t *sysevent_devi;
  46
  47 /* Definitions for binding handle array */
  48 static ulong_t sysevent_bitmap_initial = 1;     /* index 0 indicates error */
  49 static ulong_t *sysevent_minor_bitmap = &sysevent_bitmap_initial;
  50 static size_t sysevent_minor_bits = BT_NBIPUL;
  51 static kmutex_t sysevent_minor_mutex;
  52
  53 /*
  54  * evchan_ctl acts as a container for the binding handle
  55  */
  56 typedef struct evchan_ctl {
  57         evchan_t *chp;
  58 } evchan_ctl_t;
  59
  60 static void *evchan_ctlp;
  61
  62 /*
  63  * Check if it's a null terminated array - to avoid DoS attack
  64  * It is supposed that string points to an array with
  65  * a minimum length of len. len must be strlen + 1.
  66  * Checks for printable characters are already done in library.
  67  */
  68 static int
  69 sysevent_isstrend(char *string, size_t len)
  70 {
  71         /* Return 0 if string has length of zero */
  72         if (len > 0) {
  73                 return (string[len - 1] == '\0' ? 1 : 0);
  74         } else {
  75                 return (0);
  76         }
  77 }
  78
  79 /*
  80  * Following sysevent_minor_* routines map
  81  * a binding handle (evchan_t *) to a minor number
  82  * Has to be called w/ locks held.
  83  */
  84 static ulong_t *
  85 sysevent_minor_alloc(void)
  86 {
  87         ulong_t *bhst = sysevent_minor_bitmap;
  88
  89         /* Increase bitmap by one BT_NBIPUL */
  90         if (sysevent_minor_bits + BT_NBIPUL > SYSEVENT_MINOR_MAX) {
  91                 return ((ulong_t *)NULL);
  92         }
  93         sysevent_minor_bitmap = kmem_zalloc(
  94             BT_SIZEOFMAP(sysevent_minor_bits + BT_NBIPUL), KM_SLEEP);
  95         bcopy(bhst, sysevent_minor_bitmap, BT_SIZEOFMAP(sysevent_minor_bits));
  96         if (bhst != &sysevent_bitmap_initial)
  97                 kmem_free(bhst, BT_SIZEOFMAP(sysevent_minor_bits));
  98         sysevent_minor_bits += BT_NBIPUL;
  99
 100         return (sysevent_minor_bitmap);
 101 }
 102
 103 static void
 104 sysevent_minor_free(ulong_t *bitmap)
 105 {
 106         if (bitmap != &sysevent_bitmap_initial)
 107                 kmem_free(bitmap, BT_SIZEOFMAP(sysevent_minor_bits));
 108 }
 109
 110 static index_t
 111 sysevent_minor_get(void)
 112 {
 113         index_t idx;
 114         ulong_t *bhst;
 115
 116         /* Search for an available index */
 117         mutex_enter(&sysevent_minor_mutex);
 118         if ((idx = bt_availbit(sysevent_minor_bitmap,
 119             sysevent_minor_bits)) == -1) {
 120                 /* All busy - allocate additional binding handle bitmap space */
 121                 if ((bhst = sysevent_minor_alloc()) == NULL) {
 122                         /* Reached our maximum of id's == SHRT_MAX */
 123                         mutex_exit(&sysevent_minor_mutex);
 124                         return (0);
 125                 } else {
 126                         sysevent_minor_bitmap = bhst;
 127                 }
 128                 idx = bt_availbit(sysevent_minor_bitmap, sysevent_minor_bits);
 129         }
 130         BT_SET(sysevent_minor_bitmap, idx);
 131         mutex_exit(&sysevent_minor_mutex);
 132         return (idx);
 133 }
 134
 135 static void
 136 sysevent_minor_rele(index_t idx)
 137 {
 138         mutex_enter(&sysevent_minor_mutex);
 139         ASSERT(BT_TEST(sysevent_minor_bitmap, idx) == 1);
 140         BT_CLEAR(sysevent_minor_bitmap, idx);
 141         mutex_exit(&sysevent_minor_mutex);
 142 }
 143
 144 static void
 145 sysevent_minor_init(void)
 146 {
 147         mutex_init(&sysevent_minor_mutex, NULL, MUTEX_DEFAULT, NULL);
 148 }
 149
 150 /* ARGSUSED */
 151 static int
 152 sysevent_publish(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
 153 {
 154         int km_flags;
 155         sev_publish_args_t uargs;
 156         sysevent_impl_t *ev;
 157         evchan_ctl_t *ctl;
 158
 159         ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
 160         if (ctl == NULL || ctl->chp == NULL)
 161                 return (ENXIO);
 162
 163         if (copyin(arg, &uargs, sizeof (sev_publish_args_t)) != 0)
 164                 return (EFAULT);
 165
 166         /*
 167          * This limits the size of an event
 168          */
 169         if (uargs.ev.len > MAX_EV_SIZE_LEN)
 170                 return (EOVERFLOW);
 171
 172         /*
 173          * Check for valid uargs.flags
 174          */
 175         if (uargs.flags & ~(EVCH_NOSLEEP | EVCH_SLEEP | EVCH_QWAIT))
 176                 return (EINVAL);
 177
 178         /*
 179          * Check that at least one of EVCH_NOSLEEP or EVCH_SLEEP is
 180          * specified
 181          */
 182         km_flags = uargs.flags & (EVCH_NOSLEEP | EVCH_SLEEP);
 183         if (km_flags != EVCH_NOSLEEP && km_flags != EVCH_SLEEP)
 184                 return (EINVAL);
 185
 186         ev = evch_usrallocev(uargs.ev.len, uargs.flags);
 187
 188         if (copyin((void *)(uintptr_t)uargs.ev.name, ev, uargs.ev.len) != 0) {
 189                 evch_usrfreeev(ev);
 190                 return (EFAULT);
 191         }
 192
 193         return (evch_usrpostevent(ctl->chp, ev, uargs.flags));
 194
 195         /* Event will be freed internally */
 196 }
 197
 198 /*
 199  * sysevent_chan_open - used to open a channel in the GPEC channel layer
 200  */
 201
 202 /* ARGSUSED */
 203 static int
 204 sysevent_chan_open(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
 205 {
 206         sev_bind_args_t uargs;
 207         evchan_ctl_t *ctl;
 208         char *chan_name;
 209         int ec;
 210
 211         ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
 212         if (ctl == NULL) {
 213                 return (ENXIO);
 214         }
 215
 216         if (copyin(arg, &uargs, sizeof (sev_bind_args_t)) != 0)
 217                 return (EFAULT);
 218
 219         if (uargs.chan_name.len > MAX_CHNAME_LEN)
 220                 return (EINVAL);
 221
 222         chan_name = kmem_alloc(uargs.chan_name.len, KM_SLEEP);
 223
 224         if (copyin((void *)(uintptr_t)uargs.chan_name.name, chan_name,
 225             uargs.chan_name.len) != 0) {
 226                 kmem_free(chan_name, uargs.chan_name.len);
 227                 return (EFAULT);
 228         }
 229
 230         if (!sysevent_isstrend(chan_name, uargs.chan_name.len)) {
 231                 kmem_free(chan_name, uargs.chan_name.len);
 232                 return (EINVAL);
 233         }
 234
 235         /*
 236          * Check of uargs.flags and uargs.perms just to avoid DoS attacks.
 237          * libsysevent does this carefully
 238          */
 239         ctl->chp = evch_usrchanopen((const char *)chan_name,
 240             uargs.flags & EVCH_B_FLAGS, &ec);
 241
 242         kmem_free(chan_name, uargs.chan_name.len);
 243
 244         if (ec != 0) {
 245                 return (ec);
 246         }
 247
 248         return (0);
 249 }
 250
 251 /* ARGSUSED */
 252 static int
 253 sysevent_chan_control(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
 254 {
 255         sev_control_args_t uargs;
 256         evchan_ctl_t *ctl;
 257         int rc;
 258
 259         ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
 260         if (ctl == NULL || ctl->chp == NULL)
 261                 return (ENXIO);
 262
 263         if (copyin(arg, &uargs, sizeof (sev_control_args_t)) != 0)
 264                 return (EFAULT);
 265
 266         switch (uargs.cmd) {
 267         case EVCH_GET_CHAN_LEN:
 268         case EVCH_GET_CHAN_LEN_MAX:
 269                 rc = evch_usrcontrol_get(ctl->chp, uargs.cmd, &uargs.value);
 270                 if (rc == 0) {
 271                         if (copyout((void *)&uargs, arg,
 272                             sizeof (sev_control_args_t)) != 0) {
 273                                 rc = EFAULT;
 274                         }
 275                 }
 276                 break;
 277         case EVCH_SET_CHAN_LEN:
 278                 rc = evch_usrcontrol_set(ctl->chp, uargs.cmd, uargs.value);
 279                 break;
 280         default:
 281                 rc = EINVAL;
 282         }
 283         return (rc);
 284 }
 285
 286 /* ARGSUSED */
 287 static int
 288 sysevent_subscribe(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
 289 {
 290         sev_subscribe_args_t uargs;
 291         char *sid;
 292         char *class_info = NULL;
 293         evchan_ctl_t *ctl;
 294         int rc;
 295
 296         ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
 297         if (ctl == NULL || ctl->chp == NULL)
 298                 return (ENXIO);
 299
 300         if (copyin(arg, &uargs, sizeof (sev_subscribe_args_t)) != 0)
 301                 return (EFAULT);
 302
 303         if (uargs.sid.len > MAX_SUBID_LEN ||
 304             uargs.class_info.len > MAX_CLASS_LEN)
 305                 return (EINVAL);
 306
 307         sid = kmem_alloc(uargs.sid.len, KM_SLEEP);
 308         if (copyin((void *)(uintptr_t)uargs.sid.name,
 309             sid, uargs.sid.len) != 0) {
 310                 kmem_free(sid, uargs.sid.len);
 311                 return (EFAULT);
 312         }
 313         if (!sysevent_isstrend(sid, uargs.sid.len)) {
 314                 kmem_free(sid, uargs.sid.len);
 315                 return (EINVAL);
 316         }
 317
 318         /* If class string empty then class EC_ALL is assumed */
 319         if (uargs.class_info.len != 0) {
 320                 class_info = kmem_alloc(uargs.class_info.len, KM_SLEEP);
 321                 if (copyin((void *)(uintptr_t)uargs.class_info.name, class_info,
 322                     uargs.class_info.len) != 0) {
 323                         kmem_free(class_info, uargs.class_info.len);
 324                         kmem_free(sid, uargs.sid.len);
 325                         return (EFAULT);
 326                 }
 327                 if (!sysevent_isstrend(class_info, uargs.class_info.len)) {
 328                         kmem_free(class_info, uargs.class_info.len);
 329                         kmem_free(sid, uargs.sid.len);
 330                         return (EINVAL);
 331                 }
 332         }
 333
 334         /*
 335          * Check of uargs.flags just to avoid DoS attacks
 336          * libsysevent does this carefully.
 337          */
 338         rc = evch_usrsubscribe(ctl->chp, sid, class_info,
 339             (int)uargs.door_desc, uargs.flags);
 340
 341         kmem_free(class_info, uargs.class_info.len);
 342         kmem_free(sid, uargs.sid.len);
 343
 344         return (rc);
 345 }
 346
 347 /* ARGSUSED */
 348 static int
 349 sysevent_unsubscribe(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
 350 {
 351         sev_unsubscribe_args_t uargs;
 352         char *sid;
 353         evchan_ctl_t *ctl;
 354
 355         if (copyin(arg, &uargs, sizeof (sev_unsubscribe_args_t)) != 0)
 356                 return (EFAULT);
 357
 358         ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
 359         if (ctl == NULL || ctl->chp == NULL)
 360                 return (ENXIO);
 361
 362         if (uargs.sid.len > MAX_SUBID_LEN)
 363                 return (EINVAL);
 364
 365         /* Unsubscribe for all */
 366         if (uargs.sid.len == 0) {
 367                 evch_usrunsubscribe(ctl->chp, NULL, 0);
 368                 return (0);
 369         }
 370
 371         sid = kmem_alloc(uargs.sid.len, KM_SLEEP);
 372
 373         if (copyin((void *)(uintptr_t)uargs.sid.name,
 374             sid, uargs.sid.len) != 0) {
 375                 kmem_free(sid, uargs.sid.len);
 376                 return (EFAULT);
 377         }
 378
 379         evch_usrunsubscribe(ctl->chp, sid, 0);
 380
 381         kmem_free(sid, uargs.sid.len);
 382
 383         return (0);
 384 }
 385
 386 /* ARGSUSED */
 387 static int
 388 sysevent_channames(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
 389 {
 390         sev_chandata_args_t uargs;
 391         char *buf;
 392         int len;
 393         int rc = 0;
 394
 395         if (copyin(arg, &uargs, sizeof (sev_chandata_args_t)) != 0)
 396                 return (EFAULT);
 397
 398         if (uargs.out_data.len == 0 || uargs.out_data.len > EVCH_MAX_DATA_SIZE)
 399                 return (EINVAL);
 400
 401         buf = kmem_alloc(uargs.out_data.len, KM_SLEEP);
 402
 403         if ((len = evch_usrgetchnames(buf, uargs.out_data.len)) == -1) {
 404                 rc = EOVERFLOW;
 405         }
 406
 407         if (rc == 0) {
 408                 ASSERT(len <= uargs.out_data.len);
 409                 if (copyout(buf,
 410                     (void *)(uintptr_t)uargs.out_data.name, len) != 0) {
 411                         rc = EFAULT;
 412                 }
 413         }
 414
 415         kmem_free(buf, uargs.out_data.len);
 416
 417         return (rc);
 418 }
 419
 420 /* ARGSUSED */
 421 static int
 422 sysevent_chandata(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
 423 {
 424         sev_chandata_args_t uargs;
 425         char *channel;
 426         char *buf;
 427         int len;
 428         int rc = 0;
 429
 430         if (copyin(arg, &uargs, sizeof (sev_chandata_args_t)) != 0)
 431                 return (EFAULT);
 432
 433         if (uargs.in_data.len > MAX_CHNAME_LEN ||
 434             uargs.out_data.len > EVCH_MAX_DATA_SIZE)
 435                 return (EINVAL);
 436
 437         channel = kmem_alloc(uargs.in_data.len, KM_SLEEP);
 438
 439         if (copyin((void *)(uintptr_t)uargs.in_data.name, channel,
 440             uargs.in_data.len) != 0) {
 441                 kmem_free(channel, uargs.in_data.len);
 442                 return (EFAULT);
 443         }
 444
 445         if (!sysevent_isstrend(channel, uargs.in_data.len)) {
 446                 kmem_free(channel, uargs.in_data.len);
 447                 return (EINVAL);
 448         }
 449
 450         buf = kmem_alloc(uargs.out_data.len, KM_SLEEP);
 451
 452         len = evch_usrgetchdata(channel, buf, uargs.out_data.len);
 453         if (len == 0) {
 454                 rc = EOVERFLOW;
 455         } else if (len == -1) {
 456                 rc = ENOENT;
 457         }
 458
 459         if (rc == 0) {
 460                 ASSERT(len <= uargs.out_data.len);
 461                 if (copyout(buf,
 462                     (void *)(uintptr_t)uargs.out_data.name, len) != 0) {
 463                         rc = EFAULT;
 464                 }
 465         }
 466
 467         kmem_free(buf, uargs.out_data.len);
 468         kmem_free(channel, uargs.in_data.len);
 469
 470         return (rc);
 471 }
 472
 473 /* ARGSUSED */
 474 static int
 475 sysevent_setpropnvl(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
 476 {
 477         sev_propnvl_args_t uargs;
 478         nvlist_t *nvl = NULL;
 479         evchan_ctl_t *ctl;
 480         size_t bufsz;
 481         char *buf;
 482
 483         ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
 484         if (ctl == NULL || ctl->chp == NULL)
 485                 return (ENXIO);
 486
 487         if (copyin(arg, &uargs, sizeof (uargs)) != 0)
 488                 return (EFAULT);
 489
 490         if (uargs.packednvl.name != 0) {
 491                 bufsz = uargs.packednvl.len;
 492
 493                 if (bufsz == 0)
 494                         return (EINVAL);
 495
 496                 if (bufsz > EVCH_MAX_DATA_SIZE)
 497                         return (EOVERFLOW);
 498
 499                 buf = kmem_alloc(bufsz, KM_SLEEP);
 500
 501                 if (copyin((void *)(uintptr_t)uargs.packednvl.name, buf,
 502                     bufsz) != 0 ||
 503                     nvlist_unpack(buf, bufsz, &nvl, KM_SLEEP) != 0) {
 504                         kmem_free(buf, bufsz);
 505                         return (EFAULT);
 506                 }
 507
 508                 kmem_free(buf, bufsz);
 509
 510                 if (nvl == NULL)
 511                         return (EINVAL);
 512         }
 513
 514         evch_usrsetpropnvl(ctl->chp, nvl);
 515         return (0);
 516 }
 517
 518 /* ARGSUSED */
 519 static int
 520 sysevent_getpropnvl(dev_t dev, int *rvalp, void *arg, int flag, cred_t *cr)
 521 {
 522         sev_propnvl_args_t uargs;
 523         size_t reqsz, avlsz;
 524         evchan_ctl_t *ctl;
 525         nvlist_t *nvl;
 526         int64_t gen;
 527         int rc;
 528
 529         ctl = ddi_get_soft_state(evchan_ctlp, getminor(dev));
 530
 531         if (ctl == NULL || ctl->chp == NULL)
 532                 return (ENXIO);
 533
 534         if (copyin(arg, &uargs, sizeof (uargs)) != 0)
 535                 return (EFAULT);
 536
 537         if ((rc = evch_usrgetpropnvl(ctl->chp, &nvl, &gen)) != 0)
 538                 return (rc);
 539
 540         if (nvl != NULL) {
 541                 avlsz = uargs.packednvl.len;
 542
 543                 if (nvlist_size(nvl, &reqsz, NV_ENCODE_NATIVE) != 0) {
 544                         nvlist_free(nvl);
 545                         return (EINVAL);
 546                 }
 547
 548                 if (reqsz > EVCH_MAX_DATA_SIZE) {
 549                         nvlist_free(nvl);
 550                         return (E2BIG);
 551                 }
 552
 553                 if (reqsz <= avlsz) {
 554                         char *buf = kmem_alloc(reqsz, KM_SLEEP);
 555
 556                         if (nvlist_pack(nvl, &buf, &reqsz,
 557                             NV_ENCODE_NATIVE, 0) != 0 || copyout(buf,
 558                             (void *)(uintptr_t)uargs.packednvl.name,
 559                             reqsz) != 0) {
 560                                 kmem_free(buf, reqsz);
 561                                 nvlist_free(nvl);
 562                                 return (EFAULT);
 563                         }
 564                         kmem_free(buf, reqsz);
 565                         rc = 0;
 566                 } else {
 567                         rc = EOVERFLOW;
 568                 }
 569                 uargs.packednvl.len = (uint32_t)reqsz;
 570                 nvlist_free(nvl);
 571         } else {
 572                 uargs.packednvl.len = 0;
 573                 rc = 0;
 574         }
 575
 576         uargs.generation = gen;
 577         if (copyout((void *)&uargs, arg, sizeof (uargs)) != 0)
 578                 rc = EFAULT;
 579
 580         return (rc);
 581 }
 582
 583 /*ARGSUSED*/
 584 static int
 585 sysevent_ioctl(dev_t dev, int cmd, intptr_t arg,
 586     int flag, cred_t *cr, int *rvalp)
 587 {
 588         int rc;
 589
 590         switch (cmd) {
 591         case SEV_PUBLISH:
 592                 rc = sysevent_publish(dev, rvalp, (void *)arg, flag, cr);
 593                 break;
 594         case SEV_CHAN_OPEN:
 595                 rc = sysevent_chan_open(dev, rvalp, (void *)arg, flag, cr);
 596                 break;
 597         case SEV_CHAN_CONTROL:
 598                 rc = sysevent_chan_control(dev, rvalp, (void *)arg, flag, cr);
 599                 break;
 600         case SEV_SUBSCRIBE:
 601                 rc = sysevent_subscribe(dev, rvalp, (void *)arg, flag, cr);
 602                 break;
 603         case SEV_UNSUBSCRIBE:
 604                 rc = sysevent_unsubscribe(dev, rvalp, (void *)arg, flag, cr);
 605                 break;
 606         case SEV_CHANNAMES:
 607                 rc = sysevent_channames(dev, rvalp, (void *)arg, flag, cr);
 608                 break;
 609         case SEV_CHANDATA:
 610                 rc = sysevent_chandata(dev, rvalp, (void *)arg, flag, cr);
 611                 break;
 612         case SEV_SETPROPNVL:
 613                 rc = sysevent_setpropnvl(dev, rvalp, (void *)arg, flag, cr);
 614                 break;
 615         case SEV_GETPROPNVL:
 616                 rc = sysevent_getpropnvl(dev, rvalp, (void *)arg, flag, cr);
 617                 break;
 618         default:
 619                 rc = EINVAL;
 620         }
 621
 622         return (rc);
 623 }
 624
 625 /*ARGSUSED*/
 626 static int
 627 sysevent_open(dev_t *devp, int flag, int otyp, cred_t *cr)
 628 {
 629         int minor;
 630
 631         if (otyp != OTYP_CHR)
 632                 return (EINVAL);
 633
 634         if (getminor(*devp) != 0)
 635                 return (ENXIO);
 636
 637         minor = sysevent_minor_get();
 638         if (minor == 0)
 639                 /* All minors are busy */
 640                 return (EBUSY);
 641
 642         if (ddi_soft_state_zalloc(evchan_ctlp, minor)
 643             != DDI_SUCCESS) {
 644                 sysevent_minor_rele(minor);
 645                 return (ENOMEM);
 646         }
 647
 648         *devp = makedevice(getmajor(*devp), minor);
 649
 650         return (0);
 651 }
 652
 653 /*ARGSUSED*/
 654 static int
 655 sysevent_close(dev_t dev, int flag, int otyp, cred_t *cr)
 656 {
 657         int minor = (int)getminor(dev);
 658         evchan_ctl_t *ctl;
 659
 660         if (otyp != OTYP_CHR)
 661                 return (EINVAL);
 662
 663         ctl = ddi_get_soft_state(evchan_ctlp, minor);
 664         if (ctl == NULL) {
 665                 return (ENXIO);
 666         }
 667
 668         if (ctl->chp) {
 669                 /* Release all non-persistant subscriptions */
 670                 evch_usrunsubscribe(ctl->chp, NULL, EVCH_SUB_KEEP);
 671                 evch_usrchanclose(ctl->chp);
 672         }
 673
 674         ddi_soft_state_free(evchan_ctlp, minor);
 675         sysevent_minor_rele(minor);
 676
 677         return (0);
 678 }
 679
 680 /* ARGSUSED */
 681 static int
 682 sysevent_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
 683     void *arg, void **result)
 684 {
 685         switch (infocmd) {
 686         case DDI_INFO_DEVT2DEVINFO:
 687                 *result = sysevent_devi;
 688                 return (DDI_SUCCESS);
 689         case DDI_INFO_DEVT2INSTANCE:
 690                 *result = 0;
 691                 return (DDI_SUCCESS);
 692         }
 693         return (DDI_FAILURE);
 694 }
 695
 696 /* ARGSUSED */
 697 static int
 698 sysevent_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
 699 {
 700
 701         if (cmd != DDI_ATTACH) {
 702                 return (DDI_FAILURE);
 703         }
 704
 705         if (ddi_create_minor_node(devi, "sysevent", S_IFCHR,
 706             0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
 707                 ddi_remove_minor_node(devi, NULL);
 708                 return (DDI_FAILURE);
 709         }
 710         sysevent_devi = devi;
 711
 712         sysevent_minor_init();
 713
 714         return (DDI_SUCCESS);
 715 }
 716
 717 static int
 718 sysevent_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
 719 {
 720         if (cmd != DDI_DETACH) {
 721                 return (DDI_FAILURE);
 722         }
 723
 724         sysevent_minor_free(sysevent_minor_bitmap);
 725         ddi_remove_minor_node(devi, NULL);
 726         return (DDI_SUCCESS);
 727 }
 728
 729 static struct cb_ops sysevent_cb_ops = {
 730         sysevent_open,          /* open */
 731         sysevent_close,         /* close */
 732         nodev,                  /* strategy */
 733         nodev,                  /* print */
 734         nodev,                  /* dump */
 735         nodev,                  /* read */
 736         nodev,                  /* write */
 737         sysevent_ioctl,         /* ioctl */
 738         nodev,                  /* devmap */
 739         nodev,                  /* mmap */
 740         nodev,                  /* segmap */
 741         nochpoll,               /* poll */
 742         ddi_prop_op,            /* prop_op */
 743         0,                      /* streamtab  */
 744         D_NEW|D_MP,             /* flag */
 745         NULL,                   /* aread */
 746         NULL                    /* awrite */
 747 };
 748
 749 static struct dev_ops sysevent_ops = {
 750         DEVO_REV,               /* devo_rev */
 751         0,                      /* refcnt  */
 752         sysevent_info,          /* info */
 753         nulldev,                /* identify */
 754         nulldev,                /* probe */
 755         sysevent_attach,        /* attach */
 756         sysevent_detach,        /* detach */
 757         nodev,                  /* reset */
 758         &sysevent_cb_ops,       /* driver operations */
 759         (struct bus_ops *)0,    /* no bus operations */
 760         nulldev,                /* power */
 761         ddi_quiesce_not_needed,         /* quiesce */
 762 };
 763
 764 static struct modldrv modldrv = {
 765         &mod_driverops, "sysevent driver", &sysevent_ops
 766 };
 767
 768 static struct modlinkage modlinkage = {
 769         MODREV_1, &modldrv, NULL
 770 };
 771
 772 int
 773 _init(void)
 774 {
 775         int s;
 776
 777         s = ddi_soft_state_init(&evchan_ctlp, sizeof (evchan_ctl_t), 1);
 778         if (s != 0)
 779                 return (s);
 780
 781         if ((s = mod_install(&modlinkage)) != 0)
 782                 ddi_soft_state_fini(&evchan_ctlp);
 783         return (s);
 784 }
 785
 786 int
 787 _fini(void)
 788 {
 789         int s;
 790
 791         if ((s = mod_remove(&modlinkage)) != 0)
 792                 return (s);
 793
 794         ddi_soft_state_fini(&evchan_ctlp);
 795         return (s);
 796 }
 797
 798 int
 799 _info(struct modinfo *modinfop)
 800 {
 801         return (mod_info(&modlinkage, modinfop));
 802 }