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