/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2016 Toomas Soome * Copyright 2016 Nexenta Systems, Inc. All rights reserved. * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright 2019, Joyent, Inc. */ /* * Devfsadm replaces drvconfig, audlinks, disks, tapes, ports, devlinks * as a general purpose device administrative utility. It creates * devices special files in /devices and logical links in /dev, and * coordinates updates to /etc/path_to_instance with the kernel. It * operates in both command line mode to handle user or script invoked * reconfiguration updates, and operates in daemon mode to handle dynamic * reconfiguration for hotplugging support. */ #include #include #include #include #include #include #include #include #include #include "devfsadm_impl.h" /* externs from devalloc.c */ extern void _reset_devalloc(int); extern void _update_devalloc_db(devlist_t *, int, int, char *, char *); extern int _da_check_for_usb(char *, char *); /* create or remove nodes or links. unset with -n */ static int file_mods = TRUE; /* cleanup mode. Set with -C */ static int cleanup = FALSE; /* devlinks -d compatibility */ static int devlinks_debug = FALSE; /* flag to check if system is labeled */ int system_labeled = FALSE; /* flag to enable/disable device allocation with -e/-d */ static int devalloc_flag = 0; /* flag that indicates if device allocation is on or not */ static int devalloc_is_on = 0; /* flag to update device allocation database for this device type */ static int update_devdb = 0; /* * devices to be deallocated with -d : * audio, floppy, cd, floppy, tape, rmdisk. */ static char *devalloc_list[10] = {DDI_NT_AUDIO, DDI_NT_CD, DDI_NT_CD_CHAN, DDI_NT_FD, DDI_NT_TAPE, DDI_NT_BLOCK_CHAN, DDI_NT_UGEN, DDI_NT_USB_ATTACHMENT_POINT, DDI_NT_SCSI_NEXUS, NULL}; /* list of allocatable devices */ static devlist_t devlist; /* load a single driver only. set with -i */ static int single_drv = FALSE; static char *driver = NULL; /* attempt to load drivers or defer attach nodes */ static int load_attach_drv = TRUE; /* reload all driver.conf files */ static int update_all_drivers = FALSE; /* set if invoked via /usr/lib/devfsadm/devfsadmd */ static int daemon_mode = FALSE; /* set if event_handler triggered */ int event_driven = FALSE; /* output directed to syslog during daemon mode if set */ static int logflag = FALSE; /* build links in /dev. -x to turn off */ static int build_dev = TRUE; /* build nodes in /devices. -y to turn off */ static int build_devices = TRUE; /* -z to turn off */ static int flush_path_to_inst_enable = TRUE; /* variables used for path_to_inst flushing */ static int inst_count = 0; static mutex_t count_lock; static cond_t cv; /* variables for minor_fini thread */ static mutex_t minor_fini_mutex; static int minor_fini_canceled = TRUE; static int minor_fini_delayed = FALSE; static cond_t minor_fini_cv; static int minor_fini_timeout = MINOR_FINI_TIMEOUT_DEFAULT; /* single-threads /dev modification */ static sema_t dev_sema; /* the program we were invoked as; ie argv[0] */ static char *prog; /* pointers to create/remove link lists */ static create_list_t *create_head = NULL; static remove_list_t *remove_head = NULL; /* supports the class -c option */ static char **classes = NULL; static int num_classes = 0; /* used with verbose option -v or -V */ static int num_verbose = 0; static char **verbose = NULL; static struct mperm *minor_perms = NULL; static driver_alias_t *driver_aliases = NULL; /* set if -r alternate root given */ static char *root_dir = ""; /* /devices or /devices */ static char *devices_dir = DEVICES; /* /dev or /dev */ static char *dev_dir = DEV; /* /etc/dev or /etc/dev */ static char *etc_dev_dir = ETCDEV; /* * writable root (for lock files and doors during install). * This is also root dir for /dev attr dir during install. */ static char *attr_root = NULL; /* /etc/path_to_inst unless -p used */ static char *inst_file = INSTANCE_FILE; /* /usr/lib/devfsadm/linkmods unless -l used */ static char *module_dirs = MODULE_DIRS; /* default uid/gid used if /etc/minor_perm entry not found */ static uid_t root_uid; static gid_t sys_gid; /* /etc/devlink.tab unless devlinks -t used */ static char *devlinktab_file = NULL; /* File and data structure to reserve enumerate IDs */ static char *enumerate_file = ENUMERATE_RESERVED; static enumerate_file_t *enumerate_reserved = NULL; /* set if /dev link is new. speeds up rm_stale_links */ static int linknew = TRUE; /* variables for devlink.tab compat processing */ static devlinktab_list_t *devlinktab_list = NULL; static unsigned int devlinktab_line = 0; /* cache head for devfsadm_enumerate*() functions */ static numeral_set_t *head_numeral_set = NULL; /* list list of devfsadm modules */ static module_t *module_head = NULL; /* name_to_major list used in utility function */ static n2m_t *n2m_list = NULL; /* cache of some links used for performance */ static linkhead_t *headlinkhead = NULL; /* locking variables to prevent multiples writes to /dev */ static int hold_dev_lock = FALSE; static int hold_daemon_lock = FALSE; static int dev_lock_fd; static int daemon_lock_fd; static char dev_lockfile[PATH_MAX + 1]; static char daemon_lockfile[PATH_MAX + 1]; /* last devinfo node/minor processed. used for performance */ static di_node_t lnode; static di_minor_t lminor; static char lphy_path[PATH_MAX + 1] = {""}; /* Globals used by the link database */ static di_devlink_handle_t devlink_cache; static int update_database = FALSE; /* Globals used to set logindev perms */ static struct login_dev *login_dev_cache = NULL; static int login_dev_enable = FALSE; /* Global to use devinfo snapshot cache */ static int use_snapshot_cache = FALSE; /* Global for no-further-processing hash */ static item_t **nfp_hash; static mutex_t nfp_mutex = DEFAULTMUTEX; /* * Directories not removed even when empty. They are packaged, or may * be referred to from a non-global zone. The dirs must be listed in * canonical form i.e. without leading "/dev/" */ static char *sticky_dirs[] = {"dsk", "rdsk", "term", "lofi", "rlofi", NULL}; /* Devname globals */ static int lookup_door_fd = -1; static char *lookup_door_path; static void load_dev_acl(void); static void update_drvconf(major_t, int); static void check_reconfig_state(void); static int s_stat(const char *, struct stat *); static int is_blank(char *); /* sysevent queue related globals */ static mutex_t syseventq_mutex = DEFAULTMUTEX; static syseventq_t *syseventq_front; static syseventq_t *syseventq_back; static void process_syseventq(); static di_node_t devi_root_node = DI_NODE_NIL; int main(int argc, char *argv[]) { struct passwd *pw; struct group *gp; pid_t pid; (void) setlocale(LC_ALL, ""); (void) textdomain(TEXT_DOMAIN); if ((prog = strrchr(argv[0], '/')) == NULL) { prog = argv[0]; } else { prog++; } if (getuid() != 0) { err_print(MUST_BE_ROOT); devfsadm_exit(1); /*NOTREACHED*/ } if (getzoneid() != GLOBAL_ZONEID) { err_print(MUST_BE_GLOBAL_ZONE); devfsadm_exit(1); } /* * Close all files except stdin/stdout/stderr */ closefrom(3); if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) { root_uid = pw->pw_uid; } else { err_print(CANT_FIND_USER, DEFAULT_DEV_USER); root_uid = (uid_t)0; /* assume 0 is root */ } /* the default group is sys */ if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) { sys_gid = gp->gr_gid; } else { err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP); sys_gid = (gid_t)3; /* assume 3 is sys */ } (void) umask(0); system_labeled = is_system_labeled(); if (system_labeled == FALSE) { /* * is_system_labeled() will return false in case we are * starting before the first reboot after Trusted Extensions * is enabled. Check the setting in /etc/system to see if * TX is enabled (even if not yet booted). */ if (defopen("/etc/system") == 0) { if (defread("set sys_labeling=1") != NULL) system_labeled = TRUE; /* close defaults file */ (void) defopen(NULL); } } /* * Check if device allocation is enabled. */ devalloc_is_on = (da_is_on() == 1) ? 1 : 0; #ifdef DEBUG if (system_labeled == FALSE) { struct stat tx_stat; /* test hook: see also mkdevalloc.c and allocate.c */ system_labeled = is_system_labeled_debug(&tx_stat); } #endif parse_args(argc, argv); (void) sema_init(&dev_sema, 1, USYNC_THREAD, NULL); /* Initialize device allocation list */ devlist.audio = devlist.cd = devlist.floppy = devlist.tape = devlist.rmdisk = NULL; if (daemon_mode == TRUE) { /* * Build /dev and /devices before daemonizing if * reconfig booting and daemon invoked with alternate * root. This is to support install. */ if (getenv(RECONFIG_BOOT) != NULL && root_dir[0] != '\0') { vprint(INFO_MID, CONFIGURING); load_dev_acl(); update_drvconf((major_t)-1, 0); process_devinfo_tree(); (void) modctl(MODSETMINIROOT); } /* * fork before detaching from tty in order to print error * message if unable to acquire file lock. locks not preserved * across forks. Even under debug we want to fork so that * when executed at boot we don't hang. */ if (fork() != 0) { devfsadm_exit(0); /*NOTREACHED*/ } /* set directory to / so it coredumps there */ if (chdir("/") == -1) { err_print(CHROOT_FAILED, strerror(errno)); } /* only one daemon can run at a time */ if ((pid = enter_daemon_lock()) == getpid()) { detachfromtty(); (void) cond_init(&cv, USYNC_THREAD, 0); (void) mutex_init(&count_lock, USYNC_THREAD, 0); if (thr_create(NULL, 0, (void *(*)(void *))instance_flush_thread, NULL, THR_DETACHED, NULL) != 0) { err_print(CANT_CREATE_THREAD, "daemon", strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } /* start the minor_fini_thread */ (void) mutex_init(&minor_fini_mutex, USYNC_THREAD, 0); (void) cond_init(&minor_fini_cv, USYNC_THREAD, 0); if (thr_create(NULL, 0, minor_fini_thread, NULL, THR_DETACHED, NULL)) { err_print(CANT_CREATE_THREAD, "minor_fini", strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } /* * logindevperms need only be set * in daemon mode and when root dir is "/". */ if (root_dir[0] == '\0') login_dev_enable = TRUE; daemon_update(); devfsadm_exit(0); /*NOTREACHED*/ } else { err_print(DAEMON_RUNNING, pid); devfsadm_exit(1); /*NOTREACHED*/ } } else { /* not a daemon, so just build /dev and /devices */ /* * If turning off device allocation, load the * minor_perm file because process_devinfo_tree() will * need this in order to reset the permissions of the * device files. */ if (devalloc_flag == DA_OFF) { read_minor_perm_file(); } process_devinfo_tree(); if (devalloc_flag != 0) /* Enable/disable device allocation */ _reset_devalloc(devalloc_flag); } return (0); } static void update_drvconf(major_t major, int flags) { if (modctl(MODLOADDRVCONF, major, flags) != 0) err_print(gettext("update_drvconf failed for major %d\n"), major); } static void load_dev_acl() { if (load_devpolicy() != 0) err_print(gettext("device policy load failed\n")); load_minor_perm_file(); } /* * As devfsadm is run early in boot to provide the kernel with * minor_perm info, we might as well check for reconfig at the * same time to avoid running devfsadm twice. This gets invoked * earlier than the env variable RECONFIG_BOOT is set up. */ static void check_reconfig_state() { struct stat sb; if (s_stat("/reconfigure", &sb) == 0) { (void) modctl(MODDEVNAME, MODDEVNAME_RECONFIG, 0); } } static void modctl_sysavail() { /* * Inform /dev that system is available, that * implicit reconfig can now be performed. */ (void) modctl(MODDEVNAME, MODDEVNAME_SYSAVAIL, 0); } static void set_lock_root(void) { struct stat sb; char *lock_root; size_t len; lock_root = attr_root ? attr_root : root_dir; len = strlen(lock_root) + strlen(ETCDEV) + 1; etc_dev_dir = s_malloc(len); (void) snprintf(etc_dev_dir, len, "%s%s", lock_root, ETCDEV); if (s_stat(etc_dev_dir, &sb) != 0) { s_mkdirp(etc_dev_dir, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH); } else if (!S_ISDIR(sb.st_mode)) { err_print(NOT_DIR, etc_dev_dir); devfsadm_exit(1); /*NOTREACHED*/ } } /* * Parse arguments for all 6 programs handled from devfsadm. */ static void parse_args(int argc, char *argv[]) { char opt; char get_linkcompat_opts = FALSE; char *compat_class; int num_aliases = 0; int len; int retval; int config = TRUE; int bind = FALSE; int force_flag = FALSE; struct aliases *ap = NULL; struct aliases *a_head = NULL; struct aliases *a_tail = NULL; struct modconfig mc; (void) bzero(&mc, sizeof (mc)); if (strcmp(prog, DISKS) == 0) { compat_class = "disk"; get_linkcompat_opts = TRUE; } else if (strcmp(prog, TAPES) == 0) { compat_class = "tape"; get_linkcompat_opts = TRUE; } else if (strcmp(prog, PORTS) == 0) { compat_class = "port"; get_linkcompat_opts = TRUE; } else if (strcmp(prog, AUDLINKS) == 0) { compat_class = "audio"; get_linkcompat_opts = TRUE; } else if (strcmp(prog, DEVLINKS) == 0) { devlinktab_file = DEVLINKTAB_FILE; build_devices = FALSE; load_attach_drv = FALSE; while ((opt = getopt(argc, argv, "dnr:st:vV:")) != EOF) { switch (opt) { case 'd': file_mods = FALSE; flush_path_to_inst_enable = FALSE; devlinks_debug = TRUE; break; case 'n': /* prevent driver loading and deferred attach */ load_attach_drv = FALSE; break; case 'r': set_root_devices_dev_dir(optarg); if (zone_pathcheck(root_dir) != DEVFSADM_SUCCESS) devfsadm_exit(1); /*NOTREACHED*/ break; case 's': /* * suppress. don't create/remove links/nodes * useful with -v or -V */ file_mods = FALSE; flush_path_to_inst_enable = FALSE; break; case 't': /* supply a non-default table file */ devlinktab_file = optarg; break; case 'v': /* documented verbose flag */ add_verbose_id(VERBOSE_MID); break; case 'V': /* undocumented for extra verbose levels */ add_verbose_id(optarg); break; default: usage(); break; } } if (optind < argc) { usage(); } } else if (strcmp(prog, DRVCONFIG) == 0) { int update_only = 0; build_dev = FALSE; while ((opt = getopt(argc, argv, "a:bc:dfi:m:np:R:r:suvV:x")) != EOF) { switch (opt) { case 'a': ap = calloc(sizeof (struct aliases), 1); ap->a_name = dequote(optarg); len = strlen(ap->a_name) + 1; if (len > MAXMODCONFNAME) { err_print(ALIAS_TOO_LONG, MAXMODCONFNAME, ap->a_name); devfsadm_exit(1); /*NOTREACHED*/ } ap->a_len = len; if (a_tail == NULL) { a_head = ap; } else { a_tail->a_next = ap; } a_tail = ap; num_aliases++; bind = TRUE; break; case 'b': bind = TRUE; break; case 'c': (void) strcpy(mc.drvclass, optarg); break; case 'd': /* * need to keep for compatibility, but * do nothing. */ break; case 'f': force_flag = TRUE; break; case 'i': single_drv = TRUE; (void) strcpy(mc.drvname, optarg); driver = s_strdup(optarg); break; case 'm': mc.major = atoi(optarg); break; case 'n': /* prevent driver loading and deferred attach */ load_attach_drv = FALSE; break; case 'p': /* specify alternate path_to_inst file */ inst_file = s_strdup(optarg); break; case 'R': /* * Private flag for suninstall to populate * device information on the installed root. */ root_dir = s_strdup(optarg); if (zone_pathcheck(root_dir) != DEVFSADM_SUCCESS) devfsadm_exit(devfsadm_copy()); /*NOTREACHED*/ break; case 'r': devices_dir = s_strdup(optarg); if (zone_pathcheck(devices_dir) != DEVFSADM_SUCCESS) devfsadm_exit(1); /*NOTREACHED*/ break; case 's': /* * suppress. don't create nodes * useful with -v or -V */ file_mods = FALSE; flush_path_to_inst_enable = FALSE; break; case 'u': /* * Invoked via update_drv(8) to update * the kernel's driver/alias binding * when removing one or more aliases. */ config = FALSE; break; case 'v': /* documented verbose flag */ add_verbose_id(VERBOSE_MID); break; case 'V': /* undocumented for extra verbose levels */ add_verbose_id(optarg); break; case 'x': update_only = 1; break; default: usage(); } } if (optind < argc) { usage(); } if (bind == TRUE) { if ((mc.major == -1) || (mc.drvname[0] == '\0')) { err_print(MAJOR_AND_B_FLAG); devfsadm_exit(1); /*NOTREACHED*/ } mc.flags = 0; if (force_flag) mc.flags |= MOD_UNBIND_OVERRIDE; if (update_only) mc.flags |= MOD_ADDMAJBIND_UPDATE; mc.num_aliases = num_aliases; mc.ap = a_head; retval = modctl((config == TRUE) ? MODADDMAJBIND : MODREMDRVALIAS, NULL, (caddr_t)&mc); if (retval < 0) { err_print((config == TRUE) ? MODCTL_ADDMAJBIND : MODCTL_REMMAJBIND); } devfsadm_exit(retval); /*NOTREACHED*/ } } else if ((strcmp(prog, DEVFSADM) == 0) || (strcmp(prog, DEVFSADMD) == 0)) { char *zonename = NULL; int init_drvconf = 0; int init_perm = 0; int public_mode = 0; int init_sysavail = 0; if (strcmp(prog, DEVFSADMD) == 0) { daemon_mode = TRUE; } devlinktab_file = DEVLINKTAB_FILE; while ((opt = getopt(argc, argv, "a:Cc:deIi:l:np:PR:r:sSt:uvV:x:")) != EOF) { if (opt == 'I' || opt == 'P' || opt == 'S') { if (public_mode) usage(); } else { if (init_perm || init_drvconf || init_sysavail) usage(); public_mode = 1; } switch (opt) { case 'a': attr_root = s_strdup(optarg); break; case 'C': cleanup = TRUE; break; case 'c': num_classes++; classes = s_realloc(classes, num_classes * sizeof (char *)); classes[num_classes - 1] = optarg; break; case 'd': if (daemon_mode == FALSE) { /* * Device allocation to be disabled. */ devalloc_flag = DA_OFF; build_dev = FALSE; } break; case 'e': if (daemon_mode == FALSE) { /* * Device allocation to be enabled. */ devalloc_flag = DA_ON; build_dev = FALSE; } break; case 'I': /* update kernel driver.conf cache */ if (daemon_mode == TRUE) usage(); init_drvconf = 1; break; case 'i': single_drv = TRUE; driver = s_strdup(optarg); break; case 'l': /* specify an alternate module load path */ module_dirs = s_strdup(optarg); break; case 'n': /* prevent driver loading and deferred attach */ load_attach_drv = FALSE; break; case 'p': /* specify alternate path_to_inst file */ inst_file = s_strdup(optarg); break; case 'P': if (daemon_mode == TRUE) usage(); /* load minor_perm and device_policy */ init_perm = 1; break; case 'R': /* * Private flag for suninstall to populate * device information on the installed root. */ root_dir = s_strdup(optarg); devfsadm_exit(devfsadm_copy()); /*NOTREACHED*/ break; case 'r': set_root_devices_dev_dir(optarg); break; case 's': /* * suppress. don't create/remove links/nodes * useful with -v or -V */ file_mods = FALSE; flush_path_to_inst_enable = FALSE; break; case 'S': if (daemon_mode == TRUE) usage(); init_sysavail = 1; break; case 't': devlinktab_file = optarg; break; case 'u': /* complete configuration after */ /* adding a driver update-only */ if (daemon_mode == TRUE) usage(); update_all_drivers = TRUE; break; case 'v': /* documented verbose flag */ add_verbose_id(VERBOSE_MID); break; case 'V': /* undocumented: specify verbose lvl */ add_verbose_id(optarg); break; case 'x': /* * x is the "private switch" option. The * goal is to not suck up all the other * option letters. */ if (strcmp(optarg, "update_devlinksdb") == 0) { update_database = TRUE; } else if (strcmp(optarg, "no_dev") == 0) { /* don't build /dev */ build_dev = FALSE; } else if (strcmp(optarg, "no_devices") == 0) { /* don't build /devices */ build_devices = FALSE; } else if (strcmp(optarg, "no_p2i") == 0) { /* don't flush path_to_inst */ flush_path_to_inst_enable = FALSE; } else if (strcmp(optarg, "use_dicache") == 0) { use_snapshot_cache = TRUE; } else { usage(); } break; default: usage(); break; } } if (optind < argc) { usage(); } /* * We're not in zone mode; Check to see if the rootpath * collides with any zonepaths. */ if (zonename == NULL) { if (zone_pathcheck(root_dir) != DEVFSADM_SUCCESS) devfsadm_exit(1); /*NOTREACHED*/ } if (init_drvconf || init_perm || init_sysavail) { /* * Load minor perm before force-loading drivers * so the correct permissions are picked up. */ if (init_perm) { check_reconfig_state(); load_dev_acl(); } if (init_drvconf) update_drvconf((major_t)-1, 0); if (init_sysavail) modctl_sysavail(); devfsadm_exit(0); /*NOTREACHED*/ } } if (get_linkcompat_opts == TRUE) { build_devices = FALSE; load_attach_drv = FALSE; num_classes++; classes = s_realloc(classes, num_classes * sizeof (char *)); classes[num_classes - 1] = compat_class; while ((opt = getopt(argc, argv, "Cnr:svV:")) != EOF) { switch (opt) { case 'C': cleanup = TRUE; break; case 'n': /* prevent driver loading or deferred attach */ load_attach_drv = FALSE; break; case 'r': set_root_devices_dev_dir(optarg); if (zone_pathcheck(root_dir) != DEVFSADM_SUCCESS) devfsadm_exit(1); /*NOTREACHED*/ break; case 's': /* suppress. don't create/remove links/nodes */ /* useful with -v or -V */ file_mods = FALSE; flush_path_to_inst_enable = FALSE; break; case 'v': /* documented verbose flag */ add_verbose_id(VERBOSE_MID); break; case 'V': /* undocumented for extra verbose levels */ add_verbose_id(optarg); break; default: usage(); } } if (optind < argc) { usage(); } } set_lock_root(); } void usage(void) { if (strcmp(prog, DEVLINKS) == 0) { err_print(DEVLINKS_USAGE); } else if (strcmp(prog, DRVCONFIG) == 0) { err_print(DRVCONFIG_USAGE); } else if ((strcmp(prog, DEVFSADM) == 0) || (strcmp(prog, DEVFSADMD) == 0)) { err_print(DEVFSADM_USAGE); } else { err_print(COMPAT_LINK_USAGE); } devfsadm_exit(1); /*NOTREACHED*/ } static void devi_tree_walk(struct dca_impl *dcip, int flags, char *ev_subclass) { char *msg, *name; struct mlist mlist = {0}; di_node_t node; vprint(CHATTY_MID, "devi_tree_walk: root=%s, minor=%s, driver=%s," " error=%d, flags=%u\n", dcip->dci_root, dcip->dci_minor ? dcip->dci_minor : "", dcip->dci_driver ? dcip->dci_driver : "", dcip->dci_error, dcip->dci_flags); assert(dcip->dci_root); if (dcip->dci_flags & DCA_LOAD_DRV) { node = di_init_driver(dcip->dci_driver, flags); msg = DRIVER_FAILURE; name = dcip->dci_driver; } else { node = di_init(dcip->dci_root, flags); msg = DI_INIT_FAILED; name = dcip->dci_root; } if (node == DI_NODE_NIL) { dcip->dci_error = errno; /* * Rapid hotplugging (commonly seen during USB testing), * may remove a device before the create event for it * has been processed. To prevent alarming users with * a superfluous message, we suppress error messages * for ENXIO and hotplug. */ if (!(errno == ENXIO && (dcip->dci_flags & DCA_HOT_PLUG))) err_print(msg, name, strerror(dcip->dci_error)); return; } if (dcip->dci_flags & DCA_FLUSH_PATHINST) flush_path_to_inst(); dcip->dci_arg = &mlist; devi_root_node = node; /* protected by lock_dev() */ vprint(CHATTY_MID, "walking device tree\n"); (void) di_walk_minor(node, NULL, DI_CHECK_ALIAS, dcip, check_minor_type); process_deferred_links(dcip, DCA_CREATE_LINK); dcip->dci_arg = NULL; /* * Finished creating devfs files and dev links. * Log sysevent. */ if (ev_subclass) build_and_enq_event(EC_DEV_ADD, ev_subclass, dcip->dci_root, node, dcip->dci_minor); /* Add new device to device allocation database */ if (system_labeled && update_devdb) { _update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir); update_devdb = 0; } devi_root_node = DI_NODE_NIL; /* protected by lock_dev() */ di_fini(node); } static void process_deferred_links(struct dca_impl *dcip, int flags) { struct mlist *dep; struct minor *mp, *smp; vprint(CHATTY_MID, "processing deferred links\n"); dep = dcip->dci_arg; /* * The list head is not used during the deferred create phase */ dcip->dci_arg = NULL; assert(dep); assert((dep->head == NULL) ^ (dep->tail != NULL)); assert(flags == DCA_FREE_LIST || flags == DCA_CREATE_LINK); for (smp = NULL, mp = dep->head; mp; mp = mp->next) { if (flags == DCA_CREATE_LINK) (void) check_minor_type(mp->node, mp->minor, dcip); free(smp); smp = mp; } free(smp); } /* * Called in non-daemon mode to take a snap shot of the devinfo tree. * Then it calls the appropriate functions to build /devices and /dev. * It also flushes path_to_inst. * Except in the devfsadm -i (single driver case), the flags used by devfsadm * needs to match DI_CACHE_SNAPSHOT_FLAGS. That will make DINFOCACHE snapshot * updated. */ void process_devinfo_tree() { uint_t flags; struct dca_impl dci; char name[MAXNAMELEN]; char *fcn = "process_devinfo_tree: "; vprint(CHATTY_MID, "%senter\n", fcn); dca_impl_init("/", NULL, &dci); lock_dev(); /* * Update kernel driver.conf cache when devfsadm/drvconfig * is invoked to build /devices and /dev. */ if (update_all_drivers || load_attach_drv) { update_drvconf((major_t)-1, update_all_drivers ? MOD_LOADDRVCONF_RECONF : 0); } if (single_drv == TRUE) { /* * load a single driver, but walk the entire devinfo tree */ if (load_attach_drv == FALSE) err_print(DRV_LOAD_REQD); vprint(CHATTY_MID, "%sattaching driver (%s)\n", fcn, driver); dci.dci_flags |= DCA_LOAD_DRV; (void) snprintf(name, sizeof (name), "%s", driver); dci.dci_driver = name; flags = DINFOCPYALL | DINFOPATH; } else if (load_attach_drv == TRUE) { /* * Load and attach all drivers, then walk the entire tree. * If the cache flag is set, use DINFOCACHE to get cached * data. */ if (use_snapshot_cache == TRUE) { flags = DINFOCACHE; vprint(CHATTY_MID, "%susing snapshot cache\n", fcn); } else { vprint(CHATTY_MID, "%sattaching all drivers\n", fcn); flags = DI_CACHE_SNAPSHOT_FLAGS; if (cleanup) { /* * remove dangling entries from /etc/devices * files. */ flags |= DINFOCLEANUP; } } } else { /* * For devlinks, disks, ports, tapes and devfsadm -n, * just need to take a snapshot with active devices. */ vprint(CHATTY_MID, "%staking snapshot of active devices\n", fcn); flags = DINFOCPYALL; } if (((load_attach_drv == TRUE) || (single_drv == TRUE)) && (build_devices == TRUE)) { dci.dci_flags |= DCA_FLUSH_PATHINST; } /* handle pre-cleanup operations desired by the modules. */ pre_and_post_cleanup(RM_PRE); devi_tree_walk(&dci, flags, NULL); if (dci.dci_error) { devfsadm_exit(1); /*NOTREACHED*/ } /* handle post-cleanup operations desired by the modules. */ pre_and_post_cleanup(RM_POST); unlock_dev(SYNC_STATE); } /*ARGSUSED*/ static void print_cache_signal(int signo) { if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) { err_print("signal SIGUSR1 failed: %s\n", strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } } static void revoke_lookup_door(void) { if (lookup_door_fd != -1) { if (door_revoke(lookup_door_fd) == -1) { err_print("door_revoke of %s failed - %s\n", lookup_door_path, strerror(errno)); } } } /*ARGSUSED*/ static void catch_exit(int signo) { revoke_lookup_door(); } /* * Register with eventd for messages. Create doors for synchronous * link creation. */ static void daemon_update(void) { int fd; char *fcn = "daemon_update: "; char door_file[MAXPATHLEN]; const char *subclass_list; sysevent_handle_t *sysevent_hp; vprint(CHATTY_MID, "%senter\n", fcn); if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) { err_print("signal SIGUSR1 failed: %s\n", strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } if (signal(SIGTERM, catch_exit) == SIG_ERR) { err_print("signal SIGTERM failed: %s\n", strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } if (snprintf(door_file, sizeof (door_file), "%s%s", attr_root ? attr_root : root_dir, DEVFSADM_SERVICE_DOOR) >= sizeof (door_file)) { err_print("update_daemon failed to open sysevent service " "door\n"); devfsadm_exit(1); /*NOTREACHED*/ } if ((sysevent_hp = sysevent_open_channel_alt( door_file)) == NULL) { err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } if (sysevent_bind_subscriber(sysevent_hp, event_handler) != 0) { err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); (void) sysevent_close_channel(sysevent_hp); devfsadm_exit(1); /*NOTREACHED*/ } subclass_list = EC_SUB_ALL; if (sysevent_register_event(sysevent_hp, EC_ALL, &subclass_list, 1) != 0) { err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); (void) sysevent_unbind_subscriber(sysevent_hp); (void) sysevent_close_channel(sysevent_hp); devfsadm_exit(1); /*NOTREACHED*/ } if (snprintf(door_file, sizeof (door_file), "%s/%s", etc_dev_dir, DEVFSADM_SYNCH_DOOR) >= sizeof (door_file)) { err_print(CANT_CREATE_DOOR, DEVFSADM_SYNCH_DOOR, strerror(ENAMETOOLONG)); devfsadm_exit(1); /*NOTREACHED*/ } (void) s_unlink(door_file); if ((fd = open(door_file, O_RDWR | O_CREAT, SYNCH_DOOR_PERMS)) == -1) { err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } (void) close(fd); if ((fd = door_create(sync_handler, NULL, DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) { err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); (void) s_unlink(door_file); devfsadm_exit(1); /*NOTREACHED*/ } if (fattach(fd, door_file) == -1) { err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); (void) s_unlink(door_file); devfsadm_exit(1); /*NOTREACHED*/ } /* * devname_lookup_door */ if (snprintf(door_file, sizeof (door_file), "%s/%s", etc_dev_dir, DEVNAME_LOOKUP_DOOR) >= sizeof (door_file)) { err_print(CANT_CREATE_DOOR, DEVNAME_LOOKUP_DOOR, strerror(ENAMETOOLONG)); devfsadm_exit(1); /*NOTREACHED*/ } (void) s_unlink(door_file); if ((fd = open(door_file, O_RDWR | O_CREAT, S_IRUSR|S_IWUSR)) == -1) { err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } (void) close(fd); if ((fd = door_create(devname_lookup_handler, NULL, DOOR_REFUSE_DESC)) == -1) { err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); (void) s_unlink(door_file); devfsadm_exit(1); /*NOTREACHED*/ } (void) fdetach(door_file); lookup_door_path = s_strdup(door_file); retry: if (fattach(fd, door_file) == -1) { if (errno == EBUSY) goto retry; err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); (void) s_unlink(door_file); devfsadm_exit(1); /*NOTREACHED*/ } lookup_door_fd = fd; /* pass down the door name to kernel for door_ki_open */ if (devname_kcall(MODDEVNAME_LOOKUPDOOR, (void *)door_file) != 0) err_print(DEVNAME_CONTACT_FAILED, strerror(errno)); vprint(CHATTY_MID, "%spausing\n", fcn); for (;;) { (void) pause(); } } /*ARGSUSED*/ static void sync_handler(void *cookie, char *ap, size_t asize, door_desc_t *dp, uint_t ndesc) { door_cred_t dcred; struct dca_off *dcp, rdca; struct dca_impl dci; /* * Must be root to make this call * If caller is not root, don't touch its data. */ if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) { dcp = ⤷ dcp->dca_error = EPERM; goto out; } assert(ap); assert(asize == sizeof (*dcp)); dcp = (void *)ap; /* * Root is always present and is the first component of "name" member */ assert(dcp->dca_root == 0); /* * The structure passed in by the door_client uses offsets * instead of pointers to work across address space boundaries. * Now copy the data into a structure (dca_impl) which uses * pointers. */ dci.dci_root = &dcp->dca_name[dcp->dca_root]; dci.dci_minor = dcp->dca_minor ? &dcp->dca_name[dcp->dca_minor] : NULL; dci.dci_driver = dcp->dca_driver ? &dcp->dca_name[dcp->dca_driver] : NULL; dci.dci_error = 0; dci.dci_flags = dcp->dca_flags | (dci.dci_driver ? DCA_LOAD_DRV : 0); dci.dci_arg = NULL; lock_dev(); devi_tree_walk(&dci, DINFOCPYALL, NULL); dcp->dca_error = dci.dci_error; if (dcp->dca_flags & DCA_DEVLINK_SYNC) unlock_dev(SYNC_STATE); else unlock_dev(CACHE_STATE); out: (void) door_return((char *)dcp, sizeof (*dcp), NULL, 0); } static void lock_dev(void) { vprint(CHATTY_MID, "lock_dev(): entered\n"); if (build_dev == FALSE) return; /* lockout other threads from /dev */ while (sema_wait(&dev_sema) != 0) ; /* * Lock out other devfsadm processes from /dev. * If this wasn't the last process to run, * clear caches */ if (enter_dev_lock() != getpid()) { invalidate_enumerate_cache(); rm_all_links_from_cache(); (void) di_devlink_close(&devlink_cache, DI_LINK_ERROR); /* send any sysevents that were queued up. */ process_syseventq(); } /* * (re)load the reverse links database if not * already cached. */ if (devlink_cache == NULL) devlink_cache = di_devlink_open(root_dir, 0); /* * If modules were unloaded, reload them. Also use module status * as an indication that we should check to see if other binding * files need to be reloaded. */ if (module_head == NULL) { load_modules(); read_minor_perm_file(); read_driver_aliases_file(); read_devlinktab_file(); read_logindevperm_file(); read_enumerate_file(); } if (module_head != NULL) return; if (strcmp(prog, DEVLINKS) == 0) { if (devlinktab_list == NULL) { err_print(NO_LINKTAB, devlinktab_file); err_print(NO_MODULES, module_dirs); err_print(ABORTING); devfsadm_exit(1); /*NOTREACHED*/ } } else { err_print(NO_MODULES, module_dirs); if (strcmp(prog, DEVFSADM) == 0) { err_print(MODIFY_PATH); } } } /* * Unlock the device. If we are processing a CACHE_STATE call, we signal a * minor_fini_thread delayed SYNC_STATE at the end of the call. If we are * processing a SYNC_STATE call, we cancel any minor_fini_thread SYNC_STATE * at both the start and end of the call since we will be doing the SYNC_STATE. */ static void unlock_dev(int flag) { assert(flag == SYNC_STATE || flag == CACHE_STATE); vprint(CHATTY_MID, "unlock_dev(): entered\n"); /* If we are starting a SYNC_STATE, cancel minor_fini_thread SYNC */ if (flag == SYNC_STATE) { (void) mutex_lock(&minor_fini_mutex); minor_fini_canceled = TRUE; minor_fini_delayed = FALSE; (void) mutex_unlock(&minor_fini_mutex); } if (build_dev == FALSE) return; if (devlink_cache == NULL) { err_print(NO_DEVLINK_CACHE); } assert(devlink_cache); if (flag == SYNC_STATE) { unload_modules(); if (update_database) (void) di_devlink_update(devlink_cache); (void) di_devlink_close(&devlink_cache, 0); /* * now that the devlinks db cache has been flushed, it is safe * to send any sysevents that were queued up. */ process_syseventq(); } exit_dev_lock(0); (void) mutex_lock(&minor_fini_mutex); if (flag == SYNC_STATE) { /* We did a SYNC_STATE, cancel minor_fini_thread SYNC */ minor_fini_canceled = TRUE; minor_fini_delayed = FALSE; } else { /* We did a CACHE_STATE, start delayed minor_fini_thread SYNC */ minor_fini_canceled = FALSE; minor_fini_delayed = TRUE; (void) cond_signal(&minor_fini_cv); } (void) mutex_unlock(&minor_fini_mutex); (void) sema_post(&dev_sema); } /* * Check that if -r is set, it is not any part of a zone--- that is, that * the zonepath is not a substring of the root path. */ static int zone_pathcheck(char *checkpath) { void *dlhdl = NULL; char *name; char root[MAXPATHLEN]; /* resolved devfsadm root path */ char zroot[MAXPATHLEN]; /* zone root path */ char rzroot[MAXPATHLEN]; /* resolved zone root path */ char tmp[MAXPATHLEN]; FILE *cookie; int err = DEVFSADM_SUCCESS; if (checkpath[0] == '\0') return (DEVFSADM_SUCCESS); /* * Check if zones is available on this system. */ if ((dlhdl = dlopen(LIBZONECFG_PATH, RTLD_LAZY)) == NULL) { return (DEVFSADM_SUCCESS); } bzero(root, sizeof (root)); if (resolvepath(checkpath, root, sizeof (root) - 1) == -1) { /* * In this case the user has done "devfsadm -r" on some path * which does not yet exist, or we got some other misc. error. * We punt and don't resolve the path in this case. */ (void) strlcpy(root, checkpath, sizeof (root)); } if (strlen(root) > 0 && (root[strlen(root) - 1] != '/')) { (void) snprintf(tmp, sizeof (tmp), "%s/", root); (void) strlcpy(root, tmp, sizeof (root)); } cookie = setzoneent(); while ((name = getzoneent(cookie)) != NULL) { /* Skip the global zone */ if (strcmp(name, GLOBAL_ZONENAME) == 0) { free(name); continue; } if (zone_get_zonepath(name, zroot, sizeof (zroot)) != Z_OK) { free(name); continue; } bzero(rzroot, sizeof (rzroot)); if (resolvepath(zroot, rzroot, sizeof (rzroot) - 1) == -1) { /* * Zone path doesn't exist, or other misc error, * so we try using the non-resolved pathname. */ (void) strlcpy(rzroot, zroot, sizeof (rzroot)); } if (strlen(rzroot) > 0 && (rzroot[strlen(rzroot) - 1] != '/')) { (void) snprintf(tmp, sizeof (tmp), "%s/", rzroot); (void) strlcpy(rzroot, tmp, sizeof (rzroot)); } /* * Finally, the comparison. If the zone root path is a * leading substring of the root path, fail. */ if (strncmp(rzroot, root, strlen(rzroot)) == 0) { err_print(ZONE_PATHCHECK, root, name); err = DEVFSADM_FAILURE; free(name); break; } free(name); } endzoneent(cookie); (void) dlclose(dlhdl); return (err); } /* * Called by the daemon when it receives an event from the devfsadm SLM * to syseventd. * * The devfsadm SLM uses a private event channel for communication to * devfsadmd set-up via private libsysevent interfaces. This handler is * used to bind to the devfsadmd channel for event delivery. * The devfsadmd SLM insures single calls to this routine as well as * synchronized event delivery. * */ static void event_handler(sysevent_t *ev) { char *path; char *minor; char *subclass; char *dev_ev_subclass; char *driver_name; nvlist_t *attr_list = NULL; int err = 0; int instance; int branch_event = 0; /* * If this is event-driven, then we cannot trust the static devlist * to be correct. */ event_driven = TRUE; subclass = sysevent_get_subclass_name(ev); vprint(EVENT_MID, "event_handler: %s id:0X%llx\n", subclass, sysevent_get_seq(ev)); if (strcmp(subclass, ESC_DEVFS_START) == 0) { return; } /* Check if event is an instance modification */ if (strcmp(subclass, ESC_DEVFS_INSTANCE_MOD) == 0) { devfs_instance_mod(); return; } if (sysevent_get_attr_list(ev, &attr_list) != 0) { vprint(EVENT_MID, "event_handler: can not get attr list\n"); return; } if (strcmp(subclass, ESC_DEVFS_DEVI_ADD) == 0 || strcmp(subclass, ESC_DEVFS_DEVI_REMOVE) == 0 || strcmp(subclass, ESC_DEVFS_MINOR_CREATE) == 0 || strcmp(subclass, ESC_DEVFS_MINOR_REMOVE) == 0) { if ((err = nvlist_lookup_string(attr_list, DEVFS_PATHNAME, &path)) != 0) goto out; if (nvlist_lookup_string(attr_list, DEVFS_DEVI_CLASS, &dev_ev_subclass) != 0) dev_ev_subclass = NULL; if (nvlist_lookup_string(attr_list, DEVFS_DRIVER_NAME, &driver_name) != 0) driver_name = NULL; if (nvlist_lookup_int32(attr_list, DEVFS_INSTANCE, &instance) != 0) instance = -1; if (nvlist_lookup_int32(attr_list, DEVFS_BRANCH_EVENT, &branch_event) != 0) branch_event = 0; if (nvlist_lookup_string(attr_list, DEVFS_MINOR_NAME, &minor) != 0) minor = NULL; lock_dev(); if (strcmp(ESC_DEVFS_DEVI_ADD, subclass) == 0) { add_minor_pathname(path, NULL, dev_ev_subclass); if (branch_event) { build_and_enq_event(EC_DEV_BRANCH, ESC_DEV_BRANCH_ADD, path, DI_NODE_NIL, NULL); } } else if (strcmp(ESC_DEVFS_MINOR_CREATE, subclass) == 0) { add_minor_pathname(path, minor, dev_ev_subclass); } else if (strcmp(ESC_DEVFS_MINOR_REMOVE, subclass) == 0) { hot_cleanup(path, minor, dev_ev_subclass, driver_name, instance); } else { /* ESC_DEVFS_DEVI_REMOVE */ hot_cleanup(path, NULL, dev_ev_subclass, driver_name, instance); if (branch_event) { build_and_enq_event(EC_DEV_BRANCH, ESC_DEV_BRANCH_REMOVE, path, DI_NODE_NIL, NULL); } } unlock_dev(CACHE_STATE); } else if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0 || strcmp(subclass, ESC_DEVFS_BRANCH_REMOVE) == 0) { if ((err = nvlist_lookup_string(attr_list, DEVFS_PATHNAME, &path)) != 0) goto out; /* just log ESC_DEV_BRANCH... event */ if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0) dev_ev_subclass = ESC_DEV_BRANCH_ADD; else dev_ev_subclass = ESC_DEV_BRANCH_REMOVE; lock_dev(); build_and_enq_event(EC_DEV_BRANCH, dev_ev_subclass, path, DI_NODE_NIL, NULL); unlock_dev(CACHE_STATE); } else err_print(UNKNOWN_EVENT, subclass); out: if (err) err_print(EVENT_ATTR_LOOKUP_FAILED, strerror(err)); nvlist_free(attr_list); } static void dca_impl_init(char *root, char *minor, struct dca_impl *dcip) { assert(root); dcip->dci_root = root; dcip->dci_minor = minor; dcip->dci_driver = NULL; dcip->dci_error = 0; dcip->dci_flags = 0; dcip->dci_arg = NULL; } /* * Kernel logs a message when a devinfo node is attached. Try to create * /dev and /devices for each minor node. minorname can be NULL. */ void add_minor_pathname(char *node, char *minor, char *ev_subclass) { struct dca_impl dci; vprint(CHATTY_MID, "add_minor_pathname: node_path=%s minor=%s\n", node, minor ? minor : "NULL"); dca_impl_init(node, minor, &dci); /* * Restrict hotplug link creation if daemon * started with -i option. */ if (single_drv == TRUE) { dci.dci_driver = driver; } /* * We are being invoked in response to a hotplug event. */ dci.dci_flags = DCA_HOT_PLUG | DCA_CHECK_TYPE; devi_tree_walk(&dci, DINFOPROP|DINFOMINOR, ev_subclass); } static di_node_t find_clone_node() { static di_node_t clone_node = DI_NODE_NIL; if (clone_node == DI_NODE_NIL) clone_node = di_init("/pseudo/clone@0", DINFOPROP); return (clone_node); } static int is_descendent_of(di_node_t node, char *driver) { while (node != DI_NODE_NIL) { char *drv = di_driver_name(node); if (strcmp(drv, driver) == 0) return (1); node = di_parent_node(node); } return (0); } /* * Checks the minor type. If it is an alias node, then lookup * the real node/minor first, then call minor_process() to * do the real work. */ static int check_minor_type(di_node_t node, di_minor_t minor, void *arg) { ddi_minor_type minor_type; di_node_t clone_node; char *mn; char *nt; struct mlist *dep; struct dca_impl *dcip = arg; assert(dcip); dep = dcip->dci_arg; mn = di_minor_name(minor); /* * We match driver here instead of in minor_process * as we want the actual driver name. This check is * unnecessary during deferred processing. */ if (dep && ((dcip->dci_driver && !is_descendent_of(node, dcip->dci_driver)) || (dcip->dci_minor && strcmp(mn, dcip->dci_minor)))) { return (DI_WALK_CONTINUE); } if ((dcip->dci_flags & DCA_CHECK_TYPE) && (nt = di_minor_nodetype(minor)) && (strcmp(nt, DDI_NT_NET) == 0)) { dcip->dci_flags &= ~DCA_CHECK_TYPE; } minor_type = di_minor_type(minor); if (minor_type == DDM_MINOR) { minor_process(node, minor, dep); } else if (minor_type == DDM_ALIAS) { struct mlist *cdep, clone_del = {0}; clone_node = find_clone_node(); if (clone_node == DI_NODE_NIL) { err_print(DI_INIT_FAILED, "clone", strerror(errno)); return (DI_WALK_CONTINUE); } cdep = dep ? &clone_del : NULL; minor_process(clone_node, minor, cdep); /* * cache "alias" minor node and free "clone" minor */ if (cdep != NULL && cdep->head != NULL) { assert(cdep->tail != NULL); cache_deferred_minor(dep, node, minor); dcip->dci_arg = cdep; process_deferred_links(dcip, DCA_FREE_LIST); dcip->dci_arg = dep; } } return (DI_WALK_CONTINUE); } /* * This is the entry point for each minor node, whether walking * the entire tree via di_walk_minor() or processing a hotplug event * for a single devinfo node (via hotplug ndi_devi_online()). */ /*ARGSUSED*/ static void minor_process(di_node_t node, di_minor_t minor, struct mlist *dep) { create_list_t *create; int defer; vprint(CHATTY_MID, "minor_process: node=%s, minor=%s\n", di_node_name(node), di_minor_name(minor)); if (dep != NULL) { /* * Reset /devices node to minor_perm perm/ownership * if we are here to deactivate device allocation */ if (build_devices == TRUE) { reset_node_permissions(node, minor); } if (build_dev == FALSE) { return; } /* * This function will create any nodes for /etc/devlink.tab. * If devlink.tab handles link creation, we don't call any * devfsadm modules since that could cause duplicate caching * in the enumerate functions if different re strings are * passed that are logically identical. I'm still not * convinced this would cause any harm, but better to be safe. * * Deferred processing is available only for devlinks * created through devfsadm modules. */ if (process_devlink_compat(minor, node) == TRUE) { return; } } else { vprint(CHATTY_MID, "minor_process: deferred processing\n"); } /* * look for relevant link create rules in the modules, and * invoke the link create callback function to build a link * if there is a match. */ defer = 0; for (create = create_head; create != NULL; create = create->next) { if ((minor_matches_rule(node, minor, create) == TRUE) && class_ok(create->create->device_class) == DEVFSADM_SUCCESS) { if (call_minor_init(create->modptr) == DEVFSADM_FAILURE) { continue; } /* * If NOT doing the deferred creates (i.e. 1st pass) and * rule requests deferred processing cache the minor * data. * * If deferred processing (2nd pass), create links * ONLY if rule requests deferred processing. */ if (dep && ((create->create->flags & CREATE_MASK) == CREATE_DEFER)) { defer = 1; continue; } else if (dep == NULL && ((create->create->flags & CREATE_MASK) != CREATE_DEFER)) { continue; } if ((*(create->create->callback_fcn)) (minor, node) == DEVFSADM_TERMINATE) { break; } } } if (defer) cache_deferred_minor(dep, node, minor); } /* * Cache node and minor in defer list. */ static void cache_deferred_minor( struct mlist *dep, di_node_t node, di_minor_t minor) { struct minor *mp; const char *fcn = "cache_deferred_minor"; vprint(CHATTY_MID, "%s node=%s, minor=%s\n", fcn, di_node_name(node), di_minor_name(minor)); if (dep == NULL) { vprint(CHATTY_MID, "%s: cannot cache during " "deferred processing. Ignoring minor\n", fcn); return; } mp = (struct minor *)s_zalloc(sizeof (struct minor)); mp->node = node; mp->minor = minor; mp->next = NULL; assert(dep->head == NULL || dep->tail != NULL); if (dep->head == NULL) { dep->head = mp; } else { dep->tail->next = mp; } dep->tail = mp; } /* * Check to see if "create" link creation rule matches this node/minor. * If it does, return TRUE. */ static int minor_matches_rule(di_node_t node, di_minor_t minor, create_list_t *create) { char *m_nodetype, *m_drvname; if (create->create->node_type != NULL) { m_nodetype = di_minor_nodetype(minor); assert(m_nodetype != NULL); switch (create->create->flags & TYPE_MASK) { case TYPE_EXACT: if (strcmp(create->create->node_type, m_nodetype) != 0) { return (FALSE); } break; case TYPE_PARTIAL: if (strncmp(create->create->node_type, m_nodetype, strlen(create->create->node_type)) != 0) { return (FALSE); } break; case TYPE_RE: if (regexec(&(create->node_type_comp), m_nodetype, 0, NULL, 0) != 0) { return (FALSE); } break; } } if (create->create->drv_name != NULL) { m_drvname = di_driver_name(node); switch (create->create->flags & DRV_MASK) { case DRV_EXACT: if (strcmp(create->create->drv_name, m_drvname) != 0) { return (FALSE); } break; case DRV_RE: if (regexec(&(create->drv_name_comp), m_drvname, 0, NULL, 0) != 0) { return (FALSE); } break; } } return (TRUE); } /* * If no classes were given on the command line, then return DEVFSADM_SUCCESS. * Otherwise, return DEVFSADM_SUCCESS if the device "class" from the module * matches one of the device classes given on the command line, * otherwise, return DEVFSADM_FAILURE. */ static int class_ok(char *class) { int i; if (num_classes == 0) { return (DEVFSADM_SUCCESS); } /* * Some create tabs operate on multiple classes of devices because the * kernel doesn't have a good way for a driver to indicate that a * particular minor's class is different from that of the dev_info_t * it belongs to. As such, we'll always fail to match those here. */ if (class == NULL) { return (DEVFSADM_FAILURE); } for (i = 0; i < num_classes; i++) { if (strcmp(class, classes[i]) == 0) { return (DEVFSADM_SUCCESS); } } return (DEVFSADM_FAILURE); } /* * call minor_fini on active modules, then unload ALL modules */ static void unload_modules(void) { module_t *module_free; create_list_t *create_free; remove_list_t *remove_free; while (create_head != NULL) { create_free = create_head; create_head = create_head->next; if ((create_free->create->flags & TYPE_RE) == TYPE_RE) { regfree(&(create_free->node_type_comp)); } if ((create_free->create->flags & DRV_RE) == DRV_RE) { regfree(&(create_free->drv_name_comp)); } free(create_free); } while (remove_head != NULL) { remove_free = remove_head; remove_head = remove_head->next; free(remove_free); } while (module_head != NULL) { if ((module_head->minor_fini != NULL) && ((module_head->flags & MODULE_ACTIVE) == MODULE_ACTIVE)) { (void) (*(module_head->minor_fini))(); } vprint(MODLOAD_MID, "unloading module %s\n", module_head->name); free(module_head->name); (void) dlclose(module_head->dlhandle); module_free = module_head; module_head = module_head->next; free(module_free); } } /* * Load devfsadm logical link processing modules. */ static void load_modules(void) { DIR *mod_dir; struct dirent *entp; char cdir[PATH_MAX + 1]; char *last; char *mdir = module_dirs; char *fcn = "load_modules: "; while (*mdir != '\0') { while (*mdir == ':') { mdir++; } if (*mdir == '\0') { continue; } last = strchr(mdir, ':'); if (last == NULL) { last = mdir + strlen(mdir); } (void) strncpy(cdir, mdir, last - mdir); cdir[last - mdir] = '\0'; mdir += strlen(cdir); if ((mod_dir = opendir(cdir)) == NULL) { vprint(MODLOAD_MID, "%sopendir(%s): %s\n", fcn, cdir, strerror(errno)); continue; } while ((entp = readdir(mod_dir)) != NULL) { if ((strcmp(entp->d_name, ".") == 0) || (strcmp(entp->d_name, "..") == 0)) { continue; } load_module(entp->d_name, cdir); } s_closedir(mod_dir); } } static void load_module(char *mname, char *cdir) { _devfsadm_create_reg_t *create_reg; _devfsadm_remove_reg_V1_t *remove_reg; create_list_t *create_list_element; create_list_t **create_list_next; remove_list_t *remove_list_element; remove_list_t **remove_list_next; char epath[PATH_MAX + 1], *end; char *fcn = "load_module: "; char *dlerrstr; void *dlhandle; module_t *module; int flags; int n; int i; /* ignore any file which does not end in '.so' */ if ((end = strstr(mname, MODULE_SUFFIX)) != NULL) { if (end[strlen(MODULE_SUFFIX)] != '\0') { return; } } else { return; } (void) snprintf(epath, sizeof (epath), "%s/%s", cdir, mname); if ((dlhandle = dlopen(epath, RTLD_LAZY)) == NULL) { dlerrstr = dlerror(); err_print(DLOPEN_FAILED, epath, dlerrstr ? dlerrstr : "unknown error"); return; } /* dlsym the _devfsadm_create_reg structure */ if (NULL == (create_reg = (_devfsadm_create_reg_t *) dlsym(dlhandle, _DEVFSADM_CREATE_REG))) { vprint(MODLOAD_MID, "dlsym(%s, %s): symbol not found\n", epath, _DEVFSADM_CREATE_REG); } else { vprint(MODLOAD_MID, "%sdlsym(%s, %s) succeeded\n", fcn, epath, _DEVFSADM_CREATE_REG); } /* dlsym the _devfsadm_remove_reg structure */ if (NULL == (remove_reg = (_devfsadm_remove_reg_V1_t *) dlsym(dlhandle, _DEVFSADM_REMOVE_REG))) { vprint(MODLOAD_MID, "dlsym(%s,\n\t%s): symbol not found\n", epath, _DEVFSADM_REMOVE_REG); } else { vprint(MODLOAD_MID, "dlsym(%s, %s): succeeded\n", epath, _DEVFSADM_REMOVE_REG); } vprint(MODLOAD_MID, "module %s loaded\n", epath); module = (module_t *)s_malloc(sizeof (module_t)); module->name = s_strdup(epath); module->dlhandle = dlhandle; /* dlsym other module functions, to be called later */ module->minor_fini = (int (*)())dlsym(dlhandle, MINOR_FINI); module->minor_init = (int (*)())dlsym(dlhandle, MINOR_INIT); module->flags = 0; /* * put a ptr to each struct devfsadm_create on "create_head" * list sorted in interpose_lvl. */ if (create_reg != NULL) { for (i = 0; i < create_reg->count; i++) { int flags = create_reg->tblp[i].flags; create_list_element = (create_list_t *) s_malloc(sizeof (create_list_t)); create_list_element->create = &(create_reg->tblp[i]); create_list_element->modptr = module; if (((flags & CREATE_MASK) != 0) && ((flags & CREATE_MASK) != CREATE_DEFER)) { free(create_list_element); err_print("illegal flag combination in " "module create\n"); err_print(IGNORING_ENTRY, i, epath); continue; } if (((flags & TYPE_MASK) == 0) ^ (create_reg->tblp[i].node_type == NULL)) { free(create_list_element); err_print("flags value incompatible with " "node_type value in module create\n"); err_print(IGNORING_ENTRY, i, epath); continue; } if (((flags & TYPE_MASK) != 0) && ((flags & TYPE_MASK) != TYPE_EXACT) && ((flags & TYPE_MASK) != TYPE_RE) && ((flags & TYPE_MASK) != TYPE_PARTIAL)) { free(create_list_element); err_print("illegal TYPE_* flag combination in " "module create\n"); err_print(IGNORING_ENTRY, i, epath); continue; } /* precompile regular expression for efficiency */ if ((flags & TYPE_RE) == TYPE_RE) { if ((n = regcomp(&(create_list_element-> node_type_comp), create_reg->tblp[i].node_type, REG_EXTENDED)) != 0) { free(create_list_element); err_print(REGCOMP_FAILED, create_reg->tblp[i].node_type, n); err_print(IGNORING_ENTRY, i, epath); continue; } } if (((flags & DRV_MASK) == 0) ^ (create_reg->tblp[i].drv_name == NULL)) { if ((flags & TYPE_RE) == TYPE_RE) { regfree(&(create_list_element-> node_type_comp)); } free(create_list_element); err_print("flags value incompatible with " "drv_name value in module create\n"); err_print(IGNORING_ENTRY, i, epath); continue; } if (((flags & DRV_MASK) != 0) && ((flags & DRV_MASK) != DRV_EXACT) && ((flags & DRV_MASK) != DRV_RE)) { if ((flags & TYPE_RE) == TYPE_RE) { regfree(&(create_list_element-> node_type_comp)); } free(create_list_element); err_print("illegal DRV_* flag combination in " "module create\n"); err_print(IGNORING_ENTRY, i, epath); continue; } /* precompile regular expression for efficiency */ if ((create_reg->tblp[i].flags & DRV_RE) == DRV_RE) { if ((n = regcomp(&(create_list_element-> drv_name_comp), create_reg->tblp[i].drv_name, REG_EXTENDED)) != 0) { if ((flags & TYPE_RE) == TYPE_RE) { regfree(&(create_list_element-> node_type_comp)); } free(create_list_element); err_print(REGCOMP_FAILED, create_reg->tblp[i].drv_name, n); err_print(IGNORING_ENTRY, i, epath); continue; } } /* add to list sorted by interpose level */ for (create_list_next = &(create_head); (*create_list_next != NULL) && (*create_list_next)->create->interpose_lvl >= create_list_element->create->interpose_lvl; create_list_next = &((*create_list_next)->next)) ; create_list_element->next = *create_list_next; *create_list_next = create_list_element; } } /* * put a ptr to each struct devfsadm_remove on "remove_head" * list sorted by interpose_lvl. */ flags = 0; if (remove_reg != NULL) { if (remove_reg->version < DEVFSADM_V1) flags |= RM_NOINTERPOSE; for (i = 0; i < remove_reg->count; i++) { remove_list_element = (remove_list_t *) s_malloc(sizeof (remove_list_t)); remove_list_element->remove = &(remove_reg->tblp[i]); remove_list_element->remove->flags |= flags; remove_list_element->modptr = module; for (remove_list_next = &(remove_head); (*remove_list_next != NULL) && (*remove_list_next)->remove->interpose_lvl >= remove_list_element->remove->interpose_lvl; remove_list_next = &((*remove_list_next)->next)) ; remove_list_element->next = *remove_list_next; *remove_list_next = remove_list_element; } } module->next = module_head; module_head = module; } /* * After we have completed a CACHE_STATE, if a SYNC_STATE does not occur * within 'timeout' secs the minor_fini_thread needs to do a SYNC_STATE * so that we still call the minor_fini routines. */ static void * minor_fini_thread(void *arg __unused) { timestruc_t abstime; vprint(INITFINI_MID, "minor_fini_thread starting\n"); (void) mutex_lock(&minor_fini_mutex); for (;;) { /* wait the gather period, or until signaled */ abstime.tv_sec = time(NULL) + minor_fini_timeout; abstime.tv_nsec = 0; (void) cond_timedwait(&minor_fini_cv, &minor_fini_mutex, &abstime); /* if minor_fini was canceled, go wait again */ if (minor_fini_canceled == TRUE) continue; /* if minor_fini was delayed, go wait again */ if (minor_fini_delayed == TRUE) { minor_fini_delayed = FALSE; continue; } /* done with cancellations and delays, do the SYNC_STATE */ (void) mutex_unlock(&minor_fini_mutex); lock_dev(); unlock_dev(SYNC_STATE); vprint(INITFINI_MID, "minor_fini sync done\n"); (void) mutex_lock(&minor_fini_mutex); } return (NULL); } /* * Attempt to initialize module, if a minor_init routine exists. Set * the active flag if the routine exists and succeeds. If it doesn't * exist, just set the active flag. */ static int call_minor_init(module_t *module) { char *fcn = "call_minor_init: "; if ((module->flags & MODULE_ACTIVE) == MODULE_ACTIVE) { return (DEVFSADM_SUCCESS); } vprint(INITFINI_MID, "%smodule %s. current state: inactive\n", fcn, module->name); if (module->minor_init == NULL) { module->flags |= MODULE_ACTIVE; vprint(INITFINI_MID, "minor_init not defined\n"); return (DEVFSADM_SUCCESS); } if ((*(module->minor_init))() == DEVFSADM_FAILURE) { err_print(FAILED_FOR_MODULE, MINOR_INIT, module->name); return (DEVFSADM_FAILURE); } vprint(INITFINI_MID, "minor_init() returns DEVFSADM_SUCCESS. " "new state: active\n"); module->flags |= MODULE_ACTIVE; return (DEVFSADM_SUCCESS); } /* * Creates a symlink 'link' to the physical path of node:minor. * Construct link contents, then call create_link_common(). */ /*ARGSUSED*/ int devfsadm_mklink(char *link, di_node_t node, di_minor_t minor, int flags) { char rcontents[PATH_MAX]; char devlink[PATH_MAX]; char phy_path[PATH_MAX]; char *acontents; char *dev_path; int numslashes; int rv; int i, link_exists; int last_was_slash = FALSE; /* * try to use devices path */ if ((node == lnode) && (minor == lminor)) { acontents = lphy_path; } else if (di_minor_type(minor) == DDM_ALIAS) { /* use /pseudo/clone@0: as the phys path */ (void) snprintf(phy_path, sizeof (phy_path), "/pseudo/clone@0:%s", di_driver_name(di_minor_devinfo(minor))); acontents = phy_path; } else { if ((dev_path = di_devfs_path(node)) == NULL) { err_print(DI_DEVFS_PATH_FAILED, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } (void) snprintf(phy_path, sizeof (phy_path), "%s:%s", dev_path, di_minor_name(minor)); di_devfs_path_free(dev_path); acontents = phy_path; } /* prepend link with dev_dir contents */ (void) strlcpy(devlink, dev_dir, sizeof (devlink)); (void) strlcat(devlink, "/", sizeof (devlink)); (void) strlcat(devlink, link, sizeof (devlink)); /* * Calculate # of ../ to add. Account for double '//' in path. * Ignore all leading slashes. */ for (i = 0; link[i] == '/'; i++) ; for (numslashes = 0; link[i] != '\0'; i++) { if (link[i] == '/') { if (last_was_slash == FALSE) { numslashes++; last_was_slash = TRUE; } } else { last_was_slash = FALSE; } } /* Don't count any trailing '/' */ if (link[i-1] == '/') { numslashes--; } rcontents[0] = '\0'; do { (void) strlcat(rcontents, "../", sizeof (rcontents)); } while (numslashes-- != 0); (void) strlcat(rcontents, "devices", sizeof (rcontents)); (void) strlcat(rcontents, acontents, sizeof (rcontents)); if (devlinks_debug == TRUE) { vprint(INFO_MID, "adding link %s ==> %s\n", devlink, rcontents); } if ((rv = create_link_common(devlink, rcontents, &link_exists)) == DEVFSADM_SUCCESS) { linknew = TRUE; add_link_to_cache(link, acontents); } else { linknew = FALSE; } if (link_exists == TRUE) { /* Link exists or was just created */ (void) di_devlink_add_link(devlink_cache, link, rcontents, DI_PRIMARY_LINK); if (system_labeled && (flags & DA_ADD)) { /* * Add this to the list of allocatable devices. If this * is a hotplugged, removable disk, add it as rmdisk. */ int instance = di_instance(node); if ((flags & DA_CD) && (_da_check_for_usb(devlink, root_dir) == 1)) { (void) da_add_list(&devlist, devlink, instance, DA_ADD|DA_RMDISK); update_devdb = DA_RMDISK; } else if (linknew == TRUE) { (void) da_add_list(&devlist, devlink, instance, flags); update_devdb = flags; } } } return (rv); } /* * Creates a symlink link to primary_link. Calculates relative * directory offsets, then calls link_common(). */ /*ARGSUSED*/ int devfsadm_secondary_link(char *link, char *primary_link, int flags) { char contents[PATH_MAX + 1]; char devlink[PATH_MAX + 1]; int rv, link_exists; char *fpath; char *tpath; char *op; /* prepend link with dev_dir contents */ (void) strcpy(devlink, dev_dir); (void) strcat(devlink, "/"); (void) strcat(devlink, link); /* * building extra link, so use first link as link contents, but first * make it relative. */ fpath = link; tpath = primary_link; op = contents; while (*fpath == *tpath && *fpath != '\0') { fpath++, tpath++; } /* Count directories to go up, if any, and add "../" */ while (*fpath != '\0') { if (*fpath == '/') { (void) strcpy(op, "../"); op += 3; } fpath++; } /* * Back up to the start of the current path component, in * case in the middle */ while (tpath != primary_link && *(tpath-1) != '/') { tpath--; } (void) strcpy(op, tpath); if (devlinks_debug == TRUE) { vprint(INFO_MID, "adding extra link %s ==> %s\n", devlink, contents); } if ((rv = create_link_common(devlink, contents, &link_exists)) == DEVFSADM_SUCCESS) { /* * we need to save the ultimate /devices contents, and not the * secondary link, since hotcleanup only looks at /devices path. * Since we don't have devices path here, we can try to get it * by readlink'ing the secondary link. This assumes the primary * link was created first. */ add_link_to_cache(link, lphy_path); linknew = TRUE; if (system_labeled && ((flags & DA_AUDIO) && (flags & DA_ADD))) { /* * Add this device to the list of allocatable devices. */ int instance = 0; op = strrchr(contents, '/'); op++; (void) sscanf(op, "%d", &instance); (void) da_add_list(&devlist, devlink, instance, flags); update_devdb = flags; } } else { linknew = FALSE; } /* * If link exists or was just created, add it to the database */ if (link_exists == TRUE) { (void) di_devlink_add_link(devlink_cache, link, contents, DI_SECONDARY_LINK); } return (rv); } /* returns pointer to the devices directory */ char * devfsadm_get_devices_dir() { return (devices_dir); } /* * Does the actual link creation. VERBOSE_MID only used if there is * a change. CHATTY_MID used otherwise. */ static int create_link_common(char *devlink, char *contents, int *exists) { int try; int linksize; int max_tries = 0; static int prev_link_existed = TRUE; char checkcontents[PATH_MAX + 1]; char *hide; *exists = FALSE; /* Database is not updated when file_mods == FALSE */ if (file_mods == FALSE) { /* we want *actual* link contents so no alias redirection */ linksize = readlink(devlink, checkcontents, PATH_MAX); if (linksize > 0) { checkcontents[linksize] = '\0'; if (strcmp(checkcontents, contents) != 0) { vprint(CHATTY_MID, REMOVING_LINK, devlink, checkcontents); return (DEVFSADM_SUCCESS); } else { vprint(CHATTY_MID, "link exists and is correct:" " %s -> %s\n", devlink, contents); /* failure only in that the link existed */ return (DEVFSADM_FAILURE); } } else { vprint(VERBOSE_MID, CREATING_LINK, devlink, contents); return (DEVFSADM_SUCCESS); } } /* * systems calls are expensive, so predict whether to readlink * or symlink first, based on previous attempt */ if (prev_link_existed == FALSE) { try = CREATE_LINK; } else { try = READ_LINK; } while (++max_tries <= 3) { switch (try) { case CREATE_LINK: if (symlink(contents, devlink) == 0) { vprint(VERBOSE_MID, CREATING_LINK, devlink, contents); prev_link_existed = FALSE; /* link successfully created */ *exists = TRUE; set_logindev_perms(devlink); return (DEVFSADM_SUCCESS); } else { switch (errno) { case ENOENT: /* dirpath to node doesn't exist */ hide = strrchr(devlink, '/'); *hide = '\0'; s_mkdirp(devlink, S_IRWXU|S_IRGRP| S_IXGRP|S_IROTH|S_IXOTH); *hide = '/'; break; case EEXIST: try = READ_LINK; break; default: err_print(SYMLINK_FAILED, devlink, contents, strerror(errno)); return (DEVFSADM_FAILURE); } } break; case READ_LINK: /* * If there is redirection, new phys path * and old phys path will not match and the * link will be created with new phys path * which is what we want. So we want real * contents. */ linksize = readlink(devlink, checkcontents, PATH_MAX); if (linksize >= 0) { checkcontents[linksize] = '\0'; if (strcmp(checkcontents, contents) != 0) { s_unlink(devlink); vprint(VERBOSE_MID, REMOVING_LINK, devlink, checkcontents); try = CREATE_LINK; } else { prev_link_existed = TRUE; vprint(CHATTY_MID, "link exists and is correct:" " %s -> %s\n", devlink, contents); *exists = TRUE; /* failure in that the link existed */ return (DEVFSADM_FAILURE); } } else { switch (errno) { case EINVAL: /* not a symlink, remove and create */ s_unlink(devlink); /* FALLTHROUGH */ default: /* maybe it didn't exist at all */ try = CREATE_LINK; break; } } break; } } err_print(MAX_ATTEMPTS, devlink, contents); return (DEVFSADM_FAILURE); } static void set_logindev_perms(char *devlink) { struct login_dev *newdev; struct passwd pwd, *resp; char pwd_buf[PATH_MAX]; int rv; struct stat sb; char *devfs_path = NULL; /* * We only want logindev perms to be set when a device is * hotplugged or an application requests synchronous creates. * So we enable this only in daemon mode. In addition, * login(1) only fixes the std. /dev dir. So we don't * change perms if alternate root is set. * login_dev_enable is TRUE only in these cases. */ if (login_dev_enable != TRUE) return; /* * Normally, /etc/logindevperm has few (8 - 10 entries) which * may be regular expressions (globs were converted to RE). * So just do a linear search through the list. */ for (newdev = login_dev_cache; newdev; newdev = newdev->ldev_next) { vprint(FILES_MID, "matching %s with %s\n", devlink, newdev->ldev_device); if (regexec(&newdev->ldev_device_regex, devlink, 0, NULL, 0) == 0) { vprint(FILES_MID, "matched %s with %s\n", devlink, newdev->ldev_device); break; } } if (newdev == NULL) return; /* * we have a match, now find the driver associated with this * minor node using a snapshot on the physical path */ (void) resolve_link(devlink, NULL, NULL, &devfs_path, 0); /* * We dont need redirection here - the actual link contents * whether "alias" or "current" are fine */ if (devfs_path) { di_node_t node; char *drv; struct driver_list *list; char *p; /* truncate on : so we can take a snapshot */ (void) strcpy(pwd_buf, devfs_path); p = strrchr(pwd_buf, ':'); if (p == NULL) { free(devfs_path); return; } *p = '\0'; vprint(FILES_MID, "link=%s->physpath=%s\n", devlink, pwd_buf); node = di_init(pwd_buf, DINFOMINOR); drv = NULL; if (node) { drv = di_driver_name(node); if (drv) { vprint(FILES_MID, "%s: driver is %s\n", devlink, drv); } } /* search thru the driver list specified in logindevperm */ list = newdev->ldev_driver_list; if ((drv != NULL) && (list != NULL)) { while (list) { if (strcmp(list->driver_name, drv) == 0) { vprint(FILES_MID, "driver %s match!\n", drv); break; } list = list->next; } if (list == NULL) { vprint(FILES_MID, "no driver match!\n"); free(devfs_path); return; } } free(devfs_path); di_fini(node); } else { return; } vprint(FILES_MID, "changing permissions of %s\n", devlink); /* * We have a match. We now attempt to determine the * owner and group of the console user. * * stat() the console device newdev->ldev_console * which will always exist - it will have the right owner but * not the right group. Use getpwuid_r() to determine group for this * uid. * Note, it is safe to use name service here since if name services * are not available (during boot or in single-user mode), then * console owner will be root and its gid can be found in * local files. */ if (stat(newdev->ldev_console, &sb) == -1) { vprint(VERBOSE_MID, STAT_FAILED, newdev->ldev_console, strerror(errno)); return; } resp = NULL; rv = getpwuid_r(sb.st_uid, &pwd, pwd_buf, sizeof (pwd_buf), &resp); if (rv || resp == NULL) { rv = rv ? rv : EINVAL; vprint(VERBOSE_MID, GID_FAILED, sb.st_uid, strerror(rv)); return; } assert(&pwd == resp); sb.st_gid = resp->pw_gid; if (chmod(devlink, newdev->ldev_perms) == -1) { vprint(VERBOSE_MID, CHMOD_FAILED, devlink, strerror(errno)); return; } if (chown(devlink, sb.st_uid, sb.st_gid) == -1) { vprint(VERBOSE_MID, CHOWN_FAILED, devlink, strerror(errno)); } } /* * Reset /devices node with appropriate permissions and * ownership as specified in /etc/minor_perm. */ static void reset_node_permissions(di_node_t node, di_minor_t minor) { int spectype; char phy_path[PATH_MAX + 1]; mode_t mode; dev_t dev; uid_t uid; gid_t gid; struct stat sb; char *dev_path, *aminor = NULL; /* lphy_path starts with / */ if ((dev_path = di_devfs_path(node)) == NULL) { err_print(DI_DEVFS_PATH_FAILED, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } (void) strcpy(lphy_path, dev_path); di_devfs_path_free(dev_path); (void) strcat(lphy_path, ":"); if (di_minor_type(minor) == DDM_ALIAS) { char *driver; aminor = di_minor_name(minor); driver = di_driver_name(di_minor_devinfo(minor)); (void) strcat(lphy_path, driver); } else (void) strcat(lphy_path, di_minor_name(minor)); (void) strcpy(phy_path, devices_dir); (void) strcat(phy_path, lphy_path); lnode = node; lminor = minor; vprint(CHATTY_MID, "reset_node_permissions: phy_path=%s lphy_path=%s\n", phy_path, lphy_path); dev = di_minor_devt(minor); spectype = di_minor_spectype(minor); /* block or char */ getattr(phy_path, aminor, spectype, dev, &mode, &uid, &gid); /* * compare and set permissions and ownership * * Under devfs, a quick insertion and removal of USB devices * would cause stat of physical path to fail. In this case, * we emit a verbose message, but don't print errors. */ if ((stat(phy_path, &sb) == -1) || (sb.st_rdev != dev)) { vprint(VERBOSE_MID, NO_DEVFS_NODE, phy_path); return; } /* * If we are here for a new device * If device allocation is on * then * set ownership to root:other and permissions to 0000 * else * set ownership and permissions as specified in minor_perm * If we are here for an existing device * If device allocation is to be turned on * then * reset ownership to root:other and permissions to 0000 * else if device allocation is to be turned off * reset ownership and permissions to those specified in * minor_perm * else * preserve existing/user-modified ownership and * permissions * * devfs indicates a new device by faking access time to be zero. */ if (sb.st_atime != 0) { int i; char *nt; if ((devalloc_flag == 0) && (devalloc_is_on != 1)) /* * Leave existing devices as they are if we are not * turning device allocation on/off. */ return; nt = di_minor_nodetype(minor); if (nt == NULL) return; for (i = 0; devalloc_list[i]; i++) { if (strcmp(nt, devalloc_list[i]) == 0) /* * One of the types recognized by devalloc, * reset attrs. */ break; } if (devalloc_list[i] == NULL) return; } if (file_mods == FALSE) { /* Nothing more to do if simulating */ vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode); return; } if ((devalloc_flag == DA_ON) || ((devalloc_is_on == 1) && (devalloc_flag != DA_OFF))) { /* * we are here either to turn device allocation on or * to add a new device while device allocation is on * (and we've confirmed that we're not turning it * off). */ mode = DEALLOC_MODE; uid = DA_UID; gid = DA_GID; } if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) || (sb.st_mode != mode)) { if (chmod(phy_path, mode) == -1) vprint(VERBOSE_MID, CHMOD_FAILED, phy_path, strerror(errno)); } if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) || (sb.st_uid != uid || sb.st_gid != gid)) { if (chown(phy_path, uid, gid) == -1) vprint(VERBOSE_MID, CHOWN_FAILED, phy_path, strerror(errno)); } /* Report that we actually did something */ vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode); } /* * Removes logical link and the minor node it refers to. If file is a * link, we recurse and try to remove the minor node (or link if path is * a double link) that file's link contents refer to. */ static void devfsadm_rm_work(char *file, int recurse, int file_type) { char *fcn = "devfsadm_rm_work: "; int linksize; char contents[PATH_MAX + 1]; char nextfile[PATH_MAX + 1]; char newfile[PATH_MAX + 1]; char *ptr; vprint(REMOVE_MID, "%s%s\n", fcn, file); /* * Note: we don't remove /devices (non-links) entries because they are * covered by devfs. */ if (file_type != TYPE_LINK) { return; } /* split into multiple if's due to excessive indentations */ (void) strcpy(newfile, dev_dir); (void) strcat(newfile, "/"); (void) strcat(newfile, file); /* * we dont care about the content of the symlink, so * redirection is not needed. */ if ((recurse == TRUE) && ((linksize = readlink(newfile, contents, PATH_MAX)) > 0)) { contents[linksize] = '\0'; /* * recurse if link points to another link */ if (is_minor_node(contents, &ptr) != DEVFSADM_TRUE) { if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0) { devfsadm_rm_work(&contents[strlen(DEV) + 1], TRUE, TYPE_LINK); } else { if ((ptr = strrchr(file, '/')) != NULL) { *ptr = '\0'; (void) strcpy(nextfile, file); *ptr = '/'; (void) strcat(nextfile, "/"); } else { (void) strcpy(nextfile, ""); } (void) strcat(nextfile, contents); devfsadm_rm_work(nextfile, TRUE, TYPE_LINK); } } } vprint(VERBOSE_MID, DEVFSADM_UNLINK, newfile); if (file_mods == TRUE) { rm_link_from_cache(file); s_unlink(newfile); rm_parent_dir_if_empty(newfile); invalidate_enumerate_cache(); (void) di_devlink_rm_link(devlink_cache, file); } } void devfsadm_rm_link(char *file) { devfsadm_rm_work(file, FALSE, TYPE_LINK); } void devfsadm_rm_all(char *file) { devfsadm_rm_work(file, TRUE, TYPE_LINK); } static int s_rmdir(char *path) { int i; char *rpath, *dir; const char *fcn = "s_rmdir"; /* * Certain directories are created at install time by packages. * Some of them (listed in sticky_dirs[]) are required by apps * and need to be present even when empty. */ vprint(REMOVE_MID, "%s: checking if %s is sticky\n", fcn, path); rpath = path + strlen(dev_dir) + 1; for (i = 0; (dir = sticky_dirs[i]) != NULL; i++) { if (*rpath == *dir) { if (strcmp(rpath, dir) == 0) { vprint(REMOVE_MID, "%s: skipping sticky dir: " "%s\n", fcn, path); errno = EEXIST; return (-1); } } } return (rmdir(path)); } /* * Try to remove any empty directories up the tree. It is assumed that * pathname is a file that was removed, so start with its parent, and * work up the tree. */ static void rm_parent_dir_if_empty(char *pathname) { char *ptr, path[PATH_MAX + 1]; char *fcn = "rm_parent_dir_if_empty: "; vprint(REMOVE_MID, "%schecking %s if empty\n", fcn, pathname); (void) strcpy(path, pathname); /* * ascend up the dir tree, deleting all empty dirs. * Return immediately if a dir is not empty. */ for (;;) { if ((ptr = strrchr(path, '/')) == NULL) { return; } *ptr = '\0'; if (finddev_emptydir(path)) { /* directory is empty */ if (s_rmdir(path) == 0) { vprint(REMOVE_MID, "%sremoving empty dir %s\n", fcn, path); } else if (errno == EEXIST) { vprint(REMOVE_MID, "%sfailed to remove dir: %s\n", fcn, path); return; } } else { /* some other file is here, so return */ vprint(REMOVE_MID, "%sdir not empty: %s\n", fcn, path); return; } } } /* * This function and all the functions it calls below were added to * handle the unique problem with world wide names (WWN). The problem is * that if a WWN device is moved to another address on the same controller * its logical link will change, while the physical node remains the same. * The result is that two logical links will point to the same physical path * in /devices, the valid link and a stale link. This function will * find all the stale nodes, though at a significant performance cost. * * Caching is used to increase performance. * A cache will be built from disk if the cache tag doesn't already exist. * The cache tag is a regular expression "dir_re", which selects a * subset of disks to search from typically something like * "dev/cXt[0-9]+d[0-9]+s[0-9]+". After the cache is built, consistency must * be maintained, so entries are added as new links are created, and removed * as old links are deleted. The whole cache is flushed if we are a daemon, * and another devfsadm process ran in between. * * Once the cache is built, this function finds the cache which matches * dir_re, and then it searches all links in that cache looking for * any link whose contents match "valid_link_contents" with a corresponding link * which does not match "valid_link". Any such matches are stale and removed. * * This happens outside the context of a "reparenting" so we dont need * redirection. */ void devfsadm_rm_stale_links(char *dir_re, char *valid_link, di_node_t node, di_minor_t minor) { link_t *link; linkhead_t *head; char phy_path[PATH_MAX + 1]; char *valid_link_contents; char *dev_path; char rmlink[PATH_MAX + 1]; /* * try to use devices path */ if ((node == lnode) && (minor == lminor)) { valid_link_contents = lphy_path; } else { if ((dev_path = di_devfs_path(node)) == NULL) { err_print(DI_DEVFS_PATH_FAILED, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } (void) strcpy(phy_path, dev_path); di_devfs_path_free(dev_path); (void) strcat(phy_path, ":"); (void) strcat(phy_path, di_minor_name(minor)); valid_link_contents = phy_path; } /* * As an optimization, check to make sure the corresponding * devlink was just created before continuing. */ if (linknew == FALSE) { return; } head = get_cached_links(dir_re); assert(head->nextlink == NULL); for (link = head->link; link != NULL; link = head->nextlink) { /* * See hot_cleanup() for why we do this */ head->nextlink = link->next; if ((strcmp(link->contents, valid_link_contents) == 0) && (strcmp(link->devlink, valid_link) != 0)) { vprint(CHATTY_MID, "removing %s -> %s\n" "valid link is: %s -> %s\n", link->devlink, link->contents, valid_link, valid_link_contents); /* * Use a copy of the cached link name as the * cache entry will go away during link removal */ (void) snprintf(rmlink, sizeof (rmlink), "%s", link->devlink); devfsadm_rm_link(rmlink); } } } /* * Return previously created cache, or create cache. */ static linkhead_t * get_cached_links(char *dir_re) { recurse_dev_t rd; linkhead_t *linkhead; int n; vprint(BUILDCACHE_MID, "get_cached_links: %s\n", dir_re); for (linkhead = headlinkhead; linkhead != NULL; linkhead = linkhead->nexthead) { if (strcmp(linkhead->dir_re, dir_re) == 0) { return (linkhead); } } /* * This tag is not in cache, so add it, along with all its * matching /dev entries. This is the only time we go to disk. */ linkhead = s_malloc(sizeof (linkhead_t)); linkhead->nexthead = headlinkhead; headlinkhead = linkhead; linkhead->dir_re = s_strdup(dir_re); if ((n = regcomp(&(linkhead->dir_re_compiled), dir_re, REG_EXTENDED)) != 0) { err_print(REGCOMP_FAILED, dir_re, n); } linkhead->nextlink = NULL; linkhead->link = NULL; rd.fcn = build_devlink_list; rd.data = (void *)linkhead; vprint(BUILDCACHE_MID, "get_cached_links: calling recurse_dev_re\n"); /* call build_devlink_list for each directory in the dir_re RE */ if (dir_re[0] == '/') { recurse_dev_re("/", &dir_re[1], &rd); } else { recurse_dev_re(dev_dir, dir_re, &rd); } return (linkhead); } static void build_devlink_list(char *devlink, void *data) { char *fcn = "build_devlink_list: "; char *ptr; char *r_contents; char *r_devlink; char contents[PATH_MAX + 1]; char newlink[PATH_MAX + 1]; char stage_link[PATH_MAX + 1]; int linksize; linkhead_t *linkhead = (linkhead_t *)data; link_t *link; int i = 0; vprint(BUILDCACHE_MID, "%scheck_link: %s\n", fcn, devlink); (void) strcpy(newlink, devlink); do { /* * None of the consumers of this function need redirection * so this readlink gets the "current" contents */ linksize = readlink(newlink, contents, PATH_MAX); if (linksize <= 0) { /* * The first pass through the do loop we may readlink() * non-symlink files(EINVAL) from false regexec matches. * Suppress error messages in those cases or if the link * content is the empty string. */ if (linksize < 0 && (i || errno != EINVAL)) err_print(READLINK_FAILED, "build_devlink_list", newlink, strerror(errno)); return; } contents[linksize] = '\0'; i = 1; if (is_minor_node(contents, &r_contents) == DEVFSADM_FALSE) { /* * assume that link contents is really a pointer to * another link, so recurse and read its link contents. * * some link contents are absolute: * /dev/audio -> /dev/sound/0 */ if (strncmp(contents, DEV "/", strlen(DEV) + strlen("/")) != 0) { if ((ptr = strrchr(newlink, '/')) == NULL) { vprint(REMOVE_MID, "%s%s -> %s invalid " "link. missing '/'\n", fcn, newlink, contents); return; } *ptr = '\0'; (void) strcpy(stage_link, newlink); *ptr = '/'; (void) strcat(stage_link, "/"); (void) strcat(stage_link, contents); (void) strcpy(newlink, stage_link); } else { (void) strcpy(newlink, dev_dir); (void) strcat(newlink, "/"); (void) strcat(newlink, &contents[strlen(DEV) + strlen("/")]); } } else { newlink[0] = '\0'; } } while (newlink[0] != '\0'); if (strncmp(devlink, dev_dir, strlen(dev_dir)) != 0) { vprint(BUILDCACHE_MID, "%sinvalid link: %s\n", fcn, devlink); return; } r_devlink = devlink + strlen(dev_dir); if (r_devlink[0] != '/') return; link = s_malloc(sizeof (link_t)); /* don't store the '/' after rootdir/dev */ r_devlink += 1; vprint(BUILDCACHE_MID, "%scaching link: %s\n", fcn, r_devlink); link->devlink = s_strdup(r_devlink); link->contents = s_strdup(r_contents); link->next = linkhead->link; linkhead->link = link; } /* * to be consistent, devlink must not begin with / and must be * relative to /dev/, whereas physpath must contain / and be * relative to /devices. */ static void add_link_to_cache(char *devlink, char *physpath) { linkhead_t *linkhead; link_t *link; int added = 0; if (file_mods == FALSE) { return; } vprint(CACHE_MID, "add_link_to_cache: %s -> %s ", devlink, physpath); for (linkhead = headlinkhead; linkhead != NULL; linkhead = linkhead->nexthead) { if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0) == 0) { added++; link = s_malloc(sizeof (link_t)); link->devlink = s_strdup(devlink); link->contents = s_strdup(physpath); link->next = linkhead->link; linkhead->link = link; } } vprint(CACHE_MID, " %d %s\n", added, added == 0 ? "NOT ADDED" : "ADDED"); } /* * Remove devlink from cache. Devlink must be relative to /dev/ and not start * with /. */ static void rm_link_from_cache(char *devlink) { linkhead_t *linkhead; link_t **linkp; link_t *save; vprint(CACHE_MID, "rm_link_from_cache enter: %s\n", devlink); for (linkhead = headlinkhead; linkhead != NULL; linkhead = linkhead->nexthead) { if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0) == 0) { for (linkp = &(linkhead->link); *linkp != NULL; ) { if ((strcmp((*linkp)->devlink, devlink) == 0)) { save = *linkp; *linkp = (*linkp)->next; /* * We are removing our caller's * "next" link. Update the nextlink * field in the head so that our * callers accesses the next valid * link */ if (linkhead->nextlink == save) linkhead->nextlink = *linkp; free(save->devlink); free(save->contents); free(save); vprint(CACHE_MID, " %s FREED FROM " "CACHE\n", devlink); } else { linkp = &((*linkp)->next); } } } } } static void rm_all_links_from_cache() { linkhead_t *linkhead; linkhead_t *nextlinkhead; link_t *link; link_t *nextlink; vprint(CACHE_MID, "rm_all_links_from_cache\n"); for (linkhead = headlinkhead; linkhead != NULL; linkhead = nextlinkhead) { nextlinkhead = linkhead->nexthead; assert(linkhead->nextlink == NULL); for (link = linkhead->link; link != NULL; link = nextlink) { nextlink = link->next; free(link->devlink); free(link->contents); free(link); } regfree(&(linkhead->dir_re_compiled)); free(linkhead->dir_re); free(linkhead); } headlinkhead = NULL; } /* * Called when the kernel has modified the incore path_to_inst data. This * function will schedule a flush of the data to the filesystem. */ static void devfs_instance_mod(void) { char *fcn = "devfs_instance_mod: "; vprint(PATH2INST_MID, "%senter\n", fcn); /* signal instance thread */ (void) mutex_lock(&count_lock); inst_count++; (void) cond_signal(&cv); (void) mutex_unlock(&count_lock); } static void instance_flush_thread(void) { int i; int idle; for (;;) { (void) mutex_lock(&count_lock); while (inst_count == 0) { (void) cond_wait(&cv, &count_lock); } inst_count = 0; vprint(PATH2INST_MID, "signaled to flush path_to_inst." " Enter delay loop\n"); /* * Wait MAX_IDLE_DELAY seconds after getting the last flush * path_to_inst event before invoking a flush, but never wait * more than MAX_DELAY seconds after getting the first event. */ for (idle = 0, i = 0; i < MAX_DELAY; i++) { (void) mutex_unlock(&count_lock); (void) sleep(1); (void) mutex_lock(&count_lock); /* shorten the delay if we are idle */ if (inst_count == 0) { idle++; if (idle > MAX_IDLE_DELAY) { break; } } else { inst_count = idle = 0; } } (void) mutex_unlock(&count_lock); flush_path_to_inst(); } } /* * Helper function for flush_path_to_inst() below; this routine calls the * inst_sync syscall to flush the path_to_inst database to the given file. */ static int do_inst_sync(char *filename, char *instfilename) { void (*sigsaved)(int); int err = 0, flags = INST_SYNC_IF_REQUIRED; struct stat sb; if (stat(instfilename, &sb) == -1 && errno == ENOENT) flags = INST_SYNC_ALWAYS; vprint(INSTSYNC_MID, "do_inst_sync: about to flush %s\n", filename); sigsaved = sigset(SIGSYS, SIG_IGN); if (inst_sync(filename, flags) == -1) err = errno; (void) sigset(SIGSYS, sigsaved); switch (err) { case 0: return (DEVFSADM_SUCCESS); case EALREADY: /* no-op, path_to_inst already up to date */ return (EALREADY); case ENOSYS: err_print(CANT_LOAD_SYSCALL); break; case EPERM: err_print(SUPER_TO_SYNC); break; default: err_print(INSTSYNC_FAILED, filename, strerror(err)); break; } return (DEVFSADM_FAILURE); } /* * Flush the kernel's path_to_inst database to /etc/path_to_inst. To do so * safely, the database is flushed to a temporary file, then moved into place. * * The following files are used during this process: * /etc/path_to_inst: The path_to_inst file * /etc/path_to_inst.: Contains data flushed from the kernel * /etc/path_to_inst.old: The backup file * /etc/path_to_inst.old.: Temp file for creating backup * */ static void flush_path_to_inst(void) { char *new_inst_file = NULL; char *old_inst_file = NULL; char *old_inst_file_npid = NULL; FILE *inst_file_fp = NULL; FILE *old_inst_file_fp = NULL; struct stat sb; int err = 0; int c; int inst_strlen; vprint(PATH2INST_MID, "flush_path_to_inst: %s\n", (flush_path_to_inst_enable == TRUE) ? "ENABLED" : "DISABLED"); if (flush_path_to_inst_enable == FALSE) { return; } inst_strlen = strlen(inst_file); new_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 2); old_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 6); old_inst_file_npid = s_malloc(inst_strlen + sizeof (INSTANCE_FILE_SUFFIX)); (void) snprintf(new_inst_file, inst_strlen + PID_STR_LEN + 2, "%s.%ld", inst_file, getpid()); if (stat(new_inst_file, &sb) == 0) { s_unlink(new_inst_file); } err = do_inst_sync(new_inst_file, inst_file); if (err != DEVFSADM_SUCCESS) { goto out; /*NOTREACHED*/ } /* * Now we deal with the somewhat tricky updating and renaming * of this critical piece of kernel state. */ /* * Copy the current instance file into a temporary file. * Then rename the temporary file into the backup (.old) * file and rename the newly flushed kernel data into * the instance file. * Of course if 'inst_file' doesn't exist, there's much * less for us to do .. tee hee. */ if ((inst_file_fp = fopen(inst_file, "r")) == NULL) { /* * No such file. Rename the new onto the old */ if ((err = rename(new_inst_file, inst_file)) != 0) err_print(RENAME_FAILED, inst_file, strerror(errno)); goto out; /*NOTREACHED*/ } (void) snprintf(old_inst_file, inst_strlen + PID_STR_LEN + 6, "%s.old.%ld", inst_file, getpid()); if (stat(old_inst_file, &sb) == 0) { s_unlink(old_inst_file); } if ((old_inst_file_fp = fopen(old_inst_file, "w")) == NULL) { /* * Can't open the 'old_inst_file' file for writing. * This is somewhat strange given that the syscall * just succeeded to write a file out.. hmm.. maybe * the fs just filled up or something nasty. * * Anyway, abort what we've done so far. */ err_print(CANT_UPDATE, old_inst_file); err = DEVFSADM_FAILURE; goto out; /*NOTREACHED*/ } /* * Copy current instance file into the temporary file */ err = 0; while ((c = getc(inst_file_fp)) != EOF) { if ((err = putc(c, old_inst_file_fp)) == EOF) { break; } } if (fclose(old_inst_file_fp) == EOF || err == EOF) { vprint(INFO_MID, CANT_UPDATE, old_inst_file); err = DEVFSADM_FAILURE; goto out; /* NOTREACHED */ } /* * Set permissions to be the same on the backup as * /etc/path_to_inst. */ (void) chmod(old_inst_file, 0444); /* * So far, everything we've done is more or less reversible. * But now we're going to commit ourselves. */ (void) snprintf(old_inst_file_npid, inst_strlen + sizeof (INSTANCE_FILE_SUFFIX), "%s%s", inst_file, INSTANCE_FILE_SUFFIX); if ((err = rename(old_inst_file, old_inst_file_npid)) != 0) { err_print(RENAME_FAILED, old_inst_file_npid, strerror(errno)); } else if ((err = rename(new_inst_file, inst_file)) != 0) { err_print(RENAME_FAILED, inst_file, strerror(errno)); } out: if (inst_file_fp != NULL) { if (fclose(inst_file_fp) == EOF) { err_print(FCLOSE_FAILED, inst_file, strerror(errno)); } } if (stat(new_inst_file, &sb) == 0) { s_unlink(new_inst_file); } free(new_inst_file); if (stat(old_inst_file, &sb) == 0) { s_unlink(old_inst_file); } free(old_inst_file); free(old_inst_file_npid); if (err != 0 && err != EALREADY) { err_print(FAILED_TO_UPDATE, inst_file); } } /* * detach from tty. For daemon mode. */ void detachfromtty() { (void) setsid(); if (DEVFSADM_DEBUG_ON == TRUE) { return; } (void) close(0); (void) close(1); (void) close(2); (void) open("/dev/null", O_RDWR, 0); (void) dup(0); (void) dup(0); openlog(DEVFSADMD, LOG_PID, LOG_DAEMON); (void) setlogmask(LOG_UPTO(LOG_INFO)); logflag = TRUE; } /* * Use an advisory lock to synchronize updates to /dev. If the lock is * held by another process, block in the fcntl() system call until that * process drops the lock or exits. The lock file itself is * DEV_LOCK_FILE. The process id of the current and last process owning * the lock is kept in the lock file. After acquiring the lock, read the * process id and return it. It is the process ID which last owned the * lock, and will be used to determine if caches need to be flushed. * * NOTE: if the devlink database is held open by the caller, it may * be closed by this routine. This is to enforce the following lock ordering: * 1) /dev lock 2) database open */ pid_t enter_dev_lock() { struct flock lock; int n; pid_t pid; pid_t last_owner_pid; if (file_mods == FALSE) { return (0); } (void) snprintf(dev_lockfile, sizeof (dev_lockfile), "%s/%s", etc_dev_dir, DEV_LOCK_FILE); vprint(LOCK_MID, "enter_dev_lock: lock file %s\n", dev_lockfile); dev_lock_fd = open(dev_lockfile, O_CREAT|O_RDWR, 0644); if (dev_lock_fd < 0) { err_print(OPEN_FAILED, dev_lockfile, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } lock.l_type = F_WRLCK; lock.l_whence = SEEK_SET; lock.l_start = 0; lock.l_len = 0; /* try for the lock, but don't wait */ if (fcntl(dev_lock_fd, F_SETLK, &lock) == -1) { if ((errno == EACCES) || (errno == EAGAIN)) { pid = 0; n = read(dev_lock_fd, &pid, sizeof (pid_t)); vprint(LOCK_MID, "waiting for PID %d to complete\n", (int)pid); if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) { err_print(LSEEK_FAILED, dev_lockfile, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } /* * wait for the dev lock. If we have the database open, * close it first - the order of lock acquisition should * always be: 1) dev_lock 2) database * This is to prevent deadlocks with any locks the * database code may hold. */ (void) di_devlink_close(&devlink_cache, 0); /* send any sysevents that were queued up. */ process_syseventq(); if (fcntl(dev_lock_fd, F_SETLKW, &lock) == -1) { err_print(LOCK_FAILED, dev_lockfile, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } } } hold_dev_lock = TRUE; pid = 0; n = read(dev_lock_fd, &pid, sizeof (pid_t)); if (n == sizeof (pid_t) && pid == getpid()) { return (pid); } last_owner_pid = pid; if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) { err_print(LSEEK_FAILED, dev_lockfile, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } pid = getpid(); n = write(dev_lock_fd, &pid, sizeof (pid_t)); if (n != sizeof (pid_t)) { err_print(WRITE_FAILED, dev_lockfile, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } return (last_owner_pid); } /* * Drop the advisory /dev lock, close lock file. Close and re-open the * file every time so to ensure a resync if for some reason the lock file * gets removed. */ void exit_dev_lock(int exiting) { struct flock unlock; if (hold_dev_lock == FALSE) { return; } vprint(LOCK_MID, "exit_dev_lock: lock file %s, exiting = %d\n", dev_lockfile, exiting); unlock.l_type = F_UNLCK; unlock.l_whence = SEEK_SET; unlock.l_start = 0; unlock.l_len = 0; if (fcntl(dev_lock_fd, F_SETLK, &unlock) == -1) { err_print(UNLOCK_FAILED, dev_lockfile, strerror(errno)); } hold_dev_lock = FALSE; if (close(dev_lock_fd) == -1) { err_print(CLOSE_FAILED, dev_lockfile, strerror(errno)); if (!exiting) devfsadm_exit(1); /*NOTREACHED*/ } } /* * * Use an advisory lock to ensure that only one daemon process is active * in the system at any point in time. If the lock is held by another * process, do not block but return the pid owner of the lock to the * caller immediately. The lock is cleared if the holding daemon process * exits for any reason even if the lock file remains, so the daemon can * be restarted if necessary. The lock file is DAEMON_LOCK_FILE. */ pid_t enter_daemon_lock(void) { struct flock lock; (void) snprintf(daemon_lockfile, sizeof (daemon_lockfile), "%s/%s", etc_dev_dir, DAEMON_LOCK_FILE); vprint(LOCK_MID, "enter_daemon_lock: lock file %s\n", daemon_lockfile); daemon_lock_fd = open(daemon_lockfile, O_CREAT|O_RDWR, 0644); if (daemon_lock_fd < 0) { err_print(OPEN_FAILED, daemon_lockfile, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } lock.l_type = F_WRLCK; lock.l_whence = SEEK_SET; lock.l_start = 0; lock.l_len = 0; if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) { if (errno == EAGAIN || errno == EDEADLK) { if (fcntl(daemon_lock_fd, F_GETLK, &lock) == -1) { err_print(LOCK_FAILED, daemon_lockfile, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } return (lock.l_pid); } } hold_daemon_lock = TRUE; return (getpid()); } /* * Drop the advisory daemon lock, close lock file */ void exit_daemon_lock(int exiting) { struct flock lock; if (hold_daemon_lock == FALSE) { return; } vprint(LOCK_MID, "exit_daemon_lock: lock file %s, exiting = %d\n", daemon_lockfile, exiting); lock.l_type = F_UNLCK; lock.l_whence = SEEK_SET; lock.l_start = 0; lock.l_len = 0; if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) { err_print(UNLOCK_FAILED, daemon_lockfile, strerror(errno)); } if (close(daemon_lock_fd) == -1) { err_print(CLOSE_FAILED, daemon_lockfile, strerror(errno)); if (!exiting) devfsadm_exit(1); /*NOTREACHED*/ } } /* * Called to removed danging nodes in two different modes: RM_PRE, RM_POST. * RM_PRE mode is called before processing the entire devinfo tree, and RM_POST * is called after processing the entire devinfo tree. */ static void pre_and_post_cleanup(int flags) { remove_list_t *rm; recurse_dev_t rd; cleanup_data_t cleanup_data; char *fcn = "pre_and_post_cleanup: "; if (build_dev == FALSE) return; vprint(CHATTY_MID, "attempting %s-cleanup\n", flags == RM_PRE ? "pre" : "post"); vprint(REMOVE_MID, "%sflags = %d\n", fcn, flags); /* * the generic function recurse_dev_re is shared among different * functions, so set the method and data that it should use for * matches. */ rd.fcn = matching_dev; rd.data = (void *)&cleanup_data; cleanup_data.flags = flags; (void) mutex_lock(&nfp_mutex); nfphash_create(); for (rm = remove_head; rm != NULL; rm = rm->next) { if ((flags & rm->remove->flags) == flags) { cleanup_data.rm = rm; /* * If reached this point, RM_PRE or RM_POST cleanup is * desired. clean_ok() decides whether to clean * under the given circumstances. */ vprint(REMOVE_MID, "%scleanup: PRE or POST\n", fcn); if (clean_ok(rm->remove) == DEVFSADM_SUCCESS) { vprint(REMOVE_MID, "cleanup: cleanup OK\n"); recurse_dev_re(dev_dir, rm->remove->dev_dirs_re, &rd); } } } nfphash_destroy(); (void) mutex_unlock(&nfp_mutex); } /* * clean_ok() determines whether cleanup should be done according * to the following matrix: * * command line arguments RM_PRE RM_POST RM_PRE && RM_POST && * RM_ALWAYS RM_ALWAYS * ---------------------- ------ ----- --------- ---------- * * - - pre-clean post-clean * * -C pre-clean post-clean pre-clean post-clean * * -C -c class pre-clean post-clean pre-clean post-clean * if class if class if class if class * matches matches matches matches * * -c class - - pre-clean post-clean * if class if class * matches matches * */ static int clean_ok(devfsadm_remove_V1_t *remove) { int i; if (single_drv == TRUE) { /* no cleanup at all when using -i option */ return (DEVFSADM_FAILURE); } /* * no cleanup if drivers are not loaded. We make an exception * for the "disks" program however, since disks has a public * cleanup flag (-C) and disk drivers are usually never * unloaded. */ if (load_attach_drv == FALSE && strcmp(prog, DISKS) != 0) { return (DEVFSADM_FAILURE); } /* if the cleanup flag was not specified, return false */ if ((cleanup == FALSE) && ((remove->flags & RM_ALWAYS) == 0)) { return (DEVFSADM_FAILURE); } if (num_classes == 0) { return (DEVFSADM_SUCCESS); } /* * if reached this point, check to see if the class in the given * remove structure matches a class given on the command line */ for (i = 0; i < num_classes; i++) { if (strcmp(remove->device_class, classes[i]) == 0) { return (DEVFSADM_SUCCESS); } } return (DEVFSADM_FAILURE); } /* * Called to remove dangling nodes after receiving a hotplug event * containing the physical node pathname to be removed. */ void hot_cleanup(char *node_path, char *minor_name, char *ev_subclass, char *driver_name, int instance) { link_t *link; linkhead_t *head; remove_list_t *rm; char *fcn = "hot_cleanup: "; char path[PATH_MAX + 1]; int path_len; char rmlink[PATH_MAX + 1]; nvlist_t *nvl = NULL; int skip; int ret; /* * dev links can go away as part of hot cleanup. * So first build event attributes in order capture dev links. */ if (ev_subclass != NULL) nvl = build_event_attributes(EC_DEV_REMOVE, ev_subclass, node_path, DI_NODE_NIL, driver_name, instance, minor_name); (void) strcpy(path, node_path); (void) strcat(path, ":"); (void) strcat(path, minor_name == NULL ? "" : minor_name); path_len = strlen(path); vprint(REMOVE_MID, "%spath=%s\n", fcn, path); (void) mutex_lock(&nfp_mutex); nfphash_create(); for (rm = remove_head; rm != NULL; rm = rm->next) { if ((RM_HOT & rm->remove->flags) == RM_HOT) { head = get_cached_links(rm->remove->dev_dirs_re); assert(head->nextlink == NULL); for (link = head->link; link != NULL; link = head->nextlink) { /* * The remove callback below may remove * the current and/or any or all of the * subsequent links in the list. * Save the next link in the head. If * the callback removes the next link * the saved pointer in the head will be * updated by the callback to point at * the next valid link. */ head->nextlink = link->next; /* * if devlink is in no-further-process hash, * skip its remove */ if (nfphash_lookup(link->devlink) != NULL) continue; if (minor_name) skip = strcmp(link->contents, path); else skip = strncmp(link->contents, path, path_len); if (skip || (call_minor_init(rm->modptr) == DEVFSADM_FAILURE)) continue; vprint(REMOVE_MID, "%sremoving %s -> %s\n", fcn, link->devlink, link->contents); /* * Use a copy of the cached link name * as the cache entry will go away * during link removal */ (void) snprintf(rmlink, sizeof (rmlink), "%s", link->devlink); if (rm->remove->flags & RM_NOINTERPOSE) { (void) (rm->remove->callback_fcn)(rmlink); } else { ret = (rm->remove->callback_fcn)(rmlink); if (ret == DEVFSADM_TERMINATE) nfphash_insert(rmlink); } } } } nfphash_destroy(); (void) mutex_unlock(&nfp_mutex); /* update device allocation database */ if (system_labeled) { int devtype = 0; if (strstr(path, DA_SOUND_NAME)) devtype = DA_AUDIO; else if (strstr(path, "storage")) devtype = DA_RMDISK; else if (strstr(path, "disk")) devtype = DA_RMDISK; else if (strstr(path, "floppy")) /* TODO: detect usb cds and floppies at insert time */ devtype = DA_RMDISK; else goto out; (void) _update_devalloc_db(&devlist, devtype, DA_REMOVE, node_path, root_dir); } out: /* now log an event */ if (nvl) { log_event(EC_DEV_REMOVE, ev_subclass, nvl); free(nvl); } } /* * Open the dir current_dir. For every file which matches the first dir * component of path_re, recurse. If there are no more *dir* path * components left in path_re (ie no more /), then call function rd->fcn. */ static void recurse_dev_re(char *current_dir, char *path_re, recurse_dev_t *rd) { regex_t re1; char *slash; char new_path[PATH_MAX + 1]; char *anchored_path_re; size_t len; finddevhdl_t fhandle; const char *fp; vprint(RECURSEDEV_MID, "recurse_dev_re: curr = %s path=%s\n", current_dir, path_re); if (finddev_readdir(current_dir, &fhandle) != 0) return; len = strlen(path_re); if ((slash = strchr(path_re, '/')) != NULL) { len = (slash - path_re); } anchored_path_re = s_malloc(len + 3); (void) sprintf(anchored_path_re, "^%.*s$", len, path_re); if (regcomp(&re1, anchored_path_re, REG_EXTENDED) != 0) { free(anchored_path_re); goto out; } free(anchored_path_re); while ((fp = finddev_next(fhandle)) != NULL) { if (regexec(&re1, fp, 0, NULL, 0) == 0) { /* match */ (void) strcpy(new_path, current_dir); (void) strcat(new_path, "/"); (void) strcat(new_path, fp); vprint(RECURSEDEV_MID, "recurse_dev_re: match, new " "path = %s\n", new_path); if (slash != NULL) { recurse_dev_re(new_path, slash + 1, rd); } else { /* reached the leaf component of path_re */ vprint(RECURSEDEV_MID, "recurse_dev_re: calling fcn\n"); (*(rd->fcn))(new_path, rd->data); } } } regfree(&re1); out: finddev_close(fhandle); } /* * Found a devpath which matches a RE in the remove structure. * Now check to see if it is dangling. */ static void matching_dev(char *devpath, void *data) { cleanup_data_t *cleanup_data = data; int norm_len = strlen(dev_dir) + strlen("/"); int ret; char *fcn = "matching_dev: "; vprint(RECURSEDEV_MID, "%sexamining devpath = '%s'\n", fcn, devpath); /* * If the link is in the no-further-process hash * don't do any remove operation on it. */ if (nfphash_lookup(devpath + norm_len) != NULL) return; /* * Dangling check will work whether "alias" or "current" * so no need to redirect. */ if (resolve_link(devpath, NULL, NULL, NULL, 1) == TRUE) { if (call_minor_init(cleanup_data->rm->modptr) == DEVFSADM_FAILURE) { return; } devpath += norm_len; vprint(RECURSEDEV_MID, "%scalling callback %s\n", fcn, devpath); if (cleanup_data->rm->remove->flags & RM_NOINTERPOSE) (void) (cleanup_data->rm->remove->callback_fcn)(devpath); else { ret = (cleanup_data->rm->remove->callback_fcn)(devpath); if (ret == DEVFSADM_TERMINATE) { /* * We want no further remove processing for * this link. Add it to the nfp_hash; */ nfphash_insert(devpath); } } } } int devfsadm_read_link(di_node_t anynode, char *link, char **devfs_path) { char devlink[PATH_MAX]; char *path; *devfs_path = NULL; /* prepend link with dev_dir contents */ (void) strcpy(devlink, dev_dir); (void) strcat(devlink, "/"); (void) strcat(devlink, link); /* We *don't* want a stat of the /devices node */ path = NULL; (void) resolve_link(devlink, NULL, NULL, &path, 0); if (path != NULL) { /* redirect if alias to current */ *devfs_path = di_alias2curr(anynode, path); free(path); } return (*devfs_path ? DEVFSADM_SUCCESS : DEVFSADM_FAILURE); } int devfsadm_link_valid(di_node_t anynode, char *link) { struct stat sb; char devlink[PATH_MAX + 1], *contents, *raw_contents; int rv, type; int instance = 0; /* prepend link with dev_dir contents */ (void) strcpy(devlink, dev_dir); (void) strcat(devlink, "/"); (void) strcat(devlink, link); if (!device_exists(devlink) || lstat(devlink, &sb) != 0) { return (DEVFSADM_FALSE); } raw_contents = NULL; type = 0; if (resolve_link(devlink, &raw_contents, &type, NULL, 1) == TRUE) { rv = DEVFSADM_FALSE; } else { rv = DEVFSADM_TRUE; } /* * resolve alias paths for primary links */ contents = raw_contents; if (type == DI_PRIMARY_LINK) { contents = di_alias2curr(anynode, raw_contents); free(raw_contents); } /* * The link exists. Add it to the database */ (void) di_devlink_add_link(devlink_cache, link, contents, type); if (system_labeled && (rv == DEVFSADM_TRUE) && strstr(devlink, DA_AUDIO_NAME) && contents) { (void) sscanf(contents, "%*[a-z]%d", &instance); (void) da_add_list(&devlist, devlink, instance, DA_ADD|DA_AUDIO); _update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir); } free(contents); return (rv); } /* * devpath: Absolute path to /dev link * content_p: Returns malloced string (link content) * type_p: Returns link type: primary or secondary * devfs_path: Returns malloced string: /devices path w/out "/devices" * dangle: if set, check if link is dangling * Returns: * TRUE if dangling * FALSE if not or if caller doesn't care * Caller is assumed to have initialized pointer contents to NULL * */ static int resolve_link(char *devpath, char **content_p, int *type_p, char **devfs_path, int dangle) { char contents[PATH_MAX + 1]; char stage_link[PATH_MAX + 1]; char *fcn = "resolve_link: "; char *ptr; int linksize; int rv = TRUE; struct stat sb; /* * This routine will return the "raw" contents. It is upto the * the caller to redirect "alias" to "current" (or vice versa) */ linksize = readlink(devpath, contents, PATH_MAX); if (linksize <= 0) { return (FALSE); } else { contents[linksize] = '\0'; } vprint(REMOVE_MID, "%s %s -> %s\n", fcn, devpath, contents); if (content_p) { *content_p = s_strdup(contents); } /* * Check to see if this is a link pointing to another link in /dev. The * cheap way to do this is to look for a lack of ../devices/. */ if (is_minor_node(contents, &ptr) == DEVFSADM_FALSE) { if (type_p) { *type_p = DI_SECONDARY_LINK; } /* * assume that linkcontents is really a pointer to another * link, and if so recurse and read its link contents. */ if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0) { (void) strcpy(stage_link, dev_dir); (void) strcat(stage_link, "/"); (void) strcpy(stage_link, &contents[strlen(DEV) + strlen("/")]); } else { if ((ptr = strrchr(devpath, '/')) == NULL) { vprint(REMOVE_MID, "%s%s -> %s invalid link. " "missing '/'\n", fcn, devpath, contents); return (TRUE); } *ptr = '\0'; (void) strcpy(stage_link, devpath); *ptr = '/'; (void) strcat(stage_link, "/"); (void) strcat(stage_link, contents); } return (resolve_link(stage_link, NULL, NULL, devfs_path, dangle)); } /* Current link points at a /devices minor node */ if (type_p) { *type_p = DI_PRIMARY_LINK; } if (devfs_path) *devfs_path = s_strdup(ptr); rv = FALSE; if (dangle) rv = (stat(ptr - strlen(DEVICES), &sb) == -1); vprint(REMOVE_MID, "%slink=%s, returning %s\n", fcn, devpath, ((rv == TRUE) ? "TRUE" : "FALSE")); return (rv); } /* * Returns the substring of interest, given a path. */ static char * alloc_cmp_str(const char *path, devfsadm_enumerate_t *dep) { uint_t match; char *np, *ap, *mp; char *cmp_str = NULL; char at[] = "@"; char *fcn = "alloc_cmp_str"; np = ap = mp = NULL; /* * extract match flags from the flags argument. */ match = (dep->flags & MATCH_MASK); vprint(ENUM_MID, "%s: enumeration match type: 0x%x" " path: %s\n", fcn, match, path); /* * MATCH_CALLBACK and MATCH_ALL are the only flags * which may be used if "path" is a /dev path */ if (match == MATCH_CALLBACK) { if (dep->sel_fcn == NULL) { vprint(ENUM_MID, "%s: invalid enumerate" " callback: path: %s\n", fcn, path); return (NULL); } cmp_str = dep->sel_fcn(path, dep->cb_arg); return (cmp_str); } cmp_str = s_strdup(path); if (match == MATCH_ALL) { return (cmp_str); } /* * The remaining flags make sense only for /devices * paths */ if ((mp = strrchr(cmp_str, ':')) == NULL) { vprint(ENUM_MID, "%s: invalid path: %s\n", fcn, path); goto err; } if (match == MATCH_MINOR) { /* A NULL "match_arg" values implies entire minor */ if (get_component(mp + 1, dep->match_arg) == NULL) { vprint(ENUM_MID, "%s: invalid minor component:" " path: %s\n", fcn, path); goto err; } return (cmp_str); } if ((np = strrchr(cmp_str, '/')) == NULL) { vprint(ENUM_MID, "%s: invalid path: %s\n", fcn, path); goto err; } if (match == MATCH_PARENT) { if (strcmp(cmp_str, "/") == 0) { vprint(ENUM_MID, "%s: invalid path: %s\n", fcn, path); goto err; } if (np == cmp_str) { *(np + 1) = '\0'; } else { *np = '\0'; } return (cmp_str); } /* ap can be NULL - Leaf address may not exist or be empty string */ ap = strchr(np+1, '@'); /* minor is no longer of interest */ *mp = '\0'; if (match == MATCH_NODE) { if (ap) *ap = '\0'; return (cmp_str); } else if (match == MATCH_ADDR) { /* * The empty string is a valid address. The only MATCH_ADDR * allowed in this case is against the whole address or * the first component of the address (match_arg=NULL/"0"/"1") * Note that in this case, the path won't have an "@" * As a result ap will be NULL. We fake up an ap = @'\0' * so that get_component() will work correctly. */ if (ap == NULL) { ap = at; } if (get_component(ap + 1, dep->match_arg) == NULL) { vprint(ENUM_MID, "%s: invalid leaf addr. component:" " path: %s\n", fcn, path); goto err; } return (cmp_str); } vprint(ENUM_MID, "%s: invalid enumeration flags: 0x%x" " path: %s\n", fcn, dep->flags, path); /*FALLTHRU*/ err: free(cmp_str); return (NULL); } /* * "str" is expected to be a string with components separated by ',' * The terminating null char is considered a separator. * get_component() will remove the portion of the string beyond * the component indicated. * If comp_str is NULL, the entire "str" is returned. */ static char * get_component(char *str, const char *comp_str) { long comp; char *cp; if (str == NULL) { return (NULL); } if (comp_str == NULL) { return (str); } errno = 0; comp = strtol(comp_str, &cp, 10); if (errno != 0 || *cp != '\0' || comp < 0) { return (NULL); } if (comp == 0) return (str); for (cp = str; ; cp++) { if (*cp == ',' || *cp == '\0') comp--; if (*cp == '\0' || comp <= 0) { break; } } if (comp == 0) { *cp = '\0'; } else { str = NULL; } return (str); } /* * Enumerate serves as a generic counter as well as a means to determine * logical unit/controller numbers for such items as disk and tape * drives. * * rules[] is an array of devfsadm_enumerate_t structures which defines * the enumeration rules to be used for a specified set of links in /dev. * The set of links is specified through regular expressions (of the flavor * described in regex(7)). These regular expressions are used to determine * the set of links in /dev to examine. The last path component in these * regular expressions MUST contain a parenthesized subexpression surrounding * the RE which is to be considered the enumerating component. The subexp * member in a rule is the subexpression number of the enumerating * component. Subexpressions in the last path component are numbered starting * from 1. * * A cache of current id assignments is built up from existing symlinks and * new assignments use the lowest unused id. Assignments are based on a * match of a specified substring of a symlink's contents. If the specified * component for the devfs_path argument matches the corresponding substring * for a existing symlink's contents, the cached id is returned. Else, a new * id is created and returned in *buf. *buf must be freed by the caller. * * An id assignment may be governed by a combination of rules, each rule * applicable to a different subset of links in /dev. For example, controller * numbers may be determined by a combination of disk symlinks in /dev/[r]dsk * and controller symlinks in /dev/cfg, with the two sets requiring different * rules to derive the "substring of interest". In such cases, the rules * array will have more than one element. */ int devfsadm_enumerate_int(char *devfs_path, int index, char **buf, devfsadm_enumerate_t rules[], int nrules) { return (find_enum_id(rules, nrules, devfs_path, index, "0", INTEGER, buf, 0)); } int ctrl_enumerate_int(char *devfs_path, int index, char **buf, devfsadm_enumerate_t rules[], int nrules, int multiple, boolean_t scsi_vhci) { return (find_enum_id(rules, nrules, devfs_path, index, scsi_vhci ? "0" : "1", INTEGER, buf, multiple)); } /* * Same as above, but allows a starting value to be specified. * Private to devfsadm.... used by devlinks. */ static int devfsadm_enumerate_int_start(char *devfs_path, int index, char **buf, devfsadm_enumerate_t rules[], int nrules, char *start) { return (find_enum_id(rules, nrules, devfs_path, index, start, INTEGER, buf, 0)); } /* * devfsadm_enumerate_char serves as a generic counter returning * a single letter. */ int devfsadm_enumerate_char(char *devfs_path, int index, char **buf, devfsadm_enumerate_t rules[], int nrules) { return (find_enum_id(rules, nrules, devfs_path, index, "a", LETTER, buf, 0)); } /* * Same as above, but allows a starting char to be specified. * Private to devfsadm - used by ports module (port_link.c) */ int devfsadm_enumerate_char_start(char *devfs_path, int index, char **buf, devfsadm_enumerate_t rules[], int nrules, char *start) { return (find_enum_id(rules, nrules, devfs_path, index, start, LETTER, buf, 0)); } /* * For a given numeral_set (see get_cached_set for desc of numeral_set), * search all cached entries looking for matches on a specified substring * of devfs_path. The substring is derived from devfs_path based on the * rule specified by "index". If a match is found on a cached entry, * return the enumerated id in buf. Otherwise, create a new id by calling * new_id, then cache and return that entry. */ static int find_enum_id(devfsadm_enumerate_t rules[], int nrules, char *devfs_path, int index, char *min, int type, char **buf, int multiple) { numeral_t *matchnp; numeral_t *numeral; int matchcount = 0; char *cmp_str; char *fcn = "find_enum_id"; numeral_set_t *set; if (rules == NULL) { vprint(ENUM_MID, "%s: no rules. path: %s\n", fcn, devfs_path ? devfs_path : ""); return (DEVFSADM_FAILURE); } if (devfs_path == NULL) { vprint(ENUM_MID, "%s: NULL path\n", fcn); return (DEVFSADM_FAILURE); } if (nrules <= 0 || index < 0 || index >= nrules || buf == NULL) { vprint(ENUM_MID, "%s: invalid arguments. path: %s\n", fcn, devfs_path); return (DEVFSADM_FAILURE); } *buf = NULL; cmp_str = alloc_cmp_str(devfs_path, &rules[index]); if (cmp_str == NULL) { return (DEVFSADM_FAILURE); } if ((set = get_enum_cache(rules, nrules)) == NULL) { free(cmp_str); return (DEVFSADM_FAILURE); } assert(nrules == set->re_count); /* * Check and see if a matching entry is already cached. */ matchcount = lookup_enum_cache(set, cmp_str, rules, index, &matchnp); if (matchcount < 0 || matchcount > 1) { free(cmp_str); if (multiple && matchcount > 1) return (DEVFSADM_MULTIPLE); else return (DEVFSADM_FAILURE); } /* if matching entry already cached, return it */ if (matchcount == 1) { /* should never create a link with a reserved ID */ vprint(ENUM_MID, "%s: 1 match w/ ID: %s\n", fcn, matchnp->id); assert(matchnp->flags == 0); *buf = s_strdup(matchnp->id); free(cmp_str); return (DEVFSADM_SUCCESS); } /* * no cached entry, initialize a numeral struct * by calling new_id() and cache onto the numeral_set */ numeral = s_malloc(sizeof (numeral_t)); numeral->id = new_id(set->headnumeral, type, min); numeral->full_path = s_strdup(devfs_path); numeral->rule_index = index; numeral->cmp_str = cmp_str; cmp_str = NULL; numeral->flags = 0; vprint(RSRV_MID, "%s: alloc new_id: %s numeral flags = %d\n", fcn, numeral->id, numeral->flags); /* insert to head of list for fast lookups */ numeral->next = set->headnumeral; set->headnumeral = numeral; *buf = s_strdup(numeral->id); return (DEVFSADM_SUCCESS); } /* * Looks up the specified cache for a match with a specified string * Returns: * -1 : on error. * 0/1/2 : Number of matches. * Returns the matching element only if there is a single match. * If the "uncached" flag is set, derives the "cmp_str" afresh * for the match instead of using cached values. */ static int lookup_enum_cache(numeral_set_t *set, char *cmp_str, devfsadm_enumerate_t rules[], int index, numeral_t **matchnpp) { int matchcount = 0, rv = -1; int uncached; numeral_t *np; char *fcn = "lookup_enum_cache"; char *cp; *matchnpp = NULL; assert(index < set->re_count); if (cmp_str == NULL) { return (-1); } uncached = 0; if ((rules[index].flags & MATCH_UNCACHED) == MATCH_UNCACHED) { uncached = 1; } /* * Check and see if a matching entry is already cached. */ for (np = set->headnumeral; np != NULL; np = np->next) { /* * Skip reserved IDs */ if (np->flags & NUMERAL_RESERVED) { vprint(RSRV_MID, "lookup_enum_cache: " "Cannot Match with reserved ID (%s), " "skipping\n", np->id); assert(np->flags == NUMERAL_RESERVED); continue; } else { vprint(RSRV_MID, "lookup_enum_cache: " "Attempting match with numeral ID: %s" " numeral flags = %d\n", np->id, np->flags); assert(np->flags == 0); } if (np->cmp_str == NULL) { vprint(ENUM_MID, "%s: invalid entry in enumerate" " cache. path: %s\n", fcn, np->full_path); return (-1); } if (uncached) { vprint(CHATTY_MID, "%s: bypassing enumerate cache." " path: %s\n", fcn, cmp_str); cp = alloc_cmp_str(np->full_path, &rules[np->rule_index]); if (cp == NULL) return (-1); rv = strcmp(cmp_str, cp); free(cp); } else { rv = strcmp(cmp_str, np->cmp_str); } if (rv == 0) { if (matchcount++ != 0) { break; /* more than 1 match. */ } *matchnpp = np; } } return (matchcount); } #ifdef DEBUG static void dump_enum_cache(numeral_set_t *setp) { int i; numeral_t *np; char *fcn = "dump_enum_cache"; vprint(ENUM_MID, "%s: re_count = %d\n", fcn, setp->re_count); for (i = 0; i < setp->re_count; i++) { vprint(ENUM_MID, "%s: re[%d] = %s\n", fcn, i, setp->re[i]); } for (np = setp->headnumeral; np != NULL; np = np->next) { vprint(ENUM_MID, "%s: id: %s\n", fcn, np->id); vprint(ENUM_MID, "%s: full_path: %s\n", fcn, np->full_path); vprint(ENUM_MID, "%s: rule_index: %d\n", fcn, np->rule_index); vprint(ENUM_MID, "%s: cmp_str: %s\n", fcn, np->cmp_str); vprint(ENUM_MID, "%s: flags: %d\n", fcn, np->flags); } } #endif /* * For a given set of regular expressions in rules[], this function returns * either a previously cached struct numeral_set or it will create and * cache a new struct numeral_set. There is only one struct numeral_set * for the combination of REs present in rules[]. Each numeral_set contains * the regular expressions in rules[] used for cache selection AND a linked * list of struct numerals, ONE FOR EACH *UNIQUE* numeral or character ID * selected by the grouping parenthesized subexpression found in the last * path component of each rules[].re. For example, the RE: "rmt/([0-9]+)" * selects all the logical nodes of the correct form in dev/rmt/. * Each rmt/X will store a *single* struct numeral... ie 0, 1, 2 each get a * single struct numeral. There is no need to store more than a single logical * node matching X since the information desired in the devfspath would be * identical for the portion of the devfspath of interest. (the part up to, * but not including the minor name in this example.) * * If the given numeral_set is not yet cached, call enumerate_recurse to * create it. */ static numeral_set_t * get_enum_cache(devfsadm_enumerate_t rules[], int nrules) { /* linked list of numeral sets */ numeral_set_t *setp; int i; int ret; char *path_left; enumerate_file_t *entry; char *fcn = "get_enum_cache"; /* * See if we've already cached this numeral set. */ for (setp = head_numeral_set; setp != NULL; setp = setp->next) { /* * check all regexp's passed in function against * those in cached set. */ if (nrules != setp->re_count) { continue; } for (i = 0; i < nrules; i++) { if (strcmp(setp->re[i], rules[i].re) != 0) { break; } } if (i == nrules) { return (setp); } } /* * If the MATCH_UNCACHED flag is set, we should not be here. */ for (i = 0; i < nrules; i++) { if ((rules[i].flags & MATCH_UNCACHED) == MATCH_UNCACHED) { vprint(ENUM_MID, "%s: invalid enumeration flags: " "0x%x\n", fcn, rules[i].flags); return (NULL); } } /* * Since we made it here, we have not yet cached the given set of * logical nodes matching the passed re. Create a cached entry * struct numeral_set and populate it with a minimal set of * logical nodes from /dev. */ setp = s_malloc(sizeof (numeral_set_t)); setp->re = s_malloc(sizeof (char *) * nrules); for (i = 0; i < nrules; i++) { setp->re[i] = s_strdup(rules[i].re); } setp->re_count = nrules; setp->headnumeral = NULL; /* put this new cached set on the cached set list */ setp->next = head_numeral_set; head_numeral_set = setp; /* * For each RE, search the "reserved" list to create numeral IDs that * are reserved. */ for (entry = enumerate_reserved; entry; entry = entry->er_next) { vprint(RSRV_MID, "parsing rstring: %s\n", entry->er_file); for (i = 0; i < nrules; i++) { path_left = s_strdup(setp->re[i]); vprint(RSRV_MID, "parsing rule RE: %s\n", path_left); ret = enumerate_parse(entry->er_file, path_left, setp, rules, i); free(path_left); if (ret == 1) { /* * We found the reserved ID for this entry. * We still keep the entry since it is needed * by the new link bypass code in disks */ vprint(RSRV_MID, "found rsv ID: rstring: %s " "rule RE: %s\n", entry->er_file, path_left); break; } } } /* * For each RE, search disk and cache any matches on the * numeral list. */ for (i = 0; i < nrules; i++) { path_left = s_strdup(setp->re[i]); enumerate_recurse(dev_dir, path_left, setp, rules, i); free(path_left); } #ifdef DEBUG dump_enum_cache(setp); #endif return (setp); } /* * This function stats the pathname namebuf. If this is a directory * entry, we recurse down dname/fname until we find the first symbolic * link, and then stat and return it. This is valid for the same reason * that we only need to read a single pathname for multiple matching * logical ID's... ie, all the logical nodes should contain identical * physical paths for the parts we are interested. */ int get_stat_info(char *namebuf, struct stat *sb) { char *cp; finddevhdl_t fhandle; const char *fp; if (lstat(namebuf, sb) < 0) { (void) err_print(LSTAT_FAILED, namebuf, strerror(errno)); return (DEVFSADM_FAILURE); } if ((sb->st_mode & S_IFMT) == S_IFLNK) { return (DEVFSADM_SUCCESS); } /* * If it is a dir, recurse down until we find a link and * then use the link. */ if ((sb->st_mode & S_IFMT) == S_IFDIR) { if (finddev_readdir(namebuf, &fhandle) != 0) { return (DEVFSADM_FAILURE); } /* * Search each dir entry looking for a symlink. Return * the first symlink found in namebuf. Recurse dirs. */ while ((fp = finddev_next(fhandle)) != NULL) { cp = namebuf + strlen(namebuf); if ((strlcat(namebuf, "/", PATH_MAX) >= PATH_MAX) || (strlcat(namebuf, fp, PATH_MAX) >= PATH_MAX)) { *cp = '\0'; finddev_close(fhandle); return (DEVFSADM_FAILURE); } if (get_stat_info(namebuf, sb) == DEVFSADM_SUCCESS) { finddev_close(fhandle); return (DEVFSADM_SUCCESS); } *cp = '\0'; } finddev_close(fhandle); } /* no symlink found, so return error */ return (DEVFSADM_FAILURE); } /* * An existing matching ID was not found, so this function is called to * create the next lowest ID. In the INTEGER case, return the next * lowest unused integer. In the case of LETTER, return the next lowest * unused letter. Return empty string if all 26 are used. * Only IDs >= min will be returned. */ char * new_id(numeral_t *numeral, int type, char *min) { int imin; temp_t *temp; temp_t *ptr; temp_t **previous; temp_t *head = NULL; char *retval; static char tempbuff[8]; numeral_t *np; if (type == LETTER) { char letter[26], i; if (numeral == NULL) { return (s_strdup(min)); } for (i = 0; i < 26; i++) { letter[i] = 0; } for (np = numeral; np != NULL; np = np->next) { assert(np->flags == 0 || np->flags == NUMERAL_RESERVED); letter[*np->id - 'a']++; } imin = *min - 'a'; for (i = imin; i < 26; i++) { if (letter[i] == 0) { retval = s_malloc(2); retval[0] = 'a' + i; retval[1] = '\0'; return (retval); } } return (s_strdup("")); } if (type == INTEGER) { if (numeral == NULL) { return (s_strdup(min)); } imin = atoi(min); /* sort list */ for (np = numeral; np != NULL; np = np->next) { assert(np->flags == 0 || np->flags == NUMERAL_RESERVED); temp = s_malloc(sizeof (temp_t)); temp->integer = atoi(np->id); temp->next = NULL; previous = &head; for (ptr = head; ptr != NULL; ptr = ptr->next) { if (temp->integer < ptr->integer) { temp->next = ptr; *previous = temp; break; } previous = &(ptr->next); } if (ptr == NULL) { *previous = temp; } } /* now search sorted list for first hole >= imin */ for (ptr = head; ptr != NULL; ptr = ptr->next) { if (imin == ptr->integer) { imin++; } else { if (imin < ptr->integer) { break; } } } /* free temp list */ for (ptr = head; ptr != NULL; ) { temp = ptr; ptr = ptr->next; free(temp); } (void) sprintf(tempbuff, "%d", imin); return (s_strdup(tempbuff)); } return (s_strdup("")); } static int enumerate_parse(char *rsvstr, char *path_left, numeral_set_t *setp, devfsadm_enumerate_t rules[], int index) { char *slash1 = NULL; char *slash2 = NULL; char *numeral_id; char *path_left_save; char *rsvstr_save; int ret = 0; static int warned = 0; rsvstr_save = rsvstr; path_left_save = path_left; if (rsvstr == NULL || rsvstr[0] == '\0' || rsvstr[0] == '/') { if (!warned) { err_print("invalid reserved filepath: %s\n", rsvstr ? rsvstr : ""); warned = 1; } return (0); } vprint(RSRV_MID, "processing rule: %s, rstring: %s\n", path_left, rsvstr); for (;;) { /* get rid of any extra '/' in the reserve string */ while (*rsvstr == '/') { rsvstr++; } /* get rid of any extra '/' in the RE */ while (*path_left == '/') { path_left++; } if (slash1 = strchr(path_left, '/')) { *slash1 = '\0'; } if (slash2 = strchr(rsvstr, '/')) { *slash2 = '\0'; } if ((slash1 != NULL) ^ (slash2 != NULL)) { ret = 0; vprint(RSRV_MID, "mismatch in # of path components\n"); goto out; } /* * Returns true if path_left matches the list entry. * If it is the last path component, pass subexp * so that it will return the corresponding ID in * numeral_id. */ numeral_id = NULL; if (match_path_component(path_left, rsvstr, &numeral_id, slash1 ? 0 : rules[index].subexp)) { /* We have a match. */ if (slash1 == NULL) { /* Is last path component */ vprint(RSRV_MID, "match and last component\n"); create_reserved_numeral(setp, numeral_id); if (numeral_id != NULL) { free(numeral_id); } ret = 1; goto out; } else { /* Not last path component. Continue parsing */ *slash1 = '/'; *slash2 = '/'; path_left = slash1 + 1; rsvstr = slash2 + 1; vprint(RSRV_MID, "match and NOT last component\n"); continue; } } else { /* No match */ ret = 0; vprint(RSRV_MID, "No match: rule RE = %s, " "rstring = %s\n", path_left, rsvstr); goto out; } } out: if (slash1) *slash1 = '/'; if (slash2) *slash2 = '/'; if (ret == 1) { vprint(RSRV_MID, "match: rule RE: %s, rstring: %s\n", path_left_save, rsvstr_save); } else { vprint(RSRV_MID, "NO match: rule RE: %s, rstring: %s\n", path_left_save, rsvstr_save); } return (ret); } /* * Search current_dir for all files which match the first path component * of path_left, which is an RE. If a match is found, but there are more * components of path_left, then recurse, otherwise, if we have reached * the last component of path_left, call create_cached_numerals for each * file. At some point, recurse_dev_re() should be rewritten so that this * function can be eliminated. */ static void enumerate_recurse(char *current_dir, char *path_left, numeral_set_t *setp, devfsadm_enumerate_t rules[], int index) { char *slash; char *new_path; char *numeral_id; finddevhdl_t fhandle; const char *fp; if (finddev_readdir(current_dir, &fhandle) != 0) { return; } /* get rid of any extra '/' */ while (*path_left == '/') { path_left++; } if (slash = strchr(path_left, '/')) { *slash = '\0'; } while ((fp = finddev_next(fhandle)) != NULL) { /* * Returns true if path_left matches the list entry. * If it is the last path component, pass subexp * so that it will return the corresponding ID in * numeral_id. */ numeral_id = NULL; if (match_path_component(path_left, (char *)fp, &numeral_id, slash ? 0 : rules[index].subexp)) { new_path = s_malloc(strlen(current_dir) + strlen(fp) + 2); (void) strcpy(new_path, current_dir); (void) strcat(new_path, "/"); (void) strcat(new_path, fp); if (slash != NULL) { enumerate_recurse(new_path, slash + 1, setp, rules, index); } else { create_cached_numeral(new_path, setp, numeral_id, rules, index); if (numeral_id != NULL) { free(numeral_id); } } free(new_path); } } if (slash != NULL) { *slash = '/'; } finddev_close(fhandle); } /* * Returns true if file matches file_re. If subexp is non-zero, it means * we are searching the last path component and need to return the * parenthesized subexpression subexp in id. * */ static int match_path_component(char *file_re, char *file, char **id, int subexp) { regex_t re1; int match = 0; int nelements; regmatch_t *pmatch; if (subexp != 0) { nelements = subexp + 1; pmatch = (regmatch_t *)s_malloc(sizeof (regmatch_t) * nelements); } else { pmatch = NULL; nelements = 0; } if (regcomp(&re1, file_re, REG_EXTENDED) != 0) { if (pmatch != NULL) { free(pmatch); } return (0); } if (regexec(&re1, file, nelements, pmatch, 0) == 0) { match = 1; } if ((match != 0) && (subexp != 0)) { int size = pmatch[subexp].rm_eo - pmatch[subexp].rm_so; *id = s_malloc(size + 1); (void) strncpy(*id, &file[pmatch[subexp].rm_so], size); (*id)[size] = '\0'; } if (pmatch != NULL) { free(pmatch); } regfree(&re1); return (match); } static void create_reserved_numeral(numeral_set_t *setp, char *numeral_id) { numeral_t *np; vprint(RSRV_MID, "Attempting to create reserved numeral: %s\n", numeral_id); /* * We found a numeral_id from an entry in the enumerate_reserved file * which matched the re passed in from devfsadm_enumerate. We only * need to make sure ONE copy of numeral_id exists on the numeral list. * We only need to store /dev/dsk/cNtod0s0 and no other entries * hanging off of controller N. */ for (np = setp->headnumeral; np != NULL; np = np->next) { if (strcmp(numeral_id, np->id) == 0) { vprint(RSRV_MID, "ID: %s, already reserved\n", np->id); assert(np->flags == NUMERAL_RESERVED); return; } else { assert(np->flags == 0 || np->flags == NUMERAL_RESERVED); } } /* NOT on list, so add it */ np = s_malloc(sizeof (numeral_t)); np->id = s_strdup(numeral_id); np->full_path = NULL; np->rule_index = 0; np->cmp_str = NULL; np->flags = NUMERAL_RESERVED; np->next = setp->headnumeral; setp->headnumeral = np; vprint(RSRV_MID, "Reserved numeral ID: %s\n", np->id); } /* * This function is called for every file which matched the leaf * component of the RE. If the "numeral_id" is not already on the * numeral set's numeral list, add it and its physical path. */ static void create_cached_numeral(char *path, numeral_set_t *setp, char *numeral_id, devfsadm_enumerate_t rules[], int index) { char linkbuf[PATH_MAX + 1]; char lpath[PATH_MAX + 1]; char *linkptr, *cmp_str; numeral_t *np; int linksize; struct stat sb; char *contents; const char *fcn = "create_cached_numeral"; assert(index >= 0 && index < setp->re_count); assert(strcmp(rules[index].re, setp->re[index]) == 0); /* * We found a numeral_id from an entry in /dev which matched * the re passed in from devfsadm_enumerate. We only need to make sure * ONE copy of numeral_id exists on the numeral list. We only need * to store /dev/dsk/cNtod0s0 and no other entries hanging off * of controller N. */ for (np = setp->headnumeral; np != NULL; np = np->next) { assert(np->flags == 0 || np->flags == NUMERAL_RESERVED); if (strcmp(numeral_id, np->id) == 0) { /* * Note that we can't assert that the flags field * of the numeral is 0, since both reserved and * unreserved links in /dev come here */ if (np->flags == NUMERAL_RESERVED) { vprint(RSRV_MID, "ID derived from /dev link is" " reserved: %s\n", np->id); } else { vprint(RSRV_MID, "ID derived from /dev link is" " NOT reserved: %s\n", np->id); } return; } } /* NOT on list, so add it */ (void) strcpy(lpath, path); /* * If path is a dir, it is changed to the first symbolic link it find * if it finds one. */ if (get_stat_info(lpath, &sb) == DEVFSADM_FAILURE) { return; } /* If we get here, we found a symlink */ linksize = readlink(lpath, linkbuf, PATH_MAX); if (linksize <= 0) { err_print(READLINK_FAILED, fcn, lpath, strerror(errno)); return; } linkbuf[linksize] = '\0'; /* * redirect alias path to current path * devi_root_node is protected by lock_dev() */ contents = di_alias2curr(devi_root_node, linkbuf); /* * the following just points linkptr to the root of the /devices * node if it is a minor node, otherwise, to the first char of * linkbuf if it is a link. */ (void) is_minor_node(contents, &linkptr); cmp_str = alloc_cmp_str(linkptr, &rules[index]); if (cmp_str == NULL) { free(contents); return; } np = s_malloc(sizeof (numeral_t)); np->id = s_strdup(numeral_id); np->full_path = s_strdup(linkptr); np->rule_index = index; np->cmp_str = cmp_str; np->flags = 0; np->next = setp->headnumeral; setp->headnumeral = np; free(contents); } /* * This should be called either before or after granting access to a * command line version of devfsadm running, since it may have changed * the state of /dev. It forces future enumerate calls to re-build * cached information from /dev. */ void invalidate_enumerate_cache(void) { numeral_set_t *setp; numeral_set_t *savedsetp; numeral_t *savednumset; numeral_t *numset; int i; for (setp = head_numeral_set; setp != NULL; ) { /* * check all regexp's passed in function against * those in cached set. */ savedsetp = setp; setp = setp->next; for (i = 0; i < savedsetp->re_count; i++) { free(savedsetp->re[i]); } free(savedsetp->re); for (numset = savedsetp->headnumeral; numset != NULL; ) { savednumset = numset; numset = numset->next; assert(savednumset->rule_index < savedsetp->re_count); free(savednumset->id); free(savednumset->full_path); free(savednumset->cmp_str); free(savednumset); } free(savedsetp); } head_numeral_set = NULL; } /* * Copies over links from /dev to /dev and device special files in * /devices to /devices, preserving the existing file modes. If * the link or special file already exists on , skip the copy. (it * would exist only if a package hard coded it there, so assume package * knows best?). Use /etc/name_to_major and /etc/name_to_major to * make translations for major numbers on device special files. No need to * make a translation on minor_perm since if the file was created in the * miniroot then it would presumably have the same minor_perm entry in * /etc/minor_perm. To be used only by install. */ int devfsadm_copy(void) { char filename[PATH_MAX + 1]; /* load the installed root's name_to_major for translations */ (void) snprintf(filename, sizeof (filename), "%s%s", root_dir, NAME_TO_MAJOR); if (load_n2m_table(filename) == DEVFSADM_FAILURE) { return (DEVFSADM_FAILURE); } /* Copy /dev to target disk. No need to copy /devices with devfs */ (void) nftw(DEV, devfsadm_copy_file, 20, FTW_PHYS); /* Let install handle copying over path_to_inst */ return (DEVFSADM_SUCCESS); } /* * This function copies links, dirs, and device special files. * Note that it always returns DEVFSADM_SUCCESS, so that nftw doesn't * abort. */ /*ARGSUSED*/ static int devfsadm_copy_file(const char *file, const struct stat *stat, int flags, struct FTW *ftw) { struct stat sp; dev_t newdev; char newfile[PATH_MAX + 1]; char linkcontents[PATH_MAX + 1]; int bytes; const char *fcn = "devfsadm_copy_file"; (void) strcpy(newfile, root_dir); (void) strcat(newfile, "/"); (void) strcat(newfile, file); if (lstat(newfile, &sp) == 0) { /* newfile already exists, so no need to continue */ return (DEVFSADM_SUCCESS); } if (((stat->st_mode & S_IFMT) == S_IFBLK) || ((stat->st_mode & S_IFMT) == S_IFCHR)) { if (translate_major(stat->st_rdev, &newdev) == DEVFSADM_FAILURE) { return (DEVFSADM_SUCCESS); } if (mknod(newfile, stat->st_mode, newdev) == -1) { err_print(MKNOD_FAILED, newfile, strerror(errno)); return (DEVFSADM_SUCCESS); } } else if ((stat->st_mode & S_IFMT) == S_IFDIR) { if (mknod(newfile, stat->st_mode, 0) == -1) { err_print(MKNOD_FAILED, newfile, strerror(errno)); return (DEVFSADM_SUCCESS); } } else if ((stat->st_mode & S_IFMT) == S_IFLNK) { /* * No need to redirect alias paths. We want a * true copy. The system on first boot after install * will redirect paths */ if ((bytes = readlink(file, linkcontents, PATH_MAX)) == -1) { err_print(READLINK_FAILED, fcn, file, strerror(errno)); return (DEVFSADM_SUCCESS); } linkcontents[bytes] = '\0'; if (symlink(linkcontents, newfile) == -1) { err_print(SYMLINK_FAILED, newfile, newfile, strerror(errno)); return (DEVFSADM_SUCCESS); } } (void) lchown(newfile, stat->st_uid, stat->st_gid); return (DEVFSADM_SUCCESS); } /* * Given a dev_t from the running kernel, return the new_dev_t * by translating to the major number found on the installed * target's root name_to_major file. */ static int translate_major(dev_t old_dev, dev_t *new_dev) { major_t oldmajor; major_t newmajor; minor_t oldminor; minor_t newminor; char cdriver[FILENAME_MAX + 1]; char driver[FILENAME_MAX + 1]; char *fcn = "translate_major: "; oldmajor = major(old_dev); if (modctl(MODGETNAME, driver, sizeof (driver), &oldmajor) != 0) { return (DEVFSADM_FAILURE); } if (strcmp(driver, "clone") != 0) { /* non-clone case */ /* look up major number is target's name2major */ if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) { return (DEVFSADM_FAILURE); } *new_dev = makedev(newmajor, minor(old_dev)); if (old_dev != *new_dev) { vprint(CHATTY_MID, "%sdriver: %s old: %lu,%lu " "new: %lu,%lu\n", fcn, driver, major(old_dev), minor(old_dev), major(*new_dev), minor(*new_dev)); } return (DEVFSADM_SUCCESS); } else { /* * The clone is a special case. Look at its minor * number since it is the major number of the real driver. */ if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) { return (DEVFSADM_FAILURE); } oldminor = minor(old_dev); if (modctl(MODGETNAME, cdriver, sizeof (cdriver), &oldminor) != 0) { err_print(MODGETNAME_FAILED, oldminor); return (DEVFSADM_FAILURE); } if (get_major_no(cdriver, &newminor) == DEVFSADM_FAILURE) { return (DEVFSADM_FAILURE); } *new_dev = makedev(newmajor, newminor); if (old_dev != *new_dev) { vprint(CHATTY_MID, "%sdriver: %s old: " "%lu,%lu new: %lu,%lu\n", fcn, driver, major(old_dev), minor(old_dev), major(*new_dev), minor(*new_dev)); } return (DEVFSADM_SUCCESS); } } /* * * Find the major number for driver, searching the n2m_list that was * built in load_n2m_table(). */ static int get_major_no(char *driver, major_t *major) { n2m_t *ptr; for (ptr = n2m_list; ptr != NULL; ptr = ptr->next) { if (strcmp(ptr->driver, driver) == 0) { *major = ptr->major; return (DEVFSADM_SUCCESS); } } err_print(FIND_MAJOR_FAILED, driver); return (DEVFSADM_FAILURE); } /* * Loads a name_to_major table into memory. Used only for suninstall's * private -R option to devfsadm, to translate major numbers from the * running to the installed target disk. */ static int load_n2m_table(char *file) { FILE *fp; char line[1024], *cp; char driver[PATH_MAX + 1]; major_t major; n2m_t *ptr; int ln = 0; if ((fp = fopen(file, "r")) == NULL) { err_print(FOPEN_FAILED, file, strerror(errno)); return (DEVFSADM_FAILURE); } while (fgets(line, sizeof (line), fp) != NULL) { ln++; /* cut off comments starting with '#' */ if ((cp = strchr(line, '#')) != NULL) *cp = '\0'; /* ignore comment or blank lines */ if (is_blank(line)) continue; /* sanity-check */ if (sscanf(line, "%1024s%lu", driver, &major) != 2) { err_print(IGNORING_LINE_IN, ln, file); continue; } ptr = (n2m_t *)s_malloc(sizeof (n2m_t)); ptr->major = major; ptr->driver = s_strdup(driver); ptr->next = n2m_list; n2m_list = ptr; } if (fclose(fp) == EOF) { err_print(FCLOSE_FAILED, file, strerror(errno)); } return (DEVFSADM_SUCCESS); } /* * Called at devfsadm startup to read the file /etc/dev/enumerate_reserved * Creates a linked list of devlinks from which reserved IDs can be derived */ static void read_enumerate_file(void) { FILE *fp; int linenum; char line[PATH_MAX+1]; enumerate_file_t *entry; struct stat current_sb; static struct stat cached_sb; static int cached = FALSE; assert(enumerate_file); if (stat(enumerate_file, ¤t_sb) == -1) { vprint(RSRV_MID, "No reserved file: %s\n", enumerate_file); cached = FALSE; if (enumerate_reserved != NULL) { vprint(RSRV_MID, "invalidating %s cache\n", enumerate_file); } while (enumerate_reserved != NULL) { entry = enumerate_reserved; enumerate_reserved = entry->er_next; free(entry->er_file); free(entry->er_id); free(entry); } return; } /* if already cached, check to see if it is still valid */ if (cached == TRUE) { if (current_sb.st_mtime == cached_sb.st_mtime) { vprint(RSRV_MID, "%s cache valid\n", enumerate_file); vprint(FILES_MID, "%s cache valid\n", enumerate_file); return; } vprint(RSRV_MID, "invalidating %s cache\n", enumerate_file); vprint(FILES_MID, "invalidating %s cache\n", enumerate_file); while (enumerate_reserved != NULL) { entry = enumerate_reserved; enumerate_reserved = entry->er_next; free(entry->er_file); free(entry->er_id); free(entry); } vprint(RSRV_MID, "Recaching file: %s\n", enumerate_file); } else { vprint(RSRV_MID, "Caching file (first time): %s\n", enumerate_file); cached = TRUE; } (void) stat(enumerate_file, &cached_sb); if ((fp = fopen(enumerate_file, "r")) == NULL) { err_print(FOPEN_FAILED, enumerate_file, strerror(errno)); return; } vprint(RSRV_MID, "Reading reserve file: %s\n", enumerate_file); linenum = 0; while (fgets(line, sizeof (line), fp) != NULL) { char *cp, *ncp; linenum++; /* remove newline */ cp = strchr(line, '\n'); if (cp) *cp = '\0'; vprint(RSRV_MID, "Reserve file: line %d: %s\n", linenum, line); /* skip over space and tab */ for (cp = line; *cp == ' ' || *cp == '\t'; cp++) ; if (*cp == '\0' || *cp == '#') { vprint(RSRV_MID, "Skipping line: '%s'\n", line); continue; /* blank line or comment line */ } ncp = cp; /* delete trailing blanks */ for (; *cp != ' ' && *cp != '\t' && *cp != '\0'; cp++) ; *cp = '\0'; entry = s_zalloc(sizeof (enumerate_file_t)); entry->er_file = s_strdup(ncp); entry->er_id = NULL; entry->er_next = enumerate_reserved; enumerate_reserved = entry; } if (fclose(fp) == EOF) { err_print(FCLOSE_FAILED, enumerate_file, strerror(errno)); } } /* * Called at devfsadm startup to read in the devlink.tab file. Creates * a linked list of devlinktab_list structures which will be * searched for every minor node. */ static void read_devlinktab_file(void) { devlinktab_list_t *headp = NULL; devlinktab_list_t *entryp; devlinktab_list_t **previous; devlinktab_list_t *save; char line[MAX_DEVLINK_LINE], *cp; char *selector; char *p_link; char *s_link; FILE *fp; int i; static struct stat cached_sb; struct stat current_sb; static int cached = FALSE; if (devlinktab_file == NULL) { return; } (void) stat(devlinktab_file, ¤t_sb); /* if already cached, check to see if it is still valid */ if (cached == TRUE) { if (current_sb.st_mtime == cached_sb.st_mtime) { vprint(FILES_MID, "%s cache valid\n", devlinktab_file); return; } vprint(FILES_MID, "invalidating %s cache\n", devlinktab_file); while (devlinktab_list != NULL) { free_link_list(devlinktab_list->p_link); free_link_list(devlinktab_list->s_link); free_selector_list(devlinktab_list->selector); free(devlinktab_list->selector_pattern); free(devlinktab_list->p_link_pattern); if (devlinktab_list->s_link_pattern != NULL) { free(devlinktab_list->s_link_pattern); } save = devlinktab_list; devlinktab_list = devlinktab_list->next; free(save); } } else { cached = TRUE; } (void) stat(devlinktab_file, &cached_sb); if ((fp = fopen(devlinktab_file, "r")) == NULL) { err_print(FOPEN_FAILED, devlinktab_file, strerror(errno)); return; } previous = &headp; while (fgets(line, sizeof (line), fp) != NULL) { devlinktab_line++; i = strlen(line); if (line[i-1] == NEWLINE) { line[i-1] = '\0'; } else if (i == sizeof (line-1)) { err_print(LINE_TOO_LONG, devlinktab_line, devlinktab_file, sizeof (line)-1); while (((i = getc(fp)) != '\n') && (i != EOF)) ; continue; } /* cut off comments starting with '#' */ if ((cp = strchr(line, '#')) != NULL) *cp = '\0'; /* ignore comment or blank lines */ if (is_blank(line)) continue; vprint(DEVLINK_MID, "table: %s line %d: '%s'\n", devlinktab_file, devlinktab_line, line); /* break each entry into fields. s_link may be NULL */ if (split_devlinktab_entry(line, &selector, &p_link, &s_link) == DEVFSADM_FAILURE) { vprint(DEVLINK_MID, "split_entry returns failure\n"); continue; } else { vprint(DEVLINK_MID, "split_entry selector='%s' " "p_link='%s' s_link='%s'\n\n", selector, p_link, (s_link == NULL) ? "" : s_link); } entryp = (devlinktab_list_t *)s_malloc(sizeof (devlinktab_list_t)); entryp->line_number = devlinktab_line; if ((entryp->selector = create_selector_list(selector)) == NULL) { free(entryp); continue; } entryp->selector_pattern = s_strdup(selector); if ((entryp->p_link = create_link_list(p_link)) == NULL) { free_selector_list(entryp->selector); free(entryp->selector_pattern); free(entryp); continue; } entryp->p_link_pattern = s_strdup(p_link); if (s_link != NULL) { if ((entryp->s_link = create_link_list(s_link)) == NULL) { free_selector_list(entryp->selector); free_link_list(entryp->p_link); free(entryp->selector_pattern); free(entryp->p_link_pattern); free(entryp); continue; } entryp->s_link_pattern = s_strdup(s_link); } else { entryp->s_link = NULL; entryp->s_link_pattern = NULL; } /* append to end of list */ entryp->next = NULL; *previous = entryp; previous = &(entryp->next); } if (fclose(fp) == EOF) { err_print(FCLOSE_FAILED, devlinktab_file, strerror(errno)); } devlinktab_list = headp; } /* * * For a single line entry in devlink.tab, split the line into fields * selector, p_link, and an optionally s_link. If s_link field is not * present, then return NULL in s_link (not NULL string). */ static int split_devlinktab_entry(char *entry, char **selector, char **p_link, char **s_link) { char *tab; *selector = entry; if ((tab = strchr(entry, TAB)) != NULL) { *tab = '\0'; *p_link = ++tab; } else { err_print(MISSING_TAB, devlinktab_line, devlinktab_file); return (DEVFSADM_FAILURE); } if (**p_link == '\0') { err_print(MISSING_DEVNAME, devlinktab_line, devlinktab_file); return (DEVFSADM_FAILURE); } if ((tab = strchr(*p_link, TAB)) != NULL) { *tab = '\0'; *s_link = ++tab; if (strchr(*s_link, TAB) != NULL) { err_print(TOO_MANY_FIELDS, devlinktab_line, devlinktab_file); return (DEVFSADM_FAILURE); } } else { *s_link = NULL; } return (DEVFSADM_SUCCESS); } /* * For a given devfs_spec field, for each element in the field, add it to * a linked list of devfs_spec structures. Return the linked list in * devfs_spec_list. */ static selector_list_t * create_selector_list(char *selector) { char *key; char *val; int error = FALSE; selector_list_t *head_selector_list = NULL; selector_list_t *selector_list; /* parse_devfs_spec splits the next field into keyword & value */ while ((*selector != '\0') && (error == FALSE)) { if (parse_selector(&selector, &key, &val) == DEVFSADM_FAILURE) { error = TRUE; break; } else { selector_list = (selector_list_t *) s_malloc(sizeof (selector_list_t)); if (strcmp(NAME_S, key) == 0) { selector_list->key = NAME; } else if (strcmp(TYPE_S, key) == 0) { selector_list->key = TYPE; } else if (strncmp(ADDR_S, key, ADDR_S_LEN) == 0) { selector_list->key = ADDR; if (key[ADDR_S_LEN] == '\0') { selector_list->arg = 0; } else if (isdigit(key[ADDR_S_LEN]) != FALSE) { selector_list->arg = atoi(&key[ADDR_S_LEN]); } else { error = TRUE; free(selector_list); err_print(BADKEYWORD, key, devlinktab_line, devlinktab_file); break; } } else if (strncmp(MINOR_S, key, MINOR_S_LEN) == 0) { selector_list->key = MINOR; if (key[MINOR_S_LEN] == '\0') { selector_list->arg = 0; } else if (isdigit(key[MINOR_S_LEN]) != FALSE) { selector_list->arg = atoi(&key[MINOR_S_LEN]); } else { error = TRUE; free(selector_list); err_print(BADKEYWORD, key, devlinktab_line, devlinktab_file); break; } vprint(DEVLINK_MID, "MINOR = %s\n", val); } else { err_print(UNRECOGNIZED_KEY, key, devlinktab_line, devlinktab_file); error = TRUE; free(selector_list); break; } selector_list->val = s_strdup(val); selector_list->next = head_selector_list; head_selector_list = selector_list; vprint(DEVLINK_MID, "key='%s' val='%s' arg=%d\n", key, val, selector_list->arg); } } if ((error == FALSE) && (head_selector_list != NULL)) { return (head_selector_list); } else { /* parse failed. Free any allocated structs */ free_selector_list(head_selector_list); return (NULL); } } /* * Takes a semicolon separated list of selector elements and breaks up * into a keyword-value pair. semicolon and equal characters are * replaced with NULL's. On success, selector is updated to point to the * terminating NULL character terminating the keyword-value pair, and the * function returns DEVFSADM_SUCCESS. If there is a syntax error, * devfs_spec is not modified and function returns DEVFSADM_FAILURE. */ static int parse_selector(char **selector, char **key, char **val) { char *equal; char *semi_colon; *key = *selector; if ((equal = strchr(*key, '=')) != NULL) { *equal = '\0'; } else { err_print(MISSING_EQUAL, devlinktab_line, devlinktab_file); return (DEVFSADM_FAILURE); } *val = ++equal; if ((semi_colon = strchr(equal, ';')) != NULL) { *semi_colon = '\0'; *selector = semi_colon + 1; } else { *selector = equal + strlen(equal); } return (DEVFSADM_SUCCESS); } /* * link is either the second or third field of devlink.tab. Parse link * into a linked list of devlink structures and return ptr to list. Each * list element is either a constant string, or one of the following * escape sequences: \M, \A, \N, or \D. The first three escape sequences * take a numerical argument. */ static link_list_t * create_link_list(char *link) { int x = 0; int error = FALSE; int counter_found = FALSE; link_list_t *head = NULL; link_list_t **ptr; link_list_t *link_list; char constant[MAX_DEVLINK_LINE]; char *error_str; if (link == NULL) { return (NULL); } while ((*link != '\0') && (error == FALSE)) { link_list = (link_list_t *)s_malloc(sizeof (link_list_t)); link_list->next = NULL; while ((*link != '\0') && (*link != '\\')) { /* a non-escaped string */ constant[x++] = *(link++); } if (x != 0) { constant[x] = '\0'; link_list->type = CONSTANT; link_list->constant = s_strdup(constant); x = 0; vprint(DEVLINK_MID, "CONSTANT FOUND %s\n", constant); } else { switch (*(++link)) { case 'M': link_list->type = MINOR; break; case 'A': link_list->type = ADDR; break; case 'N': if (counter_found == TRUE) { error = TRUE; error_str = "multiple counters not permitted"; free(link_list); } else { counter_found = TRUE; link_list->type = COUNTER; } break; case 'D': link_list->type = NAME; break; default: error = TRUE; free(link_list); error_str = "unrecognized escape sequence"; break; } if (*(link++) != 'D') { if (isdigit(*link) == FALSE) { error_str = "escape sequence must be " "followed by a digit\n"; error = TRUE; free(link_list); } else { link_list->arg = (int)strtoul(link, &link, 10); vprint(DEVLINK_MID, "link_list->arg = " "%d\n", link_list->arg); } } } /* append link_list struct to end of list */ if (error == FALSE) { for (ptr = &head; *ptr != NULL; ptr = &((*ptr)->next)) ; *ptr = link_list; } } if (error == FALSE) { return (head); } else { err_print(CONFIG_INCORRECT, devlinktab_line, devlinktab_file, error_str); free_link_list(head); return (NULL); } } /* * Called for each minor node devfsadm processes; for each minor node, * look for matches in the devlinktab_list list which was created on * startup read_devlinktab_file(). If there is a match, call build_links() * to build a logical devlink and a possible extra devlink. */ static int process_devlink_compat(di_minor_t minor, di_node_t node) { int link_built = FALSE; devlinktab_list_t *entry; char *nodetype; char *dev_path; if (devlinks_debug == TRUE) { nodetype = di_minor_nodetype(minor); assert(nodetype != NULL); if ((dev_path = di_devfs_path(node)) != NULL) { vprint(INFO_MID, "'%s' entry: %s:%s\n", nodetype, dev_path, di_minor_name(minor) ? di_minor_name(minor) : ""); di_devfs_path_free(dev_path); } } /* don't process devlink.tab if devfsadm invoked with -c */ if (num_classes > 0) { return (FALSE); } for (entry = devlinktab_list; entry != NULL; entry = entry->next) { if (devlink_matches(entry, minor, node) == DEVFSADM_SUCCESS) { link_built = TRUE; (void) build_links(entry, minor, node); } } return (link_built); } /* * For a given devlink.tab devlinktab_list entry, see if the selector * field matches this minor node. If it does, return DEVFSADM_SUCCESS, * otherwise DEVFSADM_FAILURE. */ static int devlink_matches(devlinktab_list_t *entry, di_minor_t minor, di_node_t node) { selector_list_t *selector = entry->selector; char *addr; char *minor_name; char *node_type; for (; selector != NULL; selector = selector->next) { switch (selector->key) { case NAME: if (strcmp(di_node_name(node), selector->val) != 0) { return (DEVFSADM_FAILURE); } break; case TYPE: node_type = di_minor_nodetype(minor); assert(node_type != NULL); if (strcmp(node_type, selector->val) != 0) { return (DEVFSADM_FAILURE); } break; case ADDR: if ((addr = di_bus_addr(node)) == NULL) { return (DEVFSADM_FAILURE); } if (selector->arg == 0) { if (strcmp(addr, selector->val) != 0) { return (DEVFSADM_FAILURE); } } else { if (compare_field(addr, selector->val, selector->arg) == DEVFSADM_FAILURE) { return (DEVFSADM_FAILURE); } } break; case MINOR: if ((minor_name = di_minor_name(minor)) == NULL) { return (DEVFSADM_FAILURE); } if (selector->arg == 0) { if (strcmp(minor_name, selector->val) != 0) { return (DEVFSADM_FAILURE); } } else { if (compare_field(minor_name, selector->val, selector->arg) == DEVFSADM_FAILURE) { return (DEVFSADM_FAILURE); } } break; default: return (DEVFSADM_FAILURE); } } return (DEVFSADM_SUCCESS); } /* * For the given minor node and devlinktab_list entry from devlink.tab, * build a logical dev link and a possible extra devlink. * Return DEVFSADM_SUCCESS if link is created, otherwise DEVFSADM_FAILURE. */ static int build_links(devlinktab_list_t *entry, di_minor_t minor, di_node_t node) { char secondary_link[PATH_MAX + 1]; char primary_link[PATH_MAX + 1]; char contents[PATH_MAX + 1]; char *dev_path; if ((dev_path = di_devfs_path(node)) == NULL) { err_print(DI_DEVFS_PATH_FAILED, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } (void) strcpy(contents, dev_path); di_devfs_path_free(dev_path); (void) strcat(contents, ":"); (void) strcat(contents, di_minor_name(minor)); if (construct_devlink(primary_link, entry->p_link, contents, minor, node, entry->p_link_pattern) == DEVFSADM_FAILURE) { return (DEVFSADM_FAILURE); } (void) devfsadm_mklink(primary_link, node, minor, 0); if (entry->s_link == NULL) { return (DEVFSADM_SUCCESS); } if (construct_devlink(secondary_link, entry->s_link, primary_link, minor, node, entry->s_link_pattern) == DEVFSADM_FAILURE) { return (DEVFSADM_FAILURE); } (void) devfsadm_secondary_link(secondary_link, primary_link, 0); return (DEVFSADM_SUCCESS); } /* * The counter rule for devlink.tab entries is implemented via * devfsadm_enumerate_int_start(). One of the arguments to this function * is a path, where each path component is treated as a regular expression. * For devlink.tab entries, this path regular expression is derived from * the devlink spec. get_anchored_re() accepts path regular expressions derived * from devlink.tab entries and inserts the anchors '^' and '$' at the beginning * and end respectively of each path component. This is done to prevent * false matches. For example, without anchors, "a/([0-9]+)" will match "ab/c9" * and incorrect links will be generated. */ static int get_anchored_re(char *link, char *anchored_re, char *pattern) { if (*link == '/' || *link == '\0') { err_print(INVALID_DEVLINK_SPEC, pattern); return (DEVFSADM_FAILURE); } *anchored_re++ = '^'; for (; *link != '\0'; ) { if (*link == '/') { while (*link == '/') link++; *anchored_re++ = '$'; *anchored_re++ = '/'; if (*link != '\0') { *anchored_re++ = '^'; } } else { *anchored_re++ = *link++; if (*link == '\0') { *anchored_re++ = '$'; } } } *anchored_re = '\0'; return (DEVFSADM_SUCCESS); } static int construct_devlink(char *link, link_list_t *link_build, char *contents, di_minor_t minor, di_node_t node, char *pattern) { int counter_offset = -1; devfsadm_enumerate_t rules[1] = {NULL}; char templink[PATH_MAX + 1]; char *buff; char start[10]; char *node_path; char anchored_re[PATH_MAX + 1]; link[0] = '\0'; for (; link_build != NULL; link_build = link_build->next) { switch (link_build->type) { case NAME: (void) strcat(link, di_node_name(node)); break; case CONSTANT: (void) strcat(link, link_build->constant); break; case ADDR: if (component_cat(link, di_bus_addr(node), link_build->arg) == DEVFSADM_FAILURE) { node_path = di_devfs_path(node); err_print(CANNOT_BE_USED, pattern, node_path, di_minor_name(minor)); di_devfs_path_free(node_path); return (DEVFSADM_FAILURE); } break; case MINOR: if (component_cat(link, di_minor_name(minor), link_build->arg) == DEVFSADM_FAILURE) { node_path = di_devfs_path(node); err_print(CANNOT_BE_USED, pattern, node_path, di_minor_name(minor)); di_devfs_path_free(node_path); return (DEVFSADM_FAILURE); } break; case COUNTER: counter_offset = strlen(link); (void) strcat(link, "([0-9]+)"); (void) sprintf(start, "%d", link_build->arg); break; default: return (DEVFSADM_FAILURE); } } if (counter_offset != -1) { /* * copy anything appended after "([0-9]+)" into * templink */ (void) strcpy(templink, &link[counter_offset + strlen("([0-9]+)")]); if (get_anchored_re(link, anchored_re, pattern) != DEVFSADM_SUCCESS) { return (DEVFSADM_FAILURE); } rules[0].re = anchored_re; rules[0].subexp = 1; rules[0].flags = MATCH_ALL; if (devfsadm_enumerate_int_start(contents, 0, &buff, rules, 1, start) == DEVFSADM_FAILURE) { return (DEVFSADM_FAILURE); } (void) strcpy(&link[counter_offset], buff); free(buff); (void) strcat(link, templink); vprint(DEVLINK_MID, "COUNTER is %s\n", link); } return (DEVFSADM_SUCCESS); } /* * Compares "field" number of the comma separated list "full_name" with * field_item. Returns DEVFSADM_SUCCESS for match, * DEVFSADM_FAILURE for no match. */ static int compare_field(char *full_name, char *field_item, int field) { --field; while ((*full_name != '\0') && (field != 0)) { if (*(full_name++) == ',') { field--; } } if (field != 0) { return (DEVFSADM_FAILURE); } while ((*full_name != '\0') && (*field_item != '\0') && (*full_name != ',')) { if (*(full_name++) != *(field_item++)) { return (DEVFSADM_FAILURE); } } if (*field_item != '\0') { return (DEVFSADM_FAILURE); } if ((*full_name == '\0') || (*full_name == ',')) return (DEVFSADM_SUCCESS); return (DEVFSADM_FAILURE); } /* * strcat() field # "field" of comma separated list "name" to "link". * Field 0 is the entire name. * Return DEVFSADM_SUCCESS or DEVFSADM_FAILURE. */ static int component_cat(char *link, char *name, int field) { if (name == NULL) { return (DEVFSADM_FAILURE); } if (field == 0) { (void) strcat(link, name); return (DEVFSADM_SUCCESS); } while (*link != '\0') { link++; } --field; while ((*name != '\0') && (field != 0)) { if (*(name++) == ',') { --field; } } if (field != 0) { return (DEVFSADM_FAILURE); } while ((*name != '\0') && (*name != ',')) { *(link++) = *(name++); } *link = '\0'; return (DEVFSADM_SUCCESS); } static void free_selector_list(selector_list_t *head) { selector_list_t *temp; while (head != NULL) { temp = head; head = head->next; free(temp->val); free(temp); } } static void free_link_list(link_list_t *head) { link_list_t *temp; while (head != NULL) { temp = head; head = head->next; if (temp->type == CONSTANT) { free(temp->constant); } free(temp); } } /* * Prints only if level matches one of the debug levels * given on command line. INFO_MID is always printed. * * See devfsadm.h for a listing of globally defined levels and * meanings. Modules should prefix the level with their * module name to prevent collisions. */ /*PRINTFLIKE2*/ void devfsadm_print(char *msgid, char *message, ...) { va_list ap; static int newline = TRUE; int x; if (msgid != NULL) { for (x = 0; x < num_verbose; x++) { if (strcmp(verbose[x], msgid) == 0) { break; } if (strcmp(verbose[x], ALL_MID) == 0) { break; } } if (x == num_verbose) { return; } } va_start(ap, message); if (msgid == NULL) { if (logflag == TRUE) { (void) vsyslog(LOG_NOTICE, message, ap); } else { (void) vfprintf(stdout, message, ap); } } else { if (logflag == TRUE) { (void) syslog(LOG_DEBUG, "%s[%ld]: %s: ", prog, getpid(), msgid); (void) vsyslog(LOG_DEBUG, message, ap); } else { if (newline == TRUE) { (void) fprintf(stdout, "%s[%ld]: %s: ", prog, getpid(), msgid); } (void) vfprintf(stdout, message, ap); } } if (message[strlen(message) - 1] == '\n') { newline = TRUE; } else { newline = FALSE; } va_end(ap); } /* * print error messages to the terminal or to syslog */ /*PRINTFLIKE1*/ void devfsadm_errprint(char *message, ...) { va_list ap; va_start(ap, message); if (logflag == TRUE) { (void) vsyslog(LOG_ERR, message, ap); } else { (void) fprintf(stderr, "%s: ", prog); (void) vfprintf(stderr, message, ap); } va_end(ap); } /* * return noupdate state (-s) */ int devfsadm_noupdate(void) { return (file_mods == TRUE ? DEVFSADM_TRUE : DEVFSADM_FALSE); } /* * return current root update path (-r) */ const char * devfsadm_root_path(void) { if (root_dir[0] == '\0') { return ("/"); } else { return ((const char *)root_dir); } } void devfsadm_free_dev_names(char **dev_names, int len) { int i; for (i = 0; i < len; i++) free(dev_names[i]); free(dev_names); } /* * Return all devlinks corresponding to phys_path as an array of strings. * The number of entries in the array is returned through lenp. * devfsadm_free_dev_names() is used to free the returned array. * NULL is returned on failure or when there are no matching devlinks. * * re is an extended regular expression in regex(7) format used to further * match devlinks pointing to phys_path; it may be NULL to match all */ char ** devfsadm_lookup_dev_names(char *phys_path, char *re, int *lenp) { struct devlink_cb_arg cb_arg; char **dev_names = NULL; int i; *lenp = 0; cb_arg.count = 0; cb_arg.rv = 0; (void) di_devlink_cache_walk(devlink_cache, re, phys_path, DI_PRIMARY_LINK, &cb_arg, devlink_cb); if (cb_arg.rv == -1 || cb_arg.count <= 0) return (NULL); dev_names = s_malloc(cb_arg.count * sizeof (char *)); if (dev_names == NULL) goto out; for (i = 0; i < cb_arg.count; i++) { dev_names[i] = s_strdup(cb_arg.dev_names[i]); if (dev_names[i] == NULL) { devfsadm_free_dev_names(dev_names, i); dev_names = NULL; goto out; } } *lenp = cb_arg.count; out: free_dev_names(&cb_arg); return (dev_names); } /* common exit function which ensures releasing locks */ static void devfsadm_exit(int status) { if (DEVFSADM_DEBUG_ON) { vprint(INFO_MID, "exit status = %d\n", status); } exit_dev_lock(1); exit_daemon_lock(1); if (logflag == TRUE) { closelog(); } exit(status); /*NOTREACHED*/ } /* * set root_dir, devices_dir, dev_dir using optarg. */ static void set_root_devices_dev_dir(char *dir) { size_t len; root_dir = s_strdup(dir); len = strlen(dir) + strlen(DEVICES) + 1; devices_dir = s_malloc(len); (void) snprintf(devices_dir, len, "%s%s", root_dir, DEVICES); len = strlen(root_dir) + strlen(DEV) + 1; dev_dir = s_malloc(len); (void) snprintf(dev_dir, len, "%s%s", root_dir, DEV); } /* * Removes quotes. */ static char * dequote(char *src) { char *dst; int len; len = strlen(src); dst = s_malloc(len + 1); if (src[0] == '\"' && src[len - 1] == '\"') { len -= 2; (void) strncpy(dst, &src[1], len); dst[len] = '\0'; } else { (void) strcpy(dst, src); } return (dst); } /* * For a given physical device pathname and spectype, return the * ownership and permissions attributes by looking in data from * /etc/minor_perm. If currently in installation mode, check for * possible major number translations from the miniroot to the installed * root's name_to_major table. Note that there can be multiple matches, * but the last match takes effect. pts seems to rely on this * implementation behavior. */ static void getattr(char *phy_path, char *aminor, int spectype, dev_t dev, mode_t *mode, uid_t *uid, gid_t *gid) { char devname[PATH_MAX + 1]; char *node_name; char *minor_name; int match = FALSE; int is_clone; int mp_drvname_matches_node_name; int mp_drvname_matches_minor_name; int mp_drvname_is_clone; int mp_drvname_matches_drvname; struct mperm *mp; major_t major_no; char driver[PATH_MAX + 1]; /* * Get the driver name based on the major number since the name * in /devices may be generic. Could be running with more major * numbers than are in /etc/name_to_major, so get it from the kernel */ major_no = major(dev); if (modctl(MODGETNAME, driver, sizeof (driver), &major_no) != 0) { /* return default values */ goto use_defaults; } (void) strcpy(devname, phy_path); node_name = strrchr(devname, '/'); /* node name is the last */ /* component */ if (node_name == NULL) { err_print(NO_NODE, devname); goto use_defaults; } minor_name = strchr(++node_name, '@'); /* see if it has address part */ if (minor_name != NULL) { *minor_name++ = '\0'; } else { minor_name = node_name; } minor_name = strchr(minor_name, ':'); /* look for minor name */ if (minor_name == NULL) { err_print(NO_MINOR, devname); goto use_defaults; } *minor_name++ = '\0'; /* * mp->mp_drvname = device name from minor_perm * mp->mp_minorname = minor part of device name from * minor_perm * drvname = name of driver for this device */ is_clone = (strcmp(node_name, "clone") == 0 ? TRUE : FALSE); for (mp = minor_perms; mp != NULL; mp = mp->mp_next) { mp_drvname_matches_node_name = (strcmp(mp->mp_drvname, node_name) == 0 ? TRUE : FALSE); mp_drvname_matches_minor_name = (strcmp(mp->mp_drvname, minor_name) == 0 ? TRUE:FALSE); mp_drvname_is_clone = (strcmp(mp->mp_drvname, "clone") == 0 ? TRUE : FALSE); mp_drvname_matches_drvname = (strcmp(mp->mp_drvname, driver) == 0 ? TRUE : FALSE); /* * If one of the following cases is true, then we try to change * the permissions if a "shell global pattern match" of * mp_>mp_minorname matches minor_name. * * 1. mp->mp_drvname matches driver. * * OR * * 2. mp->mp_drvname matches node_name and this * name is an alias of the driver name * * OR * * 3. /devices entry is the clone device and either * minor_perm entry is the clone device or matches * the minor part of the clone device. */ if ((mp_drvname_matches_drvname == TRUE)|| ((mp_drvname_matches_node_name == TRUE) && (alias(driver, node_name) == TRUE)) || ((is_clone == TRUE) && ((mp_drvname_is_clone == TRUE) || (mp_drvname_matches_minor_name == TRUE)))) { /* * Check that the minor part of the * device name from the minor_perm * entry matches and if so, set the * permissions. * * Under real devfs, clone minor name is changed * to match the driver name, but minor_perm may * not match. We reconcile it here. */ if (aminor != NULL) minor_name = aminor; if (gmatch(minor_name, mp->mp_minorname) != 0) { *uid = mp->mp_uid; *gid = mp->mp_gid; *mode = spectype | mp->mp_mode; match = TRUE; } } } if (match == TRUE) { return; } use_defaults: /* not found in minor_perm, so just use default values */ *uid = root_uid; *gid = sys_gid; *mode = (spectype | 0600); } /* * Called by devfs_read_minor_perm() to report errors * key is: * line number: ignoring line number error * errno: open/close errors * size: alloc errors */ static void minorperm_err_cb(minorperm_err_t mp_err, int key) { switch (mp_err) { case MP_FOPEN_ERR: err_print(FOPEN_FAILED, MINOR_PERM_FILE, strerror(key)); break; case MP_FCLOSE_ERR: err_print(FCLOSE_FAILED, MINOR_PERM_FILE, strerror(key)); break; case MP_IGNORING_LINE_ERR: err_print(IGNORING_LINE_IN, key, MINOR_PERM_FILE); break; case MP_ALLOC_ERR: err_print(MALLOC_FAILED, key); break; case MP_NVLIST_ERR: err_print(NVLIST_ERROR, MINOR_PERM_FILE, strerror(key)); break; case MP_CANT_FIND_USER_ERR: err_print(CANT_FIND_USER, DEFAULT_DEV_USER); break; case MP_CANT_FIND_GROUP_ERR: err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP); break; } } static void read_minor_perm_file(void) { static int cached = FALSE; static struct stat cached_sb; struct stat current_sb; (void) stat(MINOR_PERM_FILE, ¤t_sb); /* If already cached, check to see if it is still valid */ if (cached == TRUE) { if (current_sb.st_mtime == cached_sb.st_mtime) { vprint(FILES_MID, "%s cache valid\n", MINOR_PERM_FILE); return; } devfs_free_minor_perm(minor_perms); minor_perms = NULL; } else { cached = TRUE; } (void) stat(MINOR_PERM_FILE, &cached_sb); vprint(FILES_MID, "loading binding file: %s\n", MINOR_PERM_FILE); minor_perms = devfs_read_minor_perm(minorperm_err_cb); } static void load_minor_perm_file(void) { read_minor_perm_file(); if (devfs_load_minor_perm(minor_perms, minorperm_err_cb) != 0) err_print(gettext("minor_perm load failed\n")); } static char * convert_to_re(char *dev) { char *p, *l, *out; int i; out = s_malloc(PATH_MAX); for (l = p = dev, i = 0; (*p != '\0') && (i < (PATH_MAX - 1)); ++p, i++) { if ((*p == '*') && ((l != p) && (*l == '/'))) { out[i++] = '.'; out[i] = '+'; } else { out[i] = *p; } l = p; } out[i] = '\0'; p = (char *)s_malloc(strlen(out) + 1); (void) strlcpy(p, out, strlen(out) + 1); free(out); vprint(FILES_MID, "converted %s -> %s\n", dev, p); return (p); } static void read_logindevperm_file(void) { static int cached = FALSE; static struct stat cached_sb; struct stat current_sb; struct login_dev *ldev; FILE *fp; char line[MAX_LDEV_LINE]; int ln, perm, rv; char *cp, *console, *dlist, *dev; char *lasts, *devlasts, *permstr, *drv; struct driver_list *list, *next; /* Read logindevperm only when enabled */ if (login_dev_enable != TRUE) return; if (cached == TRUE) { if (stat(LDEV_FILE, ¤t_sb) == 0 && current_sb.st_mtime == cached_sb.st_mtime) { vprint(FILES_MID, "%s cache valid\n", LDEV_FILE); return; } vprint(FILES_MID, "invalidating %s cache\n", LDEV_FILE); while (login_dev_cache != NULL) { ldev = login_dev_cache; login_dev_cache = ldev->ldev_next; free(ldev->ldev_console); free(ldev->ldev_device); regfree(&ldev->ldev_device_regex); list = ldev->ldev_driver_list; while (list) { next = list->next; free(list); list = next; } free(ldev); } } else { cached = TRUE; } assert(login_dev_cache == NULL); if (stat(LDEV_FILE, &cached_sb) != 0) { cached = FALSE; return; } vprint(FILES_MID, "loading file: %s\n", LDEV_FILE); if ((fp = fopen(LDEV_FILE, "r")) == NULL) { /* Not fatal to devfsadm */ cached = FALSE; err_print(FOPEN_FAILED, LDEV_FILE, strerror(errno)); return; } ln = 0; while (fgets(line, MAX_LDEV_LINE, fp) != NULL) { ln++; /* Remove comments */ if ((cp = strchr(line, '#')) != NULL) *cp = '\0'; if ((console = strtok_r(line, LDEV_DELIMS, &lasts)) == NULL) continue; /* Blank line */ if ((permstr = strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) { err_print(IGNORING_LINE_IN, ln, LDEV_FILE); continue; /* Malformed line */ } /* * permstr is string in octal format. Convert to int */ cp = NULL; errno = 0; perm = strtol(permstr, &cp, 8); if (errno || perm < 0 || perm > 0777 || *cp != '\0') { err_print(IGNORING_LINE_IN, ln, LDEV_FILE); continue; } if ((dlist = strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) { err_print(IGNORING_LINE_IN, ln, LDEV_FILE); continue; } dev = strtok_r(dlist, LDEV_DEV_DELIM, &devlasts); while (dev) { ldev = (struct login_dev *)s_zalloc( sizeof (struct login_dev)); ldev->ldev_console = s_strdup(console); ldev->ldev_perms = perm; /* * the logical device name may contain '*' which * we convert to a regular expression */ ldev->ldev_device = convert_to_re(dev); if (ldev->ldev_device && (rv = regcomp(&ldev->ldev_device_regex, ldev->ldev_device, REG_EXTENDED))) { bzero(&ldev->ldev_device_regex, sizeof (ldev->ldev_device_regex)); err_print(REGCOMP_FAILED, ldev->ldev_device, rv); } ldev->ldev_next = login_dev_cache; login_dev_cache = ldev; dev = strtok_r(NULL, LDEV_DEV_DELIM, &devlasts); } drv = strtok_r(NULL, LDEV_DRVLIST_DELIMS, &lasts); if (drv) { if (strcmp(drv, LDEV_DRVLIST_NAME) == 0) { drv = strtok_r(NULL, LDEV_DRV_DELIMS, &lasts); while (drv) { vprint(FILES_MID, "logindevperm driver=%s\n", drv); /* * create a linked list of driver * names */ list = (struct driver_list *) s_zalloc( sizeof (struct driver_list)); (void) strlcpy(list->driver_name, drv, sizeof (list->driver_name)); list->next = ldev->ldev_driver_list; ldev->ldev_driver_list = list; drv = strtok_r(NULL, LDEV_DRV_DELIMS, &lasts); } } } } (void) fclose(fp); } /* * Tokens are separated by ' ', '\t', ':', '=', '&', '|', ';', '\n', or '\0' * * Returns DEVFSADM_SUCCESS if token found, DEVFSADM_FAILURE otherwise. */ static int getnexttoken(char *next, char **nextp, char **tokenpp, char *tchar) { char *cp; char *cp1; char *tokenp; cp = next; while (*cp == ' ' || *cp == '\t') { cp++; /* skip leading spaces */ } tokenp = cp; /* start of token */ while (*cp != '\0' && *cp != '\n' && *cp != ' ' && *cp != '\t' && *cp != ':' && *cp != '=' && *cp != '&' && *cp != '|' && *cp != ';') { cp++; /* point to next character */ } /* * If terminating character is a space or tab, look ahead to see if * there's another terminator that's not a space or a tab. * (This code handles trailing spaces.) */ if (*cp == ' ' || *cp == '\t') { cp1 = cp; while (*++cp1 == ' ' || *cp1 == '\t') ; if (*cp1 == '=' || *cp1 == ':' || *cp1 == '&' || *cp1 == '|' || *cp1 == ';' || *cp1 == '\n' || *cp1 == '\0') { *cp = '\0'; /* terminate token */ cp = cp1; } } if (tchar != NULL) { *tchar = *cp; /* save terminating character */ if (*tchar == '\0') { *tchar = '\n'; } } *cp++ = '\0'; /* terminate token, point to next */ *nextp = cp; /* set pointer to next character */ if (cp - tokenp - 1 == 0) { return (DEVFSADM_FAILURE); } *tokenpp = tokenp; return (DEVFSADM_SUCCESS); } /* * read or reread the driver aliases file */ static void read_driver_aliases_file(void) { driver_alias_t *save; driver_alias_t *lst_tail; driver_alias_t *ap; static int cached = FALSE; FILE *afd; char line[256]; char *cp; char *p; char t; int ln = 0; static struct stat cached_sb; struct stat current_sb; (void) stat(ALIASFILE, ¤t_sb); /* If already cached, check to see if it is still valid */ if (cached == TRUE) { if (current_sb.st_mtime == cached_sb.st_mtime) { vprint(FILES_MID, "%s cache valid\n", ALIASFILE); return; } vprint(FILES_MID, "invalidating %s cache\n", ALIASFILE); while (driver_aliases != NULL) { free(driver_aliases->alias_name); free(driver_aliases->driver_name); save = driver_aliases; driver_aliases = driver_aliases->next; free(save); } } else { cached = TRUE; } (void) stat(ALIASFILE, &cached_sb); vprint(FILES_MID, "loading binding file: %s\n", ALIASFILE); if ((afd = fopen(ALIASFILE, "r")) == NULL) { err_print(FOPEN_FAILED, ALIASFILE, strerror(errno)); devfsadm_exit(1); /*NOTREACHED*/ } while (fgets(line, sizeof (line), afd) != NULL) { ln++; /* cut off comments starting with '#' */ if ((cp = strchr(line, '#')) != NULL) *cp = '\0'; /* ignore comment or blank lines */ if (is_blank(line)) continue; cp = line; if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) { err_print(IGNORING_LINE_IN, ln, ALIASFILE); continue; } if (t == '\n' || t == '\0') { err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE); continue; } ap = (struct driver_alias *) s_zalloc(sizeof (struct driver_alias)); ap->driver_name = s_strdup(p); if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) { err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE); free(ap->driver_name); free(ap); continue; } if (*p == '"') { if (p[strlen(p) - 1] == '"') { p[strlen(p) - 1] = '\0'; p++; } } ap->alias_name = s_strdup(p); if (driver_aliases == NULL) { driver_aliases = ap; lst_tail = ap; } else { lst_tail->next = ap; lst_tail = ap; } } if (fclose(afd) == EOF) { err_print(FCLOSE_FAILED, ALIASFILE, strerror(errno)); } } /* * return TRUE if alias_name is an alias for driver_name, otherwise * return FALSE. */ static int alias(char *driver_name, char *alias_name) { driver_alias_t *alias; /* * check for a match */ for (alias = driver_aliases; alias != NULL; alias = alias->next) { if ((strcmp(alias->driver_name, driver_name) == 0) && (strcmp(alias->alias_name, alias_name) == 0)) { return (TRUE); } } return (FALSE); } /* * convenience functions */ static int s_stat(const char *path, struct stat *sbufp) { int rv; retry: if ((rv = stat(path, sbufp)) == -1) { if (errno == EINTR) goto retry; } return (rv); } static void * s_malloc(const size_t size) { void *rp; rp = malloc(size); if (rp == NULL) { err_print(MALLOC_FAILED, size); devfsadm_exit(1); /*NOTREACHED*/ } return (rp); } /* * convenience functions */ static void * s_realloc(void *ptr, const size_t size) { ptr = realloc(ptr, size); if (ptr == NULL) { err_print(REALLOC_FAILED, size); devfsadm_exit(1); /*NOTREACHED*/ } return (ptr); } static void * s_zalloc(const size_t size) { void *rp; rp = calloc(1, size); if (rp == NULL) { err_print(CALLOC_FAILED, size); devfsadm_exit(1); /*NOTREACHED*/ } return (rp); } char * s_strdup(const char *ptr) { void *rp; rp = strdup(ptr); if (rp == NULL) { err_print(STRDUP_FAILED, ptr); devfsadm_exit(1); /*NOTREACHED*/ } return (rp); } static void s_closedir(DIR *dirp) { retry: if (closedir(dirp) != 0) { if (errno == EINTR) goto retry; err_print(CLOSEDIR_FAILED, strerror(errno)); } } static void s_mkdirp(const char *path, const mode_t mode) { vprint(CHATTY_MID, "mkdirp(%s, 0x%lx)\n", path, mode); if (mkdirp(path, mode) == -1) { if (errno != EEXIST) { err_print(MKDIR_FAILED, path, mode, strerror(errno)); } } } static void s_unlink(const char *file) { retry: if (unlink(file) == -1) { if (errno == EINTR || errno == EAGAIN) goto retry; if (errno != ENOENT) { err_print(UNLINK_FAILED, file, strerror(errno)); } } } static void add_verbose_id(char *mid) { num_verbose++; verbose = s_realloc(verbose, num_verbose * sizeof (char *)); verbose[num_verbose - 1] = mid; } /* * returns DEVFSADM_TRUE if contents is a minor node in /devices. * If mn_root is not NULL, mn_root is set to: * if contents is a /dev node, mn_root = contents * OR * if contents is a /devices node, mn_root set to the '/' * following /devices. */ static int is_minor_node(char *contents, char **mn_root) { char *ptr; char device_prefix[100]; (void) snprintf(device_prefix, sizeof (device_prefix), "../devices/"); if ((ptr = strstr(contents, device_prefix)) != NULL) { if (mn_root != NULL) { /* mn_root should point to the / following /devices */ *mn_root = ptr += strlen(device_prefix) - 1; } return (DEVFSADM_TRUE); } (void) snprintf(device_prefix, sizeof (device_prefix), "/devices/"); if (strncmp(contents, device_prefix, strlen(device_prefix)) == 0) { if (mn_root != NULL) { /* mn_root should point to the / following /devices */ *mn_root = contents + strlen(device_prefix) - 1; } return (DEVFSADM_TRUE); } if (mn_root != NULL) { *mn_root = contents; } return (DEVFSADM_FALSE); } /* * Add the specified property to nvl. * Returns: * 0 successfully added * -1 an error occurred * 1 could not add the property for reasons not due to errors. */ static int add_property(nvlist_t *nvl, di_prop_t prop) { char *name; char *attr_name; int n, len; int32_t *int32p; int64_t *int64p; char *str; char **strarray; uchar_t *bytep; int rv = 0; int i; if ((name = di_prop_name(prop)) == NULL) return (-1); len = sizeof (DEV_PROP_PREFIX) + strlen(name); if ((attr_name = malloc(len)) == NULL) return (-1); (void) strlcpy(attr_name, DEV_PROP_PREFIX, len); (void) strlcat(attr_name, name, len); switch (di_prop_type(prop)) { case DI_PROP_TYPE_BOOLEAN: if (nvlist_add_boolean(nvl, attr_name) != 0) goto out; break; case DI_PROP_TYPE_INT: if ((n = di_prop_ints(prop, &int32p)) < 1) goto out; if (n <= (PROP_LEN_LIMIT / sizeof (int32_t))) { if (nvlist_add_int32_array(nvl, attr_name, int32p, n) != 0) goto out; } else rv = 1; break; case DI_PROP_TYPE_INT64: if ((n = di_prop_int64(prop, &int64p)) < 1) goto out; if (n <= (PROP_LEN_LIMIT / sizeof (int64_t))) { if (nvlist_add_int64_array(nvl, attr_name, int64p, n) != 0) goto out; } else rv = 1; break; case DI_PROP_TYPE_BYTE: case DI_PROP_TYPE_UNKNOWN: if ((n = di_prop_bytes(prop, &bytep)) < 1) goto out; if (n <= PROP_LEN_LIMIT) { if (nvlist_add_byte_array(nvl, attr_name, bytep, n) != 0) goto out; } else rv = 1; break; case DI_PROP_TYPE_STRING: if ((n = di_prop_strings(prop, &str)) < 1) goto out; if ((strarray = malloc(n * sizeof (char *))) == NULL) goto out; len = 0; for (i = 0; i < n; i++) { strarray[i] = str + len; len += strlen(strarray[i]) + 1; } if (len <= PROP_LEN_LIMIT) { if (nvlist_add_string_array(nvl, attr_name, strarray, n) != 0) { free(strarray); goto out; } } else rv = 1; free(strarray); break; default: rv = 1; break; } free(attr_name); return (rv); out: free(attr_name); return (-1); } static void free_dev_names(struct devlink_cb_arg *x) { int i; for (i = 0; i < x->count; i++) { free(x->dev_names[i]); free(x->link_contents[i]); } } /* callback function for di_devlink_cache_walk */ static int devlink_cb(di_devlink_t dl, void *arg) { struct devlink_cb_arg *x = (struct devlink_cb_arg *)arg; const char *path; const char *content; if ((path = di_devlink_path(dl)) == NULL || (content = di_devlink_content(dl)) == NULL || (x->dev_names[x->count] = s_strdup(path)) == NULL) goto out; if ((x->link_contents[x->count] = s_strdup(content)) == NULL) { free(x->dev_names[x->count]); goto out; } x->count++; if (x->count >= MAX_DEV_NAME_COUNT) return (DI_WALK_TERMINATE); return (DI_WALK_CONTINUE); out: x->rv = -1; free_dev_names(x); return (DI_WALK_TERMINATE); } /* * Lookup dev name corresponding to the phys_path. * phys_path is path to a node or minor node. * Returns: * 0 with *dev_name set to the dev name * Lookup succeeded and dev_name found * 0 with *dev_name set to NULL * Lookup encountered no errors but dev name not found * -1 * Lookup failed */ static int lookup_dev_name(char *phys_path, char **dev_name) { struct devlink_cb_arg cb_arg; *dev_name = NULL; cb_arg.count = 0; cb_arg.rv = 0; (void) di_devlink_cache_walk(devlink_cache, NULL, phys_path, DI_PRIMARY_LINK, &cb_arg, devlink_cb); if (cb_arg.rv == -1) return (-1); if (cb_arg.count > 0) { *dev_name = s_strdup(cb_arg.dev_names[0]); free_dev_names(&cb_arg); if (*dev_name == NULL) return (-1); } return (0); } static char * lookup_disk_dev_name(char *node_path) { struct devlink_cb_arg cb_arg; char *dev_name = NULL; int i; char *p; int len1, len2; #define DEV_RDSK "/dev/rdsk/" #define DISK_RAW_MINOR ",raw" cb_arg.count = 0; cb_arg.rv = 0; (void) di_devlink_cache_walk(devlink_cache, NULL, node_path, DI_PRIMARY_LINK, &cb_arg, devlink_cb); if (cb_arg.rv == -1 || cb_arg.count == 0) return (NULL); /* first try lookup based on /dev/rdsk name */ for (i = 0; i < cb_arg.count; i++) { if (strncmp(cb_arg.dev_names[i], DEV_RDSK, sizeof (DEV_RDSK) - 1) == 0) { dev_name = s_strdup(cb_arg.dev_names[i]); break; } } if (dev_name == NULL) { /* now try lookup based on a minor name ending with ",raw" */ len1 = sizeof (DISK_RAW_MINOR) - 1; for (i = 0; i < cb_arg.count; i++) { len2 = strlen(cb_arg.link_contents[i]); if (len2 >= len1 && strcmp(cb_arg.link_contents[i] + len2 - len1, DISK_RAW_MINOR) == 0) { dev_name = s_strdup(cb_arg.dev_names[i]); break; } } } free_dev_names(&cb_arg); if (dev_name == NULL) return (NULL); if (strlen(dev_name) == 0) { free(dev_name); return (NULL); } /* if the name contains slice or partition number strip it */ p = dev_name + strlen(dev_name) - 1; if (isdigit(*p)) { while (p != dev_name && isdigit(*p)) p--; if (*p == 's' || *p == 'p') *p = '\0'; } return (dev_name); } static char * lookup_lofi_dev_name(char *node_path, char *minor) { struct devlink_cb_arg cb_arg; char *dev_name = NULL; int i; int len1, len2; cb_arg.count = 0; cb_arg.rv = 0; (void) di_devlink_cache_walk(devlink_cache, NULL, node_path, DI_PRIMARY_LINK, &cb_arg, devlink_cb); if (cb_arg.rv == -1 || cb_arg.count == 0) return (NULL); /* lookup based on a minor name ending with ",raw" */ len1 = strlen(minor); for (i = 0; i < cb_arg.count; i++) { len2 = strlen(cb_arg.link_contents[i]); if (len2 >= len1 && strcmp(cb_arg.link_contents[i] + len2 - len1, minor) == 0) { dev_name = s_strdup(cb_arg.dev_names[i]); break; } } free_dev_names(&cb_arg); if (dev_name == NULL) return (NULL); if (strlen(dev_name) == 0) { free(dev_name); return (NULL); } return (dev_name); } static char * lookup_network_dev_name(char *node_path, char *driver_name) { char *dev_name = NULL; char phys_path[MAXPATHLEN]; if (lookup_dev_name(node_path, &dev_name) == -1) return (NULL); if (dev_name == NULL) { /* dlpi style-2 only interface */ (void) snprintf(phys_path, sizeof (phys_path), "/pseudo/clone@0:%s", driver_name); if (lookup_dev_name(phys_path, &dev_name) == -1 || dev_name == NULL) return (NULL); } return (dev_name); } static char * lookup_printer_dev_name(char *node_path) { struct devlink_cb_arg cb_arg; char *dev_name = NULL; int i; #define DEV_PRINTERS "/dev/printers/" cb_arg.count = 0; cb_arg.rv = 0; (void) di_devlink_cache_walk(devlink_cache, NULL, node_path, DI_PRIMARY_LINK, &cb_arg, devlink_cb); if (cb_arg.rv == -1 || cb_arg.count == 0) return (NULL); /* first try lookup based on /dev/printers name */ for (i = 0; i < cb_arg.count; i++) { if (strncmp(cb_arg.dev_names[i], DEV_PRINTERS, sizeof (DEV_PRINTERS) - 1) == 0) { dev_name = s_strdup(cb_arg.dev_names[i]); break; } } /* fallback to the first name */ if ((dev_name == NULL) && (cb_arg.count > 0)) dev_name = s_strdup(cb_arg.dev_names[0]); free_dev_names(&cb_arg); return (dev_name); } /* * Build an nvlist containing all attributes for devfs events. * Returns nvlist pointer on success, NULL on failure. */ static nvlist_t * build_event_attributes(char *class, char *subclass, char *node_path, di_node_t node, char *driver_name, int instance, char *minor) { nvlist_t *nvl; int err = 0; di_prop_t prop; int count; char *prop_name; int x; char *dev_name = NULL; int dev_name_lookup_err = 0; if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, 0)) != 0) { nvl = NULL; goto out; } if ((err = nvlist_add_int32(nvl, EV_VERSION, EV_V1)) != 0) goto out; if ((err = nvlist_add_string(nvl, DEV_PHYS_PATH, node_path)) != 0) goto out; if (strcmp(class, EC_DEV_ADD) != 0 && strcmp(class, EC_DEV_REMOVE) != 0) return (nvl); if (driver_name == NULL || instance == -1) goto out; if (strcmp(subclass, ESC_DISK) == 0) { /* * While we're removing labeled lofi device, we will receive * event for every registered minor device and lastly, * an event with minor set to NULL, as in following example: * class: EC_dev_remove subclass: disk * node_path: /pseudo/lofi@1 driver: lofi minor: u,raw * class: EC_dev_remove subclass: disk * node_path: /pseudo/lofi@1 driver: lofi minor: NULL * * When we receive this last event with minor set to NULL, * all lofi minor devices are already removed and the call to * lookup_disk_dev_name() would result in error. * To prevent name lookup error messages for this case, we * need to filter out that last event. */ if (strcmp(class, EC_DEV_REMOVE) == 0 && strcmp(driver_name, "lofi") == 0 && minor == NULL) { nvlist_free(nvl); return (NULL); } if ((dev_name = lookup_disk_dev_name(node_path)) == NULL) { dev_name_lookup_err = 1; goto out; } } else if (strcmp(subclass, ESC_NETWORK) == 0) { if ((dev_name = lookup_network_dev_name(node_path, driver_name)) == NULL) { dev_name_lookup_err = 1; goto out; } } else if (strcmp(subclass, ESC_PRINTER) == 0) { if ((dev_name = lookup_printer_dev_name(node_path)) == NULL) { dev_name_lookup_err = 1; goto out; } } else if (strcmp(subclass, ESC_LOFI) == 0) { /* * The raw minor node is created or removed after the block * node. Lofi devfs events are dependent on this behavior. * Generate the sysevent only for the raw minor node. * * If the lofi mapping is created, we will receive the following * event: class: EC_dev_add subclass: lofi minor: NULL * * As in case of EC_dev_add, the minor is NULL pointer, * to get device links created, we will need to provide the * type of minor node for lookup_lofi_dev_name() * * If the lofi device is unmapped, we will receive following * events: * class: EC_dev_remove subclass: lofi minor: disk * class: EC_dev_remove subclass: lofi minor: disk,raw * class: EC_dev_remove subclass: lofi minor: NULL */ if (strcmp(class, EC_DEV_ADD) == 0 && minor == NULL) minor = "disk,raw"; if (minor == NULL || strstr(minor, "raw") == NULL) { nvlist_free(nvl); return (NULL); } if ((dev_name = lookup_lofi_dev_name(node_path, minor)) == NULL) { dev_name_lookup_err = 1; goto out; } } if (dev_name) { if ((err = nvlist_add_string(nvl, DEV_NAME, dev_name)) != 0) goto out; free(dev_name); dev_name = NULL; } if ((err = nvlist_add_string(nvl, DEV_DRIVER_NAME, driver_name)) != 0) goto out; if ((err = nvlist_add_int32(nvl, DEV_INSTANCE, instance)) != 0) goto out; if (strcmp(class, EC_DEV_ADD) == 0) { /* add properties */ count = 0; for (prop = di_prop_next(node, DI_PROP_NIL); prop != DI_PROP_NIL && count < MAX_PROP_COUNT; prop = di_prop_next(node, prop)) { if (di_prop_devt(prop) != DDI_DEV_T_NONE) continue; if ((x = add_property(nvl, prop)) == 0) count++; else if (x == -1) { if ((prop_name = di_prop_name(prop)) == NULL) prop_name = ""; err_print(PROP_ADD_FAILED, prop_name); goto out; } } } return (nvl); out: nvlist_free(nvl); if (dev_name) free(dev_name); if (dev_name_lookup_err) { /* * If a lofi mount fails, the /devices node may well have * disappeared by the time we run, so let's not complain. */ if (strcmp(subclass, ESC_LOFI) != 0) err_print(DEV_NAME_LOOKUP_FAILED, node_path); } else { err_print(BUILD_EVENT_ATTR_FAILED, (err) ? strerror(err) : ""); } return (NULL); } static void log_event(char *class, char *subclass, nvlist_t *nvl) { sysevent_id_t eid; if (sysevent_post_event(class, subclass, "SUNW", DEVFSADMD, nvl, &eid) != 0) { err_print(LOG_EVENT_FAILED, strerror(errno)); } } /* * When devfsadmd needs to generate sysevents, they are queued for later * delivery this allows them to be delivered after the devlinks db cache has * been flushed guaranteeing that applications consuming these events have * access to an accurate devlinks db. The queue is a FIFO, sysevents to be * inserted in the front of the queue and consumed off the back. */ static void enqueue_sysevent(char *class, char *subclass, nvlist_t *nvl) { syseventq_t *tmp; if ((tmp = s_zalloc(sizeof (*tmp))) == NULL) return; tmp->class = s_strdup(class); tmp->subclass = s_strdup(subclass); tmp->nvl = nvl; (void) mutex_lock(&syseventq_mutex); if (syseventq_front != NULL) syseventq_front->next = tmp; else syseventq_back = tmp; syseventq_front = tmp; (void) mutex_unlock(&syseventq_mutex); } static void process_syseventq() { (void) mutex_lock(&syseventq_mutex); while (syseventq_back != NULL) { syseventq_t *tmp = syseventq_back; vprint(CHATTY_MID, "sending queued event: %s, %s\n", tmp->class, tmp->subclass); log_event(tmp->class, tmp->subclass, tmp->nvl); if (tmp->class != NULL) free(tmp->class); if (tmp->subclass != NULL) free(tmp->subclass); nvlist_free(tmp->nvl); syseventq_back = syseventq_back->next; if (syseventq_back == NULL) syseventq_front = NULL; free(tmp); } (void) mutex_unlock(&syseventq_mutex); } static void build_and_enq_event(char *class, char *subclass, char *node_path, di_node_t node, char *minor) { nvlist_t *nvl; vprint(CHATTY_MID, "build_and_enq_event(%s, %s, %s, 0x%8.8x)\n", class, subclass, node_path, (int)node); if (node != DI_NODE_NIL) nvl = build_event_attributes(class, subclass, node_path, node, di_driver_name(node), di_instance(node), minor); else nvl = build_event_attributes(class, subclass, node_path, node, NULL, -1, minor); if (nvl) { enqueue_sysevent(class, subclass, nvl); } } /* * is_blank() returns 1 (true) if a line specified is composed of * whitespace characters only. otherwise, it returns 0 (false). * * Note. the argument (line) must be null-terminated. */ static int is_blank(char *line) { for (/* nothing */; *line != '\0'; line++) if (!isspace(*line)) return (0); return (1); } /* * Functions to deal with the no-further-processing hash */ static void nfphash_create(void) { assert(nfp_hash == NULL); nfp_hash = s_zalloc(NFP_HASH_SZ * sizeof (item_t *)); } static int nfphash_fcn(char *key) { int i; uint64_t sum = 0; for (i = 0; key[i] != '\0'; i++) { sum += (uchar_t)key[i]; } return (sum % NFP_HASH_SZ); } static item_t * nfphash_lookup(char *key) { int index; item_t *ip; index = nfphash_fcn(key); assert(index >= 0); for (ip = nfp_hash[index]; ip; ip = ip->i_next) { if (strcmp(ip->i_key, key) == 0) return (ip); } return (NULL); } static void nfphash_insert(char *key) { item_t *ip; int index; index = nfphash_fcn(key); assert(index >= 0); ip = s_zalloc(sizeof (item_t)); ip->i_key = s_strdup(key); ip->i_next = nfp_hash[index]; nfp_hash[index] = ip; } static void nfphash_destroy(void) { int i; item_t *ip; for (i = 0; i < NFP_HASH_SZ; i++) { /*LINTED*/ while (ip = nfp_hash[i]) { nfp_hash[i] = ip->i_next; free(ip->i_key); free(ip); } } free(nfp_hash); nfp_hash = NULL; } static int devname_kcall(int subcmd, void *args) { int error = 0; switch (subcmd) { case MODDEVNAME_LOOKUPDOOR: error = modctl(MODDEVNAME, subcmd, (uintptr_t)args); if (error) { vprint(INFO_MID, "modctl(MODDEVNAME, " "MODDEVNAME_LOOKUPDOOR) failed - %s\n", strerror(errno)); } break; default: error = EINVAL; break; } return (error); } /* ARGSUSED */ static void devname_lookup_handler(void *cookie, char *argp, size_t arg_size, door_desc_t *dp, uint_t n_desc) { int32_t error = 0; door_cred_t dcred; struct dca_impl dci; uint8_t cmd; sdev_door_res_t res; sdev_door_arg_t *args; if (argp == NULL || arg_size == 0) { vprint(DEVNAME_MID, "devname_lookup_handler: argp wrong\n"); error = DEVFSADM_RUN_INVALID; goto done; } vprint(DEVNAME_MID, "devname_lookup_handler\n"); if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) { vprint(DEVNAME_MID, "devname_lookup_handler: cred wrong\n"); error = DEVFSADM_RUN_EPERM; goto done; } args = (sdev_door_arg_t *)argp; cmd = args->devfsadm_cmd; vprint(DEVNAME_MID, "devname_lookup_handler: cmd %d\n", cmd); switch (cmd) { case DEVFSADMD_RUN_ALL: /* * run "devfsadm" */ dci.dci_root = "/"; dci.dci_minor = NULL; dci.dci_driver = NULL; dci.dci_error = 0; dci.dci_flags = 0; dci.dci_arg = NULL; lock_dev(); update_drvconf((major_t)-1, 0); dci.dci_flags |= DCA_FLUSH_PATHINST; pre_and_post_cleanup(RM_PRE); devi_tree_walk(&dci, DI_CACHE_SNAPSHOT_FLAGS, NULL); error = (int32_t)dci.dci_error; if (!error) { pre_and_post_cleanup(RM_POST); update_database = TRUE; unlock_dev(SYNC_STATE); update_database = FALSE; } else { if (DEVFSADM_DEBUG_ON) { vprint(INFO_MID, "devname_lookup_handler: " "DEVFSADMD_RUN_ALL failed\n"); } unlock_dev(SYNC_STATE); } break; default: /* log an error here? */ error = DEVFSADM_RUN_NOTSUP; break; } done: vprint(DEVNAME_MID, "devname_lookup_handler: error %d\n", error); res.devfsadm_error = error; (void) door_return((char *)&res, sizeof (struct sdev_door_res), NULL, 0); } di_devlink_handle_t devfsadm_devlink_cache(void) { return (devlink_cache); } int devfsadm_reserve_id_cache(devlink_re_t re_array[], enumerate_file_t *head) { enumerate_file_t *entry; int nelem; int i; int subex; char *re; size_t size; regmatch_t *pmch; /* * Check the array passed in and compile it. */ for (i = 0; re_array[i].d_re; i++) { if (re_array[i].d_subexp == 0) { err_print("bad subexp value in RE: %s\n", re_array[i].d_re); goto bad_re; } re = re_array[i].d_re; if (regcomp(&re_array[i].d_rcomp, re, REG_EXTENDED) != 0) { err_print("reg. exp. failed to compile: %s\n", re); goto bad_re; } subex = re_array[i].d_subexp; nelem = subex + 1; re_array[i].d_pmatch = s_malloc(sizeof (regmatch_t) * nelem); } entry = head ? head : enumerate_reserved; for (; entry; entry = entry->er_next) { if (entry->er_id) { vprint(RSBY_MID, "entry %s already has ID %s\n", entry->er_file, entry->er_id); continue; } for (i = 0; re_array[i].d_re; i++) { subex = re_array[i].d_subexp; pmch = re_array[i].d_pmatch; if (regexec(&re_array[i].d_rcomp, entry->er_file, subex + 1, pmch, 0) != 0) { /* No match */ continue; } size = pmch[subex].rm_eo - pmch[subex].rm_so; entry->er_id = s_malloc(size + 1); (void) strncpy(entry->er_id, &entry->er_file[pmch[subex].rm_so], size); entry->er_id[size] = '\0'; if (head) { vprint(RSBY_MID, "devlink(%s) matches RE(%s). " "ID is %s\n", entry->er_file, re_array[i].d_re, entry->er_id); } else { vprint(RSBY_MID, "rsrv entry(%s) matches " "RE(%s) ID is %s\n", entry->er_file, re_array[i].d_re, entry->er_id); } break; } } for (i = 0; re_array[i].d_re; i++) { regfree(&re_array[i].d_rcomp); assert(re_array[i].d_pmatch); free(re_array[i].d_pmatch); } entry = head ? head : enumerate_reserved; for (; entry; entry = entry->er_next) { if (entry->er_id == NULL) continue; if (head) { vprint(RSBY_MID, "devlink: %s\n", entry->er_file); vprint(RSBY_MID, "ID: %s\n", entry->er_id); } else { vprint(RSBY_MID, "reserve file entry: %s\n", entry->er_file); vprint(RSBY_MID, "reserve file id: %s\n", entry->er_id); } } return (DEVFSADM_SUCCESS); bad_re: for (i = i-1; i >= 0; i--) { regfree(&re_array[i].d_rcomp); assert(re_array[i].d_pmatch); free(re_array[i].d_pmatch); } return (DEVFSADM_FAILURE); } /* * Return 1 if we have reserved links. */ int devfsadm_have_reserved() { return (enumerate_reserved ? 1 : 0); } /* * This functions errs on the side of caution. If there is any error * we assume that the devlink is *not* reserved */ int devfsadm_is_reserved(devlink_re_t re_array[], char *devlink) { int match; enumerate_file_t estruct = {NULL}; enumerate_file_t *entry; match = 0; estruct.er_file = devlink; estruct.er_id = NULL; estruct.er_next = NULL; if (devfsadm_reserve_id_cache(re_array, &estruct) != DEVFSADM_SUCCESS) { err_print("devfsadm_is_reserved: devlink (%s) does not " "match RE\n", devlink); return (0); } if (estruct.er_id == NULL) { err_print("devfsadm_is_reserved: ID derived from devlink %s " "is NULL\n", devlink); return (0); } entry = enumerate_reserved; for (; entry; entry = entry->er_next) { if (entry->er_id == NULL) continue; if (strcmp(entry->er_id, estruct.er_id) != 0) continue; match = 1; vprint(RSBY_MID, "reserve file entry (%s) and devlink (%s) " "match\n", entry->er_file, devlink); break; } free(estruct.er_id); return (match); }