patch tsoome-feedback
6659 nvlist_free(NULL) is a no-op

   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 (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 
  26 /*
  27  * Devfsadm replaces drvconfig, audlinks, disks, tapes, ports, devlinks
  28  * as a general purpose device administrative utility.  It creates
  29  * devices special files in /devices and logical links in /dev, and
  30  * coordinates updates to /etc/path_to_instance with the kernel.  It
  31  * operates in both command line mode to handle user or script invoked
  32  * reconfiguration updates, and operates in daemon mode to handle dynamic
  33  * reconfiguration for hotplugging support.
  34  */
  35 
  36 #include <string.h>
  37 #include <deflt.h>
  38 #include <tsol/label.h>
  39 #include <bsm/devices.h>
  40 #include <bsm/devalloc.h>
  41 #include <utime.h>
  42 #include <sys/param.h>
  43 #include <bsm/libbsm.h>
  44 #include <zone.h>
  45 #include "devfsadm_impl.h"
  46 
  47 /* externs from devalloc.c */
  48 extern void  _reset_devalloc(int);
  49 extern void _update_devalloc_db(devlist_t *, int, int, char *, char *);
  50 extern int _da_check_for_usb(char *, char *);
  51 
  52 /* create or remove nodes or links. unset with -n */
  53 static int file_mods = TRUE;
  54 
  55 /* cleanup mode.  Set with -C */
  56 static int cleanup = FALSE;
  57 
  58 /* devlinks -d compatibility */
  59 static int devlinks_debug = FALSE;
  60 
  61 /* flag to check if system is labeled */
  62 int system_labeled = FALSE;
  63 
  64 /* flag to enable/disable device allocation with -e/-d */
  65 static int devalloc_flag = 0;
  66 
  67 /* flag that indicates if device allocation is on or not */
  68 static int devalloc_is_on = 0;
  69 
  70 /* flag to update device allocation database for this device type */
  71 static int update_devdb = 0;
  72 
  73 /*
  74  * devices to be deallocated with -d :
  75  *      audio, floppy, cd, floppy, tape, rmdisk.
  76  */
  77 static char *devalloc_list[10] = {DDI_NT_AUDIO, DDI_NT_CD, DDI_NT_CD_CHAN,
  78                                     DDI_NT_FD, DDI_NT_TAPE, DDI_NT_BLOCK_CHAN,
  79                                     DDI_NT_UGEN, DDI_NT_USB_ATTACHMENT_POINT,
  80                                     DDI_NT_SCSI_NEXUS, NULL};
  81 
  82 /* list of allocatable devices */
  83 static devlist_t devlist;
  84 
  85 /* load a single driver only.  set with -i */
  86 static int single_drv = FALSE;
  87 static char *driver = NULL;
  88 
  89 /* attempt to load drivers or defer attach nodes */
  90 static int load_attach_drv = TRUE;
  91 
  92 /* reload all driver.conf files */
  93 static int update_all_drivers = FALSE;
  94 
  95 /* set if invoked via /usr/lib/devfsadm/devfsadmd */
  96 static int daemon_mode = FALSE;
  97 
  98 /* set if event_handler triggered */
  99 int event_driven = FALSE;
 100 
 101 /* output directed to syslog during daemon mode if set */
 102 static int logflag = FALSE;
 103 
 104 /* build links in /dev.  -x to turn off */
 105 static int build_dev = TRUE;
 106 
 107 /* build nodes in /devices.  -y to turn off */
 108 static int build_devices = TRUE;
 109 
 110 /* -z to turn off */
 111 static int flush_path_to_inst_enable = TRUE;
 112 
 113 /* variables used for path_to_inst flushing */
 114 static int inst_count = 0;
 115 static mutex_t count_lock;
 116 static cond_t cv;
 117 
 118 /* variables for minor_fini thread */
 119 static mutex_t minor_fini_mutex;
 120 static int minor_fini_canceled = TRUE;
 121 static int minor_fini_delayed = FALSE;
 122 static cond_t minor_fini_cv;
 123 static int minor_fini_timeout = MINOR_FINI_TIMEOUT_DEFAULT;
 124 
 125 /* single-threads /dev modification */
 126 static sema_t dev_sema;
 127 
 128 /* the program we were invoked as; ie argv[0] */
 129 static char *prog;
 130 
 131 /* pointers to create/remove link lists */
 132 static create_list_t *create_head = NULL;
 133 static remove_list_t *remove_head = NULL;
 134 
 135 /*  supports the class -c option */
 136 static char **classes = NULL;
 137 static int num_classes = 0;
 138 
 139 /* used with verbose option -v or -V */
 140 static int num_verbose = 0;
 141 static char **verbose = NULL;
 142 
 143 static struct mperm *minor_perms = NULL;
 144 static driver_alias_t *driver_aliases = NULL;
 145 
 146 /* set if -r alternate root given */
 147 static char *root_dir = "";
 148 
 149 /* /devices or <rootdir>/devices */
 150 static char *devices_dir  = DEVICES;
 151 
 152 /* /dev or <rootdir>/dev */
 153 static char *dev_dir = DEV;
 154 
 155 /* /etc/dev or <rootdir>/etc/dev */
 156 static char *etc_dev_dir = ETCDEV;
 157 
 158 /*
 159  * writable root (for lock files and doors during install).
 160  * This is also root dir for /dev attr dir during install.
 161  */
 162 static char *attr_root = NULL;
 163 
 164 /* /etc/path_to_inst unless -p used */
 165 static char *inst_file = INSTANCE_FILE;
 166 
 167 /* /usr/lib/devfsadm/linkmods unless -l used */
 168 static char *module_dirs = MODULE_DIRS;
 169 
 170 /* default uid/gid used if /etc/minor_perm entry not found */
 171 static uid_t root_uid;
 172 static gid_t sys_gid;
 173 
 174 /* /etc/devlink.tab unless devlinks -t used */
 175 static char *devlinktab_file = NULL;
 176 
 177 /* File and data structure to reserve enumerate IDs */
 178 static char *enumerate_file = ENUMERATE_RESERVED;
 179 static enumerate_file_t *enumerate_reserved = NULL;
 180 
 181 /* set if /dev link is new. speeds up rm_stale_links */
 182 static int linknew = TRUE;
 183 
 184 /* variables for devlink.tab compat processing */
 185 static devlinktab_list_t *devlinktab_list = NULL;
 186 static unsigned int devlinktab_line = 0;
 187 
 188 /* cache head for devfsadm_enumerate*() functions */
 189 static numeral_set_t *head_numeral_set = NULL;
 190 
 191 /* list list of devfsadm modules */
 192 static module_t *module_head = NULL;
 193 
 194 /* name_to_major list used in utility function */
 195 static n2m_t *n2m_list = NULL;
 196 
 197 /* cache of some links used for performance */
 198 static linkhead_t *headlinkhead = NULL;
 199 
 200 /* locking variables to prevent multiples writes to /dev */
 201 static int hold_dev_lock = FALSE;
 202 static int hold_daemon_lock = FALSE;
 203 static int dev_lock_fd;
 204 static int daemon_lock_fd;
 205 static char dev_lockfile[PATH_MAX + 1];
 206 static char daemon_lockfile[PATH_MAX + 1];
 207 
 208 /* last devinfo node/minor processed. used for performance */
 209 static di_node_t lnode;
 210 static di_minor_t lminor;
 211 static char lphy_path[PATH_MAX + 1] = {""};
 212 
 213 /* Globals used by the link database */
 214 static di_devlink_handle_t devlink_cache;
 215 static int update_database = FALSE;
 216 
 217 /* Globals used to set logindev perms */
 218 static struct login_dev *login_dev_cache = NULL;
 219 static int login_dev_enable = FALSE;
 220 
 221 /* Global to use devinfo snapshot cache */
 222 static int use_snapshot_cache = FALSE;
 223 
 224 /* Global for no-further-processing hash */
 225 static item_t **nfp_hash;
 226 static mutex_t  nfp_mutex = DEFAULTMUTEX;
 227 
 228 /*
 229  * Directories not removed even when empty.  They are packaged, or may
 230  * be referred to from a non-global zone.  The dirs must be listed in
 231  * canonical form i.e. without leading "/dev/"
 232  */
 233 static char *sticky_dirs[] =
 234         {"dsk", "rdsk", "term", "lofi", "rlofi", NULL};
 235 
 236 /* Devname globals */
 237 static int lookup_door_fd = -1;
 238 static char *lookup_door_path;
 239 
 240 static void load_dev_acl(void);
 241 static void update_drvconf(major_t, int);
 242 static void check_reconfig_state(void);
 243 static int s_stat(const char *, struct stat *);
 244 
 245 static int is_blank(char *);
 246 
 247 /* sysevent queue related globals */
 248 static mutex_t  syseventq_mutex = DEFAULTMUTEX;
 249 static syseventq_t *syseventq_front;
 250 static syseventq_t *syseventq_back;
 251 static void process_syseventq();
 252 
 253 static di_node_t devi_root_node = DI_NODE_NIL;
 254 
 255 int
 256 main(int argc, char *argv[])
 257 {
 258         struct passwd *pw;
 259         struct group *gp;
 260         pid_t pid;
 261 
 262         (void) setlocale(LC_ALL, "");
 263         (void) textdomain(TEXT_DOMAIN);
 264 
 265         if ((prog = strrchr(argv[0], '/')) == NULL) {
 266                 prog = argv[0];
 267         } else {
 268                 prog++;
 269         }
 270 
 271         if (getuid() != 0) {
 272                 err_print(MUST_BE_ROOT);
 273                 devfsadm_exit(1);
 274                 /*NOTREACHED*/
 275         }
 276 
 277         if (getzoneid() != GLOBAL_ZONEID) {
 278                 err_print(MUST_BE_GLOBAL_ZONE);
 279                 devfsadm_exit(1);
 280         }
 281 
 282         /*
 283          * Close all files except stdin/stdout/stderr
 284          */
 285         closefrom(3);
 286 
 287         if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) {
 288                 root_uid = pw->pw_uid;
 289         } else {
 290                 err_print(CANT_FIND_USER, DEFAULT_DEV_USER);
 291                 root_uid = (uid_t)0;    /* assume 0 is root */
 292         }
 293 
 294         /* the default group is sys */
 295 
 296         if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) {
 297                 sys_gid = gp->gr_gid;
 298         } else {
 299                 err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP);
 300                 sys_gid = (gid_t)3;     /* assume 3 is sys */
 301         }
 302 
 303         (void) umask(0);
 304 
 305         system_labeled = is_system_labeled();
 306         if (system_labeled == FALSE) {
 307                 /*
 308                  * is_system_labeled() will return false in case we are
 309                  * starting before the first reboot after Trusted Extensions
 310                  * is enabled.  Check the setting in /etc/system to see if
 311                  * TX is enabled (even if not yet booted).
 312                  */
 313                 if (defopen("/etc/system") == 0) {
 314                         if (defread("set sys_labeling=1") != NULL)
 315                                 system_labeled = TRUE;
 316 
 317                         /* close defaults file */
 318                         (void) defopen(NULL);
 319                 }
 320         }
 321         /*
 322          * Check if device allocation is enabled.
 323          */
 324         devalloc_is_on = (da_is_on() == 1) ? 1 : 0;
 325 
 326 #ifdef DEBUG
 327         if (system_labeled == FALSE) {
 328                 struct stat tx_stat;
 329 
 330                 /* test hook: see also mkdevalloc.c and allocate.c */
 331                 system_labeled = is_system_labeled_debug(&tx_stat);
 332         }
 333 #endif
 334 
 335         parse_args(argc, argv);
 336 
 337         (void) sema_init(&dev_sema, 1, USYNC_THREAD, NULL);
 338 
 339         /* Initialize device allocation list */
 340         devlist.audio = devlist.cd = devlist.floppy = devlist.tape =
 341             devlist.rmdisk = NULL;
 342 
 343         if (daemon_mode == TRUE) {
 344                 /*
 345                  * Build /dev and /devices before daemonizing if
 346                  * reconfig booting and daemon invoked with alternate
 347                  * root. This is to support install.
 348                  */
 349                 if (getenv(RECONFIG_BOOT) != NULL && root_dir[0] != '\0') {
 350                         vprint(INFO_MID, CONFIGURING);
 351                         load_dev_acl();
 352                         update_drvconf((major_t)-1, 0);
 353                         process_devinfo_tree();
 354                         (void) modctl(MODSETMINIROOT);
 355                 }
 356 
 357                 /*
 358                  * fork before detaching from tty in order to print error
 359                  * message if unable to acquire file lock.  locks not preserved
 360                  * across forks.  Even under debug we want to fork so that
 361                  * when executed at boot we don't hang.
 362                  */
 363                 if (fork() != 0) {
 364                         devfsadm_exit(0);
 365                         /*NOTREACHED*/
 366                 }
 367 
 368                 /* set directory to / so it coredumps there */
 369                 if (chdir("/") == -1) {
 370                         err_print(CHROOT_FAILED, strerror(errno));
 371                 }
 372 
 373                 /* only one daemon can run at a time */
 374                 if ((pid = enter_daemon_lock()) == getpid()) {
 375                         detachfromtty();
 376                         (void) cond_init(&cv, USYNC_THREAD, 0);
 377                         (void) mutex_init(&count_lock, USYNC_THREAD, 0);
 378                         if (thr_create(NULL, NULL,
 379                             (void *(*)(void *))instance_flush_thread,
 380                             NULL, THR_DETACHED, NULL) != 0) {
 381                                 err_print(CANT_CREATE_THREAD, "daemon",
 382                                     strerror(errno));
 383                                 devfsadm_exit(1);
 384                                 /*NOTREACHED*/
 385                         }
 386 
 387                         /* start the minor_fini_thread */
 388                         (void) mutex_init(&minor_fini_mutex, USYNC_THREAD, 0);
 389                         (void) cond_init(&minor_fini_cv, USYNC_THREAD, 0);
 390                         if (thr_create(NULL, NULL,
 391                             (void *(*)(void *))minor_fini_thread,
 392                             NULL, THR_DETACHED, NULL)) {
 393                                 err_print(CANT_CREATE_THREAD, "minor_fini",
 394                                     strerror(errno));
 395                                 devfsadm_exit(1);
 396                                 /*NOTREACHED*/
 397                         }
 398 
 399 
 400                         /*
 401                          * logindevperms need only be set
 402                          * in daemon mode and when root dir is "/".
 403                          */
 404                         if (root_dir[0] == '\0')
 405                                 login_dev_enable = TRUE;
 406                         daemon_update();
 407                         devfsadm_exit(0);
 408                         /*NOTREACHED*/
 409                 } else {
 410                         err_print(DAEMON_RUNNING, pid);
 411                         devfsadm_exit(1);
 412                         /*NOTREACHED*/
 413                 }
 414         } else {
 415                 /* not a daemon, so just build /dev and /devices */
 416 
 417                 /*
 418                  * If turning off device allocation, load the
 419                  * minor_perm file because process_devinfo_tree() will
 420                  * need this in order to reset the permissions of the
 421                  * device files.
 422                  */
 423                 if (devalloc_flag == DA_OFF) {
 424                         read_minor_perm_file();
 425                 }
 426 
 427                 process_devinfo_tree();
 428                 if (devalloc_flag != 0)
 429                         /* Enable/disable device allocation */
 430                         _reset_devalloc(devalloc_flag);
 431         }
 432         return (0);
 433 }
 434 
 435 static void
 436 update_drvconf(major_t major, int flags)
 437 {
 438         if (modctl(MODLOADDRVCONF, major, flags) != 0)
 439                 err_print(gettext("update_drvconf failed for major %d\n"),
 440                     major);
 441 }
 442 
 443 static void
 444 load_dev_acl()
 445 {
 446         if (load_devpolicy() != 0)
 447                 err_print(gettext("device policy load failed\n"));
 448         load_minor_perm_file();
 449 }
 450 
 451 /*
 452  * As devfsadm is run early in boot to provide the kernel with
 453  * minor_perm info, we might as well check for reconfig at the
 454  * same time to avoid running devfsadm twice.  This gets invoked
 455  * earlier than the env variable RECONFIG_BOOT is set up.
 456  */
 457 static void
 458 check_reconfig_state()
 459 {
 460         struct stat sb;
 461 
 462         if (s_stat("/reconfigure", &sb) == 0) {
 463                 (void) modctl(MODDEVNAME, MODDEVNAME_RECONFIG, 0);
 464         }
 465 }
 466 
 467 static void
 468 modctl_sysavail()
 469 {
 470         /*
 471          * Inform /dev that system is available, that
 472          * implicit reconfig can now be performed.
 473          */
 474         (void) modctl(MODDEVNAME, MODDEVNAME_SYSAVAIL, 0);
 475 }
 476 
 477 static void
 478 set_lock_root(void)
 479 {
 480         struct stat sb;
 481         char *lock_root;
 482         size_t len;
 483 
 484         lock_root = attr_root ? attr_root : root_dir;
 485 
 486         len = strlen(lock_root) + strlen(ETCDEV) + 1;
 487         etc_dev_dir = s_malloc(len);
 488         (void) snprintf(etc_dev_dir, len, "%s%s", lock_root, ETCDEV);
 489 
 490         if (s_stat(etc_dev_dir, &sb) != 0) {
 491                 s_mkdirp(etc_dev_dir, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
 492         } else if (!S_ISDIR(sb.st_mode)) {
 493                 err_print(NOT_DIR, etc_dev_dir);
 494                 devfsadm_exit(1);
 495                 /*NOTREACHED*/
 496         }
 497 }
 498 
 499 
 500 /*
 501  * Parse arguments for all 6 programs handled from devfsadm.
 502  */
 503 static void
 504 parse_args(int argc, char *argv[])
 505 {
 506         char opt;
 507         char get_linkcompat_opts = FALSE;
 508         char *compat_class;
 509         int num_aliases = 0;
 510         int len;
 511         int retval;
 512         int config = TRUE;
 513         int bind = FALSE;
 514         int force_flag = FALSE;
 515         struct aliases *ap = NULL;
 516         struct aliases *a_head = NULL;
 517         struct aliases *a_tail = NULL;
 518         struct modconfig mc;
 519 
 520         (void) bzero(&mc, sizeof (mc));
 521 
 522         if (strcmp(prog, DISKS) == 0) {
 523                 compat_class = "disk";
 524                 get_linkcompat_opts = TRUE;
 525 
 526         } else if (strcmp(prog, TAPES) == 0) {
 527                 compat_class = "tape";
 528                 get_linkcompat_opts = TRUE;
 529 
 530         } else if (strcmp(prog, PORTS) == 0) {
 531                 compat_class = "port";
 532                 get_linkcompat_opts = TRUE;
 533 
 534         } else if (strcmp(prog, AUDLINKS) == 0) {
 535                 compat_class = "audio";
 536                 get_linkcompat_opts = TRUE;
 537 
 538         } else if (strcmp(prog, DEVLINKS) == 0) {
 539                 devlinktab_file = DEVLINKTAB_FILE;
 540 
 541                 build_devices = FALSE;
 542                 load_attach_drv = FALSE;
 543 
 544                 while ((opt = getopt(argc, argv, "dnr:st:vV:")) != EOF) {
 545                         switch (opt) {
 546                         case 'd':
 547                                 file_mods = FALSE;
 548                                 flush_path_to_inst_enable = FALSE;
 549                                 devlinks_debug = TRUE;
 550                                 break;
 551                         case 'n':
 552                                 /* prevent driver loading and deferred attach */
 553                                 load_attach_drv = FALSE;
 554                                 break;
 555                         case 'r':
 556                                 set_root_devices_dev_dir(optarg);
 557                                 if (zone_pathcheck(root_dir) !=
 558                                     DEVFSADM_SUCCESS)
 559                                         devfsadm_exit(1);
 560                                         /*NOTREACHED*/
 561                                 break;
 562                         case 's':
 563                                 /*
 564                                  * suppress.  don't create/remove links/nodes
 565                                  * useful with -v or -V
 566                                  */
 567                                 file_mods = FALSE;
 568                                 flush_path_to_inst_enable = FALSE;
 569                                 break;
 570                         case 't':
 571                                 /* supply a non-default table file */
 572                                 devlinktab_file = optarg;
 573                                 break;
 574                         case 'v':
 575                                 /* documented verbose flag */
 576                                 add_verbose_id(VERBOSE_MID);
 577                                 break;
 578                         case 'V':
 579                                 /* undocumented for extra verbose levels */
 580                                 add_verbose_id(optarg);
 581                                 break;
 582                         default:
 583                                 usage();
 584                                 break;
 585                         }
 586                 }
 587 
 588                 if (optind < argc) {
 589                         usage();
 590                 }
 591 
 592         } else if (strcmp(prog, DRVCONFIG) == 0) {
 593                 int update_only = 0;
 594                 build_dev = FALSE;
 595 
 596                 while ((opt =
 597                     getopt(argc, argv, "a:bc:dfi:m:np:R:r:suvV:x")) != EOF) {
 598                         switch (opt) {
 599                         case 'a':
 600                                 ap = calloc(sizeof (struct aliases), 1);
 601                                 ap->a_name = dequote(optarg);
 602                                 len = strlen(ap->a_name) + 1;
 603                                 if (len > MAXMODCONFNAME) {
 604                                         err_print(ALIAS_TOO_LONG,
 605                                             MAXMODCONFNAME, ap->a_name);
 606                                         devfsadm_exit(1);
 607                                         /*NOTREACHED*/
 608                                 }
 609                                 ap->a_len = len;
 610                                 if (a_tail == NULL) {
 611                                         a_head = ap;
 612                                 } else {
 613                                         a_tail->a_next = ap;
 614                                 }
 615                                 a_tail = ap;
 616                                 num_aliases++;
 617                                 bind = TRUE;
 618                                 break;
 619                         case 'b':
 620                                 bind = TRUE;
 621                                 break;
 622                         case 'c':
 623                                 (void) strcpy(mc.drvclass, optarg);
 624                                 break;
 625                         case 'd':
 626                                 /*
 627                                  * need to keep for compatibility, but
 628                                  * do nothing.
 629                                  */
 630                                 break;
 631                         case 'f':
 632                                 force_flag = TRUE;
 633                                 break;
 634                         case 'i':
 635                                 single_drv = TRUE;
 636                                 (void) strcpy(mc.drvname, optarg);
 637                                 driver = s_strdup(optarg);
 638                                 break;
 639                         case 'm':
 640                                 mc.major = atoi(optarg);
 641                                 break;
 642                         case 'n':
 643                                 /* prevent driver loading and deferred attach */
 644                                 load_attach_drv = FALSE;
 645                                 break;
 646                         case 'p':
 647                                 /* specify alternate path_to_inst file */
 648                                 inst_file = s_strdup(optarg);
 649                                 break;
 650                         case 'R':
 651                                 /*
 652                                  * Private flag for suninstall to populate
 653                                  * device information on the installed root.
 654                                  */
 655                                 root_dir = s_strdup(optarg);
 656                                 if (zone_pathcheck(root_dir) !=
 657                                     DEVFSADM_SUCCESS)
 658                                 devfsadm_exit(devfsadm_copy());
 659                                 /*NOTREACHED*/
 660                                 break;
 661                         case 'r':
 662                                 devices_dir = s_strdup(optarg);
 663                                 if (zone_pathcheck(devices_dir) !=
 664                                     DEVFSADM_SUCCESS)
 665                                         devfsadm_exit(1);
 666                                         /*NOTREACHED*/
 667                                 break;
 668                         case 's':
 669                                 /*
 670                                  * suppress.  don't create nodes
 671                                  * useful with -v or -V
 672                                  */
 673                                 file_mods = FALSE;
 674                                 flush_path_to_inst_enable = FALSE;
 675                                 break;
 676                         case 'u':
 677                                 /*
 678                                  * Invoked via update_drv(1m) to update
 679                                  * the kernel's driver/alias binding
 680                                  * when removing one or more aliases.
 681                                  */
 682                                 config = FALSE;
 683                                 break;
 684                         case 'v':
 685                                 /* documented verbose flag */
 686                                 add_verbose_id(VERBOSE_MID);
 687                                 break;
 688                         case 'V':
 689                                 /* undocumented for extra verbose levels */
 690                                 add_verbose_id(optarg);
 691                                 break;
 692                         case 'x':
 693                                 update_only = 1;
 694                                 break;
 695                         default:
 696                                 usage();
 697                         }
 698                 }
 699 
 700                 if (optind < argc) {
 701                         usage();
 702                 }
 703 
 704                 if (bind == TRUE) {
 705                         if ((mc.major == -1) || (mc.drvname[0] == NULL)) {
 706                                 err_print(MAJOR_AND_B_FLAG);
 707                                 devfsadm_exit(1);
 708                                 /*NOTREACHED*/
 709                         }
 710                         mc.flags = 0;
 711                         if (force_flag)
 712                                 mc.flags |= MOD_UNBIND_OVERRIDE;
 713                         if (update_only)
 714                                 mc.flags |= MOD_ADDMAJBIND_UPDATE;
 715                         mc.num_aliases = num_aliases;
 716                         mc.ap = a_head;
 717                         retval =  modctl((config == TRUE) ? MODADDMAJBIND :
 718                             MODREMDRVALIAS, NULL, (caddr_t)&mc);
 719                         if (retval < 0) {
 720                                 err_print((config == TRUE) ? MODCTL_ADDMAJBIND :
 721                                     MODCTL_REMMAJBIND);
 722                         }
 723                         devfsadm_exit(retval);
 724                         /*NOTREACHED*/
 725                 }
 726 
 727         } else if ((strcmp(prog, DEVFSADM) == 0) ||
 728             (strcmp(prog, DEVFSADMD) == 0)) {
 729                 char *zonename = NULL;
 730                 int init_drvconf = 0;
 731                 int init_perm = 0;
 732                 int public_mode = 0;
 733                 int init_sysavail = 0;
 734 
 735                 if (strcmp(prog, DEVFSADMD) == 0) {
 736                         daemon_mode = TRUE;
 737                 }
 738 
 739                 devlinktab_file = DEVLINKTAB_FILE;
 740 
 741                 while ((opt = getopt(argc, argv,
 742                     "a:Cc:deIi:l:np:PR:r:sSt:uvV:x:")) != EOF) {
 743                         if (opt == 'I' || opt == 'P' || opt == 'S') {
 744                                 if (public_mode)
 745                                         usage();
 746                         } else {
 747                                 if (init_perm || init_drvconf || init_sysavail)
 748                                         usage();
 749                                 public_mode = 1;
 750                         }
 751                         switch (opt) {
 752                         case 'a':
 753                                 attr_root = s_strdup(optarg);
 754                                 break;
 755                         case 'C':
 756                                 cleanup = TRUE;
 757                                 break;
 758                         case 'c':
 759                                 num_classes++;
 760                                 classes = s_realloc(classes,
 761                                     num_classes * sizeof (char *));
 762                                 classes[num_classes - 1] = optarg;
 763                                 break;
 764                         case 'd':
 765                                 if (daemon_mode == FALSE) {
 766                                         /*
 767                                          * Device allocation to be disabled.
 768                                          */
 769                                         devalloc_flag = DA_OFF;
 770                                         build_dev = FALSE;
 771                                 }
 772                                 break;
 773                         case 'e':
 774                                 if (daemon_mode == FALSE) {
 775                                         /*
 776                                          * Device allocation to be enabled.
 777                                          */
 778                                         devalloc_flag = DA_ON;
 779                                         build_dev = FALSE;
 780                                 }
 781                                 break;
 782                         case 'I':       /* update kernel driver.conf cache */
 783                                 if (daemon_mode == TRUE)
 784                                         usage();
 785                                 init_drvconf = 1;
 786                                 break;
 787                         case 'i':
 788                                 single_drv = TRUE;
 789                                 driver = s_strdup(optarg);
 790                                 break;
 791                         case 'l':
 792                                 /* specify an alternate module load path */
 793                                 module_dirs = s_strdup(optarg);
 794                                 break;
 795                         case 'n':
 796                                 /* prevent driver loading and deferred attach */
 797                                 load_attach_drv = FALSE;
 798                                 break;
 799                         case 'p':
 800                                 /* specify alternate path_to_inst file */
 801                                 inst_file = s_strdup(optarg);
 802                                 break;
 803                         case 'P':
 804                                 if (daemon_mode == TRUE)
 805                                         usage();
 806                                 /* load minor_perm and device_policy */
 807                                 init_perm = 1;
 808                                 break;
 809                         case 'R':
 810                                 /*
 811                                  * Private flag for suninstall to populate
 812                                  * device information on the installed root.
 813                                  */
 814                                 root_dir = s_strdup(optarg);
 815                                 devfsadm_exit(devfsadm_copy());
 816                                 /*NOTREACHED*/
 817                                 break;
 818                         case 'r':
 819                                 set_root_devices_dev_dir(optarg);
 820                                 break;
 821                         case 's':
 822                                 /*
 823                                  * suppress. don't create/remove links/nodes
 824                                  * useful with -v or -V
 825                                  */
 826                                 file_mods = FALSE;
 827                                 flush_path_to_inst_enable = FALSE;
 828                                 break;
 829                         case 'S':
 830                                 if (daemon_mode == TRUE)
 831                                         usage();
 832                                 init_sysavail = 1;
 833                                 break;
 834                         case 't':
 835                                 devlinktab_file = optarg;
 836                                 break;
 837                         case 'u':       /* complete configuration after */
 838                                         /* adding a driver update-only */
 839                                 if (daemon_mode == TRUE)
 840                                         usage();
 841                                 update_all_drivers = TRUE;
 842                                 break;
 843                         case 'v':
 844                                 /* documented verbose flag */
 845                                 add_verbose_id(VERBOSE_MID);
 846                                 break;
 847                         case 'V':
 848                                 /* undocumented: specify verbose lvl */
 849                                 add_verbose_id(optarg);
 850                                 break;
 851                         case 'x':
 852                                 /*
 853                                  * x is the "private switch" option.  The
 854                                  * goal is to not suck up all the other
 855                                  * option letters.
 856                                  */
 857                                 if (strcmp(optarg, "update_devlinksdb") == 0) {
 858                                         update_database = TRUE;
 859                                 } else if (strcmp(optarg, "no_dev") == 0) {
 860                                         /* don't build /dev */
 861                                         build_dev = FALSE;
 862                                 } else if (strcmp(optarg, "no_devices") == 0) {
 863                                         /* don't build /devices */
 864                                         build_devices = FALSE;
 865                                 } else if (strcmp(optarg, "no_p2i") == 0) {
 866                                         /* don't flush path_to_inst */
 867                                         flush_path_to_inst_enable = FALSE;
 868                                 } else if (strcmp(optarg, "use_dicache") == 0) {
 869                                         use_snapshot_cache = TRUE;
 870                                 } else {
 871                                         usage();
 872                                 }
 873                                 break;
 874                         default:
 875                                 usage();
 876                                 break;
 877                         }
 878                 }
 879                 if (optind < argc) {
 880                         usage();
 881                 }
 882 
 883                 /*
 884                  * We're not in zone mode; Check to see if the rootpath
 885                  * collides with any zonepaths.
 886                  */
 887                 if (zonename == NULL) {
 888                         if (zone_pathcheck(root_dir) != DEVFSADM_SUCCESS)
 889                                 devfsadm_exit(1);
 890                                 /*NOTREACHED*/
 891                 }
 892 
 893                 if (init_drvconf || init_perm || init_sysavail) {
 894                         /*
 895                          * Load minor perm before force-loading drivers
 896                          * so the correct permissions are picked up.
 897                          */
 898                         if (init_perm) {
 899                                 check_reconfig_state();
 900                                 load_dev_acl();
 901                         }
 902                         if (init_drvconf)
 903                                 update_drvconf((major_t)-1, 0);
 904                         if (init_sysavail)
 905                                 modctl_sysavail();
 906                         devfsadm_exit(0);
 907                         /*NOTREACHED*/
 908                 }
 909         }
 910 
 911 
 912         if (get_linkcompat_opts == TRUE) {
 913 
 914                 build_devices = FALSE;
 915                 load_attach_drv = FALSE;
 916                 num_classes++;
 917                 classes = s_realloc(classes, num_classes *
 918                     sizeof (char *));
 919                 classes[num_classes - 1] = compat_class;
 920 
 921                 while ((opt = getopt(argc, argv, "Cnr:svV:")) != EOF) {
 922                         switch (opt) {
 923                         case 'C':
 924                                 cleanup = TRUE;
 925                                 break;
 926                         case 'n':
 927                                 /* prevent driver loading or deferred attach */
 928                                 load_attach_drv = FALSE;
 929                                 break;
 930                         case 'r':
 931                                 set_root_devices_dev_dir(optarg);
 932                                 if (zone_pathcheck(root_dir) !=
 933                                     DEVFSADM_SUCCESS)
 934                                         devfsadm_exit(1);
 935                                         /*NOTREACHED*/
 936                                 break;
 937                         case 's':
 938                                 /* suppress.  don't create/remove links/nodes */
 939                                 /* useful with -v or -V */
 940                                 file_mods = FALSE;
 941                                 flush_path_to_inst_enable = FALSE;
 942                                 break;
 943                         case 'v':
 944                                 /* documented verbose flag */
 945                                 add_verbose_id(VERBOSE_MID);
 946                                 break;
 947                         case 'V':
 948                                 /* undocumented for extra verbose levels */
 949                                 add_verbose_id(optarg);
 950                                 break;
 951                         default:
 952                                 usage();
 953                         }
 954                 }
 955                 if (optind < argc) {
 956                         usage();
 957                 }
 958         }
 959         set_lock_root();
 960 }
 961 
 962 void
 963 usage(void)
 964 {
 965         if (strcmp(prog, DEVLINKS) == 0) {
 966                 err_print(DEVLINKS_USAGE);
 967         } else if (strcmp(prog, DRVCONFIG) == 0) {
 968                 err_print(DRVCONFIG_USAGE);
 969         } else if ((strcmp(prog, DEVFSADM) == 0) ||
 970             (strcmp(prog, DEVFSADMD) == 0)) {
 971                 err_print(DEVFSADM_USAGE);
 972         } else {
 973                 err_print(COMPAT_LINK_USAGE);
 974         }
 975 
 976         devfsadm_exit(1);
 977         /*NOTREACHED*/
 978 }
 979 
 980 static void
 981 devi_tree_walk(struct dca_impl *dcip, int flags, char *ev_subclass)
 982 {
 983         char *msg, *name;
 984         struct mlist    mlist = {0};
 985         di_node_t       node;
 986 
 987         vprint(CHATTY_MID, "devi_tree_walk: root=%s, minor=%s, driver=%s,"
 988             " error=%d, flags=%u\n", dcip->dci_root,
 989             dcip->dci_minor ? dcip->dci_minor : "<NULL>",
 990             dcip->dci_driver ? dcip->dci_driver : "<NULL>", dcip->dci_error,
 991             dcip->dci_flags);
 992 
 993         assert(dcip->dci_root);
 994 
 995         if (dcip->dci_flags & DCA_LOAD_DRV) {
 996                 node = di_init_driver(dcip->dci_driver, flags);
 997                 msg = DRIVER_FAILURE;
 998                 name = dcip->dci_driver;
 999         } else {
1000                 node = di_init(dcip->dci_root, flags);
1001                 msg = DI_INIT_FAILED;
1002                 name = dcip->dci_root;
1003         }
1004 
1005         if (node == DI_NODE_NIL) {
1006                 dcip->dci_error = errno;
1007                 /*
1008                  * Rapid hotplugging (commonly seen during USB testing),
1009                  * may remove a device before the create event for it
1010                  * has been processed. To prevent alarming users with
1011                  * a superfluous message, we suppress error messages
1012                  * for ENXIO and hotplug.
1013                  */
1014                 if (!(errno == ENXIO && (dcip->dci_flags & DCA_HOT_PLUG)))
1015                         err_print(msg, name, strerror(dcip->dci_error));
1016                 return;
1017         }
1018 
1019         if (dcip->dci_flags & DCA_FLUSH_PATHINST)
1020                 flush_path_to_inst();
1021 
1022         dcip->dci_arg = &mlist;
1023         devi_root_node = node;  /* protected by lock_dev() */
1024 
1025         vprint(CHATTY_MID, "walking device tree\n");
1026 
1027         (void) di_walk_minor(node, NULL, DI_CHECK_ALIAS, dcip,
1028             check_minor_type);
1029 
1030         process_deferred_links(dcip, DCA_CREATE_LINK);
1031 
1032         dcip->dci_arg = NULL;
1033 
1034         /*
1035          * Finished creating devfs files and dev links.
1036          * Log sysevent.
1037          */
1038         if (ev_subclass)
1039                 build_and_enq_event(EC_DEV_ADD, ev_subclass, dcip->dci_root,
1040                     node, dcip->dci_minor);
1041 
1042         /* Add new device to device allocation database */
1043         if (system_labeled && update_devdb) {
1044                 _update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir);
1045                 update_devdb = 0;
1046         }
1047 
1048         devi_root_node = DI_NODE_NIL;   /* protected by lock_dev() */
1049         di_fini(node);
1050 }
1051 
1052 static void
1053 process_deferred_links(struct dca_impl *dcip, int flags)
1054 {
1055         struct mlist    *dep;
1056         struct minor    *mp, *smp;
1057 
1058         vprint(CHATTY_MID, "processing deferred links\n");
1059 
1060         dep = dcip->dci_arg;
1061 
1062         /*
1063          * The list head is not used during the deferred create phase
1064          */
1065         dcip->dci_arg = NULL;
1066 
1067         assert(dep);
1068         assert((dep->head == NULL) ^ (dep->tail != NULL));
1069         assert(flags == DCA_FREE_LIST || flags == DCA_CREATE_LINK);
1070 
1071         for (smp = NULL, mp = dep->head; mp; mp = mp->next) {
1072                 if (flags == DCA_CREATE_LINK)
1073                         (void) check_minor_type(mp->node, mp->minor, dcip);
1074                 free(smp);
1075                 smp = mp;
1076         }
1077 
1078         free(smp);
1079 }
1080 
1081 /*
1082  * Called in non-daemon mode to take a snap shot of the devinfo tree.
1083  * Then it calls the appropriate functions to build /devices and /dev.
1084  * It also flushes path_to_inst.
1085  * Except in the devfsadm -i (single driver case), the flags used by devfsadm
1086  * needs to match DI_CACHE_SNAPSHOT_FLAGS. That will make DINFOCACHE snapshot
1087  * updated.
1088  */
1089 void
1090 process_devinfo_tree()
1091 {
1092         uint_t          flags;
1093         struct dca_impl dci;
1094         char            name[MAXNAMELEN];
1095         char            *fcn = "process_devinfo_tree: ";
1096 
1097         vprint(CHATTY_MID, "%senter\n", fcn);
1098 
1099         dca_impl_init("/", NULL, &dci);
1100 
1101         lock_dev();
1102 
1103         /*
1104          * Update kernel driver.conf cache when devfsadm/drvconfig
1105          * is invoked to build /devices and /dev.
1106          */
1107         if (update_all_drivers || load_attach_drv) {
1108                 update_drvconf((major_t)-1,
1109                     update_all_drivers ? MOD_LOADDRVCONF_RECONF : 0);
1110         }
1111 
1112         if (single_drv == TRUE) {
1113                 /*
1114                  * load a single driver, but walk the entire devinfo tree
1115                  */
1116                 if (load_attach_drv == FALSE)
1117                         err_print(DRV_LOAD_REQD);
1118 
1119                 vprint(CHATTY_MID, "%sattaching driver (%s)\n", fcn, driver);
1120 
1121                 dci.dci_flags |= DCA_LOAD_DRV;
1122                 (void) snprintf(name, sizeof (name), "%s", driver);
1123                 dci.dci_driver = name;
1124                 flags = DINFOCPYALL | DINFOPATH;
1125 
1126         } else if (load_attach_drv == TRUE) {
1127                 /*
1128                  * Load and attach all drivers, then walk the entire tree.
1129                  * If the cache flag is set, use DINFOCACHE to get cached
1130                  * data.
1131                  */
1132                 if (use_snapshot_cache == TRUE) {
1133                         flags = DINFOCACHE;
1134                         vprint(CHATTY_MID, "%susing snapshot cache\n", fcn);
1135                 } else {
1136                         vprint(CHATTY_MID, "%sattaching all drivers\n", fcn);
1137                         flags = DI_CACHE_SNAPSHOT_FLAGS;
1138                         if (cleanup) {
1139                                 /*
1140                                  * remove dangling entries from /etc/devices
1141                                  * files.
1142                                  */
1143                                 flags |= DINFOCLEANUP;
1144                         }
1145                 }
1146         } else {
1147                 /*
1148                  * For devlinks, disks, ports, tapes and devfsadm -n,
1149                  * just need to take a snapshot with active devices.
1150                  */
1151                 vprint(CHATTY_MID, "%staking snapshot of active devices\n",
1152                     fcn);
1153                 flags = DINFOCPYALL;
1154         }
1155 
1156         if (((load_attach_drv == TRUE) || (single_drv == TRUE)) &&
1157             (build_devices == TRUE)) {
1158                 dci.dci_flags |= DCA_FLUSH_PATHINST;
1159         }
1160 
1161         /* handle pre-cleanup operations desired by the modules. */
1162         pre_and_post_cleanup(RM_PRE);
1163 
1164         devi_tree_walk(&dci, flags, NULL);
1165 
1166         if (dci.dci_error) {
1167                 devfsadm_exit(1);
1168                 /*NOTREACHED*/
1169         }
1170 
1171         /* handle post-cleanup operations desired by the modules. */
1172         pre_and_post_cleanup(RM_POST);
1173 
1174         unlock_dev(SYNC_STATE);
1175 }
1176 
1177 /*ARGSUSED*/
1178 static void
1179 print_cache_signal(int signo)
1180 {
1181         if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) {
1182                 err_print("signal SIGUSR1 failed: %s\n", strerror(errno));
1183                 devfsadm_exit(1);
1184                 /*NOTREACHED*/
1185         }
1186 }
1187 
1188 static void
1189 revoke_lookup_door(void)
1190 {
1191         if (lookup_door_fd != -1) {
1192                 if (door_revoke(lookup_door_fd) == -1) {
1193                         err_print("door_revoke of %s failed - %s\n",
1194                             lookup_door_path, strerror(errno));
1195                 }
1196         }
1197 }
1198 
1199 /*ARGSUSED*/
1200 static void
1201 catch_exit(int signo)
1202 {
1203         revoke_lookup_door();
1204 }
1205 
1206 /*
1207  * Register with eventd for messages. Create doors for synchronous
1208  * link creation.
1209  */
1210 static void
1211 daemon_update(void)
1212 {
1213         int fd;
1214         char *fcn = "daemon_update: ";
1215         char door_file[MAXPATHLEN];
1216         const char *subclass_list;
1217         sysevent_handle_t *sysevent_hp;
1218         vprint(CHATTY_MID, "%senter\n", fcn);
1219 
1220         if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) {
1221                 err_print("signal SIGUSR1 failed: %s\n", strerror(errno));
1222                 devfsadm_exit(1);
1223                 /*NOTREACHED*/
1224         }
1225         if (signal(SIGTERM, catch_exit) == SIG_ERR) {
1226                 err_print("signal SIGTERM failed: %s\n", strerror(errno));
1227                 devfsadm_exit(1);
1228                 /*NOTREACHED*/
1229         }
1230 
1231         if (snprintf(door_file, sizeof (door_file),
1232             "%s%s", attr_root ? attr_root : root_dir, DEVFSADM_SERVICE_DOOR)
1233             >= sizeof (door_file)) {
1234                 err_print("update_daemon failed to open sysevent service "
1235                     "door\n");
1236                 devfsadm_exit(1);
1237                 /*NOTREACHED*/
1238         }
1239         if ((sysevent_hp = sysevent_open_channel_alt(
1240             door_file)) == NULL) {
1241                 err_print(CANT_CREATE_DOOR,
1242                     door_file, strerror(errno));
1243                 devfsadm_exit(1);
1244                 /*NOTREACHED*/
1245         }
1246         if (sysevent_bind_subscriber(sysevent_hp, event_handler) != 0) {
1247                 err_print(CANT_CREATE_DOOR,
1248                     door_file, strerror(errno));
1249                 (void) sysevent_close_channel(sysevent_hp);
1250                 devfsadm_exit(1);
1251                 /*NOTREACHED*/
1252         }
1253         subclass_list = EC_SUB_ALL;
1254         if (sysevent_register_event(sysevent_hp, EC_ALL, &subclass_list, 1)
1255             != 0) {
1256                 err_print(CANT_CREATE_DOOR,
1257                     door_file, strerror(errno));
1258                 (void) sysevent_unbind_subscriber(sysevent_hp);
1259                 (void) sysevent_close_channel(sysevent_hp);
1260                 devfsadm_exit(1);
1261                 /*NOTREACHED*/
1262         }
1263         if (snprintf(door_file, sizeof (door_file), "%s/%s",
1264             etc_dev_dir, DEVFSADM_SYNCH_DOOR) >= sizeof (door_file)) {
1265                 err_print(CANT_CREATE_DOOR, DEVFSADM_SYNCH_DOOR,
1266                     strerror(ENAMETOOLONG));
1267                 devfsadm_exit(1);
1268                 /*NOTREACHED*/
1269         }
1270 
1271         (void) s_unlink(door_file);
1272         if ((fd = open(door_file, O_RDWR | O_CREAT, SYNCH_DOOR_PERMS)) == -1) {
1273                 err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
1274                 devfsadm_exit(1);
1275                 /*NOTREACHED*/
1276         }
1277         (void) close(fd);
1278 
1279         if ((fd = door_create(sync_handler, NULL,
1280             DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
1281                 err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
1282                 (void) s_unlink(door_file);
1283                 devfsadm_exit(1);
1284                 /*NOTREACHED*/
1285         }
1286 
1287         if (fattach(fd, door_file) == -1) {
1288                 err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
1289                 (void) s_unlink(door_file);
1290                 devfsadm_exit(1);
1291                 /*NOTREACHED*/
1292         }
1293 
1294         /*
1295          * devname_lookup_door
1296          */
1297         if (snprintf(door_file, sizeof (door_file), "%s/%s",
1298             etc_dev_dir, DEVNAME_LOOKUP_DOOR) >= sizeof (door_file)) {
1299                 err_print(CANT_CREATE_DOOR, DEVNAME_LOOKUP_DOOR,
1300                     strerror(ENAMETOOLONG));
1301                 devfsadm_exit(1);
1302                 /*NOTREACHED*/
1303         }
1304 
1305         (void) s_unlink(door_file);
1306         if ((fd = open(door_file, O_RDWR | O_CREAT, S_IRUSR|S_IWUSR)) == -1) {
1307                 err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
1308                 devfsadm_exit(1);
1309                 /*NOTREACHED*/
1310         }
1311         (void) close(fd);
1312 
1313         if ((fd = door_create(devname_lookup_handler, NULL,
1314             DOOR_REFUSE_DESC)) == -1) {
1315                 err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
1316                 (void) s_unlink(door_file);
1317                 devfsadm_exit(1);
1318                 /*NOTREACHED*/
1319         }
1320 
1321         (void) fdetach(door_file);
1322         lookup_door_path = s_strdup(door_file);
1323 retry:
1324         if (fattach(fd, door_file) == -1) {
1325                 if (errno == EBUSY)
1326                         goto retry;
1327                 err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
1328                 (void) s_unlink(door_file);
1329                 devfsadm_exit(1);
1330                 /*NOTREACHED*/
1331         }
1332         lookup_door_fd = fd;
1333 
1334         /* pass down the door name to kernel for door_ki_open */
1335         if (devname_kcall(MODDEVNAME_LOOKUPDOOR, (void *)door_file) != 0)
1336                 err_print(DEVNAME_CONTACT_FAILED, strerror(errno));
1337 
1338         vprint(CHATTY_MID, "%spausing\n", fcn);
1339         for (;;) {
1340                 (void) pause();
1341         }
1342 }
1343 
1344 /*ARGSUSED*/
1345 static void
1346 sync_handler(void *cookie, char *ap, size_t asize,
1347     door_desc_t *dp, uint_t ndesc)
1348 {
1349         door_cred_t     dcred;
1350         struct dca_off  *dcp, rdca;
1351         struct dca_impl dci;
1352 
1353         /*
1354          * Must be root to make this call
1355          * If caller is not root, don't touch its data.
1356          */
1357         if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) {
1358                 dcp = &rdca;
1359                 dcp->dca_error = EPERM;
1360                 goto out;
1361         }
1362 
1363         assert(ap);
1364         assert(asize == sizeof (*dcp));
1365 
1366         dcp = (void *)ap;
1367 
1368         /*
1369          * Root is always present and is the first component of "name" member
1370          */
1371         assert(dcp->dca_root == 0);
1372 
1373         /*
1374          * The structure passed in by the door_client uses offsets
1375          * instead of pointers to work across address space boundaries.
1376          * Now copy the data into a structure (dca_impl) which uses
1377          * pointers.
1378          */
1379         dci.dci_root = &dcp->dca_name[dcp->dca_root];
1380         dci.dci_minor = dcp->dca_minor ? &dcp->dca_name[dcp->dca_minor] : NULL;
1381         dci.dci_driver =
1382             dcp->dca_driver ? &dcp->dca_name[dcp->dca_driver] : NULL;
1383         dci.dci_error = 0;
1384         dci.dci_flags = dcp->dca_flags | (dci.dci_driver ? DCA_LOAD_DRV : 0);
1385         dci.dci_arg = NULL;
1386 
1387         lock_dev();
1388         devi_tree_walk(&dci, DINFOCPYALL, NULL);
1389         dcp->dca_error = dci.dci_error;
1390 
1391         if (dcp->dca_flags & DCA_DEVLINK_SYNC)
1392                 unlock_dev(SYNC_STATE);
1393         else
1394                 unlock_dev(CACHE_STATE);
1395 
1396 out:    (void) door_return((char *)dcp, sizeof (*dcp), NULL, 0);
1397 }
1398 
1399 static void
1400 lock_dev(void)
1401 {
1402         vprint(CHATTY_MID, "lock_dev(): entered\n");
1403 
1404         if (build_dev == FALSE)
1405                 return;
1406 
1407         /* lockout other threads from /dev */
1408         while (sema_wait(&dev_sema) != 0)
1409                 ;
1410 
1411         /*
1412          * Lock out other devfsadm processes from /dev.
1413          * If this wasn't the last process to run,
1414          * clear caches
1415          */
1416         if (enter_dev_lock() != getpid()) {
1417                 invalidate_enumerate_cache();
1418                 rm_all_links_from_cache();
1419                 (void) di_devlink_close(&devlink_cache, DI_LINK_ERROR);
1420 
1421                 /* send any sysevents that were queued up. */
1422                 process_syseventq();
1423         }
1424 
1425         /*
1426          * (re)load the  reverse links database if not
1427          * already cached.
1428          */
1429         if (devlink_cache == NULL)
1430                 devlink_cache = di_devlink_open(root_dir, 0);
1431 
1432         /*
1433          * If modules were unloaded, reload them.  Also use module status
1434          * as an indication that we should check to see if other binding
1435          * files need to be reloaded.
1436          */
1437         if (module_head == NULL) {
1438                 load_modules();
1439                 read_minor_perm_file();
1440                 read_driver_aliases_file();
1441                 read_devlinktab_file();
1442                 read_logindevperm_file();
1443                 read_enumerate_file();
1444         }
1445 
1446         if (module_head != NULL)
1447                 return;
1448 
1449         if (strcmp(prog, DEVLINKS) == 0) {
1450                 if (devlinktab_list == NULL) {
1451                         err_print(NO_LINKTAB, devlinktab_file);
1452                         err_print(NO_MODULES, module_dirs);
1453                         err_print(ABORTING);
1454                         devfsadm_exit(1);
1455                         /*NOTREACHED*/
1456                 }
1457         } else {
1458                 err_print(NO_MODULES, module_dirs);
1459                 if (strcmp(prog, DEVFSADM) == 0) {
1460                         err_print(MODIFY_PATH);
1461                 }
1462         }
1463 }
1464 
1465 /*
1466  * Unlock the device.  If we are processing a CACHE_STATE call, we signal a
1467  * minor_fini_thread delayed SYNC_STATE at the end of the call.  If we are
1468  * processing a SYNC_STATE call, we cancel any minor_fini_thread SYNC_STATE
1469  * at both the start and end of the call since we will be doing the SYNC_STATE.
1470  */
1471 static void
1472 unlock_dev(int flag)
1473 {
1474         assert(flag == SYNC_STATE || flag == CACHE_STATE);
1475 
1476         vprint(CHATTY_MID, "unlock_dev(): entered\n");
1477 
1478         /* If we are starting a SYNC_STATE, cancel minor_fini_thread SYNC */
1479         if (flag == SYNC_STATE) {
1480                 (void) mutex_lock(&minor_fini_mutex);
1481                 minor_fini_canceled = TRUE;
1482                 minor_fini_delayed = FALSE;
1483                 (void) mutex_unlock(&minor_fini_mutex);
1484         }
1485 
1486         if (build_dev == FALSE)
1487                 return;
1488 
1489         if (devlink_cache == NULL) {
1490                 err_print(NO_DEVLINK_CACHE);
1491         }
1492         assert(devlink_cache);
1493 
1494         if (flag == SYNC_STATE) {
1495                 unload_modules();
1496                 if (update_database)
1497                         (void) di_devlink_update(devlink_cache);
1498                 (void) di_devlink_close(&devlink_cache, 0);
1499 
1500                 /*
1501                  * now that the devlinks db cache has been flushed, it is safe
1502                  * to send any sysevents that were queued up.
1503                  */
1504                 process_syseventq();
1505         }
1506 
1507         exit_dev_lock(0);
1508 
1509         (void) mutex_lock(&minor_fini_mutex);
1510         if (flag == SYNC_STATE) {
1511                 /* We did a SYNC_STATE, cancel minor_fini_thread SYNC */
1512                 minor_fini_canceled = TRUE;
1513                 minor_fini_delayed = FALSE;
1514         } else {
1515                 /* We did a CACHE_STATE, start delayed minor_fini_thread SYNC */
1516                 minor_fini_canceled = FALSE;
1517                 minor_fini_delayed = TRUE;
1518                 (void) cond_signal(&minor_fini_cv);
1519         }
1520         (void) mutex_unlock(&minor_fini_mutex);
1521 
1522         (void) sema_post(&dev_sema);
1523 }
1524 
1525 /*
1526  * Check that if -r is set, it is not any part of a zone--- that is, that
1527  * the zonepath is not a substring of the root path.
1528  */
1529 static int
1530 zone_pathcheck(char *checkpath)
1531 {
1532         void            *dlhdl = NULL;
1533         char            *name;
1534         char            root[MAXPATHLEN]; /* resolved devfsadm root path */
1535         char            zroot[MAXPATHLEN]; /* zone root path */
1536         char            rzroot[MAXPATHLEN]; /* resolved zone root path */
1537         char            tmp[MAXPATHLEN];
1538         FILE            *cookie;
1539         int             err = DEVFSADM_SUCCESS;
1540 
1541         if (checkpath[0] == '\0')
1542                 return (DEVFSADM_SUCCESS);
1543 
1544         /*
1545          * Check if zones is available on this system.
1546          */
1547         if ((dlhdl = dlopen(LIBZONECFG_PATH, RTLD_LAZY)) == NULL) {
1548                 return (DEVFSADM_SUCCESS);
1549         }
1550 
1551         bzero(root, sizeof (root));
1552         if (resolvepath(checkpath, root, sizeof (root) - 1) == -1) {
1553                 /*
1554                  * In this case the user has done "devfsadm -r" on some path
1555                  * which does not yet exist, or we got some other misc. error.
1556                  * We punt and don't resolve the path in this case.
1557                  */
1558                 (void) strlcpy(root, checkpath, sizeof (root));
1559         }
1560 
1561         if (strlen(root) > 0 && (root[strlen(root) - 1] != '/')) {
1562                 (void) snprintf(tmp, sizeof (tmp), "%s/", root);
1563                 (void) strlcpy(root, tmp, sizeof (root));
1564         }
1565 
1566         cookie = setzoneent();
1567         while ((name = getzoneent(cookie)) != NULL) {
1568                 /* Skip the global zone */
1569                 if (strcmp(name, GLOBAL_ZONENAME) == 0) {
1570                         free(name);
1571                         continue;
1572                 }
1573 
1574                 if (zone_get_zonepath(name, zroot, sizeof (zroot)) != Z_OK) {
1575                         free(name);
1576                         continue;
1577                 }
1578 
1579                 bzero(rzroot, sizeof (rzroot));
1580                 if (resolvepath(zroot, rzroot, sizeof (rzroot) - 1) == -1) {
1581                         /*
1582                          * Zone path doesn't exist, or other misc error,
1583                          * so we try using the non-resolved pathname.
1584                          */
1585                         (void) strlcpy(rzroot, zroot, sizeof (rzroot));
1586                 }
1587                 if (strlen(rzroot) > 0 && (rzroot[strlen(rzroot) - 1] != '/')) {
1588                         (void) snprintf(tmp, sizeof (tmp), "%s/", rzroot);
1589                         (void) strlcpy(rzroot, tmp, sizeof (rzroot));
1590                 }
1591 
1592                 /*
1593                  * Finally, the comparison.  If the zone root path is a
1594                  * leading substring of the root path, fail.
1595                  */
1596                 if (strncmp(rzroot, root, strlen(rzroot)) == 0) {
1597                         err_print(ZONE_PATHCHECK, root, name);
1598                         err = DEVFSADM_FAILURE;
1599                         free(name);
1600                         break;
1601                 }
1602                 free(name);
1603         }
1604         endzoneent(cookie);
1605         (void) dlclose(dlhdl);
1606         return (err);
1607 }
1608 
1609 /*
1610  *  Called by the daemon when it receives an event from the devfsadm SLM
1611  *  to syseventd.
1612  *
1613  *  The devfsadm SLM uses a private event channel for communication to
1614  *  devfsadmd set-up via private libsysevent interfaces.  This handler is
1615  *  used to bind to the devfsadmd channel for event delivery.
1616  *  The devfsadmd SLM insures single calls to this routine as well as
1617  *  synchronized event delivery.
1618  *
1619  */
1620 static void
1621 event_handler(sysevent_t *ev)
1622 {
1623         char *path;
1624         char *minor;
1625         char *subclass;
1626         char *dev_ev_subclass;
1627         char *driver_name;
1628         nvlist_t *attr_list = NULL;
1629         int err = 0;
1630         int instance;
1631         int branch_event = 0;
1632 
1633         /*
1634          * If this is event-driven, then we cannot trust the static devlist
1635          * to be correct.
1636          */
1637 
1638         event_driven = TRUE;
1639         subclass = sysevent_get_subclass_name(ev);
1640         vprint(EVENT_MID, "event_handler: %s id:0X%llx\n",
1641             subclass, sysevent_get_seq(ev));
1642 
1643         if (strcmp(subclass, ESC_DEVFS_START) == 0) {
1644                 return;
1645         }
1646 
1647         /* Check if event is an instance modification */
1648         if (strcmp(subclass, ESC_DEVFS_INSTANCE_MOD) == 0) {
1649                 devfs_instance_mod();
1650                 return;
1651         }
1652         if (sysevent_get_attr_list(ev, &attr_list) != 0) {
1653                 vprint(EVENT_MID, "event_handler: can not get attr list\n");
1654                 return;
1655         }
1656 
1657         if (strcmp(subclass, ESC_DEVFS_DEVI_ADD) == 0 ||
1658             strcmp(subclass, ESC_DEVFS_DEVI_REMOVE) == 0 ||
1659             strcmp(subclass, ESC_DEVFS_MINOR_CREATE) == 0 ||
1660             strcmp(subclass, ESC_DEVFS_MINOR_REMOVE) == 0) {
1661                 if ((err = nvlist_lookup_string(attr_list, DEVFS_PATHNAME,
1662                     &path)) != 0)
1663                         goto out;
1664 
1665                 if (nvlist_lookup_string(attr_list, DEVFS_DEVI_CLASS,
1666                     &dev_ev_subclass) != 0)
1667                         dev_ev_subclass = NULL;
1668 
1669                 if (nvlist_lookup_string(attr_list, DEVFS_DRIVER_NAME,
1670                     &driver_name) != 0)
1671                         driver_name = NULL;
1672 
1673                 if (nvlist_lookup_int32(attr_list, DEVFS_INSTANCE,
1674                     &instance) != 0)
1675                         instance = -1;
1676 
1677                 if (nvlist_lookup_int32(attr_list, DEVFS_BRANCH_EVENT,
1678                     &branch_event) != 0)
1679                         branch_event = 0;
1680 
1681                 if (nvlist_lookup_string(attr_list, DEVFS_MINOR_NAME,
1682                     &minor) != 0)
1683                         minor = NULL;
1684 
1685                 lock_dev();
1686 
1687                 if (strcmp(ESC_DEVFS_DEVI_ADD, subclass) == 0) {
1688                         add_minor_pathname(path, NULL, dev_ev_subclass);
1689                         if (branch_event) {
1690                                 build_and_enq_event(EC_DEV_BRANCH,
1691                                     ESC_DEV_BRANCH_ADD, path, DI_NODE_NIL,
1692                                     NULL);
1693                         }
1694 
1695                 } else if (strcmp(ESC_DEVFS_MINOR_CREATE, subclass) == 0) {
1696                         add_minor_pathname(path, minor, dev_ev_subclass);
1697 
1698                 } else if (strcmp(ESC_DEVFS_MINOR_REMOVE, subclass) == 0) {
1699                         hot_cleanup(path, minor, dev_ev_subclass, driver_name,
1700                             instance);
1701 
1702                 } else { /* ESC_DEVFS_DEVI_REMOVE */
1703                         hot_cleanup(path, NULL, dev_ev_subclass,
1704                             driver_name, instance);
1705                         if (branch_event) {
1706                                 build_and_enq_event(EC_DEV_BRANCH,
1707                                     ESC_DEV_BRANCH_REMOVE, path, DI_NODE_NIL,
1708                                     NULL);
1709                         }
1710                 }
1711 
1712                 unlock_dev(CACHE_STATE);
1713 
1714         } else if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0 ||
1715             strcmp(subclass, ESC_DEVFS_BRANCH_REMOVE) == 0) {
1716                 if ((err = nvlist_lookup_string(attr_list,
1717                     DEVFS_PATHNAME, &path)) != 0)
1718                         goto out;
1719 
1720                 /* just log ESC_DEV_BRANCH... event */
1721                 if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0)
1722                         dev_ev_subclass = ESC_DEV_BRANCH_ADD;
1723                 else
1724                         dev_ev_subclass = ESC_DEV_BRANCH_REMOVE;
1725 
1726                 lock_dev();
1727                 build_and_enq_event(EC_DEV_BRANCH, dev_ev_subclass, path,
1728                     DI_NODE_NIL, NULL);
1729                 unlock_dev(CACHE_STATE);
1730         } else
1731                 err_print(UNKNOWN_EVENT, subclass);
1732 
1733 out:
1734         if (err)
1735                 err_print(EVENT_ATTR_LOOKUP_FAILED, strerror(err));
1736         nvlist_free(attr_list);
1737 }
1738 
1739 static void
1740 dca_impl_init(char *root, char *minor, struct dca_impl *dcip)
1741 {
1742         assert(root);
1743 
1744         dcip->dci_root = root;
1745         dcip->dci_minor = minor;
1746         dcip->dci_driver = NULL;
1747         dcip->dci_error = 0;
1748         dcip->dci_flags = 0;
1749         dcip->dci_arg = NULL;
1750 }
1751 
1752 /*
1753  *  Kernel logs a message when a devinfo node is attached.  Try to create
1754  *  /dev and /devices for each minor node.  minorname can be NULL.
1755  */
1756 void
1757 add_minor_pathname(char *node, char *minor, char *ev_subclass)
1758 {
1759         struct dca_impl dci;
1760 
1761         vprint(CHATTY_MID, "add_minor_pathname: node_path=%s minor=%s\n",
1762             node, minor ? minor : "NULL");
1763 
1764         dca_impl_init(node, minor, &dci);
1765 
1766         /*
1767          * Restrict hotplug link creation if daemon
1768          * started  with -i option.
1769          */
1770         if (single_drv == TRUE) {
1771                 dci.dci_driver = driver;
1772         }
1773 
1774         /*
1775          * We are being invoked in response to a hotplug event.
1776          */
1777         dci.dci_flags = DCA_HOT_PLUG | DCA_CHECK_TYPE;
1778 
1779         devi_tree_walk(&dci, DINFOPROP|DINFOMINOR, ev_subclass);
1780 }
1781 
1782 static di_node_t
1783 find_clone_node()
1784 {
1785         static di_node_t clone_node = DI_NODE_NIL;
1786 
1787         if (clone_node == DI_NODE_NIL)
1788                 clone_node = di_init("/pseudo/clone@0", DINFOPROP);
1789         return (clone_node);
1790 }
1791 
1792 static int
1793 is_descendent_of(di_node_t node, char *driver)
1794 {
1795         while (node != DI_NODE_NIL) {
1796                 char *drv = di_driver_name(node);
1797                 if (strcmp(drv, driver) == 0)
1798                         return (1);
1799                 node = di_parent_node(node);
1800         }
1801         return (0);
1802 }
1803 
1804 /*
1805  * Checks the minor type.  If it is an alias node, then lookup
1806  * the real node/minor first, then call minor_process() to
1807  * do the real work.
1808  */
1809 static int
1810 check_minor_type(di_node_t node, di_minor_t minor, void *arg)
1811 {
1812         ddi_minor_type  minor_type;
1813         di_node_t       clone_node;
1814         char            *mn;
1815         char            *nt;
1816         struct mlist    *dep;
1817         struct dca_impl *dcip = arg;
1818 
1819         assert(dcip);
1820 
1821         dep = dcip->dci_arg;
1822 
1823         mn = di_minor_name(minor);
1824 
1825         /*
1826          * We match driver here instead of in minor_process
1827          * as we want the actual driver name. This check is
1828          * unnecessary during deferred processing.
1829          */
1830         if (dep &&
1831             ((dcip->dci_driver && !is_descendent_of(node, dcip->dci_driver)) ||
1832             (dcip->dci_minor && strcmp(mn, dcip->dci_minor)))) {
1833                 return (DI_WALK_CONTINUE);
1834         }
1835 
1836         if ((dcip->dci_flags & DCA_CHECK_TYPE) &&
1837             (nt = di_minor_nodetype(minor)) &&
1838             (strcmp(nt, DDI_NT_NET) == 0)) {
1839                 dcip->dci_flags &= ~DCA_CHECK_TYPE;
1840         }
1841 
1842         minor_type = di_minor_type(minor);
1843 
1844         if (minor_type == DDM_MINOR) {
1845                 minor_process(node, minor, dep);
1846 
1847         } else if (minor_type == DDM_ALIAS) {
1848                 struct mlist *cdep, clone_del = {0};
1849 
1850                 clone_node = find_clone_node();
1851                 if (clone_node == DI_NODE_NIL) {
1852                         err_print(DI_INIT_FAILED, "clone", strerror(errno));
1853                         return (DI_WALK_CONTINUE);
1854                 }
1855 
1856                 cdep = dep ? &clone_del : NULL;
1857 
1858                 minor_process(clone_node, minor, cdep);
1859 
1860                 /*
1861                  * cache "alias" minor node and free "clone" minor
1862                  */
1863                 if (cdep != NULL && cdep->head != NULL) {
1864                         assert(cdep->tail != NULL);
1865                         cache_deferred_minor(dep, node, minor);
1866                         dcip->dci_arg = cdep;
1867                         process_deferred_links(dcip, DCA_FREE_LIST);
1868                         dcip->dci_arg = dep;
1869                 }
1870         }
1871 
1872         return (DI_WALK_CONTINUE);
1873 }
1874 
1875 
1876 /*
1877  *  This is the entry point for each minor node, whether walking
1878  *  the entire tree via di_walk_minor() or processing a hotplug event
1879  *  for a single devinfo node (via hotplug ndi_devi_online()).
1880  */
1881 /*ARGSUSED*/
1882 static void
1883 minor_process(di_node_t node, di_minor_t minor, struct mlist *dep)
1884 {
1885         create_list_t   *create;
1886         int             defer;
1887 
1888         vprint(CHATTY_MID, "minor_process: node=%s, minor=%s\n",
1889             di_node_name(node), di_minor_name(minor));
1890 
1891         if (dep != NULL) {
1892 
1893                 /*
1894                  * Reset /devices node to minor_perm perm/ownership
1895                  * if we are here to deactivate device allocation
1896                  */
1897                 if (build_devices == TRUE) {
1898                         reset_node_permissions(node, minor);
1899                 }
1900 
1901                 if (build_dev == FALSE) {
1902                         return;
1903                 }
1904 
1905                 /*
1906                  * This function will create any nodes for /etc/devlink.tab.
1907                  * If devlink.tab handles link creation, we don't call any
1908                  * devfsadm modules since that could cause duplicate caching
1909                  * in the enumerate functions if different re strings are
1910                  * passed that are logically identical.  I'm still not
1911                  * convinced this would cause any harm, but better to be safe.
1912                  *
1913                  * Deferred processing is available only for devlinks
1914                  * created through devfsadm modules.
1915                  */
1916                 if (process_devlink_compat(minor, node) == TRUE) {
1917                         return;
1918                 }
1919         } else {
1920                 vprint(CHATTY_MID, "minor_process: deferred processing\n");
1921         }
1922 
1923         /*
1924          * look for relevant link create rules in the modules, and
1925          * invoke the link create callback function to build a link
1926          * if there is a match.
1927          */
1928         defer = 0;
1929         for (create = create_head; create != NULL; create = create->next) {
1930                 if ((minor_matches_rule(node, minor, create) == TRUE) &&
1931                     class_ok(create->create->device_class) ==
1932                     DEVFSADM_SUCCESS) {
1933                         if (call_minor_init(create->modptr) ==
1934                             DEVFSADM_FAILURE) {
1935                                 continue;
1936                         }
1937 
1938                         /*
1939                          * If NOT doing the deferred creates (i.e. 1st pass) and
1940                          * rule requests deferred processing cache the minor
1941                          * data.
1942                          *
1943                          * If deferred processing (2nd pass), create links
1944                          * ONLY if rule requests deferred processing.
1945                          */
1946                         if (dep && ((create->create->flags & CREATE_MASK) ==
1947                             CREATE_DEFER)) {
1948                                 defer = 1;
1949                                 continue;
1950                         } else if (dep == NULL &&
1951                             ((create->create->flags & CREATE_MASK) !=
1952                             CREATE_DEFER)) {
1953                                 continue;
1954                         }
1955 
1956                         if ((*(create->create->callback_fcn))
1957                             (minor, node) == DEVFSADM_TERMINATE) {
1958                                 break;
1959                         }
1960                 }
1961         }
1962 
1963         if (defer)
1964                 cache_deferred_minor(dep, node, minor);
1965 }
1966 
1967 
1968 /*
1969  * Cache node and minor in defer list.
1970  */
1971 static void
1972 cache_deferred_minor(
1973         struct mlist *dep,
1974         di_node_t node,
1975         di_minor_t minor)
1976 {
1977         struct minor    *mp;
1978         const char      *fcn = "cache_deferred_minor";
1979 
1980         vprint(CHATTY_MID, "%s node=%s, minor=%s\n", fcn,
1981             di_node_name(node), di_minor_name(minor));
1982 
1983         if (dep == NULL) {
1984                 vprint(CHATTY_MID, "%s: cannot cache during "
1985                     "deferred processing. Ignoring minor\n", fcn);
1986                 return;
1987         }
1988 
1989         mp = (struct minor *)s_zalloc(sizeof (struct minor));
1990         mp->node = node;
1991         mp->minor = minor;
1992         mp->next = NULL;
1993 
1994         assert(dep->head == NULL || dep->tail != NULL);
1995         if (dep->head == NULL) {
1996                 dep->head = mp;
1997         } else {
1998                 dep->tail->next = mp;
1999         }
2000         dep->tail = mp;
2001 }
2002 
2003 /*
2004  *  Check to see if "create" link creation rule matches this node/minor.
2005  *  If it does, return TRUE.
2006  */
2007 static int
2008 minor_matches_rule(di_node_t node, di_minor_t minor, create_list_t *create)
2009 {
2010         char *m_nodetype, *m_drvname;
2011 
2012         if (create->create->node_type != NULL) {
2013 
2014                 m_nodetype = di_minor_nodetype(minor);
2015                 assert(m_nodetype != NULL);
2016 
2017                 switch (create->create->flags & TYPE_MASK) {
2018                 case TYPE_EXACT:
2019                         if (strcmp(create->create->node_type, m_nodetype) !=
2020                             0) {
2021                                 return (FALSE);
2022                         }
2023                         break;
2024                 case TYPE_PARTIAL:
2025                         if (strncmp(create->create->node_type, m_nodetype,
2026                             strlen(create->create->node_type)) != 0) {
2027                                 return (FALSE);
2028                         }
2029                         break;
2030                 case TYPE_RE:
2031                         if (regexec(&(create->node_type_comp), m_nodetype,
2032                             0, NULL, 0) != 0) {
2033                                 return (FALSE);
2034                         }
2035                         break;
2036                 }
2037         }
2038 
2039         if (create->create->drv_name != NULL) {
2040                 m_drvname = di_driver_name(node);
2041                 switch (create->create->flags & DRV_MASK) {
2042                 case DRV_EXACT:
2043                         if (strcmp(create->create->drv_name, m_drvname) != 0) {
2044                                 return (FALSE);
2045                         }
2046                         break;
2047                 case DRV_RE:
2048                         if (regexec(&(create->drv_name_comp), m_drvname,
2049                             0, NULL, 0) != 0) {
2050                                 return (FALSE);
2051                         }
2052                         break;
2053                 }
2054         }
2055 
2056         return (TRUE);
2057 }
2058 
2059 /*
2060  * If no classes were given on the command line, then return DEVFSADM_SUCCESS.
2061  * Otherwise, return DEVFSADM_SUCCESS if the device "class" from the module
2062  * matches one of the device classes given on the command line,
2063  * otherwise, return DEVFSADM_FAILURE.
2064  */
2065 static int
2066 class_ok(char *class)
2067 {
2068         int i;
2069 
2070         if (num_classes == 0) {
2071                 return (DEVFSADM_SUCCESS);
2072         }
2073 
2074         for (i = 0; i < num_classes; i++) {
2075                 if (strcmp(class, classes[i]) == 0) {
2076                         return (DEVFSADM_SUCCESS);
2077                 }
2078         }
2079         return (DEVFSADM_FAILURE);
2080 }
2081 
2082 /*
2083  * call minor_fini on active modules, then unload ALL modules
2084  */
2085 static void
2086 unload_modules(void)
2087 {
2088         module_t *module_free;
2089         create_list_t *create_free;
2090         remove_list_t *remove_free;
2091 
2092         while (create_head != NULL) {
2093                 create_free = create_head;
2094                 create_head = create_head->next;
2095 
2096                 if ((create_free->create->flags & TYPE_RE) == TYPE_RE) {
2097                         regfree(&(create_free->node_type_comp));
2098                 }
2099                 if ((create_free->create->flags & DRV_RE) == DRV_RE) {
2100                         regfree(&(create_free->drv_name_comp));
2101                 }
2102                 free(create_free);
2103         }
2104 
2105         while (remove_head != NULL) {
2106                 remove_free = remove_head;
2107                 remove_head = remove_head->next;
2108                 free(remove_free);
2109         }
2110 
2111         while (module_head != NULL) {
2112 
2113                 if ((module_head->minor_fini != NULL) &&
2114                     ((module_head->flags & MODULE_ACTIVE) == MODULE_ACTIVE)) {
2115                         (void) (*(module_head->minor_fini))();
2116                 }
2117 
2118                 vprint(MODLOAD_MID, "unloading module %s\n", module_head->name);
2119                 free(module_head->name);
2120                 (void) dlclose(module_head->dlhandle);
2121 
2122                 module_free = module_head;
2123                 module_head = module_head->next;
2124                 free(module_free);
2125         }
2126 }
2127 
2128 /*
2129  * Load devfsadm logical link processing modules.
2130  */
2131 static void
2132 load_modules(void)
2133 {
2134         DIR *mod_dir;
2135         struct dirent *entp;
2136         char cdir[PATH_MAX + 1];
2137         char *last;
2138         char *mdir = module_dirs;
2139         char *fcn = "load_modules: ";
2140 
2141         while (*mdir != '\0') {
2142 
2143                 while (*mdir == ':') {
2144                         mdir++;
2145                 }
2146 
2147                 if (*mdir == '\0') {
2148                         continue;
2149                 }
2150 
2151                 last = strchr(mdir, ':');
2152 
2153                 if (last == NULL) {
2154                         last = mdir + strlen(mdir);
2155                 }
2156 
2157                 (void) strncpy(cdir, mdir, last - mdir);
2158                 cdir[last - mdir] = '\0';
2159                 mdir += strlen(cdir);
2160 
2161                 if ((mod_dir = opendir(cdir)) == NULL) {
2162                         vprint(MODLOAD_MID, "%sopendir(%s): %s\n",
2163                             fcn, cdir, strerror(errno));
2164                         continue;
2165                 }
2166 
2167                 while ((entp = readdir(mod_dir)) != NULL) {
2168 
2169                         if ((strcmp(entp->d_name, ".") == 0) ||
2170                             (strcmp(entp->d_name, "..") == 0)) {
2171                                 continue;
2172                         }
2173 
2174                         load_module(entp->d_name, cdir);
2175                 }
2176                 s_closedir(mod_dir);
2177         }
2178 }
2179 
2180 static void
2181 load_module(char *mname, char *cdir)
2182 {
2183         _devfsadm_create_reg_t *create_reg;
2184         _devfsadm_remove_reg_V1_t *remove_reg;
2185         create_list_t *create_list_element;
2186         create_list_t **create_list_next;
2187         remove_list_t *remove_list_element;
2188         remove_list_t **remove_list_next;
2189         char epath[PATH_MAX + 1], *end;
2190         char *fcn = "load_module: ";
2191         char *dlerrstr;
2192         void *dlhandle;
2193         module_t *module;
2194         int flags;
2195         int n;
2196         int i;
2197 
2198         /* ignore any file which does not end in '.so' */
2199         if ((end = strstr(mname, MODULE_SUFFIX)) != NULL) {
2200                 if (end[strlen(MODULE_SUFFIX)] != '\0') {
2201                         return;
2202                 }
2203         } else {
2204                 return;
2205         }
2206 
2207         (void) snprintf(epath, sizeof (epath), "%s/%s", cdir, mname);
2208 
2209         if ((dlhandle = dlopen(epath, RTLD_LAZY)) == NULL) {
2210                 dlerrstr = dlerror();
2211                 err_print(DLOPEN_FAILED, epath,
2212                     dlerrstr ? dlerrstr : "unknown error");
2213                 return;
2214         }
2215 
2216         /* dlsym the _devfsadm_create_reg structure */
2217         if (NULL == (create_reg = (_devfsadm_create_reg_t *)
2218             dlsym(dlhandle, _DEVFSADM_CREATE_REG))) {
2219                 vprint(MODLOAD_MID, "dlsym(%s, %s): symbol not found\n", epath,
2220                     _DEVFSADM_CREATE_REG);
2221         } else {
2222                 vprint(MODLOAD_MID, "%sdlsym(%s, %s) succeeded\n",
2223                     fcn, epath, _DEVFSADM_CREATE_REG);
2224         }
2225 
2226         /* dlsym the _devfsadm_remove_reg structure */
2227         if (NULL == (remove_reg = (_devfsadm_remove_reg_V1_t *)
2228             dlsym(dlhandle, _DEVFSADM_REMOVE_REG))) {
2229                 vprint(MODLOAD_MID, "dlsym(%s,\n\t%s): symbol not found\n",
2230                     epath, _DEVFSADM_REMOVE_REG);
2231         } else {
2232                 vprint(MODLOAD_MID, "dlsym(%s, %s): succeeded\n",
2233                     epath, _DEVFSADM_REMOVE_REG);
2234         }
2235 
2236         vprint(MODLOAD_MID, "module %s loaded\n", epath);
2237 
2238         module = (module_t *)s_malloc(sizeof (module_t));
2239         module->name = s_strdup(epath);
2240         module->dlhandle = dlhandle;
2241 
2242         /* dlsym other module functions, to be called later */
2243         module->minor_fini = (int (*)())dlsym(dlhandle, MINOR_FINI);
2244         module->minor_init = (int (*)())dlsym(dlhandle, MINOR_INIT);
2245         module->flags = 0;
2246 
2247         /*
2248          *  put a ptr to each struct devfsadm_create on "create_head"
2249          *  list sorted in interpose_lvl.
2250          */
2251         if (create_reg != NULL) {
2252                 for (i = 0; i < create_reg->count; i++) {
2253                         int flags = create_reg->tblp[i].flags;
2254 
2255                         create_list_element = (create_list_t *)
2256                             s_malloc(sizeof (create_list_t));
2257 
2258                         create_list_element->create = &(create_reg->tblp[i]);
2259                         create_list_element->modptr = module;
2260 
2261                         if (((flags & CREATE_MASK) != 0) &&
2262                             ((flags & CREATE_MASK) != CREATE_DEFER)) {
2263                                 free(create_list_element);
2264                                 err_print("illegal flag combination in "
2265                                     "module create\n");
2266                                 err_print(IGNORING_ENTRY, i, epath);
2267                                 continue;
2268                         }
2269 
2270                         if (((flags & TYPE_MASK) == 0) ^
2271                             (create_reg->tblp[i].node_type == NULL)) {
2272                                 free(create_list_element);
2273                                 err_print("flags value incompatible with "
2274                                     "node_type value in module create\n");
2275                                 err_print(IGNORING_ENTRY, i, epath);
2276                                 continue;
2277                         }
2278 
2279                         if (((flags & TYPE_MASK) != 0) &&
2280                             ((flags & TYPE_MASK) != TYPE_EXACT) &&
2281                             ((flags & TYPE_MASK) != TYPE_RE) &&
2282                             ((flags & TYPE_MASK) != TYPE_PARTIAL)) {
2283                                 free(create_list_element);
2284                                 err_print("illegal TYPE_* flag combination in "
2285                                     "module create\n");
2286                                 err_print(IGNORING_ENTRY, i, epath);
2287                                 continue;
2288                         }
2289 
2290                         /* precompile regular expression for efficiency */
2291                         if ((flags & TYPE_RE) == TYPE_RE) {
2292                                 if ((n = regcomp(&(create_list_element->
2293                                     node_type_comp),
2294                                     create_reg->tblp[i].node_type,
2295                                     REG_EXTENDED)) != 0) {
2296                                         free(create_list_element);
2297                                         err_print(REGCOMP_FAILED,
2298                                             create_reg->tblp[i].node_type, n);
2299                                         err_print(IGNORING_ENTRY, i, epath);
2300                                         continue;
2301                                 }
2302                         }
2303 
2304                         if (((flags & DRV_MASK) == 0) ^
2305                             (create_reg->tblp[i].drv_name == NULL)) {
2306                                 if ((flags & TYPE_RE) == TYPE_RE) {
2307                                         regfree(&(create_list_element->
2308                                             node_type_comp));
2309                                 }
2310                                 free(create_list_element);
2311                                 err_print("flags value incompatible with "
2312                                     "drv_name value in module create\n");
2313                                 err_print(IGNORING_ENTRY, i, epath);
2314                                 continue;
2315                         }
2316 
2317                         if (((flags & DRV_MASK) != 0) &&
2318                             ((flags & DRV_MASK) != DRV_EXACT) &&
2319                             ((flags & DRV_MASK) !=  DRV_RE)) {
2320                                 if ((flags & TYPE_RE) == TYPE_RE) {
2321                                         regfree(&(create_list_element->
2322                                             node_type_comp));
2323                                 }
2324                                 free(create_list_element);
2325                                 err_print("illegal DRV_* flag combination in "
2326                                     "module create\n");
2327                                 err_print(IGNORING_ENTRY, i, epath);
2328                                 continue;
2329                         }
2330 
2331                         /* precompile regular expression for efficiency */
2332                         if ((create_reg->tblp[i].flags & DRV_RE) == DRV_RE) {
2333                                 if ((n = regcomp(&(create_list_element->
2334                                     drv_name_comp),
2335                                     create_reg->tblp[i].drv_name,
2336                                     REG_EXTENDED)) != 0) {
2337                                         if ((flags & TYPE_RE) == TYPE_RE) {
2338                                                 regfree(&(create_list_element->
2339                                                     node_type_comp));
2340                                         }
2341                                         free(create_list_element);
2342                                         err_print(REGCOMP_FAILED,
2343                                             create_reg->tblp[i].drv_name, n);
2344                                         err_print(IGNORING_ENTRY, i, epath);
2345                                         continue;
2346                                 }
2347                         }
2348 
2349 
2350                         /* add to list sorted by interpose level */
2351                         for (create_list_next = &(create_head);
2352                             (*create_list_next != NULL) &&
2353                             (*create_list_next)->create->interpose_lvl >=
2354                             create_list_element->create->interpose_lvl;
2355                             create_list_next = &((*create_list_next)->next))
2356                                 ;
2357                         create_list_element->next = *create_list_next;
2358                         *create_list_next = create_list_element;
2359                 }
2360         }
2361 
2362         /*
2363          *  put a ptr to each struct devfsadm_remove on "remove_head"
2364          *  list sorted by interpose_lvl.
2365          */
2366         flags = 0;
2367         if (remove_reg != NULL) {
2368                 if (remove_reg->version < DEVFSADM_V1)
2369                         flags |= RM_NOINTERPOSE;
2370                 for (i = 0; i < remove_reg->count; i++) {
2371 
2372                         remove_list_element = (remove_list_t *)
2373                             s_malloc(sizeof (remove_list_t));
2374 
2375                         remove_list_element->remove = &(remove_reg->tblp[i]);
2376                         remove_list_element->remove->flags |= flags;
2377                         remove_list_element->modptr = module;
2378 
2379                         for (remove_list_next = &(remove_head);
2380                             (*remove_list_next != NULL) &&
2381                             (*remove_list_next)->remove->interpose_lvl >=
2382                             remove_list_element->remove->interpose_lvl;
2383                             remove_list_next = &((*remove_list_next)->next))
2384                                 ;
2385                         remove_list_element->next = *remove_list_next;
2386                         *remove_list_next = remove_list_element;
2387                 }
2388         }
2389 
2390         module->next = module_head;
2391         module_head = module;
2392 }
2393 
2394 /*
2395  * After we have completed a CACHE_STATE, if a SYNC_STATE does not occur
2396  * within 'timeout' secs the minor_fini_thread needs to do a SYNC_STATE
2397  * so that we still call the minor_fini routines.
2398  */
2399 /*ARGSUSED*/
2400 static void
2401 minor_fini_thread(void *arg)
2402 {
2403         timestruc_t     abstime;
2404 
2405         vprint(INITFINI_MID, "minor_fini_thread starting\n");
2406 
2407         (void) mutex_lock(&minor_fini_mutex);
2408         for (;;) {
2409                 /* wait the gather period, or until signaled */
2410                 abstime.tv_sec = time(NULL) + minor_fini_timeout;
2411                 abstime.tv_nsec = 0;
2412                 (void) cond_timedwait(&minor_fini_cv,
2413                     &minor_fini_mutex, &abstime);
2414 
2415                 /* if minor_fini was canceled, go wait again */
2416                 if (minor_fini_canceled == TRUE)
2417                         continue;
2418 
2419                 /* if minor_fini was delayed, go wait again */
2420                 if (minor_fini_delayed == TRUE) {
2421                         minor_fini_delayed = FALSE;
2422                         continue;
2423                 }
2424 
2425                 /* done with cancellations and delays, do the SYNC_STATE */
2426                 (void) mutex_unlock(&minor_fini_mutex);
2427 
2428                 lock_dev();
2429                 unlock_dev(SYNC_STATE);
2430                 vprint(INITFINI_MID, "minor_fini sync done\n");
2431 
2432                 (void) mutex_lock(&minor_fini_mutex);
2433         }
2434 }
2435 
2436 
2437 /*
2438  * Attempt to initialize module, if a minor_init routine exists.  Set
2439  * the active flag if the routine exists and succeeds.  If it doesn't
2440  * exist, just set the active flag.
2441  */
2442 static int
2443 call_minor_init(module_t *module)
2444 {
2445         char *fcn = "call_minor_init: ";
2446 
2447         if ((module->flags & MODULE_ACTIVE) == MODULE_ACTIVE) {
2448                 return (DEVFSADM_SUCCESS);
2449         }
2450 
2451         vprint(INITFINI_MID, "%smodule %s.  current state: inactive\n",
2452             fcn, module->name);
2453 
2454         if (module->minor_init == NULL) {
2455                 module->flags |= MODULE_ACTIVE;
2456                 vprint(INITFINI_MID, "minor_init not defined\n");
2457                 return (DEVFSADM_SUCCESS);
2458         }
2459 
2460         if ((*(module->minor_init))() == DEVFSADM_FAILURE) {
2461                 err_print(FAILED_FOR_MODULE, MINOR_INIT, module->name);
2462                 return (DEVFSADM_FAILURE);
2463         }
2464 
2465         vprint(INITFINI_MID, "minor_init() returns DEVFSADM_SUCCESS. "
2466             "new state: active\n");
2467 
2468         module->flags |= MODULE_ACTIVE;
2469         return (DEVFSADM_SUCCESS);
2470 }
2471 
2472 /*
2473  * Creates a symlink 'link' to the physical path of node:minor.
2474  * Construct link contents, then call create_link_common().
2475  */
2476 /*ARGSUSED*/
2477 int
2478 devfsadm_mklink(char *link, di_node_t node, di_minor_t minor, int flags)
2479 {
2480         char rcontents[PATH_MAX];
2481         char devlink[PATH_MAX];
2482         char phy_path[PATH_MAX];
2483         char *acontents;
2484         char *dev_path;
2485         int numslashes;
2486         int rv;
2487         int i, link_exists;
2488         int last_was_slash = FALSE;
2489 
2490         /*
2491          * try to use devices path
2492          */
2493         if ((node == lnode) && (minor == lminor)) {
2494                 acontents = lphy_path;
2495         } else if (di_minor_type(minor) == DDM_ALIAS) {
2496                 /* use /pseudo/clone@0:<driver> as the phys path */
2497                 (void) snprintf(phy_path, sizeof (phy_path),
2498                     "/pseudo/clone@0:%s",
2499                     di_driver_name(di_minor_devinfo(minor)));
2500                 acontents = phy_path;
2501         } else {
2502                 if ((dev_path = di_devfs_path(node)) == NULL) {
2503                         err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
2504                         devfsadm_exit(1);
2505                         /*NOTREACHED*/
2506                 }
2507                 (void) snprintf(phy_path, sizeof (phy_path), "%s:%s",
2508                     dev_path, di_minor_name(minor));
2509                 di_devfs_path_free(dev_path);
2510                 acontents = phy_path;
2511         }
2512 
2513         /* prepend link with dev_dir contents */
2514         (void) strlcpy(devlink, dev_dir, sizeof (devlink));
2515         (void) strlcat(devlink, "/", sizeof (devlink));
2516         (void) strlcat(devlink, link, sizeof (devlink));
2517 
2518         /*
2519          * Calculate # of ../ to add.  Account for double '//' in path.
2520          * Ignore all leading slashes.
2521          */
2522         for (i = 0; link[i] == '/'; i++)
2523                 ;
2524         for (numslashes = 0; link[i] != '\0'; i++) {
2525                 if (link[i] == '/') {
2526                         if (last_was_slash == FALSE) {
2527                                 numslashes++;
2528                                 last_was_slash = TRUE;
2529                         }
2530                 } else {
2531                         last_was_slash = FALSE;
2532                 }
2533         }
2534         /* Don't count any trailing '/' */
2535         if (link[i-1] == '/') {
2536                 numslashes--;
2537         }
2538 
2539         rcontents[0] = '\0';
2540         do {
2541                 (void) strlcat(rcontents, "../", sizeof (rcontents));
2542         } while (numslashes-- != 0);
2543 
2544         (void) strlcat(rcontents, "devices", sizeof (rcontents));
2545         (void) strlcat(rcontents, acontents, sizeof (rcontents));
2546 
2547         if (devlinks_debug == TRUE) {
2548                 vprint(INFO_MID, "adding link %s ==> %s\n", devlink, rcontents);
2549         }
2550 
2551         if ((rv = create_link_common(devlink, rcontents, &link_exists))
2552             == DEVFSADM_SUCCESS) {
2553                 linknew = TRUE;
2554                 add_link_to_cache(link, acontents);
2555         } else {
2556                 linknew = FALSE;
2557         }
2558 
2559         if (link_exists == TRUE) {
2560                 /* Link exists or was just created */
2561                 (void) di_devlink_add_link(devlink_cache, link, rcontents,
2562                     DI_PRIMARY_LINK);
2563 
2564                 if (system_labeled && (flags & DA_ADD)) {
2565                         /*
2566                          * Add this to the list of allocatable devices. If this
2567                          * is a hotplugged, removable disk, add it as rmdisk.
2568                          */
2569                         int instance = di_instance(node);
2570 
2571                         if ((flags & DA_CD) &&
2572                             (_da_check_for_usb(devlink, root_dir) == 1)) {
2573                                 (void) da_add_list(&devlist, devlink, instance,
2574                                     DA_ADD|DA_RMDISK);
2575                                 update_devdb = DA_RMDISK;
2576                         } else if (linknew == TRUE) {
2577                                 (void) da_add_list(&devlist, devlink, instance,
2578                                     flags);
2579                                 update_devdb = flags;
2580                         }
2581                 }
2582         }
2583 
2584         return (rv);
2585 }
2586 
2587 /*
2588  * Creates a symlink link to primary_link.  Calculates relative
2589  * directory offsets, then calls link_common().
2590  */
2591 /*ARGSUSED*/
2592 int
2593 devfsadm_secondary_link(char *link, char *primary_link, int flags)
2594 {
2595         char contents[PATH_MAX + 1];
2596         char devlink[PATH_MAX + 1];
2597         int rv, link_exists;
2598         char *fpath;
2599         char *tpath;
2600         char *op;
2601 
2602         /* prepend link with dev_dir contents */
2603         (void) strcpy(devlink, dev_dir);
2604         (void) strcat(devlink, "/");
2605         (void) strcat(devlink, link);
2606         /*
2607          * building extra link, so use first link as link contents, but first
2608          * make it relative.
2609          */
2610         fpath = link;
2611         tpath = primary_link;
2612         op = contents;
2613 
2614         while (*fpath == *tpath && *fpath != '\0') {
2615                 fpath++, tpath++;
2616         }
2617 
2618         /* Count directories to go up, if any, and add "../" */
2619         while (*fpath != '\0') {
2620                 if (*fpath == '/') {
2621                         (void) strcpy(op, "../");
2622                         op += 3;
2623                 }
2624                 fpath++;
2625         }
2626 
2627         /*
2628          * Back up to the start of the current path component, in
2629          * case in the middle
2630          */
2631         while (tpath != primary_link && *(tpath-1) != '/') {
2632                 tpath--;
2633         }
2634         (void) strcpy(op, tpath);
2635 
2636         if (devlinks_debug == TRUE) {
2637                 vprint(INFO_MID, "adding extra link %s ==> %s\n",
2638                     devlink, contents);
2639         }
2640 
2641         if ((rv = create_link_common(devlink, contents, &link_exists))
2642             == DEVFSADM_SUCCESS) {
2643                 /*
2644                  * we need to save the ultimate /devices contents, and not the
2645                  * secondary link, since hotcleanup only looks at /devices path.
2646                  * Since we don't have devices path here, we can try to get it
2647                  * by readlink'ing the secondary link.  This assumes the primary
2648                  * link was created first.
2649                  */
2650                 add_link_to_cache(link, lphy_path);
2651                 linknew = TRUE;
2652                 if (system_labeled &&
2653                     ((flags & DA_AUDIO) && (flags & DA_ADD))) {
2654                         /*
2655                          * Add this device to the list of allocatable devices.
2656                          */
2657                         int     instance = 0;
2658 
2659                         op = strrchr(contents, '/');
2660                         op++;
2661                         (void) sscanf(op, "%d", &instance);
2662                         (void) da_add_list(&devlist, devlink, instance, flags);
2663                         update_devdb = flags;
2664                 }
2665         } else {
2666                 linknew = FALSE;
2667         }
2668 
2669         /*
2670          * If link exists or was just created, add it to the database
2671          */
2672         if (link_exists == TRUE) {
2673                 (void) di_devlink_add_link(devlink_cache, link, contents,
2674                     DI_SECONDARY_LINK);
2675         }
2676 
2677         return (rv);
2678 }
2679 
2680 /* returns pointer to the devices directory */
2681 char *
2682 devfsadm_get_devices_dir()
2683 {
2684         return (devices_dir);
2685 }
2686 
2687 /*
2688  * Does the actual link creation.  VERBOSE_MID only used if there is
2689  * a change.  CHATTY_MID used otherwise.
2690  */
2691 static int
2692 create_link_common(char *devlink, char *contents, int *exists)
2693 {
2694         int try;
2695         int linksize;
2696         int max_tries = 0;
2697         static int prev_link_existed = TRUE;
2698         char checkcontents[PATH_MAX + 1];
2699         char *hide;
2700 
2701         *exists = FALSE;
2702 
2703         /* Database is not updated when file_mods == FALSE */
2704         if (file_mods == FALSE) {
2705                 /* we want *actual* link contents so no alias redirection */
2706                 linksize = readlink(devlink, checkcontents, PATH_MAX);
2707                 if (linksize > 0) {
2708                         checkcontents[linksize] = '\0';
2709                         if (strcmp(checkcontents, contents) != 0) {
2710                                 vprint(CHATTY_MID, REMOVING_LINK,
2711                                     devlink, checkcontents);
2712                                 return (DEVFSADM_SUCCESS);
2713                         } else {
2714                                 vprint(CHATTY_MID, "link exists and is correct:"
2715                                     " %s -> %s\n", devlink, contents);
2716                                 /* failure only in that the link existed */
2717                                 return (DEVFSADM_FAILURE);
2718                         }
2719                 } else {
2720                         vprint(VERBOSE_MID, CREATING_LINK, devlink, contents);
2721                         return (DEVFSADM_SUCCESS);
2722                 }
2723         }
2724 
2725         /*
2726          * systems calls are expensive, so predict whether to readlink
2727          * or symlink first, based on previous attempt
2728          */
2729         if (prev_link_existed == FALSE) {
2730                 try = CREATE_LINK;
2731         } else {
2732                 try = READ_LINK;
2733         }
2734 
2735         while (++max_tries <= 3) {
2736 
2737                 switch (try) {
2738                 case  CREATE_LINK:
2739 
2740                         if (symlink(contents, devlink) == 0) {
2741                                 vprint(VERBOSE_MID, CREATING_LINK, devlink,
2742                                     contents);
2743                                 prev_link_existed = FALSE;
2744                                 /* link successfully created */
2745                                 *exists = TRUE;
2746                                 set_logindev_perms(devlink);
2747                                 return (DEVFSADM_SUCCESS);
2748                         } else {
2749                                 switch (errno) {
2750 
2751                                 case ENOENT:
2752                                         /* dirpath to node doesn't exist */
2753                                         hide = strrchr(devlink, '/');
2754                                         *hide = '\0';
2755                                         s_mkdirp(devlink, S_IRWXU|S_IRGRP|
2756                                             S_IXGRP|S_IROTH|S_IXOTH);
2757                                         *hide = '/';
2758                                         break;
2759                                 case EEXIST:
2760                                         try = READ_LINK;
2761                                         break;
2762                                 default:
2763                                         err_print(SYMLINK_FAILED, devlink,
2764                                             contents, strerror(errno));
2765                                         return (DEVFSADM_FAILURE);
2766                                 }
2767                         }
2768                         break;
2769 
2770                 case READ_LINK:
2771 
2772                         /*
2773                          * If there is redirection, new phys path
2774                          * and old phys path will not match and the
2775                          * link will be created with new phys path
2776                          * which is what we want. So we want real
2777                          * contents.
2778                          */
2779                         linksize = readlink(devlink, checkcontents, PATH_MAX);
2780                         if (linksize >= 0) {
2781                                 checkcontents[linksize] = '\0';
2782                                 if (strcmp(checkcontents, contents) != 0) {
2783                                         s_unlink(devlink);
2784                                         vprint(VERBOSE_MID, REMOVING_LINK,
2785                                             devlink, checkcontents);
2786                                         try = CREATE_LINK;
2787                                 } else {
2788                                         prev_link_existed = TRUE;
2789                                         vprint(CHATTY_MID,
2790                                             "link exists and is correct:"
2791                                             " %s -> %s\n", devlink, contents);
2792                                         *exists = TRUE;
2793                                         /* failure in that the link existed */
2794                                         return (DEVFSADM_FAILURE);
2795                                 }
2796                         } else {
2797                                 switch (errno) {
2798                                 case EINVAL:
2799                                         /* not a symlink, remove and create */
2800                                         s_unlink(devlink);
2801                                 default:
2802                                         /* maybe it didn't exist at all */
2803                                         try = CREATE_LINK;
2804                                         break;
2805                                 }
2806                         }
2807                         break;
2808                 }
2809         }
2810         err_print(MAX_ATTEMPTS, devlink, contents);
2811         return (DEVFSADM_FAILURE);
2812 }
2813 
2814 static void
2815 set_logindev_perms(char *devlink)
2816 {
2817         struct login_dev *newdev;
2818         struct passwd pwd, *resp;
2819         char pwd_buf[PATH_MAX];
2820         int rv;
2821         struct stat sb;
2822         char *devfs_path = NULL;
2823 
2824         /*
2825          * We only want logindev perms to be set when a device is
2826          * hotplugged or an application requests synchronous creates.
2827          * So we enable this only in daemon mode. In addition,
2828          * login(1) only fixes the std. /dev dir. So we don't
2829          * change perms if alternate root is set.
2830          * login_dev_enable is TRUE only in these cases.
2831          */
2832         if (login_dev_enable != TRUE)
2833                 return;
2834 
2835         /*
2836          * Normally, /etc/logindevperm has few (8 - 10 entries) which
2837          * may be regular expressions (globs were converted to RE).
2838          * So just do a linear search through the list.
2839          */
2840         for (newdev = login_dev_cache; newdev; newdev = newdev->ldev_next) {
2841                 vprint(FILES_MID, "matching %s with %s\n", devlink,
2842                     newdev->ldev_device);
2843 
2844                 if (regexec(&newdev->ldev_device_regex, devlink, 0,
2845                     NULL, 0) == 0)  {
2846                         vprint(FILES_MID, "matched %s with %s\n", devlink,
2847                             newdev->ldev_device);
2848                         break;
2849                 }
2850         }
2851 
2852         if (newdev == NULL)
2853                 return;
2854 
2855         /*
2856          * we have a match, now find the driver associated with this
2857          * minor node using a snapshot on the physical path
2858          */
2859         (void) resolve_link(devlink, NULL, NULL, &devfs_path, 0);
2860         /*
2861          * We dont need redirection here - the actual link contents
2862          * whether "alias" or "current" are fine
2863          */
2864         if (devfs_path) {
2865                 di_node_t node;
2866                 char *drv;
2867                 struct driver_list *list;
2868                 char *p;
2869 
2870                 /* truncate on : so we can take a snapshot */
2871                 (void) strcpy(pwd_buf, devfs_path);
2872                 p = strrchr(pwd_buf, ':');
2873                 if (p == NULL) {
2874                         free(devfs_path);
2875                         return;
2876                 }
2877                 *p = '\0';
2878 
2879                 vprint(FILES_MID, "link=%s->physpath=%s\n",
2880                     devlink, pwd_buf);
2881 
2882                 node = di_init(pwd_buf, DINFOMINOR);
2883 
2884                 drv = NULL;
2885                 if (node) {
2886                         drv = di_driver_name(node);
2887 
2888                         if (drv) {
2889                                 vprint(FILES_MID, "%s: driver is %s\n",
2890                                     devlink, drv);
2891                         }
2892                 }
2893                 /* search thru the driver list specified in logindevperm */
2894                 list = newdev->ldev_driver_list;
2895                 if ((drv != NULL) && (list != NULL)) {
2896                         while (list) {
2897                                 if (strcmp(list->driver_name,
2898                                     drv) == 0) {
2899                                         vprint(FILES_MID,
2900                                             "driver %s match!\n", drv);
2901                                         break;
2902                                 }
2903                                 list = list->next;
2904                         }
2905                         if (list == NULL) {
2906                                 vprint(FILES_MID, "no driver match!\n");
2907                                 free(devfs_path);
2908                                 return;
2909                         }
2910                 }
2911                 free(devfs_path);
2912                 di_fini(node);
2913         } else {
2914                 return;
2915         }
2916 
2917         vprint(FILES_MID, "changing permissions of %s\n", devlink);
2918 
2919         /*
2920          * We have a match. We now attempt to determine the
2921          * owner and group of the console user.
2922          *
2923          * stat() the console device newdev->ldev_console
2924          * which will always exist - it will have the right owner but
2925          * not the right group. Use getpwuid_r() to determine group for this
2926          * uid.
2927          * Note, it is safe to use name service here since if name services
2928          * are not available (during boot or in single-user mode), then
2929          * console owner will be root and its gid can be found in
2930          * local files.
2931          */
2932         if (stat(newdev->ldev_console, &sb) == -1) {
2933                 vprint(VERBOSE_MID, STAT_FAILED, newdev->ldev_console,
2934                     strerror(errno));
2935                 return;
2936         }
2937 
2938         resp = NULL;
2939         rv = getpwuid_r(sb.st_uid, &pwd, pwd_buf, sizeof (pwd_buf), &resp);
2940         if (rv || resp == NULL) {
2941                 rv = rv ? rv : EINVAL;
2942                 vprint(VERBOSE_MID, GID_FAILED, sb.st_uid,
2943                     strerror(rv));
2944                 return;
2945         }
2946 
2947         assert(&pwd == resp);
2948 
2949         sb.st_gid = resp->pw_gid;
2950 
2951         if (chmod(devlink, newdev->ldev_perms) == -1) {
2952                 vprint(VERBOSE_MID, CHMOD_FAILED, devlink,
2953                     strerror(errno));
2954                 return;
2955         }
2956 
2957         if (chown(devlink, sb.st_uid, sb.st_gid)  == -1) {
2958                 vprint(VERBOSE_MID, CHOWN_FAILED, devlink,
2959                     strerror(errno));
2960         }
2961 }
2962 
2963 /*
2964  * Reset /devices node with appropriate permissions and
2965  * ownership as specified in /etc/minor_perm.
2966  */
2967 static void
2968 reset_node_permissions(di_node_t node, di_minor_t minor)
2969 {
2970         int spectype;
2971         char phy_path[PATH_MAX + 1];
2972         mode_t mode;
2973         dev_t dev;
2974         uid_t uid;
2975         gid_t gid;
2976         struct stat sb;
2977         char *dev_path, *aminor = NULL;
2978 
2979         /* lphy_path starts with / */
2980         if ((dev_path = di_devfs_path(node)) == NULL) {
2981                 err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
2982                 devfsadm_exit(1);
2983                 /*NOTREACHED*/
2984         }
2985         (void) strcpy(lphy_path, dev_path);
2986         di_devfs_path_free(dev_path);
2987 
2988         (void) strcat(lphy_path, ":");
2989         if (di_minor_type(minor) == DDM_ALIAS) {
2990                 char *driver;
2991                 aminor = di_minor_name(minor);
2992                 driver = di_driver_name(di_minor_devinfo(minor));
2993                 (void) strcat(lphy_path, driver);
2994         } else
2995                 (void) strcat(lphy_path, di_minor_name(minor));
2996 
2997         (void) strcpy(phy_path, devices_dir);
2998         (void) strcat(phy_path, lphy_path);
2999 
3000         lnode = node;
3001         lminor = minor;
3002 
3003         vprint(CHATTY_MID, "reset_node_permissions: phy_path=%s lphy_path=%s\n",
3004             phy_path, lphy_path);
3005 
3006         dev = di_minor_devt(minor);
3007         spectype = di_minor_spectype(minor); /* block or char */
3008 
3009         getattr(phy_path, aminor, spectype, dev, &mode, &uid, &gid);
3010 
3011         /*
3012          * compare and set permissions and ownership
3013          *
3014          * Under devfs, a quick insertion and removal of USB devices
3015          * would cause stat of physical path to fail. In this case,
3016          * we emit a verbose message, but don't print errors.
3017          */
3018         if ((stat(phy_path, &sb) == -1) || (sb.st_rdev != dev)) {
3019                 vprint(VERBOSE_MID, NO_DEVFS_NODE, phy_path);
3020                 return;
3021         }
3022 
3023         /*
3024          * If we are here for a new device
3025          *      If device allocation is on
3026          *      then
3027          *              set ownership to root:other and permissions to 0000
3028          *      else
3029          *              set ownership and permissions as specified in minor_perm
3030          * If we are here for an existing device
3031          *      If device allocation is to be turned on
3032          *      then
3033          *              reset ownership to root:other and permissions to 0000
3034          *      else if device allocation is to be turned off
3035          *              reset ownership and permissions to those specified in
3036          *              minor_perm
3037          *      else
3038          *              preserve existing/user-modified ownership and
3039          *              permissions
3040          *
3041          * devfs indicates a new device by faking access time to be zero.
3042          */
3043         if (sb.st_atime != 0) {
3044                 int  i;
3045                 char *nt;
3046 
3047                 if ((devalloc_flag == 0) && (devalloc_is_on != 1))
3048                         /*
3049                          * Leave existing devices as they are if we are not
3050                          * turning device allocation on/off.
3051                          */
3052                         return;
3053 
3054                 nt = di_minor_nodetype(minor);
3055 
3056                 if (nt == NULL)
3057                         return;
3058 
3059                 for (i = 0; devalloc_list[i]; i++) {
3060                         if (strcmp(nt, devalloc_list[i]) == 0)
3061                                 /*
3062                                  * One of the types recognized by devalloc,
3063                                  * reset attrs.
3064                                  */
3065                                 break;
3066                 }
3067                 if (devalloc_list[i] == NULL)
3068                         return;
3069         }
3070 
3071         if (file_mods == FALSE) {
3072                 /* Nothing more to do if simulating */
3073                 vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode);
3074                 return;
3075         }
3076 
3077         if ((devalloc_flag == DA_ON) ||
3078             ((devalloc_is_on == 1) && (devalloc_flag != DA_OFF))) {
3079                 /*
3080                  * we are here either to turn device allocation on or
3081                  * to add a new device while device allocation is on
3082                  * (and we've confirmed that we're not turning it
3083                  * off).
3084                  */
3085                 mode = DEALLOC_MODE;
3086                 uid = DA_UID;
3087                 gid = DA_GID;
3088         }
3089 
3090         if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) ||
3091             (sb.st_mode != mode)) {
3092                 if (chmod(phy_path, mode) == -1)
3093                         vprint(VERBOSE_MID, CHMOD_FAILED,
3094                             phy_path, strerror(errno));
3095         }
3096         if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) ||
3097             (sb.st_uid != uid || sb.st_gid != gid)) {
3098                 if (chown(phy_path, uid, gid) == -1)
3099                         vprint(VERBOSE_MID, CHOWN_FAILED,
3100                             phy_path, strerror(errno));
3101         }
3102 
3103         /* Report that we actually did something */
3104         vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode);
3105 }
3106 
3107 /*
3108  * Removes logical link and the minor node it refers to.  If file is a
3109  * link, we recurse and try to remove the minor node (or link if path is
3110  * a double link) that file's link contents refer to.
3111  */
3112 static void
3113 devfsadm_rm_work(char *file, int recurse, int file_type)
3114 {
3115         char *fcn = "devfsadm_rm_work: ";
3116         int linksize;
3117         char contents[PATH_MAX + 1];
3118         char nextfile[PATH_MAX + 1];
3119         char newfile[PATH_MAX + 1];
3120         char *ptr;
3121 
3122         vprint(REMOVE_MID, "%s%s\n", fcn, file);
3123 
3124         /*
3125          * Note: we don't remove /devices (non-links) entries because they are
3126          *      covered by devfs.
3127          */
3128         if (file_type != TYPE_LINK) {
3129                 return;
3130         }
3131 
3132         /* split into multiple if's due to excessive indentations */
3133         (void) strcpy(newfile, dev_dir);
3134         (void) strcat(newfile, "/");
3135         (void) strcat(newfile, file);
3136 
3137         /*
3138          * we dont care about the content of the symlink, so
3139          * redirection is not needed.
3140          */
3141         if ((recurse == TRUE) &&
3142             ((linksize = readlink(newfile, contents, PATH_MAX)) > 0)) {
3143                 contents[linksize] = '\0';
3144 
3145                 /*
3146                  * recurse if link points to another link
3147                  */
3148                 if (is_minor_node(contents, &ptr) != DEVFSADM_TRUE) {
3149                         if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0) {
3150                                 devfsadm_rm_work(&contents[strlen(DEV) + 1],
3151                                     TRUE, TYPE_LINK);
3152                         } else {
3153                                 if ((ptr = strrchr(file, '/')) != NULL) {
3154                                         *ptr = '\0';
3155                                         (void) strcpy(nextfile, file);
3156                                         *ptr = '/';
3157                                         (void) strcat(nextfile, "/");
3158                                 } else {
3159                                         (void) strcpy(nextfile, "");
3160                                 }
3161                                 (void) strcat(nextfile, contents);
3162                                 devfsadm_rm_work(nextfile, TRUE, TYPE_LINK);
3163                         }
3164                 }
3165         }
3166 
3167         vprint(VERBOSE_MID, DEVFSADM_UNLINK, newfile);
3168         if (file_mods == TRUE) {
3169                 rm_link_from_cache(file);
3170                 s_unlink(newfile);
3171                 rm_parent_dir_if_empty(newfile);
3172                 invalidate_enumerate_cache();
3173                 (void) di_devlink_rm_link(devlink_cache, file);
3174         }
3175 }
3176 
3177 void
3178 devfsadm_rm_link(char *file)
3179 {
3180         devfsadm_rm_work(file, FALSE, TYPE_LINK);
3181 }
3182 
3183 void
3184 devfsadm_rm_all(char *file)
3185 {
3186         devfsadm_rm_work(file, TRUE, TYPE_LINK);
3187 }
3188 
3189 static int
3190 s_rmdir(char *path)
3191 {
3192         int     i;
3193         char    *rpath, *dir;
3194         const char *fcn = "s_rmdir";
3195 
3196         /*
3197          * Certain directories are created at install time by packages.
3198          * Some of them (listed in sticky_dirs[]) are required by apps
3199          * and need to be present even when empty.
3200          */
3201         vprint(REMOVE_MID, "%s: checking if %s is sticky\n", fcn, path);
3202 
3203         rpath = path + strlen(dev_dir) + 1;
3204 
3205         for (i = 0; (dir = sticky_dirs[i]) != NULL; i++) {
3206                 if (*rpath == *dir) {
3207                         if (strcmp(rpath, dir) == 0) {
3208                                 vprint(REMOVE_MID, "%s: skipping sticky dir: "
3209                                     "%s\n", fcn, path);
3210                                 errno = EEXIST;
3211                                 return (-1);
3212                         }
3213                 }
3214         }
3215 
3216         return (rmdir(path));
3217 }
3218 
3219 /*
3220  * Try to remove any empty directories up the tree.  It is assumed that
3221  * pathname is a file that was removed, so start with its parent, and
3222  * work up the tree.
3223  */
3224 static void
3225 rm_parent_dir_if_empty(char *pathname)
3226 {
3227         char *ptr, path[PATH_MAX + 1];
3228         char *fcn = "rm_parent_dir_if_empty: ";
3229 
3230         vprint(REMOVE_MID, "%schecking %s if empty\n", fcn, pathname);
3231 
3232         (void) strcpy(path, pathname);
3233 
3234         /*
3235          * ascend up the dir tree, deleting all empty dirs.
3236          * Return immediately if a dir is not empty.
3237          */
3238         for (;;) {
3239 
3240                 if ((ptr = strrchr(path, '/')) == NULL) {
3241                         return;
3242                 }
3243 
3244                 *ptr = '\0';
3245 
3246                 if (finddev_emptydir(path)) {
3247                         /* directory is empty */
3248                         if (s_rmdir(path) == 0) {
3249                                 vprint(REMOVE_MID,
3250                                     "%sremoving empty dir %s\n", fcn, path);
3251                         } else if (errno == EEXIST) {
3252                                 vprint(REMOVE_MID,
3253                                     "%sfailed to remove dir: %s\n", fcn, path);
3254                                 return;
3255                         }
3256                 } else {
3257                         /* some other file is here, so return */
3258                         vprint(REMOVE_MID, "%sdir not empty: %s\n", fcn, path);
3259                         return;
3260                 }
3261         }
3262 }
3263 
3264 /*
3265  * This function and all the functions it calls below were added to
3266  * handle the unique problem with world wide names (WWN).  The problem is
3267  * that if a WWN device is moved to another address on the same controller
3268  * its logical link will change, while the physical node remains the same.
3269  * The result is that two logical links will point to the same physical path
3270  * in /devices, the valid link and a stale link. This function will
3271  * find all the stale nodes, though at a significant performance cost.
3272  *
3273  * Caching is used to increase performance.
3274  * A cache will be built from disk if the cache tag doesn't already exist.
3275  * The cache tag is a regular expression "dir_re", which selects a
3276  * subset of disks to search from typically something like
3277  * "dev/cXt[0-9]+d[0-9]+s[0-9]+".  After the cache is built, consistency must
3278  * be maintained, so entries are added as new links are created, and removed
3279  * as old links are deleted.  The whole cache is flushed if we are a daemon,
3280  * and another devfsadm process ran in between.
3281  *
3282  * Once the cache is built, this function finds the cache which matches
3283  * dir_re, and then it searches all links in that cache looking for
3284  * any link whose contents match "valid_link_contents" with a corresponding link
3285  * which does not match "valid_link".  Any such matches are stale and removed.
3286  *
3287  * This happens outside the context of a "reparenting" so we dont need
3288  * redirection.
3289  */
3290 void
3291 devfsadm_rm_stale_links(char *dir_re, char *valid_link, di_node_t node,
3292                         di_minor_t minor)
3293 {
3294         link_t *link;
3295         linkhead_t *head;
3296         char phy_path[PATH_MAX + 1];
3297         char *valid_link_contents;
3298         char *dev_path;
3299         char rmlink[PATH_MAX + 1];
3300 
3301         /*
3302          * try to use devices path
3303          */
3304         if ((node == lnode) && (minor == lminor)) {
3305                 valid_link_contents = lphy_path;
3306         } else {
3307                 if ((dev_path = di_devfs_path(node)) == NULL) {
3308                         err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
3309                         devfsadm_exit(1);
3310                         /*NOTREACHED*/
3311                 }
3312                 (void) strcpy(phy_path, dev_path);
3313                 di_devfs_path_free(dev_path);
3314 
3315                 (void) strcat(phy_path, ":");
3316                 (void) strcat(phy_path, di_minor_name(minor));
3317                 valid_link_contents = phy_path;
3318         }
3319 
3320         /*
3321          * As an optimization, check to make sure the corresponding
3322          * devlink was just created before continuing.
3323          */
3324 
3325         if (linknew == FALSE) {
3326                 return;
3327         }
3328 
3329         head = get_cached_links(dir_re);
3330 
3331         assert(head->nextlink == NULL);
3332 
3333         for (link = head->link; link != NULL; link = head->nextlink) {
3334                 /*
3335                  * See hot_cleanup() for why we do this
3336                  */
3337                 head->nextlink = link->next;
3338                 if ((strcmp(link->contents, valid_link_contents) == 0) &&
3339                     (strcmp(link->devlink, valid_link) != 0)) {
3340                         vprint(CHATTY_MID, "removing %s -> %s\n"
3341                             "valid link is: %s -> %s\n",
3342                             link->devlink, link->contents,
3343                             valid_link, valid_link_contents);
3344                         /*
3345                          * Use a copy of the cached link name as the
3346                          * cache entry will go away during link removal
3347                          */
3348                         (void) snprintf(rmlink, sizeof (rmlink), "%s",
3349                             link->devlink);
3350                         devfsadm_rm_link(rmlink);
3351                 }
3352         }
3353 }
3354 
3355 /*
3356  * Return previously created cache, or create cache.
3357  */
3358 static linkhead_t *
3359 get_cached_links(char *dir_re)
3360 {
3361         recurse_dev_t rd;
3362         linkhead_t *linkhead;
3363         int n;
3364 
3365         vprint(BUILDCACHE_MID, "get_cached_links: %s\n", dir_re);
3366 
3367         for (linkhead = headlinkhead; linkhead != NULL;
3368             linkhead = linkhead->nexthead) {
3369                 if (strcmp(linkhead->dir_re, dir_re) == 0) {
3370                         return (linkhead);
3371                 }
3372         }
3373 
3374         /*
3375          * This tag is not in cache, so add it, along with all its
3376          * matching /dev entries.  This is the only time we go to disk.
3377          */
3378         linkhead = s_malloc(sizeof (linkhead_t));
3379         linkhead->nexthead = headlinkhead;
3380         headlinkhead = linkhead;
3381         linkhead->dir_re = s_strdup(dir_re);
3382 
3383         if ((n = regcomp(&(linkhead->dir_re_compiled), dir_re,
3384             REG_EXTENDED)) != 0) {
3385                 err_print(REGCOMP_FAILED,  dir_re, n);
3386         }
3387 
3388         linkhead->nextlink = NULL;
3389         linkhead->link = NULL;
3390 
3391         rd.fcn = build_devlink_list;
3392         rd.data = (void *)linkhead;
3393 
3394         vprint(BUILDCACHE_MID, "get_cached_links: calling recurse_dev_re\n");
3395 
3396         /* call build_devlink_list for each directory in the dir_re RE */
3397         if (dir_re[0] == '/') {
3398                 recurse_dev_re("/", &dir_re[1], &rd);
3399         } else {
3400                 recurse_dev_re(dev_dir, dir_re, &rd);
3401         }
3402 
3403         return (linkhead);
3404 }
3405 
3406 static void
3407 build_devlink_list(char *devlink, void *data)
3408 {
3409         char *fcn = "build_devlink_list: ";
3410         char *ptr;
3411         char *r_contents;
3412         char *r_devlink;
3413         char contents[PATH_MAX + 1];
3414         char newlink[PATH_MAX + 1];
3415         char stage_link[PATH_MAX + 1];
3416         int linksize;
3417         linkhead_t *linkhead = (linkhead_t *)data;
3418         link_t *link;
3419         int i = 0;
3420 
3421         vprint(BUILDCACHE_MID, "%scheck_link: %s\n", fcn, devlink);
3422 
3423         (void) strcpy(newlink, devlink);
3424 
3425         do {
3426                 /*
3427                  * None of the consumers of this function need redirection
3428                  * so this readlink gets the "current" contents
3429                  */
3430                 linksize = readlink(newlink, contents, PATH_MAX);
3431                 if (linksize <= 0) {
3432                         /*
3433                          * The first pass through the do loop we may readlink()
3434                          * non-symlink files(EINVAL) from false regexec matches.
3435                          * Suppress error messages in those cases or if the link
3436                          * content is the empty string.
3437                          */
3438                         if (linksize < 0 && (i || errno != EINVAL))
3439                                 err_print(READLINK_FAILED, "build_devlink_list",
3440                                     newlink, strerror(errno));
3441                         return;
3442                 }
3443                 contents[linksize] = '\0';
3444                 i = 1;
3445 
3446                 if (is_minor_node(contents, &r_contents) == DEVFSADM_FALSE) {
3447                         /*
3448                          * assume that link contents is really a pointer to
3449                          * another link, so recurse and read its link contents.
3450                          *
3451                          * some link contents are absolute:
3452                          *      /dev/audio -> /dev/sound/0
3453                          */
3454                         if (strncmp(contents, DEV "/",
3455                             strlen(DEV) + strlen("/")) != 0) {
3456 
3457                                 if ((ptr = strrchr(newlink, '/')) == NULL) {
3458                                         vprint(REMOVE_MID, "%s%s -> %s invalid "
3459                                             "link. missing '/'\n", fcn,
3460                                             newlink, contents);
3461                                         return;
3462                                 }
3463                                 *ptr = '\0';
3464                                 (void) strcpy(stage_link, newlink);
3465                                 *ptr = '/';
3466                                 (void) strcat(stage_link, "/");
3467                                 (void) strcat(stage_link, contents);
3468                                 (void) strcpy(newlink, stage_link);
3469                         } else {
3470                                 (void) strcpy(newlink, dev_dir);
3471                                 (void) strcat(newlink, "/");
3472                                 (void) strcat(newlink,
3473                                     &contents[strlen(DEV) + strlen("/")]);
3474                         }
3475 
3476                 } else {
3477                         newlink[0] = '\0';
3478                 }
3479         } while (newlink[0] != '\0');
3480 
3481         if (strncmp(devlink, dev_dir, strlen(dev_dir)) != 0) {
3482                 vprint(BUILDCACHE_MID, "%sinvalid link: %s\n", fcn, devlink);
3483                 return;
3484         }
3485 
3486         r_devlink = devlink + strlen(dev_dir);
3487 
3488         if (r_devlink[0] != '/')
3489                 return;
3490 
3491         link = s_malloc(sizeof (link_t));
3492 
3493         /* don't store the '/' after rootdir/dev */
3494         r_devlink += 1;
3495 
3496         vprint(BUILDCACHE_MID, "%scaching link: %s\n", fcn, r_devlink);
3497         link->devlink = s_strdup(r_devlink);
3498 
3499         link->contents = s_strdup(r_contents);
3500 
3501         link->next = linkhead->link;
3502         linkhead->link = link;
3503 }
3504 
3505 /*
3506  * to be consistent, devlink must not begin with / and must be
3507  * relative to /dev/, whereas physpath must contain / and be
3508  * relative to /devices.
3509  */
3510 static void
3511 add_link_to_cache(char *devlink, char *physpath)
3512 {
3513         linkhead_t *linkhead;
3514         link_t *link;
3515         int added = 0;
3516 
3517         if (file_mods == FALSE) {
3518                 return;
3519         }
3520 
3521         vprint(CACHE_MID, "add_link_to_cache: %s -> %s ",
3522             devlink, physpath);
3523 
3524         for (linkhead = headlinkhead; linkhead != NULL;
3525             linkhead = linkhead->nexthead) {
3526                 if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0)
3527                     == 0) {
3528                         added++;
3529                         link = s_malloc(sizeof (link_t));
3530                         link->devlink = s_strdup(devlink);
3531                         link->contents = s_strdup(physpath);
3532                         link->next = linkhead->link;
3533                         linkhead->link = link;
3534                 }
3535         }
3536 
3537         vprint(CACHE_MID,
3538             " %d %s\n", added, added == 0 ? "NOT ADDED" : "ADDED");
3539 }
3540 
3541 /*
3542  * Remove devlink from cache.  Devlink must be relative to /dev/ and not start
3543  * with /.
3544  */
3545 static void
3546 rm_link_from_cache(char *devlink)
3547 {
3548         linkhead_t *linkhead;
3549         link_t **linkp;
3550         link_t *save;
3551 
3552         vprint(CACHE_MID, "rm_link_from_cache enter: %s\n", devlink);
3553 
3554         for (linkhead = headlinkhead; linkhead != NULL;
3555             linkhead = linkhead->nexthead) {
3556                 if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0)
3557                     == 0) {
3558 
3559                         for (linkp = &(linkhead->link); *linkp != NULL; ) {
3560                                 if ((strcmp((*linkp)->devlink, devlink) == 0)) {
3561                                         save = *linkp;
3562                                         *linkp = (*linkp)->next;
3563                                         /*
3564                                          * We are removing our caller's
3565                                          * "next" link. Update the nextlink
3566                                          * field in the head so that our
3567                                          * callers accesses the next valid
3568                                          * link
3569                                          */
3570                                         if (linkhead->nextlink == save)
3571                                                 linkhead->nextlink = *linkp;
3572                                         free(save->devlink);
3573                                         free(save->contents);
3574                                         free(save);
3575                                         vprint(CACHE_MID, " %s FREED FROM "
3576                                             "CACHE\n", devlink);
3577                                 } else {
3578                                         linkp = &((*linkp)->next);
3579                                 }
3580                         }
3581                 }
3582         }
3583 }
3584 
3585 static void
3586 rm_all_links_from_cache()
3587 {
3588         linkhead_t *linkhead;
3589         linkhead_t *nextlinkhead;
3590         link_t *link;
3591         link_t *nextlink;
3592 
3593         vprint(CACHE_MID, "rm_all_links_from_cache\n");
3594 
3595         for (linkhead = headlinkhead; linkhead != NULL;
3596             linkhead = nextlinkhead) {
3597 
3598                 nextlinkhead = linkhead->nexthead;
3599                 assert(linkhead->nextlink == NULL);
3600                 for (link = linkhead->link; link != NULL; link = nextlink) {
3601                         nextlink = link->next;
3602                         free(link->devlink);
3603                         free(link->contents);
3604                         free(link);
3605                 }
3606                 regfree(&(linkhead->dir_re_compiled));
3607                 free(linkhead->dir_re);
3608                 free(linkhead);
3609         }
3610         headlinkhead = NULL;
3611 }
3612 
3613 /*
3614  * Called when the kernel has modified the incore path_to_inst data.  This
3615  * function will schedule a flush of the data to the filesystem.
3616  */
3617 static void
3618 devfs_instance_mod(void)
3619 {
3620         char *fcn = "devfs_instance_mod: ";
3621         vprint(PATH2INST_MID, "%senter\n", fcn);
3622 
3623         /* signal instance thread */
3624         (void) mutex_lock(&count_lock);
3625         inst_count++;
3626         (void) cond_signal(&cv);
3627         (void) mutex_unlock(&count_lock);
3628 }
3629 
3630 static void
3631 instance_flush_thread(void)
3632 {
3633         int i;
3634         int idle;
3635 
3636         for (;;) {
3637 
3638                 (void) mutex_lock(&count_lock);
3639                 while (inst_count == 0) {
3640                         (void) cond_wait(&cv, &count_lock);
3641                 }
3642                 inst_count = 0;
3643 
3644                 vprint(PATH2INST_MID, "signaled to flush path_to_inst."
3645                     " Enter delay loop\n");
3646                 /*
3647                  * Wait MAX_IDLE_DELAY seconds after getting the last flush
3648                  * path_to_inst event before invoking a flush, but never wait
3649                  * more than MAX_DELAY seconds after getting the first event.
3650                  */
3651                 for (idle = 0, i = 0; i < MAX_DELAY; i++) {
3652 
3653                         (void) mutex_unlock(&count_lock);
3654                         (void) sleep(1);
3655                         (void) mutex_lock(&count_lock);
3656 
3657                         /* shorten the delay if we are idle */
3658                         if (inst_count == 0) {
3659                                 idle++;
3660                                 if (idle > MAX_IDLE_DELAY) {
3661                                         break;
3662                                 }
3663                         } else {
3664                                 inst_count = idle = 0;
3665                         }
3666                 }
3667 
3668                 (void) mutex_unlock(&count_lock);
3669 
3670                 flush_path_to_inst();
3671         }
3672 }
3673 
3674 /*
3675  * Helper function for flush_path_to_inst() below; this routine calls the
3676  * inst_sync syscall to flush the path_to_inst database to the given file.
3677  */
3678 static int
3679 do_inst_sync(char *filename, char *instfilename)
3680 {
3681         void (*sigsaved)(int);
3682         int err = 0, flags = INST_SYNC_IF_REQUIRED;
3683         struct stat sb;
3684 
3685         if (stat(instfilename, &sb) == -1 && errno == ENOENT)
3686                 flags = INST_SYNC_ALWAYS;
3687 
3688         vprint(INSTSYNC_MID, "do_inst_sync: about to flush %s\n", filename);
3689         sigsaved = sigset(SIGSYS, SIG_IGN);
3690         if (inst_sync(filename, flags) == -1)
3691                 err = errno;
3692         (void) sigset(SIGSYS, sigsaved);
3693 
3694         switch (err) {
3695         case 0:
3696                 return (DEVFSADM_SUCCESS);
3697         case EALREADY:  /* no-op, path_to_inst already up to date */
3698                 return (EALREADY);
3699         case ENOSYS:
3700                 err_print(CANT_LOAD_SYSCALL);
3701                 break;
3702         case EPERM:
3703                 err_print(SUPER_TO_SYNC);
3704                 break;
3705         default:
3706                 err_print(INSTSYNC_FAILED, filename, strerror(err));
3707                 break;
3708         }
3709         return (DEVFSADM_FAILURE);
3710 }
3711 
3712 /*
3713  * Flush the kernel's path_to_inst database to /etc/path_to_inst.  To do so
3714  * safely, the database is flushed to a temporary file, then moved into place.
3715  *
3716  * The following files are used during this process:
3717  *      /etc/path_to_inst:      The path_to_inst file
3718  *      /etc/path_to_inst.<pid>: Contains data flushed from the kernel
3719  *      /etc/path_to_inst.old:  The backup file
3720  *      /etc/path_to_inst.old.<pid>: Temp file for creating backup
3721  *
3722  */
3723 static void
3724 flush_path_to_inst(void)
3725 {
3726         char *new_inst_file = NULL;
3727         char *old_inst_file = NULL;
3728         char *old_inst_file_npid = NULL;
3729         FILE *inst_file_fp = NULL;
3730         FILE *old_inst_file_fp = NULL;
3731         struct stat sb;
3732         int err = 0;
3733         int c;
3734         int inst_strlen;
3735 
3736         vprint(PATH2INST_MID, "flush_path_to_inst: %s\n",
3737             (flush_path_to_inst_enable == TRUE) ? "ENABLED" : "DISABLED");
3738 
3739         if (flush_path_to_inst_enable == FALSE) {
3740                 return;
3741         }
3742 
3743         inst_strlen = strlen(inst_file);
3744         new_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 2);
3745         old_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 6);
3746         old_inst_file_npid = s_malloc(inst_strlen +
3747             sizeof (INSTANCE_FILE_SUFFIX));
3748 
3749         (void) snprintf(new_inst_file, inst_strlen + PID_STR_LEN + 2,
3750             "%s.%ld", inst_file, getpid());
3751 
3752         if (stat(new_inst_file, &sb) == 0) {
3753                 s_unlink(new_inst_file);
3754         }
3755 
3756         err = do_inst_sync(new_inst_file, inst_file);
3757         if (err != DEVFSADM_SUCCESS) {
3758                 goto out;
3759                 /*NOTREACHED*/
3760         }
3761 
3762         /*
3763          * Now we deal with the somewhat tricky updating and renaming
3764          * of this critical piece of kernel state.
3765          */
3766 
3767         /*
3768          * Copy the current instance file into a temporary file.
3769          * Then rename the temporary file into the backup (.old)
3770          * file and rename the newly flushed kernel data into
3771          * the instance file.
3772          * Of course if 'inst_file' doesn't exist, there's much
3773          * less for us to do .. tee hee.
3774          */
3775         if ((inst_file_fp = fopen(inst_file, "r")) == NULL) {
3776                 /*
3777                  * No such file.  Rename the new onto the old
3778                  */
3779                 if ((err = rename(new_inst_file, inst_file)) != 0)
3780                         err_print(RENAME_FAILED, inst_file, strerror(errno));
3781                 goto out;
3782                 /*NOTREACHED*/
3783         }
3784 
3785         (void) snprintf(old_inst_file, inst_strlen + PID_STR_LEN + 6,
3786             "%s.old.%ld", inst_file, getpid());
3787 
3788         if (stat(old_inst_file, &sb) == 0) {
3789                 s_unlink(old_inst_file);
3790         }
3791 
3792         if ((old_inst_file_fp = fopen(old_inst_file, "w")) == NULL) {
3793                 /*
3794                  * Can't open the 'old_inst_file' file for writing.
3795                  * This is somewhat strange given that the syscall
3796                  * just succeeded to write a file out.. hmm.. maybe
3797                  * the fs just filled up or something nasty.
3798                  *
3799                  * Anyway, abort what we've done so far.
3800                  */
3801                 err_print(CANT_UPDATE, old_inst_file);
3802                 err = DEVFSADM_FAILURE;
3803                 goto out;
3804                 /*NOTREACHED*/
3805         }
3806 
3807         /*
3808          * Copy current instance file into the temporary file
3809          */
3810         err = 0;
3811         while ((c = getc(inst_file_fp)) != EOF) {
3812                 if ((err = putc(c, old_inst_file_fp)) == EOF) {
3813                         break;
3814                 }
3815         }
3816 
3817         if (fclose(old_inst_file_fp) == EOF || err == EOF) {
3818                 vprint(INFO_MID, CANT_UPDATE, old_inst_file);
3819                 err = DEVFSADM_FAILURE;
3820                 goto out;
3821                 /* NOTREACHED */
3822         }
3823 
3824         /*
3825          * Set permissions to be the same on the backup as
3826          * /etc/path_to_inst.
3827          */
3828         (void) chmod(old_inst_file, 0444);
3829 
3830         /*
3831          * So far, everything we've done is more or less reversible.
3832          * But now we're going to commit ourselves.
3833          */
3834 
3835         (void) snprintf(old_inst_file_npid,
3836             inst_strlen + sizeof (INSTANCE_FILE_SUFFIX),
3837             "%s%s", inst_file, INSTANCE_FILE_SUFFIX);
3838 
3839         if ((err = rename(old_inst_file, old_inst_file_npid)) != 0) {
3840                 err_print(RENAME_FAILED, old_inst_file_npid,
3841                     strerror(errno));
3842         } else if ((err = rename(new_inst_file, inst_file)) != 0) {
3843                 err_print(RENAME_FAILED, inst_file, strerror(errno));
3844         }
3845 
3846 out:
3847         if (inst_file_fp != NULL) {
3848                 if (fclose(inst_file_fp) == EOF) {
3849                         err_print(FCLOSE_FAILED, inst_file, strerror(errno));
3850                 }
3851         }
3852 
3853         if (stat(new_inst_file, &sb) == 0) {
3854                 s_unlink(new_inst_file);
3855         }
3856         free(new_inst_file);
3857 
3858         if (stat(old_inst_file, &sb) == 0) {
3859                 s_unlink(old_inst_file);
3860         }
3861         free(old_inst_file);
3862 
3863         free(old_inst_file_npid);
3864 
3865         if (err != 0 && err != EALREADY) {
3866                 err_print(FAILED_TO_UPDATE, inst_file);
3867         }
3868 }
3869 
3870 /*
3871  * detach from tty.  For daemon mode.
3872  */
3873 void
3874 detachfromtty()
3875 {
3876         (void) setsid();
3877         if (DEVFSADM_DEBUG_ON == TRUE) {
3878                 return;
3879         }
3880 
3881         (void) close(0);
3882         (void) close(1);
3883         (void) close(2);
3884         (void) open("/dev/null", O_RDWR, 0);
3885         (void) dup(0);
3886         (void) dup(0);
3887         openlog(DEVFSADMD, LOG_PID, LOG_DAEMON);
3888         (void) setlogmask(LOG_UPTO(LOG_INFO));
3889         logflag = TRUE;
3890 }
3891 
3892 /*
3893  * Use an advisory lock to synchronize updates to /dev.  If the lock is
3894  * held by another process, block in the fcntl() system call until that
3895  * process drops the lock or exits.  The lock file itself is
3896  * DEV_LOCK_FILE.  The process id of the current and last process owning
3897  * the lock is kept in the lock file.  After acquiring the lock, read the
3898  * process id and return it.  It is the process ID which last owned the
3899  * lock, and will be used to determine if caches need to be flushed.
3900  *
3901  * NOTE: if the devlink database is held open by the caller, it may
3902  * be closed by this routine. This is to enforce the following lock ordering:
3903  *      1) /dev lock 2) database open
3904  */
3905 pid_t
3906 enter_dev_lock()
3907 {
3908         struct flock lock;
3909         int n;
3910         pid_t pid;
3911         pid_t last_owner_pid;
3912 
3913         if (file_mods == FALSE) {
3914                 return (0);
3915         }
3916 
3917         (void) snprintf(dev_lockfile, sizeof (dev_lockfile),
3918             "%s/%s", etc_dev_dir, DEV_LOCK_FILE);
3919 
3920         vprint(LOCK_MID, "enter_dev_lock: lock file %s\n", dev_lockfile);
3921 
3922         dev_lock_fd = open(dev_lockfile, O_CREAT|O_RDWR, 0644);
3923         if (dev_lock_fd < 0) {
3924                 err_print(OPEN_FAILED, dev_lockfile, strerror(errno));
3925                 devfsadm_exit(1);
3926                 /*NOTREACHED*/
3927         }
3928 
3929         lock.l_type = F_WRLCK;
3930         lock.l_whence = SEEK_SET;
3931         lock.l_start = 0;
3932         lock.l_len = 0;
3933 
3934         /* try for the lock, but don't wait */
3935         if (fcntl(dev_lock_fd, F_SETLK, &lock) == -1) {
3936                 if ((errno == EACCES) || (errno == EAGAIN)) {
3937                         pid = 0;
3938                         n = read(dev_lock_fd, &pid, sizeof (pid_t));
3939                         vprint(LOCK_MID, "waiting for PID %d to complete\n",
3940                             (int)pid);
3941                         if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) {
3942                                 err_print(LSEEK_FAILED, dev_lockfile,
3943                                     strerror(errno));
3944                                 devfsadm_exit(1);
3945                                 /*NOTREACHED*/
3946                         }
3947                         /*
3948                          * wait for the dev lock. If we have the database open,
3949                          * close it first - the order of lock acquisition should
3950                          * always be:  1) dev_lock 2) database
3951                          * This is to prevent deadlocks with any locks the
3952                          * database code may hold.
3953                          */
3954                         (void) di_devlink_close(&devlink_cache, 0);
3955 
3956                         /* send any sysevents that were queued up. */
3957                         process_syseventq();
3958 
3959                         if (fcntl(dev_lock_fd, F_SETLKW, &lock) == -1) {
3960                                 err_print(LOCK_FAILED, dev_lockfile,
3961                                     strerror(errno));
3962                                 devfsadm_exit(1);
3963                                 /*NOTREACHED*/
3964                         }
3965                 }
3966         }
3967 
3968         hold_dev_lock = TRUE;
3969         pid = 0;
3970         n = read(dev_lock_fd, &pid, sizeof (pid_t));
3971         if (n == sizeof (pid_t) && pid == getpid()) {
3972                 return (pid);
3973         }
3974 
3975         last_owner_pid = pid;
3976 
3977         if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) {
3978                 err_print(LSEEK_FAILED, dev_lockfile, strerror(errno));
3979                 devfsadm_exit(1);
3980                 /*NOTREACHED*/
3981         }
3982         pid = getpid();
3983         n = write(dev_lock_fd, &pid, sizeof (pid_t));
3984         if (n != sizeof (pid_t)) {
3985                 err_print(WRITE_FAILED, dev_lockfile, strerror(errno));
3986                 devfsadm_exit(1);
3987                 /*NOTREACHED*/
3988         }
3989 
3990         return (last_owner_pid);
3991 }
3992 
3993 /*
3994  * Drop the advisory /dev lock, close lock file.  Close and re-open the
3995  * file every time so to ensure a resync if for some reason the lock file
3996  * gets removed.
3997  */
3998 void
3999 exit_dev_lock(int exiting)
4000 {
4001         struct flock unlock;
4002 
4003         if (hold_dev_lock == FALSE) {
4004                 return;
4005         }
4006 
4007         vprint(LOCK_MID, "exit_dev_lock: lock file %s, exiting = %d\n",
4008             dev_lockfile, exiting);
4009 
4010         unlock.l_type = F_UNLCK;
4011         unlock.l_whence = SEEK_SET;
4012         unlock.l_start = 0;
4013         unlock.l_len = 0;
4014 
4015         if (fcntl(dev_lock_fd, F_SETLK, &unlock) == -1) {
4016                 err_print(UNLOCK_FAILED, dev_lockfile, strerror(errno));
4017         }
4018 
4019         hold_dev_lock = FALSE;
4020 
4021         if (close(dev_lock_fd) == -1) {
4022                 err_print(CLOSE_FAILED, dev_lockfile, strerror(errno));
4023                 if (!exiting)
4024                         devfsadm_exit(1);
4025                         /*NOTREACHED*/
4026         }
4027 }
4028 
4029 /*
4030  *
4031  * Use an advisory lock to ensure that only one daemon process is active
4032  * in the system at any point in time.  If the lock is held by another
4033  * process, do not block but return the pid owner of the lock to the
4034  * caller immediately.  The lock is cleared if the holding daemon process
4035  * exits for any reason even if the lock file remains, so the daemon can
4036  * be restarted if necessary.  The lock file is DAEMON_LOCK_FILE.
4037  */
4038 pid_t
4039 enter_daemon_lock(void)
4040 {
4041         struct flock lock;
4042 
4043         (void) snprintf(daemon_lockfile, sizeof (daemon_lockfile),
4044             "%s/%s", etc_dev_dir, DAEMON_LOCK_FILE);
4045 
4046         vprint(LOCK_MID, "enter_daemon_lock: lock file %s\n", daemon_lockfile);
4047 
4048         daemon_lock_fd = open(daemon_lockfile, O_CREAT|O_RDWR, 0644);
4049         if (daemon_lock_fd < 0) {
4050                 err_print(OPEN_FAILED, daemon_lockfile, strerror(errno));
4051                 devfsadm_exit(1);
4052                 /*NOTREACHED*/
4053         }
4054 
4055         lock.l_type = F_WRLCK;
4056         lock.l_whence = SEEK_SET;
4057         lock.l_start = 0;
4058         lock.l_len = 0;
4059 
4060         if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) {
4061 
4062                 if (errno == EAGAIN || errno == EDEADLK) {
4063                         if (fcntl(daemon_lock_fd, F_GETLK, &lock) == -1) {
4064                                 err_print(LOCK_FAILED, daemon_lockfile,
4065                                     strerror(errno));
4066                                 devfsadm_exit(1);
4067                                 /*NOTREACHED*/
4068                         }
4069                         return (lock.l_pid);
4070                 }
4071         }
4072         hold_daemon_lock = TRUE;
4073         return (getpid());
4074 }
4075 
4076 /*
4077  * Drop the advisory daemon lock, close lock file
4078  */
4079 void
4080 exit_daemon_lock(int exiting)
4081 {
4082         struct flock lock;
4083 
4084         if (hold_daemon_lock == FALSE) {
4085                 return;
4086         }
4087 
4088         vprint(LOCK_MID, "exit_daemon_lock: lock file %s, exiting = %d\n",
4089             daemon_lockfile, exiting);
4090 
4091         lock.l_type = F_UNLCK;
4092         lock.l_whence = SEEK_SET;
4093         lock.l_start = 0;
4094         lock.l_len = 0;
4095 
4096         if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) {
4097                 err_print(UNLOCK_FAILED, daemon_lockfile, strerror(errno));
4098         }
4099 
4100         if (close(daemon_lock_fd) == -1) {
4101                 err_print(CLOSE_FAILED, daemon_lockfile, strerror(errno));
4102                 if (!exiting)
4103                         devfsadm_exit(1);
4104                         /*NOTREACHED*/
4105         }
4106 }
4107 
4108 /*
4109  * Called to removed danging nodes in two different modes: RM_PRE, RM_POST.
4110  * RM_PRE mode is called before processing the entire devinfo tree, and RM_POST
4111  * is called after processing the entire devinfo tree.
4112  */
4113 static void
4114 pre_and_post_cleanup(int flags)
4115 {
4116         remove_list_t *rm;
4117         recurse_dev_t rd;
4118         cleanup_data_t cleanup_data;
4119         char *fcn = "pre_and_post_cleanup: ";
4120 
4121         if (build_dev == FALSE)
4122                 return;
4123 
4124         vprint(CHATTY_MID, "attempting %s-cleanup\n",
4125             flags == RM_PRE ? "pre" : "post");
4126         vprint(REMOVE_MID, "%sflags = %d\n", fcn, flags);
4127 
4128         /*
4129          * the generic function recurse_dev_re is shared among different
4130          * functions, so set the method and data that it should use for
4131          * matches.
4132          */
4133         rd.fcn = matching_dev;
4134         rd.data = (void *)&cleanup_data;
4135         cleanup_data.flags = flags;
4136 
4137         (void) mutex_lock(&nfp_mutex);
4138         nfphash_create();
4139 
4140         for (rm = remove_head; rm != NULL; rm = rm->next) {
4141                 if ((flags & rm->remove->flags) == flags) {
4142                         cleanup_data.rm = rm;
4143                         /*
4144                          * If reached this point, RM_PRE or RM_POST cleanup is
4145                          * desired.  clean_ok() decides whether to clean
4146                          * under the given circumstances.
4147                          */
4148                         vprint(REMOVE_MID, "%scleanup: PRE or POST\n", fcn);
4149                         if (clean_ok(rm->remove) == DEVFSADM_SUCCESS) {
4150                                 vprint(REMOVE_MID, "cleanup: cleanup OK\n");
4151                                 recurse_dev_re(dev_dir,
4152                                     rm->remove->dev_dirs_re, &rd);
4153                         }
4154                 }
4155         }
4156         nfphash_destroy();
4157         (void) mutex_unlock(&nfp_mutex);
4158 }
4159 
4160 /*
4161  * clean_ok() determines whether cleanup should be done according
4162  * to the following matrix:
4163  *
4164  * command line arguments RM_PRE    RM_POST       RM_PRE &&    RM_POST &&
4165  *                                                RM_ALWAYS    RM_ALWAYS
4166  * ---------------------- ------     -----        ---------    ----------
4167  *
4168  * <neither -c nor -C>      -         -             pre-clean    post-clean
4169  *
4170  * -C                     pre-clean  post-clean   pre-clean    post-clean
4171  *
4172  * -C -c class            pre-clean  post-clean   pre-clean    post-clean
4173  *                        if class  if class      if class     if class
4174  *                        matches   matches       matches      matches
4175  *
4176  * -c class                -           -          pre-clean    post-clean
4177  *                                                if class     if class
4178  *                                                matches      matches
4179  *
4180  */
4181 static int
4182 clean_ok(devfsadm_remove_V1_t *remove)
4183 {
4184         int i;
4185 
4186         if (single_drv == TRUE) {
4187                 /* no cleanup at all when using -i option */
4188                 return (DEVFSADM_FAILURE);
4189         }
4190 
4191         /*
4192          * no cleanup if drivers are not loaded. We make an exception
4193          * for the "disks" program however, since disks has a public
4194          * cleanup flag (-C) and disk drivers are usually never
4195          * unloaded.
4196          */
4197         if (load_attach_drv == FALSE && strcmp(prog, DISKS) != 0) {
4198                 return (DEVFSADM_FAILURE);
4199         }
4200 
4201         /* if the cleanup flag was not specified, return false */
4202         if ((cleanup == FALSE) && ((remove->flags & RM_ALWAYS) == 0)) {
4203                 return (DEVFSADM_FAILURE);
4204         }
4205 
4206         if (num_classes == 0) {
4207                 return (DEVFSADM_SUCCESS);
4208         }
4209 
4210         /*
4211          * if reached this point, check to see if the class in the given
4212          * remove structure matches a class given on the command line
4213          */
4214 
4215         for (i = 0; i < num_classes; i++) {
4216                 if (strcmp(remove->device_class, classes[i]) == 0) {
4217                         return (DEVFSADM_SUCCESS);
4218                 }
4219         }
4220 
4221         return (DEVFSADM_FAILURE);
4222 }
4223 
4224 /*
4225  * Called to remove dangling nodes after receiving a hotplug event
4226  * containing the physical node pathname to be removed.
4227  */
4228 void
4229 hot_cleanup(char *node_path, char *minor_name, char *ev_subclass,
4230     char *driver_name, int instance)
4231 {
4232         link_t *link;
4233         linkhead_t *head;
4234         remove_list_t *rm;
4235         char *fcn = "hot_cleanup: ";
4236         char path[PATH_MAX + 1];
4237         int path_len;
4238         char rmlink[PATH_MAX + 1];
4239         nvlist_t *nvl = NULL;
4240         int skip;
4241         int ret;
4242 
4243         /*
4244          * dev links can go away as part of hot cleanup.
4245          * So first build event attributes in order capture dev links.
4246          */
4247         if (ev_subclass != NULL)
4248                 nvl = build_event_attributes(EC_DEV_REMOVE, ev_subclass,
4249                     node_path, DI_NODE_NIL, driver_name, instance, minor_name);
4250 
4251         (void) strcpy(path, node_path);
4252         (void) strcat(path, ":");
4253         (void) strcat(path, minor_name == NULL ? "" : minor_name);
4254 
4255         path_len = strlen(path);
4256 
4257         vprint(REMOVE_MID, "%spath=%s\n", fcn, path);
4258 
4259         (void) mutex_lock(&nfp_mutex);
4260         nfphash_create();
4261 
4262         for (rm = remove_head; rm != NULL; rm = rm->next) {
4263                 if ((RM_HOT & rm->remove->flags) == RM_HOT) {
4264                         head = get_cached_links(rm->remove->dev_dirs_re);
4265                         assert(head->nextlink == NULL);
4266                         for (link = head->link;
4267                             link != NULL; link = head->nextlink) {
4268                                 /*
4269                                  * The remove callback below may remove
4270                                  * the current and/or any or all of the
4271                                  * subsequent links in the list.
4272                                  * Save the next link in the head. If
4273                                  * the callback removes the next link
4274                                  * the saved pointer in the head will be
4275                                  * updated by the callback to point at
4276                                  * the next valid link.
4277                                  */
4278                                 head->nextlink = link->next;
4279 
4280                                 /*
4281                                  * if devlink is in no-further-process hash,
4282                                  * skip its remove
4283                                  */
4284                                 if (nfphash_lookup(link->devlink) != NULL)
4285                                         continue;
4286 
4287                                 if (minor_name)
4288                                         skip = strcmp(link->contents, path);
4289                                 else
4290                                         skip = strncmp(link->contents, path,
4291                                             path_len);
4292                                 if (skip ||
4293                                     (call_minor_init(rm->modptr) ==
4294                                     DEVFSADM_FAILURE))
4295                                         continue;
4296 
4297                                 vprint(REMOVE_MID,
4298                                     "%sremoving %s -> %s\n", fcn,
4299                                     link->devlink, link->contents);
4300                                 /*
4301                                  * Use a copy of the cached link name
4302                                  * as the cache entry will go away
4303                                  * during link removal
4304                                  */
4305                                 (void) snprintf(rmlink, sizeof (rmlink),
4306                                     "%s", link->devlink);
4307                                 if (rm->remove->flags & RM_NOINTERPOSE) {
4308                                         ((void (*)(char *))
4309                                             (rm->remove->callback_fcn))(rmlink);
4310                                 } else {
4311                                         ret = ((int (*)(char *))
4312                                             (rm->remove->callback_fcn))(rmlink);
4313                                         if (ret == DEVFSADM_TERMINATE)
4314                                                 nfphash_insert(rmlink);
4315                                 }
4316                         }
4317                 }
4318         }
4319 
4320         nfphash_destroy();
4321         (void) mutex_unlock(&nfp_mutex);
4322 
4323         /* update device allocation database */
4324         if (system_labeled) {
4325                 int     devtype = 0;
4326 
4327                 if (strstr(path, DA_SOUND_NAME))
4328                         devtype = DA_AUDIO;
4329                 else if (strstr(path, "storage"))
4330                         devtype = DA_RMDISK;
4331                 else if (strstr(path, "disk"))
4332                         devtype = DA_RMDISK;
4333                 else if (strstr(path, "floppy"))
4334                         /* TODO: detect usb cds and floppies at insert time */
4335                         devtype = DA_RMDISK;
4336                 else
4337                         goto out;
4338 
4339                 (void) _update_devalloc_db(&devlist, devtype, DA_REMOVE,
4340                     node_path, root_dir);
4341         }
4342 
4343 out:
4344         /* now log an event */
4345         if (nvl) {
4346                 log_event(EC_DEV_REMOVE, ev_subclass, nvl);
4347                 free(nvl);
4348         }
4349 }
4350 
4351 /*
4352  * Open the dir current_dir.  For every file which matches the first dir
4353  * component of path_re, recurse.  If there are no more *dir* path
4354  * components left in path_re (ie no more /), then call function rd->fcn.
4355  */
4356 static void
4357 recurse_dev_re(char *current_dir, char *path_re, recurse_dev_t *rd)
4358 {
4359         regex_t re1;
4360         char *slash;
4361         char new_path[PATH_MAX + 1];
4362         char *anchored_path_re;
4363         size_t len;
4364         finddevhdl_t fhandle;
4365         const char *fp;
4366 
4367         vprint(RECURSEDEV_MID, "recurse_dev_re: curr = %s path=%s\n",
4368             current_dir, path_re);
4369 
4370         if (finddev_readdir(current_dir, &fhandle) != 0)
4371                 return;
4372 
4373         len = strlen(path_re);
4374         if ((slash = strchr(path_re, '/')) != NULL) {
4375                 len = (slash - path_re);
4376         }
4377 
4378         anchored_path_re = s_malloc(len + 3);
4379         (void) sprintf(anchored_path_re, "^%.*s$", len, path_re);
4380 
4381         if (regcomp(&re1, anchored_path_re, REG_EXTENDED) != 0) {
4382                 free(anchored_path_re);
4383                 goto out;
4384         }
4385 
4386         free(anchored_path_re);
4387 
4388         while ((fp = finddev_next(fhandle)) != NULL) {
4389 
4390                 if (regexec(&re1, fp, 0, NULL, 0) == 0) {
4391                         /* match */
4392                         (void) strcpy(new_path, current_dir);
4393                         (void) strcat(new_path, "/");
4394                         (void) strcat(new_path, fp);
4395 
4396                         vprint(RECURSEDEV_MID, "recurse_dev_re: match, new "
4397                             "path = %s\n", new_path);
4398 
4399                         if (slash != NULL) {
4400                                 recurse_dev_re(new_path, slash + 1, rd);
4401                         } else {
4402                                 /* reached the leaf component of path_re */
4403                                 vprint(RECURSEDEV_MID,
4404                                     "recurse_dev_re: calling fcn\n");
4405                                 (*(rd->fcn))(new_path, rd->data);
4406                         }
4407                 }
4408         }
4409 
4410         regfree(&re1);
4411 
4412 out:
4413         finddev_close(fhandle);
4414 }
4415 
4416 /*
4417  *  Found a devpath which matches a RE in the remove structure.
4418  *  Now check to see if it is dangling.
4419  */
4420 static void
4421 matching_dev(char *devpath, void *data)
4422 {
4423         cleanup_data_t *cleanup_data = data;
4424         int norm_len = strlen(dev_dir) + strlen("/");
4425         int ret;
4426         char *fcn = "matching_dev: ";
4427 
4428         vprint(RECURSEDEV_MID, "%sexamining devpath = '%s'\n", fcn,
4429             devpath);
4430 
4431         /*
4432          * If the link is in the no-further-process hash
4433          * don't do any remove operation on it.
4434          */
4435         if (nfphash_lookup(devpath + norm_len) != NULL)
4436                 return;
4437 
4438         /*
4439          * Dangling check will work whether "alias" or "current"
4440          * so no need to redirect.
4441          */
4442         if (resolve_link(devpath, NULL, NULL, NULL, 1) == TRUE) {
4443                 if (call_minor_init(cleanup_data->rm->modptr) ==
4444                     DEVFSADM_FAILURE) {
4445                         return;
4446                 }
4447 
4448                 devpath += norm_len;
4449 
4450                 vprint(RECURSEDEV_MID, "%scalling callback %s\n", fcn, devpath);
4451                 if (cleanup_data->rm->remove->flags & RM_NOINTERPOSE)
4452                         ((void (*)(char *))
4453                             (cleanup_data->rm->remove->callback_fcn))(devpath);
4454                 else {
4455                         ret = ((int (*)(char *))
4456                             (cleanup_data->rm->remove->callback_fcn))(devpath);
4457                         if (ret == DEVFSADM_TERMINATE) {
4458                                 /*
4459                                  * We want no further remove processing for
4460                                  * this link. Add it to the nfp_hash;
4461                                  */
4462                                 nfphash_insert(devpath);
4463                         }
4464                 }
4465         }
4466 }
4467 
4468 int
4469 devfsadm_read_link(di_node_t anynode, char *link, char **devfs_path)
4470 {
4471         char devlink[PATH_MAX];
4472         char *path;
4473 
4474         *devfs_path = NULL;
4475 
4476         /* prepend link with dev_dir contents */
4477         (void) strcpy(devlink, dev_dir);
4478         (void) strcat(devlink, "/");
4479         (void) strcat(devlink, link);
4480 
4481         /* We *don't* want a stat of the /devices node */
4482         path = NULL;
4483         (void) resolve_link(devlink, NULL, NULL, &path, 0);
4484         if (path != NULL) {
4485                 /* redirect if alias to current */
4486                 *devfs_path = di_alias2curr(anynode, path);
4487                 free(path);
4488         }
4489         return (*devfs_path ? DEVFSADM_SUCCESS : DEVFSADM_FAILURE);
4490 }
4491 
4492 int
4493 devfsadm_link_valid(di_node_t anynode, char *link)
4494 {
4495         struct stat sb;
4496         char devlink[PATH_MAX + 1], *contents, *raw_contents;
4497         int rv, type;
4498         int instance = 0;
4499 
4500         /* prepend link with dev_dir contents */
4501         (void) strcpy(devlink, dev_dir);
4502         (void) strcat(devlink, "/");
4503         (void) strcat(devlink, link);
4504 
4505         if (!device_exists(devlink) || lstat(devlink, &sb) != 0) {
4506                 return (DEVFSADM_FALSE);
4507         }
4508 
4509         raw_contents = NULL;
4510         type = 0;
4511         if (resolve_link(devlink, &raw_contents, &type, NULL, 1) == TRUE) {
4512                 rv = DEVFSADM_FALSE;
4513         } else {
4514                 rv = DEVFSADM_TRUE;
4515         }
4516 
4517         /*
4518          * resolve alias paths for primary links
4519          */
4520         contents = raw_contents;
4521         if (type == DI_PRIMARY_LINK) {
4522                 contents = di_alias2curr(anynode, raw_contents);
4523                 free(raw_contents);
4524         }
4525 
4526         /*
4527          * The link exists. Add it to the database
4528          */
4529         (void) di_devlink_add_link(devlink_cache, link, contents, type);
4530         if (system_labeled && (rv == DEVFSADM_TRUE) &&
4531             strstr(devlink, DA_AUDIO_NAME) && contents) {
4532                 (void) sscanf(contents, "%*[a-z]%d", &instance);
4533                 (void) da_add_list(&devlist, devlink, instance,
4534                     DA_ADD|DA_AUDIO);
4535                 _update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir);
4536         }
4537         free(contents);
4538 
4539         return (rv);
4540 }
4541 
4542 /*
4543  * devpath: Absolute path to /dev link
4544  * content_p: Returns malloced string (link content)
4545  * type_p: Returns link type: primary or secondary
4546  * devfs_path: Returns malloced string: /devices path w/out "/devices"
4547  * dangle: if set, check if link is dangling
4548  * Returns:
4549  *      TRUE if dangling
4550  *      FALSE if not or if caller doesn't care
4551  * Caller is assumed to have initialized pointer contents to NULL
4552  *
4553  */
4554 static int
4555 resolve_link(char *devpath, char **content_p, int *type_p, char **devfs_path,
4556     int dangle)
4557 {
4558         char contents[PATH_MAX + 1];
4559         char stage_link[PATH_MAX + 1];
4560         char *fcn = "resolve_link: ";
4561         char *ptr;
4562         int linksize;
4563         int rv = TRUE;
4564         struct stat sb;
4565 
4566         /*
4567          * This routine will return the "raw" contents. It is upto the
4568          * the caller to redirect "alias" to "current" (or vice versa)
4569          */
4570         linksize = readlink(devpath, contents, PATH_MAX);
4571 
4572         if (linksize <= 0) {
4573                 return (FALSE);
4574         } else {
4575                 contents[linksize] = '\0';
4576         }
4577         vprint(REMOVE_MID, "%s %s -> %s\n", fcn, devpath, contents);
4578 
4579         if (content_p) {
4580                 *content_p = s_strdup(contents);
4581         }
4582 
4583         /*
4584          * Check to see if this is a link pointing to another link in /dev.  The
4585          * cheap way to do this is to look for a lack of ../devices/.
4586          */
4587 
4588         if (is_minor_node(contents, &ptr) == DEVFSADM_FALSE) {
4589 
4590                 if (type_p) {
4591                         *type_p = DI_SECONDARY_LINK;
4592                 }
4593 
4594                 /*
4595                  * assume that linkcontents is really a pointer to another
4596                  * link, and if so recurse and read its link contents.
4597                  */
4598                 if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0)  {
4599                         (void) strcpy(stage_link, dev_dir);
4600                         (void) strcat(stage_link, "/");
4601                         (void) strcpy(stage_link,
4602                             &contents[strlen(DEV) + strlen("/")]);
4603                 } else {
4604                         if ((ptr = strrchr(devpath, '/')) == NULL) {
4605                                 vprint(REMOVE_MID, "%s%s -> %s invalid link. "
4606                                     "missing '/'\n", fcn, devpath, contents);
4607                                 return (TRUE);
4608                         }
4609                         *ptr = '\0';
4610                         (void) strcpy(stage_link, devpath);
4611                         *ptr = '/';
4612                         (void) strcat(stage_link, "/");
4613                         (void) strcat(stage_link, contents);
4614                 }
4615                 return (resolve_link(stage_link, NULL, NULL, devfs_path,
4616                     dangle));
4617         }
4618 
4619         /* Current link points at a /devices minor node */
4620         if (type_p) {
4621                 *type_p = DI_PRIMARY_LINK;
4622         }
4623 
4624         if (devfs_path)
4625                 *devfs_path = s_strdup(ptr);
4626 
4627         rv = FALSE;
4628         if (dangle)
4629                 rv = (stat(ptr - strlen(DEVICES), &sb) == -1);
4630 
4631         vprint(REMOVE_MID, "%slink=%s, returning %s\n", fcn,
4632             devpath, ((rv == TRUE) ? "TRUE" : "FALSE"));
4633 
4634         return (rv);
4635 }
4636 
4637 /*
4638  * Returns the substring of interest, given a path.
4639  */
4640 static char *
4641 alloc_cmp_str(const char *path, devfsadm_enumerate_t *dep)
4642 {
4643         uint_t match;
4644         char *np, *ap, *mp;
4645         char *cmp_str = NULL;
4646         char at[] = "@";
4647         char *fcn = "alloc_cmp_str";
4648 
4649         np = ap = mp = NULL;
4650 
4651         /*
4652          * extract match flags from the flags argument.
4653          */
4654         match = (dep->flags & MATCH_MASK);
4655 
4656         vprint(ENUM_MID, "%s: enumeration match type: 0x%x"
4657             " path: %s\n", fcn, match, path);
4658 
4659         /*
4660          * MATCH_CALLBACK and MATCH_ALL are the only flags
4661          * which may be used if "path" is a /dev path
4662          */
4663         if (match == MATCH_CALLBACK) {
4664                 if (dep->sel_fcn == NULL) {
4665                         vprint(ENUM_MID, "%s: invalid enumerate"
4666                             " callback: path: %s\n", fcn, path);
4667                         return (NULL);
4668                 }
4669                 cmp_str = dep->sel_fcn(path, dep->cb_arg);
4670                 return (cmp_str);
4671         }
4672 
4673         cmp_str = s_strdup(path);
4674 
4675         if (match == MATCH_ALL) {
4676                 return (cmp_str);
4677         }
4678 
4679         /*
4680          * The remaining flags make sense only for /devices
4681          * paths
4682          */
4683         if ((mp = strrchr(cmp_str, ':')) == NULL) {
4684                 vprint(ENUM_MID, "%s: invalid path: %s\n",
4685                     fcn, path);
4686                 goto err;
4687         }
4688 
4689         if (match == MATCH_MINOR) {
4690                 /* A NULL "match_arg" values implies entire minor */
4691                 if (get_component(mp + 1, dep->match_arg) == NULL) {
4692                         vprint(ENUM_MID, "%s: invalid minor component:"
4693                             " path: %s\n", fcn, path);
4694                         goto err;
4695                 }
4696                 return (cmp_str);
4697         }
4698 
4699         if ((np = strrchr(cmp_str, '/')) == NULL) {
4700                 vprint(ENUM_MID, "%s: invalid path: %s\n", fcn, path);
4701                 goto err;
4702         }
4703 
4704         if (match == MATCH_PARENT) {
4705                 if (strcmp(cmp_str, "/") == 0) {
4706                         vprint(ENUM_MID, "%s: invalid path: %s\n",
4707                             fcn, path);
4708                         goto err;
4709                 }
4710 
4711                 if (np == cmp_str) {
4712                         *(np + 1) = '\0';
4713                 } else {
4714                         *np = '\0';
4715                 }
4716                 return (cmp_str);
4717         }
4718 
4719         /* ap can be NULL - Leaf address may not exist or be empty string */
4720         ap = strchr(np+1, '@');
4721 
4722         /* minor is no longer of interest */
4723         *mp = '\0';
4724 
4725         if (match == MATCH_NODE) {
4726                 if (ap)
4727                         *ap = '\0';
4728                 return (cmp_str);
4729         } else if (match == MATCH_ADDR) {
4730                 /*
4731                  * The empty string is a valid address. The only MATCH_ADDR
4732                  * allowed in this case is against the whole address or
4733                  * the first component of the address (match_arg=NULL/"0"/"1")
4734                  * Note that in this case, the path won't have an "@"
4735                  * As a result ap will be NULL. We fake up an ap = @'\0'
4736                  * so that get_component() will work correctly.
4737                  */
4738                 if (ap == NULL) {
4739                         ap = at;
4740                 }
4741 
4742                 if (get_component(ap + 1, dep->match_arg) == NULL) {
4743                         vprint(ENUM_MID, "%s: invalid leaf addr. component:"
4744                             " path: %s\n", fcn, path);
4745                         goto err;
4746                 }
4747                 return (cmp_str);
4748         }
4749 
4750         vprint(ENUM_MID, "%s: invalid enumeration flags: 0x%x"
4751             " path: %s\n", fcn, dep->flags, path);
4752 
4753         /*FALLTHRU*/
4754 err:
4755         free(cmp_str);
4756         return (NULL);
4757 }
4758 
4759 
4760 /*
4761  * "str" is expected to be a string with components separated by ','
4762  * The terminating null char is considered a separator.
4763  * get_component() will remove the portion of the string beyond
4764  * the component indicated.
4765  * If comp_str is NULL, the entire "str" is returned.
4766  */
4767 static char *
4768 get_component(char *str, const char *comp_str)
4769 {
4770         long comp;
4771         char *cp;
4772 
4773         if (str == NULL) {
4774                 return (NULL);
4775         }
4776 
4777         if (comp_str == NULL) {
4778                 return (str);
4779         }
4780 
4781         errno = 0;
4782         comp = strtol(comp_str, &cp, 10);
4783         if (errno != 0 || *cp != '\0' || comp < 0) {
4784                 return (NULL);
4785         }
4786 
4787         if (comp == 0)
4788                 return (str);
4789 
4790         for (cp = str; ; cp++) {
4791                 if (*cp == ',' || *cp == '\0')
4792                         comp--;
4793                 if (*cp == '\0' || comp <= 0) {
4794                         break;
4795                 }
4796         }
4797 
4798         if (comp == 0) {
4799                 *cp = '\0';
4800         } else {
4801                 str = NULL;
4802         }
4803 
4804         return (str);
4805 }
4806 
4807 
4808 /*
4809  * Enumerate serves as a generic counter as well as a means to determine
4810  * logical unit/controller numbers for such items as disk and tape
4811  * drives.
4812  *
4813  * rules[] is an array of  devfsadm_enumerate_t structures which defines
4814  * the enumeration rules to be used for a specified set of links in /dev.
4815  * The set of links is specified through regular expressions (of the flavor
4816  * described in regex(5)). These regular expressions are used to determine
4817  * the set of links in /dev to examine. The last path component in these
4818  * regular expressions MUST contain a parenthesized subexpression surrounding
4819  * the RE which is to be considered the enumerating component. The subexp
4820  * member in a rule is the subexpression number of the enumerating
4821  * component. Subexpressions in the last path component are numbered starting
4822  * from 1.
4823  *
4824  * A cache of current id assignments is built up from existing symlinks and
4825  * new assignments use the lowest unused id. Assignments are based on a
4826  * match of a specified substring of a symlink's contents. If the specified
4827  * component for the devfs_path argument matches the corresponding substring
4828  * for a existing symlink's contents, the cached id is returned. Else, a new
4829  * id is created and returned in *buf. *buf must be freed by the caller.
4830  *
4831  * An id assignment may be governed by a combination of rules, each rule
4832  * applicable to a different subset of links in /dev. For example, controller
4833  * numbers may be determined by a combination of disk symlinks in /dev/[r]dsk
4834  * and controller symlinks in /dev/cfg, with the two sets requiring different
4835  * rules to derive the "substring of interest". In such cases, the rules
4836  * array will have more than one element.
4837  */
4838 int
4839 devfsadm_enumerate_int(char *devfs_path, int index, char **buf,
4840                         devfsadm_enumerate_t rules[], int nrules)
4841 {
4842         return (find_enum_id(rules, nrules,
4843             devfs_path, index, "0", INTEGER, buf, 0));
4844 }
4845 
4846 int
4847 disk_enumerate_int(char *devfs_path, int index, char **buf,
4848     devfsadm_enumerate_t rules[], int nrules)
4849 {
4850         return (find_enum_id(rules, nrules,
4851             devfs_path, index, "0", INTEGER, buf, 1));
4852 }
4853 
4854 /*
4855  * Same as above, but allows a starting value to be specified.
4856  * Private to devfsadm.... used by devlinks.
4857  */
4858 static int
4859 devfsadm_enumerate_int_start(char *devfs_path, int index, char **buf,
4860                 devfsadm_enumerate_t rules[], int nrules, char *start)
4861 {
4862         return (find_enum_id(rules, nrules,
4863             devfs_path, index, start, INTEGER, buf, 0));
4864 }
4865 
4866 /*
4867  *  devfsadm_enumerate_char serves as a generic counter returning
4868  *  a single letter.
4869  */
4870 int
4871 devfsadm_enumerate_char(char *devfs_path, int index, char **buf,
4872                         devfsadm_enumerate_t rules[], int nrules)
4873 {
4874         return (find_enum_id(rules, nrules,
4875             devfs_path, index, "a", LETTER, buf, 0));
4876 }
4877 
4878 /*
4879  * Same as above, but allows a starting char to be specified.
4880  * Private to devfsadm - used by ports module (port_link.c)
4881  */
4882 int
4883 devfsadm_enumerate_char_start(char *devfs_path, int index, char **buf,
4884         devfsadm_enumerate_t rules[], int nrules, char *start)
4885 {
4886         return (find_enum_id(rules, nrules,
4887             devfs_path, index, start, LETTER, buf, 0));
4888 }
4889 
4890 
4891 /*
4892  * For a given numeral_set (see get_cached_set for desc of numeral_set),
4893  * search all cached entries looking for matches on a specified substring
4894  * of devfs_path. The substring is derived from devfs_path based on the
4895  * rule specified by "index". If a match is found on a cached entry,
4896  * return the enumerated id in buf. Otherwise, create a new id by calling
4897  * new_id, then cache and return that entry.
4898  */
4899 static int
4900 find_enum_id(devfsadm_enumerate_t rules[], int nrules,
4901         char *devfs_path, int index, char *min, int type, char **buf,
4902         int multiple)
4903 {
4904         numeral_t *matchnp;
4905         numeral_t *numeral;
4906         int matchcount = 0;
4907         char *cmp_str;
4908         char *fcn = "find_enum_id";
4909         numeral_set_t *set;
4910 
4911         if (rules == NULL) {
4912                 vprint(ENUM_MID, "%s: no rules. path: %s\n",
4913                     fcn, devfs_path ? devfs_path : "<NULL path>");
4914                 return (DEVFSADM_FAILURE);
4915         }
4916 
4917         if (devfs_path == NULL) {
4918                 vprint(ENUM_MID, "%s: NULL path\n", fcn);
4919                 return (DEVFSADM_FAILURE);
4920         }
4921 
4922         if (nrules <= 0 || index < 0 || index >= nrules || buf == NULL) {
4923                 vprint(ENUM_MID, "%s: invalid arguments. path: %s\n",
4924                     fcn, devfs_path);
4925                 return (DEVFSADM_FAILURE);
4926         }
4927 
4928         *buf = NULL;
4929 
4930 
4931         cmp_str = alloc_cmp_str(devfs_path, &rules[index]);
4932         if (cmp_str == NULL) {
4933                 return (DEVFSADM_FAILURE);
4934         }
4935 
4936         if ((set = get_enum_cache(rules, nrules)) == NULL) {
4937                 free(cmp_str);
4938                 return (DEVFSADM_FAILURE);
4939         }
4940 
4941         assert(nrules == set->re_count);
4942 
4943         /*
4944          * Check and see if a matching entry is already cached.
4945          */
4946         matchcount = lookup_enum_cache(set, cmp_str, rules, index,
4947             &matchnp);
4948 
4949         if (matchcount < 0 || matchcount > 1) {
4950                 free(cmp_str);
4951                 if (multiple && matchcount > 1)
4952                         return (DEVFSADM_MULTIPLE);
4953                 else
4954                         return (DEVFSADM_FAILURE);
4955         }
4956 
4957         /* if matching entry already cached, return it */
4958         if (matchcount == 1) {
4959                 /* should never create a link with a reserved ID */
4960                 vprint(ENUM_MID, "%s: 1 match w/ ID: %s\n", fcn, matchnp->id);
4961                 assert(matchnp->flags == 0);
4962                 *buf = s_strdup(matchnp->id);
4963                 free(cmp_str);
4964                 return (DEVFSADM_SUCCESS);
4965         }
4966 
4967         /*
4968          * no cached entry, initialize a numeral struct
4969          * by calling new_id() and cache onto the numeral_set
4970          */
4971         numeral = s_malloc(sizeof (numeral_t));
4972         numeral->id = new_id(set->headnumeral, type, min);
4973         numeral->full_path = s_strdup(devfs_path);
4974         numeral->rule_index = index;
4975         numeral->cmp_str = cmp_str;
4976         cmp_str = NULL;
4977         numeral->flags = 0;
4978         vprint(RSRV_MID, "%s: alloc new_id: %s numeral flags = %d\n",
4979             fcn, numeral->id, numeral->flags);
4980 
4981 
4982         /* insert to head of list for fast lookups */
4983         numeral->next = set->headnumeral;
4984         set->headnumeral = numeral;
4985 
4986         *buf = s_strdup(numeral->id);
4987         return (DEVFSADM_SUCCESS);
4988 }
4989 
4990 
4991 /*
4992  * Looks up the specified cache for a match with a specified string
4993  * Returns:
4994  *      -1      : on error.
4995  *      0/1/2   : Number of matches.
4996  * Returns the matching element only if there is a single match.
4997  * If the "uncached" flag is set, derives the "cmp_str" afresh
4998  * for the match instead of using cached values.
4999  */
5000 static int
5001 lookup_enum_cache(numeral_set_t *set, char *cmp_str,
5002         devfsadm_enumerate_t rules[], int index, numeral_t **matchnpp)
5003 {
5004         int matchcount = 0, rv = -1;
5005         int uncached;
5006         numeral_t *np;
5007         char *fcn = "lookup_enum_cache";
5008         char *cp;
5009 
5010         *matchnpp = NULL;
5011 
5012         assert(index < set->re_count);
5013 
5014         if (cmp_str == NULL) {
5015                 return (-1);
5016         }
5017 
5018         uncached = 0;
5019         if ((rules[index].flags & MATCH_UNCACHED) == MATCH_UNCACHED) {
5020                 uncached = 1;
5021         }
5022 
5023         /*
5024          * Check and see if a matching entry is already cached.
5025          */
5026         for (np = set->headnumeral; np != NULL; np = np->next) {
5027 
5028                 /*
5029                  * Skip reserved IDs
5030                  */
5031                 if (np->flags & NUMERAL_RESERVED) {
5032                         vprint(RSRV_MID, "lookup_enum_cache: "
5033                             "Cannot Match with reserved ID (%s), "
5034                             "skipping\n", np->id);
5035                         assert(np->flags == NUMERAL_RESERVED);
5036                         continue;
5037                 } else {
5038                         vprint(RSRV_MID, "lookup_enum_cache: "
5039                             "Attempting match with numeral ID: %s"
5040                             " numeral flags = %d\n", np->id, np->flags);
5041                         assert(np->flags == 0);
5042                 }
5043 
5044                 if (np->cmp_str == NULL) {
5045                         vprint(ENUM_MID, "%s: invalid entry in enumerate"
5046                             " cache. path: %s\n", fcn, np->full_path);
5047                         return (-1);
5048                 }
5049 
5050                 if (uncached) {
5051                         vprint(CHATTY_MID, "%s: bypassing enumerate cache."
5052                             " path: %s\n", fcn, cmp_str);
5053                         cp = alloc_cmp_str(np->full_path,
5054                             &rules[np->rule_index]);
5055                         if (cp == NULL)
5056                                 return (-1);
5057                         rv = strcmp(cmp_str, cp);
5058                         free(cp);
5059                 } else {
5060                         rv = strcmp(cmp_str, np->cmp_str);
5061                 }
5062 
5063                 if (rv == 0) {
5064                         if (matchcount++ != 0) {
5065                                 break; /* more than 1 match. */
5066                         }
5067                         *matchnpp = np;
5068                 }
5069         }
5070 
5071         return (matchcount);
5072 }
5073 
5074 #ifdef  DEBUG
5075 static void
5076 dump_enum_cache(numeral_set_t *setp)
5077 {
5078         int i;
5079         numeral_t *np;
5080         char *fcn = "dump_enum_cache";
5081 
5082         vprint(ENUM_MID, "%s: re_count = %d\n", fcn, setp->re_count);
5083         for (i = 0; i < setp->re_count; i++) {
5084                 vprint(ENUM_MID, "%s: re[%d] = %s\n", fcn, i, setp->re[i]);
5085         }
5086 
5087         for (np = setp->headnumeral; np != NULL; np = np->next) {
5088                 vprint(ENUM_MID, "%s: id: %s\n", fcn, np->id);
5089                 vprint(ENUM_MID, "%s: full_path: %s\n", fcn, np->full_path);
5090                 vprint(ENUM_MID, "%s: rule_index: %d\n", fcn, np->rule_index);
5091                 vprint(ENUM_MID, "%s: cmp_str: %s\n", fcn, np->cmp_str);
5092                 vprint(ENUM_MID, "%s: flags: %d\n", fcn, np->flags);
5093         }
5094 }
5095 #endif
5096 
5097 /*
5098  * For a given set of regular expressions in rules[], this function returns
5099  * either a previously cached struct numeral_set or it will create and
5100  * cache a new struct numeral_set.  There is only one struct numeral_set
5101  * for the combination of REs present in rules[].  Each numeral_set contains
5102  * the regular expressions in rules[] used for cache selection AND a linked
5103  * list of struct numerals, ONE FOR EACH *UNIQUE* numeral or character ID
5104  * selected by the grouping parenthesized subexpression found in the last
5105  * path component of each rules[].re.  For example, the RE: "rmt/([0-9]+)"
5106  * selects all the logical nodes of the correct form in dev/rmt/.
5107  * Each rmt/X will store a *single* struct numeral... ie 0, 1, 2 each get a
5108  * single struct numeral. There is no need to store more than a single logical
5109  * node matching X since the information desired in the devfspath would be
5110  * identical for the portion of the devfspath of interest. (the part up to,
5111  * but not including the minor name in this example.)
5112  *
5113  * If the given numeral_set is not yet cached, call enumerate_recurse to
5114  * create it.
5115  */
5116 static numeral_set_t *
5117 get_enum_cache(devfsadm_enumerate_t rules[], int nrules)
5118 {
5119         /* linked list of numeral sets */
5120         numeral_set_t *setp;
5121         int i;
5122         int ret;
5123         char *path_left;
5124         enumerate_file_t *entry;
5125         char *fcn = "get_enum_cache";
5126 
5127         /*
5128          * See if we've already cached this numeral set.
5129          */
5130         for (setp = head_numeral_set; setp != NULL; setp = setp->next) {
5131                 /*
5132                  *  check all regexp's passed in function against
5133                  *  those in cached set.
5134                  */
5135                 if (nrules != setp->re_count) {
5136                         continue;
5137                 }
5138 
5139                 for (i = 0; i < nrules; i++) {
5140                         if (strcmp(setp->re[i], rules[i].re) != 0) {
5141                                 break;
5142                         }
5143                 }
5144 
5145                 if (i == nrules) {
5146                         return (setp);
5147                 }
5148         }
5149 
5150         /*
5151          * If the MATCH_UNCACHED flag is set, we should not  be here.
5152          */
5153         for (i = 0; i < nrules; i++) {
5154                 if ((rules[i].flags & MATCH_UNCACHED) == MATCH_UNCACHED) {
5155                         vprint(ENUM_MID, "%s: invalid enumeration flags: "
5156                             "0x%x\n", fcn, rules[i].flags);
5157                         return (NULL);
5158                 }
5159         }
5160 
5161         /*
5162          *  Since we made it here, we have not yet cached the given set of
5163          *  logical nodes matching the passed re.  Create a cached entry
5164          *  struct numeral_set and populate it with a minimal set of
5165          *  logical nodes from /dev.
5166          */
5167 
5168         setp = s_malloc(sizeof (numeral_set_t));
5169         setp->re = s_malloc(sizeof (char *) * nrules);
5170         for (i = 0; i < nrules; i++) {
5171                 setp->re[i] = s_strdup(rules[i].re);
5172         }
5173         setp->re_count = nrules;
5174         setp->headnumeral = NULL;
5175 
5176         /* put this new cached set on the cached set list */
5177         setp->next = head_numeral_set;
5178         head_numeral_set = setp;
5179 
5180         /*
5181          * For each RE, search the "reserved" list to create numeral IDs that
5182          * are reserved.
5183          */
5184         for (entry = enumerate_reserved; entry; entry = entry->er_next) {
5185 
5186                 vprint(RSRV_MID, "parsing rstring: %s\n", entry->er_file);
5187 
5188                 for (i = 0; i < nrules; i++) {
5189                         path_left = s_strdup(setp->re[i]);
5190                         vprint(RSRV_MID, "parsing rule RE: %s\n", path_left);
5191                         ret = enumerate_parse(entry->er_file, path_left,
5192                             setp, rules, i);
5193                         free(path_left);
5194                         if (ret == 1) {
5195                                 /*
5196                                  * We found the reserved ID for this entry.
5197                                  * We still keep the entry since it is needed
5198                                  * by the new link bypass code in disks
5199                                  */
5200                                 vprint(RSRV_MID, "found rsv ID: rstring: %s "
5201                                     "rule RE: %s\n", entry->er_file, path_left);
5202                                 break;
5203                         }
5204                 }
5205         }
5206 
5207         /*
5208          * For each RE, search disk and cache any matches on the
5209          * numeral list.
5210          */
5211         for (i = 0; i < nrules; i++) {
5212                 path_left = s_strdup(setp->re[i]);
5213                 enumerate_recurse(dev_dir, path_left, setp, rules, i);
5214                 free(path_left);
5215         }
5216 
5217 #ifdef  DEBUG
5218         dump_enum_cache(setp);
5219 #endif
5220 
5221         return (setp);
5222 }
5223 
5224 
5225 /*
5226  * This function stats the pathname namebuf.  If this is a directory
5227  * entry, we recurse down dname/fname until we find the first symbolic
5228  * link, and then stat and return it.  This is valid for the same reason
5229  * that we only need to read a single pathname for multiple matching
5230  * logical ID's... ie, all the logical nodes should contain identical
5231  * physical paths for the parts we are interested.
5232  */
5233 int
5234 get_stat_info(char *namebuf, struct stat *sb)
5235 {
5236         char *cp;
5237         finddevhdl_t fhandle;
5238         const char *fp;
5239 
5240         if (lstat(namebuf, sb) < 0) {
5241                 (void) err_print(LSTAT_FAILED, namebuf, strerror(errno));
5242                 return (DEVFSADM_FAILURE);
5243         }
5244 
5245         if ((sb->st_mode & S_IFMT) == S_IFLNK) {
5246                 return (DEVFSADM_SUCCESS);
5247         }
5248 
5249         /*
5250          * If it is a dir, recurse down until we find a link and
5251          * then use the link.
5252          */
5253         if ((sb->st_mode & S_IFMT) == S_IFDIR) {
5254 
5255                 if (finddev_readdir(namebuf, &fhandle) != 0) {
5256                         return (DEVFSADM_FAILURE);
5257                 }
5258 
5259                 /*
5260                  *  Search each dir entry looking for a symlink.  Return
5261                  *  the first symlink found in namebuf.  Recurse dirs.
5262                  */
5263                 while ((fp = finddev_next(fhandle)) != NULL) {
5264                         cp = namebuf + strlen(namebuf);
5265                         if ((strlcat(namebuf, "/", PATH_MAX) >= PATH_MAX) ||
5266                             (strlcat(namebuf, fp, PATH_MAX) >= PATH_MAX)) {
5267                                 *cp = '\0';
5268                                 finddev_close(fhandle);
5269                                 return (DEVFSADM_FAILURE);
5270                         }
5271                         if (get_stat_info(namebuf, sb) == DEVFSADM_SUCCESS) {
5272                                 finddev_close(fhandle);
5273                                 return (DEVFSADM_SUCCESS);
5274                         }
5275                         *cp = '\0';
5276                 }
5277                 finddev_close(fhandle);
5278         }
5279 
5280         /* no symlink found, so return error */
5281         return (DEVFSADM_FAILURE);
5282 }
5283 
5284 /*
5285  * An existing matching ID was not found, so this function is called to
5286  * create the next lowest ID.  In the INTEGER case, return the next
5287  * lowest unused integer.  In the case of LETTER, return the next lowest
5288  * unused letter.  Return empty string if all 26 are used.
5289  * Only IDs >= min will be returned.
5290  */
5291 char *
5292 new_id(numeral_t *numeral, int type, char *min)
5293 {
5294         int imin;
5295         temp_t *temp;
5296         temp_t *ptr;
5297         temp_t **previous;
5298         temp_t *head = NULL;
5299         char *retval;
5300         static char tempbuff[8];
5301         numeral_t *np;
5302 
5303         if (type == LETTER) {
5304 
5305                 char letter[26], i;
5306 
5307                 if (numeral == NULL) {
5308                         return (s_strdup(min));
5309                 }
5310 
5311                 for (i = 0; i < 26; i++) {
5312                         letter[i] = 0;
5313                 }
5314 
5315                 for (np = numeral; np != NULL; np = np->next) {
5316                         assert(np->flags == 0 ||
5317                             np->flags == NUMERAL_RESERVED);
5318                         letter[*np->id - 'a']++;
5319                 }
5320 
5321                 imin = *min - 'a';
5322 
5323                 for (i = imin; i < 26; i++) {
5324                         if (letter[i] == 0) {
5325                                 retval = s_malloc(2);
5326                                 retval[0] = 'a' + i;
5327                                 retval[1] = '\0';
5328                                 return (retval);
5329                         }
5330                 }
5331 
5332                 return (s_strdup(""));
5333         }
5334 
5335         if (type == INTEGER) {
5336 
5337                 if (numeral == NULL) {
5338                         return (s_strdup(min));
5339                 }
5340 
5341                 imin = atoi(min);
5342 
5343                 /* sort list */
5344                 for (np = numeral; np != NULL; np = np->next) {
5345                         assert(np->flags == 0 ||
5346                             np->flags == NUMERAL_RESERVED);
5347                         temp = s_malloc(sizeof (temp_t));
5348                         temp->integer = atoi(np->id);
5349                         temp->next = NULL;
5350 
5351                         previous = &head;
5352                         for (ptr = head; ptr != NULL; ptr = ptr->next) {
5353                                 if (temp->integer < ptr->integer) {
5354                                         temp->next = ptr;
5355                                         *previous = temp;
5356                                         break;
5357                                 }
5358                                 previous = &(ptr->next);
5359                         }
5360                         if (ptr == NULL) {
5361                                 *previous = temp;
5362                         }
5363                 }
5364 
5365                 /* now search sorted list for first hole >= imin */
5366                 for (ptr = head; ptr != NULL; ptr = ptr->next) {
5367                         if (imin == ptr->integer) {
5368                                 imin++;
5369                         } else {
5370                                 if (imin < ptr->integer) {
5371                                         break;
5372                                 }
5373                         }
5374 
5375                 }
5376 
5377                 /* free temp list */
5378                 for (ptr = head; ptr != NULL; ) {
5379                         temp = ptr;
5380                         ptr = ptr->next;
5381                         free(temp);
5382                 }
5383 
5384                 (void) sprintf(tempbuff, "%d", imin);
5385                 return (s_strdup(tempbuff));
5386         }
5387 
5388         return (s_strdup(""));
5389 }
5390 
5391 static int
5392 enumerate_parse(char *rsvstr, char *path_left, numeral_set_t *setp,
5393             devfsadm_enumerate_t rules[], int index)
5394 {
5395         char    *slash1 = NULL;
5396         char    *slash2 = NULL;
5397         char    *numeral_id;
5398         char    *path_left_save;
5399         char    *rsvstr_save;
5400         int     ret = 0;
5401         static int warned = 0;
5402 
5403         rsvstr_save = rsvstr;
5404         path_left_save = path_left;
5405 
5406         if (rsvstr == NULL || rsvstr[0] == '\0' || rsvstr[0] == '/') {
5407                 if (!warned) {
5408                         err_print("invalid reserved filepath: %s\n",
5409                             rsvstr ? rsvstr : "<NULL>");
5410                         warned = 1;
5411                 }
5412                 return (0);
5413         }
5414 
5415         vprint(RSRV_MID, "processing rule: %s, rstring: %s\n",
5416             path_left, rsvstr);
5417 
5418 
5419         for (;;) {
5420                 /* get rid of any extra '/' in the reserve string */
5421                 while (*rsvstr == '/') {
5422                         rsvstr++;
5423                 }
5424 
5425                 /* get rid of any extra '/' in the RE */
5426                 while (*path_left == '/') {
5427                         path_left++;
5428                 }
5429 
5430                 if (slash1 = strchr(path_left, '/')) {
5431                         *slash1 = '\0';
5432                 }
5433                 if (slash2 = strchr(rsvstr, '/')) {
5434                         *slash2 = '\0';
5435                 }
5436 
5437                 if ((slash1 != NULL) ^ (slash2 != NULL)) {
5438                         ret = 0;
5439                         vprint(RSRV_MID, "mismatch in # of path components\n");
5440                         goto out;
5441                 }
5442 
5443                 /*
5444                  *  Returns true if path_left matches the list entry.
5445                  *  If it is the last path component, pass subexp
5446                  *  so that it will return the corresponding ID in
5447                  *  numeral_id.
5448                  */
5449                 numeral_id = NULL;
5450                 if (match_path_component(path_left, rsvstr, &numeral_id,
5451                     slash1 ? 0 : rules[index].subexp)) {
5452 
5453                         /* We have a match. */
5454                         if (slash1 == NULL) {
5455                                 /* Is last path component */
5456                                 vprint(RSRV_MID, "match and last component\n");
5457                                 create_reserved_numeral(setp, numeral_id);
5458                                 if (numeral_id != NULL) {
5459                                         free(numeral_id);
5460                                 }
5461                                 ret = 1;
5462                                 goto out;
5463                         } else {
5464                                 /* Not last path component. Continue parsing */
5465                                 *slash1 = '/';
5466                                 *slash2 = '/';
5467                                 path_left = slash1 + 1;
5468                                 rsvstr = slash2 + 1;
5469                                 vprint(RSRV_MID,
5470                                     "match and NOT last component\n");
5471                                 continue;
5472                         }
5473                 } else {
5474                         /* No match */
5475                         ret = 0;
5476                         vprint(RSRV_MID, "No match: rule RE = %s, "
5477                             "rstring = %s\n", path_left, rsvstr);
5478                         goto out;
5479                 }
5480         }
5481 
5482 out:
5483         if (slash1)
5484                 *slash1 = '/';
5485         if (slash2)
5486                 *slash2 = '/';
5487 
5488         if (ret == 1) {
5489                 vprint(RSRV_MID, "match: rule RE: %s, rstring: %s\n",
5490                     path_left_save, rsvstr_save);
5491         } else {
5492                 vprint(RSRV_MID, "NO match: rule RE: %s, rstring: %s\n",
5493                     path_left_save, rsvstr_save);
5494         }
5495 
5496         return (ret);
5497 }
5498 
5499 /*
5500  * Search current_dir for all files which match the first path component
5501  * of path_left, which is an RE.  If a match is found, but there are more
5502  * components of path_left, then recurse, otherwise, if we have reached
5503  * the last component of path_left, call create_cached_numerals for each
5504  * file.   At some point, recurse_dev_re() should be rewritten so that this
5505  * function can be eliminated.
5506  */
5507 static void
5508 enumerate_recurse(char *current_dir, char *path_left, numeral_set_t *setp,
5509             devfsadm_enumerate_t rules[], int index)
5510 {
5511         char *slash;
5512         char *new_path;
5513         char *numeral_id;
5514         finddevhdl_t fhandle;
5515         const char *fp;
5516 
5517         if (finddev_readdir(current_dir, &fhandle) != 0) {
5518                 return;
5519         }
5520 
5521         /* get rid of any extra '/' */
5522         while (*path_left == '/') {
5523                 path_left++;
5524         }
5525 
5526         if (slash = strchr(path_left, '/')) {
5527                 *slash = '\0';
5528         }
5529 
5530         while ((fp = finddev_next(fhandle)) != NULL) {
5531 
5532                 /*
5533                  *  Returns true if path_left matches the list entry.
5534                  *  If it is the last path component, pass subexp
5535                  *  so that it will return the corresponding ID in
5536                  *  numeral_id.
5537                  */
5538                 numeral_id = NULL;
5539                 if (match_path_component(path_left, (char *)fp, &numeral_id,
5540                     slash ? 0 : rules[index].subexp)) {
5541 
5542                         new_path = s_malloc(strlen(current_dir) +
5543                             strlen(fp) + 2);
5544 
5545                         (void) strcpy(new_path, current_dir);
5546                         (void) strcat(new_path, "/");
5547                         (void) strcat(new_path, fp);
5548 
5549                         if (slash != NULL) {
5550                                 enumerate_recurse(new_path, slash + 1,
5551                                     setp, rules, index);
5552                         } else {
5553                                 create_cached_numeral(new_path, setp,
5554                                     numeral_id, rules, index);
5555                                 if (numeral_id != NULL) {
5556                                         free(numeral_id);
5557                                 }
5558                         }
5559                         free(new_path);
5560                 }
5561         }
5562 
5563         if (slash != NULL) {
5564                 *slash = '/';
5565         }
5566         finddev_close(fhandle);
5567 }
5568 
5569 
5570 /*
5571  * Returns true if file matches file_re.  If subexp is non-zero, it means
5572  * we are searching the last path component and need to return the
5573  * parenthesized subexpression subexp in id.
5574  *
5575  */
5576 static int
5577 match_path_component(char *file_re,  char *file,  char **id, int subexp)
5578 {
5579         regex_t re1;
5580         int match = 0;
5581         int nelements;
5582         regmatch_t *pmatch;
5583 
5584         if (subexp != 0) {
5585                 nelements = subexp + 1;
5586                 pmatch =
5587                     (regmatch_t *)s_malloc(sizeof (regmatch_t) * nelements);
5588         } else {
5589                 pmatch = NULL;
5590                 nelements = 0;
5591         }
5592 
5593         if (regcomp(&re1, file_re, REG_EXTENDED) != 0) {
5594                 if (pmatch != NULL) {
5595                         free(pmatch);
5596                 }
5597                 return (0);
5598         }
5599 
5600         if (regexec(&re1, file, nelements, pmatch, 0) == 0) {
5601                 match = 1;
5602         }
5603 
5604         if ((match != 0) && (subexp != 0)) {
5605                 int size = pmatch[subexp].rm_eo - pmatch[subexp].rm_so;
5606                 *id = s_malloc(size + 1);
5607                 (void) strncpy(*id, &file[pmatch[subexp].rm_so], size);
5608                 (*id)[size] = '\0';
5609         }
5610 
5611         if (pmatch != NULL) {
5612                 free(pmatch);
5613         }
5614         regfree(&re1);
5615         return (match);
5616 }
5617 
5618 static void
5619 create_reserved_numeral(numeral_set_t *setp, char *numeral_id)
5620 {
5621         numeral_t *np;
5622 
5623         vprint(RSRV_MID, "Attempting to create reserved numeral: %s\n",
5624             numeral_id);
5625 
5626         /*
5627          * We found a numeral_id from an entry in the enumerate_reserved file
5628          * which matched the re passed in from devfsadm_enumerate.  We only
5629          * need to make sure ONE copy of numeral_id exists on the numeral list.
5630          * We only need to store /dev/dsk/cNtod0s0 and no other entries
5631          * hanging off of controller N.
5632          */
5633         for (np = setp->headnumeral; np != NULL; np = np->next) {
5634                 if (strcmp(numeral_id, np->id) == 0) {
5635                         vprint(RSRV_MID, "ID: %s, already reserved\n", np->id);
5636                         assert(np->flags == NUMERAL_RESERVED);
5637                         return;
5638                 } else {
5639                         assert(np->flags == 0 ||
5640                             np->flags == NUMERAL_RESERVED);
5641                 }
5642         }
5643 
5644         /* NOT on list, so add it */
5645         np = s_malloc(sizeof (numeral_t));
5646         np->id = s_strdup(numeral_id);
5647         np->full_path = NULL;
5648         np->rule_index = 0;
5649         np->cmp_str = NULL;
5650         np->flags = NUMERAL_RESERVED;
5651         np->next = setp->headnumeral;
5652         setp->headnumeral = np;
5653 
5654         vprint(RSRV_MID, "Reserved numeral ID: %s\n", np->id);
5655 }
5656 
5657 /*
5658  * This function is called for every file which matched the leaf
5659  * component of the RE.  If the "numeral_id" is not already on the
5660  * numeral set's numeral list, add it and its physical path.
5661  */
5662 static void
5663 create_cached_numeral(char *path, numeral_set_t *setp, char *numeral_id,
5664         devfsadm_enumerate_t rules[], int index)
5665 {
5666         char linkbuf[PATH_MAX + 1];
5667         char lpath[PATH_MAX + 1];
5668         char *linkptr, *cmp_str;
5669         numeral_t *np;
5670         int linksize;
5671         struct stat sb;
5672         char *contents;
5673         const char *fcn = "create_cached_numeral";
5674 
5675         assert(index >= 0 && index < setp->re_count);
5676         assert(strcmp(rules[index].re, setp->re[index]) == 0);
5677 
5678         /*
5679          *  We found a numeral_id from an entry in /dev which matched
5680          *  the re passed in from devfsadm_enumerate.  We only need to make sure
5681          *  ONE copy of numeral_id exists on the numeral list.  We only need
5682          *  to store /dev/dsk/cNtod0s0 and no other entries hanging off
5683          *  of controller N.
5684          */
5685         for (np = setp->headnumeral; np != NULL; np = np->next) {
5686                 assert(np->flags == 0 || np->flags == NUMERAL_RESERVED);
5687                 if (strcmp(numeral_id, np->id) == 0) {
5688                         /*
5689                          * Note that we can't assert that the flags field
5690                          * of the numeral is 0, since both reserved and
5691                          * unreserved links in /dev come here
5692                          */
5693                         if (np->flags == NUMERAL_RESERVED) {
5694                                 vprint(RSRV_MID, "ID derived from /dev link is"
5695                                     " reserved: %s\n", np->id);
5696                         } else {
5697                                 vprint(RSRV_MID, "ID derived from /dev link is"
5698                                     " NOT reserved: %s\n", np->id);
5699                         }
5700                         return;
5701                 }
5702         }
5703 
5704         /* NOT on list, so add it */
5705 
5706         (void) strcpy(lpath, path);
5707         /*
5708          * If path is a dir, it is changed to the first symbolic link it find
5709          * if it finds one.
5710          */
5711         if (get_stat_info(lpath, &sb) == DEVFSADM_FAILURE) {
5712                 return;
5713         }
5714 
5715         /* If we get here, we found a symlink */
5716         linksize = readlink(lpath, linkbuf, PATH_MAX);
5717 
5718         if (linksize <= 0) {
5719                 err_print(READLINK_FAILED, fcn, lpath, strerror(errno));
5720                 return;
5721         }
5722 
5723         linkbuf[linksize] = '\0';
5724 
5725         /*
5726          * redirect alias path to current path
5727          * devi_root_node is protected by lock_dev()
5728          */
5729         contents = di_alias2curr(devi_root_node, linkbuf);
5730 
5731         /*
5732          * the following just points linkptr to the root of the /devices
5733          * node if it is a minor node, otherwise, to the first char of
5734          * linkbuf if it is a link.
5735          */
5736         (void) is_minor_node(contents, &linkptr);
5737 
5738         cmp_str = alloc_cmp_str(linkptr, &rules[index]);
5739         if (cmp_str == NULL) {
5740                 free(contents);
5741                 return;
5742         }
5743 
5744         np = s_malloc(sizeof (numeral_t));
5745 
5746         np->id = s_strdup(numeral_id);
5747         np->full_path = s_strdup(linkptr);
5748         np->rule_index = index;
5749         np->cmp_str = cmp_str;
5750         np->flags = 0;
5751 
5752         np->next = setp->headnumeral;
5753         setp->headnumeral = np;
5754 
5755         free(contents);
5756 }
5757 
5758 
5759 /*
5760  * This should be called either before or after granting access to a
5761  * command line version of devfsadm running, since it may have changed
5762  * the state of /dev.  It forces future enumerate calls to re-build
5763  * cached information from /dev.
5764  */
5765 void
5766 invalidate_enumerate_cache(void)
5767 {
5768         numeral_set_t *setp;
5769         numeral_set_t *savedsetp;
5770         numeral_t *savednumset;
5771         numeral_t *numset;
5772         int i;
5773 
5774         for (setp = head_numeral_set; setp != NULL; ) {
5775                 /*
5776                  *  check all regexp's passed in function against
5777                  *  those in cached set.
5778                  */
5779 
5780                 savedsetp = setp;
5781                 setp = setp->next;
5782 
5783                 for (i = 0; i < savedsetp->re_count; i++) {
5784                         free(savedsetp->re[i]);
5785                 }
5786                 free(savedsetp->re);
5787 
5788                 for (numset = savedsetp->headnumeral; numset != NULL; ) {
5789                         savednumset = numset;
5790                         numset = numset->next;
5791                         assert(savednumset->rule_index < savedsetp->re_count);
5792                         free(savednumset->id);
5793                         free(savednumset->full_path);
5794                         free(savednumset->cmp_str);
5795                         free(savednumset);
5796                 }
5797                 free(savedsetp);
5798         }
5799         head_numeral_set = NULL;
5800 }
5801 
5802 /*
5803  * Copies over links from /dev to <root>/dev and device special files in
5804  * /devices to <root>/devices, preserving the existing file modes.  If
5805  * the link or special file already exists on <root>, skip the copy.  (it
5806  * would exist only if a package hard coded it there, so assume package
5807  * knows best?).  Use /etc/name_to_major and <root>/etc/name_to_major to
5808  * make translations for major numbers on device special files. No need to
5809  * make a translation on minor_perm since if the file was created in the
5810  * miniroot then it would presumably have the same minor_perm entry in
5811  *  <root>/etc/minor_perm.  To be used only by install.
5812  */
5813 int
5814 devfsadm_copy(void)
5815 {
5816         char filename[PATH_MAX + 1];
5817 
5818         /* load the installed root's name_to_major for translations */
5819         (void) snprintf(filename, sizeof (filename), "%s%s", root_dir,
5820             NAME_TO_MAJOR);
5821         if (load_n2m_table(filename) == DEVFSADM_FAILURE) {
5822                 return (DEVFSADM_FAILURE);
5823         }
5824 
5825         /* Copy /dev to target disk. No need to copy /devices with devfs */
5826         (void) nftw(DEV, devfsadm_copy_file, 20, FTW_PHYS);
5827 
5828         /* Let install handle copying over path_to_inst */
5829 
5830         return (DEVFSADM_SUCCESS);
5831 }
5832 
5833 /*
5834  * This function copies links, dirs, and device special files.
5835  * Note that it always returns DEVFSADM_SUCCESS, so that nftw doesn't
5836  * abort.
5837  */
5838 /*ARGSUSED*/
5839 static int
5840 devfsadm_copy_file(const char *file, const struct stat *stat,
5841                     int flags, struct FTW *ftw)
5842 {
5843         struct stat sp;
5844         dev_t newdev;
5845         char newfile[PATH_MAX + 1];
5846         char linkcontents[PATH_MAX + 1];
5847         int bytes;
5848         const char *fcn = "devfsadm_copy_file";
5849 
5850         (void) strcpy(newfile, root_dir);
5851         (void) strcat(newfile, "/");
5852         (void) strcat(newfile, file);
5853 
5854         if (lstat(newfile, &sp) == 0) {
5855                 /* newfile already exists, so no need to continue */
5856                 return (DEVFSADM_SUCCESS);
5857         }
5858 
5859         if (((stat->st_mode & S_IFMT) == S_IFBLK) ||
5860             ((stat->st_mode & S_IFMT) == S_IFCHR)) {
5861                 if (translate_major(stat->st_rdev, &newdev) ==
5862                     DEVFSADM_FAILURE) {
5863                         return (DEVFSADM_SUCCESS);
5864                 }
5865                 if (mknod(newfile, stat->st_mode, newdev) == -1) {
5866                         err_print(MKNOD_FAILED, newfile, strerror(errno));
5867                         return (DEVFSADM_SUCCESS);
5868                 }
5869         } else if ((stat->st_mode & S_IFMT) == S_IFDIR) {
5870                 if (mknod(newfile, stat->st_mode, 0) == -1) {
5871                         err_print(MKNOD_FAILED, newfile, strerror(errno));
5872                         return (DEVFSADM_SUCCESS);
5873                 }
5874         } else if ((stat->st_mode & S_IFMT) == S_IFLNK)  {
5875                 /*
5876                  * No need to redirect alias paths. We want a
5877                  * true copy. The system on first boot after install
5878                  * will redirect paths
5879                  */
5880                 if ((bytes = readlink(file, linkcontents, PATH_MAX)) == -1)  {
5881                         err_print(READLINK_FAILED, fcn, file, strerror(errno));
5882                         return (DEVFSADM_SUCCESS);
5883                 }
5884                 linkcontents[bytes] = '\0';
5885                 if (symlink(linkcontents, newfile) == -1) {
5886                         err_print(SYMLINK_FAILED, newfile, newfile,
5887                             strerror(errno));
5888                         return (DEVFSADM_SUCCESS);
5889                 }
5890         }
5891 
5892         (void) lchown(newfile, stat->st_uid, stat->st_gid);
5893         return (DEVFSADM_SUCCESS);
5894 }
5895 
5896 /*
5897  *  Given a dev_t from the running kernel, return the new_dev_t
5898  *  by translating to the major number found on the installed
5899  *  target's root name_to_major file.
5900  */
5901 static int
5902 translate_major(dev_t old_dev, dev_t *new_dev)
5903 {
5904         major_t oldmajor;
5905         major_t newmajor;
5906         minor_t oldminor;
5907         minor_t newminor;
5908         char cdriver[FILENAME_MAX + 1];
5909         char driver[FILENAME_MAX + 1];
5910         char *fcn = "translate_major: ";
5911 
5912         oldmajor = major(old_dev);
5913         if (modctl(MODGETNAME, driver, sizeof (driver), &oldmajor) != 0) {
5914                 return (DEVFSADM_FAILURE);
5915         }
5916 
5917         if (strcmp(driver, "clone") != 0) {
5918                 /* non-clone case */
5919 
5920                 /* look up major number is target's name2major */
5921                 if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) {
5922                         return (DEVFSADM_FAILURE);
5923                 }
5924 
5925                 *new_dev = makedev(newmajor, minor(old_dev));
5926                 if (old_dev != *new_dev) {
5927                         vprint(CHATTY_MID, "%sdriver: %s old: %lu,%lu "
5928                             "new: %lu,%lu\n", fcn, driver, major(old_dev),
5929                             minor(old_dev), major(*new_dev), minor(*new_dev));
5930                 }
5931                 return (DEVFSADM_SUCCESS);
5932         } else {
5933                 /*
5934                  *  The clone is a special case.  Look at its minor
5935                  *  number since it is the major number of the real driver.
5936                  */
5937                 if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) {
5938                         return (DEVFSADM_FAILURE);
5939                 }
5940 
5941                 oldminor = minor(old_dev);
5942                 if (modctl(MODGETNAME, cdriver, sizeof (cdriver),
5943                     &oldminor) != 0) {
5944                         err_print(MODGETNAME_FAILED, oldminor);
5945                         return (DEVFSADM_FAILURE);
5946                 }
5947 
5948                 if (get_major_no(cdriver, &newminor) == DEVFSADM_FAILURE) {
5949                         return (DEVFSADM_FAILURE);
5950                 }
5951 
5952                 *new_dev = makedev(newmajor, newminor);
5953                 if (old_dev != *new_dev) {
5954                         vprint(CHATTY_MID, "%sdriver: %s old: "
5955                             "%lu,%lu  new: %lu,%lu\n", fcn, driver,
5956                             major(old_dev), minor(old_dev),
5957                             major(*new_dev), minor(*new_dev));
5958                 }
5959                 return (DEVFSADM_SUCCESS);
5960         }
5961 }
5962 
5963 /*
5964  *
5965  * Find the major number for driver, searching the n2m_list that was
5966  * built in load_n2m_table().
5967  */
5968 static int
5969 get_major_no(char *driver, major_t *major)
5970 {
5971         n2m_t *ptr;
5972 
5973         for (ptr = n2m_list; ptr != NULL; ptr = ptr->next) {
5974                 if (strcmp(ptr->driver, driver) == 0) {
5975                         *major = ptr->major;
5976                         return (DEVFSADM_SUCCESS);
5977                 }
5978         }
5979         err_print(FIND_MAJOR_FAILED, driver);
5980         return (DEVFSADM_FAILURE);
5981 }
5982 
5983 /*
5984  * Loads a name_to_major table into memory.  Used only for suninstall's
5985  * private -R option to devfsadm, to translate major numbers from the
5986  * running to the installed target disk.
5987  */
5988 static int
5989 load_n2m_table(char *file)
5990 {
5991         FILE *fp;
5992         char line[1024], *cp;
5993         char driver[PATH_MAX + 1];
5994         major_t major;
5995         n2m_t *ptr;
5996         int ln = 0;
5997 
5998         if ((fp = fopen(file, "r")) == NULL) {
5999                 err_print(FOPEN_FAILED, file, strerror(errno));
6000                 return (DEVFSADM_FAILURE);
6001         }
6002 
6003         while (fgets(line, sizeof (line), fp) != NULL) {
6004                 ln++;
6005                 /* cut off comments starting with '#' */
6006                 if ((cp = strchr(line, '#')) != NULL)
6007                         *cp = '\0';
6008                 /* ignore comment or blank lines */
6009                 if (is_blank(line))
6010                         continue;
6011                 /* sanity-check */
6012                 if (sscanf(line, "%1024s%lu", driver, &major) != 2) {
6013                         err_print(IGNORING_LINE_IN, ln, file);
6014                         continue;
6015                 }
6016                 ptr = (n2m_t *)s_malloc(sizeof (n2m_t));
6017                 ptr->major = major;
6018                 ptr->driver = s_strdup(driver);
6019                 ptr->next = n2m_list;
6020                 n2m_list = ptr;
6021         }
6022         if (fclose(fp) == EOF) {
6023                 err_print(FCLOSE_FAILED, file, strerror(errno));
6024         }
6025         return (DEVFSADM_SUCCESS);
6026 }
6027 
6028 /*
6029  * Called at devfsadm startup to read the file /etc/dev/enumerate_reserved
6030  * Creates a linked list of devlinks from which reserved IDs can be derived
6031  */
6032 static void
6033 read_enumerate_file(void)
6034 {
6035         FILE *fp;
6036         int linenum;
6037         char line[PATH_MAX+1];
6038         enumerate_file_t *entry;
6039         struct stat current_sb;
6040         static struct stat cached_sb;
6041         static int cached = FALSE;
6042 
6043         assert(enumerate_file);
6044 
6045         if (stat(enumerate_file, &current_sb) == -1) {
6046                 vprint(RSRV_MID, "No reserved file: %s\n", enumerate_file);
6047                 cached = FALSE;
6048                 if (enumerate_reserved != NULL) {
6049                         vprint(RSRV_MID, "invalidating %s cache\n",
6050                             enumerate_file);
6051                 }
6052                 while (enumerate_reserved != NULL) {
6053                         entry = enumerate_reserved;
6054                         enumerate_reserved = entry->er_next;
6055                         free(entry->er_file);
6056                         free(entry->er_id);
6057                         free(entry);
6058                 }
6059                 return;
6060         }
6061 
6062         /* if already cached, check to see if it is still valid */
6063         if (cached == TRUE) {
6064 
6065                 if (current_sb.st_mtime == cached_sb.st_mtime) {
6066                         vprint(RSRV_MID, "%s cache valid\n", enumerate_file);
6067                         vprint(FILES_MID, "%s cache valid\n", enumerate_file);
6068                         return;
6069                 }
6070 
6071                 vprint(RSRV_MID, "invalidating %s cache\n", enumerate_file);
6072                 vprint(FILES_MID, "invalidating %s cache\n", enumerate_file);
6073 
6074                 while (enumerate_reserved != NULL) {
6075                         entry = enumerate_reserved;
6076                         enumerate_reserved = entry->er_next;
6077                         free(entry->er_file);
6078                         free(entry->er_id);
6079                         free(entry);
6080                 }
6081                 vprint(RSRV_MID, "Recaching file: %s\n", enumerate_file);
6082         } else {
6083                 vprint(RSRV_MID, "Caching file (first time): %s\n",
6084                     enumerate_file);
6085                 cached = TRUE;
6086         }
6087 
6088         (void) stat(enumerate_file, &cached_sb);
6089 
6090         if ((fp = fopen(enumerate_file, "r")) == NULL) {
6091                 err_print(FOPEN_FAILED, enumerate_file, strerror(errno));
6092                 return;
6093         }
6094 
6095         vprint(RSRV_MID, "Reading reserve file: %s\n", enumerate_file);
6096         linenum = 0;
6097         while (fgets(line, sizeof (line), fp) != NULL) {
6098                 char    *cp, *ncp;
6099 
6100                 linenum++;
6101 
6102                 /* remove newline */
6103                 cp = strchr(line, '\n');
6104                 if (cp)
6105                         *cp = '\0';
6106 
6107                 vprint(RSRV_MID, "Reserve file: line %d: %s\n", linenum, line);
6108 
6109                 /* skip over space and tab */
6110                 for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
6111                         ;
6112 
6113                 if (*cp == '\0' || *cp == '#') {
6114                         vprint(RSRV_MID, "Skipping line: '%s'\n", line);
6115                         continue; /* blank line or comment line */
6116                 }
6117 
6118                 ncp = cp;
6119 
6120                 /* delete trailing blanks */
6121                 for (; *cp != ' ' && *cp != '\t' && *cp != '\0'; cp++)
6122                         ;
6123                 *cp = '\0';
6124 
6125                 entry = s_zalloc(sizeof (enumerate_file_t));
6126                 entry->er_file = s_strdup(ncp);
6127                 entry->er_id = NULL;
6128                 entry->er_next = enumerate_reserved;
6129                 enumerate_reserved = entry;
6130         }
6131 
6132         if (fclose(fp) == EOF) {
6133                 err_print(FCLOSE_FAILED, enumerate_file, strerror(errno));
6134         }
6135 }
6136 
6137 /*
6138  * Called at devfsadm startup to read in the devlink.tab file.  Creates
6139  * a linked list of devlinktab_list structures which will be
6140  * searched for every minor node.
6141  */
6142 static void
6143 read_devlinktab_file(void)
6144 {
6145         devlinktab_list_t *headp = NULL;
6146         devlinktab_list_t *entryp;
6147         devlinktab_list_t **previous;
6148         devlinktab_list_t *save;
6149         char line[MAX_DEVLINK_LINE], *cp;
6150         char *selector;
6151         char *p_link;
6152         char *s_link;
6153         FILE *fp;
6154         int i;
6155         static struct stat cached_sb;
6156         struct stat current_sb;
6157         static int cached = FALSE;
6158 
6159         if (devlinktab_file == NULL) {
6160                 return;
6161         }
6162 
6163         (void) stat(devlinktab_file, &current_sb);
6164 
6165         /* if already cached, check to see if it is still valid */
6166         if (cached == TRUE) {
6167 
6168                 if (current_sb.st_mtime == cached_sb.st_mtime) {
6169                         vprint(FILES_MID, "%s cache valid\n", devlinktab_file);
6170                         return;
6171                 }
6172 
6173                 vprint(FILES_MID, "invalidating %s cache\n", devlinktab_file);
6174 
6175                 while (devlinktab_list != NULL) {
6176                         free_link_list(devlinktab_list->p_link);
6177                         free_link_list(devlinktab_list->s_link);
6178                         free_selector_list(devlinktab_list->selector);
6179                         free(devlinktab_list->selector_pattern);
6180                         free(devlinktab_list->p_link_pattern);
6181                         if (devlinktab_list->s_link_pattern != NULL) {
6182                                 free(devlinktab_list->s_link_pattern);
6183                         }
6184                         save = devlinktab_list;
6185                         devlinktab_list = devlinktab_list->next;
6186                         free(save);
6187                 }
6188         } else {
6189                 cached = TRUE;
6190         }
6191 
6192         (void) stat(devlinktab_file, &cached_sb);
6193 
6194         if ((fp = fopen(devlinktab_file, "r")) == NULL) {
6195                 err_print(FOPEN_FAILED, devlinktab_file, strerror(errno));
6196                 return;
6197         }
6198 
6199         previous = &headp;
6200 
6201         while (fgets(line, sizeof (line), fp) != NULL) {
6202                 devlinktab_line++;
6203                 i = strlen(line);
6204                 if (line[i-1] == NEWLINE) {
6205                         line[i-1] = '\0';
6206                 } else if (i == sizeof (line-1)) {
6207                         err_print(LINE_TOO_LONG, devlinktab_line,
6208                             devlinktab_file, sizeof (line)-1);
6209                         while (((i = getc(fp)) != '\n') && (i != EOF))
6210                                 ;
6211                         continue;
6212                 }
6213 
6214                 /* cut off comments starting with '#' */
6215                 if ((cp = strchr(line, '#')) != NULL)
6216                         *cp = '\0';
6217                 /* ignore comment or blank lines */
6218                 if (is_blank(line))
6219                         continue;
6220 
6221                 vprint(DEVLINK_MID, "table: %s line %d: '%s'\n",
6222                     devlinktab_file, devlinktab_line, line);
6223 
6224                 /* break each entry into fields.  s_link may be NULL */
6225                 if (split_devlinktab_entry(line, &selector, &p_link,
6226                     &s_link) == DEVFSADM_FAILURE) {
6227                         vprint(DEVLINK_MID, "split_entry returns failure\n");
6228                         continue;
6229                 } else {
6230                         vprint(DEVLINK_MID, "split_entry selector='%s' "
6231                             "p_link='%s' s_link='%s'\n\n", selector,
6232                             p_link, (s_link == NULL) ? "" : s_link);
6233                 }
6234 
6235                 entryp =
6236                     (devlinktab_list_t *)s_malloc(sizeof (devlinktab_list_t));
6237 
6238                 entryp->line_number = devlinktab_line;
6239 
6240                 if ((entryp->selector = create_selector_list(selector))
6241                     == NULL) {
6242                         free(entryp);
6243                         continue;
6244                 }
6245                 entryp->selector_pattern = s_strdup(selector);
6246 
6247                 if ((entryp->p_link = create_link_list(p_link)) == NULL) {
6248                         free_selector_list(entryp->selector);
6249                         free(entryp->selector_pattern);
6250                         free(entryp);
6251                         continue;
6252                 }
6253 
6254                 entryp->p_link_pattern = s_strdup(p_link);
6255 
6256                 if (s_link != NULL) {
6257                         if ((entryp->s_link =
6258                             create_link_list(s_link)) == NULL) {
6259                                 free_selector_list(entryp->selector);
6260                                 free_link_list(entryp->p_link);
6261                                 free(entryp->selector_pattern);
6262                                 free(entryp->p_link_pattern);
6263                                 free(entryp);
6264                                 continue;
6265                         }
6266                         entryp->s_link_pattern = s_strdup(s_link);
6267                 } else {
6268                         entryp->s_link = NULL;
6269                         entryp->s_link_pattern = NULL;
6270 
6271                 }
6272 
6273                 /* append to end of list */
6274 
6275                 entryp->next = NULL;
6276                 *previous = entryp;
6277                 previous = &(entryp->next);
6278         }
6279         if (fclose(fp) == EOF) {
6280                 err_print(FCLOSE_FAILED, devlinktab_file, strerror(errno));
6281         }
6282         devlinktab_list = headp;
6283 }
6284 
6285 /*
6286  *
6287  * For a single line entry in devlink.tab, split the line into fields
6288  * selector, p_link, and an optionally s_link.  If s_link field is not
6289  * present, then return NULL in s_link (not NULL string).
6290  */
6291 static int
6292 split_devlinktab_entry(char *entry, char **selector, char **p_link,
6293                         char **s_link)
6294 {
6295         char *tab;
6296 
6297         *selector = entry;
6298 
6299         if ((tab = strchr(entry, TAB)) != NULL) {
6300                 *tab = '\0';
6301                 *p_link = ++tab;
6302         } else {
6303                 err_print(MISSING_TAB, devlinktab_line, devlinktab_file);
6304                 return (DEVFSADM_FAILURE);
6305         }
6306 
6307         if (*p_link == '\0') {
6308                 err_print(MISSING_DEVNAME, devlinktab_line, devlinktab_file);
6309                 return (DEVFSADM_FAILURE);
6310         }
6311 
6312         if ((tab = strchr(*p_link, TAB)) != NULL) {
6313                 *tab = '\0';
6314                 *s_link = ++tab;
6315                 if (strchr(*s_link, TAB) != NULL) {
6316                         err_print(TOO_MANY_FIELDS, devlinktab_line,
6317                             devlinktab_file);
6318                         return (DEVFSADM_FAILURE);
6319                 }
6320         } else {
6321                 *s_link = NULL;
6322         }
6323 
6324         return (DEVFSADM_SUCCESS);
6325 }
6326 
6327 /*
6328  * For a given devfs_spec field, for each element in the field, add it to
6329  * a linked list of devfs_spec structures.  Return the linked list in
6330  * devfs_spec_list.
6331  */
6332 static selector_list_t *
6333 create_selector_list(char *selector)
6334 {
6335         char *key;
6336         char *val;
6337         int error = FALSE;
6338         selector_list_t *head_selector_list = NULL;
6339         selector_list_t *selector_list;
6340 
6341         /* parse_devfs_spec splits the next field into keyword & value */
6342         while ((*selector != NULL) && (error == FALSE)) {
6343                 if (parse_selector(&selector, &key, &val) == DEVFSADM_FAILURE) {
6344                         error = TRUE;
6345                         break;
6346                 } else {
6347                         selector_list = (selector_list_t *)
6348                             s_malloc(sizeof (selector_list_t));
6349                         if (strcmp(NAME_S, key) == 0) {
6350                                 selector_list->key = NAME;
6351                         } else if (strcmp(TYPE_S, key) == 0) {
6352                                 selector_list->key = TYPE;
6353                         } else if (strncmp(ADDR_S, key, ADDR_S_LEN) == 0) {
6354                                 selector_list->key = ADDR;
6355                                 if (key[ADDR_S_LEN] == '\0') {
6356                                         selector_list->arg = 0;
6357                                 } else if (isdigit(key[ADDR_S_LEN]) != FALSE) {
6358                                         selector_list->arg =
6359                                             atoi(&key[ADDR_S_LEN]);
6360                                 } else {
6361                                         error = TRUE;
6362                                         free(selector_list);
6363                                         err_print(BADKEYWORD, key,
6364                                             devlinktab_line, devlinktab_file);
6365                                         break;
6366                                 }
6367                         } else if (strncmp(MINOR_S, key, MINOR_S_LEN) == 0) {
6368                                 selector_list->key = MINOR;
6369                                 if (key[MINOR_S_LEN] == '\0') {
6370                                         selector_list->arg = 0;
6371                                 } else if (isdigit(key[MINOR_S_LEN]) != FALSE) {
6372                                         selector_list->arg =
6373                                             atoi(&key[MINOR_S_LEN]);
6374                                 } else {
6375                                         error = TRUE;
6376                                         free(selector_list);
6377                                         err_print(BADKEYWORD, key,
6378                                             devlinktab_line, devlinktab_file);
6379                                         break;
6380                                 }
6381                                 vprint(DEVLINK_MID, "MINOR = %s\n", val);
6382                         } else {
6383                                 err_print(UNRECOGNIZED_KEY, key,
6384                                     devlinktab_line, devlinktab_file);
6385                                 error = TRUE;
6386                                 free(selector_list);
6387                                 break;
6388                         }
6389                         selector_list->val = s_strdup(val);
6390                         selector_list->next = head_selector_list;
6391                         head_selector_list = selector_list;
6392                         vprint(DEVLINK_MID, "key='%s' val='%s' arg=%d\n",
6393                             key, val, selector_list->arg);
6394                 }
6395         }
6396 
6397         if ((error == FALSE) && (head_selector_list != NULL)) {
6398                 return (head_selector_list);
6399         } else {
6400                 /* parse failed.  Free any allocated structs */
6401                 free_selector_list(head_selector_list);
6402                 return (NULL);
6403         }
6404 }
6405 
6406 /*
6407  * Takes a semicolon separated list of selector elements and breaks up
6408  * into a keyword-value pair.   semicolon and equal characters are
6409  * replaced with NULL's.  On success, selector is updated to point to the
6410  * terminating NULL character terminating the keyword-value pair, and the
6411  * function returns DEVFSADM_SUCCESS.   If there is a syntax error,
6412  * devfs_spec is not modified and function returns DEVFSADM_FAILURE.
6413  */
6414 static int
6415 parse_selector(char **selector, char **key, char **val)
6416 {
6417         char *equal;
6418         char *semi_colon;
6419 
6420         *key = *selector;
6421 
6422         if ((equal = strchr(*key, '=')) != NULL) {
6423                 *equal = '\0';
6424         } else {
6425                 err_print(MISSING_EQUAL, devlinktab_line, devlinktab_file);
6426                 return (DEVFSADM_FAILURE);
6427         }
6428 
6429         *val = ++equal;
6430         if ((semi_colon = strchr(equal, ';')) != NULL) {
6431                 *semi_colon = '\0';
6432                 *selector = semi_colon + 1;
6433         } else {
6434                 *selector = equal + strlen(equal);
6435         }
6436         return (DEVFSADM_SUCCESS);
6437 }
6438 
6439 /*
6440  * link is either the second or third field of devlink.tab.  Parse link
6441  * into a linked list of devlink structures and return ptr to list.  Each
6442  * list element is either a constant string, or one of the following
6443  * escape sequences: \M, \A, \N, or \D.  The first three escape sequences
6444  * take a numerical argument.
6445  */
6446 static link_list_t *
6447 create_link_list(char *link)
6448 {
6449         int x = 0;
6450         int error = FALSE;
6451         int counter_found = FALSE;
6452         link_list_t *head = NULL;
6453         link_list_t **ptr;
6454         link_list_t *link_list;
6455         char constant[MAX_DEVLINK_LINE];
6456         char *error_str;
6457 
6458         if (link == NULL) {
6459                 return (NULL);
6460         }
6461 
6462         while ((*link != '\0') && (error == FALSE)) {
6463                 link_list = (link_list_t *)s_malloc(sizeof (link_list_t));
6464                 link_list->next = NULL;
6465 
6466                 while ((*link != '\0') && (*link != '\\')) {
6467                         /* a non-escaped string */
6468                         constant[x++] = *(link++);
6469                 }
6470                 if (x != 0) {
6471                         constant[x] = '\0';
6472                         link_list->type = CONSTANT;
6473                         link_list->constant = s_strdup(constant);
6474                         x = 0;
6475                         vprint(DEVLINK_MID, "CONSTANT FOUND %s\n", constant);
6476                 } else {
6477                         switch (*(++link)) {
6478                         case 'M':
6479                                 link_list->type = MINOR;
6480                                 break;
6481                         case 'A':
6482                                 link_list->type = ADDR;
6483                                 break;
6484                         case 'N':
6485                                 if (counter_found == TRUE) {
6486                                         error = TRUE;
6487                                         error_str =
6488                                             "multiple counters not permitted";
6489                                         free(link_list);
6490                                 } else {
6491                                         counter_found = TRUE;
6492                                         link_list->type = COUNTER;
6493                                 }
6494                                 break;
6495                         case 'D':
6496                                 link_list->type = NAME;
6497                                 break;
6498                         default:
6499                                 error = TRUE;
6500                                 free(link_list);
6501                                 error_str = "unrecognized escape sequence";
6502                                 break;
6503                         }
6504                         if (*(link++) != 'D') {
6505                                 if (isdigit(*link) == FALSE) {
6506                                         error_str = "escape sequence must be "
6507                                             "followed by a digit\n";
6508                                         error = TRUE;
6509                                         free(link_list);
6510                                 } else {
6511                                         link_list->arg =
6512                                             (int)strtoul(link, &link, 10);
6513                                         vprint(DEVLINK_MID, "link_list->arg = "
6514                                             "%d\n", link_list->arg);
6515                                 }
6516                         }
6517                 }
6518                 /* append link_list struct to end of list */
6519                 if (error == FALSE) {
6520                         for (ptr = &head; *ptr != NULL; ptr = &((*ptr)->next))
6521                                 ;
6522                         *ptr = link_list;
6523                 }
6524         }
6525 
6526         if (error == FALSE) {
6527                 return (head);
6528         } else {
6529                 err_print(CONFIG_INCORRECT, devlinktab_line, devlinktab_file,
6530                     error_str);
6531                 free_link_list(head);
6532                 return (NULL);
6533         }
6534 }
6535 
6536 /*
6537  * Called for each minor node devfsadm processes; for each minor node,
6538  * look for matches in the devlinktab_list list which was created on
6539  * startup read_devlinktab_file().  If there is a match, call build_links()
6540  * to build a logical devlink and a possible extra devlink.
6541  */
6542 static int
6543 process_devlink_compat(di_minor_t minor, di_node_t node)
6544 {
6545         int link_built = FALSE;
6546         devlinktab_list_t *entry;
6547         char *nodetype;
6548         char *dev_path;
6549 
6550         if (devlinks_debug == TRUE) {
6551                 nodetype =  di_minor_nodetype(minor);
6552                 assert(nodetype != NULL);
6553                 if ((dev_path = di_devfs_path(node)) != NULL) {
6554                         vprint(INFO_MID, "'%s' entry: %s:%s\n",
6555                             nodetype, dev_path,
6556                             di_minor_name(minor) ? di_minor_name(minor) : "");
6557                         di_devfs_path_free(dev_path);
6558                 }
6559 
6560         }
6561 
6562 
6563         /* don't process devlink.tab if devfsadm invoked with -c <class> */
6564         if (num_classes > 0) {
6565                 return (FALSE);
6566         }
6567 
6568         for (entry = devlinktab_list; entry != NULL; entry = entry->next) {
6569                 if (devlink_matches(entry, minor, node) == DEVFSADM_SUCCESS) {
6570                         link_built = TRUE;
6571                         (void) build_links(entry, minor, node);
6572                 }
6573         }
6574         return (link_built);
6575 }
6576 
6577 /*
6578  * For a given devlink.tab devlinktab_list entry, see if the selector
6579  * field matches this minor node.  If it does, return DEVFSADM_SUCCESS,
6580  * otherwise DEVFSADM_FAILURE.
6581  */
6582 static int
6583 devlink_matches(devlinktab_list_t *entry, di_minor_t minor, di_node_t node)
6584 {
6585         selector_list_t *selector = entry->selector;
6586         char *addr;
6587         char *minor_name;
6588         char *node_type;
6589 
6590         for (; selector != NULL; selector = selector->next) {
6591                 switch (selector->key) {
6592                 case NAME:
6593                         if (strcmp(di_node_name(node), selector->val) != 0) {
6594                                 return (DEVFSADM_FAILURE);
6595                         }
6596                         break;
6597                 case TYPE:
6598                         node_type = di_minor_nodetype(minor);
6599                         assert(node_type != NULL);
6600                         if (strcmp(node_type, selector->val) != 0) {
6601                                 return (DEVFSADM_FAILURE);
6602                         }
6603                         break;
6604                 case ADDR:
6605                         if ((addr = di_bus_addr(node)) == NULL) {
6606                                 return (DEVFSADM_FAILURE);
6607                         }
6608                         if (selector->arg == 0) {
6609                                 if (strcmp(addr, selector->val) != 0) {
6610                                         return (DEVFSADM_FAILURE);
6611                                 }
6612                         } else {
6613                                 if (compare_field(addr, selector->val,
6614                                     selector->arg) == DEVFSADM_FAILURE) {
6615                                         return (DEVFSADM_FAILURE);
6616                                 }
6617                         }
6618                         break;
6619                 case MINOR:
6620                         if ((minor_name = di_minor_name(minor)) == NULL) {
6621                                 return (DEVFSADM_FAILURE);
6622                         }
6623                         if (selector->arg == 0) {
6624                                 if (strcmp(minor_name, selector->val) != 0) {
6625                                         return (DEVFSADM_FAILURE);
6626                                 }
6627                         } else {
6628                                 if (compare_field(minor_name, selector->val,
6629                                     selector->arg) == DEVFSADM_FAILURE) {
6630                                         return (DEVFSADM_FAILURE);
6631                                 }
6632                         }
6633                         break;
6634                 default:
6635                         return (DEVFSADM_FAILURE);
6636                 }
6637         }
6638 
6639         return (DEVFSADM_SUCCESS);
6640 }
6641 
6642 /*
6643  * For the given minor node and devlinktab_list entry from devlink.tab,
6644  * build a logical dev link and a possible extra devlink.
6645  * Return DEVFSADM_SUCCESS if link is created, otherwise DEVFSADM_FAILURE.
6646  */
6647 static int
6648 build_links(devlinktab_list_t *entry, di_minor_t minor, di_node_t node)
6649 {
6650         char secondary_link[PATH_MAX + 1];
6651         char primary_link[PATH_MAX + 1];
6652         char contents[PATH_MAX + 1];
6653         char *dev_path;
6654 
6655         if ((dev_path = di_devfs_path(node)) == NULL) {
6656                 err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
6657                 devfsadm_exit(1);
6658                 /*NOTREACHED*/
6659         }
6660         (void) strcpy(contents, dev_path);
6661         di_devfs_path_free(dev_path);
6662 
6663         (void) strcat(contents, ":");
6664         (void) strcat(contents, di_minor_name(minor));
6665 
6666         if (construct_devlink(primary_link, entry->p_link, contents,
6667             minor, node, entry->p_link_pattern) == DEVFSADM_FAILURE) {
6668                 return (DEVFSADM_FAILURE);
6669         }
6670         (void) devfsadm_mklink(primary_link, node, minor, 0);
6671 
6672         if (entry->s_link == NULL) {
6673                 return (DEVFSADM_SUCCESS);
6674         }
6675 
6676         if (construct_devlink(secondary_link, entry->s_link, primary_link,
6677             minor, node, entry->s_link_pattern) == DEVFSADM_FAILURE) {
6678                 return (DEVFSADM_FAILURE);
6679         }
6680 
6681         (void) devfsadm_secondary_link(secondary_link, primary_link, 0);
6682 
6683         return (DEVFSADM_SUCCESS);
6684 }
6685 
6686 /*
6687  * The counter rule for devlink.tab entries is implemented via
6688  * devfsadm_enumerate_int_start(). One of the arguments to this function
6689  * is a path, where each path component is treated as a regular expression.
6690  * For devlink.tab entries, this path regular expression is derived from
6691  * the devlink spec. get_anchored_re() accepts path regular expressions derived
6692  * from devlink.tab entries and inserts the anchors '^' and '$' at the beginning
6693  * and end respectively of each path component. This is done to prevent
6694  * false matches. For example, without anchors, "a/([0-9]+)" will match "ab/c9"
6695  * and incorrect links will be generated.
6696  */
6697 static int
6698 get_anchored_re(char *link, char *anchored_re, char *pattern)
6699 {
6700         if (*link == '/' || *link == '\0') {
6701                 err_print(INVALID_DEVLINK_SPEC, pattern);
6702                 return (DEVFSADM_FAILURE);
6703         }
6704 
6705         *anchored_re++ = '^';
6706         for (; *link != '\0'; ) {
6707                 if (*link == '/') {
6708                         while (*link == '/')
6709                                 link++;
6710                         *anchored_re++ = '$';
6711                         *anchored_re++ = '/';
6712                         if (*link != '\0') {
6713                                 *anchored_re++ = '^';
6714                         }
6715                 } else {
6716                         *anchored_re++ = *link++;
6717                         if (*link == '\0') {
6718                                 *anchored_re++ = '$';
6719                         }
6720                 }
6721         }
6722         *anchored_re = '\0';
6723 
6724         return (DEVFSADM_SUCCESS);
6725 }
6726 
6727 static int
6728 construct_devlink(char *link, link_list_t *link_build, char *contents,
6729                         di_minor_t minor, di_node_t node, char *pattern)
6730 {
6731         int counter_offset = -1;
6732         devfsadm_enumerate_t rules[1] = {NULL};
6733         char templink[PATH_MAX + 1];
6734         char *buff;
6735         char start[10];
6736         char *node_path;
6737         char anchored_re[PATH_MAX + 1];
6738 
6739         link[0] = '\0';
6740 
6741         for (; link_build != NULL; link_build = link_build->next) {
6742                 switch (link_build->type) {
6743                 case NAME:
6744                         (void) strcat(link, di_node_name(node));
6745                         break;
6746                 case CONSTANT:
6747                         (void) strcat(link, link_build->constant);
6748                         break;
6749                 case ADDR:
6750                         if (component_cat(link, di_bus_addr(node),
6751                             link_build->arg) == DEVFSADM_FAILURE) {
6752                                 node_path = di_devfs_path(node);
6753                                 err_print(CANNOT_BE_USED, pattern, node_path,
6754                                     di_minor_name(minor));
6755                                 di_devfs_path_free(node_path);
6756                                 return (DEVFSADM_FAILURE);
6757                         }
6758                         break;
6759                 case MINOR:
6760                         if (component_cat(link, di_minor_name(minor),
6761                             link_build->arg) == DEVFSADM_FAILURE) {
6762                                 node_path = di_devfs_path(node);
6763                                 err_print(CANNOT_BE_USED, pattern, node_path,
6764                                     di_minor_name(minor));
6765                                 di_devfs_path_free(node_path);
6766                                 return (DEVFSADM_FAILURE);
6767                         }
6768                         break;
6769                 case COUNTER:
6770                         counter_offset = strlen(link);
6771                         (void) strcat(link, "([0-9]+)");
6772                         (void) sprintf(start, "%d", link_build->arg);
6773                         break;
6774                 default:
6775                         return (DEVFSADM_FAILURE);
6776                 }
6777         }
6778 
6779         if (counter_offset != -1) {
6780                 /*
6781                  * copy anything appended after "([0-9]+)" into
6782                  * templink
6783                  */
6784 
6785                 (void) strcpy(templink,
6786                     &link[counter_offset + strlen("([0-9]+)")]);
6787                 if (get_anchored_re(link, anchored_re, pattern)
6788                     != DEVFSADM_SUCCESS) {
6789                         return (DEVFSADM_FAILURE);
6790                 }
6791                 rules[0].re = anchored_re;
6792                 rules[0].subexp = 1;
6793                 rules[0].flags = MATCH_ALL;
6794                 if (devfsadm_enumerate_int_start(contents, 0, &buff,
6795                     rules, 1, start) == DEVFSADM_FAILURE) {
6796                         return (DEVFSADM_FAILURE);
6797                 }
6798                 (void) strcpy(&link[counter_offset], buff);
6799                 free(buff);
6800                 (void) strcat(link, templink);
6801                 vprint(DEVLINK_MID, "COUNTER is %s\n", link);
6802         }
6803         return (DEVFSADM_SUCCESS);
6804 }
6805 
6806 /*
6807  * Compares "field" number of the comma separated list "full_name" with
6808  * field_item.  Returns DEVFSADM_SUCCESS for match,
6809  * DEVFSADM_FAILURE for no match.
6810  */
6811 static int
6812 compare_field(char *full_name, char *field_item, int field)
6813 {
6814         --field;
6815         while ((*full_name != '\0') && (field != 0)) {
6816                 if (*(full_name++) == ',') {
6817                         field--;
6818                 }
6819         }
6820 
6821         if (field != 0) {
6822                 return (DEVFSADM_FAILURE);
6823         }
6824 
6825         while ((*full_name != '\0') && (*field_item != '\0') &&
6826             (*full_name != ',')) {
6827                 if (*(full_name++) != *(field_item++)) {
6828                         return (DEVFSADM_FAILURE);
6829                 }
6830         }
6831 
6832         if (*field_item != '\0') {
6833                 return (DEVFSADM_FAILURE);
6834         }
6835 
6836         if ((*full_name == '\0') || (*full_name == ','))
6837                 return (DEVFSADM_SUCCESS);
6838 
6839         return (DEVFSADM_FAILURE);
6840 }
6841 
6842 /*
6843  * strcat() field # "field" of comma separated list "name" to "link".
6844  * Field 0 is the entire name.
6845  * Return DEVFSADM_SUCCESS or DEVFSADM_FAILURE.
6846  */
6847 static int
6848 component_cat(char *link, char *name, int field)
6849 {
6850 
6851         if (name == NULL) {
6852                 return (DEVFSADM_FAILURE);
6853         }
6854 
6855         if (field == 0) {
6856                 (void) strcat(link, name);
6857                 return (DEVFSADM_SUCCESS);
6858         }
6859 
6860         while (*link != '\0') {
6861                 link++;
6862         }
6863 
6864         --field;
6865         while ((*name != '\0') && (field != 0)) {
6866                 if (*(name++) == ',') {
6867                         --field;
6868                 }
6869         }
6870 
6871         if (field != 0) {
6872                 return (DEVFSADM_FAILURE);
6873         }
6874 
6875         while ((*name != '\0') && (*name != ',')) {
6876                 *(link++) = *(name++);
6877         }
6878 
6879         *link = '\0';
6880         return (DEVFSADM_SUCCESS);
6881 }
6882 
6883 static void
6884 free_selector_list(selector_list_t *head)
6885 {
6886         selector_list_t *temp;
6887 
6888         while (head != NULL) {
6889                 temp = head;
6890                 head = head->next;
6891                 free(temp->val);
6892                 free(temp);
6893         }
6894 }
6895 
6896 static void
6897 free_link_list(link_list_t *head)
6898 {
6899         link_list_t *temp;
6900 
6901         while (head != NULL) {
6902                 temp = head;
6903                 head = head->next;
6904                 if (temp->type == CONSTANT) {
6905                         free(temp->constant);
6906                 }
6907                 free(temp);
6908         }
6909 }
6910 
6911 /*
6912  * Prints only if level matches one of the debug levels
6913  * given on command line.  INFO_MID is always printed.
6914  *
6915  * See devfsadm.h for a listing of globally defined levels and
6916  * meanings.  Modules should prefix the level with their
6917  * module name to prevent collisions.
6918  */
6919 /*PRINTFLIKE2*/
6920 void
6921 devfsadm_print(char *msgid, char *message, ...)
6922 {
6923         va_list ap;
6924         static int newline = TRUE;
6925         int x;
6926 
6927         if (msgid != NULL) {
6928                 for (x = 0; x < num_verbose; x++) {
6929                         if (strcmp(verbose[x], msgid) == 0) {
6930                                 break;
6931                         }
6932                         if (strcmp(verbose[x], ALL_MID) == 0) {
6933                                 break;
6934                         }
6935                 }
6936                 if (x == num_verbose) {
6937                         return;
6938                 }
6939         }
6940 
6941         va_start(ap, message);
6942 
6943         if (msgid == NULL) {
6944                 if (logflag == TRUE) {
6945                         (void) vsyslog(LOG_NOTICE, message, ap);
6946                 } else {
6947                         (void) vfprintf(stdout, message, ap);
6948                 }
6949 
6950         } else {
6951                 if (logflag == TRUE) {
6952                         (void) syslog(LOG_DEBUG, "%s[%ld]: %s: ",
6953                             prog, getpid(), msgid);
6954                         (void) vsyslog(LOG_DEBUG, message, ap);
6955                 } else {
6956                         if (newline == TRUE) {
6957                                 (void) fprintf(stdout, "%s[%ld]: %s: ",
6958                                     prog, getpid(), msgid);
6959                         }
6960                         (void) vfprintf(stdout, message, ap);
6961                 }
6962         }
6963 
6964         if (message[strlen(message) - 1] == '\n') {
6965                 newline = TRUE;
6966         } else {
6967                 newline = FALSE;
6968         }
6969         va_end(ap);
6970 }
6971 
6972 /*
6973  * print error messages to the terminal or to syslog
6974  */
6975 /*PRINTFLIKE1*/
6976 void
6977 devfsadm_errprint(char *message, ...)
6978 {
6979         va_list ap;
6980 
6981         va_start(ap, message);
6982 
6983         if (logflag == TRUE) {
6984                 (void) vsyslog(LOG_ERR, message, ap);
6985         } else {
6986                 (void) fprintf(stderr, "%s: ", prog);
6987                 (void) vfprintf(stderr, message, ap);
6988         }
6989         va_end(ap);
6990 }
6991 
6992 /*
6993  * return noupdate state (-s)
6994  */
6995 int
6996 devfsadm_noupdate(void)
6997 {
6998         return (file_mods == TRUE ? DEVFSADM_TRUE : DEVFSADM_FALSE);
6999 }
7000 
7001 /*
7002  * return current root update path (-r)
7003  */
7004 const char *
7005 devfsadm_root_path(void)
7006 {
7007         if (root_dir[0] == '\0') {
7008                 return ("/");
7009         } else {
7010                 return ((const char *)root_dir);
7011         }
7012 }
7013 
7014 void
7015 devfsadm_free_dev_names(char **dev_names, int len)
7016 {
7017         int i;
7018 
7019         for (i = 0; i < len; i++)
7020                 free(dev_names[i]);
7021         free(dev_names);
7022 }
7023 
7024 /*
7025  * Return all devlinks corresponding to phys_path as an array of strings.
7026  * The number of entries in the array is returned through lenp.
7027  * devfsadm_free_dev_names() is used to free the returned array.
7028  * NULL is returned on failure or when there are no matching devlinks.
7029  *
7030  * re is an extended regular expression in regex(5) format used to further
7031  * match devlinks pointing to phys_path; it may be NULL to match all
7032  */
7033 char **
7034 devfsadm_lookup_dev_names(char *phys_path, char *re, int *lenp)
7035 {
7036         struct devlink_cb_arg cb_arg;
7037         char **dev_names = NULL;
7038         int i;
7039 
7040         *lenp = 0;
7041         cb_arg.count = 0;
7042         cb_arg.rv = 0;
7043         (void) di_devlink_cache_walk(devlink_cache, re, phys_path,
7044             DI_PRIMARY_LINK, &cb_arg, devlink_cb);
7045 
7046         if (cb_arg.rv == -1 || cb_arg.count <= 0)
7047                 return (NULL);
7048 
7049         dev_names = s_malloc(cb_arg.count * sizeof (char *));
7050         if (dev_names == NULL)
7051                 goto out;
7052 
7053         for (i = 0; i < cb_arg.count; i++) {
7054                 dev_names[i] = s_strdup(cb_arg.dev_names[i]);
7055                 if (dev_names[i] == NULL) {
7056                         devfsadm_free_dev_names(dev_names, i);
7057                         dev_names = NULL;
7058                         goto out;
7059                 }
7060         }
7061         *lenp = cb_arg.count;
7062 
7063 out:
7064         free_dev_names(&cb_arg);
7065         return (dev_names);
7066 }
7067 
7068 /* common exit function which ensures releasing locks */
7069 static void
7070 devfsadm_exit(int status)
7071 {
7072         if (DEVFSADM_DEBUG_ON) {
7073                 vprint(INFO_MID, "exit status = %d\n", status);
7074         }
7075 
7076         exit_dev_lock(1);
7077         exit_daemon_lock(1);
7078 
7079         if (logflag == TRUE) {
7080                 closelog();
7081         }
7082 
7083         exit(status);
7084         /*NOTREACHED*/
7085 }
7086 
7087 /*
7088  * set root_dir, devices_dir, dev_dir using optarg.
7089  */
7090 static void
7091 set_root_devices_dev_dir(char *dir)
7092 {
7093         size_t len;
7094 
7095         root_dir = s_strdup(dir);
7096         len = strlen(dir) + strlen(DEVICES) + 1;
7097         devices_dir = s_malloc(len);
7098         (void) snprintf(devices_dir, len, "%s%s", root_dir, DEVICES);
7099         len = strlen(root_dir) + strlen(DEV) + 1;
7100         dev_dir = s_malloc(len);
7101         (void) snprintf(dev_dir, len, "%s%s", root_dir, DEV);
7102 }
7103 
7104 /*
7105  * Removes quotes.
7106  */
7107 static char *
7108 dequote(char *src)
7109 {
7110         char    *dst;
7111         int     len;
7112 
7113         len = strlen(src);
7114         dst = s_malloc(len + 1);
7115         if (src[0] == '\"' && src[len - 1] == '\"') {
7116                 len -= 2;
7117                 (void) strncpy(dst, &src[1], len);
7118                 dst[len] = '\0';
7119         } else {
7120                 (void) strcpy(dst, src);
7121         }
7122         return (dst);
7123 }
7124 
7125 /*
7126  * For a given physical device pathname and spectype, return the
7127  * ownership and permissions attributes by looking in data from
7128  * /etc/minor_perm.  If currently in installation mode, check for
7129  * possible major number translations from the miniroot to the installed
7130  * root's name_to_major table. Note that there can be multiple matches,
7131  * but the last match takes effect.  pts seems to rely on this
7132  * implementation behavior.
7133  */
7134 static void
7135 getattr(char *phy_path, char *aminor, int spectype, dev_t dev, mode_t *mode,
7136         uid_t *uid, gid_t *gid)
7137 {
7138         char devname[PATH_MAX + 1];
7139         char *node_name;
7140         char *minor_name;
7141         int match = FALSE;
7142         int is_clone;
7143         int mp_drvname_matches_node_name;
7144         int mp_drvname_matches_minor_name;
7145         int mp_drvname_is_clone;
7146         int mp_drvname_matches_drvname;
7147         struct mperm *mp;
7148         major_t major_no;
7149         char driver[PATH_MAX + 1];
7150 
7151         /*
7152          * Get the driver name based on the major number since the name
7153          * in /devices may be generic.  Could be running with more major
7154          * numbers than are in /etc/name_to_major, so get it from the kernel
7155          */
7156         major_no = major(dev);
7157 
7158         if (modctl(MODGETNAME, driver, sizeof (driver), &major_no) != 0) {
7159                 /* return default values */
7160                 goto use_defaults;
7161         }
7162 
7163         (void) strcpy(devname, phy_path);
7164 
7165         node_name = strrchr(devname, '/'); /* node name is the last */
7166                                         /* component */
7167         if (node_name == NULL) {
7168                 err_print(NO_NODE, devname);
7169                 goto use_defaults;
7170         }
7171 
7172         minor_name = strchr(++node_name, '@'); /* see if it has address part */
7173 
7174         if (minor_name != NULL) {
7175                 *minor_name++ = '\0';
7176         } else {
7177                 minor_name = node_name;
7178         }
7179 
7180         minor_name = strchr(minor_name, ':'); /* look for minor name */
7181 
7182         if (minor_name == NULL) {
7183                 err_print(NO_MINOR, devname);
7184                 goto use_defaults;
7185         }
7186         *minor_name++ = '\0';
7187 
7188         /*
7189          * mp->mp_drvname = device name from minor_perm
7190          * mp->mp_minorname = minor part of device name from
7191          * minor_perm
7192          * drvname = name of driver for this device
7193          */
7194 
7195         is_clone = (strcmp(node_name, "clone") == 0 ? TRUE : FALSE);
7196         for (mp = minor_perms; mp != NULL; mp = mp->mp_next) {
7197                 mp_drvname_matches_node_name =
7198                     (strcmp(mp->mp_drvname, node_name) == 0 ? TRUE : FALSE);
7199                 mp_drvname_matches_minor_name =
7200                     (strcmp(mp->mp_drvname, minor_name) == 0  ? TRUE:FALSE);
7201                 mp_drvname_is_clone =
7202                     (strcmp(mp->mp_drvname, "clone") == 0  ? TRUE : FALSE);
7203                 mp_drvname_matches_drvname =
7204                     (strcmp(mp->mp_drvname, driver) == 0  ? TRUE : FALSE);
7205 
7206                 /*
7207                  * If one of the following cases is true, then we try to change
7208                  * the permissions if a "shell global pattern match" of
7209                  * mp_>mp_minorname matches minor_name.
7210                  *
7211                  * 1.  mp->mp_drvname matches driver.
7212                  *
7213                  * OR
7214                  *
7215                  * 2.  mp->mp_drvname matches node_name and this
7216                  *      name is an alias of the driver name
7217                  *
7218                  * OR
7219                  *
7220                  * 3.  /devices entry is the clone device and either
7221                  *      minor_perm entry is the clone device or matches
7222                  *      the minor part of the clone device.
7223                  */
7224 
7225                 if ((mp_drvname_matches_drvname == TRUE)||
7226                     ((mp_drvname_matches_node_name == TRUE) &&
7227                     (alias(driver, node_name) == TRUE)) ||
7228                     ((is_clone == TRUE) &&
7229                     ((mp_drvname_is_clone == TRUE) ||
7230                     (mp_drvname_matches_minor_name == TRUE)))) {
7231                         /*
7232                          * Check that the minor part of the
7233                          * device name from the minor_perm
7234                          * entry matches and if so, set the
7235                          * permissions.
7236                          *
7237                          * Under real devfs, clone minor name is changed
7238                          * to match the driver name, but minor_perm may
7239                          * not match. We reconcile it here.
7240                          */
7241                         if (aminor != NULL)
7242                                 minor_name = aminor;
7243 
7244                         if (gmatch(minor_name, mp->mp_minorname) != 0) {
7245                                 *uid = mp->mp_uid;
7246                                 *gid = mp->mp_gid;
7247                                 *mode = spectype | mp->mp_mode;
7248                                 match = TRUE;
7249                         }
7250                 }
7251         }
7252 
7253         if (match == TRUE) {
7254                 return;
7255         }
7256 
7257         use_defaults:
7258         /* not found in minor_perm, so just use default values */
7259         *uid = root_uid;
7260         *gid = sys_gid;
7261         *mode = (spectype | 0600);
7262 }
7263 
7264 /*
7265  * Called by devfs_read_minor_perm() to report errors
7266  * key is:
7267  *      line number: ignoring line number error
7268  *      errno: open/close errors
7269  *      size: alloc errors
7270  */
7271 static void
7272 minorperm_err_cb(minorperm_err_t mp_err, int key)
7273 {
7274         switch (mp_err) {
7275         case MP_FOPEN_ERR:
7276                 err_print(FOPEN_FAILED, MINOR_PERM_FILE, strerror(key));
7277                 break;
7278         case MP_FCLOSE_ERR:
7279                 err_print(FCLOSE_FAILED, MINOR_PERM_FILE, strerror(key));
7280                 break;
7281         case MP_IGNORING_LINE_ERR:
7282                 err_print(IGNORING_LINE_IN, key, MINOR_PERM_FILE);
7283                 break;
7284         case MP_ALLOC_ERR:
7285                 err_print(MALLOC_FAILED, key);
7286                 break;
7287         case MP_NVLIST_ERR:
7288                 err_print(NVLIST_ERROR, MINOR_PERM_FILE, strerror(key));
7289                 break;
7290         case MP_CANT_FIND_USER_ERR:
7291                 err_print(CANT_FIND_USER, DEFAULT_DEV_USER);
7292                 break;
7293         case MP_CANT_FIND_GROUP_ERR:
7294                 err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP);
7295                 break;
7296         }
7297 }
7298 
7299 static void
7300 read_minor_perm_file(void)
7301 {
7302         static int cached = FALSE;
7303         static struct stat cached_sb;
7304         struct stat current_sb;
7305 
7306         (void) stat(MINOR_PERM_FILE, &current_sb);
7307 
7308         /* If already cached, check to see if it is still valid */
7309         if (cached == TRUE) {
7310 
7311                 if (current_sb.st_mtime == cached_sb.st_mtime) {
7312                         vprint(FILES_MID, "%s cache valid\n", MINOR_PERM_FILE);
7313                         return;
7314                 }
7315                 devfs_free_minor_perm(minor_perms);
7316                 minor_perms = NULL;
7317         } else {
7318                 cached = TRUE;
7319         }
7320 
7321         (void) stat(MINOR_PERM_FILE, &cached_sb);
7322 
7323         vprint(FILES_MID, "loading binding file: %s\n", MINOR_PERM_FILE);
7324 
7325         minor_perms = devfs_read_minor_perm(minorperm_err_cb);
7326 }
7327 
7328 static void
7329 load_minor_perm_file(void)
7330 {
7331         read_minor_perm_file();
7332         if (devfs_load_minor_perm(minor_perms, minorperm_err_cb) != 0)
7333                 err_print(gettext("minor_perm load failed\n"));
7334 }
7335 
7336 static char *
7337 convert_to_re(char *dev)
7338 {
7339         char *p, *l, *out;
7340         int i;
7341 
7342         out = s_malloc(PATH_MAX);
7343 
7344         for (l = p = dev, i = 0; (*p != '\0') && (i < (PATH_MAX - 1));
7345             ++p, i++) {
7346                 if ((*p == '*') && ((l != p) && (*l == '/'))) {
7347                         out[i++] = '.';
7348                         out[i] = '+';
7349                 } else {
7350                         out[i] = *p;
7351                 }
7352                 l = p;
7353         }
7354         out[i] = '\0';
7355         p = (char *)s_malloc(strlen(out) + 1);
7356         (void) strlcpy(p, out, strlen(out) + 1);
7357         free(out);
7358 
7359         vprint(FILES_MID, "converted %s -> %s\n", dev, p);
7360 
7361         return (p);
7362 }
7363 
7364 static void
7365 read_logindevperm_file(void)
7366 {
7367         static int cached = FALSE;
7368         static struct stat cached_sb;
7369         struct stat current_sb;
7370         struct login_dev *ldev;
7371         FILE *fp;
7372         char line[MAX_LDEV_LINE];
7373         int ln, perm, rv;
7374         char *cp, *console, *dlist, *dev;
7375         char *lasts, *devlasts, *permstr, *drv;
7376         struct driver_list *list, *next;
7377 
7378         /* Read logindevperm only when enabled */
7379         if (login_dev_enable != TRUE)
7380                 return;
7381 
7382         if (cached == TRUE) {
7383                 if (stat(LDEV_FILE, &current_sb) == 0 &&
7384                     current_sb.st_mtime == cached_sb.st_mtime) {
7385                         vprint(FILES_MID, "%s cache valid\n", LDEV_FILE);
7386                         return;
7387                 }
7388                 vprint(FILES_MID, "invalidating %s cache\n", LDEV_FILE);
7389                 while (login_dev_cache != NULL) {
7390 
7391                         ldev = login_dev_cache;
7392                         login_dev_cache = ldev->ldev_next;
7393                         free(ldev->ldev_console);
7394                         free(ldev->ldev_device);
7395                         regfree(&ldev->ldev_device_regex);
7396                         list = ldev->ldev_driver_list;
7397                         while (list) {
7398                                 next = list->next;
7399                                 free(list);
7400                                 list = next;
7401                         }
7402                         free(ldev);
7403                 }
7404         } else {
7405                 cached = TRUE;
7406         }
7407 
7408         assert(login_dev_cache == NULL);
7409 
7410         if (stat(LDEV_FILE, &cached_sb) != 0) {
7411                 cached = FALSE;
7412                 return;
7413         }
7414 
7415         vprint(FILES_MID, "loading file: %s\n", LDEV_FILE);
7416 
7417         if ((fp = fopen(LDEV_FILE, "r")) == NULL) {
7418                 /* Not fatal to devfsadm */
7419                 cached = FALSE;
7420                 err_print(FOPEN_FAILED, LDEV_FILE, strerror(errno));
7421                 return;
7422         }
7423 
7424         ln = 0;
7425         while (fgets(line, MAX_LDEV_LINE, fp) != NULL) {
7426                 ln++;
7427 
7428                 /* Remove comments */
7429                 if ((cp = strchr(line, '#')) != NULL)
7430                         *cp = '\0';
7431 
7432                 if ((console = strtok_r(line, LDEV_DELIMS, &lasts)) == NULL)
7433                         continue;       /* Blank line */
7434 
7435                 if ((permstr =  strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) {
7436                         err_print(IGNORING_LINE_IN, ln, LDEV_FILE);
7437                         continue;       /* Malformed line */
7438                 }
7439 
7440                 /*
7441                  * permstr is string in octal format. Convert to int
7442                  */
7443                 cp = NULL;
7444                 errno = 0;
7445                 perm = strtol(permstr, &cp, 8);
7446                 if (errno || perm < 0 || perm > 0777 || *cp != '\0') {
7447                         err_print(IGNORING_LINE_IN, ln, LDEV_FILE);
7448                         continue;
7449                 }
7450 
7451                 if ((dlist = strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) {
7452                         err_print(IGNORING_LINE_IN, ln, LDEV_FILE);
7453                         continue;
7454                 }
7455 
7456                 dev = strtok_r(dlist, LDEV_DEV_DELIM, &devlasts);
7457                 while (dev) {
7458 
7459                         ldev = (struct login_dev *)s_zalloc(
7460                             sizeof (struct login_dev));
7461                         ldev->ldev_console = s_strdup(console);
7462                         ldev->ldev_perms = perm;
7463 
7464                         /*
7465                          * the logical device name may contain '*' which
7466                          * we convert to a regular expression
7467                          */
7468                         ldev->ldev_device = convert_to_re(dev);
7469                         if (ldev->ldev_device &&
7470                             (rv = regcomp(&ldev->ldev_device_regex,
7471                             ldev->ldev_device, REG_EXTENDED))) {
7472                                 bzero(&ldev->ldev_device_regex,
7473                                     sizeof (ldev->ldev_device_regex));
7474                                 err_print(REGCOMP_FAILED,
7475                                     ldev->ldev_device, rv);
7476                         }
7477                         ldev->ldev_next = login_dev_cache;
7478                         login_dev_cache = ldev;
7479                         dev = strtok_r(NULL, LDEV_DEV_DELIM, &devlasts);
7480                 }
7481 
7482                 drv = strtok_r(NULL, LDEV_DRVLIST_DELIMS, &lasts);
7483                 if (drv) {
7484                         if (strcmp(drv, LDEV_DRVLIST_NAME) == 0) {
7485 
7486                                 drv = strtok_r(NULL, LDEV_DRV_DELIMS, &lasts);
7487 
7488                                 while (drv) {
7489                                         vprint(FILES_MID,
7490                                             "logindevperm driver=%s\n", drv);
7491 
7492                                         /*
7493                                          * create a linked list of driver
7494                                          * names
7495                                          */
7496                                         list = (struct driver_list *)
7497                                             s_zalloc(
7498                                             sizeof (struct driver_list));
7499                                         (void) strlcpy(list->driver_name, drv,
7500                                             sizeof (list->driver_name));
7501                                         list->next = ldev->ldev_driver_list;
7502                                         ldev->ldev_driver_list = list;
7503                                         drv = strtok_r(NULL, LDEV_DRV_DELIMS,
7504                                             &lasts);
7505                                 }
7506                         }
7507                 }
7508         }
7509         (void) fclose(fp);
7510 }
7511 
7512 /*
7513  * Tokens are separated by ' ', '\t', ':', '=', '&', '|', ';', '\n', or '\0'
7514  *
7515  * Returns DEVFSADM_SUCCESS if token found, DEVFSADM_FAILURE otherwise.
7516  */
7517 static int
7518 getnexttoken(char *next, char **nextp, char **tokenpp, char *tchar)
7519 {
7520         char *cp;
7521         char *cp1;
7522         char *tokenp;
7523 
7524         cp = next;
7525         while (*cp == ' ' || *cp == '\t') {
7526                 cp++;                   /* skip leading spaces */
7527         }
7528         tokenp = cp;                    /* start of token */
7529         while (*cp != '\0' && *cp != '\n' && *cp != ' ' && *cp != '\t' &&
7530             *cp != ':' && *cp != '=' && *cp != '&' &&
7531             *cp != '|' && *cp != ';') {
7532                 cp++;                   /* point to next character */
7533         }
7534         /*
7535          * If terminating character is a space or tab, look ahead to see if
7536          * there's another terminator that's not a space or a tab.
7537          * (This code handles trailing spaces.)
7538          */
7539         if (*cp == ' ' || *cp == '\t') {
7540                 cp1 = cp;
7541                 while (*++cp1 == ' ' || *cp1 == '\t')
7542                         ;
7543                 if (*cp1 == '=' || *cp1 == ':' || *cp1 == '&' || *cp1 == '|' ||
7544                     *cp1 == ';' || *cp1 == '\n' || *cp1 == '\0') {
7545                         *cp = NULL;     /* terminate token */
7546                         cp = cp1;
7547                 }
7548         }
7549         if (tchar != NULL) {
7550                 *tchar = *cp;           /* save terminating character */
7551                 if (*tchar == '\0') {
7552                         *tchar = '\n';
7553                 }
7554         }
7555         *cp++ = '\0';                   /* terminate token, point to next */
7556         *nextp = cp;                    /* set pointer to next character */
7557         if (cp - tokenp - 1 == 0) {
7558                 return (DEVFSADM_FAILURE);
7559         }
7560         *tokenpp = tokenp;
7561         return (DEVFSADM_SUCCESS);
7562 }
7563 
7564 /*
7565  * read or reread the driver aliases file
7566  */
7567 static void
7568 read_driver_aliases_file(void)
7569 {
7570 
7571         driver_alias_t *save;
7572         driver_alias_t *lst_tail;
7573         driver_alias_t *ap;
7574         static int cached = FALSE;
7575         FILE *afd;
7576         char line[256];
7577         char *cp;
7578         char *p;
7579         char t;
7580         int ln = 0;
7581         static struct stat cached_sb;
7582         struct stat current_sb;
7583 
7584         (void) stat(ALIASFILE, &current_sb);
7585 
7586         /* If already cached, check to see if it is still valid */
7587         if (cached == TRUE) {
7588 
7589                 if (current_sb.st_mtime == cached_sb.st_mtime) {
7590                         vprint(FILES_MID, "%s cache valid\n", ALIASFILE);
7591                         return;
7592                 }
7593 
7594                 vprint(FILES_MID, "invalidating %s cache\n", ALIASFILE);
7595                 while (driver_aliases != NULL) {
7596                         free(driver_aliases->alias_name);
7597                         free(driver_aliases->driver_name);
7598                         save = driver_aliases;
7599                         driver_aliases = driver_aliases->next;
7600                         free(save);
7601                 }
7602         } else {
7603                 cached = TRUE;
7604         }
7605 
7606         (void) stat(ALIASFILE, &cached_sb);
7607 
7608         vprint(FILES_MID, "loading binding file: %s\n", ALIASFILE);
7609 
7610         if ((afd = fopen(ALIASFILE, "r")) == NULL) {
7611                 err_print(FOPEN_FAILED, ALIASFILE, strerror(errno));
7612                 devfsadm_exit(1);
7613                 /*NOTREACHED*/
7614         }
7615 
7616         while (fgets(line, sizeof (line), afd) != NULL) {
7617                 ln++;
7618                 /* cut off comments starting with '#' */
7619                 if ((cp = strchr(line, '#')) != NULL)
7620                         *cp = '\0';
7621                 /* ignore comment or blank lines */
7622                 if (is_blank(line))
7623                         continue;
7624                 cp = line;
7625                 if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) {
7626                         err_print(IGNORING_LINE_IN, ln, ALIASFILE);
7627                         continue;
7628                 }
7629                 if (t == '\n' || t == '\0') {
7630                         err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE);
7631                         continue;
7632                 }
7633                 ap = (struct driver_alias *)
7634                     s_zalloc(sizeof (struct driver_alias));
7635                 ap->driver_name = s_strdup(p);
7636                 if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) {
7637                         err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE);
7638                         free(ap->driver_name);
7639                         free(ap);
7640                         continue;
7641                 }
7642                 if (*p == '"') {
7643                         if (p[strlen(p) - 1] == '"') {
7644                                 p[strlen(p) - 1] = '\0';
7645                                 p++;
7646                         }
7647                 }
7648                 ap->alias_name = s_strdup(p);
7649                 if (driver_aliases == NULL) {
7650                         driver_aliases = ap;
7651                         lst_tail = ap;
7652                 } else {
7653                         lst_tail->next = ap;
7654                         lst_tail = ap;
7655                 }
7656         }
7657         if (fclose(afd) == EOF) {
7658                 err_print(FCLOSE_FAILED, ALIASFILE, strerror(errno));
7659         }
7660 }
7661 
7662 /*
7663  * return TRUE if alias_name is an alias for driver_name, otherwise
7664  * return FALSE.
7665  */
7666 static int
7667 alias(char *driver_name, char *alias_name)
7668 {
7669         driver_alias_t *alias;
7670 
7671         /*
7672          * check for a match
7673          */
7674         for (alias = driver_aliases; alias != NULL; alias = alias->next) {
7675                 if ((strcmp(alias->driver_name, driver_name) == 0) &&
7676                     (strcmp(alias->alias_name, alias_name) == 0)) {
7677                         return (TRUE);
7678                 }
7679         }
7680         return (FALSE);
7681 }
7682 
7683 /*
7684  * convenience functions
7685  */
7686 static int
7687 s_stat(const char *path, struct stat *sbufp)
7688 {
7689         int rv;
7690 retry:
7691         if ((rv = stat(path, sbufp)) == -1) {
7692                 if (errno == EINTR)
7693                         goto retry;
7694         }
7695         return (rv);
7696 }
7697 
7698 static void *
7699 s_malloc(const size_t size)
7700 {
7701         void *rp;
7702 
7703         rp = malloc(size);
7704         if (rp == NULL) {
7705                 err_print(MALLOC_FAILED, size);
7706                 devfsadm_exit(1);
7707                 /*NOTREACHED*/
7708         }
7709         return (rp);
7710 }
7711 
7712 /*
7713  * convenience functions
7714  */
7715 static void *
7716 s_realloc(void *ptr, const size_t size)
7717 {
7718         ptr = realloc(ptr, size);
7719         if (ptr == NULL) {
7720                 err_print(REALLOC_FAILED, size);
7721                 devfsadm_exit(1);
7722                 /*NOTREACHED*/
7723         }
7724         return (ptr);
7725 }
7726 
7727 static void *
7728 s_zalloc(const size_t size)
7729 {
7730         void *rp;
7731 
7732         rp = calloc(1, size);
7733         if (rp == NULL) {
7734                 err_print(CALLOC_FAILED, size);
7735                 devfsadm_exit(1);
7736                 /*NOTREACHED*/
7737         }
7738         return (rp);
7739 }
7740 
7741 char *
7742 s_strdup(const char *ptr)
7743 {
7744         void *rp;
7745 
7746         rp = strdup(ptr);
7747         if (rp == NULL) {
7748                 err_print(STRDUP_FAILED, ptr);
7749                 devfsadm_exit(1);
7750                 /*NOTREACHED*/
7751         }
7752         return (rp);
7753 }
7754 
7755 static void
7756 s_closedir(DIR *dirp)
7757 {
7758 retry:
7759         if (closedir(dirp) != 0) {
7760                 if (errno == EINTR)
7761                         goto retry;
7762                 err_print(CLOSEDIR_FAILED, strerror(errno));
7763         }
7764 }
7765 
7766 static void
7767 s_mkdirp(const char *path, const mode_t mode)
7768 {
7769         vprint(CHATTY_MID, "mkdirp(%s, 0x%lx)\n", path, mode);
7770         if (mkdirp(path, mode) == -1) {
7771                 if (errno != EEXIST) {
7772                         err_print(MKDIR_FAILED, path, mode, strerror(errno));
7773                 }
7774         }
7775 }
7776 
7777 static void
7778 s_unlink(const char *file)
7779 {
7780 retry:
7781         if (unlink(file) == -1) {
7782                 if (errno == EINTR || errno == EAGAIN)
7783                         goto retry;
7784                 if (errno != ENOENT) {
7785                         err_print(UNLINK_FAILED, file, strerror(errno));
7786                 }
7787         }
7788 }
7789 
7790 static void
7791 add_verbose_id(char *mid)
7792 {
7793         num_verbose++;
7794         verbose = s_realloc(verbose, num_verbose * sizeof (char *));
7795         verbose[num_verbose - 1] = mid;
7796 }
7797 
7798 /*
7799  * returns DEVFSADM_TRUE if contents is a minor node in /devices.
7800  * If mn_root is not NULL, mn_root is set to:
7801  *      if contents is a /dev node, mn_root = contents
7802  *                      OR
7803  *      if contents is a /devices node, mn_root set to the '/'
7804  *      following /devices.
7805  */
7806 static int
7807 is_minor_node(char *contents, char **mn_root)
7808 {
7809         char *ptr;
7810         char device_prefix[100];
7811 
7812         (void) snprintf(device_prefix, sizeof (device_prefix), "../devices/");
7813 
7814         if ((ptr = strstr(contents, device_prefix)) != NULL) {
7815                 if (mn_root != NULL) {
7816                         /* mn_root should point to the / following /devices */
7817                         *mn_root = ptr += strlen(device_prefix) - 1;
7818                 }
7819                 return (DEVFSADM_TRUE);
7820         }
7821 
7822         (void) snprintf(device_prefix, sizeof (device_prefix), "/devices/");
7823 
7824         if (strncmp(contents, device_prefix, strlen(device_prefix)) == 0) {
7825                 if (mn_root != NULL) {
7826                         /* mn_root should point to the / following /devices */
7827                         *mn_root = contents + strlen(device_prefix) - 1;
7828                 }
7829                 return (DEVFSADM_TRUE);
7830         }
7831 
7832         if (mn_root != NULL) {
7833                 *mn_root = contents;
7834         }
7835         return (DEVFSADM_FALSE);
7836 }
7837 
7838 /*
7839  * Add the specified property to nvl.
7840  * Returns:
7841  *   0  successfully added
7842  *   -1 an error occurred
7843  *   1  could not add the property for reasons not due to errors.
7844  */
7845 static int
7846 add_property(nvlist_t *nvl, di_prop_t prop)
7847 {
7848         char *name;
7849         char *attr_name;
7850         int n, len;
7851         int32_t *int32p;
7852         int64_t *int64p;
7853         char *str;
7854         char **strarray;
7855         uchar_t *bytep;
7856         int rv = 0;
7857         int i;
7858 
7859         if ((name = di_prop_name(prop)) == NULL)
7860                 return (-1);
7861 
7862         len = sizeof (DEV_PROP_PREFIX) + strlen(name);
7863         if ((attr_name = malloc(len)) == NULL)
7864                 return (-1);
7865 
7866         (void) strlcpy(attr_name, DEV_PROP_PREFIX, len);
7867         (void) strlcat(attr_name, name, len);
7868 
7869         switch (di_prop_type(prop)) {
7870         case DI_PROP_TYPE_BOOLEAN:
7871                 if (nvlist_add_boolean(nvl, attr_name) != 0)
7872                         goto out;
7873                 break;
7874 
7875         case DI_PROP_TYPE_INT:
7876                 if ((n = di_prop_ints(prop, &int32p)) < 1)
7877                         goto out;
7878 
7879                 if (n <= (PROP_LEN_LIMIT / sizeof (int32_t))) {
7880                         if (nvlist_add_int32_array(nvl, attr_name, int32p,
7881                             n) != 0)
7882                                 goto out;
7883                 } else
7884                         rv = 1;
7885                 break;
7886 
7887         case DI_PROP_TYPE_INT64:
7888                 if ((n = di_prop_int64(prop, &int64p)) < 1)
7889                         goto out;
7890 
7891                 if (n <= (PROP_LEN_LIMIT / sizeof (int64_t))) {
7892                         if (nvlist_add_int64_array(nvl, attr_name, int64p,
7893                             n) != 0)
7894                                 goto out;
7895                 } else
7896                         rv = 1;
7897                 break;
7898 
7899         case DI_PROP_TYPE_BYTE:
7900         case DI_PROP_TYPE_UNKNOWN:
7901                 if ((n = di_prop_bytes(prop, &bytep)) < 1)
7902                         goto out;
7903 
7904                 if (n <= PROP_LEN_LIMIT) {
7905                         if (nvlist_add_byte_array(nvl, attr_name, bytep, n)
7906                             != 0)
7907                                 goto out;
7908                 } else
7909                         rv = 1;
7910                 break;
7911 
7912         case DI_PROP_TYPE_STRING:
7913                 if ((n = di_prop_strings(prop, &str)) < 1)
7914                         goto out;
7915 
7916                 if ((strarray = malloc(n * sizeof (char *))) == NULL)
7917                         goto out;
7918 
7919                 len = 0;
7920                 for (i = 0; i < n; i++) {
7921                         strarray[i] = str + len;
7922                         len += strlen(strarray[i]) + 1;
7923                 }
7924 
7925                 if (len <= PROP_LEN_LIMIT) {
7926                         if (nvlist_add_string_array(nvl, attr_name, strarray,
7927                             n) != 0) {
7928                                 free(strarray);
7929                                 goto out;
7930                         }
7931                 } else
7932                         rv = 1;
7933                 free(strarray);
7934                 break;
7935 
7936         default:
7937                 rv = 1;
7938                 break;
7939         }
7940 
7941         free(attr_name);
7942         return (rv);
7943 
7944 out:
7945         free(attr_name);
7946         return (-1);
7947 }
7948 
7949 static void
7950 free_dev_names(struct devlink_cb_arg *x)
7951 {
7952         int i;
7953 
7954         for (i = 0; i < x->count; i++) {
7955                 free(x->dev_names[i]);
7956                 free(x->link_contents[i]);
7957         }
7958 }
7959 
7960 /* callback function for di_devlink_cache_walk */
7961 static int
7962 devlink_cb(di_devlink_t dl, void *arg)
7963 {
7964         struct devlink_cb_arg *x = (struct devlink_cb_arg *)arg;
7965         const char *path;
7966         const char *content;
7967 
7968         if ((path = di_devlink_path(dl)) == NULL ||
7969             (content = di_devlink_content(dl)) == NULL ||
7970             (x->dev_names[x->count] = s_strdup(path)) == NULL)
7971                 goto out;
7972 
7973         if ((x->link_contents[x->count] = s_strdup(content)) == NULL) {
7974                 free(x->dev_names[x->count]);
7975                 goto out;
7976         }
7977 
7978         x->count++;
7979         if (x->count >= MAX_DEV_NAME_COUNT)
7980                 return (DI_WALK_TERMINATE);
7981 
7982         return (DI_WALK_CONTINUE);
7983 
7984 out:
7985         x->rv = -1;
7986         free_dev_names(x);
7987         return (DI_WALK_TERMINATE);
7988 }
7989 
7990 /*
7991  * Lookup dev name corresponding to the phys_path.
7992  * phys_path is path to a node or minor node.
7993  * Returns:
7994  *      0 with *dev_name set to the dev name
7995  *              Lookup succeeded and dev_name found
7996  *      0 with *dev_name set to NULL
7997  *              Lookup encountered no errors but dev name not found
7998  *      -1
7999  *              Lookup failed
8000  */
8001 static int
8002 lookup_dev_name(char *phys_path, char **dev_name)
8003 {
8004         struct devlink_cb_arg cb_arg;
8005 
8006         *dev_name = NULL;
8007 
8008         cb_arg.count = 0;
8009         cb_arg.rv = 0;
8010         (void) di_devlink_cache_walk(devlink_cache, NULL, phys_path,
8011             DI_PRIMARY_LINK, &cb_arg, devlink_cb);
8012 
8013         if (cb_arg.rv == -1)
8014                 return (-1);
8015 
8016         if (cb_arg.count > 0) {
8017                 *dev_name = s_strdup(cb_arg.dev_names[0]);
8018                 free_dev_names(&cb_arg);
8019                 if (*dev_name == NULL)
8020                         return (-1);
8021         }
8022 
8023         return (0);
8024 }
8025 
8026 static char *
8027 lookup_disk_dev_name(char *node_path)
8028 {
8029         struct devlink_cb_arg cb_arg;
8030         char *dev_name = NULL;
8031         int i;
8032         char *p;
8033         int len1, len2;
8034 
8035 #define DEV_RDSK        "/dev/rdsk/"
8036 #define DISK_RAW_MINOR  ",raw"
8037 
8038         cb_arg.count = 0;
8039         cb_arg.rv = 0;
8040         (void) di_devlink_cache_walk(devlink_cache, NULL, node_path,
8041             DI_PRIMARY_LINK, &cb_arg, devlink_cb);
8042 
8043         if (cb_arg.rv == -1 || cb_arg.count == 0)
8044                 return (NULL);
8045 
8046         /* first try lookup based on /dev/rdsk name */
8047         for (i = 0; i < cb_arg.count; i++) {
8048                 if (strncmp(cb_arg.dev_names[i], DEV_RDSK,
8049                     sizeof (DEV_RDSK) - 1) == 0) {
8050                         dev_name = s_strdup(cb_arg.dev_names[i]);
8051                         break;
8052                 }
8053         }
8054 
8055         if (dev_name == NULL) {
8056                 /* now try lookup based on a minor name ending with ",raw" */
8057                 len1 = sizeof (DISK_RAW_MINOR) - 1;
8058                 for (i = 0; i < cb_arg.count; i++) {
8059                         len2 = strlen(cb_arg.link_contents[i]);
8060                         if (len2 >= len1 &&
8061                             strcmp(cb_arg.link_contents[i] + len2 - len1,
8062                             DISK_RAW_MINOR) == 0) {
8063                                 dev_name = s_strdup(cb_arg.dev_names[i]);
8064                                 break;
8065                         }
8066                 }
8067         }
8068 
8069         free_dev_names(&cb_arg);
8070 
8071         if (dev_name == NULL)
8072                 return (NULL);
8073         if (strlen(dev_name) == 0) {
8074                 free(dev_name);
8075                 return (NULL);
8076         }
8077 
8078         /* if the name contains slice or partition number strip it */
8079         p = dev_name + strlen(dev_name) - 1;
8080         if (isdigit(*p)) {
8081                 while (p != dev_name && isdigit(*p))
8082                         p--;
8083                 if (*p == 's' || *p == 'p')
8084                         *p = '\0';
8085         }
8086 
8087         return (dev_name);
8088 }
8089 
8090 static char *
8091 lookup_lofi_dev_name(char *node_path, char *minor)
8092 {
8093         struct devlink_cb_arg cb_arg;
8094         char *dev_name = NULL;
8095         int i;
8096         int len1, len2;
8097 
8098         cb_arg.count = 0;
8099         cb_arg.rv = 0;
8100         (void) di_devlink_cache_walk(devlink_cache, NULL, node_path,
8101             DI_PRIMARY_LINK, &cb_arg, devlink_cb);
8102 
8103         if (cb_arg.rv == -1 || cb_arg.count == 0)
8104                 return (NULL);
8105 
8106         /* lookup based on a minor name ending with ",raw" */
8107         len1 = strlen(minor);
8108         for (i = 0; i < cb_arg.count; i++) {
8109                 len2 = strlen(cb_arg.link_contents[i]);
8110                 if (len2 >= len1 &&
8111                     strcmp(cb_arg.link_contents[i] + len2 - len1,
8112                     minor) == 0) {
8113                         dev_name = s_strdup(cb_arg.dev_names[i]);
8114                         break;
8115                 }
8116         }
8117 
8118         free_dev_names(&cb_arg);
8119 
8120         if (dev_name == NULL)
8121                 return (NULL);
8122         if (strlen(dev_name) == 0) {
8123                 free(dev_name);
8124                 return (NULL);
8125         }
8126 
8127         return (dev_name);
8128 }
8129 
8130 static char *
8131 lookup_network_dev_name(char *node_path, char *driver_name)
8132 {
8133         char *dev_name = NULL;
8134         char phys_path[MAXPATHLEN];
8135 
8136         if (lookup_dev_name(node_path, &dev_name) == -1)
8137                 return (NULL);
8138 
8139         if (dev_name == NULL) {
8140                 /* dlpi style-2 only interface */
8141                 (void) snprintf(phys_path, sizeof (phys_path),
8142                     "/pseudo/clone@0:%s", driver_name);
8143                 if (lookup_dev_name(phys_path, &dev_name) == -1 ||
8144                     dev_name == NULL)
8145                         return (NULL);
8146         }
8147 
8148         return (dev_name);
8149 }
8150 
8151 static char *
8152 lookup_printer_dev_name(char *node_path)
8153 {
8154         struct devlink_cb_arg cb_arg;
8155         char *dev_name = NULL;
8156         int i;
8157 
8158 #define DEV_PRINTERS    "/dev/printers/"
8159 
8160         cb_arg.count = 0;
8161         cb_arg.rv = 0;
8162         (void) di_devlink_cache_walk(devlink_cache, NULL, node_path,
8163             DI_PRIMARY_LINK, &cb_arg, devlink_cb);
8164 
8165         if (cb_arg.rv == -1 || cb_arg.count == 0)
8166                 return (NULL);
8167 
8168         /* first try lookup based on /dev/printers name */
8169         for (i = 0; i < cb_arg.count; i++) {
8170                 if (strncmp(cb_arg.dev_names[i], DEV_PRINTERS,
8171                     sizeof (DEV_PRINTERS) - 1) == 0) {
8172                         dev_name = s_strdup(cb_arg.dev_names[i]);
8173                         break;
8174                 }
8175         }
8176 
8177         /* fallback to the first name */
8178         if ((dev_name == NULL) && (cb_arg.count > 0))
8179                 dev_name = s_strdup(cb_arg.dev_names[0]);
8180 
8181         free_dev_names(&cb_arg);
8182 
8183         return (dev_name);
8184 }
8185 
8186 /*
8187  * Build an nvlist containing all attributes for devfs events.
8188  * Returns nvlist pointer on success, NULL on failure.
8189  */
8190 static nvlist_t *
8191 build_event_attributes(char *class, char *subclass, char *node_path,
8192     di_node_t node, char *driver_name, int instance, char *minor)
8193 {
8194         nvlist_t *nvl;
8195         int err = 0;
8196         di_prop_t prop;
8197         int count;
8198         char *prop_name;
8199         int x;
8200         char *dev_name = NULL;
8201         int dev_name_lookup_err = 0;
8202 
8203         if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, 0)) != 0) {
8204                 nvl = NULL;
8205                 goto out;
8206         }
8207 
8208         if ((err = nvlist_add_int32(nvl, EV_VERSION, EV_V1)) != 0)
8209                 goto out;
8210 
8211         if ((err = nvlist_add_string(nvl, DEV_PHYS_PATH, node_path)) != 0)
8212                 goto out;
8213 
8214         if (strcmp(class, EC_DEV_ADD) != 0 &&
8215             strcmp(class, EC_DEV_REMOVE) != 0)
8216                 return (nvl);
8217 
8218         if (driver_name == NULL || instance == -1)
8219                 goto out;
8220 
8221         if (strcmp(subclass, ESC_DISK) == 0) {
8222                 if ((dev_name = lookup_disk_dev_name(node_path)) == NULL) {
8223                         dev_name_lookup_err = 1;
8224                         goto out;
8225                 }
8226         } else if (strcmp(subclass, ESC_NETWORK) == 0) {
8227                 if ((dev_name = lookup_network_dev_name(node_path, driver_name))
8228                     == NULL) {
8229                         dev_name_lookup_err = 1;
8230                         goto out;
8231                 }
8232         } else if (strcmp(subclass, ESC_PRINTER) == 0) {
8233                 if ((dev_name = lookup_printer_dev_name(node_path)) == NULL) {
8234                         dev_name_lookup_err = 1;
8235                         goto out;
8236                 }
8237         } else if (strcmp(subclass, ESC_LOFI) == 0) {
8238                 /*
8239                  * The raw minor node is created or removed after the block
8240                  * node.  Lofi devfs events are dependent on this behavior.
8241                  * Generate the sysevent only for the raw minor node.
8242                  */
8243                 if (strstr(minor, "raw") == NULL) {
8244                         if (nvl) {
8245                                 nvlist_free(nvl);
8246                         }
8247                         return (NULL);
8248                 }
8249                 if ((dev_name = lookup_lofi_dev_name(node_path, minor)) ==
8250                     NULL) {
8251                         dev_name_lookup_err = 1;
8252                         goto out;
8253                 }
8254         }
8255 
8256         if (dev_name) {
8257                 if ((err = nvlist_add_string(nvl, DEV_NAME, dev_name)) != 0)
8258                         goto out;
8259                 free(dev_name);
8260                 dev_name = NULL;
8261         }
8262 
8263         if ((err = nvlist_add_string(nvl, DEV_DRIVER_NAME, driver_name)) != 0)
8264                 goto out;
8265 
8266         if ((err = nvlist_add_int32(nvl, DEV_INSTANCE, instance)) != 0)
8267                 goto out;
8268 
8269         if (strcmp(class, EC_DEV_ADD) == 0) {
8270                 /* add properties */
8271                 count = 0;
8272                 for (prop = di_prop_next(node, DI_PROP_NIL);
8273                     prop != DI_PROP_NIL && count < MAX_PROP_COUNT;
8274                     prop = di_prop_next(node, prop)) {
8275 
8276                         if (di_prop_devt(prop) != DDI_DEV_T_NONE)
8277                                 continue;
8278 
8279                         if ((x = add_property(nvl, prop)) == 0)
8280                                 count++;
8281                         else if (x == -1) {
8282                                 if ((prop_name = di_prop_name(prop)) == NULL)
8283                                         prop_name = "";
8284                                 err_print(PROP_ADD_FAILED, prop_name);
8285                                 goto out;
8286                         }
8287                 }
8288         }
8289 
8290         return (nvl);
8291 
8292 out:
8293         if (nvl)
8294                 nvlist_free(nvl);
8295 
8296         if (dev_name)
8297                 free(dev_name);
8298 
8299         if (dev_name_lookup_err) {
8300                 /*
8301                  * If a lofi mount fails, the /devices node may well have
8302                  * disappeared by the time we run, so let's not complain.
8303                  */
8304                 if (strcmp(subclass, ESC_LOFI) != 0)
8305                         err_print(DEV_NAME_LOOKUP_FAILED, node_path);
8306         } else {
8307                 err_print(BUILD_EVENT_ATTR_FAILED, (err) ? strerror(err) : "");
8308         }
8309         return (NULL);
8310 }
8311 
8312 static void
8313 log_event(char *class, char *subclass, nvlist_t *nvl)
8314 {
8315         sysevent_id_t eid;
8316 
8317         if (sysevent_post_event(class, subclass, "SUNW", DEVFSADMD,
8318             nvl, &eid) != 0) {
8319                 err_print(LOG_EVENT_FAILED, strerror(errno));
8320         }
8321 }
8322 
8323 /*
8324  * When devfsadmd needs to generate sysevents, they are queued for later
8325  * delivery this allows them to be delivered after the devlinks db cache has
8326  * been flushed guaranteeing that applications consuming these events have
8327  * access to an accurate devlinks db.  The queue is a FIFO, sysevents to be
8328  * inserted in the front of the queue and consumed off the back.
8329  */
8330 static void
8331 enqueue_sysevent(char *class, char *subclass, nvlist_t *nvl)
8332 {
8333         syseventq_t *tmp;
8334 
8335         if ((tmp = s_zalloc(sizeof (*tmp))) == NULL)
8336                 return;
8337 
8338         tmp->class = s_strdup(class);
8339         tmp->subclass = s_strdup(subclass);
8340         tmp->nvl = nvl;
8341 
8342         (void) mutex_lock(&syseventq_mutex);
8343         if (syseventq_front != NULL)
8344                 syseventq_front->next = tmp;
8345         else
8346                 syseventq_back = tmp;
8347         syseventq_front = tmp;
8348         (void) mutex_unlock(&syseventq_mutex);
8349 }
8350 
8351 static void
8352 process_syseventq()
8353 {
8354         (void) mutex_lock(&syseventq_mutex);
8355         while (syseventq_back != NULL) {
8356                 syseventq_t *tmp = syseventq_back;
8357 
8358                 vprint(CHATTY_MID, "sending queued event: %s, %s\n",
8359                     tmp->class, tmp->subclass);
8360 
8361                 log_event(tmp->class, tmp->subclass, tmp->nvl);
8362 
8363                 if (tmp->class != NULL)
8364                         free(tmp->class);
8365                 if (tmp->subclass != NULL)
8366                         free(tmp->subclass);
8367                 if (tmp->nvl != NULL)
8368                         nvlist_free(tmp->nvl);
8369                 syseventq_back = syseventq_back->next;
8370                 if (syseventq_back == NULL)
8371                         syseventq_front = NULL;
8372                 free(tmp);
8373         }
8374         (void) mutex_unlock(&syseventq_mutex);
8375 }
8376 
8377 static void
8378 build_and_enq_event(char *class, char *subclass, char *node_path,
8379         di_node_t node, char *minor)
8380 {
8381         nvlist_t *nvl;
8382 
8383         vprint(CHATTY_MID, "build_and_enq_event(%s, %s, %s, 0x%8.8x)\n",
8384             class, subclass, node_path, (int)node);
8385 
8386         if (node != DI_NODE_NIL)
8387                 nvl = build_event_attributes(class, subclass, node_path, node,
8388                     di_driver_name(node), di_instance(node), minor);
8389         else
8390                 nvl = build_event_attributes(class, subclass, node_path, node,
8391                     NULL, -1, minor);
8392 
8393         if (nvl) {
8394                 enqueue_sysevent(class, subclass, nvl);
8395         }
8396 }
8397 
8398 /*
8399  * is_blank() returns 1 (true) if a line specified is composed of
8400  * whitespace characters only. otherwise, it returns 0 (false).
8401  *
8402  * Note. the argument (line) must be null-terminated.
8403  */
8404 static int
8405 is_blank(char *line)
8406 {
8407         for (/* nothing */; *line != '\0'; line++)
8408                 if (!isspace(*line))
8409                         return (0);
8410         return (1);
8411 }
8412 
8413 /*
8414  * Functions to deal with the no-further-processing hash
8415  */
8416 
8417 static void
8418 nfphash_create(void)
8419 {
8420         assert(nfp_hash == NULL);
8421         nfp_hash = s_zalloc(NFP_HASH_SZ * sizeof (item_t *));
8422 }
8423 
8424 static int
8425 nfphash_fcn(char *key)
8426 {
8427         int i;
8428         uint64_t sum = 0;
8429 
8430         for (i = 0; key[i] != '\0'; i++) {
8431                 sum += (uchar_t)key[i];
8432         }
8433 
8434         return (sum % NFP_HASH_SZ);
8435 }
8436 
8437 static item_t *
8438 nfphash_lookup(char *key)
8439 {
8440         int     index;
8441         item_t  *ip;
8442 
8443         index = nfphash_fcn(key);
8444 
8445         assert(index >= 0);
8446 
8447         for (ip = nfp_hash[index]; ip; ip = ip->i_next) {
8448                 if (strcmp(ip->i_key, key) == 0)
8449                         return (ip);
8450         }
8451 
8452         return (NULL);
8453 }
8454 
8455 static void
8456 nfphash_insert(char *key)
8457 {
8458         item_t  *ip;
8459         int     index;
8460 
8461         index = nfphash_fcn(key);
8462 
8463         assert(index >= 0);
8464 
8465         ip = s_zalloc(sizeof (item_t));
8466         ip->i_key = s_strdup(key);
8467 
8468         ip->i_next = nfp_hash[index];
8469         nfp_hash[index] = ip;
8470 }
8471 
8472 static void
8473 nfphash_destroy(void)
8474 {
8475         int     i;
8476         item_t  *ip;
8477 
8478         for (i = 0; i < NFP_HASH_SZ; i++) {
8479                 /*LINTED*/
8480                 while (ip = nfp_hash[i]) {
8481                         nfp_hash[i] = ip->i_next;
8482                         free(ip->i_key);
8483                         free(ip);
8484                 }
8485         }
8486 
8487         free(nfp_hash);
8488         nfp_hash = NULL;
8489 }
8490 
8491 static int
8492 devname_kcall(int subcmd, void *args)
8493 {
8494         int error = 0;
8495 
8496         switch (subcmd) {
8497         case MODDEVNAME_LOOKUPDOOR:
8498                 error = modctl(MODDEVNAME, subcmd, (uintptr_t)args);
8499                 if (error) {
8500                         vprint(INFO_MID, "modctl(MODDEVNAME, "
8501                             "MODDEVNAME_LOOKUPDOOR) failed - %s\n",
8502                             strerror(errno));
8503                 }
8504                 break;
8505         default:
8506                 error = EINVAL;
8507                 break;
8508         }
8509         return (error);
8510 }
8511 
8512 /* ARGSUSED */
8513 static void
8514 devname_lookup_handler(void *cookie, char *argp, size_t arg_size,
8515     door_desc_t *dp, uint_t n_desc)
8516 {
8517         int32_t error = 0;
8518         door_cred_t dcred;
8519         struct dca_impl dci;
8520         uint8_t cmd;
8521         sdev_door_res_t res;
8522         sdev_door_arg_t *args;
8523 
8524         if (argp == NULL || arg_size == 0) {
8525                 vprint(DEVNAME_MID, "devname_lookup_handler: argp wrong\n");
8526                 error = DEVFSADM_RUN_INVALID;
8527                 goto done;
8528         }
8529         vprint(DEVNAME_MID, "devname_lookup_handler\n");
8530 
8531         if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) {
8532                 vprint(DEVNAME_MID, "devname_lookup_handler: cred wrong\n");
8533                 error = DEVFSADM_RUN_EPERM;
8534                 goto done;
8535         }
8536 
8537         args = (sdev_door_arg_t *)argp;
8538         cmd = args->devfsadm_cmd;
8539 
8540         vprint(DEVNAME_MID, "devname_lookup_handler: cmd %d\n", cmd);
8541         switch (cmd) {
8542         case DEVFSADMD_RUN_ALL:
8543                 /*
8544                  * run "devfsadm"
8545                  */
8546                 dci.dci_root = "/";
8547                 dci.dci_minor = NULL;
8548                 dci.dci_driver = NULL;
8549                 dci.dci_error = 0;
8550                 dci.dci_flags = 0;
8551                 dci.dci_arg = NULL;
8552 
8553                 lock_dev();
8554                 update_drvconf((major_t)-1, 0);
8555                 dci.dci_flags |= DCA_FLUSH_PATHINST;
8556 
8557                 pre_and_post_cleanup(RM_PRE);
8558                 devi_tree_walk(&dci, DI_CACHE_SNAPSHOT_FLAGS, NULL);
8559                 error = (int32_t)dci.dci_error;
8560                 if (!error) {
8561                         pre_and_post_cleanup(RM_POST);
8562                         update_database = TRUE;
8563                         unlock_dev(SYNC_STATE);
8564                         update_database = FALSE;
8565                 } else {
8566                         if (DEVFSADM_DEBUG_ON) {
8567                                 vprint(INFO_MID, "devname_lookup_handler: "
8568                                     "DEVFSADMD_RUN_ALL failed\n");
8569                         }
8570 
8571                         unlock_dev(SYNC_STATE);
8572                 }
8573                 break;
8574         default:
8575                 /* log an error here? */
8576                 error = DEVFSADM_RUN_NOTSUP;
8577                 break;
8578         }
8579 
8580 done:
8581         vprint(DEVNAME_MID, "devname_lookup_handler: error %d\n", error);
8582         res.devfsadm_error = error;
8583         (void) door_return((char *)&res, sizeof (struct sdev_door_res),
8584             NULL, 0);
8585 }
8586 
8587 
8588 di_devlink_handle_t
8589 devfsadm_devlink_cache(void)
8590 {
8591         return (devlink_cache);
8592 }
8593 
8594 int
8595 devfsadm_reserve_id_cache(devlink_re_t re_array[], enumerate_file_t *head)
8596 {
8597         enumerate_file_t *entry;
8598         int nelem;
8599         int i;
8600         int subex;
8601         char *re;
8602         size_t size;
8603         regmatch_t *pmch;
8604 
8605         /*
8606          * Check the <RE, subexp> array passed in and compile it.
8607          */
8608         for (i = 0; re_array[i].d_re; i++) {
8609                 if (re_array[i].d_subexp == 0) {
8610                         err_print("bad subexp value in RE: %s\n",
8611                             re_array[i].d_re);
8612                         goto bad_re;
8613                 }
8614 
8615                 re = re_array[i].d_re;
8616                 if (regcomp(&re_array[i].d_rcomp, re, REG_EXTENDED) != 0) {
8617                         err_print("reg. exp. failed to compile: %s\n", re);
8618                         goto bad_re;
8619                 }
8620                 subex = re_array[i].d_subexp;
8621                 nelem = subex + 1;
8622                 re_array[i].d_pmatch = s_malloc(sizeof (regmatch_t) * nelem);
8623         }
8624 
8625         entry = head ? head : enumerate_reserved;
8626         for (; entry; entry = entry->er_next) {
8627                 if (entry->er_id) {
8628                         vprint(RSBY_MID, "entry %s already has ID %s\n",
8629                             entry->er_file, entry->er_id);
8630                         continue;
8631                 }
8632                 for (i = 0; re_array[i].d_re; i++) {
8633                         subex = re_array[i].d_subexp;
8634                         pmch = re_array[i].d_pmatch;
8635                         if (regexec(&re_array[i].d_rcomp, entry->er_file,
8636                             subex + 1, pmch, 0) != 0) {
8637                                 /* No match */
8638                                 continue;
8639                         }
8640                         size = pmch[subex].rm_eo - pmch[subex].rm_so;
8641                         entry->er_id = s_malloc(size + 1);
8642                         (void) strncpy(entry->er_id,
8643                             &entry->er_file[pmch[subex].rm_so], size);
8644                         entry->er_id[size] = '\0';
8645                         if (head) {
8646                                 vprint(RSBY_MID, "devlink(%s) matches RE(%s). "
8647                                     "ID is %s\n", entry->er_file,
8648                                     re_array[i].d_re, entry->er_id);
8649                         } else {
8650                                 vprint(RSBY_MID, "rsrv entry(%s) matches "
8651                                     "RE(%s) ID is %s\n", entry->er_file,
8652                                     re_array[i].d_re, entry->er_id);
8653                         }
8654                         break;
8655                 }
8656         }
8657 
8658         for (i = 0; re_array[i].d_re; i++) {
8659                 regfree(&re_array[i].d_rcomp);
8660                 assert(re_array[i].d_pmatch);
8661                 free(re_array[i].d_pmatch);
8662         }
8663 
8664         entry = head ? head : enumerate_reserved;
8665         for (; entry; entry = entry->er_next) {
8666                 if (entry->er_id == NULL)
8667                         continue;
8668                 if (head) {
8669                         vprint(RSBY_MID, "devlink: %s\n", entry->er_file);
8670                         vprint(RSBY_MID, "ID: %s\n", entry->er_id);
8671                 } else {
8672                         vprint(RSBY_MID, "reserve file entry: %s\n",
8673                             entry->er_file);
8674                         vprint(RSBY_MID, "reserve file id: %s\n",
8675                             entry->er_id);
8676                 }
8677         }
8678 
8679         return (DEVFSADM_SUCCESS);
8680 
8681 bad_re:
8682         for (i = i-1; i >= 0; i--) {
8683                 regfree(&re_array[i].d_rcomp);
8684                 assert(re_array[i].d_pmatch);
8685                 free(re_array[i].d_pmatch);
8686         }
8687         return (DEVFSADM_FAILURE);
8688 }
8689 
8690 /*
8691  * Return 1 if we have reserved links.
8692  */
8693 int
8694 devfsadm_have_reserved()
8695 {
8696         return (enumerate_reserved ? 1 : 0);
8697 }
8698 
8699 /*
8700  * This functions errs on the side of caution. If there is any error
8701  * we assume that the devlink is  *not* reserved
8702  */
8703 int
8704 devfsadm_is_reserved(devlink_re_t re_array[], char *devlink)
8705 {
8706         int match;
8707         enumerate_file_t estruct = {NULL};
8708         enumerate_file_t *entry;
8709 
8710         match = 0;
8711         estruct.er_file = devlink;
8712         estruct.er_id = NULL;
8713         estruct.er_next = NULL;
8714 
8715         if (devfsadm_reserve_id_cache(re_array, &estruct) != DEVFSADM_SUCCESS) {
8716                 err_print("devfsadm_is_reserved: devlink (%s) does not "
8717                     "match RE\n", devlink);
8718                 return (0);
8719         }
8720         if (estruct.er_id == NULL) {
8721                 err_print("devfsadm_is_reserved: ID derived from devlink %s "
8722                     "is NULL\n", devlink);
8723                 return (0);
8724         }
8725 
8726         entry = enumerate_reserved;
8727         for (; entry; entry = entry->er_next) {
8728                 if (entry->er_id == NULL)
8729                         continue;
8730                 if (strcmp(entry->er_id, estruct.er_id) != 0)
8731                         continue;
8732                 match = 1;
8733                 vprint(RSBY_MID, "reserve file entry (%s) and devlink (%s) "
8734                     "match\n", entry->er_file, devlink);
8735                 break;
8736         }
8737 
8738         free(estruct.er_id);
8739         return (match);
8740 }
--- EOF ---