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