xref: /illumos-gate/usr/src/cmd/devfsadm/devfsadm.c (revision 4dd25bdc)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5055e805aSedp  * Common Development and Distribution License (the "License").
6055e805aSedp  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
21055e805aSedp 
227c478bd9Sstevel@tonic-gate /*
2394c894bbSVikram Hegde  * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate /*
277c478bd9Sstevel@tonic-gate  * Devfsadm replaces drvconfig, audlinks, disks, tapes, ports, devlinks
287c478bd9Sstevel@tonic-gate  * as a general purpose device administrative utility.	It creates
297c478bd9Sstevel@tonic-gate  * devices special files in /devices and logical links in /dev, and
307c478bd9Sstevel@tonic-gate  * coordinates updates to /etc/path_to_instance with the kernel.  It
317c478bd9Sstevel@tonic-gate  * operates in both command line mode to handle user or script invoked
327c478bd9Sstevel@tonic-gate  * reconfiguration updates, and operates in daemon mode to handle dynamic
337c478bd9Sstevel@tonic-gate  * reconfiguration for hotplugging support.
347c478bd9Sstevel@tonic-gate  */
357c478bd9Sstevel@tonic-gate 
3645916cd2Sjpk #include <string.h>
37f875b4ebSrica #include <deflt.h>
3845916cd2Sjpk #include <tsol/label.h>
3945916cd2Sjpk #include <bsm/devices.h>
4045916cd2Sjpk #include <bsm/devalloc.h>
417c478bd9Sstevel@tonic-gate #include <utime.h>
426638bf60Saj #include <sys/param.h>
436638bf60Saj #include <bsm/libbsm.h>
4417e9b2b7SDhanaraj M #include <zone.h>
4545916cd2Sjpk #include "devfsadm_impl.h"
467c478bd9Sstevel@tonic-gate 
4745916cd2Sjpk /* externs from devalloc.c */
4845916cd2Sjpk extern void  _reset_devalloc(int);
4945916cd2Sjpk extern void _update_devalloc_db(devlist_t *, int, int, char *, char *);
5045916cd2Sjpk extern int _da_check_for_usb(char *, char *);
517c478bd9Sstevel@tonic-gate 
527c478bd9Sstevel@tonic-gate /* create or remove nodes or links. unset with -n */
537c478bd9Sstevel@tonic-gate static int file_mods = TRUE;
547c478bd9Sstevel@tonic-gate 
557c478bd9Sstevel@tonic-gate /* cleanup mode.  Set with -C */
567c478bd9Sstevel@tonic-gate static int cleanup = FALSE;
577c478bd9Sstevel@tonic-gate 
587c478bd9Sstevel@tonic-gate /* devlinks -d compatibility */
597c478bd9Sstevel@tonic-gate static int devlinks_debug = FALSE;
607c478bd9Sstevel@tonic-gate 
6145916cd2Sjpk /* flag to check if system is labeled */
6245916cd2Sjpk int system_labeled = FALSE;
6345916cd2Sjpk 
6445916cd2Sjpk /* flag to enable/disable device allocation with -e/-d */
6545916cd2Sjpk static int devalloc_flag = 0;
6645916cd2Sjpk 
676638bf60Saj /* flag that indicates if device allocation is on or not */
686638bf60Saj static int devalloc_is_on = 0;
696638bf60Saj 
7045916cd2Sjpk /* flag to update device allocation database for this device type */
7145916cd2Sjpk static int update_devdb = 0;
7245916cd2Sjpk 
7345916cd2Sjpk /*
7445916cd2Sjpk  * devices to be deallocated with -d :
7545916cd2Sjpk  *	audio, floppy, cd, floppy, tape, rmdisk.
7645916cd2Sjpk  */
7745916cd2Sjpk static char *devalloc_list[10] = {DDI_NT_AUDIO, DDI_NT_CD, DDI_NT_CD_CHAN,
7845916cd2Sjpk 				    DDI_NT_FD, DDI_NT_TAPE, DDI_NT_BLOCK_CHAN,
7945916cd2Sjpk 				    DDI_NT_UGEN, DDI_NT_USB_ATTACHMENT_POINT,
8045916cd2Sjpk 				    DDI_NT_SCSI_NEXUS, NULL};
817c478bd9Sstevel@tonic-gate 
8245916cd2Sjpk /* list of allocatable devices */
8345916cd2Sjpk static devlist_t devlist;
847c478bd9Sstevel@tonic-gate 
857c478bd9Sstevel@tonic-gate /* load a single driver only.  set with -i */
867c478bd9Sstevel@tonic-gate static int single_drv = FALSE;
877c478bd9Sstevel@tonic-gate static char *driver = NULL;
887c478bd9Sstevel@tonic-gate 
897c478bd9Sstevel@tonic-gate /* attempt to load drivers or defer attach nodes */
907c478bd9Sstevel@tonic-gate static int load_attach_drv = TRUE;
917c478bd9Sstevel@tonic-gate 
92c9cc1492SJerry Gilliam /* reload all driver.conf files */
93c9cc1492SJerry Gilliam static int update_all_drivers = FALSE;
94c9cc1492SJerry Gilliam 
957c478bd9Sstevel@tonic-gate /* set if invoked via /usr/lib/devfsadm/devfsadmd */
967c478bd9Sstevel@tonic-gate static int daemon_mode = FALSE;
977c478bd9Sstevel@tonic-gate 
987e3e5701SJan Parcel /* set if event_handler triggered */
997e3e5701SJan Parcel int event_driven = FALSE;
1007e3e5701SJan Parcel 
1017c478bd9Sstevel@tonic-gate /* output directed to syslog during daemon mode if set */
1027c478bd9Sstevel@tonic-gate static int logflag = FALSE;
1037c478bd9Sstevel@tonic-gate 
1047c478bd9Sstevel@tonic-gate /* build links in /dev.  -x to turn off */
1057c478bd9Sstevel@tonic-gate static int build_dev = TRUE;
1067c478bd9Sstevel@tonic-gate 
1077c478bd9Sstevel@tonic-gate /* build nodes in /devices.  -y to turn off */
1087c478bd9Sstevel@tonic-gate static int build_devices = TRUE;
1097c478bd9Sstevel@tonic-gate 
1107c478bd9Sstevel@tonic-gate /* -z to turn off */
1117c478bd9Sstevel@tonic-gate static int flush_path_to_inst_enable = TRUE;
1127c478bd9Sstevel@tonic-gate 
1137c478bd9Sstevel@tonic-gate /* variables used for path_to_inst flushing */
1147c478bd9Sstevel@tonic-gate static int inst_count = 0;
1157c478bd9Sstevel@tonic-gate static mutex_t count_lock;
1167c478bd9Sstevel@tonic-gate static cond_t cv;
1177c478bd9Sstevel@tonic-gate 
118ff2aee48Scth /* variables for minor_fini thread */
1197c478bd9Sstevel@tonic-gate static mutex_t minor_fini_mutex;
120ff2aee48Scth static int minor_fini_canceled = TRUE;
121ff2aee48Scth static int minor_fini_delayed = FALSE;
122ff2aee48Scth static cond_t minor_fini_cv;
123ff2aee48Scth static int minor_fini_timeout = MINOR_FINI_TIMEOUT_DEFAULT;
1247c478bd9Sstevel@tonic-gate 
1257c478bd9Sstevel@tonic-gate /* single-threads /dev modification */
1267c478bd9Sstevel@tonic-gate static sema_t dev_sema;
1277c478bd9Sstevel@tonic-gate 
1287c478bd9Sstevel@tonic-gate /* the program we were invoked as; ie argv[0] */
1297c478bd9Sstevel@tonic-gate static char *prog;
1307c478bd9Sstevel@tonic-gate 
1317c478bd9Sstevel@tonic-gate /* pointers to create/remove link lists */
1327c478bd9Sstevel@tonic-gate static create_list_t *create_head = NULL;
1337c478bd9Sstevel@tonic-gate static remove_list_t *remove_head = NULL;
1347c478bd9Sstevel@tonic-gate 
1357c478bd9Sstevel@tonic-gate /*  supports the class -c option */
1367c478bd9Sstevel@tonic-gate static char **classes = NULL;
1377c478bd9Sstevel@tonic-gate static int num_classes = 0;
1387c478bd9Sstevel@tonic-gate 
1397c478bd9Sstevel@tonic-gate /* used with verbose option -v or -V */
1407c478bd9Sstevel@tonic-gate static int num_verbose = 0;
1417c478bd9Sstevel@tonic-gate static char **verbose = NULL;
1427c478bd9Sstevel@tonic-gate 
1437c478bd9Sstevel@tonic-gate static struct mperm *minor_perms = NULL;
1447c478bd9Sstevel@tonic-gate static driver_alias_t *driver_aliases = NULL;
1457c478bd9Sstevel@tonic-gate 
1467c478bd9Sstevel@tonic-gate /* set if -r alternate root given */
1477c478bd9Sstevel@tonic-gate static char *root_dir = "";
1487c478bd9Sstevel@tonic-gate 
1497c478bd9Sstevel@tonic-gate /* /devices or <rootdir>/devices */
1507c478bd9Sstevel@tonic-gate static char *devices_dir  = DEVICES;
1517c478bd9Sstevel@tonic-gate 
1527c478bd9Sstevel@tonic-gate /* /dev or <rootdir>/dev */
1537c478bd9Sstevel@tonic-gate static char *dev_dir = DEV;
1547c478bd9Sstevel@tonic-gate 
155facf4a8dSllai /* /etc/dev or <rootdir>/etc/dev */
156facf4a8dSllai static char *etc_dev_dir = ETCDEV;
157facf4a8dSllai 
158facf4a8dSllai /*
159facf4a8dSllai  * writable root (for lock files and doors during install).
160facf4a8dSllai  * This is also root dir for /dev attr dir during install.
161facf4a8dSllai  */
162facf4a8dSllai static char *attr_root = NULL;
1637c478bd9Sstevel@tonic-gate 
1647c478bd9Sstevel@tonic-gate /* /etc/path_to_inst unless -p used */
1657c478bd9Sstevel@tonic-gate static char *inst_file = INSTANCE_FILE;
1667c478bd9Sstevel@tonic-gate 
1677c478bd9Sstevel@tonic-gate /* /usr/lib/devfsadm/linkmods unless -l used */
1687c478bd9Sstevel@tonic-gate static char *module_dirs = MODULE_DIRS;
1697c478bd9Sstevel@tonic-gate 
1707c478bd9Sstevel@tonic-gate /* default uid/gid used if /etc/minor_perm entry not found */
1717c478bd9Sstevel@tonic-gate static uid_t root_uid;
1727c478bd9Sstevel@tonic-gate static gid_t sys_gid;
1737c478bd9Sstevel@tonic-gate 
1747c478bd9Sstevel@tonic-gate /* /etc/devlink.tab unless devlinks -t used */
1757c478bd9Sstevel@tonic-gate static char *devlinktab_file = NULL;
1767c478bd9Sstevel@tonic-gate 
1778d483882Smlf /* File and data structure to reserve enumerate IDs */
1788d483882Smlf static char *enumerate_file = ENUMERATE_RESERVED;
1798d483882Smlf static enumerate_file_t *enumerate_reserved = NULL;
1808d483882Smlf 
1817c478bd9Sstevel@tonic-gate /* set if /dev link is new. speeds up rm_stale_links */
1827c478bd9Sstevel@tonic-gate static int linknew = TRUE;
1837c478bd9Sstevel@tonic-gate 
1847c478bd9Sstevel@tonic-gate /* variables for devlink.tab compat processing */
1857c478bd9Sstevel@tonic-gate static devlinktab_list_t *devlinktab_list = NULL;
1867c478bd9Sstevel@tonic-gate static unsigned int devlinktab_line = 0;
1877c478bd9Sstevel@tonic-gate 
1887c478bd9Sstevel@tonic-gate /* cache head for devfsadm_enumerate*() functions */
1897c478bd9Sstevel@tonic-gate static numeral_set_t *head_numeral_set = NULL;
1907c478bd9Sstevel@tonic-gate 
1917c478bd9Sstevel@tonic-gate /* list list of devfsadm modules */
1927c478bd9Sstevel@tonic-gate static module_t *module_head = NULL;
1937c478bd9Sstevel@tonic-gate 
1947c478bd9Sstevel@tonic-gate /* name_to_major list used in utility function */
1957c478bd9Sstevel@tonic-gate static n2m_t *n2m_list = NULL;
1967c478bd9Sstevel@tonic-gate 
1977c478bd9Sstevel@tonic-gate /* cache of some links used for performance */
1987c478bd9Sstevel@tonic-gate static linkhead_t *headlinkhead = NULL;
1997c478bd9Sstevel@tonic-gate 
2007c478bd9Sstevel@tonic-gate /* locking variables to prevent multiples writes to /dev */
2017c478bd9Sstevel@tonic-gate static int hold_dev_lock = FALSE;
2027c478bd9Sstevel@tonic-gate static int hold_daemon_lock = FALSE;
2037c478bd9Sstevel@tonic-gate static int dev_lock_fd;
2047c478bd9Sstevel@tonic-gate static int daemon_lock_fd;
2057c478bd9Sstevel@tonic-gate static char dev_lockfile[PATH_MAX + 1];
2067c478bd9Sstevel@tonic-gate static char daemon_lockfile[PATH_MAX + 1];
2077c478bd9Sstevel@tonic-gate 
2087c478bd9Sstevel@tonic-gate /* last devinfo node/minor processed. used for performance */
2097c478bd9Sstevel@tonic-gate static di_node_t lnode;
2107c478bd9Sstevel@tonic-gate static di_minor_t lminor;
2117c478bd9Sstevel@tonic-gate static char lphy_path[PATH_MAX + 1] = {""};
2127c478bd9Sstevel@tonic-gate 
2137c478bd9Sstevel@tonic-gate /* Globals used by the link database */
2147c478bd9Sstevel@tonic-gate static di_devlink_handle_t devlink_cache;
2157c478bd9Sstevel@tonic-gate static int update_database = FALSE;
2167c478bd9Sstevel@tonic-gate 
2177c478bd9Sstevel@tonic-gate /* Globals used to set logindev perms */
2187c478bd9Sstevel@tonic-gate static struct login_dev *login_dev_cache = NULL;
2197c478bd9Sstevel@tonic-gate static int login_dev_enable = FALSE;
2207c478bd9Sstevel@tonic-gate 
2217c478bd9Sstevel@tonic-gate /* Global to use devinfo snapshot cache */
2227c478bd9Sstevel@tonic-gate static int use_snapshot_cache = FALSE;
2237c478bd9Sstevel@tonic-gate 
224aa646b9dSvikram /* Global for no-further-processing hash */
225aa646b9dSvikram static item_t **nfp_hash;
226aa646b9dSvikram static mutex_t  nfp_mutex = DEFAULTMUTEX;
227aa646b9dSvikram 
2287c478bd9Sstevel@tonic-gate /*
2297c478bd9Sstevel@tonic-gate  * Packaged directories - not removed even when empty.
2307c478bd9Sstevel@tonic-gate  * The dirs must be listed in canonical form
2317c478bd9Sstevel@tonic-gate  * i.e. without leading "/dev/"
2327c478bd9Sstevel@tonic-gate  */
2337c478bd9Sstevel@tonic-gate static char *packaged_dirs[] =
2347c478bd9Sstevel@tonic-gate 	{"dsk", "rdsk", "term", NULL};
2357c478bd9Sstevel@tonic-gate 
236facf4a8dSllai /* Devname globals */
237facf4a8dSllai static int lookup_door_fd = -1;
238facf4a8dSllai static char *lookup_door_path;
239facf4a8dSllai 
2407c478bd9Sstevel@tonic-gate static void load_dev_acl(void);
241c9cc1492SJerry Gilliam static void update_drvconf(major_t, int);
242facf4a8dSllai static void check_reconfig_state(void);
243facf4a8dSllai static int s_stat(const char *, struct stat *);
2447c478bd9Sstevel@tonic-gate 
2451ca93273Seota static int is_blank(char *);
2461ca93273Seota 
247f05faa4eSjacobs /* sysevent queue related globals */
248f05faa4eSjacobs static mutex_t  syseventq_mutex = DEFAULTMUTEX;
249f05faa4eSjacobs static syseventq_t *syseventq_front;
250f05faa4eSjacobs static syseventq_t *syseventq_back;
251f05faa4eSjacobs static void process_syseventq();
252f05faa4eSjacobs 
25394c894bbSVikram Hegde static di_node_t devi_root_node = DI_NODE_NIL;
25494c894bbSVikram Hegde 
2557c478bd9Sstevel@tonic-gate int
2567c478bd9Sstevel@tonic-gate main(int argc, char *argv[])
2577c478bd9Sstevel@tonic-gate {
2587c478bd9Sstevel@tonic-gate 	struct passwd *pw;
2597c478bd9Sstevel@tonic-gate 	struct group *gp;
2607c478bd9Sstevel@tonic-gate 	pid_t pid;
2617c478bd9Sstevel@tonic-gate 
2627c478bd9Sstevel@tonic-gate 	(void) setlocale(LC_ALL, "");
2637c478bd9Sstevel@tonic-gate 	(void) textdomain(TEXT_DOMAIN);
2647c478bd9Sstevel@tonic-gate 
2657c478bd9Sstevel@tonic-gate 	if ((prog = strrchr(argv[0], '/')) == NULL) {
2667c478bd9Sstevel@tonic-gate 		prog = argv[0];
2677c478bd9Sstevel@tonic-gate 	} else {
2687c478bd9Sstevel@tonic-gate 		prog++;
2697c478bd9Sstevel@tonic-gate 	}
2707c478bd9Sstevel@tonic-gate 
2717c478bd9Sstevel@tonic-gate 	if (getuid() != 0) {
2727c478bd9Sstevel@tonic-gate 		err_print(MUST_BE_ROOT);
2737c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
274537714daSvikram 		/*NOTREACHED*/
2757c478bd9Sstevel@tonic-gate 	}
2767c478bd9Sstevel@tonic-gate 
27717e9b2b7SDhanaraj M 	if (getzoneid() != GLOBAL_ZONEID) {
27817e9b2b7SDhanaraj M 		err_print(MUST_BE_GLOBAL_ZONE);
27917e9b2b7SDhanaraj M 		devfsadm_exit(1);
28017e9b2b7SDhanaraj M 	}
28117e9b2b7SDhanaraj M 
2827c478bd9Sstevel@tonic-gate 	/*
2837c478bd9Sstevel@tonic-gate 	 * Close all files except stdin/stdout/stderr
2847c478bd9Sstevel@tonic-gate 	 */
2857c478bd9Sstevel@tonic-gate 	closefrom(3);
2867c478bd9Sstevel@tonic-gate 
2877c478bd9Sstevel@tonic-gate 	if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) {
2887c478bd9Sstevel@tonic-gate 		root_uid = pw->pw_uid;
2897c478bd9Sstevel@tonic-gate 	} else {
2907c478bd9Sstevel@tonic-gate 		err_print(CANT_FIND_USER, DEFAULT_DEV_USER);
2917c478bd9Sstevel@tonic-gate 		root_uid = (uid_t)0;	/* assume 0 is root */
2927c478bd9Sstevel@tonic-gate 	}
2937c478bd9Sstevel@tonic-gate 
2947c478bd9Sstevel@tonic-gate 	/* the default group is sys */
2957c478bd9Sstevel@tonic-gate 
2967c478bd9Sstevel@tonic-gate 	if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) {
2977c478bd9Sstevel@tonic-gate 		sys_gid = gp->gr_gid;
2987c478bd9Sstevel@tonic-gate 	} else {
2997c478bd9Sstevel@tonic-gate 		err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP);
3007c478bd9Sstevel@tonic-gate 		sys_gid = (gid_t)3;	/* assume 3 is sys */
3017c478bd9Sstevel@tonic-gate 	}
3027c478bd9Sstevel@tonic-gate 
3037c478bd9Sstevel@tonic-gate 	(void) umask(0);
3047c478bd9Sstevel@tonic-gate 
30545916cd2Sjpk 	system_labeled = is_system_labeled();
30645916cd2Sjpk 	if (system_labeled == FALSE) {
30745916cd2Sjpk 		/*
30845916cd2Sjpk 		 * is_system_labeled() will return false in case we are
30945916cd2Sjpk 		 * starting before the first reboot after Trusted Extensions
310f875b4ebSrica 		 * is enabled.  Check the setting in /etc/system to see if
311f875b4ebSrica 		 * TX is enabled (even if not yet booted).
31245916cd2Sjpk 		 */
313f875b4ebSrica 		if (defopen("/etc/system") == 0) {
314f875b4ebSrica 			if (defread("set sys_labeling=1") != NULL)
315f875b4ebSrica 				system_labeled = TRUE;
316f875b4ebSrica 
317f875b4ebSrica 			/* close defaults file */
318f875b4ebSrica 			(void) defopen(NULL);
319facf4a8dSllai 		}
32045916cd2Sjpk 	}
3216638bf60Saj 	/*
3226638bf60Saj 	 * Check if device allocation is enabled.
3236638bf60Saj 	 */
324*4dd25bdcSJerry Gilliam 	devalloc_is_on = (da_is_on() == 1) ? 1 : 0;
32545916cd2Sjpk 
326f875b4ebSrica #ifdef DEBUG
327f875b4ebSrica 	if (system_labeled == FALSE) {
328f875b4ebSrica 		struct stat tx_stat;
329f875b4ebSrica 
330f875b4ebSrica 		/* test hook: see also mkdevalloc.c and allocate.c */
331f875b4ebSrica 		system_labeled = is_system_labeled_debug(&tx_stat);
332f875b4ebSrica 	}
333f875b4ebSrica #endif
334f875b4ebSrica 
3357c478bd9Sstevel@tonic-gate 	parse_args(argc, argv);
3367c478bd9Sstevel@tonic-gate 
3377c478bd9Sstevel@tonic-gate 	(void) sema_init(&dev_sema, 1, USYNC_THREAD, NULL);
3387c478bd9Sstevel@tonic-gate 
33945916cd2Sjpk 	/* Initialize device allocation list */
34045916cd2Sjpk 	devlist.audio = devlist.cd = devlist.floppy = devlist.tape =
3410a653502Swroche 	    devlist.rmdisk = NULL;
34245916cd2Sjpk 
3437c478bd9Sstevel@tonic-gate 	if (daemon_mode == TRUE) {
3447c478bd9Sstevel@tonic-gate 		/*
3457c478bd9Sstevel@tonic-gate 		 * Build /dev and /devices before daemonizing if
3467c478bd9Sstevel@tonic-gate 		 * reconfig booting and daemon invoked with alternate
3477c478bd9Sstevel@tonic-gate 		 * root. This is to support install.
3487c478bd9Sstevel@tonic-gate 		 */
3497c478bd9Sstevel@tonic-gate 		if (getenv(RECONFIG_BOOT) != NULL && root_dir[0] != '\0') {
3507c478bd9Sstevel@tonic-gate 			vprint(INFO_MID, CONFIGURING);
3517c478bd9Sstevel@tonic-gate 			load_dev_acl();
352c9cc1492SJerry Gilliam 			update_drvconf((major_t)-1, 0);
3537c478bd9Sstevel@tonic-gate 			process_devinfo_tree();
3547c478bd9Sstevel@tonic-gate 			(void) modctl(MODSETMINIROOT);
3557c478bd9Sstevel@tonic-gate 		}
3567c478bd9Sstevel@tonic-gate 
3577c478bd9Sstevel@tonic-gate 		/*
3587c478bd9Sstevel@tonic-gate 		 * fork before detaching from tty in order to print error
3597c478bd9Sstevel@tonic-gate 		 * message if unable to acquire file lock.  locks not preserved
3607c478bd9Sstevel@tonic-gate 		 * across forks.  Even under debug we want to fork so that
3617c478bd9Sstevel@tonic-gate 		 * when executed at boot we don't hang.
3627c478bd9Sstevel@tonic-gate 		 */
3637c478bd9Sstevel@tonic-gate 		if (fork() != 0) {
3647c478bd9Sstevel@tonic-gate 			devfsadm_exit(0);
365537714daSvikram 			/*NOTREACHED*/
3667c478bd9Sstevel@tonic-gate 		}
3677c478bd9Sstevel@tonic-gate 
3687c478bd9Sstevel@tonic-gate 		/* set directory to / so it coredumps there */
3697c478bd9Sstevel@tonic-gate 		if (chdir("/") == -1) {
3707c478bd9Sstevel@tonic-gate 			err_print(CHROOT_FAILED, strerror(errno));
3717c478bd9Sstevel@tonic-gate 		}
3727c478bd9Sstevel@tonic-gate 
3737c478bd9Sstevel@tonic-gate 		/* only one daemon can run at a time */
3747c478bd9Sstevel@tonic-gate 		if ((pid = enter_daemon_lock()) == getpid()) {
3757c478bd9Sstevel@tonic-gate 			detachfromtty();
3767c478bd9Sstevel@tonic-gate 			(void) cond_init(&cv, USYNC_THREAD, 0);
3777c478bd9Sstevel@tonic-gate 			(void) mutex_init(&count_lock, USYNC_THREAD, 0);
3787c478bd9Sstevel@tonic-gate 			if (thr_create(NULL, NULL,
379ff2aee48Scth 			    (void *(*)(void *))instance_flush_thread,
380ff2aee48Scth 			    NULL, THR_DETACHED, NULL) != 0) {
3817c478bd9Sstevel@tonic-gate 				err_print(CANT_CREATE_THREAD, "daemon",
3820a653502Swroche 				    strerror(errno));
3837c478bd9Sstevel@tonic-gate 				devfsadm_exit(1);
384537714daSvikram 				/*NOTREACHED*/
3857c478bd9Sstevel@tonic-gate 			}
3867c478bd9Sstevel@tonic-gate 
387ff2aee48Scth 			/* start the minor_fini_thread */
388ff2aee48Scth 			(void) mutex_init(&minor_fini_mutex, USYNC_THREAD, 0);
389ff2aee48Scth 			(void) cond_init(&minor_fini_cv, USYNC_THREAD, 0);
390ff2aee48Scth 			if (thr_create(NULL, NULL,
391ff2aee48Scth 			    (void *(*)(void *))minor_fini_thread,
392ff2aee48Scth 			    NULL, THR_DETACHED, NULL)) {
393ff2aee48Scth 				err_print(CANT_CREATE_THREAD, "minor_fini",
394ff2aee48Scth 				    strerror(errno));
395ff2aee48Scth 				devfsadm_exit(1);
396537714daSvikram 				/*NOTREACHED*/
397ff2aee48Scth 			}
398ff2aee48Scth 
399ff2aee48Scth 
4007c478bd9Sstevel@tonic-gate 			/*
4010dc974a9SCathy Zhou 			 * logindevperms need only be set
4027c478bd9Sstevel@tonic-gate 			 * in daemon mode and when root dir is "/".
4037c478bd9Sstevel@tonic-gate 			 */
4040dc974a9SCathy Zhou 			if (root_dir[0] == '\0')
4057c478bd9Sstevel@tonic-gate 				login_dev_enable = TRUE;
4067c478bd9Sstevel@tonic-gate 			daemon_update();
407537714daSvikram 			devfsadm_exit(0);
408537714daSvikram 			/*NOTREACHED*/
4097c478bd9Sstevel@tonic-gate 		} else {
4107c478bd9Sstevel@tonic-gate 			err_print(DAEMON_RUNNING, pid);
4117c478bd9Sstevel@tonic-gate 			devfsadm_exit(1);
412537714daSvikram 			/*NOTREACHED*/
4137c478bd9Sstevel@tonic-gate 		}
4147c478bd9Sstevel@tonic-gate 	} else {
4157c478bd9Sstevel@tonic-gate 		/* not a daemon, so just build /dev and /devices */
4168c206d17Spr 
4178c206d17Spr 		/*
4188c206d17Spr 		 * If turning off device allocation, load the
4198c206d17Spr 		 * minor_perm file because process_devinfo_tree() will
4208c206d17Spr 		 * need this in order to reset the permissions of the
4218c206d17Spr 		 * device files.
4228c206d17Spr 		 */
4238c206d17Spr 		if (devalloc_flag == DA_OFF) {
4248c206d17Spr 			read_minor_perm_file();
4258c206d17Spr 		}
4268c206d17Spr 
4277c478bd9Sstevel@tonic-gate 		process_devinfo_tree();
42845916cd2Sjpk 		if (devalloc_flag != 0)
42945916cd2Sjpk 			/* Enable/disable device allocation */
43045916cd2Sjpk 			_reset_devalloc(devalloc_flag);
4317c478bd9Sstevel@tonic-gate 	}
4327c478bd9Sstevel@tonic-gate 	return (0);
4337c478bd9Sstevel@tonic-gate }
4347c478bd9Sstevel@tonic-gate 
4357c478bd9Sstevel@tonic-gate static void
436c9cc1492SJerry Gilliam update_drvconf(major_t major, int flags)
4377c478bd9Sstevel@tonic-gate {
438c9cc1492SJerry Gilliam 	if (modctl(MODLOADDRVCONF, major, flags) != 0)
4397c478bd9Sstevel@tonic-gate 		err_print(gettext("update_drvconf failed for major %d\n"),
4407c478bd9Sstevel@tonic-gate 		    major);
4417c478bd9Sstevel@tonic-gate }
4427c478bd9Sstevel@tonic-gate 
4437c478bd9Sstevel@tonic-gate static void
4447c478bd9Sstevel@tonic-gate load_dev_acl()
4457c478bd9Sstevel@tonic-gate {
4467c478bd9Sstevel@tonic-gate 	if (load_devpolicy() != 0)
4477c478bd9Sstevel@tonic-gate 		err_print(gettext("device policy load failed\n"));
4487c478bd9Sstevel@tonic-gate 	load_minor_perm_file();
4497c478bd9Sstevel@tonic-gate }
4507c478bd9Sstevel@tonic-gate 
4517c478bd9Sstevel@tonic-gate /*
452facf4a8dSllai  * As devfsadm is run early in boot to provide the kernel with
453facf4a8dSllai  * minor_perm info, we might as well check for reconfig at the
454facf4a8dSllai  * same time to avoid running devfsadm twice.  This gets invoked
455facf4a8dSllai  * earlier than the env variable RECONFIG_BOOT is set up.
4567c478bd9Sstevel@tonic-gate  */
457facf4a8dSllai static void
458facf4a8dSllai check_reconfig_state()
4597c478bd9Sstevel@tonic-gate {
460facf4a8dSllai 	struct stat sb;
4617c478bd9Sstevel@tonic-gate 
462facf4a8dSllai 	if (s_stat("/reconfigure", &sb) == 0) {
463facf4a8dSllai 		(void) modctl(MODDEVNAME, MODDEVNAME_RECONFIG, 0);
4647c478bd9Sstevel@tonic-gate 	}
465facf4a8dSllai }
4667c478bd9Sstevel@tonic-gate 
467facf4a8dSllai static void
468facf4a8dSllai modctl_sysavail()
469facf4a8dSllai {
470facf4a8dSllai 	/*
471facf4a8dSllai 	 * Inform /dev that system is available, that
472facf4a8dSllai 	 * implicit reconfig can now be performed.
473facf4a8dSllai 	 */
474facf4a8dSllai 	(void) modctl(MODDEVNAME, MODDEVNAME_SYSAVAIL, 0);
475facf4a8dSllai }
4767c478bd9Sstevel@tonic-gate 
477facf4a8dSllai static void
478facf4a8dSllai set_lock_root(void)
479facf4a8dSllai {
480facf4a8dSllai 	struct stat sb;
481facf4a8dSllai 	char *lock_root;
482facf4a8dSllai 	size_t len;
4837c478bd9Sstevel@tonic-gate 
484facf4a8dSllai 	lock_root = attr_root ? attr_root : root_dir;
4857c478bd9Sstevel@tonic-gate 
486facf4a8dSllai 	len = strlen(lock_root) + strlen(ETCDEV) + 1;
487facf4a8dSllai 	etc_dev_dir = s_malloc(len);
488facf4a8dSllai 	(void) snprintf(etc_dev_dir, len, "%s%s", lock_root, ETCDEV);
4897c478bd9Sstevel@tonic-gate 
490facf4a8dSllai 	if (s_stat(etc_dev_dir, &sb) != 0) {
491facf4a8dSllai 		s_mkdirp(etc_dev_dir, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
492facf4a8dSllai 	} else if (!S_ISDIR(sb.st_mode)) {
493facf4a8dSllai 		err_print(NOT_DIR, etc_dev_dir);
494facf4a8dSllai 		devfsadm_exit(1);
495537714daSvikram 		/*NOTREACHED*/
496facf4a8dSllai 	}
4977c478bd9Sstevel@tonic-gate }
4987c478bd9Sstevel@tonic-gate 
499facf4a8dSllai 
5007c478bd9Sstevel@tonic-gate /*
5017c478bd9Sstevel@tonic-gate  * Parse arguments for all 6 programs handled from devfsadm.
5027c478bd9Sstevel@tonic-gate  */
5037c478bd9Sstevel@tonic-gate static void
5047c478bd9Sstevel@tonic-gate parse_args(int argc, char *argv[])
5057c478bd9Sstevel@tonic-gate {
5067c478bd9Sstevel@tonic-gate 	char opt;
5077c478bd9Sstevel@tonic-gate 	char get_linkcompat_opts = FALSE;
5087c478bd9Sstevel@tonic-gate 	char *compat_class;
5097c478bd9Sstevel@tonic-gate 	int num_aliases = 0;
5107c478bd9Sstevel@tonic-gate 	int len;
5117c478bd9Sstevel@tonic-gate 	int retval;
5126532b960SJerry Gilliam 	int config = TRUE;
5136532b960SJerry Gilliam 	int bind = FALSE;
5146532b960SJerry Gilliam 	int force_flag = FALSE;
5157c478bd9Sstevel@tonic-gate 	struct aliases *ap = NULL;
5167c478bd9Sstevel@tonic-gate 	struct aliases *a_head = NULL;
5177c478bd9Sstevel@tonic-gate 	struct aliases *a_tail = NULL;
5187c478bd9Sstevel@tonic-gate 	struct modconfig mc;
5197c478bd9Sstevel@tonic-gate 
5206532b960SJerry Gilliam 	(void) bzero(&mc, sizeof (mc));
5216532b960SJerry Gilliam 
5227c478bd9Sstevel@tonic-gate 	if (strcmp(prog, DISKS) == 0) {
5237c478bd9Sstevel@tonic-gate 		compat_class = "disk";
5247c478bd9Sstevel@tonic-gate 		get_linkcompat_opts = TRUE;
5257c478bd9Sstevel@tonic-gate 
5267c478bd9Sstevel@tonic-gate 	} else if (strcmp(prog, TAPES) == 0) {
5277c478bd9Sstevel@tonic-gate 		compat_class = "tape";
5287c478bd9Sstevel@tonic-gate 		get_linkcompat_opts = TRUE;
5297c478bd9Sstevel@tonic-gate 
5307c478bd9Sstevel@tonic-gate 	} else if (strcmp(prog, PORTS) == 0) {
5317c478bd9Sstevel@tonic-gate 		compat_class = "port";
5327c478bd9Sstevel@tonic-gate 		get_linkcompat_opts = TRUE;
5337c478bd9Sstevel@tonic-gate 
5347c478bd9Sstevel@tonic-gate 	} else if (strcmp(prog, AUDLINKS) == 0) {
5357c478bd9Sstevel@tonic-gate 		compat_class = "audio";
5367c478bd9Sstevel@tonic-gate 		get_linkcompat_opts = TRUE;
5377c478bd9Sstevel@tonic-gate 
5387c478bd9Sstevel@tonic-gate 	} else if (strcmp(prog, DEVLINKS) == 0) {
5397c478bd9Sstevel@tonic-gate 		devlinktab_file = DEVLINKTAB_FILE;
5407c478bd9Sstevel@tonic-gate 
5417c478bd9Sstevel@tonic-gate 		build_devices = FALSE;
5427c478bd9Sstevel@tonic-gate 		load_attach_drv = FALSE;
5437c478bd9Sstevel@tonic-gate 
5447c478bd9Sstevel@tonic-gate 		while ((opt = getopt(argc, argv, "dnr:st:vV:")) != EOF) {
5457c478bd9Sstevel@tonic-gate 			switch (opt) {
5467c478bd9Sstevel@tonic-gate 			case 'd':
5477c478bd9Sstevel@tonic-gate 				file_mods = FALSE;
5487c478bd9Sstevel@tonic-gate 				flush_path_to_inst_enable = FALSE;
5497c478bd9Sstevel@tonic-gate 				devlinks_debug = TRUE;
5507c478bd9Sstevel@tonic-gate 				break;
5517c478bd9Sstevel@tonic-gate 			case 'n':
5527c478bd9Sstevel@tonic-gate 				/* prevent driver loading and deferred attach */
5537c478bd9Sstevel@tonic-gate 				load_attach_drv = FALSE;
5547c478bd9Sstevel@tonic-gate 				break;
5557c478bd9Sstevel@tonic-gate 			case 'r':
556facf4a8dSllai 				set_root_devices_dev_dir(optarg);
5577c478bd9Sstevel@tonic-gate 				if (zone_pathcheck(root_dir) !=
5587c478bd9Sstevel@tonic-gate 				    DEVFSADM_SUCCESS)
5597c478bd9Sstevel@tonic-gate 					devfsadm_exit(1);
560537714daSvikram 					/*NOTREACHED*/
5617c478bd9Sstevel@tonic-gate 				break;
5627c478bd9Sstevel@tonic-gate 			case 's':
5637c478bd9Sstevel@tonic-gate 				/*
5647c478bd9Sstevel@tonic-gate 				 * suppress.  don't create/remove links/nodes
5657c478bd9Sstevel@tonic-gate 				 * useful with -v or -V
5667c478bd9Sstevel@tonic-gate 				 */
5677c478bd9Sstevel@tonic-gate 				file_mods = FALSE;
5687c478bd9Sstevel@tonic-gate 				flush_path_to_inst_enable = FALSE;
5697c478bd9Sstevel@tonic-gate 				break;
5707c478bd9Sstevel@tonic-gate 			case 't':
5717c478bd9Sstevel@tonic-gate 				/* supply a non-default table file */
5727c478bd9Sstevel@tonic-gate 				devlinktab_file = optarg;
5737c478bd9Sstevel@tonic-gate 				break;
5747c478bd9Sstevel@tonic-gate 			case 'v':
5757c478bd9Sstevel@tonic-gate 				/* documented verbose flag */
5767c478bd9Sstevel@tonic-gate 				add_verbose_id(VERBOSE_MID);
5777c478bd9Sstevel@tonic-gate 				break;
5787c478bd9Sstevel@tonic-gate 			case 'V':
5797c478bd9Sstevel@tonic-gate 				/* undocumented for extra verbose levels */
5807c478bd9Sstevel@tonic-gate 				add_verbose_id(optarg);
5817c478bd9Sstevel@tonic-gate 				break;
5827c478bd9Sstevel@tonic-gate 			default:
5837c478bd9Sstevel@tonic-gate 				usage();
5847c478bd9Sstevel@tonic-gate 				break;
5857c478bd9Sstevel@tonic-gate 			}
5867c478bd9Sstevel@tonic-gate 		}
5877c478bd9Sstevel@tonic-gate 
5887c478bd9Sstevel@tonic-gate 		if (optind < argc) {
5897c478bd9Sstevel@tonic-gate 			usage();
5907c478bd9Sstevel@tonic-gate 		}
5917c478bd9Sstevel@tonic-gate 
5927c478bd9Sstevel@tonic-gate 	} else if (strcmp(prog, DRVCONFIG) == 0) {
593c9cc1492SJerry Gilliam 		int update_only = 0;
5947c478bd9Sstevel@tonic-gate 		build_dev = FALSE;
5957c478bd9Sstevel@tonic-gate 
5967c478bd9Sstevel@tonic-gate 		while ((opt =
597c9cc1492SJerry Gilliam 		    getopt(argc, argv, "a:bc:dfi:m:np:R:r:suvV:x")) != EOF) {
5987c478bd9Sstevel@tonic-gate 			switch (opt) {
5997c478bd9Sstevel@tonic-gate 			case 'a':
6007c478bd9Sstevel@tonic-gate 				ap = calloc(sizeof (struct aliases), 1);
6017c478bd9Sstevel@tonic-gate 				ap->a_name = dequote(optarg);
6027c478bd9Sstevel@tonic-gate 				len = strlen(ap->a_name) + 1;
6037c478bd9Sstevel@tonic-gate 				if (len > MAXMODCONFNAME) {
6047c478bd9Sstevel@tonic-gate 					err_print(ALIAS_TOO_LONG,
6057c478bd9Sstevel@tonic-gate 					    MAXMODCONFNAME, ap->a_name);
6067c478bd9Sstevel@tonic-gate 					devfsadm_exit(1);
607537714daSvikram 					/*NOTREACHED*/
6087c478bd9Sstevel@tonic-gate 				}
6097c478bd9Sstevel@tonic-gate 				ap->a_len = len;
6107c478bd9Sstevel@tonic-gate 				if (a_tail == NULL) {
6117c478bd9Sstevel@tonic-gate 					a_head = ap;
6127c478bd9Sstevel@tonic-gate 				} else {
6137c478bd9Sstevel@tonic-gate 					a_tail->a_next = ap;
6147c478bd9Sstevel@tonic-gate 				}
6157c478bd9Sstevel@tonic-gate 				a_tail = ap;
6167c478bd9Sstevel@tonic-gate 				num_aliases++;
6176532b960SJerry Gilliam 				bind = TRUE;
6187c478bd9Sstevel@tonic-gate 				break;
6197c478bd9Sstevel@tonic-gate 			case 'b':
6206532b960SJerry Gilliam 				bind = TRUE;
6217c478bd9Sstevel@tonic-gate 				break;
6227c478bd9Sstevel@tonic-gate 			case 'c':
6237c478bd9Sstevel@tonic-gate 				(void) strcpy(mc.drvclass, optarg);
6247c478bd9Sstevel@tonic-gate 				break;
6257c478bd9Sstevel@tonic-gate 			case 'd':
6267c478bd9Sstevel@tonic-gate 				/*
6277c478bd9Sstevel@tonic-gate 				 * need to keep for compatibility, but
6287c478bd9Sstevel@tonic-gate 				 * do nothing.
6297c478bd9Sstevel@tonic-gate 				 */
6307c478bd9Sstevel@tonic-gate 				break;
6316532b960SJerry Gilliam 			case 'f':
6326532b960SJerry Gilliam 				force_flag = TRUE;
6336532b960SJerry Gilliam 				break;
6347c478bd9Sstevel@tonic-gate 			case 'i':
6357c478bd9Sstevel@tonic-gate 				single_drv = TRUE;
6367c478bd9Sstevel@tonic-gate 				(void) strcpy(mc.drvname, optarg);
6377c478bd9Sstevel@tonic-gate 				driver = s_strdup(optarg);
6387c478bd9Sstevel@tonic-gate 				break;
6397c478bd9Sstevel@tonic-gate 			case 'm':
6407c478bd9Sstevel@tonic-gate 				mc.major = atoi(optarg);
6417c478bd9Sstevel@tonic-gate 				break;
6427c478bd9Sstevel@tonic-gate 			case 'n':
6437c478bd9Sstevel@tonic-gate 				/* prevent driver loading and deferred attach */
6447c478bd9Sstevel@tonic-gate 				load_attach_drv = FALSE;
6457c478bd9Sstevel@tonic-gate 				break;
6467c478bd9Sstevel@tonic-gate 			case 'p':
6477c478bd9Sstevel@tonic-gate 				/* specify alternate path_to_inst file */
6487c478bd9Sstevel@tonic-gate 				inst_file = s_strdup(optarg);
6497c478bd9Sstevel@tonic-gate 				break;
6507c478bd9Sstevel@tonic-gate 			case 'R':
6517c478bd9Sstevel@tonic-gate 				/*
6527c478bd9Sstevel@tonic-gate 				 * Private flag for suninstall to populate
6537c478bd9Sstevel@tonic-gate 				 * device information on the installed root.
6547c478bd9Sstevel@tonic-gate 				 */
6557c478bd9Sstevel@tonic-gate 				root_dir = s_strdup(optarg);
6567c478bd9Sstevel@tonic-gate 				if (zone_pathcheck(root_dir) !=
6577c478bd9Sstevel@tonic-gate 				    DEVFSADM_SUCCESS)
6587c478bd9Sstevel@tonic-gate 				devfsadm_exit(devfsadm_copy());
659537714daSvikram 				/*NOTREACHED*/
6607c478bd9Sstevel@tonic-gate 				break;
6617c478bd9Sstevel@tonic-gate 			case 'r':
6627c478bd9Sstevel@tonic-gate 				devices_dir = s_strdup(optarg);
6637c478bd9Sstevel@tonic-gate 				if (zone_pathcheck(devices_dir) !=
6647c478bd9Sstevel@tonic-gate 				    DEVFSADM_SUCCESS)
6657c478bd9Sstevel@tonic-gate 					devfsadm_exit(1);
666537714daSvikram 					/*NOTREACHED*/
6677c478bd9Sstevel@tonic-gate 				break;
6687c478bd9Sstevel@tonic-gate 			case 's':
6697c478bd9Sstevel@tonic-gate 				/*
6707c478bd9Sstevel@tonic-gate 				 * suppress.  don't create nodes
6717c478bd9Sstevel@tonic-gate 				 * useful with -v or -V
6727c478bd9Sstevel@tonic-gate 				 */
6737c478bd9Sstevel@tonic-gate 				file_mods = FALSE;
6747c478bd9Sstevel@tonic-gate 				flush_path_to_inst_enable = FALSE;
6757c478bd9Sstevel@tonic-gate 				break;
6766532b960SJerry Gilliam 			case 'u':
6776532b960SJerry Gilliam 				/*
6786532b960SJerry Gilliam 				 * Invoked via update_drv(1m) to update
6796532b960SJerry Gilliam 				 * the kernel's driver/alias binding
6806532b960SJerry Gilliam 				 * when removing one or more aliases.
6816532b960SJerry Gilliam 				 */
6826532b960SJerry Gilliam 				config = FALSE;
6836532b960SJerry Gilliam 				break;
6847c478bd9Sstevel@tonic-gate 			case 'v':
6857c478bd9Sstevel@tonic-gate 				/* documented verbose flag */
6867c478bd9Sstevel@tonic-gate 				add_verbose_id(VERBOSE_MID);
6877c478bd9Sstevel@tonic-gate 				break;
6887c478bd9Sstevel@tonic-gate 			case 'V':
6897c478bd9Sstevel@tonic-gate 				/* undocumented for extra verbose levels */
6907c478bd9Sstevel@tonic-gate 				add_verbose_id(optarg);
6917c478bd9Sstevel@tonic-gate 				break;
692c9cc1492SJerry Gilliam 			case 'x':
693c9cc1492SJerry Gilliam 				update_only = 1;
694c9cc1492SJerry Gilliam 				break;
6957c478bd9Sstevel@tonic-gate 			default:
6967c478bd9Sstevel@tonic-gate 				usage();
6977c478bd9Sstevel@tonic-gate 			}
6987c478bd9Sstevel@tonic-gate 		}
6997c478bd9Sstevel@tonic-gate 
7007c478bd9Sstevel@tonic-gate 		if (optind < argc) {
7017c478bd9Sstevel@tonic-gate 			usage();
7027c478bd9Sstevel@tonic-gate 		}
7037c478bd9Sstevel@tonic-gate 
7046532b960SJerry Gilliam 		if (bind == TRUE) {
7056532b960SJerry Gilliam 			if ((mc.major == -1) || (mc.drvname[0] == NULL)) {
7066532b960SJerry Gilliam 				err_print(MAJOR_AND_B_FLAG);
7076532b960SJerry Gilliam 				devfsadm_exit(1);
7086532b960SJerry Gilliam 				/*NOTREACHED*/
7096532b960SJerry Gilliam 			}
710c9cc1492SJerry Gilliam 			mc.flags = 0;
711c9cc1492SJerry Gilliam 			if (force_flag)
712c9cc1492SJerry Gilliam 				mc.flags |= MOD_UNBIND_OVERRIDE;
713c9cc1492SJerry Gilliam 			if (update_only)
714c9cc1492SJerry Gilliam 				mc.flags |= MOD_ADDMAJBIND_UPDATE;
7157c478bd9Sstevel@tonic-gate 			mc.num_aliases = num_aliases;
7167c478bd9Sstevel@tonic-gate 			mc.ap = a_head;
7176532b960SJerry Gilliam 			retval =  modctl((config == TRUE) ? MODADDMAJBIND :
7186532b960SJerry Gilliam 			    MODREMDRVALIAS, NULL, (caddr_t)&mc);
7197c478bd9Sstevel@tonic-gate 			if (retval < 0) {
7206532b960SJerry Gilliam 				err_print((config == TRUE) ? MODCTL_ADDMAJBIND :
7216532b960SJerry Gilliam 				    MODCTL_REMMAJBIND);
7227c478bd9Sstevel@tonic-gate 			}
7237c478bd9Sstevel@tonic-gate 			devfsadm_exit(retval);
724537714daSvikram 			/*NOTREACHED*/
7257c478bd9Sstevel@tonic-gate 		}
7267c478bd9Sstevel@tonic-gate 
7277c478bd9Sstevel@tonic-gate 	} else if ((strcmp(prog, DEVFSADM) == 0) ||
7287c478bd9Sstevel@tonic-gate 	    (strcmp(prog, DEVFSADMD) == 0)) {
7297c478bd9Sstevel@tonic-gate 		char *zonename = NULL;
7307c478bd9Sstevel@tonic-gate 		int init_drvconf = 0;
7317c478bd9Sstevel@tonic-gate 		int init_perm = 0;
7327c478bd9Sstevel@tonic-gate 		int public_mode = 0;
733facf4a8dSllai 		int init_sysavail = 0;
7347c478bd9Sstevel@tonic-gate 
7357c478bd9Sstevel@tonic-gate 		if (strcmp(prog, DEVFSADMD) == 0) {
7367c478bd9Sstevel@tonic-gate 			daemon_mode = TRUE;
7377c478bd9Sstevel@tonic-gate 		}
7387c478bd9Sstevel@tonic-gate 
7397c478bd9Sstevel@tonic-gate 		devlinktab_file = DEVLINKTAB_FILE;
7407c478bd9Sstevel@tonic-gate 
7417c478bd9Sstevel@tonic-gate 		while ((opt = getopt(argc, argv,
742c9cc1492SJerry Gilliam 		    "a:Cc:deIi:l:np:PR:r:sSt:uvV:x:")) != EOF) {
743facf4a8dSllai 			if (opt == 'I' || opt == 'P' || opt == 'S') {
7447c478bd9Sstevel@tonic-gate 				if (public_mode)
7457c478bd9Sstevel@tonic-gate 					usage();
7467c478bd9Sstevel@tonic-gate 			} else {
747facf4a8dSllai 				if (init_perm || init_drvconf || init_sysavail)
7487c478bd9Sstevel@tonic-gate 					usage();
7497c478bd9Sstevel@tonic-gate 				public_mode = 1;
7507c478bd9Sstevel@tonic-gate 			}
7517c478bd9Sstevel@tonic-gate 			switch (opt) {
752facf4a8dSllai 			case 'a':
753facf4a8dSllai 				attr_root = s_strdup(optarg);
754facf4a8dSllai 				break;
7557c478bd9Sstevel@tonic-gate 			case 'C':
7567c478bd9Sstevel@tonic-gate 				cleanup = TRUE;
7577c478bd9Sstevel@tonic-gate 				break;
7587c478bd9Sstevel@tonic-gate 			case 'c':
7597c478bd9Sstevel@tonic-gate 				num_classes++;
7600a653502Swroche 				classes = s_realloc(classes,
7610a653502Swroche 				    num_classes * sizeof (char *));
7627c478bd9Sstevel@tonic-gate 				classes[num_classes - 1] = optarg;
7637c478bd9Sstevel@tonic-gate 				break;
76445916cd2Sjpk 			case 'd':
7657c478bd9Sstevel@tonic-gate 				if (daemon_mode == FALSE) {
76645916cd2Sjpk 					/*
76745916cd2Sjpk 					 * Device allocation to be disabled.
76845916cd2Sjpk 					 */
76945916cd2Sjpk 					devalloc_flag = DA_OFF;
77045916cd2Sjpk 					build_dev = FALSE;
77145916cd2Sjpk 				}
77245916cd2Sjpk 				break;
77345916cd2Sjpk 			case 'e':
77445916cd2Sjpk 				if (daemon_mode == FALSE) {
77545916cd2Sjpk 					/*
77645916cd2Sjpk 					 * Device allocation to be enabled.
77745916cd2Sjpk 					 */
77845916cd2Sjpk 					devalloc_flag = DA_ON;
7797c478bd9Sstevel@tonic-gate 					build_dev = FALSE;
7807c478bd9Sstevel@tonic-gate 				}
7817c478bd9Sstevel@tonic-gate 				break;
7827c478bd9Sstevel@tonic-gate 			case 'I':	/* update kernel driver.conf cache */
7837c478bd9Sstevel@tonic-gate 				if (daemon_mode == TRUE)
7847c478bd9Sstevel@tonic-gate 					usage();
7857c478bd9Sstevel@tonic-gate 				init_drvconf = 1;
7867c478bd9Sstevel@tonic-gate 				break;
7877c478bd9Sstevel@tonic-gate 			case 'i':
7887c478bd9Sstevel@tonic-gate 				single_drv = TRUE;
7897c478bd9Sstevel@tonic-gate 				driver = s_strdup(optarg);
7907c478bd9Sstevel@tonic-gate 				break;
7917c478bd9Sstevel@tonic-gate 			case 'l':
7927c478bd9Sstevel@tonic-gate 				/* specify an alternate module load path */
7937c478bd9Sstevel@tonic-gate 				module_dirs = s_strdup(optarg);
7947c478bd9Sstevel@tonic-gate 				break;
7957c478bd9Sstevel@tonic-gate 			case 'n':
7967c478bd9Sstevel@tonic-gate 				/* prevent driver loading and deferred attach */
7977c478bd9Sstevel@tonic-gate 				load_attach_drv = FALSE;
7987c478bd9Sstevel@tonic-gate 				break;
7997c478bd9Sstevel@tonic-gate 			case 'p':
8007c478bd9Sstevel@tonic-gate 				/* specify alternate path_to_inst file */
8017c478bd9Sstevel@tonic-gate 				inst_file = s_strdup(optarg);
8027c478bd9Sstevel@tonic-gate 				break;
8037c478bd9Sstevel@tonic-gate 			case 'P':
8047c478bd9Sstevel@tonic-gate 				if (daemon_mode == TRUE)
8057c478bd9Sstevel@tonic-gate 					usage();
8067c478bd9Sstevel@tonic-gate 				/* load minor_perm and device_policy */
8077c478bd9Sstevel@tonic-gate 				init_perm = 1;
8087c478bd9Sstevel@tonic-gate 				break;
8097c478bd9Sstevel@tonic-gate 			case 'R':
8107c478bd9Sstevel@tonic-gate 				/*
8117c478bd9Sstevel@tonic-gate 				 * Private flag for suninstall to populate
8127c478bd9Sstevel@tonic-gate 				 * device information on the installed root.
8137c478bd9Sstevel@tonic-gate 				 */
8147c478bd9Sstevel@tonic-gate 				root_dir = s_strdup(optarg);
8157c478bd9Sstevel@tonic-gate 				devfsadm_exit(devfsadm_copy());
816537714daSvikram 				/*NOTREACHED*/
8177c478bd9Sstevel@tonic-gate 				break;
8187c478bd9Sstevel@tonic-gate 			case 'r':
819facf4a8dSllai 				set_root_devices_dev_dir(optarg);
8207c478bd9Sstevel@tonic-gate 				break;
8217c478bd9Sstevel@tonic-gate 			case 's':
8227c478bd9Sstevel@tonic-gate 				/*
8237c478bd9Sstevel@tonic-gate 				 * suppress. don't create/remove links/nodes
8247c478bd9Sstevel@tonic-gate 				 * useful with -v or -V
8257c478bd9Sstevel@tonic-gate 				 */
8267c478bd9Sstevel@tonic-gate 				file_mods = FALSE;
8277c478bd9Sstevel@tonic-gate 				flush_path_to_inst_enable = FALSE;
8287c478bd9Sstevel@tonic-gate 				break;
829facf4a8dSllai 			case 'S':
830facf4a8dSllai 				if (daemon_mode == TRUE)
831facf4a8dSllai 					usage();
832facf4a8dSllai 				init_sysavail = 1;
833facf4a8dSllai 				break;
8347c478bd9Sstevel@tonic-gate 			case 't':
8357c478bd9Sstevel@tonic-gate 				devlinktab_file = optarg;
8367c478bd9Sstevel@tonic-gate 				break;
837c9cc1492SJerry Gilliam 			case 'u':	/* complete configuration after */
838c9cc1492SJerry Gilliam 					/* adding a driver update-only */
839c9cc1492SJerry Gilliam 				if (daemon_mode == TRUE)
840c9cc1492SJerry Gilliam 					usage();
841c9cc1492SJerry Gilliam 				update_all_drivers = TRUE;
842c9cc1492SJerry Gilliam 				break;
8437c478bd9Sstevel@tonic-gate 			case 'v':
8447c478bd9Sstevel@tonic-gate 				/* documented verbose flag */
8457c478bd9Sstevel@tonic-gate 				add_verbose_id(VERBOSE_MID);
8467c478bd9Sstevel@tonic-gate 				break;
8477c478bd9Sstevel@tonic-gate 			case 'V':
8487c478bd9Sstevel@tonic-gate 				/* undocumented: specify verbose lvl */
8497c478bd9Sstevel@tonic-gate 				add_verbose_id(optarg);
8507c478bd9Sstevel@tonic-gate 				break;
8517c478bd9Sstevel@tonic-gate 			case 'x':
8527c478bd9Sstevel@tonic-gate 				/*
8537c478bd9Sstevel@tonic-gate 				 * x is the "private switch" option.  The
8547c478bd9Sstevel@tonic-gate 				 * goal is to not suck up all the other
8557c478bd9Sstevel@tonic-gate 				 * option letters.
8567c478bd9Sstevel@tonic-gate 				 */
8577c478bd9Sstevel@tonic-gate 				if (strcmp(optarg, "update_devlinksdb") == 0) {
8587c478bd9Sstevel@tonic-gate 					update_database = TRUE;
8597c478bd9Sstevel@tonic-gate 				} else if (strcmp(optarg, "no_dev") == 0) {
8607c478bd9Sstevel@tonic-gate 					/* don't build /dev */
8617c478bd9Sstevel@tonic-gate 					build_dev = FALSE;
8627c478bd9Sstevel@tonic-gate 				} else if (strcmp(optarg, "no_devices") == 0) {
8637c478bd9Sstevel@tonic-gate 					/* don't build /devices */
8647c478bd9Sstevel@tonic-gate 					build_devices = FALSE;
8657c478bd9Sstevel@tonic-gate 				} else if (strcmp(optarg, "no_p2i") == 0) {
8667c478bd9Sstevel@tonic-gate 					/* don't flush path_to_inst */
8677c478bd9Sstevel@tonic-gate 					flush_path_to_inst_enable = FALSE;
8687c478bd9Sstevel@tonic-gate 				} else if (strcmp(optarg, "use_dicache") == 0) {
8697c478bd9Sstevel@tonic-gate 					use_snapshot_cache = TRUE;
8707c478bd9Sstevel@tonic-gate 				} else {
8717c478bd9Sstevel@tonic-gate 					usage();
8727c478bd9Sstevel@tonic-gate 				}
8737c478bd9Sstevel@tonic-gate 				break;
8747c478bd9Sstevel@tonic-gate 			default:
8757c478bd9Sstevel@tonic-gate 				usage();
8767c478bd9Sstevel@tonic-gate 				break;
8777c478bd9Sstevel@tonic-gate 			}
8787c478bd9Sstevel@tonic-gate 		}
8797c478bd9Sstevel@tonic-gate 		if (optind < argc) {
8807c478bd9Sstevel@tonic-gate 			usage();
8817c478bd9Sstevel@tonic-gate 		}
8827c478bd9Sstevel@tonic-gate 
8837c478bd9Sstevel@tonic-gate 		/*
8847c478bd9Sstevel@tonic-gate 		 * We're not in zone mode; Check to see if the rootpath
8857c478bd9Sstevel@tonic-gate 		 * collides with any zonepaths.
8867c478bd9Sstevel@tonic-gate 		 */
8877c478bd9Sstevel@tonic-gate 		if (zonename == NULL) {
8887c478bd9Sstevel@tonic-gate 			if (zone_pathcheck(root_dir) != DEVFSADM_SUCCESS)
8897c478bd9Sstevel@tonic-gate 				devfsadm_exit(1);
890537714daSvikram 				/*NOTREACHED*/
8917c478bd9Sstevel@tonic-gate 		}
8927c478bd9Sstevel@tonic-gate 
893facf4a8dSllai 		if (init_drvconf || init_perm || init_sysavail) {
8947c478bd9Sstevel@tonic-gate 			/*
8957c478bd9Sstevel@tonic-gate 			 * Load minor perm before force-loading drivers
8967c478bd9Sstevel@tonic-gate 			 * so the correct permissions are picked up.
8977c478bd9Sstevel@tonic-gate 			 */
898facf4a8dSllai 			if (init_perm) {
899facf4a8dSllai 				check_reconfig_state();
9007c478bd9Sstevel@tonic-gate 				load_dev_acl();
901facf4a8dSllai 			}
9027c478bd9Sstevel@tonic-gate 			if (init_drvconf)
903c9cc1492SJerry Gilliam 				update_drvconf((major_t)-1, 0);
904facf4a8dSllai 			if (init_sysavail)
905facf4a8dSllai 				modctl_sysavail();
9067c478bd9Sstevel@tonic-gate 			devfsadm_exit(0);
907537714daSvikram 			/*NOTREACHED*/
9087c478bd9Sstevel@tonic-gate 		}
9097c478bd9Sstevel@tonic-gate 	}
9107c478bd9Sstevel@tonic-gate 
9117c478bd9Sstevel@tonic-gate 
9127c478bd9Sstevel@tonic-gate 	if (get_linkcompat_opts == TRUE) {
9137c478bd9Sstevel@tonic-gate 
9147c478bd9Sstevel@tonic-gate 		build_devices = FALSE;
9157c478bd9Sstevel@tonic-gate 		load_attach_drv = FALSE;
9167c478bd9Sstevel@tonic-gate 		num_classes++;
9177c478bd9Sstevel@tonic-gate 		classes = s_realloc(classes, num_classes *
9187c478bd9Sstevel@tonic-gate 		    sizeof (char *));
9197c478bd9Sstevel@tonic-gate 		classes[num_classes - 1] = compat_class;
9207c478bd9Sstevel@tonic-gate 
9217c478bd9Sstevel@tonic-gate 		while ((opt = getopt(argc, argv, "Cnr:svV:")) != EOF) {
9227c478bd9Sstevel@tonic-gate 			switch (opt) {
9237c478bd9Sstevel@tonic-gate 			case 'C':
9247c478bd9Sstevel@tonic-gate 				cleanup = TRUE;
9257c478bd9Sstevel@tonic-gate 				break;
9267c478bd9Sstevel@tonic-gate 			case 'n':
9277c478bd9Sstevel@tonic-gate 				/* prevent driver loading or deferred attach */
9287c478bd9Sstevel@tonic-gate 				load_attach_drv = FALSE;
9297c478bd9Sstevel@tonic-gate 				break;
9307c478bd9Sstevel@tonic-gate 			case 'r':
931facf4a8dSllai 				set_root_devices_dev_dir(optarg);
9327c478bd9Sstevel@tonic-gate 				if (zone_pathcheck(root_dir) !=
9337c478bd9Sstevel@tonic-gate 				    DEVFSADM_SUCCESS)
9347c478bd9Sstevel@tonic-gate 					devfsadm_exit(1);
935537714daSvikram 					/*NOTREACHED*/
9367c478bd9Sstevel@tonic-gate 				break;
9377c478bd9Sstevel@tonic-gate 			case 's':
9387c478bd9Sstevel@tonic-gate 				/* suppress.  don't create/remove links/nodes */
9397c478bd9Sstevel@tonic-gate 				/* useful with -v or -V */
9407c478bd9Sstevel@tonic-gate 				file_mods = FALSE;
9417c478bd9Sstevel@tonic-gate 				flush_path_to_inst_enable = FALSE;
9427c478bd9Sstevel@tonic-gate 				break;
9437c478bd9Sstevel@tonic-gate 			case 'v':
9447c478bd9Sstevel@tonic-gate 				/* documented verbose flag */
9457c478bd9Sstevel@tonic-gate 				add_verbose_id(VERBOSE_MID);
9467c478bd9Sstevel@tonic-gate 				break;
9477c478bd9Sstevel@tonic-gate 			case 'V':
9487c478bd9Sstevel@tonic-gate 				/* undocumented for extra verbose levels */
9497c478bd9Sstevel@tonic-gate 				add_verbose_id(optarg);
9507c478bd9Sstevel@tonic-gate 				break;
9517c478bd9Sstevel@tonic-gate 			default:
9527c478bd9Sstevel@tonic-gate 				usage();
9537c478bd9Sstevel@tonic-gate 			}
9547c478bd9Sstevel@tonic-gate 		}
9557c478bd9Sstevel@tonic-gate 		if (optind < argc) {
9567c478bd9Sstevel@tonic-gate 			usage();
9577c478bd9Sstevel@tonic-gate 		}
9587c478bd9Sstevel@tonic-gate 	}
959facf4a8dSllai 	set_lock_root();
9607c478bd9Sstevel@tonic-gate }
9617c478bd9Sstevel@tonic-gate 
9627c478bd9Sstevel@tonic-gate void
9637c478bd9Sstevel@tonic-gate usage(void)
9647c478bd9Sstevel@tonic-gate {
9657c478bd9Sstevel@tonic-gate 	if (strcmp(prog, DEVLINKS) == 0) {
9667c478bd9Sstevel@tonic-gate 		err_print(DEVLINKS_USAGE);
9677c478bd9Sstevel@tonic-gate 	} else if (strcmp(prog, DRVCONFIG) == 0) {
9687c478bd9Sstevel@tonic-gate 		err_print(DRVCONFIG_USAGE);
9697c478bd9Sstevel@tonic-gate 	} else if ((strcmp(prog, DEVFSADM) == 0) ||
9700a653502Swroche 	    (strcmp(prog, DEVFSADMD) == 0)) {
9717c478bd9Sstevel@tonic-gate 		err_print(DEVFSADM_USAGE);
9727c478bd9Sstevel@tonic-gate 	} else {
9737c478bd9Sstevel@tonic-gate 		err_print(COMPAT_LINK_USAGE);
9747c478bd9Sstevel@tonic-gate 	}
9757c478bd9Sstevel@tonic-gate 
9767c478bd9Sstevel@tonic-gate 	devfsadm_exit(1);
977537714daSvikram 	/*NOTREACHED*/
9787c478bd9Sstevel@tonic-gate }
9797c478bd9Sstevel@tonic-gate 
9807c478bd9Sstevel@tonic-gate static void
9817c478bd9Sstevel@tonic-gate devi_tree_walk(struct dca_impl *dcip, int flags, char *ev_subclass)
9827c478bd9Sstevel@tonic-gate {
9837c478bd9Sstevel@tonic-gate 	char *msg, *name;
9847c478bd9Sstevel@tonic-gate 	struct mlist	mlist = {0};
9857c478bd9Sstevel@tonic-gate 	di_node_t	node;
9867c478bd9Sstevel@tonic-gate 
9877c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "devi_tree_walk: root=%s, minor=%s, driver=%s,"
9887c478bd9Sstevel@tonic-gate 	    " error=%d, flags=%u\n", dcip->dci_root,
9897c478bd9Sstevel@tonic-gate 	    dcip->dci_minor ? dcip->dci_minor : "<NULL>",
9907c478bd9Sstevel@tonic-gate 	    dcip->dci_driver ? dcip->dci_driver : "<NULL>", dcip->dci_error,
9917c478bd9Sstevel@tonic-gate 	    dcip->dci_flags);
9927c478bd9Sstevel@tonic-gate 
9937c478bd9Sstevel@tonic-gate 	assert(dcip->dci_root);
9947c478bd9Sstevel@tonic-gate 
9957c478bd9Sstevel@tonic-gate 	if (dcip->dci_flags & DCA_LOAD_DRV) {
9967c478bd9Sstevel@tonic-gate 		node = di_init_driver(dcip->dci_driver, flags);
9977c478bd9Sstevel@tonic-gate 		msg = DRIVER_FAILURE;
9987c478bd9Sstevel@tonic-gate 		name = dcip->dci_driver;
9997c478bd9Sstevel@tonic-gate 	} else {
10007c478bd9Sstevel@tonic-gate 		node = di_init(dcip->dci_root, flags);
10017c478bd9Sstevel@tonic-gate 		msg = DI_INIT_FAILED;
10027c478bd9Sstevel@tonic-gate 		name = dcip->dci_root;
10037c478bd9Sstevel@tonic-gate 	}
10047c478bd9Sstevel@tonic-gate 
10057c478bd9Sstevel@tonic-gate 	if (node == DI_NODE_NIL) {
10067c478bd9Sstevel@tonic-gate 		dcip->dci_error = errno;
10077c478bd9Sstevel@tonic-gate 		/*
10087c478bd9Sstevel@tonic-gate 		 * Rapid hotplugging (commonly seen during USB testing),
10097c478bd9Sstevel@tonic-gate 		 * may remove a device before the create event for it
10107c478bd9Sstevel@tonic-gate 		 * has been processed. To prevent alarming users with
10117c478bd9Sstevel@tonic-gate 		 * a superfluous message, we suppress error messages
10127c478bd9Sstevel@tonic-gate 		 * for ENXIO and hotplug.
10137c478bd9Sstevel@tonic-gate 		 */
10147c478bd9Sstevel@tonic-gate 		if (!(errno == ENXIO && (dcip->dci_flags & DCA_HOT_PLUG)))
10157c478bd9Sstevel@tonic-gate 			err_print(msg, name, strerror(dcip->dci_error));
10167c478bd9Sstevel@tonic-gate 		return;
10177c478bd9Sstevel@tonic-gate 	}
10187c478bd9Sstevel@tonic-gate 
10197c478bd9Sstevel@tonic-gate 	if (dcip->dci_flags & DCA_FLUSH_PATHINST)
10207c478bd9Sstevel@tonic-gate 		flush_path_to_inst();
10217c478bd9Sstevel@tonic-gate 
10227c478bd9Sstevel@tonic-gate 	dcip->dci_arg = &mlist;
102394c894bbSVikram Hegde 	devi_root_node = node;	/* protected by lock_dev() */
10247c478bd9Sstevel@tonic-gate 
10257c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "walking device tree\n");
10267c478bd9Sstevel@tonic-gate 
10277c478bd9Sstevel@tonic-gate 	(void) di_walk_minor(node, NULL, DI_CHECK_ALIAS, dcip,
10287c478bd9Sstevel@tonic-gate 	    check_minor_type);
10297c478bd9Sstevel@tonic-gate 
10307c478bd9Sstevel@tonic-gate 	process_deferred_links(dcip, DCA_CREATE_LINK);
10317c478bd9Sstevel@tonic-gate 
10327c478bd9Sstevel@tonic-gate 	dcip->dci_arg = NULL;
10337c478bd9Sstevel@tonic-gate 
10347c478bd9Sstevel@tonic-gate 	/*
10357c478bd9Sstevel@tonic-gate 	 * Finished creating devfs files and dev links.
10360dc974a9SCathy Zhou 	 * Log sysevent.
10377c478bd9Sstevel@tonic-gate 	 */
10387c478bd9Sstevel@tonic-gate 	if (ev_subclass)
1039f05faa4eSjacobs 		build_and_enq_event(EC_DEV_ADD, ev_subclass, dcip->dci_root,
104030294554Sphitran 		    node, dcip->dci_minor);
10417c478bd9Sstevel@tonic-gate 
104245916cd2Sjpk 	/* Add new device to device allocation database */
104345916cd2Sjpk 	if (system_labeled && update_devdb) {
104445916cd2Sjpk 		_update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir);
104545916cd2Sjpk 		update_devdb = 0;
104645916cd2Sjpk 	}
104745916cd2Sjpk 
104894c894bbSVikram Hegde 	devi_root_node = DI_NODE_NIL;	/* protected by lock_dev() */
10497c478bd9Sstevel@tonic-gate 	di_fini(node);
10507c478bd9Sstevel@tonic-gate }
10517c478bd9Sstevel@tonic-gate 
10527c478bd9Sstevel@tonic-gate static void
10537c478bd9Sstevel@tonic-gate process_deferred_links(struct dca_impl *dcip, int flags)
10547c478bd9Sstevel@tonic-gate {
10557c478bd9Sstevel@tonic-gate 	struct mlist	*dep;
10567c478bd9Sstevel@tonic-gate 	struct minor	*mp, *smp;
10577c478bd9Sstevel@tonic-gate 
10587c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "processing deferred links\n");
10597c478bd9Sstevel@tonic-gate 
10607c478bd9Sstevel@tonic-gate 	dep = dcip->dci_arg;
10617c478bd9Sstevel@tonic-gate 
10627c478bd9Sstevel@tonic-gate 	/*
10637c478bd9Sstevel@tonic-gate 	 * The list head is not used during the deferred create phase
10647c478bd9Sstevel@tonic-gate 	 */
10657c478bd9Sstevel@tonic-gate 	dcip->dci_arg = NULL;
10667c478bd9Sstevel@tonic-gate 
10677c478bd9Sstevel@tonic-gate 	assert(dep);
10687c478bd9Sstevel@tonic-gate 	assert((dep->head == NULL) ^ (dep->tail != NULL));
10697c478bd9Sstevel@tonic-gate 	assert(flags == DCA_FREE_LIST || flags == DCA_CREATE_LINK);
10707c478bd9Sstevel@tonic-gate 
10717c478bd9Sstevel@tonic-gate 	for (smp = NULL, mp = dep->head; mp; mp = mp->next) {
10727c478bd9Sstevel@tonic-gate 		if (flags == DCA_CREATE_LINK)
10737c478bd9Sstevel@tonic-gate 			(void) check_minor_type(mp->node, mp->minor, dcip);
10747c478bd9Sstevel@tonic-gate 		free(smp);
10757c478bd9Sstevel@tonic-gate 		smp = mp;
10767c478bd9Sstevel@tonic-gate 	}
10777c478bd9Sstevel@tonic-gate 
10787c478bd9Sstevel@tonic-gate 	free(smp);
10797c478bd9Sstevel@tonic-gate }
10807c478bd9Sstevel@tonic-gate 
10817c478bd9Sstevel@tonic-gate /*
10827c478bd9Sstevel@tonic-gate  * Called in non-daemon mode to take a snap shot of the devinfo tree.
10837c478bd9Sstevel@tonic-gate  * Then it calls the appropriate functions to build /devices and /dev.
10847c478bd9Sstevel@tonic-gate  * It also flushes path_to_inst.
108598a9beefShtk  * Except in the devfsadm -i (single driver case), the flags used by devfsadm
108698a9beefShtk  * needs to match DI_CACHE_SNAPSHOT_FLAGS. That will make DINFOCACHE snapshot
108798a9beefShtk  * updated.
10887c478bd9Sstevel@tonic-gate  */
10897c478bd9Sstevel@tonic-gate void
10907c478bd9Sstevel@tonic-gate process_devinfo_tree()
10917c478bd9Sstevel@tonic-gate {
109298a9beefShtk 	uint_t		flags;
10937c478bd9Sstevel@tonic-gate 	struct dca_impl	dci;
10947c478bd9Sstevel@tonic-gate 	char		name[MAXNAMELEN];
10957c478bd9Sstevel@tonic-gate 	char		*fcn = "process_devinfo_tree: ";
10967c478bd9Sstevel@tonic-gate 
10977c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "%senter\n", fcn);
10987c478bd9Sstevel@tonic-gate 
10997c478bd9Sstevel@tonic-gate 	dca_impl_init("/", NULL, &dci);
11007c478bd9Sstevel@tonic-gate 
11017c478bd9Sstevel@tonic-gate 	lock_dev();
11027c478bd9Sstevel@tonic-gate 
11037c478bd9Sstevel@tonic-gate 	/*
11047c478bd9Sstevel@tonic-gate 	 * Update kernel driver.conf cache when devfsadm/drvconfig
11057c478bd9Sstevel@tonic-gate 	 * is invoked to build /devices and /dev.
11067c478bd9Sstevel@tonic-gate 	 */
1107c9cc1492SJerry Gilliam 	if (update_all_drivers || load_attach_drv) {
1108c9cc1492SJerry Gilliam 		update_drvconf((major_t)-1,
1109c9cc1492SJerry Gilliam 		    update_all_drivers ? MOD_LOADDRVCONF_RECONF : 0);
1110c9cc1492SJerry Gilliam 	}
11117c478bd9Sstevel@tonic-gate 
11127c478bd9Sstevel@tonic-gate 	if (single_drv == TRUE) {
11137c478bd9Sstevel@tonic-gate 		/*
11147c478bd9Sstevel@tonic-gate 		 * load a single driver, but walk the entire devinfo tree
11157c478bd9Sstevel@tonic-gate 		 */
11167c478bd9Sstevel@tonic-gate 		if (load_attach_drv == FALSE)
11177c478bd9Sstevel@tonic-gate 			err_print(DRV_LOAD_REQD);
11187c478bd9Sstevel@tonic-gate 
11197c478bd9Sstevel@tonic-gate 		vprint(CHATTY_MID, "%sattaching driver (%s)\n", fcn, driver);
11207c478bd9Sstevel@tonic-gate 
11217c478bd9Sstevel@tonic-gate 		dci.dci_flags |= DCA_LOAD_DRV;
11227c478bd9Sstevel@tonic-gate 		(void) snprintf(name, sizeof (name), "%s", driver);
11237c478bd9Sstevel@tonic-gate 		dci.dci_driver = name;
112498a9beefShtk 		flags = DINFOCPYALL | DINFOPATH;
11257c478bd9Sstevel@tonic-gate 
11267c478bd9Sstevel@tonic-gate 	} else if (load_attach_drv == TRUE) {
11277c478bd9Sstevel@tonic-gate 		/*
112845916cd2Sjpk 		 * Load and attach all drivers, then walk the entire tree.
11297c478bd9Sstevel@tonic-gate 		 * If the cache flag is set, use DINFOCACHE to get cached
11307c478bd9Sstevel@tonic-gate 		 * data.
11317c478bd9Sstevel@tonic-gate 		 */
11327c478bd9Sstevel@tonic-gate 		if (use_snapshot_cache == TRUE) {
11337c478bd9Sstevel@tonic-gate 			flags = DINFOCACHE;
11347c478bd9Sstevel@tonic-gate 			vprint(CHATTY_MID, "%susing snapshot cache\n", fcn);
11357c478bd9Sstevel@tonic-gate 		} else {
11367c478bd9Sstevel@tonic-gate 			vprint(CHATTY_MID, "%sattaching all drivers\n", fcn);
113798a9beefShtk 			flags = DI_CACHE_SNAPSHOT_FLAGS;
11383c34adc5Sramat 			if (cleanup) {
11393c34adc5Sramat 				/*
11403c34adc5Sramat 				 * remove dangling entries from /etc/devices
11413c34adc5Sramat 				 * files.
11423c34adc5Sramat 				 */
11433c34adc5Sramat 				flags |= DINFOCLEANUP;
11443c34adc5Sramat 			}
11457c478bd9Sstevel@tonic-gate 		}
114634087db8Shtk 	} else {
114734087db8Shtk 		/*
114834087db8Shtk 		 * For devlinks, disks, ports, tapes and devfsadm -n,
114934087db8Shtk 		 * just need to take a snapshot with active devices.
115034087db8Shtk 		 */
115134087db8Shtk 		vprint(CHATTY_MID, "%staking snapshot of active devices\n",
11520a653502Swroche 		    fcn);
115334087db8Shtk 		flags = DINFOCPYALL;
11547c478bd9Sstevel@tonic-gate 	}
11557c478bd9Sstevel@tonic-gate 
11567c478bd9Sstevel@tonic-gate 	if (((load_attach_drv == TRUE) || (single_drv == TRUE)) &&
11577c478bd9Sstevel@tonic-gate 	    (build_devices == TRUE)) {
11587c478bd9Sstevel@tonic-gate 		dci.dci_flags |= DCA_FLUSH_PATHINST;
11597c478bd9Sstevel@tonic-gate 	}
11607c478bd9Sstevel@tonic-gate 
11617c478bd9Sstevel@tonic-gate 	/* handle pre-cleanup operations desired by the modules. */
11627c478bd9Sstevel@tonic-gate 	pre_and_post_cleanup(RM_PRE);
11637c478bd9Sstevel@tonic-gate 
11647c478bd9Sstevel@tonic-gate 	devi_tree_walk(&dci, flags, NULL);
11657c478bd9Sstevel@tonic-gate 
11667c478bd9Sstevel@tonic-gate 	if (dci.dci_error) {
11677c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1168537714daSvikram 		/*NOTREACHED*/
11697c478bd9Sstevel@tonic-gate 	}
11707c478bd9Sstevel@tonic-gate 
11717c478bd9Sstevel@tonic-gate 	/* handle post-cleanup operations desired by the modules. */
11727c478bd9Sstevel@tonic-gate 	pre_and_post_cleanup(RM_POST);
11737c478bd9Sstevel@tonic-gate 
11747c478bd9Sstevel@tonic-gate 	unlock_dev(SYNC_STATE);
11757c478bd9Sstevel@tonic-gate }
11767c478bd9Sstevel@tonic-gate 
11777c478bd9Sstevel@tonic-gate /*ARGSUSED*/
11787c478bd9Sstevel@tonic-gate static void
11797c478bd9Sstevel@tonic-gate print_cache_signal(int signo)
11807c478bd9Sstevel@tonic-gate {
11817c478bd9Sstevel@tonic-gate 	if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) {
11827c478bd9Sstevel@tonic-gate 		err_print("signal SIGUSR1 failed: %s\n", strerror(errno));
11837c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1184537714daSvikram 		/*NOTREACHED*/
11857c478bd9Sstevel@tonic-gate 	}
11867c478bd9Sstevel@tonic-gate }
11877c478bd9Sstevel@tonic-gate 
1188facf4a8dSllai static void
1189facf4a8dSllai revoke_lookup_door(void)
1190facf4a8dSllai {
1191facf4a8dSllai 	if (lookup_door_fd != -1) {
1192facf4a8dSllai 		if (door_revoke(lookup_door_fd) == -1) {
1193facf4a8dSllai 			err_print("door_revoke of %s failed - %s\n",
1194facf4a8dSllai 			    lookup_door_path, strerror(errno));
1195facf4a8dSllai 		}
1196facf4a8dSllai 	}
1197facf4a8dSllai }
1198facf4a8dSllai 
1199facf4a8dSllai /*ARGSUSED*/
1200facf4a8dSllai static void
1201facf4a8dSllai catch_exit(int signo)
1202facf4a8dSllai {
1203facf4a8dSllai 	revoke_lookup_door();
1204facf4a8dSllai }
1205facf4a8dSllai 
12067c478bd9Sstevel@tonic-gate /*
12077c478bd9Sstevel@tonic-gate  * Register with eventd for messages. Create doors for synchronous
12087c478bd9Sstevel@tonic-gate  * link creation.
12097c478bd9Sstevel@tonic-gate  */
12107c478bd9Sstevel@tonic-gate static void
12117c478bd9Sstevel@tonic-gate daemon_update(void)
12127c478bd9Sstevel@tonic-gate {
12137c478bd9Sstevel@tonic-gate 	int fd;
12147c478bd9Sstevel@tonic-gate 	char *fcn = "daemon_update: ";
12157c478bd9Sstevel@tonic-gate 	char door_file[MAXPATHLEN];
12167c478bd9Sstevel@tonic-gate 	const char *subclass_list;
12177c478bd9Sstevel@tonic-gate 	sysevent_handle_t *sysevent_hp;
12187c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "%senter\n", fcn);
12197c478bd9Sstevel@tonic-gate 
12207c478bd9Sstevel@tonic-gate 	if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) {
12217c478bd9Sstevel@tonic-gate 		err_print("signal SIGUSR1 failed: %s\n", strerror(errno));
12227c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1223537714daSvikram 		/*NOTREACHED*/
12247c478bd9Sstevel@tonic-gate 	}
1225facf4a8dSllai 	if (signal(SIGTERM, catch_exit) == SIG_ERR) {
1226facf4a8dSllai 		err_print("signal SIGTERM failed: %s\n", strerror(errno));
1227facf4a8dSllai 		devfsadm_exit(1);
1228537714daSvikram 		/*NOTREACHED*/
1229facf4a8dSllai 	}
12307c478bd9Sstevel@tonic-gate 
12317c478bd9Sstevel@tonic-gate 	if (snprintf(door_file, sizeof (door_file),
1232facf4a8dSllai 	    "%s%s", attr_root ? attr_root : root_dir, DEVFSADM_SERVICE_DOOR)
1233facf4a8dSllai 	    >= sizeof (door_file)) {
12347c478bd9Sstevel@tonic-gate 		err_print("update_daemon failed to open sysevent service "
12357c478bd9Sstevel@tonic-gate 		    "door\n");
12367c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1237537714daSvikram 		/*NOTREACHED*/
12387c478bd9Sstevel@tonic-gate 	}
12397c478bd9Sstevel@tonic-gate 	if ((sysevent_hp = sysevent_open_channel_alt(
12407c478bd9Sstevel@tonic-gate 	    door_file)) == NULL) {
12417c478bd9Sstevel@tonic-gate 		err_print(CANT_CREATE_DOOR,
12420a653502Swroche 		    door_file, strerror(errno));
12437c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1244537714daSvikram 		/*NOTREACHED*/
12457c478bd9Sstevel@tonic-gate 	}
12467c478bd9Sstevel@tonic-gate 	if (sysevent_bind_subscriber(sysevent_hp, event_handler) != 0) {
12477c478bd9Sstevel@tonic-gate 		err_print(CANT_CREATE_DOOR,
12487c478bd9Sstevel@tonic-gate 		    door_file, strerror(errno));
12497c478bd9Sstevel@tonic-gate 		(void) sysevent_close_channel(sysevent_hp);
12507c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1251537714daSvikram 		/*NOTREACHED*/
12527c478bd9Sstevel@tonic-gate 	}
12537c478bd9Sstevel@tonic-gate 	subclass_list = EC_SUB_ALL;
12547c478bd9Sstevel@tonic-gate 	if (sysevent_register_event(sysevent_hp, EC_ALL, &subclass_list, 1)
12557c478bd9Sstevel@tonic-gate 	    != 0) {
12567c478bd9Sstevel@tonic-gate 		err_print(CANT_CREATE_DOOR,
12577c478bd9Sstevel@tonic-gate 		    door_file, strerror(errno));
12587c478bd9Sstevel@tonic-gate 		(void) sysevent_unbind_subscriber(sysevent_hp);
12597c478bd9Sstevel@tonic-gate 		(void) sysevent_close_channel(sysevent_hp);
12607c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1261537714daSvikram 		/*NOTREACHED*/
12627c478bd9Sstevel@tonic-gate 	}
1263facf4a8dSllai 	if (snprintf(door_file, sizeof (door_file), "%s/%s",
1264facf4a8dSllai 	    etc_dev_dir, DEVFSADM_SYNCH_DOOR) >= sizeof (door_file)) {
1265facf4a8dSllai 		err_print(CANT_CREATE_DOOR, DEVFSADM_SYNCH_DOOR,
12667c478bd9Sstevel@tonic-gate 		    strerror(ENAMETOOLONG));
12677c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1268537714daSvikram 		/*NOTREACHED*/
12697c478bd9Sstevel@tonic-gate 	}
1270facf4a8dSllai 
12717c478bd9Sstevel@tonic-gate 	(void) s_unlink(door_file);
1272facf4a8dSllai 	if ((fd = open(door_file, O_RDWR | O_CREAT, SYNCH_DOOR_PERMS)) == -1) {
1273facf4a8dSllai 		err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
12747c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1275537714daSvikram 		/*NOTREACHED*/
12767c478bd9Sstevel@tonic-gate 	}
12777c478bd9Sstevel@tonic-gate 	(void) close(fd);
1278facf4a8dSllai 
1279facf4a8dSllai 	if ((fd = door_create(sync_handler, NULL,
12807c478bd9Sstevel@tonic-gate 	    DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
1281facf4a8dSllai 		err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
12827c478bd9Sstevel@tonic-gate 		(void) s_unlink(door_file);
12837c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1284537714daSvikram 		/*NOTREACHED*/
12857c478bd9Sstevel@tonic-gate 	}
1286facf4a8dSllai 
12877c478bd9Sstevel@tonic-gate 	if (fattach(fd, door_file) == -1) {
1288facf4a8dSllai 		err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
12897c478bd9Sstevel@tonic-gate 		(void) s_unlink(door_file);
12907c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1291537714daSvikram 		/*NOTREACHED*/
12927c478bd9Sstevel@tonic-gate 	}
12937c478bd9Sstevel@tonic-gate 
1294facf4a8dSllai 	/*
1295facf4a8dSllai 	 * devname_lookup_door
1296facf4a8dSllai 	 */
1297facf4a8dSllai 	if (snprintf(door_file, sizeof (door_file), "%s/%s",
1298facf4a8dSllai 	    etc_dev_dir, DEVNAME_LOOKUP_DOOR) >= sizeof (door_file)) {
1299facf4a8dSllai 		err_print(CANT_CREATE_DOOR, DEVNAME_LOOKUP_DOOR,
1300facf4a8dSllai 		    strerror(ENAMETOOLONG));
1301facf4a8dSllai 		devfsadm_exit(1);
1302537714daSvikram 		/*NOTREACHED*/
1303facf4a8dSllai 	}
13047c478bd9Sstevel@tonic-gate 
13057c478bd9Sstevel@tonic-gate 	(void) s_unlink(door_file);
1306facf4a8dSllai 	if ((fd = open(door_file, O_RDWR | O_CREAT, S_IRUSR|S_IWUSR)) == -1) {
13077c478bd9Sstevel@tonic-gate 		err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
13087c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1309537714daSvikram 		/*NOTREACHED*/
13107c478bd9Sstevel@tonic-gate 	}
13117c478bd9Sstevel@tonic-gate 	(void) close(fd);
13127c478bd9Sstevel@tonic-gate 
1313facf4a8dSllai 	if ((fd = door_create(devname_lookup_handler, NULL,
1314facf4a8dSllai 	    DOOR_REFUSE_DESC)) == -1) {
13157c478bd9Sstevel@tonic-gate 		err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
13167c478bd9Sstevel@tonic-gate 		(void) s_unlink(door_file);
13177c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1318537714daSvikram 		/*NOTREACHED*/
13197c478bd9Sstevel@tonic-gate 	}
13207c478bd9Sstevel@tonic-gate 
1321facf4a8dSllai 	(void) fdetach(door_file);
1322facf4a8dSllai 	lookup_door_path = s_strdup(door_file);
1323facf4a8dSllai retry:
13247c478bd9Sstevel@tonic-gate 	if (fattach(fd, door_file) == -1) {
1325facf4a8dSllai 		if (errno == EBUSY)
1326facf4a8dSllai 			goto retry;
13277c478bd9Sstevel@tonic-gate 		err_print(CANT_CREATE_DOOR, door_file, strerror(errno));
13287c478bd9Sstevel@tonic-gate 		(void) s_unlink(door_file);
13297c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
1330537714daSvikram 		/*NOTREACHED*/
13317c478bd9Sstevel@tonic-gate 	}
1332facf4a8dSllai 	lookup_door_fd = fd;
13337c478bd9Sstevel@tonic-gate 
1334facf4a8dSllai 	/* pass down the door name to kernel for door_ki_open */
1335facf4a8dSllai 	if (devname_kcall(MODDEVNAME_LOOKUPDOOR, (void *)door_file) != 0)
1336facf4a8dSllai 		err_print(DEVNAME_CONTACT_FAILED, strerror(errno));
13377c478bd9Sstevel@tonic-gate 
13387c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "%spausing\n", fcn);
13397c478bd9Sstevel@tonic-gate 	for (;;) {
13407c478bd9Sstevel@tonic-gate 		(void) pause();
13417c478bd9Sstevel@tonic-gate 	}
13427c478bd9Sstevel@tonic-gate }
13437c478bd9Sstevel@tonic-gate 
13447c478bd9Sstevel@tonic-gate /*ARGSUSED*/
13457c478bd9Sstevel@tonic-gate static void
13467c478bd9Sstevel@tonic-gate sync_handler(void *cookie, char *ap, size_t asize,
13477c478bd9Sstevel@tonic-gate     door_desc_t *dp, uint_t ndesc)
13487c478bd9Sstevel@tonic-gate {
13497c478bd9Sstevel@tonic-gate 	door_cred_t	dcred;
13507c478bd9Sstevel@tonic-gate 	struct dca_off	*dcp, rdca;
13517c478bd9Sstevel@tonic-gate 	struct dca_impl dci;
13527c478bd9Sstevel@tonic-gate 
13537c478bd9Sstevel@tonic-gate 	/*
13547c478bd9Sstevel@tonic-gate 	 * Must be root to make this call
13557c478bd9Sstevel@tonic-gate 	 * If caller is not root, don't touch its data.
13567c478bd9Sstevel@tonic-gate 	 */
13577c478bd9Sstevel@tonic-gate 	if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) {
13587c478bd9Sstevel@tonic-gate 		dcp = &rdca;
13597c478bd9Sstevel@tonic-gate 		dcp->dca_error = EPERM;
13607c478bd9Sstevel@tonic-gate 		goto out;
13617c478bd9Sstevel@tonic-gate 	}
13627c478bd9Sstevel@tonic-gate 
13637c478bd9Sstevel@tonic-gate 	assert(ap);
13647c478bd9Sstevel@tonic-gate 	assert(asize == sizeof (*dcp));
13657c478bd9Sstevel@tonic-gate 
13667c478bd9Sstevel@tonic-gate 	dcp = (void *)ap;
13677c478bd9Sstevel@tonic-gate 
13687c478bd9Sstevel@tonic-gate 	/*
13697c478bd9Sstevel@tonic-gate 	 * Root is always present and is the first component of "name" member
13707c478bd9Sstevel@tonic-gate 	 */
13717c478bd9Sstevel@tonic-gate 	assert(dcp->dca_root == 0);
13727c478bd9Sstevel@tonic-gate 
13737c478bd9Sstevel@tonic-gate 	/*
13747c478bd9Sstevel@tonic-gate 	 * The structure passed in by the door_client uses offsets
13757c478bd9Sstevel@tonic-gate 	 * instead of pointers to work across address space boundaries.
13767c478bd9Sstevel@tonic-gate 	 * Now copy the data into a structure (dca_impl) which uses
13777c478bd9Sstevel@tonic-gate 	 * pointers.
13787c478bd9Sstevel@tonic-gate 	 */
13797c478bd9Sstevel@tonic-gate 	dci.dci_root = &dcp->dca_name[dcp->dca_root];
13807c478bd9Sstevel@tonic-gate 	dci.dci_minor = dcp->dca_minor ? &dcp->dca_name[dcp->dca_minor] : NULL;
13817c478bd9Sstevel@tonic-gate 	dci.dci_driver =
13827c478bd9Sstevel@tonic-gate 	    dcp->dca_driver ? &dcp->dca_name[dcp->dca_driver] : NULL;
13837c478bd9Sstevel@tonic-gate 	dci.dci_error = 0;
13847c478bd9Sstevel@tonic-gate 	dci.dci_flags = dcp->dca_flags | (dci.dci_driver ? DCA_LOAD_DRV : 0);
13857c478bd9Sstevel@tonic-gate 	dci.dci_arg = NULL;
13867c478bd9Sstevel@tonic-gate 
13877c478bd9Sstevel@tonic-gate 	lock_dev();
13887c478bd9Sstevel@tonic-gate 	devi_tree_walk(&dci, DINFOCPYALL, NULL);
13897c478bd9Sstevel@tonic-gate 	dcp->dca_error = dci.dci_error;
13907c478bd9Sstevel@tonic-gate 
1391ff2aee48Scth 	if (dcp->dca_flags & DCA_DEVLINK_SYNC)
1392ff2aee48Scth 		unlock_dev(SYNC_STATE);
1393ff2aee48Scth 	else
1394ff2aee48Scth 		unlock_dev(CACHE_STATE);
13957c478bd9Sstevel@tonic-gate 
1396ff2aee48Scth out:	(void) door_return((char *)dcp, sizeof (*dcp), NULL, 0);
13977c478bd9Sstevel@tonic-gate }
13987c478bd9Sstevel@tonic-gate 
13997c478bd9Sstevel@tonic-gate static void
14007c478bd9Sstevel@tonic-gate lock_dev(void)
14017c478bd9Sstevel@tonic-gate {
14027c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "lock_dev(): entered\n");
14037c478bd9Sstevel@tonic-gate 
14047c478bd9Sstevel@tonic-gate 	if (build_dev == FALSE)
14057c478bd9Sstevel@tonic-gate 		return;
14067c478bd9Sstevel@tonic-gate 
14077c478bd9Sstevel@tonic-gate 	/* lockout other threads from /dev */
14080a653502Swroche 	while (sema_wait(&dev_sema) != 0)
14090a653502Swroche 		;
14107c478bd9Sstevel@tonic-gate 
14117c478bd9Sstevel@tonic-gate 	/*
14127c478bd9Sstevel@tonic-gate 	 * Lock out other devfsadm processes from /dev.
14137c478bd9Sstevel@tonic-gate 	 * If this wasn't the last process to run,
14147c478bd9Sstevel@tonic-gate 	 * clear caches
14157c478bd9Sstevel@tonic-gate 	 */
14167c478bd9Sstevel@tonic-gate 	if (enter_dev_lock() != getpid()) {
14177c478bd9Sstevel@tonic-gate 		invalidate_enumerate_cache();
14187c478bd9Sstevel@tonic-gate 		rm_all_links_from_cache();
14197c478bd9Sstevel@tonic-gate 		(void) di_devlink_close(&devlink_cache, DI_LINK_ERROR);
1420f05faa4eSjacobs 
1421f05faa4eSjacobs 		/* send any sysevents that were queued up. */
1422f05faa4eSjacobs 		process_syseventq();
14237c478bd9Sstevel@tonic-gate 	}
14247c478bd9Sstevel@tonic-gate 
14257c478bd9Sstevel@tonic-gate 	/*
14267c478bd9Sstevel@tonic-gate 	 * (re)load the  reverse links database if not
14277c478bd9Sstevel@tonic-gate 	 * already cached.
14287c478bd9Sstevel@tonic-gate 	 */
14297c478bd9Sstevel@tonic-gate 	if (devlink_cache == NULL)
14307c478bd9Sstevel@tonic-gate 		devlink_cache = di_devlink_open(root_dir, 0);
14317c478bd9Sstevel@tonic-gate 
14327c478bd9Sstevel@tonic-gate 	/*
14337c478bd9Sstevel@tonic-gate 	 * If modules were unloaded, reload them.  Also use module status
14347c478bd9Sstevel@tonic-gate 	 * as an indication that we should check to see if other binding
14357c478bd9Sstevel@tonic-gate 	 * files need to be reloaded.
14367c478bd9Sstevel@tonic-gate 	 */
14377c478bd9Sstevel@tonic-gate 	if (module_head == NULL) {
14387c478bd9Sstevel@tonic-gate 		load_modules();
14397c478bd9Sstevel@tonic-gate 		read_minor_perm_file();
14407c478bd9Sstevel@tonic-gate 		read_driver_aliases_file();
14417c478bd9Sstevel@tonic-gate 		read_devlinktab_file();
14427c478bd9Sstevel@tonic-gate 		read_logindevperm_file();
14438d483882Smlf 		read_enumerate_file();
14447c478bd9Sstevel@tonic-gate 	}
14457c478bd9Sstevel@tonic-gate 
14467c478bd9Sstevel@tonic-gate 	if (module_head != NULL)
14477c478bd9Sstevel@tonic-gate 		return;
14487c478bd9Sstevel@tonic-gate 
14497c478bd9Sstevel@tonic-gate 	if (strcmp(prog, DEVLINKS) == 0) {
14507c478bd9Sstevel@tonic-gate 		if (devlinktab_list == NULL) {
14517c478bd9Sstevel@tonic-gate 			err_print(NO_LINKTAB, devlinktab_file);
14527c478bd9Sstevel@tonic-gate 			err_print(NO_MODULES, module_dirs);
14537c478bd9Sstevel@tonic-gate 			err_print(ABORTING);
14547c478bd9Sstevel@tonic-gate 			devfsadm_exit(1);
1455537714daSvikram 			/*NOTREACHED*/
14567c478bd9Sstevel@tonic-gate 		}
14577c478bd9Sstevel@tonic-gate 	} else {
14587c478bd9Sstevel@tonic-gate 		err_print(NO_MODULES, module_dirs);
14597c478bd9Sstevel@tonic-gate 		if (strcmp(prog, DEVFSADM) == 0) {
14607c478bd9Sstevel@tonic-gate 			err_print(MODIFY_PATH);
14617c478bd9Sstevel@tonic-gate 		}
14627c478bd9Sstevel@tonic-gate 	}
14637c478bd9Sstevel@tonic-gate }
14647c478bd9Sstevel@tonic-gate 
1465ff2aee48Scth /*
1466ff2aee48Scth  * Unlock the device.  If we are processing a CACHE_STATE call, we signal a
1467ff2aee48Scth  * minor_fini_thread delayed SYNC_STATE at the end of the call.  If we are
1468ff2aee48Scth  * processing a SYNC_STATE call, we cancel any minor_fini_thread SYNC_STATE
1469ff2aee48Scth  * at both the start and end of the call since we will be doing the SYNC_STATE.
1470ff2aee48Scth  */
14717c478bd9Sstevel@tonic-gate static void
14727c478bd9Sstevel@tonic-gate unlock_dev(int flag)
14737c478bd9Sstevel@tonic-gate {
1474ff2aee48Scth 	assert(flag == SYNC_STATE || flag == CACHE_STATE);
1475ff2aee48Scth 
14767c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "unlock_dev(): entered\n");
14777c478bd9Sstevel@tonic-gate 
1478ff2aee48Scth 	/* If we are starting a SYNC_STATE, cancel minor_fini_thread SYNC */
1479ff2aee48Scth 	if (flag == SYNC_STATE) {
1480ff2aee48Scth 		(void) mutex_lock(&minor_fini_mutex);
1481ff2aee48Scth 		minor_fini_canceled = TRUE;
1482ff2aee48Scth 		minor_fini_delayed = FALSE;
1483ff2aee48Scth 		(void) mutex_unlock(&minor_fini_mutex);
1484ff2aee48Scth 	}
1485ff2aee48Scth 
14867c478bd9Sstevel@tonic-gate 	if (build_dev == FALSE)
14877c478bd9Sstevel@tonic-gate 		return;
14887c478bd9Sstevel@tonic-gate 
1489568e756aSvikram 	if (devlink_cache == NULL) {
1490568e756aSvikram 		err_print(NO_DEVLINK_CACHE);
1491568e756aSvikram 	}
14927c478bd9Sstevel@tonic-gate 	assert(devlink_cache);
14937c478bd9Sstevel@tonic-gate 
14947c478bd9Sstevel@tonic-gate 	if (flag == SYNC_STATE) {
14957c478bd9Sstevel@tonic-gate 		unload_modules();
14967c478bd9Sstevel@tonic-gate 		if (update_database)
14977c478bd9Sstevel@tonic-gate 			(void) di_devlink_update(devlink_cache);
14987c478bd9Sstevel@tonic-gate 		(void) di_devlink_close(&devlink_cache, 0);
1499f05faa4eSjacobs 
1500f05faa4eSjacobs 		/*
1501f05faa4eSjacobs 		 * now that the devlinks db cache has been flushed, it is safe
1502f05faa4eSjacobs 		 * to send any sysevents that were queued up.
1503f05faa4eSjacobs 		 */
1504f05faa4eSjacobs 		process_syseventq();
15057c478bd9Sstevel@tonic-gate 	}
15067c478bd9Sstevel@tonic-gate 
1507537714daSvikram 	exit_dev_lock(0);
15087c478bd9Sstevel@tonic-gate 
1509ff2aee48Scth 	(void) mutex_lock(&minor_fini_mutex);
1510ff2aee48Scth 	if (flag == SYNC_STATE) {
1511ff2aee48Scth 		/* We did a SYNC_STATE, cancel minor_fini_thread SYNC */
1512ff2aee48Scth 		minor_fini_canceled = TRUE;
1513ff2aee48Scth 		minor_fini_delayed = FALSE;
1514ff2aee48Scth 	} else {
1515ff2aee48Scth 		/* We did a CACHE_STATE, start delayed minor_fini_thread SYNC */
1516ff2aee48Scth 		minor_fini_canceled = FALSE;
1517ff2aee48Scth 		minor_fini_delayed = TRUE;
1518ff2aee48Scth 		(void) cond_signal(&minor_fini_cv);
1519ff2aee48Scth 	}
1520ff2aee48Scth 	(void) mutex_unlock(&minor_fini_mutex);
1521ff2aee48Scth 
15227c478bd9Sstevel@tonic-gate 	(void) sema_post(&dev_sema);
15237c478bd9Sstevel@tonic-gate }
15247c478bd9Sstevel@tonic-gate 
15257c478bd9Sstevel@tonic-gate /*
15267c478bd9Sstevel@tonic-gate  * Check that if -r is set, it is not any part of a zone--- that is, that
15277c478bd9Sstevel@tonic-gate  * the zonepath is not a substring of the root path.
15287c478bd9Sstevel@tonic-gate  */
15297c478bd9Sstevel@tonic-gate static int
15307c478bd9Sstevel@tonic-gate zone_pathcheck(char *checkpath)
15317c478bd9Sstevel@tonic-gate {
15327c478bd9Sstevel@tonic-gate 	void		*dlhdl = NULL;
15337c478bd9Sstevel@tonic-gate 	char		*name;
15347c478bd9Sstevel@tonic-gate 	char		root[MAXPATHLEN]; /* resolved devfsadm root path */
15357c478bd9Sstevel@tonic-gate 	char		zroot[MAXPATHLEN]; /* zone root path */
15367c478bd9Sstevel@tonic-gate 	char		rzroot[MAXPATHLEN]; /* resolved zone root path */
1537facf4a8dSllai 	char		tmp[MAXPATHLEN];
15387c478bd9Sstevel@tonic-gate 	FILE		*cookie;
15397c478bd9Sstevel@tonic-gate 	int		err = DEVFSADM_SUCCESS;
15407c478bd9Sstevel@tonic-gate 
15417c478bd9Sstevel@tonic-gate 	if (checkpath[0] == '\0')
15427c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
15437c478bd9Sstevel@tonic-gate 
15447c478bd9Sstevel@tonic-gate 	/*
15457c478bd9Sstevel@tonic-gate 	 * Check if zones is available on this system.
15467c478bd9Sstevel@tonic-gate 	 */
15477c478bd9Sstevel@tonic-gate 	if ((dlhdl = dlopen(LIBZONECFG_PATH, RTLD_LAZY)) == NULL) {
15487c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
15497c478bd9Sstevel@tonic-gate 	}
15507c478bd9Sstevel@tonic-gate 
15517c478bd9Sstevel@tonic-gate 	bzero(root, sizeof (root));
15527c478bd9Sstevel@tonic-gate 	if (resolvepath(checkpath, root, sizeof (root) - 1) == -1) {
15537c478bd9Sstevel@tonic-gate 		/*
1554facf4a8dSllai 		 * In this case the user has done "devfsadm -r" on some path
15557c478bd9Sstevel@tonic-gate 		 * which does not yet exist, or we got some other misc. error.
15567c478bd9Sstevel@tonic-gate 		 * We punt and don't resolve the path in this case.
15577c478bd9Sstevel@tonic-gate 		 */
15587c478bd9Sstevel@tonic-gate 		(void) strlcpy(root, checkpath, sizeof (root));
15597c478bd9Sstevel@tonic-gate 	}
15607c478bd9Sstevel@tonic-gate 
15617c478bd9Sstevel@tonic-gate 	if (strlen(root) > 0 && (root[strlen(root) - 1] != '/')) {
15627c478bd9Sstevel@tonic-gate 		(void) snprintf(tmp, sizeof (tmp), "%s/", root);
15637c478bd9Sstevel@tonic-gate 		(void) strlcpy(root, tmp, sizeof (root));
15647c478bd9Sstevel@tonic-gate 	}
15657c478bd9Sstevel@tonic-gate 
15667c478bd9Sstevel@tonic-gate 	cookie = setzoneent();
15677c478bd9Sstevel@tonic-gate 	while ((name = getzoneent(cookie)) != NULL) {
15687c478bd9Sstevel@tonic-gate 		/* Skip the global zone */
15697c478bd9Sstevel@tonic-gate 		if (strcmp(name, GLOBAL_ZONENAME) == 0) {
15707c478bd9Sstevel@tonic-gate 			free(name);
15717c478bd9Sstevel@tonic-gate 			continue;
15727c478bd9Sstevel@tonic-gate 		}
15737c478bd9Sstevel@tonic-gate 
15747c478bd9Sstevel@tonic-gate 		if (zone_get_zonepath(name, zroot, sizeof (zroot)) != Z_OK) {
15757c478bd9Sstevel@tonic-gate 			free(name);
15767c478bd9Sstevel@tonic-gate 			continue;
15777c478bd9Sstevel@tonic-gate 		}
15787c478bd9Sstevel@tonic-gate 
15797c478bd9Sstevel@tonic-gate 		bzero(rzroot, sizeof (rzroot));
15807c478bd9Sstevel@tonic-gate 		if (resolvepath(zroot, rzroot, sizeof (rzroot) - 1) == -1) {
15817c478bd9Sstevel@tonic-gate 			/*
15827c478bd9Sstevel@tonic-gate 			 * Zone path doesn't exist, or other misc error,
15837c478bd9Sstevel@tonic-gate 			 * so we try using the non-resolved pathname.
15847c478bd9Sstevel@tonic-gate 			 */
15857c478bd9Sstevel@tonic-gate 			(void) strlcpy(rzroot, zroot, sizeof (rzroot));
15867c478bd9Sstevel@tonic-gate 		}
15877c478bd9Sstevel@tonic-gate 		if (strlen(rzroot) > 0 && (rzroot[strlen(rzroot) - 1] != '/')) {
15887c478bd9Sstevel@tonic-gate 			(void) snprintf(tmp, sizeof (tmp), "%s/", rzroot);
15897c478bd9Sstevel@tonic-gate 			(void) strlcpy(rzroot, tmp, sizeof (rzroot));
15907c478bd9Sstevel@tonic-gate 		}
15917c478bd9Sstevel@tonic-gate 
15927c478bd9Sstevel@tonic-gate 		/*
15937c478bd9Sstevel@tonic-gate 		 * Finally, the comparison.  If the zone root path is a
15947c478bd9Sstevel@tonic-gate 		 * leading substring of the root path, fail.
15957c478bd9Sstevel@tonic-gate 		 */
15967c478bd9Sstevel@tonic-gate 		if (strncmp(rzroot, root, strlen(rzroot)) == 0) {
15977c478bd9Sstevel@tonic-gate 			err_print(ZONE_PATHCHECK, root, name);
15987c478bd9Sstevel@tonic-gate 			err = DEVFSADM_FAILURE;
15997c478bd9Sstevel@tonic-gate 			free(name);
16007c478bd9Sstevel@tonic-gate 			break;
16017c478bd9Sstevel@tonic-gate 		}
16027c478bd9Sstevel@tonic-gate 		free(name);
16037c478bd9Sstevel@tonic-gate 	}
16047c478bd9Sstevel@tonic-gate 	endzoneent(cookie);
16057c478bd9Sstevel@tonic-gate 	(void) dlclose(dlhdl);
16067c478bd9Sstevel@tonic-gate 	return (err);
16077c478bd9Sstevel@tonic-gate }
16087c478bd9Sstevel@tonic-gate 
16097c478bd9Sstevel@tonic-gate /*
16107c478bd9Sstevel@tonic-gate  *  Called by the daemon when it receives an event from the devfsadm SLM
16117c478bd9Sstevel@tonic-gate  *  to syseventd.
16127c478bd9Sstevel@tonic-gate  *
16137c478bd9Sstevel@tonic-gate  *  The devfsadm SLM uses a private event channel for communication to
16147c478bd9Sstevel@tonic-gate  *  devfsadmd set-up via private libsysevent interfaces.  This handler is
16157c478bd9Sstevel@tonic-gate  *  used to bind to the devfsadmd channel for event delivery.
16167c478bd9Sstevel@tonic-gate  *  The devfsadmd SLM insures single calls to this routine as well as
16177c478bd9Sstevel@tonic-gate  *  synchronized event delivery.
16187c478bd9Sstevel@tonic-gate  *
16197c478bd9Sstevel@tonic-gate  */
16207c478bd9Sstevel@tonic-gate static void
16217c478bd9Sstevel@tonic-gate event_handler(sysevent_t *ev)
16227c478bd9Sstevel@tonic-gate {
16237c478bd9Sstevel@tonic-gate 	char *path;
16247c478bd9Sstevel@tonic-gate 	char *minor;
16257c478bd9Sstevel@tonic-gate 	char *subclass;
16267c478bd9Sstevel@tonic-gate 	char *dev_ev_subclass;
16277c478bd9Sstevel@tonic-gate 	char *driver_name;
16287c478bd9Sstevel@tonic-gate 	nvlist_t *attr_list = NULL;
16297c478bd9Sstevel@tonic-gate 	int err = 0;
16307c478bd9Sstevel@tonic-gate 	int instance;
16317c478bd9Sstevel@tonic-gate 	int branch_event = 0;
16327c478bd9Sstevel@tonic-gate 
16337e3e5701SJan Parcel 	/*
16347e3e5701SJan Parcel 	 * If this is event-driven, then we cannot trust the static devlist
16357e3e5701SJan Parcel 	 * to be correct.
16367e3e5701SJan Parcel 	 */
16377e3e5701SJan Parcel 
16387e3e5701SJan Parcel 	event_driven = TRUE;
16397c478bd9Sstevel@tonic-gate 	subclass = sysevent_get_subclass_name(ev);
16407c478bd9Sstevel@tonic-gate 	vprint(EVENT_MID, "event_handler: %s id:0X%llx\n",
16417c478bd9Sstevel@tonic-gate 	    subclass, sysevent_get_seq(ev));
16427c478bd9Sstevel@tonic-gate 
1643facf4a8dSllai 	if (strcmp(subclass, ESC_DEVFS_START) == 0) {
1644facf4a8dSllai 		return;
1645facf4a8dSllai 	}
1646facf4a8dSllai 
16477c478bd9Sstevel@tonic-gate 	/* Check if event is an instance modification */
16487c478bd9Sstevel@tonic-gate 	if (strcmp(subclass, ESC_DEVFS_INSTANCE_MOD) == 0) {
16497c478bd9Sstevel@tonic-gate 		devfs_instance_mod();
16507c478bd9Sstevel@tonic-gate 		return;
16517c478bd9Sstevel@tonic-gate 	}
16527c478bd9Sstevel@tonic-gate 	if (sysevent_get_attr_list(ev, &attr_list) != 0) {
16537c478bd9Sstevel@tonic-gate 		vprint(EVENT_MID, "event_handler: can not get attr list\n");
16547c478bd9Sstevel@tonic-gate 		return;
16557c478bd9Sstevel@tonic-gate 	}
16567c478bd9Sstevel@tonic-gate 
16577c478bd9Sstevel@tonic-gate 	if (strcmp(subclass, ESC_DEVFS_DEVI_ADD) == 0 ||
16587c478bd9Sstevel@tonic-gate 	    strcmp(subclass, ESC_DEVFS_DEVI_REMOVE) == 0 ||
16597c478bd9Sstevel@tonic-gate 	    strcmp(subclass, ESC_DEVFS_MINOR_CREATE) == 0 ||
16607c478bd9Sstevel@tonic-gate 	    strcmp(subclass, ESC_DEVFS_MINOR_REMOVE) == 0) {
16617c478bd9Sstevel@tonic-gate 		if ((err = nvlist_lookup_string(attr_list, DEVFS_PATHNAME,
16627c478bd9Sstevel@tonic-gate 		    &path)) != 0)
16637c478bd9Sstevel@tonic-gate 			goto out;
16647c478bd9Sstevel@tonic-gate 
166530294554Sphitran 		if (nvlist_lookup_string(attr_list, DEVFS_DEVI_CLASS,
166630294554Sphitran 		    &dev_ev_subclass) != 0)
166730294554Sphitran 			dev_ev_subclass = NULL;
16687c478bd9Sstevel@tonic-gate 
166930294554Sphitran 		if (nvlist_lookup_string(attr_list, DEVFS_DRIVER_NAME,
167030294554Sphitran 		    &driver_name) != 0)
167130294554Sphitran 			driver_name = NULL;
16727c478bd9Sstevel@tonic-gate 
167330294554Sphitran 		if (nvlist_lookup_int32(attr_list, DEVFS_INSTANCE,
167430294554Sphitran 		    &instance) != 0)
167530294554Sphitran 			instance = -1;
16767c478bd9Sstevel@tonic-gate 
167730294554Sphitran 		if (nvlist_lookup_int32(attr_list, DEVFS_BRANCH_EVENT,
167830294554Sphitran 		    &branch_event) != 0)
167930294554Sphitran 			branch_event = 0;
16807c478bd9Sstevel@tonic-gate 
168130294554Sphitran 		if (nvlist_lookup_string(attr_list, DEVFS_MINOR_NAME,
168230294554Sphitran 		    &minor) != 0)
168330294554Sphitran 			minor = NULL;
16847c478bd9Sstevel@tonic-gate 
16857c478bd9Sstevel@tonic-gate 		lock_dev();
16867c478bd9Sstevel@tonic-gate 
16877c478bd9Sstevel@tonic-gate 		if (strcmp(ESC_DEVFS_DEVI_ADD, subclass) == 0) {
16887c478bd9Sstevel@tonic-gate 			add_minor_pathname(path, NULL, dev_ev_subclass);
16897c478bd9Sstevel@tonic-gate 			if (branch_event) {
1690f05faa4eSjacobs 				build_and_enq_event(EC_DEV_BRANCH,
169130294554Sphitran 				    ESC_DEV_BRANCH_ADD, path, DI_NODE_NIL,
169230294554Sphitran 				    NULL);
16937c478bd9Sstevel@tonic-gate 			}
16947c478bd9Sstevel@tonic-gate 
16957c478bd9Sstevel@tonic-gate 		} else if (strcmp(ESC_DEVFS_MINOR_CREATE, subclass) == 0) {
169630294554Sphitran 			add_minor_pathname(path, minor, dev_ev_subclass);
16977c478bd9Sstevel@tonic-gate 
16987c478bd9Sstevel@tonic-gate 		} else if (strcmp(ESC_DEVFS_MINOR_REMOVE, subclass) == 0) {
169930294554Sphitran 			hot_cleanup(path, minor, dev_ev_subclass, driver_name,
170030294554Sphitran 			    instance);
17017c478bd9Sstevel@tonic-gate 
17027c478bd9Sstevel@tonic-gate 		} else { /* ESC_DEVFS_DEVI_REMOVE */
17037c478bd9Sstevel@tonic-gate 			hot_cleanup(path, NULL, dev_ev_subclass,
17047c478bd9Sstevel@tonic-gate 			    driver_name, instance);
17057c478bd9Sstevel@tonic-gate 			if (branch_event) {
1706f05faa4eSjacobs 				build_and_enq_event(EC_DEV_BRANCH,
170730294554Sphitran 				    ESC_DEV_BRANCH_REMOVE, path, DI_NODE_NIL,
170830294554Sphitran 				    NULL);
17097c478bd9Sstevel@tonic-gate 			}
17107c478bd9Sstevel@tonic-gate 		}
17117c478bd9Sstevel@tonic-gate 
17127c478bd9Sstevel@tonic-gate 		unlock_dev(CACHE_STATE);
17137c478bd9Sstevel@tonic-gate 
17147c478bd9Sstevel@tonic-gate 	} else if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0 ||
17157c478bd9Sstevel@tonic-gate 	    strcmp(subclass, ESC_DEVFS_BRANCH_REMOVE) == 0) {
17167c478bd9Sstevel@tonic-gate 		if ((err = nvlist_lookup_string(attr_list,
17177c478bd9Sstevel@tonic-gate 		    DEVFS_PATHNAME, &path)) != 0)
17187c478bd9Sstevel@tonic-gate 			goto out;
17197c478bd9Sstevel@tonic-gate 
17207c478bd9Sstevel@tonic-gate 		/* just log ESC_DEV_BRANCH... event */
17217c478bd9Sstevel@tonic-gate 		if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0)
17227c478bd9Sstevel@tonic-gate 			dev_ev_subclass = ESC_DEV_BRANCH_ADD;
17237c478bd9Sstevel@tonic-gate 		else
17247c478bd9Sstevel@tonic-gate 			dev_ev_subclass = ESC_DEV_BRANCH_REMOVE;
17257c478bd9Sstevel@tonic-gate 
1726d2596142Scth 		lock_dev();
1727f05faa4eSjacobs 		build_and_enq_event(EC_DEV_BRANCH, dev_ev_subclass, path,
172830294554Sphitran 		    DI_NODE_NIL, NULL);
1729d2596142Scth 		unlock_dev(CACHE_STATE);
17307c478bd9Sstevel@tonic-gate 	} else
17317c478bd9Sstevel@tonic-gate 		err_print(UNKNOWN_EVENT, subclass);
17327c478bd9Sstevel@tonic-gate 
17337c478bd9Sstevel@tonic-gate out:
17347c478bd9Sstevel@tonic-gate 	if (err)
17357c478bd9Sstevel@tonic-gate 		err_print(EVENT_ATTR_LOOKUP_FAILED, strerror(err));
17367c478bd9Sstevel@tonic-gate 	nvlist_free(attr_list);
17377c478bd9Sstevel@tonic-gate }
17387c478bd9Sstevel@tonic-gate 
17397c478bd9Sstevel@tonic-gate static void
17407c478bd9Sstevel@tonic-gate dca_impl_init(char *root, char *minor, struct dca_impl *dcip)
17417c478bd9Sstevel@tonic-gate {
17427c478bd9Sstevel@tonic-gate 	assert(root);
17437c478bd9Sstevel@tonic-gate 
17447c478bd9Sstevel@tonic-gate 	dcip->dci_root = root;
17457c478bd9Sstevel@tonic-gate 	dcip->dci_minor = minor;
17467c478bd9Sstevel@tonic-gate 	dcip->dci_driver = NULL;
17477c478bd9Sstevel@tonic-gate 	dcip->dci_error = 0;
17487c478bd9Sstevel@tonic-gate 	dcip->dci_flags = 0;
17497c478bd9Sstevel@tonic-gate 	dcip->dci_arg = NULL;
17507c478bd9Sstevel@tonic-gate }
17517c478bd9Sstevel@tonic-gate 
17527c478bd9Sstevel@tonic-gate /*
17537c478bd9Sstevel@tonic-gate  *  Kernel logs a message when a devinfo node is attached.  Try to create
17547c478bd9Sstevel@tonic-gate  *  /dev and /devices for each minor node.  minorname can be NULL.
17557c478bd9Sstevel@tonic-gate  */
17567c478bd9Sstevel@tonic-gate void
17577c478bd9Sstevel@tonic-gate add_minor_pathname(char *node, char *minor, char *ev_subclass)
17587c478bd9Sstevel@tonic-gate {
17597c478bd9Sstevel@tonic-gate 	struct dca_impl	dci;
17607c478bd9Sstevel@tonic-gate 
17617c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "add_minor_pathname: node_path=%s minor=%s\n",
17627c478bd9Sstevel@tonic-gate 	    node, minor ? minor : "NULL");
17637c478bd9Sstevel@tonic-gate 
17647c478bd9Sstevel@tonic-gate 	dca_impl_init(node, minor, &dci);
17657c478bd9Sstevel@tonic-gate 
17667c478bd9Sstevel@tonic-gate 	/*
17677c478bd9Sstevel@tonic-gate 	 * Restrict hotplug link creation if daemon
17687c478bd9Sstevel@tonic-gate 	 * started  with -i option.
17697c478bd9Sstevel@tonic-gate 	 */
17707c478bd9Sstevel@tonic-gate 	if (single_drv == TRUE) {
17717c478bd9Sstevel@tonic-gate 		dci.dci_driver = driver;
17727c478bd9Sstevel@tonic-gate 	}
17737c478bd9Sstevel@tonic-gate 
17747c478bd9Sstevel@tonic-gate 	/*
17750dc974a9SCathy Zhou 	 * We are being invoked in response to a hotplug event.
17767c478bd9Sstevel@tonic-gate 	 */
17777c478bd9Sstevel@tonic-gate 	dci.dci_flags = DCA_HOT_PLUG | DCA_CHECK_TYPE;
17787c478bd9Sstevel@tonic-gate 
17797c478bd9Sstevel@tonic-gate 	devi_tree_walk(&dci, DINFOPROP|DINFOMINOR, ev_subclass);
17807c478bd9Sstevel@tonic-gate }
17817c478bd9Sstevel@tonic-gate 
17827c478bd9Sstevel@tonic-gate static di_node_t
17837c478bd9Sstevel@tonic-gate find_clone_node()
17847c478bd9Sstevel@tonic-gate {
17857c478bd9Sstevel@tonic-gate 	static di_node_t clone_node = DI_NODE_NIL;
17867c478bd9Sstevel@tonic-gate 
17877c478bd9Sstevel@tonic-gate 	if (clone_node == DI_NODE_NIL)
17887c478bd9Sstevel@tonic-gate 		clone_node = di_init("/pseudo/clone@0", DINFOPROP);
17897c478bd9Sstevel@tonic-gate 	return (clone_node);
17907c478bd9Sstevel@tonic-gate }
17917c478bd9Sstevel@tonic-gate 
17927c478bd9Sstevel@tonic-gate static int
17937c478bd9Sstevel@tonic-gate is_descendent_of(di_node_t node, char *driver)
17947c478bd9Sstevel@tonic-gate {
17957c478bd9Sstevel@tonic-gate 	while (node != DI_NODE_NIL) {
17967c478bd9Sstevel@tonic-gate 		char *drv = di_driver_name(node);
17977c478bd9Sstevel@tonic-gate 		if (strcmp(drv, driver) == 0)
17987c478bd9Sstevel@tonic-gate 			return (1);
17997c478bd9Sstevel@tonic-gate 		node = di_parent_node(node);
18007c478bd9Sstevel@tonic-gate 	}
18017c478bd9Sstevel@tonic-gate 	return (0);
18027c478bd9Sstevel@tonic-gate }
18037c478bd9Sstevel@tonic-gate 
18047c478bd9Sstevel@tonic-gate /*
18057c478bd9Sstevel@tonic-gate  * Checks the minor type.  If it is an alias node, then lookup
18067c478bd9Sstevel@tonic-gate  * the real node/minor first, then call minor_process() to
18077c478bd9Sstevel@tonic-gate  * do the real work.
18087c478bd9Sstevel@tonic-gate  */
18097c478bd9Sstevel@tonic-gate static int
18107c478bd9Sstevel@tonic-gate check_minor_type(di_node_t node, di_minor_t minor, void *arg)
18117c478bd9Sstevel@tonic-gate {
18127c478bd9Sstevel@tonic-gate 	ddi_minor_type	minor_type;
18137c478bd9Sstevel@tonic-gate 	di_node_t	clone_node;
18147c478bd9Sstevel@tonic-gate 	char		*mn;
18157c478bd9Sstevel@tonic-gate 	char		*nt;
18167c478bd9Sstevel@tonic-gate 	struct mlist	*dep;
18177c478bd9Sstevel@tonic-gate 	struct dca_impl	*dcip = arg;
18187c478bd9Sstevel@tonic-gate 
18197c478bd9Sstevel@tonic-gate 	assert(dcip);
18207c478bd9Sstevel@tonic-gate 
18217c478bd9Sstevel@tonic-gate 	dep = dcip->dci_arg;
18227c478bd9Sstevel@tonic-gate 
18237c478bd9Sstevel@tonic-gate 	mn = di_minor_name(minor);
18247c478bd9Sstevel@tonic-gate 
18257c478bd9Sstevel@tonic-gate 	/*
18267c478bd9Sstevel@tonic-gate 	 * We match driver here instead of in minor_process
18277c478bd9Sstevel@tonic-gate 	 * as we want the actual driver name. This check is
18287c478bd9Sstevel@tonic-gate 	 * unnecessary during deferred processing.
18297c478bd9Sstevel@tonic-gate 	 */
18307c478bd9Sstevel@tonic-gate 	if (dep &&
18317c478bd9Sstevel@tonic-gate 	    ((dcip->dci_driver && !is_descendent_of(node, dcip->dci_driver)) ||
18327c478bd9Sstevel@tonic-gate 	    (dcip->dci_minor && strcmp(mn, dcip->dci_minor)))) {
18337c478bd9Sstevel@tonic-gate 		return (DI_WALK_CONTINUE);
18347c478bd9Sstevel@tonic-gate 	}
18357c478bd9Sstevel@tonic-gate 
18367c478bd9Sstevel@tonic-gate 	if ((dcip->dci_flags & DCA_CHECK_TYPE) &&
18377c478bd9Sstevel@tonic-gate 	    (nt = di_minor_nodetype(minor)) &&
1838210db224Sericheng 	    (strcmp(nt, DDI_NT_NET) == 0)) {
18397c478bd9Sstevel@tonic-gate 		dcip->dci_flags &= ~DCA_CHECK_TYPE;
18407c478bd9Sstevel@tonic-gate 	}
18417c478bd9Sstevel@tonic-gate 
18427c478bd9Sstevel@tonic-gate 	minor_type = di_minor_type(minor);
18437c478bd9Sstevel@tonic-gate 
18447c478bd9Sstevel@tonic-gate 	if (minor_type == DDM_MINOR) {
18457c478bd9Sstevel@tonic-gate 		minor_process(node, minor, dep);
18467c478bd9Sstevel@tonic-gate 
18477c478bd9Sstevel@tonic-gate 	} else if (minor_type == DDM_ALIAS) {
18487c478bd9Sstevel@tonic-gate 		struct mlist *cdep, clone_del = {0};
18497c478bd9Sstevel@tonic-gate 
18507c478bd9Sstevel@tonic-gate 		clone_node = find_clone_node();
18517c478bd9Sstevel@tonic-gate 		if (clone_node == DI_NODE_NIL) {
18527c478bd9Sstevel@tonic-gate 			err_print(DI_INIT_FAILED, "clone", strerror(errno));
18537c478bd9Sstevel@tonic-gate 			return (DI_WALK_CONTINUE);
18547c478bd9Sstevel@tonic-gate 		}
18557c478bd9Sstevel@tonic-gate 
18567c478bd9Sstevel@tonic-gate 		cdep = dep ? &clone_del : NULL;
18577c478bd9Sstevel@tonic-gate 
18587c478bd9Sstevel@tonic-gate 		minor_process(clone_node, minor, cdep);
18597c478bd9Sstevel@tonic-gate 
18607c478bd9Sstevel@tonic-gate 		/*
18617c478bd9Sstevel@tonic-gate 		 * cache "alias" minor node and free "clone" minor
18627c478bd9Sstevel@tonic-gate 		 */
18637c478bd9Sstevel@tonic-gate 		if (cdep != NULL && cdep->head != NULL) {
18647c478bd9Sstevel@tonic-gate 			assert(cdep->tail != NULL);
18657c478bd9Sstevel@tonic-gate 			cache_deferred_minor(dep, node, minor);
18667c478bd9Sstevel@tonic-gate 			dcip->dci_arg = cdep;
18677c478bd9Sstevel@tonic-gate 			process_deferred_links(dcip, DCA_FREE_LIST);
18687c478bd9Sstevel@tonic-gate 			dcip->dci_arg = dep;
18697c478bd9Sstevel@tonic-gate 		}
18707c478bd9Sstevel@tonic-gate 	}
18717c478bd9Sstevel@tonic-gate 
18727c478bd9Sstevel@tonic-gate 	return (DI_WALK_CONTINUE);
18737c478bd9Sstevel@tonic-gate }
18747c478bd9Sstevel@tonic-gate 
18757c478bd9Sstevel@tonic-gate 
18767c478bd9Sstevel@tonic-gate /*
18777c478bd9Sstevel@tonic-gate  *  This is the entry point for each minor node, whether walking
18787c478bd9Sstevel@tonic-gate  *  the entire tree via di_walk_minor() or processing a hotplug event
18797c478bd9Sstevel@tonic-gate  *  for a single devinfo node (via hotplug ndi_devi_online()).
18807c478bd9Sstevel@tonic-gate  */
18817c478bd9Sstevel@tonic-gate /*ARGSUSED*/
18827c478bd9Sstevel@tonic-gate static void
18837c478bd9Sstevel@tonic-gate minor_process(di_node_t node, di_minor_t minor, struct mlist *dep)
18847c478bd9Sstevel@tonic-gate {
18857c478bd9Sstevel@tonic-gate 	create_list_t	*create;
18867c478bd9Sstevel@tonic-gate 	int		defer;
18877c478bd9Sstevel@tonic-gate 
18887c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "minor_process: node=%s, minor=%s\n",
18890a653502Swroche 	    di_node_name(node), di_minor_name(minor));
18907c478bd9Sstevel@tonic-gate 
18917c478bd9Sstevel@tonic-gate 	if (dep != NULL) {
18927c478bd9Sstevel@tonic-gate 
18937c478bd9Sstevel@tonic-gate 		/*
18947c478bd9Sstevel@tonic-gate 		 * Reset /devices node to minor_perm perm/ownership
18957c478bd9Sstevel@tonic-gate 		 * if we are here to deactivate device allocation
18967c478bd9Sstevel@tonic-gate 		 */
18977c478bd9Sstevel@tonic-gate 		if (build_devices == TRUE) {
18987c478bd9Sstevel@tonic-gate 			reset_node_permissions(node, minor);
18997c478bd9Sstevel@tonic-gate 		}
19007c478bd9Sstevel@tonic-gate 
19017c478bd9Sstevel@tonic-gate 		if (build_dev == FALSE) {
19027c478bd9Sstevel@tonic-gate 			return;
19037c478bd9Sstevel@tonic-gate 		}
19047c478bd9Sstevel@tonic-gate 
19057c478bd9Sstevel@tonic-gate 		/*
19067c478bd9Sstevel@tonic-gate 		 * This function will create any nodes for /etc/devlink.tab.
19077c478bd9Sstevel@tonic-gate 		 * If devlink.tab handles link creation, we don't call any
19087c478bd9Sstevel@tonic-gate 		 * devfsadm modules since that could cause duplicate caching
19097c478bd9Sstevel@tonic-gate 		 * in the enumerate functions if different re strings are
19107c478bd9Sstevel@tonic-gate 		 * passed that are logically identical.  I'm still not
19117c478bd9Sstevel@tonic-gate 		 * convinced this would cause any harm, but better to be safe.
19127c478bd9Sstevel@tonic-gate 		 *
19137c478bd9Sstevel@tonic-gate 		 * Deferred processing is available only for devlinks
19147c478bd9Sstevel@tonic-gate 		 * created through devfsadm modules.
19157c478bd9Sstevel@tonic-gate 		 */
19167c478bd9Sstevel@tonic-gate 		if (process_devlink_compat(minor, node) == TRUE) {
19177c478bd9Sstevel@tonic-gate 			return;
19187c478bd9Sstevel@tonic-gate 		}
19197c478bd9Sstevel@tonic-gate 	} else {
19207c478bd9Sstevel@tonic-gate 		vprint(CHATTY_MID, "minor_process: deferred processing\n");
19217c478bd9Sstevel@tonic-gate 	}
19227c478bd9Sstevel@tonic-gate 
19237c478bd9Sstevel@tonic-gate 	/*
19247c478bd9Sstevel@tonic-gate 	 * look for relevant link create rules in the modules, and
19257c478bd9Sstevel@tonic-gate 	 * invoke the link create callback function to build a link
19267c478bd9Sstevel@tonic-gate 	 * if there is a match.
19277c478bd9Sstevel@tonic-gate 	 */
19287c478bd9Sstevel@tonic-gate 	defer = 0;
19297c478bd9Sstevel@tonic-gate 	for (create = create_head; create != NULL; create = create->next) {
19307c478bd9Sstevel@tonic-gate 		if ((minor_matches_rule(node, minor, create) == TRUE) &&
19317c478bd9Sstevel@tonic-gate 		    class_ok(create->create->device_class) ==
19327c478bd9Sstevel@tonic-gate 		    DEVFSADM_SUCCESS) {
19337c478bd9Sstevel@tonic-gate 			if (call_minor_init(create->modptr) ==
19347c478bd9Sstevel@tonic-gate 			    DEVFSADM_FAILURE) {
19357c478bd9Sstevel@tonic-gate 				continue;
19367c478bd9Sstevel@tonic-gate 			}
19377c478bd9Sstevel@tonic-gate 
19387c478bd9Sstevel@tonic-gate 			/*
19397c478bd9Sstevel@tonic-gate 			 * If NOT doing the deferred creates (i.e. 1st pass) and
19407c478bd9Sstevel@tonic-gate 			 * rule requests deferred processing cache the minor
19417c478bd9Sstevel@tonic-gate 			 * data.
19427c478bd9Sstevel@tonic-gate 			 *
19437c478bd9Sstevel@tonic-gate 			 * If deferred processing (2nd pass), create links
19447c478bd9Sstevel@tonic-gate 			 * ONLY if rule requests deferred processing.
19457c478bd9Sstevel@tonic-gate 			 */
19467c478bd9Sstevel@tonic-gate 			if (dep && ((create->create->flags & CREATE_MASK) ==
19477c478bd9Sstevel@tonic-gate 			    CREATE_DEFER)) {
19487c478bd9Sstevel@tonic-gate 				defer = 1;
19497c478bd9Sstevel@tonic-gate 				continue;
19507c478bd9Sstevel@tonic-gate 			} else if (dep == NULL &&
19517c478bd9Sstevel@tonic-gate 			    ((create->create->flags & CREATE_MASK) !=
19527c478bd9Sstevel@tonic-gate 			    CREATE_DEFER)) {
19537c478bd9Sstevel@tonic-gate 				continue;
19547c478bd9Sstevel@tonic-gate 			}
19557c478bd9Sstevel@tonic-gate 
19567c478bd9Sstevel@tonic-gate 			if ((*(create->create->callback_fcn))
19577c478bd9Sstevel@tonic-gate 			    (minor, node) == DEVFSADM_TERMINATE) {
19587c478bd9Sstevel@tonic-gate 				break;
19597c478bd9Sstevel@tonic-gate 			}
19607c478bd9Sstevel@tonic-gate 		}
19617c478bd9Sstevel@tonic-gate 	}
19627c478bd9Sstevel@tonic-gate 
19637c478bd9Sstevel@tonic-gate 	if (defer)
19647c478bd9Sstevel@tonic-gate 		cache_deferred_minor(dep, node, minor);
19657c478bd9Sstevel@tonic-gate }
19667c478bd9Sstevel@tonic-gate 
19677c478bd9Sstevel@tonic-gate 
19687c478bd9Sstevel@tonic-gate /*
19697c478bd9Sstevel@tonic-gate  * Cache node and minor in defer list.
19707c478bd9Sstevel@tonic-gate  */
19717c478bd9Sstevel@tonic-gate static void
19727c478bd9Sstevel@tonic-gate cache_deferred_minor(
19737c478bd9Sstevel@tonic-gate 	struct mlist *dep,
19747c478bd9Sstevel@tonic-gate 	di_node_t node,
19757c478bd9Sstevel@tonic-gate 	di_minor_t minor)
19767c478bd9Sstevel@tonic-gate {
19777c478bd9Sstevel@tonic-gate 	struct minor	*mp;
19787c478bd9Sstevel@tonic-gate 	const char	*fcn = "cache_deferred_minor";
19797c478bd9Sstevel@tonic-gate 
19807c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "%s node=%s, minor=%s\n", fcn,
19817c478bd9Sstevel@tonic-gate 	    di_node_name(node), di_minor_name(minor));
19827c478bd9Sstevel@tonic-gate 
19837c478bd9Sstevel@tonic-gate 	if (dep == NULL) {
19847c478bd9Sstevel@tonic-gate 		vprint(CHATTY_MID, "%s: cannot cache during "
19857c478bd9Sstevel@tonic-gate 		    "deferred processing. Ignoring minor\n", fcn);
19867c478bd9Sstevel@tonic-gate 		return;
19877c478bd9Sstevel@tonic-gate 	}
19887c478bd9Sstevel@tonic-gate 
19897c478bd9Sstevel@tonic-gate 	mp = (struct minor *)s_zalloc(sizeof (struct minor));
19907c478bd9Sstevel@tonic-gate 	mp->node = node;
19917c478bd9Sstevel@tonic-gate 	mp->minor = minor;
19927c478bd9Sstevel@tonic-gate 	mp->next = NULL;
19937c478bd9Sstevel@tonic-gate 
19947c478bd9Sstevel@tonic-gate 	assert(dep->head == NULL || dep->tail != NULL);
19957c478bd9Sstevel@tonic-gate 	if (dep->head == NULL) {
19967c478bd9Sstevel@tonic-gate 		dep->head = mp;
19977c478bd9Sstevel@tonic-gate 	} else {
19987c478bd9Sstevel@tonic-gate 		dep->tail->next = mp;
19997c478bd9Sstevel@tonic-gate 	}
20007c478bd9Sstevel@tonic-gate 	dep->tail = mp;
20017c478bd9Sstevel@tonic-gate }
20027c478bd9Sstevel@tonic-gate 
20037c478bd9Sstevel@tonic-gate /*
20047c478bd9Sstevel@tonic-gate  *  Check to see if "create" link creation rule matches this node/minor.
20057c478bd9Sstevel@tonic-gate  *  If it does, return TRUE.
20067c478bd9Sstevel@tonic-gate  */
20077c478bd9Sstevel@tonic-gate static int
20087c478bd9Sstevel@tonic-gate minor_matches_rule(di_node_t node, di_minor_t minor, create_list_t *create)
20097c478bd9Sstevel@tonic-gate {
20107c478bd9Sstevel@tonic-gate 	char *m_nodetype, *m_drvname;
20117c478bd9Sstevel@tonic-gate 
20127c478bd9Sstevel@tonic-gate 	if (create->create->node_type != NULL) {
20137c478bd9Sstevel@tonic-gate 
20147c478bd9Sstevel@tonic-gate 		m_nodetype = di_minor_nodetype(minor);
20157c478bd9Sstevel@tonic-gate 		assert(m_nodetype != NULL);
20167c478bd9Sstevel@tonic-gate 
20177c478bd9Sstevel@tonic-gate 		switch (create->create->flags & TYPE_MASK) {
20187c478bd9Sstevel@tonic-gate 		case TYPE_EXACT:
20197c478bd9Sstevel@tonic-gate 			if (strcmp(create->create->node_type, m_nodetype) !=
20207c478bd9Sstevel@tonic-gate 			    0) {
20217c478bd9Sstevel@tonic-gate 				return (FALSE);
20227c478bd9Sstevel@tonic-gate 			}
20237c478bd9Sstevel@tonic-gate 			break;
20247c478bd9Sstevel@tonic-gate 		case TYPE_PARTIAL:
20257c478bd9Sstevel@tonic-gate 			if (strncmp(create->create->node_type, m_nodetype,
20267c478bd9Sstevel@tonic-gate 			    strlen(create->create->node_type)) != 0) {
20277c478bd9Sstevel@tonic-gate 				return (FALSE);
20287c478bd9Sstevel@tonic-gate 			}
20297c478bd9Sstevel@tonic-gate 			break;
20307c478bd9Sstevel@tonic-gate 		case TYPE_RE:
20317c478bd9Sstevel@tonic-gate 			if (regexec(&(create->node_type_comp), m_nodetype,
20327c478bd9Sstevel@tonic-gate 			    0, NULL, 0) != 0) {
20337c478bd9Sstevel@tonic-gate 				return (FALSE);
20347c478bd9Sstevel@tonic-gate 			}
20357c478bd9Sstevel@tonic-gate 			break;
20367c478bd9Sstevel@tonic-gate 		}
20377c478bd9Sstevel@tonic-gate 	}
20387c478bd9Sstevel@tonic-gate 
20397c478bd9Sstevel@tonic-gate 	if (create->create->drv_name != NULL) {
20407c478bd9Sstevel@tonic-gate 		m_drvname = di_driver_name(node);
20417c478bd9Sstevel@tonic-gate 		switch (create->create->flags & DRV_MASK) {
20427c478bd9Sstevel@tonic-gate 		case DRV_EXACT:
20437c478bd9Sstevel@tonic-gate 			if (strcmp(create->create->drv_name, m_drvname) != 0) {
20447c478bd9Sstevel@tonic-gate 				return (FALSE);
20457c478bd9Sstevel@tonic-gate 			}
20467c478bd9Sstevel@tonic-gate 			break;
20477c478bd9Sstevel@tonic-gate 		case DRV_RE:
20487c478bd9Sstevel@tonic-gate 			if (regexec(&(create->drv_name_comp), m_drvname,
20497c478bd9Sstevel@tonic-gate 			    0, NULL, 0) != 0) {
20507c478bd9Sstevel@tonic-gate 				return (FALSE);
20517c478bd9Sstevel@tonic-gate 			}
20527c478bd9Sstevel@tonic-gate 			break;
20537c478bd9Sstevel@tonic-gate 		}
20547c478bd9Sstevel@tonic-gate 	}
20557c478bd9Sstevel@tonic-gate 
20567c478bd9Sstevel@tonic-gate 	return (TRUE);
20577c478bd9Sstevel@tonic-gate }
20587c478bd9Sstevel@tonic-gate 
20597c478bd9Sstevel@tonic-gate /*
20607c478bd9Sstevel@tonic-gate  * If no classes were given on the command line, then return DEVFSADM_SUCCESS.
20617c478bd9Sstevel@tonic-gate  * Otherwise, return DEVFSADM_SUCCESS if the device "class" from the module
20627c478bd9Sstevel@tonic-gate  * matches one of the device classes given on the command line,
20637c478bd9Sstevel@tonic-gate  * otherwise, return DEVFSADM_FAILURE.
20647c478bd9Sstevel@tonic-gate  */
20657c478bd9Sstevel@tonic-gate static int
20667c478bd9Sstevel@tonic-gate class_ok(char *class)
20677c478bd9Sstevel@tonic-gate {
20687c478bd9Sstevel@tonic-gate 	int i;
20697c478bd9Sstevel@tonic-gate 
20707c478bd9Sstevel@tonic-gate 	if (num_classes == 0) {
20717c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
20727c478bd9Sstevel@tonic-gate 	}
20737c478bd9Sstevel@tonic-gate 
20747c478bd9Sstevel@tonic-gate 	for (i = 0; i < num_classes; i++) {
20757c478bd9Sstevel@tonic-gate 		if (strcmp(class, classes[i]) == 0) {
20767c478bd9Sstevel@tonic-gate 			return (DEVFSADM_SUCCESS);
20777c478bd9Sstevel@tonic-gate 		}
20787c478bd9Sstevel@tonic-gate 	}
20797c478bd9Sstevel@tonic-gate 	return (DEVFSADM_FAILURE);
20807c478bd9Sstevel@tonic-gate }
20817c478bd9Sstevel@tonic-gate 
20827c478bd9Sstevel@tonic-gate /*
20837c478bd9Sstevel@tonic-gate  * call minor_fini on active modules, then unload ALL modules
20847c478bd9Sstevel@tonic-gate  */
20857c478bd9Sstevel@tonic-gate static void
20867c478bd9Sstevel@tonic-gate unload_modules(void)
20877c478bd9Sstevel@tonic-gate {
20887c478bd9Sstevel@tonic-gate 	module_t *module_free;
20897c478bd9Sstevel@tonic-gate 	create_list_t *create_free;
20907c478bd9Sstevel@tonic-gate 	remove_list_t *remove_free;
20917c478bd9Sstevel@tonic-gate 
20927c478bd9Sstevel@tonic-gate 	while (create_head != NULL) {
20937c478bd9Sstevel@tonic-gate 		create_free = create_head;
20947c478bd9Sstevel@tonic-gate 		create_head = create_head->next;
20957c478bd9Sstevel@tonic-gate 
20967c478bd9Sstevel@tonic-gate 		if ((create_free->create->flags & TYPE_RE) == TYPE_RE) {
20977c478bd9Sstevel@tonic-gate 			regfree(&(create_free->node_type_comp));
20987c478bd9Sstevel@tonic-gate 		}
20997c478bd9Sstevel@tonic-gate 		if ((create_free->create->flags & DRV_RE) == DRV_RE) {
21007c478bd9Sstevel@tonic-gate 			regfree(&(create_free->drv_name_comp));
21017c478bd9Sstevel@tonic-gate 		}
21027c478bd9Sstevel@tonic-gate 		free(create_free);
21037c478bd9Sstevel@tonic-gate 	}
21047c478bd9Sstevel@tonic-gate 
21057c478bd9Sstevel@tonic-gate 	while (remove_head != NULL) {
21067c478bd9Sstevel@tonic-gate 		remove_free = remove_head;
21077c478bd9Sstevel@tonic-gate 		remove_head = remove_head->next;
21087c478bd9Sstevel@tonic-gate 		free(remove_free);
21097c478bd9Sstevel@tonic-gate 	}
21107c478bd9Sstevel@tonic-gate 
21117c478bd9Sstevel@tonic-gate 	while (module_head != NULL) {
21127c478bd9Sstevel@tonic-gate 
21137c478bd9Sstevel@tonic-gate 		if ((module_head->minor_fini != NULL) &&
21147c478bd9Sstevel@tonic-gate 		    ((module_head->flags & MODULE_ACTIVE) == MODULE_ACTIVE)) {
21157c478bd9Sstevel@tonic-gate 			(void) (*(module_head->minor_fini))();
21167c478bd9Sstevel@tonic-gate 		}
21177c478bd9Sstevel@tonic-gate 
21187c478bd9Sstevel@tonic-gate 		vprint(MODLOAD_MID, "unloading module %s\n", module_head->name);
21197c478bd9Sstevel@tonic-gate 		free(module_head->name);
21207c478bd9Sstevel@tonic-gate 		(void) dlclose(module_head->dlhandle);
21217c478bd9Sstevel@tonic-gate 
21227c478bd9Sstevel@tonic-gate 		module_free = module_head;
21237c478bd9Sstevel@tonic-gate 		module_head = module_head->next;
21247c478bd9Sstevel@tonic-gate 		free(module_free);
21257c478bd9Sstevel@tonic-gate 	}
21267c478bd9Sstevel@tonic-gate }
21277c478bd9Sstevel@tonic-gate 
21287c478bd9Sstevel@tonic-gate /*
21297c478bd9Sstevel@tonic-gate  * Load devfsadm logical link processing modules.
21307c478bd9Sstevel@tonic-gate  */
21317c478bd9Sstevel@tonic-gate static void
21327c478bd9Sstevel@tonic-gate load_modules(void)
21337c478bd9Sstevel@tonic-gate {
21347c478bd9Sstevel@tonic-gate 	DIR *mod_dir;
21354bc0a2efScasper 	struct dirent *entp;
21367c478bd9Sstevel@tonic-gate 	char cdir[PATH_MAX + 1];
21377c478bd9Sstevel@tonic-gate 	char *last;
21387c478bd9Sstevel@tonic-gate 	char *mdir = module_dirs;
21397c478bd9Sstevel@tonic-gate 	char *fcn = "load_modules: ";
21407c478bd9Sstevel@tonic-gate 
21417c478bd9Sstevel@tonic-gate 	while (*mdir != '\0') {
21427c478bd9Sstevel@tonic-gate 
21437c478bd9Sstevel@tonic-gate 		while (*mdir == ':') {
21447c478bd9Sstevel@tonic-gate 			mdir++;
21457c478bd9Sstevel@tonic-gate 		}
21467c478bd9Sstevel@tonic-gate 
21477c478bd9Sstevel@tonic-gate 		if (*mdir == '\0') {
21487c478bd9Sstevel@tonic-gate 			continue;
21497c478bd9Sstevel@tonic-gate 		}
21507c478bd9Sstevel@tonic-gate 
21517c478bd9Sstevel@tonic-gate 		last = strchr(mdir, ':');
21527c478bd9Sstevel@tonic-gate 
21537c478bd9Sstevel@tonic-gate 		if (last == NULL) {
21547c478bd9Sstevel@tonic-gate 			last = mdir + strlen(mdir);
21557c478bd9Sstevel@tonic-gate 		}
21567c478bd9Sstevel@tonic-gate 
21577c478bd9Sstevel@tonic-gate 		(void) strncpy(cdir, mdir, last - mdir);
21587c478bd9Sstevel@tonic-gate 		cdir[last - mdir] = '\0';
21597c478bd9Sstevel@tonic-gate 		mdir += strlen(cdir);
21607c478bd9Sstevel@tonic-gate 
21617c478bd9Sstevel@tonic-gate 		if ((mod_dir = opendir(cdir)) == NULL) {
21627c478bd9Sstevel@tonic-gate 			vprint(MODLOAD_MID, "%sopendir(%s): %s\n",
21630a653502Swroche 			    fcn, cdir, strerror(errno));
21647c478bd9Sstevel@tonic-gate 			continue;
21657c478bd9Sstevel@tonic-gate 		}
21667c478bd9Sstevel@tonic-gate 
21674bc0a2efScasper 		while ((entp = readdir(mod_dir)) != NULL) {
21687c478bd9Sstevel@tonic-gate 
21697c478bd9Sstevel@tonic-gate 			if ((strcmp(entp->d_name, ".") == 0) ||
21707c478bd9Sstevel@tonic-gate 			    (strcmp(entp->d_name, "..") == 0)) {
21717c478bd9Sstevel@tonic-gate 				continue;
21727c478bd9Sstevel@tonic-gate 			}
21737c478bd9Sstevel@tonic-gate 
21747c478bd9Sstevel@tonic-gate 			load_module(entp->d_name, cdir);
21757c478bd9Sstevel@tonic-gate 		}
21767c478bd9Sstevel@tonic-gate 		s_closedir(mod_dir);
21777c478bd9Sstevel@tonic-gate 	}
21787c478bd9Sstevel@tonic-gate }
21797c478bd9Sstevel@tonic-gate 
21807c478bd9Sstevel@tonic-gate static void
21817c478bd9Sstevel@tonic-gate load_module(char *mname, char *cdir)
21827c478bd9Sstevel@tonic-gate {
21837c478bd9Sstevel@tonic-gate 	_devfsadm_create_reg_t *create_reg;
2184aa646b9dSvikram 	_devfsadm_remove_reg_V1_t *remove_reg;
21857c478bd9Sstevel@tonic-gate 	create_list_t *create_list_element;
21867c478bd9Sstevel@tonic-gate 	create_list_t **create_list_next;
21877c478bd9Sstevel@tonic-gate 	remove_list_t *remove_list_element;
21887c478bd9Sstevel@tonic-gate 	remove_list_t **remove_list_next;
21897c478bd9Sstevel@tonic-gate 	char epath[PATH_MAX + 1], *end;
21907c478bd9Sstevel@tonic-gate 	char *fcn = "load_module: ";
21917c478bd9Sstevel@tonic-gate 	char *dlerrstr;
21927c478bd9Sstevel@tonic-gate 	void *dlhandle;
21937c478bd9Sstevel@tonic-gate 	module_t *module;
2194aa646b9dSvikram 	int flags;
21957c478bd9Sstevel@tonic-gate 	int n;
21967c478bd9Sstevel@tonic-gate 	int i;
21977c478bd9Sstevel@tonic-gate 
21987c478bd9Sstevel@tonic-gate 	/* ignore any file which does not end in '.so' */
21997c478bd9Sstevel@tonic-gate 	if ((end = strstr(mname, MODULE_SUFFIX)) != NULL) {
22007c478bd9Sstevel@tonic-gate 		if (end[strlen(MODULE_SUFFIX)] != '\0') {
22017c478bd9Sstevel@tonic-gate 			return;
22027c478bd9Sstevel@tonic-gate 		}
22037c478bd9Sstevel@tonic-gate 	} else {
22047c478bd9Sstevel@tonic-gate 		return;
22057c478bd9Sstevel@tonic-gate 	}
22067c478bd9Sstevel@tonic-gate 
22077c478bd9Sstevel@tonic-gate 	(void) snprintf(epath, sizeof (epath), "%s/%s", cdir, mname);
22087c478bd9Sstevel@tonic-gate 
22097c478bd9Sstevel@tonic-gate 	if ((dlhandle = dlopen(epath, RTLD_LAZY)) == NULL) {
22107c478bd9Sstevel@tonic-gate 		dlerrstr = dlerror();
22117c478bd9Sstevel@tonic-gate 		err_print(DLOPEN_FAILED, epath,
22120a653502Swroche 		    dlerrstr ? dlerrstr : "unknown error");
22137c478bd9Sstevel@tonic-gate 		return;
22147c478bd9Sstevel@tonic-gate 	}
22157c478bd9Sstevel@tonic-gate 
22167c478bd9Sstevel@tonic-gate 	/* dlsym the _devfsadm_create_reg structure */
22177c478bd9Sstevel@tonic-gate 	if (NULL == (create_reg = (_devfsadm_create_reg_t *)
22180a653502Swroche 	    dlsym(dlhandle, _DEVFSADM_CREATE_REG))) {
22197c478bd9Sstevel@tonic-gate 		vprint(MODLOAD_MID, "dlsym(%s, %s): symbol not found\n", epath,
22200a653502Swroche 		    _DEVFSADM_CREATE_REG);
22217c478bd9Sstevel@tonic-gate 	} else {
22227c478bd9Sstevel@tonic-gate 		vprint(MODLOAD_MID, "%sdlsym(%s, %s) succeeded\n",
22230a653502Swroche 		    fcn, epath, _DEVFSADM_CREATE_REG);
22247c478bd9Sstevel@tonic-gate 	}
22257c478bd9Sstevel@tonic-gate 
22267c478bd9Sstevel@tonic-gate 	/* dlsym the _devfsadm_remove_reg structure */
2227aa646b9dSvikram 	if (NULL == (remove_reg = (_devfsadm_remove_reg_V1_t *)
22287c478bd9Sstevel@tonic-gate 	    dlsym(dlhandle, _DEVFSADM_REMOVE_REG))) {
22297c478bd9Sstevel@tonic-gate 		vprint(MODLOAD_MID, "dlsym(%s,\n\t%s): symbol not found\n",
22300a653502Swroche 		    epath, _DEVFSADM_REMOVE_REG);
22317c478bd9Sstevel@tonic-gate 	} else {
22327c478bd9Sstevel@tonic-gate 		vprint(MODLOAD_MID, "dlsym(%s, %s): succeeded\n",
22330a653502Swroche 		    epath, _DEVFSADM_REMOVE_REG);
22347c478bd9Sstevel@tonic-gate 	}
22357c478bd9Sstevel@tonic-gate 
22367c478bd9Sstevel@tonic-gate 	vprint(MODLOAD_MID, "module %s loaded\n", epath);
22377c478bd9Sstevel@tonic-gate 
22387c478bd9Sstevel@tonic-gate 	module = (module_t *)s_malloc(sizeof (module_t));
22397c478bd9Sstevel@tonic-gate 	module->name = s_strdup(epath);
22407c478bd9Sstevel@tonic-gate 	module->dlhandle = dlhandle;
22417c478bd9Sstevel@tonic-gate 
22427c478bd9Sstevel@tonic-gate 	/* dlsym other module functions, to be called later */
22437c478bd9Sstevel@tonic-gate 	module->minor_fini = (int (*)())dlsym(dlhandle, MINOR_FINI);
22447c478bd9Sstevel@tonic-gate 	module->minor_init = (int (*)())dlsym(dlhandle, MINOR_INIT);
22457c478bd9Sstevel@tonic-gate 	module->flags = 0;
22467c478bd9Sstevel@tonic-gate 
22477c478bd9Sstevel@tonic-gate 	/*
22487c478bd9Sstevel@tonic-gate 	 *  put a ptr to each struct devfsadm_create on "create_head"
22497c478bd9Sstevel@tonic-gate 	 *  list sorted in interpose_lvl.
22507c478bd9Sstevel@tonic-gate 	 */
22517c478bd9Sstevel@tonic-gate 	if (create_reg != NULL) {
22527c478bd9Sstevel@tonic-gate 		for (i = 0; i < create_reg->count; i++) {
22537c478bd9Sstevel@tonic-gate 			int flags = create_reg->tblp[i].flags;
22547c478bd9Sstevel@tonic-gate 
22557c478bd9Sstevel@tonic-gate 			create_list_element = (create_list_t *)
22560a653502Swroche 			    s_malloc(sizeof (create_list_t));
22577c478bd9Sstevel@tonic-gate 
22587c478bd9Sstevel@tonic-gate 			create_list_element->create = &(create_reg->tblp[i]);
22597c478bd9Sstevel@tonic-gate 			create_list_element->modptr = module;
22607c478bd9Sstevel@tonic-gate 
22617c478bd9Sstevel@tonic-gate 			if (((flags & CREATE_MASK) != 0) &&
22627c478bd9Sstevel@tonic-gate 			    ((flags & CREATE_MASK) != CREATE_DEFER)) {
22637c478bd9Sstevel@tonic-gate 				free(create_list_element);
22647c478bd9Sstevel@tonic-gate 				err_print("illegal flag combination in "
22650a653502Swroche 				    "module create\n");
22667c478bd9Sstevel@tonic-gate 				err_print(IGNORING_ENTRY, i, epath);
22677c478bd9Sstevel@tonic-gate 				continue;
22687c478bd9Sstevel@tonic-gate 			}
22697c478bd9Sstevel@tonic-gate 
22707c478bd9Sstevel@tonic-gate 			if (((flags & TYPE_MASK) == 0) ^
22717c478bd9Sstevel@tonic-gate 			    (create_reg->tblp[i].node_type == NULL)) {
22727c478bd9Sstevel@tonic-gate 				free(create_list_element);
22737c478bd9Sstevel@tonic-gate 				err_print("flags value incompatible with "
22740a653502Swroche 				    "node_type value in module create\n");
22757c478bd9Sstevel@tonic-gate 				err_print(IGNORING_ENTRY, i, epath);
22767c478bd9Sstevel@tonic-gate 				continue;
22777c478bd9Sstevel@tonic-gate 			}
22787c478bd9Sstevel@tonic-gate 
22797c478bd9Sstevel@tonic-gate 			if (((flags & TYPE_MASK) != 0) &&
22807c478bd9Sstevel@tonic-gate 			    ((flags & TYPE_MASK) != TYPE_EXACT) &&
22817c478bd9Sstevel@tonic-gate 			    ((flags & TYPE_MASK) != TYPE_RE) &&
22827c478bd9Sstevel@tonic-gate 			    ((flags & TYPE_MASK) != TYPE_PARTIAL)) {
22837c478bd9Sstevel@tonic-gate 				free(create_list_element);
22847c478bd9Sstevel@tonic-gate 				err_print("illegal TYPE_* flag combination in "
22850a653502Swroche 				    "module create\n");
22867c478bd9Sstevel@tonic-gate 				err_print(IGNORING_ENTRY, i, epath);
22877c478bd9Sstevel@tonic-gate 				continue;
22887c478bd9Sstevel@tonic-gate 			}
22897c478bd9Sstevel@tonic-gate 
22907c478bd9Sstevel@tonic-gate 			/* precompile regular expression for efficiency */
22917c478bd9Sstevel@tonic-gate 			if ((flags & TYPE_RE) == TYPE_RE) {
22927c478bd9Sstevel@tonic-gate 				if ((n = regcomp(&(create_list_element->
22937c478bd9Sstevel@tonic-gate 				    node_type_comp),
22947c478bd9Sstevel@tonic-gate 				    create_reg->tblp[i].node_type,
22957c478bd9Sstevel@tonic-gate 				    REG_EXTENDED)) != 0) {
22967c478bd9Sstevel@tonic-gate 					free(create_list_element);
22977c478bd9Sstevel@tonic-gate 					err_print(REGCOMP_FAILED,
22980a653502Swroche 					    create_reg->tblp[i].node_type, n);
22997c478bd9Sstevel@tonic-gate 					err_print(IGNORING_ENTRY, i, epath);
23007c478bd9Sstevel@tonic-gate 					continue;
23017c478bd9Sstevel@tonic-gate 				}
23027c478bd9Sstevel@tonic-gate 			}
23037c478bd9Sstevel@tonic-gate 
23047c478bd9Sstevel@tonic-gate 			if (((flags & DRV_MASK) == 0) ^
23057c478bd9Sstevel@tonic-gate 			    (create_reg->tblp[i].drv_name == NULL)) {
23067c478bd9Sstevel@tonic-gate 				if ((flags & TYPE_RE) == TYPE_RE) {
23077c478bd9Sstevel@tonic-gate 					regfree(&(create_list_element->
23087c478bd9Sstevel@tonic-gate 					    node_type_comp));
23097c478bd9Sstevel@tonic-gate 				}
23107c478bd9Sstevel@tonic-gate 				free(create_list_element);
23117c478bd9Sstevel@tonic-gate 				err_print("flags value incompatible with "
23120a653502Swroche 				    "drv_name value in module create\n");
23137c478bd9Sstevel@tonic-gate 				err_print(IGNORING_ENTRY, i, epath);
23147c478bd9Sstevel@tonic-gate 				continue;
23157c478bd9Sstevel@tonic-gate 			}
23167c478bd9Sstevel@tonic-gate 
23177c478bd9Sstevel@tonic-gate 			if (((flags & DRV_MASK) != 0) &&
23187c478bd9Sstevel@tonic-gate 			    ((flags & DRV_MASK) != DRV_EXACT) &&
23197c478bd9Sstevel@tonic-gate 			    ((flags & DRV_MASK) !=  DRV_RE)) {
23207c478bd9Sstevel@tonic-gate 				if ((flags & TYPE_RE) == TYPE_RE) {
23217c478bd9Sstevel@tonic-gate 					regfree(&(create_list_element->
23227c478bd9Sstevel@tonic-gate 					    node_type_comp));
23237c478bd9Sstevel@tonic-gate 				}
23247c478bd9Sstevel@tonic-gate 				free(create_list_element);
23257c478bd9Sstevel@tonic-gate 				err_print("illegal DRV_* flag combination in "
23260a653502Swroche 				    "module create\n");
23277c478bd9Sstevel@tonic-gate 				err_print(IGNORING_ENTRY, i, epath);
23287c478bd9Sstevel@tonic-gate 				continue;
23297c478bd9Sstevel@tonic-gate 			}
23307c478bd9Sstevel@tonic-gate 
23317c478bd9Sstevel@tonic-gate 			/* precompile regular expression for efficiency */
23327c478bd9Sstevel@tonic-gate 			if ((create_reg->tblp[i].flags & DRV_RE) == DRV_RE) {
23337c478bd9Sstevel@tonic-gate 				if ((n = regcomp(&(create_list_element->
23347c478bd9Sstevel@tonic-gate 				    drv_name_comp),
23357c478bd9Sstevel@tonic-gate 				    create_reg->tblp[i].drv_name,
23367c478bd9Sstevel@tonic-gate 				    REG_EXTENDED)) != 0) {
23377c478bd9Sstevel@tonic-gate 					if ((flags & TYPE_RE) == TYPE_RE) {
23387c478bd9Sstevel@tonic-gate 						regfree(&(create_list_element->
23397c478bd9Sstevel@tonic-gate 						    node_type_comp));
23407c478bd9Sstevel@tonic-gate 					}
23417c478bd9Sstevel@tonic-gate 					free(create_list_element);
23427c478bd9Sstevel@tonic-gate 					err_print(REGCOMP_FAILED,
23430a653502Swroche 					    create_reg->tblp[i].drv_name, n);
23447c478bd9Sstevel@tonic-gate 					err_print(IGNORING_ENTRY, i, epath);
23457c478bd9Sstevel@tonic-gate 					continue;
23467c478bd9Sstevel@tonic-gate 				}
23477c478bd9Sstevel@tonic-gate 			}
23487c478bd9Sstevel@tonic-gate 
23497c478bd9Sstevel@tonic-gate 
23507c478bd9Sstevel@tonic-gate 			/* add to list sorted by interpose level */
23517c478bd9Sstevel@tonic-gate 			for (create_list_next = &(create_head);
23520a653502Swroche 			    (*create_list_next != NULL) &&
23530a653502Swroche 			    (*create_list_next)->create->interpose_lvl >=
23540a653502Swroche 			    create_list_element->create->interpose_lvl;
23550a653502Swroche 			    create_list_next = &((*create_list_next)->next))
23560a653502Swroche 				;
23577c478bd9Sstevel@tonic-gate 			create_list_element->next = *create_list_next;
23587c478bd9Sstevel@tonic-gate 			*create_list_next = create_list_element;
23597c478bd9Sstevel@tonic-gate 		}
23607c478bd9Sstevel@tonic-gate 	}
23617c478bd9Sstevel@tonic-gate 
23627c478bd9Sstevel@tonic-gate 	/*
23637c478bd9Sstevel@tonic-gate 	 *  put a ptr to each struct devfsadm_remove on "remove_head"
23647c478bd9Sstevel@tonic-gate 	 *  list sorted by interpose_lvl.
23657c478bd9Sstevel@tonic-gate 	 */
2366aa646b9dSvikram 	flags = 0;
23677c478bd9Sstevel@tonic-gate 	if (remove_reg != NULL) {
2368aa646b9dSvikram 		if (remove_reg->version < DEVFSADM_V1)
2369aa646b9dSvikram 			flags |= RM_NOINTERPOSE;
23707c478bd9Sstevel@tonic-gate 		for (i = 0; i < remove_reg->count; i++) {
23717c478bd9Sstevel@tonic-gate 
23727c478bd9Sstevel@tonic-gate 			remove_list_element = (remove_list_t *)
23730a653502Swroche 			    s_malloc(sizeof (remove_list_t));
23747c478bd9Sstevel@tonic-gate 
23757c478bd9Sstevel@tonic-gate 			remove_list_element->remove = &(remove_reg->tblp[i]);
2376aa646b9dSvikram 			remove_list_element->remove->flags |= flags;
23777c478bd9Sstevel@tonic-gate 			remove_list_element->modptr = module;
23787c478bd9Sstevel@tonic-gate 
23797c478bd9Sstevel@tonic-gate 			for (remove_list_next = &(remove_head);
23800a653502Swroche 			    (*remove_list_next != NULL) &&
23810a653502Swroche 			    (*remove_list_next)->remove->interpose_lvl >=
23820a653502Swroche 			    remove_list_element->remove->interpose_lvl;
23830a653502Swroche 			    remove_list_next = &((*remove_list_next)->next))
23840a653502Swroche 				;
23857c478bd9Sstevel@tonic-gate 			remove_list_element->next = *remove_list_next;
23867c478bd9Sstevel@tonic-gate 			*remove_list_next = remove_list_element;
23877c478bd9Sstevel@tonic-gate 		}
23887c478bd9Sstevel@tonic-gate 	}
23897c478bd9Sstevel@tonic-gate 
23907c478bd9Sstevel@tonic-gate 	module->next = module_head;
23917c478bd9Sstevel@tonic-gate 	module_head = module;
23927c478bd9Sstevel@tonic-gate }
23937c478bd9Sstevel@tonic-gate 
23947c478bd9Sstevel@tonic-gate /*
2395ff2aee48Scth  * After we have completed a CACHE_STATE, if a SYNC_STATE does not occur
2396ff2aee48Scth  * within 'timeout' secs the minor_fini_thread needs to do a SYNC_STATE
2397ff2aee48Scth  * so that we still call the minor_fini routines.
23987c478bd9Sstevel@tonic-gate  */
23997c478bd9Sstevel@tonic-gate /*ARGSUSED*/
24007c478bd9Sstevel@tonic-gate static void
2401ff2aee48Scth minor_fini_thread(void *arg)
24027c478bd9Sstevel@tonic-gate {
2403ff2aee48Scth 	timestruc_t	abstime;
24047c478bd9Sstevel@tonic-gate 
2405ff2aee48Scth 	vprint(INITFINI_MID, "minor_fini_thread starting\n");
24067c478bd9Sstevel@tonic-gate 
2407ff2aee48Scth 	(void) mutex_lock(&minor_fini_mutex);
2408ff2aee48Scth 	for (;;) {
2409ff2aee48Scth 		/* wait the gather period, or until signaled */
2410ff2aee48Scth 		abstime.tv_sec = time(NULL) + minor_fini_timeout;
2411ff2aee48Scth 		abstime.tv_nsec = 0;
2412ff2aee48Scth 		(void) cond_timedwait(&minor_fini_cv,
2413ff2aee48Scth 		    &minor_fini_mutex, &abstime);
2414ff2aee48Scth 
2415ff2aee48Scth 		/* if minor_fini was canceled, go wait again */
2416ff2aee48Scth 		if (minor_fini_canceled == TRUE)
2417ff2aee48Scth 			continue;
24187c478bd9Sstevel@tonic-gate 
2419ff2aee48Scth 		/* if minor_fini was delayed, go wait again */
2420ff2aee48Scth 		if (minor_fini_delayed == TRUE) {
2421ff2aee48Scth 			minor_fini_delayed = FALSE;
2422ff2aee48Scth 			continue;
2423ff2aee48Scth 		}
24247c478bd9Sstevel@tonic-gate 
2425ff2aee48Scth 		/* done with cancellations and delays, do the SYNC_STATE */
24267c478bd9Sstevel@tonic-gate 		(void) mutex_unlock(&minor_fini_mutex);
24277c478bd9Sstevel@tonic-gate 
2428ff2aee48Scth 		lock_dev();
2429ff2aee48Scth 		unlock_dev(SYNC_STATE);
2430ff2aee48Scth 		vprint(INITFINI_MID, "minor_fini sync done\n");
24317c478bd9Sstevel@tonic-gate 
2432ff2aee48Scth 		(void) mutex_lock(&minor_fini_mutex);
2433ff2aee48Scth 	}
24347c478bd9Sstevel@tonic-gate }
24357c478bd9Sstevel@tonic-gate 
2436ff2aee48Scth 
24377c478bd9Sstevel@tonic-gate /*
24387c478bd9Sstevel@tonic-gate  * Attempt to initialize module, if a minor_init routine exists.  Set
24397c478bd9Sstevel@tonic-gate  * the active flag if the routine exists and succeeds.	If it doesn't
24407c478bd9Sstevel@tonic-gate  * exist, just set the active flag.
24417c478bd9Sstevel@tonic-gate  */
24427c478bd9Sstevel@tonic-gate static int
24437c478bd9Sstevel@tonic-gate call_minor_init(module_t *module)
24447c478bd9Sstevel@tonic-gate {
24457c478bd9Sstevel@tonic-gate 	char *fcn = "call_minor_init: ";
24467c478bd9Sstevel@tonic-gate 
24477c478bd9Sstevel@tonic-gate 	if ((module->flags & MODULE_ACTIVE) == MODULE_ACTIVE) {
24487c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
24497c478bd9Sstevel@tonic-gate 	}
24507c478bd9Sstevel@tonic-gate 
24517c478bd9Sstevel@tonic-gate 	vprint(INITFINI_MID, "%smodule %s.  current state: inactive\n",
24520a653502Swroche 	    fcn, module->name);
24537c478bd9Sstevel@tonic-gate 
24547c478bd9Sstevel@tonic-gate 	if (module->minor_init == NULL) {
24557c478bd9Sstevel@tonic-gate 		module->flags |= MODULE_ACTIVE;
24567c478bd9Sstevel@tonic-gate 		vprint(INITFINI_MID, "minor_init not defined\n");
24577c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
24587c478bd9Sstevel@tonic-gate 	}
24597c478bd9Sstevel@tonic-gate 
24607c478bd9Sstevel@tonic-gate 	if ((*(module->minor_init))() == DEVFSADM_FAILURE) {
24617c478bd9Sstevel@tonic-gate 		err_print(FAILED_FOR_MODULE, MINOR_INIT, module->name);
24627c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
24637c478bd9Sstevel@tonic-gate 	}
24647c478bd9Sstevel@tonic-gate 
24657c478bd9Sstevel@tonic-gate 	vprint(INITFINI_MID, "minor_init() returns DEVFSADM_SUCCESS. "
24660a653502Swroche 	    "new state: active\n");
24677c478bd9Sstevel@tonic-gate 
24687c478bd9Sstevel@tonic-gate 	module->flags |= MODULE_ACTIVE;
24697c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
24707c478bd9Sstevel@tonic-gate }
24717c478bd9Sstevel@tonic-gate 
24727c478bd9Sstevel@tonic-gate /*
24737c478bd9Sstevel@tonic-gate  * Creates a symlink 'link' to the physical path of node:minor.
24747c478bd9Sstevel@tonic-gate  * Construct link contents, then call create_link_common().
24757c478bd9Sstevel@tonic-gate  */
24767c478bd9Sstevel@tonic-gate /*ARGSUSED*/
24777c478bd9Sstevel@tonic-gate int
2478facf4a8dSllai devfsadm_mklink(char *link, di_node_t node, di_minor_t minor, int flags)
24797c478bd9Sstevel@tonic-gate {
24807c478bd9Sstevel@tonic-gate 	char rcontents[PATH_MAX];
24817c478bd9Sstevel@tonic-gate 	char devlink[PATH_MAX];
24827c478bd9Sstevel@tonic-gate 	char phy_path[PATH_MAX];
24837c478bd9Sstevel@tonic-gate 	char *acontents;
24847c478bd9Sstevel@tonic-gate 	char *dev_path;
24857c478bd9Sstevel@tonic-gate 	int numslashes;
24867c478bd9Sstevel@tonic-gate 	int rv;
24877c478bd9Sstevel@tonic-gate 	int i, link_exists;
24887c478bd9Sstevel@tonic-gate 	int last_was_slash = FALSE;
24897c478bd9Sstevel@tonic-gate 
24907c478bd9Sstevel@tonic-gate 	/*
24917c478bd9Sstevel@tonic-gate 	 * try to use devices path
24927c478bd9Sstevel@tonic-gate 	 */
24937c478bd9Sstevel@tonic-gate 	if ((node == lnode) && (minor == lminor)) {
24947c478bd9Sstevel@tonic-gate 		acontents = lphy_path;
24957c478bd9Sstevel@tonic-gate 	} else if (di_minor_type(minor) == DDM_ALIAS) {
24967c478bd9Sstevel@tonic-gate 		/* use /pseudo/clone@0:<driver> as the phys path */
24977c478bd9Sstevel@tonic-gate 		(void) snprintf(phy_path, sizeof (phy_path),
24987c478bd9Sstevel@tonic-gate 		    "/pseudo/clone@0:%s",
24997c478bd9Sstevel@tonic-gate 		    di_driver_name(di_minor_devinfo(minor)));
25007c478bd9Sstevel@tonic-gate 		acontents = phy_path;
25017c478bd9Sstevel@tonic-gate 	} else {
25027c478bd9Sstevel@tonic-gate 		if ((dev_path = di_devfs_path(node)) == NULL) {
25037c478bd9Sstevel@tonic-gate 			err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
25047c478bd9Sstevel@tonic-gate 			devfsadm_exit(1);
2505537714daSvikram 			/*NOTREACHED*/
25067c478bd9Sstevel@tonic-gate 		}
25077c478bd9Sstevel@tonic-gate 		(void) snprintf(phy_path, sizeof (phy_path), "%s:%s",
25087c478bd9Sstevel@tonic-gate 		    dev_path, di_minor_name(minor));
25097c478bd9Sstevel@tonic-gate 		di_devfs_path_free(dev_path);
25107c478bd9Sstevel@tonic-gate 		acontents = phy_path;
25117c478bd9Sstevel@tonic-gate 	}
25127c478bd9Sstevel@tonic-gate 
25137c478bd9Sstevel@tonic-gate 	/* prepend link with dev_dir contents */
25147c478bd9Sstevel@tonic-gate 	(void) strlcpy(devlink, dev_dir, sizeof (devlink));
25157c478bd9Sstevel@tonic-gate 	(void) strlcat(devlink, "/", sizeof (devlink));
25167c478bd9Sstevel@tonic-gate 	(void) strlcat(devlink, link, sizeof (devlink));
25177c478bd9Sstevel@tonic-gate 
25187c478bd9Sstevel@tonic-gate 	/*
25197c478bd9Sstevel@tonic-gate 	 * Calculate # of ../ to add.  Account for double '//' in path.
25207c478bd9Sstevel@tonic-gate 	 * Ignore all leading slashes.
25217c478bd9Sstevel@tonic-gate 	 */
25227c478bd9Sstevel@tonic-gate 	for (i = 0; link[i] == '/'; i++)
25237c478bd9Sstevel@tonic-gate 		;
25247c478bd9Sstevel@tonic-gate 	for (numslashes = 0; link[i] != '\0'; i++) {
25257c478bd9Sstevel@tonic-gate 		if (link[i] == '/') {
25267c478bd9Sstevel@tonic-gate 			if (last_was_slash == FALSE) {
25277c478bd9Sstevel@tonic-gate 				numslashes++;
25287c478bd9Sstevel@tonic-gate 				last_was_slash = TRUE;
25297c478bd9Sstevel@tonic-gate 			}
25307c478bd9Sstevel@tonic-gate 		} else {
25317c478bd9Sstevel@tonic-gate 			last_was_slash = FALSE;
25327c478bd9Sstevel@tonic-gate 		}
25337c478bd9Sstevel@tonic-gate 	}
25347c478bd9Sstevel@tonic-gate 	/* Don't count any trailing '/' */
25357c478bd9Sstevel@tonic-gate 	if (link[i-1] == '/') {
25367c478bd9Sstevel@tonic-gate 		numslashes--;
25377c478bd9Sstevel@tonic-gate 	}
25387c478bd9Sstevel@tonic-gate 
25397c478bd9Sstevel@tonic-gate 	rcontents[0] = '\0';
25407c478bd9Sstevel@tonic-gate 	do {
25417c478bd9Sstevel@tonic-gate 		(void) strlcat(rcontents, "../", sizeof (rcontents));
25427c478bd9Sstevel@tonic-gate 	} while (numslashes-- != 0);
25437c478bd9Sstevel@tonic-gate 
25447c478bd9Sstevel@tonic-gate 	(void) strlcat(rcontents, "devices", sizeof (rcontents));
25457c478bd9Sstevel@tonic-gate 	(void) strlcat(rcontents, acontents, sizeof (rcontents));
25467c478bd9Sstevel@tonic-gate 
25477c478bd9Sstevel@tonic-gate 	if (devlinks_debug == TRUE) {
25487c478bd9Sstevel@tonic-gate 		vprint(INFO_MID, "adding link %s ==> %s\n", devlink, rcontents);
25497c478bd9Sstevel@tonic-gate 	}
25507c478bd9Sstevel@tonic-gate 
25517c478bd9Sstevel@tonic-gate 	if ((rv = create_link_common(devlink, rcontents, &link_exists))
25527c478bd9Sstevel@tonic-gate 	    == DEVFSADM_SUCCESS) {
25537c478bd9Sstevel@tonic-gate 		linknew = TRUE;
25547c478bd9Sstevel@tonic-gate 		add_link_to_cache(link, acontents);
25557c478bd9Sstevel@tonic-gate 	} else {
25567c478bd9Sstevel@tonic-gate 		linknew = FALSE;
25577c478bd9Sstevel@tonic-gate 	}
25587c478bd9Sstevel@tonic-gate 
25597c478bd9Sstevel@tonic-gate 	if (link_exists == TRUE) {
25606e670f77Saj 		/* Link exists or was just created */
25616e670f77Saj 		(void) di_devlink_add_link(devlink_cache, link, rcontents,
25626e670f77Saj 		    DI_PRIMARY_LINK);
25636e670f77Saj 
25646e670f77Saj 		if (system_labeled && (flags & DA_ADD)) {
256545916cd2Sjpk 			/*
25666e670f77Saj 			 * Add this to the list of allocatable devices. If this
25676e670f77Saj 			 * is a hotplugged, removable disk, add it as rmdisk.
256845916cd2Sjpk 			 */
25696e670f77Saj 			int instance = di_instance(node);
257045916cd2Sjpk 
25716e670f77Saj 			if ((flags & DA_CD) &&
25726e670f77Saj 			    (_da_check_for_usb(devlink, root_dir) == 1)) {
257345916cd2Sjpk 				(void) da_add_list(&devlist, devlink, instance,
257445916cd2Sjpk 				    DA_ADD|DA_RMDISK);
257545916cd2Sjpk 				update_devdb = DA_RMDISK;
25766e670f77Saj 			} else if (linknew == TRUE) {
25776e670f77Saj 				(void) da_add_list(&devlist, devlink, instance,
25786e670f77Saj 				    flags);
25796e670f77Saj 				update_devdb = flags;
258045916cd2Sjpk 			}
258145916cd2Sjpk 		}
25827c478bd9Sstevel@tonic-gate 	}
25837c478bd9Sstevel@tonic-gate 
25847c478bd9Sstevel@tonic-gate 	return (rv);
25857c478bd9Sstevel@tonic-gate }
25867c478bd9Sstevel@tonic-gate 
25877c478bd9Sstevel@tonic-gate /*
25887c478bd9Sstevel@tonic-gate  * Creates a symlink link to primary_link.  Calculates relative
25897c478bd9Sstevel@tonic-gate  * directory offsets, then calls link_common().
25907c478bd9Sstevel@tonic-gate  */
25917c478bd9Sstevel@tonic-gate /*ARGSUSED*/
25927c478bd9Sstevel@tonic-gate int
25937c478bd9Sstevel@tonic-gate devfsadm_secondary_link(char *link, char *primary_link, int flags)
25947c478bd9Sstevel@tonic-gate {
25957c478bd9Sstevel@tonic-gate 	char contents[PATH_MAX + 1];
25967c478bd9Sstevel@tonic-gate 	char devlink[PATH_MAX + 1];
25977c478bd9Sstevel@tonic-gate 	int rv, link_exists;
25987c478bd9Sstevel@tonic-gate 	char *fpath;
25997c478bd9Sstevel@tonic-gate 	char *tpath;
26007c478bd9Sstevel@tonic-gate 	char *op;
26017c478bd9Sstevel@tonic-gate 
26027c478bd9Sstevel@tonic-gate 	/* prepend link with dev_dir contents */
26037c478bd9Sstevel@tonic-gate 	(void) strcpy(devlink, dev_dir);
26047c478bd9Sstevel@tonic-gate 	(void) strcat(devlink, "/");
26057c478bd9Sstevel@tonic-gate 	(void) strcat(devlink, link);
26067c478bd9Sstevel@tonic-gate 	/*
26077c478bd9Sstevel@tonic-gate 	 * building extra link, so use first link as link contents, but first
26087c478bd9Sstevel@tonic-gate 	 * make it relative.
26097c478bd9Sstevel@tonic-gate 	 */
26107c478bd9Sstevel@tonic-gate 	fpath = link;
26117c478bd9Sstevel@tonic-gate 	tpath = primary_link;
26127c478bd9Sstevel@tonic-gate 	op = contents;
26137c478bd9Sstevel@tonic-gate 
26147c478bd9Sstevel@tonic-gate 	while (*fpath == *tpath && *fpath != '\0') {
26157c478bd9Sstevel@tonic-gate 		fpath++, tpath++;
26167c478bd9Sstevel@tonic-gate 	}
26177c478bd9Sstevel@tonic-gate 
26187c478bd9Sstevel@tonic-gate 	/* Count directories to go up, if any, and add "../" */
26197c478bd9Sstevel@tonic-gate 	while (*fpath != '\0') {
26207c478bd9Sstevel@tonic-gate 		if (*fpath == '/') {
26217c478bd9Sstevel@tonic-gate 			(void) strcpy(op, "../");
26227c478bd9Sstevel@tonic-gate 			op += 3;
26237c478bd9Sstevel@tonic-gate 		}
26247c478bd9Sstevel@tonic-gate 		fpath++;
26257c478bd9Sstevel@tonic-gate 	}
26267c478bd9Sstevel@tonic-gate 
26277c478bd9Sstevel@tonic-gate 	/*
26287c478bd9Sstevel@tonic-gate 	 * Back up to the start of the current path component, in
26297c478bd9Sstevel@tonic-gate 	 * case in the middle
26307c478bd9Sstevel@tonic-gate 	 */
26317c478bd9Sstevel@tonic-gate 	while (tpath != primary_link && *(tpath-1) != '/') {
26327c478bd9Sstevel@tonic-gate 		tpath--;
26337c478bd9Sstevel@tonic-gate 	}
26347c478bd9Sstevel@tonic-gate 	(void) strcpy(op, tpath);
26357c478bd9Sstevel@tonic-gate 
26367c478bd9Sstevel@tonic-gate 	if (devlinks_debug == TRUE) {
26377c478bd9Sstevel@tonic-gate 		vprint(INFO_MID, "adding extra link %s ==> %s\n",
26380a653502Swroche 		    devlink, contents);
26397c478bd9Sstevel@tonic-gate 	}
26407c478bd9Sstevel@tonic-gate 
26417c478bd9Sstevel@tonic-gate 	if ((rv = create_link_common(devlink, contents, &link_exists))
26427c478bd9Sstevel@tonic-gate 	    == DEVFSADM_SUCCESS) {
26437c478bd9Sstevel@tonic-gate 		/*
26447c478bd9Sstevel@tonic-gate 		 * we need to save the ultimate /devices contents, and not the
26457c478bd9Sstevel@tonic-gate 		 * secondary link, since hotcleanup only looks at /devices path.
26467c478bd9Sstevel@tonic-gate 		 * Since we don't have devices path here, we can try to get it
26477c478bd9Sstevel@tonic-gate 		 * by readlink'ing the secondary link.  This assumes the primary
26487c478bd9Sstevel@tonic-gate 		 * link was created first.
26497c478bd9Sstevel@tonic-gate 		 */
26507c478bd9Sstevel@tonic-gate 		add_link_to_cache(link, lphy_path);
26517c478bd9Sstevel@tonic-gate 		linknew = TRUE;
265245916cd2Sjpk 		if (system_labeled &&
265345916cd2Sjpk 		    ((flags & DA_AUDIO) && (flags & DA_ADD))) {
265445916cd2Sjpk 			/*
265545916cd2Sjpk 			 * Add this device to the list of allocatable devices.
265645916cd2Sjpk 			 */
265745916cd2Sjpk 			int	instance = 0;
265845916cd2Sjpk 
265945916cd2Sjpk 			op = strrchr(contents, '/');
266045916cd2Sjpk 			op++;
266145916cd2Sjpk 			(void) sscanf(op, "%d", &instance);
266245916cd2Sjpk 			(void) da_add_list(&devlist, devlink, instance, flags);
266345916cd2Sjpk 			update_devdb = flags;
266445916cd2Sjpk 		}
26657c478bd9Sstevel@tonic-gate 	} else {
26667c478bd9Sstevel@tonic-gate 		linknew = FALSE;
26677c478bd9Sstevel@tonic-gate 	}
26687c478bd9Sstevel@tonic-gate 
26697c478bd9Sstevel@tonic-gate 	/*
26707c478bd9Sstevel@tonic-gate 	 * If link exists or was just created, add it to the database
26717c478bd9Sstevel@tonic-gate 	 */
26727c478bd9Sstevel@tonic-gate 	if (link_exists == TRUE) {
26737c478bd9Sstevel@tonic-gate 		(void) di_devlink_add_link(devlink_cache, link, contents,
26747c478bd9Sstevel@tonic-gate 		    DI_SECONDARY_LINK);
26757c478bd9Sstevel@tonic-gate 	}
26767c478bd9Sstevel@tonic-gate 
26777c478bd9Sstevel@tonic-gate 	return (rv);
26787c478bd9Sstevel@tonic-gate }
26797c478bd9Sstevel@tonic-gate 
26807c478bd9Sstevel@tonic-gate /* returns pointer to the devices directory */
26817c478bd9Sstevel@tonic-gate char *
26827c478bd9Sstevel@tonic-gate devfsadm_get_devices_dir()
26837c478bd9Sstevel@tonic-gate {
26847c478bd9Sstevel@tonic-gate 	return (devices_dir);
26857c478bd9Sstevel@tonic-gate }
26867c478bd9Sstevel@tonic-gate 
26877c478bd9Sstevel@tonic-gate /*
26887c478bd9Sstevel@tonic-gate  * Does the actual link creation.  VERBOSE_MID only used if there is
26897c478bd9Sstevel@tonic-gate  * a change.  CHATTY_MID used otherwise.
26907c478bd9Sstevel@tonic-gate  */
26917c478bd9Sstevel@tonic-gate static int
26927c478bd9Sstevel@tonic-gate create_link_common(char *devlink, char *contents, int *exists)
26937c478bd9Sstevel@tonic-gate {
26947c478bd9Sstevel@tonic-gate 	int try;
26957c478bd9Sstevel@tonic-gate 	int linksize;
26967c478bd9Sstevel@tonic-gate 	int max_tries = 0;
26977c478bd9Sstevel@tonic-gate 	static int prev_link_existed = TRUE;
26987c478bd9Sstevel@tonic-gate 	char checkcontents[PATH_MAX + 1];
26997c478bd9Sstevel@tonic-gate 	char *hide;
27007c478bd9Sstevel@tonic-gate 
27017c478bd9Sstevel@tonic-gate 	*exists = FALSE;
27027c478bd9Sstevel@tonic-gate 
27037c478bd9Sstevel@tonic-gate 	/* Database is not updated when file_mods == FALSE */
27047c478bd9Sstevel@tonic-gate 	if (file_mods == FALSE) {
270594c894bbSVikram Hegde 		/* we want *actual* link contents so no alias redirection */
27067c478bd9Sstevel@tonic-gate 		linksize = readlink(devlink, checkcontents, PATH_MAX);
27077c478bd9Sstevel@tonic-gate 		if (linksize > 0) {
27087c478bd9Sstevel@tonic-gate 			checkcontents[linksize] = '\0';
27097c478bd9Sstevel@tonic-gate 			if (strcmp(checkcontents, contents) != 0) {
27107c478bd9Sstevel@tonic-gate 				vprint(CHATTY_MID, REMOVING_LINK,
27110a653502Swroche 				    devlink, checkcontents);
27127c478bd9Sstevel@tonic-gate 				return (DEVFSADM_SUCCESS);
27137c478bd9Sstevel@tonic-gate 			} else {
27147c478bd9Sstevel@tonic-gate 				vprint(CHATTY_MID, "link exists and is correct:"
27150a653502Swroche 				    " %s -> %s\n", devlink, contents);
27167c478bd9Sstevel@tonic-gate 				/* failure only in that the link existed */
27177c478bd9Sstevel@tonic-gate 				return (DEVFSADM_FAILURE);
27187c478bd9Sstevel@tonic-gate 			}
27197c478bd9Sstevel@tonic-gate 		} else {
27207c478bd9Sstevel@tonic-gate 			vprint(VERBOSE_MID, CREATING_LINK, devlink, contents);
27217c478bd9Sstevel@tonic-gate 			return (DEVFSADM_SUCCESS);
27227c478bd9Sstevel@tonic-gate 		}
27237c478bd9Sstevel@tonic-gate 	}
27247c478bd9Sstevel@tonic-gate 
27257c478bd9Sstevel@tonic-gate 	/*
27267c478bd9Sstevel@tonic-gate 	 * systems calls are expensive, so predict whether to readlink
27277c478bd9Sstevel@tonic-gate 	 * or symlink first, based on previous attempt
27287c478bd9Sstevel@tonic-gate 	 */
27297c478bd9Sstevel@tonic-gate 	if (prev_link_existed == FALSE) {
27307c478bd9Sstevel@tonic-gate 		try = CREATE_LINK;
27317c478bd9Sstevel@tonic-gate 	} else {
27327c478bd9Sstevel@tonic-gate 		try = READ_LINK;
27337c478bd9Sstevel@tonic-gate 	}
27347c478bd9Sstevel@tonic-gate 
27357c478bd9Sstevel@tonic-gate 	while (++max_tries <= 3) {
27367c478bd9Sstevel@tonic-gate 
27377c478bd9Sstevel@tonic-gate 		switch (try) {
27387c478bd9Sstevel@tonic-gate 		case  CREATE_LINK:
27397c478bd9Sstevel@tonic-gate 
27407c478bd9Sstevel@tonic-gate 			if (symlink(contents, devlink) == 0) {
27417c478bd9Sstevel@tonic-gate 				vprint(VERBOSE_MID, CREATING_LINK, devlink,
27420a653502Swroche 				    contents);
27437c478bd9Sstevel@tonic-gate 				prev_link_existed = FALSE;
27447c478bd9Sstevel@tonic-gate 				/* link successfully created */
27457c478bd9Sstevel@tonic-gate 				*exists = TRUE;
27467c478bd9Sstevel@tonic-gate 				set_logindev_perms(devlink);
27477c478bd9Sstevel@tonic-gate 				return (DEVFSADM_SUCCESS);
27487c478bd9Sstevel@tonic-gate 			} else {
27497c478bd9Sstevel@tonic-gate 				switch (errno) {
27507c478bd9Sstevel@tonic-gate 
27517c478bd9Sstevel@tonic-gate 				case ENOENT:
27527c478bd9Sstevel@tonic-gate 					/* dirpath to node doesn't exist */
27537c478bd9Sstevel@tonic-gate 					hide = strrchr(devlink, '/');
27547c478bd9Sstevel@tonic-gate 					*hide = '\0';
27557c478bd9Sstevel@tonic-gate 					s_mkdirp(devlink, S_IRWXU|S_IRGRP|
27560a653502Swroche 					    S_IXGRP|S_IROTH|S_IXOTH);
27577c478bd9Sstevel@tonic-gate 					*hide = '/';
27587c478bd9Sstevel@tonic-gate 					break;
27597c478bd9Sstevel@tonic-gate 				case EEXIST:
27607c478bd9Sstevel@tonic-gate 					try = READ_LINK;
27617c478bd9Sstevel@tonic-gate 					break;
27627c478bd9Sstevel@tonic-gate 				default:
27637c478bd9Sstevel@tonic-gate 					err_print(SYMLINK_FAILED, devlink,
27640a653502Swroche 					    contents, strerror(errno));
27657c478bd9Sstevel@tonic-gate 					return (DEVFSADM_FAILURE);
27667c478bd9Sstevel@tonic-gate 				}
27677c478bd9Sstevel@tonic-gate 			}
27687c478bd9Sstevel@tonic-gate 			break;
27697c478bd9Sstevel@tonic-gate 
27707c478bd9Sstevel@tonic-gate 		case READ_LINK:
27717c478bd9Sstevel@tonic-gate 
277294c894bbSVikram Hegde 			/*
277394c894bbSVikram Hegde 			 * If there is redirection, new phys path
277494c894bbSVikram Hegde 			 * and old phys path will not match and the
277594c894bbSVikram Hegde 			 * link will be created with new phys path
277694c894bbSVikram Hegde 			 * which is what we want. So we want real
277794c894bbSVikram Hegde 			 * contents.
277894c894bbSVikram Hegde 			 */
27797c478bd9Sstevel@tonic-gate 			linksize = readlink(devlink, checkcontents, PATH_MAX);
27807c478bd9Sstevel@tonic-gate 			if (linksize >= 0) {
27817c478bd9Sstevel@tonic-gate 				checkcontents[linksize] = '\0';
27827c478bd9Sstevel@tonic-gate 				if (strcmp(checkcontents, contents) != 0) {
27837c478bd9Sstevel@tonic-gate 					s_unlink(devlink);
27847c478bd9Sstevel@tonic-gate 					vprint(VERBOSE_MID, REMOVING_LINK,
27850a653502Swroche 					    devlink, checkcontents);
27867c478bd9Sstevel@tonic-gate 					try = CREATE_LINK;
27877c478bd9Sstevel@tonic-gate 				} else {
27887c478bd9Sstevel@tonic-gate 					prev_link_existed = TRUE;
27897c478bd9Sstevel@tonic-gate 					vprint(CHATTY_MID,
27900a653502Swroche 					    "link exists and is correct:"
27910a653502Swroche 					    " %s -> %s\n", devlink, contents);
27927c478bd9Sstevel@tonic-gate 					*exists = TRUE;
27937c478bd9Sstevel@tonic-gate 					/* failure in that the link existed */
27947c478bd9Sstevel@tonic-gate 					return (DEVFSADM_FAILURE);
27957c478bd9Sstevel@tonic-gate 				}
27967c478bd9Sstevel@tonic-gate 			} else {
27977c478bd9Sstevel@tonic-gate 				switch (errno) {
27987c478bd9Sstevel@tonic-gate 				case EINVAL:
27997c478bd9Sstevel@tonic-gate 					/* not a symlink, remove and create */
28007c478bd9Sstevel@tonic-gate 					s_unlink(devlink);
28017c478bd9Sstevel@tonic-gate 				default:
28027c478bd9Sstevel@tonic-gate 					/* maybe it didn't exist at all */
28037c478bd9Sstevel@tonic-gate 					try = CREATE_LINK;
28047c478bd9Sstevel@tonic-gate 					break;
28057c478bd9Sstevel@tonic-gate 				}
28067c478bd9Sstevel@tonic-gate 			}
28077c478bd9Sstevel@tonic-gate 			break;
28087c478bd9Sstevel@tonic-gate 		}
28097c478bd9Sstevel@tonic-gate 	}
28107c478bd9Sstevel@tonic-gate 	err_print(MAX_ATTEMPTS, devlink, contents);
28117c478bd9Sstevel@tonic-gate 	return (DEVFSADM_FAILURE);
28127c478bd9Sstevel@tonic-gate }
28137c478bd9Sstevel@tonic-gate 
28147c478bd9Sstevel@tonic-gate static void
28157c478bd9Sstevel@tonic-gate set_logindev_perms(char *devlink)
28167c478bd9Sstevel@tonic-gate {
28177c478bd9Sstevel@tonic-gate 	struct login_dev *newdev;
28187c478bd9Sstevel@tonic-gate 	struct passwd pwd, *resp;
28197c478bd9Sstevel@tonic-gate 	char pwd_buf[PATH_MAX];
28207c478bd9Sstevel@tonic-gate 	int rv;
28217c478bd9Sstevel@tonic-gate 	struct stat sb;
28227c478bd9Sstevel@tonic-gate 	char *devfs_path = NULL;
28237c478bd9Sstevel@tonic-gate 
28247c478bd9Sstevel@tonic-gate 	/*
28257c478bd9Sstevel@tonic-gate 	 * We only want logindev perms to be set when a device is
28267c478bd9Sstevel@tonic-gate 	 * hotplugged or an application requests synchronous creates.
28277c478bd9Sstevel@tonic-gate 	 * So we enable this only in daemon mode. In addition,
28287c478bd9Sstevel@tonic-gate 	 * login(1) only fixes the std. /dev dir. So we don't
28297c478bd9Sstevel@tonic-gate 	 * change perms if alternate root is set.
28307c478bd9Sstevel@tonic-gate 	 * login_dev_enable is TRUE only in these cases.
28317c478bd9Sstevel@tonic-gate 	 */
28327c478bd9Sstevel@tonic-gate 	if (login_dev_enable != TRUE)
28337c478bd9Sstevel@tonic-gate 		return;
28347c478bd9Sstevel@tonic-gate 
28357c478bd9Sstevel@tonic-gate 	/*
28367c478bd9Sstevel@tonic-gate 	 * Normally, /etc/logindevperm has few (8 - 10 entries) which
28377c478bd9Sstevel@tonic-gate 	 * may be regular expressions (globs were converted to RE).
28387c478bd9Sstevel@tonic-gate 	 * So just do a linear search through the list.
28397c478bd9Sstevel@tonic-gate 	 */
28407c478bd9Sstevel@tonic-gate 	for (newdev = login_dev_cache; newdev; newdev = newdev->ldev_next) {
28417c478bd9Sstevel@tonic-gate 		vprint(FILES_MID, "matching %s with %s\n", devlink,
28427c478bd9Sstevel@tonic-gate 		    newdev->ldev_device);
28437c478bd9Sstevel@tonic-gate 
28447c478bd9Sstevel@tonic-gate 		if (regexec(&newdev->ldev_device_regex, devlink, 0,
28457c478bd9Sstevel@tonic-gate 		    NULL, 0) == 0)  {
28467c478bd9Sstevel@tonic-gate 			vprint(FILES_MID, "matched %s with %s\n", devlink,
28477c478bd9Sstevel@tonic-gate 			    newdev->ldev_device);
28487c478bd9Sstevel@tonic-gate 			break;
28497c478bd9Sstevel@tonic-gate 		}
28507c478bd9Sstevel@tonic-gate 	}
28517c478bd9Sstevel@tonic-gate 
28527c478bd9Sstevel@tonic-gate 	if (newdev == NULL)
28537c478bd9Sstevel@tonic-gate 		return;
28547c478bd9Sstevel@tonic-gate 
28557c478bd9Sstevel@tonic-gate 	/*
28567c478bd9Sstevel@tonic-gate 	 * we have a match, now find the driver associated with this
28577c478bd9Sstevel@tonic-gate 	 * minor node using a snapshot on the physical path
28587c478bd9Sstevel@tonic-gate 	 */
28597c478bd9Sstevel@tonic-gate 	(void) resolve_link(devlink, NULL, NULL, &devfs_path, 0);
286094c894bbSVikram Hegde 	/*
286194c894bbSVikram Hegde 	 * We dont need redirection here - the actual link contents
286294c894bbSVikram Hegde 	 * whether "alias" or "current" are fine
286394c894bbSVikram Hegde 	 */
28647c478bd9Sstevel@tonic-gate 	if (devfs_path) {
28657c478bd9Sstevel@tonic-gate 		di_node_t node;
286694c894bbSVikram Hegde 		char *drv;
28677c478bd9Sstevel@tonic-gate 		struct driver_list *list;
28687c478bd9Sstevel@tonic-gate 		char *p;
28697c478bd9Sstevel@tonic-gate 
28707c478bd9Sstevel@tonic-gate 		/* truncate on : so we can take a snapshot */
28717c478bd9Sstevel@tonic-gate 		(void) strcpy(pwd_buf, devfs_path);
28727c478bd9Sstevel@tonic-gate 		p = strrchr(pwd_buf, ':');
28737c478bd9Sstevel@tonic-gate 		if (p == NULL) {
28747c478bd9Sstevel@tonic-gate 			free(devfs_path);
28757c478bd9Sstevel@tonic-gate 			return;
28767c478bd9Sstevel@tonic-gate 		}
28777c478bd9Sstevel@tonic-gate 		*p = '\0';
28787c478bd9Sstevel@tonic-gate 
28797c478bd9Sstevel@tonic-gate 		vprint(FILES_MID, "link=%s->physpath=%s\n",
28807c478bd9Sstevel@tonic-gate 		    devlink, pwd_buf);
28817c478bd9Sstevel@tonic-gate 
28827c478bd9Sstevel@tonic-gate 		node = di_init(pwd_buf, DINFOMINOR);
28837c478bd9Sstevel@tonic-gate 
288494c894bbSVikram Hegde 		drv = NULL;
28857c478bd9Sstevel@tonic-gate 		if (node) {
28867c478bd9Sstevel@tonic-gate 			drv = di_driver_name(node);
28877c478bd9Sstevel@tonic-gate 
28887c478bd9Sstevel@tonic-gate 			if (drv) {
28897c478bd9Sstevel@tonic-gate 				vprint(FILES_MID, "%s: driver is %s\n",
28907c478bd9Sstevel@tonic-gate 				    devlink, drv);
28917c478bd9Sstevel@tonic-gate 			}
28927c478bd9Sstevel@tonic-gate 		}
28937c478bd9Sstevel@tonic-gate 		/* search thru the driver list specified in logindevperm */
28947c478bd9Sstevel@tonic-gate 		list = newdev->ldev_driver_list;
28957c478bd9Sstevel@tonic-gate 		if ((drv != NULL) && (list != NULL)) {
28967c478bd9Sstevel@tonic-gate 			while (list) {
28977c478bd9Sstevel@tonic-gate 				if (strcmp(list->driver_name,
28987c478bd9Sstevel@tonic-gate 				    drv) == 0) {
28997c478bd9Sstevel@tonic-gate 					vprint(FILES_MID,
29007c478bd9Sstevel@tonic-gate 					    "driver %s match!\n", drv);
29017c478bd9Sstevel@tonic-gate 					break;
29027c478bd9Sstevel@tonic-gate 				}
29037c478bd9Sstevel@tonic-gate 				list = list->next;
29047c478bd9Sstevel@tonic-gate 			}
29057c478bd9Sstevel@tonic-gate 			if (list == NULL) {
29067c478bd9Sstevel@tonic-gate 				vprint(FILES_MID, "no driver match!\n");
29077c478bd9Sstevel@tonic-gate 				free(devfs_path);
29087c478bd9Sstevel@tonic-gate 				return;
29097c478bd9Sstevel@tonic-gate 			}
29107c478bd9Sstevel@tonic-gate 		}
29117c478bd9Sstevel@tonic-gate 		free(devfs_path);
291294c894bbSVikram Hegde 		di_fini(node);
29137c478bd9Sstevel@tonic-gate 	} else {
29147c478bd9Sstevel@tonic-gate 		return;
29157c478bd9Sstevel@tonic-gate 	}
29167c478bd9Sstevel@tonic-gate 
29177c478bd9Sstevel@tonic-gate 	vprint(FILES_MID, "changing permissions of %s\n", devlink);
29187c478bd9Sstevel@tonic-gate 
29197c478bd9Sstevel@tonic-gate 	/*
29207c478bd9Sstevel@tonic-gate 	 * We have a match. We now attempt to determine the
29217c478bd9Sstevel@tonic-gate 	 * owner and group of the console user.
29227c478bd9Sstevel@tonic-gate 	 *
29237c478bd9Sstevel@tonic-gate 	 * stat() the console device newdev->ldev_console
29247c478bd9Sstevel@tonic-gate 	 * which will always exist - it will have the right owner but
29257c478bd9Sstevel@tonic-gate 	 * not the right group. Use getpwuid_r() to determine group for this
29267c478bd9Sstevel@tonic-gate 	 * uid.
29277c478bd9Sstevel@tonic-gate 	 * Note, it is safe to use name service here since if name services
29287c478bd9Sstevel@tonic-gate 	 * are not available (during boot or in single-user mode), then
29297c478bd9Sstevel@tonic-gate 	 * console owner will be root and its gid can be found in
29307c478bd9Sstevel@tonic-gate 	 * local files.
29317c478bd9Sstevel@tonic-gate 	 */
29327c478bd9Sstevel@tonic-gate 	if (stat(newdev->ldev_console, &sb) == -1) {
29337c478bd9Sstevel@tonic-gate 		vprint(VERBOSE_MID, STAT_FAILED, newdev->ldev_console,
29347c478bd9Sstevel@tonic-gate 		    strerror(errno));
29357c478bd9Sstevel@tonic-gate 		return;
29367c478bd9Sstevel@tonic-gate 	}
29377c478bd9Sstevel@tonic-gate 
29387c478bd9Sstevel@tonic-gate 	resp = NULL;
29397c478bd9Sstevel@tonic-gate 	rv = getpwuid_r(sb.st_uid, &pwd, pwd_buf, sizeof (pwd_buf), &resp);
29407c478bd9Sstevel@tonic-gate 	if (rv || resp == NULL) {
29417c478bd9Sstevel@tonic-gate 		rv = rv ? rv : EINVAL;
29427c478bd9Sstevel@tonic-gate 		vprint(VERBOSE_MID, GID_FAILED, sb.st_uid,
29437c478bd9Sstevel@tonic-gate 		    strerror(rv));
29447c478bd9Sstevel@tonic-gate 		return;
29457c478bd9Sstevel@tonic-gate 	}
29467c478bd9Sstevel@tonic-gate 
29477c478bd9Sstevel@tonic-gate 	assert(&pwd == resp);
29487c478bd9Sstevel@tonic-gate 
29497c478bd9Sstevel@tonic-gate 	sb.st_gid = resp->pw_gid;
29507c478bd9Sstevel@tonic-gate 
29517c478bd9Sstevel@tonic-gate 	if (chmod(devlink, newdev->ldev_perms) == -1) {
29527c478bd9Sstevel@tonic-gate 		vprint(VERBOSE_MID, CHMOD_FAILED, devlink,
29537c478bd9Sstevel@tonic-gate 		    strerror(errno));
29547c478bd9Sstevel@tonic-gate 		return;
29557c478bd9Sstevel@tonic-gate 	}
29567c478bd9Sstevel@tonic-gate 
29577c478bd9Sstevel@tonic-gate 	if (chown(devlink, sb.st_uid, sb.st_gid)  == -1) {
29587c478bd9Sstevel@tonic-gate 		vprint(VERBOSE_MID, CHOWN_FAILED, devlink,
29597c478bd9Sstevel@tonic-gate 		    strerror(errno));
29607c478bd9Sstevel@tonic-gate 	}
29617c478bd9Sstevel@tonic-gate }
29627c478bd9Sstevel@tonic-gate 
29637c478bd9Sstevel@tonic-gate /*
29647c478bd9Sstevel@tonic-gate  * Reset /devices node with appropriate permissions and
29657c478bd9Sstevel@tonic-gate  * ownership as specified in /etc/minor_perm.
29667c478bd9Sstevel@tonic-gate  */
29677c478bd9Sstevel@tonic-gate static void
29687c478bd9Sstevel@tonic-gate reset_node_permissions(di_node_t node, di_minor_t minor)
29697c478bd9Sstevel@tonic-gate {
29707c478bd9Sstevel@tonic-gate 	int spectype;
29717c478bd9Sstevel@tonic-gate 	char phy_path[PATH_MAX + 1];
29727c478bd9Sstevel@tonic-gate 	mode_t mode;
29737c478bd9Sstevel@tonic-gate 	dev_t dev;
29747c478bd9Sstevel@tonic-gate 	uid_t uid;
29757c478bd9Sstevel@tonic-gate 	gid_t gid;
29767c478bd9Sstevel@tonic-gate 	struct stat sb;
29777c478bd9Sstevel@tonic-gate 	char *dev_path, *aminor = NULL;
29787c478bd9Sstevel@tonic-gate 
29797c478bd9Sstevel@tonic-gate 	/* lphy_path starts with / */
29807c478bd9Sstevel@tonic-gate 	if ((dev_path = di_devfs_path(node)) == NULL) {
29817c478bd9Sstevel@tonic-gate 		err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
29827c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
2983537714daSvikram 		/*NOTREACHED*/
29847c478bd9Sstevel@tonic-gate 	}
29857c478bd9Sstevel@tonic-gate 	(void) strcpy(lphy_path, dev_path);
29867c478bd9Sstevel@tonic-gate 	di_devfs_path_free(dev_path);
29877c478bd9Sstevel@tonic-gate 
29887c478bd9Sstevel@tonic-gate 	(void) strcat(lphy_path, ":");
29897c478bd9Sstevel@tonic-gate 	if (di_minor_type(minor) == DDM_ALIAS) {
29907c478bd9Sstevel@tonic-gate 		char *driver;
29917c478bd9Sstevel@tonic-gate 		aminor = di_minor_name(minor);
29927c478bd9Sstevel@tonic-gate 		driver = di_driver_name(di_minor_devinfo(minor));
29937c478bd9Sstevel@tonic-gate 		(void) strcat(lphy_path, driver);
29947c478bd9Sstevel@tonic-gate 	} else
29957c478bd9Sstevel@tonic-gate 		(void) strcat(lphy_path, di_minor_name(minor));
29967c478bd9Sstevel@tonic-gate 
29977c478bd9Sstevel@tonic-gate 	(void) strcpy(phy_path, devices_dir);
29987c478bd9Sstevel@tonic-gate 	(void) strcat(phy_path, lphy_path);
29997c478bd9Sstevel@tonic-gate 
30007c478bd9Sstevel@tonic-gate 	lnode = node;
30017c478bd9Sstevel@tonic-gate 	lminor = minor;
30027c478bd9Sstevel@tonic-gate 
30037c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "reset_node_permissions: phy_path=%s lphy_path=%s\n",
30040a653502Swroche 	    phy_path, lphy_path);
30057c478bd9Sstevel@tonic-gate 
30067c478bd9Sstevel@tonic-gate 	dev = di_minor_devt(minor);
30077c478bd9Sstevel@tonic-gate 	spectype = di_minor_spectype(minor); /* block or char */
30087c478bd9Sstevel@tonic-gate 
30097c478bd9Sstevel@tonic-gate 	getattr(phy_path, aminor, spectype, dev, &mode, &uid, &gid);
30107c478bd9Sstevel@tonic-gate 
30117c478bd9Sstevel@tonic-gate 	/*
30127c478bd9Sstevel@tonic-gate 	 * compare and set permissions and ownership
30137c478bd9Sstevel@tonic-gate 	 *
30147c478bd9Sstevel@tonic-gate 	 * Under devfs, a quick insertion and removal of USB devices
30157c478bd9Sstevel@tonic-gate 	 * would cause stat of physical path to fail. In this case,
30167c478bd9Sstevel@tonic-gate 	 * we emit a verbose message, but don't print errors.
30177c478bd9Sstevel@tonic-gate 	 */
30187c478bd9Sstevel@tonic-gate 	if ((stat(phy_path, &sb) == -1) || (sb.st_rdev != dev)) {
30197c478bd9Sstevel@tonic-gate 		vprint(VERBOSE_MID, NO_DEVFS_NODE, phy_path);
30207c478bd9Sstevel@tonic-gate 		return;
30217c478bd9Sstevel@tonic-gate 	}
30227c478bd9Sstevel@tonic-gate 
30237c478bd9Sstevel@tonic-gate 	/*
302445916cd2Sjpk 	 * If we are here for a new device
302545916cd2Sjpk 	 *	If device allocation is on
302645916cd2Sjpk 	 *	then
302745916cd2Sjpk 	 *		set ownership to root:other and permissions to 0000
302845916cd2Sjpk 	 *	else
302945916cd2Sjpk 	 *		set ownership and permissions as specified in minor_perm
303045916cd2Sjpk 	 * If we are here for an existing device
303145916cd2Sjpk 	 *	If device allocation is to be turned on
303245916cd2Sjpk 	 *	then
303345916cd2Sjpk 	 *		reset ownership to root:other and permissions to 0000
303445916cd2Sjpk 	 *	else if device allocation is to be turned off
303545916cd2Sjpk 	 *		reset ownership and permissions to those specified in
303645916cd2Sjpk 	 *		minor_perm
303745916cd2Sjpk 	 *	else
3038ff2aee48Scth 	 *		preserve existing/user-modified ownership and
303945916cd2Sjpk 	 *		permissions
304045916cd2Sjpk 	 *
304145916cd2Sjpk 	 * devfs indicates a new device by faking access time to be zero.
30427c478bd9Sstevel@tonic-gate 	 */
30437c478bd9Sstevel@tonic-gate 	if (sb.st_atime != 0) {
30447c478bd9Sstevel@tonic-gate 		int  i;
30457c478bd9Sstevel@tonic-gate 		char *nt;
30467c478bd9Sstevel@tonic-gate 
304745916cd2Sjpk 		if ((devalloc_flag == 0) && (devalloc_is_on != 1))
304845916cd2Sjpk 			/*
304945916cd2Sjpk 			 * Leave existing devices as they are if we are not
305045916cd2Sjpk 			 * turning device allocation on/off.
305145916cd2Sjpk 			 */
30527c478bd9Sstevel@tonic-gate 			return;
30537c478bd9Sstevel@tonic-gate 
30547c478bd9Sstevel@tonic-gate 		nt = di_minor_nodetype(minor);
305545916cd2Sjpk 
30567c478bd9Sstevel@tonic-gate 		if (nt == NULL)
30577c478bd9Sstevel@tonic-gate 			return;
305845916cd2Sjpk 
305945916cd2Sjpk 		for (i = 0; devalloc_list[i]; i++) {
306045916cd2Sjpk 			if (strcmp(nt, devalloc_list[i]) == 0)
306145916cd2Sjpk 				/*
306245916cd2Sjpk 				 * One of the types recognized by devalloc,
306345916cd2Sjpk 				 * reset attrs.
306445916cd2Sjpk 				 */
30657c478bd9Sstevel@tonic-gate 				break;
30667c478bd9Sstevel@tonic-gate 		}
306745916cd2Sjpk 		if (devalloc_list[i] == NULL)
30687c478bd9Sstevel@tonic-gate 			return;
30697c478bd9Sstevel@tonic-gate 	}
30707c478bd9Sstevel@tonic-gate 
30717c478bd9Sstevel@tonic-gate 	if (file_mods == FALSE) {
30727c478bd9Sstevel@tonic-gate 		/* Nothing more to do if simulating */
30737c478bd9Sstevel@tonic-gate 		vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode);
30747c478bd9Sstevel@tonic-gate 		return;
30757c478bd9Sstevel@tonic-gate 	}
30767c478bd9Sstevel@tonic-gate 
30778c206d17Spr 	if ((devalloc_flag == DA_ON) ||
30788c206d17Spr 	    ((devalloc_is_on == 1) && (devalloc_flag != DA_OFF))) {
307945916cd2Sjpk 		/*
30808c206d17Spr 		 * we are here either to turn device allocation on or
30818c206d17Spr 		 * to add a new device while device allocation is on
30828c206d17Spr 		 * (and we've confirmed that we're not turning it
30838c206d17Spr 		 * off).
308445916cd2Sjpk 		 */
308545916cd2Sjpk 		mode = DEALLOC_MODE;
308645916cd2Sjpk 		uid = DA_UID;
308745916cd2Sjpk 		gid = DA_GID;
308845916cd2Sjpk 	}
308945916cd2Sjpk 
309045916cd2Sjpk 	if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) ||
309145916cd2Sjpk 	    (sb.st_mode != mode)) {
30927c478bd9Sstevel@tonic-gate 		if (chmod(phy_path, mode) == -1)
30937c478bd9Sstevel@tonic-gate 			vprint(VERBOSE_MID, CHMOD_FAILED,
30947c478bd9Sstevel@tonic-gate 			    phy_path, strerror(errno));
30957c478bd9Sstevel@tonic-gate 	}
309645916cd2Sjpk 	if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) ||
309745916cd2Sjpk 	    (sb.st_uid != uid || sb.st_gid != gid)) {
30987c478bd9Sstevel@tonic-gate 		if (chown(phy_path, uid, gid) == -1)
30997c478bd9Sstevel@tonic-gate 			vprint(VERBOSE_MID, CHOWN_FAILED,
31007c478bd9Sstevel@tonic-gate 			    phy_path, strerror(errno));
31017c478bd9Sstevel@tonic-gate 	}
31027c478bd9Sstevel@tonic-gate 
31037c478bd9Sstevel@tonic-gate 	/* Report that we actually did something */
31047c478bd9Sstevel@tonic-gate 	vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode);
31057c478bd9Sstevel@tonic-gate }
31067c478bd9Sstevel@tonic-gate 
31077c478bd9Sstevel@tonic-gate /*
31087c478bd9Sstevel@tonic-gate  * Removes logical link and the minor node it refers to.  If file is a
31097c478bd9Sstevel@tonic-gate  * link, we recurse and try to remove the minor node (or link if path is
31107c478bd9Sstevel@tonic-gate  * a double link) that file's link contents refer to.
31117c478bd9Sstevel@tonic-gate  */
31127c478bd9Sstevel@tonic-gate static void
31137c478bd9Sstevel@tonic-gate devfsadm_rm_work(char *file, int recurse, int file_type)
31147c478bd9Sstevel@tonic-gate {
31157c478bd9Sstevel@tonic-gate 	char *fcn = "devfsadm_rm_work: ";
31167c478bd9Sstevel@tonic-gate 	int linksize;
31177c478bd9Sstevel@tonic-gate 	char contents[PATH_MAX + 1];
31187c478bd9Sstevel@tonic-gate 	char nextfile[PATH_MAX + 1];
31197c478bd9Sstevel@tonic-gate 	char newfile[PATH_MAX + 1];
31207c478bd9Sstevel@tonic-gate 	char *ptr;
31217c478bd9Sstevel@tonic-gate 
31227c478bd9Sstevel@tonic-gate 	vprint(REMOVE_MID, "%s%s\n", fcn, file);
31237c478bd9Sstevel@tonic-gate 
312494c894bbSVikram Hegde 	/*
312594c894bbSVikram Hegde 	 * Note: we don't remove /devices (non-links) entries because they are
312694c894bbSVikram Hegde 	 *	covered by devfs.
312794c894bbSVikram Hegde 	 */
312894c894bbSVikram Hegde 	if (file_type != TYPE_LINK) {
312994c894bbSVikram Hegde 		return;
31307c478bd9Sstevel@tonic-gate 	}
31317c478bd9Sstevel@tonic-gate 
313294c894bbSVikram Hegde 	/* split into multiple if's due to excessive indentations */
313394c894bbSVikram Hegde 	(void) strcpy(newfile, dev_dir);
313494c894bbSVikram Hegde 	(void) strcat(newfile, "/");
313594c894bbSVikram Hegde 	(void) strcat(newfile, file);
313694c894bbSVikram Hegde 
313794c894bbSVikram Hegde 	/*
313894c894bbSVikram Hegde 	 * we dont care about the content of the symlink, so
313994c894bbSVikram Hegde 	 * redirection is not needed.
314094c894bbSVikram Hegde 	 */
314194c894bbSVikram Hegde 	if ((recurse == TRUE) &&
31427c478bd9Sstevel@tonic-gate 	    ((linksize = readlink(newfile, contents, PATH_MAX)) > 0)) {
31437c478bd9Sstevel@tonic-gate 		contents[linksize] = '\0';
31447c478bd9Sstevel@tonic-gate 
314594c894bbSVikram Hegde 		/*
314694c894bbSVikram Hegde 		 * recurse if link points to another link
314794c894bbSVikram Hegde 		 */
314894c894bbSVikram Hegde 		if (is_minor_node(contents, &ptr) != DEVFSADM_TRUE) {
31497c478bd9Sstevel@tonic-gate 			if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0) {
31507c478bd9Sstevel@tonic-gate 				devfsadm_rm_work(&contents[strlen(DEV) + 1],
31510a653502Swroche 				    TRUE, TYPE_LINK);
31527c478bd9Sstevel@tonic-gate 			} else {
31537c478bd9Sstevel@tonic-gate 				if ((ptr = strrchr(file, '/')) != NULL) {
31547c478bd9Sstevel@tonic-gate 					*ptr = '\0';
31557c478bd9Sstevel@tonic-gate 					(void) strcpy(nextfile, file);
31567c478bd9Sstevel@tonic-gate 					*ptr = '/';
31577c478bd9Sstevel@tonic-gate 					(void) strcat(nextfile, "/");
31587c478bd9Sstevel@tonic-gate 				} else {
31597c478bd9Sstevel@tonic-gate 					(void) strcpy(nextfile, "");
31607c478bd9Sstevel@tonic-gate 				}
31617c478bd9Sstevel@tonic-gate 				(void) strcat(nextfile, contents);
31627c478bd9Sstevel@tonic-gate 				devfsadm_rm_work(nextfile, TRUE, TYPE_LINK);
31637c478bd9Sstevel@tonic-gate 			}
31647c478bd9Sstevel@tonic-gate 		}
31657c478bd9Sstevel@tonic-gate 	}
31667c478bd9Sstevel@tonic-gate 
316794c894bbSVikram Hegde 	vprint(VERBOSE_MID, DEVFSADM_UNLINK, newfile);
316894c894bbSVikram Hegde 	if (file_mods == TRUE) {
316994c894bbSVikram Hegde 		rm_link_from_cache(file);
317094c894bbSVikram Hegde 		s_unlink(newfile);
317194c894bbSVikram Hegde 		rm_parent_dir_if_empty(newfile);
317294c894bbSVikram Hegde 		invalidate_enumerate_cache();
317394c894bbSVikram Hegde 		(void) di_devlink_rm_link(devlink_cache, file);
31747c478bd9Sstevel@tonic-gate 	}
31757c478bd9Sstevel@tonic-gate }
31767c478bd9Sstevel@tonic-gate 
31777c478bd9Sstevel@tonic-gate void
31787c478bd9Sstevel@tonic-gate devfsadm_rm_link(char *file)
31797c478bd9Sstevel@tonic-gate {
31807c478bd9Sstevel@tonic-gate 	devfsadm_rm_work(file, FALSE, TYPE_LINK);
31817c478bd9Sstevel@tonic-gate }
31827c478bd9Sstevel@tonic-gate 
31837c478bd9Sstevel@tonic-gate void
31847c478bd9Sstevel@tonic-gate devfsadm_rm_all(char *file)
31857c478bd9Sstevel@tonic-gate {
31867c478bd9Sstevel@tonic-gate 	devfsadm_rm_work(file, TRUE, TYPE_LINK);
31877c478bd9Sstevel@tonic-gate }
31887c478bd9Sstevel@tonic-gate 
31894bc0a2efScasper static int
31907c478bd9Sstevel@tonic-gate s_rmdir(char *path)
31917c478bd9Sstevel@tonic-gate {
31927c478bd9Sstevel@tonic-gate 	int	i;
31937c478bd9Sstevel@tonic-gate 	char	*rpath, *dir;
31947c478bd9Sstevel@tonic-gate 	const char *fcn = "s_rmdir";
31957c478bd9Sstevel@tonic-gate 
31967c478bd9Sstevel@tonic-gate 	/*
31977c478bd9Sstevel@tonic-gate 	 * Certain directories are created at install time by packages.
31987c478bd9Sstevel@tonic-gate 	 * Some of them (listed in packaged_dirs[]) are required by apps
31997c478bd9Sstevel@tonic-gate 	 * and need to be present even when empty.
32007c478bd9Sstevel@tonic-gate 	 */
32017c478bd9Sstevel@tonic-gate 	vprint(REMOVE_MID, "%s: checking if %s is packaged\n", fcn, path);
32027c478bd9Sstevel@tonic-gate 
32037c478bd9Sstevel@tonic-gate 	rpath = path + strlen(dev_dir) + 1;
32047c478bd9Sstevel@tonic-gate 
32057c478bd9Sstevel@tonic-gate 	for (i = 0; (dir = packaged_dirs[i]) != NULL; i++) {
32067c478bd9Sstevel@tonic-gate 		if (*rpath == *dir) {
32077c478bd9Sstevel@tonic-gate 			if (strcmp(rpath, dir) == 0) {
32087c478bd9Sstevel@tonic-gate 				vprint(REMOVE_MID, "%s: skipping packaged dir: "
32097c478bd9Sstevel@tonic-gate 				    "%s\n", fcn, path);
32104bc0a2efScasper 				errno = EEXIST;
32114bc0a2efScasper 				return (-1);
32127c478bd9Sstevel@tonic-gate 			}
32137c478bd9Sstevel@tonic-gate 		}
32147c478bd9Sstevel@tonic-gate 	}
32157c478bd9Sstevel@tonic-gate 
32164bc0a2efScasper 	return (rmdir(path));
32177c478bd9Sstevel@tonic-gate }
32187c478bd9Sstevel@tonic-gate 
32197c478bd9Sstevel@tonic-gate /*
32207c478bd9Sstevel@tonic-gate  * Try to remove any empty directories up the tree.  It is assumed that
32217c478bd9Sstevel@tonic-gate  * pathname is a file that was removed, so start with its parent, and
32227c478bd9Sstevel@tonic-gate  * work up the tree.
32237c478bd9Sstevel@tonic-gate  */
32247c478bd9Sstevel@tonic-gate static void
32257c478bd9Sstevel@tonic-gate rm_parent_dir_if_empty(char *pathname)
32267c478bd9Sstevel@tonic-gate {
32277c478bd9Sstevel@tonic-gate 	char *ptr, path[PATH_MAX + 1];
32287c478bd9Sstevel@tonic-gate 	char *fcn = "rm_parent_dir_if_empty: ";
32297c478bd9Sstevel@tonic-gate 
32307c478bd9Sstevel@tonic-gate 	vprint(REMOVE_MID, "%schecking %s if empty\n", fcn, pathname);
32317c478bd9Sstevel@tonic-gate 
32327c478bd9Sstevel@tonic-gate 	(void) strcpy(path, pathname);
32337c478bd9Sstevel@tonic-gate 
32347c478bd9Sstevel@tonic-gate 	/*
32357c478bd9Sstevel@tonic-gate 	 * ascend up the dir tree, deleting all empty dirs.
32367c478bd9Sstevel@tonic-gate 	 * Return immediately if a dir is not empty.
32377c478bd9Sstevel@tonic-gate 	 */
32387c478bd9Sstevel@tonic-gate 	for (;;) {
32397c478bd9Sstevel@tonic-gate 
32407c478bd9Sstevel@tonic-gate 		if ((ptr = strrchr(path, '/')) == NULL) {
32417c478bd9Sstevel@tonic-gate 			return;
32427c478bd9Sstevel@tonic-gate 		}
32437c478bd9Sstevel@tonic-gate 
32447c478bd9Sstevel@tonic-gate 		*ptr = '\0';
32457c478bd9Sstevel@tonic-gate 
3246e37c6c37Scth 		if (finddev_emptydir(path)) {
3247e37c6c37Scth 			/* directory is empty */
3248facf4a8dSllai 			if (s_rmdir(path) == 0) {
3249facf4a8dSllai 				vprint(REMOVE_MID,
3250facf4a8dSllai 				    "%sremoving empty dir %s\n", fcn, path);
3251facf4a8dSllai 			} else if (errno == EEXIST) {
3252facf4a8dSllai 				vprint(REMOVE_MID,
3253facf4a8dSllai 				    "%sfailed to remove dir: %s\n", fcn, path);
3254facf4a8dSllai 				return;
3255facf4a8dSllai 			}
3256facf4a8dSllai 		} else {
3257facf4a8dSllai 			/* some other file is here, so return */
32587c478bd9Sstevel@tonic-gate 			vprint(REMOVE_MID, "%sdir not empty: %s\n", fcn, path);
32597c478bd9Sstevel@tonic-gate 			return;
32607c478bd9Sstevel@tonic-gate 		}
32617c478bd9Sstevel@tonic-gate 	}
32627c478bd9Sstevel@tonic-gate }
32637c478bd9Sstevel@tonic-gate 
32647c478bd9Sstevel@tonic-gate /*
32657c478bd9Sstevel@tonic-gate  * This function and all the functions it calls below were added to
32667c478bd9Sstevel@tonic-gate  * handle the unique problem with world wide names (WWN).  The problem is
32677c478bd9Sstevel@tonic-gate  * that if a WWN device is moved to another address on the same controller
32687c478bd9Sstevel@tonic-gate  * its logical link will change, while the physical node remains the same.
32697c478bd9Sstevel@tonic-gate  * The result is that two logical links will point to the same physical path
32707c478bd9Sstevel@tonic-gate  * in /devices, the valid link and a stale link. This function will
32717c478bd9Sstevel@tonic-gate  * find all the stale nodes, though at a significant performance cost.
32727c478bd9Sstevel@tonic-gate  *
32737c478bd9Sstevel@tonic-gate  * Caching is used to increase performance.
32747c478bd9Sstevel@tonic-gate  * A cache will be built from disk if the cache tag doesn't already exist.
32757c478bd9Sstevel@tonic-gate  * The cache tag is a regular expression "dir_re", which selects a
32767c478bd9Sstevel@tonic-gate  * subset of disks to search from typically something like
32777c478bd9Sstevel@tonic-gate  * "dev/cXt[0-9]+d[0-9]+s[0-9]+".  After the cache is built, consistency must
32787c478bd9Sstevel@tonic-gate  * be maintained, so entries are added as new links are created, and removed
32797c478bd9Sstevel@tonic-gate  * as old links are deleted.  The whole cache is flushed if we are a daemon,
32807c478bd9Sstevel@tonic-gate  * and another devfsadm process ran in between.
32817c478bd9Sstevel@tonic-gate  *
32827c478bd9Sstevel@tonic-gate  * Once the cache is built, this function finds the cache which matches
32837c478bd9Sstevel@tonic-gate  * dir_re, and then it searches all links in that cache looking for
32847c478bd9Sstevel@tonic-gate  * any link whose contents match "valid_link_contents" with a corresponding link
32857c478bd9Sstevel@tonic-gate  * which does not match "valid_link".  Any such matches are stale and removed.
328694c894bbSVikram Hegde  *
328794c894bbSVikram Hegde  * This happens outside the context of a "reparenting" so we dont need
328894c894bbSVikram Hegde  * redirection.
32897c478bd9Sstevel@tonic-gate  */
32907c478bd9Sstevel@tonic-gate void
32917c478bd9Sstevel@tonic-gate devfsadm_rm_stale_links(char *dir_re, char *valid_link, di_node_t node,
32927c478bd9Sstevel@tonic-gate 			di_minor_t minor)
32937c478bd9Sstevel@tonic-gate {
32947c478bd9Sstevel@tonic-gate 	link_t *link;
32957c478bd9Sstevel@tonic-gate 	linkhead_t *head;
32967c478bd9Sstevel@tonic-gate 	char phy_path[PATH_MAX + 1];
32977c478bd9Sstevel@tonic-gate 	char *valid_link_contents;
32987c478bd9Sstevel@tonic-gate 	char *dev_path;
32997c478bd9Sstevel@tonic-gate 	char rmlink[PATH_MAX + 1];
33007c478bd9Sstevel@tonic-gate 
33017c478bd9Sstevel@tonic-gate 	/*
33027c478bd9Sstevel@tonic-gate 	 * try to use devices path
33037c478bd9Sstevel@tonic-gate 	 */
33047c478bd9Sstevel@tonic-gate 	if ((node == lnode) && (minor == lminor)) {
33057c478bd9Sstevel@tonic-gate 		valid_link_contents = lphy_path;
33067c478bd9Sstevel@tonic-gate 	} else {
33077c478bd9Sstevel@tonic-gate 		if ((dev_path = di_devfs_path(node)) == NULL) {
33087c478bd9Sstevel@tonic-gate 			err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
33097c478bd9Sstevel@tonic-gate 			devfsadm_exit(1);
3310537714daSvikram 			/*NOTREACHED*/
33117c478bd9Sstevel@tonic-gate 		}
33127c478bd9Sstevel@tonic-gate 		(void) strcpy(phy_path, dev_path);
33137c478bd9Sstevel@tonic-gate 		di_devfs_path_free(dev_path);
33147c478bd9Sstevel@tonic-gate 
33157c478bd9Sstevel@tonic-gate 		(void) strcat(phy_path, ":");
33167c478bd9Sstevel@tonic-gate 		(void) strcat(phy_path, di_minor_name(minor));
33177c478bd9Sstevel@tonic-gate 		valid_link_contents = phy_path;
33187c478bd9Sstevel@tonic-gate 	}
33197c478bd9Sstevel@tonic-gate 
33207c478bd9Sstevel@tonic-gate 	/*
33217c478bd9Sstevel@tonic-gate 	 * As an optimization, check to make sure the corresponding
33227c478bd9Sstevel@tonic-gate 	 * devlink was just created before continuing.
33237c478bd9Sstevel@tonic-gate 	 */
33247c478bd9Sstevel@tonic-gate 
33257c478bd9Sstevel@tonic-gate 	if (linknew == FALSE) {
33267c478bd9Sstevel@tonic-gate 		return;
33277c478bd9Sstevel@tonic-gate 	}
33287c478bd9Sstevel@tonic-gate 
33297c478bd9Sstevel@tonic-gate 	head = get_cached_links(dir_re);
33307c478bd9Sstevel@tonic-gate 
33317c478bd9Sstevel@tonic-gate 	assert(head->nextlink == NULL);
33327c478bd9Sstevel@tonic-gate 
33337c478bd9Sstevel@tonic-gate 	for (link = head->link; link != NULL; link = head->nextlink) {
33347c478bd9Sstevel@tonic-gate 		/*
33357c478bd9Sstevel@tonic-gate 		 * See hot_cleanup() for why we do this
33367c478bd9Sstevel@tonic-gate 		 */
33377c478bd9Sstevel@tonic-gate 		head->nextlink = link->next;
33387c478bd9Sstevel@tonic-gate 		if ((strcmp(link->contents, valid_link_contents) == 0) &&
33397c478bd9Sstevel@tonic-gate 		    (strcmp(link->devlink, valid_link) != 0)) {
33407c478bd9Sstevel@tonic-gate 			vprint(CHATTY_MID, "removing %s -> %s\n"
33410a653502Swroche 			    "valid link is: %s -> %s\n",
33420a653502Swroche 			    link->devlink, link->contents,
33430a653502Swroche 			    valid_link, valid_link_contents);
33447c478bd9Sstevel@tonic-gate 			/*
33457c478bd9Sstevel@tonic-gate 			 * Use a copy of the cached link name as the
33467c478bd9Sstevel@tonic-gate 			 * cache entry will go away during link removal
33477c478bd9Sstevel@tonic-gate 			 */
33487c478bd9Sstevel@tonic-gate 			(void) snprintf(rmlink, sizeof (rmlink), "%s",
33497c478bd9Sstevel@tonic-gate 			    link->devlink);
33507c478bd9Sstevel@tonic-gate 			devfsadm_rm_link(rmlink);
33517c478bd9Sstevel@tonic-gate 		}
33527c478bd9Sstevel@tonic-gate 	}
33537c478bd9Sstevel@tonic-gate }
33547c478bd9Sstevel@tonic-gate 
33557c478bd9Sstevel@tonic-gate /*
33567c478bd9Sstevel@tonic-gate  * Return previously created cache, or create cache.
33577c478bd9Sstevel@tonic-gate  */
33587c478bd9Sstevel@tonic-gate static linkhead_t *
33597c478bd9Sstevel@tonic-gate get_cached_links(char *dir_re)
33607c478bd9Sstevel@tonic-gate {
33617c478bd9Sstevel@tonic-gate 	recurse_dev_t rd;
33627c478bd9Sstevel@tonic-gate 	linkhead_t *linkhead;
33637c478bd9Sstevel@tonic-gate 	int n;
33647c478bd9Sstevel@tonic-gate 
33657c478bd9Sstevel@tonic-gate 	vprint(BUILDCACHE_MID, "get_cached_links: %s\n", dir_re);
33667c478bd9Sstevel@tonic-gate 
33677c478bd9Sstevel@tonic-gate 	for (linkhead = headlinkhead; linkhead != NULL;
33680a653502Swroche 	    linkhead = linkhead->nexthead) {
33697c478bd9Sstevel@tonic-gate 		if (strcmp(linkhead->dir_re, dir_re) == 0) {
33707c478bd9Sstevel@tonic-gate 			return (linkhead);
33717c478bd9Sstevel@tonic-gate 		}
33727c478bd9Sstevel@tonic-gate 	}
33737c478bd9Sstevel@tonic-gate 
33747c478bd9Sstevel@tonic-gate 	/*
33757c478bd9Sstevel@tonic-gate 	 * This tag is not in cache, so add it, along with all its
33767c478bd9Sstevel@tonic-gate 	 * matching /dev entries.  This is the only time we go to disk.
33777c478bd9Sstevel@tonic-gate 	 */
33787c478bd9Sstevel@tonic-gate 	linkhead = s_malloc(sizeof (linkhead_t));
33797c478bd9Sstevel@tonic-gate 	linkhead->nexthead = headlinkhead;
33807c478bd9Sstevel@tonic-gate 	headlinkhead = linkhead;
33817c478bd9Sstevel@tonic-gate 	linkhead->dir_re = s_strdup(dir_re);
33827c478bd9Sstevel@tonic-gate 
33837c478bd9Sstevel@tonic-gate 	if ((n = regcomp(&(linkhead->dir_re_compiled), dir_re,
33840a653502Swroche 	    REG_EXTENDED)) != 0) {
33857c478bd9Sstevel@tonic-gate 		err_print(REGCOMP_FAILED,  dir_re, n);
33867c478bd9Sstevel@tonic-gate 	}
33877c478bd9Sstevel@tonic-gate 
33887c478bd9Sstevel@tonic-gate 	linkhead->nextlink = NULL;
33897c478bd9Sstevel@tonic-gate 	linkhead->link = NULL;
33907c478bd9Sstevel@tonic-gate 
33917c478bd9Sstevel@tonic-gate 	rd.fcn = build_devlink_list;
33927c478bd9Sstevel@tonic-gate 	rd.data = (void *)linkhead;
33937c478bd9Sstevel@tonic-gate 
33947c478bd9Sstevel@tonic-gate 	vprint(BUILDCACHE_MID, "get_cached_links: calling recurse_dev_re\n");
33957c478bd9Sstevel@tonic-gate 
33967c478bd9Sstevel@tonic-gate 	/* call build_devlink_list for each directory in the dir_re RE */
33977c478bd9Sstevel@tonic-gate 	if (dir_re[0] == '/') {
33987c478bd9Sstevel@tonic-gate 		recurse_dev_re("/", &dir_re[1], &rd);
33997c478bd9Sstevel@tonic-gate 	} else {
34007c478bd9Sstevel@tonic-gate 		recurse_dev_re(dev_dir, dir_re, &rd);
34017c478bd9Sstevel@tonic-gate 	}
34027c478bd9Sstevel@tonic-gate 
34037c478bd9Sstevel@tonic-gate 	return (linkhead);
34047c478bd9Sstevel@tonic-gate }
34057c478bd9Sstevel@tonic-gate 
34067c478bd9Sstevel@tonic-gate static void
34077c478bd9Sstevel@tonic-gate build_devlink_list(char *devlink, void *data)
34087c478bd9Sstevel@tonic-gate {
34097c478bd9Sstevel@tonic-gate 	char *fcn = "build_devlink_list: ";
34107c478bd9Sstevel@tonic-gate 	char *ptr;
34117c478bd9Sstevel@tonic-gate 	char *r_contents;
34127c478bd9Sstevel@tonic-gate 	char *r_devlink;
34137c478bd9Sstevel@tonic-gate 	char contents[PATH_MAX + 1];
34147c478bd9Sstevel@tonic-gate 	char newlink[PATH_MAX + 1];
34157c478bd9Sstevel@tonic-gate 	char stage_link[PATH_MAX + 1];
34167c478bd9Sstevel@tonic-gate 	int linksize;
34177c478bd9Sstevel@tonic-gate 	linkhead_t *linkhead = (linkhead_t *)data;
34187c478bd9Sstevel@tonic-gate 	link_t *link;
34197c478bd9Sstevel@tonic-gate 	int i = 0;
34207c478bd9Sstevel@tonic-gate 
34217c478bd9Sstevel@tonic-gate 	vprint(BUILDCACHE_MID, "%scheck_link: %s\n", fcn, devlink);
34227c478bd9Sstevel@tonic-gate 
34237c478bd9Sstevel@tonic-gate 	(void) strcpy(newlink, devlink);
34247c478bd9Sstevel@tonic-gate 
34257c478bd9Sstevel@tonic-gate 	do {
342694c894bbSVikram Hegde 		/*
342794c894bbSVikram Hegde 		 * None of the consumers of this function need redirection
342894c894bbSVikram Hegde 		 * so this readlink gets the "current" contents
342994c894bbSVikram Hegde 		 */
34307c478bd9Sstevel@tonic-gate 		linksize = readlink(newlink, contents, PATH_MAX);
34317c478bd9Sstevel@tonic-gate 		if (linksize <= 0) {
34327c478bd9Sstevel@tonic-gate 			/*
34337c478bd9Sstevel@tonic-gate 			 * The first pass through the do loop we may readlink()
34347c478bd9Sstevel@tonic-gate 			 * non-symlink files(EINVAL) from false regexec matches.
34357c478bd9Sstevel@tonic-gate 			 * Suppress error messages in those cases or if the link
34367c478bd9Sstevel@tonic-gate 			 * content is the empty string.
34377c478bd9Sstevel@tonic-gate 			 */
34387c478bd9Sstevel@tonic-gate 			if (linksize < 0 && (i || errno != EINVAL))
34397c478bd9Sstevel@tonic-gate 				err_print(READLINK_FAILED, "build_devlink_list",
34407c478bd9Sstevel@tonic-gate 				    newlink, strerror(errno));
34417c478bd9Sstevel@tonic-gate 			return;
34427c478bd9Sstevel@tonic-gate 		}
34437c478bd9Sstevel@tonic-gate 		contents[linksize] = '\0';
34447c478bd9Sstevel@tonic-gate 		i = 1;
34457c478bd9Sstevel@tonic-gate 
34467c478bd9Sstevel@tonic-gate 		if (is_minor_node(contents, &r_contents) == DEVFSADM_FALSE) {
34477c478bd9Sstevel@tonic-gate 			/*
34487c478bd9Sstevel@tonic-gate 			 * assume that link contents is really a pointer to
34497c478bd9Sstevel@tonic-gate 			 * another link, so recurse and read its link contents.
34507c478bd9Sstevel@tonic-gate 			 *
34517c478bd9Sstevel@tonic-gate 			 * some link contents are absolute:
34527c478bd9Sstevel@tonic-gate 			 *	/dev/audio -> /dev/sound/0
34537c478bd9Sstevel@tonic-gate 			 */
34547c478bd9Sstevel@tonic-gate 			if (strncmp(contents, DEV "/",
34550a653502Swroche 			    strlen(DEV) + strlen("/")) != 0) {
34567c478bd9Sstevel@tonic-gate 
34577c478bd9Sstevel@tonic-gate 				if ((ptr = strrchr(newlink, '/')) == NULL) {
34587c478bd9Sstevel@tonic-gate 					vprint(REMOVE_MID, "%s%s -> %s invalid "
34590a653502Swroche 					    "link. missing '/'\n", fcn,
34600a653502Swroche 					    newlink, contents);
34610a653502Swroche 					return;
34627c478bd9Sstevel@tonic-gate 				}
34637c478bd9Sstevel@tonic-gate 				*ptr = '\0';
34647c478bd9Sstevel@tonic-gate 				(void) strcpy(stage_link, newlink);
34657c478bd9Sstevel@tonic-gate 				*ptr = '/';
34667c478bd9Sstevel@tonic-gate 				(void) strcat(stage_link, "/");
34677c478bd9Sstevel@tonic-gate 				(void) strcat(stage_link, contents);
34687c478bd9Sstevel@tonic-gate 				(void) strcpy(newlink, stage_link);
34697c478bd9Sstevel@tonic-gate 			} else {
34707c478bd9Sstevel@tonic-gate 				(void) strcpy(newlink, dev_dir);
34717c478bd9Sstevel@tonic-gate 				(void) strcat(newlink, "/");
34727c478bd9Sstevel@tonic-gate 				(void) strcat(newlink,
34730a653502Swroche 				    &contents[strlen(DEV) + strlen("/")]);
34747c478bd9Sstevel@tonic-gate 			}
34757c478bd9Sstevel@tonic-gate 
34767c478bd9Sstevel@tonic-gate 		} else {
34777c478bd9Sstevel@tonic-gate 			newlink[0] = '\0';
34787c478bd9Sstevel@tonic-gate 		}
34797c478bd9Sstevel@tonic-gate 	} while (newlink[0] != '\0');
34807c478bd9Sstevel@tonic-gate 
34817c478bd9Sstevel@tonic-gate 	if (strncmp(devlink, dev_dir, strlen(dev_dir)) != 0) {
34827c478bd9Sstevel@tonic-gate 		vprint(BUILDCACHE_MID, "%sinvalid link: %s\n", fcn, devlink);
34837c478bd9Sstevel@tonic-gate 		return;
34847c478bd9Sstevel@tonic-gate 	}
34857c478bd9Sstevel@tonic-gate 
34867c478bd9Sstevel@tonic-gate 	r_devlink = devlink + strlen(dev_dir);
34877c478bd9Sstevel@tonic-gate 
34887c478bd9Sstevel@tonic-gate 	if (r_devlink[0] != '/')
34897c478bd9Sstevel@tonic-gate 		return;
34907c478bd9Sstevel@tonic-gate 
34917c478bd9Sstevel@tonic-gate 	link = s_malloc(sizeof (link_t));
34927c478bd9Sstevel@tonic-gate 
34937c478bd9Sstevel@tonic-gate 	/* don't store the '/' after rootdir/dev */
34947c478bd9Sstevel@tonic-gate 	r_devlink += 1;
34957c478bd9Sstevel@tonic-gate 
34967c478bd9Sstevel@tonic-gate 	vprint(BUILDCACHE_MID, "%scaching link: %s\n", fcn, r_devlink);
34977c478bd9Sstevel@tonic-gate 	link->devlink = s_strdup(r_devlink);
34987c478bd9Sstevel@tonic-gate 
34997c478bd9Sstevel@tonic-gate 	link->contents = s_strdup(r_contents);
35007c478bd9Sstevel@tonic-gate 
35017c478bd9Sstevel@tonic-gate 	link->next = linkhead->link;
35027c478bd9Sstevel@tonic-gate 	linkhead->link = link;
35037c478bd9Sstevel@tonic-gate }
35047c478bd9Sstevel@tonic-gate 
35057c478bd9Sstevel@tonic-gate /*
35067c478bd9Sstevel@tonic-gate  * to be consistent, devlink must not begin with / and must be
35077c478bd9Sstevel@tonic-gate  * relative to /dev/, whereas physpath must contain / and be
35087c478bd9Sstevel@tonic-gate  * relative to /devices.
35097c478bd9Sstevel@tonic-gate  */
35107c478bd9Sstevel@tonic-gate static void
35117c478bd9Sstevel@tonic-gate add_link_to_cache(char *devlink, char *physpath)
35127c478bd9Sstevel@tonic-gate {
35137c478bd9Sstevel@tonic-gate 	linkhead_t *linkhead;
35147c478bd9Sstevel@tonic-gate 	link_t *link;
35157c478bd9Sstevel@tonic-gate 	int added = 0;
35167c478bd9Sstevel@tonic-gate 
35177c478bd9Sstevel@tonic-gate 	if (file_mods == FALSE) {
35187c478bd9Sstevel@tonic-gate 		return;
35197c478bd9Sstevel@tonic-gate 	}
35207c478bd9Sstevel@tonic-gate 
35217c478bd9Sstevel@tonic-gate 	vprint(CACHE_MID, "add_link_to_cache: %s -> %s ",
35220a653502Swroche 	    devlink, physpath);
35237c478bd9Sstevel@tonic-gate 
35247c478bd9Sstevel@tonic-gate 	for (linkhead = headlinkhead; linkhead != NULL;
35250a653502Swroche 	    linkhead = linkhead->nexthead) {
35260a653502Swroche 		if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0)
35270a653502Swroche 		    == 0) {
35287c478bd9Sstevel@tonic-gate 			added++;
35297c478bd9Sstevel@tonic-gate 			link = s_malloc(sizeof (link_t));
35307c478bd9Sstevel@tonic-gate 			link->devlink = s_strdup(devlink);
35317c478bd9Sstevel@tonic-gate 			link->contents = s_strdup(physpath);
35327c478bd9Sstevel@tonic-gate 			link->next = linkhead->link;
35337c478bd9Sstevel@tonic-gate 			linkhead->link = link;
35347c478bd9Sstevel@tonic-gate 		}
35357c478bd9Sstevel@tonic-gate 	}
35367c478bd9Sstevel@tonic-gate 
35377c478bd9Sstevel@tonic-gate 	vprint(CACHE_MID,
35380a653502Swroche 	    " %d %s\n", added, added == 0 ? "NOT ADDED" : "ADDED");
35397c478bd9Sstevel@tonic-gate }
35407c478bd9Sstevel@tonic-gate 
35417c478bd9Sstevel@tonic-gate /*
35427c478bd9Sstevel@tonic-gate  * Remove devlink from cache.  Devlink must be relative to /dev/ and not start
35437c478bd9Sstevel@tonic-gate  * with /.
35447c478bd9Sstevel@tonic-gate  */
35457c478bd9Sstevel@tonic-gate static void
35467c478bd9Sstevel@tonic-gate rm_link_from_cache(char *devlink)
35477c478bd9Sstevel@tonic-gate {
35487c478bd9Sstevel@tonic-gate 	linkhead_t *linkhead;
35497c478bd9Sstevel@tonic-gate 	link_t **linkp;
35507c478bd9Sstevel@tonic-gate 	link_t *save;
35517c478bd9Sstevel@tonic-gate 
35527c478bd9Sstevel@tonic-gate 	vprint(CACHE_MID, "rm_link_from_cache enter: %s\n", devlink);
35537c478bd9Sstevel@tonic-gate 
35547c478bd9Sstevel@tonic-gate 	for (linkhead = headlinkhead; linkhead != NULL;
35557c478bd9Sstevel@tonic-gate 	    linkhead = linkhead->nexthead) {
35560a653502Swroche 		if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0)
35570a653502Swroche 		    == 0) {
35587c478bd9Sstevel@tonic-gate 
35597c478bd9Sstevel@tonic-gate 			for (linkp = &(linkhead->link); *linkp != NULL; ) {
35607c478bd9Sstevel@tonic-gate 				if ((strcmp((*linkp)->devlink, devlink) == 0)) {
35617c478bd9Sstevel@tonic-gate 					save = *linkp;
35627c478bd9Sstevel@tonic-gate 					*linkp = (*linkp)->next;
35637c478bd9Sstevel@tonic-gate 					/*
35647c478bd9Sstevel@tonic-gate 					 * We are removing our caller's
35657c478bd9Sstevel@tonic-gate 					 * "next" link. Update the nextlink
35667c478bd9Sstevel@tonic-gate 					 * field in the head so that our
35677c478bd9Sstevel@tonic-gate 					 * callers accesses the next valid
35687c478bd9Sstevel@tonic-gate 					 * link
35697c478bd9Sstevel@tonic-gate 					 */
35707c478bd9Sstevel@tonic-gate 					if (linkhead->nextlink == save)
35717c478bd9Sstevel@tonic-gate 						linkhead->nextlink = *linkp;
35727c478bd9Sstevel@tonic-gate 					free(save->devlink);
35737c478bd9Sstevel@tonic-gate 					free(save->contents);
35747c478bd9Sstevel@tonic-gate 					free(save);
35757c478bd9Sstevel@tonic-gate 					vprint(CACHE_MID, " %s FREED FROM "
35760a653502Swroche 					    "CACHE\n", devlink);
35777c478bd9Sstevel@tonic-gate 				} else {
35787c478bd9Sstevel@tonic-gate 					linkp = &((*linkp)->next);
35797c478bd9Sstevel@tonic-gate 				}
35807c478bd9Sstevel@tonic-gate 			}
35817c478bd9Sstevel@tonic-gate 		}
35827c478bd9Sstevel@tonic-gate 	}
35837c478bd9Sstevel@tonic-gate }
35847c478bd9Sstevel@tonic-gate 
35857c478bd9Sstevel@tonic-gate static void
35867c478bd9Sstevel@tonic-gate rm_all_links_from_cache()
35877c478bd9Sstevel@tonic-gate {
35887c478bd9Sstevel@tonic-gate 	linkhead_t *linkhead;
35897c478bd9Sstevel@tonic-gate 	linkhead_t *nextlinkhead;
35907c478bd9Sstevel@tonic-gate 	link_t *link;
35917c478bd9Sstevel@tonic-gate 	link_t *nextlink;
35927c478bd9Sstevel@tonic-gate 
35937c478bd9Sstevel@tonic-gate 	vprint(CACHE_MID, "rm_all_links_from_cache\n");
35947c478bd9Sstevel@tonic-gate 
35957c478bd9Sstevel@tonic-gate 	for (linkhead = headlinkhead; linkhead != NULL;
35960a653502Swroche 	    linkhead = nextlinkhead) {
35977c478bd9Sstevel@tonic-gate 
35987c478bd9Sstevel@tonic-gate 		nextlinkhead = linkhead->nexthead;
35997c478bd9Sstevel@tonic-gate 		assert(linkhead->nextlink == NULL);
36007c478bd9Sstevel@tonic-gate 		for (link = linkhead->link; link != NULL; link = nextlink) {
36017c478bd9Sstevel@tonic-gate 			nextlink = link->next;
36027c478bd9Sstevel@tonic-gate 			free(link->devlink);
36037c478bd9Sstevel@tonic-gate 			free(link->contents);
36047c478bd9Sstevel@tonic-gate 			free(link);
36057c478bd9Sstevel@tonic-gate 		}
36067c478bd9Sstevel@tonic-gate 		regfree(&(linkhead->dir_re_compiled));
36077c478bd9Sstevel@tonic-gate 		free(linkhead->dir_re);
36087c478bd9Sstevel@tonic-gate 		free(linkhead);
36097c478bd9Sstevel@tonic-gate 	}
36107c478bd9Sstevel@tonic-gate 	headlinkhead = NULL;
36117c478bd9Sstevel@tonic-gate }
36127c478bd9Sstevel@tonic-gate 
36137c478bd9Sstevel@tonic-gate /*
36147c478bd9Sstevel@tonic-gate  * Called when the kernel has modified the incore path_to_inst data.  This
36157c478bd9Sstevel@tonic-gate  * function will schedule a flush of the data to the filesystem.
36167c478bd9Sstevel@tonic-gate  */
36177c478bd9Sstevel@tonic-gate static void
36187c478bd9Sstevel@tonic-gate devfs_instance_mod(void)
36197c478bd9Sstevel@tonic-gate {
36207c478bd9Sstevel@tonic-gate 	char *fcn = "devfs_instance_mod: ";
36217c478bd9Sstevel@tonic-gate 	vprint(PATH2INST_MID, "%senter\n", fcn);
36227c478bd9Sstevel@tonic-gate 
36237c478bd9Sstevel@tonic-gate 	/* signal instance thread */
36247c478bd9Sstevel@tonic-gate 	(void) mutex_lock(&count_lock);
36257c478bd9Sstevel@tonic-gate 	inst_count++;
36267c478bd9Sstevel@tonic-gate 	(void) cond_signal(&cv);
36277c478bd9Sstevel@tonic-gate 	(void) mutex_unlock(&count_lock);
36287c478bd9Sstevel@tonic-gate }
36297c478bd9Sstevel@tonic-gate 
36307c478bd9Sstevel@tonic-gate static void
36317c478bd9Sstevel@tonic-gate instance_flush_thread(void)
36327c478bd9Sstevel@tonic-gate {
36337c478bd9Sstevel@tonic-gate 	int i;
36347c478bd9Sstevel@tonic-gate 	int idle;
36357c478bd9Sstevel@tonic-gate 
36367c478bd9Sstevel@tonic-gate 	for (;;) {
36377c478bd9Sstevel@tonic-gate 
36387c478bd9Sstevel@tonic-gate 		(void) mutex_lock(&count_lock);
36397c478bd9Sstevel@tonic-gate 		while (inst_count == 0) {
36407c478bd9Sstevel@tonic-gate 			(void) cond_wait(&cv, &count_lock);
36417c478bd9Sstevel@tonic-gate 		}
36427c478bd9Sstevel@tonic-gate 		inst_count = 0;
36437c478bd9Sstevel@tonic-gate 
36447c478bd9Sstevel@tonic-gate 		vprint(PATH2INST_MID, "signaled to flush path_to_inst."
36450a653502Swroche 		    " Enter delay loop\n");
36467c478bd9Sstevel@tonic-gate 		/*
36477c478bd9Sstevel@tonic-gate 		 * Wait MAX_IDLE_DELAY seconds after getting the last flush
36487c478bd9Sstevel@tonic-gate 		 * path_to_inst event before invoking a flush, but never wait
36497c478bd9Sstevel@tonic-gate 		 * more than MAX_DELAY seconds after getting the first event.
36507c478bd9Sstevel@tonic-gate 		 */
36517c478bd9Sstevel@tonic-gate 		for (idle = 0, i = 0; i < MAX_DELAY; i++) {
36527c478bd9Sstevel@tonic-gate 
36537c478bd9Sstevel@tonic-gate 			(void) mutex_unlock(&count_lock);
36547c478bd9Sstevel@tonic-gate 			(void) sleep(1);
36557c478bd9Sstevel@tonic-gate 			(void) mutex_lock(&count_lock);
36567c478bd9Sstevel@tonic-gate 
36577c478bd9Sstevel@tonic-gate 			/* shorten the delay if we are idle */
36587c478bd9Sstevel@tonic-gate 			if (inst_count == 0) {
36597c478bd9Sstevel@tonic-gate 				idle++;
36607c478bd9Sstevel@tonic-gate 				if (idle > MAX_IDLE_DELAY) {
36617c478bd9Sstevel@tonic-gate 					break;
36627c478bd9Sstevel@tonic-gate 				}
36637c478bd9Sstevel@tonic-gate 			} else {
36647c478bd9Sstevel@tonic-gate 				inst_count = idle = 0;
36657c478bd9Sstevel@tonic-gate 			}
36667c478bd9Sstevel@tonic-gate 		}
36677c478bd9Sstevel@tonic-gate 
36687c478bd9Sstevel@tonic-gate 		(void) mutex_unlock(&count_lock);
36697c478bd9Sstevel@tonic-gate 
36707c478bd9Sstevel@tonic-gate 		flush_path_to_inst();
36717c478bd9Sstevel@tonic-gate 	}
36727c478bd9Sstevel@tonic-gate }
36737c478bd9Sstevel@tonic-gate 
36747c478bd9Sstevel@tonic-gate /*
36757c478bd9Sstevel@tonic-gate  * Helper function for flush_path_to_inst() below; this routine calls the
36767c478bd9Sstevel@tonic-gate  * inst_sync syscall to flush the path_to_inst database to the given file.
36777c478bd9Sstevel@tonic-gate  */
36787c478bd9Sstevel@tonic-gate static int
36790a653502Swroche do_inst_sync(char *filename, char *instfilename)
36807c478bd9Sstevel@tonic-gate {
36817c478bd9Sstevel@tonic-gate 	void (*sigsaved)(int);
36820a653502Swroche 	int err = 0, flags = INST_SYNC_IF_REQUIRED;
36830a653502Swroche 	struct stat sb;
36840a653502Swroche 
36850a653502Swroche 	if (stat(instfilename, &sb) == -1 && errno == ENOENT)
36860a653502Swroche 		flags = INST_SYNC_ALWAYS;
36877c478bd9Sstevel@tonic-gate 
36887c478bd9Sstevel@tonic-gate 	vprint(INSTSYNC_MID, "do_inst_sync: about to flush %s\n", filename);
36897c478bd9Sstevel@tonic-gate 	sigsaved = sigset(SIGSYS, SIG_IGN);
36900a653502Swroche 	if (inst_sync(filename, flags) == -1)
36917c478bd9Sstevel@tonic-gate 		err = errno;
36927c478bd9Sstevel@tonic-gate 	(void) sigset(SIGSYS, sigsaved);
36937c478bd9Sstevel@tonic-gate 
36947c478bd9Sstevel@tonic-gate 	switch (err) {
36957c478bd9Sstevel@tonic-gate 	case 0:
36967c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
36977c478bd9Sstevel@tonic-gate 	case EALREADY:	/* no-op, path_to_inst already up to date */
36987c478bd9Sstevel@tonic-gate 		return (EALREADY);
36997c478bd9Sstevel@tonic-gate 	case ENOSYS:
37007c478bd9Sstevel@tonic-gate 		err_print(CANT_LOAD_SYSCALL);
37017c478bd9Sstevel@tonic-gate 		break;
37027c478bd9Sstevel@tonic-gate 	case EPERM:
37037c478bd9Sstevel@tonic-gate 		err_print(SUPER_TO_SYNC);
37047c478bd9Sstevel@tonic-gate 		break;
37057c478bd9Sstevel@tonic-gate 	default:
37067c478bd9Sstevel@tonic-gate 		err_print(INSTSYNC_FAILED, filename, strerror(err));
37077c478bd9Sstevel@tonic-gate 		break;
37087c478bd9Sstevel@tonic-gate 	}
37097c478bd9Sstevel@tonic-gate 	return (DEVFSADM_FAILURE);
37107c478bd9Sstevel@tonic-gate }
37117c478bd9Sstevel@tonic-gate 
37127c478bd9Sstevel@tonic-gate /*
37137c478bd9Sstevel@tonic-gate  * Flush the kernel's path_to_inst database to /etc/path_to_inst.  To do so
37147c478bd9Sstevel@tonic-gate  * safely, the database is flushed to a temporary file, then moved into place.
37157c478bd9Sstevel@tonic-gate  *
37167c478bd9Sstevel@tonic-gate  * The following files are used during this process:
37177c478bd9Sstevel@tonic-gate  * 	/etc/path_to_inst:	The path_to_inst file
37187c478bd9Sstevel@tonic-gate  * 	/etc/path_to_inst.<pid>: Contains data flushed from the kernel
37197c478bd9Sstevel@tonic-gate  * 	/etc/path_to_inst.old:  The backup file
37207c478bd9Sstevel@tonic-gate  * 	/etc/path_to_inst.old.<pid>: Temp file for creating backup
37217c478bd9Sstevel@tonic-gate  *
37227c478bd9Sstevel@tonic-gate  */
37237c478bd9Sstevel@tonic-gate static void
37247c478bd9Sstevel@tonic-gate flush_path_to_inst(void)
37257c478bd9Sstevel@tonic-gate {
37267c478bd9Sstevel@tonic-gate 	char *new_inst_file = NULL;
37277c478bd9Sstevel@tonic-gate 	char *old_inst_file = NULL;
37287c478bd9Sstevel@tonic-gate 	char *old_inst_file_npid = NULL;
37297c478bd9Sstevel@tonic-gate 	FILE *inst_file_fp = NULL;
37307c478bd9Sstevel@tonic-gate 	FILE *old_inst_file_fp = NULL;
37317c478bd9Sstevel@tonic-gate 	struct stat sb;
37327c478bd9Sstevel@tonic-gate 	int err = 0;
37337c478bd9Sstevel@tonic-gate 	int c;
37347c478bd9Sstevel@tonic-gate 	int inst_strlen;
37357c478bd9Sstevel@tonic-gate 
37367c478bd9Sstevel@tonic-gate 	vprint(PATH2INST_MID, "flush_path_to_inst: %s\n",
37377c478bd9Sstevel@tonic-gate 	    (flush_path_to_inst_enable == TRUE) ? "ENABLED" : "DISABLED");
37387c478bd9Sstevel@tonic-gate 
37397c478bd9Sstevel@tonic-gate 	if (flush_path_to_inst_enable == FALSE) {
37407c478bd9Sstevel@tonic-gate 		return;
37417c478bd9Sstevel@tonic-gate 	}
37427c478bd9Sstevel@tonic-gate 
37437c478bd9Sstevel@tonic-gate 	inst_strlen = strlen(inst_file);
37447c478bd9Sstevel@tonic-gate 	new_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 2);
37457c478bd9Sstevel@tonic-gate 	old_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 6);
37467c478bd9Sstevel@tonic-gate 	old_inst_file_npid = s_malloc(inst_strlen +
37477c478bd9Sstevel@tonic-gate 	    sizeof (INSTANCE_FILE_SUFFIX));
37487c478bd9Sstevel@tonic-gate 
37497c478bd9Sstevel@tonic-gate 	(void) snprintf(new_inst_file, inst_strlen + PID_STR_LEN + 2,
37500a653502Swroche 	    "%s.%ld", inst_file, getpid());
37517c478bd9Sstevel@tonic-gate 
37527c478bd9Sstevel@tonic-gate 	if (stat(new_inst_file, &sb) == 0) {
37537c478bd9Sstevel@tonic-gate 		s_unlink(new_inst_file);
37547c478bd9Sstevel@tonic-gate 	}
37557c478bd9Sstevel@tonic-gate 
37560a653502Swroche 	err = do_inst_sync(new_inst_file, inst_file);
37570a653502Swroche 	if (err != DEVFSADM_SUCCESS) {
37587c478bd9Sstevel@tonic-gate 		goto out;
37597c478bd9Sstevel@tonic-gate 		/*NOTREACHED*/
37607c478bd9Sstevel@tonic-gate 	}
37617c478bd9Sstevel@tonic-gate 
37627c478bd9Sstevel@tonic-gate 	/*
37637c478bd9Sstevel@tonic-gate 	 * Now we deal with the somewhat tricky updating and renaming
37647c478bd9Sstevel@tonic-gate 	 * of this critical piece of kernel state.
37657c478bd9Sstevel@tonic-gate 	 */
37667c478bd9Sstevel@tonic-gate 
37677c478bd9Sstevel@tonic-gate 	/*
37687c478bd9Sstevel@tonic-gate 	 * Copy the current instance file into a temporary file.
37697c478bd9Sstevel@tonic-gate 	 * Then rename the temporary file into the backup (.old)
37707c478bd9Sstevel@tonic-gate 	 * file and rename the newly flushed kernel data into
37717c478bd9Sstevel@tonic-gate 	 * the instance file.
37727c478bd9Sstevel@tonic-gate 	 * Of course if 'inst_file' doesn't exist, there's much
37737c478bd9Sstevel@tonic-gate 	 * less for us to do .. tee hee.
37747c478bd9Sstevel@tonic-gate 	 */
37757c478bd9Sstevel@tonic-gate 	if ((inst_file_fp = fopen(inst_file, "r")) == NULL) {
37767c478bd9Sstevel@tonic-gate 		/*
37777c478bd9Sstevel@tonic-gate 		 * No such file.  Rename the new onto the old
37787c478bd9Sstevel@tonic-gate 		 */
37797c478bd9Sstevel@tonic-gate 		if ((err = rename(new_inst_file, inst_file)) != 0)
37807c478bd9Sstevel@tonic-gate 			err_print(RENAME_FAILED, inst_file, strerror(errno));
37817c478bd9Sstevel@tonic-gate 		goto out;
37827c478bd9Sstevel@tonic-gate 		/*NOTREACHED*/
37837c478bd9Sstevel@tonic-gate 	}
37847c478bd9Sstevel@tonic-gate 
37857c478bd9Sstevel@tonic-gate 	(void) snprintf(old_inst_file, inst_strlen + PID_STR_LEN + 6,
37860a653502Swroche 	    "%s.old.%ld", inst_file, getpid());
37877c478bd9Sstevel@tonic-gate 
37887c478bd9Sstevel@tonic-gate 	if (stat(old_inst_file, &sb) == 0) {
37897c478bd9Sstevel@tonic-gate 		s_unlink(old_inst_file);
37907c478bd9Sstevel@tonic-gate 	}
37917c478bd9Sstevel@tonic-gate 
37927c478bd9Sstevel@tonic-gate 	if ((old_inst_file_fp = fopen(old_inst_file, "w")) == NULL) {
37937c478bd9Sstevel@tonic-gate 		/*
37947c478bd9Sstevel@tonic-gate 		 * Can't open the 'old_inst_file' file for writing.
37957c478bd9Sstevel@tonic-gate 		 * This is somewhat strange given that the syscall
37967c478bd9Sstevel@tonic-gate 		 * just succeeded to write a file out.. hmm.. maybe
37977c478bd9Sstevel@tonic-gate 		 * the fs just filled up or something nasty.
37987c478bd9Sstevel@tonic-gate 		 *
37997c478bd9Sstevel@tonic-gate 		 * Anyway, abort what we've done so far.
38007c478bd9Sstevel@tonic-gate 		 */
38017c478bd9Sstevel@tonic-gate 		err_print(CANT_UPDATE, old_inst_file);
38027c478bd9Sstevel@tonic-gate 		err = DEVFSADM_FAILURE;
38037c478bd9Sstevel@tonic-gate 		goto out;
38047c478bd9Sstevel@tonic-gate 		/*NOTREACHED*/
38057c478bd9Sstevel@tonic-gate 	}
38067c478bd9Sstevel@tonic-gate 
38077c478bd9Sstevel@tonic-gate 	/*
38087c478bd9Sstevel@tonic-gate 	 * Copy current instance file into the temporary file
38097c478bd9Sstevel@tonic-gate 	 */
38107c478bd9Sstevel@tonic-gate 	err = 0;
38117c478bd9Sstevel@tonic-gate 	while ((c = getc(inst_file_fp)) != EOF) {
38127c478bd9Sstevel@tonic-gate 		if ((err = putc(c, old_inst_file_fp)) == EOF) {
38137c478bd9Sstevel@tonic-gate 			break;
38147c478bd9Sstevel@tonic-gate 		}
38157c478bd9Sstevel@tonic-gate 	}
38167c478bd9Sstevel@tonic-gate 
38177c478bd9Sstevel@tonic-gate 	if (fclose(old_inst_file_fp) == EOF || err == EOF) {
38187c478bd9Sstevel@tonic-gate 		vprint(INFO_MID, CANT_UPDATE, old_inst_file);
38197c478bd9Sstevel@tonic-gate 		err = DEVFSADM_FAILURE;
38207c478bd9Sstevel@tonic-gate 		goto out;
38217c478bd9Sstevel@tonic-gate 		/* NOTREACHED */
38227c478bd9Sstevel@tonic-gate 	}
38237c478bd9Sstevel@tonic-gate 
38247c478bd9Sstevel@tonic-gate 	/*
38257c478bd9Sstevel@tonic-gate 	 * Set permissions to be the same on the backup as
38267c478bd9Sstevel@tonic-gate 	 * /etc/path_to_inst.
38277c478bd9Sstevel@tonic-gate 	 */
38287c478bd9Sstevel@tonic-gate 	(void) chmod(old_inst_file, 0444);
38297c478bd9Sstevel@tonic-gate 
38307c478bd9Sstevel@tonic-gate 	/*
38317c478bd9Sstevel@tonic-gate 	 * So far, everything we've done is more or less reversible.
38327c478bd9Sstevel@tonic-gate 	 * But now we're going to commit ourselves.
38337c478bd9Sstevel@tonic-gate 	 */
38347c478bd9Sstevel@tonic-gate 
38357c478bd9Sstevel@tonic-gate 	(void) snprintf(old_inst_file_npid,
38367c478bd9Sstevel@tonic-gate 	    inst_strlen + sizeof (INSTANCE_FILE_SUFFIX),
38377c478bd9Sstevel@tonic-gate 	    "%s%s", inst_file, INSTANCE_FILE_SUFFIX);
38387c478bd9Sstevel@tonic-gate 
38397c478bd9Sstevel@tonic-gate 	if ((err = rename(old_inst_file, old_inst_file_npid)) != 0) {
38407c478bd9Sstevel@tonic-gate 		err_print(RENAME_FAILED, old_inst_file_npid,
38410a653502Swroche 		    strerror(errno));
38427c478bd9Sstevel@tonic-gate 	} else if ((err = rename(new_inst_file, inst_file)) != 0) {
38437c478bd9Sstevel@tonic-gate 		err_print(RENAME_FAILED, inst_file, strerror(errno));
38447c478bd9Sstevel@tonic-gate 	}
38457c478bd9Sstevel@tonic-gate 
38467c478bd9Sstevel@tonic-gate out:
38477c478bd9Sstevel@tonic-gate 	if (inst_file_fp != NULL) {
38487c478bd9Sstevel@tonic-gate 		if (fclose(inst_file_fp) == EOF) {
38497c478bd9Sstevel@tonic-gate 			err_print(FCLOSE_FAILED, inst_file, strerror(errno));
38507c478bd9Sstevel@tonic-gate 		}
38517c478bd9Sstevel@tonic-gate 	}
38527c478bd9Sstevel@tonic-gate 
38537c478bd9Sstevel@tonic-gate 	if (stat(new_inst_file, &sb) == 0) {
38547c478bd9Sstevel@tonic-gate 		s_unlink(new_inst_file);
38557c478bd9Sstevel@tonic-gate 	}
38567c478bd9Sstevel@tonic-gate 	free(new_inst_file);
38577c478bd9Sstevel@tonic-gate 
38587c478bd9Sstevel@tonic-gate 	if (stat(old_inst_file, &sb) == 0) {
38597c478bd9Sstevel@tonic-gate 		s_unlink(old_inst_file);
38607c478bd9Sstevel@tonic-gate 	}
38617c478bd9Sstevel@tonic-gate 	free(old_inst_file);
38627c478bd9Sstevel@tonic-gate 
38637c478bd9Sstevel@tonic-gate 	free(old_inst_file_npid);
38647c478bd9Sstevel@tonic-gate 
38657c478bd9Sstevel@tonic-gate 	if (err != 0 && err != EALREADY) {
38667c478bd9Sstevel@tonic-gate 		err_print(FAILED_TO_UPDATE, inst_file);
38677c478bd9Sstevel@tonic-gate 	}
38687c478bd9Sstevel@tonic-gate }
38697c478bd9Sstevel@tonic-gate 
38707c478bd9Sstevel@tonic-gate /*
38717c478bd9Sstevel@tonic-gate  * detach from tty.  For daemon mode.
38727c478bd9Sstevel@tonic-gate  */
38737c478bd9Sstevel@tonic-gate void
38747c478bd9Sstevel@tonic-gate detachfromtty()
38757c478bd9Sstevel@tonic-gate {
38767c478bd9Sstevel@tonic-gate 	(void) setsid();
38777c478bd9Sstevel@tonic-gate 	if (DEVFSADM_DEBUG_ON == TRUE) {
38787c478bd9Sstevel@tonic-gate 		return;
38797c478bd9Sstevel@tonic-gate 	}
38807c478bd9Sstevel@tonic-gate 
38817c478bd9Sstevel@tonic-gate 	(void) close(0);
38827c478bd9Sstevel@tonic-gate 	(void) close(1);
38837c478bd9Sstevel@tonic-gate 	(void) close(2);
38847c478bd9Sstevel@tonic-gate 	(void) open("/dev/null", O_RDWR, 0);
38857c478bd9Sstevel@tonic-gate 	(void) dup(0);
38867c478bd9Sstevel@tonic-gate 	(void) dup(0);
38877c478bd9Sstevel@tonic-gate 	openlog(DEVFSADMD, LOG_PID, LOG_DAEMON);
38887c478bd9Sstevel@tonic-gate 	(void) setlogmask(LOG_UPTO(LOG_INFO));
38897c478bd9Sstevel@tonic-gate 	logflag = TRUE;
38907c478bd9Sstevel@tonic-gate }
38917c478bd9Sstevel@tonic-gate 
38927c478bd9Sstevel@tonic-gate /*
38937c478bd9Sstevel@tonic-gate  * Use an advisory lock to synchronize updates to /dev.  If the lock is
38947c478bd9Sstevel@tonic-gate  * held by another process, block in the fcntl() system call until that
38957c478bd9Sstevel@tonic-gate  * process drops the lock or exits.  The lock file itself is
38967c478bd9Sstevel@tonic-gate  * DEV_LOCK_FILE.  The process id of the current and last process owning
38977c478bd9Sstevel@tonic-gate  * the lock is kept in the lock file.  After acquiring the lock, read the
38987c478bd9Sstevel@tonic-gate  * process id and return it.  It is the process ID which last owned the
38997c478bd9Sstevel@tonic-gate  * lock, and will be used to determine if caches need to be flushed.
39007c478bd9Sstevel@tonic-gate  *
39017c478bd9Sstevel@tonic-gate  * NOTE: if the devlink database is held open by the caller, it may
39027c478bd9Sstevel@tonic-gate  * be closed by this routine. This is to enforce the following lock ordering:
39037c478bd9Sstevel@tonic-gate  *	1) /dev lock 2) database open
39047c478bd9Sstevel@tonic-gate  */
39057c478bd9Sstevel@tonic-gate pid_t
39067c478bd9Sstevel@tonic-gate enter_dev_lock()
39077c478bd9Sstevel@tonic-gate {
39087c478bd9Sstevel@tonic-gate 	struct flock lock;
39097c478bd9Sstevel@tonic-gate 	int n;
39107c478bd9Sstevel@tonic-gate 	pid_t pid;
39117c478bd9Sstevel@tonic-gate 	pid_t last_owner_pid;
39127c478bd9Sstevel@tonic-gate 
39137c478bd9Sstevel@tonic-gate 	if (file_mods == FALSE) {
39147c478bd9Sstevel@tonic-gate 		return (0);
39157c478bd9Sstevel@tonic-gate 	}
39167c478bd9Sstevel@tonic-gate 
39177c478bd9Sstevel@tonic-gate 	(void) snprintf(dev_lockfile, sizeof (dev_lockfile),
3918facf4a8dSllai 	    "%s/%s", etc_dev_dir, DEV_LOCK_FILE);
39197c478bd9Sstevel@tonic-gate 
39207c478bd9Sstevel@tonic-gate 	vprint(LOCK_MID, "enter_dev_lock: lock file %s\n", dev_lockfile);
39217c478bd9Sstevel@tonic-gate 
39227c478bd9Sstevel@tonic-gate 	dev_lock_fd = open(dev_lockfile, O_CREAT|O_RDWR, 0644);
39237c478bd9Sstevel@tonic-gate 	if (dev_lock_fd < 0) {
39247c478bd9Sstevel@tonic-gate 		err_print(OPEN_FAILED, dev_lockfile, strerror(errno));
39257c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
3926537714daSvikram 		/*NOTREACHED*/
39277c478bd9Sstevel@tonic-gate 	}
39287c478bd9Sstevel@tonic-gate 
39297c478bd9Sstevel@tonic-gate 	lock.l_type = F_WRLCK;
39307c478bd9Sstevel@tonic-gate 	lock.l_whence = SEEK_SET;
39317c478bd9Sstevel@tonic-gate 	lock.l_start = 0;
39327c478bd9Sstevel@tonic-gate 	lock.l_len = 0;
39337c478bd9Sstevel@tonic-gate 
39347c478bd9Sstevel@tonic-gate 	/* try for the lock, but don't wait */
39357c478bd9Sstevel@tonic-gate 	if (fcntl(dev_lock_fd, F_SETLK, &lock) == -1) {
39367c478bd9Sstevel@tonic-gate 		if ((errno == EACCES) || (errno == EAGAIN)) {
39377c478bd9Sstevel@tonic-gate 			pid = 0;
39387c478bd9Sstevel@tonic-gate 			n = read(dev_lock_fd, &pid, sizeof (pid_t));
39397c478bd9Sstevel@tonic-gate 			vprint(LOCK_MID, "waiting for PID %d to complete\n",
39400a653502Swroche 			    (int)pid);
39417c478bd9Sstevel@tonic-gate 			if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) {
39427c478bd9Sstevel@tonic-gate 				err_print(LSEEK_FAILED, dev_lockfile,
39430a653502Swroche 				    strerror(errno));
39447c478bd9Sstevel@tonic-gate 				devfsadm_exit(1);
3945537714daSvikram 				/*NOTREACHED*/
39467c478bd9Sstevel@tonic-gate 			}
39477c478bd9Sstevel@tonic-gate 			/*
39487c478bd9Sstevel@tonic-gate 			 * wait for the dev lock. If we have the database open,
39497c478bd9Sstevel@tonic-gate 			 * close it first - the order of lock acquisition should
39507c478bd9Sstevel@tonic-gate 			 * always be:  1) dev_lock 2) database
39517c478bd9Sstevel@tonic-gate 			 * This is to prevent deadlocks with any locks the
39527c478bd9Sstevel@tonic-gate 			 * database code may hold.
39537c478bd9Sstevel@tonic-gate 			 */
39547c478bd9Sstevel@tonic-gate 			(void) di_devlink_close(&devlink_cache, 0);
3955f05faa4eSjacobs 
3956f05faa4eSjacobs 			/* send any sysevents that were queued up. */
3957f05faa4eSjacobs 			process_syseventq();
3958f05faa4eSjacobs 
39597c478bd9Sstevel@tonic-gate 			if (fcntl(dev_lock_fd, F_SETLKW, &lock) == -1) {
39607c478bd9Sstevel@tonic-gate 				err_print(LOCK_FAILED, dev_lockfile,
39610a653502Swroche 				    strerror(errno));
39627c478bd9Sstevel@tonic-gate 				devfsadm_exit(1);
3963537714daSvikram 				/*NOTREACHED*/
39647c478bd9Sstevel@tonic-gate 			}
39657c478bd9Sstevel@tonic-gate 		}
39667c478bd9Sstevel@tonic-gate 	}
39677c478bd9Sstevel@tonic-gate 
39687c478bd9Sstevel@tonic-gate 	hold_dev_lock = TRUE;
39697c478bd9Sstevel@tonic-gate 	pid = 0;
39707c478bd9Sstevel@tonic-gate 	n = read(dev_lock_fd, &pid, sizeof (pid_t));
39717c478bd9Sstevel@tonic-gate 	if (n == sizeof (pid_t) && pid == getpid()) {
39727c478bd9Sstevel@tonic-gate 		return (pid);
39737c478bd9Sstevel@tonic-gate 	}
39747c478bd9Sstevel@tonic-gate 
39757c478bd9Sstevel@tonic-gate 	last_owner_pid = pid;
39767c478bd9Sstevel@tonic-gate 
39777c478bd9Sstevel@tonic-gate 	if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) {
39787c478bd9Sstevel@tonic-gate 		err_print(LSEEK_FAILED, dev_lockfile, strerror(errno));
39797c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
3980537714daSvikram 		/*NOTREACHED*/
39817c478bd9Sstevel@tonic-gate 	}
39827c478bd9Sstevel@tonic-gate 	pid = getpid();
39837c478bd9Sstevel@tonic-gate 	n = write(dev_lock_fd, &pid, sizeof (pid_t));
39847c478bd9Sstevel@tonic-gate 	if (n != sizeof (pid_t)) {
39857c478bd9Sstevel@tonic-gate 		err_print(WRITE_FAILED, dev_lockfile, strerror(errno));
39867c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
3987537714daSvikram 		/*NOTREACHED*/
39887c478bd9Sstevel@tonic-gate 	}
39897c478bd9Sstevel@tonic-gate 
39907c478bd9Sstevel@tonic-gate 	return (last_owner_pid);
39917c478bd9Sstevel@tonic-gate }
39927c478bd9Sstevel@tonic-gate 
39937c478bd9Sstevel@tonic-gate /*
39947c478bd9Sstevel@tonic-gate  * Drop the advisory /dev lock, close lock file.  Close and re-open the
39957c478bd9Sstevel@tonic-gate  * file every time so to ensure a resync if for some reason the lock file
39967c478bd9Sstevel@tonic-gate  * gets removed.
39977c478bd9Sstevel@tonic-gate  */
39987c478bd9Sstevel@tonic-gate void
3999537714daSvikram exit_dev_lock(int exiting)
40007c478bd9Sstevel@tonic-gate {
40017c478bd9Sstevel@tonic-gate 	struct flock unlock;
40027c478bd9Sstevel@tonic-gate 
40037c478bd9Sstevel@tonic-gate 	if (hold_dev_lock == FALSE) {
40047c478bd9Sstevel@tonic-gate 		return;
40057c478bd9Sstevel@tonic-gate 	}
40067c478bd9Sstevel@tonic-gate 
4007537714daSvikram 	vprint(LOCK_MID, "exit_dev_lock: lock file %s, exiting = %d\n",
4008537714daSvikram 	    dev_lockfile, exiting);
40097c478bd9Sstevel@tonic-gate 
40107c478bd9Sstevel@tonic-gate 	unlock.l_type = F_UNLCK;
40117c478bd9Sstevel@tonic-gate 	unlock.l_whence = SEEK_SET;
40127c478bd9Sstevel@tonic-gate 	unlock.l_start = 0;
40137c478bd9Sstevel@tonic-gate 	unlock.l_len = 0;
40147c478bd9Sstevel@tonic-gate 
40157c478bd9Sstevel@tonic-gate 	if (fcntl(dev_lock_fd, F_SETLK, &unlock) == -1) {
40167c478bd9Sstevel@tonic-gate 		err_print(UNLOCK_FAILED, dev_lockfile, strerror(errno));
40177c478bd9Sstevel@tonic-gate 	}
40187c478bd9Sstevel@tonic-gate 
40197c478bd9Sstevel@tonic-gate 	hold_dev_lock = FALSE;
40207c478bd9Sstevel@tonic-gate 
40217c478bd9Sstevel@tonic-gate 	if (close(dev_lock_fd) == -1) {
40227c478bd9Sstevel@tonic-gate 		err_print(CLOSE_FAILED, dev_lockfile, strerror(errno));
4023537714daSvikram 		if (!exiting)
4024537714daSvikram 			devfsadm_exit(1);
4025537714daSvikram 			/*NOTREACHED*/
40267c478bd9Sstevel@tonic-gate 	}
40277c478bd9Sstevel@tonic-gate }
40287c478bd9Sstevel@tonic-gate 
40297c478bd9Sstevel@tonic-gate /*
40307c478bd9Sstevel@tonic-gate  *
40317c478bd9Sstevel@tonic-gate  * Use an advisory lock to ensure that only one daemon process is active
40327c478bd9Sstevel@tonic-gate  * in the system at any point in time.	If the lock is held by another
40337c478bd9Sstevel@tonic-gate  * process, do not block but return the pid owner of the lock to the
40347c478bd9Sstevel@tonic-gate  * caller immediately.	The lock is cleared if the holding daemon process
40357c478bd9Sstevel@tonic-gate  * exits for any reason even if the lock file remains, so the daemon can
40367c478bd9Sstevel@tonic-gate  * be restarted if necessary.  The lock file is DAEMON_LOCK_FILE.
40377c478bd9Sstevel@tonic-gate  */
40387c478bd9Sstevel@tonic-gate pid_t
40397c478bd9Sstevel@tonic-gate enter_daemon_lock(void)
40407c478bd9Sstevel@tonic-gate {
40417c478bd9Sstevel@tonic-gate 	struct flock lock;
40427c478bd9Sstevel@tonic-gate 
40437c478bd9Sstevel@tonic-gate 	(void) snprintf(daemon_lockfile, sizeof (daemon_lockfile),
4044facf4a8dSllai 	    "%s/%s", etc_dev_dir, DAEMON_LOCK_FILE);
40457c478bd9Sstevel@tonic-gate 
40467c478bd9Sstevel@tonic-gate 	vprint(LOCK_MID, "enter_daemon_lock: lock file %s\n", daemon_lockfile);
40477c478bd9Sstevel@tonic-gate 
40487c478bd9Sstevel@tonic-gate 	daemon_lock_fd = open(daemon_lockfile, O_CREAT|O_RDWR, 0644);
40497c478bd9Sstevel@tonic-gate 	if (daemon_lock_fd < 0) {
40507c478bd9Sstevel@tonic-gate 		err_print(OPEN_FAILED, daemon_lockfile, strerror(errno));
40517c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
4052537714daSvikram 		/*NOTREACHED*/
40537c478bd9Sstevel@tonic-gate 	}
40547c478bd9Sstevel@tonic-gate 
40557c478bd9Sstevel@tonic-gate 	lock.l_type = F_WRLCK;
40567c478bd9Sstevel@tonic-gate 	lock.l_whence = SEEK_SET;
40577c478bd9Sstevel@tonic-gate 	lock.l_start = 0;
40587c478bd9Sstevel@tonic-gate 	lock.l_len = 0;
40597c478bd9Sstevel@tonic-gate 
40607c478bd9Sstevel@tonic-gate 	if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) {
40617c478bd9Sstevel@tonic-gate 
40627c478bd9Sstevel@tonic-gate 		if (errno == EAGAIN || errno == EDEADLK) {
40637c478bd9Sstevel@tonic-gate 			if (fcntl(daemon_lock_fd, F_GETLK, &lock) == -1) {
40647c478bd9Sstevel@tonic-gate 				err_print(LOCK_FAILED, daemon_lockfile,
40650a653502Swroche 				    strerror(errno));
40667c478bd9Sstevel@tonic-gate 				devfsadm_exit(1);
4067537714daSvikram 				/*NOTREACHED*/
40687c478bd9Sstevel@tonic-gate 			}
40697c478bd9Sstevel@tonic-gate 			return (lock.l_pid);
40707c478bd9Sstevel@tonic-gate 		}
40717c478bd9Sstevel@tonic-gate 	}
40727c478bd9Sstevel@tonic-gate 	hold_daemon_lock = TRUE;
40737c478bd9Sstevel@tonic-gate 	return (getpid());
40747c478bd9Sstevel@tonic-gate }
40757c478bd9Sstevel@tonic-gate 
40767c478bd9Sstevel@tonic-gate /*
40777c478bd9Sstevel@tonic-gate  * Drop the advisory daemon lock, close lock file
40787c478bd9Sstevel@tonic-gate  */
40797c478bd9Sstevel@tonic-gate void
4080537714daSvikram exit_daemon_lock(int exiting)
40817c478bd9Sstevel@tonic-gate {
40827c478bd9Sstevel@tonic-gate 	struct flock lock;
40837c478bd9Sstevel@tonic-gate 
40847c478bd9Sstevel@tonic-gate 	if (hold_daemon_lock == FALSE) {
40857c478bd9Sstevel@tonic-gate 		return;
40867c478bd9Sstevel@tonic-gate 	}
40877c478bd9Sstevel@tonic-gate 
4088537714daSvikram 	vprint(LOCK_MID, "exit_daemon_lock: lock file %s, exiting = %d\n",
4089537714daSvikram 	    daemon_lockfile, exiting);
40907c478bd9Sstevel@tonic-gate 
40917c478bd9Sstevel@tonic-gate 	lock.l_type = F_UNLCK;
40927c478bd9Sstevel@tonic-gate 	lock.l_whence = SEEK_SET;
40937c478bd9Sstevel@tonic-gate 	lock.l_start = 0;
40947c478bd9Sstevel@tonic-gate 	lock.l_len = 0;
40957c478bd9Sstevel@tonic-gate 
40967c478bd9Sstevel@tonic-gate 	if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) {
40977c478bd9Sstevel@tonic-gate 		err_print(UNLOCK_FAILED, daemon_lockfile, strerror(errno));
40987c478bd9Sstevel@tonic-gate 	}
40997c478bd9Sstevel@tonic-gate 
41007c478bd9Sstevel@tonic-gate 	if (close(daemon_lock_fd) == -1) {
41017c478bd9Sstevel@tonic-gate 		err_print(CLOSE_FAILED, daemon_lockfile, strerror(errno));
4102537714daSvikram 		if (!exiting)
4103537714daSvikram 			devfsadm_exit(1);
4104537714daSvikram 			/*NOTREACHED*/
41057c478bd9Sstevel@tonic-gate 	}
41067c478bd9Sstevel@tonic-gate }
41077c478bd9Sstevel@tonic-gate 
41087c478bd9Sstevel@tonic-gate /*
41097c478bd9Sstevel@tonic-gate  * Called to removed danging nodes in two different modes: RM_PRE, RM_POST.
41107c478bd9Sstevel@tonic-gate  * RM_PRE mode is called before processing the entire devinfo tree, and RM_POST
41117c478bd9Sstevel@tonic-gate  * is called after processing the entire devinfo tree.
41127c478bd9Sstevel@tonic-gate  */
41137c478bd9Sstevel@tonic-gate static void
41147c478bd9Sstevel@tonic-gate pre_and_post_cleanup(int flags)
41157c478bd9Sstevel@tonic-gate {
41167c478bd9Sstevel@tonic-gate 	remove_list_t *rm;
41177c478bd9Sstevel@tonic-gate 	recurse_dev_t rd;
41187c478bd9Sstevel@tonic-gate 	cleanup_data_t cleanup_data;
41197c478bd9Sstevel@tonic-gate 	char *fcn = "pre_and_post_cleanup: ";
41207c478bd9Sstevel@tonic-gate 
41217c478bd9Sstevel@tonic-gate 	if (build_dev == FALSE)
41227c478bd9Sstevel@tonic-gate 		return;
41237c478bd9Sstevel@tonic-gate 
41247c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "attempting %s-cleanup\n",
41257c478bd9Sstevel@tonic-gate 	    flags == RM_PRE ? "pre" : "post");
41267c478bd9Sstevel@tonic-gate 	vprint(REMOVE_MID, "%sflags = %d\n", fcn, flags);
41277c478bd9Sstevel@tonic-gate 
41287c478bd9Sstevel@tonic-gate 	/*
41297c478bd9Sstevel@tonic-gate 	 * the generic function recurse_dev_re is shared among different
41307c478bd9Sstevel@tonic-gate 	 * functions, so set the method and data that it should use for
41317c478bd9Sstevel@tonic-gate 	 * matches.
41327c478bd9Sstevel@tonic-gate 	 */
41337c478bd9Sstevel@tonic-gate 	rd.fcn = matching_dev;
41347c478bd9Sstevel@tonic-gate 	rd.data = (void *)&cleanup_data;
41357c478bd9Sstevel@tonic-gate 	cleanup_data.flags = flags;
41367c478bd9Sstevel@tonic-gate 
4137aa646b9dSvikram 	(void) mutex_lock(&nfp_mutex);
4138aa646b9dSvikram 	nfphash_create();
4139aa646b9dSvikram 
41407c478bd9Sstevel@tonic-gate 	for (rm = remove_head; rm != NULL; rm = rm->next) {
41417c478bd9Sstevel@tonic-gate 		if ((flags & rm->remove->flags) == flags) {
41427c478bd9Sstevel@tonic-gate 			cleanup_data.rm = rm;
41437c478bd9Sstevel@tonic-gate 			/*
41447c478bd9Sstevel@tonic-gate 			 * If reached this point, RM_PRE or RM_POST cleanup is
41457c478bd9Sstevel@tonic-gate 			 * desired.  clean_ok() decides whether to clean
41467c478bd9Sstevel@tonic-gate 			 * under the given circumstances.
41477c478bd9Sstevel@tonic-gate 			 */
41487c478bd9Sstevel@tonic-gate 			vprint(REMOVE_MID, "%scleanup: PRE or POST\n", fcn);
41497c478bd9Sstevel@tonic-gate 			if (clean_ok(rm->remove) == DEVFSADM_SUCCESS) {
41507c478bd9Sstevel@tonic-gate 				vprint(REMOVE_MID, "cleanup: cleanup OK\n");
41510a653502Swroche 				recurse_dev_re(dev_dir,
41520a653502Swroche 				    rm->remove->dev_dirs_re, &rd);
41537c478bd9Sstevel@tonic-gate 			}
41547c478bd9Sstevel@tonic-gate 		}
41557c478bd9Sstevel@tonic-gate 	}
4156aa646b9dSvikram 	nfphash_destroy();
4157aa646b9dSvikram 	(void) mutex_unlock(&nfp_mutex);
41587c478bd9Sstevel@tonic-gate }
41597c478bd9Sstevel@tonic-gate 
41607c478bd9Sstevel@tonic-gate /*
41617c478bd9Sstevel@tonic-gate  * clean_ok() determines whether cleanup should be done according
41627c478bd9Sstevel@tonic-gate  * to the following matrix:
41637c478bd9Sstevel@tonic-gate  *
41647c478bd9Sstevel@tonic-gate  * command line arguments RM_PRE    RM_POST	  RM_PRE &&    RM_POST &&
41657c478bd9Sstevel@tonic-gate  *						  RM_ALWAYS    RM_ALWAYS
41667c478bd9Sstevel@tonic-gate  * ---------------------- ------     -----	  ---------    ----------
41677c478bd9Sstevel@tonic-gate  *
41687c478bd9Sstevel@tonic-gate  * <neither -c nor -C>	  -	    -		  pre-clean    post-clean
41697c478bd9Sstevel@tonic-gate  *
41707c478bd9Sstevel@tonic-gate  * -C			  pre-clean  post-clean   pre-clean    post-clean
41717c478bd9Sstevel@tonic-gate  *
41727c478bd9Sstevel@tonic-gate  * -C -c class		  pre-clean  post-clean   pre-clean    post-clean
41737c478bd9Sstevel@tonic-gate  *			  if class  if class	  if class     if class
41747c478bd9Sstevel@tonic-gate  *			  matches   matches	  matches      matches
41757c478bd9Sstevel@tonic-gate  *
41767c478bd9Sstevel@tonic-gate  * -c class		   -	       -	  pre-clean    post-clean
41777c478bd9Sstevel@tonic-gate  *						  if class     if class
41787c478bd9Sstevel@tonic-gate  *						  matches      matches
41797c478bd9Sstevel@tonic-gate  *
41807c478bd9Sstevel@tonic-gate  */
41817c478bd9Sstevel@tonic-gate static int
4182aa646b9dSvikram clean_ok(devfsadm_remove_V1_t *remove)
41837c478bd9Sstevel@tonic-gate {
41847c478bd9Sstevel@tonic-gate 	int i;
41857c478bd9Sstevel@tonic-gate 
41867c478bd9Sstevel@tonic-gate 	if (single_drv == TRUE) {
41877c478bd9Sstevel@tonic-gate 		/* no cleanup at all when using -i option */
41887c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
41897c478bd9Sstevel@tonic-gate 	}
41907c478bd9Sstevel@tonic-gate 
41917c478bd9Sstevel@tonic-gate 	/*
41927c478bd9Sstevel@tonic-gate 	 * no cleanup if drivers are not loaded. We make an exception
41937c478bd9Sstevel@tonic-gate 	 * for the "disks" program however, since disks has a public
41947c478bd9Sstevel@tonic-gate 	 * cleanup flag (-C) and disk drivers are usually never
41957c478bd9Sstevel@tonic-gate 	 * unloaded.
41967c478bd9Sstevel@tonic-gate 	 */
41977c478bd9Sstevel@tonic-gate 	if (load_attach_drv == FALSE && strcmp(prog, DISKS) != 0) {
41987c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
41997c478bd9Sstevel@tonic-gate 	}
42007c478bd9Sstevel@tonic-gate 
42017c478bd9Sstevel@tonic-gate 	/* if the cleanup flag was not specified, return false */
42027c478bd9Sstevel@tonic-gate 	if ((cleanup == FALSE) && ((remove->flags & RM_ALWAYS) == 0)) {
42037c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
42047c478bd9Sstevel@tonic-gate 	}
42057c478bd9Sstevel@tonic-gate 
42067c478bd9Sstevel@tonic-gate 	if (num_classes == 0) {
42077c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
42087c478bd9Sstevel@tonic-gate 	}
42097c478bd9Sstevel@tonic-gate 
42107c478bd9Sstevel@tonic-gate 	/*
42117c478bd9Sstevel@tonic-gate 	 * if reached this point, check to see if the class in the given
42127c478bd9Sstevel@tonic-gate 	 * remove structure matches a class given on the command line
42137c478bd9Sstevel@tonic-gate 	 */
42147c478bd9Sstevel@tonic-gate 
42157c478bd9Sstevel@tonic-gate 	for (i = 0; i < num_classes; i++) {
42167c478bd9Sstevel@tonic-gate 		if (strcmp(remove->device_class, classes[i]) == 0) {
42177c478bd9Sstevel@tonic-gate 			return (DEVFSADM_SUCCESS);
42187c478bd9Sstevel@tonic-gate 		}
42197c478bd9Sstevel@tonic-gate 	}
42207c478bd9Sstevel@tonic-gate 
42217c478bd9Sstevel@tonic-gate 	return (DEVFSADM_FAILURE);
42227c478bd9Sstevel@tonic-gate }
42237c478bd9Sstevel@tonic-gate 
42247c478bd9Sstevel@tonic-gate /*
42257c478bd9Sstevel@tonic-gate  * Called to remove dangling nodes after receiving a hotplug event
42267c478bd9Sstevel@tonic-gate  * containing the physical node pathname to be removed.
42277c478bd9Sstevel@tonic-gate  */
42287c478bd9Sstevel@tonic-gate void
42297c478bd9Sstevel@tonic-gate hot_cleanup(char *node_path, char *minor_name, char *ev_subclass,
42307c478bd9Sstevel@tonic-gate     char *driver_name, int instance)
42317c478bd9Sstevel@tonic-gate {
42327c478bd9Sstevel@tonic-gate 	link_t *link;
42337c478bd9Sstevel@tonic-gate 	linkhead_t *head;
42347c478bd9Sstevel@tonic-gate 	remove_list_t *rm;
42357c478bd9Sstevel@tonic-gate 	char *fcn = "hot_cleanup: ";
42367c478bd9Sstevel@tonic-gate 	char path[PATH_MAX + 1];
42377c478bd9Sstevel@tonic-gate 	int path_len;
42387c478bd9Sstevel@tonic-gate 	char rmlink[PATH_MAX + 1];
42397c478bd9Sstevel@tonic-gate 	nvlist_t *nvl = NULL;
4240fb9251a6Scth 	int skip;
4241aa646b9dSvikram 	int ret;
42427c478bd9Sstevel@tonic-gate 
42437c478bd9Sstevel@tonic-gate 	/*
42447c478bd9Sstevel@tonic-gate 	 * dev links can go away as part of hot cleanup.
42457c478bd9Sstevel@tonic-gate 	 * So first build event attributes in order capture dev links.
42467c478bd9Sstevel@tonic-gate 	 */
42477c478bd9Sstevel@tonic-gate 	if (ev_subclass != NULL)
42487c478bd9Sstevel@tonic-gate 		nvl = build_event_attributes(EC_DEV_REMOVE, ev_subclass,
424930294554Sphitran 		    node_path, DI_NODE_NIL, driver_name, instance, minor_name);
42507c478bd9Sstevel@tonic-gate 
42517c478bd9Sstevel@tonic-gate 	(void) strcpy(path, node_path);
42527c478bd9Sstevel@tonic-gate 	(void) strcat(path, ":");
42537c478bd9Sstevel@tonic-gate 	(void) strcat(path, minor_name == NULL ? "" : minor_name);
42547c478bd9Sstevel@tonic-gate 
42557c478bd9Sstevel@tonic-gate 	path_len = strlen(path);
42567c478bd9Sstevel@tonic-gate 
42577c478bd9Sstevel@tonic-gate 	vprint(REMOVE_MID, "%spath=%s\n", fcn, path);
42587c478bd9Sstevel@tonic-gate 
4259aa646b9dSvikram 	(void) mutex_lock(&nfp_mutex);
4260aa646b9dSvikram 	nfphash_create();
4261aa646b9dSvikram 
42627c478bd9Sstevel@tonic-gate 	for (rm = remove_head; rm != NULL; rm = rm->next) {
42637c478bd9Sstevel@tonic-gate 		if ((RM_HOT & rm->remove->flags) == RM_HOT) {
42647c478bd9Sstevel@tonic-gate 			head = get_cached_links(rm->remove->dev_dirs_re);
42657c478bd9Sstevel@tonic-gate 			assert(head->nextlink == NULL);
42667c478bd9Sstevel@tonic-gate 			for (link = head->link;
42677c478bd9Sstevel@tonic-gate 			    link != NULL; link = head->nextlink) {
42687c478bd9Sstevel@tonic-gate 				/*
42697c478bd9Sstevel@tonic-gate 				 * The remove callback below may remove
42707c478bd9Sstevel@tonic-gate 				 * the current and/or any or all of the
42717c478bd9Sstevel@tonic-gate 				 * subsequent links in the list.
42727c478bd9Sstevel@tonic-gate 				 * Save the next link in the head. If
42737c478bd9Sstevel@tonic-gate 				 * the callback removes the next link
42747c478bd9Sstevel@tonic-gate 				 * the saved pointer in the head will be
42757c478bd9Sstevel@tonic-gate 				 * updated by the callback to point at
42767c478bd9Sstevel@tonic-gate 				 * the next valid link.
42777c478bd9Sstevel@tonic-gate 				 */
42787c478bd9Sstevel@tonic-gate 				head->nextlink = link->next;
4279aa646b9dSvikram 
4280aa646b9dSvikram 				/*
4281aa646b9dSvikram 				 * if devlink is in no-further-process hash,
4282aa646b9dSvikram 				 * skip its remove
4283aa646b9dSvikram 				 */
4284aa646b9dSvikram 				if (nfphash_lookup(link->devlink) != NULL)
4285aa646b9dSvikram 					continue;
4286aa646b9dSvikram 
4287fb9251a6Scth 				if (minor_name)
4288fb9251a6Scth 					skip = strcmp(link->contents, path);
4289fb9251a6Scth 				else
4290fb9251a6Scth 					skip = strncmp(link->contents, path,
4291fb9251a6Scth 					    path_len);
4292fb9251a6Scth 				if (skip ||
4293fb9251a6Scth 				    (call_minor_init(rm->modptr) ==
4294fb9251a6Scth 				    DEVFSADM_FAILURE))
4295fb9251a6Scth 					continue;
42967c478bd9Sstevel@tonic-gate 
4297fb9251a6Scth 				vprint(REMOVE_MID,
42980a653502Swroche 				    "%sremoving %s -> %s\n", fcn,
42990a653502Swroche 				    link->devlink, link->contents);
4300fb9251a6Scth 				/*
4301fb9251a6Scth 				 * Use a copy of the cached link name
4302fb9251a6Scth 				 * as the cache entry will go away
4303fb9251a6Scth 				 * during link removal
4304fb9251a6Scth 				 */
4305fb9251a6Scth 				(void) snprintf(rmlink, sizeof (rmlink),
4306fb9251a6Scth 				    "%s", link->devlink);
4307aa646b9dSvikram 				if (rm->remove->flags & RM_NOINTERPOSE) {
4308aa646b9dSvikram 					((void (*)(char *))
43090a653502Swroche 					    (rm->remove->callback_fcn))(rmlink);
4310aa646b9dSvikram 				} else {
4311aa646b9dSvikram 					ret = ((int (*)(char *))
4312aa646b9dSvikram 					    (rm->remove->callback_fcn))(rmlink);
4313aa646b9dSvikram 					if (ret == DEVFSADM_TERMINATE)
4314aa646b9dSvikram 						nfphash_insert(rmlink);
4315aa646b9dSvikram 				}
43167c478bd9Sstevel@tonic-gate 			}
43177c478bd9Sstevel@tonic-gate 		}
43187c478bd9Sstevel@tonic-gate 	}
43197c478bd9Sstevel@tonic-gate 
4320aa646b9dSvikram 	nfphash_destroy();
4321aa646b9dSvikram 	(void) mutex_unlock(&nfp_mutex);
4322aa646b9dSvikram 
432345916cd2Sjpk 	/* update device allocation database */
432445916cd2Sjpk 	if (system_labeled) {
432545916cd2Sjpk 		int	devtype = 0;
432645916cd2Sjpk 
43277e3e5701SJan Parcel 		if (strstr(path, DA_SOUND_NAME))
432845916cd2Sjpk 			devtype = DA_AUDIO;
43297e3e5701SJan Parcel 		else if (strstr(path, "storage"))
43307e3e5701SJan Parcel 			devtype = DA_RMDISK;
43317e3e5701SJan Parcel 		else if (strstr(path, "disk"))
43327e3e5701SJan Parcel 			devtype = DA_RMDISK;
43337e3e5701SJan Parcel 		else if (strstr(path, "floppy"))
43347e3e5701SJan Parcel 			/* TODO: detect usb cds and floppies at insert time */
433545916cd2Sjpk 			devtype = DA_RMDISK;
433645916cd2Sjpk 		else
433745916cd2Sjpk 			goto out;
43387e3e5701SJan Parcel 
43397e3e5701SJan Parcel 		(void) _update_devalloc_db(&devlist, devtype, DA_REMOVE,
43407e3e5701SJan Parcel 		    node_path, root_dir);
434145916cd2Sjpk 	}
434245916cd2Sjpk 
434345916cd2Sjpk out:
43447c478bd9Sstevel@tonic-gate 	/* now log an event */
43457c478bd9Sstevel@tonic-gate 	if (nvl) {
43467c478bd9Sstevel@tonic-gate 		log_event(EC_DEV_REMOVE, ev_subclass, nvl);
43477c478bd9Sstevel@tonic-gate 		free(nvl);
43487c478bd9Sstevel@tonic-gate 	}
43497c478bd9Sstevel@tonic-gate }
43507c478bd9Sstevel@tonic-gate 
43517c478bd9Sstevel@tonic-gate /*
43527c478bd9Sstevel@tonic-gate  * Open the dir current_dir.  For every file which matches the first dir
43537c478bd9Sstevel@tonic-gate  * component of path_re, recurse.  If there are no more *dir* path
43547c478bd9Sstevel@tonic-gate  * components left in path_re (ie no more /), then call function rd->fcn.
43557c478bd9Sstevel@tonic-gate  */
43567c478bd9Sstevel@tonic-gate static void
43577c478bd9Sstevel@tonic-gate recurse_dev_re(char *current_dir, char *path_re, recurse_dev_t *rd)
43587c478bd9Sstevel@tonic-gate {
43597c478bd9Sstevel@tonic-gate 	regex_t re1;
43607c478bd9Sstevel@tonic-gate 	char *slash;
43617c478bd9Sstevel@tonic-gate 	char new_path[PATH_MAX + 1];
43627c478bd9Sstevel@tonic-gate 	char *anchored_path_re;
43637c478bd9Sstevel@tonic-gate 	size_t len;
436473de625bSjg 	finddevhdl_t fhandle;
436573de625bSjg 	const char *fp;
43667c478bd9Sstevel@tonic-gate 
43677c478bd9Sstevel@tonic-gate 	vprint(RECURSEDEV_MID, "recurse_dev_re: curr = %s path=%s\n",
43680a653502Swroche 	    current_dir, path_re);
43697c478bd9Sstevel@tonic-gate 
437073de625bSjg 	if (finddev_readdir(current_dir, &fhandle) != 0)
43717c478bd9Sstevel@tonic-gate 		return;
43727c478bd9Sstevel@tonic-gate 
43737c478bd9Sstevel@tonic-gate 	len = strlen(path_re);
43747c478bd9Sstevel@tonic-gate 	if ((slash = strchr(path_re, '/')) != NULL) {
43757c478bd9Sstevel@tonic-gate 		len = (slash - path_re);
43767c478bd9Sstevel@tonic-gate 	}
43777c478bd9Sstevel@tonic-gate 
43787c478bd9Sstevel@tonic-gate 	anchored_path_re = s_malloc(len + 3);
43797c478bd9Sstevel@tonic-gate 	(void) sprintf(anchored_path_re, "^%.*s$", len, path_re);
43807c478bd9Sstevel@tonic-gate 
43817c478bd9Sstevel@tonic-gate 	if (regcomp(&re1, anchored_path_re, REG_EXTENDED) != 0) {
43827c478bd9Sstevel@tonic-gate 		free(anchored_path_re);
43837c478bd9Sstevel@tonic-gate 		goto out;
43847c478bd9Sstevel@tonic-gate 	}
43857c478bd9Sstevel@tonic-gate 
43867c478bd9Sstevel@tonic-gate 	free(anchored_path_re);
43877c478bd9Sstevel@tonic-gate 
438873de625bSjg 	while ((fp = finddev_next(fhandle)) != NULL) {
43897c478bd9Sstevel@tonic-gate 
439073de625bSjg 		if (regexec(&re1, fp, 0, NULL, 0) == 0) {
43917c478bd9Sstevel@tonic-gate 			/* match */
43927c478bd9Sstevel@tonic-gate 			(void) strcpy(new_path, current_dir);
43937c478bd9Sstevel@tonic-gate 			(void) strcat(new_path, "/");
439473de625bSjg 			(void) strcat(new_path, fp);
43957c478bd9Sstevel@tonic-gate 
43967c478bd9Sstevel@tonic-gate 			vprint(RECURSEDEV_MID, "recurse_dev_re: match, new "
43970a653502Swroche 			    "path = %s\n", new_path);
43987c478bd9Sstevel@tonic-gate 
43997c478bd9Sstevel@tonic-gate 			if (slash != NULL) {
44007c478bd9Sstevel@tonic-gate 				recurse_dev_re(new_path, slash + 1, rd);
44017c478bd9Sstevel@tonic-gate 			} else {
44027c478bd9Sstevel@tonic-gate 				/* reached the leaf component of path_re */
44037c478bd9Sstevel@tonic-gate 				vprint(RECURSEDEV_MID,
44040a653502Swroche 				    "recurse_dev_re: calling fcn\n");
44057c478bd9Sstevel@tonic-gate 				(*(rd->fcn))(new_path, rd->data);
44067c478bd9Sstevel@tonic-gate 			}
44077c478bd9Sstevel@tonic-gate 		}
44087c478bd9Sstevel@tonic-gate 	}
44097c478bd9Sstevel@tonic-gate 
44107c478bd9Sstevel@tonic-gate 	regfree(&re1);
44117c478bd9Sstevel@tonic-gate 
44127c478bd9Sstevel@tonic-gate out:
441373de625bSjg 	finddev_close(fhandle);
44147c478bd9Sstevel@tonic-gate }
44157c478bd9Sstevel@tonic-gate 
44167c478bd9Sstevel@tonic-gate /*
44177c478bd9Sstevel@tonic-gate  *  Found a devpath which matches a RE in the remove structure.
44187c478bd9Sstevel@tonic-gate  *  Now check to see if it is dangling.
44197c478bd9Sstevel@tonic-gate  */
44207c478bd9Sstevel@tonic-gate static void
44217c478bd9Sstevel@tonic-gate matching_dev(char *devpath, void *data)
44227c478bd9Sstevel@tonic-gate {
44237c478bd9Sstevel@tonic-gate 	cleanup_data_t *cleanup_data = data;
4424aa646b9dSvikram 	int norm_len = strlen(dev_dir) + strlen("/");
4425aa646b9dSvikram 	int ret;
44267c478bd9Sstevel@tonic-gate 	char *fcn = "matching_dev: ";
44277c478bd9Sstevel@tonic-gate 
44287c478bd9Sstevel@tonic-gate 	vprint(RECURSEDEV_MID, "%sexamining devpath = '%s'\n", fcn,
44290a653502Swroche 	    devpath);
44307c478bd9Sstevel@tonic-gate 
4431aa646b9dSvikram 	/*
4432aa646b9dSvikram 	 * If the link is in the no-further-process hash
4433aa646b9dSvikram 	 * don't do any remove operation on it.
4434aa646b9dSvikram 	 */
4435aa646b9dSvikram 	if (nfphash_lookup(devpath + norm_len) != NULL)
4436aa646b9dSvikram 		return;
4437aa646b9dSvikram 
443894c894bbSVikram Hegde 	/*
443994c894bbSVikram Hegde 	 * Dangling check will work whether "alias" or "current"
444094c894bbSVikram Hegde 	 * so no need to redirect.
444194c894bbSVikram Hegde 	 */
44427c478bd9Sstevel@tonic-gate 	if (resolve_link(devpath, NULL, NULL, NULL, 1) == TRUE) {
44437c478bd9Sstevel@tonic-gate 		if (call_minor_init(cleanup_data->rm->modptr) ==
44440a653502Swroche 		    DEVFSADM_FAILURE) {
44457c478bd9Sstevel@tonic-gate 			return;
44467c478bd9Sstevel@tonic-gate 		}
44477c478bd9Sstevel@tonic-gate 
4448aa646b9dSvikram 		devpath += norm_len;
44497c478bd9Sstevel@tonic-gate 
44500a653502Swroche 		vprint(RECURSEDEV_MID, "%scalling callback %s\n", fcn, devpath);
4451aa646b9dSvikram 		if (cleanup_data->rm->remove->flags & RM_NOINTERPOSE)
4452aa646b9dSvikram 			((void (*)(char *))
44530a653502Swroche 			    (cleanup_data->rm->remove->callback_fcn))(devpath);
4454aa646b9dSvikram 		else {
4455aa646b9dSvikram 			ret = ((int (*)(char *))
4456aa646b9dSvikram 			    (cleanup_data->rm->remove->callback_fcn))(devpath);
4457aa646b9dSvikram 			if (ret == DEVFSADM_TERMINATE) {
4458aa646b9dSvikram 				/*
4459aa646b9dSvikram 				 * We want no further remove processing for
4460aa646b9dSvikram 				 * this link. Add it to the nfp_hash;
4461aa646b9dSvikram 				 */
4462aa646b9dSvikram 				nfphash_insert(devpath);
4463aa646b9dSvikram 			}
4464aa646b9dSvikram 		}
44657c478bd9Sstevel@tonic-gate 	}
44667c478bd9Sstevel@tonic-gate }
44677c478bd9Sstevel@tonic-gate 
44687c478bd9Sstevel@tonic-gate int
446994c894bbSVikram Hegde devfsadm_read_link(di_node_t anynode, char *link, char **devfs_path)
44707c478bd9Sstevel@tonic-gate {
44717c478bd9Sstevel@tonic-gate 	char devlink[PATH_MAX];
447294c894bbSVikram Hegde 	char *path;
44737c478bd9Sstevel@tonic-gate 
44747c478bd9Sstevel@tonic-gate 	*devfs_path = NULL;
44757c478bd9Sstevel@tonic-gate 
44767c478bd9Sstevel@tonic-gate 	/* prepend link with dev_dir contents */
44777c478bd9Sstevel@tonic-gate 	(void) strcpy(devlink, dev_dir);
44787c478bd9Sstevel@tonic-gate 	(void) strcat(devlink, "/");
44797c478bd9Sstevel@tonic-gate 	(void) strcat(devlink, link);
44807c478bd9Sstevel@tonic-gate 
44817c478bd9Sstevel@tonic-gate 	/* We *don't* want a stat of the /devices node */
448294c894bbSVikram Hegde 	path = NULL;
448394c894bbSVikram Hegde 	(void) resolve_link(devlink, NULL, NULL, &path, 0);
44847c478bd9Sstevel@tonic-gate 
448594c894bbSVikram Hegde 	/* redirect if alias to current */
448694c894bbSVikram Hegde 	*devfs_path = di_alias2curr(anynode, path);
448794c894bbSVikram Hegde 	free(path);
44887c478bd9Sstevel@tonic-gate 	return (*devfs_path ? DEVFSADM_SUCCESS : DEVFSADM_FAILURE);
44897c478bd9Sstevel@tonic-gate }
44907c478bd9Sstevel@tonic-gate 
44917c478bd9Sstevel@tonic-gate int
449294c894bbSVikram Hegde devfsadm_link_valid(di_node_t anynode, char *link)
44937c478bd9Sstevel@tonic-gate {
44947c478bd9Sstevel@tonic-gate 	struct stat sb;
449594c894bbSVikram Hegde 	char devlink[PATH_MAX + 1], *contents, *raw_contents;
44967c478bd9Sstevel@tonic-gate 	int rv, type;
449745916cd2Sjpk 	int instance = 0;
44987c478bd9Sstevel@tonic-gate 
44997c478bd9Sstevel@tonic-gate 	/* prepend link with dev_dir contents */
45007c478bd9Sstevel@tonic-gate 	(void) strcpy(devlink, dev_dir);
45017c478bd9Sstevel@tonic-gate 	(void) strcat(devlink, "/");
45027c478bd9Sstevel@tonic-gate 	(void) strcat(devlink, link);
45037c478bd9Sstevel@tonic-gate 
4504facf4a8dSllai 	if (!device_exists(devlink) || lstat(devlink, &sb) != 0) {
45057c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FALSE);
45067c478bd9Sstevel@tonic-gate 	}
45077c478bd9Sstevel@tonic-gate 
450894c894bbSVikram Hegde 	raw_contents = NULL;
45097c478bd9Sstevel@tonic-gate 	type = 0;
451094c894bbSVikram Hegde 	if (resolve_link(devlink, &raw_contents, &type, NULL, 1) == TRUE) {
45117c478bd9Sstevel@tonic-gate 		rv = DEVFSADM_FALSE;
45127c478bd9Sstevel@tonic-gate 	} else {
45137c478bd9Sstevel@tonic-gate 		rv = DEVFSADM_TRUE;
45147c478bd9Sstevel@tonic-gate 	}
45157c478bd9Sstevel@tonic-gate 
451694c894bbSVikram Hegde 	/*
451794c894bbSVikram Hegde 	 * resolve alias paths for primary links
451894c894bbSVikram Hegde 	 */
451994c894bbSVikram Hegde 	contents = raw_contents;
452094c894bbSVikram Hegde 	if (type == DI_PRIMARY_LINK) {
452194c894bbSVikram Hegde 		contents = di_alias2curr(anynode, raw_contents);
452294c894bbSVikram Hegde 		free(raw_contents);
452394c894bbSVikram Hegde 	}
452494c894bbSVikram Hegde 
45257c478bd9Sstevel@tonic-gate 	/*
45267c478bd9Sstevel@tonic-gate 	 * The link exists. Add it to the database
45277c478bd9Sstevel@tonic-gate 	 */
45287c478bd9Sstevel@tonic-gate 	(void) di_devlink_add_link(devlink_cache, link, contents, type);
452945916cd2Sjpk 	if (system_labeled && (rv == DEVFSADM_TRUE) &&
453045916cd2Sjpk 	    strstr(devlink, DA_AUDIO_NAME) && contents) {
453145916cd2Sjpk 		(void) sscanf(contents, "%*[a-z]%d", &instance);
453245916cd2Sjpk 		(void) da_add_list(&devlist, devlink, instance,
453345916cd2Sjpk 		    DA_ADD|DA_AUDIO);
453445916cd2Sjpk 		_update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir);
453545916cd2Sjpk 	}
45367c478bd9Sstevel@tonic-gate 	free(contents);
45377c478bd9Sstevel@tonic-gate 
45387c478bd9Sstevel@tonic-gate 	return (rv);
45397c478bd9Sstevel@tonic-gate }
45407c478bd9Sstevel@tonic-gate 
45417c478bd9Sstevel@tonic-gate /*
45427c478bd9Sstevel@tonic-gate  * devpath: Absolute path to /dev link
45437c478bd9Sstevel@tonic-gate  * content_p: Returns malloced string (link content)
45447c478bd9Sstevel@tonic-gate  * type_p: Returns link type: primary or secondary
45457c478bd9Sstevel@tonic-gate  * devfs_path: Returns malloced string: /devices path w/out "/devices"
45467c478bd9Sstevel@tonic-gate  * dangle: if set, check if link is dangling
45477c478bd9Sstevel@tonic-gate  * Returns:
45487c478bd9Sstevel@tonic-gate  *	TRUE if dangling
45497c478bd9Sstevel@tonic-gate  *	FALSE if not or if caller doesn't care
45507c478bd9Sstevel@tonic-gate  * Caller is assumed to have initialized pointer contents to NULL
455194c894bbSVikram Hegde  *
45527c478bd9Sstevel@tonic-gate  */
45537c478bd9Sstevel@tonic-gate static int
45547c478bd9Sstevel@tonic-gate resolve_link(char *devpath, char **content_p, int *type_p, char **devfs_path,
45557c478bd9Sstevel@tonic-gate     int dangle)
45567c478bd9Sstevel@tonic-gate {
45577c478bd9Sstevel@tonic-gate 	char contents[PATH_MAX + 1];
45587c478bd9Sstevel@tonic-gate 	char stage_link[PATH_MAX + 1];
45597c478bd9Sstevel@tonic-gate 	char *fcn = "resolve_link: ";
45607c478bd9Sstevel@tonic-gate 	char *ptr;
45617c478bd9Sstevel@tonic-gate 	int linksize;
45627c478bd9Sstevel@tonic-gate 	int rv = TRUE;
45637c478bd9Sstevel@tonic-gate 	struct stat sb;
45647c478bd9Sstevel@tonic-gate 
456594c894bbSVikram Hegde 	/*
456694c894bbSVikram Hegde 	 * This routine will return the "raw" contents. It is upto the
456794c894bbSVikram Hegde 	 * the caller to redirect "alias" to "current" (or vice versa)
456894c894bbSVikram Hegde 	 */
45697c478bd9Sstevel@tonic-gate 	linksize = readlink(devpath, contents, PATH_MAX);
45707c478bd9Sstevel@tonic-gate 
45717c478bd9Sstevel@tonic-gate 	if (linksize <= 0) {
45727c478bd9Sstevel@tonic-gate 		return (FALSE);
45737c478bd9Sstevel@tonic-gate 	} else {
45747c478bd9Sstevel@tonic-gate 		contents[linksize] = '\0';
45757c478bd9Sstevel@tonic-gate 	}
45767c478bd9Sstevel@tonic-gate 	vprint(REMOVE_MID, "%s %s -> %s\n", fcn, devpath, contents);
45777c478bd9Sstevel@tonic-gate 
45787c478bd9Sstevel@tonic-gate 	if (content_p) {
45797c478bd9Sstevel@tonic-gate 		*content_p = s_strdup(contents);
45807c478bd9Sstevel@tonic-gate 	}
45817c478bd9Sstevel@tonic-gate 
45827c478bd9Sstevel@tonic-gate 	/*
45837c478bd9Sstevel@tonic-gate 	 * Check to see if this is a link pointing to another link in /dev.  The
45847c478bd9Sstevel@tonic-gate 	 * cheap way to do this is to look for a lack of ../devices/.
45857c478bd9Sstevel@tonic-gate 	 */
45867c478bd9Sstevel@tonic-gate 
45877c478bd9Sstevel@tonic-gate 	if (is_minor_node(contents, &ptr) == DEVFSADM_FALSE) {
45887c478bd9Sstevel@tonic-gate 
45897c478bd9Sstevel@tonic-gate 		if (type_p) {
45907c478bd9Sstevel@tonic-gate 			*type_p = DI_SECONDARY_LINK;
45917c478bd9Sstevel@tonic-gate 		}
45927c478bd9Sstevel@tonic-gate 
45937c478bd9Sstevel@tonic-gate 		/*
45947c478bd9Sstevel@tonic-gate 		 * assume that linkcontents is really a pointer to another
45957c478bd9Sstevel@tonic-gate 		 * link, and if so recurse and read its link contents.
45967c478bd9Sstevel@tonic-gate 		 */
45977c478bd9Sstevel@tonic-gate 		if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0)  {
45987c478bd9Sstevel@tonic-gate 			(void) strcpy(stage_link, dev_dir);
45997c478bd9Sstevel@tonic-gate 			(void) strcat(stage_link, "/");
46007c478bd9Sstevel@tonic-gate 			(void) strcpy(stage_link,
46010a653502Swroche 			    &contents[strlen(DEV) + strlen("/")]);
46027c478bd9Sstevel@tonic-gate 		} else {
46037c478bd9Sstevel@tonic-gate 			if ((ptr = strrchr(devpath, '/')) == NULL) {
46047c478bd9Sstevel@tonic-gate 				vprint(REMOVE_MID, "%s%s -> %s invalid link. "
46050a653502Swroche 				    "missing '/'\n", fcn, devpath, contents);
46067c478bd9Sstevel@tonic-gate 				return (TRUE);
46077c478bd9Sstevel@tonic-gate 			}
46087c478bd9Sstevel@tonic-gate 			*ptr = '\0';
46097c478bd9Sstevel@tonic-gate 			(void) strcpy(stage_link, devpath);
46107c478bd9Sstevel@tonic-gate 			*ptr = '/';
46117c478bd9Sstevel@tonic-gate 			(void) strcat(stage_link, "/");
46127c478bd9Sstevel@tonic-gate 			(void) strcat(stage_link, contents);
46137c478bd9Sstevel@tonic-gate 		}
46147c478bd9Sstevel@tonic-gate 		return (resolve_link(stage_link, NULL, NULL, devfs_path,
46157c478bd9Sstevel@tonic-gate 		    dangle));
46167c478bd9Sstevel@tonic-gate 	}
46177c478bd9Sstevel@tonic-gate 
46187c478bd9Sstevel@tonic-gate 	/* Current link points at a /devices minor node */
46197c478bd9Sstevel@tonic-gate 	if (type_p) {
46207c478bd9Sstevel@tonic-gate 		*type_p = DI_PRIMARY_LINK;
46217c478bd9Sstevel@tonic-gate 	}
46227c478bd9Sstevel@tonic-gate 
46237c478bd9Sstevel@tonic-gate 	if (devfs_path)
46247c478bd9Sstevel@tonic-gate 		*devfs_path = s_strdup(ptr);
46257c478bd9Sstevel@tonic-gate 
46267c478bd9Sstevel@tonic-gate 	rv = FALSE;
46277c478bd9Sstevel@tonic-gate 	if (dangle)
46287c478bd9Sstevel@tonic-gate 		rv = (stat(ptr - strlen(DEVICES), &sb) == -1);
46297c478bd9Sstevel@tonic-gate 
46307c478bd9Sstevel@tonic-gate 	vprint(REMOVE_MID, "%slink=%s, returning %s\n", fcn,
46310a653502Swroche 	    devpath, ((rv == TRUE) ? "TRUE" : "FALSE"));
46327c478bd9Sstevel@tonic-gate 
46337c478bd9Sstevel@tonic-gate 	return (rv);
46347c478bd9Sstevel@tonic-gate }
46357c478bd9Sstevel@tonic-gate 
46367c478bd9Sstevel@tonic-gate /*
46377c478bd9Sstevel@tonic-gate  * Returns the substring of interest, given a path.
46387c478bd9Sstevel@tonic-gate  */
46397c478bd9Sstevel@tonic-gate static char *
46407c478bd9Sstevel@tonic-gate alloc_cmp_str(const char *path, devfsadm_enumerate_t *dep)
46417c478bd9Sstevel@tonic-gate {
46427c478bd9Sstevel@tonic-gate 	uint_t match;
46437c478bd9Sstevel@tonic-gate 	char *np, *ap, *mp;
46447c478bd9Sstevel@tonic-gate 	char *cmp_str = NULL;
46457c478bd9Sstevel@tonic-gate 	char at[] = "@";
46467c478bd9Sstevel@tonic-gate 	char *fcn = "alloc_cmp_str";
46477c478bd9Sstevel@tonic-gate 
46487c478bd9Sstevel@tonic-gate 	np = ap = mp = NULL;
46497c478bd9Sstevel@tonic-gate 
46507c478bd9Sstevel@tonic-gate 	/*
46517c478bd9Sstevel@tonic-gate 	 * extract match flags from the flags argument.
46527c478bd9Sstevel@tonic-gate 	 */
46537c478bd9Sstevel@tonic-gate 	match = (dep->flags & MATCH_MASK);
46547c478bd9Sstevel@tonic-gate 
46557c478bd9Sstevel@tonic-gate 	vprint(ENUM_MID, "%s: enumeration match type: 0x%x"
46567c478bd9Sstevel@tonic-gate 	    " path: %s\n", fcn, match, path);
46577c478bd9Sstevel@tonic-gate 
46587c478bd9Sstevel@tonic-gate 	/*
46597c478bd9Sstevel@tonic-gate 	 * MATCH_CALLBACK and MATCH_ALL are the only flags
46607c478bd9Sstevel@tonic-gate 	 * which may be used if "path" is a /dev path
46617c478bd9Sstevel@tonic-gate 	 */
46627c478bd9Sstevel@tonic-gate 	if (match == MATCH_CALLBACK) {
46637c478bd9Sstevel@tonic-gate 		if (dep->sel_fcn == NULL) {
46647c478bd9Sstevel@tonic-gate 			vprint(ENUM_MID, "%s: invalid enumerate"
46657c478bd9Sstevel@tonic-gate 			    " callback: path: %s\n", fcn, path);
46667c478bd9Sstevel@tonic-gate 			return (NULL);
46677c478bd9Sstevel@tonic-gate 		}
46687c478bd9Sstevel@tonic-gate 		cmp_str = dep->sel_fcn(path, dep->cb_arg);
46697c478bd9Sstevel@tonic-gate 		return (cmp_str);
46707c478bd9Sstevel@tonic-gate 	}
46717c478bd9Sstevel@tonic-gate 
46727c478bd9Sstevel@tonic-gate 	cmp_str = s_strdup(path);
46737c478bd9Sstevel@tonic-gate 
46747c478bd9Sstevel@tonic-gate 	if (match == MATCH_ALL) {
46757c478bd9Sstevel@tonic-gate 		return (cmp_str);
46767c478bd9Sstevel@tonic-gate 	}
46777c478bd9Sstevel@tonic-gate 
46787c478bd9Sstevel@tonic-gate 	/*
46797c478bd9Sstevel@tonic-gate 	 * The remaining flags make sense only for /devices
46807c478bd9Sstevel@tonic-gate 	 * paths
46817c478bd9Sstevel@tonic-gate 	 */
46827c478bd9Sstevel@tonic-gate 	if ((mp = strrchr(cmp_str, ':')) == NULL) {
46837c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: invalid path: %s\n",
46847c478bd9Sstevel@tonic-gate 		    fcn, path);
46857c478bd9Sstevel@tonic-gate 		goto err;
46867c478bd9Sstevel@tonic-gate 	}
46877c478bd9Sstevel@tonic-gate 
46887c478bd9Sstevel@tonic-gate 	if (match == MATCH_MINOR) {
46897c478bd9Sstevel@tonic-gate 		/* A NULL "match_arg" values implies entire minor */
46907c478bd9Sstevel@tonic-gate 		if (get_component(mp + 1, dep->match_arg) == NULL) {
46917c478bd9Sstevel@tonic-gate 			vprint(ENUM_MID, "%s: invalid minor component:"
46927c478bd9Sstevel@tonic-gate 			    " path: %s\n", fcn, path);
46937c478bd9Sstevel@tonic-gate 			goto err;
46947c478bd9Sstevel@tonic-gate 		}
46957c478bd9Sstevel@tonic-gate 		return (cmp_str);
46967c478bd9Sstevel@tonic-gate 	}
46977c478bd9Sstevel@tonic-gate 
46987c478bd9Sstevel@tonic-gate 	if ((np = strrchr(cmp_str, '/')) == NULL) {
46997c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: invalid path: %s\n", fcn, path);
47007c478bd9Sstevel@tonic-gate 		goto err;
47017c478bd9Sstevel@tonic-gate 	}
47027c478bd9Sstevel@tonic-gate 
47037c478bd9Sstevel@tonic-gate 	if (match == MATCH_PARENT) {
47047c478bd9Sstevel@tonic-gate 		if (strcmp(cmp_str, "/") == 0) {
47057c478bd9Sstevel@tonic-gate 			vprint(ENUM_MID, "%s: invalid path: %s\n",
47067c478bd9Sstevel@tonic-gate 			    fcn, path);
47077c478bd9Sstevel@tonic-gate 			goto err;
47087c478bd9Sstevel@tonic-gate 		}
47097c478bd9Sstevel@tonic-gate 
47107c478bd9Sstevel@tonic-gate 		if (np == cmp_str) {
47117c478bd9Sstevel@tonic-gate 			*(np + 1) = '\0';
47127c478bd9Sstevel@tonic-gate 		} else {
47137c478bd9Sstevel@tonic-gate 			*np = '\0';
47147c478bd9Sstevel@tonic-gate 		}
47157c478bd9Sstevel@tonic-gate 		return (cmp_str);
47167c478bd9Sstevel@tonic-gate 	}
47177c478bd9Sstevel@tonic-gate 
47187c478bd9Sstevel@tonic-gate 	/* ap can be NULL - Leaf address may not exist or be empty string */
47197c478bd9Sstevel@tonic-gate 	ap = strchr(np+1, '@');
47207c478bd9Sstevel@tonic-gate 
47217c478bd9Sstevel@tonic-gate 	/* minor is no longer of interest */
47227c478bd9Sstevel@tonic-gate 	*mp = '\0';
47237c478bd9Sstevel@tonic-gate 
47247c478bd9Sstevel@tonic-gate 	if (match == MATCH_NODE) {
47257c478bd9Sstevel@tonic-gate 		if (ap)
47267c478bd9Sstevel@tonic-gate 			*ap = '\0';
47277c478bd9Sstevel@tonic-gate 		return (cmp_str);
47287c478bd9Sstevel@tonic-gate 	} else if (match == MATCH_ADDR) {
47297c478bd9Sstevel@tonic-gate 		/*
47307c478bd9Sstevel@tonic-gate 		 * The empty string is a valid address. The only MATCH_ADDR
47317c478bd9Sstevel@tonic-gate 		 * allowed in this case is against the whole address or
47327c478bd9Sstevel@tonic-gate 		 * the first component of the address (match_arg=NULL/"0"/"1")
47337c478bd9Sstevel@tonic-gate 		 * Note that in this case, the path won't have an "@"
47347c478bd9Sstevel@tonic-gate 		 * As a result ap will be NULL. We fake up an ap = @'\0'
47357c478bd9Sstevel@tonic-gate 		 * so that get_component() will work correctly.
47367c478bd9Sstevel@tonic-gate 		 */
47377c478bd9Sstevel@tonic-gate 		if (ap == NULL) {
47387c478bd9Sstevel@tonic-gate 			ap = at;
47397c478bd9Sstevel@tonic-gate 		}
47407c478bd9Sstevel@tonic-gate 
47417c478bd9Sstevel@tonic-gate 		if (get_component(ap + 1, dep->match_arg) == NULL) {
47427c478bd9Sstevel@tonic-gate 			vprint(ENUM_MID, "%s: invalid leaf addr. component:"
47437c478bd9Sstevel@tonic-gate 			    " path: %s\n", fcn, path);
47447c478bd9Sstevel@tonic-gate 			goto err;
47457c478bd9Sstevel@tonic-gate 		}
47467c478bd9Sstevel@tonic-gate 		return (cmp_str);
47477c478bd9Sstevel@tonic-gate 	}
47487c478bd9Sstevel@tonic-gate 
47497c478bd9Sstevel@tonic-gate 	vprint(ENUM_MID, "%s: invalid enumeration flags: 0x%x"
47500a653502Swroche 	    " path: %s\n", fcn, dep->flags, path);
47517c478bd9Sstevel@tonic-gate 
47527c478bd9Sstevel@tonic-gate 	/*FALLTHRU*/
47537c478bd9Sstevel@tonic-gate err:
47547c478bd9Sstevel@tonic-gate 	free(cmp_str);
47557c478bd9Sstevel@tonic-gate 	return (NULL);
47567c478bd9Sstevel@tonic-gate }
47577c478bd9Sstevel@tonic-gate 
47587c478bd9Sstevel@tonic-gate 
47597c478bd9Sstevel@tonic-gate /*
47607c478bd9Sstevel@tonic-gate  * "str" is expected to be a string with components separated by ','
47617c478bd9Sstevel@tonic-gate  * The terminating null char is considered a separator.
47627c478bd9Sstevel@tonic-gate  * get_component() will remove the portion of the string beyond
47637c478bd9Sstevel@tonic-gate  * the component indicated.
47647c478bd9Sstevel@tonic-gate  * If comp_str is NULL, the entire "str" is returned.
47657c478bd9Sstevel@tonic-gate  */
47667c478bd9Sstevel@tonic-gate static char *
47677c478bd9Sstevel@tonic-gate get_component(char *str, const char *comp_str)
47687c478bd9Sstevel@tonic-gate {
47697c478bd9Sstevel@tonic-gate 	long comp;
47707c478bd9Sstevel@tonic-gate 	char *cp;
47717c478bd9Sstevel@tonic-gate 
47727c478bd9Sstevel@tonic-gate 	if (str == NULL) {
47737c478bd9Sstevel@tonic-gate 		return (NULL);
47747c478bd9Sstevel@tonic-gate 	}
47757c478bd9Sstevel@tonic-gate 
47767c478bd9Sstevel@tonic-gate 	if (comp_str == NULL) {
47777c478bd9Sstevel@tonic-gate 		return (str);
47787c478bd9Sstevel@tonic-gate 	}
47797c478bd9Sstevel@tonic-gate 
47807c478bd9Sstevel@tonic-gate 	errno = 0;
47817c478bd9Sstevel@tonic-gate 	comp = strtol(comp_str, &cp, 10);
47827c478bd9Sstevel@tonic-gate 	if (errno != 0 || *cp != '\0' || comp < 0) {
47837c478bd9Sstevel@tonic-gate 		return (NULL);
47847c478bd9Sstevel@tonic-gate 	}
47857c478bd9Sstevel@tonic-gate 
47867c478bd9Sstevel@tonic-gate 	if (comp == 0)
47877c478bd9Sstevel@tonic-gate 		return (str);
47887c478bd9Sstevel@tonic-gate 
47897c478bd9Sstevel@tonic-gate 	for (cp = str; ; cp++) {
47907c478bd9Sstevel@tonic-gate 		if (*cp == ',' || *cp == '\0')
47917c478bd9Sstevel@tonic-gate 			comp--;
47927c478bd9Sstevel@tonic-gate 		if (*cp == '\0' || comp <= 0) {
47937c478bd9Sstevel@tonic-gate 			break;
47947c478bd9Sstevel@tonic-gate 		}
47957c478bd9Sstevel@tonic-gate 	}
47967c478bd9Sstevel@tonic-gate 
47977c478bd9Sstevel@tonic-gate 	if (comp == 0) {
47987c478bd9Sstevel@tonic-gate 		*cp = '\0';
47997c478bd9Sstevel@tonic-gate 	} else {
48007c478bd9Sstevel@tonic-gate 		str = NULL;
48017c478bd9Sstevel@tonic-gate 	}
48027c478bd9Sstevel@tonic-gate 
48037c478bd9Sstevel@tonic-gate 	return (str);
48047c478bd9Sstevel@tonic-gate }
48057c478bd9Sstevel@tonic-gate 
48067c478bd9Sstevel@tonic-gate 
48077c478bd9Sstevel@tonic-gate /*
48087c478bd9Sstevel@tonic-gate  * Enumerate serves as a generic counter as well as a means to determine
48097c478bd9Sstevel@tonic-gate  * logical unit/controller numbers for such items as disk and tape
48107c478bd9Sstevel@tonic-gate  * drives.
48117c478bd9Sstevel@tonic-gate  *
48127c478bd9Sstevel@tonic-gate  * rules[] is an array of  devfsadm_enumerate_t structures which defines
48137c478bd9Sstevel@tonic-gate  * the enumeration rules to be used for a specified set of links in /dev.
48147c478bd9Sstevel@tonic-gate  * The set of links is specified through regular expressions (of the flavor
48157c478bd9Sstevel@tonic-gate  * described in regex(5)). These regular expressions are used to determine
48167c478bd9Sstevel@tonic-gate  * the set of links in /dev to examine. The last path component in these
48177c478bd9Sstevel@tonic-gate  * regular expressions MUST contain a parenthesized subexpression surrounding
48187c478bd9Sstevel@tonic-gate  * the RE which is to be considered the enumerating component. The subexp
48197c478bd9Sstevel@tonic-gate  * member in a rule is the subexpression number of the enumerating
48207c478bd9Sstevel@tonic-gate  * component. Subexpressions in the last path component are numbered starting
48217c478bd9Sstevel@tonic-gate  * from 1.
48227c478bd9Sstevel@tonic-gate  *
48237c478bd9Sstevel@tonic-gate  * A cache of current id assignments is built up from existing symlinks and
48247c478bd9Sstevel@tonic-gate  * new assignments use the lowest unused id. Assignments are based on a
48257c478bd9Sstevel@tonic-gate  * match of a specified substring of a symlink's contents. If the specified
48267c478bd9Sstevel@tonic-gate  * component for the devfs_path argument matches the corresponding substring
48277c478bd9Sstevel@tonic-gate  * for a existing symlink's contents, the cached id is returned. Else, a new
48287c478bd9Sstevel@tonic-gate  * id is created and returned in *buf. *buf must be freed by the caller.
48297c478bd9Sstevel@tonic-gate  *
48307c478bd9Sstevel@tonic-gate  * An id assignment may be governed by a combination of rules, each rule
48317c478bd9Sstevel@tonic-gate  * applicable to a different subset of links in /dev. For example, controller
48327c478bd9Sstevel@tonic-gate  * numbers may be determined by a combination of disk symlinks in /dev/[r]dsk
48337c478bd9Sstevel@tonic-gate  * and controller symlinks in /dev/cfg, with the two sets requiring different
48347c478bd9Sstevel@tonic-gate  * rules to derive the "substring of interest". In such cases, the rules
48357c478bd9Sstevel@tonic-gate  * array will have more than one element.
48367c478bd9Sstevel@tonic-gate  */
48377c478bd9Sstevel@tonic-gate int
48387c478bd9Sstevel@tonic-gate devfsadm_enumerate_int(char *devfs_path, int index, char **buf,
48397c478bd9Sstevel@tonic-gate 			devfsadm_enumerate_t rules[], int nrules)
48407c478bd9Sstevel@tonic-gate {
48417c478bd9Sstevel@tonic-gate 	return (find_enum_id(rules, nrules,
48427c478bd9Sstevel@tonic-gate 	    devfs_path, index, "0", INTEGER, buf, 0));
48437c478bd9Sstevel@tonic-gate }
48447c478bd9Sstevel@tonic-gate 
48457c478bd9Sstevel@tonic-gate int
48467c478bd9Sstevel@tonic-gate disk_enumerate_int(char *devfs_path, int index, char **buf,
48477c478bd9Sstevel@tonic-gate     devfsadm_enumerate_t rules[], int nrules)
48487c478bd9Sstevel@tonic-gate {
48497c478bd9Sstevel@tonic-gate 	return (find_enum_id(rules, nrules,
48507c478bd9Sstevel@tonic-gate 	    devfs_path, index, "0", INTEGER, buf, 1));
48517c478bd9Sstevel@tonic-gate }
48527c478bd9Sstevel@tonic-gate 
48537c478bd9Sstevel@tonic-gate /*
48547c478bd9Sstevel@tonic-gate  * Same as above, but allows a starting value to be specified.
48557c478bd9Sstevel@tonic-gate  * Private to devfsadm.... used by devlinks.
48567c478bd9Sstevel@tonic-gate  */
48577c478bd9Sstevel@tonic-gate static int
48587c478bd9Sstevel@tonic-gate devfsadm_enumerate_int_start(char *devfs_path, int index, char **buf,
48597c478bd9Sstevel@tonic-gate 		devfsadm_enumerate_t rules[], int nrules, char *start)
48607c478bd9Sstevel@tonic-gate {
48617c478bd9Sstevel@tonic-gate 	return (find_enum_id(rules, nrules,
48627c478bd9Sstevel@tonic-gate 	    devfs_path, index, start, INTEGER, buf, 0));
48637c478bd9Sstevel@tonic-gate }
48647c478bd9Sstevel@tonic-gate 
48657c478bd9Sstevel@tonic-gate /*
48667c478bd9Sstevel@tonic-gate  *  devfsadm_enumerate_char serves as a generic counter returning
48677c478bd9Sstevel@tonic-gate  *  a single letter.
48687c478bd9Sstevel@tonic-gate  */
48697c478bd9Sstevel@tonic-gate int
48707c478bd9Sstevel@tonic-gate devfsadm_enumerate_char(char *devfs_path, int index, char **buf,
48717c478bd9Sstevel@tonic-gate 			devfsadm_enumerate_t rules[], int nrules)
48727c478bd9Sstevel@tonic-gate {
48737c478bd9Sstevel@tonic-gate 	return (find_enum_id(rules, nrules,
48747c478bd9Sstevel@tonic-gate 	    devfs_path, index, "a", LETTER, buf, 0));
48757c478bd9Sstevel@tonic-gate }
48767c478bd9Sstevel@tonic-gate 
48777c478bd9Sstevel@tonic-gate /*
48787c478bd9Sstevel@tonic-gate  * Same as above, but allows a starting char to be specified.
48797c478bd9Sstevel@tonic-gate  * Private to devfsadm - used by ports module (port_link.c)
48807c478bd9Sstevel@tonic-gate  */
48817c478bd9Sstevel@tonic-gate int
48827c478bd9Sstevel@tonic-gate devfsadm_enumerate_char_start(char *devfs_path, int index, char **buf,
48837c478bd9Sstevel@tonic-gate 	devfsadm_enumerate_t rules[], int nrules, char *start)
48847c478bd9Sstevel@tonic-gate {
48857c478bd9Sstevel@tonic-gate 	return (find_enum_id(rules, nrules,
48867c478bd9Sstevel@tonic-gate 	    devfs_path, index, start, LETTER, buf, 0));
48877c478bd9Sstevel@tonic-gate }
48887c478bd9Sstevel@tonic-gate 
48897c478bd9Sstevel@tonic-gate 
48907c478bd9Sstevel@tonic-gate /*
48917c478bd9Sstevel@tonic-gate  * For a given numeral_set (see get_cached_set for desc of numeral_set),
48927c478bd9Sstevel@tonic-gate  * search all cached entries looking for matches on a specified substring
48937c478bd9Sstevel@tonic-gate  * of devfs_path. The substring is derived from devfs_path based on the
48947c478bd9Sstevel@tonic-gate  * rule specified by "index". If a match is found on a cached entry,
48957c478bd9Sstevel@tonic-gate  * return the enumerated id in buf. Otherwise, create a new id by calling
48967c478bd9Sstevel@tonic-gate  * new_id, then cache and return that entry.
48977c478bd9Sstevel@tonic-gate  */
48987c478bd9Sstevel@tonic-gate static int
48997c478bd9Sstevel@tonic-gate find_enum_id(devfsadm_enumerate_t rules[], int nrules,
49007c478bd9Sstevel@tonic-gate 	char *devfs_path, int index, char *min, int type, char **buf,
49017c478bd9Sstevel@tonic-gate 	int multiple)
49027c478bd9Sstevel@tonic-gate {
49037c478bd9Sstevel@tonic-gate 	numeral_t *matchnp;
49047c478bd9Sstevel@tonic-gate 	numeral_t *numeral;
49057c478bd9Sstevel@tonic-gate 	int matchcount = 0;
49067c478bd9Sstevel@tonic-gate 	char *cmp_str;
49077c478bd9Sstevel@tonic-gate 	char *fcn = "find_enum_id";
49087c478bd9Sstevel@tonic-gate 	numeral_set_t *set;
49097c478bd9Sstevel@tonic-gate 
49107c478bd9Sstevel@tonic-gate 	if (rules == NULL) {
49117c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: no rules. path: %s\n",
49127c478bd9Sstevel@tonic-gate 		    fcn, devfs_path ? devfs_path : "<NULL path>");
49137c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
49147c478bd9Sstevel@tonic-gate 	}
49157c478bd9Sstevel@tonic-gate 
49167c478bd9Sstevel@tonic-gate 	if (devfs_path == NULL) {
49177c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: NULL path\n", fcn);
49187c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
49197c478bd9Sstevel@tonic-gate 	}
49207c478bd9Sstevel@tonic-gate 
49217c478bd9Sstevel@tonic-gate 	if (nrules <= 0 || index < 0 || index >= nrules || buf == NULL) {
49227c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: invalid arguments. path: %s\n",
49237c478bd9Sstevel@tonic-gate 		    fcn, devfs_path);
49247c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
49257c478bd9Sstevel@tonic-gate 	}
49267c478bd9Sstevel@tonic-gate 
49277c478bd9Sstevel@tonic-gate 	*buf = NULL;
49287c478bd9Sstevel@tonic-gate 
49297c478bd9Sstevel@tonic-gate 
49307c478bd9Sstevel@tonic-gate 	cmp_str = alloc_cmp_str(devfs_path, &rules[index]);
49317c478bd9Sstevel@tonic-gate 	if (cmp_str == NULL) {
49327c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
49337c478bd9Sstevel@tonic-gate 	}
49347c478bd9Sstevel@tonic-gate 
49357c478bd9Sstevel@tonic-gate 	if ((set = get_enum_cache(rules, nrules)) == NULL) {
49367c478bd9Sstevel@tonic-gate 		free(cmp_str);
49377c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
49387c478bd9Sstevel@tonic-gate 	}
49397c478bd9Sstevel@tonic-gate 
49407c478bd9Sstevel@tonic-gate 	assert(nrules == set->re_count);
49417c478bd9Sstevel@tonic-gate 
49427c478bd9Sstevel@tonic-gate 	/*
49437c478bd9Sstevel@tonic-gate 	 * Check and see if a matching entry is already cached.
49447c478bd9Sstevel@tonic-gate 	 */
49457c478bd9Sstevel@tonic-gate 	matchcount = lookup_enum_cache(set, cmp_str, rules, index,
49467c478bd9Sstevel@tonic-gate 	    &matchnp);
49477c478bd9Sstevel@tonic-gate 
49487c478bd9Sstevel@tonic-gate 	if (matchcount < 0 || matchcount > 1) {
49497c478bd9Sstevel@tonic-gate 		free(cmp_str);
49507c478bd9Sstevel@tonic-gate 		if (multiple && matchcount > 1)
49517c478bd9Sstevel@tonic-gate 			return (DEVFSADM_MULTIPLE);
49527c478bd9Sstevel@tonic-gate 		else
49537c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
49547c478bd9Sstevel@tonic-gate 	}
49557c478bd9Sstevel@tonic-gate 
49567c478bd9Sstevel@tonic-gate 	/* if matching entry already cached, return it */
49577c478bd9Sstevel@tonic-gate 	if (matchcount == 1) {
49588d483882Smlf 		/* should never create a link with a reserved ID */
49598d483882Smlf 		vprint(ENUM_MID, "%s: 1 match w/ ID: %s\n", fcn, matchnp->id);
49608d483882Smlf 		assert(matchnp->flags == 0);
49617c478bd9Sstevel@tonic-gate 		*buf = s_strdup(matchnp->id);
49627c478bd9Sstevel@tonic-gate 		free(cmp_str);
49637c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
49647c478bd9Sstevel@tonic-gate 	}
49657c478bd9Sstevel@tonic-gate 
49667c478bd9Sstevel@tonic-gate 	/*
49677c478bd9Sstevel@tonic-gate 	 * no cached entry, initialize a numeral struct
49687c478bd9Sstevel@tonic-gate 	 * by calling new_id() and cache onto the numeral_set
49697c478bd9Sstevel@tonic-gate 	 */
49707c478bd9Sstevel@tonic-gate 	numeral = s_malloc(sizeof (numeral_t));
49717c478bd9Sstevel@tonic-gate 	numeral->id = new_id(set->headnumeral, type, min);
49727c478bd9Sstevel@tonic-gate 	numeral->full_path = s_strdup(devfs_path);
49737c478bd9Sstevel@tonic-gate 	numeral->rule_index = index;
49747c478bd9Sstevel@tonic-gate 	numeral->cmp_str = cmp_str;
49757c478bd9Sstevel@tonic-gate 	cmp_str = NULL;
49768d483882Smlf 	numeral->flags = 0;
49778d483882Smlf 	vprint(RSRV_MID, "%s: alloc new_id: %s numeral flags = %d\n",
49788d483882Smlf 	    fcn, numeral->id, numeral->flags);
49798d483882Smlf 
49807c478bd9Sstevel@tonic-gate 
49817c478bd9Sstevel@tonic-gate 	/* insert to head of list for fast lookups */
49827c478bd9Sstevel@tonic-gate 	numeral->next = set->headnumeral;
49837c478bd9Sstevel@tonic-gate 	set->headnumeral = numeral;
49847c478bd9Sstevel@tonic-gate 
49857c478bd9Sstevel@tonic-gate 	*buf = s_strdup(numeral->id);
49867c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
49877c478bd9Sstevel@tonic-gate }
49887c478bd9Sstevel@tonic-gate 
49897c478bd9Sstevel@tonic-gate 
49907c478bd9Sstevel@tonic-gate /*
49917c478bd9Sstevel@tonic-gate  * Looks up the specified cache for a match with a specified string
49927c478bd9Sstevel@tonic-gate  * Returns:
49937c478bd9Sstevel@tonic-gate  *	-1	: on error.
49947c478bd9Sstevel@tonic-gate  *	0/1/2	: Number of matches.
49957c478bd9Sstevel@tonic-gate  * Returns the matching element only if there is a single match.
49967c478bd9Sstevel@tonic-gate  * If the "uncached" flag is set, derives the "cmp_str" afresh
49977c478bd9Sstevel@tonic-gate  * for the match instead of using cached values.
49987c478bd9Sstevel@tonic-gate  */
49997c478bd9Sstevel@tonic-gate static int
50007c478bd9Sstevel@tonic-gate lookup_enum_cache(numeral_set_t *set, char *cmp_str,
50017c478bd9Sstevel@tonic-gate 	devfsadm_enumerate_t rules[], int index, numeral_t **matchnpp)
50027c478bd9Sstevel@tonic-gate {
50037c478bd9Sstevel@tonic-gate 	int matchcount = 0, rv = -1;
50047c478bd9Sstevel@tonic-gate 	int uncached;
50057c478bd9Sstevel@tonic-gate 	numeral_t *np;
50067c478bd9Sstevel@tonic-gate 	char *fcn = "lookup_enum_cache";
50077c478bd9Sstevel@tonic-gate 	char *cp;
50087c478bd9Sstevel@tonic-gate 
50097c478bd9Sstevel@tonic-gate 	*matchnpp = NULL;
50107c478bd9Sstevel@tonic-gate 
50117c478bd9Sstevel@tonic-gate 	assert(index < set->re_count);
50127c478bd9Sstevel@tonic-gate 
50137c478bd9Sstevel@tonic-gate 	if (cmp_str == NULL) {
50147c478bd9Sstevel@tonic-gate 		return (-1);
50157c478bd9Sstevel@tonic-gate 	}
50167c478bd9Sstevel@tonic-gate 
50177c478bd9Sstevel@tonic-gate 	uncached = 0;
50187c478bd9Sstevel@tonic-gate 	if ((rules[index].flags & MATCH_UNCACHED) == MATCH_UNCACHED) {
50197c478bd9Sstevel@tonic-gate 		uncached = 1;
50207c478bd9Sstevel@tonic-gate 	}
50217c478bd9Sstevel@tonic-gate 
50227c478bd9Sstevel@tonic-gate 	/*
50237c478bd9Sstevel@tonic-gate 	 * Check and see if a matching entry is already cached.
50247c478bd9Sstevel@tonic-gate 	 */
50257c478bd9Sstevel@tonic-gate 	for (np = set->headnumeral; np != NULL; np = np->next) {
50268d483882Smlf 
50278d483882Smlf 		/*
50288d483882Smlf 		 * Skip reserved IDs
50298d483882Smlf 		 */
50308d483882Smlf 		if (np->flags & NUMERAL_RESERVED) {
50318d483882Smlf 			vprint(RSRV_MID, "lookup_enum_cache: "
50328d483882Smlf 			    "Cannot Match with reserved ID (%s), "
50338d483882Smlf 			    "skipping\n", np->id);
50348d483882Smlf 			assert(np->flags == NUMERAL_RESERVED);
50358d483882Smlf 			continue;
50368d483882Smlf 		} else {
50378d483882Smlf 			vprint(RSRV_MID, "lookup_enum_cache: "
50388d483882Smlf 			    "Attempting match with numeral ID: %s"
50398d483882Smlf 			    " numeral flags = %d\n", np->id, np->flags);
50408d483882Smlf 			assert(np->flags == 0);
50418d483882Smlf 		}
50428d483882Smlf 
50437c478bd9Sstevel@tonic-gate 		if (np->cmp_str == NULL) {
50447c478bd9Sstevel@tonic-gate 			vprint(ENUM_MID, "%s: invalid entry in enumerate"
50457c478bd9Sstevel@tonic-gate 			    " cache. path: %s\n", fcn, np->full_path);
50467c478bd9Sstevel@tonic-gate 			return (-1);
50477c478bd9Sstevel@tonic-gate 		}
50487c478bd9Sstevel@tonic-gate 
50497c478bd9Sstevel@tonic-gate 		if (uncached) {
50507c478bd9Sstevel@tonic-gate 			vprint(CHATTY_MID, "%s: bypassing enumerate cache."
50517c478bd9Sstevel@tonic-gate 			    " path: %s\n", fcn, cmp_str);
50527c478bd9Sstevel@tonic-gate 			cp = alloc_cmp_str(np->full_path,
50537c478bd9Sstevel@tonic-gate 			    &rules[np->rule_index]);
50547c478bd9Sstevel@tonic-gate 			if (cp == NULL)
50557c478bd9Sstevel@tonic-gate 				return (-1);
50567c478bd9Sstevel@tonic-gate 			rv = strcmp(cmp_str, cp);
50577c478bd9Sstevel@tonic-gate 			free(cp);
50587c478bd9Sstevel@tonic-gate 		} else {
50597c478bd9Sstevel@tonic-gate 			rv = strcmp(cmp_str, np->cmp_str);
50607c478bd9Sstevel@tonic-gate 		}
50617c478bd9Sstevel@tonic-gate 
50627c478bd9Sstevel@tonic-gate 		if (rv == 0) {
50637c478bd9Sstevel@tonic-gate 			if (matchcount++ != 0) {
50647c478bd9Sstevel@tonic-gate 				break; /* more than 1 match. */
50657c478bd9Sstevel@tonic-gate 			}
50667c478bd9Sstevel@tonic-gate 			*matchnpp = np;
50677c478bd9Sstevel@tonic-gate 		}
50687c478bd9Sstevel@tonic-gate 	}
50697c478bd9Sstevel@tonic-gate 
50707c478bd9Sstevel@tonic-gate 	return (matchcount);
50717c478bd9Sstevel@tonic-gate }
50727c478bd9Sstevel@tonic-gate 
50737c478bd9Sstevel@tonic-gate #ifdef	DEBUG
50747c478bd9Sstevel@tonic-gate static void
50757c478bd9Sstevel@tonic-gate dump_enum_cache(numeral_set_t *setp)
50767c478bd9Sstevel@tonic-gate {
50777c478bd9Sstevel@tonic-gate 	int i;
50787c478bd9Sstevel@tonic-gate 	numeral_t *np;
50797c478bd9Sstevel@tonic-gate 	char *fcn = "dump_enum_cache";
50807c478bd9Sstevel@tonic-gate 
50817c478bd9Sstevel@tonic-gate 	vprint(ENUM_MID, "%s: re_count = %d\n", fcn, setp->re_count);
50827c478bd9Sstevel@tonic-gate 	for (i = 0; i < setp->re_count; i++) {
50837c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: re[%d] = %s\n", fcn, i, setp->re[i]);
50847c478bd9Sstevel@tonic-gate 	}
50857c478bd9Sstevel@tonic-gate 
50867c478bd9Sstevel@tonic-gate 	for (np = setp->headnumeral; np != NULL; np = np->next) {
50877c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: id: %s\n", fcn, np->id);
50887c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: full_path: %s\n", fcn, np->full_path);
50897c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: rule_index: %d\n", fcn, np->rule_index);
50907c478bd9Sstevel@tonic-gate 		vprint(ENUM_MID, "%s: cmp_str: %s\n", fcn, np->cmp_str);
50918d483882Smlf 		vprint(ENUM_MID, "%s: flags: %d\n", fcn, np->flags);
50927c478bd9Sstevel@tonic-gate 	}
50937c478bd9Sstevel@tonic-gate }
50947c478bd9Sstevel@tonic-gate #endif
50957c478bd9Sstevel@tonic-gate 
50967c478bd9Sstevel@tonic-gate /*
50977c478bd9Sstevel@tonic-gate  * For a given set of regular expressions in rules[], this function returns
50987c478bd9Sstevel@tonic-gate  * either a previously cached struct numeral_set or it will create and
50997c478bd9Sstevel@tonic-gate  * cache a new struct numeral_set.  There is only one struct numeral_set
51007c478bd9Sstevel@tonic-gate  * for the combination of REs present in rules[].  Each numeral_set contains
51017c478bd9Sstevel@tonic-gate  * the regular expressions in rules[] used for cache selection AND a linked
51027c478bd9Sstevel@tonic-gate  * list of struct numerals, ONE FOR EACH *UNIQUE* numeral or character ID
51037c478bd9Sstevel@tonic-gate  * selected by the grouping parenthesized subexpression found in the last
51047c478bd9Sstevel@tonic-gate  * path component of each rules[].re.  For example, the RE: "rmt/([0-9]+)"
51057c478bd9Sstevel@tonic-gate  * selects all the logical nodes of the correct form in dev/rmt/.
51067c478bd9Sstevel@tonic-gate  * Each rmt/X will store a *single* struct numeral... ie 0, 1, 2 each get a
51077c478bd9Sstevel@tonic-gate  * single struct numeral. There is no need to store more than a single logical
51087c478bd9Sstevel@tonic-gate  * node matching X since the information desired in the devfspath would be
51097c478bd9Sstevel@tonic-gate  * identical for the portion of the devfspath of interest. (the part up to,
51107c478bd9Sstevel@tonic-gate  * but not including the minor name in this example.)
51117c478bd9Sstevel@tonic-gate  *
51127c478bd9Sstevel@tonic-gate  * If the given numeral_set is not yet cached, call enumerate_recurse to
51137c478bd9Sstevel@tonic-gate  * create it.
51147c478bd9Sstevel@tonic-gate  */
51157c478bd9Sstevel@tonic-gate static numeral_set_t *
51167c478bd9Sstevel@tonic-gate get_enum_cache(devfsadm_enumerate_t rules[], int nrules)
51177c478bd9Sstevel@tonic-gate {
51187c478bd9Sstevel@tonic-gate 	/* linked list of numeral sets */
51197c478bd9Sstevel@tonic-gate 	numeral_set_t *setp;
51207c478bd9Sstevel@tonic-gate 	int i;
51218d483882Smlf 	int ret;
51227c478bd9Sstevel@tonic-gate 	char *path_left;
51238d483882Smlf 	enumerate_file_t *entry;
51247c478bd9Sstevel@tonic-gate 	char *fcn = "get_enum_cache";
51257c478bd9Sstevel@tonic-gate 
51267c478bd9Sstevel@tonic-gate 	/*
51277c478bd9Sstevel@tonic-gate 	 * See if we've already cached this numeral set.
51287c478bd9Sstevel@tonic-gate 	 */
51297c478bd9Sstevel@tonic-gate 	for (setp = head_numeral_set; setp != NULL; setp = setp->next) {
51307c478bd9Sstevel@tonic-gate 		/*
51317c478bd9Sstevel@tonic-gate 		 *  check all regexp's passed in function against
51327c478bd9Sstevel@tonic-gate 		 *  those in cached set.
51337c478bd9Sstevel@tonic-gate 		 */
51347c478bd9Sstevel@tonic-gate 		if (nrules != setp->re_count) {
51357c478bd9Sstevel@tonic-gate 			continue;
51367c478bd9Sstevel@tonic-gate 		}
51377c478bd9Sstevel@tonic-gate 
51387c478bd9Sstevel@tonic-gate 		for (i = 0; i < nrules; i++) {
51397c478bd9Sstevel@tonic-gate 			if (strcmp(setp->re[i], rules[i].re) != 0) {
51407c478bd9Sstevel@tonic-gate 				break;
51417c478bd9Sstevel@tonic-gate 			}
51427c478bd9Sstevel@tonic-gate 		}
51437c478bd9Sstevel@tonic-gate 
51447c478bd9Sstevel@tonic-gate 		if (i == nrules) {
51457c478bd9Sstevel@tonic-gate 			return (setp);
51467c478bd9Sstevel@tonic-gate 		}
51477c478bd9Sstevel@tonic-gate 	}
51487c478bd9Sstevel@tonic-gate 
51497c478bd9Sstevel@tonic-gate 	/*
51507c478bd9Sstevel@tonic-gate 	 * If the MATCH_UNCACHED flag is set, we should not  be here.
51517c478bd9Sstevel@tonic-gate 	 */
51527c478bd9Sstevel@tonic-gate 	for (i = 0; i < nrules; i++) {
51537c478bd9Sstevel@tonic-gate 		if ((rules[i].flags & MATCH_UNCACHED) == MATCH_UNCACHED) {
51547c478bd9Sstevel@tonic-gate 			vprint(ENUM_MID, "%s: invalid enumeration flags: "
51557c478bd9Sstevel@tonic-gate 			    "0x%x\n", fcn, rules[i].flags);
51567c478bd9Sstevel@tonic-gate 			return (NULL);
51577c478bd9Sstevel@tonic-gate 		}
51587c478bd9Sstevel@tonic-gate 	}
51597c478bd9Sstevel@tonic-gate 
51607c478bd9Sstevel@tonic-gate 	/*
51617c478bd9Sstevel@tonic-gate 	 *  Since we made it here, we have not yet cached the given set of
51627c478bd9Sstevel@tonic-gate 	 *  logical nodes matching the passed re.  Create a cached entry
51637c478bd9Sstevel@tonic-gate 	 *  struct numeral_set and populate it with a minimal set of
51647c478bd9Sstevel@tonic-gate 	 *  logical nodes from /dev.
51657c478bd9Sstevel@tonic-gate 	 */
51667c478bd9Sstevel@tonic-gate 
51677c478bd9Sstevel@tonic-gate 	setp = s_malloc(sizeof (numeral_set_t));
51687c478bd9Sstevel@tonic-gate 	setp->re = s_malloc(sizeof (char *) * nrules);
51697c478bd9Sstevel@tonic-gate 	for (i = 0; i < nrules; i++) {
51707c478bd9Sstevel@tonic-gate 		setp->re[i] = s_strdup(rules[i].re);
51717c478bd9Sstevel@tonic-gate 	}
51727c478bd9Sstevel@tonic-gate 	setp->re_count = nrules;
51737c478bd9Sstevel@tonic-gate 	setp->headnumeral = NULL;
51747c478bd9Sstevel@tonic-gate 
51757c478bd9Sstevel@tonic-gate 	/* put this new cached set on the cached set list */
51767c478bd9Sstevel@tonic-gate 	setp->next = head_numeral_set;
51777c478bd9Sstevel@tonic-gate 	head_numeral_set = setp;
51787c478bd9Sstevel@tonic-gate 
51798d483882Smlf 	/*
51808d483882Smlf 	 * For each RE, search the "reserved" list to create numeral IDs that
51818d483882Smlf 	 * are reserved.
51828d483882Smlf 	 */
51838d483882Smlf 	for (entry = enumerate_reserved; entry; entry = entry->er_next) {
51848d483882Smlf 
51858d483882Smlf 		vprint(RSRV_MID, "parsing rstring: %s\n", entry->er_file);
51868d483882Smlf 
51878d483882Smlf 		for (i = 0; i < nrules; i++) {
51888d483882Smlf 			path_left = s_strdup(setp->re[i]);
51898d483882Smlf 			vprint(RSRV_MID, "parsing rule RE: %s\n", path_left);
51908d483882Smlf 			ret = enumerate_parse(entry->er_file, path_left,
51918d483882Smlf 			    setp, rules, i);
51928d483882Smlf 			free(path_left);
51938d483882Smlf 			if (ret == 1) {
51948d483882Smlf 				/*
51958d483882Smlf 				 * We found the reserved ID for this entry.
51968d483882Smlf 				 * We still keep the entry since it is needed
51978d483882Smlf 				 * by the new link bypass code in disks
51988d483882Smlf 				 */
51998d483882Smlf 				vprint(RSRV_MID, "found rsv ID: rstring: %s "
52008d483882Smlf 				    "rule RE: %s\n", entry->er_file, path_left);
52018d483882Smlf 				break;
52028d483882Smlf 			}
52038d483882Smlf 		}
52048d483882Smlf 	}
52058d483882Smlf 
52067c478bd9Sstevel@tonic-gate 	/*
52077c478bd9Sstevel@tonic-gate 	 * For each RE, search disk and cache any matches on the
5208facf4a8dSllai 	 * numeral list.
52097c478bd9Sstevel@tonic-gate 	 */
52107c478bd9Sstevel@tonic-gate 	for (i = 0; i < nrules; i++) {
52117c478bd9Sstevel@tonic-gate 		path_left = s_strdup(setp->re[i]);
5212facf4a8dSllai 		enumerate_recurse(dev_dir, path_left, setp, rules, i);
52137c478bd9Sstevel@tonic-gate 		free(path_left);
52147c478bd9Sstevel@tonic-gate 	}
52157c478bd9Sstevel@tonic-gate 
52167c478bd9Sstevel@tonic-gate #ifdef	DEBUG
52177c478bd9Sstevel@tonic-gate 	dump_enum_cache(setp);
52187c478bd9Sstevel@tonic-gate #endif
52197c478bd9Sstevel@tonic-gate 
52207c478bd9Sstevel@tonic-gate 	return (setp);
52217c478bd9Sstevel@tonic-gate }
52227c478bd9Sstevel@tonic-gate 
52237c478bd9Sstevel@tonic-gate 
52247c478bd9Sstevel@tonic-gate /*
52257c478bd9Sstevel@tonic-gate  * This function stats the pathname namebuf.  If this is a directory
52267c478bd9Sstevel@tonic-gate  * entry, we recurse down dname/fname until we find the first symbolic
52277c478bd9Sstevel@tonic-gate  * link, and then stat and return it.  This is valid for the same reason
52287c478bd9Sstevel@tonic-gate  * that we only need to read a single pathname for multiple matching
52297c478bd9Sstevel@tonic-gate  * logical ID's... ie, all the logical nodes should contain identical
52307c478bd9Sstevel@tonic-gate  * physical paths for the parts we are interested.
52317c478bd9Sstevel@tonic-gate  */
52327c478bd9Sstevel@tonic-gate int
52337c478bd9Sstevel@tonic-gate get_stat_info(char *namebuf, struct stat *sb)
52347c478bd9Sstevel@tonic-gate {
52357c478bd9Sstevel@tonic-gate 	char *cp;
523673de625bSjg 	finddevhdl_t fhandle;
523773de625bSjg 	const char *fp;
52387c478bd9Sstevel@tonic-gate 
52397c478bd9Sstevel@tonic-gate 	if (lstat(namebuf, sb) < 0) {
52407c478bd9Sstevel@tonic-gate 		(void) err_print(LSTAT_FAILED, namebuf, strerror(errno));
52417c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
52427c478bd9Sstevel@tonic-gate 	}
52437c478bd9Sstevel@tonic-gate 
52447c478bd9Sstevel@tonic-gate 	if ((sb->st_mode & S_IFMT) == S_IFLNK) {
52457c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
52467c478bd9Sstevel@tonic-gate 	}
52477c478bd9Sstevel@tonic-gate 
52487c478bd9Sstevel@tonic-gate 	/*
52497c478bd9Sstevel@tonic-gate 	 * If it is a dir, recurse down until we find a link and
52507c478bd9Sstevel@tonic-gate 	 * then use the link.
52517c478bd9Sstevel@tonic-gate 	 */
52527c478bd9Sstevel@tonic-gate 	if ((sb->st_mode & S_IFMT) == S_IFDIR) {
52537c478bd9Sstevel@tonic-gate 
525473de625bSjg 		if (finddev_readdir(namebuf, &fhandle) != 0) {
52557c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
52567c478bd9Sstevel@tonic-gate 		}
52577c478bd9Sstevel@tonic-gate 
52587c478bd9Sstevel@tonic-gate 		/*
52597c478bd9Sstevel@tonic-gate 		 *  Search each dir entry looking for a symlink.  Return
52607c478bd9Sstevel@tonic-gate 		 *  the first symlink found in namebuf.  Recurse dirs.
52617c478bd9Sstevel@tonic-gate 		 */
526273de625bSjg 		while ((fp = finddev_next(fhandle)) != NULL) {
52637c478bd9Sstevel@tonic-gate 			cp = namebuf + strlen(namebuf);
5264facf4a8dSllai 			if ((strlcat(namebuf, "/", PATH_MAX) >= PATH_MAX) ||
526573de625bSjg 			    (strlcat(namebuf, fp, PATH_MAX) >= PATH_MAX)) {
5266facf4a8dSllai 				*cp = '\0';
526773de625bSjg 				finddev_close(fhandle);
5268facf4a8dSllai 				return (DEVFSADM_FAILURE);
5269facf4a8dSllai 			}
52707c478bd9Sstevel@tonic-gate 			if (get_stat_info(namebuf, sb) == DEVFSADM_SUCCESS) {
527173de625bSjg 				finddev_close(fhandle);
52727c478bd9Sstevel@tonic-gate 				return (DEVFSADM_SUCCESS);
52737c478bd9Sstevel@tonic-gate 			}
52747c478bd9Sstevel@tonic-gate 			*cp = '\0';
52757c478bd9Sstevel@tonic-gate 		}
527673de625bSjg 		finddev_close(fhandle);
52777c478bd9Sstevel@tonic-gate 	}
52787c478bd9Sstevel@tonic-gate 
52797c478bd9Sstevel@tonic-gate 	/* no symlink found, so return error */
52807c478bd9Sstevel@tonic-gate 	return (DEVFSADM_FAILURE);
52817c478bd9Sstevel@tonic-gate }
52827c478bd9Sstevel@tonic-gate 
52837c478bd9Sstevel@tonic-gate /*
52847c478bd9Sstevel@tonic-gate  * An existing matching ID was not found, so this function is called to
52857c478bd9Sstevel@tonic-gate  * create the next lowest ID.  In the INTEGER case, return the next
52867c478bd9Sstevel@tonic-gate  * lowest unused integer.  In the case of LETTER, return the next lowest
52877c478bd9Sstevel@tonic-gate  * unused letter.  Return empty string if all 26 are used.
52887c478bd9Sstevel@tonic-gate  * Only IDs >= min will be returned.
52897c478bd9Sstevel@tonic-gate  */
52907c478bd9Sstevel@tonic-gate char *
52917c478bd9Sstevel@tonic-gate new_id(numeral_t *numeral, int type, char *min)
52927c478bd9Sstevel@tonic-gate {
52937c478bd9Sstevel@tonic-gate 	int imin;
52947c478bd9Sstevel@tonic-gate 	temp_t *temp;
52957c478bd9Sstevel@tonic-gate 	temp_t *ptr;
52967c478bd9Sstevel@tonic-gate 	temp_t **previous;
52977c478bd9Sstevel@tonic-gate 	temp_t *head = NULL;
52987c478bd9Sstevel@tonic-gate 	char *retval;
52997c478bd9Sstevel@tonic-gate 	static char tempbuff[8];
53007c478bd9Sstevel@tonic-gate 	numeral_t *np;
53017c478bd9Sstevel@tonic-gate 
53027c478bd9Sstevel@tonic-gate 	if (type == LETTER) {
53037c478bd9Sstevel@tonic-gate 
53047c478bd9Sstevel@tonic-gate 		char letter[26], i;
53057c478bd9Sstevel@tonic-gate 
53067c478bd9Sstevel@tonic-gate 		if (numeral == NULL) {
53077c478bd9Sstevel@tonic-gate 			return (s_strdup(min));
53087c478bd9Sstevel@tonic-gate 		}
53097c478bd9Sstevel@tonic-gate 
53107c478bd9Sstevel@tonic-gate 		for (i = 0; i < 26; i++) {
53117c478bd9Sstevel@tonic-gate 			letter[i] = 0;
53127c478bd9Sstevel@tonic-gate 		}
53137c478bd9Sstevel@tonic-gate 
53147c478bd9Sstevel@tonic-gate 		for (np = numeral; np != NULL; np = np->next) {
53158d483882Smlf 			assert(np->flags == 0 ||
53168d483882Smlf 			    np->flags == NUMERAL_RESERVED);
53177c478bd9Sstevel@tonic-gate 			letter[*np->id - 'a']++;
53187c478bd9Sstevel@tonic-gate 		}
53197c478bd9Sstevel@tonic-gate 
53207c478bd9Sstevel@tonic-gate 		imin = *min - 'a';
53217c478bd9Sstevel@tonic-gate 
53227c478bd9Sstevel@tonic-gate 		for (i = imin; i < 26; i++) {
53237c478bd9Sstevel@tonic-gate 			if (letter[i] == 0) {
53247c478bd9Sstevel@tonic-gate 				retval = s_malloc(2);
53257c478bd9Sstevel@tonic-gate 				retval[0] = 'a' + i;
53267c478bd9Sstevel@tonic-gate 				retval[1] = '\0';
53277c478bd9Sstevel@tonic-gate 				return (retval);
53287c478bd9Sstevel@tonic-gate 			}
53297c478bd9Sstevel@tonic-gate 		}
53307c478bd9Sstevel@tonic-gate 
53317c478bd9Sstevel@tonic-gate 		return (s_strdup(""));
53327c478bd9Sstevel@tonic-gate 	}
53337c478bd9Sstevel@tonic-gate 
53347c478bd9Sstevel@tonic-gate 	if (type == INTEGER) {
53357c478bd9Sstevel@tonic-gate 
53367c478bd9Sstevel@tonic-gate 		if (numeral == NULL) {
53377c478bd9Sstevel@tonic-gate 			return (s_strdup(min));
53387c478bd9Sstevel@tonic-gate 		}
53397c478bd9Sstevel@tonic-gate 
53407c478bd9Sstevel@tonic-gate 		imin = atoi(min);
53417c478bd9Sstevel@tonic-gate 
53427c478bd9Sstevel@tonic-gate 		/* sort list */
53437c478bd9Sstevel@tonic-gate 		for (np = numeral; np != NULL; np = np->next) {
53448d483882Smlf 			assert(np->flags == 0 ||
53458d483882Smlf 			    np->flags == NUMERAL_RESERVED);
53467c478bd9Sstevel@tonic-gate 			temp = s_malloc(sizeof (temp_t));
53477c478bd9Sstevel@tonic-gate 			temp->integer = atoi(np->id);
53487c478bd9Sstevel@tonic-gate 			temp->next = NULL;
53497c478bd9Sstevel@tonic-gate 
53507c478bd9Sstevel@tonic-gate 			previous = &head;
53517c478bd9Sstevel@tonic-gate 			for (ptr = head; ptr != NULL; ptr = ptr->next) {
53527c478bd9Sstevel@tonic-gate 				if (temp->integer < ptr->integer) {
53537c478bd9Sstevel@tonic-gate 					temp->next = ptr;
53547c478bd9Sstevel@tonic-gate 					*previous = temp;
53557c478bd9Sstevel@tonic-gate 					break;
53567c478bd9Sstevel@tonic-gate 				}
53577c478bd9Sstevel@tonic-gate 				previous = &(ptr->next);
53587c478bd9Sstevel@tonic-gate 			}
53597c478bd9Sstevel@tonic-gate 			if (ptr == NULL) {
53607c478bd9Sstevel@tonic-gate 				*previous = temp;
53617c478bd9Sstevel@tonic-gate 			}
53627c478bd9Sstevel@tonic-gate 		}
53637c478bd9Sstevel@tonic-gate 
53647c478bd9Sstevel@tonic-gate 		/* now search sorted list for first hole >= imin */
53657c478bd9Sstevel@tonic-gate 		for (ptr = head; ptr != NULL; ptr = ptr->next) {
53667c478bd9Sstevel@tonic-gate 			if (imin == ptr->integer) {
53677c478bd9Sstevel@tonic-gate 				imin++;
53687c478bd9Sstevel@tonic-gate 			} else {
53697c478bd9Sstevel@tonic-gate 				if (imin < ptr->integer) {
53707c478bd9Sstevel@tonic-gate 					break;
53717c478bd9Sstevel@tonic-gate 				}
53727c478bd9Sstevel@tonic-gate 			}
53737c478bd9Sstevel@tonic-gate 
53747c478bd9Sstevel@tonic-gate 		}
53757c478bd9Sstevel@tonic-gate 
53767c478bd9Sstevel@tonic-gate 		/* free temp list */
53777c478bd9Sstevel@tonic-gate 		for (ptr = head; ptr != NULL; ) {
53787c478bd9Sstevel@tonic-gate 			temp = ptr;
53797c478bd9Sstevel@tonic-gate 			ptr = ptr->next;
53807c478bd9Sstevel@tonic-gate 			free(temp);
53817c478bd9Sstevel@tonic-gate 		}
53827c478bd9Sstevel@tonic-gate 
53837c478bd9Sstevel@tonic-gate 		(void) sprintf(tempbuff, "%d", imin);
53847c478bd9Sstevel@tonic-gate 		return (s_strdup(tempbuff));
53857c478bd9Sstevel@tonic-gate 	}
53867c478bd9Sstevel@tonic-gate 
53877c478bd9Sstevel@tonic-gate 	return (s_strdup(""));
53887c478bd9Sstevel@tonic-gate }
53897c478bd9Sstevel@tonic-gate 
53908d483882Smlf static int
53918d483882Smlf enumerate_parse(char *rsvstr, char *path_left, numeral_set_t *setp,
53928d483882Smlf 	    devfsadm_enumerate_t rules[], int index)
53938d483882Smlf {
53948d483882Smlf 	char	*slash1 = NULL;
53958d483882Smlf 	char	*slash2 = NULL;
53968d483882Smlf 	char	*numeral_id;
53978d483882Smlf 	char	*path_left_save;
53988d483882Smlf 	char	*rsvstr_save;
53998d483882Smlf 	int	ret = 0;
54008d483882Smlf 	static int warned = 0;
54018d483882Smlf 
54028d483882Smlf 	rsvstr_save = rsvstr;
54038d483882Smlf 	path_left_save = path_left;
54048d483882Smlf 
54058d483882Smlf 	if (rsvstr == NULL || rsvstr[0] == '\0' || rsvstr[0] == '/') {
54068d483882Smlf 		if (!warned) {
54078d483882Smlf 			err_print("invalid reserved filepath: %s\n",
54088d483882Smlf 			    rsvstr ? rsvstr : "<NULL>");
54098d483882Smlf 			warned = 1;
54108d483882Smlf 		}
54118d483882Smlf 		return (0);
54128d483882Smlf 	}
54138d483882Smlf 
54148d483882Smlf 	vprint(RSRV_MID, "processing rule: %s, rstring: %s\n",
54158d483882Smlf 	    path_left, rsvstr);
54168d483882Smlf 
54178d483882Smlf 
54188d483882Smlf 	for (;;) {
54198d483882Smlf 		/* get rid of any extra '/' in the reserve string */
54208d483882Smlf 		while (*rsvstr == '/') {
54218d483882Smlf 			rsvstr++;
54228d483882Smlf 		}
54238d483882Smlf 
54248d483882Smlf 		/* get rid of any extra '/' in the RE */
54258d483882Smlf 		while (*path_left == '/') {
54268d483882Smlf 			path_left++;
54278d483882Smlf 		}
54288d483882Smlf 
54298d483882Smlf 		if (slash1 = strchr(path_left, '/')) {
54308d483882Smlf 			*slash1 = '\0';
54318d483882Smlf 		}
54328d483882Smlf 		if (slash2 = strchr(rsvstr, '/')) {
54338d483882Smlf 			*slash2 = '\0';
54348d483882Smlf 		}
54358d483882Smlf 
54368d483882Smlf 		if ((slash1 != NULL) ^ (slash2 != NULL)) {
54378d483882Smlf 			ret = 0;
54388d483882Smlf 			vprint(RSRV_MID, "mismatch in # of path components\n");
54398d483882Smlf 			goto out;
54408d483882Smlf 		}
54418d483882Smlf 
54428d483882Smlf 		/*
54438d483882Smlf 		 *  Returns true if path_left matches the list entry.
54448d483882Smlf 		 *  If it is the last path component, pass subexp
54458d483882Smlf 		 *  so that it will return the corresponding ID in
54468d483882Smlf 		 *  numeral_id.
54478d483882Smlf 		 */
54488d483882Smlf 		numeral_id = NULL;
54498d483882Smlf 		if (match_path_component(path_left, rsvstr, &numeral_id,
54500a653502Swroche 		    slash1 ? 0 : rules[index].subexp)) {
54518d483882Smlf 
54528d483882Smlf 			/* We have a match. */
54538d483882Smlf 			if (slash1 == NULL) {
54548d483882Smlf 				/* Is last path component */
54558d483882Smlf 				vprint(RSRV_MID, "match and last component\n");
54568d483882Smlf 				create_reserved_numeral(setp, numeral_id);
54578d483882Smlf 				if (numeral_id != NULL) {
54588d483882Smlf 					free(numeral_id);
54598d483882Smlf 				}
54608d483882Smlf 				ret = 1;
54618d483882Smlf 				goto out;
54628d483882Smlf 			} else {
54638d483882Smlf 				/* Not last path component. Continue parsing */
54648d483882Smlf 				*slash1 = '/';
54658d483882Smlf 				*slash2 = '/';
54668d483882Smlf 				path_left = slash1 + 1;
54678d483882Smlf 				rsvstr = slash2 + 1;
54688d483882Smlf 				vprint(RSRV_MID,
54698d483882Smlf 				    "match and NOT last component\n");
54708d483882Smlf 				continue;
54718d483882Smlf 			}
54728d483882Smlf 		} else {
54738d483882Smlf 			/* No match */
54748d483882Smlf 			ret = 0;
54758d483882Smlf 			vprint(RSRV_MID, "No match: rule RE = %s, "
54768d483882Smlf 			    "rstring = %s\n", path_left, rsvstr);
54778d483882Smlf 			goto out;
54788d483882Smlf 		}
54798d483882Smlf 	}
54808d483882Smlf 
54818d483882Smlf out:
54828d483882Smlf 	if (slash1)
54838d483882Smlf 		*slash1 = '/';
54848d483882Smlf 	if (slash2)
54858d483882Smlf 		*slash2 = '/';
54868d483882Smlf 
54878d483882Smlf 	if (ret == 1) {
54888d483882Smlf 		vprint(RSRV_MID, "match: rule RE: %s, rstring: %s\n",
54898d483882Smlf 		    path_left_save, rsvstr_save);
54908d483882Smlf 	} else {
54918d483882Smlf 		vprint(RSRV_MID, "NO match: rule RE: %s, rstring: %s\n",
54928d483882Smlf 		    path_left_save, rsvstr_save);
54938d483882Smlf 	}
54948d483882Smlf 
54958d483882Smlf 	return (ret);
54968d483882Smlf }
54978d483882Smlf 
54987c478bd9Sstevel@tonic-gate /*
54997c478bd9Sstevel@tonic-gate  * Search current_dir for all files which match the first path component
55007c478bd9Sstevel@tonic-gate  * of path_left, which is an RE.  If a match is found, but there are more
55017c478bd9Sstevel@tonic-gate  * components of path_left, then recurse, otherwise, if we have reached
55027c478bd9Sstevel@tonic-gate  * the last component of path_left, call create_cached_numerals for each
55037c478bd9Sstevel@tonic-gate  * file.   At some point, recurse_dev_re() should be rewritten so that this
55047c478bd9Sstevel@tonic-gate  * function can be eliminated.
55057c478bd9Sstevel@tonic-gate  */
55067c478bd9Sstevel@tonic-gate static void
55077c478bd9Sstevel@tonic-gate enumerate_recurse(char *current_dir, char *path_left, numeral_set_t *setp,
55087c478bd9Sstevel@tonic-gate 	    devfsadm_enumerate_t rules[], int index)
55097c478bd9Sstevel@tonic-gate {
55107c478bd9Sstevel@tonic-gate 	char *slash;
55117c478bd9Sstevel@tonic-gate 	char *new_path;
55127c478bd9Sstevel@tonic-gate 	char *numeral_id;
551373de625bSjg 	finddevhdl_t fhandle;
551473de625bSjg 	const char *fp;
55157c478bd9Sstevel@tonic-gate 
551673de625bSjg 	if (finddev_readdir(current_dir, &fhandle) != 0) {
55177c478bd9Sstevel@tonic-gate 		return;
55187c478bd9Sstevel@tonic-gate 	}
55197c478bd9Sstevel@tonic-gate 
55207c478bd9Sstevel@tonic-gate 	/* get rid of any extra '/' */
55217c478bd9Sstevel@tonic-gate 	while (*path_left == '/') {
55227c478bd9Sstevel@tonic-gate 		path_left++;
55237c478bd9Sstevel@tonic-gate 	}
55247c478bd9Sstevel@tonic-gate 
55257c478bd9Sstevel@tonic-gate 	if (slash = strchr(path_left, '/')) {
55267c478bd9Sstevel@tonic-gate 		*slash = '\0';
55277c478bd9Sstevel@tonic-gate 	}
55287c478bd9Sstevel@tonic-gate 
552973de625bSjg 	while ((fp = finddev_next(fhandle)) != NULL) {
55307c478bd9Sstevel@tonic-gate 
55317c478bd9Sstevel@tonic-gate 		/*
5532facf4a8dSllai 		 *  Returns true if path_left matches the list entry.
55337c478bd9Sstevel@tonic-gate 		 *  If it is the last path component, pass subexp
55347c478bd9Sstevel@tonic-gate 		 *  so that it will return the corresponding ID in
55357c478bd9Sstevel@tonic-gate 		 *  numeral_id.
55367c478bd9Sstevel@tonic-gate 		 */
55377c478bd9Sstevel@tonic-gate 		numeral_id = NULL;
553873de625bSjg 		if (match_path_component(path_left, (char *)fp, &numeral_id,
55390a653502Swroche 		    slash ? 0 : rules[index].subexp)) {
55407c478bd9Sstevel@tonic-gate 
55417c478bd9Sstevel@tonic-gate 			new_path = s_malloc(strlen(current_dir) +
554273de625bSjg 			    strlen(fp) + 2);
55437c478bd9Sstevel@tonic-gate 
55447c478bd9Sstevel@tonic-gate 			(void) strcpy(new_path, current_dir);
55457c478bd9Sstevel@tonic-gate 			(void) strcat(new_path, "/");
554673de625bSjg 			(void) strcat(new_path, fp);
55477c478bd9Sstevel@tonic-gate 
55487c478bd9Sstevel@tonic-gate 			if (slash != NULL) {
55497c478bd9Sstevel@tonic-gate 				enumerate_recurse(new_path, slash + 1,
55507c478bd9Sstevel@tonic-gate 				    setp, rules, index);
55517c478bd9Sstevel@tonic-gate 			} else {
55527c478bd9Sstevel@tonic-gate 				create_cached_numeral(new_path, setp,
55537c478bd9Sstevel@tonic-gate 				    numeral_id, rules, index);
55547c478bd9Sstevel@tonic-gate 				if (numeral_id != NULL) {
55557c478bd9Sstevel@tonic-gate 					free(numeral_id);
55567c478bd9Sstevel@tonic-gate 				}
55577c478bd9Sstevel@tonic-gate 			}
55587c478bd9Sstevel@tonic-gate 			free(new_path);
55597c478bd9Sstevel@tonic-gate 		}
55607c478bd9Sstevel@tonic-gate 	}
55617c478bd9Sstevel@tonic-gate 
55627c478bd9Sstevel@tonic-gate 	if (slash != NULL) {
55637c478bd9Sstevel@tonic-gate 		*slash = '/';
55647c478bd9Sstevel@tonic-gate 	}
556573de625bSjg 	finddev_close(fhandle);
55667c478bd9Sstevel@tonic-gate }
55677c478bd9Sstevel@tonic-gate 
55687c478bd9Sstevel@tonic-gate 
55697c478bd9Sstevel@tonic-gate /*
55707c478bd9Sstevel@tonic-gate  * Returns true if file matches file_re.  If subexp is non-zero, it means
55717c478bd9Sstevel@tonic-gate  * we are searching the last path component and need to return the
55727c478bd9Sstevel@tonic-gate  * parenthesized subexpression subexp in id.
55737c478bd9Sstevel@tonic-gate  *
55747c478bd9Sstevel@tonic-gate  */
55757c478bd9Sstevel@tonic-gate static int
55767c478bd9Sstevel@tonic-gate match_path_component(char *file_re,  char *file,  char **id, int subexp)
55777c478bd9Sstevel@tonic-gate {
55787c478bd9Sstevel@tonic-gate 	regex_t re1;
55797c478bd9Sstevel@tonic-gate 	int match = 0;
55807c478bd9Sstevel@tonic-gate 	int nelements;
55817c478bd9Sstevel@tonic-gate 	regmatch_t *pmatch;
55827c478bd9Sstevel@tonic-gate 
55837c478bd9Sstevel@tonic-gate 	if (subexp != 0) {
55847c478bd9Sstevel@tonic-gate 		nelements = subexp + 1;
55850a653502Swroche 		pmatch =
55860a653502Swroche 		    (regmatch_t *)s_malloc(sizeof (regmatch_t) * nelements);
55877c478bd9Sstevel@tonic-gate 	} else {
55887c478bd9Sstevel@tonic-gate 		pmatch = NULL;
55897c478bd9Sstevel@tonic-gate 		nelements = 0;
55907c478bd9Sstevel@tonic-gate 	}
55917c478bd9Sstevel@tonic-gate 
55927c478bd9Sstevel@tonic-gate 	if (regcomp(&re1, file_re, REG_EXTENDED) != 0) {
55937c478bd9Sstevel@tonic-gate 		if (pmatch != NULL) {
55947c478bd9Sstevel@tonic-gate 			free(pmatch);
55957c478bd9Sstevel@tonic-gate 		}
55967c478bd9Sstevel@tonic-gate 		return (0);
55977c478bd9Sstevel@tonic-gate 	}
55987c478bd9Sstevel@tonic-gate 
55997c478bd9Sstevel@tonic-gate 	if (regexec(&re1, file, nelements, pmatch, 0) == 0) {
56007c478bd9Sstevel@tonic-gate 		match = 1;
56017c478bd9Sstevel@tonic-gate 	}
56027c478bd9Sstevel@tonic-gate 
56037c478bd9Sstevel@tonic-gate 	if ((match != 0) && (subexp != 0)) {
56047c478bd9Sstevel@tonic-gate 		int size = pmatch[subexp].rm_eo - pmatch[subexp].rm_so;
56057c478bd9Sstevel@tonic-gate 		*id = s_malloc(size + 1);
56067c478bd9Sstevel@tonic-gate 		(void) strncpy(*id, &file[pmatch[subexp].rm_so], size);
56077c478bd9Sstevel@tonic-gate 		(*id)[size] = '\0';
56087c478bd9Sstevel@tonic-gate 	}
56097c478bd9Sstevel@tonic-gate 
56107c478bd9Sstevel@tonic-gate 	if (pmatch != NULL) {
56117c478bd9Sstevel@tonic-gate 		free(pmatch);
56127c478bd9Sstevel@tonic-gate 	}
56137c478bd9Sstevel@tonic-gate 	regfree(&re1);
56147c478bd9Sstevel@tonic-gate 	return (match);
56157c478bd9Sstevel@tonic-gate }
56167c478bd9Sstevel@tonic-gate 
56178d483882Smlf static void
56188d483882Smlf create_reserved_numeral(numeral_set_t *setp, char *numeral_id)
56198d483882Smlf {
56208d483882Smlf 	numeral_t *np;
56218d483882Smlf 
56228d483882Smlf 	vprint(RSRV_MID, "Attempting to create reserved numeral: %s\n",
56238d483882Smlf 	    numeral_id);
56248d483882Smlf 
56258d483882Smlf 	/*
56268d483882Smlf 	 * We found a numeral_id from an entry in the enumerate_reserved file
56278d483882Smlf 	 * which matched the re passed in from devfsadm_enumerate.  We only
56288d483882Smlf 	 * need to make sure ONE copy of numeral_id exists on the numeral list.
56298d483882Smlf 	 * We only need to store /dev/dsk/cNtod0s0 and no other entries
56308d483882Smlf 	 * hanging off of controller N.
56318d483882Smlf 	 */
56328d483882Smlf 	for (np = setp->headnumeral; np != NULL; np = np->next) {
56338d483882Smlf 		if (strcmp(numeral_id, np->id) == 0) {
56348d483882Smlf 			vprint(RSRV_MID, "ID: %s, already reserved\n", np->id);
56358d483882Smlf 			assert(np->flags == NUMERAL_RESERVED);
56368d483882Smlf 			return;
56378d483882Smlf 		} else {
56388d483882Smlf 			assert(np->flags == 0 ||
56398d483882Smlf 			    np->flags == NUMERAL_RESERVED);
56408d483882Smlf 		}
56418d483882Smlf 	}
56428d483882Smlf 
56438d483882Smlf 	/* NOT on list, so add it */
56448d483882Smlf 	np = s_malloc(sizeof (numeral_t));
56458d483882Smlf 	np->id = s_strdup(numeral_id);
56468d483882Smlf 	np->full_path = NULL;
56478d483882Smlf 	np->rule_index = 0;
56488d483882Smlf 	np->cmp_str = NULL;
56498d483882Smlf 	np->flags = NUMERAL_RESERVED;
56508d483882Smlf 	np->next = setp->headnumeral;
56518d483882Smlf 	setp->headnumeral = np;
56528d483882Smlf 
56538d483882Smlf 	vprint(RSRV_MID, "Reserved numeral ID: %s\n", np->id);
56548d483882Smlf }
56558d483882Smlf 
56567c478bd9Sstevel@tonic-gate /*
56577c478bd9Sstevel@tonic-gate  * This function is called for every file which matched the leaf
56587c478bd9Sstevel@tonic-gate  * component of the RE.  If the "numeral_id" is not already on the
56597c478bd9Sstevel@tonic-gate  * numeral set's numeral list, add it and its physical path.
56607c478bd9Sstevel@tonic-gate  */
56617c478bd9Sstevel@tonic-gate static void
56627c478bd9Sstevel@tonic-gate create_cached_numeral(char *path, numeral_set_t *setp, char *numeral_id,
56637c478bd9Sstevel@tonic-gate 	devfsadm_enumerate_t rules[], int index)
56647c478bd9Sstevel@tonic-gate {
56657c478bd9Sstevel@tonic-gate 	char linkbuf[PATH_MAX + 1];
56667c478bd9Sstevel@tonic-gate 	char lpath[PATH_MAX + 1];
56677c478bd9Sstevel@tonic-gate 	char *linkptr, *cmp_str;
56687c478bd9Sstevel@tonic-gate 	numeral_t *np;
56697c478bd9Sstevel@tonic-gate 	int linksize;
56707c478bd9Sstevel@tonic-gate 	struct stat sb;
567194c894bbSVikram Hegde 	char *contents;
56727c478bd9Sstevel@tonic-gate 	const char *fcn = "create_cached_numeral";
56737c478bd9Sstevel@tonic-gate 
56747c478bd9Sstevel@tonic-gate 	assert(index >= 0 && index < setp->re_count);
56757c478bd9Sstevel@tonic-gate 	assert(strcmp(rules[index].re, setp->re[index]) == 0);
56767c478bd9Sstevel@tonic-gate 
56777c478bd9Sstevel@tonic-gate 	/*
56787c478bd9Sstevel@tonic-gate 	 *  We found a numeral_id from an entry in /dev which matched
56797c478bd9Sstevel@tonic-gate 	 *  the re passed in from devfsadm_enumerate.  We only need to make sure
56807c478bd9Sstevel@tonic-gate 	 *  ONE copy of numeral_id exists on the numeral list.  We only need
56817c478bd9Sstevel@tonic-gate 	 *  to store /dev/dsk/cNtod0s0 and no other entries hanging off
56827c478bd9Sstevel@tonic-gate 	 *  of controller N.
56837c478bd9Sstevel@tonic-gate 	 */
56847c478bd9Sstevel@tonic-gate 	for (np = setp->headnumeral; np != NULL; np = np->next) {
56858d483882Smlf 		assert(np->flags == 0 || np->flags == NUMERAL_RESERVED);
56867c478bd9Sstevel@tonic-gate 		if (strcmp(numeral_id, np->id) == 0) {
56878d483882Smlf 			/*
56888d483882Smlf 			 * Note that we can't assert that the flags field
56898d483882Smlf 			 * of the numeral is 0, since both reserved and
56908d483882Smlf 			 * unreserved links in /dev come here
56918d483882Smlf 			 */
56928d483882Smlf 			if (np->flags == NUMERAL_RESERVED) {
56938d483882Smlf 				vprint(RSRV_MID, "ID derived from /dev link is"
56948d483882Smlf 				    " reserved: %s\n", np->id);
56958d483882Smlf 			} else {
56968d483882Smlf 				vprint(RSRV_MID, "ID derived from /dev link is"
56978d483882Smlf 				    " NOT reserved: %s\n", np->id);
56988d483882Smlf 			}
56997c478bd9Sstevel@tonic-gate 			return;
57007c478bd9Sstevel@tonic-gate 		}
57017c478bd9Sstevel@tonic-gate 	}
57027c478bd9Sstevel@tonic-gate 
57037c478bd9Sstevel@tonic-gate 	/* NOT on list, so add it */
57047c478bd9Sstevel@tonic-gate 
57057c478bd9Sstevel@tonic-gate 	(void) strcpy(lpath, path);
57067c478bd9Sstevel@tonic-gate 	/*
57077c478bd9Sstevel@tonic-gate 	 * If path is a dir, it is changed to the first symbolic link it find
57087c478bd9Sstevel@tonic-gate 	 * if it finds one.
57097c478bd9Sstevel@tonic-gate 	 */
57107c478bd9Sstevel@tonic-gate 	if (get_stat_info(lpath, &sb) == DEVFSADM_FAILURE) {
57117c478bd9Sstevel@tonic-gate 		return;
57127c478bd9Sstevel@tonic-gate 	}
57137c478bd9Sstevel@tonic-gate 
57147c478bd9Sstevel@tonic-gate 	/* If we get here, we found a symlink */
57157c478bd9Sstevel@tonic-gate 	linksize = readlink(lpath, linkbuf, PATH_MAX);
57167c478bd9Sstevel@tonic-gate 
57177c478bd9Sstevel@tonic-gate 	if (linksize <= 0) {
57187c478bd9Sstevel@tonic-gate 		err_print(READLINK_FAILED, fcn, lpath, strerror(errno));
57197c478bd9Sstevel@tonic-gate 		return;
57207c478bd9Sstevel@tonic-gate 	}
57217c478bd9Sstevel@tonic-gate 
57227c478bd9Sstevel@tonic-gate 	linkbuf[linksize] = '\0';
57237c478bd9Sstevel@tonic-gate 
572494c894bbSVikram Hegde 	/*
572594c894bbSVikram Hegde 	 * redirect alias path to current path
572694c894bbSVikram Hegde 	 * devi_root_node is protected by lock_dev()
572794c894bbSVikram Hegde 	 */
572894c894bbSVikram Hegde 	contents = di_alias2curr(devi_root_node, linkbuf);
572994c894bbSVikram Hegde 
57307c478bd9Sstevel@tonic-gate 	/*
57317c478bd9Sstevel@tonic-gate 	 * the following just points linkptr to the root of the /devices
57327c478bd9Sstevel@tonic-gate 	 * node if it is a minor node, otherwise, to the first char of
57337c478bd9Sstevel@tonic-gate 	 * linkbuf if it is a link.
57347c478bd9Sstevel@tonic-gate 	 */
573594c894bbSVikram Hegde 	(void) is_minor_node(contents, &linkptr);
57367c478bd9Sstevel@tonic-gate 
57377c478bd9Sstevel@tonic-gate 	cmp_str = alloc_cmp_str(linkptr, &rules[index]);
57387c478bd9Sstevel@tonic-gate 	if (cmp_str == NULL) {
573994c894bbSVikram Hegde 		free(contents);
57407c478bd9Sstevel@tonic-gate 		return;
57417c478bd9Sstevel@tonic-gate 	}
57427c478bd9Sstevel@tonic-gate 
57437c478bd9Sstevel@tonic-gate 	np = s_malloc(sizeof (numeral_t));
57447c478bd9Sstevel@tonic-gate 
57457c478bd9Sstevel@tonic-gate 	np->id = s_strdup(numeral_id);
57467c478bd9Sstevel@tonic-gate 	np->full_path = s_strdup(linkptr);
57477c478bd9Sstevel@tonic-gate 	np->rule_index = index;
57487c478bd9Sstevel@tonic-gate 	np->cmp_str = cmp_str;
57498d483882Smlf 	np->flags = 0;
57507c478bd9Sstevel@tonic-gate 
57517c478bd9Sstevel@tonic-gate 	np->next = setp->headnumeral;
57527c478bd9Sstevel@tonic-gate 	setp->headnumeral = np;
575394c894bbSVikram Hegde 
575494c894bbSVikram Hegde 	free(contents);
57557c478bd9Sstevel@tonic-gate }
57567c478bd9Sstevel@tonic-gate 
57577c478bd9Sstevel@tonic-gate 
57587c478bd9Sstevel@tonic-gate /*
57597c478bd9Sstevel@tonic-gate  * This should be called either before or after granting access to a
57607c478bd9Sstevel@tonic-gate  * command line version of devfsadm running, since it may have changed
57617c478bd9Sstevel@tonic-gate  * the state of /dev.  It forces future enumerate calls to re-build
57627c478bd9Sstevel@tonic-gate  * cached information from /dev.
57637c478bd9Sstevel@tonic-gate  */
57647c478bd9Sstevel@tonic-gate void
57657c478bd9Sstevel@tonic-gate invalidate_enumerate_cache(void)
57667c478bd9Sstevel@tonic-gate {
57677c478bd9Sstevel@tonic-gate 	numeral_set_t *setp;
57687c478bd9Sstevel@tonic-gate 	numeral_set_t *savedsetp;
57697c478bd9Sstevel@tonic-gate 	numeral_t *savednumset;
57707c478bd9Sstevel@tonic-gate 	numeral_t *numset;
57717c478bd9Sstevel@tonic-gate 	int i;
57727c478bd9Sstevel@tonic-gate 
57737c478bd9Sstevel@tonic-gate 	for (setp = head_numeral_set; setp != NULL; ) {
57747c478bd9Sstevel@tonic-gate 		/*
57757c478bd9Sstevel@tonic-gate 		 *  check all regexp's passed in function against
57767c478bd9Sstevel@tonic-gate 		 *  those in cached set.
57777c478bd9Sstevel@tonic-gate 		 */
57787c478bd9Sstevel@tonic-gate 
57797c478bd9Sstevel@tonic-gate 		savedsetp = setp;
57807c478bd9Sstevel@tonic-gate 		setp = setp->next;
57817c478bd9Sstevel@tonic-gate 
57827c478bd9Sstevel@tonic-gate 		for (i = 0; i < savedsetp->re_count; i++) {
57837c478bd9Sstevel@tonic-gate 			free(savedsetp->re[i]);
57847c478bd9Sstevel@tonic-gate 		}
57857c478bd9Sstevel@tonic-gate 		free(savedsetp->re);
57867c478bd9Sstevel@tonic-gate 
57877c478bd9Sstevel@tonic-gate 		for (numset = savedsetp->headnumeral; numset != NULL; ) {
57887c478bd9Sstevel@tonic-gate 			savednumset = numset;
57897c478bd9Sstevel@tonic-gate 			numset = numset->next;
57907c478bd9Sstevel@tonic-gate 			assert(savednumset->rule_index < savedsetp->re_count);
57917c478bd9Sstevel@tonic-gate 			free(savednumset->id);
57927c478bd9Sstevel@tonic-gate 			free(savednumset->full_path);
57937c478bd9Sstevel@tonic-gate 			free(savednumset->cmp_str);
57947c478bd9Sstevel@tonic-gate 			free(savednumset);
57957c478bd9Sstevel@tonic-gate 		}
57967c478bd9Sstevel@tonic-gate 		free(savedsetp);
57977c478bd9Sstevel@tonic-gate 	}
57987c478bd9Sstevel@tonic-gate 	head_numeral_set = NULL;
57997c478bd9Sstevel@tonic-gate }
58007c478bd9Sstevel@tonic-gate 
58017c478bd9Sstevel@tonic-gate /*
58027c478bd9Sstevel@tonic-gate  * Copies over links from /dev to <root>/dev and device special files in
58037c478bd9Sstevel@tonic-gate  * /devices to <root>/devices, preserving the existing file modes.  If
58047c478bd9Sstevel@tonic-gate  * the link or special file already exists on <root>, skip the copy.  (it
58057c478bd9Sstevel@tonic-gate  * would exist only if a package hard coded it there, so assume package
58067c478bd9Sstevel@tonic-gate  * knows best?).  Use /etc/name_to_major and <root>/etc/name_to_major to
58077c478bd9Sstevel@tonic-gate  * make translations for major numbers on device special files.	No need to
58087c478bd9Sstevel@tonic-gate  * make a translation on minor_perm since if the file was created in the
58097c478bd9Sstevel@tonic-gate  * miniroot then it would presumably have the same minor_perm entry in
58107c478bd9Sstevel@tonic-gate  *  <root>/etc/minor_perm.  To be used only by install.
58117c478bd9Sstevel@tonic-gate  */
58127c478bd9Sstevel@tonic-gate int
58137c478bd9Sstevel@tonic-gate devfsadm_copy(void)
58147c478bd9Sstevel@tonic-gate {
58157c478bd9Sstevel@tonic-gate 	char filename[PATH_MAX + 1];
58167c478bd9Sstevel@tonic-gate 
58177c478bd9Sstevel@tonic-gate 	/* load the installed root's name_to_major for translations */
58187c478bd9Sstevel@tonic-gate 	(void) snprintf(filename, sizeof (filename), "%s%s", root_dir,
58197c478bd9Sstevel@tonic-gate 	    NAME_TO_MAJOR);
58207c478bd9Sstevel@tonic-gate 	if (load_n2m_table(filename) == DEVFSADM_FAILURE) {
58217c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
58227c478bd9Sstevel@tonic-gate 	}
58237c478bd9Sstevel@tonic-gate 
58247c478bd9Sstevel@tonic-gate 	/* Copy /dev to target disk. No need to copy /devices with devfs */
58257c478bd9Sstevel@tonic-gate 	(void) nftw(DEV, devfsadm_copy_file, 20, FTW_PHYS);
58267c478bd9Sstevel@tonic-gate 
58277c478bd9Sstevel@tonic-gate 	/* Let install handle copying over path_to_inst */
58287c478bd9Sstevel@tonic-gate 
58297c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
58307c478bd9Sstevel@tonic-gate }
58317c478bd9Sstevel@tonic-gate 
58327c478bd9Sstevel@tonic-gate /*
58337c478bd9Sstevel@tonic-gate  * This function copies links, dirs, and device special files.
58347c478bd9Sstevel@tonic-gate  * Note that it always returns DEVFSADM_SUCCESS, so that nftw doesn't
58357c478bd9Sstevel@tonic-gate  * abort.
58367c478bd9Sstevel@tonic-gate  */
58377c478bd9Sstevel@tonic-gate /*ARGSUSED*/
58387c478bd9Sstevel@tonic-gate static int
58397c478bd9Sstevel@tonic-gate devfsadm_copy_file(const char *file, const struct stat *stat,
58407c478bd9Sstevel@tonic-gate 		    int flags, struct FTW *ftw)
58417c478bd9Sstevel@tonic-gate {
58427c478bd9Sstevel@tonic-gate 	struct stat sp;
58437c478bd9Sstevel@tonic-gate 	dev_t newdev;
58447c478bd9Sstevel@tonic-gate 	char newfile[PATH_MAX + 1];
58457c478bd9Sstevel@tonic-gate 	char linkcontents[PATH_MAX + 1];
58467c478bd9Sstevel@tonic-gate 	int bytes;
58477c478bd9Sstevel@tonic-gate 	const char *fcn = "devfsadm_copy_file";
58487c478bd9Sstevel@tonic-gate 
58497c478bd9Sstevel@tonic-gate 	(void) strcpy(newfile, root_dir);
58507c478bd9Sstevel@tonic-gate 	(void) strcat(newfile, "/");
58517c478bd9Sstevel@tonic-gate 	(void) strcat(newfile, file);
58527c478bd9Sstevel@tonic-gate 
58537c478bd9Sstevel@tonic-gate 	if (lstat(newfile, &sp) == 0) {
58547c478bd9Sstevel@tonic-gate 		/* newfile already exists, so no need to continue */
58557c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
58567c478bd9Sstevel@tonic-gate 	}
58577c478bd9Sstevel@tonic-gate 
58587c478bd9Sstevel@tonic-gate 	if (((stat->st_mode & S_IFMT) == S_IFBLK) ||
58597c478bd9Sstevel@tonic-gate 	    ((stat->st_mode & S_IFMT) == S_IFCHR)) {
58607c478bd9Sstevel@tonic-gate 		if (translate_major(stat->st_rdev, &newdev) ==
58617c478bd9Sstevel@tonic-gate 		    DEVFSADM_FAILURE) {
58627c478bd9Sstevel@tonic-gate 			return (DEVFSADM_SUCCESS);
58637c478bd9Sstevel@tonic-gate 		}
58647c478bd9Sstevel@tonic-gate 		if (mknod(newfile, stat->st_mode, newdev) == -1) {
58657c478bd9Sstevel@tonic-gate 			err_print(MKNOD_FAILED, newfile, strerror(errno));
58667c478bd9Sstevel@tonic-gate 			return (DEVFSADM_SUCCESS);
58677c478bd9Sstevel@tonic-gate 		}
58687c478bd9Sstevel@tonic-gate 	} else if ((stat->st_mode & S_IFMT) == S_IFDIR) {
58697c478bd9Sstevel@tonic-gate 		if (mknod(newfile, stat->st_mode, 0) == -1) {
58707c478bd9Sstevel@tonic-gate 			err_print(MKNOD_FAILED, newfile, strerror(errno));
58717c478bd9Sstevel@tonic-gate 			return (DEVFSADM_SUCCESS);
58727c478bd9Sstevel@tonic-gate 		}
58737c478bd9Sstevel@tonic-gate 	} else if ((stat->st_mode & S_IFMT) == S_IFLNK)  {
587494c894bbSVikram Hegde 		/*
587594c894bbSVikram Hegde 		 * No need to redirect alias paths. We want a
587694c894bbSVikram Hegde 		 * true copy. The system on first boot after install
587794c894bbSVikram Hegde 		 * will redirect paths
587894c894bbSVikram Hegde 		 */
58797c478bd9Sstevel@tonic-gate 		if ((bytes = readlink(file, linkcontents, PATH_MAX)) == -1)  {
58807c478bd9Sstevel@tonic-gate 			err_print(READLINK_FAILED, fcn, file, strerror(errno));
58817c478bd9Sstevel@tonic-gate 			return (DEVFSADM_SUCCESS);
58827c478bd9Sstevel@tonic-gate 		}
58837c478bd9Sstevel@tonic-gate 		linkcontents[bytes] = '\0';
58847c478bd9Sstevel@tonic-gate 		if (symlink(linkcontents, newfile) == -1) {
58857c478bd9Sstevel@tonic-gate 			err_print(SYMLINK_FAILED, newfile, newfile,
58860a653502Swroche 			    strerror(errno));
58877c478bd9Sstevel@tonic-gate 			return (DEVFSADM_SUCCESS);
58887c478bd9Sstevel@tonic-gate 		}
58897c478bd9Sstevel@tonic-gate 	}
58907c478bd9Sstevel@tonic-gate 
58917c478bd9Sstevel@tonic-gate 	(void) lchown(newfile, stat->st_uid, stat->st_gid);
58927c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
58937c478bd9Sstevel@tonic-gate }
58947c478bd9Sstevel@tonic-gate 
58957c478bd9Sstevel@tonic-gate /*
58967c478bd9Sstevel@tonic-gate  *  Given a dev_t from the running kernel, return the new_dev_t
58977c478bd9Sstevel@tonic-gate  *  by translating to the major number found on the installed
58987c478bd9Sstevel@tonic-gate  *  target's root name_to_major file.
58997c478bd9Sstevel@tonic-gate  */
59007c478bd9Sstevel@tonic-gate static int
59017c478bd9Sstevel@tonic-gate translate_major(dev_t old_dev, dev_t *new_dev)
59027c478bd9Sstevel@tonic-gate {
59037c478bd9Sstevel@tonic-gate 	major_t oldmajor;
59047c478bd9Sstevel@tonic-gate 	major_t newmajor;
59057c478bd9Sstevel@tonic-gate 	minor_t oldminor;
59067c478bd9Sstevel@tonic-gate 	minor_t newminor;
59077c478bd9Sstevel@tonic-gate 	char cdriver[FILENAME_MAX + 1];
59087c478bd9Sstevel@tonic-gate 	char driver[FILENAME_MAX + 1];
59097c478bd9Sstevel@tonic-gate 	char *fcn = "translate_major: ";
59107c478bd9Sstevel@tonic-gate 
59117c478bd9Sstevel@tonic-gate 	oldmajor = major(old_dev);
59120a653502Swroche 	if (modctl(MODGETNAME, driver, sizeof (driver), &oldmajor) != 0) {
59137c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
59147c478bd9Sstevel@tonic-gate 	}
59157c478bd9Sstevel@tonic-gate 
59167c478bd9Sstevel@tonic-gate 	if (strcmp(driver, "clone") != 0) {
59177c478bd9Sstevel@tonic-gate 		/* non-clone case */
59187c478bd9Sstevel@tonic-gate 
59197c478bd9Sstevel@tonic-gate 		/* look up major number is target's name2major */
59207c478bd9Sstevel@tonic-gate 		if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) {
59217c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
59227c478bd9Sstevel@tonic-gate 		}
59237c478bd9Sstevel@tonic-gate 
59247c478bd9Sstevel@tonic-gate 		*new_dev = makedev(newmajor, minor(old_dev));
59257c478bd9Sstevel@tonic-gate 		if (old_dev != *new_dev) {
59267c478bd9Sstevel@tonic-gate 			vprint(CHATTY_MID, "%sdriver: %s old: %lu,%lu "
59270a653502Swroche 			    "new: %lu,%lu\n", fcn, driver, major(old_dev),
59280a653502Swroche 			    minor(old_dev), major(*new_dev), minor(*new_dev));
59297c478bd9Sstevel@tonic-gate 		}
59307c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
59317c478bd9Sstevel@tonic-gate 	} else {
59327c478bd9Sstevel@tonic-gate 		/*
59337c478bd9Sstevel@tonic-gate 		 *  The clone is a special case.  Look at its minor
59347c478bd9Sstevel@tonic-gate 		 *  number since it is the major number of the real driver.
59357c478bd9Sstevel@tonic-gate 		 */
59367c478bd9Sstevel@tonic-gate 		if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) {
59377c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
59387c478bd9Sstevel@tonic-gate 		}
59397c478bd9Sstevel@tonic-gate 
59407c478bd9Sstevel@tonic-gate 		oldminor = minor(old_dev);
59417c478bd9Sstevel@tonic-gate 		if (modctl(MODGETNAME, cdriver, sizeof (cdriver),
59420a653502Swroche 		    &oldminor) != 0) {
59437c478bd9Sstevel@tonic-gate 			err_print(MODGETNAME_FAILED, oldminor);
59447c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
59457c478bd9Sstevel@tonic-gate 		}
59467c478bd9Sstevel@tonic-gate 
59477c478bd9Sstevel@tonic-gate 		if (get_major_no(cdriver, &newminor) == DEVFSADM_FAILURE) {
59487c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
59497c478bd9Sstevel@tonic-gate 		}
59507c478bd9Sstevel@tonic-gate 
59517c478bd9Sstevel@tonic-gate 		*new_dev = makedev(newmajor, newminor);
59527c478bd9Sstevel@tonic-gate 		if (old_dev != *new_dev) {
59537c478bd9Sstevel@tonic-gate 			vprint(CHATTY_MID, "%sdriver: %s old: "
59540a653502Swroche 			    "%lu,%lu  new: %lu,%lu\n", fcn, driver,
59550a653502Swroche 			    major(old_dev), minor(old_dev),
59560a653502Swroche 			    major(*new_dev), minor(*new_dev));
59577c478bd9Sstevel@tonic-gate 		}
59587c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
59597c478bd9Sstevel@tonic-gate 	}
59607c478bd9Sstevel@tonic-gate }
59617c478bd9Sstevel@tonic-gate 
59627c478bd9Sstevel@tonic-gate /*
59637c478bd9Sstevel@tonic-gate  *
59647c478bd9Sstevel@tonic-gate  * Find the major number for driver, searching the n2m_list that was
59657c478bd9Sstevel@tonic-gate  * built in load_n2m_table().
59667c478bd9Sstevel@tonic-gate  */
59677c478bd9Sstevel@tonic-gate static int
59687c478bd9Sstevel@tonic-gate get_major_no(char *driver, major_t *major)
59697c478bd9Sstevel@tonic-gate {
59707c478bd9Sstevel@tonic-gate 	n2m_t *ptr;
59717c478bd9Sstevel@tonic-gate 
59727c478bd9Sstevel@tonic-gate 	for (ptr = n2m_list; ptr != NULL; ptr = ptr->next) {
59737c478bd9Sstevel@tonic-gate 		if (strcmp(ptr->driver, driver) == 0) {
59747c478bd9Sstevel@tonic-gate 			*major = ptr->major;
59757c478bd9Sstevel@tonic-gate 			return (DEVFSADM_SUCCESS);
59767c478bd9Sstevel@tonic-gate 		}
59777c478bd9Sstevel@tonic-gate 	}
59787c478bd9Sstevel@tonic-gate 	err_print(FIND_MAJOR_FAILED, driver);
59797c478bd9Sstevel@tonic-gate 	return (DEVFSADM_FAILURE);
59807c478bd9Sstevel@tonic-gate }
59817c478bd9Sstevel@tonic-gate 
59827c478bd9Sstevel@tonic-gate /*
59837c478bd9Sstevel@tonic-gate  * Loads a name_to_major table into memory.  Used only for suninstall's
59847c478bd9Sstevel@tonic-gate  * private -R option to devfsadm, to translate major numbers from the
59857c478bd9Sstevel@tonic-gate  * running to the installed target disk.
59867c478bd9Sstevel@tonic-gate  */
59877c478bd9Sstevel@tonic-gate static int
59887c478bd9Sstevel@tonic-gate load_n2m_table(char *file)
59897c478bd9Sstevel@tonic-gate {
59907c478bd9Sstevel@tonic-gate 	FILE *fp;
59911ca93273Seota 	char line[1024], *cp;
59927c478bd9Sstevel@tonic-gate 	char driver[PATH_MAX + 1];
59937c478bd9Sstevel@tonic-gate 	major_t major;
59947c478bd9Sstevel@tonic-gate 	n2m_t *ptr;
59957c478bd9Sstevel@tonic-gate 	int ln = 0;
59967c478bd9Sstevel@tonic-gate 
59977c478bd9Sstevel@tonic-gate 	if ((fp = fopen(file, "r")) == NULL) {
59987c478bd9Sstevel@tonic-gate 		err_print(FOPEN_FAILED, file, strerror(errno));
59997c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
60007c478bd9Sstevel@tonic-gate 	}
60017c478bd9Sstevel@tonic-gate 
60027c478bd9Sstevel@tonic-gate 	while (fgets(line, sizeof (line), fp) != NULL) {
60037c478bd9Sstevel@tonic-gate 		ln++;
60041ca93273Seota 		/* cut off comments starting with '#' */
60051ca93273Seota 		if ((cp = strchr(line, '#')) != NULL)
60061ca93273Seota 			*cp = '\0';
60071ca93273Seota 		/* ignore comment or blank lines */
60081ca93273Seota 		if (is_blank(line))
60097c478bd9Sstevel@tonic-gate 			continue;
60101ca93273Seota 		/* sanity-check */
60117c478bd9Sstevel@tonic-gate 		if (sscanf(line, "%1024s%lu", driver, &major) != 2) {
60127c478bd9Sstevel@tonic-gate 			err_print(IGNORING_LINE_IN, ln, file);
60137c478bd9Sstevel@tonic-gate 			continue;
60147c478bd9Sstevel@tonic-gate 		}
60157c478bd9Sstevel@tonic-gate 		ptr = (n2m_t *)s_malloc(sizeof (n2m_t));
60167c478bd9Sstevel@tonic-gate 		ptr->major = major;
60177c478bd9Sstevel@tonic-gate 		ptr->driver = s_strdup(driver);
60187c478bd9Sstevel@tonic-gate 		ptr->next = n2m_list;
60197c478bd9Sstevel@tonic-gate 		n2m_list = ptr;
60207c478bd9Sstevel@tonic-gate 	}
60217c478bd9Sstevel@tonic-gate 	if (fclose(fp) == EOF) {
60227c478bd9Sstevel@tonic-gate 		err_print(FCLOSE_FAILED, file, strerror(errno));
60237c478bd9Sstevel@tonic-gate 	}
60247c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
60257c478bd9Sstevel@tonic-gate }
60267c478bd9Sstevel@tonic-gate 
60278d483882Smlf /*
60288d483882Smlf  * Called at devfsadm startup to read the file /etc/dev/enumerate_reserved
60298d483882Smlf  * Creates a linked list of devlinks from which reserved IDs can be derived
60308d483882Smlf  */
60318d483882Smlf static void
60328d483882Smlf read_enumerate_file(void)
60338d483882Smlf {
60348d483882Smlf 	FILE *fp;
60358d483882Smlf 	int linenum;
60368d483882Smlf 	char line[PATH_MAX+1];
60378d483882Smlf 	enumerate_file_t *entry;
60388d483882Smlf 	struct stat current_sb;
60398d483882Smlf 	static struct stat cached_sb;
60408d483882Smlf 	static int cached = FALSE;
60418d483882Smlf 
60428d483882Smlf 	assert(enumerate_file);
60438d483882Smlf 
60448d483882Smlf 	if (stat(enumerate_file, &current_sb) == -1) {
60458d483882Smlf 		vprint(RSRV_MID, "No reserved file: %s\n", enumerate_file);
60468d483882Smlf 		cached = FALSE;
60478d483882Smlf 		if (enumerate_reserved != NULL) {
60488d483882Smlf 			vprint(RSRV_MID, "invalidating %s cache\n",
60498d483882Smlf 			    enumerate_file);
60508d483882Smlf 		}
60518d483882Smlf 		while (enumerate_reserved != NULL) {
60528d483882Smlf 			entry = enumerate_reserved;
60538d483882Smlf 			enumerate_reserved = entry->er_next;
60548d483882Smlf 			free(entry->er_file);
60558d483882Smlf 			free(entry->er_id);
60568d483882Smlf 			free(entry);
60578d483882Smlf 		}
60588d483882Smlf 		return;
60598d483882Smlf 	}
60608d483882Smlf 
60618d483882Smlf 	/* if already cached, check to see if it is still valid */
60628d483882Smlf 	if (cached == TRUE) {
60638d483882Smlf 
60648d483882Smlf 		if (current_sb.st_mtime == cached_sb.st_mtime) {
60658d483882Smlf 			vprint(RSRV_MID, "%s cache valid\n", enumerate_file);
60668d483882Smlf 			vprint(FILES_MID, "%s cache valid\n", enumerate_file);
60678d483882Smlf 			return;
60688d483882Smlf 		}
60698d483882Smlf 
60708d483882Smlf 		vprint(RSRV_MID, "invalidating %s cache\n", enumerate_file);
60718d483882Smlf 		vprint(FILES_MID, "invalidating %s cache\n", enumerate_file);
60728d483882Smlf 
60738d483882Smlf 		while (enumerate_reserved != NULL) {
60748d483882Smlf 			entry = enumerate_reserved;
60758d483882Smlf 			enumerate_reserved = entry->er_next;
60768d483882Smlf 			free(entry->er_file);
60778d483882Smlf 			free(entry->er_id);
60788d483882Smlf 			free(entry);
60798d483882Smlf 		}
60808d483882Smlf 		vprint(RSRV_MID, "Recaching file: %s\n", enumerate_file);
60818d483882Smlf 	} else {
60828d483882Smlf 		vprint(RSRV_MID, "Caching file (first time): %s\n",
60838d483882Smlf 		    enumerate_file);
60848d483882Smlf 		cached = TRUE;
60858d483882Smlf 	}
60868d483882Smlf 
60878d483882Smlf 	(void) stat(enumerate_file, &cached_sb);
60888d483882Smlf 
60898d483882Smlf 	if ((fp = fopen(enumerate_file, "r")) == NULL) {
60908d483882Smlf 		err_print(FOPEN_FAILED, enumerate_file, strerror(errno));
60918d483882Smlf 		return;
60928d483882Smlf 	}
60938d483882Smlf 
60948d483882Smlf 	vprint(RSRV_MID, "Reading reserve file: %s\n", enumerate_file);
60958d483882Smlf 	linenum = 0;
60968d483882Smlf 	while (fgets(line, sizeof (line), fp) != NULL) {
60978d483882Smlf 		char	*cp, *ncp;
60988d483882Smlf 
60998d483882Smlf 		linenum++;
61008d483882Smlf 
61018d483882Smlf 		/* remove newline */
61028d483882Smlf 		cp = strchr(line, '\n');
61038d483882Smlf 		if (cp)
61048d483882Smlf 			*cp = '\0';
61058d483882Smlf 
61060a653502Swroche 		vprint(RSRV_MID, "Reserve file: line %d: %s\n", linenum, line);
61078d483882Smlf 
61088d483882Smlf 		/* skip over space and tab */
61090a653502Swroche 		for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
61100a653502Swroche 			;
61118d483882Smlf 
61128d483882Smlf 		if (*cp == '\0' || *cp == '#') {
61138d483882Smlf 			vprint(RSRV_MID, "Skipping line: '%s'\n", line);
61148d483882Smlf 			continue; /* blank line or comment line */
61158d483882Smlf 		}
61168d483882Smlf 
61178d483882Smlf 		ncp = cp;
61188d483882Smlf 
61198d483882Smlf 		/* delete trailing blanks */
61200a653502Swroche 		for (; *cp != ' ' && *cp != '\t' && *cp != '\0'; cp++)
61210a653502Swroche 			;
61228d483882Smlf 		*cp = '\0';
61238d483882Smlf 
61248d483882Smlf 		entry = s_zalloc(sizeof (enumerate_file_t));
61258d483882Smlf 		entry->er_file = s_strdup(ncp);
61268d483882Smlf 		entry->er_id = NULL;
61278d483882Smlf 		entry->er_next = enumerate_reserved;
61288d483882Smlf 		enumerate_reserved = entry;
61298d483882Smlf 	}
61308d483882Smlf 
61318d483882Smlf 	if (fclose(fp) == EOF) {
61328d483882Smlf 		err_print(FCLOSE_FAILED, enumerate_file, strerror(errno));
61338d483882Smlf 	}
61348d483882Smlf }
61358d483882Smlf 
61367c478bd9Sstevel@tonic-gate /*
61377c478bd9Sstevel@tonic-gate  * Called at devfsadm startup to read in the devlink.tab file.	Creates
61387c478bd9Sstevel@tonic-gate  * a linked list of devlinktab_list structures which will be
61397c478bd9Sstevel@tonic-gate  * searched for every minor node.
61407c478bd9Sstevel@tonic-gate  */
61417c478bd9Sstevel@tonic-gate static void
61427c478bd9Sstevel@tonic-gate read_devlinktab_file(void)
61437c478bd9Sstevel@tonic-gate {
61447c478bd9Sstevel@tonic-gate 	devlinktab_list_t *headp = NULL;
61457c478bd9Sstevel@tonic-gate 	devlinktab_list_t *entryp;
61467c478bd9Sstevel@tonic-gate 	devlinktab_list_t **previous;
61477c478bd9Sstevel@tonic-gate 	devlinktab_list_t *save;
61481ca93273Seota 	char line[MAX_DEVLINK_LINE], *cp;
61497c478bd9Sstevel@tonic-gate 	char *selector;
61507c478bd9Sstevel@tonic-gate 	char *p_link;
61517c478bd9Sstevel@tonic-gate 	char *s_link;
61527c478bd9Sstevel@tonic-gate 	FILE *fp;
61537c478bd9Sstevel@tonic-gate 	int i;
61547c478bd9Sstevel@tonic-gate 	static struct stat cached_sb;
61557c478bd9Sstevel@tonic-gate 	struct stat current_sb;
61567c478bd9Sstevel@tonic-gate 	static int cached = FALSE;
61577c478bd9Sstevel@tonic-gate 
61587c478bd9Sstevel@tonic-gate 	if (devlinktab_file == NULL) {
61597c478bd9Sstevel@tonic-gate 		return;
61607c478bd9Sstevel@tonic-gate 	}
61617c478bd9Sstevel@tonic-gate 
61627c478bd9Sstevel@tonic-gate 	(void) stat(devlinktab_file, &current_sb);
61637c478bd9Sstevel@tonic-gate 
61647c478bd9Sstevel@tonic-gate 	/* if already cached, check to see if it is still valid */
61657c478bd9Sstevel@tonic-gate 	if (cached == TRUE) {
61667c478bd9Sstevel@tonic-gate 
61677c478bd9Sstevel@tonic-gate 		if (current_sb.st_mtime == cached_sb.st_mtime) {
61687c478bd9Sstevel@tonic-gate 			vprint(FILES_MID, "%s cache valid\n", devlinktab_file);
61697c478bd9Sstevel@tonic-gate 			return;
61707c478bd9Sstevel@tonic-gate 		}
61717c478bd9Sstevel@tonic-gate 
61727c478bd9Sstevel@tonic-gate 		vprint(FILES_MID, "invalidating %s cache\n", devlinktab_file);
61737c478bd9Sstevel@tonic-gate 
61747c478bd9Sstevel@tonic-gate 		while (devlinktab_list != NULL) {
61757c478bd9Sstevel@tonic-gate 			free_link_list(devlinktab_list->p_link);
61767c478bd9Sstevel@tonic-gate 			free_link_list(devlinktab_list->s_link);
61777c478bd9Sstevel@tonic-gate 			free_selector_list(devlinktab_list->selector);
61787c478bd9Sstevel@tonic-gate 			free(devlinktab_list->selector_pattern);
61797c478bd9Sstevel@tonic-gate 			free(devlinktab_list->p_link_pattern);
61807c478bd9Sstevel@tonic-gate 			if (devlinktab_list->s_link_pattern != NULL) {
61817c478bd9Sstevel@tonic-gate 				free(devlinktab_list->s_link_pattern);
61827c478bd9Sstevel@tonic-gate 			}
61837c478bd9Sstevel@tonic-gate 			save = devlinktab_list;
61847c478bd9Sstevel@tonic-gate 			devlinktab_list = devlinktab_list->next;
61857c478bd9Sstevel@tonic-gate 			free(save);
61867c478bd9Sstevel@tonic-gate 		}
61877c478bd9Sstevel@tonic-gate 	} else {
61887c478bd9Sstevel@tonic-gate 		cached = TRUE;
61897c478bd9Sstevel@tonic-gate 	}
61907c478bd9Sstevel@tonic-gate 
61917c478bd9Sstevel@tonic-gate 	(void) stat(devlinktab_file, &cached_sb);
61927c478bd9Sstevel@tonic-gate 
61937c478bd9Sstevel@tonic-gate 	if ((fp = fopen(devlinktab_file, "r")) == NULL) {
61947c478bd9Sstevel@tonic-gate 		err_print(FOPEN_FAILED, devlinktab_file, strerror(errno));
61957c478bd9Sstevel@tonic-gate 		return;
61967c478bd9Sstevel@tonic-gate 	}
61977c478bd9Sstevel@tonic-gate 
61987c478bd9Sstevel@tonic-gate 	previous = &headp;
61997c478bd9Sstevel@tonic-gate 
62007c478bd9Sstevel@tonic-gate 	while (fgets(line, sizeof (line), fp) != NULL) {
62017c478bd9Sstevel@tonic-gate 		devlinktab_line++;
62027c478bd9Sstevel@tonic-gate 		i = strlen(line);
62037c478bd9Sstevel@tonic-gate 		if (line[i-1] == NEWLINE) {
62047c478bd9Sstevel@tonic-gate 			line[i-1] = '\0';
62057c478bd9Sstevel@tonic-gate 		} else if (i == sizeof (line-1)) {
62067c478bd9Sstevel@tonic-gate 			err_print(LINE_TOO_LONG, devlinktab_line,
62077c478bd9Sstevel@tonic-gate 			    devlinktab_file, sizeof (line)-1);
62080a653502Swroche 			while (((i = getc(fp)) != '\n') && (i != EOF))
62090a653502Swroche 				;
62107c478bd9Sstevel@tonic-gate 			continue;
62117c478bd9Sstevel@tonic-gate 		}
62127c478bd9Sstevel@tonic-gate 
62131ca93273Seota 		/* cut off comments starting with '#' */
62141ca93273Seota 		if ((cp = strchr(line, '#')) != NULL)
62151ca93273Seota 			*cp = '\0';
62161ca93273Seota 		/* ignore comment or blank lines */
62171ca93273Seota 		if (is_blank(line))
62187c478bd9Sstevel@tonic-gate 			continue;
62197c478bd9Sstevel@tonic-gate 
62207c478bd9Sstevel@tonic-gate 		vprint(DEVLINK_MID, "table: %s line %d: '%s'\n",
62210a653502Swroche 		    devlinktab_file, devlinktab_line, line);
62227c478bd9Sstevel@tonic-gate 
62237c478bd9Sstevel@tonic-gate 		/* break each entry into fields.  s_link may be NULL */
62247c478bd9Sstevel@tonic-gate 		if (split_devlinktab_entry(line, &selector, &p_link,
62257c478bd9Sstevel@tonic-gate 		    &s_link) == DEVFSADM_FAILURE) {
62267c478bd9Sstevel@tonic-gate 			vprint(DEVLINK_MID, "split_entry returns failure\n");
62277c478bd9Sstevel@tonic-gate 			continue;
62287c478bd9Sstevel@tonic-gate 		} else {
62297c478bd9Sstevel@tonic-gate 			vprint(DEVLINK_MID, "split_entry selector='%s' "
62300a653502Swroche 			    "p_link='%s' s_link='%s'\n\n", selector,
62310a653502Swroche 			    p_link, (s_link == NULL) ? "" : s_link);
62327c478bd9Sstevel@tonic-gate 		}
62337c478bd9Sstevel@tonic-gate 
62340a653502Swroche 		entryp =
62350a653502Swroche 		    (devlinktab_list_t *)s_malloc(sizeof (devlinktab_list_t));
62367c478bd9Sstevel@tonic-gate 
62377c478bd9Sstevel@tonic-gate 		entryp->line_number = devlinktab_line;
62387c478bd9Sstevel@tonic-gate 
62390a653502Swroche 		if ((entryp->selector = create_selector_list(selector))
62400a653502Swroche 		    == NULL) {
62417c478bd9Sstevel@tonic-gate 			free(entryp);
62427c478bd9Sstevel@tonic-gate 			continue;
62437c478bd9Sstevel@tonic-gate 		}
62447c478bd9Sstevel@tonic-gate 		entryp->selector_pattern = s_strdup(selector);
62457c478bd9Sstevel@tonic-gate 
62467c478bd9Sstevel@tonic-gate 		if ((entryp->p_link = create_link_list(p_link)) == NULL) {
62477c478bd9Sstevel@tonic-gate 			free_selector_list(entryp->selector);
62487c478bd9Sstevel@tonic-gate 			free(entryp->selector_pattern);
62497c478bd9Sstevel@tonic-gate 			free(entryp);
62507c478bd9Sstevel@tonic-gate 			continue;
62517c478bd9Sstevel@tonic-gate 		}
62527c478bd9Sstevel@tonic-gate 
62537c478bd9Sstevel@tonic-gate 		entryp->p_link_pattern = s_strdup(p_link);
62547c478bd9Sstevel@tonic-gate 
62557c478bd9Sstevel@tonic-gate 		if (s_link != NULL) {
62567c478bd9Sstevel@tonic-gate 			if ((entryp->s_link =
62577c478bd9Sstevel@tonic-gate 			    create_link_list(s_link)) == NULL) {
62587c478bd9Sstevel@tonic-gate 				free_selector_list(entryp->selector);
62597c478bd9Sstevel@tonic-gate 				free_link_list(entryp->p_link);
62607c478bd9Sstevel@tonic-gate 				free(entryp->selector_pattern);
62617c478bd9Sstevel@tonic-gate 				free(entryp->p_link_pattern);
62627c478bd9Sstevel@tonic-gate 				free(entryp);
62637c478bd9Sstevel@tonic-gate 				continue;
62647c478bd9Sstevel@tonic-gate 			}
62650a653502Swroche 			entryp->s_link_pattern = s_strdup(s_link);
62667c478bd9Sstevel@tonic-gate 		} else {
62677c478bd9Sstevel@tonic-gate 			entryp->s_link = NULL;
62687c478bd9Sstevel@tonic-gate 			entryp->s_link_pattern = NULL;
62697c478bd9Sstevel@tonic-gate 
62707c478bd9Sstevel@tonic-gate 		}
62717c478bd9Sstevel@tonic-gate 
62727c478bd9Sstevel@tonic-gate 		/* append to end of list */
62737c478bd9Sstevel@tonic-gate 
62747c478bd9Sstevel@tonic-gate 		entryp->next = NULL;
62757c478bd9Sstevel@tonic-gate 		*previous = entryp;
62767c478bd9Sstevel@tonic-gate 		previous = &(entryp->next);
62777c478bd9Sstevel@tonic-gate 	}
62787c478bd9Sstevel@tonic-gate 	if (fclose(fp) == EOF) {
62797c478bd9Sstevel@tonic-gate 		err_print(FCLOSE_FAILED, devlinktab_file, strerror(errno));
62807c478bd9Sstevel@tonic-gate 	}
62817c478bd9Sstevel@tonic-gate 	devlinktab_list = headp;
62827c478bd9Sstevel@tonic-gate }
62837c478bd9Sstevel@tonic-gate 
62847c478bd9Sstevel@tonic-gate /*
62857c478bd9Sstevel@tonic-gate  *
62867c478bd9Sstevel@tonic-gate  * For a single line entry in devlink.tab, split the line into fields
62877c478bd9Sstevel@tonic-gate  * selector, p_link, and an optionally s_link.	If s_link field is not
62887c478bd9Sstevel@tonic-gate  * present, then return NULL in s_link (not NULL string).
62897c478bd9Sstevel@tonic-gate  */
62907c478bd9Sstevel@tonic-gate static int
62917c478bd9Sstevel@tonic-gate split_devlinktab_entry(char *entry, char **selector, char **p_link,
62927c478bd9Sstevel@tonic-gate 			char **s_link)
62937c478bd9Sstevel@tonic-gate {
62947c478bd9Sstevel@tonic-gate 	char *tab;
62957c478bd9Sstevel@tonic-gate 
62967c478bd9Sstevel@tonic-gate 	*selector = entry;
62977c478bd9Sstevel@tonic-gate 
62987c478bd9Sstevel@tonic-gate 	if ((tab = strchr(entry, TAB)) != NULL) {
62997c478bd9Sstevel@tonic-gate 		*tab = '\0';
63007c478bd9Sstevel@tonic-gate 		*p_link = ++tab;
63017c478bd9Sstevel@tonic-gate 	} else {
63027c478bd9Sstevel@tonic-gate 		err_print(MISSING_TAB, devlinktab_line, devlinktab_file);
63037c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
63047c478bd9Sstevel@tonic-gate 	}
63057c478bd9Sstevel@tonic-gate 
63067c478bd9Sstevel@tonic-gate 	if (*p_link == '\0') {
63077c478bd9Sstevel@tonic-gate 		err_print(MISSING_DEVNAME, devlinktab_line, devlinktab_file);
63087c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
63097c478bd9Sstevel@tonic-gate 	}
63107c478bd9Sstevel@tonic-gate 
63117c478bd9Sstevel@tonic-gate 	if ((tab = strchr(*p_link, TAB)) != NULL) {
63127c478bd9Sstevel@tonic-gate 		*tab = '\0';
63137c478bd9Sstevel@tonic-gate 		*s_link = ++tab;
63147c478bd9Sstevel@tonic-gate 		if (strchr(*s_link, TAB) != NULL) {
63157c478bd9Sstevel@tonic-gate 			err_print(TOO_MANY_FIELDS, devlinktab_line,
63160a653502Swroche 			    devlinktab_file);
63177c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
63187c478bd9Sstevel@tonic-gate 		}
63197c478bd9Sstevel@tonic-gate 	} else {
63207c478bd9Sstevel@tonic-gate 		*s_link = NULL;
63217c478bd9Sstevel@tonic-gate 	}
63227c478bd9Sstevel@tonic-gate 
63237c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
63247c478bd9Sstevel@tonic-gate }
63257c478bd9Sstevel@tonic-gate 
63267c478bd9Sstevel@tonic-gate /*
63277c478bd9Sstevel@tonic-gate  * For a given devfs_spec field, for each element in the field, add it to
63287c478bd9Sstevel@tonic-gate  * a linked list of devfs_spec structures.  Return the linked list in
63297c478bd9Sstevel@tonic-gate  * devfs_spec_list.
63307c478bd9Sstevel@tonic-gate  */
63317c478bd9Sstevel@tonic-gate static selector_list_t *
63327c478bd9Sstevel@tonic-gate create_selector_list(char *selector)
63337c478bd9Sstevel@tonic-gate {
63340a653502Swroche 	char *key;
63350a653502Swroche 	char *val;
63360a653502Swroche 	int error = FALSE;
63370a653502Swroche 	selector_list_t *head_selector_list = NULL;
63380a653502Swroche 	selector_list_t *selector_list;
63390a653502Swroche 
63400a653502Swroche 	/* parse_devfs_spec splits the next field into keyword & value */
63410a653502Swroche 	while ((*selector != NULL) && (error == FALSE)) {
63420a653502Swroche 		if (parse_selector(&selector, &key, &val) == DEVFSADM_FAILURE) {
63430a653502Swroche 			error = TRUE;
63440a653502Swroche 			break;
63450a653502Swroche 		} else {
63460a653502Swroche 			selector_list = (selector_list_t *)
63470a653502Swroche 			    s_malloc(sizeof (selector_list_t));
63480a653502Swroche 			if (strcmp(NAME_S, key) == 0) {
63490a653502Swroche 				selector_list->key = NAME;
63500a653502Swroche 			} else if (strcmp(TYPE_S, key) == 0) {
63510a653502Swroche 				selector_list->key = TYPE;
63520a653502Swroche 			} else if (strncmp(ADDR_S, key, ADDR_S_LEN) == 0) {
63530a653502Swroche 				selector_list->key = ADDR;
63540a653502Swroche 				if (key[ADDR_S_LEN] == '\0') {
63550a653502Swroche 					selector_list->arg = 0;
63560a653502Swroche 				} else if (isdigit(key[ADDR_S_LEN]) != FALSE) {
63570a653502Swroche 					selector_list->arg =
63580a653502Swroche 					    atoi(&key[ADDR_S_LEN]);
63590a653502Swroche 				} else {
63600a653502Swroche 					error = TRUE;
63610a653502Swroche 					free(selector_list);
63620a653502Swroche 					err_print(BADKEYWORD, key,
63630a653502Swroche 					    devlinktab_line, devlinktab_file);
63640a653502Swroche 					break;
63650a653502Swroche 				}
63660a653502Swroche 			} else if (strncmp(MINOR_S, key, MINOR_S_LEN) == 0) {
63670a653502Swroche 				selector_list->key = MINOR;
63680a653502Swroche 				if (key[MINOR_S_LEN] == '\0') {
63690a653502Swroche 					selector_list->arg = 0;
63700a653502Swroche 				} else if (isdigit(key[MINOR_S_LEN]) != FALSE) {
63710a653502Swroche 					selector_list->arg =
63720a653502Swroche 					    atoi(&key[MINOR_S_LEN]);
63730a653502Swroche 				} else {
63740a653502Swroche 					error = TRUE;
63750a653502Swroche 					free(selector_list);
63760a653502Swroche 					err_print(BADKEYWORD, key,
63770a653502Swroche 					    devlinktab_line, devlinktab_file);
63780a653502Swroche 					break;
63790a653502Swroche 				}
63800a653502Swroche 				vprint(DEVLINK_MID, "MINOR = %s\n", val);
63810a653502Swroche 			} else {
63820a653502Swroche 				err_print(UNRECOGNIZED_KEY, key,
63830a653502Swroche 				    devlinktab_line, devlinktab_file);
63840a653502Swroche 				error = TRUE;
63850a653502Swroche 				free(selector_list);
63860a653502Swroche 				break;
63870a653502Swroche 			}
63880a653502Swroche 			selector_list->val = s_strdup(val);
63890a653502Swroche 			selector_list->next = head_selector_list;
63900a653502Swroche 			head_selector_list = selector_list;
63910a653502Swroche 			vprint(DEVLINK_MID, "key='%s' val='%s' arg=%d\n",
63920a653502Swroche 			    key, val, selector_list->arg);
63930a653502Swroche 		}
63940a653502Swroche 	}
63950a653502Swroche 
63960a653502Swroche 	if ((error == FALSE) && (head_selector_list != NULL)) {
63970a653502Swroche 		return (head_selector_list);
63980a653502Swroche 	} else {
63990a653502Swroche 		/* parse failed.  Free any allocated structs */
64000a653502Swroche 		free_selector_list(head_selector_list);
64010a653502Swroche 		return (NULL);
64020a653502Swroche 	}
64037c478bd9Sstevel@tonic-gate }
64047c478bd9Sstevel@tonic-gate 
64057c478bd9Sstevel@tonic-gate /*
64067c478bd9Sstevel@tonic-gate  * Takes a semicolon separated list of selector elements and breaks up
64077c478bd9Sstevel@tonic-gate  * into a keyword-value pair.	semicolon and equal characters are
64087c478bd9Sstevel@tonic-gate  * replaced with NULL's.  On success, selector is updated to point to the
64097c478bd9Sstevel@tonic-gate  * terminating NULL character terminating the keyword-value pair, and the
64107c478bd9Sstevel@tonic-gate  * function returns DEVFSADM_SUCCESS.	If there is a syntax error,
64117c478bd9Sstevel@tonic-gate  * devfs_spec is not modified and function returns DEVFSADM_FAILURE.
64127c478bd9Sstevel@tonic-gate  */
64137c478bd9Sstevel@tonic-gate static int
64147c478bd9Sstevel@tonic-gate parse_selector(char **selector, char **key, char **val)
64157c478bd9Sstevel@tonic-gate {
64167c478bd9Sstevel@tonic-gate 	char *equal;
64177c478bd9Sstevel@tonic-gate 	char *semi_colon;
64187c478bd9Sstevel@tonic-gate 
64197c478bd9Sstevel@tonic-gate 	*key = *selector;
64207c478bd9Sstevel@tonic-gate 
64217c478bd9Sstevel@tonic-gate 	if ((equal = strchr(*key, '=')) != NULL) {
64227c478bd9Sstevel@tonic-gate 		*equal = '\0';
64237c478bd9Sstevel@tonic-gate 	} else {
64247c478bd9Sstevel@tonic-gate 		err_print(MISSING_EQUAL, devlinktab_line, devlinktab_file);
64257c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
64267c478bd9Sstevel@tonic-gate 	}
64277c478bd9Sstevel@tonic-gate 
64287c478bd9Sstevel@tonic-gate 	*val = ++equal;
64297c478bd9Sstevel@tonic-gate 	if ((semi_colon = strchr(equal, ';')) != NULL) {
64307c478bd9Sstevel@tonic-gate 		*semi_colon = '\0';
64317c478bd9Sstevel@tonic-gate 		*selector = semi_colon + 1;
64327c478bd9Sstevel@tonic-gate 	} else {
64337c478bd9Sstevel@tonic-gate 		*selector = equal + strlen(equal);
64347c478bd9Sstevel@tonic-gate 	}
64357c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
64367c478bd9Sstevel@tonic-gate }
64377c478bd9Sstevel@tonic-gate 
64387c478bd9Sstevel@tonic-gate /*
64397c478bd9Sstevel@tonic-gate  * link is either the second or third field of devlink.tab.  Parse link
64407c478bd9Sstevel@tonic-gate  * into a linked list of devlink structures and return ptr to list.  Each
64417c478bd9Sstevel@tonic-gate  * list element is either a constant string, or one of the following
64427c478bd9Sstevel@tonic-gate  * escape sequences: \M, \A, \N, or \D.  The first three escape sequences
64437c478bd9Sstevel@tonic-gate  * take a numerical argument.
64447c478bd9Sstevel@tonic-gate  */
64457c478bd9Sstevel@tonic-gate static link_list_t *
64467c478bd9Sstevel@tonic-gate create_link_list(char *link)
64477c478bd9Sstevel@tonic-gate {
64487c478bd9Sstevel@tonic-gate 	int x = 0;
64497c478bd9Sstevel@tonic-gate 	int error = FALSE;
64507c478bd9Sstevel@tonic-gate 	int counter_found = FALSE;
64517c478bd9Sstevel@tonic-gate 	link_list_t *head = NULL;
64527c478bd9Sstevel@tonic-gate 	link_list_t **ptr;
64537c478bd9Sstevel@tonic-gate 	link_list_t *link_list;
64547c478bd9Sstevel@tonic-gate 	char constant[MAX_DEVLINK_LINE];
64557c478bd9Sstevel@tonic-gate 	char *error_str;
64567c478bd9Sstevel@tonic-gate 
64577c478bd9Sstevel@tonic-gate 	if (link == NULL) {
64587c478bd9Sstevel@tonic-gate 		return (NULL);
64597c478bd9Sstevel@tonic-gate 	}
64607c478bd9Sstevel@tonic-gate 
64617c478bd9Sstevel@tonic-gate 	while ((*link != '\0') && (error == FALSE)) {
64627c478bd9Sstevel@tonic-gate 		link_list = (link_list_t *)s_malloc(sizeof (link_list_t));
64637c478bd9Sstevel@tonic-gate 		link_list->next = NULL;
64647c478bd9Sstevel@tonic-gate 
64657c478bd9Sstevel@tonic-gate 		while ((*link != '\0') && (*link != '\\')) {
64667c478bd9Sstevel@tonic-gate 			/* a non-escaped string */
64677c478bd9Sstevel@tonic-gate 			constant[x++] = *(link++);
64687c478bd9Sstevel@tonic-gate 		}
64697c478bd9Sstevel@tonic-gate 		if (x != 0) {
64707c478bd9Sstevel@tonic-gate 			constant[x] = '\0';
64717c478bd9Sstevel@tonic-gate 			link_list->type = CONSTANT;
64727c478bd9Sstevel@tonic-gate 			link_list->constant = s_strdup(constant);
64737c478bd9Sstevel@tonic-gate 			x = 0;
64747c478bd9Sstevel@tonic-gate 			vprint(DEVLINK_MID, "CONSTANT FOUND %s\n", constant);
64757c478bd9Sstevel@tonic-gate 		} else {
64767c478bd9Sstevel@tonic-gate 			switch (*(++link)) {
64777c478bd9Sstevel@tonic-gate 			case 'M':
64787c478bd9Sstevel@tonic-gate 				link_list->type = MINOR;
64797c478bd9Sstevel@tonic-gate 				break;
64807c478bd9Sstevel@tonic-gate 			case 'A':
64817c478bd9Sstevel@tonic-gate 				link_list->type = ADDR;
64827c478bd9Sstevel@tonic-gate 				break;
64837c478bd9Sstevel@tonic-gate 			case 'N':
64847c478bd9Sstevel@tonic-gate 				if (counter_found == TRUE) {
64857c478bd9Sstevel@tonic-gate 					error = TRUE;
64860a653502Swroche 					error_str =
64870a653502Swroche 					    "multiple counters not permitted";
64887c478bd9Sstevel@tonic-gate 					free(link_list);
64897c478bd9Sstevel@tonic-gate 				} else {
64907c478bd9Sstevel@tonic-gate 					counter_found = TRUE;
64917c478bd9Sstevel@tonic-gate 					link_list->type = COUNTER;
64927c478bd9Sstevel@tonic-gate 				}
64937c478bd9Sstevel@tonic-gate 				break;
64947c478bd9Sstevel@tonic-gate 			case 'D':
64957c478bd9Sstevel@tonic-gate 				link_list->type = NAME;
64967c478bd9Sstevel@tonic-gate 				break;
64977c478bd9Sstevel@tonic-gate 			default:
64987c478bd9Sstevel@tonic-gate 				error = TRUE;
64997c478bd9Sstevel@tonic-gate 				free(link_list);
65007c478bd9Sstevel@tonic-gate 				error_str = "unrecognized escape sequence";
65017c478bd9Sstevel@tonic-gate 				break;
65027c478bd9Sstevel@tonic-gate 			}
65037c478bd9Sstevel@tonic-gate 			if (*(link++) != 'D') {
65047c478bd9Sstevel@tonic-gate 				if (isdigit(*link) == FALSE) {
65057c478bd9Sstevel@tonic-gate 					error_str = "escape sequence must be "
65060a653502Swroche 					    "followed by a digit\n";
65077c478bd9Sstevel@tonic-gate 					error = TRUE;
65087c478bd9Sstevel@tonic-gate 					free(link_list);
65097c478bd9Sstevel@tonic-gate 				} else {
65107c478bd9Sstevel@tonic-gate 					link_list->arg =
65110a653502Swroche 					    (int)strtoul(link, &link, 10);
65127c478bd9Sstevel@tonic-gate 					vprint(DEVLINK_MID, "link_list->arg = "
65130a653502Swroche 					    "%d\n", link_list->arg);
65147c478bd9Sstevel@tonic-gate 				}
65157c478bd9Sstevel@tonic-gate 			}
65167c478bd9Sstevel@tonic-gate 		}
65177c478bd9Sstevel@tonic-gate 		/* append link_list struct to end of list */
65187c478bd9Sstevel@tonic-gate 		if (error == FALSE) {
65190a653502Swroche 			for (ptr = &head; *ptr != NULL; ptr = &((*ptr)->next))
65200a653502Swroche 				;
65217c478bd9Sstevel@tonic-gate 			*ptr = link_list;
65227c478bd9Sstevel@tonic-gate 		}
65237c478bd9Sstevel@tonic-gate 	}
65247c478bd9Sstevel@tonic-gate 
65257c478bd9Sstevel@tonic-gate 	if (error == FALSE) {
65267c478bd9Sstevel@tonic-gate 		return (head);
65277c478bd9Sstevel@tonic-gate 	} else {
65287c478bd9Sstevel@tonic-gate 		err_print(CONFIG_INCORRECT, devlinktab_line, devlinktab_file,
65297c478bd9Sstevel@tonic-gate 		    error_str);
65307c478bd9Sstevel@tonic-gate 		free_link_list(head);
65317c478bd9Sstevel@tonic-gate 		return (NULL);
65327c478bd9Sstevel@tonic-gate 	}
65337c478bd9Sstevel@tonic-gate }
65347c478bd9Sstevel@tonic-gate 
65357c478bd9Sstevel@tonic-gate /*
65367c478bd9Sstevel@tonic-gate  * Called for each minor node devfsadm processes; for each minor node,
65377c478bd9Sstevel@tonic-gate  * look for matches in the devlinktab_list list which was created on
65387c478bd9Sstevel@tonic-gate  * startup read_devlinktab_file().  If there is a match, call build_links()
65397c478bd9Sstevel@tonic-gate  * to build a logical devlink and a possible extra devlink.
65407c478bd9Sstevel@tonic-gate  */
65417c478bd9Sstevel@tonic-gate static int
65427c478bd9Sstevel@tonic-gate process_devlink_compat(di_minor_t minor, di_node_t node)
65437c478bd9Sstevel@tonic-gate {
65447c478bd9Sstevel@tonic-gate 	int link_built = FALSE;
65457c478bd9Sstevel@tonic-gate 	devlinktab_list_t *entry;
65467c478bd9Sstevel@tonic-gate 	char *nodetype;
65477c478bd9Sstevel@tonic-gate 	char *dev_path;
65487c478bd9Sstevel@tonic-gate 
65497c478bd9Sstevel@tonic-gate 	if (devlinks_debug == TRUE) {
65507c478bd9Sstevel@tonic-gate 		nodetype =  di_minor_nodetype(minor);
65517c478bd9Sstevel@tonic-gate 		assert(nodetype != NULL);
65527c478bd9Sstevel@tonic-gate 		if ((dev_path = di_devfs_path(node)) != NULL) {
65530a653502Swroche 			vprint(INFO_MID, "'%s' entry: %s:%s\n",
65540a653502Swroche 			    nodetype, dev_path,
65550a653502Swroche 			    di_minor_name(minor) ? di_minor_name(minor) : "");
65567c478bd9Sstevel@tonic-gate 			di_devfs_path_free(dev_path);
65577c478bd9Sstevel@tonic-gate 		}
65587c478bd9Sstevel@tonic-gate 
65597c478bd9Sstevel@tonic-gate 	}
65607c478bd9Sstevel@tonic-gate 
65617c478bd9Sstevel@tonic-gate 
65627c478bd9Sstevel@tonic-gate 	/* don't process devlink.tab if devfsadm invoked with -c <class> */
65637c478bd9Sstevel@tonic-gate 	if (num_classes > 0) {
65647c478bd9Sstevel@tonic-gate 		return (FALSE);
65657c478bd9Sstevel@tonic-gate 	}
65667c478bd9Sstevel@tonic-gate 
65677c478bd9Sstevel@tonic-gate 	for (entry = devlinktab_list; entry != NULL; entry = entry->next) {
65687c478bd9Sstevel@tonic-gate 		if (devlink_matches(entry, minor, node) == DEVFSADM_SUCCESS) {
65697c478bd9Sstevel@tonic-gate 			link_built = TRUE;
65707c478bd9Sstevel@tonic-gate 			(void) build_links(entry, minor, node);
65717c478bd9Sstevel@tonic-gate 		}
65727c478bd9Sstevel@tonic-gate 	}
65737c478bd9Sstevel@tonic-gate 	return (link_built);
65747c478bd9Sstevel@tonic-gate }
65757c478bd9Sstevel@tonic-gate 
65767c478bd9Sstevel@tonic-gate /*
65777c478bd9Sstevel@tonic-gate  * For a given devlink.tab devlinktab_list entry, see if the selector
65787c478bd9Sstevel@tonic-gate  * field matches this minor node.  If it does, return DEVFSADM_SUCCESS,
65797c478bd9Sstevel@tonic-gate  * otherwise DEVFSADM_FAILURE.
65807c478bd9Sstevel@tonic-gate  */
65817c478bd9Sstevel@tonic-gate static int
65827c478bd9Sstevel@tonic-gate devlink_matches(devlinktab_list_t *entry, di_minor_t minor, di_node_t node)
65837c478bd9Sstevel@tonic-gate {
65847c478bd9Sstevel@tonic-gate 	selector_list_t *selector = entry->selector;
65857c478bd9Sstevel@tonic-gate 	char *addr;
65867c478bd9Sstevel@tonic-gate 	char *minor_name;
65877c478bd9Sstevel@tonic-gate 	char *node_type;
65887c478bd9Sstevel@tonic-gate 
65897c478bd9Sstevel@tonic-gate 	for (; selector != NULL; selector = selector->next) {
65907c478bd9Sstevel@tonic-gate 		switch (selector->key) {
65917c478bd9Sstevel@tonic-gate 		case NAME:
65927c478bd9Sstevel@tonic-gate 			if (strcmp(di_node_name(node), selector->val) != 0) {
65937c478bd9Sstevel@tonic-gate 				return (DEVFSADM_FAILURE);
65947c478bd9Sstevel@tonic-gate 			}
65957c478bd9Sstevel@tonic-gate 			break;
65967c478bd9Sstevel@tonic-gate 		case TYPE:
65977c478bd9Sstevel@tonic-gate 			node_type = di_minor_nodetype(minor);
65987c478bd9Sstevel@tonic-gate 			assert(node_type != NULL);
65997c478bd9Sstevel@tonic-gate 			if (strcmp(node_type, selector->val) != 0) {
66007c478bd9Sstevel@tonic-gate 				return (DEVFSADM_FAILURE);
66017c478bd9Sstevel@tonic-gate 			}
66027c478bd9Sstevel@tonic-gate 			break;
66037c478bd9Sstevel@tonic-gate 		case ADDR:
66047c478bd9Sstevel@tonic-gate 			if ((addr = di_bus_addr(node)) == NULL) {
66057c478bd9Sstevel@tonic-gate 				return (DEVFSADM_FAILURE);
66067c478bd9Sstevel@tonic-gate 			}
66077c478bd9Sstevel@tonic-gate 			if (selector->arg == 0) {
66087c478bd9Sstevel@tonic-gate 				if (strcmp(addr, selector->val) != 0) {
66097c478bd9Sstevel@tonic-gate 					return (DEVFSADM_FAILURE);
66107c478bd9Sstevel@tonic-gate 				}
66117c478bd9Sstevel@tonic-gate 			} else {
66127c478bd9Sstevel@tonic-gate 				if (compare_field(addr, selector->val,
66137c478bd9Sstevel@tonic-gate 				    selector->arg) == DEVFSADM_FAILURE) {
66147c478bd9Sstevel@tonic-gate 					return (DEVFSADM_FAILURE);
66157c478bd9Sstevel@tonic-gate 				}
66167c478bd9Sstevel@tonic-gate 			}
66177c478bd9Sstevel@tonic-gate 			break;
66187c478bd9Sstevel@tonic-gate 		case MINOR:
66197c478bd9Sstevel@tonic-gate 			if ((minor_name = di_minor_name(minor)) == NULL) {
66207c478bd9Sstevel@tonic-gate 				return (DEVFSADM_FAILURE);
66217c478bd9Sstevel@tonic-gate 			}
66227c478bd9Sstevel@tonic-gate 			if (selector->arg == 0) {
66237c478bd9Sstevel@tonic-gate 				if (strcmp(minor_name, selector->val) != 0) {
66247c478bd9Sstevel@tonic-gate 					return (DEVFSADM_FAILURE);
66257c478bd9Sstevel@tonic-gate 				}
66267c478bd9Sstevel@tonic-gate 			} else {
66277c478bd9Sstevel@tonic-gate 				if (compare_field(minor_name, selector->val,
66280a653502Swroche 				    selector->arg) == DEVFSADM_FAILURE) {
66297c478bd9Sstevel@tonic-gate 					return (DEVFSADM_FAILURE);
66307c478bd9Sstevel@tonic-gate 				}
66317c478bd9Sstevel@tonic-gate 			}
66327c478bd9Sstevel@tonic-gate 			break;
66337c478bd9Sstevel@tonic-gate 		default:
66347c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
66357c478bd9Sstevel@tonic-gate 		}
66367c478bd9Sstevel@tonic-gate 	}
66377c478bd9Sstevel@tonic-gate 
66387c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
66397c478bd9Sstevel@tonic-gate }
66407c478bd9Sstevel@tonic-gate 
66417c478bd9Sstevel@tonic-gate /*
66427c478bd9Sstevel@tonic-gate  * For the given minor node and devlinktab_list entry from devlink.tab,
66437c478bd9Sstevel@tonic-gate  * build a logical dev link and a possible extra devlink.
66447c478bd9Sstevel@tonic-gate  * Return DEVFSADM_SUCCESS if link is created, otherwise DEVFSADM_FAILURE.
66457c478bd9Sstevel@tonic-gate  */
66467c478bd9Sstevel@tonic-gate static int
66477c478bd9Sstevel@tonic-gate build_links(devlinktab_list_t *entry, di_minor_t minor, di_node_t node)
66487c478bd9Sstevel@tonic-gate {
66497c478bd9Sstevel@tonic-gate 	char secondary_link[PATH_MAX + 1];
66507c478bd9Sstevel@tonic-gate 	char primary_link[PATH_MAX + 1];
66517c478bd9Sstevel@tonic-gate 	char contents[PATH_MAX + 1];
66527c478bd9Sstevel@tonic-gate 	char *dev_path;
66537c478bd9Sstevel@tonic-gate 
66547c478bd9Sstevel@tonic-gate 	if ((dev_path = di_devfs_path(node)) == NULL) {
66557c478bd9Sstevel@tonic-gate 		err_print(DI_DEVFS_PATH_FAILED, strerror(errno));
66567c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
6657537714daSvikram 		/*NOTREACHED*/
66587c478bd9Sstevel@tonic-gate 	}
66597c478bd9Sstevel@tonic-gate 	(void) strcpy(contents, dev_path);
66607c478bd9Sstevel@tonic-gate 	di_devfs_path_free(dev_path);
66617c478bd9Sstevel@tonic-gate 
66627c478bd9Sstevel@tonic-gate 	(void) strcat(contents, ":");
66637c478bd9Sstevel@tonic-gate 	(void) strcat(contents, di_minor_name(minor));
66647c478bd9Sstevel@tonic-gate 
66657c478bd9Sstevel@tonic-gate 	if (construct_devlink(primary_link, entry->p_link, contents,
66660a653502Swroche 	    minor, node, entry->p_link_pattern) == DEVFSADM_FAILURE) {
66677c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
66687c478bd9Sstevel@tonic-gate 	}
66697c478bd9Sstevel@tonic-gate 	(void) devfsadm_mklink(primary_link, node, minor, 0);
66707c478bd9Sstevel@tonic-gate 
66717c478bd9Sstevel@tonic-gate 	if (entry->s_link == NULL) {
66727c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
66737c478bd9Sstevel@tonic-gate 	}
66747c478bd9Sstevel@tonic-gate 
66750a653502Swroche 	if (construct_devlink(secondary_link, entry->s_link, primary_link,
66760a653502Swroche 	    minor, node, entry->s_link_pattern) == DEVFSADM_FAILURE) {
66777c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
66787c478bd9Sstevel@tonic-gate 	}
66797c478bd9Sstevel@tonic-gate 
66807c478bd9Sstevel@tonic-gate 	(void) devfsadm_secondary_link(secondary_link, primary_link, 0);
66817c478bd9Sstevel@tonic-gate 
66827c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
66837c478bd9Sstevel@tonic-gate }
66847c478bd9Sstevel@tonic-gate 
66857c478bd9Sstevel@tonic-gate /*
66867c478bd9Sstevel@tonic-gate  * The counter rule for devlink.tab entries is implemented via
66877c478bd9Sstevel@tonic-gate  * devfsadm_enumerate_int_start(). One of the arguments to this function
66887c478bd9Sstevel@tonic-gate  * is a path, where each path component is treated as a regular expression.
66897c478bd9Sstevel@tonic-gate  * For devlink.tab entries, this path regular expression is derived from
66907c478bd9Sstevel@tonic-gate  * the devlink spec. get_anchored_re() accepts path regular expressions derived
66917c478bd9Sstevel@tonic-gate  * from devlink.tab entries and inserts the anchors '^' and '$' at the beginning
66927c478bd9Sstevel@tonic-gate  * and end respectively of each path component. This is done to prevent
66937c478bd9Sstevel@tonic-gate  * false matches. For example, without anchors, "a/([0-9]+)" will match "ab/c9"
66947c478bd9Sstevel@tonic-gate  * and incorrect links will be generated.
66957c478bd9Sstevel@tonic-gate  */
66967c478bd9Sstevel@tonic-gate static int
66977c478bd9Sstevel@tonic-gate get_anchored_re(char *link, char *anchored_re, char *pattern)
66987c478bd9Sstevel@tonic-gate {
66997c478bd9Sstevel@tonic-gate 	if (*link == '/' || *link == '\0') {
67007c478bd9Sstevel@tonic-gate 		err_print(INVALID_DEVLINK_SPEC, pattern);
67017c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
67027c478bd9Sstevel@tonic-gate 	}
67037c478bd9Sstevel@tonic-gate 
67047c478bd9Sstevel@tonic-gate 	*anchored_re++ = '^';
67057c478bd9Sstevel@tonic-gate 	for (; *link != '\0'; ) {
67067c478bd9Sstevel@tonic-gate 		if (*link == '/') {
67077c478bd9Sstevel@tonic-gate 			while (*link == '/')
67087c478bd9Sstevel@tonic-gate 				link++;
67097c478bd9Sstevel@tonic-gate 			*anchored_re++ = '$';
67107c478bd9Sstevel@tonic-gate 			*anchored_re++ = '/';
67117c478bd9Sstevel@tonic-gate 			if (*link != '\0') {
67127c478bd9Sstevel@tonic-gate 				*anchored_re++ = '^';
67137c478bd9Sstevel@tonic-gate 			}
67147c478bd9Sstevel@tonic-gate 		} else {
67157c478bd9Sstevel@tonic-gate 			*anchored_re++ = *link++;
67167c478bd9Sstevel@tonic-gate 			if (*link == '\0') {
67177c478bd9Sstevel@tonic-gate 				*anchored_re++ = '$';
67187c478bd9Sstevel@tonic-gate 			}
67197c478bd9Sstevel@tonic-gate 		}
67207c478bd9Sstevel@tonic-gate 	}
67217c478bd9Sstevel@tonic-gate 	*anchored_re = '\0';
67227c478bd9Sstevel@tonic-gate 
67237c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
67247c478bd9Sstevel@tonic-gate }
67257c478bd9Sstevel@tonic-gate 
67267c478bd9Sstevel@tonic-gate static int
67277c478bd9Sstevel@tonic-gate construct_devlink(char *link, link_list_t *link_build, char *contents,
67287c478bd9Sstevel@tonic-gate 			di_minor_t minor, di_node_t node, char *pattern)
67297c478bd9Sstevel@tonic-gate {
67307c478bd9Sstevel@tonic-gate 	int counter_offset = -1;
67317c478bd9Sstevel@tonic-gate 	devfsadm_enumerate_t rules[1] = {NULL};
67327c478bd9Sstevel@tonic-gate 	char templink[PATH_MAX + 1];
67337c478bd9Sstevel@tonic-gate 	char *buff;
67347c478bd9Sstevel@tonic-gate 	char start[10];
67357c478bd9Sstevel@tonic-gate 	char *node_path;
67367c478bd9Sstevel@tonic-gate 	char anchored_re[PATH_MAX + 1];
67377c478bd9Sstevel@tonic-gate 
67387c478bd9Sstevel@tonic-gate 	link[0] = '\0';
67397c478bd9Sstevel@tonic-gate 
67407c478bd9Sstevel@tonic-gate 	for (; link_build != NULL; link_build = link_build->next) {
67417c478bd9Sstevel@tonic-gate 		switch (link_build->type) {
67427c478bd9Sstevel@tonic-gate 		case NAME:
67437c478bd9Sstevel@tonic-gate 			(void) strcat(link, di_node_name(node));
67447c478bd9Sstevel@tonic-gate 			break;
67457c478bd9Sstevel@tonic-gate 		case CONSTANT:
67467c478bd9Sstevel@tonic-gate 			(void) strcat(link, link_build->constant);
67477c478bd9Sstevel@tonic-gate 			break;
67487c478bd9Sstevel@tonic-gate 		case ADDR:
67497c478bd9Sstevel@tonic-gate 			if (component_cat(link, di_bus_addr(node),
67500a653502Swroche 			    link_build->arg) == DEVFSADM_FAILURE) {
67517c478bd9Sstevel@tonic-gate 				node_path = di_devfs_path(node);
67527c478bd9Sstevel@tonic-gate 				err_print(CANNOT_BE_USED, pattern, node_path,
67530a653502Swroche 				    di_minor_name(minor));
67547c478bd9Sstevel@tonic-gate 				di_devfs_path_free(node_path);
67557c478bd9Sstevel@tonic-gate 				return (DEVFSADM_FAILURE);
67567c478bd9Sstevel@tonic-gate 			}
67577c478bd9Sstevel@tonic-gate 			break;
67587c478bd9Sstevel@tonic-gate 		case MINOR:
67597c478bd9Sstevel@tonic-gate 			if (component_cat(link, di_minor_name(minor),
67600a653502Swroche 			    link_build->arg) == DEVFSADM_FAILURE) {
67617c478bd9Sstevel@tonic-gate 				node_path = di_devfs_path(node);
67627c478bd9Sstevel@tonic-gate 				err_print(CANNOT_BE_USED, pattern, node_path,
67630a653502Swroche 				    di_minor_name(minor));
67647c478bd9Sstevel@tonic-gate 				di_devfs_path_free(node_path);
67657c478bd9Sstevel@tonic-gate 				return (DEVFSADM_FAILURE);
67667c478bd9Sstevel@tonic-gate 			}
67677c478bd9Sstevel@tonic-gate 			break;
67687c478bd9Sstevel@tonic-gate 		case COUNTER:
67697c478bd9Sstevel@tonic-gate 			counter_offset = strlen(link);
67707c478bd9Sstevel@tonic-gate 			(void) strcat(link, "([0-9]+)");
67717c478bd9Sstevel@tonic-gate 			(void) sprintf(start, "%d", link_build->arg);
67727c478bd9Sstevel@tonic-gate 			break;
67737c478bd9Sstevel@tonic-gate 		default:
67747c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
67757c478bd9Sstevel@tonic-gate 		}
67767c478bd9Sstevel@tonic-gate 	}
67777c478bd9Sstevel@tonic-gate 
67787c478bd9Sstevel@tonic-gate 	if (counter_offset != -1) {
67797c478bd9Sstevel@tonic-gate 		/*
67807c478bd9Sstevel@tonic-gate 		 * copy anything appended after "([0-9]+)" into
67817c478bd9Sstevel@tonic-gate 		 * templink
67827c478bd9Sstevel@tonic-gate 		 */
67837c478bd9Sstevel@tonic-gate 
67847c478bd9Sstevel@tonic-gate 		(void) strcpy(templink,
67850a653502Swroche 		    &link[counter_offset + strlen("([0-9]+)")]);
67867c478bd9Sstevel@tonic-gate 		if (get_anchored_re(link, anchored_re, pattern)
67877c478bd9Sstevel@tonic-gate 		    != DEVFSADM_SUCCESS) {
67887c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
67897c478bd9Sstevel@tonic-gate 		}
67907c478bd9Sstevel@tonic-gate 		rules[0].re = anchored_re;
67917c478bd9Sstevel@tonic-gate 		rules[0].subexp = 1;
67927c478bd9Sstevel@tonic-gate 		rules[0].flags = MATCH_ALL;
67937c478bd9Sstevel@tonic-gate 		if (devfsadm_enumerate_int_start(contents, 0, &buff,
67947c478bd9Sstevel@tonic-gate 		    rules, 1, start) == DEVFSADM_FAILURE) {
67957c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
67967c478bd9Sstevel@tonic-gate 		}
67977c478bd9Sstevel@tonic-gate 		(void) strcpy(&link[counter_offset], buff);
67987c478bd9Sstevel@tonic-gate 		free(buff);
67997c478bd9Sstevel@tonic-gate 		(void) strcat(link, templink);
68007c478bd9Sstevel@tonic-gate 		vprint(DEVLINK_MID, "COUNTER is	%s\n", link);
68017c478bd9Sstevel@tonic-gate 	}
68027c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
68037c478bd9Sstevel@tonic-gate }
68047c478bd9Sstevel@tonic-gate 
68057c478bd9Sstevel@tonic-gate /*
68067c478bd9Sstevel@tonic-gate  * Compares "field" number of the comma separated list "full_name" with
68077c478bd9Sstevel@tonic-gate  * field_item.	Returns DEVFSADM_SUCCESS for match,
68087c478bd9Sstevel@tonic-gate  * DEVFSADM_FAILURE for no match.
68097c478bd9Sstevel@tonic-gate  */
68107c478bd9Sstevel@tonic-gate static int
68117c478bd9Sstevel@tonic-gate compare_field(char *full_name, char *field_item, int field)
68127c478bd9Sstevel@tonic-gate {
68137c478bd9Sstevel@tonic-gate 	--field;
68147c478bd9Sstevel@tonic-gate 	while ((*full_name != '\0') && (field != 0)) {
68157c478bd9Sstevel@tonic-gate 		if (*(full_name++) == ',') {
68167c478bd9Sstevel@tonic-gate 			field--;
68177c478bd9Sstevel@tonic-gate 		}
68187c478bd9Sstevel@tonic-gate 	}
68197c478bd9Sstevel@tonic-gate 
68207c478bd9Sstevel@tonic-gate 	if (field != 0) {
68217c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
68227c478bd9Sstevel@tonic-gate 	}
68237c478bd9Sstevel@tonic-gate 
68247c478bd9Sstevel@tonic-gate 	while ((*full_name != '\0') && (*field_item != '\0') &&
68250a653502Swroche 	    (*full_name != ',')) {
68267c478bd9Sstevel@tonic-gate 		if (*(full_name++) != *(field_item++)) {
68277c478bd9Sstevel@tonic-gate 			return (DEVFSADM_FAILURE);
68287c478bd9Sstevel@tonic-gate 		}
68297c478bd9Sstevel@tonic-gate 	}
68307c478bd9Sstevel@tonic-gate 
68317c478bd9Sstevel@tonic-gate 	if (*field_item != '\0') {
68327c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
68337c478bd9Sstevel@tonic-gate 	}
68347c478bd9Sstevel@tonic-gate 
68357c478bd9Sstevel@tonic-gate 	if ((*full_name == '\0') || (*full_name == ','))
68367c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
68377c478bd9Sstevel@tonic-gate 
68387c478bd9Sstevel@tonic-gate 	return (DEVFSADM_FAILURE);
68397c478bd9Sstevel@tonic-gate }
68407c478bd9Sstevel@tonic-gate 
68417c478bd9Sstevel@tonic-gate /*
68427c478bd9Sstevel@tonic-gate  * strcat() field # "field" of comma separated list "name" to "link".
68437c478bd9Sstevel@tonic-gate  * Field 0 is the entire name.
68447c478bd9Sstevel@tonic-gate  * Return DEVFSADM_SUCCESS or DEVFSADM_FAILURE.
68457c478bd9Sstevel@tonic-gate  */
68467c478bd9Sstevel@tonic-gate static int
68477c478bd9Sstevel@tonic-gate component_cat(char *link, char *name, int field)
68487c478bd9Sstevel@tonic-gate {
68497c478bd9Sstevel@tonic-gate 
68507c478bd9Sstevel@tonic-gate 	if (name == NULL) {
68517c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
68527c478bd9Sstevel@tonic-gate 	}
68537c478bd9Sstevel@tonic-gate 
68547c478bd9Sstevel@tonic-gate 	if (field == 0) {
68557c478bd9Sstevel@tonic-gate 		(void) strcat(link, name);
68567c478bd9Sstevel@tonic-gate 		return (DEVFSADM_SUCCESS);
68577c478bd9Sstevel@tonic-gate 	}
68587c478bd9Sstevel@tonic-gate 
68597c478bd9Sstevel@tonic-gate 	while (*link != '\0') {
68607c478bd9Sstevel@tonic-gate 		link++;
68617c478bd9Sstevel@tonic-gate 	}
68627c478bd9Sstevel@tonic-gate 
68637c478bd9Sstevel@tonic-gate 	--field;
68647c478bd9Sstevel@tonic-gate 	while ((*name != '\0') && (field != 0)) {
68657c478bd9Sstevel@tonic-gate 		if (*(name++) == ',') {
68667c478bd9Sstevel@tonic-gate 			--field;
68677c478bd9Sstevel@tonic-gate 		}
68687c478bd9Sstevel@tonic-gate 	}
68697c478bd9Sstevel@tonic-gate 
68707c478bd9Sstevel@tonic-gate 	if (field != 0) {
68717c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
68727c478bd9Sstevel@tonic-gate 	}
68737c478bd9Sstevel@tonic-gate 
68747c478bd9Sstevel@tonic-gate 	while ((*name != '\0') && (*name != ',')) {
68757c478bd9Sstevel@tonic-gate 		*(link++) = *(name++);
68767c478bd9Sstevel@tonic-gate 	}
68777c478bd9Sstevel@tonic-gate 
68787c478bd9Sstevel@tonic-gate 	*link = '\0';
68797c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
68807c478bd9Sstevel@tonic-gate }
68817c478bd9Sstevel@tonic-gate 
68827c478bd9Sstevel@tonic-gate static void
68837c478bd9Sstevel@tonic-gate free_selector_list(selector_list_t *head)
68847c478bd9Sstevel@tonic-gate {
68857c478bd9Sstevel@tonic-gate 	selector_list_t *temp;
68867c478bd9Sstevel@tonic-gate 
68877c478bd9Sstevel@tonic-gate 	while (head != NULL) {
68887c478bd9Sstevel@tonic-gate 		temp = head;
68897c478bd9Sstevel@tonic-gate 		head = head->next;
68907c478bd9Sstevel@tonic-gate 		free(temp->val);
68917c478bd9Sstevel@tonic-gate 		free(temp);
68927c478bd9Sstevel@tonic-gate 	}
68937c478bd9Sstevel@tonic-gate }
68947c478bd9Sstevel@tonic-gate 
68957c478bd9Sstevel@tonic-gate static void
68967c478bd9Sstevel@tonic-gate free_link_list(link_list_t *head)
68977c478bd9Sstevel@tonic-gate {
68987c478bd9Sstevel@tonic-gate 	link_list_t *temp;
68997c478bd9Sstevel@tonic-gate 
69007c478bd9Sstevel@tonic-gate 	while (head != NULL) {
69017c478bd9Sstevel@tonic-gate 		temp = head;
69027c478bd9Sstevel@tonic-gate 		head = head->next;
69037c478bd9Sstevel@tonic-gate 		if (temp->type == CONSTANT) {
69047c478bd9Sstevel@tonic-gate 			free(temp->constant);
69057c478bd9Sstevel@tonic-gate 		}
69067c478bd9Sstevel@tonic-gate 		free(temp);
69077c478bd9Sstevel@tonic-gate 	}
69087c478bd9Sstevel@tonic-gate }
69097c478bd9Sstevel@tonic-gate 
69107c478bd9Sstevel@tonic-gate /*
69117c478bd9Sstevel@tonic-gate  * Prints only if level matches one of the debug levels
69127c478bd9Sstevel@tonic-gate  * given on command line.  INFO_MID is always printed.
69137c478bd9Sstevel@tonic-gate  *
69147c478bd9Sstevel@tonic-gate  * See devfsadm.h for a listing of globally defined levels and
69157c478bd9Sstevel@tonic-gate  * meanings.  Modules should prefix the level with their
69167c478bd9Sstevel@tonic-gate  * module name to prevent collisions.
69177c478bd9Sstevel@tonic-gate  */
69187c478bd9Sstevel@tonic-gate /*PRINTFLIKE2*/
69197c478bd9Sstevel@tonic-gate void
69207c478bd9Sstevel@tonic-gate devfsadm_print(char *msgid, char *message, ...)
69217c478bd9Sstevel@tonic-gate {
69227c478bd9Sstevel@tonic-gate 	va_list ap;
69237c478bd9Sstevel@tonic-gate 	static int newline = TRUE;
69247c478bd9Sstevel@tonic-gate 	int x;
69257c478bd9Sstevel@tonic-gate 
69267c478bd9Sstevel@tonic-gate 	if (msgid != NULL) {
69277c478bd9Sstevel@tonic-gate 		for (x = 0; x < num_verbose; x++) {
69287c478bd9Sstevel@tonic-gate 			if (strcmp(verbose[x], msgid) == 0) {
69297c478bd9Sstevel@tonic-gate 				break;
69307c478bd9Sstevel@tonic-gate 			}
69317c478bd9Sstevel@tonic-gate 			if (strcmp(verbose[x], ALL_MID) == 0) {
69327c478bd9Sstevel@tonic-gate 				break;
69337c478bd9Sstevel@tonic-gate 			}
69347c478bd9Sstevel@tonic-gate 		}
69357c478bd9Sstevel@tonic-gate 		if (x == num_verbose) {
69367c478bd9Sstevel@tonic-gate 			return;
69377c478bd9Sstevel@tonic-gate 		}
69387c478bd9Sstevel@tonic-gate 	}
69397c478bd9Sstevel@tonic-gate 
69407c478bd9Sstevel@tonic-gate 	va_start(ap, message);
69417c478bd9Sstevel@tonic-gate 
69427c478bd9Sstevel@tonic-gate 	if (msgid == NULL) {
69437c478bd9Sstevel@tonic-gate 		if (logflag == TRUE) {
69447c478bd9Sstevel@tonic-gate 			(void) vsyslog(LOG_NOTICE, message, ap);
69457c478bd9Sstevel@tonic-gate 		} else {
69467c478bd9Sstevel@tonic-gate 			(void) vfprintf(stdout, message, ap);
69477c478bd9Sstevel@tonic-gate 		}
69487c478bd9Sstevel@tonic-gate 
69497c478bd9Sstevel@tonic-gate 	} else {
69507c478bd9Sstevel@tonic-gate 		if (logflag == TRUE) {
69517c478bd9Sstevel@tonic-gate 			(void) syslog(LOG_DEBUG, "%s[%ld]: %s: ",
69520a653502Swroche 			    prog, getpid(), msgid);
69537c478bd9Sstevel@tonic-gate 			(void) vsyslog(LOG_DEBUG, message, ap);
69547c478bd9Sstevel@tonic-gate 		} else {
69557c478bd9Sstevel@tonic-gate 			if (newline == TRUE) {
69567c478bd9Sstevel@tonic-gate 				(void) fprintf(stdout, "%s[%ld]: %s: ",
69570a653502Swroche 				    prog, getpid(), msgid);
69587c478bd9Sstevel@tonic-gate 			}
69597c478bd9Sstevel@tonic-gate 			(void) vfprintf(stdout, message, ap);
69607c478bd9Sstevel@tonic-gate 		}
69617c478bd9Sstevel@tonic-gate 	}
69627c478bd9Sstevel@tonic-gate 
69637c478bd9Sstevel@tonic-gate 	if (message[strlen(message) - 1] == '\n') {
69647c478bd9Sstevel@tonic-gate 		newline = TRUE;
69657c478bd9Sstevel@tonic-gate 	} else {
69667c478bd9Sstevel@tonic-gate 		newline = FALSE;
69677c478bd9Sstevel@tonic-gate 	}
69687c478bd9Sstevel@tonic-gate 	va_end(ap);
69697c478bd9Sstevel@tonic-gate }
69707c478bd9Sstevel@tonic-gate 
69717c478bd9Sstevel@tonic-gate /*
69727c478bd9Sstevel@tonic-gate  * print error messages to the terminal or to syslog
69737c478bd9Sstevel@tonic-gate  */
69747c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/
69757c478bd9Sstevel@tonic-gate void
69767c478bd9Sstevel@tonic-gate devfsadm_errprint(char *message, ...)
69777c478bd9Sstevel@tonic-gate {
69787c478bd9Sstevel@tonic-gate 	va_list ap;
69797c478bd9Sstevel@tonic-gate 
69807c478bd9Sstevel@tonic-gate 	va_start(ap, message);
69817c478bd9Sstevel@tonic-gate 
69827c478bd9Sstevel@tonic-gate 	if (logflag == TRUE) {
69837c478bd9Sstevel@tonic-gate 		(void) vsyslog(LOG_ERR, message, ap);
69847c478bd9Sstevel@tonic-gate 	} else {
69857c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, "%s: ", prog);
69867c478bd9Sstevel@tonic-gate 		(void) vfprintf(stderr, message, ap);
69877c478bd9Sstevel@tonic-gate 	}
69887c478bd9Sstevel@tonic-gate 	va_end(ap);
69897c478bd9Sstevel@tonic-gate }
69907c478bd9Sstevel@tonic-gate 
69917c478bd9Sstevel@tonic-gate /*
69927c478bd9Sstevel@tonic-gate  * return noupdate state (-s)
69937c478bd9Sstevel@tonic-gate  */
69947c478bd9Sstevel@tonic-gate int
69957c478bd9Sstevel@tonic-gate devfsadm_noupdate(void)
69967c478bd9Sstevel@tonic-gate {
69977c478bd9Sstevel@tonic-gate 	return (file_mods == TRUE ? DEVFSADM_TRUE : DEVFSADM_FALSE);
69987c478bd9Sstevel@tonic-gate }
69997c478bd9Sstevel@tonic-gate 
70007c478bd9Sstevel@tonic-gate /*
70017c478bd9Sstevel@tonic-gate  * return current root update path (-r)
70027c478bd9Sstevel@tonic-gate  */
70037c478bd9Sstevel@tonic-gate const char *
70047c478bd9Sstevel@tonic-gate devfsadm_root_path(void)
70057c478bd9Sstevel@tonic-gate {
70067c478bd9Sstevel@tonic-gate 	if (root_dir[0] == '\0') {
70077c478bd9Sstevel@tonic-gate 		return ("/");
70087c478bd9Sstevel@tonic-gate 	} else {
70097c478bd9Sstevel@tonic-gate 		return ((const char *)root_dir);
70107c478bd9Sstevel@tonic-gate 	}
70117c478bd9Sstevel@tonic-gate }
70127c478bd9Sstevel@tonic-gate 
70133c4226f9Spjha void
70143c4226f9Spjha devfsadm_free_dev_names(char **dev_names, int len)
70153c4226f9Spjha {
70163c4226f9Spjha 	int i;
70173c4226f9Spjha 
70183c4226f9Spjha 	for (i = 0; i < len; i++)
70193c4226f9Spjha 		free(dev_names[i]);
70203c4226f9Spjha 	free(dev_names);
70213c4226f9Spjha }
70223c4226f9Spjha 
70233c4226f9Spjha /*
70243c4226f9Spjha  * Return all devlinks corresponding to phys_path as an array of strings.
70253c4226f9Spjha  * The number of entries in the array is returned through lenp.
70263c4226f9Spjha  * devfsadm_free_dev_names() is used to free the returned array.
70273c4226f9Spjha  * NULL is returned on failure or when there are no matching devlinks.
70283c4226f9Spjha  *
70293c4226f9Spjha  * re is an extended regular expression in regex(5) format used to further
70303c4226f9Spjha  * match devlinks pointing to phys_path; it may be NULL to match all
70313c4226f9Spjha  */
70323c4226f9Spjha char **
70333c4226f9Spjha devfsadm_lookup_dev_names(char *phys_path, char *re, int *lenp)
70343c4226f9Spjha {
70353c4226f9Spjha 	struct devlink_cb_arg cb_arg;
70363c4226f9Spjha 	char **dev_names = NULL;
70373c4226f9Spjha 	int i;
70383c4226f9Spjha 
70393c4226f9Spjha 	*lenp = 0;
70403c4226f9Spjha 	cb_arg.count = 0;
70413c4226f9Spjha 	cb_arg.rv = 0;
70423c4226f9Spjha 	(void) di_devlink_cache_walk(devlink_cache, re, phys_path,
70433c4226f9Spjha 	    DI_PRIMARY_LINK, &cb_arg, devlink_cb);
70443c4226f9Spjha 
70453c4226f9Spjha 	if (cb_arg.rv == -1 || cb_arg.count <= 0)
70463c4226f9Spjha 		return (NULL);
70473c4226f9Spjha 
70483c4226f9Spjha 	dev_names = s_malloc(cb_arg.count * sizeof (char *));
70493c4226f9Spjha 	if (dev_names == NULL)
70503c4226f9Spjha 		goto out;
70513c4226f9Spjha 
70523c4226f9Spjha 	for (i = 0; i < cb_arg.count; i++) {
70533c4226f9Spjha 		dev_names[i] = s_strdup(cb_arg.dev_names[i]);
70543c4226f9Spjha 		if (dev_names[i] == NULL) {
70553c4226f9Spjha 			devfsadm_free_dev_names(dev_names, i);
70563c4226f9Spjha 			dev_names = NULL;
70573c4226f9Spjha 			goto out;
70583c4226f9Spjha 		}
70593c4226f9Spjha 	}
70603c4226f9Spjha 	*lenp = cb_arg.count;
70613c4226f9Spjha 
70623c4226f9Spjha out:
70633c4226f9Spjha 	free_dev_names(&cb_arg);
70643c4226f9Spjha 	return (dev_names);
70653c4226f9Spjha }
70663c4226f9Spjha 
70677c478bd9Sstevel@tonic-gate /* common exit function which ensures releasing locks */
70687c478bd9Sstevel@tonic-gate static void
70697c478bd9Sstevel@tonic-gate devfsadm_exit(int status)
70707c478bd9Sstevel@tonic-gate {
70717c478bd9Sstevel@tonic-gate 	if (DEVFSADM_DEBUG_ON) {
70727c478bd9Sstevel@tonic-gate 		vprint(INFO_MID, "exit status = %d\n", status);
70737c478bd9Sstevel@tonic-gate 	}
70747c478bd9Sstevel@tonic-gate 
7075537714daSvikram 	exit_dev_lock(1);
7076537714daSvikram 	exit_daemon_lock(1);
70777c478bd9Sstevel@tonic-gate 
70787c478bd9Sstevel@tonic-gate 	if (logflag == TRUE) {
70797c478bd9Sstevel@tonic-gate 		closelog();
70807c478bd9Sstevel@tonic-gate 	}
70817c478bd9Sstevel@tonic-gate 
70827c478bd9Sstevel@tonic-gate 	exit(status);
7083537714daSvikram 	/*NOTREACHED*/
70847c478bd9Sstevel@tonic-gate }
70857c478bd9Sstevel@tonic-gate 
70867c478bd9Sstevel@tonic-gate /*
7087facf4a8dSllai  * set root_dir, devices_dir, dev_dir using optarg.
70887c478bd9Sstevel@tonic-gate  */
70897c478bd9Sstevel@tonic-gate static void
7090facf4a8dSllai set_root_devices_dev_dir(char *dir)
70917c478bd9Sstevel@tonic-gate {
70927c478bd9Sstevel@tonic-gate 	size_t len;
70937c478bd9Sstevel@tonic-gate 
70947c478bd9Sstevel@tonic-gate 	root_dir = s_strdup(dir);
70957c478bd9Sstevel@tonic-gate 	len = strlen(dir) + strlen(DEVICES) + 1;
70967c478bd9Sstevel@tonic-gate 	devices_dir = s_malloc(len);
70977c478bd9Sstevel@tonic-gate 	(void) snprintf(devices_dir, len, "%s%s", root_dir, DEVICES);
70987c478bd9Sstevel@tonic-gate 	len = strlen(root_dir) + strlen(DEV) + 1;
70997c478bd9Sstevel@tonic-gate 	dev_dir = s_malloc(len);
71007c478bd9Sstevel@tonic-gate 	(void) snprintf(dev_dir, len, "%s%s", root_dir, DEV);
71017c478bd9Sstevel@tonic-gate }
71027c478bd9Sstevel@tonic-gate 
71037c478bd9Sstevel@tonic-gate /*
71047c478bd9Sstevel@tonic-gate  * Removes quotes.
71057c478bd9Sstevel@tonic-gate  */
71067c478bd9Sstevel@tonic-gate static char *
71077c478bd9Sstevel@tonic-gate dequote(char *src)
71087c478bd9Sstevel@tonic-gate {
71097c478bd9Sstevel@tonic-gate 	char	*dst;
71107c478bd9Sstevel@tonic-gate 	int	len;
71117c478bd9Sstevel@tonic-gate 
71127c478bd9Sstevel@tonic-gate 	len = strlen(src);
71137c478bd9Sstevel@tonic-gate 	dst = s_malloc(len + 1);
71147c478bd9Sstevel@tonic-gate 	if (src[0] == '\"' && src[len - 1] == '\"') {
71157c478bd9Sstevel@tonic-gate 		len -= 2;
71167c478bd9Sstevel@tonic-gate 		(void) strncpy(dst, &src[1], len);
71177c478bd9Sstevel@tonic-gate 		dst[len] = '\0';
71187c478bd9Sstevel@tonic-gate 	} else {
71197c478bd9Sstevel@tonic-gate 		(void) strcpy(dst, src);
71207c478bd9Sstevel@tonic-gate 	}
71217c478bd9Sstevel@tonic-gate 	return (dst);
71227c478bd9Sstevel@tonic-gate }
71237c478bd9Sstevel@tonic-gate 
71247c478bd9Sstevel@tonic-gate /*
71257c478bd9Sstevel@tonic-gate  * For a given physical device pathname and spectype, return the
71267c478bd9Sstevel@tonic-gate  * ownership and permissions attributes by looking in data from
71277c478bd9Sstevel@tonic-gate  * /etc/minor_perm.  If currently in installation mode, check for
71287c478bd9Sstevel@tonic-gate  * possible major number translations from the miniroot to the installed
71297c478bd9Sstevel@tonic-gate  * root's name_to_major table. Note that there can be multiple matches,
71307c478bd9Sstevel@tonic-gate  * but the last match takes effect.  pts seems to rely on this
71317c478bd9Sstevel@tonic-gate  * implementation behavior.
71327c478bd9Sstevel@tonic-gate  */
71337c478bd9Sstevel@tonic-gate static void
71347c478bd9Sstevel@tonic-gate getattr(char *phy_path, char *aminor, int spectype, dev_t dev, mode_t *mode,
71357c478bd9Sstevel@tonic-gate 	uid_t *uid, gid_t *gid)
71367c478bd9Sstevel@tonic-gate {
71377c478bd9Sstevel@tonic-gate 	char devname[PATH_MAX + 1];
71387c478bd9Sstevel@tonic-gate 	char *node_name;
71397c478bd9Sstevel@tonic-gate 	char *minor_name;
71407c478bd9Sstevel@tonic-gate 	int match = FALSE;
71417c478bd9Sstevel@tonic-gate 	int is_clone;
71427c478bd9Sstevel@tonic-gate 	int mp_drvname_matches_node_name;
71437c478bd9Sstevel@tonic-gate 	int mp_drvname_matches_minor_name;
71447c478bd9Sstevel@tonic-gate 	int mp_drvname_is_clone;
71457c478bd9Sstevel@tonic-gate 	int mp_drvname_matches_drvname;
71467c478bd9Sstevel@tonic-gate 	struct mperm *mp;
71477c478bd9Sstevel@tonic-gate 	major_t major_no;
71487c478bd9Sstevel@tonic-gate 	char driver[PATH_MAX + 1];
71497c478bd9Sstevel@tonic-gate 
71507c478bd9Sstevel@tonic-gate 	/*
71517c478bd9Sstevel@tonic-gate 	 * Get the driver name based on the major number since the name
71527c478bd9Sstevel@tonic-gate 	 * in /devices may be generic.  Could be running with more major
71537c478bd9Sstevel@tonic-gate 	 * numbers than are in /etc/name_to_major, so get it from the kernel
71547c478bd9Sstevel@tonic-gate 	 */
71557c478bd9Sstevel@tonic-gate 	major_no = major(dev);
71567c478bd9Sstevel@tonic-gate 
71577c478bd9Sstevel@tonic-gate 	if (modctl(MODGETNAME, driver, sizeof (driver), &major_no) != 0) {
71587c478bd9Sstevel@tonic-gate 		/* return default values */
71597c478bd9Sstevel@tonic-gate 		goto use_defaults;
71607c478bd9Sstevel@tonic-gate 	}
71617c478bd9Sstevel@tonic-gate 
71627c478bd9Sstevel@tonic-gate 	(void) strcpy(devname, phy_path);
71637c478bd9Sstevel@tonic-gate 
71647c478bd9Sstevel@tonic-gate 	node_name = strrchr(devname, '/'); /* node name is the last */
71657c478bd9Sstevel@tonic-gate 					/* component */
71667c478bd9Sstevel@tonic-gate 	if (node_name == NULL) {
71677c478bd9Sstevel@tonic-gate 		err_print(NO_NODE, devname);
71687c478bd9Sstevel@tonic-gate 		goto use_defaults;
71697c478bd9Sstevel@tonic-gate 	}
71707c478bd9Sstevel@tonic-gate 
71717c478bd9Sstevel@tonic-gate 	minor_name = strchr(++node_name, '@'); /* see if it has address part */
71727c478bd9Sstevel@tonic-gate 
71737c478bd9Sstevel@tonic-gate 	if (minor_name != NULL) {
71747c478bd9Sstevel@tonic-gate 		*minor_name++ = '\0';
71757c478bd9Sstevel@tonic-gate 	} else {
71767c478bd9Sstevel@tonic-gate 		minor_name = node_name;
71777c478bd9Sstevel@tonic-gate 	}
71787c478bd9Sstevel@tonic-gate 
71797c478bd9Sstevel@tonic-gate 	minor_name = strchr(minor_name, ':'); /* look for minor name */
71807c478bd9Sstevel@tonic-gate 
71817c478bd9Sstevel@tonic-gate 	if (minor_name == NULL) {
71827c478bd9Sstevel@tonic-gate 		err_print(NO_MINOR, devname);
71837c478bd9Sstevel@tonic-gate 		goto use_defaults;
71847c478bd9Sstevel@tonic-gate 	}
71857c478bd9Sstevel@tonic-gate 	*minor_name++ = '\0';
71867c478bd9Sstevel@tonic-gate 
71877c478bd9Sstevel@tonic-gate 	/*
71887c478bd9Sstevel@tonic-gate 	 * mp->mp_drvname = device name from minor_perm
71897c478bd9Sstevel@tonic-gate 	 * mp->mp_minorname = minor part of device name from
71907c478bd9Sstevel@tonic-gate 	 * minor_perm
71917c478bd9Sstevel@tonic-gate 	 * drvname = name of driver for this device
71927c478bd9Sstevel@tonic-gate 	 */
71937c478bd9Sstevel@tonic-gate 
71947c478bd9Sstevel@tonic-gate 	is_clone = (strcmp(node_name, "clone") == 0 ? TRUE : FALSE);
71957c478bd9Sstevel@tonic-gate 	for (mp = minor_perms; mp != NULL; mp = mp->mp_next) {
71967c478bd9Sstevel@tonic-gate 		mp_drvname_matches_node_name =
71970a653502Swroche 		    (strcmp(mp->mp_drvname, node_name) == 0 ? TRUE : FALSE);
71987c478bd9Sstevel@tonic-gate 		mp_drvname_matches_minor_name =
71990a653502Swroche 		    (strcmp(mp->mp_drvname, minor_name) == 0  ? TRUE:FALSE);
72007c478bd9Sstevel@tonic-gate 		mp_drvname_is_clone =
72010a653502Swroche 		    (strcmp(mp->mp_drvname, "clone") == 0  ? TRUE : FALSE);
72027c478bd9Sstevel@tonic-gate 		mp_drvname_matches_drvname =
72030a653502Swroche 		    (strcmp(mp->mp_drvname, driver) == 0  ? TRUE : FALSE);
72047c478bd9Sstevel@tonic-gate 
72057c478bd9Sstevel@tonic-gate 		/*
72067c478bd9Sstevel@tonic-gate 		 * If one of the following cases is true, then we try to change
72077c478bd9Sstevel@tonic-gate 		 * the permissions if a "shell global pattern match" of
72087c478bd9Sstevel@tonic-gate 		 * mp_>mp_minorname matches minor_name.
72097c478bd9Sstevel@tonic-gate 		 *
72107c478bd9Sstevel@tonic-gate 		 * 1.  mp->mp_drvname matches driver.
72117c478bd9Sstevel@tonic-gate 		 *
72127c478bd9Sstevel@tonic-gate 		 * OR
72137c478bd9Sstevel@tonic-gate 		 *
72147c478bd9Sstevel@tonic-gate 		 * 2.  mp->mp_drvname matches node_name and this
72157c478bd9Sstevel@tonic-gate 		 *	name is an alias of the driver name
72167c478bd9Sstevel@tonic-gate 		 *
72177c478bd9Sstevel@tonic-gate 		 * OR
72187c478bd9Sstevel@tonic-gate 		 *
72197c478bd9Sstevel@tonic-gate 		 * 3.  /devices entry is the clone device and either
72207c478bd9Sstevel@tonic-gate 		 *	minor_perm entry is the clone device or matches
72217c478bd9Sstevel@tonic-gate 		 *	the minor part of the clone device.
72227c478bd9Sstevel@tonic-gate 		 */
72237c478bd9Sstevel@tonic-gate 
72247c478bd9Sstevel@tonic-gate 		if ((mp_drvname_matches_drvname == TRUE)||
72257c478bd9Sstevel@tonic-gate 		    ((mp_drvname_matches_node_name == TRUE) &&
72267c478bd9Sstevel@tonic-gate 		    (alias(driver, node_name) == TRUE)) ||
72277c478bd9Sstevel@tonic-gate 		    ((is_clone == TRUE) &&
72287c478bd9Sstevel@tonic-gate 		    ((mp_drvname_is_clone == TRUE) ||
72297c478bd9Sstevel@tonic-gate 		    (mp_drvname_matches_minor_name == TRUE)))) {
72307c478bd9Sstevel@tonic-gate 			/*
72317c478bd9Sstevel@tonic-gate 			 * Check that the minor part of the
72327c478bd9Sstevel@tonic-gate 			 * device name from the minor_perm
72337c478bd9Sstevel@tonic-gate 			 * entry matches and if so, set the
72347c478bd9Sstevel@tonic-gate 			 * permissions.
72357c478bd9Sstevel@tonic-gate 			 *
72367c478bd9Sstevel@tonic-gate 			 * Under real devfs, clone minor name is changed
72377c478bd9Sstevel@tonic-gate 			 * to match the driver name, but minor_perm may
72387c478bd9Sstevel@tonic-gate 			 * not match. We reconcile it here.
72397c478bd9Sstevel@tonic-gate 			 */
72407c478bd9Sstevel@tonic-gate 			if (aminor != NULL)
72417c478bd9Sstevel@tonic-gate 				minor_name = aminor;
72427c478bd9Sstevel@tonic-gate 
72437c478bd9Sstevel@tonic-gate 			if (gmatch(minor_name, mp->mp_minorname) != 0) {
72447c478bd9Sstevel@tonic-gate 				*uid = mp->mp_uid;
72457c478bd9Sstevel@tonic-gate 				*gid = mp->mp_gid;
72467c478bd9Sstevel@tonic-gate 				*mode = spectype | mp->mp_mode;
72477c478bd9Sstevel@tonic-gate 				match = TRUE;
72487c478bd9Sstevel@tonic-gate 			}
72497c478bd9Sstevel@tonic-gate 		}
72507c478bd9Sstevel@tonic-gate 	}
72517c478bd9Sstevel@tonic-gate 
72527c478bd9Sstevel@tonic-gate 	if (match == TRUE) {
72537c478bd9Sstevel@tonic-gate 		return;
72547c478bd9Sstevel@tonic-gate 	}
72557c478bd9Sstevel@tonic-gate 
72567c478bd9Sstevel@tonic-gate 	use_defaults:
72577c478bd9Sstevel@tonic-gate 	/* not found in minor_perm, so just use default values */
72587c478bd9Sstevel@tonic-gate 	*uid = root_uid;
72597c478bd9Sstevel@tonic-gate 	*gid = sys_gid;
72607c478bd9Sstevel@tonic-gate 	*mode = (spectype | 0600);
72617c478bd9Sstevel@tonic-gate }
72627c478bd9Sstevel@tonic-gate 
72637c478bd9Sstevel@tonic-gate /*
72647c478bd9Sstevel@tonic-gate  * Called by devfs_read_minor_perm() to report errors
72657c478bd9Sstevel@tonic-gate  * key is:
72667c478bd9Sstevel@tonic-gate  *	line number: ignoring line number error
72677c478bd9Sstevel@tonic-gate  *	errno: open/close errors
72687c478bd9Sstevel@tonic-gate  *	size: alloc errors
72697c478bd9Sstevel@tonic-gate  */
72707c478bd9Sstevel@tonic-gate static void
72717c478bd9Sstevel@tonic-gate minorperm_err_cb(minorperm_err_t mp_err, int key)
72727c478bd9Sstevel@tonic-gate {
72737c478bd9Sstevel@tonic-gate 	switch (mp_err) {
72747c478bd9Sstevel@tonic-gate 	case MP_FOPEN_ERR:
72757c478bd9Sstevel@tonic-gate 		err_print(FOPEN_FAILED, MINOR_PERM_FILE, strerror(key));
72767c478bd9Sstevel@tonic-gate 		break;
72777c478bd9Sstevel@tonic-gate 	case MP_FCLOSE_ERR:
72787c478bd9Sstevel@tonic-gate 		err_print(FCLOSE_FAILED, MINOR_PERM_FILE, strerror(key));
72797c478bd9Sstevel@tonic-gate 		break;
72807c478bd9Sstevel@tonic-gate 	case MP_IGNORING_LINE_ERR:
72817c478bd9Sstevel@tonic-gate 		err_print(IGNORING_LINE_IN, key, MINOR_PERM_FILE);
72827c478bd9Sstevel@tonic-gate 		break;
72837c478bd9Sstevel@tonic-gate 	case MP_ALLOC_ERR:
72847c478bd9Sstevel@tonic-gate 		err_print(MALLOC_FAILED, key);
72857c478bd9Sstevel@tonic-gate 		break;
72867c478bd9Sstevel@tonic-gate 	case MP_NVLIST_ERR:
72877c478bd9Sstevel@tonic-gate 		err_print(NVLIST_ERROR, MINOR_PERM_FILE, strerror(key));
72887c478bd9Sstevel@tonic-gate 		break;
72897c478bd9Sstevel@tonic-gate 	case MP_CANT_FIND_USER_ERR:
72907c478bd9Sstevel@tonic-gate 		err_print(CANT_FIND_USER, DEFAULT_DEV_USER);
72917c478bd9Sstevel@tonic-gate 		break;
72927c478bd9Sstevel@tonic-gate 	case MP_CANT_FIND_GROUP_ERR:
72937c478bd9Sstevel@tonic-gate 		err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP);
72947c478bd9Sstevel@tonic-gate 		break;
72957c478bd9Sstevel@tonic-gate 	}
72967c478bd9Sstevel@tonic-gate }
72977c478bd9Sstevel@tonic-gate 
72987c478bd9Sstevel@tonic-gate static void
72997c478bd9Sstevel@tonic-gate read_minor_perm_file(void)
73007c478bd9Sstevel@tonic-gate {
73017c478bd9Sstevel@tonic-gate 	static int cached = FALSE;
73027c478bd9Sstevel@tonic-gate 	static struct stat cached_sb;
73037c478bd9Sstevel@tonic-gate 	struct stat current_sb;
73047c478bd9Sstevel@tonic-gate 
73057c478bd9Sstevel@tonic-gate 	(void) stat(MINOR_PERM_FILE, &current_sb);
73067c478bd9Sstevel@tonic-gate 
73077c478bd9Sstevel@tonic-gate 	/* If already cached, check to see if it is still valid */
73087c478bd9Sstevel@tonic-gate 	if (cached == TRUE) {
73097c478bd9Sstevel@tonic-gate 
73107c478bd9Sstevel@tonic-gate 		if (current_sb.st_mtime == cached_sb.st_mtime) {
73117c478bd9Sstevel@tonic-gate 			vprint(FILES_MID, "%s cache valid\n", MINOR_PERM_FILE);
73127c478bd9Sstevel@tonic-gate 			return;
73137c478bd9Sstevel@tonic-gate 		}
73147c478bd9Sstevel@tonic-gate 		devfs_free_minor_perm(minor_perms);
73157c478bd9Sstevel@tonic-gate 		minor_perms = NULL;
73167c478bd9Sstevel@tonic-gate 	} else {
73177c478bd9Sstevel@tonic-gate 		cached = TRUE;
73187c478bd9Sstevel@tonic-gate 	}
73197c478bd9Sstevel@tonic-gate 
73207c478bd9Sstevel@tonic-gate 	(void) stat(MINOR_PERM_FILE, &cached_sb);
73217c478bd9Sstevel@tonic-gate 
73227c478bd9Sstevel@tonic-gate 	vprint(FILES_MID, "loading binding file: %s\n", MINOR_PERM_FILE);
73237c478bd9Sstevel@tonic-gate 
73247c478bd9Sstevel@tonic-gate 	minor_perms = devfs_read_minor_perm(minorperm_err_cb);
73257c478bd9Sstevel@tonic-gate }
73267c478bd9Sstevel@tonic-gate 
73277c478bd9Sstevel@tonic-gate static void
73287c478bd9Sstevel@tonic-gate load_minor_perm_file(void)
73297c478bd9Sstevel@tonic-gate {
73307c478bd9Sstevel@tonic-gate 	read_minor_perm_file();
73317c478bd9Sstevel@tonic-gate 	if (devfs_load_minor_perm(minor_perms, minorperm_err_cb) != 0)
73327c478bd9Sstevel@tonic-gate 		err_print(gettext("minor_perm load failed\n"));
73337c478bd9Sstevel@tonic-gate }
73347c478bd9Sstevel@tonic-gate 
73357c478bd9Sstevel@tonic-gate static char *
73367c478bd9Sstevel@tonic-gate convert_to_re(char *dev)
73377c478bd9Sstevel@tonic-gate {
73387c478bd9Sstevel@tonic-gate 	char *p, *l, *out;
73397c478bd9Sstevel@tonic-gate 	int i;
73407c478bd9Sstevel@tonic-gate 
73417c478bd9Sstevel@tonic-gate 	out = s_malloc(PATH_MAX);
73427c478bd9Sstevel@tonic-gate 
73437c478bd9Sstevel@tonic-gate 	for (l = p = dev, i = 0; (*p != '\0') && (i < (PATH_MAX - 1));
73447c478bd9Sstevel@tonic-gate 	    ++p, i++) {
73457c478bd9Sstevel@tonic-gate 		if ((*p == '*') && ((l != p) && (*l == '/'))) {
73467c478bd9Sstevel@tonic-gate 			out[i++] = '.';
73477c478bd9Sstevel@tonic-gate 			out[i] = '+';
73487c478bd9Sstevel@tonic-gate 		} else {
73497c478bd9Sstevel@tonic-gate 			out[i] = *p;
73507c478bd9Sstevel@tonic-gate 		}
73517c478bd9Sstevel@tonic-gate 		l = p;
73527c478bd9Sstevel@tonic-gate 	}
73537c478bd9Sstevel@tonic-gate 	out[i] = '\0';
73547c478bd9Sstevel@tonic-gate 	p = (char *)s_malloc(strlen(out) + 1);
73557c478bd9Sstevel@tonic-gate 	(void) strlcpy(p, out, strlen(out) + 1);
73567c478bd9Sstevel@tonic-gate 	free(out);
73577c478bd9Sstevel@tonic-gate 
73587c478bd9Sstevel@tonic-gate 	vprint(FILES_MID, "converted %s -> %s\n", dev, p);
73597c478bd9Sstevel@tonic-gate 
73607c478bd9Sstevel@tonic-gate 	return (p);
73617c478bd9Sstevel@tonic-gate }
73627c478bd9Sstevel@tonic-gate 
73637c478bd9Sstevel@tonic-gate static void
73647c478bd9Sstevel@tonic-gate read_logindevperm_file(void)
73657c478bd9Sstevel@tonic-gate {
73667c478bd9Sstevel@tonic-gate 	static int cached = FALSE;
73677c478bd9Sstevel@tonic-gate 	static struct stat cached_sb;
73687c478bd9Sstevel@tonic-gate 	struct stat current_sb;
73697c478bd9Sstevel@tonic-gate 	struct login_dev *ldev;
73707c478bd9Sstevel@tonic-gate 	FILE *fp;
73717c478bd9Sstevel@tonic-gate 	char line[MAX_LDEV_LINE];
73727c478bd9Sstevel@tonic-gate 	int ln, perm, rv;
73736e670f77Saj 	char *cp, *console, *dlist, *dev;
73747c478bd9Sstevel@tonic-gate 	char *lasts, *devlasts, *permstr, *drv;
73757c478bd9Sstevel@tonic-gate 	struct driver_list *list, *next;
73767c478bd9Sstevel@tonic-gate 
73777c478bd9Sstevel@tonic-gate 	/* Read logindevperm only when enabled */
73787c478bd9Sstevel@tonic-gate 	if (login_dev_enable != TRUE)
73797c478bd9Sstevel@tonic-gate 		return;
73807c478bd9Sstevel@tonic-gate 
73817c478bd9Sstevel@tonic-gate 	if (cached == TRUE) {
73827c478bd9Sstevel@tonic-gate 		if (stat(LDEV_FILE, &current_sb) == 0 &&
73837c478bd9Sstevel@tonic-gate 		    current_sb.st_mtime == cached_sb.st_mtime) {
73847c478bd9Sstevel@tonic-gate 			vprint(FILES_MID, "%s cache valid\n", LDEV_FILE);
73857c478bd9Sstevel@tonic-gate 			return;
73867c478bd9Sstevel@tonic-gate 		}
73877c478bd9Sstevel@tonic-gate 		vprint(FILES_MID, "invalidating %s cache\n", LDEV_FILE);
73887c478bd9Sstevel@tonic-gate 		while (login_dev_cache != NULL) {
73897c478bd9Sstevel@tonic-gate 
73907c478bd9Sstevel@tonic-gate 			ldev = login_dev_cache;
73917c478bd9Sstevel@tonic-gate 			login_dev_cache = ldev->ldev_next;
73927c478bd9Sstevel@tonic-gate 			free(ldev->ldev_console);
73937c478bd9Sstevel@tonic-gate 			free(ldev->ldev_device);
73947c478bd9Sstevel@tonic-gate 			regfree(&ldev->ldev_device_regex);
73957c478bd9Sstevel@tonic-gate 			list = ldev->ldev_driver_list;
73967c478bd9Sstevel@tonic-gate 			while (list) {
73977c478bd9Sstevel@tonic-gate 				next = list->next;
73987c478bd9Sstevel@tonic-gate 				free(list);
73997c478bd9Sstevel@tonic-gate 				list = next;
74007c478bd9Sstevel@tonic-gate 			}
74017c478bd9Sstevel@tonic-gate 			free(ldev);
74027c478bd9Sstevel@tonic-gate 		}
74037c478bd9Sstevel@tonic-gate 	} else {
74047c478bd9Sstevel@tonic-gate 		cached = TRUE;
74057c478bd9Sstevel@tonic-gate 	}
74067c478bd9Sstevel@tonic-gate 
74077c478bd9Sstevel@tonic-gate 	assert(login_dev_cache == NULL);
74087c478bd9Sstevel@tonic-gate 
74097c478bd9Sstevel@tonic-gate 	if (stat(LDEV_FILE, &cached_sb) != 0) {
74107c478bd9Sstevel@tonic-gate 		cached = FALSE;
74117c478bd9Sstevel@tonic-gate 		return;
74127c478bd9Sstevel@tonic-gate 	}
74137c478bd9Sstevel@tonic-gate 
74147c478bd9Sstevel@tonic-gate 	vprint(FILES_MID, "loading file: %s\n", LDEV_FILE);
74157c478bd9Sstevel@tonic-gate 
74167c478bd9Sstevel@tonic-gate 	if ((fp = fopen(LDEV_FILE, "r")) == NULL) {
74177c478bd9Sstevel@tonic-gate 		/* Not fatal to devfsadm */
74187c478bd9Sstevel@tonic-gate 		cached = FALSE;
74197c478bd9Sstevel@tonic-gate 		err_print(FOPEN_FAILED, LDEV_FILE, strerror(errno));
74207c478bd9Sstevel@tonic-gate 		return;
74217c478bd9Sstevel@tonic-gate 	}
74227c478bd9Sstevel@tonic-gate 
74237c478bd9Sstevel@tonic-gate 	ln = 0;
74247c478bd9Sstevel@tonic-gate 	while (fgets(line, MAX_LDEV_LINE, fp) != NULL) {
74257c478bd9Sstevel@tonic-gate 		ln++;
74267c478bd9Sstevel@tonic-gate 
74277c478bd9Sstevel@tonic-gate 		/* Remove comments */
74287c478bd9Sstevel@tonic-gate 		if ((cp = strchr(line, '#')) != NULL)
74297c478bd9Sstevel@tonic-gate 			*cp = '\0';
74307c478bd9Sstevel@tonic-gate 
74317c478bd9Sstevel@tonic-gate 		if ((console = strtok_r(line, LDEV_DELIMS, &lasts)) == NULL)
74327c478bd9Sstevel@tonic-gate 			continue;	/* Blank line */
74337c478bd9Sstevel@tonic-gate 
74347c478bd9Sstevel@tonic-gate 		if ((permstr =  strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) {
74357c478bd9Sstevel@tonic-gate 			err_print(IGNORING_LINE_IN, ln, LDEV_FILE);
74367c478bd9Sstevel@tonic-gate 			continue;	/* Malformed line */
74377c478bd9Sstevel@tonic-gate 		}
74387c478bd9Sstevel@tonic-gate 
74397c478bd9Sstevel@tonic-gate 		/*
74407c478bd9Sstevel@tonic-gate 		 * permstr is string in octal format. Convert to int
74417c478bd9Sstevel@tonic-gate 		 */
74427c478bd9Sstevel@tonic-gate 		cp = NULL;
74437c478bd9Sstevel@tonic-gate 		errno = 0;
74447c478bd9Sstevel@tonic-gate 		perm = strtol(permstr, &cp, 8);
74457c478bd9Sstevel@tonic-gate 		if (errno || perm < 0 || perm > 0777 || *cp != '\0') {
74467c478bd9Sstevel@tonic-gate 			err_print(IGNORING_LINE_IN, ln, LDEV_FILE);
74477c478bd9Sstevel@tonic-gate 			continue;
74487c478bd9Sstevel@tonic-gate 		}
74497c478bd9Sstevel@tonic-gate 
74506e670f77Saj 		if ((dlist = strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) {
74517c478bd9Sstevel@tonic-gate 			err_print(IGNORING_LINE_IN, ln, LDEV_FILE);
74527c478bd9Sstevel@tonic-gate 			continue;
74537c478bd9Sstevel@tonic-gate 		}
74547c478bd9Sstevel@tonic-gate 
74556e670f77Saj 		dev = strtok_r(dlist, LDEV_DEV_DELIM, &devlasts);
74567c478bd9Sstevel@tonic-gate 		while (dev) {
74577c478bd9Sstevel@tonic-gate 
74587c478bd9Sstevel@tonic-gate 			ldev = (struct login_dev *)s_zalloc(
74597c478bd9Sstevel@tonic-gate 			    sizeof (struct login_dev));
74607c478bd9Sstevel@tonic-gate 			ldev->ldev_console = s_strdup(console);
74617c478bd9Sstevel@tonic-gate 			ldev->ldev_perms = perm;
74627c478bd9Sstevel@tonic-gate 
74637c478bd9Sstevel@tonic-gate 			/*
74647c478bd9Sstevel@tonic-gate 			 * the logical device name may contain '*' which
74657c478bd9Sstevel@tonic-gate 			 * we convert to a regular expression
74667c478bd9Sstevel@tonic-gate 			 */
74677c478bd9Sstevel@tonic-gate 			ldev->ldev_device = convert_to_re(dev);
74687c478bd9Sstevel@tonic-gate 			if (ldev->ldev_device &&
74697c478bd9Sstevel@tonic-gate 			    (rv = regcomp(&ldev->ldev_device_regex,
74707c478bd9Sstevel@tonic-gate 			    ldev->ldev_device, REG_EXTENDED))) {
74717c478bd9Sstevel@tonic-gate 				bzero(&ldev->ldev_device_regex,
74727c478bd9Sstevel@tonic-gate 				    sizeof (ldev->ldev_device_regex));
74737c478bd9Sstevel@tonic-gate 				err_print(REGCOMP_FAILED,
74747c478bd9Sstevel@tonic-gate 				    ldev->ldev_device, rv);
74757c478bd9Sstevel@tonic-gate 			}
74767c478bd9Sstevel@tonic-gate 			ldev->ldev_next = login_dev_cache;
74777c478bd9Sstevel@tonic-gate 			login_dev_cache = ldev;
74787c478bd9Sstevel@tonic-gate 			dev = strtok_r(NULL, LDEV_DEV_DELIM, &devlasts);
74797c478bd9Sstevel@tonic-gate 		}
74807c478bd9Sstevel@tonic-gate 
74817c478bd9Sstevel@tonic-gate 		drv = strtok_r(NULL, LDEV_DRVLIST_DELIMS, &lasts);
74827c478bd9Sstevel@tonic-gate 		if (drv) {
74837c478bd9Sstevel@tonic-gate 			if (strcmp(drv, LDEV_DRVLIST_NAME) == 0) {
74847c478bd9Sstevel@tonic-gate 
74850a653502Swroche 				drv = strtok_r(NULL, LDEV_DRV_DELIMS, &lasts);
74867c478bd9Sstevel@tonic-gate 
74877c478bd9Sstevel@tonic-gate 				while (drv) {
74887c478bd9Sstevel@tonic-gate 					vprint(FILES_MID,
74890a653502Swroche 					    "logindevperm driver=%s\n", drv);
74907c478bd9Sstevel@tonic-gate 
74917c478bd9Sstevel@tonic-gate 					/*
74927c478bd9Sstevel@tonic-gate 					 * create a linked list of driver
74937c478bd9Sstevel@tonic-gate 					 * names
74947c478bd9Sstevel@tonic-gate 					 */
74957c478bd9Sstevel@tonic-gate 					list = (struct driver_list *)
74967c478bd9Sstevel@tonic-gate 					    s_zalloc(
74977c478bd9Sstevel@tonic-gate 					    sizeof (struct driver_list));
74987c478bd9Sstevel@tonic-gate 					(void) strlcpy(list->driver_name, drv,
74997c478bd9Sstevel@tonic-gate 					    sizeof (list->driver_name));
75007c478bd9Sstevel@tonic-gate 					list->next = ldev->ldev_driver_list;
75017c478bd9Sstevel@tonic-gate 					ldev->ldev_driver_list = list;
75027c478bd9Sstevel@tonic-gate 					drv = strtok_r(NULL, LDEV_DRV_DELIMS,
75037c478bd9Sstevel@tonic-gate 					    &lasts);
75047c478bd9Sstevel@tonic-gate 				}
75057c478bd9Sstevel@tonic-gate 			}
75067c478bd9Sstevel@tonic-gate 		}
75077c478bd9Sstevel@tonic-gate 	}
75087c478bd9Sstevel@tonic-gate 	(void) fclose(fp);
75097c478bd9Sstevel@tonic-gate }
75107c478bd9Sstevel@tonic-gate 
75117c478bd9Sstevel@tonic-gate /*
75127c478bd9Sstevel@tonic-gate  * Tokens are separated by ' ', '\t', ':', '=', '&', '|', ';', '\n', or '\0'
75137c478bd9Sstevel@tonic-gate  *
75147c478bd9Sstevel@tonic-gate  * Returns DEVFSADM_SUCCESS if token found, DEVFSADM_FAILURE otherwise.
75157c478bd9Sstevel@tonic-gate  */
75167c478bd9Sstevel@tonic-gate static int
75177c478bd9Sstevel@tonic-gate getnexttoken(char *next, char **nextp, char **tokenpp, char *tchar)
75187c478bd9Sstevel@tonic-gate {
75197c478bd9Sstevel@tonic-gate 	char *cp;
75207c478bd9Sstevel@tonic-gate 	char *cp1;
75217c478bd9Sstevel@tonic-gate 	char *tokenp;
75227c478bd9Sstevel@tonic-gate 
75237c478bd9Sstevel@tonic-gate 	cp = next;
75247c478bd9Sstevel@tonic-gate 	while (*cp == ' ' || *cp == '\t') {
75257c478bd9Sstevel@tonic-gate 		cp++;			/* skip leading spaces */
75267c478bd9Sstevel@tonic-gate 	}
75277c478bd9Sstevel@tonic-gate 	tokenp = cp;			/* start of token */
75287c478bd9Sstevel@tonic-gate 	while (*cp != '\0' && *cp != '\n' && *cp != ' ' && *cp != '\t' &&
75290a653502Swroche 	    *cp != ':' && *cp != '=' && *cp != '&' &&
75300a653502Swroche 	    *cp != '|' && *cp != ';') {
75317c478bd9Sstevel@tonic-gate 		cp++;			/* point to next character */
75327c478bd9Sstevel@tonic-gate 	}
75337c478bd9Sstevel@tonic-gate 	/*
75347c478bd9Sstevel@tonic-gate 	 * If terminating character is a space or tab, look ahead to see if
75357c478bd9Sstevel@tonic-gate 	 * there's another terminator that's not a space or a tab.
75367c478bd9Sstevel@tonic-gate 	 * (This code handles trailing spaces.)
75377c478bd9Sstevel@tonic-gate 	 */
75387c478bd9Sstevel@tonic-gate 	if (*cp == ' ' || *cp == '\t') {
75397c478bd9Sstevel@tonic-gate 		cp1 = cp;
75407c478bd9Sstevel@tonic-gate 		while (*++cp1 == ' ' || *cp1 == '\t')
75417c478bd9Sstevel@tonic-gate 			;
75427c478bd9Sstevel@tonic-gate 		if (*cp1 == '=' || *cp1 == ':' || *cp1 == '&' || *cp1 == '|' ||
75430a653502Swroche 		    *cp1 == ';' || *cp1 == '\n' || *cp1 == '\0') {
75447c478bd9Sstevel@tonic-gate 			*cp = NULL;	/* terminate token */
75457c478bd9Sstevel@tonic-gate 			cp = cp1;
75467c478bd9Sstevel@tonic-gate 		}
75477c478bd9Sstevel@tonic-gate 	}
75487c478bd9Sstevel@tonic-gate 	if (tchar != NULL) {
75497c478bd9Sstevel@tonic-gate 		*tchar = *cp;		/* save terminating character */
75507c478bd9Sstevel@tonic-gate 		if (*tchar == '\0') {
75517c478bd9Sstevel@tonic-gate 			*tchar = '\n';
75527c478bd9Sstevel@tonic-gate 		}
75537c478bd9Sstevel@tonic-gate 	}
75547c478bd9Sstevel@tonic-gate 	*cp++ = '\0';			/* terminate token, point to next */
75557c478bd9Sstevel@tonic-gate 	*nextp = cp;			/* set pointer to next character */
75567c478bd9Sstevel@tonic-gate 	if (cp - tokenp - 1 == 0) {
75577c478bd9Sstevel@tonic-gate 		return (DEVFSADM_FAILURE);
75587c478bd9Sstevel@tonic-gate 	}
75597c478bd9Sstevel@tonic-gate 	*tokenpp = tokenp;
75607c478bd9Sstevel@tonic-gate 	return (DEVFSADM_SUCCESS);
75617c478bd9Sstevel@tonic-gate }
75627c478bd9Sstevel@tonic-gate 
75637c478bd9Sstevel@tonic-gate /*
75647c478bd9Sstevel@tonic-gate  * read or reread the driver aliases file
75657c478bd9Sstevel@tonic-gate  */
75667c478bd9Sstevel@tonic-gate static void
75677c478bd9Sstevel@tonic-gate read_driver_aliases_file(void)
75687c478bd9Sstevel@tonic-gate {
75697c478bd9Sstevel@tonic-gate 
75707c478bd9Sstevel@tonic-gate 	driver_alias_t *save;
75717c478bd9Sstevel@tonic-gate 	driver_alias_t *lst_tail;
75727c478bd9Sstevel@tonic-gate 	driver_alias_t *ap;
75737c478bd9Sstevel@tonic-gate 	static int cached = FALSE;
75747c478bd9Sstevel@tonic-gate 	FILE *afd;
75757c478bd9Sstevel@tonic-gate 	char line[256];
75767c478bd9Sstevel@tonic-gate 	char *cp;
75777c478bd9Sstevel@tonic-gate 	char *p;
75787c478bd9Sstevel@tonic-gate 	char t;
75797c478bd9Sstevel@tonic-gate 	int ln = 0;
75807c478bd9Sstevel@tonic-gate 	static struct stat cached_sb;
75817c478bd9Sstevel@tonic-gate 	struct stat current_sb;
75827c478bd9Sstevel@tonic-gate 
75837c478bd9Sstevel@tonic-gate 	(void) stat(ALIASFILE, &current_sb);
75847c478bd9Sstevel@tonic-gate 
75857c478bd9Sstevel@tonic-gate 	/* If already cached, check to see if it is still valid */
75867c478bd9Sstevel@tonic-gate 	if (cached == TRUE) {
75877c478bd9Sstevel@tonic-gate 
75887c478bd9Sstevel@tonic-gate 		if (current_sb.st_mtime == cached_sb.st_mtime) {
75897c478bd9Sstevel@tonic-gate 			vprint(FILES_MID, "%s cache valid\n", ALIASFILE);
75907c478bd9Sstevel@tonic-gate 			return;
75917c478bd9Sstevel@tonic-gate 		}
75927c478bd9Sstevel@tonic-gate 
75937c478bd9Sstevel@tonic-gate 		vprint(FILES_MID, "invalidating %s cache\n", ALIASFILE);
75947c478bd9Sstevel@tonic-gate 		while (driver_aliases != NULL) {
75957c478bd9Sstevel@tonic-gate 			free(driver_aliases->alias_name);
75967c478bd9Sstevel@tonic-gate 			free(driver_aliases->driver_name);
75977c478bd9Sstevel@tonic-gate 			save = driver_aliases;
75987c478bd9Sstevel@tonic-gate 			driver_aliases = driver_aliases->next;
75997c478bd9Sstevel@tonic-gate 			free(save);
76007c478bd9Sstevel@tonic-gate 		}
76017c478bd9Sstevel@tonic-gate 	} else {
76027c478bd9Sstevel@tonic-gate 		cached = TRUE;
76037c478bd9Sstevel@tonic-gate 	}
76047c478bd9Sstevel@tonic-gate 
76057c478bd9Sstevel@tonic-gate 	(void) stat(ALIASFILE, &cached_sb);
76067c478bd9Sstevel@tonic-gate 
76077c478bd9Sstevel@tonic-gate 	vprint(FILES_MID, "loading binding file: %s\n", ALIASFILE);
76087c478bd9Sstevel@tonic-gate 
76097c478bd9Sstevel@tonic-gate 	if ((afd = fopen(ALIASFILE, "r")) == NULL) {
76107c478bd9Sstevel@tonic-gate 		err_print(FOPEN_FAILED, ALIASFILE, strerror(errno));
76117c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
7612537714daSvikram 		/*NOTREACHED*/
76137c478bd9Sstevel@tonic-gate 	}
76147c478bd9Sstevel@tonic-gate 
76151ca93273Seota 	while (fgets(line, sizeof (line), afd) != NULL) {
76167c478bd9Sstevel@tonic-gate 		ln++;
76171ca93273Seota 		/* cut off comments starting with '#' */
76181ca93273Seota 		if ((cp = strchr(line, '#')) != NULL)
76191ca93273Seota 			*cp = '\0';
76201ca93273Seota 		/* ignore comment or blank lines */
76211ca93273Seota 		if (is_blank(line))
76221ca93273Seota 			continue;
76237c478bd9Sstevel@tonic-gate 		cp = line;
76247c478bd9Sstevel@tonic-gate 		if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) {
76257c478bd9Sstevel@tonic-gate 			err_print(IGNORING_LINE_IN, ln, ALIASFILE);
76267c478bd9Sstevel@tonic-gate 			continue;
76277c478bd9Sstevel@tonic-gate 		}
76287c478bd9Sstevel@tonic-gate 		if (t == '\n' || t == '\0') {
76297c478bd9Sstevel@tonic-gate 			err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE);
76307c478bd9Sstevel@tonic-gate 			continue;
76317c478bd9Sstevel@tonic-gate 		}
76327c478bd9Sstevel@tonic-gate 		ap = (struct driver_alias *)
76330a653502Swroche 		    s_zalloc(sizeof (struct driver_alias));
76347c478bd9Sstevel@tonic-gate 		ap->driver_name = s_strdup(p);
76357c478bd9Sstevel@tonic-gate 		if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) {
76367c478bd9Sstevel@tonic-gate 			err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE);
76377c478bd9Sstevel@tonic-gate 			free(ap->driver_name);
76387c478bd9Sstevel@tonic-gate 			free(ap);
76397c478bd9Sstevel@tonic-gate 			continue;
76407c478bd9Sstevel@tonic-gate 		}
76417c478bd9Sstevel@tonic-gate 		if (*p == '"') {
76427c478bd9Sstevel@tonic-gate 			if (p[strlen(p) - 1] == '"') {
76437c478bd9Sstevel@tonic-gate 				p[strlen(p) - 1] = '\0';
76447c478bd9Sstevel@tonic-gate 				p++;
76457c478bd9Sstevel@tonic-gate 			}
76467c478bd9Sstevel@tonic-gate 		}
76477c478bd9Sstevel@tonic-gate 		ap->alias_name = s_strdup(p);
76487c478bd9Sstevel@tonic-gate 		if (driver_aliases == NULL) {
76497c478bd9Sstevel@tonic-gate 			driver_aliases = ap;
76507c478bd9Sstevel@tonic-gate 			lst_tail = ap;
76517c478bd9Sstevel@tonic-gate 		} else {
76527c478bd9Sstevel@tonic-gate 			lst_tail->next = ap;
76537c478bd9Sstevel@tonic-gate 			lst_tail = ap;
76547c478bd9Sstevel@tonic-gate 		}
76557c478bd9Sstevel@tonic-gate 	}
76567c478bd9Sstevel@tonic-gate 	if (fclose(afd) == EOF) {
76577c478bd9Sstevel@tonic-gate 		err_print(FCLOSE_FAILED, ALIASFILE, strerror(errno));
76587c478bd9Sstevel@tonic-gate 	}
76597c478bd9Sstevel@tonic-gate }
76607c478bd9Sstevel@tonic-gate 
76617c478bd9Sstevel@tonic-gate /*
76627c478bd9Sstevel@tonic-gate  * return TRUE if alias_name is an alias for driver_name, otherwise
76637c478bd9Sstevel@tonic-gate  * return FALSE.
76647c478bd9Sstevel@tonic-gate  */
76657c478bd9Sstevel@tonic-gate static int
76667c478bd9Sstevel@tonic-gate alias(char *driver_name, char *alias_name)
76677c478bd9Sstevel@tonic-gate {
76687c478bd9Sstevel@tonic-gate 	driver_alias_t *alias;
76697c478bd9Sstevel@tonic-gate 
76707c478bd9Sstevel@tonic-gate 	/*
76717c478bd9Sstevel@tonic-gate 	 * check for a match
76727c478bd9Sstevel@tonic-gate 	 */
76737c478bd9Sstevel@tonic-gate 	for (alias = driver_aliases; alias != NULL; alias = alias->next) {
76747c478bd9Sstevel@tonic-gate 		if ((strcmp(alias->driver_name, driver_name) == 0) &&
76757c478bd9Sstevel@tonic-gate 		    (strcmp(alias->alias_name, alias_name) == 0)) {
76767c478bd9Sstevel@tonic-gate 			return (TRUE);
76777c478bd9Sstevel@tonic-gate 		}
76787c478bd9Sstevel@tonic-gate 	}
76797c478bd9Sstevel@tonic-gate 	return (FALSE);
76807c478bd9Sstevel@tonic-gate }
76817c478bd9Sstevel@tonic-gate 
76827c478bd9Sstevel@tonic-gate /*
76837c478bd9Sstevel@tonic-gate  * convenience functions
76847c478bd9Sstevel@tonic-gate  */
7685facf4a8dSllai static int
7686facf4a8dSllai s_stat(const char *path, struct stat *sbufp)
7687facf4a8dSllai {
7688facf4a8dSllai 	int rv;
7689facf4a8dSllai retry:
7690facf4a8dSllai 	if ((rv = stat(path, sbufp)) == -1) {
7691facf4a8dSllai 		if (errno == EINTR)
7692facf4a8dSllai 			goto retry;
7693facf4a8dSllai 	}
7694facf4a8dSllai 	return (rv);
7695facf4a8dSllai }
7696facf4a8dSllai 
76977c478bd9Sstevel@tonic-gate static void *
76987c478bd9Sstevel@tonic-gate s_malloc(const size_t size)
76997c478bd9Sstevel@tonic-gate {
77007c478bd9Sstevel@tonic-gate 	void *rp;
77017c478bd9Sstevel@tonic-gate 
77027c478bd9Sstevel@tonic-gate 	rp = malloc(size);
77037c478bd9Sstevel@tonic-gate 	if (rp == NULL) {
77047c478bd9Sstevel@tonic-gate 		err_print(MALLOC_FAILED, size);
77057c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
7706537714daSvikram 		/*NOTREACHED*/
77077c478bd9Sstevel@tonic-gate 	}
77087c478bd9Sstevel@tonic-gate 	return (rp);
77097c478bd9Sstevel@tonic-gate }
77107c478bd9Sstevel@tonic-gate 
77117c478bd9Sstevel@tonic-gate /*
77127c478bd9Sstevel@tonic-gate  * convenience functions
77137c478bd9Sstevel@tonic-gate  */
77147c478bd9Sstevel@tonic-gate static void *
77157c478bd9Sstevel@tonic-gate s_realloc(void *ptr, const size_t size)
77167c478bd9Sstevel@tonic-gate {
77177c478bd9Sstevel@tonic-gate 	ptr = realloc(ptr, size);
77187c478bd9Sstevel@tonic-gate 	if (ptr == NULL) {
77197c478bd9Sstevel@tonic-gate 		err_print(REALLOC_FAILED, size);
77207c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
7721537714daSvikram 		/*NOTREACHED*/
77227c478bd9Sstevel@tonic-gate 	}
77237c478bd9Sstevel@tonic-gate 	return (ptr);
77247c478bd9Sstevel@tonic-gate }
77257c478bd9Sstevel@tonic-gate 
77267c478bd9Sstevel@tonic-gate static void *
77277c478bd9Sstevel@tonic-gate s_zalloc(const size_t size)
77287c478bd9Sstevel@tonic-gate {
77297c478bd9Sstevel@tonic-gate 	void *rp;
77307c478bd9Sstevel@tonic-gate 
77317c478bd9Sstevel@tonic-gate 	rp = calloc(1, size);
77327c478bd9Sstevel@tonic-gate 	if (rp == NULL) {
77337c478bd9Sstevel@tonic-gate 		err_print(CALLOC_FAILED, size);
77347c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
7735537714daSvikram 		/*NOTREACHED*/
77367c478bd9Sstevel@tonic-gate 	}
77377c478bd9Sstevel@tonic-gate 	return (rp);
77387c478bd9Sstevel@tonic-gate }
77397c478bd9Sstevel@tonic-gate 
77407c478bd9Sstevel@tonic-gate char *
77417c478bd9Sstevel@tonic-gate s_strdup(const char *ptr)
77427c478bd9Sstevel@tonic-gate {
77437c478bd9Sstevel@tonic-gate 	void *rp;
77447c478bd9Sstevel@tonic-gate 
77457c478bd9Sstevel@tonic-gate 	rp = strdup(ptr);
77467c478bd9Sstevel@tonic-gate 	if (rp == NULL) {
77477c478bd9Sstevel@tonic-gate 		err_print(STRDUP_FAILED, ptr);
77487c478bd9Sstevel@tonic-gate 		devfsadm_exit(1);
7749537714daSvikram 		/*NOTREACHED*/
77507c478bd9Sstevel@tonic-gate 	}
77517c478bd9Sstevel@tonic-gate 	return (rp);
77527c478bd9Sstevel@tonic-gate }
77537c478bd9Sstevel@tonic-gate 
77547c478bd9Sstevel@tonic-gate static void
77557c478bd9Sstevel@tonic-gate s_closedir(DIR *dirp)
77567c478bd9Sstevel@tonic-gate {
77577c478bd9Sstevel@tonic-gate retry:
77587c478bd9Sstevel@tonic-gate 	if (closedir(dirp) != 0) {
77597c478bd9Sstevel@tonic-gate 		if (errno == EINTR)
77607c478bd9Sstevel@tonic-gate 			goto retry;
77617c478bd9Sstevel@tonic-gate 		err_print(CLOSEDIR_FAILED, strerror(errno));
77627c478bd9Sstevel@tonic-gate 	}
77637c478bd9Sstevel@tonic-gate }
77647c478bd9Sstevel@tonic-gate 
77657c478bd9Sstevel@tonic-gate static void
77667c478bd9Sstevel@tonic-gate s_mkdirp(const char *path, const mode_t mode)
77677c478bd9Sstevel@tonic-gate {
77687c478bd9Sstevel@tonic-gate 	vprint(CHATTY_MID, "mkdirp(%s, 0x%lx)\n", path, mode);
77697c478bd9Sstevel@tonic-gate 	if (mkdirp(path, mode) == -1) {
77707c478bd9Sstevel@tonic-gate 		if (errno != EEXIST) {
77717c478bd9Sstevel@tonic-gate 			err_print(MKDIR_FAILED, path, mode, strerror(errno));
77727c478bd9Sstevel@tonic-gate 		}
77737c478bd9Sstevel@tonic-gate 	}
77747c478bd9Sstevel@tonic-gate }
77757c478bd9Sstevel@tonic-gate 
77767c478bd9Sstevel@tonic-gate static void
77777c478bd9Sstevel@tonic-gate s_unlink(const char *file)
77787c478bd9Sstevel@tonic-gate {
77797c478bd9Sstevel@tonic-gate retry:
77807c478bd9Sstevel@tonic-gate 	if (unlink(file) == -1) {
77817c478bd9Sstevel@tonic-gate 		if (errno == EINTR || errno == EAGAIN)
77827c478bd9Sstevel@tonic-gate 			goto retry;
77837c478bd9Sstevel@tonic-gate 		if (errno != ENOENT) {
77847c478bd9Sstevel@tonic-gate 			err_print(UNLINK_FAILED, file, strerror(errno));
77857c478bd9Sstevel@tonic-gate 		}
77867c478bd9Sstevel@tonic-gate 	}
77877c478bd9Sstevel@tonic-gate }
77887c478bd9Sstevel@tonic-gate 
77897c478bd9Sstevel@tonic-gate static void
77907c478bd9Sstevel@tonic-gate add_verbose_id(char *mid)
77917c478bd9Sstevel@tonic-gate {
77927c478bd9Sstevel@tonic-gate 	num_verbose++;
77937c478bd9Sstevel@tonic-gate 	verbose = s_realloc(verbose, num_verbose * sizeof (char *));
77947c478bd9Sstevel@tonic-gate 	verbose[num_verbose - 1] = mid;
77957c478bd9Sstevel@tonic-gate }
77967c478bd9Sstevel@tonic-gate 
77977c478bd9Sstevel@tonic-gate /*
77987c478bd9Sstevel@tonic-gate  * returns DEVFSADM_TRUE if contents is a minor node in /devices.
77997c478bd9Sstevel@tonic-gate  * If mn_root is not NULL, mn_root is set to:
78007c478bd9Sstevel@tonic-gate  *	if contents is a /dev node, mn_root = contents
78017c478bd9Sstevel@tonic-gate  * 			OR
78027c478bd9Sstevel@tonic-gate  *	if contents is a /devices node, mn_root set to the '/'
78037c478bd9Sstevel@tonic-gate  *	following /devices.
78047c478bd9Sstevel@tonic-gate  */
78057c478bd9Sstevel@tonic-gate static int
78067c478bd9Sstevel@tonic-gate is_minor_node(char *contents, char **mn_root)
78077c478bd9Sstevel@tonic-gate {
78087c478bd9Sstevel@tonic-gate 	char *ptr;
78097c478bd9Sstevel@tonic-gate 	char device_prefix[100];
78107c478bd9Sstevel@tonic-gate 
78117c478bd9Sstevel@tonic-gate 	(void) snprintf(device_prefix, sizeof (device_prefix), "../devices/");
78127c478bd9Sstevel@tonic-gate 
78137c478bd9Sstevel@tonic-gate 	if ((ptr = strstr(contents, device_prefix)) != NULL) {
78147c478bd9Sstevel@tonic-gate 		if (mn_root != NULL) {
78157c478bd9Sstevel@tonic-gate 			/* mn_root should point to the / following /devices */
78167c478bd9Sstevel@tonic-gate 			*mn_root = ptr += strlen(device_prefix) - 1;
78177c478bd9Sstevel@tonic-gate 		}
78187c478bd9Sstevel@tonic-gate 		return (DEVFSADM_TRUE);
78197c478bd9Sstevel@tonic-gate 	}
78207c478bd9Sstevel@tonic-gate 
78217c478bd9Sstevel@tonic-gate 	(void) snprintf(device_prefix, sizeof (device_prefix), "/devices/");
78227c478bd9Sstevel@tonic-gate 
78237c478bd9Sstevel@tonic-gate 	if (strncmp(contents, device_prefix, strlen(device_prefix)) == 0) {
78247c478bd9Sstevel@tonic-gate 		if (mn_root != NULL) {
78257c478bd9Sstevel@tonic-gate 			/* mn_root should point to the / following /devices */
78267c478bd9Sstevel@tonic-gate 			*mn_root = contents + strlen(device_prefix) - 1;
78277c478bd9Sstevel@tonic-gate 		}
78287c478bd9Sstevel@tonic-gate 		return (DEVFSADM_TRUE);
78297c478bd9Sstevel@tonic-gate 	}
78307c478bd9Sstevel@tonic-gate 
78317c478bd9Sstevel@tonic-gate 	if (mn_root != NULL) {
78327c478bd9Sstevel@tonic-gate 		*mn_root = contents;
78337c478bd9Sstevel@tonic-gate 	}
78347c478bd9Sstevel@tonic-gate 	return (DEVFSADM_FALSE);
78357c478bd9Sstevel@tonic-gate }
78367c478bd9Sstevel@tonic-gate 
78377c478bd9Sstevel@tonic-gate /*
78387c478bd9Sstevel@tonic-gate  * Add the specified property to nvl.
78397c478bd9Sstevel@tonic-gate  * Returns:
78407c478bd9Sstevel@tonic-gate  *   0	successfully added
78417c478bd9Sstevel@tonic-gate  *   -1	an error occurred
78427c478bd9Sstevel@tonic-gate  *   1	could not add the property for reasons not due to errors.
78437c478bd9Sstevel@tonic-gate  */
78447c478bd9Sstevel@tonic-gate static int
78457c478bd9Sstevel@tonic-gate add_property(nvlist_t *nvl, di_prop_t prop)
78467c478bd9Sstevel@tonic-gate {
78477c478bd9Sstevel@tonic-gate 	char *name;
78487c478bd9Sstevel@tonic-gate 	char *attr_name;
78497c478bd9Sstevel@tonic-gate 	int n, len;
78507c478bd9Sstevel@tonic-gate 	int32_t *int32p;
78517c478bd9Sstevel@tonic-gate 	int64_t *int64p;
78527c478bd9Sstevel@tonic-gate 	char *str;
78537c478bd9Sstevel@tonic-gate 	char **strarray;
78547c478bd9Sstevel@tonic-gate 	uchar_t *bytep;
78557c478bd9Sstevel@tonic-gate 	int rv = 0;
78567c478bd9Sstevel@tonic-gate 	int i;
78577c478bd9Sstevel@tonic-gate 
78587c478bd9Sstevel@tonic-gate 	if ((name = di_prop_name(prop)) == NULL)
78597c478bd9Sstevel@tonic-gate 		return (-1);
78607c478bd9Sstevel@tonic-gate 
78617c478bd9Sstevel@tonic-gate 	len = sizeof (DEV_PROP_PREFIX) + strlen(name);
78627c478bd9Sstevel@tonic-gate 	if ((attr_name = malloc(len)) == NULL)
78637c478bd9Sstevel@tonic-gate 		return (-1);
78647c478bd9Sstevel@tonic-gate 
78657c478bd9Sstevel@tonic-gate 	(void) strlcpy(attr_name, DEV_PROP_PREFIX, len);
78667c478bd9Sstevel@tonic-gate 	(void) strlcat(attr_name, name, len);
78677c478bd9Sstevel@tonic-gate 
78687c478bd9Sstevel@tonic-gate 	switch (di_prop_type(prop)) {
78697c478bd9Sstevel@tonic-gate 	case DI_PROP_TYPE_BOOLEAN:
78707c478bd9Sstevel@tonic-gate 		if (nvlist_add_boolean(nvl, attr_name) != 0)
78717c478bd9Sstevel@tonic-gate 			goto out;
78727c478bd9Sstevel@tonic-gate 		break;
78737c478bd9Sstevel@tonic-gate 
78747c478bd9Sstevel@tonic-gate 	case DI_PROP_TYPE_INT:
78757c478bd9Sstevel@tonic-gate 		if ((n = di_prop_ints(prop, &int32p)) < 1)
78767c478bd9Sstevel@tonic-gate 			goto out;
78777c478bd9Sstevel@tonic-gate 
78787c478bd9Sstevel@tonic-gate 		if (n <= (PROP_LEN_LIMIT / sizeof (int32_t))) {
78797c478bd9Sstevel@tonic-gate 			if (nvlist_add_int32_array(nvl, attr_name, int32p,
78807c478bd9Sstevel@tonic-gate 			    n) != 0)
78817c478bd9Sstevel@tonic-gate 				goto out;
78827c478bd9Sstevel@tonic-gate 		} else
78837c478bd9Sstevel@tonic-gate 			rv = 1;
78847c478bd9Sstevel@tonic-gate 		break;
78857c478bd9Sstevel@tonic-gate 
78867c478bd9Sstevel@tonic-gate 	case DI_PROP_TYPE_INT64:
78877c478bd9Sstevel@tonic-gate 		if ((n = di_prop_int64(prop, &int64p)) < 1)
78887c478bd9Sstevel@tonic-gate 			goto out;
78897c478bd9Sstevel@tonic-gate 
78907c478bd9Sstevel@tonic-gate 		if (n <= (PROP_LEN_LIMIT / sizeof (int64_t))) {
78917c478bd9Sstevel@tonic-gate 			if (nvlist_add_int64_array(nvl, attr_name, int64p,
78927c478bd9Sstevel@tonic-gate 			    n) != 0)
78937c478bd9Sstevel@tonic-gate 				goto out;
78947c478bd9Sstevel@tonic-gate 		} else
78957c478bd9Sstevel@tonic-gate 			rv = 1;
78967c478bd9Sstevel@tonic-gate 		break;
78977c478bd9Sstevel@tonic-gate 
78987c478bd9Sstevel@tonic-gate 	case DI_PROP_TYPE_BYTE:
78997c478bd9Sstevel@tonic-gate 	case DI_PROP_TYPE_UNKNOWN:
79007c478bd9Sstevel@tonic-gate 		if ((n = di_prop_bytes(prop, &bytep)) < 1)
79017c478bd9Sstevel@tonic-gate 			goto out;
79027c478bd9Sstevel@tonic-gate 
79037c478bd9Sstevel@tonic-gate 		if (n <= PROP_LEN_LIMIT) {
79047c478bd9Sstevel@tonic-gate 			if (nvlist_add_byte_array(nvl, attr_name, bytep, n)
79057c478bd9Sstevel@tonic-gate 			    != 0)
79067c478bd9Sstevel@tonic-gate 				goto out;
79077c478bd9Sstevel@tonic-gate 		} else
79087c478bd9Sstevel@tonic-gate 			rv = 1;
79097c478bd9Sstevel@tonic-gate 		break;
79107c478bd9Sstevel@tonic-gate 
79117c478bd9Sstevel@tonic-gate 	case DI_PROP_TYPE_STRING:
79127c478bd9Sstevel@tonic-gate 		if ((n = di_prop_strings(prop, &str)) < 1)
79137c478bd9Sstevel@tonic-gate 			goto out;
79147c478bd9Sstevel@tonic-gate 
79157c478bd9Sstevel@tonic-gate 		if ((strarray = malloc(n * sizeof (char *))) == NULL)
79167c478bd9Sstevel@tonic-gate 			goto out;
79177c478bd9Sstevel@tonic-gate 
79187c478bd9Sstevel@tonic-gate 		len = 0;
79197c478bd9Sstevel@tonic-gate 		for (i = 0; i < n; i++) {
79207c478bd9Sstevel@tonic-gate 			strarray[i] = str + len;
79217c478bd9Sstevel@tonic-gate 			len += strlen(strarray[i]) + 1;
79227c478bd9Sstevel@tonic-gate 		}
79237c478bd9Sstevel@tonic-gate 
79247c478bd9Sstevel@tonic-gate 		if (len <= PROP_LEN_LIMIT) {
79257c478bd9Sstevel@tonic-gate 			if (nvlist_add_string_array(nvl, attr_name, strarray,
79267c478bd9Sstevel@tonic-gate 			    n) != 0) {
79277c478bd9Sstevel@tonic-gate 				free(strarray);
79287c478bd9Sstevel@tonic-gate 				goto out;
79297c478bd9Sstevel@tonic-gate 			}
79307c478bd9Sstevel@tonic-gate 		} else
79317c478bd9Sstevel@tonic-gate 			rv = 1;
79327c478bd9Sstevel@tonic-gate 		free(strarray);
79337c478bd9Sstevel@tonic-gate 		break;
79347c478bd9Sstevel@tonic-gate 
79357c478bd9Sstevel@tonic-gate 	default:
79367c478bd9Sstevel@tonic-gate 		rv = 1;
79377c478bd9Sstevel@tonic-gate 		break;
79387c478bd9Sstevel@tonic-gate 	}
79397c478bd9Sstevel@tonic-gate 
79407c478bd9Sstevel@tonic-gate 	free(attr_name);
79417c478bd9Sstevel@tonic-gate 	return (rv);
79427c478bd9Sstevel@tonic-gate 
79437c478bd9Sstevel@tonic-gate out:
79447c478bd9Sstevel@tonic-gate 	free(attr_name);
79457c478bd9Sstevel@tonic-gate 	return (-1);
79467c478bd9Sstevel@tonic-gate }
79477c478bd9Sstevel@tonic-gate 
79487c478bd9Sstevel@tonic-gate static void
79497c478bd9Sstevel@tonic-gate free_dev_names(struct devlink_cb_arg *x)
79507c478bd9Sstevel@tonic-gate {
79517c478bd9Sstevel@tonic-gate 	int i;
79527c478bd9Sstevel@tonic-gate 
79537c478bd9Sstevel@tonic-gate 	for (i = 0; i < x->count; i++) {
79547c478bd9Sstevel@tonic-gate 		free(x->dev_names[i]);
79557c478bd9Sstevel@tonic-gate 		free(x->link_contents[i]);
79567c478bd9Sstevel@tonic-gate 	}
79577c478bd9Sstevel@tonic-gate }
79587c478bd9Sstevel@tonic-gate 
79597c478bd9Sstevel@tonic-gate /* callback function for di_devlink_cache_walk */
79607c478bd9Sstevel@tonic-gate static int
79617c478bd9Sstevel@tonic-gate devlink_cb(di_devlink_t dl, void *arg)
79627c478bd9Sstevel@tonic-gate {
79637c478bd9Sstevel@tonic-gate 	struct devlink_cb_arg *x = (struct devlink_cb_arg *)arg;
79647c478bd9Sstevel@tonic-gate 	const char *path;
79657c478bd9Sstevel@tonic-gate 	const char *content;
79667c478bd9Sstevel@tonic-gate 
79677c478bd9Sstevel@tonic-gate 	if ((path = di_devlink_path(dl)) == NULL ||
79687c478bd9Sstevel@tonic-gate 	    (content = di_devlink_content(dl)) == NULL ||
796912d8cf2aSjg 	    (x->dev_names[x->count] = s_strdup(path)) == NULL)
79707c478bd9Sstevel@tonic-gate 		goto out;
79717c478bd9Sstevel@tonic-gate 
797212d8cf2aSjg 	if ((x->link_contents[x->count] = s_strdup(content)) == NULL) {
79737c478bd9Sstevel@tonic-gate 		free(x->dev_names[x->count]);
79747c478bd9Sstevel@tonic-gate 		goto out;
79757c478bd9Sstevel@tonic-gate 	}
79767c478bd9Sstevel@tonic-gate 
79777c478bd9Sstevel@tonic-gate 	x->count++;
79787c478bd9Sstevel@tonic-gate 	if (x->count >= MAX_DEV_NAME_COUNT)
79797c478bd9Sstevel@tonic-gate 		return (DI_WALK_TERMINATE);
79807c478bd9Sstevel@tonic-gate 
79817c478bd9Sstevel@tonic-gate 	return (DI_WALK_CONTINUE);
79827c478bd9Sstevel@tonic-gate 
79837c478bd9Sstevel@tonic-gate out:
79847c478bd9Sstevel@tonic-gate 	x->rv = -1;
79857c478bd9Sstevel@tonic-gate 	free_dev_names(x);
79867c478bd9Sstevel@tonic-gate 	return (DI_WALK_TERMINATE);
79877c478bd9Sstevel@tonic-gate }
79887c478bd9Sstevel@tonic-gate 
79897c478bd9Sstevel@tonic-gate /*
79907c478bd9Sstevel@tonic-gate  * Lookup dev name corresponding to the phys_path.
79917c478bd9Sstevel@tonic-gate  * phys_path is path to a node or minor node.
79927c478bd9Sstevel@tonic-gate  * Returns:
79937c478bd9Sstevel@tonic-gate  *	0 with *dev_name set to the dev name
79947c478bd9Sstevel@tonic-gate  *		Lookup succeeded and dev_name found
79957c478bd9Sstevel@tonic-gate  *	0 with *dev_name set to NULL
79967c478bd9Sstevel@tonic-gate  *		Lookup encountered no errors but dev name not found
79977c478bd9Sstevel@tonic-gate  *	-1
79987c478bd9Sstevel@tonic-gate  *		Lookup failed
79997c478bd9Sstevel@tonic-gate  */
80007c478bd9Sstevel@tonic-gate static int
80017c478bd9Sstevel@tonic-gate lookup_dev_name(char *phys_path, char **dev_name)
80027c478bd9Sstevel@tonic-gate {
80037c478bd9Sstevel@tonic-gate 	struct devlink_cb_arg cb_arg;
80047c478bd9Sstevel@tonic-gate 
80057c478bd9Sstevel@tonic-gate 	*dev_name = NULL;
80067c478bd9Sstevel@tonic-gate 
80077c478bd9Sstevel@tonic-gate 	cb_arg.count = 0;
80087c478bd9Sstevel@tonic-gate 	cb_arg.rv = 0;
80097c478bd9Sstevel@tonic-gate 	(void) di_devlink_cache_walk(devlink_cache, NULL, phys_path,
80107c478bd9Sstevel@tonic-gate 	    DI_PRIMARY_LINK, &cb_arg, devlink_cb);
80117c478bd9Sstevel@tonic-gate 
80127c478bd9Sstevel@tonic-gate 	if (cb_arg.rv == -1)
80137c478bd9Sstevel@tonic-gate 		return (-1);
80147c478bd9Sstevel@tonic-gate 
80157c478bd9Sstevel@tonic-gate 	if (cb_arg.count > 0) {
801612d8cf2aSjg 		*dev_name = s_strdup(cb_arg.dev_names[0]);
80177c478bd9Sstevel@tonic-gate 		free_dev_names(&cb_arg);
80187c478bd9Sstevel@tonic-gate 		if (*dev_name == NULL)
80197c478bd9Sstevel@tonic-gate 			return (-1);
80207c478bd9Sstevel@tonic-gate 	}
80217c478bd9Sstevel@tonic-gate 
80227c478bd9Sstevel@tonic-gate 	return (0);
80237c478bd9Sstevel@tonic-gate }
80247c478bd9Sstevel@tonic-gate 
80257c478bd9Sstevel@tonic-gate static char *
80267c478bd9Sstevel@tonic-gate lookup_disk_dev_name(char *node_path)
80277c478bd9Sstevel@tonic-gate {
80287c478bd9Sstevel@tonic-gate 	struct devlink_cb_arg cb_arg;
80297c478bd9Sstevel@tonic-gate 	char *dev_name = NULL;
80307c478bd9Sstevel@tonic-gate 	int i;
80317c478bd9Sstevel@tonic-gate 	char *p;
80327c478bd9Sstevel@tonic-gate 	int len1, len2;
80337c478bd9Sstevel@tonic-gate 
80347c478bd9Sstevel@tonic-gate #define	DEV_RDSK	"/dev/rdsk/"
80357c478bd9Sstevel@tonic-gate #define	DISK_RAW_MINOR	",raw"
80367c478bd9Sstevel@tonic-gate 
80377c478bd9Sstevel@tonic-gate 	cb_arg.count = 0;
80387c478bd9Sstevel@tonic-gate 	cb_arg.rv = 0;
80397c478bd9Sstevel@tonic-gate 	(void) di_devlink_cache_walk(devlink_cache, NULL, node_path,
80407c478bd9Sstevel@tonic-gate 	    DI_PRIMARY_LINK, &cb_arg, devlink_cb);
80417c478bd9Sstevel@tonic-gate 
80427c478bd9Sstevel@tonic-gate 	if (cb_arg.rv == -1 || cb_arg.count == 0)
80437c478bd9Sstevel@tonic-gate 		return (NULL);
80447c478bd9Sstevel@tonic-gate 
80457c478bd9Sstevel@tonic-gate 	/* first try lookup based on /dev/rdsk name */
80467c478bd9Sstevel@tonic-gate 	for (i = 0; i < cb_arg.count; i++) {
80477c478bd9Sstevel@tonic-gate 		if (strncmp(cb_arg.dev_names[i], DEV_RDSK,
80487c478bd9Sstevel@tonic-gate 		    sizeof (DEV_RDSK) - 1) == 0) {
804912d8cf2aSjg 			dev_name = s_strdup(cb_arg.dev_names[i]);
80507c478bd9Sstevel@tonic-gate 			break;
80517c478bd9Sstevel@tonic-gate 		}
80527c478bd9Sstevel@tonic-gate 	}
80537c478bd9Sstevel@tonic-gate 
80547c478bd9Sstevel@tonic-gate 	if (dev_name == NULL) {
80557c478bd9Sstevel@tonic-gate 		/* now try lookup based on a minor name ending with ",raw" */
80567c478bd9Sstevel@tonic-gate 		len1 = sizeof (DISK_RAW_MINOR) - 1;
80577c478bd9Sstevel@tonic-gate 		for (i = 0; i < cb_arg.count; i++) {
80587c478bd9Sstevel@tonic-gate 			len2 = strlen(cb_arg.link_contents[i]);
80597c478bd9Sstevel@tonic-gate 			if (len2 >= len1 &&
80607c478bd9Sstevel@tonic-gate 			    strcmp(cb_arg.link_contents[i] + len2 - len1,
80617c478bd9Sstevel@tonic-gate 			    DISK_RAW_MINOR) == 0) {
806212d8cf2aSjg 				dev_name = s_strdup(cb_arg.dev_names[i]);
80637c478bd9Sstevel@tonic-gate 				break;
80647c478bd9Sstevel@tonic-gate 			}
80657c478bd9Sstevel@tonic-gate 		}
80667c478bd9Sstevel@tonic-gate 	}
80677c478bd9Sstevel@tonic-gate 
80687c478bd9Sstevel@tonic-gate 	free_dev_names(&cb_arg);
80697c478bd9Sstevel@tonic-gate 
807012d8cf2aSjg 	if (dev_name == NULL)
807112d8cf2aSjg 		return (NULL);
80727c478bd9Sstevel@tonic-gate 	if (strlen(dev_name) == 0) {
80737c478bd9Sstevel@tonic-gate 		free(dev_name);
80747c478bd9Sstevel@tonic-gate 		return (NULL);
80757c478bd9Sstevel@tonic-gate 	}
80767c478bd9Sstevel@tonic-gate 
80777c478bd9Sstevel@tonic-gate 	/* if the name contains slice or partition number strip it */
80787c478bd9Sstevel@tonic-gate 	p = dev_name + strlen(dev_name) - 1;
80797c478bd9Sstevel@tonic-gate 	if (isdigit(*p)) {
80807c478bd9Sstevel@tonic-gate 		while (p != dev_name && isdigit(*p))
80817c478bd9Sstevel@tonic-gate 			p--;
80827c478bd9Sstevel@tonic-gate 		if (*p == 's' || *p == 'p')
80837c478bd9Sstevel@tonic-gate 			*p = '\0';
80847c478bd9Sstevel@tonic-gate 	}
80857c478bd9Sstevel@tonic-gate 
80867c478bd9Sstevel@tonic-gate 	return (dev_name);
80877c478bd9Sstevel@tonic-gate }
80887c478bd9Sstevel@tonic-gate 
808930294554Sphitran static char *
809030294554Sphitran lookup_lofi_dev_name(char *node_path, char *minor)
809130294554Sphitran {
809230294554Sphitran 	struct devlink_cb_arg cb_arg;
809330294554Sphitran 	char *dev_name = NULL;
809430294554Sphitran 	int i;
809530294554Sphitran 	int len1, len2;
809630294554Sphitran 
809730294554Sphitran 	cb_arg.count = 0;
809830294554Sphitran 	cb_arg.rv = 0;
809930294554Sphitran 	(void) di_devlink_cache_walk(devlink_cache, NULL, node_path,
810030294554Sphitran 	    DI_PRIMARY_LINK, &cb_arg, devlink_cb);
810130294554Sphitran 
810230294554Sphitran 	if (cb_arg.rv == -1 || cb_arg.count == 0)
810330294554Sphitran 		return (NULL);
810430294554Sphitran 
810530294554Sphitran 	/* lookup based on a minor name ending with ",raw" */
810630294554Sphitran 	len1 = strlen(minor);
810730294554Sphitran 	for (i = 0; i < cb_arg.count; i++) {
810830294554Sphitran 		len2 = strlen(cb_arg.link_contents[i]);
810930294554Sphitran 		if (len2 >= len1 &&
811030294554Sphitran 		    strcmp(cb_arg.link_contents[i] + len2 - len1,
811130294554Sphitran 		    minor) == 0) {
811230294554Sphitran 			dev_name = s_strdup(cb_arg.dev_names[i]);
811330294554Sphitran 			break;
811430294554Sphitran 		}
811530294554Sphitran 	}
811630294554Sphitran 
811730294554Sphitran 	free_dev_names(&cb_arg);
811830294554Sphitran 
811930294554Sphitran 	if (dev_name == NULL)
812030294554Sphitran 		return (NULL);
812130294554Sphitran 	if (strlen(dev_name) == 0) {
812230294554Sphitran 		free(dev_name);
812330294554Sphitran 		return (NULL);
812430294554Sphitran 	}
812530294554Sphitran 
812630294554Sphitran 	return (dev_name);
812730294554Sphitran }
812830294554Sphitran 
81297c478bd9Sstevel@tonic-gate static char *
81307c478bd9Sstevel@tonic-gate lookup_network_dev_name(char *node_path, char *driver_name)
81317c478bd9Sstevel@tonic-gate {
81327c478bd9Sstevel@tonic-gate 	char *dev_name = NULL;
81337c478bd9Sstevel@tonic-gate 	char phys_path[MAXPATHLEN];
81347c478bd9Sstevel@tonic-gate 
81357c478bd9Sstevel@tonic-gate 	if (lookup_dev_name(node_path, &dev_name) == -1)
81367c478bd9Sstevel@tonic-gate 		return (NULL);
81377c478bd9Sstevel@tonic-gate 
81387c478bd9Sstevel@tonic-gate 	if (dev_name == NULL) {
81397c478bd9Sstevel@tonic-gate 		/* dlpi style-2 only interface */
81407c478bd9Sstevel@tonic-gate 		(void) snprintf(phys_path, sizeof (phys_path),
81417c478bd9Sstevel@tonic-gate 		    "/pseudo/clone@0:%s", driver_name);
81427c478bd9Sstevel@tonic-gate 		if (lookup_dev_name(phys_path, &dev_name) == -1 ||
81437c478bd9Sstevel@tonic-gate 		    dev_name == NULL)
81447c478bd9Sstevel@tonic-gate 			return (NULL);
81457c478bd9Sstevel@tonic-gate 	}
81467c478bd9Sstevel@tonic-gate 
81477c478bd9Sstevel@tonic-gate 	return (dev_name);
81487c478bd9Sstevel@tonic-gate }
81497c478bd9Sstevel@tonic-gate 
8150db11e6feSjacobs static char *
8151db11e6feSjacobs lookup_printer_dev_name(char *node_path)
8152db11e6feSjacobs {
8153db11e6feSjacobs 	struct devlink_cb_arg cb_arg;
8154db11e6feSjacobs 	char *dev_name = NULL;
8155db11e6feSjacobs 	int i;
8156db11e6feSjacobs 
8157db11e6feSjacobs #define	DEV_PRINTERS	"/dev/printers/"
8158db11e6feSjacobs 
8159db11e6feSjacobs 	cb_arg.count = 0;
8160db11e6feSjacobs 	cb_arg.rv = 0;
8161db11e6feSjacobs 	(void) di_devlink_cache_walk(devlink_cache, NULL, node_path,
8162db11e6feSjacobs 	    DI_PRIMARY_LINK, &cb_arg, devlink_cb);
8163db11e6feSjacobs 
8164db11e6feSjacobs 	if (cb_arg.rv == -1 || cb_arg.count == 0)
8165db11e6feSjacobs 		return (NULL);
8166db11e6feSjacobs 
8167db11e6feSjacobs 	/* first try lookup based on /dev/printers name */
8168db11e6feSjacobs 	for (i = 0; i < cb_arg.count; i++) {
8169db11e6feSjacobs 		if (strncmp(cb_arg.dev_names[i], DEV_PRINTERS,
8170db11e6feSjacobs 		    sizeof (DEV_PRINTERS) - 1) == 0) {
8171db11e6feSjacobs 			dev_name = s_strdup(cb_arg.dev_names[i]);
8172db11e6feSjacobs 			break;
8173db11e6feSjacobs 		}
8174db11e6feSjacobs 	}
8175db11e6feSjacobs 
8176db11e6feSjacobs 	/* fallback to the first name */
8177db11e6feSjacobs 	if ((dev_name == NULL) && (cb_arg.count > 0))
8178db11e6feSjacobs 		dev_name = s_strdup(cb_arg.dev_names[0]);
8179db11e6feSjacobs 
8180db11e6feSjacobs 	free_dev_names(&cb_arg);
8181db11e6feSjacobs 
8182db11e6feSjacobs 	return (dev_name);
8183db11e6feSjacobs }
8184db11e6feSjacobs 
81857c478bd9Sstevel@tonic-gate /*
81867c478bd9Sstevel@tonic-gate  * Build an nvlist containing all attributes for devfs events.
81877c478bd9Sstevel@tonic-gate  * Returns nvlist pointer on success, NULL on failure.
81887c478bd9Sstevel@tonic-gate  */
81897c478bd9Sstevel@tonic-gate static nvlist_t *
81907c478bd9Sstevel@tonic-gate build_event_attributes(char *class, char *subclass, char *node_path,
819130294554Sphitran     di_node_t node, char *driver_name, int instance, char *minor)
81927c478bd9Sstevel@tonic-gate {
81937c478bd9Sstevel@tonic-gate 	nvlist_t *nvl;
81947c478bd9Sstevel@tonic-gate 	int err = 0;
81957c478bd9Sstevel@tonic-gate 	di_prop_t prop;
81967c478bd9Sstevel@tonic-gate 	int count;
81977c478bd9Sstevel@tonic-gate 	char *prop_name;
81987c478bd9Sstevel@tonic-gate 	int x;
81997c478bd9Sstevel@tonic-gate 	char *dev_name = NULL;
82007c478bd9Sstevel@tonic-gate 	int dev_name_lookup_err = 0;
82017c478bd9Sstevel@tonic-gate 
82027c478bd9Sstevel@tonic-gate 	if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, 0)) != 0) {
82037c478bd9Sstevel@tonic-gate 		nvl = NULL;
82047c478bd9Sstevel@tonic-gate 		goto out;
82057c478bd9Sstevel@tonic-gate 	}
82067c478bd9Sstevel@tonic-gate 
82077c478bd9Sstevel@tonic-gate 	if ((err = nvlist_add_int32(nvl, EV_VERSION, EV_V1)) != 0)
82087c478bd9Sstevel@tonic-gate 		goto out;
82097c478bd9Sstevel@tonic-gate 
82107c478bd9Sstevel@tonic-gate 	if ((err = nvlist_add_string(nvl, DEV_PHYS_PATH, node_path)) != 0)
82117c478bd9Sstevel@tonic-gate 		goto out;
82127c478bd9Sstevel@tonic-gate 
82137c478bd9Sstevel@tonic-gate 	if (strcmp(class, EC_DEV_ADD) != 0 &&
82147c478bd9Sstevel@tonic-gate 	    strcmp(class, EC_DEV_REMOVE) != 0)
82157c478bd9Sstevel@tonic-gate 		return (nvl);
82167c478bd9Sstevel@tonic-gate 
82177c478bd9Sstevel@tonic-gate 	if (driver_name == NULL || instance == -1)
82187c478bd9Sstevel@tonic-gate 		goto out;
82197c478bd9Sstevel@tonic-gate 
82207c478bd9Sstevel@tonic-gate 	if (strcmp(subclass, ESC_DISK) == 0) {
82217c478bd9Sstevel@tonic-gate 		if ((dev_name = lookup_disk_dev_name(node_path)) == NULL) {
82227c478bd9Sstevel@tonic-gate 			dev_name_lookup_err = 1;
82237c478bd9Sstevel@tonic-gate 			goto out;
82247c478bd9Sstevel@tonic-gate 		}
82257c478bd9Sstevel@tonic-gate 	} else if (strcmp(subclass, ESC_NETWORK) == 0) {
82267c478bd9Sstevel@tonic-gate 		if ((dev_name = lookup_network_dev_name(node_path, driver_name))
82277c478bd9Sstevel@tonic-gate 		    == NULL) {
82287c478bd9Sstevel@tonic-gate 			dev_name_lookup_err = 1;
82297c478bd9Sstevel@tonic-gate 			goto out;
82307c478bd9Sstevel@tonic-gate 		}
8231db11e6feSjacobs 	} else if (strcmp(subclass, ESC_PRINTER) == 0) {
8232db11e6feSjacobs 		if ((dev_name = lookup_printer_dev_name(node_path)) == NULL) {
8233db11e6feSjacobs 			dev_name_lookup_err = 1;
8234db11e6feSjacobs 			goto out;
8235db11e6feSjacobs 		}
823630294554Sphitran 	} else if (strcmp(subclass, ESC_LOFI) == 0) {
823730294554Sphitran 		/*
823830294554Sphitran 		 * The raw minor node is created or removed after the block
823930294554Sphitran 		 * node.  Lofi devfs events are dependent on this behavior.
824030294554Sphitran 		 * Generate the sysevent only for the raw minor node.
824130294554Sphitran 		 */
824230294554Sphitran 		if (strstr(minor, "raw") == NULL) {
824330294554Sphitran 			if (nvl) {
824430294554Sphitran 				nvlist_free(nvl);
824530294554Sphitran 			}
824630294554Sphitran 			return (NULL);
824730294554Sphitran 		}
824830294554Sphitran 		if ((dev_name = lookup_lofi_dev_name(node_path, minor)) ==
824930294554Sphitran 		    NULL) {
825030294554Sphitran 			dev_name_lookup_err = 1;
825130294554Sphitran 			goto out;
825230294554Sphitran 		}
82537c478bd9Sstevel@tonic-gate 	}
82547c478bd9Sstevel@tonic-gate 
82557c478bd9Sstevel@tonic-gate 	if (dev_name) {
82567c478bd9Sstevel@tonic-gate 		if ((err = nvlist_add_string(nvl, DEV_NAME, dev_name)) != 0)
82577c478bd9Sstevel@tonic-gate 			goto out;
82587c478bd9Sstevel@tonic-gate 		free(dev_name);
82597c478bd9Sstevel@tonic-gate 		dev_name = NULL;
82607c478bd9Sstevel@tonic-gate 	}
82617c478bd9Sstevel@tonic-gate 
82627c478bd9Sstevel@tonic-gate 	if ((err = nvlist_add_string(nvl, DEV_DRIVER_NAME, driver_name)) != 0)
82637c478bd9Sstevel@tonic-gate 		goto out;
82647c478bd9Sstevel@tonic-gate 
82657c478bd9Sstevel@tonic-gate 	if ((err = nvlist_add_int32(nvl, DEV_INSTANCE, instance)) != 0)
82667c478bd9Sstevel@tonic-gate 		goto out;
82677c478bd9Sstevel@tonic-gate 
82687c478bd9Sstevel@tonic-gate 	if (strcmp(class, EC_DEV_ADD) == 0) {
82697c478bd9Sstevel@tonic-gate 		/* add properties */
82707c478bd9Sstevel@tonic-gate 		count = 0;
82717c478bd9Sstevel@tonic-gate 		for (prop = di_prop_next(node, DI_PROP_NIL);
82727c478bd9Sstevel@tonic-gate 		    prop != DI_PROP_NIL && count < MAX_PROP_COUNT;
82737c478bd9Sstevel@tonic-gate 		    prop = di_prop_next(node, prop)) {
82747c478bd9Sstevel@tonic-gate 
82757c478bd9Sstevel@tonic-gate 			if (di_prop_devt(prop) != DDI_DEV_T_NONE)
82767c478bd9Sstevel@tonic-gate 				continue;
82777c478bd9Sstevel@tonic-gate 
82787c478bd9Sstevel@tonic-gate 			if ((x = add_property(nvl, prop)) == 0)
82797c478bd9Sstevel@tonic-gate 				count++;
82807c478bd9Sstevel@tonic-gate 			else if (x == -1) {
82817c478bd9Sstevel@tonic-gate 				if ((prop_name = di_prop_name(prop)) == NULL)
82827c478bd9Sstevel@tonic-gate 					prop_name = "";
82837c478bd9Sstevel@tonic-gate 				err_print(PROP_ADD_FAILED, prop_name);
82847c478bd9Sstevel@tonic-gate 				goto out;
82857c478bd9Sstevel@tonic-gate 			}
82867c478bd9Sstevel@tonic-gate 		}
82877c478bd9Sstevel@tonic-gate 	}
82887c478bd9Sstevel@tonic-gate 
82897c478bd9Sstevel@tonic-gate 	return (nvl);
82907c478bd9Sstevel@tonic-gate 
82917c478bd9Sstevel@tonic-gate out:
82927c478bd9Sstevel@tonic-gate 	if (nvl)
82937c478bd9Sstevel@tonic-gate 		nvlist_free(nvl);
82947c478bd9Sstevel@tonic-gate 
82957c478bd9Sstevel@tonic-gate 	if (dev_name)
82967c478bd9Sstevel@tonic-gate 		free(dev_name);
82977c478bd9Sstevel@tonic-gate 
829893239addSjohnlev 	if (dev_name_lookup_err) {
829993239addSjohnlev 		/*
830093239addSjohnlev 		 * If a lofi mount fails, the /devices node may well have
830193239addSjohnlev 		 * disappeared by the time we run, so let's not complain.
830293239addSjohnlev 		 */
830393239addSjohnlev 		if (strcmp(subclass, ESC_LOFI) != 0)
830493239addSjohnlev 			err_print(DEV_NAME_LOOKUP_FAILED, node_path);
830593239addSjohnlev 	} else {
83067c478bd9Sstevel@tonic-gate 		err_print(BUILD_EVENT_ATTR_FAILED, (err) ? strerror(err) : "");
830793239addSjohnlev 	}
83087c478bd9Sstevel@tonic-gate 	return (NULL);
83097c478bd9Sstevel@tonic-gate }
83107c478bd9Sstevel@tonic-gate 
83117c478bd9Sstevel@tonic-gate static void
83127c478bd9Sstevel@tonic-gate log_event(char *class, char *subclass, nvlist_t *nvl)
83137c478bd9Sstevel@tonic-gate {
83147c478bd9Sstevel@tonic-gate 	sysevent_id_t eid;
83157c478bd9Sstevel@tonic-gate 
83167c478bd9Sstevel@tonic-gate 	if (sysevent_post_event(class, subclass, "SUNW", DEVFSADMD,
83177c478bd9Sstevel@tonic-gate 	    nvl, &eid) != 0) {
83187c478bd9Sstevel@tonic-gate 		err_print(LOG_EVENT_FAILED, strerror(errno));
83197c478bd9Sstevel@tonic-gate 	}
83207c478bd9Sstevel@tonic-gate }
83217c478bd9Sstevel@tonic-gate 
8322f05faa4eSjacobs /*
8323f05faa4eSjacobs  * When devfsadmd needs to generate sysevents, they are queued for later
8324f05faa4eSjacobs  * delivery this allows them to be delivered after the devlinks db cache has
8325f05faa4eSjacobs  * been flushed guaranteeing that applications consuming these events have
8326f05faa4eSjacobs  * access to an accurate devlinks db.  The queue is a FIFO, sysevents to be
8327f05faa4eSjacobs  * inserted in the front of the queue and consumed off the back.
8328f05faa4eSjacobs  */
8329f05faa4eSjacobs static void
8330f05faa4eSjacobs enqueue_sysevent(char *class, char *subclass, nvlist_t *nvl)
8331f05faa4eSjacobs {
8332f05faa4eSjacobs 	syseventq_t *tmp;
8333f05faa4eSjacobs 
8334f05faa4eSjacobs 	if ((tmp = s_zalloc(sizeof (*tmp))) == NULL)
8335f05faa4eSjacobs 		return;
8336f05faa4eSjacobs 
8337f05faa4eSjacobs 	tmp->class = s_strdup(class);
8338f05faa4eSjacobs 	tmp->subclass = s_strdup(subclass);
8339f05faa4eSjacobs 	tmp->nvl = nvl;
8340f05faa4eSjacobs 
8341f05faa4eSjacobs 	(void) mutex_lock(&syseventq_mutex);
8342f05faa4eSjacobs 	if (syseventq_front != NULL)
8343f05faa4eSjacobs 		syseventq_front->next = tmp;
8344f05faa4eSjacobs 	else
8345f05faa4eSjacobs 		syseventq_back = tmp;
8346f05faa4eSjacobs 	syseventq_front = tmp;
8347f05faa4eSjacobs 	(void) mutex_unlock(&syseventq_mutex);
8348f05faa4eSjacobs }
8349f05faa4eSjacobs 
8350f05faa4eSjacobs static void
8351f05faa4eSjacobs process_syseventq()
8352f05faa4eSjacobs {
8353f05faa4eSjacobs 	(void) mutex_lock(&syseventq_mutex);
8354f05faa4eSjacobs 	while (syseventq_back != NULL) {
8355f05faa4eSjacobs 		syseventq_t *tmp = syseventq_back;
8356f05faa4eSjacobs 
8357f05faa4eSjacobs 		vprint(CHATTY_MID, "sending queued event: %s, %s\n",
83580a653502Swroche 		    tmp->class, tmp->subclass);
8359f05faa4eSjacobs 
8360f05faa4eSjacobs 		log_event(tmp->class, tmp->subclass, tmp->nvl);
8361f05faa4eSjacobs 
8362f05faa4eSjacobs 		if (tmp->class != NULL)
8363f05faa4eSjacobs 			free(tmp->class);
8364f05faa4eSjacobs 		if (tmp->subclass != NULL)
8365f05faa4eSjacobs 			free(tmp->subclass);
8366f05faa4eSjacobs 		if (tmp->nvl != NULL)
8367f05faa4eSjacobs 			nvlist_free(tmp->nvl);
8368f05faa4eSjacobs 		syseventq_back = syseventq_back->next;
8369f05faa4eSjacobs 		if (syseventq_back == NULL)
8370f05faa4eSjacobs 			syseventq_front = NULL;
8371f05faa4eSjacobs 		free(tmp);
8372f05faa4eSjacobs 	}
8373f05faa4eSjacobs 	(void) mutex_unlock(&syseventq_mutex);
8374f05faa4eSjacobs }
8375f05faa4eSjacobs 
83767c478bd9Sstevel@tonic-gate static void
8377f05faa4eSjacobs build_and_enq_event(char *class, char *subclass, char *node_path,
837830294554Sphitran 	di_node_t node, char *minor)
83797c478bd9Sstevel@tonic-gate {
83807c478bd9Sstevel@tonic-gate 	nvlist_t *nvl;
83817c478bd9Sstevel@tonic-gate 
8382f05faa4eSjacobs 	vprint(CHATTY_MID, "build_and_enq_event(%s, %s, %s, 0x%8.8x)\n",
83830a653502Swroche 	    class, subclass, node_path, (int)node);
8384f05faa4eSjacobs 
83857c478bd9Sstevel@tonic-gate 	if (node != DI_NODE_NIL)
83867c478bd9Sstevel@tonic-gate 		nvl = build_event_attributes(class, subclass, node_path, node,
838730294554Sphitran 		    di_driver_name(node), di_instance(node), minor);
83887c478bd9Sstevel@tonic-gate 	else
83897c478bd9Sstevel@tonic-gate 		nvl = build_event_attributes(class, subclass, node_path, node,
839030294554Sphitran 		    NULL, -1, minor);
83917c478bd9Sstevel@tonic-gate 
83927c478bd9Sstevel@tonic-gate 	if (nvl) {
8393f05faa4eSjacobs 		enqueue_sysevent(class, subclass, nvl);
83947c478bd9Sstevel@tonic-gate 	}
83957c478bd9Sstevel@tonic-gate }
8396facf4a8dSllai 
83971ca93273Seota /*
83981ca93273Seota  * is_blank() returns 1 (true) if a line specified is composed of
83991ca93273Seota  * whitespace characters only. otherwise, it returns 0 (false).
84001ca93273Seota  *
84011ca93273Seota  * Note. the argument (line) must be null-terminated.
84021ca93273Seota  */
84031ca93273Seota static int
84041ca93273Seota is_blank(char *line)
84051ca93273Seota {
84061ca93273Seota 	for (/* nothing */; *line != '\0'; line++)
84071ca93273Seota 		if (!isspace(*line))
84081ca93273Seota 			return (0);
84091ca93273Seota 	return (1);
84101ca93273Seota }
84111ca93273Seota 
8412aa646b9dSvikram /*
8413aa646b9dSvikram  * Functions to deal with the no-further-processing hash
8414aa646b9dSvikram  */
8415aa646b9dSvikram 
8416aa646b9dSvikram static void
8417aa646b9dSvikram nfphash_create(void)
8418aa646b9dSvikram {
8419aa646b9dSvikram 	assert(nfp_hash == NULL);
8420aa646b9dSvikram 	nfp_hash = s_zalloc(NFP_HASH_SZ * sizeof (item_t *));
8421aa646b9dSvikram }
8422aa646b9dSvikram 
8423aa646b9dSvikram static int
8424aa646b9dSvikram nfphash_fcn(char *key)
8425aa646b9dSvikram {
8426aa646b9dSvikram 	int i;
8427aa646b9dSvikram 	uint64_t sum = 0;
8428aa646b9dSvikram 
8429aa646b9dSvikram 	for (i = 0; key[i] != '\0'; i++) {
8430aa646b9dSvikram 		sum += (uchar_t)key[i];
8431aa646b9dSvikram 	}
8432aa646b9dSvikram 
8433aa646b9dSvikram 	return (sum % NFP_HASH_SZ);
8434aa646b9dSvikram }
8435aa646b9dSvikram 
8436aa646b9dSvikram static item_t *
8437aa646b9dSvikram nfphash_lookup(char *key)
8438aa646b9dSvikram {
8439aa646b9dSvikram 	int	index;
8440aa646b9dSvikram 	item_t  *ip;
8441aa646b9dSvikram 
8442aa646b9dSvikram 	index = nfphash_fcn(key);
8443aa646b9dSvikram 
8444aa646b9dSvikram 	assert(index >= 0);
8445aa646b9dSvikram 
8446aa646b9dSvikram 	for (ip = nfp_hash[index]; ip; ip = ip->i_next) {
8447aa646b9dSvikram 		if (strcmp(ip->i_key, key) == 0)
8448aa646b9dSvikram 			return (ip);
8449aa646b9dSvikram 	}
8450aa646b9dSvikram 
8451aa646b9dSvikram 	return (NULL);
8452aa646b9dSvikram }
8453aa646b9dSvikram 
8454aa646b9dSvikram static void
8455aa646b9dSvikram nfphash_insert(char *key)
8456aa646b9dSvikram {
8457aa646b9dSvikram 	item_t	*ip;
8458aa646b9dSvikram 	int	index;
8459aa646b9dSvikram 
8460aa646b9dSvikram 	index = nfphash_fcn(key);
8461aa646b9dSvikram 
8462aa646b9dSvikram 	assert(index >= 0);
8463aa646b9dSvikram 
8464aa646b9dSvikram 	ip = s_zalloc(sizeof (item_t));
8465aa646b9dSvikram 	ip->i_key = s_strdup(key);
8466aa646b9dSvikram 
8467aa646b9dSvikram 	ip->i_next = nfp_hash[index];
8468aa646b9dSvikram 	nfp_hash[index] = ip;
8469aa646b9dSvikram }
8470aa646b9dSvikram 
8471aa646b9dSvikram static void
8472aa646b9dSvikram nfphash_destroy(void)
8473aa646b9dSvikram {
8474aa646b9dSvikram 	int	i;
8475aa646b9dSvikram 	item_t	*ip;
8476aa646b9dSvikram 
8477aa646b9dSvikram 	for (i = 0; i < NFP_HASH_SZ; i++) {
8478aa646b9dSvikram 		/*LINTED*/
8479aa646b9dSvikram 		while (ip = nfp_hash[i]) {
8480aa646b9dSvikram 			nfp_hash[i] = ip->i_next;
8481aa646b9dSvikram 			free(ip->i_key);
8482aa646b9dSvikram 			free(ip);
8483aa646b9dSvikram 		}
8484aa646b9dSvikram 	}
8485aa646b9dSvikram 
8486aa646b9dSvikram 	free(nfp_hash);
8487aa646b9dSvikram 	nfp_hash = NULL;
8488aa646b9dSvikram }
8489aa646b9dSvikram 
8490facf4a8dSllai static int
8491facf4a8dSllai devname_kcall(int subcmd, void *args)
8492facf4a8dSllai {
8493facf4a8dSllai 	int error = 0;
8494facf4a8dSllai 
8495facf4a8dSllai 	switch (subcmd) {
8496facf4a8dSllai 	case MODDEVNAME_LOOKUPDOOR:
8497facf4a8dSllai 		error = modctl(MODDEVNAME, subcmd, (uintptr_t)args);
8498facf4a8dSllai 		if (error) {
8499facf4a8dSllai 			vprint(INFO_MID, "modctl(MODDEVNAME, "
8500facf4a8dSllai 			    "MODDEVNAME_LOOKUPDOOR) failed - %s\n",
8501facf4a8dSllai 			    strerror(errno));
8502facf4a8dSllai 		}
8503facf4a8dSllai 		break;
8504facf4a8dSllai 	default:
8505facf4a8dSllai 		error = EINVAL;
8506facf4a8dSllai 		break;
8507facf4a8dSllai 	}
8508facf4a8dSllai 	return (error);
8509facf4a8dSllai }
8510facf4a8dSllai 
8511facf4a8dSllai /* ARGSUSED */
8512facf4a8dSllai static void
8513facf4a8dSllai devname_lookup_handler(void *cookie, char *argp, size_t arg_size,
8514facf4a8dSllai     door_desc_t *dp, uint_t n_desc)
8515facf4a8dSllai {
8516facf4a8dSllai 	int32_t error = 0;
8517facf4a8dSllai 	door_cred_t dcred;
8518facf4a8dSllai 	struct dca_impl	dci;
8519facf4a8dSllai 	uint8_t	cmd;
8520facf4a8dSllai 	sdev_door_res_t res;
8521facf4a8dSllai 	sdev_door_arg_t *args;
8522facf4a8dSllai 
8523facf4a8dSllai 	if (argp == NULL || arg_size == 0) {
8524facf4a8dSllai 		vprint(DEVNAME_MID, "devname_lookup_handler: argp wrong\n");
8525facf4a8dSllai 		error = DEVFSADM_RUN_INVALID;
8526facf4a8dSllai 		goto done;
8527facf4a8dSllai 	}
8528facf4a8dSllai 	vprint(DEVNAME_MID, "devname_lookup_handler\n");
8529facf4a8dSllai 
8530facf4a8dSllai 	if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) {
8531facf4a8dSllai 		vprint(DEVNAME_MID, "devname_lookup_handler: cred wrong\n");
8532facf4a8dSllai 		error = DEVFSADM_RUN_EPERM;
8533facf4a8dSllai 		goto done;
8534facf4a8dSllai 	}
8535facf4a8dSllai 
8536facf4a8dSllai 	args = (sdev_door_arg_t *)argp;
8537facf4a8dSllai 	cmd = args->devfsadm_cmd;
8538facf4a8dSllai 
8539facf4a8dSllai 	vprint(DEVNAME_MID, "devname_lookup_handler: cmd %d\n", cmd);
8540facf4a8dSllai 	switch (cmd) {
8541facf4a8dSllai 	case DEVFSADMD_RUN_ALL:
8542facf4a8dSllai 		/*
8543facf4a8dSllai 		 * run "devfsadm"
8544facf4a8dSllai 		 */
8545facf4a8dSllai 		dci.dci_root = "/";
8546facf4a8dSllai 		dci.dci_minor = NULL;
8547facf4a8dSllai 		dci.dci_driver = NULL;
8548facf4a8dSllai 		dci.dci_error = 0;
8549facf4a8dSllai 		dci.dci_flags = 0;
8550facf4a8dSllai 		dci.dci_arg = NULL;
8551facf4a8dSllai 
8552facf4a8dSllai 		lock_dev();
8553c9cc1492SJerry Gilliam 		update_drvconf((major_t)-1, 0);
8554facf4a8dSllai 		dci.dci_flags |= DCA_FLUSH_PATHINST;
8555facf4a8dSllai 
8556facf4a8dSllai 		pre_and_post_cleanup(RM_PRE);
855766ea8494SVikram Hegde 		devi_tree_walk(&dci, DI_CACHE_SNAPSHOT_FLAGS, NULL);
8558facf4a8dSllai 		error = (int32_t)dci.dci_error;
8559facf4a8dSllai 		if (!error) {
8560facf4a8dSllai 			pre_and_post_cleanup(RM_POST);
8561facf4a8dSllai 			update_database = TRUE;
8562facf4a8dSllai 			unlock_dev(SYNC_STATE);
8563facf4a8dSllai 			update_database = FALSE;
8564facf4a8dSllai 		} else {
8565facf4a8dSllai 			if (DEVFSADM_DEBUG_ON) {
8566facf4a8dSllai 				vprint(INFO_MID, "devname_lookup_handler: "
8567facf4a8dSllai 				    "DEVFSADMD_RUN_ALL failed\n");
8568facf4a8dSllai 			}
8569facf4a8dSllai 
8570facf4a8dSllai 			unlock_dev(SYNC_STATE);
8571facf4a8dSllai 		}
8572facf4a8dSllai 		break;
8573facf4a8dSllai 	default:
8574facf4a8dSllai 		/* log an error here? */
8575facf4a8dSllai 		error = DEVFSADM_RUN_NOTSUP;
8576facf4a8dSllai 		break;
8577facf4a8dSllai 	}
8578facf4a8dSllai 
8579facf4a8dSllai done:
8580facf4a8dSllai 	vprint(DEVNAME_MID, "devname_lookup_handler: error %d\n", error);
8581facf4a8dSllai 	res.devfsadm_error = error;
8582facf4a8dSllai 	(void) door_return((char *)&res, sizeof (struct sdev_door_res),
8583facf4a8dSllai 	    NULL, 0);
8584facf4a8dSllai }
85858d483882Smlf 
85868d483882Smlf 
85878d483882Smlf di_devlink_handle_t
85888d483882Smlf devfsadm_devlink_cache(void)
85898d483882Smlf {
85908d483882Smlf 	return (devlink_cache);
85918d483882Smlf }
85928d483882Smlf 
85938d483882Smlf int
85948d483882Smlf devfsadm_reserve_id_cache(devlink_re_t re_array[], enumerate_file_t *head)
85958d483882Smlf {
85968d483882Smlf 	enumerate_file_t *entry;
85978d483882Smlf 	int nelem;
85988d483882Smlf 	int i;
85998d483882Smlf 	int subex;
86008d483882Smlf 	char *re;
86018d483882Smlf 	size_t size;
86028d483882Smlf 	regmatch_t *pmch;
86038d483882Smlf 
86048d483882Smlf 	/*
86058d483882Smlf 	 * Check the <RE, subexp> array passed in and compile it.
86068d483882Smlf 	 */
86078d483882Smlf 	for (i = 0; re_array[i].d_re; i++) {
86088d483882Smlf 		if (re_array[i].d_subexp == 0) {
86098d483882Smlf 			err_print("bad subexp value in RE: %s\n",
86108d483882Smlf 			    re_array[i].d_re);
86118d483882Smlf 			goto bad_re;
86128d483882Smlf 		}
86138d483882Smlf 
86148d483882Smlf 		re = re_array[i].d_re;
86158d483882Smlf 		if (regcomp(&re_array[i].d_rcomp, re, REG_EXTENDED) != 0) {
86168d483882Smlf 			err_print("reg. exp. failed to compile: %s\n", re);
86178d483882Smlf 			goto bad_re;
86188d483882Smlf 		}
86198d483882Smlf 		subex = re_array[i].d_subexp;
86208d483882Smlf 		nelem = subex + 1;
86218d483882Smlf 		re_array[i].d_pmatch = s_malloc(sizeof (regmatch_t) * nelem);
86228d483882Smlf 	}
86238d483882Smlf 
86248d483882Smlf 	entry = head ? head : enumerate_reserved;
86258d483882Smlf 	for (; entry; entry = entry->er_next) {
86268d483882Smlf 		if (entry->er_id) {
86278d483882Smlf 			vprint(RSBY_MID, "entry %s already has ID %s\n",
86288d483882Smlf 			    entry->er_file, entry->er_id);
86298d483882Smlf 			continue;
86308d483882Smlf 		}
86318d483882Smlf 		for (i = 0; re_array[i].d_re; i++) {
86328d483882Smlf 			subex = re_array[i].d_subexp;
86338d483882Smlf 			pmch = re_array[i].d_pmatch;
86348d483882Smlf 			if (regexec(&re_array[i].d_rcomp, entry->er_file,
86358d483882Smlf 			    subex + 1, pmch, 0) != 0) {
86368d483882Smlf 				/* No match */
86378d483882Smlf 				continue;
86388d483882Smlf 			}
86398d483882Smlf 			size = pmch[subex].rm_eo - pmch[subex].rm_so;
86408d483882Smlf 			entry->er_id = s_malloc(size + 1);
86418d483882Smlf 			(void) strncpy(entry->er_id,
86428d483882Smlf 			    &entry->er_file[pmch[subex].rm_so], size);
86438d483882Smlf 			entry->er_id[size] = '\0';
86448d483882Smlf 			if (head) {
86458d483882Smlf 				vprint(RSBY_MID, "devlink(%s) matches RE(%s). "
86468d483882Smlf 				    "ID is %s\n", entry->er_file,
86478d483882Smlf 				    re_array[i].d_re, entry->er_id);
86488d483882Smlf 			} else {
86498d483882Smlf 				vprint(RSBY_MID, "rsrv entry(%s) matches "
86508d483882Smlf 				    "RE(%s) ID is %s\n", entry->er_file,
86518d483882Smlf 				    re_array[i].d_re, entry->er_id);
86528d483882Smlf 			}
86538d483882Smlf 			break;
86548d483882Smlf 		}
86558d483882Smlf 	}
86568d483882Smlf 
86578d483882Smlf 	for (i = 0; re_array[i].d_re; i++) {
86588d483882Smlf 		regfree(&re_array[i].d_rcomp);
86598d483882Smlf 		assert(re_array[i].d_pmatch);
86608d483882Smlf 		free(re_array[i].d_pmatch);
86618d483882Smlf 	}
86628d483882Smlf 
86638d483882Smlf 	entry = head ? head : enumerate_reserved;
86648d483882Smlf 	for (; entry; entry = entry->er_next) {
86658d483882Smlf 		if (entry->er_id == NULL)
86668d483882Smlf 			continue;
86678d483882Smlf 		if (head) {
86688d483882Smlf 			vprint(RSBY_MID, "devlink: %s\n", entry->er_file);
86698d483882Smlf 			vprint(RSBY_MID, "ID: %s\n", entry->er_id);
86708d483882Smlf 		} else {
86718d483882Smlf 			vprint(RSBY_MID, "reserve file entry: %s\n",
86728d483882Smlf 			    entry->er_file);
86738d483882Smlf 			vprint(RSBY_MID, "reserve file id: %s\n",
86748d483882Smlf 			    entry->er_id);
86758d483882Smlf 		}
86768d483882Smlf 	}
86778d483882Smlf 
86788d483882Smlf 	return (DEVFSADM_SUCCESS);
86798d483882Smlf 
86808d483882Smlf bad_re:
86818d483882Smlf 	for (i = i-1; i >= 0; i--) {
86828d483882Smlf 		regfree(&re_array[i].d_rcomp);
86838d483882Smlf 		assert(re_array[i].d_pmatch);
86848d483882Smlf 		free(re_array[i].d_pmatch);
86858d483882Smlf 	}
86868d483882Smlf 	return (DEVFSADM_FAILURE);
86878d483882Smlf }
8688e37c6c37Scth 
8689e37c6c37Scth /*
8690e37c6c37Scth  * Return 1 if we have reserved links.
8691e37c6c37Scth  */
8692e37c6c37Scth int
8693e37c6c37Scth devfsadm_have_reserved()
8694e37c6c37Scth {
8695e37c6c37Scth 	return (enumerate_reserved ? 1 : 0);
8696e37c6c37Scth }
86978d483882Smlf 
86988d483882Smlf /*
86998d483882Smlf  * This functions errs on the side of caution. If there is any error
87008d483882Smlf  * we assume that the devlink is  *not* reserved
87018d483882Smlf  */
87028d483882Smlf int
87038d483882Smlf devfsadm_is_reserved(devlink_re_t re_array[], char *devlink)
87048d483882Smlf {
87058d483882Smlf 	int match;
87068d483882Smlf 	enumerate_file_t estruct = {NULL};
87078d483882Smlf 	enumerate_file_t *entry;
87088d483882Smlf 
87098d483882Smlf 	match = 0;
87108d483882Smlf 	estruct.er_file = devlink;
87118d483882Smlf 	estruct.er_id = NULL;
87128d483882Smlf 	estruct.er_next = NULL;
87138d483882Smlf 
87148d483882Smlf 	if (devfsadm_reserve_id_cache(re_array, &estruct) != DEVFSADM_SUCCESS) {
87158d483882Smlf 		err_print("devfsadm_is_reserved: devlink (%s) does not "
87168d483882Smlf 		    "match RE\n", devlink);
87178d483882Smlf 		return (0);
87188d483882Smlf 	}
87198d483882Smlf 	if (estruct.er_id == NULL) {
87208d483882Smlf 		err_print("devfsadm_is_reserved: ID derived from devlink %s "
87218d483882Smlf 		    "is NULL\n", devlink);
87228d483882Smlf 		return (0);
87238d483882Smlf 	}
87248d483882Smlf 
87258d483882Smlf 	entry = enumerate_reserved;
87268d483882Smlf 	for (; entry; entry = entry->er_next) {
87278d483882Smlf 		if (entry->er_id == NULL)
87288d483882Smlf 			continue;
87298d483882Smlf 		if (strcmp(entry->er_id, estruct.er_id) != 0)
87308d483882Smlf 			continue;
87318d483882Smlf 		match = 1;
87328d483882Smlf 		vprint(RSBY_MID, "reserve file entry (%s) and devlink (%s) "
87338d483882Smlf 		    "match\n", entry->er_file, devlink);
87348d483882Smlf 		break;
87358d483882Smlf 	}
87368d483882Smlf 
87378d483882Smlf 	free(estruct.er_id);
87388d483882Smlf 	return (match);
87398d483882Smlf }
8740