usr/src/uts/common/io/vscan/vscan_drv.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 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <sys/stat.h>
  28 #include <sys/ddi.h>
  29 #include <sys/sunddi.h>
  30 #include <sys/time.h>
  31 #include <sys/varargs.h>
  32 #include <sys/conf.h>
  33 #include <sys/modctl.h>
  34 #include <sys/vnode.h>
  35 #include <sys/fs_subr.h>
  36 #include <sys/types.h>
  37 #include <sys/file.h>
  38 #include <sys/disp.h>
  39 #include <sys/vscan.h>
  40 #include <sys/policy.h>
  41 #include <sys/sdt.h>
  42
  43
  44 /* seconds to wait for daemon to reconnect before disabling */
  45 #define VS_DAEMON_WAIT_SEC      60
  46
  47 /* length of minor node name - vscan%d */
  48 #define VS_NODENAME_LEN         16
  49
  50 /* global variables - tunable via /etc/system */
  51 uint32_t vs_reconnect_timeout = VS_DAEMON_WAIT_SEC;
  52 extern uint32_t vs_nodes_max;   /* max in-progress scan requests */
  53
  54 /*
  55  * vscan_drv_state
  56  *
  57  * Operations on instance 0 represent vscand initiated state
  58  * transition events:
  59  * open(0) - vscand connect
  60  * close(0) - vscan disconnect
  61  * enable(0) - vscand enable (ready to hand requests)
  62  * disable(0) - vscand disable (shutting down)
  63  *
  64  *   +------------------------+
  65  *   | VS_DRV_UNCONFIG        |
  66  *   +------------------------+
  67  *      |           ^
  68  *      | attach    | detach
  69  *      v           |
  70  *   +------------------------+
  71  *   | VS_DRV_IDLE            |<------|
  72  *   +------------------------+       |
  73  *      |           ^                 |
  74  *      | open(0)   | close(0)        |
  75  *      v           |                 |
  76  *   +------------------------+       |
  77  *   | VS_DRV_CONNECTED       |<-|    |
  78  *   +------------------------+  |    |
  79  *      |           ^            |    |
  80  *      | enable(0) | disable(0) |    |
  81  *      v           |            |    |
  82  *   +------------------------+  |    |
  83  *   | VS_DRV_ENABLED         |  |    |
  84  *   +------------------------+  |    |
  85  *      |                        |    |
  86  *      | close(0)            open(0) |
  87  *      v                        |    |
  88  *   +------------------------+  |    | timeout
  89  *   | VS_DRV_DELAYED_DISABLE | --    |
  90  *   +------------------------+ ------|
  91  *
  92  */
  93 typedef enum {
  94         VS_DRV_UNCONFIG,
  95         VS_DRV_IDLE,
  96         VS_DRV_CONNECTED,
  97         VS_DRV_ENABLED,
  98         VS_DRV_DELAYED_DISABLE
  99 } vscan_drv_state_t;
 100 static vscan_drv_state_t vscan_drv_state = VS_DRV_UNCONFIG;
 101
 102
 103 /*
 104  * vscan_drv_inst_state
 105  *
 106  * Instance 0 controls the state of the driver: vscan_drv_state.
 107  * vscan_drv_inst_state[0] should NOT be used.
 108  *
 109  * vscan_drv_inst_state[n] represents the state of driver
 110  * instance n, used by vscand to access file data for the
 111  * scan request with index n in vscan_svc_reqs.
 112  * Minor nodes are created as required then all are destroyed
 113  * during driver detach.
 114  *
 115  *   +------------------------+
 116  *   | VS_DRV_INST_UNCONFIG   |
 117  *   +------------------------+
 118  *      |                 ^
 119  *      | create_node(n)  | detach
 120  *      v                 |
 121  *   +------------------------+
 122  *   | VS_DRV_INST_INIT       |<-|
 123  *   +------------------------+  |
 124  *      |                        |
 125  *      | open(n)                |
 126  *      v                        |
 127  *   +------------------------+  |
 128  *   | VS_DRV_INST_OPEN       |--|
 129  *   +------------------------+  |
 130  *      |                        |
 131  *      | read(n)                |
 132  *      v                        | close(n)
 133  *   +------------------------+  |
 134  *   | VS_DRV_INST_READING    |--|
 135  *   +------------------------+
 136  */
 137 typedef enum {
 138         VS_DRV_INST_UNCONFIG = 0, /* minor node not created */
 139         VS_DRV_INST_INIT,
 140         VS_DRV_INST_OPEN,
 141         VS_DRV_INST_READING
 142 } vscan_drv_inst_state_t;
 143
 144 static vscan_drv_inst_state_t *vscan_drv_inst_state;
 145 static int vscan_drv_inst_state_sz;
 146
 147 static dev_info_t *vscan_drv_dip;
 148 static kmutex_t vscan_drv_mutex;
 149 static kcondvar_t vscan_drv_cv; /* wait for daemon reconnect */
 150
 151 /*
 152  * DDI entry points.
 153  */
 154 static int vscan_drv_attach(dev_info_t *, ddi_attach_cmd_t);
 155 static int vscan_drv_detach(dev_info_t *, ddi_detach_cmd_t);
 156 static int vscan_drv_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
 157 static int vscan_drv_open(dev_t *, int, int, cred_t *);
 158 static int vscan_drv_close(dev_t, int, int, cred_t *);
 159 static int vscan_drv_read(dev_t, struct uio *, cred_t *);
 160 static int vscan_drv_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
 161
 162 static boolean_t vscan_drv_in_use(void);
 163 static void vscan_drv_delayed_disable(void);
 164
 165
 166 /*
 167  * module linkage info for the kernel
 168  */
 169 static struct cb_ops cbops = {
 170         vscan_drv_open,         /* cb_open */
 171         vscan_drv_close,        /* cb_close */
 172         nodev,                  /* cb_strategy */
 173         nodev,                  /* cb_print */
 174         nodev,                  /* cb_dump */
 175         vscan_drv_read,         /* cb_read */
 176         nodev,                  /* cb_write */
 177         vscan_drv_ioctl,        /* cb_ioctl */
 178         nodev,                  /* cb_devmap */
 179         nodev,                  /* cb_mmap */
 180         nodev,                  /* cb_segmap */
 181         nochpoll,               /* cb_chpoll */
 182         ddi_prop_op,            /* cb_prop_op */
 183         NULL,                   /* cb_streamtab */
 184         D_MP,                   /* cb_flag */
 185         CB_REV,                 /* cb_rev */
 186         nodev,                  /* cb_aread */
 187         nodev,                  /* cb_awrite */
 188 };
 189
 190 static struct dev_ops devops = {
 191         DEVO_REV,               /* devo_rev */
 192         0,                      /* devo_refcnt */
 193         vscan_drv_getinfo,      /* devo_getinfo */
 194         nulldev,                /* devo_identify */
 195         nulldev,                /* devo_probe */
 196         vscan_drv_attach,       /* devo_attach */
 197         vscan_drv_detach,       /* devo_detach */
 198         nodev,                  /* devo_reset */
 199         &cbops,                 /* devo_cb_ops */
 200         NULL,                   /* devo_bus_ops */
 201         NULL,                   /* devo_power */
 202         ddi_quiesce_not_needed,         /* devo_quiesce */
 203 };
 204
 205 static struct modldrv modldrv = {
 206         &mod_driverops,         /* drv_modops */
 207         "virus scanning",       /* drv_linkinfo */
 208         &devops,
 209 };
 210
 211 static struct modlinkage modlinkage = {
 212
 213         MODREV_1,       /* revision of the module, must be: MODREV_1    */
 214         &modldrv,       /* ptr to linkage structures                    */
 215         NULL,
 216 };
 217
 218
 219 /*
 220  * _init
 221  */
 222 int
 223 _init(void)
 224 {
 225         int rc;
 226
 227         vscan_drv_inst_state_sz =
 228             sizeof (vscan_drv_inst_state_t) * (vs_nodes_max + 1);
 229
 230         if (vscan_door_init() != 0)
 231                 return (DDI_FAILURE);
 232
 233         if (vscan_svc_init() != 0) {
 234                 vscan_door_fini();
 235                 return (DDI_FAILURE);
 236         }
 237
 238         mutex_init(&vscan_drv_mutex, NULL, MUTEX_DRIVER, NULL);
 239         vscan_drv_inst_state = kmem_zalloc(vscan_drv_inst_state_sz, KM_SLEEP);
 240
 241         cv_init(&vscan_drv_cv, NULL, CV_DEFAULT, NULL);
 242
 243         if ((rc  = mod_install(&modlinkage)) != 0) {
 244                 vscan_door_fini();
 245                 vscan_svc_fini();
 246                 kmem_free(vscan_drv_inst_state, vscan_drv_inst_state_sz);
 247                 cv_destroy(&vscan_drv_cv);
 248                 mutex_destroy(&vscan_drv_mutex);
 249         }
 250
 251         return (rc);
 252 }
 253
 254
 255 /*
 256  * _info
 257  */
 258 int
 259 _info(struct modinfo *modinfop)
 260 {
 261         return (mod_info(&modlinkage, modinfop));
 262 }
 263
 264
 265 /*
 266  * _fini
 267  */
 268 int
 269 _fini(void)
 270 {
 271         int rc;
 272
 273         if (vscan_drv_in_use())
 274                 return (EBUSY);
 275
 276         if ((rc = mod_remove(&modlinkage)) == 0) {
 277                 vscan_door_fini();
 278                 vscan_svc_fini();
 279                 kmem_free(vscan_drv_inst_state, vscan_drv_inst_state_sz);
 280                 cv_destroy(&vscan_drv_cv);
 281                 mutex_destroy(&vscan_drv_mutex);
 282         }
 283
 284         return (rc);
 285 }
 286
 287
 288 /*
 289  * DDI entry points.
 290  */
 291
 292 /*
 293  * vscan_drv_getinfo
 294  */
 295 /* ARGSUSED */
 296 static int
 297 vscan_drv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
 298 {
 299         ulong_t inst = getminor((dev_t)arg);
 300
 301         switch (cmd) {
 302         case DDI_INFO_DEVT2DEVINFO:
 303                 *result = vscan_drv_dip;
 304                 return (DDI_SUCCESS);
 305         case DDI_INFO_DEVT2INSTANCE:
 306                 *result = (void *)inst;
 307                 return (DDI_SUCCESS);
 308         }
 309         return (DDI_FAILURE);
 310 }
 311
 312
 313 /*
 314  * vscan_drv_attach
 315  */
 316 static int
 317 vscan_drv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 318 {
 319         if (cmd != DDI_ATTACH)
 320                 return (DDI_FAILURE);
 321
 322         if (ddi_get_instance(dip) != 0)
 323                 return (DDI_FAILURE);
 324
 325         vscan_drv_dip = dip;
 326
 327         /* create minor node 0 for daemon-driver synchronization */
 328         if (vscan_drv_create_node(0) == B_FALSE)
 329                 return (DDI_FAILURE);
 330
 331         vscan_drv_state = VS_DRV_IDLE;
 332         return (DDI_SUCCESS);
 333 }
 334
 335
 336 /*
 337  * vscan_drv_detach
 338  */
 339 static int
 340 vscan_drv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 341 {
 342         int i;
 343
 344         if (cmd != DDI_DETACH)
 345                 return (DDI_FAILURE);
 346
 347         if (ddi_get_instance(dip) != 0)
 348                 return (DDI_FAILURE);
 349
 350         if (vscan_drv_in_use())
 351                 return (DDI_FAILURE);
 352
 353         /* remove all minor nodes */
 354         vscan_drv_dip = NULL;
 355         ddi_remove_minor_node(dip, NULL);
 356         for (i = 0; i <= vs_nodes_max; i++)
 357                 vscan_drv_inst_state[i] = VS_DRV_INST_UNCONFIG;
 358
 359         vscan_drv_state = VS_DRV_UNCONFIG;
 360         return (DDI_SUCCESS);
 361 }
 362
 363
 364 /*
 365  * vscan_drv_in_use
 366  *
 367  * If the driver state is not IDLE or UNCONFIG then the
 368  * driver is in use. Otherwise, check the service interface
 369  * (vscan_svc) to see if it is still in use - for example
 370  * there there may be requests still in progress.
 371  */
 372 static boolean_t
 373 vscan_drv_in_use()
 374 {
 375         boolean_t in_use = B_FALSE;
 376
 377         mutex_enter(&vscan_drv_mutex);
 378         if ((vscan_drv_state != VS_DRV_IDLE) &&
 379             (vscan_drv_state != VS_DRV_UNCONFIG)) {
 380                 in_use = B_TRUE;
 381         }
 382         mutex_exit(&vscan_drv_mutex);
 383
 384         if (in_use)
 385                 return (B_TRUE);
 386         else
 387                 return (vscan_svc_in_use());
 388 }
 389
 390
 391 /*
 392  * vscan_drv_open
 393  *
 394  * If inst == 0, this is vscand initializing.
 395  * If the driver is in DELAYED_DISABLE, ie vscand previously
 396  * disconnected without a clean shutdown and the driver is
 397  * waiting for a period to allow vscand to reconnect, signal
 398  * vscan_drv_cv to cancel the delayed disable.
 399  *
 400  * If inst != 0, open the file associated with inst.
 401  */
 402 /* ARGSUSED */
 403 static int
 404 vscan_drv_open(dev_t *devp, int flag, int otyp, cred_t *credp)
 405 {
 406         int rc;
 407         int inst = getminor(*devp);
 408
 409         if ((inst < 0) || (inst > vs_nodes_max))
 410                 return (EINVAL);
 411
 412         /* check if caller has privilege for virus scanning */
 413         if ((rc = secpolicy_vscan(credp)) != 0) {
 414                 DTRACE_PROBE1(vscan__priv, int, rc);
 415                 return (EPERM);
 416         }
 417
 418         mutex_enter(&vscan_drv_mutex);
 419         if (inst == 0) {
 420                 switch (vscan_drv_state) {
 421                 case VS_DRV_IDLE:
 422                         vscan_drv_state = VS_DRV_CONNECTED;
 423                         break;
 424                 case VS_DRV_DELAYED_DISABLE:
 425                         cv_signal(&vscan_drv_cv);
 426                         vscan_drv_state = VS_DRV_CONNECTED;
 427                         break;
 428                 default:
 429                         DTRACE_PROBE1(vscan__drv__state__violation,
 430                             int, vscan_drv_state);
 431                         mutex_exit(&vscan_drv_mutex);
 432                         return (EINVAL);
 433                 }
 434         } else {
 435                 if ((vscan_drv_state != VS_DRV_ENABLED) ||
 436                     (vscan_drv_inst_state[inst] != VS_DRV_INST_INIT)) {
 437                         mutex_exit(&vscan_drv_mutex);
 438                         return (EINVAL);
 439                 }
 440                 vscan_drv_inst_state[inst] = VS_DRV_INST_OPEN;
 441         }
 442         mutex_exit(&vscan_drv_mutex);
 443
 444         return (0);
 445 }
 446
 447
 448 /*
 449  * vscan_drv_close
 450  *
 451  * If inst == 0, this is vscand detaching.
 452  * If the driver is in ENABLED state vscand has terminated without
 453  * a clean shutdown (nod DISABLE received). Enter DELAYED_DISABLE
 454  * state and initiate a delayed disable to allow vscand time to
 455  * reconnect.
 456  *
 457  * If inst != 0, close the file associated with inst
 458  */
 459 /* ARGSUSED */
 460 static int
 461 vscan_drv_close(dev_t dev, int flag, int otyp, cred_t *credp)
 462 {
 463         int i, inst = getminor(dev);
 464
 465         if ((inst < 0) || (inst > vs_nodes_max))
 466                 return (EINVAL);
 467
 468         mutex_enter(&vscan_drv_mutex);
 469         if (inst != 0) {
 470                 vscan_drv_inst_state[inst] = VS_DRV_INST_INIT;
 471                 mutex_exit(&vscan_drv_mutex);
 472                 return (0);
 473         }
 474
 475         /* instance 0 - daemon disconnect */
 476         if ((vscan_drv_state != VS_DRV_CONNECTED) &&
 477             (vscan_drv_state != VS_DRV_ENABLED)) {
 478                 DTRACE_PROBE1(vscan__drv__state__violation,
 479                     int, vscan_drv_state);
 480                 mutex_exit(&vscan_drv_mutex);
 481                 return (EINVAL);
 482         }
 483
 484         for (i = 1; i <= vs_nodes_max; i++) {
 485                 if (vscan_drv_inst_state[i] != VS_DRV_INST_UNCONFIG)
 486                         vscan_drv_inst_state[i] = VS_DRV_INST_INIT;
 487         }
 488
 489         if (vscan_drv_state == VS_DRV_CONNECTED) {
 490                 vscan_drv_state = VS_DRV_IDLE;
 491         } else { /* VS_DRV_ENABLED */
 492                 cmn_err(CE_WARN, "Detected vscand exit without clean shutdown");
 493                 if (thread_create(NULL, 0, vscan_drv_delayed_disable,
 494                     0, 0, &p0, TS_RUN, minclsyspri) == NULL) {
 495                         vscan_svc_disable();
 496                         vscan_drv_state = VS_DRV_IDLE;
 497                 } else {
 498                         vscan_drv_state = VS_DRV_DELAYED_DISABLE;
 499                 }
 500         }
 501         mutex_exit(&vscan_drv_mutex);
 502
 503         vscan_svc_scan_abort();
 504         vscan_door_close();
 505         return (0);
 506 }
 507
 508
 509 /*
 510  * vscan_drv_delayed_disable
 511  *
 512  * Invoked from vscan_drv_close if the daemon disconnects
 513  * without first sending disable (e.g. daemon crashed).
 514  * Delays for vs_reconnect_timeout before disabling, to allow
 515  * the daemon to reconnect. During this time, scan requests
 516  * will be processed locally (see vscan_svc.c)
 517  */
 518 static void
 519 vscan_drv_delayed_disable(void)
 520 {
 521         mutex_enter(&vscan_drv_mutex);
 522         (void) cv_reltimedwait(&vscan_drv_cv, &vscan_drv_mutex,
 523             SEC_TO_TICK(vs_reconnect_timeout), TR_CLOCK_TICK);
 524
 525         if (vscan_drv_state == VS_DRV_DELAYED_DISABLE) {
 526                 vscan_svc_disable();
 527                 vscan_drv_state = VS_DRV_IDLE;
 528         } else {
 529                 DTRACE_PROBE(vscan__reconnect);
 530         }
 531         mutex_exit(&vscan_drv_mutex);
 532 }
 533
 534
 535 /*
 536  * vscan_drv_read
 537  */
 538 /* ARGSUSED */
 539 static int
 540 vscan_drv_read(dev_t dev, struct uio *uiop, cred_t *credp)
 541 {
 542         int rc;
 543         int inst = getminor(dev);
 544         vnode_t *vp;
 545
 546         if ((inst <= 0) || (inst > vs_nodes_max))
 547                 return (EINVAL);
 548
 549         mutex_enter(&vscan_drv_mutex);
 550         if ((vscan_drv_state != VS_DRV_ENABLED) ||
 551             (vscan_drv_inst_state[inst] != VS_DRV_INST_OPEN)) {
 552                 mutex_exit(&vscan_drv_mutex);
 553                 return (EINVAL);
 554         }
 555         vscan_drv_inst_state[inst] = VS_DRV_INST_READING;
 556         mutex_exit(&vscan_drv_mutex);
 557
 558         if ((vp = vscan_svc_get_vnode(inst)) == NULL)
 559                 return (EINVAL);
 560
 561         (void) fop_rwlock(vp, V_WRITELOCK_FALSE, NULL);
 562         rc = fop_read(vp, uiop, 0, kcred, NULL);
 563         fop_rwunlock(vp, V_WRITELOCK_FALSE, NULL);
 564
 565         mutex_enter(&vscan_drv_mutex);
 566         if (vscan_drv_inst_state[inst] == VS_DRV_INST_READING)
 567                 vscan_drv_inst_state[inst] = VS_DRV_INST_OPEN;
 568         mutex_exit(&vscan_drv_mutex);
 569
 570         return (rc);
 571 }
 572
 573
 574 /*
 575  * vscan_drv_ioctl
 576  *
 577  * Process ioctls from vscand:
 578  * VS_IOCTL_ENABLE - vscand is ready to handle scan requests,
 579  *    enable VFS interface.
 580  * VS_IOCTL_DISABLE - vscand is shutting down, disable VFS interface
 581  * VS_IOCTL_RESULT - scan response data
 582  * VS_IOCTL_CONFIG - configuration data from vscand
 583  * VS_IOCTL_MAX_REQ - provide the max request idx to vscand,
 584  *    to allow vscand to set appropriate resource allocation limits
 585  */
 586 /* ARGSUSED */
 587 static int
 588 vscan_drv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
 589         cred_t *credp, int *rvalp)
 590 {
 591         int inst = getminor(dev);
 592         vs_config_t conf;
 593         vs_scan_rsp_t rsp;
 594
 595         if (inst != 0)
 596                 return (EINVAL);
 597
 598         switch (cmd) {
 599         case VS_IOCTL_ENABLE:
 600                 mutex_enter(&vscan_drv_mutex);
 601                 if (vscan_drv_state != VS_DRV_CONNECTED) {
 602                         DTRACE_PROBE1(vscan__drv__state__violation,
 603                             int, vscan_drv_state);
 604                         mutex_exit(&vscan_drv_mutex);
 605                         return (EINVAL);
 606                 }
 607                 if ((vscan_door_open((int)arg) != 0) ||
 608                     (vscan_svc_enable() != 0)) {
 609                         mutex_exit(&vscan_drv_mutex);
 610                         return (EINVAL);
 611                 }
 612                 vscan_drv_state = VS_DRV_ENABLED;
 613                 mutex_exit(&vscan_drv_mutex);
 614                 break;
 615
 616         case VS_IOCTL_DISABLE:
 617                 mutex_enter(&vscan_drv_mutex);
 618                 if (vscan_drv_state != VS_DRV_ENABLED) {
 619                         DTRACE_PROBE1(vscan__drv__state__violation,
 620                             int, vscan_drv_state);
 621                         mutex_exit(&vscan_drv_mutex);
 622                         return (EINVAL);
 623                 }
 624                 vscan_svc_disable();
 625                 vscan_drv_state = VS_DRV_CONNECTED;
 626                 mutex_exit(&vscan_drv_mutex);
 627                 break;
 628
 629         case VS_IOCTL_RESULT:
 630                 if (ddi_copyin((void *)arg, &rsp,
 631                     sizeof (vs_scan_rsp_t), 0) == -1)
 632                         return (EFAULT);
 633                 else
 634                         vscan_svc_scan_result(&rsp);
 635                 break;
 636
 637         case VS_IOCTL_CONFIG:
 638                 if (ddi_copyin((void *)arg, &conf,
 639                     sizeof (vs_config_t), 0) == -1)
 640                         return (EFAULT);
 641                 if (vscan_svc_configure(&conf) == -1)
 642                         return (EINVAL);
 643                 break;
 644
 645         case VS_IOCTL_MAX_REQ:
 646                 if (ddi_copyout(&vs_nodes_max, (void *)arg,
 647                     sizeof (uint32_t), 0) == -1)
 648                         return (EFAULT);
 649                 break;
 650
 651         default:
 652                 return (ENOTTY);
 653         }
 654
 655         return (0);
 656 }
 657
 658
 659 /*
 660  * vscan_drv_create_node
 661  *
 662  * Create minor node with which vscan daemon will communicate
 663  * to access a file. Invoked from vscan_svc before scan request
 664  * sent up to daemon.
 665  * Minor node 0 is reserved for daemon-driver synchronization
 666  * and is created during attach.
 667  * All minor nodes are removed during detach.
 668  */
 669 boolean_t
 670 vscan_drv_create_node(int idx)
 671 {
 672         char name[VS_NODENAME_LEN];
 673         boolean_t rc = B_TRUE;
 674
 675         mutex_enter(&vscan_drv_mutex);
 676
 677         if (vscan_drv_inst_state[idx] == VS_DRV_INST_UNCONFIG) {
 678                 (void) snprintf(name, VS_NODENAME_LEN, "vscan%d", idx);
 679                 if (ddi_create_minor_node(vscan_drv_dip, name,
 680                     S_IFCHR, idx, DDI_PSEUDO, 0) == DDI_SUCCESS) {
 681                         vscan_drv_inst_state[idx] = VS_DRV_INST_INIT;
 682                 } else {
 683                         rc = B_FALSE;
 684                 }
 685                 DTRACE_PROBE2(vscan__minor__node, int, idx, int, rc);
 686         }
 687
 688         mutex_exit(&vscan_drv_mutex);
 689
 690         return (rc);
 691 }