17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5055e805aSedp * Common Development and Distribution License (the "License"). 6055e805aSedp * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21055e805aSedp 227c478bd9Sstevel@tonic-gate /* 23d62bc4baSyz * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * Devfsadm replaces drvconfig, audlinks, disks, tapes, ports, devlinks 317c478bd9Sstevel@tonic-gate * as a general purpose device administrative utility. It creates 327c478bd9Sstevel@tonic-gate * devices special files in /devices and logical links in /dev, and 337c478bd9Sstevel@tonic-gate * coordinates updates to /etc/path_to_instance with the kernel. It 347c478bd9Sstevel@tonic-gate * operates in both command line mode to handle user or script invoked 357c478bd9Sstevel@tonic-gate * reconfiguration updates, and operates in daemon mode to handle dynamic 367c478bd9Sstevel@tonic-gate * reconfiguration for hotplugging support. 377c478bd9Sstevel@tonic-gate */ 387c478bd9Sstevel@tonic-gate 3945916cd2Sjpk #include <string.h> 40f875b4ebSrica #include <deflt.h> 4145916cd2Sjpk #include <tsol/label.h> 4245916cd2Sjpk #include <bsm/devices.h> 4345916cd2Sjpk #include <bsm/devalloc.h> 447c478bd9Sstevel@tonic-gate #include <utime.h> 456638bf60Saj #include <sys/param.h> 466638bf60Saj #include <bsm/libbsm.h> 4745916cd2Sjpk #include "devfsadm_impl.h" 487c478bd9Sstevel@tonic-gate 4945916cd2Sjpk /* externs from devalloc.c */ 5045916cd2Sjpk extern void _reset_devalloc(int); 5145916cd2Sjpk extern void _update_devalloc_db(devlist_t *, int, int, char *, char *); 5245916cd2Sjpk extern int _da_check_for_usb(char *, char *); 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate /* create or remove nodes or links. unset with -n */ 557c478bd9Sstevel@tonic-gate static int file_mods = TRUE; 567c478bd9Sstevel@tonic-gate 577c478bd9Sstevel@tonic-gate /* cleanup mode. Set with -C */ 587c478bd9Sstevel@tonic-gate static int cleanup = FALSE; 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate /* devlinks -d compatibility */ 617c478bd9Sstevel@tonic-gate static int devlinks_debug = FALSE; 627c478bd9Sstevel@tonic-gate 6345916cd2Sjpk /* flag to check if system is labeled */ 6445916cd2Sjpk int system_labeled = FALSE; 6545916cd2Sjpk 6645916cd2Sjpk /* flag to enable/disable device allocation with -e/-d */ 6745916cd2Sjpk static int devalloc_flag = 0; 6845916cd2Sjpk 696638bf60Saj /* flag that indicates if device allocation is on or not */ 706638bf60Saj static int devalloc_is_on = 0; 716638bf60Saj 7245916cd2Sjpk /* flag to update device allocation database for this device type */ 7345916cd2Sjpk static int update_devdb = 0; 7445916cd2Sjpk 7545916cd2Sjpk /* 7645916cd2Sjpk * devices to be deallocated with -d : 7745916cd2Sjpk * audio, floppy, cd, floppy, tape, rmdisk. 7845916cd2Sjpk */ 7945916cd2Sjpk static char *devalloc_list[10] = {DDI_NT_AUDIO, DDI_NT_CD, DDI_NT_CD_CHAN, 8045916cd2Sjpk DDI_NT_FD, DDI_NT_TAPE, DDI_NT_BLOCK_CHAN, 8145916cd2Sjpk DDI_NT_UGEN, DDI_NT_USB_ATTACHMENT_POINT, 8245916cd2Sjpk DDI_NT_SCSI_NEXUS, NULL}; 837c478bd9Sstevel@tonic-gate 8445916cd2Sjpk /* list of allocatable devices */ 8545916cd2Sjpk static devlist_t devlist; 867c478bd9Sstevel@tonic-gate 877c478bd9Sstevel@tonic-gate /* load a single driver only. set with -i */ 887c478bd9Sstevel@tonic-gate static int single_drv = FALSE; 897c478bd9Sstevel@tonic-gate static char *driver = NULL; 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate /* attempt to load drivers or defer attach nodes */ 927c478bd9Sstevel@tonic-gate static int load_attach_drv = TRUE; 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate /* set if invoked via /usr/lib/devfsadm/devfsadmd */ 957c478bd9Sstevel@tonic-gate static int daemon_mode = FALSE; 967c478bd9Sstevel@tonic-gate 977c478bd9Sstevel@tonic-gate /* output directed to syslog during daemon mode if set */ 987c478bd9Sstevel@tonic-gate static int logflag = FALSE; 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate /* build links in /dev. -x to turn off */ 1017c478bd9Sstevel@tonic-gate static int build_dev = TRUE; 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate /* build nodes in /devices. -y to turn off */ 1047c478bd9Sstevel@tonic-gate static int build_devices = TRUE; 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate /* -z to turn off */ 1077c478bd9Sstevel@tonic-gate static int flush_path_to_inst_enable = TRUE; 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate /* variables used for path_to_inst flushing */ 1107c478bd9Sstevel@tonic-gate static int inst_count = 0; 1117c478bd9Sstevel@tonic-gate static mutex_t count_lock; 1127c478bd9Sstevel@tonic-gate static cond_t cv; 1137c478bd9Sstevel@tonic-gate 114ff2aee48Scth /* variables for minor_fini thread */ 1157c478bd9Sstevel@tonic-gate static mutex_t minor_fini_mutex; 116ff2aee48Scth static int minor_fini_canceled = TRUE; 117ff2aee48Scth static int minor_fini_delayed = FALSE; 118ff2aee48Scth static cond_t minor_fini_cv; 119ff2aee48Scth static int minor_fini_timeout = MINOR_FINI_TIMEOUT_DEFAULT; 1207c478bd9Sstevel@tonic-gate 1217c478bd9Sstevel@tonic-gate /* single-threads /dev modification */ 1227c478bd9Sstevel@tonic-gate static sema_t dev_sema; 1237c478bd9Sstevel@tonic-gate 1247c478bd9Sstevel@tonic-gate /* the program we were invoked as; ie argv[0] */ 1257c478bd9Sstevel@tonic-gate static char *prog; 1267c478bd9Sstevel@tonic-gate 1277c478bd9Sstevel@tonic-gate /* pointers to create/remove link lists */ 1287c478bd9Sstevel@tonic-gate static create_list_t *create_head = NULL; 1297c478bd9Sstevel@tonic-gate static remove_list_t *remove_head = NULL; 1307c478bd9Sstevel@tonic-gate 1317c478bd9Sstevel@tonic-gate /* supports the class -c option */ 1327c478bd9Sstevel@tonic-gate static char **classes = NULL; 1337c478bd9Sstevel@tonic-gate static int num_classes = 0; 1347c478bd9Sstevel@tonic-gate 1357c478bd9Sstevel@tonic-gate /* used with verbose option -v or -V */ 1367c478bd9Sstevel@tonic-gate static int num_verbose = 0; 1377c478bd9Sstevel@tonic-gate static char **verbose = NULL; 1387c478bd9Sstevel@tonic-gate 1397c478bd9Sstevel@tonic-gate static struct mperm *minor_perms = NULL; 1407c478bd9Sstevel@tonic-gate static driver_alias_t *driver_aliases = NULL; 1417c478bd9Sstevel@tonic-gate 1427c478bd9Sstevel@tonic-gate /* set if -r alternate root given */ 1437c478bd9Sstevel@tonic-gate static char *root_dir = ""; 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate /* /devices or <rootdir>/devices */ 1467c478bd9Sstevel@tonic-gate static char *devices_dir = DEVICES; 1477c478bd9Sstevel@tonic-gate 1487c478bd9Sstevel@tonic-gate /* /dev or <rootdir>/dev */ 1497c478bd9Sstevel@tonic-gate static char *dev_dir = DEV; 1507c478bd9Sstevel@tonic-gate 151facf4a8dSllai /* /etc/dev or <rootdir>/etc/dev */ 152facf4a8dSllai static char *etc_dev_dir = ETCDEV; 153facf4a8dSllai 154facf4a8dSllai /* 155facf4a8dSllai * writable root (for lock files and doors during install). 156facf4a8dSllai * This is also root dir for /dev attr dir during install. 157facf4a8dSllai */ 158facf4a8dSllai static char *attr_root = NULL; 1597c478bd9Sstevel@tonic-gate 1607c478bd9Sstevel@tonic-gate /* /etc/path_to_inst unless -p used */ 1617c478bd9Sstevel@tonic-gate static char *inst_file = INSTANCE_FILE; 1627c478bd9Sstevel@tonic-gate 1637c478bd9Sstevel@tonic-gate /* /usr/lib/devfsadm/linkmods unless -l used */ 1647c478bd9Sstevel@tonic-gate static char *module_dirs = MODULE_DIRS; 1657c478bd9Sstevel@tonic-gate 1667c478bd9Sstevel@tonic-gate /* default uid/gid used if /etc/minor_perm entry not found */ 1677c478bd9Sstevel@tonic-gate static uid_t root_uid; 1687c478bd9Sstevel@tonic-gate static gid_t sys_gid; 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate /* /etc/devlink.tab unless devlinks -t used */ 1717c478bd9Sstevel@tonic-gate static char *devlinktab_file = NULL; 1727c478bd9Sstevel@tonic-gate 1738d483882Smlf /* File and data structure to reserve enumerate IDs */ 1748d483882Smlf static char *enumerate_file = ENUMERATE_RESERVED; 1758d483882Smlf static enumerate_file_t *enumerate_reserved = NULL; 1768d483882Smlf 1777c478bd9Sstevel@tonic-gate /* set if /dev link is new. speeds up rm_stale_links */ 1787c478bd9Sstevel@tonic-gate static int linknew = TRUE; 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate /* variables for devlink.tab compat processing */ 1817c478bd9Sstevel@tonic-gate static devlinktab_list_t *devlinktab_list = NULL; 1827c478bd9Sstevel@tonic-gate static unsigned int devlinktab_line = 0; 1837c478bd9Sstevel@tonic-gate 1847c478bd9Sstevel@tonic-gate /* cache head for devfsadm_enumerate*() functions */ 1857c478bd9Sstevel@tonic-gate static numeral_set_t *head_numeral_set = NULL; 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate /* list list of devfsadm modules */ 1887c478bd9Sstevel@tonic-gate static module_t *module_head = NULL; 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate /* name_to_major list used in utility function */ 1917c478bd9Sstevel@tonic-gate static n2m_t *n2m_list = NULL; 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate /* cache of some links used for performance */ 1947c478bd9Sstevel@tonic-gate static linkhead_t *headlinkhead = NULL; 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate /* locking variables to prevent multiples writes to /dev */ 1977c478bd9Sstevel@tonic-gate static int hold_dev_lock = FALSE; 1987c478bd9Sstevel@tonic-gate static int hold_daemon_lock = FALSE; 1997c478bd9Sstevel@tonic-gate static int dev_lock_fd; 2007c478bd9Sstevel@tonic-gate static int daemon_lock_fd; 2017c478bd9Sstevel@tonic-gate static char dev_lockfile[PATH_MAX + 1]; 2027c478bd9Sstevel@tonic-gate static char daemon_lockfile[PATH_MAX + 1]; 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate /* last devinfo node/minor processed. used for performance */ 2057c478bd9Sstevel@tonic-gate static di_node_t lnode; 2067c478bd9Sstevel@tonic-gate static di_minor_t lminor; 2077c478bd9Sstevel@tonic-gate static char lphy_path[PATH_MAX + 1] = {""}; 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate /* Globals used by the link database */ 2107c478bd9Sstevel@tonic-gate static di_devlink_handle_t devlink_cache; 2117c478bd9Sstevel@tonic-gate static int update_database = FALSE; 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate /* Globals used to set logindev perms */ 2147c478bd9Sstevel@tonic-gate static struct login_dev *login_dev_cache = NULL; 2157c478bd9Sstevel@tonic-gate static int login_dev_enable = FALSE; 2167c478bd9Sstevel@tonic-gate 2177c478bd9Sstevel@tonic-gate /* Global to use devinfo snapshot cache */ 2187c478bd9Sstevel@tonic-gate static int use_snapshot_cache = FALSE; 2197c478bd9Sstevel@tonic-gate 220aa646b9dSvikram /* Global for no-further-processing hash */ 221aa646b9dSvikram static item_t **nfp_hash; 222aa646b9dSvikram static mutex_t nfp_mutex = DEFAULTMUTEX; 223aa646b9dSvikram 2247c478bd9Sstevel@tonic-gate /* 2257c478bd9Sstevel@tonic-gate * Packaged directories - not removed even when empty. 2267c478bd9Sstevel@tonic-gate * The dirs must be listed in canonical form 2277c478bd9Sstevel@tonic-gate * i.e. without leading "/dev/" 2287c478bd9Sstevel@tonic-gate */ 2297c478bd9Sstevel@tonic-gate static char *packaged_dirs[] = 2307c478bd9Sstevel@tonic-gate {"dsk", "rdsk", "term", NULL}; 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate /* RCM related globals */ 2337c478bd9Sstevel@tonic-gate static void *librcm_hdl; 2347c478bd9Sstevel@tonic-gate static rcm_handle_t *rcm_hdl = NULL; 2357c478bd9Sstevel@tonic-gate static thread_t process_rcm_events_tid; 2367c478bd9Sstevel@tonic-gate static struct rcm_eventq *volatile rcm_eventq_head = NULL; 2377c478bd9Sstevel@tonic-gate static struct rcm_eventq *rcm_eventq_tail = NULL; 2387c478bd9Sstevel@tonic-gate static mutex_t rcm_eventq_lock; 2397c478bd9Sstevel@tonic-gate static cond_t rcm_eventq_cv; 2407c478bd9Sstevel@tonic-gate static volatile int need_to_exit_rcm_event_thread = 0; 2417c478bd9Sstevel@tonic-gate 242facf4a8dSllai /* Devname globals */ 243facf4a8dSllai static int devname_debug_msg = 1; 244facf4a8dSllai static nvlist_t *devname_maps = NULL; 245facf4a8dSllai static int devname_first_call = 1; 246facf4a8dSllai static int load_devname_nsmaps = FALSE; 247facf4a8dSllai static int lookup_door_fd = -1; 248facf4a8dSllai static char *lookup_door_path; 249facf4a8dSllai 2507c478bd9Sstevel@tonic-gate static void load_dev_acl(void); 2517c478bd9Sstevel@tonic-gate static void update_drvconf(major_t); 252facf4a8dSllai static void check_reconfig_state(void); 253facf4a8dSllai static void devname_setup_nsmaps(void); 254facf4a8dSllai static int s_stat(const char *, struct stat *); 2557c478bd9Sstevel@tonic-gate 2561ca93273Seota static int is_blank(char *); 2571ca93273Seota 258f05faa4eSjacobs /* sysevent queue related globals */ 259f05faa4eSjacobs static mutex_t syseventq_mutex = DEFAULTMUTEX; 260f05faa4eSjacobs static syseventq_t *syseventq_front; 261f05faa4eSjacobs static syseventq_t *syseventq_back; 262f05faa4eSjacobs static void process_syseventq(); 263f05faa4eSjacobs 2647c478bd9Sstevel@tonic-gate int 2657c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 2667c478bd9Sstevel@tonic-gate { 2677c478bd9Sstevel@tonic-gate struct passwd *pw; 2687c478bd9Sstevel@tonic-gate struct group *gp; 2697c478bd9Sstevel@tonic-gate pid_t pid; 2706638bf60Saj int cond = 0; 2717c478bd9Sstevel@tonic-gate 2727c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 2737c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate if ((prog = strrchr(argv[0], '/')) == NULL) { 2767c478bd9Sstevel@tonic-gate prog = argv[0]; 2777c478bd9Sstevel@tonic-gate } else { 2787c478bd9Sstevel@tonic-gate prog++; 2797c478bd9Sstevel@tonic-gate } 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate if (getuid() != 0) { 2827c478bd9Sstevel@tonic-gate err_print(MUST_BE_ROOT); 2837c478bd9Sstevel@tonic-gate devfsadm_exit(1); 284*537714daSvikram /*NOTREACHED*/ 2857c478bd9Sstevel@tonic-gate } 2867c478bd9Sstevel@tonic-gate 2877c478bd9Sstevel@tonic-gate /* 2887c478bd9Sstevel@tonic-gate * Close all files except stdin/stdout/stderr 2897c478bd9Sstevel@tonic-gate */ 2907c478bd9Sstevel@tonic-gate closefrom(3); 2917c478bd9Sstevel@tonic-gate 2927c478bd9Sstevel@tonic-gate if ((pw = getpwnam(DEFAULT_DEV_USER)) != NULL) { 2937c478bd9Sstevel@tonic-gate root_uid = pw->pw_uid; 2947c478bd9Sstevel@tonic-gate } else { 2957c478bd9Sstevel@tonic-gate err_print(CANT_FIND_USER, DEFAULT_DEV_USER); 2967c478bd9Sstevel@tonic-gate root_uid = (uid_t)0; /* assume 0 is root */ 2977c478bd9Sstevel@tonic-gate } 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate /* the default group is sys */ 3007c478bd9Sstevel@tonic-gate 3017c478bd9Sstevel@tonic-gate if ((gp = getgrnam(DEFAULT_DEV_GROUP)) != NULL) { 3027c478bd9Sstevel@tonic-gate sys_gid = gp->gr_gid; 3037c478bd9Sstevel@tonic-gate } else { 3047c478bd9Sstevel@tonic-gate err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP); 3057c478bd9Sstevel@tonic-gate sys_gid = (gid_t)3; /* assume 3 is sys */ 3067c478bd9Sstevel@tonic-gate } 3077c478bd9Sstevel@tonic-gate 3087c478bd9Sstevel@tonic-gate (void) umask(0); 3097c478bd9Sstevel@tonic-gate 31045916cd2Sjpk system_labeled = is_system_labeled(); 31145916cd2Sjpk if (system_labeled == FALSE) { 31245916cd2Sjpk /* 31345916cd2Sjpk * is_system_labeled() will return false in case we are 31445916cd2Sjpk * starting before the first reboot after Trusted Extensions 315f875b4ebSrica * is enabled. Check the setting in /etc/system to see if 316f875b4ebSrica * TX is enabled (even if not yet booted). 31745916cd2Sjpk */ 318f875b4ebSrica if (defopen("/etc/system") == 0) { 319f875b4ebSrica if (defread("set sys_labeling=1") != NULL) 320f875b4ebSrica system_labeled = TRUE; 321f875b4ebSrica 322f875b4ebSrica /* close defaults file */ 323f875b4ebSrica (void) defopen(NULL); 324facf4a8dSllai } 32545916cd2Sjpk } 3266638bf60Saj /* 3276638bf60Saj * Check if device allocation is enabled. 3286638bf60Saj */ 3296638bf60Saj if (system_labeled) { 3306638bf60Saj /* 3316638bf60Saj * In TX, the first line in /etc/security/device_allocate has 3326638bf60Saj * DEVICE_ALLOCATION=ON if the feature is enabled. 3336638bf60Saj */ 3346638bf60Saj devalloc_is_on = da_is_on(); 3356638bf60Saj } else if (auditon(A_GETCOND, (caddr_t)&cond, sizeof (cond)) == 0) { 3366638bf60Saj /* 3376638bf60Saj * Device allocation (and auditing) is enabled if BSM is 3386638bf60Saj * enabled. auditon returns -1 and sets errno to EINVAL if BSM 3396638bf60Saj * is not enabled. 3406638bf60Saj */ 3416638bf60Saj devalloc_is_on = 1; 3426638bf60Saj } 34345916cd2Sjpk 344f875b4ebSrica #ifdef DEBUG 345f875b4ebSrica if (system_labeled == FALSE) { 346f875b4ebSrica struct stat tx_stat; 347f875b4ebSrica 348f875b4ebSrica /* test hook: see also mkdevalloc.c and allocate.c */ 349f875b4ebSrica system_labeled = is_system_labeled_debug(&tx_stat); 350f875b4ebSrica } 351f875b4ebSrica #endif 352f875b4ebSrica 3537c478bd9Sstevel@tonic-gate parse_args(argc, argv); 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate (void) sema_init(&dev_sema, 1, USYNC_THREAD, NULL); 3567c478bd9Sstevel@tonic-gate 35745916cd2Sjpk /* Initialize device allocation list */ 35845916cd2Sjpk devlist.audio = devlist.cd = devlist.floppy = devlist.tape = 3590a653502Swroche devlist.rmdisk = NULL; 36045916cd2Sjpk 3617c478bd9Sstevel@tonic-gate if (daemon_mode == TRUE) { 3627c478bd9Sstevel@tonic-gate /* 3637c478bd9Sstevel@tonic-gate * Build /dev and /devices before daemonizing if 3647c478bd9Sstevel@tonic-gate * reconfig booting and daemon invoked with alternate 3657c478bd9Sstevel@tonic-gate * root. This is to support install. 3667c478bd9Sstevel@tonic-gate */ 3677c478bd9Sstevel@tonic-gate if (getenv(RECONFIG_BOOT) != NULL && root_dir[0] != '\0') { 3687c478bd9Sstevel@tonic-gate vprint(INFO_MID, CONFIGURING); 3697c478bd9Sstevel@tonic-gate load_dev_acl(); 3707c478bd9Sstevel@tonic-gate update_drvconf((major_t)-1); 3717c478bd9Sstevel@tonic-gate process_devinfo_tree(); 3727c478bd9Sstevel@tonic-gate (void) modctl(MODSETMINIROOT); 3737c478bd9Sstevel@tonic-gate } 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate /* 3767c478bd9Sstevel@tonic-gate * fork before detaching from tty in order to print error 3777c478bd9Sstevel@tonic-gate * message if unable to acquire file lock. locks not preserved 3787c478bd9Sstevel@tonic-gate * across forks. Even under debug we want to fork so that 3797c478bd9Sstevel@tonic-gate * when executed at boot we don't hang. 3807c478bd9Sstevel@tonic-gate */ 3817c478bd9Sstevel@tonic-gate if (fork() != 0) { 3827c478bd9Sstevel@tonic-gate devfsadm_exit(0); 383*537714daSvikram /*NOTREACHED*/ 3847c478bd9Sstevel@tonic-gate } 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate /* set directory to / so it coredumps there */ 3877c478bd9Sstevel@tonic-gate if (chdir("/") == -1) { 3887c478bd9Sstevel@tonic-gate err_print(CHROOT_FAILED, strerror(errno)); 3897c478bd9Sstevel@tonic-gate } 3907c478bd9Sstevel@tonic-gate 3917c478bd9Sstevel@tonic-gate /* only one daemon can run at a time */ 3927c478bd9Sstevel@tonic-gate if ((pid = enter_daemon_lock()) == getpid()) { 3937c478bd9Sstevel@tonic-gate detachfromtty(); 3947c478bd9Sstevel@tonic-gate (void) cond_init(&cv, USYNC_THREAD, 0); 3957c478bd9Sstevel@tonic-gate (void) mutex_init(&count_lock, USYNC_THREAD, 0); 3967c478bd9Sstevel@tonic-gate if (thr_create(NULL, NULL, 397ff2aee48Scth (void *(*)(void *))instance_flush_thread, 398ff2aee48Scth NULL, THR_DETACHED, NULL) != 0) { 3997c478bd9Sstevel@tonic-gate err_print(CANT_CREATE_THREAD, "daemon", 4000a653502Swroche strerror(errno)); 4017c478bd9Sstevel@tonic-gate devfsadm_exit(1); 402*537714daSvikram /*NOTREACHED*/ 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate 405ff2aee48Scth /* start the minor_fini_thread */ 406ff2aee48Scth (void) mutex_init(&minor_fini_mutex, USYNC_THREAD, 0); 407ff2aee48Scth (void) cond_init(&minor_fini_cv, USYNC_THREAD, 0); 408ff2aee48Scth if (thr_create(NULL, NULL, 409ff2aee48Scth (void *(*)(void *))minor_fini_thread, 410ff2aee48Scth NULL, THR_DETACHED, NULL)) { 411ff2aee48Scth err_print(CANT_CREATE_THREAD, "minor_fini", 412ff2aee48Scth strerror(errno)); 413ff2aee48Scth devfsadm_exit(1); 414*537714daSvikram /*NOTREACHED*/ 415ff2aee48Scth } 416ff2aee48Scth 417ff2aee48Scth 4187c478bd9Sstevel@tonic-gate /* 4197c478bd9Sstevel@tonic-gate * No need for rcm notifications when running 4207c478bd9Sstevel@tonic-gate * with an alternate root. So initialize rcm only 4217c478bd9Sstevel@tonic-gate * when devfsadm is running with root dir "/". 4227c478bd9Sstevel@tonic-gate * Similarly, logindevperms need only be set 4237c478bd9Sstevel@tonic-gate * in daemon mode and when root dir is "/". 4247c478bd9Sstevel@tonic-gate */ 4257c478bd9Sstevel@tonic-gate if (root_dir[0] == '\0') { 4267c478bd9Sstevel@tonic-gate (void) rcm_init(); 4277c478bd9Sstevel@tonic-gate login_dev_enable = TRUE; 4287c478bd9Sstevel@tonic-gate } 4297c478bd9Sstevel@tonic-gate daemon_update(); 430*537714daSvikram devfsadm_exit(0); 431*537714daSvikram /*NOTREACHED*/ 4327c478bd9Sstevel@tonic-gate } else { 4337c478bd9Sstevel@tonic-gate err_print(DAEMON_RUNNING, pid); 4347c478bd9Sstevel@tonic-gate devfsadm_exit(1); 435*537714daSvikram /*NOTREACHED*/ 4367c478bd9Sstevel@tonic-gate } 4377c478bd9Sstevel@tonic-gate } else { 4387c478bd9Sstevel@tonic-gate /* not a daemon, so just build /dev and /devices */ 4398c206d17Spr 4408c206d17Spr /* 4418c206d17Spr * If turning off device allocation, load the 4428c206d17Spr * minor_perm file because process_devinfo_tree() will 4438c206d17Spr * need this in order to reset the permissions of the 4448c206d17Spr * device files. 4458c206d17Spr */ 4468c206d17Spr if (devalloc_flag == DA_OFF) { 4478c206d17Spr read_minor_perm_file(); 4488c206d17Spr } 4498c206d17Spr 4507c478bd9Sstevel@tonic-gate process_devinfo_tree(); 45145916cd2Sjpk if (devalloc_flag != 0) 45245916cd2Sjpk /* Enable/disable device allocation */ 45345916cd2Sjpk _reset_devalloc(devalloc_flag); 4547c478bd9Sstevel@tonic-gate } 4557c478bd9Sstevel@tonic-gate return (0); 4567c478bd9Sstevel@tonic-gate } 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate static void 4597c478bd9Sstevel@tonic-gate update_drvconf(major_t major) 4607c478bd9Sstevel@tonic-gate { 4617c478bd9Sstevel@tonic-gate if (modctl(MODLOADDRVCONF, major) != 0) 4627c478bd9Sstevel@tonic-gate err_print(gettext("update_drvconf failed for major %d\n"), 4637c478bd9Sstevel@tonic-gate major); 4647c478bd9Sstevel@tonic-gate } 4657c478bd9Sstevel@tonic-gate 466aa646b9dSvikram 4677c478bd9Sstevel@tonic-gate static void 4687c478bd9Sstevel@tonic-gate load_dev_acl() 4697c478bd9Sstevel@tonic-gate { 4707c478bd9Sstevel@tonic-gate if (load_devpolicy() != 0) 4717c478bd9Sstevel@tonic-gate err_print(gettext("device policy load failed\n")); 4727c478bd9Sstevel@tonic-gate load_minor_perm_file(); 4737c478bd9Sstevel@tonic-gate } 4747c478bd9Sstevel@tonic-gate 4757c478bd9Sstevel@tonic-gate /* 476facf4a8dSllai * As devfsadm is run early in boot to provide the kernel with 477facf4a8dSllai * minor_perm info, we might as well check for reconfig at the 478facf4a8dSllai * same time to avoid running devfsadm twice. This gets invoked 479facf4a8dSllai * earlier than the env variable RECONFIG_BOOT is set up. 4807c478bd9Sstevel@tonic-gate */ 481facf4a8dSllai static void 482facf4a8dSllai check_reconfig_state() 4837c478bd9Sstevel@tonic-gate { 484facf4a8dSllai struct stat sb; 4857c478bd9Sstevel@tonic-gate 486facf4a8dSllai if (s_stat("/reconfigure", &sb) == 0) { 487facf4a8dSllai (void) modctl(MODDEVNAME, MODDEVNAME_RECONFIG, 0); 4887c478bd9Sstevel@tonic-gate } 489facf4a8dSllai } 4907c478bd9Sstevel@tonic-gate 491facf4a8dSllai static void 492facf4a8dSllai modctl_sysavail() 493facf4a8dSllai { 494facf4a8dSllai /* 495facf4a8dSllai * Inform /dev that system is available, that 496facf4a8dSllai * implicit reconfig can now be performed. 497facf4a8dSllai */ 498facf4a8dSllai (void) modctl(MODDEVNAME, MODDEVNAME_SYSAVAIL, 0); 499facf4a8dSllai } 5007c478bd9Sstevel@tonic-gate 501facf4a8dSllai static void 502facf4a8dSllai set_lock_root(void) 503facf4a8dSllai { 504facf4a8dSllai struct stat sb; 505facf4a8dSllai char *lock_root; 506facf4a8dSllai size_t len; 5077c478bd9Sstevel@tonic-gate 508facf4a8dSllai lock_root = attr_root ? attr_root : root_dir; 5097c478bd9Sstevel@tonic-gate 510facf4a8dSllai len = strlen(lock_root) + strlen(ETCDEV) + 1; 511facf4a8dSllai etc_dev_dir = s_malloc(len); 512facf4a8dSllai (void) snprintf(etc_dev_dir, len, "%s%s", lock_root, ETCDEV); 5137c478bd9Sstevel@tonic-gate 514facf4a8dSllai if (s_stat(etc_dev_dir, &sb) != 0) { 515facf4a8dSllai s_mkdirp(etc_dev_dir, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH); 516facf4a8dSllai } else if (!S_ISDIR(sb.st_mode)) { 517facf4a8dSllai err_print(NOT_DIR, etc_dev_dir); 518facf4a8dSllai devfsadm_exit(1); 519*537714daSvikram /*NOTREACHED*/ 520facf4a8dSllai } 5217c478bd9Sstevel@tonic-gate } 5227c478bd9Sstevel@tonic-gate 523facf4a8dSllai 5247c478bd9Sstevel@tonic-gate /* 5257c478bd9Sstevel@tonic-gate * Parse arguments for all 6 programs handled from devfsadm. 5267c478bd9Sstevel@tonic-gate */ 5277c478bd9Sstevel@tonic-gate static void 5287c478bd9Sstevel@tonic-gate parse_args(int argc, char *argv[]) 5297c478bd9Sstevel@tonic-gate { 5307c478bd9Sstevel@tonic-gate char opt; 5317c478bd9Sstevel@tonic-gate char get_linkcompat_opts = FALSE; 5327c478bd9Sstevel@tonic-gate char *compat_class; 5337c478bd9Sstevel@tonic-gate int num_aliases = 0; 5347c478bd9Sstevel@tonic-gate int len; 5357c478bd9Sstevel@tonic-gate int retval; 5367c478bd9Sstevel@tonic-gate int add_bind = FALSE; 5377c478bd9Sstevel@tonic-gate struct aliases *ap = NULL; 5387c478bd9Sstevel@tonic-gate struct aliases *a_head = NULL; 5397c478bd9Sstevel@tonic-gate struct aliases *a_tail = NULL; 5407c478bd9Sstevel@tonic-gate struct modconfig mc; 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate if (strcmp(prog, DISKS) == 0) { 5437c478bd9Sstevel@tonic-gate compat_class = "disk"; 5447c478bd9Sstevel@tonic-gate get_linkcompat_opts = TRUE; 5457c478bd9Sstevel@tonic-gate 5467c478bd9Sstevel@tonic-gate } else if (strcmp(prog, TAPES) == 0) { 5477c478bd9Sstevel@tonic-gate compat_class = "tape"; 5487c478bd9Sstevel@tonic-gate get_linkcompat_opts = TRUE; 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate } else if (strcmp(prog, PORTS) == 0) { 5517c478bd9Sstevel@tonic-gate compat_class = "port"; 5527c478bd9Sstevel@tonic-gate get_linkcompat_opts = TRUE; 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate } else if (strcmp(prog, AUDLINKS) == 0) { 5557c478bd9Sstevel@tonic-gate compat_class = "audio"; 5567c478bd9Sstevel@tonic-gate get_linkcompat_opts = TRUE; 5577c478bd9Sstevel@tonic-gate 5587c478bd9Sstevel@tonic-gate } else if (strcmp(prog, DEVLINKS) == 0) { 5597c478bd9Sstevel@tonic-gate devlinktab_file = DEVLINKTAB_FILE; 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate build_devices = FALSE; 5627c478bd9Sstevel@tonic-gate load_attach_drv = FALSE; 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate while ((opt = getopt(argc, argv, "dnr:st:vV:")) != EOF) { 5657c478bd9Sstevel@tonic-gate switch (opt) { 5667c478bd9Sstevel@tonic-gate case 'd': 5677c478bd9Sstevel@tonic-gate file_mods = FALSE; 5687c478bd9Sstevel@tonic-gate flush_path_to_inst_enable = FALSE; 5697c478bd9Sstevel@tonic-gate devlinks_debug = TRUE; 5707c478bd9Sstevel@tonic-gate break; 5717c478bd9Sstevel@tonic-gate case 'n': 5727c478bd9Sstevel@tonic-gate /* prevent driver loading and deferred attach */ 5737c478bd9Sstevel@tonic-gate load_attach_drv = FALSE; 5747c478bd9Sstevel@tonic-gate break; 5757c478bd9Sstevel@tonic-gate case 'r': 576facf4a8dSllai set_root_devices_dev_dir(optarg); 5777c478bd9Sstevel@tonic-gate if (zone_pathcheck(root_dir) != 5787c478bd9Sstevel@tonic-gate DEVFSADM_SUCCESS) 5797c478bd9Sstevel@tonic-gate devfsadm_exit(1); 580*537714daSvikram /*NOTREACHED*/ 5817c478bd9Sstevel@tonic-gate break; 5827c478bd9Sstevel@tonic-gate case 's': 5837c478bd9Sstevel@tonic-gate /* 5847c478bd9Sstevel@tonic-gate * suppress. don't create/remove links/nodes 5857c478bd9Sstevel@tonic-gate * useful with -v or -V 5867c478bd9Sstevel@tonic-gate */ 5877c478bd9Sstevel@tonic-gate file_mods = FALSE; 5887c478bd9Sstevel@tonic-gate flush_path_to_inst_enable = FALSE; 5897c478bd9Sstevel@tonic-gate break; 5907c478bd9Sstevel@tonic-gate case 't': 5917c478bd9Sstevel@tonic-gate /* supply a non-default table file */ 5927c478bd9Sstevel@tonic-gate devlinktab_file = optarg; 5937c478bd9Sstevel@tonic-gate break; 5947c478bd9Sstevel@tonic-gate case 'v': 5957c478bd9Sstevel@tonic-gate /* documented verbose flag */ 5967c478bd9Sstevel@tonic-gate add_verbose_id(VERBOSE_MID); 5977c478bd9Sstevel@tonic-gate break; 5987c478bd9Sstevel@tonic-gate case 'V': 5997c478bd9Sstevel@tonic-gate /* undocumented for extra verbose levels */ 6007c478bd9Sstevel@tonic-gate add_verbose_id(optarg); 6017c478bd9Sstevel@tonic-gate break; 6027c478bd9Sstevel@tonic-gate default: 6037c478bd9Sstevel@tonic-gate usage(); 6047c478bd9Sstevel@tonic-gate break; 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate } 6077c478bd9Sstevel@tonic-gate 6087c478bd9Sstevel@tonic-gate if (optind < argc) { 6097c478bd9Sstevel@tonic-gate usage(); 6107c478bd9Sstevel@tonic-gate } 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate } else if (strcmp(prog, DRVCONFIG) == 0) { 6137c478bd9Sstevel@tonic-gate build_dev = FALSE; 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate while ((opt = 6160a653502Swroche getopt(argc, argv, "a:bdc:i:m:np:R:r:svV:")) != EOF) { 6177c478bd9Sstevel@tonic-gate switch (opt) { 6187c478bd9Sstevel@tonic-gate case 'a': 6197c478bd9Sstevel@tonic-gate ap = calloc(sizeof (struct aliases), 1); 6207c478bd9Sstevel@tonic-gate ap->a_name = dequote(optarg); 6217c478bd9Sstevel@tonic-gate len = strlen(ap->a_name) + 1; 6227c478bd9Sstevel@tonic-gate if (len > MAXMODCONFNAME) { 6237c478bd9Sstevel@tonic-gate err_print(ALIAS_TOO_LONG, 6247c478bd9Sstevel@tonic-gate MAXMODCONFNAME, ap->a_name); 6257c478bd9Sstevel@tonic-gate devfsadm_exit(1); 626*537714daSvikram /*NOTREACHED*/ 6277c478bd9Sstevel@tonic-gate } 6287c478bd9Sstevel@tonic-gate ap->a_len = len; 6297c478bd9Sstevel@tonic-gate if (a_tail == NULL) { 6307c478bd9Sstevel@tonic-gate a_head = ap; 6317c478bd9Sstevel@tonic-gate } else { 6327c478bd9Sstevel@tonic-gate a_tail->a_next = ap; 6337c478bd9Sstevel@tonic-gate } 6347c478bd9Sstevel@tonic-gate a_tail = ap; 6357c478bd9Sstevel@tonic-gate num_aliases++; 6367c478bd9Sstevel@tonic-gate add_bind = TRUE; 6377c478bd9Sstevel@tonic-gate break; 6387c478bd9Sstevel@tonic-gate case 'b': 6397c478bd9Sstevel@tonic-gate add_bind = TRUE; 6407c478bd9Sstevel@tonic-gate break; 6417c478bd9Sstevel@tonic-gate case 'c': 6427c478bd9Sstevel@tonic-gate (void) strcpy(mc.drvclass, optarg); 6437c478bd9Sstevel@tonic-gate break; 6447c478bd9Sstevel@tonic-gate case 'd': 6457c478bd9Sstevel@tonic-gate /* 6467c478bd9Sstevel@tonic-gate * need to keep for compatibility, but 6477c478bd9Sstevel@tonic-gate * do nothing. 6487c478bd9Sstevel@tonic-gate */ 6497c478bd9Sstevel@tonic-gate break; 6507c478bd9Sstevel@tonic-gate case 'i': 6517c478bd9Sstevel@tonic-gate single_drv = TRUE; 6527c478bd9Sstevel@tonic-gate (void) strcpy(mc.drvname, optarg); 6537c478bd9Sstevel@tonic-gate driver = s_strdup(optarg); 6547c478bd9Sstevel@tonic-gate break; 6557c478bd9Sstevel@tonic-gate case 'm': 6567c478bd9Sstevel@tonic-gate mc.major = atoi(optarg); 6577c478bd9Sstevel@tonic-gate break; 6587c478bd9Sstevel@tonic-gate case 'n': 6597c478bd9Sstevel@tonic-gate /* prevent driver loading and deferred attach */ 6607c478bd9Sstevel@tonic-gate load_attach_drv = FALSE; 6617c478bd9Sstevel@tonic-gate break; 6627c478bd9Sstevel@tonic-gate case 'p': 6637c478bd9Sstevel@tonic-gate /* specify alternate path_to_inst file */ 6647c478bd9Sstevel@tonic-gate inst_file = s_strdup(optarg); 6657c478bd9Sstevel@tonic-gate break; 6667c478bd9Sstevel@tonic-gate case 'R': 6677c478bd9Sstevel@tonic-gate /* 6687c478bd9Sstevel@tonic-gate * Private flag for suninstall to populate 6697c478bd9Sstevel@tonic-gate * device information on the installed root. 6707c478bd9Sstevel@tonic-gate */ 6717c478bd9Sstevel@tonic-gate root_dir = s_strdup(optarg); 6727c478bd9Sstevel@tonic-gate if (zone_pathcheck(root_dir) != 6737c478bd9Sstevel@tonic-gate DEVFSADM_SUCCESS) 6747c478bd9Sstevel@tonic-gate devfsadm_exit(devfsadm_copy()); 675*537714daSvikram /*NOTREACHED*/ 6767c478bd9Sstevel@tonic-gate break; 6777c478bd9Sstevel@tonic-gate case 'r': 6787c478bd9Sstevel@tonic-gate devices_dir = s_strdup(optarg); 6797c478bd9Sstevel@tonic-gate if (zone_pathcheck(devices_dir) != 6807c478bd9Sstevel@tonic-gate DEVFSADM_SUCCESS) 6817c478bd9Sstevel@tonic-gate devfsadm_exit(1); 682*537714daSvikram /*NOTREACHED*/ 6837c478bd9Sstevel@tonic-gate break; 6847c478bd9Sstevel@tonic-gate case 's': 6857c478bd9Sstevel@tonic-gate /* 6867c478bd9Sstevel@tonic-gate * suppress. don't create nodes 6877c478bd9Sstevel@tonic-gate * useful with -v or -V 6887c478bd9Sstevel@tonic-gate */ 6897c478bd9Sstevel@tonic-gate file_mods = FALSE; 6907c478bd9Sstevel@tonic-gate flush_path_to_inst_enable = FALSE; 6917c478bd9Sstevel@tonic-gate break; 6927c478bd9Sstevel@tonic-gate case 'v': 6937c478bd9Sstevel@tonic-gate /* documented verbose flag */ 6947c478bd9Sstevel@tonic-gate add_verbose_id(VERBOSE_MID); 6957c478bd9Sstevel@tonic-gate break; 6967c478bd9Sstevel@tonic-gate case 'V': 6977c478bd9Sstevel@tonic-gate /* undocumented for extra verbose levels */ 6987c478bd9Sstevel@tonic-gate add_verbose_id(optarg); 6997c478bd9Sstevel@tonic-gate break; 7007c478bd9Sstevel@tonic-gate default: 7017c478bd9Sstevel@tonic-gate usage(); 7027c478bd9Sstevel@tonic-gate } 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate if (optind < argc) { 7067c478bd9Sstevel@tonic-gate usage(); 7077c478bd9Sstevel@tonic-gate } 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate if ((add_bind == TRUE) && (mc.major == -1 || 7107c478bd9Sstevel@tonic-gate mc.drvname[0] == NULL)) { 7117c478bd9Sstevel@tonic-gate err_print(MAJOR_AND_B_FLAG); 7127c478bd9Sstevel@tonic-gate devfsadm_exit(1); 713*537714daSvikram /*NOTREACHED*/ 7147c478bd9Sstevel@tonic-gate } 7157c478bd9Sstevel@tonic-gate if (add_bind == TRUE) { 7167c478bd9Sstevel@tonic-gate mc.num_aliases = num_aliases; 7177c478bd9Sstevel@tonic-gate mc.ap = a_head; 7187c478bd9Sstevel@tonic-gate retval = modctl(MODADDMAJBIND, NULL, (caddr_t)&mc); 7197c478bd9Sstevel@tonic-gate if (retval < 0) { 7207c478bd9Sstevel@tonic-gate err_print(MODCTL_ADDMAJBIND); 7217c478bd9Sstevel@tonic-gate } 7227c478bd9Sstevel@tonic-gate devfsadm_exit(retval); 723*537714daSvikram /*NOTREACHED*/ 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate } else if ((strcmp(prog, DEVFSADM) == 0) || 7277c478bd9Sstevel@tonic-gate (strcmp(prog, DEVFSADMD) == 0)) { 7287c478bd9Sstevel@tonic-gate char *zonename = NULL; 7297c478bd9Sstevel@tonic-gate int init_drvconf = 0; 7307c478bd9Sstevel@tonic-gate int init_perm = 0; 7317c478bd9Sstevel@tonic-gate int public_mode = 0; 732facf4a8dSllai int init_sysavail = 0; 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate if (strcmp(prog, DEVFSADMD) == 0) { 7357c478bd9Sstevel@tonic-gate daemon_mode = TRUE; 7367c478bd9Sstevel@tonic-gate } 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate devlinktab_file = DEVLINKTAB_FILE; 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate while ((opt = getopt(argc, argv, 741facf4a8dSllai "a:Cc:deIi:l:mnp:PR:r:sSt:vV:x:")) != EOF) { 742facf4a8dSllai if (opt == 'I' || opt == 'P' || opt == 'S') { 7437c478bd9Sstevel@tonic-gate if (public_mode) 7447c478bd9Sstevel@tonic-gate usage(); 7457c478bd9Sstevel@tonic-gate } else { 746facf4a8dSllai if (init_perm || init_drvconf || init_sysavail) 7477c478bd9Sstevel@tonic-gate usage(); 7487c478bd9Sstevel@tonic-gate public_mode = 1; 7497c478bd9Sstevel@tonic-gate } 7507c478bd9Sstevel@tonic-gate switch (opt) { 751facf4a8dSllai case 'a': 752facf4a8dSllai attr_root = s_strdup(optarg); 753facf4a8dSllai break; 7547c478bd9Sstevel@tonic-gate case 'C': 7557c478bd9Sstevel@tonic-gate cleanup = TRUE; 7567c478bd9Sstevel@tonic-gate break; 7577c478bd9Sstevel@tonic-gate case 'c': 7587c478bd9Sstevel@tonic-gate num_classes++; 7590a653502Swroche classes = s_realloc(classes, 7600a653502Swroche num_classes * sizeof (char *)); 7617c478bd9Sstevel@tonic-gate classes[num_classes - 1] = optarg; 7627c478bd9Sstevel@tonic-gate break; 76345916cd2Sjpk case 'd': 7647c478bd9Sstevel@tonic-gate if (daemon_mode == FALSE) { 76545916cd2Sjpk /* 76645916cd2Sjpk * Device allocation to be disabled. 76745916cd2Sjpk */ 76845916cd2Sjpk devalloc_flag = DA_OFF; 76945916cd2Sjpk build_dev = FALSE; 77045916cd2Sjpk } 77145916cd2Sjpk break; 77245916cd2Sjpk case 'e': 77345916cd2Sjpk if (daemon_mode == FALSE) { 77445916cd2Sjpk /* 77545916cd2Sjpk * Device allocation to be enabled. 77645916cd2Sjpk */ 77745916cd2Sjpk devalloc_flag = DA_ON; 7787c478bd9Sstevel@tonic-gate build_dev = FALSE; 7797c478bd9Sstevel@tonic-gate } 7807c478bd9Sstevel@tonic-gate break; 7817c478bd9Sstevel@tonic-gate case 'I': /* update kernel driver.conf cache */ 7827c478bd9Sstevel@tonic-gate if (daemon_mode == TRUE) 7837c478bd9Sstevel@tonic-gate usage(); 7847c478bd9Sstevel@tonic-gate init_drvconf = 1; 7857c478bd9Sstevel@tonic-gate break; 7867c478bd9Sstevel@tonic-gate case 'i': 7877c478bd9Sstevel@tonic-gate single_drv = TRUE; 7887c478bd9Sstevel@tonic-gate driver = s_strdup(optarg); 7897c478bd9Sstevel@tonic-gate break; 7907c478bd9Sstevel@tonic-gate case 'l': 7917c478bd9Sstevel@tonic-gate /* specify an alternate module load path */ 7927c478bd9Sstevel@tonic-gate module_dirs = s_strdup(optarg); 7937c478bd9Sstevel@tonic-gate break; 794facf4a8dSllai case 'm': 795facf4a8dSllai load_devname_nsmaps = TRUE; 796facf4a8dSllai break; 7977c478bd9Sstevel@tonic-gate case 'n': 7987c478bd9Sstevel@tonic-gate /* prevent driver loading and deferred attach */ 7997c478bd9Sstevel@tonic-gate load_attach_drv = FALSE; 8007c478bd9Sstevel@tonic-gate break; 8017c478bd9Sstevel@tonic-gate case 'p': 8027c478bd9Sstevel@tonic-gate /* specify alternate path_to_inst file */ 8037c478bd9Sstevel@tonic-gate inst_file = s_strdup(optarg); 8047c478bd9Sstevel@tonic-gate break; 8057c478bd9Sstevel@tonic-gate case 'P': 8067c478bd9Sstevel@tonic-gate if (daemon_mode == TRUE) 8077c478bd9Sstevel@tonic-gate usage(); 8087c478bd9Sstevel@tonic-gate /* load minor_perm and device_policy */ 8097c478bd9Sstevel@tonic-gate init_perm = 1; 8107c478bd9Sstevel@tonic-gate break; 8117c478bd9Sstevel@tonic-gate case 'R': 8127c478bd9Sstevel@tonic-gate /* 8137c478bd9Sstevel@tonic-gate * Private flag for suninstall to populate 8147c478bd9Sstevel@tonic-gate * device information on the installed root. 8157c478bd9Sstevel@tonic-gate */ 8167c478bd9Sstevel@tonic-gate root_dir = s_strdup(optarg); 8177c478bd9Sstevel@tonic-gate devfsadm_exit(devfsadm_copy()); 818*537714daSvikram /*NOTREACHED*/ 8197c478bd9Sstevel@tonic-gate break; 8207c478bd9Sstevel@tonic-gate case 'r': 821facf4a8dSllai set_root_devices_dev_dir(optarg); 8227c478bd9Sstevel@tonic-gate break; 8237c478bd9Sstevel@tonic-gate case 's': 8247c478bd9Sstevel@tonic-gate /* 8257c478bd9Sstevel@tonic-gate * suppress. don't create/remove links/nodes 8267c478bd9Sstevel@tonic-gate * useful with -v or -V 8277c478bd9Sstevel@tonic-gate */ 8287c478bd9Sstevel@tonic-gate file_mods = FALSE; 8297c478bd9Sstevel@tonic-gate flush_path_to_inst_enable = FALSE; 8307c478bd9Sstevel@tonic-gate break; 831facf4a8dSllai case 'S': 832facf4a8dSllai if (daemon_mode == TRUE) 833facf4a8dSllai usage(); 834facf4a8dSllai init_sysavail = 1; 835facf4a8dSllai break; 8367c478bd9Sstevel@tonic-gate case 't': 8377c478bd9Sstevel@tonic-gate devlinktab_file = optarg; 8387c478bd9Sstevel@tonic-gate break; 8397c478bd9Sstevel@tonic-gate case 'v': 8407c478bd9Sstevel@tonic-gate /* documented verbose flag */ 8417c478bd9Sstevel@tonic-gate add_verbose_id(VERBOSE_MID); 8427c478bd9Sstevel@tonic-gate break; 8437c478bd9Sstevel@tonic-gate case 'V': 8447c478bd9Sstevel@tonic-gate /* undocumented: specify verbose lvl */ 8457c478bd9Sstevel@tonic-gate add_verbose_id(optarg); 8467c478bd9Sstevel@tonic-gate break; 8477c478bd9Sstevel@tonic-gate case 'x': 8487c478bd9Sstevel@tonic-gate /* 8497c478bd9Sstevel@tonic-gate * x is the "private switch" option. The 8507c478bd9Sstevel@tonic-gate * goal is to not suck up all the other 8517c478bd9Sstevel@tonic-gate * option letters. 8527c478bd9Sstevel@tonic-gate */ 8537c478bd9Sstevel@tonic-gate if (strcmp(optarg, "update_devlinksdb") == 0) { 8547c478bd9Sstevel@tonic-gate update_database = TRUE; 8557c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "no_dev") == 0) { 8567c478bd9Sstevel@tonic-gate /* don't build /dev */ 8577c478bd9Sstevel@tonic-gate build_dev = FALSE; 8587c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "no_devices") == 0) { 8597c478bd9Sstevel@tonic-gate /* don't build /devices */ 8607c478bd9Sstevel@tonic-gate build_devices = FALSE; 8617c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "no_p2i") == 0) { 8627c478bd9Sstevel@tonic-gate /* don't flush path_to_inst */ 8637c478bd9Sstevel@tonic-gate flush_path_to_inst_enable = FALSE; 8647c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "use_dicache") == 0) { 8657c478bd9Sstevel@tonic-gate use_snapshot_cache = TRUE; 8667c478bd9Sstevel@tonic-gate } else { 8677c478bd9Sstevel@tonic-gate usage(); 8687c478bd9Sstevel@tonic-gate } 8697c478bd9Sstevel@tonic-gate break; 8707c478bd9Sstevel@tonic-gate default: 8717c478bd9Sstevel@tonic-gate usage(); 8727c478bd9Sstevel@tonic-gate break; 8737c478bd9Sstevel@tonic-gate } 8747c478bd9Sstevel@tonic-gate } 8757c478bd9Sstevel@tonic-gate if (optind < argc) { 8767c478bd9Sstevel@tonic-gate usage(); 8777c478bd9Sstevel@tonic-gate } 8787c478bd9Sstevel@tonic-gate 8797c478bd9Sstevel@tonic-gate /* 8807c478bd9Sstevel@tonic-gate * We're not in zone mode; Check to see if the rootpath 8817c478bd9Sstevel@tonic-gate * collides with any zonepaths. 8827c478bd9Sstevel@tonic-gate */ 8837c478bd9Sstevel@tonic-gate if (zonename == NULL) { 8847c478bd9Sstevel@tonic-gate if (zone_pathcheck(root_dir) != DEVFSADM_SUCCESS) 8857c478bd9Sstevel@tonic-gate devfsadm_exit(1); 886*537714daSvikram /*NOTREACHED*/ 8877c478bd9Sstevel@tonic-gate } 8887c478bd9Sstevel@tonic-gate 889facf4a8dSllai if (init_drvconf || init_perm || init_sysavail) { 8907c478bd9Sstevel@tonic-gate /* 8917c478bd9Sstevel@tonic-gate * Load minor perm before force-loading drivers 8927c478bd9Sstevel@tonic-gate * so the correct permissions are picked up. 8937c478bd9Sstevel@tonic-gate */ 894facf4a8dSllai if (init_perm) { 895facf4a8dSllai check_reconfig_state(); 8967c478bd9Sstevel@tonic-gate load_dev_acl(); 897facf4a8dSllai } 8987c478bd9Sstevel@tonic-gate if (init_drvconf) 8997c478bd9Sstevel@tonic-gate update_drvconf((major_t)-1); 900facf4a8dSllai if (init_sysavail) 901facf4a8dSllai modctl_sysavail(); 9027c478bd9Sstevel@tonic-gate devfsadm_exit(0); 903*537714daSvikram /*NOTREACHED*/ 9047c478bd9Sstevel@tonic-gate } 905facf4a8dSllai 906facf4a8dSllai if (load_devname_nsmaps == TRUE) { 907facf4a8dSllai devname_setup_nsmaps(); 908facf4a8dSllai devfsadm_exit(0); 909*537714daSvikram /*NOTREACHED*/ 910facf4a8dSllai } 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate if (get_linkcompat_opts == TRUE) { 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate build_devices = FALSE; 9177c478bd9Sstevel@tonic-gate load_attach_drv = FALSE; 9187c478bd9Sstevel@tonic-gate num_classes++; 9197c478bd9Sstevel@tonic-gate classes = s_realloc(classes, num_classes * 9207c478bd9Sstevel@tonic-gate sizeof (char *)); 9217c478bd9Sstevel@tonic-gate classes[num_classes - 1] = compat_class; 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate while ((opt = getopt(argc, argv, "Cnr:svV:")) != EOF) { 9247c478bd9Sstevel@tonic-gate switch (opt) { 9257c478bd9Sstevel@tonic-gate case 'C': 9267c478bd9Sstevel@tonic-gate cleanup = TRUE; 9277c478bd9Sstevel@tonic-gate break; 9287c478bd9Sstevel@tonic-gate case 'n': 9297c478bd9Sstevel@tonic-gate /* prevent driver loading or deferred attach */ 9307c478bd9Sstevel@tonic-gate load_attach_drv = FALSE; 9317c478bd9Sstevel@tonic-gate break; 9327c478bd9Sstevel@tonic-gate case 'r': 933facf4a8dSllai set_root_devices_dev_dir(optarg); 9347c478bd9Sstevel@tonic-gate if (zone_pathcheck(root_dir) != 9357c478bd9Sstevel@tonic-gate DEVFSADM_SUCCESS) 9367c478bd9Sstevel@tonic-gate devfsadm_exit(1); 937*537714daSvikram /*NOTREACHED*/ 9387c478bd9Sstevel@tonic-gate break; 9397c478bd9Sstevel@tonic-gate case 's': 9407c478bd9Sstevel@tonic-gate /* suppress. don't create/remove links/nodes */ 9417c478bd9Sstevel@tonic-gate /* useful with -v or -V */ 9427c478bd9Sstevel@tonic-gate file_mods = FALSE; 9437c478bd9Sstevel@tonic-gate flush_path_to_inst_enable = FALSE; 9447c478bd9Sstevel@tonic-gate break; 9457c478bd9Sstevel@tonic-gate case 'v': 9467c478bd9Sstevel@tonic-gate /* documented verbose flag */ 9477c478bd9Sstevel@tonic-gate add_verbose_id(VERBOSE_MID); 9487c478bd9Sstevel@tonic-gate break; 9497c478bd9Sstevel@tonic-gate case 'V': 9507c478bd9Sstevel@tonic-gate /* undocumented for extra verbose levels */ 9517c478bd9Sstevel@tonic-gate add_verbose_id(optarg); 9527c478bd9Sstevel@tonic-gate break; 9537c478bd9Sstevel@tonic-gate default: 9547c478bd9Sstevel@tonic-gate usage(); 9557c478bd9Sstevel@tonic-gate } 9567c478bd9Sstevel@tonic-gate } 9577c478bd9Sstevel@tonic-gate if (optind < argc) { 9587c478bd9Sstevel@tonic-gate usage(); 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate } 961facf4a8dSllai set_lock_root(); 9627c478bd9Sstevel@tonic-gate } 9637c478bd9Sstevel@tonic-gate 9647c478bd9Sstevel@tonic-gate void 9657c478bd9Sstevel@tonic-gate usage(void) 9667c478bd9Sstevel@tonic-gate { 9677c478bd9Sstevel@tonic-gate if (strcmp(prog, DEVLINKS) == 0) { 9687c478bd9Sstevel@tonic-gate err_print(DEVLINKS_USAGE); 9697c478bd9Sstevel@tonic-gate } else if (strcmp(prog, DRVCONFIG) == 0) { 9707c478bd9Sstevel@tonic-gate err_print(DRVCONFIG_USAGE); 9717c478bd9Sstevel@tonic-gate } else if ((strcmp(prog, DEVFSADM) == 0) || 9720a653502Swroche (strcmp(prog, DEVFSADMD) == 0)) { 9737c478bd9Sstevel@tonic-gate err_print(DEVFSADM_USAGE); 9747c478bd9Sstevel@tonic-gate } else { 9757c478bd9Sstevel@tonic-gate err_print(COMPAT_LINK_USAGE); 9767c478bd9Sstevel@tonic-gate } 9777c478bd9Sstevel@tonic-gate 9787c478bd9Sstevel@tonic-gate devfsadm_exit(1); 979*537714daSvikram /*NOTREACHED*/ 9807c478bd9Sstevel@tonic-gate } 9817c478bd9Sstevel@tonic-gate 9827c478bd9Sstevel@tonic-gate static void 9837c478bd9Sstevel@tonic-gate devi_tree_walk(struct dca_impl *dcip, int flags, char *ev_subclass) 9847c478bd9Sstevel@tonic-gate { 9857c478bd9Sstevel@tonic-gate char *msg, *name; 9867c478bd9Sstevel@tonic-gate struct mlist mlist = {0}; 9877c478bd9Sstevel@tonic-gate di_node_t node; 9887c478bd9Sstevel@tonic-gate 9897c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "devi_tree_walk: root=%s, minor=%s, driver=%s," 9907c478bd9Sstevel@tonic-gate " error=%d, flags=%u\n", dcip->dci_root, 9917c478bd9Sstevel@tonic-gate dcip->dci_minor ? dcip->dci_minor : "<NULL>", 9927c478bd9Sstevel@tonic-gate dcip->dci_driver ? dcip->dci_driver : "<NULL>", dcip->dci_error, 9937c478bd9Sstevel@tonic-gate dcip->dci_flags); 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate assert(dcip->dci_root); 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate if (dcip->dci_flags & DCA_LOAD_DRV) { 9987c478bd9Sstevel@tonic-gate node = di_init_driver(dcip->dci_driver, flags); 9997c478bd9Sstevel@tonic-gate msg = DRIVER_FAILURE; 10007c478bd9Sstevel@tonic-gate name = dcip->dci_driver; 10017c478bd9Sstevel@tonic-gate } else { 10027c478bd9Sstevel@tonic-gate node = di_init(dcip->dci_root, flags); 10037c478bd9Sstevel@tonic-gate msg = DI_INIT_FAILED; 10047c478bd9Sstevel@tonic-gate name = dcip->dci_root; 10057c478bd9Sstevel@tonic-gate } 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate if (node == DI_NODE_NIL) { 10087c478bd9Sstevel@tonic-gate dcip->dci_error = errno; 10097c478bd9Sstevel@tonic-gate /* 10107c478bd9Sstevel@tonic-gate * Rapid hotplugging (commonly seen during USB testing), 10117c478bd9Sstevel@tonic-gate * may remove a device before the create event for it 10127c478bd9Sstevel@tonic-gate * has been processed. To prevent alarming users with 10137c478bd9Sstevel@tonic-gate * a superfluous message, we suppress error messages 10147c478bd9Sstevel@tonic-gate * for ENXIO and hotplug. 10157c478bd9Sstevel@tonic-gate */ 10167c478bd9Sstevel@tonic-gate if (!(errno == ENXIO && (dcip->dci_flags & DCA_HOT_PLUG))) 10177c478bd9Sstevel@tonic-gate err_print(msg, name, strerror(dcip->dci_error)); 10187c478bd9Sstevel@tonic-gate return; 10197c478bd9Sstevel@tonic-gate } 10207c478bd9Sstevel@tonic-gate 10217c478bd9Sstevel@tonic-gate if (dcip->dci_flags & DCA_FLUSH_PATHINST) 10227c478bd9Sstevel@tonic-gate flush_path_to_inst(); 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate dcip->dci_arg = &mlist; 10257c478bd9Sstevel@tonic-gate 10267c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "walking device tree\n"); 10277c478bd9Sstevel@tonic-gate 10287c478bd9Sstevel@tonic-gate (void) di_walk_minor(node, NULL, DI_CHECK_ALIAS, dcip, 10297c478bd9Sstevel@tonic-gate check_minor_type); 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate process_deferred_links(dcip, DCA_CREATE_LINK); 10327c478bd9Sstevel@tonic-gate 10337c478bd9Sstevel@tonic-gate dcip->dci_arg = NULL; 10347c478bd9Sstevel@tonic-gate 10357c478bd9Sstevel@tonic-gate /* 10367c478bd9Sstevel@tonic-gate * Finished creating devfs files and dev links. 10377c478bd9Sstevel@tonic-gate * Log sysevent and notify RCM. 10387c478bd9Sstevel@tonic-gate */ 10397c478bd9Sstevel@tonic-gate if (ev_subclass) 1040f05faa4eSjacobs build_and_enq_event(EC_DEV_ADD, ev_subclass, dcip->dci_root, 104130294554Sphitran node, dcip->dci_minor); 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate if ((dcip->dci_flags & DCA_NOTIFY_RCM) && rcm_hdl) 10447c478bd9Sstevel@tonic-gate (void) notify_rcm(node, dcip->dci_minor); 10457c478bd9Sstevel@tonic-gate 104645916cd2Sjpk /* Add new device to device allocation database */ 104745916cd2Sjpk if (system_labeled && update_devdb) { 104845916cd2Sjpk _update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir); 104945916cd2Sjpk update_devdb = 0; 105045916cd2Sjpk } 105145916cd2Sjpk 10527c478bd9Sstevel@tonic-gate di_fini(node); 10537c478bd9Sstevel@tonic-gate } 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate static void 10567c478bd9Sstevel@tonic-gate process_deferred_links(struct dca_impl *dcip, int flags) 10577c478bd9Sstevel@tonic-gate { 10587c478bd9Sstevel@tonic-gate struct mlist *dep; 10597c478bd9Sstevel@tonic-gate struct minor *mp, *smp; 10607c478bd9Sstevel@tonic-gate 10617c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "processing deferred links\n"); 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate dep = dcip->dci_arg; 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate /* 10667c478bd9Sstevel@tonic-gate * The list head is not used during the deferred create phase 10677c478bd9Sstevel@tonic-gate */ 10687c478bd9Sstevel@tonic-gate dcip->dci_arg = NULL; 10697c478bd9Sstevel@tonic-gate 10707c478bd9Sstevel@tonic-gate assert(dep); 10717c478bd9Sstevel@tonic-gate assert((dep->head == NULL) ^ (dep->tail != NULL)); 10727c478bd9Sstevel@tonic-gate assert(flags == DCA_FREE_LIST || flags == DCA_CREATE_LINK); 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate for (smp = NULL, mp = dep->head; mp; mp = mp->next) { 10757c478bd9Sstevel@tonic-gate if (flags == DCA_CREATE_LINK) 10767c478bd9Sstevel@tonic-gate (void) check_minor_type(mp->node, mp->minor, dcip); 10777c478bd9Sstevel@tonic-gate free(smp); 10787c478bd9Sstevel@tonic-gate smp = mp; 10797c478bd9Sstevel@tonic-gate } 10807c478bd9Sstevel@tonic-gate 10817c478bd9Sstevel@tonic-gate free(smp); 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate 10847c478bd9Sstevel@tonic-gate /* 10857c478bd9Sstevel@tonic-gate * Called in non-daemon mode to take a snap shot of the devinfo tree. 10867c478bd9Sstevel@tonic-gate * Then it calls the appropriate functions to build /devices and /dev. 10877c478bd9Sstevel@tonic-gate * It also flushes path_to_inst. 108898a9beefShtk * Except in the devfsadm -i (single driver case), the flags used by devfsadm 108998a9beefShtk * needs to match DI_CACHE_SNAPSHOT_FLAGS. That will make DINFOCACHE snapshot 109098a9beefShtk * updated. 10917c478bd9Sstevel@tonic-gate */ 10927c478bd9Sstevel@tonic-gate void 10937c478bd9Sstevel@tonic-gate process_devinfo_tree() 10947c478bd9Sstevel@tonic-gate { 109598a9beefShtk uint_t flags; 10967c478bd9Sstevel@tonic-gate struct dca_impl dci; 10977c478bd9Sstevel@tonic-gate char name[MAXNAMELEN]; 10987c478bd9Sstevel@tonic-gate char *fcn = "process_devinfo_tree: "; 10997c478bd9Sstevel@tonic-gate 11007c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%senter\n", fcn); 11017c478bd9Sstevel@tonic-gate 11027c478bd9Sstevel@tonic-gate dca_impl_init("/", NULL, &dci); 11037c478bd9Sstevel@tonic-gate 11047c478bd9Sstevel@tonic-gate lock_dev(); 11057c478bd9Sstevel@tonic-gate 11067c478bd9Sstevel@tonic-gate /* 11077c478bd9Sstevel@tonic-gate * Update kernel driver.conf cache when devfsadm/drvconfig 11087c478bd9Sstevel@tonic-gate * is invoked to build /devices and /dev. 11097c478bd9Sstevel@tonic-gate */ 11107c478bd9Sstevel@tonic-gate if (load_attach_drv == TRUE) 11117c478bd9Sstevel@tonic-gate update_drvconf((major_t)-1); 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate if (single_drv == TRUE) { 11147c478bd9Sstevel@tonic-gate /* 11157c478bd9Sstevel@tonic-gate * load a single driver, but walk the entire devinfo tree 11167c478bd9Sstevel@tonic-gate */ 11177c478bd9Sstevel@tonic-gate if (load_attach_drv == FALSE) 11187c478bd9Sstevel@tonic-gate err_print(DRV_LOAD_REQD); 11197c478bd9Sstevel@tonic-gate 11207c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%sattaching driver (%s)\n", fcn, driver); 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate dci.dci_flags |= DCA_LOAD_DRV; 11237c478bd9Sstevel@tonic-gate (void) snprintf(name, sizeof (name), "%s", driver); 11247c478bd9Sstevel@tonic-gate dci.dci_driver = name; 112598a9beefShtk flags = DINFOCPYALL | DINFOPATH; 11267c478bd9Sstevel@tonic-gate 11277c478bd9Sstevel@tonic-gate } else if (load_attach_drv == TRUE) { 11287c478bd9Sstevel@tonic-gate /* 112945916cd2Sjpk * Load and attach all drivers, then walk the entire tree. 11307c478bd9Sstevel@tonic-gate * If the cache flag is set, use DINFOCACHE to get cached 11317c478bd9Sstevel@tonic-gate * data. 11327c478bd9Sstevel@tonic-gate */ 11337c478bd9Sstevel@tonic-gate if (use_snapshot_cache == TRUE) { 11347c478bd9Sstevel@tonic-gate flags = DINFOCACHE; 11357c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%susing snapshot cache\n", fcn); 11367c478bd9Sstevel@tonic-gate } else { 11377c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%sattaching all drivers\n", fcn); 113898a9beefShtk flags = DI_CACHE_SNAPSHOT_FLAGS; 11393c34adc5Sramat if (cleanup) { 11403c34adc5Sramat /* 11413c34adc5Sramat * remove dangling entries from /etc/devices 11423c34adc5Sramat * files. 11433c34adc5Sramat */ 11443c34adc5Sramat flags |= DINFOCLEANUP; 11453c34adc5Sramat } 11467c478bd9Sstevel@tonic-gate } 114734087db8Shtk } else { 114834087db8Shtk /* 114934087db8Shtk * For devlinks, disks, ports, tapes and devfsadm -n, 115034087db8Shtk * just need to take a snapshot with active devices. 115134087db8Shtk */ 115234087db8Shtk vprint(CHATTY_MID, "%staking snapshot of active devices\n", 11530a653502Swroche fcn); 115434087db8Shtk flags = DINFOCPYALL; 11557c478bd9Sstevel@tonic-gate } 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate if (((load_attach_drv == TRUE) || (single_drv == TRUE)) && 11587c478bd9Sstevel@tonic-gate (build_devices == TRUE)) { 11597c478bd9Sstevel@tonic-gate dci.dci_flags |= DCA_FLUSH_PATHINST; 11607c478bd9Sstevel@tonic-gate } 11617c478bd9Sstevel@tonic-gate 11627c478bd9Sstevel@tonic-gate /* handle pre-cleanup operations desired by the modules. */ 11637c478bd9Sstevel@tonic-gate pre_and_post_cleanup(RM_PRE); 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate devi_tree_walk(&dci, flags, NULL); 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate if (dci.dci_error) { 11687c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1169*537714daSvikram /*NOTREACHED*/ 11707c478bd9Sstevel@tonic-gate } 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate /* handle post-cleanup operations desired by the modules. */ 11737c478bd9Sstevel@tonic-gate pre_and_post_cleanup(RM_POST); 11747c478bd9Sstevel@tonic-gate 11757c478bd9Sstevel@tonic-gate unlock_dev(SYNC_STATE); 11767c478bd9Sstevel@tonic-gate } 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 11797c478bd9Sstevel@tonic-gate static void 11807c478bd9Sstevel@tonic-gate print_cache_signal(int signo) 11817c478bd9Sstevel@tonic-gate { 11827c478bd9Sstevel@tonic-gate if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) { 11837c478bd9Sstevel@tonic-gate err_print("signal SIGUSR1 failed: %s\n", strerror(errno)); 11847c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1185*537714daSvikram /*NOTREACHED*/ 11867c478bd9Sstevel@tonic-gate } 11877c478bd9Sstevel@tonic-gate } 11887c478bd9Sstevel@tonic-gate 1189facf4a8dSllai static void 1190facf4a8dSllai revoke_lookup_door(void) 1191facf4a8dSllai { 1192facf4a8dSllai if (lookup_door_fd != -1) { 1193facf4a8dSllai if (door_revoke(lookup_door_fd) == -1) { 1194facf4a8dSllai err_print("door_revoke of %s failed - %s\n", 1195facf4a8dSllai lookup_door_path, strerror(errno)); 1196facf4a8dSllai } 1197facf4a8dSllai } 1198facf4a8dSllai } 1199facf4a8dSllai 1200facf4a8dSllai /*ARGSUSED*/ 1201facf4a8dSllai static void 1202facf4a8dSllai catch_exit(int signo) 1203facf4a8dSllai { 1204facf4a8dSllai revoke_lookup_door(); 1205facf4a8dSllai } 1206facf4a8dSllai 12077c478bd9Sstevel@tonic-gate /* 12087c478bd9Sstevel@tonic-gate * Register with eventd for messages. Create doors for synchronous 12097c478bd9Sstevel@tonic-gate * link creation. 12107c478bd9Sstevel@tonic-gate */ 12117c478bd9Sstevel@tonic-gate static void 12127c478bd9Sstevel@tonic-gate daemon_update(void) 12137c478bd9Sstevel@tonic-gate { 12147c478bd9Sstevel@tonic-gate int fd; 12157c478bd9Sstevel@tonic-gate char *fcn = "daemon_update: "; 12167c478bd9Sstevel@tonic-gate char door_file[MAXPATHLEN]; 12177c478bd9Sstevel@tonic-gate const char *subclass_list; 12187c478bd9Sstevel@tonic-gate sysevent_handle_t *sysevent_hp; 12197c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%senter\n", fcn); 12207c478bd9Sstevel@tonic-gate 12217c478bd9Sstevel@tonic-gate if (signal(SIGUSR1, print_cache_signal) == SIG_ERR) { 12227c478bd9Sstevel@tonic-gate err_print("signal SIGUSR1 failed: %s\n", strerror(errno)); 12237c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1224*537714daSvikram /*NOTREACHED*/ 12257c478bd9Sstevel@tonic-gate } 1226facf4a8dSllai if (signal(SIGTERM, catch_exit) == SIG_ERR) { 1227facf4a8dSllai err_print("signal SIGTERM failed: %s\n", strerror(errno)); 1228facf4a8dSllai devfsadm_exit(1); 1229*537714daSvikram /*NOTREACHED*/ 1230facf4a8dSllai } 12317c478bd9Sstevel@tonic-gate 12327c478bd9Sstevel@tonic-gate if (snprintf(door_file, sizeof (door_file), 1233facf4a8dSllai "%s%s", attr_root ? attr_root : root_dir, DEVFSADM_SERVICE_DOOR) 1234facf4a8dSllai >= sizeof (door_file)) { 12357c478bd9Sstevel@tonic-gate err_print("update_daemon failed to open sysevent service " 12367c478bd9Sstevel@tonic-gate "door\n"); 12377c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1238*537714daSvikram /*NOTREACHED*/ 12397c478bd9Sstevel@tonic-gate } 12407c478bd9Sstevel@tonic-gate if ((sysevent_hp = sysevent_open_channel_alt( 12417c478bd9Sstevel@tonic-gate door_file)) == NULL) { 12427c478bd9Sstevel@tonic-gate err_print(CANT_CREATE_DOOR, 12430a653502Swroche door_file, strerror(errno)); 12447c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1245*537714daSvikram /*NOTREACHED*/ 12467c478bd9Sstevel@tonic-gate } 12477c478bd9Sstevel@tonic-gate if (sysevent_bind_subscriber(sysevent_hp, event_handler) != 0) { 12487c478bd9Sstevel@tonic-gate err_print(CANT_CREATE_DOOR, 12497c478bd9Sstevel@tonic-gate door_file, strerror(errno)); 12507c478bd9Sstevel@tonic-gate (void) sysevent_close_channel(sysevent_hp); 12517c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1252*537714daSvikram /*NOTREACHED*/ 12537c478bd9Sstevel@tonic-gate } 12547c478bd9Sstevel@tonic-gate subclass_list = EC_SUB_ALL; 12557c478bd9Sstevel@tonic-gate if (sysevent_register_event(sysevent_hp, EC_ALL, &subclass_list, 1) 12567c478bd9Sstevel@tonic-gate != 0) { 12577c478bd9Sstevel@tonic-gate err_print(CANT_CREATE_DOOR, 12587c478bd9Sstevel@tonic-gate door_file, strerror(errno)); 12597c478bd9Sstevel@tonic-gate (void) sysevent_unbind_subscriber(sysevent_hp); 12607c478bd9Sstevel@tonic-gate (void) sysevent_close_channel(sysevent_hp); 12617c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1262*537714daSvikram /*NOTREACHED*/ 12637c478bd9Sstevel@tonic-gate } 1264facf4a8dSllai if (snprintf(door_file, sizeof (door_file), "%s/%s", 1265facf4a8dSllai etc_dev_dir, DEVFSADM_SYNCH_DOOR) >= sizeof (door_file)) { 1266facf4a8dSllai err_print(CANT_CREATE_DOOR, DEVFSADM_SYNCH_DOOR, 12677c478bd9Sstevel@tonic-gate strerror(ENAMETOOLONG)); 12687c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1269*537714daSvikram /*NOTREACHED*/ 12707c478bd9Sstevel@tonic-gate } 1271facf4a8dSllai 12727c478bd9Sstevel@tonic-gate (void) s_unlink(door_file); 1273facf4a8dSllai if ((fd = open(door_file, O_RDWR | O_CREAT, SYNCH_DOOR_PERMS)) == -1) { 1274facf4a8dSllai err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); 12757c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1276*537714daSvikram /*NOTREACHED*/ 12777c478bd9Sstevel@tonic-gate } 12787c478bd9Sstevel@tonic-gate (void) close(fd); 1279facf4a8dSllai 1280facf4a8dSllai if ((fd = door_create(sync_handler, NULL, 12817c478bd9Sstevel@tonic-gate DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) { 1282facf4a8dSllai err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); 12837c478bd9Sstevel@tonic-gate (void) s_unlink(door_file); 12847c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1285*537714daSvikram /*NOTREACHED*/ 12867c478bd9Sstevel@tonic-gate } 1287facf4a8dSllai 12887c478bd9Sstevel@tonic-gate if (fattach(fd, door_file) == -1) { 1289facf4a8dSllai err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); 12907c478bd9Sstevel@tonic-gate (void) s_unlink(door_file); 12917c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1292*537714daSvikram /*NOTREACHED*/ 12937c478bd9Sstevel@tonic-gate } 12947c478bd9Sstevel@tonic-gate 1295facf4a8dSllai /* 1296facf4a8dSllai * devname_lookup_door 1297facf4a8dSllai */ 1298facf4a8dSllai if (snprintf(door_file, sizeof (door_file), "%s/%s", 1299facf4a8dSllai etc_dev_dir, DEVNAME_LOOKUP_DOOR) >= sizeof (door_file)) { 1300facf4a8dSllai err_print(CANT_CREATE_DOOR, DEVNAME_LOOKUP_DOOR, 1301facf4a8dSllai strerror(ENAMETOOLONG)); 1302facf4a8dSllai devfsadm_exit(1); 1303*537714daSvikram /*NOTREACHED*/ 1304facf4a8dSllai } 13057c478bd9Sstevel@tonic-gate 13067c478bd9Sstevel@tonic-gate (void) s_unlink(door_file); 1307facf4a8dSllai if ((fd = open(door_file, O_RDWR | O_CREAT, S_IRUSR|S_IWUSR)) == -1) { 13087c478bd9Sstevel@tonic-gate err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); 13097c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1310*537714daSvikram /*NOTREACHED*/ 13117c478bd9Sstevel@tonic-gate } 13127c478bd9Sstevel@tonic-gate (void) close(fd); 13137c478bd9Sstevel@tonic-gate 1314facf4a8dSllai if ((fd = door_create(devname_lookup_handler, NULL, 1315facf4a8dSllai DOOR_REFUSE_DESC)) == -1) { 13167c478bd9Sstevel@tonic-gate err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); 13177c478bd9Sstevel@tonic-gate (void) s_unlink(door_file); 13187c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1319*537714daSvikram /*NOTREACHED*/ 13207c478bd9Sstevel@tonic-gate } 13217c478bd9Sstevel@tonic-gate 1322facf4a8dSllai (void) fdetach(door_file); 1323facf4a8dSllai lookup_door_path = s_strdup(door_file); 1324facf4a8dSllai retry: 13257c478bd9Sstevel@tonic-gate if (fattach(fd, door_file) == -1) { 1326facf4a8dSllai if (errno == EBUSY) 1327facf4a8dSllai goto retry; 13287c478bd9Sstevel@tonic-gate err_print(CANT_CREATE_DOOR, door_file, strerror(errno)); 13297c478bd9Sstevel@tonic-gate (void) s_unlink(door_file); 13307c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1331*537714daSvikram /*NOTREACHED*/ 13327c478bd9Sstevel@tonic-gate } 1333facf4a8dSllai lookup_door_fd = fd; 13347c478bd9Sstevel@tonic-gate 1335facf4a8dSllai /* pass down the door name to kernel for door_ki_open */ 1336facf4a8dSllai if (devname_kcall(MODDEVNAME_LOOKUPDOOR, (void *)door_file) != 0) 1337facf4a8dSllai err_print(DEVNAME_CONTACT_FAILED, strerror(errno)); 1338facf4a8dSllai else 1339facf4a8dSllai devname_setup_nsmaps(); 13407c478bd9Sstevel@tonic-gate 13417c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%spausing\n", fcn); 13427c478bd9Sstevel@tonic-gate for (;;) { 13437c478bd9Sstevel@tonic-gate (void) pause(); 13447c478bd9Sstevel@tonic-gate } 13457c478bd9Sstevel@tonic-gate } 13467c478bd9Sstevel@tonic-gate 13477c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13487c478bd9Sstevel@tonic-gate static void 13497c478bd9Sstevel@tonic-gate sync_handler(void *cookie, char *ap, size_t asize, 13507c478bd9Sstevel@tonic-gate door_desc_t *dp, uint_t ndesc) 13517c478bd9Sstevel@tonic-gate { 13527c478bd9Sstevel@tonic-gate door_cred_t dcred; 13537c478bd9Sstevel@tonic-gate struct dca_off *dcp, rdca; 13547c478bd9Sstevel@tonic-gate struct dca_impl dci; 13557c478bd9Sstevel@tonic-gate 13567c478bd9Sstevel@tonic-gate /* 13577c478bd9Sstevel@tonic-gate * Must be root to make this call 13587c478bd9Sstevel@tonic-gate * If caller is not root, don't touch its data. 13597c478bd9Sstevel@tonic-gate */ 13607c478bd9Sstevel@tonic-gate if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) { 13617c478bd9Sstevel@tonic-gate dcp = ⤷ 13627c478bd9Sstevel@tonic-gate dcp->dca_error = EPERM; 13637c478bd9Sstevel@tonic-gate goto out; 13647c478bd9Sstevel@tonic-gate } 13657c478bd9Sstevel@tonic-gate 13667c478bd9Sstevel@tonic-gate assert(ap); 13677c478bd9Sstevel@tonic-gate assert(asize == sizeof (*dcp)); 13687c478bd9Sstevel@tonic-gate 13697c478bd9Sstevel@tonic-gate dcp = (void *)ap; 13707c478bd9Sstevel@tonic-gate 13717c478bd9Sstevel@tonic-gate /* 13727c478bd9Sstevel@tonic-gate * Root is always present and is the first component of "name" member 13737c478bd9Sstevel@tonic-gate */ 13747c478bd9Sstevel@tonic-gate assert(dcp->dca_root == 0); 13757c478bd9Sstevel@tonic-gate 13767c478bd9Sstevel@tonic-gate /* 13777c478bd9Sstevel@tonic-gate * The structure passed in by the door_client uses offsets 13787c478bd9Sstevel@tonic-gate * instead of pointers to work across address space boundaries. 13797c478bd9Sstevel@tonic-gate * Now copy the data into a structure (dca_impl) which uses 13807c478bd9Sstevel@tonic-gate * pointers. 13817c478bd9Sstevel@tonic-gate */ 13827c478bd9Sstevel@tonic-gate dci.dci_root = &dcp->dca_name[dcp->dca_root]; 13837c478bd9Sstevel@tonic-gate dci.dci_minor = dcp->dca_minor ? &dcp->dca_name[dcp->dca_minor] : NULL; 13847c478bd9Sstevel@tonic-gate dci.dci_driver = 13857c478bd9Sstevel@tonic-gate dcp->dca_driver ? &dcp->dca_name[dcp->dca_driver] : NULL; 13867c478bd9Sstevel@tonic-gate dci.dci_error = 0; 13877c478bd9Sstevel@tonic-gate dci.dci_flags = dcp->dca_flags | (dci.dci_driver ? DCA_LOAD_DRV : 0); 13887c478bd9Sstevel@tonic-gate dci.dci_arg = NULL; 13897c478bd9Sstevel@tonic-gate 13907c478bd9Sstevel@tonic-gate lock_dev(); 13917c478bd9Sstevel@tonic-gate devi_tree_walk(&dci, DINFOCPYALL, NULL); 13927c478bd9Sstevel@tonic-gate dcp->dca_error = dci.dci_error; 13937c478bd9Sstevel@tonic-gate 1394ff2aee48Scth if (dcp->dca_flags & DCA_DEVLINK_SYNC) 1395ff2aee48Scth unlock_dev(SYNC_STATE); 1396ff2aee48Scth else 1397ff2aee48Scth unlock_dev(CACHE_STATE); 13987c478bd9Sstevel@tonic-gate 1399ff2aee48Scth out: (void) door_return((char *)dcp, sizeof (*dcp), NULL, 0); 14007c478bd9Sstevel@tonic-gate } 14017c478bd9Sstevel@tonic-gate 14027c478bd9Sstevel@tonic-gate static void 14037c478bd9Sstevel@tonic-gate lock_dev(void) 14047c478bd9Sstevel@tonic-gate { 14057c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "lock_dev(): entered\n"); 14067c478bd9Sstevel@tonic-gate 14077c478bd9Sstevel@tonic-gate if (build_dev == FALSE) 14087c478bd9Sstevel@tonic-gate return; 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate /* lockout other threads from /dev */ 14110a653502Swroche while (sema_wait(&dev_sema) != 0) 14120a653502Swroche ; 14137c478bd9Sstevel@tonic-gate 14147c478bd9Sstevel@tonic-gate /* 14157c478bd9Sstevel@tonic-gate * Lock out other devfsadm processes from /dev. 14167c478bd9Sstevel@tonic-gate * If this wasn't the last process to run, 14177c478bd9Sstevel@tonic-gate * clear caches 14187c478bd9Sstevel@tonic-gate */ 14197c478bd9Sstevel@tonic-gate if (enter_dev_lock() != getpid()) { 14207c478bd9Sstevel@tonic-gate invalidate_enumerate_cache(); 14217c478bd9Sstevel@tonic-gate rm_all_links_from_cache(); 14227c478bd9Sstevel@tonic-gate (void) di_devlink_close(&devlink_cache, DI_LINK_ERROR); 1423f05faa4eSjacobs 1424f05faa4eSjacobs /* send any sysevents that were queued up. */ 1425f05faa4eSjacobs process_syseventq(); 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate /* 14297c478bd9Sstevel@tonic-gate * (re)load the reverse links database if not 14307c478bd9Sstevel@tonic-gate * already cached. 14317c478bd9Sstevel@tonic-gate */ 14327c478bd9Sstevel@tonic-gate if (devlink_cache == NULL) 14337c478bd9Sstevel@tonic-gate devlink_cache = di_devlink_open(root_dir, 0); 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate /* 14367c478bd9Sstevel@tonic-gate * If modules were unloaded, reload them. Also use module status 14377c478bd9Sstevel@tonic-gate * as an indication that we should check to see if other binding 14387c478bd9Sstevel@tonic-gate * files need to be reloaded. 14397c478bd9Sstevel@tonic-gate */ 14407c478bd9Sstevel@tonic-gate if (module_head == NULL) { 14417c478bd9Sstevel@tonic-gate load_modules(); 14427c478bd9Sstevel@tonic-gate read_minor_perm_file(); 14437c478bd9Sstevel@tonic-gate read_driver_aliases_file(); 14447c478bd9Sstevel@tonic-gate read_devlinktab_file(); 14457c478bd9Sstevel@tonic-gate read_logindevperm_file(); 14468d483882Smlf read_enumerate_file(); 14477c478bd9Sstevel@tonic-gate } 14487c478bd9Sstevel@tonic-gate 14497c478bd9Sstevel@tonic-gate if (module_head != NULL) 14507c478bd9Sstevel@tonic-gate return; 14517c478bd9Sstevel@tonic-gate 14527c478bd9Sstevel@tonic-gate if (strcmp(prog, DEVLINKS) == 0) { 14537c478bd9Sstevel@tonic-gate if (devlinktab_list == NULL) { 14547c478bd9Sstevel@tonic-gate err_print(NO_LINKTAB, devlinktab_file); 14557c478bd9Sstevel@tonic-gate err_print(NO_MODULES, module_dirs); 14567c478bd9Sstevel@tonic-gate err_print(ABORTING); 14577c478bd9Sstevel@tonic-gate devfsadm_exit(1); 1458*537714daSvikram /*NOTREACHED*/ 14597c478bd9Sstevel@tonic-gate } 14607c478bd9Sstevel@tonic-gate } else { 14617c478bd9Sstevel@tonic-gate err_print(NO_MODULES, module_dirs); 14627c478bd9Sstevel@tonic-gate if (strcmp(prog, DEVFSADM) == 0) { 14637c478bd9Sstevel@tonic-gate err_print(MODIFY_PATH); 14647c478bd9Sstevel@tonic-gate } 14657c478bd9Sstevel@tonic-gate } 14667c478bd9Sstevel@tonic-gate } 14677c478bd9Sstevel@tonic-gate 1468ff2aee48Scth /* 1469ff2aee48Scth * Unlock the device. If we are processing a CACHE_STATE call, we signal a 1470ff2aee48Scth * minor_fini_thread delayed SYNC_STATE at the end of the call. If we are 1471ff2aee48Scth * processing a SYNC_STATE call, we cancel any minor_fini_thread SYNC_STATE 1472ff2aee48Scth * at both the start and end of the call since we will be doing the SYNC_STATE. 1473ff2aee48Scth */ 14747c478bd9Sstevel@tonic-gate static void 14757c478bd9Sstevel@tonic-gate unlock_dev(int flag) 14767c478bd9Sstevel@tonic-gate { 1477ff2aee48Scth assert(flag == SYNC_STATE || flag == CACHE_STATE); 1478ff2aee48Scth 14797c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "unlock_dev(): entered\n"); 14807c478bd9Sstevel@tonic-gate 1481ff2aee48Scth /* If we are starting a SYNC_STATE, cancel minor_fini_thread SYNC */ 1482ff2aee48Scth if (flag == SYNC_STATE) { 1483ff2aee48Scth (void) mutex_lock(&minor_fini_mutex); 1484ff2aee48Scth minor_fini_canceled = TRUE; 1485ff2aee48Scth minor_fini_delayed = FALSE; 1486ff2aee48Scth (void) mutex_unlock(&minor_fini_mutex); 1487ff2aee48Scth } 1488ff2aee48Scth 14897c478bd9Sstevel@tonic-gate if (build_dev == FALSE) 14907c478bd9Sstevel@tonic-gate return; 14917c478bd9Sstevel@tonic-gate 1492568e756aSvikram if (devlink_cache == NULL) { 1493568e756aSvikram err_print(NO_DEVLINK_CACHE); 1494568e756aSvikram } 14957c478bd9Sstevel@tonic-gate assert(devlink_cache); 14967c478bd9Sstevel@tonic-gate 14977c478bd9Sstevel@tonic-gate if (flag == SYNC_STATE) { 14987c478bd9Sstevel@tonic-gate unload_modules(); 14997c478bd9Sstevel@tonic-gate if (update_database) 15007c478bd9Sstevel@tonic-gate (void) di_devlink_update(devlink_cache); 15017c478bd9Sstevel@tonic-gate (void) di_devlink_close(&devlink_cache, 0); 1502f05faa4eSjacobs 1503f05faa4eSjacobs /* 1504f05faa4eSjacobs * now that the devlinks db cache has been flushed, it is safe 1505f05faa4eSjacobs * to send any sysevents that were queued up. 1506f05faa4eSjacobs */ 1507f05faa4eSjacobs process_syseventq(); 15087c478bd9Sstevel@tonic-gate } 15097c478bd9Sstevel@tonic-gate 1510*537714daSvikram exit_dev_lock(0); 15117c478bd9Sstevel@tonic-gate 1512ff2aee48Scth (void) mutex_lock(&minor_fini_mutex); 1513ff2aee48Scth if (flag == SYNC_STATE) { 1514ff2aee48Scth /* We did a SYNC_STATE, cancel minor_fini_thread SYNC */ 1515ff2aee48Scth minor_fini_canceled = TRUE; 1516ff2aee48Scth minor_fini_delayed = FALSE; 1517ff2aee48Scth } else { 1518ff2aee48Scth /* We did a CACHE_STATE, start delayed minor_fini_thread SYNC */ 1519ff2aee48Scth minor_fini_canceled = FALSE; 1520ff2aee48Scth minor_fini_delayed = TRUE; 1521ff2aee48Scth (void) cond_signal(&minor_fini_cv); 1522ff2aee48Scth } 1523ff2aee48Scth (void) mutex_unlock(&minor_fini_mutex); 1524ff2aee48Scth 15257c478bd9Sstevel@tonic-gate (void) sema_post(&dev_sema); 15267c478bd9Sstevel@tonic-gate } 15277c478bd9Sstevel@tonic-gate 15287c478bd9Sstevel@tonic-gate /* 15297c478bd9Sstevel@tonic-gate * Check that if -r is set, it is not any part of a zone--- that is, that 15307c478bd9Sstevel@tonic-gate * the zonepath is not a substring of the root path. 15317c478bd9Sstevel@tonic-gate */ 15327c478bd9Sstevel@tonic-gate static int 15337c478bd9Sstevel@tonic-gate zone_pathcheck(char *checkpath) 15347c478bd9Sstevel@tonic-gate { 15357c478bd9Sstevel@tonic-gate void *dlhdl = NULL; 15367c478bd9Sstevel@tonic-gate char *name; 15377c478bd9Sstevel@tonic-gate char root[MAXPATHLEN]; /* resolved devfsadm root path */ 15387c478bd9Sstevel@tonic-gate char zroot[MAXPATHLEN]; /* zone root path */ 15397c478bd9Sstevel@tonic-gate char rzroot[MAXPATHLEN]; /* resolved zone root path */ 1540facf4a8dSllai char tmp[MAXPATHLEN]; 15417c478bd9Sstevel@tonic-gate FILE *cookie; 15427c478bd9Sstevel@tonic-gate int err = DEVFSADM_SUCCESS; 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate if (checkpath[0] == '\0') 15457c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 15467c478bd9Sstevel@tonic-gate 15477c478bd9Sstevel@tonic-gate /* 15487c478bd9Sstevel@tonic-gate * Check if zones is available on this system. 15497c478bd9Sstevel@tonic-gate */ 15507c478bd9Sstevel@tonic-gate if ((dlhdl = dlopen(LIBZONECFG_PATH, RTLD_LAZY)) == NULL) { 15517c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 15527c478bd9Sstevel@tonic-gate } 15537c478bd9Sstevel@tonic-gate 15547c478bd9Sstevel@tonic-gate bzero(root, sizeof (root)); 15557c478bd9Sstevel@tonic-gate if (resolvepath(checkpath, root, sizeof (root) - 1) == -1) { 15567c478bd9Sstevel@tonic-gate /* 1557facf4a8dSllai * In this case the user has done "devfsadm -r" on some path 15587c478bd9Sstevel@tonic-gate * which does not yet exist, or we got some other misc. error. 15597c478bd9Sstevel@tonic-gate * We punt and don't resolve the path in this case. 15607c478bd9Sstevel@tonic-gate */ 15617c478bd9Sstevel@tonic-gate (void) strlcpy(root, checkpath, sizeof (root)); 15627c478bd9Sstevel@tonic-gate } 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate if (strlen(root) > 0 && (root[strlen(root) - 1] != '/')) { 15657c478bd9Sstevel@tonic-gate (void) snprintf(tmp, sizeof (tmp), "%s/", root); 15667c478bd9Sstevel@tonic-gate (void) strlcpy(root, tmp, sizeof (root)); 15677c478bd9Sstevel@tonic-gate } 15687c478bd9Sstevel@tonic-gate 15697c478bd9Sstevel@tonic-gate cookie = setzoneent(); 15707c478bd9Sstevel@tonic-gate while ((name = getzoneent(cookie)) != NULL) { 15717c478bd9Sstevel@tonic-gate /* Skip the global zone */ 15727c478bd9Sstevel@tonic-gate if (strcmp(name, GLOBAL_ZONENAME) == 0) { 15737c478bd9Sstevel@tonic-gate free(name); 15747c478bd9Sstevel@tonic-gate continue; 15757c478bd9Sstevel@tonic-gate } 15767c478bd9Sstevel@tonic-gate 15777c478bd9Sstevel@tonic-gate if (zone_get_zonepath(name, zroot, sizeof (zroot)) != Z_OK) { 15787c478bd9Sstevel@tonic-gate free(name); 15797c478bd9Sstevel@tonic-gate continue; 15807c478bd9Sstevel@tonic-gate } 15817c478bd9Sstevel@tonic-gate 15827c478bd9Sstevel@tonic-gate bzero(rzroot, sizeof (rzroot)); 15837c478bd9Sstevel@tonic-gate if (resolvepath(zroot, rzroot, sizeof (rzroot) - 1) == -1) { 15847c478bd9Sstevel@tonic-gate /* 15857c478bd9Sstevel@tonic-gate * Zone path doesn't exist, or other misc error, 15867c478bd9Sstevel@tonic-gate * so we try using the non-resolved pathname. 15877c478bd9Sstevel@tonic-gate */ 15887c478bd9Sstevel@tonic-gate (void) strlcpy(rzroot, zroot, sizeof (rzroot)); 15897c478bd9Sstevel@tonic-gate } 15907c478bd9Sstevel@tonic-gate if (strlen(rzroot) > 0 && (rzroot[strlen(rzroot) - 1] != '/')) { 15917c478bd9Sstevel@tonic-gate (void) snprintf(tmp, sizeof (tmp), "%s/", rzroot); 15927c478bd9Sstevel@tonic-gate (void) strlcpy(rzroot, tmp, sizeof (rzroot)); 15937c478bd9Sstevel@tonic-gate } 15947c478bd9Sstevel@tonic-gate 15957c478bd9Sstevel@tonic-gate /* 15967c478bd9Sstevel@tonic-gate * Finally, the comparison. If the zone root path is a 15977c478bd9Sstevel@tonic-gate * leading substring of the root path, fail. 15987c478bd9Sstevel@tonic-gate */ 15997c478bd9Sstevel@tonic-gate if (strncmp(rzroot, root, strlen(rzroot)) == 0) { 16007c478bd9Sstevel@tonic-gate err_print(ZONE_PATHCHECK, root, name); 16017c478bd9Sstevel@tonic-gate err = DEVFSADM_FAILURE; 16027c478bd9Sstevel@tonic-gate free(name); 16037c478bd9Sstevel@tonic-gate break; 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate free(name); 16067c478bd9Sstevel@tonic-gate } 16077c478bd9Sstevel@tonic-gate endzoneent(cookie); 16087c478bd9Sstevel@tonic-gate (void) dlclose(dlhdl); 16097c478bd9Sstevel@tonic-gate return (err); 16107c478bd9Sstevel@tonic-gate } 16117c478bd9Sstevel@tonic-gate 16127c478bd9Sstevel@tonic-gate /* 16137c478bd9Sstevel@tonic-gate * Called by the daemon when it receives an event from the devfsadm SLM 16147c478bd9Sstevel@tonic-gate * to syseventd. 16157c478bd9Sstevel@tonic-gate * 16167c478bd9Sstevel@tonic-gate * The devfsadm SLM uses a private event channel for communication to 16177c478bd9Sstevel@tonic-gate * devfsadmd set-up via private libsysevent interfaces. This handler is 16187c478bd9Sstevel@tonic-gate * used to bind to the devfsadmd channel for event delivery. 16197c478bd9Sstevel@tonic-gate * The devfsadmd SLM insures single calls to this routine as well as 16207c478bd9Sstevel@tonic-gate * synchronized event delivery. 16217c478bd9Sstevel@tonic-gate * 16227c478bd9Sstevel@tonic-gate */ 16237c478bd9Sstevel@tonic-gate static void 16247c478bd9Sstevel@tonic-gate event_handler(sysevent_t *ev) 16257c478bd9Sstevel@tonic-gate { 16267c478bd9Sstevel@tonic-gate char *path; 16277c478bd9Sstevel@tonic-gate char *minor; 16287c478bd9Sstevel@tonic-gate char *subclass; 16297c478bd9Sstevel@tonic-gate char *dev_ev_subclass; 16307c478bd9Sstevel@tonic-gate char *driver_name; 16317c478bd9Sstevel@tonic-gate nvlist_t *attr_list = NULL; 16327c478bd9Sstevel@tonic-gate int err = 0; 16337c478bd9Sstevel@tonic-gate int instance; 16347c478bd9Sstevel@tonic-gate int branch_event = 0; 16357c478bd9Sstevel@tonic-gate 16367c478bd9Sstevel@tonic-gate subclass = sysevent_get_subclass_name(ev); 16377c478bd9Sstevel@tonic-gate vprint(EVENT_MID, "event_handler: %s id:0X%llx\n", 16387c478bd9Sstevel@tonic-gate subclass, sysevent_get_seq(ev)); 16397c478bd9Sstevel@tonic-gate 1640facf4a8dSllai if (strcmp(subclass, ESC_DEVFS_START) == 0) { 1641facf4a8dSllai return; 1642facf4a8dSllai } 1643facf4a8dSllai 16447c478bd9Sstevel@tonic-gate /* Check if event is an instance modification */ 16457c478bd9Sstevel@tonic-gate if (strcmp(subclass, ESC_DEVFS_INSTANCE_MOD) == 0) { 16467c478bd9Sstevel@tonic-gate devfs_instance_mod(); 16477c478bd9Sstevel@tonic-gate return; 16487c478bd9Sstevel@tonic-gate } 16497c478bd9Sstevel@tonic-gate if (sysevent_get_attr_list(ev, &attr_list) != 0) { 16507c478bd9Sstevel@tonic-gate vprint(EVENT_MID, "event_handler: can not get attr list\n"); 16517c478bd9Sstevel@tonic-gate return; 16527c478bd9Sstevel@tonic-gate } 16537c478bd9Sstevel@tonic-gate 16547c478bd9Sstevel@tonic-gate if (strcmp(subclass, ESC_DEVFS_DEVI_ADD) == 0 || 16557c478bd9Sstevel@tonic-gate strcmp(subclass, ESC_DEVFS_DEVI_REMOVE) == 0 || 16567c478bd9Sstevel@tonic-gate strcmp(subclass, ESC_DEVFS_MINOR_CREATE) == 0 || 16577c478bd9Sstevel@tonic-gate strcmp(subclass, ESC_DEVFS_MINOR_REMOVE) == 0) { 16587c478bd9Sstevel@tonic-gate if ((err = nvlist_lookup_string(attr_list, DEVFS_PATHNAME, 16597c478bd9Sstevel@tonic-gate &path)) != 0) 16607c478bd9Sstevel@tonic-gate goto out; 16617c478bd9Sstevel@tonic-gate 166230294554Sphitran if (nvlist_lookup_string(attr_list, DEVFS_DEVI_CLASS, 166330294554Sphitran &dev_ev_subclass) != 0) 166430294554Sphitran dev_ev_subclass = NULL; 16657c478bd9Sstevel@tonic-gate 166630294554Sphitran if (nvlist_lookup_string(attr_list, DEVFS_DRIVER_NAME, 166730294554Sphitran &driver_name) != 0) 166830294554Sphitran driver_name = NULL; 16697c478bd9Sstevel@tonic-gate 167030294554Sphitran if (nvlist_lookup_int32(attr_list, DEVFS_INSTANCE, 167130294554Sphitran &instance) != 0) 167230294554Sphitran instance = -1; 16737c478bd9Sstevel@tonic-gate 167430294554Sphitran if (nvlist_lookup_int32(attr_list, DEVFS_BRANCH_EVENT, 167530294554Sphitran &branch_event) != 0) 167630294554Sphitran branch_event = 0; 16777c478bd9Sstevel@tonic-gate 167830294554Sphitran if (nvlist_lookup_string(attr_list, DEVFS_MINOR_NAME, 167930294554Sphitran &minor) != 0) 168030294554Sphitran minor = NULL; 16817c478bd9Sstevel@tonic-gate 16827c478bd9Sstevel@tonic-gate lock_dev(); 16837c478bd9Sstevel@tonic-gate 16847c478bd9Sstevel@tonic-gate if (strcmp(ESC_DEVFS_DEVI_ADD, subclass) == 0) { 16857c478bd9Sstevel@tonic-gate add_minor_pathname(path, NULL, dev_ev_subclass); 16867c478bd9Sstevel@tonic-gate if (branch_event) { 1687f05faa4eSjacobs build_and_enq_event(EC_DEV_BRANCH, 168830294554Sphitran ESC_DEV_BRANCH_ADD, path, DI_NODE_NIL, 168930294554Sphitran NULL); 16907c478bd9Sstevel@tonic-gate } 16917c478bd9Sstevel@tonic-gate 16927c478bd9Sstevel@tonic-gate } else if (strcmp(ESC_DEVFS_MINOR_CREATE, subclass) == 0) { 169330294554Sphitran add_minor_pathname(path, minor, dev_ev_subclass); 16947c478bd9Sstevel@tonic-gate 16957c478bd9Sstevel@tonic-gate } else if (strcmp(ESC_DEVFS_MINOR_REMOVE, subclass) == 0) { 169630294554Sphitran hot_cleanup(path, minor, dev_ev_subclass, driver_name, 169730294554Sphitran instance); 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate } else { /* ESC_DEVFS_DEVI_REMOVE */ 17007c478bd9Sstevel@tonic-gate hot_cleanup(path, NULL, dev_ev_subclass, 17017c478bd9Sstevel@tonic-gate driver_name, instance); 17027c478bd9Sstevel@tonic-gate if (branch_event) { 1703f05faa4eSjacobs build_and_enq_event(EC_DEV_BRANCH, 170430294554Sphitran ESC_DEV_BRANCH_REMOVE, path, DI_NODE_NIL, 170530294554Sphitran NULL); 17067c478bd9Sstevel@tonic-gate } 17077c478bd9Sstevel@tonic-gate } 17087c478bd9Sstevel@tonic-gate 17097c478bd9Sstevel@tonic-gate unlock_dev(CACHE_STATE); 17107c478bd9Sstevel@tonic-gate 17117c478bd9Sstevel@tonic-gate } else if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0 || 17127c478bd9Sstevel@tonic-gate strcmp(subclass, ESC_DEVFS_BRANCH_REMOVE) == 0) { 17137c478bd9Sstevel@tonic-gate if ((err = nvlist_lookup_string(attr_list, 17147c478bd9Sstevel@tonic-gate DEVFS_PATHNAME, &path)) != 0) 17157c478bd9Sstevel@tonic-gate goto out; 17167c478bd9Sstevel@tonic-gate 17177c478bd9Sstevel@tonic-gate /* just log ESC_DEV_BRANCH... event */ 17187c478bd9Sstevel@tonic-gate if (strcmp(subclass, ESC_DEVFS_BRANCH_ADD) == 0) 17197c478bd9Sstevel@tonic-gate dev_ev_subclass = ESC_DEV_BRANCH_ADD; 17207c478bd9Sstevel@tonic-gate else 17217c478bd9Sstevel@tonic-gate dev_ev_subclass = ESC_DEV_BRANCH_REMOVE; 17227c478bd9Sstevel@tonic-gate 1723d2596142Scth lock_dev(); 1724f05faa4eSjacobs build_and_enq_event(EC_DEV_BRANCH, dev_ev_subclass, path, 172530294554Sphitran DI_NODE_NIL, NULL); 1726d2596142Scth unlock_dev(CACHE_STATE); 17277c478bd9Sstevel@tonic-gate } else 17287c478bd9Sstevel@tonic-gate err_print(UNKNOWN_EVENT, subclass); 17297c478bd9Sstevel@tonic-gate 17307c478bd9Sstevel@tonic-gate out: 17317c478bd9Sstevel@tonic-gate if (err) 17327c478bd9Sstevel@tonic-gate err_print(EVENT_ATTR_LOOKUP_FAILED, strerror(err)); 17337c478bd9Sstevel@tonic-gate nvlist_free(attr_list); 17347c478bd9Sstevel@tonic-gate } 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate static void 17377c478bd9Sstevel@tonic-gate dca_impl_init(char *root, char *minor, struct dca_impl *dcip) 17387c478bd9Sstevel@tonic-gate { 17397c478bd9Sstevel@tonic-gate assert(root); 17407c478bd9Sstevel@tonic-gate 17417c478bd9Sstevel@tonic-gate dcip->dci_root = root; 17427c478bd9Sstevel@tonic-gate dcip->dci_minor = minor; 17437c478bd9Sstevel@tonic-gate dcip->dci_driver = NULL; 17447c478bd9Sstevel@tonic-gate dcip->dci_error = 0; 17457c478bd9Sstevel@tonic-gate dcip->dci_flags = 0; 17467c478bd9Sstevel@tonic-gate dcip->dci_arg = NULL; 17477c478bd9Sstevel@tonic-gate } 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate /* 17507c478bd9Sstevel@tonic-gate * Kernel logs a message when a devinfo node is attached. Try to create 17517c478bd9Sstevel@tonic-gate * /dev and /devices for each minor node. minorname can be NULL. 17527c478bd9Sstevel@tonic-gate */ 17537c478bd9Sstevel@tonic-gate void 17547c478bd9Sstevel@tonic-gate add_minor_pathname(char *node, char *minor, char *ev_subclass) 17557c478bd9Sstevel@tonic-gate { 17567c478bd9Sstevel@tonic-gate struct dca_impl dci; 17577c478bd9Sstevel@tonic-gate 17587c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "add_minor_pathname: node_path=%s minor=%s\n", 17597c478bd9Sstevel@tonic-gate node, minor ? minor : "NULL"); 17607c478bd9Sstevel@tonic-gate 17617c478bd9Sstevel@tonic-gate dca_impl_init(node, minor, &dci); 17627c478bd9Sstevel@tonic-gate 17637c478bd9Sstevel@tonic-gate /* 17647c478bd9Sstevel@tonic-gate * Restrict hotplug link creation if daemon 17657c478bd9Sstevel@tonic-gate * started with -i option. 17667c478bd9Sstevel@tonic-gate */ 17677c478bd9Sstevel@tonic-gate if (single_drv == TRUE) { 17687c478bd9Sstevel@tonic-gate dci.dci_driver = driver; 17697c478bd9Sstevel@tonic-gate } 17707c478bd9Sstevel@tonic-gate 17717c478bd9Sstevel@tonic-gate /* 17727c478bd9Sstevel@tonic-gate * We are being invoked in response to a hotplug 17737c478bd9Sstevel@tonic-gate * event. Also, notify RCM if nodetype indicates 17747c478bd9Sstevel@tonic-gate * a network device has been hotplugged. 17757c478bd9Sstevel@tonic-gate */ 17767c478bd9Sstevel@tonic-gate dci.dci_flags = DCA_HOT_PLUG | DCA_CHECK_TYPE; 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate devi_tree_walk(&dci, DINFOPROP|DINFOMINOR, ev_subclass); 17797c478bd9Sstevel@tonic-gate } 17807c478bd9Sstevel@tonic-gate 17817c478bd9Sstevel@tonic-gate static di_node_t 17827c478bd9Sstevel@tonic-gate find_clone_node() 17837c478bd9Sstevel@tonic-gate { 17847c478bd9Sstevel@tonic-gate static di_node_t clone_node = DI_NODE_NIL; 17857c478bd9Sstevel@tonic-gate 17867c478bd9Sstevel@tonic-gate if (clone_node == DI_NODE_NIL) 17877c478bd9Sstevel@tonic-gate clone_node = di_init("/pseudo/clone@0", DINFOPROP); 17887c478bd9Sstevel@tonic-gate return (clone_node); 17897c478bd9Sstevel@tonic-gate } 17907c478bd9Sstevel@tonic-gate 17917c478bd9Sstevel@tonic-gate static int 17927c478bd9Sstevel@tonic-gate is_descendent_of(di_node_t node, char *driver) 17937c478bd9Sstevel@tonic-gate { 17947c478bd9Sstevel@tonic-gate while (node != DI_NODE_NIL) { 17957c478bd9Sstevel@tonic-gate char *drv = di_driver_name(node); 17967c478bd9Sstevel@tonic-gate if (strcmp(drv, driver) == 0) 17977c478bd9Sstevel@tonic-gate return (1); 17987c478bd9Sstevel@tonic-gate node = di_parent_node(node); 17997c478bd9Sstevel@tonic-gate } 18007c478bd9Sstevel@tonic-gate return (0); 18017c478bd9Sstevel@tonic-gate } 18027c478bd9Sstevel@tonic-gate 18037c478bd9Sstevel@tonic-gate /* 18047c478bd9Sstevel@tonic-gate * Checks the minor type. If it is an alias node, then lookup 18057c478bd9Sstevel@tonic-gate * the real node/minor first, then call minor_process() to 18067c478bd9Sstevel@tonic-gate * do the real work. 18077c478bd9Sstevel@tonic-gate */ 18087c478bd9Sstevel@tonic-gate static int 18097c478bd9Sstevel@tonic-gate check_minor_type(di_node_t node, di_minor_t minor, void *arg) 18107c478bd9Sstevel@tonic-gate { 18117c478bd9Sstevel@tonic-gate ddi_minor_type minor_type; 18127c478bd9Sstevel@tonic-gate di_node_t clone_node; 18137c478bd9Sstevel@tonic-gate char *mn; 18147c478bd9Sstevel@tonic-gate char *nt; 18157c478bd9Sstevel@tonic-gate struct mlist *dep; 18167c478bd9Sstevel@tonic-gate struct dca_impl *dcip = arg; 18177c478bd9Sstevel@tonic-gate 18187c478bd9Sstevel@tonic-gate assert(dcip); 18197c478bd9Sstevel@tonic-gate 18207c478bd9Sstevel@tonic-gate dep = dcip->dci_arg; 18217c478bd9Sstevel@tonic-gate 18227c478bd9Sstevel@tonic-gate mn = di_minor_name(minor); 18237c478bd9Sstevel@tonic-gate 18247c478bd9Sstevel@tonic-gate /* 18257c478bd9Sstevel@tonic-gate * We match driver here instead of in minor_process 18267c478bd9Sstevel@tonic-gate * as we want the actual driver name. This check is 18277c478bd9Sstevel@tonic-gate * unnecessary during deferred processing. 18287c478bd9Sstevel@tonic-gate */ 18297c478bd9Sstevel@tonic-gate if (dep && 18307c478bd9Sstevel@tonic-gate ((dcip->dci_driver && !is_descendent_of(node, dcip->dci_driver)) || 18317c478bd9Sstevel@tonic-gate (dcip->dci_minor && strcmp(mn, dcip->dci_minor)))) { 18327c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 18337c478bd9Sstevel@tonic-gate } 18347c478bd9Sstevel@tonic-gate 18357c478bd9Sstevel@tonic-gate if ((dcip->dci_flags & DCA_CHECK_TYPE) && 18367c478bd9Sstevel@tonic-gate (nt = di_minor_nodetype(minor)) && 1837210db224Sericheng (strcmp(nt, DDI_NT_NET) == 0)) { 18387c478bd9Sstevel@tonic-gate dcip->dci_flags |= DCA_NOTIFY_RCM; 18397c478bd9Sstevel@tonic-gate dcip->dci_flags &= ~DCA_CHECK_TYPE; 18407c478bd9Sstevel@tonic-gate } 18417c478bd9Sstevel@tonic-gate 18427c478bd9Sstevel@tonic-gate minor_type = di_minor_type(minor); 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate if (minor_type == DDM_MINOR) { 18457c478bd9Sstevel@tonic-gate minor_process(node, minor, dep); 18467c478bd9Sstevel@tonic-gate 18477c478bd9Sstevel@tonic-gate } else if (minor_type == DDM_ALIAS) { 18487c478bd9Sstevel@tonic-gate struct mlist *cdep, clone_del = {0}; 18497c478bd9Sstevel@tonic-gate 18507c478bd9Sstevel@tonic-gate clone_node = find_clone_node(); 18517c478bd9Sstevel@tonic-gate if (clone_node == DI_NODE_NIL) { 18527c478bd9Sstevel@tonic-gate err_print(DI_INIT_FAILED, "clone", strerror(errno)); 18537c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 18547c478bd9Sstevel@tonic-gate } 18557c478bd9Sstevel@tonic-gate 18567c478bd9Sstevel@tonic-gate cdep = dep ? &clone_del : NULL; 18577c478bd9Sstevel@tonic-gate 18587c478bd9Sstevel@tonic-gate minor_process(clone_node, minor, cdep); 18597c478bd9Sstevel@tonic-gate 18607c478bd9Sstevel@tonic-gate /* 18617c478bd9Sstevel@tonic-gate * cache "alias" minor node and free "clone" minor 18627c478bd9Sstevel@tonic-gate */ 18637c478bd9Sstevel@tonic-gate if (cdep != NULL && cdep->head != NULL) { 18647c478bd9Sstevel@tonic-gate assert(cdep->tail != NULL); 18657c478bd9Sstevel@tonic-gate cache_deferred_minor(dep, node, minor); 18667c478bd9Sstevel@tonic-gate dcip->dci_arg = cdep; 18677c478bd9Sstevel@tonic-gate process_deferred_links(dcip, DCA_FREE_LIST); 18687c478bd9Sstevel@tonic-gate dcip->dci_arg = dep; 18697c478bd9Sstevel@tonic-gate } 18707c478bd9Sstevel@tonic-gate } 18717c478bd9Sstevel@tonic-gate 18727c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 18737c478bd9Sstevel@tonic-gate } 18747c478bd9Sstevel@tonic-gate 18757c478bd9Sstevel@tonic-gate 18767c478bd9Sstevel@tonic-gate /* 18777c478bd9Sstevel@tonic-gate * This is the entry point for each minor node, whether walking 18787c478bd9Sstevel@tonic-gate * the entire tree via di_walk_minor() or processing a hotplug event 18797c478bd9Sstevel@tonic-gate * for a single devinfo node (via hotplug ndi_devi_online()). 18807c478bd9Sstevel@tonic-gate */ 18817c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 18827c478bd9Sstevel@tonic-gate static void 18837c478bd9Sstevel@tonic-gate minor_process(di_node_t node, di_minor_t minor, struct mlist *dep) 18847c478bd9Sstevel@tonic-gate { 18857c478bd9Sstevel@tonic-gate create_list_t *create; 18867c478bd9Sstevel@tonic-gate int defer; 18877c478bd9Sstevel@tonic-gate 18887c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "minor_process: node=%s, minor=%s\n", 18890a653502Swroche di_node_name(node), di_minor_name(minor)); 18907c478bd9Sstevel@tonic-gate 18917c478bd9Sstevel@tonic-gate if (dep != NULL) { 18927c478bd9Sstevel@tonic-gate 18937c478bd9Sstevel@tonic-gate /* 18947c478bd9Sstevel@tonic-gate * Reset /devices node to minor_perm perm/ownership 18957c478bd9Sstevel@tonic-gate * if we are here to deactivate device allocation 18967c478bd9Sstevel@tonic-gate */ 18977c478bd9Sstevel@tonic-gate if (build_devices == TRUE) { 18987c478bd9Sstevel@tonic-gate reset_node_permissions(node, minor); 18997c478bd9Sstevel@tonic-gate } 19007c478bd9Sstevel@tonic-gate 19017c478bd9Sstevel@tonic-gate if (build_dev == FALSE) { 19027c478bd9Sstevel@tonic-gate return; 19037c478bd9Sstevel@tonic-gate } 19047c478bd9Sstevel@tonic-gate 19057c478bd9Sstevel@tonic-gate /* 19067c478bd9Sstevel@tonic-gate * This function will create any nodes for /etc/devlink.tab. 19077c478bd9Sstevel@tonic-gate * If devlink.tab handles link creation, we don't call any 19087c478bd9Sstevel@tonic-gate * devfsadm modules since that could cause duplicate caching 19097c478bd9Sstevel@tonic-gate * in the enumerate functions if different re strings are 19107c478bd9Sstevel@tonic-gate * passed that are logically identical. I'm still not 19117c478bd9Sstevel@tonic-gate * convinced this would cause any harm, but better to be safe. 19127c478bd9Sstevel@tonic-gate * 19137c478bd9Sstevel@tonic-gate * Deferred processing is available only for devlinks 19147c478bd9Sstevel@tonic-gate * created through devfsadm modules. 19157c478bd9Sstevel@tonic-gate */ 19167c478bd9Sstevel@tonic-gate if (process_devlink_compat(minor, node) == TRUE) { 19177c478bd9Sstevel@tonic-gate return; 19187c478bd9Sstevel@tonic-gate } 19197c478bd9Sstevel@tonic-gate } else { 19207c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "minor_process: deferred processing\n"); 19217c478bd9Sstevel@tonic-gate } 19227c478bd9Sstevel@tonic-gate 19237c478bd9Sstevel@tonic-gate /* 19247c478bd9Sstevel@tonic-gate * look for relevant link create rules in the modules, and 19257c478bd9Sstevel@tonic-gate * invoke the link create callback function to build a link 19267c478bd9Sstevel@tonic-gate * if there is a match. 19277c478bd9Sstevel@tonic-gate */ 19287c478bd9Sstevel@tonic-gate defer = 0; 19297c478bd9Sstevel@tonic-gate for (create = create_head; create != NULL; create = create->next) { 19307c478bd9Sstevel@tonic-gate if ((minor_matches_rule(node, minor, create) == TRUE) && 19317c478bd9Sstevel@tonic-gate class_ok(create->create->device_class) == 19327c478bd9Sstevel@tonic-gate DEVFSADM_SUCCESS) { 19337c478bd9Sstevel@tonic-gate if (call_minor_init(create->modptr) == 19347c478bd9Sstevel@tonic-gate DEVFSADM_FAILURE) { 19357c478bd9Sstevel@tonic-gate continue; 19367c478bd9Sstevel@tonic-gate } 19377c478bd9Sstevel@tonic-gate 19387c478bd9Sstevel@tonic-gate /* 19397c478bd9Sstevel@tonic-gate * If NOT doing the deferred creates (i.e. 1st pass) and 19407c478bd9Sstevel@tonic-gate * rule requests deferred processing cache the minor 19417c478bd9Sstevel@tonic-gate * data. 19427c478bd9Sstevel@tonic-gate * 19437c478bd9Sstevel@tonic-gate * If deferred processing (2nd pass), create links 19447c478bd9Sstevel@tonic-gate * ONLY if rule requests deferred processing. 19457c478bd9Sstevel@tonic-gate */ 19467c478bd9Sstevel@tonic-gate if (dep && ((create->create->flags & CREATE_MASK) == 19477c478bd9Sstevel@tonic-gate CREATE_DEFER)) { 19487c478bd9Sstevel@tonic-gate defer = 1; 19497c478bd9Sstevel@tonic-gate continue; 19507c478bd9Sstevel@tonic-gate } else if (dep == NULL && 19517c478bd9Sstevel@tonic-gate ((create->create->flags & CREATE_MASK) != 19527c478bd9Sstevel@tonic-gate CREATE_DEFER)) { 19537c478bd9Sstevel@tonic-gate continue; 19547c478bd9Sstevel@tonic-gate } 19557c478bd9Sstevel@tonic-gate 19567c478bd9Sstevel@tonic-gate if ((*(create->create->callback_fcn)) 19577c478bd9Sstevel@tonic-gate (minor, node) == DEVFSADM_TERMINATE) { 19587c478bd9Sstevel@tonic-gate break; 19597c478bd9Sstevel@tonic-gate } 19607c478bd9Sstevel@tonic-gate } 19617c478bd9Sstevel@tonic-gate } 19627c478bd9Sstevel@tonic-gate 19637c478bd9Sstevel@tonic-gate if (defer) 19647c478bd9Sstevel@tonic-gate cache_deferred_minor(dep, node, minor); 19657c478bd9Sstevel@tonic-gate } 19667c478bd9Sstevel@tonic-gate 19677c478bd9Sstevel@tonic-gate 19687c478bd9Sstevel@tonic-gate /* 19697c478bd9Sstevel@tonic-gate * Cache node and minor in defer list. 19707c478bd9Sstevel@tonic-gate */ 19717c478bd9Sstevel@tonic-gate static void 19727c478bd9Sstevel@tonic-gate cache_deferred_minor( 19737c478bd9Sstevel@tonic-gate struct mlist *dep, 19747c478bd9Sstevel@tonic-gate di_node_t node, 19757c478bd9Sstevel@tonic-gate di_minor_t minor) 19767c478bd9Sstevel@tonic-gate { 19777c478bd9Sstevel@tonic-gate struct minor *mp; 19787c478bd9Sstevel@tonic-gate const char *fcn = "cache_deferred_minor"; 19797c478bd9Sstevel@tonic-gate 19807c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%s node=%s, minor=%s\n", fcn, 19817c478bd9Sstevel@tonic-gate di_node_name(node), di_minor_name(minor)); 19827c478bd9Sstevel@tonic-gate 19837c478bd9Sstevel@tonic-gate if (dep == NULL) { 19847c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%s: cannot cache during " 19857c478bd9Sstevel@tonic-gate "deferred processing. Ignoring minor\n", fcn); 19867c478bd9Sstevel@tonic-gate return; 19877c478bd9Sstevel@tonic-gate } 19887c478bd9Sstevel@tonic-gate 19897c478bd9Sstevel@tonic-gate mp = (struct minor *)s_zalloc(sizeof (struct minor)); 19907c478bd9Sstevel@tonic-gate mp->node = node; 19917c478bd9Sstevel@tonic-gate mp->minor = minor; 19927c478bd9Sstevel@tonic-gate mp->next = NULL; 19937c478bd9Sstevel@tonic-gate 19947c478bd9Sstevel@tonic-gate assert(dep->head == NULL || dep->tail != NULL); 19957c478bd9Sstevel@tonic-gate if (dep->head == NULL) { 19967c478bd9Sstevel@tonic-gate dep->head = mp; 19977c478bd9Sstevel@tonic-gate } else { 19987c478bd9Sstevel@tonic-gate dep->tail->next = mp; 19997c478bd9Sstevel@tonic-gate } 20007c478bd9Sstevel@tonic-gate dep->tail = mp; 20017c478bd9Sstevel@tonic-gate } 20027c478bd9Sstevel@tonic-gate 20037c478bd9Sstevel@tonic-gate /* 20047c478bd9Sstevel@tonic-gate * Check to see if "create" link creation rule matches this node/minor. 20057c478bd9Sstevel@tonic-gate * If it does, return TRUE. 20067c478bd9Sstevel@tonic-gate */ 20077c478bd9Sstevel@tonic-gate static int 20087c478bd9Sstevel@tonic-gate minor_matches_rule(di_node_t node, di_minor_t minor, create_list_t *create) 20097c478bd9Sstevel@tonic-gate { 20107c478bd9Sstevel@tonic-gate char *m_nodetype, *m_drvname; 20117c478bd9Sstevel@tonic-gate 20127c478bd9Sstevel@tonic-gate if (create->create->node_type != NULL) { 20137c478bd9Sstevel@tonic-gate 20147c478bd9Sstevel@tonic-gate m_nodetype = di_minor_nodetype(minor); 20157c478bd9Sstevel@tonic-gate assert(m_nodetype != NULL); 20167c478bd9Sstevel@tonic-gate 20177c478bd9Sstevel@tonic-gate switch (create->create->flags & TYPE_MASK) { 20187c478bd9Sstevel@tonic-gate case TYPE_EXACT: 20197c478bd9Sstevel@tonic-gate if (strcmp(create->create->node_type, m_nodetype) != 20207c478bd9Sstevel@tonic-gate 0) { 20217c478bd9Sstevel@tonic-gate return (FALSE); 20227c478bd9Sstevel@tonic-gate } 20237c478bd9Sstevel@tonic-gate break; 20247c478bd9Sstevel@tonic-gate case TYPE_PARTIAL: 20257c478bd9Sstevel@tonic-gate if (strncmp(create->create->node_type, m_nodetype, 20267c478bd9Sstevel@tonic-gate strlen(create->create->node_type)) != 0) { 20277c478bd9Sstevel@tonic-gate return (FALSE); 20287c478bd9Sstevel@tonic-gate } 20297c478bd9Sstevel@tonic-gate break; 20307c478bd9Sstevel@tonic-gate case TYPE_RE: 20317c478bd9Sstevel@tonic-gate if (regexec(&(create->node_type_comp), m_nodetype, 20327c478bd9Sstevel@tonic-gate 0, NULL, 0) != 0) { 20337c478bd9Sstevel@tonic-gate return (FALSE); 20347c478bd9Sstevel@tonic-gate } 20357c478bd9Sstevel@tonic-gate break; 20367c478bd9Sstevel@tonic-gate } 20377c478bd9Sstevel@tonic-gate } 20387c478bd9Sstevel@tonic-gate 20397c478bd9Sstevel@tonic-gate if (create->create->drv_name != NULL) { 20407c478bd9Sstevel@tonic-gate m_drvname = di_driver_name(node); 20417c478bd9Sstevel@tonic-gate switch (create->create->flags & DRV_MASK) { 20427c478bd9Sstevel@tonic-gate case DRV_EXACT: 20437c478bd9Sstevel@tonic-gate if (strcmp(create->create->drv_name, m_drvname) != 0) { 20447c478bd9Sstevel@tonic-gate return (FALSE); 20457c478bd9Sstevel@tonic-gate } 20467c478bd9Sstevel@tonic-gate break; 20477c478bd9Sstevel@tonic-gate case DRV_RE: 20487c478bd9Sstevel@tonic-gate if (regexec(&(create->drv_name_comp), m_drvname, 20497c478bd9Sstevel@tonic-gate 0, NULL, 0) != 0) { 20507c478bd9Sstevel@tonic-gate return (FALSE); 20517c478bd9Sstevel@tonic-gate } 20527c478bd9Sstevel@tonic-gate break; 20537c478bd9Sstevel@tonic-gate } 20547c478bd9Sstevel@tonic-gate } 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate return (TRUE); 20577c478bd9Sstevel@tonic-gate } 20587c478bd9Sstevel@tonic-gate 20597c478bd9Sstevel@tonic-gate /* 20607c478bd9Sstevel@tonic-gate * If no classes were given on the command line, then return DEVFSADM_SUCCESS. 20617c478bd9Sstevel@tonic-gate * Otherwise, return DEVFSADM_SUCCESS if the device "class" from the module 20627c478bd9Sstevel@tonic-gate * matches one of the device classes given on the command line, 20637c478bd9Sstevel@tonic-gate * otherwise, return DEVFSADM_FAILURE. 20647c478bd9Sstevel@tonic-gate */ 20657c478bd9Sstevel@tonic-gate static int 20667c478bd9Sstevel@tonic-gate class_ok(char *class) 20677c478bd9Sstevel@tonic-gate { 20687c478bd9Sstevel@tonic-gate int i; 20697c478bd9Sstevel@tonic-gate 20707c478bd9Sstevel@tonic-gate if (num_classes == 0) { 20717c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 20727c478bd9Sstevel@tonic-gate } 20737c478bd9Sstevel@tonic-gate 20747c478bd9Sstevel@tonic-gate for (i = 0; i < num_classes; i++) { 20757c478bd9Sstevel@tonic-gate if (strcmp(class, classes[i]) == 0) { 20767c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 20777c478bd9Sstevel@tonic-gate } 20787c478bd9Sstevel@tonic-gate } 20797c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 20807c478bd9Sstevel@tonic-gate } 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate /* 20837c478bd9Sstevel@tonic-gate * call minor_fini on active modules, then unload ALL modules 20847c478bd9Sstevel@tonic-gate */ 20857c478bd9Sstevel@tonic-gate static void 20867c478bd9Sstevel@tonic-gate unload_modules(void) 20877c478bd9Sstevel@tonic-gate { 20887c478bd9Sstevel@tonic-gate module_t *module_free; 20897c478bd9Sstevel@tonic-gate create_list_t *create_free; 20907c478bd9Sstevel@tonic-gate remove_list_t *remove_free; 20917c478bd9Sstevel@tonic-gate 20927c478bd9Sstevel@tonic-gate while (create_head != NULL) { 20937c478bd9Sstevel@tonic-gate create_free = create_head; 20947c478bd9Sstevel@tonic-gate create_head = create_head->next; 20957c478bd9Sstevel@tonic-gate 20967c478bd9Sstevel@tonic-gate if ((create_free->create->flags & TYPE_RE) == TYPE_RE) { 20977c478bd9Sstevel@tonic-gate regfree(&(create_free->node_type_comp)); 20987c478bd9Sstevel@tonic-gate } 20997c478bd9Sstevel@tonic-gate if ((create_free->create->flags & DRV_RE) == DRV_RE) { 21007c478bd9Sstevel@tonic-gate regfree(&(create_free->drv_name_comp)); 21017c478bd9Sstevel@tonic-gate } 21027c478bd9Sstevel@tonic-gate free(create_free); 21037c478bd9Sstevel@tonic-gate } 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate while (remove_head != NULL) { 21067c478bd9Sstevel@tonic-gate remove_free = remove_head; 21077c478bd9Sstevel@tonic-gate remove_head = remove_head->next; 21087c478bd9Sstevel@tonic-gate free(remove_free); 21097c478bd9Sstevel@tonic-gate } 21107c478bd9Sstevel@tonic-gate 21117c478bd9Sstevel@tonic-gate while (module_head != NULL) { 21127c478bd9Sstevel@tonic-gate 21137c478bd9Sstevel@tonic-gate if ((module_head->minor_fini != NULL) && 21147c478bd9Sstevel@tonic-gate ((module_head->flags & MODULE_ACTIVE) == MODULE_ACTIVE)) { 21157c478bd9Sstevel@tonic-gate (void) (*(module_head->minor_fini))(); 21167c478bd9Sstevel@tonic-gate } 21177c478bd9Sstevel@tonic-gate 21187c478bd9Sstevel@tonic-gate vprint(MODLOAD_MID, "unloading module %s\n", module_head->name); 21197c478bd9Sstevel@tonic-gate free(module_head->name); 21207c478bd9Sstevel@tonic-gate (void) dlclose(module_head->dlhandle); 21217c478bd9Sstevel@tonic-gate 21227c478bd9Sstevel@tonic-gate module_free = module_head; 21237c478bd9Sstevel@tonic-gate module_head = module_head->next; 21247c478bd9Sstevel@tonic-gate free(module_free); 21257c478bd9Sstevel@tonic-gate } 21267c478bd9Sstevel@tonic-gate } 21277c478bd9Sstevel@tonic-gate 21287c478bd9Sstevel@tonic-gate /* 21297c478bd9Sstevel@tonic-gate * Load devfsadm logical link processing modules. 21307c478bd9Sstevel@tonic-gate */ 21317c478bd9Sstevel@tonic-gate static void 21327c478bd9Sstevel@tonic-gate load_modules(void) 21337c478bd9Sstevel@tonic-gate { 21347c478bd9Sstevel@tonic-gate DIR *mod_dir; 21354bc0a2efScasper struct dirent *entp; 21367c478bd9Sstevel@tonic-gate char cdir[PATH_MAX + 1]; 21377c478bd9Sstevel@tonic-gate char *last; 21387c478bd9Sstevel@tonic-gate char *mdir = module_dirs; 21397c478bd9Sstevel@tonic-gate char *fcn = "load_modules: "; 21407c478bd9Sstevel@tonic-gate 21417c478bd9Sstevel@tonic-gate while (*mdir != '\0') { 21427c478bd9Sstevel@tonic-gate 21437c478bd9Sstevel@tonic-gate while (*mdir == ':') { 21447c478bd9Sstevel@tonic-gate mdir++; 21457c478bd9Sstevel@tonic-gate } 21467c478bd9Sstevel@tonic-gate 21477c478bd9Sstevel@tonic-gate if (*mdir == '\0') { 21487c478bd9Sstevel@tonic-gate continue; 21497c478bd9Sstevel@tonic-gate } 21507c478bd9Sstevel@tonic-gate 21517c478bd9Sstevel@tonic-gate last = strchr(mdir, ':'); 21527c478bd9Sstevel@tonic-gate 21537c478bd9Sstevel@tonic-gate if (last == NULL) { 21547c478bd9Sstevel@tonic-gate last = mdir + strlen(mdir); 21557c478bd9Sstevel@tonic-gate } 21567c478bd9Sstevel@tonic-gate 21577c478bd9Sstevel@tonic-gate (void) strncpy(cdir, mdir, last - mdir); 21587c478bd9Sstevel@tonic-gate cdir[last - mdir] = '\0'; 21597c478bd9Sstevel@tonic-gate mdir += strlen(cdir); 21607c478bd9Sstevel@tonic-gate 21617c478bd9Sstevel@tonic-gate if ((mod_dir = opendir(cdir)) == NULL) { 21627c478bd9Sstevel@tonic-gate vprint(MODLOAD_MID, "%sopendir(%s): %s\n", 21630a653502Swroche fcn, cdir, strerror(errno)); 21647c478bd9Sstevel@tonic-gate continue; 21657c478bd9Sstevel@tonic-gate } 21667c478bd9Sstevel@tonic-gate 21674bc0a2efScasper while ((entp = readdir(mod_dir)) != NULL) { 21687c478bd9Sstevel@tonic-gate 21697c478bd9Sstevel@tonic-gate if ((strcmp(entp->d_name, ".") == 0) || 21707c478bd9Sstevel@tonic-gate (strcmp(entp->d_name, "..") == 0)) { 21717c478bd9Sstevel@tonic-gate continue; 21727c478bd9Sstevel@tonic-gate } 21737c478bd9Sstevel@tonic-gate 21747c478bd9Sstevel@tonic-gate load_module(entp->d_name, cdir); 21757c478bd9Sstevel@tonic-gate } 21767c478bd9Sstevel@tonic-gate s_closedir(mod_dir); 21777c478bd9Sstevel@tonic-gate } 21787c478bd9Sstevel@tonic-gate } 21797c478bd9Sstevel@tonic-gate 21807c478bd9Sstevel@tonic-gate static void 21817c478bd9Sstevel@tonic-gate load_module(char *mname, char *cdir) 21827c478bd9Sstevel@tonic-gate { 21837c478bd9Sstevel@tonic-gate _devfsadm_create_reg_t *create_reg; 2184aa646b9dSvikram _devfsadm_remove_reg_V1_t *remove_reg; 21857c478bd9Sstevel@tonic-gate create_list_t *create_list_element; 21867c478bd9Sstevel@tonic-gate create_list_t **create_list_next; 21877c478bd9Sstevel@tonic-gate remove_list_t *remove_list_element; 21887c478bd9Sstevel@tonic-gate remove_list_t **remove_list_next; 21897c478bd9Sstevel@tonic-gate char epath[PATH_MAX + 1], *end; 21907c478bd9Sstevel@tonic-gate char *fcn = "load_module: "; 21917c478bd9Sstevel@tonic-gate char *dlerrstr; 21927c478bd9Sstevel@tonic-gate void *dlhandle; 21937c478bd9Sstevel@tonic-gate module_t *module; 2194aa646b9dSvikram int flags; 21957c478bd9Sstevel@tonic-gate int n; 21967c478bd9Sstevel@tonic-gate int i; 21977c478bd9Sstevel@tonic-gate 21987c478bd9Sstevel@tonic-gate /* ignore any file which does not end in '.so' */ 21997c478bd9Sstevel@tonic-gate if ((end = strstr(mname, MODULE_SUFFIX)) != NULL) { 22007c478bd9Sstevel@tonic-gate if (end[strlen(MODULE_SUFFIX)] != '\0') { 22017c478bd9Sstevel@tonic-gate return; 22027c478bd9Sstevel@tonic-gate } 22037c478bd9Sstevel@tonic-gate } else { 22047c478bd9Sstevel@tonic-gate return; 22057c478bd9Sstevel@tonic-gate } 22067c478bd9Sstevel@tonic-gate 22077c478bd9Sstevel@tonic-gate (void) snprintf(epath, sizeof (epath), "%s/%s", cdir, mname); 22087c478bd9Sstevel@tonic-gate 22097c478bd9Sstevel@tonic-gate if ((dlhandle = dlopen(epath, RTLD_LAZY)) == NULL) { 22107c478bd9Sstevel@tonic-gate dlerrstr = dlerror(); 22117c478bd9Sstevel@tonic-gate err_print(DLOPEN_FAILED, epath, 22120a653502Swroche dlerrstr ? dlerrstr : "unknown error"); 22137c478bd9Sstevel@tonic-gate return; 22147c478bd9Sstevel@tonic-gate } 22157c478bd9Sstevel@tonic-gate 22167c478bd9Sstevel@tonic-gate /* dlsym the _devfsadm_create_reg structure */ 22177c478bd9Sstevel@tonic-gate if (NULL == (create_reg = (_devfsadm_create_reg_t *) 22180a653502Swroche dlsym(dlhandle, _DEVFSADM_CREATE_REG))) { 22197c478bd9Sstevel@tonic-gate vprint(MODLOAD_MID, "dlsym(%s, %s): symbol not found\n", epath, 22200a653502Swroche _DEVFSADM_CREATE_REG); 22217c478bd9Sstevel@tonic-gate } else { 22227c478bd9Sstevel@tonic-gate vprint(MODLOAD_MID, "%sdlsym(%s, %s) succeeded\n", 22230a653502Swroche fcn, epath, _DEVFSADM_CREATE_REG); 22247c478bd9Sstevel@tonic-gate } 22257c478bd9Sstevel@tonic-gate 22267c478bd9Sstevel@tonic-gate /* dlsym the _devfsadm_remove_reg structure */ 2227aa646b9dSvikram if (NULL == (remove_reg = (_devfsadm_remove_reg_V1_t *) 22287c478bd9Sstevel@tonic-gate dlsym(dlhandle, _DEVFSADM_REMOVE_REG))) { 22297c478bd9Sstevel@tonic-gate vprint(MODLOAD_MID, "dlsym(%s,\n\t%s): symbol not found\n", 22300a653502Swroche epath, _DEVFSADM_REMOVE_REG); 22317c478bd9Sstevel@tonic-gate } else { 22327c478bd9Sstevel@tonic-gate vprint(MODLOAD_MID, "dlsym(%s, %s): succeeded\n", 22330a653502Swroche epath, _DEVFSADM_REMOVE_REG); 22347c478bd9Sstevel@tonic-gate } 22357c478bd9Sstevel@tonic-gate 22367c478bd9Sstevel@tonic-gate vprint(MODLOAD_MID, "module %s loaded\n", epath); 22377c478bd9Sstevel@tonic-gate 22387c478bd9Sstevel@tonic-gate module = (module_t *)s_malloc(sizeof (module_t)); 22397c478bd9Sstevel@tonic-gate module->name = s_strdup(epath); 22407c478bd9Sstevel@tonic-gate module->dlhandle = dlhandle; 22417c478bd9Sstevel@tonic-gate 22427c478bd9Sstevel@tonic-gate /* dlsym other module functions, to be called later */ 22437c478bd9Sstevel@tonic-gate module->minor_fini = (int (*)())dlsym(dlhandle, MINOR_FINI); 22447c478bd9Sstevel@tonic-gate module->minor_init = (int (*)())dlsym(dlhandle, MINOR_INIT); 22457c478bd9Sstevel@tonic-gate module->flags = 0; 22467c478bd9Sstevel@tonic-gate 22477c478bd9Sstevel@tonic-gate /* 22487c478bd9Sstevel@tonic-gate * put a ptr to each struct devfsadm_create on "create_head" 22497c478bd9Sstevel@tonic-gate * list sorted in interpose_lvl. 22507c478bd9Sstevel@tonic-gate */ 22517c478bd9Sstevel@tonic-gate if (create_reg != NULL) { 22527c478bd9Sstevel@tonic-gate for (i = 0; i < create_reg->count; i++) { 22537c478bd9Sstevel@tonic-gate int flags = create_reg->tblp[i].flags; 22547c478bd9Sstevel@tonic-gate 22557c478bd9Sstevel@tonic-gate create_list_element = (create_list_t *) 22560a653502Swroche s_malloc(sizeof (create_list_t)); 22577c478bd9Sstevel@tonic-gate 22587c478bd9Sstevel@tonic-gate create_list_element->create = &(create_reg->tblp[i]); 22597c478bd9Sstevel@tonic-gate create_list_element->modptr = module; 22607c478bd9Sstevel@tonic-gate 22617c478bd9Sstevel@tonic-gate if (((flags & CREATE_MASK) != 0) && 22627c478bd9Sstevel@tonic-gate ((flags & CREATE_MASK) != CREATE_DEFER)) { 22637c478bd9Sstevel@tonic-gate free(create_list_element); 22647c478bd9Sstevel@tonic-gate err_print("illegal flag combination in " 22650a653502Swroche "module create\n"); 22667c478bd9Sstevel@tonic-gate err_print(IGNORING_ENTRY, i, epath); 22677c478bd9Sstevel@tonic-gate continue; 22687c478bd9Sstevel@tonic-gate } 22697c478bd9Sstevel@tonic-gate 22707c478bd9Sstevel@tonic-gate if (((flags & TYPE_MASK) == 0) ^ 22717c478bd9Sstevel@tonic-gate (create_reg->tblp[i].node_type == NULL)) { 22727c478bd9Sstevel@tonic-gate free(create_list_element); 22737c478bd9Sstevel@tonic-gate err_print("flags value incompatible with " 22740a653502Swroche "node_type value in module create\n"); 22757c478bd9Sstevel@tonic-gate err_print(IGNORING_ENTRY, i, epath); 22767c478bd9Sstevel@tonic-gate continue; 22777c478bd9Sstevel@tonic-gate } 22787c478bd9Sstevel@tonic-gate 22797c478bd9Sstevel@tonic-gate if (((flags & TYPE_MASK) != 0) && 22807c478bd9Sstevel@tonic-gate ((flags & TYPE_MASK) != TYPE_EXACT) && 22817c478bd9Sstevel@tonic-gate ((flags & TYPE_MASK) != TYPE_RE) && 22827c478bd9Sstevel@tonic-gate ((flags & TYPE_MASK) != TYPE_PARTIAL)) { 22837c478bd9Sstevel@tonic-gate free(create_list_element); 22847c478bd9Sstevel@tonic-gate err_print("illegal TYPE_* flag combination in " 22850a653502Swroche "module create\n"); 22867c478bd9Sstevel@tonic-gate err_print(IGNORING_ENTRY, i, epath); 22877c478bd9Sstevel@tonic-gate continue; 22887c478bd9Sstevel@tonic-gate } 22897c478bd9Sstevel@tonic-gate 22907c478bd9Sstevel@tonic-gate /* precompile regular expression for efficiency */ 22917c478bd9Sstevel@tonic-gate if ((flags & TYPE_RE) == TYPE_RE) { 22927c478bd9Sstevel@tonic-gate if ((n = regcomp(&(create_list_element-> 22937c478bd9Sstevel@tonic-gate node_type_comp), 22947c478bd9Sstevel@tonic-gate create_reg->tblp[i].node_type, 22957c478bd9Sstevel@tonic-gate REG_EXTENDED)) != 0) { 22967c478bd9Sstevel@tonic-gate free(create_list_element); 22977c478bd9Sstevel@tonic-gate err_print(REGCOMP_FAILED, 22980a653502Swroche create_reg->tblp[i].node_type, n); 22997c478bd9Sstevel@tonic-gate err_print(IGNORING_ENTRY, i, epath); 23007c478bd9Sstevel@tonic-gate continue; 23017c478bd9Sstevel@tonic-gate } 23027c478bd9Sstevel@tonic-gate } 23037c478bd9Sstevel@tonic-gate 23047c478bd9Sstevel@tonic-gate if (((flags & DRV_MASK) == 0) ^ 23057c478bd9Sstevel@tonic-gate (create_reg->tblp[i].drv_name == NULL)) { 23067c478bd9Sstevel@tonic-gate if ((flags & TYPE_RE) == TYPE_RE) { 23077c478bd9Sstevel@tonic-gate regfree(&(create_list_element-> 23087c478bd9Sstevel@tonic-gate node_type_comp)); 23097c478bd9Sstevel@tonic-gate } 23107c478bd9Sstevel@tonic-gate free(create_list_element); 23117c478bd9Sstevel@tonic-gate err_print("flags value incompatible with " 23120a653502Swroche "drv_name value in module create\n"); 23137c478bd9Sstevel@tonic-gate err_print(IGNORING_ENTRY, i, epath); 23147c478bd9Sstevel@tonic-gate continue; 23157c478bd9Sstevel@tonic-gate } 23167c478bd9Sstevel@tonic-gate 23177c478bd9Sstevel@tonic-gate if (((flags & DRV_MASK) != 0) && 23187c478bd9Sstevel@tonic-gate ((flags & DRV_MASK) != DRV_EXACT) && 23197c478bd9Sstevel@tonic-gate ((flags & DRV_MASK) != DRV_RE)) { 23207c478bd9Sstevel@tonic-gate if ((flags & TYPE_RE) == TYPE_RE) { 23217c478bd9Sstevel@tonic-gate regfree(&(create_list_element-> 23227c478bd9Sstevel@tonic-gate node_type_comp)); 23237c478bd9Sstevel@tonic-gate } 23247c478bd9Sstevel@tonic-gate free(create_list_element); 23257c478bd9Sstevel@tonic-gate err_print("illegal DRV_* flag combination in " 23260a653502Swroche "module create\n"); 23277c478bd9Sstevel@tonic-gate err_print(IGNORING_ENTRY, i, epath); 23287c478bd9Sstevel@tonic-gate continue; 23297c478bd9Sstevel@tonic-gate } 23307c478bd9Sstevel@tonic-gate 23317c478bd9Sstevel@tonic-gate /* precompile regular expression for efficiency */ 23327c478bd9Sstevel@tonic-gate if ((create_reg->tblp[i].flags & DRV_RE) == DRV_RE) { 23337c478bd9Sstevel@tonic-gate if ((n = regcomp(&(create_list_element-> 23347c478bd9Sstevel@tonic-gate drv_name_comp), 23357c478bd9Sstevel@tonic-gate create_reg->tblp[i].drv_name, 23367c478bd9Sstevel@tonic-gate REG_EXTENDED)) != 0) { 23377c478bd9Sstevel@tonic-gate if ((flags & TYPE_RE) == TYPE_RE) { 23387c478bd9Sstevel@tonic-gate regfree(&(create_list_element-> 23397c478bd9Sstevel@tonic-gate node_type_comp)); 23407c478bd9Sstevel@tonic-gate } 23417c478bd9Sstevel@tonic-gate free(create_list_element); 23427c478bd9Sstevel@tonic-gate err_print(REGCOMP_FAILED, 23430a653502Swroche create_reg->tblp[i].drv_name, n); 23447c478bd9Sstevel@tonic-gate err_print(IGNORING_ENTRY, i, epath); 23457c478bd9Sstevel@tonic-gate continue; 23467c478bd9Sstevel@tonic-gate } 23477c478bd9Sstevel@tonic-gate } 23487c478bd9Sstevel@tonic-gate 23497c478bd9Sstevel@tonic-gate 23507c478bd9Sstevel@tonic-gate /* add to list sorted by interpose level */ 23517c478bd9Sstevel@tonic-gate for (create_list_next = &(create_head); 23520a653502Swroche (*create_list_next != NULL) && 23530a653502Swroche (*create_list_next)->create->interpose_lvl >= 23540a653502Swroche create_list_element->create->interpose_lvl; 23550a653502Swroche create_list_next = &((*create_list_next)->next)) 23560a653502Swroche ; 23577c478bd9Sstevel@tonic-gate create_list_element->next = *create_list_next; 23587c478bd9Sstevel@tonic-gate *create_list_next = create_list_element; 23597c478bd9Sstevel@tonic-gate } 23607c478bd9Sstevel@tonic-gate } 23617c478bd9Sstevel@tonic-gate 23627c478bd9Sstevel@tonic-gate /* 23637c478bd9Sstevel@tonic-gate * put a ptr to each struct devfsadm_remove on "remove_head" 23647c478bd9Sstevel@tonic-gate * list sorted by interpose_lvl. 23657c478bd9Sstevel@tonic-gate */ 2366aa646b9dSvikram flags = 0; 23677c478bd9Sstevel@tonic-gate if (remove_reg != NULL) { 2368aa646b9dSvikram if (remove_reg->version < DEVFSADM_V1) 2369aa646b9dSvikram flags |= RM_NOINTERPOSE; 23707c478bd9Sstevel@tonic-gate for (i = 0; i < remove_reg->count; i++) { 23717c478bd9Sstevel@tonic-gate 23727c478bd9Sstevel@tonic-gate remove_list_element = (remove_list_t *) 23730a653502Swroche s_malloc(sizeof (remove_list_t)); 23747c478bd9Sstevel@tonic-gate 23757c478bd9Sstevel@tonic-gate remove_list_element->remove = &(remove_reg->tblp[i]); 2376aa646b9dSvikram remove_list_element->remove->flags |= flags; 23777c478bd9Sstevel@tonic-gate remove_list_element->modptr = module; 23787c478bd9Sstevel@tonic-gate 23797c478bd9Sstevel@tonic-gate for (remove_list_next = &(remove_head); 23800a653502Swroche (*remove_list_next != NULL) && 23810a653502Swroche (*remove_list_next)->remove->interpose_lvl >= 23820a653502Swroche remove_list_element->remove->interpose_lvl; 23830a653502Swroche remove_list_next = &((*remove_list_next)->next)) 23840a653502Swroche ; 23857c478bd9Sstevel@tonic-gate remove_list_element->next = *remove_list_next; 23867c478bd9Sstevel@tonic-gate *remove_list_next = remove_list_element; 23877c478bd9Sstevel@tonic-gate } 23887c478bd9Sstevel@tonic-gate } 23897c478bd9Sstevel@tonic-gate 23907c478bd9Sstevel@tonic-gate module->next = module_head; 23917c478bd9Sstevel@tonic-gate module_head = module; 23927c478bd9Sstevel@tonic-gate } 23937c478bd9Sstevel@tonic-gate 23947c478bd9Sstevel@tonic-gate /* 2395ff2aee48Scth * After we have completed a CACHE_STATE, if a SYNC_STATE does not occur 2396ff2aee48Scth * within 'timeout' secs the minor_fini_thread needs to do a SYNC_STATE 2397ff2aee48Scth * so that we still call the minor_fini routines. 23987c478bd9Sstevel@tonic-gate */ 23997c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 24007c478bd9Sstevel@tonic-gate static void 2401ff2aee48Scth minor_fini_thread(void *arg) 24027c478bd9Sstevel@tonic-gate { 2403ff2aee48Scth timestruc_t abstime; 24047c478bd9Sstevel@tonic-gate 2405ff2aee48Scth vprint(INITFINI_MID, "minor_fini_thread starting\n"); 24067c478bd9Sstevel@tonic-gate 2407ff2aee48Scth (void) mutex_lock(&minor_fini_mutex); 2408ff2aee48Scth for (;;) { 2409ff2aee48Scth /* wait the gather period, or until signaled */ 2410ff2aee48Scth abstime.tv_sec = time(NULL) + minor_fini_timeout; 2411ff2aee48Scth abstime.tv_nsec = 0; 2412ff2aee48Scth (void) cond_timedwait(&minor_fini_cv, 2413ff2aee48Scth &minor_fini_mutex, &abstime); 2414ff2aee48Scth 2415ff2aee48Scth /* if minor_fini was canceled, go wait again */ 2416ff2aee48Scth if (minor_fini_canceled == TRUE) 2417ff2aee48Scth continue; 24187c478bd9Sstevel@tonic-gate 2419ff2aee48Scth /* if minor_fini was delayed, go wait again */ 2420ff2aee48Scth if (minor_fini_delayed == TRUE) { 2421ff2aee48Scth minor_fini_delayed = FALSE; 2422ff2aee48Scth continue; 2423ff2aee48Scth } 24247c478bd9Sstevel@tonic-gate 2425ff2aee48Scth /* done with cancellations and delays, do the SYNC_STATE */ 24267c478bd9Sstevel@tonic-gate (void) mutex_unlock(&minor_fini_mutex); 24277c478bd9Sstevel@tonic-gate 2428ff2aee48Scth lock_dev(); 2429ff2aee48Scth unlock_dev(SYNC_STATE); 2430ff2aee48Scth vprint(INITFINI_MID, "minor_fini sync done\n"); 24317c478bd9Sstevel@tonic-gate 2432ff2aee48Scth (void) mutex_lock(&minor_fini_mutex); 2433ff2aee48Scth } 24347c478bd9Sstevel@tonic-gate } 24357c478bd9Sstevel@tonic-gate 2436ff2aee48Scth 24377c478bd9Sstevel@tonic-gate /* 24387c478bd9Sstevel@tonic-gate * Attempt to initialize module, if a minor_init routine exists. Set 24397c478bd9Sstevel@tonic-gate * the active flag if the routine exists and succeeds. If it doesn't 24407c478bd9Sstevel@tonic-gate * exist, just set the active flag. 24417c478bd9Sstevel@tonic-gate */ 24427c478bd9Sstevel@tonic-gate static int 24437c478bd9Sstevel@tonic-gate call_minor_init(module_t *module) 24447c478bd9Sstevel@tonic-gate { 24457c478bd9Sstevel@tonic-gate char *fcn = "call_minor_init: "; 24467c478bd9Sstevel@tonic-gate 24477c478bd9Sstevel@tonic-gate if ((module->flags & MODULE_ACTIVE) == MODULE_ACTIVE) { 24487c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 24497c478bd9Sstevel@tonic-gate } 24507c478bd9Sstevel@tonic-gate 24517c478bd9Sstevel@tonic-gate vprint(INITFINI_MID, "%smodule %s. current state: inactive\n", 24520a653502Swroche fcn, module->name); 24537c478bd9Sstevel@tonic-gate 24547c478bd9Sstevel@tonic-gate if (module->minor_init == NULL) { 24557c478bd9Sstevel@tonic-gate module->flags |= MODULE_ACTIVE; 24567c478bd9Sstevel@tonic-gate vprint(INITFINI_MID, "minor_init not defined\n"); 24577c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 24587c478bd9Sstevel@tonic-gate } 24597c478bd9Sstevel@tonic-gate 24607c478bd9Sstevel@tonic-gate if ((*(module->minor_init))() == DEVFSADM_FAILURE) { 24617c478bd9Sstevel@tonic-gate err_print(FAILED_FOR_MODULE, MINOR_INIT, module->name); 24627c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 24637c478bd9Sstevel@tonic-gate } 24647c478bd9Sstevel@tonic-gate 24657c478bd9Sstevel@tonic-gate vprint(INITFINI_MID, "minor_init() returns DEVFSADM_SUCCESS. " 24660a653502Swroche "new state: active\n"); 24677c478bd9Sstevel@tonic-gate 24687c478bd9Sstevel@tonic-gate module->flags |= MODULE_ACTIVE; 24697c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 24707c478bd9Sstevel@tonic-gate } 24717c478bd9Sstevel@tonic-gate 24727c478bd9Sstevel@tonic-gate /* 24737c478bd9Sstevel@tonic-gate * Creates a symlink 'link' to the physical path of node:minor. 24747c478bd9Sstevel@tonic-gate * Construct link contents, then call create_link_common(). 24757c478bd9Sstevel@tonic-gate */ 24767c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 24777c478bd9Sstevel@tonic-gate int 2478facf4a8dSllai devfsadm_mklink(char *link, di_node_t node, di_minor_t minor, int flags) 24797c478bd9Sstevel@tonic-gate { 24807c478bd9Sstevel@tonic-gate char rcontents[PATH_MAX]; 24817c478bd9Sstevel@tonic-gate char devlink[PATH_MAX]; 24827c478bd9Sstevel@tonic-gate char phy_path[PATH_MAX]; 24837c478bd9Sstevel@tonic-gate char *acontents; 24847c478bd9Sstevel@tonic-gate char *dev_path; 24857c478bd9Sstevel@tonic-gate int numslashes; 24867c478bd9Sstevel@tonic-gate int rv; 24877c478bd9Sstevel@tonic-gate int i, link_exists; 24887c478bd9Sstevel@tonic-gate int last_was_slash = FALSE; 24897c478bd9Sstevel@tonic-gate 24907c478bd9Sstevel@tonic-gate /* 24917c478bd9Sstevel@tonic-gate * try to use devices path 24927c478bd9Sstevel@tonic-gate */ 24937c478bd9Sstevel@tonic-gate if ((node == lnode) && (minor == lminor)) { 24947c478bd9Sstevel@tonic-gate acontents = lphy_path; 24957c478bd9Sstevel@tonic-gate } else if (di_minor_type(minor) == DDM_ALIAS) { 24967c478bd9Sstevel@tonic-gate /* use /pseudo/clone@0:<driver> as the phys path */ 24977c478bd9Sstevel@tonic-gate (void) snprintf(phy_path, sizeof (phy_path), 24987c478bd9Sstevel@tonic-gate "/pseudo/clone@0:%s", 24997c478bd9Sstevel@tonic-gate di_driver_name(di_minor_devinfo(minor))); 25007c478bd9Sstevel@tonic-gate acontents = phy_path; 25017c478bd9Sstevel@tonic-gate } else { 25027c478bd9Sstevel@tonic-gate if ((dev_path = di_devfs_path(node)) == NULL) { 25037c478bd9Sstevel@tonic-gate err_print(DI_DEVFS_PATH_FAILED, strerror(errno)); 25047c478bd9Sstevel@tonic-gate devfsadm_exit(1); 2505*537714daSvikram /*NOTREACHED*/ 25067c478bd9Sstevel@tonic-gate } 25077c478bd9Sstevel@tonic-gate (void) snprintf(phy_path, sizeof (phy_path), "%s:%s", 25087c478bd9Sstevel@tonic-gate dev_path, di_minor_name(minor)); 25097c478bd9Sstevel@tonic-gate di_devfs_path_free(dev_path); 25107c478bd9Sstevel@tonic-gate acontents = phy_path; 25117c478bd9Sstevel@tonic-gate } 25127c478bd9Sstevel@tonic-gate 25137c478bd9Sstevel@tonic-gate /* prepend link with dev_dir contents */ 25147c478bd9Sstevel@tonic-gate (void) strlcpy(devlink, dev_dir, sizeof (devlink)); 25157c478bd9Sstevel@tonic-gate (void) strlcat(devlink, "/", sizeof (devlink)); 25167c478bd9Sstevel@tonic-gate (void) strlcat(devlink, link, sizeof (devlink)); 25177c478bd9Sstevel@tonic-gate 25187c478bd9Sstevel@tonic-gate /* 25197c478bd9Sstevel@tonic-gate * Calculate # of ../ to add. Account for double '//' in path. 25207c478bd9Sstevel@tonic-gate * Ignore all leading slashes. 25217c478bd9Sstevel@tonic-gate */ 25227c478bd9Sstevel@tonic-gate for (i = 0; link[i] == '/'; i++) 25237c478bd9Sstevel@tonic-gate ; 25247c478bd9Sstevel@tonic-gate for (numslashes = 0; link[i] != '\0'; i++) { 25257c478bd9Sstevel@tonic-gate if (link[i] == '/') { 25267c478bd9Sstevel@tonic-gate if (last_was_slash == FALSE) { 25277c478bd9Sstevel@tonic-gate numslashes++; 25287c478bd9Sstevel@tonic-gate last_was_slash = TRUE; 25297c478bd9Sstevel@tonic-gate } 25307c478bd9Sstevel@tonic-gate } else { 25317c478bd9Sstevel@tonic-gate last_was_slash = FALSE; 25327c478bd9Sstevel@tonic-gate } 25337c478bd9Sstevel@tonic-gate } 25347c478bd9Sstevel@tonic-gate /* Don't count any trailing '/' */ 25357c478bd9Sstevel@tonic-gate if (link[i-1] == '/') { 25367c478bd9Sstevel@tonic-gate numslashes--; 25377c478bd9Sstevel@tonic-gate } 25387c478bd9Sstevel@tonic-gate 25397c478bd9Sstevel@tonic-gate rcontents[0] = '\0'; 25407c478bd9Sstevel@tonic-gate do { 25417c478bd9Sstevel@tonic-gate (void) strlcat(rcontents, "../", sizeof (rcontents)); 25427c478bd9Sstevel@tonic-gate } while (numslashes-- != 0); 25437c478bd9Sstevel@tonic-gate 25447c478bd9Sstevel@tonic-gate (void) strlcat(rcontents, "devices", sizeof (rcontents)); 25457c478bd9Sstevel@tonic-gate (void) strlcat(rcontents, acontents, sizeof (rcontents)); 25467c478bd9Sstevel@tonic-gate 25477c478bd9Sstevel@tonic-gate if (devlinks_debug == TRUE) { 25487c478bd9Sstevel@tonic-gate vprint(INFO_MID, "adding link %s ==> %s\n", devlink, rcontents); 25497c478bd9Sstevel@tonic-gate } 25507c478bd9Sstevel@tonic-gate 25517c478bd9Sstevel@tonic-gate if ((rv = create_link_common(devlink, rcontents, &link_exists)) 25527c478bd9Sstevel@tonic-gate == DEVFSADM_SUCCESS) { 25537c478bd9Sstevel@tonic-gate linknew = TRUE; 25547c478bd9Sstevel@tonic-gate add_link_to_cache(link, acontents); 25557c478bd9Sstevel@tonic-gate } else { 25567c478bd9Sstevel@tonic-gate linknew = FALSE; 25577c478bd9Sstevel@tonic-gate } 25587c478bd9Sstevel@tonic-gate 25597c478bd9Sstevel@tonic-gate if (link_exists == TRUE) { 25606e670f77Saj /* Link exists or was just created */ 25616e670f77Saj (void) di_devlink_add_link(devlink_cache, link, rcontents, 25626e670f77Saj DI_PRIMARY_LINK); 25636e670f77Saj 25646e670f77Saj if (system_labeled && (flags & DA_ADD)) { 256545916cd2Sjpk /* 25666e670f77Saj * Add this to the list of allocatable devices. If this 25676e670f77Saj * is a hotplugged, removable disk, add it as rmdisk. 256845916cd2Sjpk */ 25696e670f77Saj int instance = di_instance(node); 257045916cd2Sjpk 25716e670f77Saj if ((flags & DA_CD) && 25726e670f77Saj (_da_check_for_usb(devlink, root_dir) == 1)) { 257345916cd2Sjpk (void) da_add_list(&devlist, devlink, instance, 257445916cd2Sjpk DA_ADD|DA_RMDISK); 257545916cd2Sjpk update_devdb = DA_RMDISK; 25766e670f77Saj } else if (linknew == TRUE) { 25776e670f77Saj (void) da_add_list(&devlist, devlink, instance, 25786e670f77Saj flags); 25796e670f77Saj update_devdb = flags; 258045916cd2Sjpk } 258145916cd2Sjpk } 25827c478bd9Sstevel@tonic-gate } 25837c478bd9Sstevel@tonic-gate 25847c478bd9Sstevel@tonic-gate return (rv); 25857c478bd9Sstevel@tonic-gate } 25867c478bd9Sstevel@tonic-gate 25877c478bd9Sstevel@tonic-gate /* 25887c478bd9Sstevel@tonic-gate * Creates a symlink link to primary_link. Calculates relative 25897c478bd9Sstevel@tonic-gate * directory offsets, then calls link_common(). 25907c478bd9Sstevel@tonic-gate */ 25917c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 25927c478bd9Sstevel@tonic-gate int 25937c478bd9Sstevel@tonic-gate devfsadm_secondary_link(char *link, char *primary_link, int flags) 25947c478bd9Sstevel@tonic-gate { 25957c478bd9Sstevel@tonic-gate char contents[PATH_MAX + 1]; 25967c478bd9Sstevel@tonic-gate char devlink[PATH_MAX + 1]; 25977c478bd9Sstevel@tonic-gate int rv, link_exists; 25987c478bd9Sstevel@tonic-gate char *fpath; 25997c478bd9Sstevel@tonic-gate char *tpath; 26007c478bd9Sstevel@tonic-gate char *op; 26017c478bd9Sstevel@tonic-gate 26027c478bd9Sstevel@tonic-gate /* prepend link with dev_dir contents */ 26037c478bd9Sstevel@tonic-gate (void) strcpy(devlink, dev_dir); 26047c478bd9Sstevel@tonic-gate (void) strcat(devlink, "/"); 26057c478bd9Sstevel@tonic-gate (void) strcat(devlink, link); 26067c478bd9Sstevel@tonic-gate /* 26077c478bd9Sstevel@tonic-gate * building extra link, so use first link as link contents, but first 26087c478bd9Sstevel@tonic-gate * make it relative. 26097c478bd9Sstevel@tonic-gate */ 26107c478bd9Sstevel@tonic-gate fpath = link; 26117c478bd9Sstevel@tonic-gate tpath = primary_link; 26127c478bd9Sstevel@tonic-gate op = contents; 26137c478bd9Sstevel@tonic-gate 26147c478bd9Sstevel@tonic-gate while (*fpath == *tpath && *fpath != '\0') { 26157c478bd9Sstevel@tonic-gate fpath++, tpath++; 26167c478bd9Sstevel@tonic-gate } 26177c478bd9Sstevel@tonic-gate 26187c478bd9Sstevel@tonic-gate /* Count directories to go up, if any, and add "../" */ 26197c478bd9Sstevel@tonic-gate while (*fpath != '\0') { 26207c478bd9Sstevel@tonic-gate if (*fpath == '/') { 26217c478bd9Sstevel@tonic-gate (void) strcpy(op, "../"); 26227c478bd9Sstevel@tonic-gate op += 3; 26237c478bd9Sstevel@tonic-gate } 26247c478bd9Sstevel@tonic-gate fpath++; 26257c478bd9Sstevel@tonic-gate } 26267c478bd9Sstevel@tonic-gate 26277c478bd9Sstevel@tonic-gate /* 26287c478bd9Sstevel@tonic-gate * Back up to the start of the current path component, in 26297c478bd9Sstevel@tonic-gate * case in the middle 26307c478bd9Sstevel@tonic-gate */ 26317c478bd9Sstevel@tonic-gate while (tpath != primary_link && *(tpath-1) != '/') { 26327c478bd9Sstevel@tonic-gate tpath--; 26337c478bd9Sstevel@tonic-gate } 26347c478bd9Sstevel@tonic-gate (void) strcpy(op, tpath); 26357c478bd9Sstevel@tonic-gate 26367c478bd9Sstevel@tonic-gate if (devlinks_debug == TRUE) { 26377c478bd9Sstevel@tonic-gate vprint(INFO_MID, "adding extra link %s ==> %s\n", 26380a653502Swroche devlink, contents); 26397c478bd9Sstevel@tonic-gate } 26407c478bd9Sstevel@tonic-gate 26417c478bd9Sstevel@tonic-gate if ((rv = create_link_common(devlink, contents, &link_exists)) 26427c478bd9Sstevel@tonic-gate == DEVFSADM_SUCCESS) { 26437c478bd9Sstevel@tonic-gate /* 26447c478bd9Sstevel@tonic-gate * we need to save the ultimate /devices contents, and not the 26457c478bd9Sstevel@tonic-gate * secondary link, since hotcleanup only looks at /devices path. 26467c478bd9Sstevel@tonic-gate * Since we don't have devices path here, we can try to get it 26477c478bd9Sstevel@tonic-gate * by readlink'ing the secondary link. This assumes the primary 26487c478bd9Sstevel@tonic-gate * link was created first. 26497c478bd9Sstevel@tonic-gate */ 26507c478bd9Sstevel@tonic-gate add_link_to_cache(link, lphy_path); 26517c478bd9Sstevel@tonic-gate linknew = TRUE; 265245916cd2Sjpk if (system_labeled && 265345916cd2Sjpk ((flags & DA_AUDIO) && (flags & DA_ADD))) { 265445916cd2Sjpk /* 265545916cd2Sjpk * Add this device to the list of allocatable devices. 265645916cd2Sjpk */ 265745916cd2Sjpk int instance = 0; 265845916cd2Sjpk 265945916cd2Sjpk op = strrchr(contents, '/'); 266045916cd2Sjpk op++; 266145916cd2Sjpk (void) sscanf(op, "%d", &instance); 266245916cd2Sjpk (void) da_add_list(&devlist, devlink, instance, flags); 266345916cd2Sjpk update_devdb = flags; 266445916cd2Sjpk } 26657c478bd9Sstevel@tonic-gate } else { 26667c478bd9Sstevel@tonic-gate linknew = FALSE; 26677c478bd9Sstevel@tonic-gate } 26687c478bd9Sstevel@tonic-gate 26697c478bd9Sstevel@tonic-gate /* 26707c478bd9Sstevel@tonic-gate * If link exists or was just created, add it to the database 26717c478bd9Sstevel@tonic-gate */ 26727c478bd9Sstevel@tonic-gate if (link_exists == TRUE) { 26737c478bd9Sstevel@tonic-gate (void) di_devlink_add_link(devlink_cache, link, contents, 26747c478bd9Sstevel@tonic-gate DI_SECONDARY_LINK); 26757c478bd9Sstevel@tonic-gate } 26767c478bd9Sstevel@tonic-gate 26777c478bd9Sstevel@tonic-gate return (rv); 26787c478bd9Sstevel@tonic-gate } 26797c478bd9Sstevel@tonic-gate 26807c478bd9Sstevel@tonic-gate /* returns pointer to the devices directory */ 26817c478bd9Sstevel@tonic-gate char * 26827c478bd9Sstevel@tonic-gate devfsadm_get_devices_dir() 26837c478bd9Sstevel@tonic-gate { 26847c478bd9Sstevel@tonic-gate return (devices_dir); 26857c478bd9Sstevel@tonic-gate } 26867c478bd9Sstevel@tonic-gate 26877c478bd9Sstevel@tonic-gate /* 26887c478bd9Sstevel@tonic-gate * Does the actual link creation. VERBOSE_MID only used if there is 26897c478bd9Sstevel@tonic-gate * a change. CHATTY_MID used otherwise. 26907c478bd9Sstevel@tonic-gate */ 26917c478bd9Sstevel@tonic-gate static int 26927c478bd9Sstevel@tonic-gate create_link_common(char *devlink, char *contents, int *exists) 26937c478bd9Sstevel@tonic-gate { 26947c478bd9Sstevel@tonic-gate int try; 26957c478bd9Sstevel@tonic-gate int linksize; 26967c478bd9Sstevel@tonic-gate int max_tries = 0; 26977c478bd9Sstevel@tonic-gate static int prev_link_existed = TRUE; 26987c478bd9Sstevel@tonic-gate char checkcontents[PATH_MAX + 1]; 26997c478bd9Sstevel@tonic-gate char *hide; 27007c478bd9Sstevel@tonic-gate 27017c478bd9Sstevel@tonic-gate *exists = FALSE; 27027c478bd9Sstevel@tonic-gate 27037c478bd9Sstevel@tonic-gate /* Database is not updated when file_mods == FALSE */ 27047c478bd9Sstevel@tonic-gate if (file_mods == FALSE) { 27057c478bd9Sstevel@tonic-gate linksize = readlink(devlink, checkcontents, PATH_MAX); 27067c478bd9Sstevel@tonic-gate if (linksize > 0) { 27077c478bd9Sstevel@tonic-gate checkcontents[linksize] = '\0'; 27087c478bd9Sstevel@tonic-gate if (strcmp(checkcontents, contents) != 0) { 27097c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, REMOVING_LINK, 27100a653502Swroche devlink, checkcontents); 27117c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 27127c478bd9Sstevel@tonic-gate } else { 27137c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "link exists and is correct:" 27140a653502Swroche " %s -> %s\n", devlink, contents); 27157c478bd9Sstevel@tonic-gate /* failure only in that the link existed */ 27167c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 27177c478bd9Sstevel@tonic-gate } 27187c478bd9Sstevel@tonic-gate } else { 27197c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, CREATING_LINK, devlink, contents); 27207c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 27217c478bd9Sstevel@tonic-gate } 27227c478bd9Sstevel@tonic-gate } 27237c478bd9Sstevel@tonic-gate 27247c478bd9Sstevel@tonic-gate /* 27257c478bd9Sstevel@tonic-gate * systems calls are expensive, so predict whether to readlink 27267c478bd9Sstevel@tonic-gate * or symlink first, based on previous attempt 27277c478bd9Sstevel@tonic-gate */ 27287c478bd9Sstevel@tonic-gate if (prev_link_existed == FALSE) { 27297c478bd9Sstevel@tonic-gate try = CREATE_LINK; 27307c478bd9Sstevel@tonic-gate } else { 27317c478bd9Sstevel@tonic-gate try = READ_LINK; 27327c478bd9Sstevel@tonic-gate } 27337c478bd9Sstevel@tonic-gate 27347c478bd9Sstevel@tonic-gate while (++max_tries <= 3) { 27357c478bd9Sstevel@tonic-gate 27367c478bd9Sstevel@tonic-gate switch (try) { 27377c478bd9Sstevel@tonic-gate case CREATE_LINK: 27387c478bd9Sstevel@tonic-gate 27397c478bd9Sstevel@tonic-gate if (symlink(contents, devlink) == 0) { 27407c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, CREATING_LINK, devlink, 27410a653502Swroche contents); 27427c478bd9Sstevel@tonic-gate prev_link_existed = FALSE; 27437c478bd9Sstevel@tonic-gate /* link successfully created */ 27447c478bd9Sstevel@tonic-gate *exists = TRUE; 27457c478bd9Sstevel@tonic-gate set_logindev_perms(devlink); 27467c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 27477c478bd9Sstevel@tonic-gate } else { 27487c478bd9Sstevel@tonic-gate switch (errno) { 27497c478bd9Sstevel@tonic-gate 27507c478bd9Sstevel@tonic-gate case ENOENT: 27517c478bd9Sstevel@tonic-gate /* dirpath to node doesn't exist */ 27527c478bd9Sstevel@tonic-gate hide = strrchr(devlink, '/'); 27537c478bd9Sstevel@tonic-gate *hide = '\0'; 27547c478bd9Sstevel@tonic-gate s_mkdirp(devlink, S_IRWXU|S_IRGRP| 27550a653502Swroche S_IXGRP|S_IROTH|S_IXOTH); 27567c478bd9Sstevel@tonic-gate *hide = '/'; 27577c478bd9Sstevel@tonic-gate break; 27587c478bd9Sstevel@tonic-gate case EEXIST: 27597c478bd9Sstevel@tonic-gate try = READ_LINK; 27607c478bd9Sstevel@tonic-gate break; 27617c478bd9Sstevel@tonic-gate default: 27627c478bd9Sstevel@tonic-gate err_print(SYMLINK_FAILED, devlink, 27630a653502Swroche contents, strerror(errno)); 27647c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 27657c478bd9Sstevel@tonic-gate } 27667c478bd9Sstevel@tonic-gate } 27677c478bd9Sstevel@tonic-gate break; 27687c478bd9Sstevel@tonic-gate 27697c478bd9Sstevel@tonic-gate case READ_LINK: 27707c478bd9Sstevel@tonic-gate 27717c478bd9Sstevel@tonic-gate linksize = readlink(devlink, checkcontents, PATH_MAX); 27727c478bd9Sstevel@tonic-gate if (linksize >= 0) { 27737c478bd9Sstevel@tonic-gate checkcontents[linksize] = '\0'; 27747c478bd9Sstevel@tonic-gate if (strcmp(checkcontents, contents) != 0) { 27757c478bd9Sstevel@tonic-gate s_unlink(devlink); 27767c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, REMOVING_LINK, 27770a653502Swroche devlink, checkcontents); 27787c478bd9Sstevel@tonic-gate try = CREATE_LINK; 27797c478bd9Sstevel@tonic-gate } else { 27807c478bd9Sstevel@tonic-gate prev_link_existed = TRUE; 27817c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, 27820a653502Swroche "link exists and is correct:" 27830a653502Swroche " %s -> %s\n", devlink, contents); 27847c478bd9Sstevel@tonic-gate *exists = TRUE; 27857c478bd9Sstevel@tonic-gate /* failure in that the link existed */ 27867c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 27877c478bd9Sstevel@tonic-gate } 27887c478bd9Sstevel@tonic-gate } else { 27897c478bd9Sstevel@tonic-gate switch (errno) { 27907c478bd9Sstevel@tonic-gate case EINVAL: 27917c478bd9Sstevel@tonic-gate /* not a symlink, remove and create */ 27927c478bd9Sstevel@tonic-gate s_unlink(devlink); 27937c478bd9Sstevel@tonic-gate default: 27947c478bd9Sstevel@tonic-gate /* maybe it didn't exist at all */ 27957c478bd9Sstevel@tonic-gate try = CREATE_LINK; 27967c478bd9Sstevel@tonic-gate break; 27977c478bd9Sstevel@tonic-gate } 27987c478bd9Sstevel@tonic-gate } 27997c478bd9Sstevel@tonic-gate break; 28007c478bd9Sstevel@tonic-gate } 28017c478bd9Sstevel@tonic-gate } 28027c478bd9Sstevel@tonic-gate err_print(MAX_ATTEMPTS, devlink, contents); 28037c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 28047c478bd9Sstevel@tonic-gate } 28057c478bd9Sstevel@tonic-gate 28067c478bd9Sstevel@tonic-gate static void 28077c478bd9Sstevel@tonic-gate set_logindev_perms(char *devlink) 28087c478bd9Sstevel@tonic-gate { 28097c478bd9Sstevel@tonic-gate struct login_dev *newdev; 28107c478bd9Sstevel@tonic-gate struct passwd pwd, *resp; 28117c478bd9Sstevel@tonic-gate char pwd_buf[PATH_MAX]; 28127c478bd9Sstevel@tonic-gate int rv; 28137c478bd9Sstevel@tonic-gate struct stat sb; 28147c478bd9Sstevel@tonic-gate char *devfs_path = NULL; 28157c478bd9Sstevel@tonic-gate 28167c478bd9Sstevel@tonic-gate /* 28177c478bd9Sstevel@tonic-gate * We only want logindev perms to be set when a device is 28187c478bd9Sstevel@tonic-gate * hotplugged or an application requests synchronous creates. 28197c478bd9Sstevel@tonic-gate * So we enable this only in daemon mode. In addition, 28207c478bd9Sstevel@tonic-gate * login(1) only fixes the std. /dev dir. So we don't 28217c478bd9Sstevel@tonic-gate * change perms if alternate root is set. 28227c478bd9Sstevel@tonic-gate * login_dev_enable is TRUE only in these cases. 28237c478bd9Sstevel@tonic-gate */ 28247c478bd9Sstevel@tonic-gate if (login_dev_enable != TRUE) 28257c478bd9Sstevel@tonic-gate return; 28267c478bd9Sstevel@tonic-gate 28277c478bd9Sstevel@tonic-gate /* 28287c478bd9Sstevel@tonic-gate * Normally, /etc/logindevperm has few (8 - 10 entries) which 28297c478bd9Sstevel@tonic-gate * may be regular expressions (globs were converted to RE). 28307c478bd9Sstevel@tonic-gate * So just do a linear search through the list. 28317c478bd9Sstevel@tonic-gate */ 28327c478bd9Sstevel@tonic-gate for (newdev = login_dev_cache; newdev; newdev = newdev->ldev_next) { 28337c478bd9Sstevel@tonic-gate vprint(FILES_MID, "matching %s with %s\n", devlink, 28347c478bd9Sstevel@tonic-gate newdev->ldev_device); 28357c478bd9Sstevel@tonic-gate 28367c478bd9Sstevel@tonic-gate if (regexec(&newdev->ldev_device_regex, devlink, 0, 28377c478bd9Sstevel@tonic-gate NULL, 0) == 0) { 28387c478bd9Sstevel@tonic-gate vprint(FILES_MID, "matched %s with %s\n", devlink, 28397c478bd9Sstevel@tonic-gate newdev->ldev_device); 28407c478bd9Sstevel@tonic-gate break; 28417c478bd9Sstevel@tonic-gate } 28427c478bd9Sstevel@tonic-gate } 28437c478bd9Sstevel@tonic-gate 28447c478bd9Sstevel@tonic-gate if (newdev == NULL) 28457c478bd9Sstevel@tonic-gate return; 28467c478bd9Sstevel@tonic-gate 28477c478bd9Sstevel@tonic-gate /* 28487c478bd9Sstevel@tonic-gate * we have a match, now find the driver associated with this 28497c478bd9Sstevel@tonic-gate * minor node using a snapshot on the physical path 28507c478bd9Sstevel@tonic-gate */ 28517c478bd9Sstevel@tonic-gate (void) resolve_link(devlink, NULL, NULL, &devfs_path, 0); 28527c478bd9Sstevel@tonic-gate if (devfs_path) { 28537c478bd9Sstevel@tonic-gate di_node_t node; 28547c478bd9Sstevel@tonic-gate char *drv = NULL; 28557c478bd9Sstevel@tonic-gate struct driver_list *list; 28567c478bd9Sstevel@tonic-gate char *p; 28577c478bd9Sstevel@tonic-gate 28587c478bd9Sstevel@tonic-gate /* truncate on : so we can take a snapshot */ 28597c478bd9Sstevel@tonic-gate (void) strcpy(pwd_buf, devfs_path); 28607c478bd9Sstevel@tonic-gate p = strrchr(pwd_buf, ':'); 28617c478bd9Sstevel@tonic-gate if (p == NULL) { 28627c478bd9Sstevel@tonic-gate free(devfs_path); 28637c478bd9Sstevel@tonic-gate return; 28647c478bd9Sstevel@tonic-gate } 28657c478bd9Sstevel@tonic-gate *p = '\0'; 28667c478bd9Sstevel@tonic-gate 28677c478bd9Sstevel@tonic-gate vprint(FILES_MID, "link=%s->physpath=%s\n", 28687c478bd9Sstevel@tonic-gate devlink, pwd_buf); 28697c478bd9Sstevel@tonic-gate 28707c478bd9Sstevel@tonic-gate node = di_init(pwd_buf, DINFOMINOR); 28717c478bd9Sstevel@tonic-gate 28727c478bd9Sstevel@tonic-gate if (node) { 28737c478bd9Sstevel@tonic-gate drv = di_driver_name(node); 28747c478bd9Sstevel@tonic-gate 28757c478bd9Sstevel@tonic-gate if (drv) { 28767c478bd9Sstevel@tonic-gate vprint(FILES_MID, "%s: driver is %s\n", 28777c478bd9Sstevel@tonic-gate devlink, drv); 28787c478bd9Sstevel@tonic-gate } 28797c478bd9Sstevel@tonic-gate di_fini(node); 28807c478bd9Sstevel@tonic-gate } 28817c478bd9Sstevel@tonic-gate /* search thru the driver list specified in logindevperm */ 28827c478bd9Sstevel@tonic-gate list = newdev->ldev_driver_list; 28837c478bd9Sstevel@tonic-gate if ((drv != NULL) && (list != NULL)) { 28847c478bd9Sstevel@tonic-gate while (list) { 28857c478bd9Sstevel@tonic-gate if (strcmp(list->driver_name, 28867c478bd9Sstevel@tonic-gate drv) == 0) { 28877c478bd9Sstevel@tonic-gate vprint(FILES_MID, 28887c478bd9Sstevel@tonic-gate "driver %s match!\n", drv); 28897c478bd9Sstevel@tonic-gate break; 28907c478bd9Sstevel@tonic-gate } 28917c478bd9Sstevel@tonic-gate list = list->next; 28927c478bd9Sstevel@tonic-gate } 28937c478bd9Sstevel@tonic-gate if (list == NULL) { 28947c478bd9Sstevel@tonic-gate vprint(FILES_MID, "no driver match!\n"); 28957c478bd9Sstevel@tonic-gate free(devfs_path); 28967c478bd9Sstevel@tonic-gate return; 28977c478bd9Sstevel@tonic-gate } 28987c478bd9Sstevel@tonic-gate } 28997c478bd9Sstevel@tonic-gate free(devfs_path); 29007c478bd9Sstevel@tonic-gate } else { 29017c478bd9Sstevel@tonic-gate return; 29027c478bd9Sstevel@tonic-gate } 29037c478bd9Sstevel@tonic-gate 29047c478bd9Sstevel@tonic-gate vprint(FILES_MID, "changing permissions of %s\n", devlink); 29057c478bd9Sstevel@tonic-gate 29067c478bd9Sstevel@tonic-gate /* 29077c478bd9Sstevel@tonic-gate * We have a match. We now attempt to determine the 29087c478bd9Sstevel@tonic-gate * owner and group of the console user. 29097c478bd9Sstevel@tonic-gate * 29107c478bd9Sstevel@tonic-gate * stat() the console device newdev->ldev_console 29117c478bd9Sstevel@tonic-gate * which will always exist - it will have the right owner but 29127c478bd9Sstevel@tonic-gate * not the right group. Use getpwuid_r() to determine group for this 29137c478bd9Sstevel@tonic-gate * uid. 29147c478bd9Sstevel@tonic-gate * Note, it is safe to use name service here since if name services 29157c478bd9Sstevel@tonic-gate * are not available (during boot or in single-user mode), then 29167c478bd9Sstevel@tonic-gate * console owner will be root and its gid can be found in 29177c478bd9Sstevel@tonic-gate * local files. 29187c478bd9Sstevel@tonic-gate */ 29197c478bd9Sstevel@tonic-gate if (stat(newdev->ldev_console, &sb) == -1) { 29207c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, STAT_FAILED, newdev->ldev_console, 29217c478bd9Sstevel@tonic-gate strerror(errno)); 29227c478bd9Sstevel@tonic-gate return; 29237c478bd9Sstevel@tonic-gate } 29247c478bd9Sstevel@tonic-gate 29257c478bd9Sstevel@tonic-gate resp = NULL; 29267c478bd9Sstevel@tonic-gate rv = getpwuid_r(sb.st_uid, &pwd, pwd_buf, sizeof (pwd_buf), &resp); 29277c478bd9Sstevel@tonic-gate if (rv || resp == NULL) { 29287c478bd9Sstevel@tonic-gate rv = rv ? rv : EINVAL; 29297c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, GID_FAILED, sb.st_uid, 29307c478bd9Sstevel@tonic-gate strerror(rv)); 29317c478bd9Sstevel@tonic-gate return; 29327c478bd9Sstevel@tonic-gate } 29337c478bd9Sstevel@tonic-gate 29347c478bd9Sstevel@tonic-gate assert(&pwd == resp); 29357c478bd9Sstevel@tonic-gate 29367c478bd9Sstevel@tonic-gate sb.st_gid = resp->pw_gid; 29377c478bd9Sstevel@tonic-gate 29387c478bd9Sstevel@tonic-gate if (chmod(devlink, newdev->ldev_perms) == -1) { 29397c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, CHMOD_FAILED, devlink, 29407c478bd9Sstevel@tonic-gate strerror(errno)); 29417c478bd9Sstevel@tonic-gate return; 29427c478bd9Sstevel@tonic-gate } 29437c478bd9Sstevel@tonic-gate 29447c478bd9Sstevel@tonic-gate if (chown(devlink, sb.st_uid, sb.st_gid) == -1) { 29457c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, CHOWN_FAILED, devlink, 29467c478bd9Sstevel@tonic-gate strerror(errno)); 29477c478bd9Sstevel@tonic-gate } 29487c478bd9Sstevel@tonic-gate } 29497c478bd9Sstevel@tonic-gate 29507c478bd9Sstevel@tonic-gate /* 29517c478bd9Sstevel@tonic-gate * Reset /devices node with appropriate permissions and 29527c478bd9Sstevel@tonic-gate * ownership as specified in /etc/minor_perm. 29537c478bd9Sstevel@tonic-gate */ 29547c478bd9Sstevel@tonic-gate static void 29557c478bd9Sstevel@tonic-gate reset_node_permissions(di_node_t node, di_minor_t minor) 29567c478bd9Sstevel@tonic-gate { 29577c478bd9Sstevel@tonic-gate int spectype; 29587c478bd9Sstevel@tonic-gate char phy_path[PATH_MAX + 1]; 29597c478bd9Sstevel@tonic-gate mode_t mode; 29607c478bd9Sstevel@tonic-gate dev_t dev; 29617c478bd9Sstevel@tonic-gate uid_t uid; 29627c478bd9Sstevel@tonic-gate gid_t gid; 29637c478bd9Sstevel@tonic-gate struct stat sb; 29647c478bd9Sstevel@tonic-gate char *dev_path, *aminor = NULL; 29657c478bd9Sstevel@tonic-gate 29667c478bd9Sstevel@tonic-gate /* lphy_path starts with / */ 29677c478bd9Sstevel@tonic-gate if ((dev_path = di_devfs_path(node)) == NULL) { 29687c478bd9Sstevel@tonic-gate err_print(DI_DEVFS_PATH_FAILED, strerror(errno)); 29697c478bd9Sstevel@tonic-gate devfsadm_exit(1); 2970*537714daSvikram /*NOTREACHED*/ 29717c478bd9Sstevel@tonic-gate } 29727c478bd9Sstevel@tonic-gate (void) strcpy(lphy_path, dev_path); 29737c478bd9Sstevel@tonic-gate di_devfs_path_free(dev_path); 29747c478bd9Sstevel@tonic-gate 29757c478bd9Sstevel@tonic-gate (void) strcat(lphy_path, ":"); 29767c478bd9Sstevel@tonic-gate if (di_minor_type(minor) == DDM_ALIAS) { 29777c478bd9Sstevel@tonic-gate char *driver; 29787c478bd9Sstevel@tonic-gate aminor = di_minor_name(minor); 29797c478bd9Sstevel@tonic-gate driver = di_driver_name(di_minor_devinfo(minor)); 29807c478bd9Sstevel@tonic-gate (void) strcat(lphy_path, driver); 29817c478bd9Sstevel@tonic-gate } else 29827c478bd9Sstevel@tonic-gate (void) strcat(lphy_path, di_minor_name(minor)); 29837c478bd9Sstevel@tonic-gate 29847c478bd9Sstevel@tonic-gate (void) strcpy(phy_path, devices_dir); 29857c478bd9Sstevel@tonic-gate (void) strcat(phy_path, lphy_path); 29867c478bd9Sstevel@tonic-gate 29877c478bd9Sstevel@tonic-gate lnode = node; 29887c478bd9Sstevel@tonic-gate lminor = minor; 29897c478bd9Sstevel@tonic-gate 29907c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "reset_node_permissions: phy_path=%s lphy_path=%s\n", 29910a653502Swroche phy_path, lphy_path); 29927c478bd9Sstevel@tonic-gate 29937c478bd9Sstevel@tonic-gate dev = di_minor_devt(minor); 29947c478bd9Sstevel@tonic-gate spectype = di_minor_spectype(minor); /* block or char */ 29957c478bd9Sstevel@tonic-gate 29967c478bd9Sstevel@tonic-gate getattr(phy_path, aminor, spectype, dev, &mode, &uid, &gid); 29977c478bd9Sstevel@tonic-gate 29987c478bd9Sstevel@tonic-gate /* 29997c478bd9Sstevel@tonic-gate * compare and set permissions and ownership 30007c478bd9Sstevel@tonic-gate * 30017c478bd9Sstevel@tonic-gate * Under devfs, a quick insertion and removal of USB devices 30027c478bd9Sstevel@tonic-gate * would cause stat of physical path to fail. In this case, 30037c478bd9Sstevel@tonic-gate * we emit a verbose message, but don't print errors. 30047c478bd9Sstevel@tonic-gate */ 30057c478bd9Sstevel@tonic-gate if ((stat(phy_path, &sb) == -1) || (sb.st_rdev != dev)) { 30067c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, NO_DEVFS_NODE, phy_path); 30077c478bd9Sstevel@tonic-gate return; 30087c478bd9Sstevel@tonic-gate } 30097c478bd9Sstevel@tonic-gate 30107c478bd9Sstevel@tonic-gate /* 301145916cd2Sjpk * If we are here for a new device 301245916cd2Sjpk * If device allocation is on 301345916cd2Sjpk * then 301445916cd2Sjpk * set ownership to root:other and permissions to 0000 301545916cd2Sjpk * else 301645916cd2Sjpk * set ownership and permissions as specified in minor_perm 301745916cd2Sjpk * If we are here for an existing device 301845916cd2Sjpk * If device allocation is to be turned on 301945916cd2Sjpk * then 302045916cd2Sjpk * reset ownership to root:other and permissions to 0000 302145916cd2Sjpk * else if device allocation is to be turned off 302245916cd2Sjpk * reset ownership and permissions to those specified in 302345916cd2Sjpk * minor_perm 302445916cd2Sjpk * else 3025ff2aee48Scth * preserve existing/user-modified ownership and 302645916cd2Sjpk * permissions 302745916cd2Sjpk * 302845916cd2Sjpk * devfs indicates a new device by faking access time to be zero. 30297c478bd9Sstevel@tonic-gate */ 30307c478bd9Sstevel@tonic-gate if (sb.st_atime != 0) { 30317c478bd9Sstevel@tonic-gate int i; 30327c478bd9Sstevel@tonic-gate char *nt; 30337c478bd9Sstevel@tonic-gate 303445916cd2Sjpk if ((devalloc_flag == 0) && (devalloc_is_on != 1)) 303545916cd2Sjpk /* 303645916cd2Sjpk * Leave existing devices as they are if we are not 303745916cd2Sjpk * turning device allocation on/off. 303845916cd2Sjpk */ 30397c478bd9Sstevel@tonic-gate return; 30407c478bd9Sstevel@tonic-gate 30417c478bd9Sstevel@tonic-gate nt = di_minor_nodetype(minor); 304245916cd2Sjpk 30437c478bd9Sstevel@tonic-gate if (nt == NULL) 30447c478bd9Sstevel@tonic-gate return; 304545916cd2Sjpk 304645916cd2Sjpk for (i = 0; devalloc_list[i]; i++) { 304745916cd2Sjpk if (strcmp(nt, devalloc_list[i]) == 0) 304845916cd2Sjpk /* 304945916cd2Sjpk * One of the types recognized by devalloc, 305045916cd2Sjpk * reset attrs. 305145916cd2Sjpk */ 30527c478bd9Sstevel@tonic-gate break; 30537c478bd9Sstevel@tonic-gate } 305445916cd2Sjpk if (devalloc_list[i] == NULL) 30557c478bd9Sstevel@tonic-gate return; 30567c478bd9Sstevel@tonic-gate } 30577c478bd9Sstevel@tonic-gate 30587c478bd9Sstevel@tonic-gate if (file_mods == FALSE) { 30597c478bd9Sstevel@tonic-gate /* Nothing more to do if simulating */ 30607c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode); 30617c478bd9Sstevel@tonic-gate return; 30627c478bd9Sstevel@tonic-gate } 30637c478bd9Sstevel@tonic-gate 30648c206d17Spr if ((devalloc_flag == DA_ON) || 30658c206d17Spr ((devalloc_is_on == 1) && (devalloc_flag != DA_OFF))) { 306645916cd2Sjpk /* 30678c206d17Spr * we are here either to turn device allocation on or 30688c206d17Spr * to add a new device while device allocation is on 30698c206d17Spr * (and we've confirmed that we're not turning it 30708c206d17Spr * off). 307145916cd2Sjpk */ 307245916cd2Sjpk mode = DEALLOC_MODE; 307345916cd2Sjpk uid = DA_UID; 307445916cd2Sjpk gid = DA_GID; 307545916cd2Sjpk } 307645916cd2Sjpk 307745916cd2Sjpk if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) || 307845916cd2Sjpk (sb.st_mode != mode)) { 30797c478bd9Sstevel@tonic-gate if (chmod(phy_path, mode) == -1) 30807c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, CHMOD_FAILED, 30817c478bd9Sstevel@tonic-gate phy_path, strerror(errno)); 30827c478bd9Sstevel@tonic-gate } 308345916cd2Sjpk if ((devalloc_is_on == 1) || (devalloc_flag == DA_ON) || 308445916cd2Sjpk (sb.st_uid != uid || sb.st_gid != gid)) { 30857c478bd9Sstevel@tonic-gate if (chown(phy_path, uid, gid) == -1) 30867c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, CHOWN_FAILED, 30877c478bd9Sstevel@tonic-gate phy_path, strerror(errno)); 30887c478bd9Sstevel@tonic-gate } 30897c478bd9Sstevel@tonic-gate 30907c478bd9Sstevel@tonic-gate /* Report that we actually did something */ 30917c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, PERM_MSG, phy_path, uid, gid, mode); 30927c478bd9Sstevel@tonic-gate } 30937c478bd9Sstevel@tonic-gate 30947c478bd9Sstevel@tonic-gate /* 30957c478bd9Sstevel@tonic-gate * Removes logical link and the minor node it refers to. If file is a 30967c478bd9Sstevel@tonic-gate * link, we recurse and try to remove the minor node (or link if path is 30977c478bd9Sstevel@tonic-gate * a double link) that file's link contents refer to. 30987c478bd9Sstevel@tonic-gate */ 30997c478bd9Sstevel@tonic-gate static void 31007c478bd9Sstevel@tonic-gate devfsadm_rm_work(char *file, int recurse, int file_type) 31017c478bd9Sstevel@tonic-gate { 31027c478bd9Sstevel@tonic-gate char *fcn = "devfsadm_rm_work: "; 31037c478bd9Sstevel@tonic-gate int linksize; 31047c478bd9Sstevel@tonic-gate char contents[PATH_MAX + 1]; 31057c478bd9Sstevel@tonic-gate char nextfile[PATH_MAX + 1]; 31067c478bd9Sstevel@tonic-gate char newfile[PATH_MAX + 1]; 31077c478bd9Sstevel@tonic-gate char *ptr; 31087c478bd9Sstevel@tonic-gate 31097c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%s%s\n", fcn, file); 31107c478bd9Sstevel@tonic-gate 31117c478bd9Sstevel@tonic-gate /* TYPE_LINK split into multiple if's due to excessive indentations */ 31127c478bd9Sstevel@tonic-gate if (file_type == TYPE_LINK) { 31137c478bd9Sstevel@tonic-gate (void) strcpy(newfile, dev_dir); 31147c478bd9Sstevel@tonic-gate (void) strcat(newfile, "/"); 31157c478bd9Sstevel@tonic-gate (void) strcat(newfile, file); 31167c478bd9Sstevel@tonic-gate } 31177c478bd9Sstevel@tonic-gate 31187c478bd9Sstevel@tonic-gate if ((file_type == TYPE_LINK) && (recurse == TRUE) && 31197c478bd9Sstevel@tonic-gate ((linksize = readlink(newfile, contents, PATH_MAX)) > 0)) { 31207c478bd9Sstevel@tonic-gate contents[linksize] = '\0'; 31217c478bd9Sstevel@tonic-gate 31227c478bd9Sstevel@tonic-gate if (is_minor_node(contents, &ptr) == DEVFSADM_TRUE) { 31237c478bd9Sstevel@tonic-gate devfsadm_rm_work(++ptr, FALSE, TYPE_DEVICES); 31247c478bd9Sstevel@tonic-gate } else { 31257c478bd9Sstevel@tonic-gate if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0) { 31267c478bd9Sstevel@tonic-gate devfsadm_rm_work(&contents[strlen(DEV) + 1], 31270a653502Swroche TRUE, TYPE_LINK); 31287c478bd9Sstevel@tonic-gate } else { 31297c478bd9Sstevel@tonic-gate if ((ptr = strrchr(file, '/')) != NULL) { 31307c478bd9Sstevel@tonic-gate *ptr = '\0'; 31317c478bd9Sstevel@tonic-gate (void) strcpy(nextfile, file); 31327c478bd9Sstevel@tonic-gate *ptr = '/'; 31337c478bd9Sstevel@tonic-gate (void) strcat(nextfile, "/"); 31347c478bd9Sstevel@tonic-gate } else { 31357c478bd9Sstevel@tonic-gate (void) strcpy(nextfile, ""); 31367c478bd9Sstevel@tonic-gate } 31377c478bd9Sstevel@tonic-gate (void) strcat(nextfile, contents); 31387c478bd9Sstevel@tonic-gate devfsadm_rm_work(nextfile, TRUE, TYPE_LINK); 31397c478bd9Sstevel@tonic-gate } 31407c478bd9Sstevel@tonic-gate } 31417c478bd9Sstevel@tonic-gate } 31427c478bd9Sstevel@tonic-gate 31437c478bd9Sstevel@tonic-gate if (file_type == TYPE_LINK) { 31447c478bd9Sstevel@tonic-gate vprint(VERBOSE_MID, DEVFSADM_UNLINK, newfile); 31457c478bd9Sstevel@tonic-gate if (file_mods == TRUE) { 31467c478bd9Sstevel@tonic-gate rm_link_from_cache(file); 31477c478bd9Sstevel@tonic-gate s_unlink(newfile); 31487c478bd9Sstevel@tonic-gate rm_parent_dir_if_empty(newfile); 31497c478bd9Sstevel@tonic-gate invalidate_enumerate_cache(); 31507c478bd9Sstevel@tonic-gate (void) di_devlink_rm_link(devlink_cache, file); 31517c478bd9Sstevel@tonic-gate } 31527c478bd9Sstevel@tonic-gate } 31537c478bd9Sstevel@tonic-gate 31547c478bd9Sstevel@tonic-gate /* 31557c478bd9Sstevel@tonic-gate * Note: we don't remove /devices entries because they are 31567c478bd9Sstevel@tonic-gate * covered by devfs. 31577c478bd9Sstevel@tonic-gate */ 31587c478bd9Sstevel@tonic-gate } 31597c478bd9Sstevel@tonic-gate 31607c478bd9Sstevel@tonic-gate void 31617c478bd9Sstevel@tonic-gate devfsadm_rm_link(char *file) 31627c478bd9Sstevel@tonic-gate { 31637c478bd9Sstevel@tonic-gate devfsadm_rm_work(file, FALSE, TYPE_LINK); 31647c478bd9Sstevel@tonic-gate } 31657c478bd9Sstevel@tonic-gate 31667c478bd9Sstevel@tonic-gate void 31677c478bd9Sstevel@tonic-gate devfsadm_rm_all(char *file) 31687c478bd9Sstevel@tonic-gate { 31697c478bd9Sstevel@tonic-gate devfsadm_rm_work(file, TRUE, TYPE_LINK); 31707c478bd9Sstevel@tonic-gate } 31717c478bd9Sstevel@tonic-gate 31724bc0a2efScasper static int 31737c478bd9Sstevel@tonic-gate s_rmdir(char *path) 31747c478bd9Sstevel@tonic-gate { 31757c478bd9Sstevel@tonic-gate int i; 31767c478bd9Sstevel@tonic-gate char *rpath, *dir; 31777c478bd9Sstevel@tonic-gate const char *fcn = "s_rmdir"; 31787c478bd9Sstevel@tonic-gate 31797c478bd9Sstevel@tonic-gate /* 31807c478bd9Sstevel@tonic-gate * Certain directories are created at install time by packages. 31817c478bd9Sstevel@tonic-gate * Some of them (listed in packaged_dirs[]) are required by apps 31827c478bd9Sstevel@tonic-gate * and need to be present even when empty. 31837c478bd9Sstevel@tonic-gate */ 31847c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%s: checking if %s is packaged\n", fcn, path); 31857c478bd9Sstevel@tonic-gate 31867c478bd9Sstevel@tonic-gate rpath = path + strlen(dev_dir) + 1; 31877c478bd9Sstevel@tonic-gate 31887c478bd9Sstevel@tonic-gate for (i = 0; (dir = packaged_dirs[i]) != NULL; i++) { 31897c478bd9Sstevel@tonic-gate if (*rpath == *dir) { 31907c478bd9Sstevel@tonic-gate if (strcmp(rpath, dir) == 0) { 31917c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%s: skipping packaged dir: " 31927c478bd9Sstevel@tonic-gate "%s\n", fcn, path); 31934bc0a2efScasper errno = EEXIST; 31944bc0a2efScasper return (-1); 31957c478bd9Sstevel@tonic-gate } 31967c478bd9Sstevel@tonic-gate } 31977c478bd9Sstevel@tonic-gate } 31987c478bd9Sstevel@tonic-gate 31994bc0a2efScasper return (rmdir(path)); 32007c478bd9Sstevel@tonic-gate } 32017c478bd9Sstevel@tonic-gate 32027c478bd9Sstevel@tonic-gate /* 32037c478bd9Sstevel@tonic-gate * Try to remove any empty directories up the tree. It is assumed that 32047c478bd9Sstevel@tonic-gate * pathname is a file that was removed, so start with its parent, and 32057c478bd9Sstevel@tonic-gate * work up the tree. 32067c478bd9Sstevel@tonic-gate */ 32077c478bd9Sstevel@tonic-gate static void 32087c478bd9Sstevel@tonic-gate rm_parent_dir_if_empty(char *pathname) 32097c478bd9Sstevel@tonic-gate { 32107c478bd9Sstevel@tonic-gate char *ptr, path[PATH_MAX + 1]; 32117c478bd9Sstevel@tonic-gate char *fcn = "rm_parent_dir_if_empty: "; 32127c478bd9Sstevel@tonic-gate 32137c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%schecking %s if empty\n", fcn, pathname); 32147c478bd9Sstevel@tonic-gate 32157c478bd9Sstevel@tonic-gate (void) strcpy(path, pathname); 32167c478bd9Sstevel@tonic-gate 32177c478bd9Sstevel@tonic-gate /* 32187c478bd9Sstevel@tonic-gate * ascend up the dir tree, deleting all empty dirs. 32197c478bd9Sstevel@tonic-gate * Return immediately if a dir is not empty. 32207c478bd9Sstevel@tonic-gate */ 32217c478bd9Sstevel@tonic-gate for (;;) { 32227c478bd9Sstevel@tonic-gate 32237c478bd9Sstevel@tonic-gate if ((ptr = strrchr(path, '/')) == NULL) { 32247c478bd9Sstevel@tonic-gate return; 32257c478bd9Sstevel@tonic-gate } 32267c478bd9Sstevel@tonic-gate 32277c478bd9Sstevel@tonic-gate *ptr = '\0'; 32287c478bd9Sstevel@tonic-gate 3229e37c6c37Scth if (finddev_emptydir(path)) { 3230e37c6c37Scth /* directory is empty */ 3231facf4a8dSllai if (s_rmdir(path) == 0) { 3232facf4a8dSllai vprint(REMOVE_MID, 3233facf4a8dSllai "%sremoving empty dir %s\n", fcn, path); 3234facf4a8dSllai } else if (errno == EEXIST) { 3235facf4a8dSllai vprint(REMOVE_MID, 3236facf4a8dSllai "%sfailed to remove dir: %s\n", fcn, path); 3237facf4a8dSllai return; 3238facf4a8dSllai } 3239facf4a8dSllai } else { 3240facf4a8dSllai /* some other file is here, so return */ 32417c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%sdir not empty: %s\n", fcn, path); 32427c478bd9Sstevel@tonic-gate return; 32437c478bd9Sstevel@tonic-gate } 32447c478bd9Sstevel@tonic-gate } 32457c478bd9Sstevel@tonic-gate } 32467c478bd9Sstevel@tonic-gate 32477c478bd9Sstevel@tonic-gate /* 32487c478bd9Sstevel@tonic-gate * This function and all the functions it calls below were added to 32497c478bd9Sstevel@tonic-gate * handle the unique problem with world wide names (WWN). The problem is 32507c478bd9Sstevel@tonic-gate * that if a WWN device is moved to another address on the same controller 32517c478bd9Sstevel@tonic-gate * its logical link will change, while the physical node remains the same. 32527c478bd9Sstevel@tonic-gate * The result is that two logical links will point to the same physical path 32537c478bd9Sstevel@tonic-gate * in /devices, the valid link and a stale link. This function will 32547c478bd9Sstevel@tonic-gate * find all the stale nodes, though at a significant performance cost. 32557c478bd9Sstevel@tonic-gate * 32567c478bd9Sstevel@tonic-gate * Caching is used to increase performance. 32577c478bd9Sstevel@tonic-gate * A cache will be built from disk if the cache tag doesn't already exist. 32587c478bd9Sstevel@tonic-gate * The cache tag is a regular expression "dir_re", which selects a 32597c478bd9Sstevel@tonic-gate * subset of disks to search from typically something like 32607c478bd9Sstevel@tonic-gate * "dev/cXt[0-9]+d[0-9]+s[0-9]+". After the cache is built, consistency must 32617c478bd9Sstevel@tonic-gate * be maintained, so entries are added as new links are created, and removed 32627c478bd9Sstevel@tonic-gate * as old links are deleted. The whole cache is flushed if we are a daemon, 32637c478bd9Sstevel@tonic-gate * and another devfsadm process ran in between. 32647c478bd9Sstevel@tonic-gate * 32657c478bd9Sstevel@tonic-gate * Once the cache is built, this function finds the cache which matches 32667c478bd9Sstevel@tonic-gate * dir_re, and then it searches all links in that cache looking for 32677c478bd9Sstevel@tonic-gate * any link whose contents match "valid_link_contents" with a corresponding link 32687c478bd9Sstevel@tonic-gate * which does not match "valid_link". Any such matches are stale and removed. 32697c478bd9Sstevel@tonic-gate */ 32707c478bd9Sstevel@tonic-gate void 32717c478bd9Sstevel@tonic-gate devfsadm_rm_stale_links(char *dir_re, char *valid_link, di_node_t node, 32727c478bd9Sstevel@tonic-gate di_minor_t minor) 32737c478bd9Sstevel@tonic-gate { 32747c478bd9Sstevel@tonic-gate link_t *link; 32757c478bd9Sstevel@tonic-gate linkhead_t *head; 32767c478bd9Sstevel@tonic-gate char phy_path[PATH_MAX + 1]; 32777c478bd9Sstevel@tonic-gate char *valid_link_contents; 32787c478bd9Sstevel@tonic-gate char *dev_path; 32797c478bd9Sstevel@tonic-gate char rmlink[PATH_MAX + 1]; 32807c478bd9Sstevel@tonic-gate 32817c478bd9Sstevel@tonic-gate /* 32827c478bd9Sstevel@tonic-gate * try to use devices path 32837c478bd9Sstevel@tonic-gate */ 32847c478bd9Sstevel@tonic-gate if ((node == lnode) && (minor == lminor)) { 32857c478bd9Sstevel@tonic-gate valid_link_contents = lphy_path; 32867c478bd9Sstevel@tonic-gate } else { 32877c478bd9Sstevel@tonic-gate if ((dev_path = di_devfs_path(node)) == NULL) { 32887c478bd9Sstevel@tonic-gate err_print(DI_DEVFS_PATH_FAILED, strerror(errno)); 32897c478bd9Sstevel@tonic-gate devfsadm_exit(1); 3290*537714daSvikram /*NOTREACHED*/ 32917c478bd9Sstevel@tonic-gate } 32927c478bd9Sstevel@tonic-gate (void) strcpy(phy_path, dev_path); 32937c478bd9Sstevel@tonic-gate di_devfs_path_free(dev_path); 32947c478bd9Sstevel@tonic-gate 32957c478bd9Sstevel@tonic-gate (void) strcat(phy_path, ":"); 32967c478bd9Sstevel@tonic-gate (void) strcat(phy_path, di_minor_name(minor)); 32977c478bd9Sstevel@tonic-gate valid_link_contents = phy_path; 32987c478bd9Sstevel@tonic-gate } 32997c478bd9Sstevel@tonic-gate 33007c478bd9Sstevel@tonic-gate /* 33017c478bd9Sstevel@tonic-gate * As an optimization, check to make sure the corresponding 33027c478bd9Sstevel@tonic-gate * devlink was just created before continuing. 33037c478bd9Sstevel@tonic-gate */ 33047c478bd9Sstevel@tonic-gate 33057c478bd9Sstevel@tonic-gate if (linknew == FALSE) { 33067c478bd9Sstevel@tonic-gate return; 33077c478bd9Sstevel@tonic-gate } 33087c478bd9Sstevel@tonic-gate 33097c478bd9Sstevel@tonic-gate head = get_cached_links(dir_re); 33107c478bd9Sstevel@tonic-gate 33117c478bd9Sstevel@tonic-gate assert(head->nextlink == NULL); 33127c478bd9Sstevel@tonic-gate 33137c478bd9Sstevel@tonic-gate for (link = head->link; link != NULL; link = head->nextlink) { 33147c478bd9Sstevel@tonic-gate /* 33157c478bd9Sstevel@tonic-gate * See hot_cleanup() for why we do this 33167c478bd9Sstevel@tonic-gate */ 33177c478bd9Sstevel@tonic-gate head->nextlink = link->next; 33187c478bd9Sstevel@tonic-gate if ((strcmp(link->contents, valid_link_contents) == 0) && 33197c478bd9Sstevel@tonic-gate (strcmp(link->devlink, valid_link) != 0)) { 33207c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "removing %s -> %s\n" 33210a653502Swroche "valid link is: %s -> %s\n", 33220a653502Swroche link->devlink, link->contents, 33230a653502Swroche valid_link, valid_link_contents); 33247c478bd9Sstevel@tonic-gate /* 33257c478bd9Sstevel@tonic-gate * Use a copy of the cached link name as the 33267c478bd9Sstevel@tonic-gate * cache entry will go away during link removal 33277c478bd9Sstevel@tonic-gate */ 33287c478bd9Sstevel@tonic-gate (void) snprintf(rmlink, sizeof (rmlink), "%s", 33297c478bd9Sstevel@tonic-gate link->devlink); 33307c478bd9Sstevel@tonic-gate devfsadm_rm_link(rmlink); 33317c478bd9Sstevel@tonic-gate } 33327c478bd9Sstevel@tonic-gate } 33337c478bd9Sstevel@tonic-gate } 33347c478bd9Sstevel@tonic-gate 33357c478bd9Sstevel@tonic-gate /* 33367c478bd9Sstevel@tonic-gate * Return previously created cache, or create cache. 33377c478bd9Sstevel@tonic-gate */ 33387c478bd9Sstevel@tonic-gate static linkhead_t * 33397c478bd9Sstevel@tonic-gate get_cached_links(char *dir_re) 33407c478bd9Sstevel@tonic-gate { 33417c478bd9Sstevel@tonic-gate recurse_dev_t rd; 33427c478bd9Sstevel@tonic-gate linkhead_t *linkhead; 33437c478bd9Sstevel@tonic-gate int n; 33447c478bd9Sstevel@tonic-gate 33457c478bd9Sstevel@tonic-gate vprint(BUILDCACHE_MID, "get_cached_links: %s\n", dir_re); 33467c478bd9Sstevel@tonic-gate 33477c478bd9Sstevel@tonic-gate for (linkhead = headlinkhead; linkhead != NULL; 33480a653502Swroche linkhead = linkhead->nexthead) { 33497c478bd9Sstevel@tonic-gate if (strcmp(linkhead->dir_re, dir_re) == 0) { 33507c478bd9Sstevel@tonic-gate return (linkhead); 33517c478bd9Sstevel@tonic-gate } 33527c478bd9Sstevel@tonic-gate } 33537c478bd9Sstevel@tonic-gate 33547c478bd9Sstevel@tonic-gate /* 33557c478bd9Sstevel@tonic-gate * This tag is not in cache, so add it, along with all its 33567c478bd9Sstevel@tonic-gate * matching /dev entries. This is the only time we go to disk. 33577c478bd9Sstevel@tonic-gate */ 33587c478bd9Sstevel@tonic-gate linkhead = s_malloc(sizeof (linkhead_t)); 33597c478bd9Sstevel@tonic-gate linkhead->nexthead = headlinkhead; 33607c478bd9Sstevel@tonic-gate headlinkhead = linkhead; 33617c478bd9Sstevel@tonic-gate linkhead->dir_re = s_strdup(dir_re); 33627c478bd9Sstevel@tonic-gate 33637c478bd9Sstevel@tonic-gate if ((n = regcomp(&(linkhead->dir_re_compiled), dir_re, 33640a653502Swroche REG_EXTENDED)) != 0) { 33657c478bd9Sstevel@tonic-gate err_print(REGCOMP_FAILED, dir_re, n); 33667c478bd9Sstevel@tonic-gate } 33677c478bd9Sstevel@tonic-gate 33687c478bd9Sstevel@tonic-gate linkhead->nextlink = NULL; 33697c478bd9Sstevel@tonic-gate linkhead->link = NULL; 33707c478bd9Sstevel@tonic-gate 33717c478bd9Sstevel@tonic-gate rd.fcn = build_devlink_list; 33727c478bd9Sstevel@tonic-gate rd.data = (void *)linkhead; 33737c478bd9Sstevel@tonic-gate 33747c478bd9Sstevel@tonic-gate vprint(BUILDCACHE_MID, "get_cached_links: calling recurse_dev_re\n"); 33757c478bd9Sstevel@tonic-gate 33767c478bd9Sstevel@tonic-gate /* call build_devlink_list for each directory in the dir_re RE */ 33777c478bd9Sstevel@tonic-gate if (dir_re[0] == '/') { 33787c478bd9Sstevel@tonic-gate recurse_dev_re("/", &dir_re[1], &rd); 33797c478bd9Sstevel@tonic-gate } else { 33807c478bd9Sstevel@tonic-gate recurse_dev_re(dev_dir, dir_re, &rd); 33817c478bd9Sstevel@tonic-gate } 33827c478bd9Sstevel@tonic-gate 33837c478bd9Sstevel@tonic-gate return (linkhead); 33847c478bd9Sstevel@tonic-gate } 33857c478bd9Sstevel@tonic-gate 33867c478bd9Sstevel@tonic-gate static void 33877c478bd9Sstevel@tonic-gate build_devlink_list(char *devlink, void *data) 33887c478bd9Sstevel@tonic-gate { 33897c478bd9Sstevel@tonic-gate char *fcn = "build_devlink_list: "; 33907c478bd9Sstevel@tonic-gate char *ptr; 33917c478bd9Sstevel@tonic-gate char *r_contents; 33927c478bd9Sstevel@tonic-gate char *r_devlink; 33937c478bd9Sstevel@tonic-gate char contents[PATH_MAX + 1]; 33947c478bd9Sstevel@tonic-gate char newlink[PATH_MAX + 1]; 33957c478bd9Sstevel@tonic-gate char stage_link[PATH_MAX + 1]; 33967c478bd9Sstevel@tonic-gate int linksize; 33977c478bd9Sstevel@tonic-gate linkhead_t *linkhead = (linkhead_t *)data; 33987c478bd9Sstevel@tonic-gate link_t *link; 33997c478bd9Sstevel@tonic-gate int i = 0; 34007c478bd9Sstevel@tonic-gate 34017c478bd9Sstevel@tonic-gate vprint(BUILDCACHE_MID, "%scheck_link: %s\n", fcn, devlink); 34027c478bd9Sstevel@tonic-gate 34037c478bd9Sstevel@tonic-gate (void) strcpy(newlink, devlink); 34047c478bd9Sstevel@tonic-gate 34057c478bd9Sstevel@tonic-gate do { 34067c478bd9Sstevel@tonic-gate linksize = readlink(newlink, contents, PATH_MAX); 34077c478bd9Sstevel@tonic-gate if (linksize <= 0) { 34087c478bd9Sstevel@tonic-gate /* 34097c478bd9Sstevel@tonic-gate * The first pass through the do loop we may readlink() 34107c478bd9Sstevel@tonic-gate * non-symlink files(EINVAL) from false regexec matches. 34117c478bd9Sstevel@tonic-gate * Suppress error messages in those cases or if the link 34127c478bd9Sstevel@tonic-gate * content is the empty string. 34137c478bd9Sstevel@tonic-gate */ 34147c478bd9Sstevel@tonic-gate if (linksize < 0 && (i || errno != EINVAL)) 34157c478bd9Sstevel@tonic-gate err_print(READLINK_FAILED, "build_devlink_list", 34167c478bd9Sstevel@tonic-gate newlink, strerror(errno)); 34177c478bd9Sstevel@tonic-gate return; 34187c478bd9Sstevel@tonic-gate } 34197c478bd9Sstevel@tonic-gate contents[linksize] = '\0'; 34207c478bd9Sstevel@tonic-gate i = 1; 34217c478bd9Sstevel@tonic-gate 34227c478bd9Sstevel@tonic-gate if (is_minor_node(contents, &r_contents) == DEVFSADM_FALSE) { 34237c478bd9Sstevel@tonic-gate /* 34247c478bd9Sstevel@tonic-gate * assume that link contents is really a pointer to 34257c478bd9Sstevel@tonic-gate * another link, so recurse and read its link contents. 34267c478bd9Sstevel@tonic-gate * 34277c478bd9Sstevel@tonic-gate * some link contents are absolute: 34287c478bd9Sstevel@tonic-gate * /dev/audio -> /dev/sound/0 34297c478bd9Sstevel@tonic-gate */ 34307c478bd9Sstevel@tonic-gate if (strncmp(contents, DEV "/", 34310a653502Swroche strlen(DEV) + strlen("/")) != 0) { 34327c478bd9Sstevel@tonic-gate 34337c478bd9Sstevel@tonic-gate if ((ptr = strrchr(newlink, '/')) == NULL) { 34347c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%s%s -> %s invalid " 34350a653502Swroche "link. missing '/'\n", fcn, 34360a653502Swroche newlink, contents); 34370a653502Swroche return; 34387c478bd9Sstevel@tonic-gate } 34397c478bd9Sstevel@tonic-gate *ptr = '\0'; 34407c478bd9Sstevel@tonic-gate (void) strcpy(stage_link, newlink); 34417c478bd9Sstevel@tonic-gate *ptr = '/'; 34427c478bd9Sstevel@tonic-gate (void) strcat(stage_link, "/"); 34437c478bd9Sstevel@tonic-gate (void) strcat(stage_link, contents); 34447c478bd9Sstevel@tonic-gate (void) strcpy(newlink, stage_link); 34457c478bd9Sstevel@tonic-gate } else { 34467c478bd9Sstevel@tonic-gate (void) strcpy(newlink, dev_dir); 34477c478bd9Sstevel@tonic-gate (void) strcat(newlink, "/"); 34487c478bd9Sstevel@tonic-gate (void) strcat(newlink, 34490a653502Swroche &contents[strlen(DEV) + strlen("/")]); 34507c478bd9Sstevel@tonic-gate } 34517c478bd9Sstevel@tonic-gate 34527c478bd9Sstevel@tonic-gate } else { 34537c478bd9Sstevel@tonic-gate newlink[0] = '\0'; 34547c478bd9Sstevel@tonic-gate } 34557c478bd9Sstevel@tonic-gate } while (newlink[0] != '\0'); 34567c478bd9Sstevel@tonic-gate 34577c478bd9Sstevel@tonic-gate if (strncmp(devlink, dev_dir, strlen(dev_dir)) != 0) { 34587c478bd9Sstevel@tonic-gate vprint(BUILDCACHE_MID, "%sinvalid link: %s\n", fcn, devlink); 34597c478bd9Sstevel@tonic-gate return; 34607c478bd9Sstevel@tonic-gate } 34617c478bd9Sstevel@tonic-gate 34627c478bd9Sstevel@tonic-gate r_devlink = devlink + strlen(dev_dir); 34637c478bd9Sstevel@tonic-gate 34647c478bd9Sstevel@tonic-gate if (r_devlink[0] != '/') 34657c478bd9Sstevel@tonic-gate return; 34667c478bd9Sstevel@tonic-gate 34677c478bd9Sstevel@tonic-gate link = s_malloc(sizeof (link_t)); 34687c478bd9Sstevel@tonic-gate 34697c478bd9Sstevel@tonic-gate /* don't store the '/' after rootdir/dev */ 34707c478bd9Sstevel@tonic-gate r_devlink += 1; 34717c478bd9Sstevel@tonic-gate 34727c478bd9Sstevel@tonic-gate vprint(BUILDCACHE_MID, "%scaching link: %s\n", fcn, r_devlink); 34737c478bd9Sstevel@tonic-gate link->devlink = s_strdup(r_devlink); 34747c478bd9Sstevel@tonic-gate 34757c478bd9Sstevel@tonic-gate link->contents = s_strdup(r_contents); 34767c478bd9Sstevel@tonic-gate 34777c478bd9Sstevel@tonic-gate link->next = linkhead->link; 34787c478bd9Sstevel@tonic-gate linkhead->link = link; 34797c478bd9Sstevel@tonic-gate } 34807c478bd9Sstevel@tonic-gate 34817c478bd9Sstevel@tonic-gate /* 34827c478bd9Sstevel@tonic-gate * to be consistent, devlink must not begin with / and must be 34837c478bd9Sstevel@tonic-gate * relative to /dev/, whereas physpath must contain / and be 34847c478bd9Sstevel@tonic-gate * relative to /devices. 34857c478bd9Sstevel@tonic-gate */ 34867c478bd9Sstevel@tonic-gate static void 34877c478bd9Sstevel@tonic-gate add_link_to_cache(char *devlink, char *physpath) 34887c478bd9Sstevel@tonic-gate { 34897c478bd9Sstevel@tonic-gate linkhead_t *linkhead; 34907c478bd9Sstevel@tonic-gate link_t *link; 34917c478bd9Sstevel@tonic-gate int added = 0; 34927c478bd9Sstevel@tonic-gate 34937c478bd9Sstevel@tonic-gate if (file_mods == FALSE) { 34947c478bd9Sstevel@tonic-gate return; 34957c478bd9Sstevel@tonic-gate } 34967c478bd9Sstevel@tonic-gate 34977c478bd9Sstevel@tonic-gate vprint(CACHE_MID, "add_link_to_cache: %s -> %s ", 34980a653502Swroche devlink, physpath); 34997c478bd9Sstevel@tonic-gate 35007c478bd9Sstevel@tonic-gate for (linkhead = headlinkhead; linkhead != NULL; 35010a653502Swroche linkhead = linkhead->nexthead) { 35020a653502Swroche if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0) 35030a653502Swroche == 0) { 35047c478bd9Sstevel@tonic-gate added++; 35057c478bd9Sstevel@tonic-gate link = s_malloc(sizeof (link_t)); 35067c478bd9Sstevel@tonic-gate link->devlink = s_strdup(devlink); 35077c478bd9Sstevel@tonic-gate link->contents = s_strdup(physpath); 35087c478bd9Sstevel@tonic-gate link->next = linkhead->link; 35097c478bd9Sstevel@tonic-gate linkhead->link = link; 35107c478bd9Sstevel@tonic-gate } 35117c478bd9Sstevel@tonic-gate } 35127c478bd9Sstevel@tonic-gate 35137c478bd9Sstevel@tonic-gate vprint(CACHE_MID, 35140a653502Swroche " %d %s\n", added, added == 0 ? "NOT ADDED" : "ADDED"); 35157c478bd9Sstevel@tonic-gate } 35167c478bd9Sstevel@tonic-gate 35177c478bd9Sstevel@tonic-gate /* 35187c478bd9Sstevel@tonic-gate * Remove devlink from cache. Devlink must be relative to /dev/ and not start 35197c478bd9Sstevel@tonic-gate * with /. 35207c478bd9Sstevel@tonic-gate */ 35217c478bd9Sstevel@tonic-gate static void 35227c478bd9Sstevel@tonic-gate rm_link_from_cache(char *devlink) 35237c478bd9Sstevel@tonic-gate { 35247c478bd9Sstevel@tonic-gate linkhead_t *linkhead; 35257c478bd9Sstevel@tonic-gate link_t **linkp; 35267c478bd9Sstevel@tonic-gate link_t *save; 35277c478bd9Sstevel@tonic-gate 35287c478bd9Sstevel@tonic-gate vprint(CACHE_MID, "rm_link_from_cache enter: %s\n", devlink); 35297c478bd9Sstevel@tonic-gate 35307c478bd9Sstevel@tonic-gate for (linkhead = headlinkhead; linkhead != NULL; 35317c478bd9Sstevel@tonic-gate linkhead = linkhead->nexthead) { 35320a653502Swroche if (regexec(&(linkhead->dir_re_compiled), devlink, 0, NULL, 0) 35330a653502Swroche == 0) { 35347c478bd9Sstevel@tonic-gate 35357c478bd9Sstevel@tonic-gate for (linkp = &(linkhead->link); *linkp != NULL; ) { 35367c478bd9Sstevel@tonic-gate if ((strcmp((*linkp)->devlink, devlink) == 0)) { 35377c478bd9Sstevel@tonic-gate save = *linkp; 35387c478bd9Sstevel@tonic-gate *linkp = (*linkp)->next; 35397c478bd9Sstevel@tonic-gate /* 35407c478bd9Sstevel@tonic-gate * We are removing our caller's 35417c478bd9Sstevel@tonic-gate * "next" link. Update the nextlink 35427c478bd9Sstevel@tonic-gate * field in the head so that our 35437c478bd9Sstevel@tonic-gate * callers accesses the next valid 35447c478bd9Sstevel@tonic-gate * link 35457c478bd9Sstevel@tonic-gate */ 35467c478bd9Sstevel@tonic-gate if (linkhead->nextlink == save) 35477c478bd9Sstevel@tonic-gate linkhead->nextlink = *linkp; 35487c478bd9Sstevel@tonic-gate free(save->devlink); 35497c478bd9Sstevel@tonic-gate free(save->contents); 35507c478bd9Sstevel@tonic-gate free(save); 35517c478bd9Sstevel@tonic-gate vprint(CACHE_MID, " %s FREED FROM " 35520a653502Swroche "CACHE\n", devlink); 35537c478bd9Sstevel@tonic-gate } else { 35547c478bd9Sstevel@tonic-gate linkp = &((*linkp)->next); 35557c478bd9Sstevel@tonic-gate } 35567c478bd9Sstevel@tonic-gate } 35577c478bd9Sstevel@tonic-gate } 35587c478bd9Sstevel@tonic-gate } 35597c478bd9Sstevel@tonic-gate } 35607c478bd9Sstevel@tonic-gate 35617c478bd9Sstevel@tonic-gate static void 35627c478bd9Sstevel@tonic-gate rm_all_links_from_cache() 35637c478bd9Sstevel@tonic-gate { 35647c478bd9Sstevel@tonic-gate linkhead_t *linkhead; 35657c478bd9Sstevel@tonic-gate linkhead_t *nextlinkhead; 35667c478bd9Sstevel@tonic-gate link_t *link; 35677c478bd9Sstevel@tonic-gate link_t *nextlink; 35687c478bd9Sstevel@tonic-gate 35697c478bd9Sstevel@tonic-gate vprint(CACHE_MID, "rm_all_links_from_cache\n"); 35707c478bd9Sstevel@tonic-gate 35717c478bd9Sstevel@tonic-gate for (linkhead = headlinkhead; linkhead != NULL; 35720a653502Swroche linkhead = nextlinkhead) { 35737c478bd9Sstevel@tonic-gate 35747c478bd9Sstevel@tonic-gate nextlinkhead = linkhead->nexthead; 35757c478bd9Sstevel@tonic-gate assert(linkhead->nextlink == NULL); 35767c478bd9Sstevel@tonic-gate for (link = linkhead->link; link != NULL; link = nextlink) { 35777c478bd9Sstevel@tonic-gate nextlink = link->next; 35787c478bd9Sstevel@tonic-gate free(link->devlink); 35797c478bd9Sstevel@tonic-gate free(link->contents); 35807c478bd9Sstevel@tonic-gate free(link); 35817c478bd9Sstevel@tonic-gate } 35827c478bd9Sstevel@tonic-gate regfree(&(linkhead->dir_re_compiled)); 35837c478bd9Sstevel@tonic-gate free(linkhead->dir_re); 35847c478bd9Sstevel@tonic-gate free(linkhead); 35857c478bd9Sstevel@tonic-gate } 35867c478bd9Sstevel@tonic-gate headlinkhead = NULL; 35877c478bd9Sstevel@tonic-gate } 35887c478bd9Sstevel@tonic-gate 35897c478bd9Sstevel@tonic-gate /* 35907c478bd9Sstevel@tonic-gate * Called when the kernel has modified the incore path_to_inst data. This 35917c478bd9Sstevel@tonic-gate * function will schedule a flush of the data to the filesystem. 35927c478bd9Sstevel@tonic-gate */ 35937c478bd9Sstevel@tonic-gate static void 35947c478bd9Sstevel@tonic-gate devfs_instance_mod(void) 35957c478bd9Sstevel@tonic-gate { 35967c478bd9Sstevel@tonic-gate char *fcn = "devfs_instance_mod: "; 35977c478bd9Sstevel@tonic-gate vprint(PATH2INST_MID, "%senter\n", fcn); 35987c478bd9Sstevel@tonic-gate 35997c478bd9Sstevel@tonic-gate /* signal instance thread */ 36007c478bd9Sstevel@tonic-gate (void) mutex_lock(&count_lock); 36017c478bd9Sstevel@tonic-gate inst_count++; 36027c478bd9Sstevel@tonic-gate (void) cond_signal(&cv); 36037c478bd9Sstevel@tonic-gate (void) mutex_unlock(&count_lock); 36047c478bd9Sstevel@tonic-gate } 36057c478bd9Sstevel@tonic-gate 36067c478bd9Sstevel@tonic-gate static void 36077c478bd9Sstevel@tonic-gate instance_flush_thread(void) 36087c478bd9Sstevel@tonic-gate { 36097c478bd9Sstevel@tonic-gate int i; 36107c478bd9Sstevel@tonic-gate int idle; 36117c478bd9Sstevel@tonic-gate 36127c478bd9Sstevel@tonic-gate for (;;) { 36137c478bd9Sstevel@tonic-gate 36147c478bd9Sstevel@tonic-gate (void) mutex_lock(&count_lock); 36157c478bd9Sstevel@tonic-gate while (inst_count == 0) { 36167c478bd9Sstevel@tonic-gate (void) cond_wait(&cv, &count_lock); 36177c478bd9Sstevel@tonic-gate } 36187c478bd9Sstevel@tonic-gate inst_count = 0; 36197c478bd9Sstevel@tonic-gate 36207c478bd9Sstevel@tonic-gate vprint(PATH2INST_MID, "signaled to flush path_to_inst." 36210a653502Swroche " Enter delay loop\n"); 36227c478bd9Sstevel@tonic-gate /* 36237c478bd9Sstevel@tonic-gate * Wait MAX_IDLE_DELAY seconds after getting the last flush 36247c478bd9Sstevel@tonic-gate * path_to_inst event before invoking a flush, but never wait 36257c478bd9Sstevel@tonic-gate * more than MAX_DELAY seconds after getting the first event. 36267c478bd9Sstevel@tonic-gate */ 36277c478bd9Sstevel@tonic-gate for (idle = 0, i = 0; i < MAX_DELAY; i++) { 36287c478bd9Sstevel@tonic-gate 36297c478bd9Sstevel@tonic-gate (void) mutex_unlock(&count_lock); 36307c478bd9Sstevel@tonic-gate (void) sleep(1); 36317c478bd9Sstevel@tonic-gate (void) mutex_lock(&count_lock); 36327c478bd9Sstevel@tonic-gate 36337c478bd9Sstevel@tonic-gate /* shorten the delay if we are idle */ 36347c478bd9Sstevel@tonic-gate if (inst_count == 0) { 36357c478bd9Sstevel@tonic-gate idle++; 36367c478bd9Sstevel@tonic-gate if (idle > MAX_IDLE_DELAY) { 36377c478bd9Sstevel@tonic-gate break; 36387c478bd9Sstevel@tonic-gate } 36397c478bd9Sstevel@tonic-gate } else { 36407c478bd9Sstevel@tonic-gate inst_count = idle = 0; 36417c478bd9Sstevel@tonic-gate } 36427c478bd9Sstevel@tonic-gate } 36437c478bd9Sstevel@tonic-gate 36447c478bd9Sstevel@tonic-gate (void) mutex_unlock(&count_lock); 36457c478bd9Sstevel@tonic-gate 36467c478bd9Sstevel@tonic-gate flush_path_to_inst(); 36477c478bd9Sstevel@tonic-gate } 36487c478bd9Sstevel@tonic-gate } 36497c478bd9Sstevel@tonic-gate 36507c478bd9Sstevel@tonic-gate /* 36517c478bd9Sstevel@tonic-gate * Helper function for flush_path_to_inst() below; this routine calls the 36527c478bd9Sstevel@tonic-gate * inst_sync syscall to flush the path_to_inst database to the given file. 36537c478bd9Sstevel@tonic-gate */ 36547c478bd9Sstevel@tonic-gate static int 36550a653502Swroche do_inst_sync(char *filename, char *instfilename) 36567c478bd9Sstevel@tonic-gate { 36577c478bd9Sstevel@tonic-gate void (*sigsaved)(int); 36580a653502Swroche int err = 0, flags = INST_SYNC_IF_REQUIRED; 36590a653502Swroche struct stat sb; 36600a653502Swroche 36610a653502Swroche if (stat(instfilename, &sb) == -1 && errno == ENOENT) 36620a653502Swroche flags = INST_SYNC_ALWAYS; 36637c478bd9Sstevel@tonic-gate 36647c478bd9Sstevel@tonic-gate vprint(INSTSYNC_MID, "do_inst_sync: about to flush %s\n", filename); 36657c478bd9Sstevel@tonic-gate sigsaved = sigset(SIGSYS, SIG_IGN); 36660a653502Swroche if (inst_sync(filename, flags) == -1) 36677c478bd9Sstevel@tonic-gate err = errno; 36687c478bd9Sstevel@tonic-gate (void) sigset(SIGSYS, sigsaved); 36697c478bd9Sstevel@tonic-gate 36707c478bd9Sstevel@tonic-gate switch (err) { 36717c478bd9Sstevel@tonic-gate case 0: 36727c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 36737c478bd9Sstevel@tonic-gate case EALREADY: /* no-op, path_to_inst already up to date */ 36747c478bd9Sstevel@tonic-gate return (EALREADY); 36757c478bd9Sstevel@tonic-gate case ENOSYS: 36767c478bd9Sstevel@tonic-gate err_print(CANT_LOAD_SYSCALL); 36777c478bd9Sstevel@tonic-gate break; 36787c478bd9Sstevel@tonic-gate case EPERM: 36797c478bd9Sstevel@tonic-gate err_print(SUPER_TO_SYNC); 36807c478bd9Sstevel@tonic-gate break; 36817c478bd9Sstevel@tonic-gate default: 36827c478bd9Sstevel@tonic-gate err_print(INSTSYNC_FAILED, filename, strerror(err)); 36837c478bd9Sstevel@tonic-gate break; 36847c478bd9Sstevel@tonic-gate } 36857c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 36867c478bd9Sstevel@tonic-gate } 36877c478bd9Sstevel@tonic-gate 36887c478bd9Sstevel@tonic-gate /* 36897c478bd9Sstevel@tonic-gate * Flush the kernel's path_to_inst database to /etc/path_to_inst. To do so 36907c478bd9Sstevel@tonic-gate * safely, the database is flushed to a temporary file, then moved into place. 36917c478bd9Sstevel@tonic-gate * 36927c478bd9Sstevel@tonic-gate * The following files are used during this process: 36937c478bd9Sstevel@tonic-gate * /etc/path_to_inst: The path_to_inst file 36947c478bd9Sstevel@tonic-gate * /etc/path_to_inst.<pid>: Contains data flushed from the kernel 36957c478bd9Sstevel@tonic-gate * /etc/path_to_inst.old: The backup file 36967c478bd9Sstevel@tonic-gate * /etc/path_to_inst.old.<pid>: Temp file for creating backup 36977c478bd9Sstevel@tonic-gate * 36987c478bd9Sstevel@tonic-gate */ 36997c478bd9Sstevel@tonic-gate static void 37007c478bd9Sstevel@tonic-gate flush_path_to_inst(void) 37017c478bd9Sstevel@tonic-gate { 37027c478bd9Sstevel@tonic-gate char *new_inst_file = NULL; 37037c478bd9Sstevel@tonic-gate char *old_inst_file = NULL; 37047c478bd9Sstevel@tonic-gate char *old_inst_file_npid = NULL; 37057c478bd9Sstevel@tonic-gate FILE *inst_file_fp = NULL; 37067c478bd9Sstevel@tonic-gate FILE *old_inst_file_fp = NULL; 37077c478bd9Sstevel@tonic-gate struct stat sb; 37087c478bd9Sstevel@tonic-gate int err = 0; 37097c478bd9Sstevel@tonic-gate int c; 37107c478bd9Sstevel@tonic-gate int inst_strlen; 37117c478bd9Sstevel@tonic-gate 37127c478bd9Sstevel@tonic-gate vprint(PATH2INST_MID, "flush_path_to_inst: %s\n", 37137c478bd9Sstevel@tonic-gate (flush_path_to_inst_enable == TRUE) ? "ENABLED" : "DISABLED"); 37147c478bd9Sstevel@tonic-gate 37157c478bd9Sstevel@tonic-gate if (flush_path_to_inst_enable == FALSE) { 37167c478bd9Sstevel@tonic-gate return; 37177c478bd9Sstevel@tonic-gate } 37187c478bd9Sstevel@tonic-gate 37197c478bd9Sstevel@tonic-gate inst_strlen = strlen(inst_file); 37207c478bd9Sstevel@tonic-gate new_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 2); 37217c478bd9Sstevel@tonic-gate old_inst_file = s_malloc(inst_strlen + PID_STR_LEN + 6); 37227c478bd9Sstevel@tonic-gate old_inst_file_npid = s_malloc(inst_strlen + 37237c478bd9Sstevel@tonic-gate sizeof (INSTANCE_FILE_SUFFIX)); 37247c478bd9Sstevel@tonic-gate 37257c478bd9Sstevel@tonic-gate (void) snprintf(new_inst_file, inst_strlen + PID_STR_LEN + 2, 37260a653502Swroche "%s.%ld", inst_file, getpid()); 37277c478bd9Sstevel@tonic-gate 37287c478bd9Sstevel@tonic-gate if (stat(new_inst_file, &sb) == 0) { 37297c478bd9Sstevel@tonic-gate s_unlink(new_inst_file); 37307c478bd9Sstevel@tonic-gate } 37317c478bd9Sstevel@tonic-gate 37320a653502Swroche err = do_inst_sync(new_inst_file, inst_file); 37330a653502Swroche if (err != DEVFSADM_SUCCESS) { 37347c478bd9Sstevel@tonic-gate goto out; 37357c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 37367c478bd9Sstevel@tonic-gate } 37377c478bd9Sstevel@tonic-gate 37387c478bd9Sstevel@tonic-gate /* 37397c478bd9Sstevel@tonic-gate * Now we deal with the somewhat tricky updating and renaming 37407c478bd9Sstevel@tonic-gate * of this critical piece of kernel state. 37417c478bd9Sstevel@tonic-gate */ 37427c478bd9Sstevel@tonic-gate 37437c478bd9Sstevel@tonic-gate /* 37447c478bd9Sstevel@tonic-gate * Copy the current instance file into a temporary file. 37457c478bd9Sstevel@tonic-gate * Then rename the temporary file into the backup (.old) 37467c478bd9Sstevel@tonic-gate * file and rename the newly flushed kernel data into 37477c478bd9Sstevel@tonic-gate * the instance file. 37487c478bd9Sstevel@tonic-gate * Of course if 'inst_file' doesn't exist, there's much 37497c478bd9Sstevel@tonic-gate * less for us to do .. tee hee. 37507c478bd9Sstevel@tonic-gate */ 37517c478bd9Sstevel@tonic-gate if ((inst_file_fp = fopen(inst_file, "r")) == NULL) { 37527c478bd9Sstevel@tonic-gate /* 37537c478bd9Sstevel@tonic-gate * No such file. Rename the new onto the old 37547c478bd9Sstevel@tonic-gate */ 37557c478bd9Sstevel@tonic-gate if ((err = rename(new_inst_file, inst_file)) != 0) 37567c478bd9Sstevel@tonic-gate err_print(RENAME_FAILED, inst_file, strerror(errno)); 37577c478bd9Sstevel@tonic-gate goto out; 37587c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 37597c478bd9Sstevel@tonic-gate } 37607c478bd9Sstevel@tonic-gate 37617c478bd9Sstevel@tonic-gate (void) snprintf(old_inst_file, inst_strlen + PID_STR_LEN + 6, 37620a653502Swroche "%s.old.%ld", inst_file, getpid()); 37637c478bd9Sstevel@tonic-gate 37647c478bd9Sstevel@tonic-gate if (stat(old_inst_file, &sb) == 0) { 37657c478bd9Sstevel@tonic-gate s_unlink(old_inst_file); 37667c478bd9Sstevel@tonic-gate } 37677c478bd9Sstevel@tonic-gate 37687c478bd9Sstevel@tonic-gate if ((old_inst_file_fp = fopen(old_inst_file, "w")) == NULL) { 37697c478bd9Sstevel@tonic-gate /* 37707c478bd9Sstevel@tonic-gate * Can't open the 'old_inst_file' file for writing. 37717c478bd9Sstevel@tonic-gate * This is somewhat strange given that the syscall 37727c478bd9Sstevel@tonic-gate * just succeeded to write a file out.. hmm.. maybe 37737c478bd9Sstevel@tonic-gate * the fs just filled up or something nasty. 37747c478bd9Sstevel@tonic-gate * 37757c478bd9Sstevel@tonic-gate * Anyway, abort what we've done so far. 37767c478bd9Sstevel@tonic-gate */ 37777c478bd9Sstevel@tonic-gate err_print(CANT_UPDATE, old_inst_file); 37787c478bd9Sstevel@tonic-gate err = DEVFSADM_FAILURE; 37797c478bd9Sstevel@tonic-gate goto out; 37807c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 37817c478bd9Sstevel@tonic-gate } 37827c478bd9Sstevel@tonic-gate 37837c478bd9Sstevel@tonic-gate /* 37847c478bd9Sstevel@tonic-gate * Copy current instance file into the temporary file 37857c478bd9Sstevel@tonic-gate */ 37867c478bd9Sstevel@tonic-gate err = 0; 37877c478bd9Sstevel@tonic-gate while ((c = getc(inst_file_fp)) != EOF) { 37887c478bd9Sstevel@tonic-gate if ((err = putc(c, old_inst_file_fp)) == EOF) { 37897c478bd9Sstevel@tonic-gate break; 37907c478bd9Sstevel@tonic-gate } 37917c478bd9Sstevel@tonic-gate } 37927c478bd9Sstevel@tonic-gate 37937c478bd9Sstevel@tonic-gate if (fclose(old_inst_file_fp) == EOF || err == EOF) { 37947c478bd9Sstevel@tonic-gate vprint(INFO_MID, CANT_UPDATE, old_inst_file); 37957c478bd9Sstevel@tonic-gate err = DEVFSADM_FAILURE; 37967c478bd9Sstevel@tonic-gate goto out; 37977c478bd9Sstevel@tonic-gate /* NOTREACHED */ 37987c478bd9Sstevel@tonic-gate } 37997c478bd9Sstevel@tonic-gate 38007c478bd9Sstevel@tonic-gate /* 38017c478bd9Sstevel@tonic-gate * Set permissions to be the same on the backup as 38027c478bd9Sstevel@tonic-gate * /etc/path_to_inst. 38037c478bd9Sstevel@tonic-gate */ 38047c478bd9Sstevel@tonic-gate (void) chmod(old_inst_file, 0444); 38057c478bd9Sstevel@tonic-gate 38067c478bd9Sstevel@tonic-gate /* 38077c478bd9Sstevel@tonic-gate * So far, everything we've done is more or less reversible. 38087c478bd9Sstevel@tonic-gate * But now we're going to commit ourselves. 38097c478bd9Sstevel@tonic-gate */ 38107c478bd9Sstevel@tonic-gate 38117c478bd9Sstevel@tonic-gate (void) snprintf(old_inst_file_npid, 38127c478bd9Sstevel@tonic-gate inst_strlen + sizeof (INSTANCE_FILE_SUFFIX), 38137c478bd9Sstevel@tonic-gate "%s%s", inst_file, INSTANCE_FILE_SUFFIX); 38147c478bd9Sstevel@tonic-gate 38157c478bd9Sstevel@tonic-gate if ((err = rename(old_inst_file, old_inst_file_npid)) != 0) { 38167c478bd9Sstevel@tonic-gate err_print(RENAME_FAILED, old_inst_file_npid, 38170a653502Swroche strerror(errno)); 38187c478bd9Sstevel@tonic-gate } else if ((err = rename(new_inst_file, inst_file)) != 0) { 38197c478bd9Sstevel@tonic-gate err_print(RENAME_FAILED, inst_file, strerror(errno)); 38207c478bd9Sstevel@tonic-gate } 38217c478bd9Sstevel@tonic-gate 38227c478bd9Sstevel@tonic-gate out: 38237c478bd9Sstevel@tonic-gate if (inst_file_fp != NULL) { 38247c478bd9Sstevel@tonic-gate if (fclose(inst_file_fp) == EOF) { 38257c478bd9Sstevel@tonic-gate err_print(FCLOSE_FAILED, inst_file, strerror(errno)); 38267c478bd9Sstevel@tonic-gate } 38277c478bd9Sstevel@tonic-gate } 38287c478bd9Sstevel@tonic-gate 38297c478bd9Sstevel@tonic-gate if (stat(new_inst_file, &sb) == 0) { 38307c478bd9Sstevel@tonic-gate s_unlink(new_inst_file); 38317c478bd9Sstevel@tonic-gate } 38327c478bd9Sstevel@tonic-gate free(new_inst_file); 38337c478bd9Sstevel@tonic-gate 38347c478bd9Sstevel@tonic-gate if (stat(old_inst_file, &sb) == 0) { 38357c478bd9Sstevel@tonic-gate s_unlink(old_inst_file); 38367c478bd9Sstevel@tonic-gate } 38377c478bd9Sstevel@tonic-gate free(old_inst_file); 38387c478bd9Sstevel@tonic-gate 38397c478bd9Sstevel@tonic-gate free(old_inst_file_npid); 38407c478bd9Sstevel@tonic-gate 38417c478bd9Sstevel@tonic-gate if (err != 0 && err != EALREADY) { 38427c478bd9Sstevel@tonic-gate err_print(FAILED_TO_UPDATE, inst_file); 38437c478bd9Sstevel@tonic-gate } 38447c478bd9Sstevel@tonic-gate } 38457c478bd9Sstevel@tonic-gate 38467c478bd9Sstevel@tonic-gate /* 38477c478bd9Sstevel@tonic-gate * detach from tty. For daemon mode. 38487c478bd9Sstevel@tonic-gate */ 38497c478bd9Sstevel@tonic-gate void 38507c478bd9Sstevel@tonic-gate detachfromtty() 38517c478bd9Sstevel@tonic-gate { 38527c478bd9Sstevel@tonic-gate (void) setsid(); 38537c478bd9Sstevel@tonic-gate if (DEVFSADM_DEBUG_ON == TRUE) { 38547c478bd9Sstevel@tonic-gate return; 38557c478bd9Sstevel@tonic-gate } 38567c478bd9Sstevel@tonic-gate 38577c478bd9Sstevel@tonic-gate (void) close(0); 38587c478bd9Sstevel@tonic-gate (void) close(1); 38597c478bd9Sstevel@tonic-gate (void) close(2); 38607c478bd9Sstevel@tonic-gate (void) open("/dev/null", O_RDWR, 0); 38617c478bd9Sstevel@tonic-gate (void) dup(0); 38627c478bd9Sstevel@tonic-gate (void) dup(0); 38637c478bd9Sstevel@tonic-gate openlog(DEVFSADMD, LOG_PID, LOG_DAEMON); 38647c478bd9Sstevel@tonic-gate (void) setlogmask(LOG_UPTO(LOG_INFO)); 38657c478bd9Sstevel@tonic-gate logflag = TRUE; 38667c478bd9Sstevel@tonic-gate } 38677c478bd9Sstevel@tonic-gate 38687c478bd9Sstevel@tonic-gate /* 38697c478bd9Sstevel@tonic-gate * Use an advisory lock to synchronize updates to /dev. If the lock is 38707c478bd9Sstevel@tonic-gate * held by another process, block in the fcntl() system call until that 38717c478bd9Sstevel@tonic-gate * process drops the lock or exits. The lock file itself is 38727c478bd9Sstevel@tonic-gate * DEV_LOCK_FILE. The process id of the current and last process owning 38737c478bd9Sstevel@tonic-gate * the lock is kept in the lock file. After acquiring the lock, read the 38747c478bd9Sstevel@tonic-gate * process id and return it. It is the process ID which last owned the 38757c478bd9Sstevel@tonic-gate * lock, and will be used to determine if caches need to be flushed. 38767c478bd9Sstevel@tonic-gate * 38777c478bd9Sstevel@tonic-gate * NOTE: if the devlink database is held open by the caller, it may 38787c478bd9Sstevel@tonic-gate * be closed by this routine. This is to enforce the following lock ordering: 38797c478bd9Sstevel@tonic-gate * 1) /dev lock 2) database open 38807c478bd9Sstevel@tonic-gate */ 38817c478bd9Sstevel@tonic-gate pid_t 38827c478bd9Sstevel@tonic-gate enter_dev_lock() 38837c478bd9Sstevel@tonic-gate { 38847c478bd9Sstevel@tonic-gate struct flock lock; 38857c478bd9Sstevel@tonic-gate int n; 38867c478bd9Sstevel@tonic-gate pid_t pid; 38877c478bd9Sstevel@tonic-gate pid_t last_owner_pid; 38887c478bd9Sstevel@tonic-gate 38897c478bd9Sstevel@tonic-gate if (file_mods == FALSE) { 38907c478bd9Sstevel@tonic-gate return (0); 38917c478bd9Sstevel@tonic-gate } 38927c478bd9Sstevel@tonic-gate 38937c478bd9Sstevel@tonic-gate (void) snprintf(dev_lockfile, sizeof (dev_lockfile), 3894facf4a8dSllai "%s/%s", etc_dev_dir, DEV_LOCK_FILE); 38957c478bd9Sstevel@tonic-gate 38967c478bd9Sstevel@tonic-gate vprint(LOCK_MID, "enter_dev_lock: lock file %s\n", dev_lockfile); 38977c478bd9Sstevel@tonic-gate 38987c478bd9Sstevel@tonic-gate dev_lock_fd = open(dev_lockfile, O_CREAT|O_RDWR, 0644); 38997c478bd9Sstevel@tonic-gate if (dev_lock_fd < 0) { 39007c478bd9Sstevel@tonic-gate err_print(OPEN_FAILED, dev_lockfile, strerror(errno)); 39017c478bd9Sstevel@tonic-gate devfsadm_exit(1); 3902*537714daSvikram /*NOTREACHED*/ 39037c478bd9Sstevel@tonic-gate } 39047c478bd9Sstevel@tonic-gate 39057c478bd9Sstevel@tonic-gate lock.l_type = F_WRLCK; 39067c478bd9Sstevel@tonic-gate lock.l_whence = SEEK_SET; 39077c478bd9Sstevel@tonic-gate lock.l_start = 0; 39087c478bd9Sstevel@tonic-gate lock.l_len = 0; 39097c478bd9Sstevel@tonic-gate 39107c478bd9Sstevel@tonic-gate /* try for the lock, but don't wait */ 39117c478bd9Sstevel@tonic-gate if (fcntl(dev_lock_fd, F_SETLK, &lock) == -1) { 39127c478bd9Sstevel@tonic-gate if ((errno == EACCES) || (errno == EAGAIN)) { 39137c478bd9Sstevel@tonic-gate pid = 0; 39147c478bd9Sstevel@tonic-gate n = read(dev_lock_fd, &pid, sizeof (pid_t)); 39157c478bd9Sstevel@tonic-gate vprint(LOCK_MID, "waiting for PID %d to complete\n", 39160a653502Swroche (int)pid); 39177c478bd9Sstevel@tonic-gate if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) { 39187c478bd9Sstevel@tonic-gate err_print(LSEEK_FAILED, dev_lockfile, 39190a653502Swroche strerror(errno)); 39207c478bd9Sstevel@tonic-gate devfsadm_exit(1); 3921*537714daSvikram /*NOTREACHED*/ 39227c478bd9Sstevel@tonic-gate } 39237c478bd9Sstevel@tonic-gate /* 39247c478bd9Sstevel@tonic-gate * wait for the dev lock. If we have the database open, 39257c478bd9Sstevel@tonic-gate * close it first - the order of lock acquisition should 39267c478bd9Sstevel@tonic-gate * always be: 1) dev_lock 2) database 39277c478bd9Sstevel@tonic-gate * This is to prevent deadlocks with any locks the 39287c478bd9Sstevel@tonic-gate * database code may hold. 39297c478bd9Sstevel@tonic-gate */ 39307c478bd9Sstevel@tonic-gate (void) di_devlink_close(&devlink_cache, 0); 3931f05faa4eSjacobs 3932f05faa4eSjacobs /* send any sysevents that were queued up. */ 3933f05faa4eSjacobs process_syseventq(); 3934f05faa4eSjacobs 39357c478bd9Sstevel@tonic-gate if (fcntl(dev_lock_fd, F_SETLKW, &lock) == -1) { 39367c478bd9Sstevel@tonic-gate err_print(LOCK_FAILED, dev_lockfile, 39370a653502Swroche strerror(errno)); 39387c478bd9Sstevel@tonic-gate devfsadm_exit(1); 3939*537714daSvikram /*NOTREACHED*/ 39407c478bd9Sstevel@tonic-gate } 39417c478bd9Sstevel@tonic-gate } 39427c478bd9Sstevel@tonic-gate } 39437c478bd9Sstevel@tonic-gate 39447c478bd9Sstevel@tonic-gate hold_dev_lock = TRUE; 39457c478bd9Sstevel@tonic-gate pid = 0; 39467c478bd9Sstevel@tonic-gate n = read(dev_lock_fd, &pid, sizeof (pid_t)); 39477c478bd9Sstevel@tonic-gate if (n == sizeof (pid_t) && pid == getpid()) { 39487c478bd9Sstevel@tonic-gate return (pid); 39497c478bd9Sstevel@tonic-gate } 39507c478bd9Sstevel@tonic-gate 39517c478bd9Sstevel@tonic-gate last_owner_pid = pid; 39527c478bd9Sstevel@tonic-gate 39537c478bd9Sstevel@tonic-gate if (lseek(dev_lock_fd, 0, SEEK_SET) == (off_t)-1) { 39547c478bd9Sstevel@tonic-gate err_print(LSEEK_FAILED, dev_lockfile, strerror(errno)); 39557c478bd9Sstevel@tonic-gate devfsadm_exit(1); 3956*537714daSvikram /*NOTREACHED*/ 39577c478bd9Sstevel@tonic-gate } 39587c478bd9Sstevel@tonic-gate pid = getpid(); 39597c478bd9Sstevel@tonic-gate n = write(dev_lock_fd, &pid, sizeof (pid_t)); 39607c478bd9Sstevel@tonic-gate if (n != sizeof (pid_t)) { 39617c478bd9Sstevel@tonic-gate err_print(WRITE_FAILED, dev_lockfile, strerror(errno)); 39627c478bd9Sstevel@tonic-gate devfsadm_exit(1); 3963*537714daSvikram /*NOTREACHED*/ 39647c478bd9Sstevel@tonic-gate } 39657c478bd9Sstevel@tonic-gate 39667c478bd9Sstevel@tonic-gate return (last_owner_pid); 39677c478bd9Sstevel@tonic-gate } 39687c478bd9Sstevel@tonic-gate 39697c478bd9Sstevel@tonic-gate /* 39707c478bd9Sstevel@tonic-gate * Drop the advisory /dev lock, close lock file. Close and re-open the 39717c478bd9Sstevel@tonic-gate * file every time so to ensure a resync if for some reason the lock file 39727c478bd9Sstevel@tonic-gate * gets removed. 39737c478bd9Sstevel@tonic-gate */ 39747c478bd9Sstevel@tonic-gate void 3975*537714daSvikram exit_dev_lock(int exiting) 39767c478bd9Sstevel@tonic-gate { 39777c478bd9Sstevel@tonic-gate struct flock unlock; 39787c478bd9Sstevel@tonic-gate 39797c478bd9Sstevel@tonic-gate if (hold_dev_lock == FALSE) { 39807c478bd9Sstevel@tonic-gate return; 39817c478bd9Sstevel@tonic-gate } 39827c478bd9Sstevel@tonic-gate 3983*537714daSvikram vprint(LOCK_MID, "exit_dev_lock: lock file %s, exiting = %d\n", 3984*537714daSvikram dev_lockfile, exiting); 39857c478bd9Sstevel@tonic-gate 39867c478bd9Sstevel@tonic-gate unlock.l_type = F_UNLCK; 39877c478bd9Sstevel@tonic-gate unlock.l_whence = SEEK_SET; 39887c478bd9Sstevel@tonic-gate unlock.l_start = 0; 39897c478bd9Sstevel@tonic-gate unlock.l_len = 0; 39907c478bd9Sstevel@tonic-gate 39917c478bd9Sstevel@tonic-gate if (fcntl(dev_lock_fd, F_SETLK, &unlock) == -1) { 39927c478bd9Sstevel@tonic-gate err_print(UNLOCK_FAILED, dev_lockfile, strerror(errno)); 39937c478bd9Sstevel@tonic-gate } 39947c478bd9Sstevel@tonic-gate 39957c478bd9Sstevel@tonic-gate hold_dev_lock = FALSE; 39967c478bd9Sstevel@tonic-gate 39977c478bd9Sstevel@tonic-gate if (close(dev_lock_fd) == -1) { 39987c478bd9Sstevel@tonic-gate err_print(CLOSE_FAILED, dev_lockfile, strerror(errno)); 3999*537714daSvikram if (!exiting) 4000*537714daSvikram devfsadm_exit(1); 4001*537714daSvikram /*NOTREACHED*/ 40027c478bd9Sstevel@tonic-gate } 40037c478bd9Sstevel@tonic-gate } 40047c478bd9Sstevel@tonic-gate 40057c478bd9Sstevel@tonic-gate /* 40067c478bd9Sstevel@tonic-gate * 40077c478bd9Sstevel@tonic-gate * Use an advisory lock to ensure that only one daemon process is active 40087c478bd9Sstevel@tonic-gate * in the system at any point in time. If the lock is held by another 40097c478bd9Sstevel@tonic-gate * process, do not block but return the pid owner of the lock to the 40107c478bd9Sstevel@tonic-gate * caller immediately. The lock is cleared if the holding daemon process 40117c478bd9Sstevel@tonic-gate * exits for any reason even if the lock file remains, so the daemon can 40127c478bd9Sstevel@tonic-gate * be restarted if necessary. The lock file is DAEMON_LOCK_FILE. 40137c478bd9Sstevel@tonic-gate */ 40147c478bd9Sstevel@tonic-gate pid_t 40157c478bd9Sstevel@tonic-gate enter_daemon_lock(void) 40167c478bd9Sstevel@tonic-gate { 40177c478bd9Sstevel@tonic-gate struct flock lock; 40187c478bd9Sstevel@tonic-gate 40197c478bd9Sstevel@tonic-gate (void) snprintf(daemon_lockfile, sizeof (daemon_lockfile), 4020facf4a8dSllai "%s/%s", etc_dev_dir, DAEMON_LOCK_FILE); 40217c478bd9Sstevel@tonic-gate 40227c478bd9Sstevel@tonic-gate vprint(LOCK_MID, "enter_daemon_lock: lock file %s\n", daemon_lockfile); 40237c478bd9Sstevel@tonic-gate 40247c478bd9Sstevel@tonic-gate daemon_lock_fd = open(daemon_lockfile, O_CREAT|O_RDWR, 0644); 40257c478bd9Sstevel@tonic-gate if (daemon_lock_fd < 0) { 40267c478bd9Sstevel@tonic-gate err_print(OPEN_FAILED, daemon_lockfile, strerror(errno)); 40277c478bd9Sstevel@tonic-gate devfsadm_exit(1); 4028*537714daSvikram /*NOTREACHED*/ 40297c478bd9Sstevel@tonic-gate } 40307c478bd9Sstevel@tonic-gate 40317c478bd9Sstevel@tonic-gate lock.l_type = F_WRLCK; 40327c478bd9Sstevel@tonic-gate lock.l_whence = SEEK_SET; 40337c478bd9Sstevel@tonic-gate lock.l_start = 0; 40347c478bd9Sstevel@tonic-gate lock.l_len = 0; 40357c478bd9Sstevel@tonic-gate 40367c478bd9Sstevel@tonic-gate if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) { 40377c478bd9Sstevel@tonic-gate 40387c478bd9Sstevel@tonic-gate if (errno == EAGAIN || errno == EDEADLK) { 40397c478bd9Sstevel@tonic-gate if (fcntl(daemon_lock_fd, F_GETLK, &lock) == -1) { 40407c478bd9Sstevel@tonic-gate err_print(LOCK_FAILED, daemon_lockfile, 40410a653502Swroche strerror(errno)); 40427c478bd9Sstevel@tonic-gate devfsadm_exit(1); 4043*537714daSvikram /*NOTREACHED*/ 40447c478bd9Sstevel@tonic-gate } 40457c478bd9Sstevel@tonic-gate return (lock.l_pid); 40467c478bd9Sstevel@tonic-gate } 40477c478bd9Sstevel@tonic-gate } 40487c478bd9Sstevel@tonic-gate hold_daemon_lock = TRUE; 40497c478bd9Sstevel@tonic-gate return (getpid()); 40507c478bd9Sstevel@tonic-gate } 40517c478bd9Sstevel@tonic-gate 40527c478bd9Sstevel@tonic-gate /* 40537c478bd9Sstevel@tonic-gate * Drop the advisory daemon lock, close lock file 40547c478bd9Sstevel@tonic-gate */ 40557c478bd9Sstevel@tonic-gate void 4056*537714daSvikram exit_daemon_lock(int exiting) 40577c478bd9Sstevel@tonic-gate { 40587c478bd9Sstevel@tonic-gate struct flock lock; 40597c478bd9Sstevel@tonic-gate 40607c478bd9Sstevel@tonic-gate if (hold_daemon_lock == FALSE) { 40617c478bd9Sstevel@tonic-gate return; 40627c478bd9Sstevel@tonic-gate } 40637c478bd9Sstevel@tonic-gate 4064*537714daSvikram vprint(LOCK_MID, "exit_daemon_lock: lock file %s, exiting = %d\n", 4065*537714daSvikram daemon_lockfile, exiting); 40667c478bd9Sstevel@tonic-gate 40677c478bd9Sstevel@tonic-gate lock.l_type = F_UNLCK; 40687c478bd9Sstevel@tonic-gate lock.l_whence = SEEK_SET; 40697c478bd9Sstevel@tonic-gate lock.l_start = 0; 40707c478bd9Sstevel@tonic-gate lock.l_len = 0; 40717c478bd9Sstevel@tonic-gate 40727c478bd9Sstevel@tonic-gate if (fcntl(daemon_lock_fd, F_SETLK, &lock) == -1) { 40737c478bd9Sstevel@tonic-gate err_print(UNLOCK_FAILED, daemon_lockfile, strerror(errno)); 40747c478bd9Sstevel@tonic-gate } 40757c478bd9Sstevel@tonic-gate 40767c478bd9Sstevel@tonic-gate if (close(daemon_lock_fd) == -1) { 40777c478bd9Sstevel@tonic-gate err_print(CLOSE_FAILED, daemon_lockfile, strerror(errno)); 4078*537714daSvikram if (!exiting) 4079*537714daSvikram devfsadm_exit(1); 4080*537714daSvikram /*NOTREACHED*/ 40817c478bd9Sstevel@tonic-gate } 40827c478bd9Sstevel@tonic-gate } 40837c478bd9Sstevel@tonic-gate 40847c478bd9Sstevel@tonic-gate /* 40857c478bd9Sstevel@tonic-gate * Called to removed danging nodes in two different modes: RM_PRE, RM_POST. 40867c478bd9Sstevel@tonic-gate * RM_PRE mode is called before processing the entire devinfo tree, and RM_POST 40877c478bd9Sstevel@tonic-gate * is called after processing the entire devinfo tree. 40887c478bd9Sstevel@tonic-gate */ 40897c478bd9Sstevel@tonic-gate static void 40907c478bd9Sstevel@tonic-gate pre_and_post_cleanup(int flags) 40917c478bd9Sstevel@tonic-gate { 40927c478bd9Sstevel@tonic-gate remove_list_t *rm; 40937c478bd9Sstevel@tonic-gate recurse_dev_t rd; 40947c478bd9Sstevel@tonic-gate cleanup_data_t cleanup_data; 40957c478bd9Sstevel@tonic-gate char *fcn = "pre_and_post_cleanup: "; 40967c478bd9Sstevel@tonic-gate 40977c478bd9Sstevel@tonic-gate if (build_dev == FALSE) 40987c478bd9Sstevel@tonic-gate return; 40997c478bd9Sstevel@tonic-gate 41007c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "attempting %s-cleanup\n", 41017c478bd9Sstevel@tonic-gate flags == RM_PRE ? "pre" : "post"); 41027c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%sflags = %d\n", fcn, flags); 41037c478bd9Sstevel@tonic-gate 41047c478bd9Sstevel@tonic-gate /* 41057c478bd9Sstevel@tonic-gate * the generic function recurse_dev_re is shared among different 41067c478bd9Sstevel@tonic-gate * functions, so set the method and data that it should use for 41077c478bd9Sstevel@tonic-gate * matches. 41087c478bd9Sstevel@tonic-gate */ 41097c478bd9Sstevel@tonic-gate rd.fcn = matching_dev; 41107c478bd9Sstevel@tonic-gate rd.data = (void *)&cleanup_data; 41117c478bd9Sstevel@tonic-gate cleanup_data.flags = flags; 41127c478bd9Sstevel@tonic-gate 4113aa646b9dSvikram (void) mutex_lock(&nfp_mutex); 4114aa646b9dSvikram nfphash_create(); 4115aa646b9dSvikram 41167c478bd9Sstevel@tonic-gate for (rm = remove_head; rm != NULL; rm = rm->next) { 41177c478bd9Sstevel@tonic-gate if ((flags & rm->remove->flags) == flags) { 41187c478bd9Sstevel@tonic-gate cleanup_data.rm = rm; 41197c478bd9Sstevel@tonic-gate /* 41207c478bd9Sstevel@tonic-gate * If reached this point, RM_PRE or RM_POST cleanup is 41217c478bd9Sstevel@tonic-gate * desired. clean_ok() decides whether to clean 41227c478bd9Sstevel@tonic-gate * under the given circumstances. 41237c478bd9Sstevel@tonic-gate */ 41247c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%scleanup: PRE or POST\n", fcn); 41257c478bd9Sstevel@tonic-gate if (clean_ok(rm->remove) == DEVFSADM_SUCCESS) { 41267c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "cleanup: cleanup OK\n"); 41270a653502Swroche recurse_dev_re(dev_dir, 41280a653502Swroche rm->remove->dev_dirs_re, &rd); 41297c478bd9Sstevel@tonic-gate } 41307c478bd9Sstevel@tonic-gate } 41317c478bd9Sstevel@tonic-gate } 4132aa646b9dSvikram nfphash_destroy(); 4133aa646b9dSvikram (void) mutex_unlock(&nfp_mutex); 41347c478bd9Sstevel@tonic-gate } 41357c478bd9Sstevel@tonic-gate 41367c478bd9Sstevel@tonic-gate /* 41377c478bd9Sstevel@tonic-gate * clean_ok() determines whether cleanup should be done according 41387c478bd9Sstevel@tonic-gate * to the following matrix: 41397c478bd9Sstevel@tonic-gate * 41407c478bd9Sstevel@tonic-gate * command line arguments RM_PRE RM_POST RM_PRE && RM_POST && 41417c478bd9Sstevel@tonic-gate * RM_ALWAYS RM_ALWAYS 41427c478bd9Sstevel@tonic-gate * ---------------------- ------ ----- --------- ---------- 41437c478bd9Sstevel@tonic-gate * 41447c478bd9Sstevel@tonic-gate * <neither -c nor -C> - - pre-clean post-clean 41457c478bd9Sstevel@tonic-gate * 41467c478bd9Sstevel@tonic-gate * -C pre-clean post-clean pre-clean post-clean 41477c478bd9Sstevel@tonic-gate * 41487c478bd9Sstevel@tonic-gate * -C -c class pre-clean post-clean pre-clean post-clean 41497c478bd9Sstevel@tonic-gate * if class if class if class if class 41507c478bd9Sstevel@tonic-gate * matches matches matches matches 41517c478bd9Sstevel@tonic-gate * 41527c478bd9Sstevel@tonic-gate * -c class - - pre-clean post-clean 41537c478bd9Sstevel@tonic-gate * if class if class 41547c478bd9Sstevel@tonic-gate * matches matches 41557c478bd9Sstevel@tonic-gate * 41567c478bd9Sstevel@tonic-gate */ 41577c478bd9Sstevel@tonic-gate static int 4158aa646b9dSvikram clean_ok(devfsadm_remove_V1_t *remove) 41597c478bd9Sstevel@tonic-gate { 41607c478bd9Sstevel@tonic-gate int i; 41617c478bd9Sstevel@tonic-gate 41627c478bd9Sstevel@tonic-gate if (single_drv == TRUE) { 41637c478bd9Sstevel@tonic-gate /* no cleanup at all when using -i option */ 41647c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 41657c478bd9Sstevel@tonic-gate } 41667c478bd9Sstevel@tonic-gate 41677c478bd9Sstevel@tonic-gate /* 41687c478bd9Sstevel@tonic-gate * no cleanup if drivers are not loaded. We make an exception 41697c478bd9Sstevel@tonic-gate * for the "disks" program however, since disks has a public 41707c478bd9Sstevel@tonic-gate * cleanup flag (-C) and disk drivers are usually never 41717c478bd9Sstevel@tonic-gate * unloaded. 41727c478bd9Sstevel@tonic-gate */ 41737c478bd9Sstevel@tonic-gate if (load_attach_drv == FALSE && strcmp(prog, DISKS) != 0) { 41747c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 41757c478bd9Sstevel@tonic-gate } 41767c478bd9Sstevel@tonic-gate 41777c478bd9Sstevel@tonic-gate /* if the cleanup flag was not specified, return false */ 41787c478bd9Sstevel@tonic-gate if ((cleanup == FALSE) && ((remove->flags & RM_ALWAYS) == 0)) { 41797c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 41807c478bd9Sstevel@tonic-gate } 41817c478bd9Sstevel@tonic-gate 41827c478bd9Sstevel@tonic-gate if (num_classes == 0) { 41837c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 41847c478bd9Sstevel@tonic-gate } 41857c478bd9Sstevel@tonic-gate 41867c478bd9Sstevel@tonic-gate /* 41877c478bd9Sstevel@tonic-gate * if reached this point, check to see if the class in the given 41887c478bd9Sstevel@tonic-gate * remove structure matches a class given on the command line 41897c478bd9Sstevel@tonic-gate */ 41907c478bd9Sstevel@tonic-gate 41917c478bd9Sstevel@tonic-gate for (i = 0; i < num_classes; i++) { 41927c478bd9Sstevel@tonic-gate if (strcmp(remove->device_class, classes[i]) == 0) { 41937c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 41947c478bd9Sstevel@tonic-gate } 41957c478bd9Sstevel@tonic-gate } 41967c478bd9Sstevel@tonic-gate 41977c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 41987c478bd9Sstevel@tonic-gate } 41997c478bd9Sstevel@tonic-gate 42007c478bd9Sstevel@tonic-gate /* 42017c478bd9Sstevel@tonic-gate * Called to remove dangling nodes after receiving a hotplug event 42027c478bd9Sstevel@tonic-gate * containing the physical node pathname to be removed. 42037c478bd9Sstevel@tonic-gate */ 42047c478bd9Sstevel@tonic-gate void 42057c478bd9Sstevel@tonic-gate hot_cleanup(char *node_path, char *minor_name, char *ev_subclass, 42067c478bd9Sstevel@tonic-gate char *driver_name, int instance) 42077c478bd9Sstevel@tonic-gate { 42087c478bd9Sstevel@tonic-gate link_t *link; 42097c478bd9Sstevel@tonic-gate linkhead_t *head; 42107c478bd9Sstevel@tonic-gate remove_list_t *rm; 42117c478bd9Sstevel@tonic-gate char *fcn = "hot_cleanup: "; 42127c478bd9Sstevel@tonic-gate char path[PATH_MAX + 1]; 42137c478bd9Sstevel@tonic-gate int path_len; 42147c478bd9Sstevel@tonic-gate char rmlink[PATH_MAX + 1]; 42157c478bd9Sstevel@tonic-gate nvlist_t *nvl = NULL; 4216fb9251a6Scth int skip; 4217aa646b9dSvikram int ret; 42187c478bd9Sstevel@tonic-gate 42197c478bd9Sstevel@tonic-gate /* 42207c478bd9Sstevel@tonic-gate * dev links can go away as part of hot cleanup. 42217c478bd9Sstevel@tonic-gate * So first build event attributes in order capture dev links. 42227c478bd9Sstevel@tonic-gate */ 42237c478bd9Sstevel@tonic-gate if (ev_subclass != NULL) 42247c478bd9Sstevel@tonic-gate nvl = build_event_attributes(EC_DEV_REMOVE, ev_subclass, 422530294554Sphitran node_path, DI_NODE_NIL, driver_name, instance, minor_name); 42267c478bd9Sstevel@tonic-gate 42277c478bd9Sstevel@tonic-gate (void) strcpy(path, node_path); 42287c478bd9Sstevel@tonic-gate (void) strcat(path, ":"); 42297c478bd9Sstevel@tonic-gate (void) strcat(path, minor_name == NULL ? "" : minor_name); 42307c478bd9Sstevel@tonic-gate 42317c478bd9Sstevel@tonic-gate path_len = strlen(path); 42327c478bd9Sstevel@tonic-gate 42337c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%spath=%s\n", fcn, path); 42347c478bd9Sstevel@tonic-gate 4235aa646b9dSvikram (void) mutex_lock(&nfp_mutex); 4236aa646b9dSvikram nfphash_create(); 4237aa646b9dSvikram 42387c478bd9Sstevel@tonic-gate for (rm = remove_head; rm != NULL; rm = rm->next) { 42397c478bd9Sstevel@tonic-gate if ((RM_HOT & rm->remove->flags) == RM_HOT) { 42407c478bd9Sstevel@tonic-gate head = get_cached_links(rm->remove->dev_dirs_re); 42417c478bd9Sstevel@tonic-gate assert(head->nextlink == NULL); 42427c478bd9Sstevel@tonic-gate for (link = head->link; 42437c478bd9Sstevel@tonic-gate link != NULL; link = head->nextlink) { 42447c478bd9Sstevel@tonic-gate /* 42457c478bd9Sstevel@tonic-gate * The remove callback below may remove 42467c478bd9Sstevel@tonic-gate * the current and/or any or all of the 42477c478bd9Sstevel@tonic-gate * subsequent links in the list. 42487c478bd9Sstevel@tonic-gate * Save the next link in the head. If 42497c478bd9Sstevel@tonic-gate * the callback removes the next link 42507c478bd9Sstevel@tonic-gate * the saved pointer in the head will be 42517c478bd9Sstevel@tonic-gate * updated by the callback to point at 42527c478bd9Sstevel@tonic-gate * the next valid link. 42537c478bd9Sstevel@tonic-gate */ 42547c478bd9Sstevel@tonic-gate head->nextlink = link->next; 4255aa646b9dSvikram 4256aa646b9dSvikram /* 4257aa646b9dSvikram * if devlink is in no-further-process hash, 4258aa646b9dSvikram * skip its remove 4259aa646b9dSvikram */ 4260aa646b9dSvikram if (nfphash_lookup(link->devlink) != NULL) 4261aa646b9dSvikram continue; 4262aa646b9dSvikram 4263fb9251a6Scth if (minor_name) 4264fb9251a6Scth skip = strcmp(link->contents, path); 4265fb9251a6Scth else 4266fb9251a6Scth skip = strncmp(link->contents, path, 4267fb9251a6Scth path_len); 4268fb9251a6Scth if (skip || 4269fb9251a6Scth (call_minor_init(rm->modptr) == 4270fb9251a6Scth DEVFSADM_FAILURE)) 4271fb9251a6Scth continue; 42727c478bd9Sstevel@tonic-gate 4273fb9251a6Scth vprint(REMOVE_MID, 42740a653502Swroche "%sremoving %s -> %s\n", fcn, 42750a653502Swroche link->devlink, link->contents); 4276fb9251a6Scth /* 4277fb9251a6Scth * Use a copy of the cached link name 4278fb9251a6Scth * as the cache entry will go away 4279fb9251a6Scth * during link removal 4280fb9251a6Scth */ 4281fb9251a6Scth (void) snprintf(rmlink, sizeof (rmlink), 4282fb9251a6Scth "%s", link->devlink); 4283aa646b9dSvikram if (rm->remove->flags & RM_NOINTERPOSE) { 4284aa646b9dSvikram ((void (*)(char *)) 42850a653502Swroche (rm->remove->callback_fcn))(rmlink); 4286aa646b9dSvikram } else { 4287aa646b9dSvikram ret = ((int (*)(char *)) 4288aa646b9dSvikram (rm->remove->callback_fcn))(rmlink); 4289aa646b9dSvikram if (ret == DEVFSADM_TERMINATE) 4290aa646b9dSvikram nfphash_insert(rmlink); 4291aa646b9dSvikram } 42927c478bd9Sstevel@tonic-gate } 42937c478bd9Sstevel@tonic-gate } 42947c478bd9Sstevel@tonic-gate } 42957c478bd9Sstevel@tonic-gate 4296aa646b9dSvikram nfphash_destroy(); 4297aa646b9dSvikram (void) mutex_unlock(&nfp_mutex); 4298aa646b9dSvikram 429945916cd2Sjpk /* update device allocation database */ 430045916cd2Sjpk if (system_labeled) { 430145916cd2Sjpk int ret = 0; 430245916cd2Sjpk int devtype = 0; 430345916cd2Sjpk char devname[MAXNAMELEN]; 430445916cd2Sjpk 430545916cd2Sjpk devname[0] = '\0'; 430645916cd2Sjpk if (strstr(node_path, DA_SOUND_NAME)) 430745916cd2Sjpk devtype = DA_AUDIO; 430845916cd2Sjpk else if (strstr(node_path, "disk")) 430945916cd2Sjpk devtype = DA_RMDISK; 431045916cd2Sjpk else 431145916cd2Sjpk goto out; 431245916cd2Sjpk ret = da_remove_list(&devlist, NULL, devtype, devname, 431345916cd2Sjpk sizeof (devname)); 431445916cd2Sjpk if (ret != -1) 431545916cd2Sjpk (void) _update_devalloc_db(&devlist, devtype, DA_REMOVE, 431645916cd2Sjpk devname, root_dir); 431745916cd2Sjpk } 431845916cd2Sjpk 431945916cd2Sjpk out: 43207c478bd9Sstevel@tonic-gate /* now log an event */ 43217c478bd9Sstevel@tonic-gate if (nvl) { 43227c478bd9Sstevel@tonic-gate log_event(EC_DEV_REMOVE, ev_subclass, nvl); 43237c478bd9Sstevel@tonic-gate free(nvl); 43247c478bd9Sstevel@tonic-gate } 43257c478bd9Sstevel@tonic-gate } 43267c478bd9Sstevel@tonic-gate 43277c478bd9Sstevel@tonic-gate /* 43287c478bd9Sstevel@tonic-gate * Open the dir current_dir. For every file which matches the first dir 43297c478bd9Sstevel@tonic-gate * component of path_re, recurse. If there are no more *dir* path 43307c478bd9Sstevel@tonic-gate * components left in path_re (ie no more /), then call function rd->fcn. 43317c478bd9Sstevel@tonic-gate */ 43327c478bd9Sstevel@tonic-gate static void 43337c478bd9Sstevel@tonic-gate recurse_dev_re(char *current_dir, char *path_re, recurse_dev_t *rd) 43347c478bd9Sstevel@tonic-gate { 43357c478bd9Sstevel@tonic-gate regex_t re1; 43367c478bd9Sstevel@tonic-gate char *slash; 43377c478bd9Sstevel@tonic-gate char new_path[PATH_MAX + 1]; 43387c478bd9Sstevel@tonic-gate char *anchored_path_re; 43397c478bd9Sstevel@tonic-gate size_t len; 434073de625bSjg finddevhdl_t fhandle; 434173de625bSjg const char *fp; 43427c478bd9Sstevel@tonic-gate 43437c478bd9Sstevel@tonic-gate vprint(RECURSEDEV_MID, "recurse_dev_re: curr = %s path=%s\n", 43440a653502Swroche current_dir, path_re); 43457c478bd9Sstevel@tonic-gate 434673de625bSjg if (finddev_readdir(current_dir, &fhandle) != 0) 43477c478bd9Sstevel@tonic-gate return; 43487c478bd9Sstevel@tonic-gate 43497c478bd9Sstevel@tonic-gate len = strlen(path_re); 43507c478bd9Sstevel@tonic-gate if ((slash = strchr(path_re, '/')) != NULL) { 43517c478bd9Sstevel@tonic-gate len = (slash - path_re); 43527c478bd9Sstevel@tonic-gate } 43537c478bd9Sstevel@tonic-gate 43547c478bd9Sstevel@tonic-gate anchored_path_re = s_malloc(len + 3); 43557c478bd9Sstevel@tonic-gate (void) sprintf(anchored_path_re, "^%.*s$", len, path_re); 43567c478bd9Sstevel@tonic-gate 43577c478bd9Sstevel@tonic-gate if (regcomp(&re1, anchored_path_re, REG_EXTENDED) != 0) { 43587c478bd9Sstevel@tonic-gate free(anchored_path_re); 43597c478bd9Sstevel@tonic-gate goto out; 43607c478bd9Sstevel@tonic-gate } 43617c478bd9Sstevel@tonic-gate 43627c478bd9Sstevel@tonic-gate free(anchored_path_re); 43637c478bd9Sstevel@tonic-gate 436473de625bSjg while ((fp = finddev_next(fhandle)) != NULL) { 43657c478bd9Sstevel@tonic-gate 436673de625bSjg if (regexec(&re1, fp, 0, NULL, 0) == 0) { 43677c478bd9Sstevel@tonic-gate /* match */ 43687c478bd9Sstevel@tonic-gate (void) strcpy(new_path, current_dir); 43697c478bd9Sstevel@tonic-gate (void) strcat(new_path, "/"); 437073de625bSjg (void) strcat(new_path, fp); 43717c478bd9Sstevel@tonic-gate 43727c478bd9Sstevel@tonic-gate vprint(RECURSEDEV_MID, "recurse_dev_re: match, new " 43730a653502Swroche "path = %s\n", new_path); 43747c478bd9Sstevel@tonic-gate 43757c478bd9Sstevel@tonic-gate if (slash != NULL) { 43767c478bd9Sstevel@tonic-gate recurse_dev_re(new_path, slash + 1, rd); 43777c478bd9Sstevel@tonic-gate } else { 43787c478bd9Sstevel@tonic-gate /* reached the leaf component of path_re */ 43797c478bd9Sstevel@tonic-gate vprint(RECURSEDEV_MID, 43800a653502Swroche "recurse_dev_re: calling fcn\n"); 43817c478bd9Sstevel@tonic-gate (*(rd->fcn))(new_path, rd->data); 43827c478bd9Sstevel@tonic-gate } 43837c478bd9Sstevel@tonic-gate } 43847c478bd9Sstevel@tonic-gate } 43857c478bd9Sstevel@tonic-gate 43867c478bd9Sstevel@tonic-gate regfree(&re1); 43877c478bd9Sstevel@tonic-gate 43887c478bd9Sstevel@tonic-gate out: 438973de625bSjg finddev_close(fhandle); 43907c478bd9Sstevel@tonic-gate } 43917c478bd9Sstevel@tonic-gate 43927c478bd9Sstevel@tonic-gate /* 43937c478bd9Sstevel@tonic-gate * Found a devpath which matches a RE in the remove structure. 43947c478bd9Sstevel@tonic-gate * Now check to see if it is dangling. 43957c478bd9Sstevel@tonic-gate */ 43967c478bd9Sstevel@tonic-gate static void 43977c478bd9Sstevel@tonic-gate matching_dev(char *devpath, void *data) 43987c478bd9Sstevel@tonic-gate { 43997c478bd9Sstevel@tonic-gate cleanup_data_t *cleanup_data = data; 4400aa646b9dSvikram int norm_len = strlen(dev_dir) + strlen("/"); 4401aa646b9dSvikram int ret; 44027c478bd9Sstevel@tonic-gate char *fcn = "matching_dev: "; 44037c478bd9Sstevel@tonic-gate 44047c478bd9Sstevel@tonic-gate vprint(RECURSEDEV_MID, "%sexamining devpath = '%s'\n", fcn, 44050a653502Swroche devpath); 44067c478bd9Sstevel@tonic-gate 4407aa646b9dSvikram /* 4408aa646b9dSvikram * If the link is in the no-further-process hash 4409aa646b9dSvikram * don't do any remove operation on it. 4410aa646b9dSvikram */ 4411aa646b9dSvikram if (nfphash_lookup(devpath + norm_len) != NULL) 4412aa646b9dSvikram return; 4413aa646b9dSvikram 44147c478bd9Sstevel@tonic-gate if (resolve_link(devpath, NULL, NULL, NULL, 1) == TRUE) { 44157c478bd9Sstevel@tonic-gate if (call_minor_init(cleanup_data->rm->modptr) == 44160a653502Swroche DEVFSADM_FAILURE) { 44177c478bd9Sstevel@tonic-gate return; 44187c478bd9Sstevel@tonic-gate } 44197c478bd9Sstevel@tonic-gate 4420aa646b9dSvikram devpath += norm_len; 44217c478bd9Sstevel@tonic-gate 44220a653502Swroche vprint(RECURSEDEV_MID, "%scalling callback %s\n", fcn, devpath); 4423aa646b9dSvikram if (cleanup_data->rm->remove->flags & RM_NOINTERPOSE) 4424aa646b9dSvikram ((void (*)(char *)) 44250a653502Swroche (cleanup_data->rm->remove->callback_fcn))(devpath); 4426aa646b9dSvikram else { 4427aa646b9dSvikram ret = ((int (*)(char *)) 4428aa646b9dSvikram (cleanup_data->rm->remove->callback_fcn))(devpath); 4429aa646b9dSvikram if (ret == DEVFSADM_TERMINATE) { 4430aa646b9dSvikram /* 4431aa646b9dSvikram * We want no further remove processing for 4432aa646b9dSvikram * this link. Add it to the nfp_hash; 4433aa646b9dSvikram */ 4434aa646b9dSvikram nfphash_insert(devpath); 4435aa646b9dSvikram } 4436aa646b9dSvikram } 44377c478bd9Sstevel@tonic-gate } 44387c478bd9Sstevel@tonic-gate } 44397c478bd9Sstevel@tonic-gate 44407c478bd9Sstevel@tonic-gate int 44417c478bd9Sstevel@tonic-gate devfsadm_read_link(char *link, char **devfs_path) 44427c478bd9Sstevel@tonic-gate { 44437c478bd9Sstevel@tonic-gate char devlink[PATH_MAX]; 44447c478bd9Sstevel@tonic-gate 44457c478bd9Sstevel@tonic-gate *devfs_path = NULL; 44467c478bd9Sstevel@tonic-gate 44477c478bd9Sstevel@tonic-gate /* prepend link with dev_dir contents */ 44487c478bd9Sstevel@tonic-gate (void) strcpy(devlink, dev_dir); 44497c478bd9Sstevel@tonic-gate (void) strcat(devlink, "/"); 44507c478bd9Sstevel@tonic-gate (void) strcat(devlink, link); 44517c478bd9Sstevel@tonic-gate 44527c478bd9Sstevel@tonic-gate /* We *don't* want a stat of the /devices node */ 44537c478bd9Sstevel@tonic-gate (void) resolve_link(devlink, NULL, NULL, devfs_path, 0); 44547c478bd9Sstevel@tonic-gate 44557c478bd9Sstevel@tonic-gate return (*devfs_path ? DEVFSADM_SUCCESS : DEVFSADM_FAILURE); 44567c478bd9Sstevel@tonic-gate } 44577c478bd9Sstevel@tonic-gate 44587c478bd9Sstevel@tonic-gate int 44597c478bd9Sstevel@tonic-gate devfsadm_link_valid(char *link) 44607c478bd9Sstevel@tonic-gate { 44617c478bd9Sstevel@tonic-gate struct stat sb; 446245916cd2Sjpk char devlink[PATH_MAX + 1], *contents = NULL; 44637c478bd9Sstevel@tonic-gate int rv, type; 446445916cd2Sjpk int instance = 0; 44657c478bd9Sstevel@tonic-gate 44667c478bd9Sstevel@tonic-gate /* prepend link with dev_dir contents */ 44677c478bd9Sstevel@tonic-gate (void) strcpy(devlink, dev_dir); 44687c478bd9Sstevel@tonic-gate (void) strcat(devlink, "/"); 44697c478bd9Sstevel@tonic-gate (void) strcat(devlink, link); 44707c478bd9Sstevel@tonic-gate 4471facf4a8dSllai if (!device_exists(devlink) || lstat(devlink, &sb) != 0) { 44727c478bd9Sstevel@tonic-gate return (DEVFSADM_FALSE); 44737c478bd9Sstevel@tonic-gate } 44747c478bd9Sstevel@tonic-gate 44757c478bd9Sstevel@tonic-gate contents = NULL; 44767c478bd9Sstevel@tonic-gate type = 0; 44777c478bd9Sstevel@tonic-gate if (resolve_link(devlink, &contents, &type, NULL, 1) == TRUE) { 44787c478bd9Sstevel@tonic-gate rv = DEVFSADM_FALSE; 44797c478bd9Sstevel@tonic-gate } else { 44807c478bd9Sstevel@tonic-gate rv = DEVFSADM_TRUE; 44817c478bd9Sstevel@tonic-gate } 44827c478bd9Sstevel@tonic-gate 44837c478bd9Sstevel@tonic-gate /* 44847c478bd9Sstevel@tonic-gate * The link exists. Add it to the database 44857c478bd9Sstevel@tonic-gate */ 44867c478bd9Sstevel@tonic-gate (void) di_devlink_add_link(devlink_cache, link, contents, type); 448745916cd2Sjpk if (system_labeled && (rv == DEVFSADM_TRUE) && 448845916cd2Sjpk strstr(devlink, DA_AUDIO_NAME) && contents) { 448945916cd2Sjpk (void) sscanf(contents, "%*[a-z]%d", &instance); 449045916cd2Sjpk (void) da_add_list(&devlist, devlink, instance, 449145916cd2Sjpk DA_ADD|DA_AUDIO); 449245916cd2Sjpk _update_devalloc_db(&devlist, 0, DA_ADD, NULL, root_dir); 449345916cd2Sjpk } 44947c478bd9Sstevel@tonic-gate free(contents); 44957c478bd9Sstevel@tonic-gate 44967c478bd9Sstevel@tonic-gate return (rv); 44977c478bd9Sstevel@tonic-gate } 44987c478bd9Sstevel@tonic-gate 44997c478bd9Sstevel@tonic-gate /* 45007c478bd9Sstevel@tonic-gate * devpath: Absolute path to /dev link 45017c478bd9Sstevel@tonic-gate * content_p: Returns malloced string (link content) 45027c478bd9Sstevel@tonic-gate * type_p: Returns link type: primary or secondary 45037c478bd9Sstevel@tonic-gate * devfs_path: Returns malloced string: /devices path w/out "/devices" 45047c478bd9Sstevel@tonic-gate * dangle: if set, check if link is dangling 45057c478bd9Sstevel@tonic-gate * Returns: 45067c478bd9Sstevel@tonic-gate * TRUE if dangling 45077c478bd9Sstevel@tonic-gate * FALSE if not or if caller doesn't care 45087c478bd9Sstevel@tonic-gate * Caller is assumed to have initialized pointer contents to NULL 45097c478bd9Sstevel@tonic-gate */ 45107c478bd9Sstevel@tonic-gate static int 45117c478bd9Sstevel@tonic-gate resolve_link(char *devpath, char **content_p, int *type_p, char **devfs_path, 45127c478bd9Sstevel@tonic-gate int dangle) 45137c478bd9Sstevel@tonic-gate { 45147c478bd9Sstevel@tonic-gate char contents[PATH_MAX + 1]; 45157c478bd9Sstevel@tonic-gate char stage_link[PATH_MAX + 1]; 45167c478bd9Sstevel@tonic-gate char *fcn = "resolve_link: "; 45177c478bd9Sstevel@tonic-gate char *ptr; 45187c478bd9Sstevel@tonic-gate int linksize; 45197c478bd9Sstevel@tonic-gate int rv = TRUE; 45207c478bd9Sstevel@tonic-gate struct stat sb; 45217c478bd9Sstevel@tonic-gate 45227c478bd9Sstevel@tonic-gate linksize = readlink(devpath, contents, PATH_MAX); 45237c478bd9Sstevel@tonic-gate 45247c478bd9Sstevel@tonic-gate if (linksize <= 0) { 45257c478bd9Sstevel@tonic-gate return (FALSE); 45267c478bd9Sstevel@tonic-gate } else { 45277c478bd9Sstevel@tonic-gate contents[linksize] = '\0'; 45287c478bd9Sstevel@tonic-gate } 45297c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%s %s -> %s\n", fcn, devpath, contents); 45307c478bd9Sstevel@tonic-gate 45317c478bd9Sstevel@tonic-gate if (content_p) { 45327c478bd9Sstevel@tonic-gate *content_p = s_strdup(contents); 45337c478bd9Sstevel@tonic-gate } 45347c478bd9Sstevel@tonic-gate 45357c478bd9Sstevel@tonic-gate /* 45367c478bd9Sstevel@tonic-gate * Check to see if this is a link pointing to another link in /dev. The 45377c478bd9Sstevel@tonic-gate * cheap way to do this is to look for a lack of ../devices/. 45387c478bd9Sstevel@tonic-gate */ 45397c478bd9Sstevel@tonic-gate 45407c478bd9Sstevel@tonic-gate if (is_minor_node(contents, &ptr) == DEVFSADM_FALSE) { 45417c478bd9Sstevel@tonic-gate 45427c478bd9Sstevel@tonic-gate if (type_p) { 45437c478bd9Sstevel@tonic-gate *type_p = DI_SECONDARY_LINK; 45447c478bd9Sstevel@tonic-gate } 45457c478bd9Sstevel@tonic-gate 45467c478bd9Sstevel@tonic-gate /* 45477c478bd9Sstevel@tonic-gate * assume that linkcontents is really a pointer to another 45487c478bd9Sstevel@tonic-gate * link, and if so recurse and read its link contents. 45497c478bd9Sstevel@tonic-gate */ 45507c478bd9Sstevel@tonic-gate if (strncmp(contents, DEV "/", strlen(DEV) + 1) == 0) { 45517c478bd9Sstevel@tonic-gate (void) strcpy(stage_link, dev_dir); 45527c478bd9Sstevel@tonic-gate (void) strcat(stage_link, "/"); 45537c478bd9Sstevel@tonic-gate (void) strcpy(stage_link, 45540a653502Swroche &contents[strlen(DEV) + strlen("/")]); 45557c478bd9Sstevel@tonic-gate } else { 45567c478bd9Sstevel@tonic-gate if ((ptr = strrchr(devpath, '/')) == NULL) { 45577c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%s%s -> %s invalid link. " 45580a653502Swroche "missing '/'\n", fcn, devpath, contents); 45597c478bd9Sstevel@tonic-gate return (TRUE); 45607c478bd9Sstevel@tonic-gate } 45617c478bd9Sstevel@tonic-gate *ptr = '\0'; 45627c478bd9Sstevel@tonic-gate (void) strcpy(stage_link, devpath); 45637c478bd9Sstevel@tonic-gate *ptr = '/'; 45647c478bd9Sstevel@tonic-gate (void) strcat(stage_link, "/"); 45657c478bd9Sstevel@tonic-gate (void) strcat(stage_link, contents); 45667c478bd9Sstevel@tonic-gate } 45677c478bd9Sstevel@tonic-gate return (resolve_link(stage_link, NULL, NULL, devfs_path, 45687c478bd9Sstevel@tonic-gate dangle)); 45697c478bd9Sstevel@tonic-gate } 45707c478bd9Sstevel@tonic-gate 45717c478bd9Sstevel@tonic-gate /* Current link points at a /devices minor node */ 45727c478bd9Sstevel@tonic-gate if (type_p) { 45737c478bd9Sstevel@tonic-gate *type_p = DI_PRIMARY_LINK; 45747c478bd9Sstevel@tonic-gate } 45757c478bd9Sstevel@tonic-gate 45767c478bd9Sstevel@tonic-gate if (devfs_path) 45777c478bd9Sstevel@tonic-gate *devfs_path = s_strdup(ptr); 45787c478bd9Sstevel@tonic-gate 45797c478bd9Sstevel@tonic-gate rv = FALSE; 45807c478bd9Sstevel@tonic-gate if (dangle) 45817c478bd9Sstevel@tonic-gate rv = (stat(ptr - strlen(DEVICES), &sb) == -1); 45827c478bd9Sstevel@tonic-gate 45837c478bd9Sstevel@tonic-gate vprint(REMOVE_MID, "%slink=%s, returning %s\n", fcn, 45840a653502Swroche devpath, ((rv == TRUE) ? "TRUE" : "FALSE")); 45857c478bd9Sstevel@tonic-gate 45867c478bd9Sstevel@tonic-gate return (rv); 45877c478bd9Sstevel@tonic-gate } 45887c478bd9Sstevel@tonic-gate 45897c478bd9Sstevel@tonic-gate /* 45907c478bd9Sstevel@tonic-gate * Returns the substring of interest, given a path. 45917c478bd9Sstevel@tonic-gate */ 45927c478bd9Sstevel@tonic-gate static char * 45937c478bd9Sstevel@tonic-gate alloc_cmp_str(const char *path, devfsadm_enumerate_t *dep) 45947c478bd9Sstevel@tonic-gate { 45957c478bd9Sstevel@tonic-gate uint_t match; 45967c478bd9Sstevel@tonic-gate char *np, *ap, *mp; 45977c478bd9Sstevel@tonic-gate char *cmp_str = NULL; 45987c478bd9Sstevel@tonic-gate char at[] = "@"; 45997c478bd9Sstevel@tonic-gate char *fcn = "alloc_cmp_str"; 46007c478bd9Sstevel@tonic-gate 46017c478bd9Sstevel@tonic-gate np = ap = mp = NULL; 46027c478bd9Sstevel@tonic-gate 46037c478bd9Sstevel@tonic-gate /* 46047c478bd9Sstevel@tonic-gate * extract match flags from the flags argument. 46057c478bd9Sstevel@tonic-gate */ 46067c478bd9Sstevel@tonic-gate match = (dep->flags & MATCH_MASK); 46077c478bd9Sstevel@tonic-gate 46087c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: enumeration match type: 0x%x" 46097c478bd9Sstevel@tonic-gate " path: %s\n", fcn, match, path); 46107c478bd9Sstevel@tonic-gate 46117c478bd9Sstevel@tonic-gate /* 46127c478bd9Sstevel@tonic-gate * MATCH_CALLBACK and MATCH_ALL are the only flags 46137c478bd9Sstevel@tonic-gate * which may be used if "path" is a /dev path 46147c478bd9Sstevel@tonic-gate */ 46157c478bd9Sstevel@tonic-gate if (match == MATCH_CALLBACK) { 46167c478bd9Sstevel@tonic-gate if (dep->sel_fcn == NULL) { 46177c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid enumerate" 46187c478bd9Sstevel@tonic-gate " callback: path: %s\n", fcn, path); 46197c478bd9Sstevel@tonic-gate return (NULL); 46207c478bd9Sstevel@tonic-gate } 46217c478bd9Sstevel@tonic-gate cmp_str = dep->sel_fcn(path, dep->cb_arg); 46227c478bd9Sstevel@tonic-gate return (cmp_str); 46237c478bd9Sstevel@tonic-gate } 46247c478bd9Sstevel@tonic-gate 46257c478bd9Sstevel@tonic-gate cmp_str = s_strdup(path); 46267c478bd9Sstevel@tonic-gate 46277c478bd9Sstevel@tonic-gate if (match == MATCH_ALL) { 46287c478bd9Sstevel@tonic-gate return (cmp_str); 46297c478bd9Sstevel@tonic-gate } 46307c478bd9Sstevel@tonic-gate 46317c478bd9Sstevel@tonic-gate /* 46327c478bd9Sstevel@tonic-gate * The remaining flags make sense only for /devices 46337c478bd9Sstevel@tonic-gate * paths 46347c478bd9Sstevel@tonic-gate */ 46357c478bd9Sstevel@tonic-gate if ((mp = strrchr(cmp_str, ':')) == NULL) { 46367c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid path: %s\n", 46377c478bd9Sstevel@tonic-gate fcn, path); 46387c478bd9Sstevel@tonic-gate goto err; 46397c478bd9Sstevel@tonic-gate } 46407c478bd9Sstevel@tonic-gate 46417c478bd9Sstevel@tonic-gate if (match == MATCH_MINOR) { 46427c478bd9Sstevel@tonic-gate /* A NULL "match_arg" values implies entire minor */ 46437c478bd9Sstevel@tonic-gate if (get_component(mp + 1, dep->match_arg) == NULL) { 46447c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid minor component:" 46457c478bd9Sstevel@tonic-gate " path: %s\n", fcn, path); 46467c478bd9Sstevel@tonic-gate goto err; 46477c478bd9Sstevel@tonic-gate } 46487c478bd9Sstevel@tonic-gate return (cmp_str); 46497c478bd9Sstevel@tonic-gate } 46507c478bd9Sstevel@tonic-gate 46517c478bd9Sstevel@tonic-gate if ((np = strrchr(cmp_str, '/')) == NULL) { 46527c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid path: %s\n", fcn, path); 46537c478bd9Sstevel@tonic-gate goto err; 46547c478bd9Sstevel@tonic-gate } 46557c478bd9Sstevel@tonic-gate 46567c478bd9Sstevel@tonic-gate if (match == MATCH_PARENT) { 46577c478bd9Sstevel@tonic-gate if (strcmp(cmp_str, "/") == 0) { 46587c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid path: %s\n", 46597c478bd9Sstevel@tonic-gate fcn, path); 46607c478bd9Sstevel@tonic-gate goto err; 46617c478bd9Sstevel@tonic-gate } 46627c478bd9Sstevel@tonic-gate 46637c478bd9Sstevel@tonic-gate if (np == cmp_str) { 46647c478bd9Sstevel@tonic-gate *(np + 1) = '\0'; 46657c478bd9Sstevel@tonic-gate } else { 46667c478bd9Sstevel@tonic-gate *np = '\0'; 46677c478bd9Sstevel@tonic-gate } 46687c478bd9Sstevel@tonic-gate return (cmp_str); 46697c478bd9Sstevel@tonic-gate } 46707c478bd9Sstevel@tonic-gate 46717c478bd9Sstevel@tonic-gate /* ap can be NULL - Leaf address may not exist or be empty string */ 46727c478bd9Sstevel@tonic-gate ap = strchr(np+1, '@'); 46737c478bd9Sstevel@tonic-gate 46747c478bd9Sstevel@tonic-gate /* minor is no longer of interest */ 46757c478bd9Sstevel@tonic-gate *mp = '\0'; 46767c478bd9Sstevel@tonic-gate 46777c478bd9Sstevel@tonic-gate if (match == MATCH_NODE) { 46787c478bd9Sstevel@tonic-gate if (ap) 46797c478bd9Sstevel@tonic-gate *ap = '\0'; 46807c478bd9Sstevel@tonic-gate return (cmp_str); 46817c478bd9Sstevel@tonic-gate } else if (match == MATCH_ADDR) { 46827c478bd9Sstevel@tonic-gate /* 46837c478bd9Sstevel@tonic-gate * The empty string is a valid address. The only MATCH_ADDR 46847c478bd9Sstevel@tonic-gate * allowed in this case is against the whole address or 46857c478bd9Sstevel@tonic-gate * the first component of the address (match_arg=NULL/"0"/"1") 46867c478bd9Sstevel@tonic-gate * Note that in this case, the path won't have an "@" 46877c478bd9Sstevel@tonic-gate * As a result ap will be NULL. We fake up an ap = @'\0' 46887c478bd9Sstevel@tonic-gate * so that get_component() will work correctly. 46897c478bd9Sstevel@tonic-gate */ 46907c478bd9Sstevel@tonic-gate if (ap == NULL) { 46917c478bd9Sstevel@tonic-gate ap = at; 46927c478bd9Sstevel@tonic-gate } 46937c478bd9Sstevel@tonic-gate 46947c478bd9Sstevel@tonic-gate if (get_component(ap + 1, dep->match_arg) == NULL) { 46957c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid leaf addr. component:" 46967c478bd9Sstevel@tonic-gate " path: %s\n", fcn, path); 46977c478bd9Sstevel@tonic-gate goto err; 46987c478bd9Sstevel@tonic-gate } 46997c478bd9Sstevel@tonic-gate return (cmp_str); 47007c478bd9Sstevel@tonic-gate } 47017c478bd9Sstevel@tonic-gate 47027c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid enumeration flags: 0x%x" 47030a653502Swroche " path: %s\n", fcn, dep->flags, path); 47047c478bd9Sstevel@tonic-gate 47057c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 47067c478bd9Sstevel@tonic-gate err: 47077c478bd9Sstevel@tonic-gate free(cmp_str); 47087c478bd9Sstevel@tonic-gate return (NULL); 47097c478bd9Sstevel@tonic-gate } 47107c478bd9Sstevel@tonic-gate 47117c478bd9Sstevel@tonic-gate 47127c478bd9Sstevel@tonic-gate /* 47137c478bd9Sstevel@tonic-gate * "str" is expected to be a string with components separated by ',' 47147c478bd9Sstevel@tonic-gate * The terminating null char is considered a separator. 47157c478bd9Sstevel@tonic-gate * get_component() will remove the portion of the string beyond 47167c478bd9Sstevel@tonic-gate * the component indicated. 47177c478bd9Sstevel@tonic-gate * If comp_str is NULL, the entire "str" is returned. 47187c478bd9Sstevel@tonic-gate */ 47197c478bd9Sstevel@tonic-gate static char * 47207c478bd9Sstevel@tonic-gate get_component(char *str, const char *comp_str) 47217c478bd9Sstevel@tonic-gate { 47227c478bd9Sstevel@tonic-gate long comp; 47237c478bd9Sstevel@tonic-gate char *cp; 47247c478bd9Sstevel@tonic-gate 47257c478bd9Sstevel@tonic-gate if (str == NULL) { 47267c478bd9Sstevel@tonic-gate return (NULL); 47277c478bd9Sstevel@tonic-gate } 47287c478bd9Sstevel@tonic-gate 47297c478bd9Sstevel@tonic-gate if (comp_str == NULL) { 47307c478bd9Sstevel@tonic-gate return (str); 47317c478bd9Sstevel@tonic-gate } 47327c478bd9Sstevel@tonic-gate 47337c478bd9Sstevel@tonic-gate errno = 0; 47347c478bd9Sstevel@tonic-gate comp = strtol(comp_str, &cp, 10); 47357c478bd9Sstevel@tonic-gate if (errno != 0 || *cp != '\0' || comp < 0) { 47367c478bd9Sstevel@tonic-gate return (NULL); 47377c478bd9Sstevel@tonic-gate } 47387c478bd9Sstevel@tonic-gate 47397c478bd9Sstevel@tonic-gate if (comp == 0) 47407c478bd9Sstevel@tonic-gate return (str); 47417c478bd9Sstevel@tonic-gate 47427c478bd9Sstevel@tonic-gate for (cp = str; ; cp++) { 47437c478bd9Sstevel@tonic-gate if (*cp == ',' || *cp == '\0') 47447c478bd9Sstevel@tonic-gate comp--; 47457c478bd9Sstevel@tonic-gate if (*cp == '\0' || comp <= 0) { 47467c478bd9Sstevel@tonic-gate break; 47477c478bd9Sstevel@tonic-gate } 47487c478bd9Sstevel@tonic-gate } 47497c478bd9Sstevel@tonic-gate 47507c478bd9Sstevel@tonic-gate if (comp == 0) { 47517c478bd9Sstevel@tonic-gate *cp = '\0'; 47527c478bd9Sstevel@tonic-gate } else { 47537c478bd9Sstevel@tonic-gate str = NULL; 47547c478bd9Sstevel@tonic-gate } 47557c478bd9Sstevel@tonic-gate 47567c478bd9Sstevel@tonic-gate return (str); 47577c478bd9Sstevel@tonic-gate } 47587c478bd9Sstevel@tonic-gate 47597c478bd9Sstevel@tonic-gate 47607c478bd9Sstevel@tonic-gate /* 47617c478bd9Sstevel@tonic-gate * Enumerate serves as a generic counter as well as a means to determine 47627c478bd9Sstevel@tonic-gate * logical unit/controller numbers for such items as disk and tape 47637c478bd9Sstevel@tonic-gate * drives. 47647c478bd9Sstevel@tonic-gate * 47657c478bd9Sstevel@tonic-gate * rules[] is an array of devfsadm_enumerate_t structures which defines 47667c478bd9Sstevel@tonic-gate * the enumeration rules to be used for a specified set of links in /dev. 47677c478bd9Sstevel@tonic-gate * The set of links is specified through regular expressions (of the flavor 47687c478bd9Sstevel@tonic-gate * described in regex(5)). These regular expressions are used to determine 47697c478bd9Sstevel@tonic-gate * the set of links in /dev to examine. The last path component in these 47707c478bd9Sstevel@tonic-gate * regular expressions MUST contain a parenthesized subexpression surrounding 47717c478bd9Sstevel@tonic-gate * the RE which is to be considered the enumerating component. The subexp 47727c478bd9Sstevel@tonic-gate * member in a rule is the subexpression number of the enumerating 47737c478bd9Sstevel@tonic-gate * component. Subexpressions in the last path component are numbered starting 47747c478bd9Sstevel@tonic-gate * from 1. 47757c478bd9Sstevel@tonic-gate * 47767c478bd9Sstevel@tonic-gate * A cache of current id assignments is built up from existing symlinks and 47777c478bd9Sstevel@tonic-gate * new assignments use the lowest unused id. Assignments are based on a 47787c478bd9Sstevel@tonic-gate * match of a specified substring of a symlink's contents. If the specified 47797c478bd9Sstevel@tonic-gate * component for the devfs_path argument matches the corresponding substring 47807c478bd9Sstevel@tonic-gate * for a existing symlink's contents, the cached id is returned. Else, a new 47817c478bd9Sstevel@tonic-gate * id is created and returned in *buf. *buf must be freed by the caller. 47827c478bd9Sstevel@tonic-gate * 47837c478bd9Sstevel@tonic-gate * An id assignment may be governed by a combination of rules, each rule 47847c478bd9Sstevel@tonic-gate * applicable to a different subset of links in /dev. For example, controller 47857c478bd9Sstevel@tonic-gate * numbers may be determined by a combination of disk symlinks in /dev/[r]dsk 47867c478bd9Sstevel@tonic-gate * and controller symlinks in /dev/cfg, with the two sets requiring different 47877c478bd9Sstevel@tonic-gate * rules to derive the "substring of interest". In such cases, the rules 47887c478bd9Sstevel@tonic-gate * array will have more than one element. 47897c478bd9Sstevel@tonic-gate */ 47907c478bd9Sstevel@tonic-gate int 47917c478bd9Sstevel@tonic-gate devfsadm_enumerate_int(char *devfs_path, int index, char **buf, 47927c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[], int nrules) 47937c478bd9Sstevel@tonic-gate { 47947c478bd9Sstevel@tonic-gate return (find_enum_id(rules, nrules, 47957c478bd9Sstevel@tonic-gate devfs_path, index, "0", INTEGER, buf, 0)); 47967c478bd9Sstevel@tonic-gate } 47977c478bd9Sstevel@tonic-gate 47987c478bd9Sstevel@tonic-gate int 47997c478bd9Sstevel@tonic-gate disk_enumerate_int(char *devfs_path, int index, char **buf, 48007c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[], int nrules) 48017c478bd9Sstevel@tonic-gate { 48027c478bd9Sstevel@tonic-gate return (find_enum_id(rules, nrules, 48037c478bd9Sstevel@tonic-gate devfs_path, index, "0", INTEGER, buf, 1)); 48047c478bd9Sstevel@tonic-gate } 48057c478bd9Sstevel@tonic-gate 48067c478bd9Sstevel@tonic-gate /* 48077c478bd9Sstevel@tonic-gate * Same as above, but allows a starting value to be specified. 48087c478bd9Sstevel@tonic-gate * Private to devfsadm.... used by devlinks. 48097c478bd9Sstevel@tonic-gate */ 48107c478bd9Sstevel@tonic-gate static int 48117c478bd9Sstevel@tonic-gate devfsadm_enumerate_int_start(char *devfs_path, int index, char **buf, 48127c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[], int nrules, char *start) 48137c478bd9Sstevel@tonic-gate { 48147c478bd9Sstevel@tonic-gate return (find_enum_id(rules, nrules, 48157c478bd9Sstevel@tonic-gate devfs_path, index, start, INTEGER, buf, 0)); 48167c478bd9Sstevel@tonic-gate } 48177c478bd9Sstevel@tonic-gate 48187c478bd9Sstevel@tonic-gate /* 48197c478bd9Sstevel@tonic-gate * devfsadm_enumerate_char serves as a generic counter returning 48207c478bd9Sstevel@tonic-gate * a single letter. 48217c478bd9Sstevel@tonic-gate */ 48227c478bd9Sstevel@tonic-gate int 48237c478bd9Sstevel@tonic-gate devfsadm_enumerate_char(char *devfs_path, int index, char **buf, 48247c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[], int nrules) 48257c478bd9Sstevel@tonic-gate { 48267c478bd9Sstevel@tonic-gate return (find_enum_id(rules, nrules, 48277c478bd9Sstevel@tonic-gate devfs_path, index, "a", LETTER, buf, 0)); 48287c478bd9Sstevel@tonic-gate } 48297c478bd9Sstevel@tonic-gate 48307c478bd9Sstevel@tonic-gate /* 48317c478bd9Sstevel@tonic-gate * Same as above, but allows a starting char to be specified. 48327c478bd9Sstevel@tonic-gate * Private to devfsadm - used by ports module (port_link.c) 48337c478bd9Sstevel@tonic-gate */ 48347c478bd9Sstevel@tonic-gate int 48357c478bd9Sstevel@tonic-gate devfsadm_enumerate_char_start(char *devfs_path, int index, char **buf, 48367c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[], int nrules, char *start) 48377c478bd9Sstevel@tonic-gate { 48387c478bd9Sstevel@tonic-gate return (find_enum_id(rules, nrules, 48397c478bd9Sstevel@tonic-gate devfs_path, index, start, LETTER, buf, 0)); 48407c478bd9Sstevel@tonic-gate } 48417c478bd9Sstevel@tonic-gate 48427c478bd9Sstevel@tonic-gate 48437c478bd9Sstevel@tonic-gate /* 48447c478bd9Sstevel@tonic-gate * For a given numeral_set (see get_cached_set for desc of numeral_set), 48457c478bd9Sstevel@tonic-gate * search all cached entries looking for matches on a specified substring 48467c478bd9Sstevel@tonic-gate * of devfs_path. The substring is derived from devfs_path based on the 48477c478bd9Sstevel@tonic-gate * rule specified by "index". If a match is found on a cached entry, 48487c478bd9Sstevel@tonic-gate * return the enumerated id in buf. Otherwise, create a new id by calling 48497c478bd9Sstevel@tonic-gate * new_id, then cache and return that entry. 48507c478bd9Sstevel@tonic-gate */ 48517c478bd9Sstevel@tonic-gate static int 48527c478bd9Sstevel@tonic-gate find_enum_id(devfsadm_enumerate_t rules[], int nrules, 48537c478bd9Sstevel@tonic-gate char *devfs_path, int index, char *min, int type, char **buf, 48547c478bd9Sstevel@tonic-gate int multiple) 48557c478bd9Sstevel@tonic-gate { 48567c478bd9Sstevel@tonic-gate numeral_t *matchnp; 48577c478bd9Sstevel@tonic-gate numeral_t *numeral; 48587c478bd9Sstevel@tonic-gate int matchcount = 0; 48597c478bd9Sstevel@tonic-gate char *cmp_str; 48607c478bd9Sstevel@tonic-gate char *fcn = "find_enum_id"; 48617c478bd9Sstevel@tonic-gate numeral_set_t *set; 48627c478bd9Sstevel@tonic-gate 48637c478bd9Sstevel@tonic-gate if (rules == NULL) { 48647c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: no rules. path: %s\n", 48657c478bd9Sstevel@tonic-gate fcn, devfs_path ? devfs_path : "<NULL path>"); 48667c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 48677c478bd9Sstevel@tonic-gate } 48687c478bd9Sstevel@tonic-gate 48697c478bd9Sstevel@tonic-gate if (devfs_path == NULL) { 48707c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: NULL path\n", fcn); 48717c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 48727c478bd9Sstevel@tonic-gate } 48737c478bd9Sstevel@tonic-gate 48747c478bd9Sstevel@tonic-gate if (nrules <= 0 || index < 0 || index >= nrules || buf == NULL) { 48757c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid arguments. path: %s\n", 48767c478bd9Sstevel@tonic-gate fcn, devfs_path); 48777c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 48787c478bd9Sstevel@tonic-gate } 48797c478bd9Sstevel@tonic-gate 48807c478bd9Sstevel@tonic-gate *buf = NULL; 48817c478bd9Sstevel@tonic-gate 48827c478bd9Sstevel@tonic-gate 48837c478bd9Sstevel@tonic-gate cmp_str = alloc_cmp_str(devfs_path, &rules[index]); 48847c478bd9Sstevel@tonic-gate if (cmp_str == NULL) { 48857c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 48867c478bd9Sstevel@tonic-gate } 48877c478bd9Sstevel@tonic-gate 48887c478bd9Sstevel@tonic-gate if ((set = get_enum_cache(rules, nrules)) == NULL) { 48897c478bd9Sstevel@tonic-gate free(cmp_str); 48907c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 48917c478bd9Sstevel@tonic-gate } 48927c478bd9Sstevel@tonic-gate 48937c478bd9Sstevel@tonic-gate assert(nrules == set->re_count); 48947c478bd9Sstevel@tonic-gate 48957c478bd9Sstevel@tonic-gate /* 48967c478bd9Sstevel@tonic-gate * Check and see if a matching entry is already cached. 48977c478bd9Sstevel@tonic-gate */ 48987c478bd9Sstevel@tonic-gate matchcount = lookup_enum_cache(set, cmp_str, rules, index, 48997c478bd9Sstevel@tonic-gate &matchnp); 49007c478bd9Sstevel@tonic-gate 49017c478bd9Sstevel@tonic-gate if (matchcount < 0 || matchcount > 1) { 49027c478bd9Sstevel@tonic-gate free(cmp_str); 49037c478bd9Sstevel@tonic-gate if (multiple && matchcount > 1) 49047c478bd9Sstevel@tonic-gate return (DEVFSADM_MULTIPLE); 49057c478bd9Sstevel@tonic-gate else 49067c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 49077c478bd9Sstevel@tonic-gate } 49087c478bd9Sstevel@tonic-gate 49097c478bd9Sstevel@tonic-gate /* if matching entry already cached, return it */ 49107c478bd9Sstevel@tonic-gate if (matchcount == 1) { 49118d483882Smlf /* should never create a link with a reserved ID */ 49128d483882Smlf vprint(ENUM_MID, "%s: 1 match w/ ID: %s\n", fcn, matchnp->id); 49138d483882Smlf assert(matchnp->flags == 0); 49147c478bd9Sstevel@tonic-gate *buf = s_strdup(matchnp->id); 49157c478bd9Sstevel@tonic-gate free(cmp_str); 49167c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 49177c478bd9Sstevel@tonic-gate } 49187c478bd9Sstevel@tonic-gate 49197c478bd9Sstevel@tonic-gate /* 49207c478bd9Sstevel@tonic-gate * no cached entry, initialize a numeral struct 49217c478bd9Sstevel@tonic-gate * by calling new_id() and cache onto the numeral_set 49227c478bd9Sstevel@tonic-gate */ 49237c478bd9Sstevel@tonic-gate numeral = s_malloc(sizeof (numeral_t)); 49247c478bd9Sstevel@tonic-gate numeral->id = new_id(set->headnumeral, type, min); 49257c478bd9Sstevel@tonic-gate numeral->full_path = s_strdup(devfs_path); 49267c478bd9Sstevel@tonic-gate numeral->rule_index = index; 49277c478bd9Sstevel@tonic-gate numeral->cmp_str = cmp_str; 49287c478bd9Sstevel@tonic-gate cmp_str = NULL; 49298d483882Smlf numeral->flags = 0; 49308d483882Smlf vprint(RSRV_MID, "%s: alloc new_id: %s numeral flags = %d\n", 49318d483882Smlf fcn, numeral->id, numeral->flags); 49328d483882Smlf 49337c478bd9Sstevel@tonic-gate 49347c478bd9Sstevel@tonic-gate /* insert to head of list for fast lookups */ 49357c478bd9Sstevel@tonic-gate numeral->next = set->headnumeral; 49367c478bd9Sstevel@tonic-gate set->headnumeral = numeral; 49377c478bd9Sstevel@tonic-gate 49387c478bd9Sstevel@tonic-gate *buf = s_strdup(numeral->id); 49397c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 49407c478bd9Sstevel@tonic-gate } 49417c478bd9Sstevel@tonic-gate 49427c478bd9Sstevel@tonic-gate 49437c478bd9Sstevel@tonic-gate /* 49447c478bd9Sstevel@tonic-gate * Looks up the specified cache for a match with a specified string 49457c478bd9Sstevel@tonic-gate * Returns: 49467c478bd9Sstevel@tonic-gate * -1 : on error. 49477c478bd9Sstevel@tonic-gate * 0/1/2 : Number of matches. 49487c478bd9Sstevel@tonic-gate * Returns the matching element only if there is a single match. 49497c478bd9Sstevel@tonic-gate * If the "uncached" flag is set, derives the "cmp_str" afresh 49507c478bd9Sstevel@tonic-gate * for the match instead of using cached values. 49517c478bd9Sstevel@tonic-gate */ 49527c478bd9Sstevel@tonic-gate static int 49537c478bd9Sstevel@tonic-gate lookup_enum_cache(numeral_set_t *set, char *cmp_str, 49547c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[], int index, numeral_t **matchnpp) 49557c478bd9Sstevel@tonic-gate { 49567c478bd9Sstevel@tonic-gate int matchcount = 0, rv = -1; 49577c478bd9Sstevel@tonic-gate int uncached; 49587c478bd9Sstevel@tonic-gate numeral_t *np; 49597c478bd9Sstevel@tonic-gate char *fcn = "lookup_enum_cache"; 49607c478bd9Sstevel@tonic-gate char *cp; 49617c478bd9Sstevel@tonic-gate 49627c478bd9Sstevel@tonic-gate *matchnpp = NULL; 49637c478bd9Sstevel@tonic-gate 49647c478bd9Sstevel@tonic-gate assert(index < set->re_count); 49657c478bd9Sstevel@tonic-gate 49667c478bd9Sstevel@tonic-gate if (cmp_str == NULL) { 49677c478bd9Sstevel@tonic-gate return (-1); 49687c478bd9Sstevel@tonic-gate } 49697c478bd9Sstevel@tonic-gate 49707c478bd9Sstevel@tonic-gate uncached = 0; 49717c478bd9Sstevel@tonic-gate if ((rules[index].flags & MATCH_UNCACHED) == MATCH_UNCACHED) { 49727c478bd9Sstevel@tonic-gate uncached = 1; 49737c478bd9Sstevel@tonic-gate } 49747c478bd9Sstevel@tonic-gate 49757c478bd9Sstevel@tonic-gate /* 49767c478bd9Sstevel@tonic-gate * Check and see if a matching entry is already cached. 49777c478bd9Sstevel@tonic-gate */ 49787c478bd9Sstevel@tonic-gate for (np = set->headnumeral; np != NULL; np = np->next) { 49798d483882Smlf 49808d483882Smlf /* 49818d483882Smlf * Skip reserved IDs 49828d483882Smlf */ 49838d483882Smlf if (np->flags & NUMERAL_RESERVED) { 49848d483882Smlf vprint(RSRV_MID, "lookup_enum_cache: " 49858d483882Smlf "Cannot Match with reserved ID (%s), " 49868d483882Smlf "skipping\n", np->id); 49878d483882Smlf assert(np->flags == NUMERAL_RESERVED); 49888d483882Smlf continue; 49898d483882Smlf } else { 49908d483882Smlf vprint(RSRV_MID, "lookup_enum_cache: " 49918d483882Smlf "Attempting match with numeral ID: %s" 49928d483882Smlf " numeral flags = %d\n", np->id, np->flags); 49938d483882Smlf assert(np->flags == 0); 49948d483882Smlf } 49958d483882Smlf 49967c478bd9Sstevel@tonic-gate if (np->cmp_str == NULL) { 49977c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid entry in enumerate" 49987c478bd9Sstevel@tonic-gate " cache. path: %s\n", fcn, np->full_path); 49997c478bd9Sstevel@tonic-gate return (-1); 50007c478bd9Sstevel@tonic-gate } 50017c478bd9Sstevel@tonic-gate 50027c478bd9Sstevel@tonic-gate if (uncached) { 50037c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%s: bypassing enumerate cache." 50047c478bd9Sstevel@tonic-gate " path: %s\n", fcn, cmp_str); 50057c478bd9Sstevel@tonic-gate cp = alloc_cmp_str(np->full_path, 50067c478bd9Sstevel@tonic-gate &rules[np->rule_index]); 50077c478bd9Sstevel@tonic-gate if (cp == NULL) 50087c478bd9Sstevel@tonic-gate return (-1); 50097c478bd9Sstevel@tonic-gate rv = strcmp(cmp_str, cp); 50107c478bd9Sstevel@tonic-gate free(cp); 50117c478bd9Sstevel@tonic-gate } else { 50127c478bd9Sstevel@tonic-gate rv = strcmp(cmp_str, np->cmp_str); 50137c478bd9Sstevel@tonic-gate } 50147c478bd9Sstevel@tonic-gate 50157c478bd9Sstevel@tonic-gate if (rv == 0) { 50167c478bd9Sstevel@tonic-gate if (matchcount++ != 0) { 50177c478bd9Sstevel@tonic-gate break; /* more than 1 match. */ 50187c478bd9Sstevel@tonic-gate } 50197c478bd9Sstevel@tonic-gate *matchnpp = np; 50207c478bd9Sstevel@tonic-gate } 50217c478bd9Sstevel@tonic-gate } 50227c478bd9Sstevel@tonic-gate 50237c478bd9Sstevel@tonic-gate return (matchcount); 50247c478bd9Sstevel@tonic-gate } 50257c478bd9Sstevel@tonic-gate 50267c478bd9Sstevel@tonic-gate #ifdef DEBUG 50277c478bd9Sstevel@tonic-gate static void 50287c478bd9Sstevel@tonic-gate dump_enum_cache(numeral_set_t *setp) 50297c478bd9Sstevel@tonic-gate { 50307c478bd9Sstevel@tonic-gate int i; 50317c478bd9Sstevel@tonic-gate numeral_t *np; 50327c478bd9Sstevel@tonic-gate char *fcn = "dump_enum_cache"; 50337c478bd9Sstevel@tonic-gate 50347c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: re_count = %d\n", fcn, setp->re_count); 50357c478bd9Sstevel@tonic-gate for (i = 0; i < setp->re_count; i++) { 50367c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: re[%d] = %s\n", fcn, i, setp->re[i]); 50377c478bd9Sstevel@tonic-gate } 50387c478bd9Sstevel@tonic-gate 50397c478bd9Sstevel@tonic-gate for (np = setp->headnumeral; np != NULL; np = np->next) { 50407c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: id: %s\n", fcn, np->id); 50417c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: full_path: %s\n", fcn, np->full_path); 50427c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: rule_index: %d\n", fcn, np->rule_index); 50437c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: cmp_str: %s\n", fcn, np->cmp_str); 50448d483882Smlf vprint(ENUM_MID, "%s: flags: %d\n", fcn, np->flags); 50457c478bd9Sstevel@tonic-gate } 50467c478bd9Sstevel@tonic-gate } 50477c478bd9Sstevel@tonic-gate #endif 50487c478bd9Sstevel@tonic-gate 50497c478bd9Sstevel@tonic-gate /* 50507c478bd9Sstevel@tonic-gate * For a given set of regular expressions in rules[], this function returns 50517c478bd9Sstevel@tonic-gate * either a previously cached struct numeral_set or it will create and 50527c478bd9Sstevel@tonic-gate * cache a new struct numeral_set. There is only one struct numeral_set 50537c478bd9Sstevel@tonic-gate * for the combination of REs present in rules[]. Each numeral_set contains 50547c478bd9Sstevel@tonic-gate * the regular expressions in rules[] used for cache selection AND a linked 50557c478bd9Sstevel@tonic-gate * list of struct numerals, ONE FOR EACH *UNIQUE* numeral or character ID 50567c478bd9Sstevel@tonic-gate * selected by the grouping parenthesized subexpression found in the last 50577c478bd9Sstevel@tonic-gate * path component of each rules[].re. For example, the RE: "rmt/([0-9]+)" 50587c478bd9Sstevel@tonic-gate * selects all the logical nodes of the correct form in dev/rmt/. 50597c478bd9Sstevel@tonic-gate * Each rmt/X will store a *single* struct numeral... ie 0, 1, 2 each get a 50607c478bd9Sstevel@tonic-gate * single struct numeral. There is no need to store more than a single logical 50617c478bd9Sstevel@tonic-gate * node matching X since the information desired in the devfspath would be 50627c478bd9Sstevel@tonic-gate * identical for the portion of the devfspath of interest. (the part up to, 50637c478bd9Sstevel@tonic-gate * but not including the minor name in this example.) 50647c478bd9Sstevel@tonic-gate * 50657c478bd9Sstevel@tonic-gate * If the given numeral_set is not yet cached, call enumerate_recurse to 50667c478bd9Sstevel@tonic-gate * create it. 50677c478bd9Sstevel@tonic-gate */ 50687c478bd9Sstevel@tonic-gate static numeral_set_t * 50697c478bd9Sstevel@tonic-gate get_enum_cache(devfsadm_enumerate_t rules[], int nrules) 50707c478bd9Sstevel@tonic-gate { 50717c478bd9Sstevel@tonic-gate /* linked list of numeral sets */ 50727c478bd9Sstevel@tonic-gate numeral_set_t *setp; 50737c478bd9Sstevel@tonic-gate int i; 50748d483882Smlf int ret; 50757c478bd9Sstevel@tonic-gate char *path_left; 50768d483882Smlf enumerate_file_t *entry; 50777c478bd9Sstevel@tonic-gate char *fcn = "get_enum_cache"; 50787c478bd9Sstevel@tonic-gate 50797c478bd9Sstevel@tonic-gate /* 50807c478bd9Sstevel@tonic-gate * See if we've already cached this numeral set. 50817c478bd9Sstevel@tonic-gate */ 50827c478bd9Sstevel@tonic-gate for (setp = head_numeral_set; setp != NULL; setp = setp->next) { 50837c478bd9Sstevel@tonic-gate /* 50847c478bd9Sstevel@tonic-gate * check all regexp's passed in function against 50857c478bd9Sstevel@tonic-gate * those in cached set. 50867c478bd9Sstevel@tonic-gate */ 50877c478bd9Sstevel@tonic-gate if (nrules != setp->re_count) { 50887c478bd9Sstevel@tonic-gate continue; 50897c478bd9Sstevel@tonic-gate } 50907c478bd9Sstevel@tonic-gate 50917c478bd9Sstevel@tonic-gate for (i = 0; i < nrules; i++) { 50927c478bd9Sstevel@tonic-gate if (strcmp(setp->re[i], rules[i].re) != 0) { 50937c478bd9Sstevel@tonic-gate break; 50947c478bd9Sstevel@tonic-gate } 50957c478bd9Sstevel@tonic-gate } 50967c478bd9Sstevel@tonic-gate 50977c478bd9Sstevel@tonic-gate if (i == nrules) { 50987c478bd9Sstevel@tonic-gate return (setp); 50997c478bd9Sstevel@tonic-gate } 51007c478bd9Sstevel@tonic-gate } 51017c478bd9Sstevel@tonic-gate 51027c478bd9Sstevel@tonic-gate /* 51037c478bd9Sstevel@tonic-gate * If the MATCH_UNCACHED flag is set, we should not be here. 51047c478bd9Sstevel@tonic-gate */ 51057c478bd9Sstevel@tonic-gate for (i = 0; i < nrules; i++) { 51067c478bd9Sstevel@tonic-gate if ((rules[i].flags & MATCH_UNCACHED) == MATCH_UNCACHED) { 51077c478bd9Sstevel@tonic-gate vprint(ENUM_MID, "%s: invalid enumeration flags: " 51087c478bd9Sstevel@tonic-gate "0x%x\n", fcn, rules[i].flags); 51097c478bd9Sstevel@tonic-gate return (NULL); 51107c478bd9Sstevel@tonic-gate } 51117c478bd9Sstevel@tonic-gate } 51127c478bd9Sstevel@tonic-gate 51137c478bd9Sstevel@tonic-gate /* 51147c478bd9Sstevel@tonic-gate * Since we made it here, we have not yet cached the given set of 51157c478bd9Sstevel@tonic-gate * logical nodes matching the passed re. Create a cached entry 51167c478bd9Sstevel@tonic-gate * struct numeral_set and populate it with a minimal set of 51177c478bd9Sstevel@tonic-gate * logical nodes from /dev. 51187c478bd9Sstevel@tonic-gate */ 51197c478bd9Sstevel@tonic-gate 51207c478bd9Sstevel@tonic-gate setp = s_malloc(sizeof (numeral_set_t)); 51217c478bd9Sstevel@tonic-gate setp->re = s_malloc(sizeof (char *) * nrules); 51227c478bd9Sstevel@tonic-gate for (i = 0; i < nrules; i++) { 51237c478bd9Sstevel@tonic-gate setp->re[i] = s_strdup(rules[i].re); 51247c478bd9Sstevel@tonic-gate } 51257c478bd9Sstevel@tonic-gate setp->re_count = nrules; 51267c478bd9Sstevel@tonic-gate setp->headnumeral = NULL; 51277c478bd9Sstevel@tonic-gate 51287c478bd9Sstevel@tonic-gate /* put this new cached set on the cached set list */ 51297c478bd9Sstevel@tonic-gate setp->next = head_numeral_set; 51307c478bd9Sstevel@tonic-gate head_numeral_set = setp; 51317c478bd9Sstevel@tonic-gate 51328d483882Smlf /* 51338d483882Smlf * For each RE, search the "reserved" list to create numeral IDs that 51348d483882Smlf * are reserved. 51358d483882Smlf */ 51368d483882Smlf for (entry = enumerate_reserved; entry; entry = entry->er_next) { 51378d483882Smlf 51388d483882Smlf vprint(RSRV_MID, "parsing rstring: %s\n", entry->er_file); 51398d483882Smlf 51408d483882Smlf for (i = 0; i < nrules; i++) { 51418d483882Smlf path_left = s_strdup(setp->re[i]); 51428d483882Smlf vprint(RSRV_MID, "parsing rule RE: %s\n", path_left); 51438d483882Smlf ret = enumerate_parse(entry->er_file, path_left, 51448d483882Smlf setp, rules, i); 51458d483882Smlf free(path_left); 51468d483882Smlf if (ret == 1) { 51478d483882Smlf /* 51488d483882Smlf * We found the reserved ID for this entry. 51498d483882Smlf * We still keep the entry since it is needed 51508d483882Smlf * by the new link bypass code in disks 51518d483882Smlf */ 51528d483882Smlf vprint(RSRV_MID, "found rsv ID: rstring: %s " 51538d483882Smlf "rule RE: %s\n", entry->er_file, path_left); 51548d483882Smlf break; 51558d483882Smlf } 51568d483882Smlf } 51578d483882Smlf } 51588d483882Smlf 51597c478bd9Sstevel@tonic-gate /* 51607c478bd9Sstevel@tonic-gate * For each RE, search disk and cache any matches on the 5161facf4a8dSllai * numeral list. 51627c478bd9Sstevel@tonic-gate */ 51637c478bd9Sstevel@tonic-gate for (i = 0; i < nrules; i++) { 51647c478bd9Sstevel@tonic-gate path_left = s_strdup(setp->re[i]); 5165facf4a8dSllai enumerate_recurse(dev_dir, path_left, setp, rules, i); 51667c478bd9Sstevel@tonic-gate free(path_left); 51677c478bd9Sstevel@tonic-gate } 51687c478bd9Sstevel@tonic-gate 51697c478bd9Sstevel@tonic-gate #ifdef DEBUG 51707c478bd9Sstevel@tonic-gate dump_enum_cache(setp); 51717c478bd9Sstevel@tonic-gate #endif 51727c478bd9Sstevel@tonic-gate 51737c478bd9Sstevel@tonic-gate return (setp); 51747c478bd9Sstevel@tonic-gate } 51757c478bd9Sstevel@tonic-gate 51767c478bd9Sstevel@tonic-gate 51777c478bd9Sstevel@tonic-gate /* 51787c478bd9Sstevel@tonic-gate * This function stats the pathname namebuf. If this is a directory 51797c478bd9Sstevel@tonic-gate * entry, we recurse down dname/fname until we find the first symbolic 51807c478bd9Sstevel@tonic-gate * link, and then stat and return it. This is valid for the same reason 51817c478bd9Sstevel@tonic-gate * that we only need to read a single pathname for multiple matching 51827c478bd9Sstevel@tonic-gate * logical ID's... ie, all the logical nodes should contain identical 51837c478bd9Sstevel@tonic-gate * physical paths for the parts we are interested. 51847c478bd9Sstevel@tonic-gate */ 51857c478bd9Sstevel@tonic-gate int 51867c478bd9Sstevel@tonic-gate get_stat_info(char *namebuf, struct stat *sb) 51877c478bd9Sstevel@tonic-gate { 51887c478bd9Sstevel@tonic-gate char *cp; 518973de625bSjg finddevhdl_t fhandle; 519073de625bSjg const char *fp; 51917c478bd9Sstevel@tonic-gate 51927c478bd9Sstevel@tonic-gate if (lstat(namebuf, sb) < 0) { 51937c478bd9Sstevel@tonic-gate (void) err_print(LSTAT_FAILED, namebuf, strerror(errno)); 51947c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 51957c478bd9Sstevel@tonic-gate } 51967c478bd9Sstevel@tonic-gate 51977c478bd9Sstevel@tonic-gate if ((sb->st_mode & S_IFMT) == S_IFLNK) { 51987c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 51997c478bd9Sstevel@tonic-gate } 52007c478bd9Sstevel@tonic-gate 52017c478bd9Sstevel@tonic-gate /* 52027c478bd9Sstevel@tonic-gate * If it is a dir, recurse down until we find a link and 52037c478bd9Sstevel@tonic-gate * then use the link. 52047c478bd9Sstevel@tonic-gate */ 52057c478bd9Sstevel@tonic-gate if ((sb->st_mode & S_IFMT) == S_IFDIR) { 52067c478bd9Sstevel@tonic-gate 520773de625bSjg if (finddev_readdir(namebuf, &fhandle) != 0) { 52087c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 52097c478bd9Sstevel@tonic-gate } 52107c478bd9Sstevel@tonic-gate 52117c478bd9Sstevel@tonic-gate /* 52127c478bd9Sstevel@tonic-gate * Search each dir entry looking for a symlink. Return 52137c478bd9Sstevel@tonic-gate * the first symlink found in namebuf. Recurse dirs. 52147c478bd9Sstevel@tonic-gate */ 521573de625bSjg while ((fp = finddev_next(fhandle)) != NULL) { 52167c478bd9Sstevel@tonic-gate cp = namebuf + strlen(namebuf); 5217facf4a8dSllai if ((strlcat(namebuf, "/", PATH_MAX) >= PATH_MAX) || 521873de625bSjg (strlcat(namebuf, fp, PATH_MAX) >= PATH_MAX)) { 5219facf4a8dSllai *cp = '\0'; 522073de625bSjg finddev_close(fhandle); 5221facf4a8dSllai return (DEVFSADM_FAILURE); 5222facf4a8dSllai } 52237c478bd9Sstevel@tonic-gate if (get_stat_info(namebuf, sb) == DEVFSADM_SUCCESS) { 522473de625bSjg finddev_close(fhandle); 52257c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 52267c478bd9Sstevel@tonic-gate } 52277c478bd9Sstevel@tonic-gate *cp = '\0'; 52287c478bd9Sstevel@tonic-gate } 522973de625bSjg finddev_close(fhandle); 52307c478bd9Sstevel@tonic-gate } 52317c478bd9Sstevel@tonic-gate 52327c478bd9Sstevel@tonic-gate /* no symlink found, so return error */ 52337c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 52347c478bd9Sstevel@tonic-gate } 52357c478bd9Sstevel@tonic-gate 52367c478bd9Sstevel@tonic-gate /* 52377c478bd9Sstevel@tonic-gate * An existing matching ID was not found, so this function is called to 52387c478bd9Sstevel@tonic-gate * create the next lowest ID. In the INTEGER case, return the next 52397c478bd9Sstevel@tonic-gate * lowest unused integer. In the case of LETTER, return the next lowest 52407c478bd9Sstevel@tonic-gate * unused letter. Return empty string if all 26 are used. 52417c478bd9Sstevel@tonic-gate * Only IDs >= min will be returned. 52427c478bd9Sstevel@tonic-gate */ 52437c478bd9Sstevel@tonic-gate char * 52447c478bd9Sstevel@tonic-gate new_id(numeral_t *numeral, int type, char *min) 52457c478bd9Sstevel@tonic-gate { 52467c478bd9Sstevel@tonic-gate int imin; 52477c478bd9Sstevel@tonic-gate temp_t *temp; 52487c478bd9Sstevel@tonic-gate temp_t *ptr; 52497c478bd9Sstevel@tonic-gate temp_t **previous; 52507c478bd9Sstevel@tonic-gate temp_t *head = NULL; 52517c478bd9Sstevel@tonic-gate char *retval; 52527c478bd9Sstevel@tonic-gate static char tempbuff[8]; 52537c478bd9Sstevel@tonic-gate numeral_t *np; 52547c478bd9Sstevel@tonic-gate 52557c478bd9Sstevel@tonic-gate if (type == LETTER) { 52567c478bd9Sstevel@tonic-gate 52577c478bd9Sstevel@tonic-gate char letter[26], i; 52587c478bd9Sstevel@tonic-gate 52597c478bd9Sstevel@tonic-gate if (numeral == NULL) { 52607c478bd9Sstevel@tonic-gate return (s_strdup(min)); 52617c478bd9Sstevel@tonic-gate } 52627c478bd9Sstevel@tonic-gate 52637c478bd9Sstevel@tonic-gate for (i = 0; i < 26; i++) { 52647c478bd9Sstevel@tonic-gate letter[i] = 0; 52657c478bd9Sstevel@tonic-gate } 52667c478bd9Sstevel@tonic-gate 52677c478bd9Sstevel@tonic-gate for (np = numeral; np != NULL; np = np->next) { 52688d483882Smlf assert(np->flags == 0 || 52698d483882Smlf np->flags == NUMERAL_RESERVED); 52707c478bd9Sstevel@tonic-gate letter[*np->id - 'a']++; 52717c478bd9Sstevel@tonic-gate } 52727c478bd9Sstevel@tonic-gate 52737c478bd9Sstevel@tonic-gate imin = *min - 'a'; 52747c478bd9Sstevel@tonic-gate 52757c478bd9Sstevel@tonic-gate for (i = imin; i < 26; i++) { 52767c478bd9Sstevel@tonic-gate if (letter[i] == 0) { 52777c478bd9Sstevel@tonic-gate retval = s_malloc(2); 52787c478bd9Sstevel@tonic-gate retval[0] = 'a' + i; 52797c478bd9Sstevel@tonic-gate retval[1] = '\0'; 52807c478bd9Sstevel@tonic-gate return (retval); 52817c478bd9Sstevel@tonic-gate } 52827c478bd9Sstevel@tonic-gate } 52837c478bd9Sstevel@tonic-gate 52847c478bd9Sstevel@tonic-gate return (s_strdup("")); 52857c478bd9Sstevel@tonic-gate } 52867c478bd9Sstevel@tonic-gate 52877c478bd9Sstevel@tonic-gate if (type == INTEGER) { 52887c478bd9Sstevel@tonic-gate 52897c478bd9Sstevel@tonic-gate if (numeral == NULL) { 52907c478bd9Sstevel@tonic-gate return (s_strdup(min)); 52917c478bd9Sstevel@tonic-gate } 52927c478bd9Sstevel@tonic-gate 52937c478bd9Sstevel@tonic-gate imin = atoi(min); 52947c478bd9Sstevel@tonic-gate 52957c478bd9Sstevel@tonic-gate /* sort list */ 52967c478bd9Sstevel@tonic-gate for (np = numeral; np != NULL; np = np->next) { 52978d483882Smlf assert(np->flags == 0 || 52988d483882Smlf np->flags == NUMERAL_RESERVED); 52997c478bd9Sstevel@tonic-gate temp = s_malloc(sizeof (temp_t)); 53007c478bd9Sstevel@tonic-gate temp->integer = atoi(np->id); 53017c478bd9Sstevel@tonic-gate temp->next = NULL; 53027c478bd9Sstevel@tonic-gate 53037c478bd9Sstevel@tonic-gate previous = &head; 53047c478bd9Sstevel@tonic-gate for (ptr = head; ptr != NULL; ptr = ptr->next) { 53057c478bd9Sstevel@tonic-gate if (temp->integer < ptr->integer) { 53067c478bd9Sstevel@tonic-gate temp->next = ptr; 53077c478bd9Sstevel@tonic-gate *previous = temp; 53087c478bd9Sstevel@tonic-gate break; 53097c478bd9Sstevel@tonic-gate } 53107c478bd9Sstevel@tonic-gate previous = &(ptr->next); 53117c478bd9Sstevel@tonic-gate } 53127c478bd9Sstevel@tonic-gate if (ptr == NULL) { 53137c478bd9Sstevel@tonic-gate *previous = temp; 53147c478bd9Sstevel@tonic-gate } 53157c478bd9Sstevel@tonic-gate } 53167c478bd9Sstevel@tonic-gate 53177c478bd9Sstevel@tonic-gate /* now search sorted list for first hole >= imin */ 53187c478bd9Sstevel@tonic-gate for (ptr = head; ptr != NULL; ptr = ptr->next) { 53197c478bd9Sstevel@tonic-gate if (imin == ptr->integer) { 53207c478bd9Sstevel@tonic-gate imin++; 53217c478bd9Sstevel@tonic-gate } else { 53227c478bd9Sstevel@tonic-gate if (imin < ptr->integer) { 53237c478bd9Sstevel@tonic-gate break; 53247c478bd9Sstevel@tonic-gate } 53257c478bd9Sstevel@tonic-gate } 53267c478bd9Sstevel@tonic-gate 53277c478bd9Sstevel@tonic-gate } 53287c478bd9Sstevel@tonic-gate 53297c478bd9Sstevel@tonic-gate /* free temp list */ 53307c478bd9Sstevel@tonic-gate for (ptr = head; ptr != NULL; ) { 53317c478bd9Sstevel@tonic-gate temp = ptr; 53327c478bd9Sstevel@tonic-gate ptr = ptr->next; 53337c478bd9Sstevel@tonic-gate free(temp); 53347c478bd9Sstevel@tonic-gate } 53357c478bd9Sstevel@tonic-gate 53367c478bd9Sstevel@tonic-gate (void) sprintf(tempbuff, "%d", imin); 53377c478bd9Sstevel@tonic-gate return (s_strdup(tempbuff)); 53387c478bd9Sstevel@tonic-gate } 53397c478bd9Sstevel@tonic-gate 53407c478bd9Sstevel@tonic-gate return (s_strdup("")); 53417c478bd9Sstevel@tonic-gate } 53427c478bd9Sstevel@tonic-gate 53438d483882Smlf static int 53448d483882Smlf enumerate_parse(char *rsvstr, char *path_left, numeral_set_t *setp, 53458d483882Smlf devfsadm_enumerate_t rules[], int index) 53468d483882Smlf { 53478d483882Smlf char *slash1 = NULL; 53488d483882Smlf char *slash2 = NULL; 53498d483882Smlf char *numeral_id; 53508d483882Smlf char *path_left_save; 53518d483882Smlf char *rsvstr_save; 53528d483882Smlf int ret = 0; 53538d483882Smlf static int warned = 0; 53548d483882Smlf 53558d483882Smlf rsvstr_save = rsvstr; 53568d483882Smlf path_left_save = path_left; 53578d483882Smlf 53588d483882Smlf if (rsvstr == NULL || rsvstr[0] == '\0' || rsvstr[0] == '/') { 53598d483882Smlf if (!warned) { 53608d483882Smlf err_print("invalid reserved filepath: %s\n", 53618d483882Smlf rsvstr ? rsvstr : "<NULL>"); 53628d483882Smlf warned = 1; 53638d483882Smlf } 53648d483882Smlf return (0); 53658d483882Smlf } 53668d483882Smlf 53678d483882Smlf vprint(RSRV_MID, "processing rule: %s, rstring: %s\n", 53688d483882Smlf path_left, rsvstr); 53698d483882Smlf 53708d483882Smlf 53718d483882Smlf for (;;) { 53728d483882Smlf /* get rid of any extra '/' in the reserve string */ 53738d483882Smlf while (*rsvstr == '/') { 53748d483882Smlf rsvstr++; 53758d483882Smlf } 53768d483882Smlf 53778d483882Smlf /* get rid of any extra '/' in the RE */ 53788d483882Smlf while (*path_left == '/') { 53798d483882Smlf path_left++; 53808d483882Smlf } 53818d483882Smlf 53828d483882Smlf if (slash1 = strchr(path_left, '/')) { 53838d483882Smlf *slash1 = '\0'; 53848d483882Smlf } 53858d483882Smlf if (slash2 = strchr(rsvstr, '/')) { 53868d483882Smlf *slash2 = '\0'; 53878d483882Smlf } 53888d483882Smlf 53898d483882Smlf if ((slash1 != NULL) ^ (slash2 != NULL)) { 53908d483882Smlf ret = 0; 53918d483882Smlf vprint(RSRV_MID, "mismatch in # of path components\n"); 53928d483882Smlf goto out; 53938d483882Smlf } 53948d483882Smlf 53958d483882Smlf /* 53968d483882Smlf * Returns true if path_left matches the list entry. 53978d483882Smlf * If it is the last path component, pass subexp 53988d483882Smlf * so that it will return the corresponding ID in 53998d483882Smlf * numeral_id. 54008d483882Smlf */ 54018d483882Smlf numeral_id = NULL; 54028d483882Smlf if (match_path_component(path_left, rsvstr, &numeral_id, 54030a653502Swroche slash1 ? 0 : rules[index].subexp)) { 54048d483882Smlf 54058d483882Smlf /* We have a match. */ 54068d483882Smlf if (slash1 == NULL) { 54078d483882Smlf /* Is last path component */ 54088d483882Smlf vprint(RSRV_MID, "match and last component\n"); 54098d483882Smlf create_reserved_numeral(setp, numeral_id); 54108d483882Smlf if (numeral_id != NULL) { 54118d483882Smlf free(numeral_id); 54128d483882Smlf } 54138d483882Smlf ret = 1; 54148d483882Smlf goto out; 54158d483882Smlf } else { 54168d483882Smlf /* Not last path component. Continue parsing */ 54178d483882Smlf *slash1 = '/'; 54188d483882Smlf *slash2 = '/'; 54198d483882Smlf path_left = slash1 + 1; 54208d483882Smlf rsvstr = slash2 + 1; 54218d483882Smlf vprint(RSRV_MID, 54228d483882Smlf "match and NOT last component\n"); 54238d483882Smlf continue; 54248d483882Smlf } 54258d483882Smlf } else { 54268d483882Smlf /* No match */ 54278d483882Smlf ret = 0; 54288d483882Smlf vprint(RSRV_MID, "No match: rule RE = %s, " 54298d483882Smlf "rstring = %s\n", path_left, rsvstr); 54308d483882Smlf goto out; 54318d483882Smlf } 54328d483882Smlf } 54338d483882Smlf 54348d483882Smlf out: 54358d483882Smlf if (slash1) 54368d483882Smlf *slash1 = '/'; 54378d483882Smlf if (slash2) 54388d483882Smlf *slash2 = '/'; 54398d483882Smlf 54408d483882Smlf if (ret == 1) { 54418d483882Smlf vprint(RSRV_MID, "match: rule RE: %s, rstring: %s\n", 54428d483882Smlf path_left_save, rsvstr_save); 54438d483882Smlf } else { 54448d483882Smlf vprint(RSRV_MID, "NO match: rule RE: %s, rstring: %s\n", 54458d483882Smlf path_left_save, rsvstr_save); 54468d483882Smlf } 54478d483882Smlf 54488d483882Smlf return (ret); 54498d483882Smlf } 54508d483882Smlf 54517c478bd9Sstevel@tonic-gate /* 54527c478bd9Sstevel@tonic-gate * Search current_dir for all files which match the first path component 54537c478bd9Sstevel@tonic-gate * of path_left, which is an RE. If a match is found, but there are more 54547c478bd9Sstevel@tonic-gate * components of path_left, then recurse, otherwise, if we have reached 54557c478bd9Sstevel@tonic-gate * the last component of path_left, call create_cached_numerals for each 54567c478bd9Sstevel@tonic-gate * file. At some point, recurse_dev_re() should be rewritten so that this 54577c478bd9Sstevel@tonic-gate * function can be eliminated. 54587c478bd9Sstevel@tonic-gate */ 54597c478bd9Sstevel@tonic-gate static void 54607c478bd9Sstevel@tonic-gate enumerate_recurse(char *current_dir, char *path_left, numeral_set_t *setp, 54617c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[], int index) 54627c478bd9Sstevel@tonic-gate { 54637c478bd9Sstevel@tonic-gate char *slash; 54647c478bd9Sstevel@tonic-gate char *new_path; 54657c478bd9Sstevel@tonic-gate char *numeral_id; 546673de625bSjg finddevhdl_t fhandle; 546773de625bSjg const char *fp; 54687c478bd9Sstevel@tonic-gate 546973de625bSjg if (finddev_readdir(current_dir, &fhandle) != 0) { 54707c478bd9Sstevel@tonic-gate return; 54717c478bd9Sstevel@tonic-gate } 54727c478bd9Sstevel@tonic-gate 54737c478bd9Sstevel@tonic-gate /* get rid of any extra '/' */ 54747c478bd9Sstevel@tonic-gate while (*path_left == '/') { 54757c478bd9Sstevel@tonic-gate path_left++; 54767c478bd9Sstevel@tonic-gate } 54777c478bd9Sstevel@tonic-gate 54787c478bd9Sstevel@tonic-gate if (slash = strchr(path_left, '/')) { 54797c478bd9Sstevel@tonic-gate *slash = '\0'; 54807c478bd9Sstevel@tonic-gate } 54817c478bd9Sstevel@tonic-gate 548273de625bSjg while ((fp = finddev_next(fhandle)) != NULL) { 54837c478bd9Sstevel@tonic-gate 54847c478bd9Sstevel@tonic-gate /* 5485facf4a8dSllai * Returns true if path_left matches the list entry. 54867c478bd9Sstevel@tonic-gate * If it is the last path component, pass subexp 54877c478bd9Sstevel@tonic-gate * so that it will return the corresponding ID in 54887c478bd9Sstevel@tonic-gate * numeral_id. 54897c478bd9Sstevel@tonic-gate */ 54907c478bd9Sstevel@tonic-gate numeral_id = NULL; 549173de625bSjg if (match_path_component(path_left, (char *)fp, &numeral_id, 54920a653502Swroche slash ? 0 : rules[index].subexp)) { 54937c478bd9Sstevel@tonic-gate 54947c478bd9Sstevel@tonic-gate new_path = s_malloc(strlen(current_dir) + 549573de625bSjg strlen(fp) + 2); 54967c478bd9Sstevel@tonic-gate 54977c478bd9Sstevel@tonic-gate (void) strcpy(new_path, current_dir); 54987c478bd9Sstevel@tonic-gate (void) strcat(new_path, "/"); 549973de625bSjg (void) strcat(new_path, fp); 55007c478bd9Sstevel@tonic-gate 55017c478bd9Sstevel@tonic-gate if (slash != NULL) { 55027c478bd9Sstevel@tonic-gate enumerate_recurse(new_path, slash + 1, 55037c478bd9Sstevel@tonic-gate setp, rules, index); 55047c478bd9Sstevel@tonic-gate } else { 55057c478bd9Sstevel@tonic-gate create_cached_numeral(new_path, setp, 55067c478bd9Sstevel@tonic-gate numeral_id, rules, index); 55077c478bd9Sstevel@tonic-gate if (numeral_id != NULL) { 55087c478bd9Sstevel@tonic-gate free(numeral_id); 55097c478bd9Sstevel@tonic-gate } 55107c478bd9Sstevel@tonic-gate } 55117c478bd9Sstevel@tonic-gate free(new_path); 55127c478bd9Sstevel@tonic-gate } 55137c478bd9Sstevel@tonic-gate } 55147c478bd9Sstevel@tonic-gate 55157c478bd9Sstevel@tonic-gate if (slash != NULL) { 55167c478bd9Sstevel@tonic-gate *slash = '/'; 55177c478bd9Sstevel@tonic-gate } 551873de625bSjg finddev_close(fhandle); 55197c478bd9Sstevel@tonic-gate } 55207c478bd9Sstevel@tonic-gate 55217c478bd9Sstevel@tonic-gate 55227c478bd9Sstevel@tonic-gate /* 55237c478bd9Sstevel@tonic-gate * Returns true if file matches file_re. If subexp is non-zero, it means 55247c478bd9Sstevel@tonic-gate * we are searching the last path component and need to return the 55257c478bd9Sstevel@tonic-gate * parenthesized subexpression subexp in id. 55267c478bd9Sstevel@tonic-gate * 55277c478bd9Sstevel@tonic-gate */ 55287c478bd9Sstevel@tonic-gate static int 55297c478bd9Sstevel@tonic-gate match_path_component(char *file_re, char *file, char **id, int subexp) 55307c478bd9Sstevel@tonic-gate { 55317c478bd9Sstevel@tonic-gate regex_t re1; 55327c478bd9Sstevel@tonic-gate int match = 0; 55337c478bd9Sstevel@tonic-gate int nelements; 55347c478bd9Sstevel@tonic-gate regmatch_t *pmatch; 55357c478bd9Sstevel@tonic-gate 55367c478bd9Sstevel@tonic-gate if (subexp != 0) { 55377c478bd9Sstevel@tonic-gate nelements = subexp + 1; 55380a653502Swroche pmatch = 55390a653502Swroche (regmatch_t *)s_malloc(sizeof (regmatch_t) * nelements); 55407c478bd9Sstevel@tonic-gate } else { 55417c478bd9Sstevel@tonic-gate pmatch = NULL; 55427c478bd9Sstevel@tonic-gate nelements = 0; 55437c478bd9Sstevel@tonic-gate } 55447c478bd9Sstevel@tonic-gate 55457c478bd9Sstevel@tonic-gate if (regcomp(&re1, file_re, REG_EXTENDED) != 0) { 55467c478bd9Sstevel@tonic-gate if (pmatch != NULL) { 55477c478bd9Sstevel@tonic-gate free(pmatch); 55487c478bd9Sstevel@tonic-gate } 55497c478bd9Sstevel@tonic-gate return (0); 55507c478bd9Sstevel@tonic-gate } 55517c478bd9Sstevel@tonic-gate 55527c478bd9Sstevel@tonic-gate if (regexec(&re1, file, nelements, pmatch, 0) == 0) { 55537c478bd9Sstevel@tonic-gate match = 1; 55547c478bd9Sstevel@tonic-gate } 55557c478bd9Sstevel@tonic-gate 55567c478bd9Sstevel@tonic-gate if ((match != 0) && (subexp != 0)) { 55577c478bd9Sstevel@tonic-gate int size = pmatch[subexp].rm_eo - pmatch[subexp].rm_so; 55587c478bd9Sstevel@tonic-gate *id = s_malloc(size + 1); 55597c478bd9Sstevel@tonic-gate (void) strncpy(*id, &file[pmatch[subexp].rm_so], size); 55607c478bd9Sstevel@tonic-gate (*id)[size] = '\0'; 55617c478bd9Sstevel@tonic-gate } 55627c478bd9Sstevel@tonic-gate 55637c478bd9Sstevel@tonic-gate if (pmatch != NULL) { 55647c478bd9Sstevel@tonic-gate free(pmatch); 55657c478bd9Sstevel@tonic-gate } 55667c478bd9Sstevel@tonic-gate regfree(&re1); 55677c478bd9Sstevel@tonic-gate return (match); 55687c478bd9Sstevel@tonic-gate } 55697c478bd9Sstevel@tonic-gate 55708d483882Smlf static void 55718d483882Smlf create_reserved_numeral(numeral_set_t *setp, char *numeral_id) 55728d483882Smlf { 55738d483882Smlf numeral_t *np; 55748d483882Smlf 55758d483882Smlf vprint(RSRV_MID, "Attempting to create reserved numeral: %s\n", 55768d483882Smlf numeral_id); 55778d483882Smlf 55788d483882Smlf /* 55798d483882Smlf * We found a numeral_id from an entry in the enumerate_reserved file 55808d483882Smlf * which matched the re passed in from devfsadm_enumerate. We only 55818d483882Smlf * need to make sure ONE copy of numeral_id exists on the numeral list. 55828d483882Smlf * We only need to store /dev/dsk/cNtod0s0 and no other entries 55838d483882Smlf * hanging off of controller N. 55848d483882Smlf */ 55858d483882Smlf for (np = setp->headnumeral; np != NULL; np = np->next) { 55868d483882Smlf if (strcmp(numeral_id, np->id) == 0) { 55878d483882Smlf vprint(RSRV_MID, "ID: %s, already reserved\n", np->id); 55888d483882Smlf assert(np->flags == NUMERAL_RESERVED); 55898d483882Smlf return; 55908d483882Smlf } else { 55918d483882Smlf assert(np->flags == 0 || 55928d483882Smlf np->flags == NUMERAL_RESERVED); 55938d483882Smlf } 55948d483882Smlf } 55958d483882Smlf 55968d483882Smlf /* NOT on list, so add it */ 55978d483882Smlf np = s_malloc(sizeof (numeral_t)); 55988d483882Smlf np->id = s_strdup(numeral_id); 55998d483882Smlf np->full_path = NULL; 56008d483882Smlf np->rule_index = 0; 56018d483882Smlf np->cmp_str = NULL; 56028d483882Smlf np->flags = NUMERAL_RESERVED; 56038d483882Smlf np->next = setp->headnumeral; 56048d483882Smlf setp->headnumeral = np; 56058d483882Smlf 56068d483882Smlf vprint(RSRV_MID, "Reserved numeral ID: %s\n", np->id); 56078d483882Smlf } 56088d483882Smlf 56097c478bd9Sstevel@tonic-gate /* 56107c478bd9Sstevel@tonic-gate * This function is called for every file which matched the leaf 56117c478bd9Sstevel@tonic-gate * component of the RE. If the "numeral_id" is not already on the 56127c478bd9Sstevel@tonic-gate * numeral set's numeral list, add it and its physical path. 56137c478bd9Sstevel@tonic-gate */ 56147c478bd9Sstevel@tonic-gate static void 56157c478bd9Sstevel@tonic-gate create_cached_numeral(char *path, numeral_set_t *setp, char *numeral_id, 56167c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[], int index) 56177c478bd9Sstevel@tonic-gate { 56187c478bd9Sstevel@tonic-gate char linkbuf[PATH_MAX + 1]; 56197c478bd9Sstevel@tonic-gate char lpath[PATH_MAX + 1]; 56207c478bd9Sstevel@tonic-gate char *linkptr, *cmp_str; 56217c478bd9Sstevel@tonic-gate numeral_t *np; 56227c478bd9Sstevel@tonic-gate int linksize; 56237c478bd9Sstevel@tonic-gate struct stat sb; 56247c478bd9Sstevel@tonic-gate const char *fcn = "create_cached_numeral"; 56257c478bd9Sstevel@tonic-gate 56267c478bd9Sstevel@tonic-gate assert(index >= 0 && index < setp->re_count); 56277c478bd9Sstevel@tonic-gate assert(strcmp(rules[index].re, setp->re[index]) == 0); 56287c478bd9Sstevel@tonic-gate 56297c478bd9Sstevel@tonic-gate /* 56307c478bd9Sstevel@tonic-gate * We found a numeral_id from an entry in /dev which matched 56317c478bd9Sstevel@tonic-gate * the re passed in from devfsadm_enumerate. We only need to make sure 56327c478bd9Sstevel@tonic-gate * ONE copy of numeral_id exists on the numeral list. We only need 56337c478bd9Sstevel@tonic-gate * to store /dev/dsk/cNtod0s0 and no other entries hanging off 56347c478bd9Sstevel@tonic-gate * of controller N. 56357c478bd9Sstevel@tonic-gate */ 56367c478bd9Sstevel@tonic-gate for (np = setp->headnumeral; np != NULL; np = np->next) { 56378d483882Smlf assert(np->flags == 0 || np->flags == NUMERAL_RESERVED); 56387c478bd9Sstevel@tonic-gate if (strcmp(numeral_id, np->id) == 0) { 56398d483882Smlf /* 56408d483882Smlf * Note that we can't assert that the flags field 56418d483882Smlf * of the numeral is 0, since both reserved and 56428d483882Smlf * unreserved links in /dev come here 56438d483882Smlf */ 56448d483882Smlf if (np->flags == NUMERAL_RESERVED) { 56458d483882Smlf vprint(RSRV_MID, "ID derived from /dev link is" 56468d483882Smlf " reserved: %s\n", np->id); 56478d483882Smlf } else { 56488d483882Smlf vprint(RSRV_MID, "ID derived from /dev link is" 56498d483882Smlf " NOT reserved: %s\n", np->id); 56508d483882Smlf } 56517c478bd9Sstevel@tonic-gate return; 56527c478bd9Sstevel@tonic-gate } 56537c478bd9Sstevel@tonic-gate } 56547c478bd9Sstevel@tonic-gate 56557c478bd9Sstevel@tonic-gate /* NOT on list, so add it */ 56567c478bd9Sstevel@tonic-gate 56577c478bd9Sstevel@tonic-gate (void) strcpy(lpath, path); 56587c478bd9Sstevel@tonic-gate /* 56597c478bd9Sstevel@tonic-gate * If path is a dir, it is changed to the first symbolic link it find 56607c478bd9Sstevel@tonic-gate * if it finds one. 56617c478bd9Sstevel@tonic-gate */ 56627c478bd9Sstevel@tonic-gate if (get_stat_info(lpath, &sb) == DEVFSADM_FAILURE) { 56637c478bd9Sstevel@tonic-gate return; 56647c478bd9Sstevel@tonic-gate } 56657c478bd9Sstevel@tonic-gate 56667c478bd9Sstevel@tonic-gate /* If we get here, we found a symlink */ 56677c478bd9Sstevel@tonic-gate linksize = readlink(lpath, linkbuf, PATH_MAX); 56687c478bd9Sstevel@tonic-gate 56697c478bd9Sstevel@tonic-gate if (linksize <= 0) { 56707c478bd9Sstevel@tonic-gate err_print(READLINK_FAILED, fcn, lpath, strerror(errno)); 56717c478bd9Sstevel@tonic-gate return; 56727c478bd9Sstevel@tonic-gate } 56737c478bd9Sstevel@tonic-gate 56747c478bd9Sstevel@tonic-gate linkbuf[linksize] = '\0'; 56757c478bd9Sstevel@tonic-gate 56767c478bd9Sstevel@tonic-gate /* 56777c478bd9Sstevel@tonic-gate * the following just points linkptr to the root of the /devices 56787c478bd9Sstevel@tonic-gate * node if it is a minor node, otherwise, to the first char of 56797c478bd9Sstevel@tonic-gate * linkbuf if it is a link. 56807c478bd9Sstevel@tonic-gate */ 56817c478bd9Sstevel@tonic-gate (void) is_minor_node(linkbuf, &linkptr); 56827c478bd9Sstevel@tonic-gate 56837c478bd9Sstevel@tonic-gate cmp_str = alloc_cmp_str(linkptr, &rules[index]); 56847c478bd9Sstevel@tonic-gate if (cmp_str == NULL) { 56857c478bd9Sstevel@tonic-gate return; 56867c478bd9Sstevel@tonic-gate } 56877c478bd9Sstevel@tonic-gate 56887c478bd9Sstevel@tonic-gate np = s_malloc(sizeof (numeral_t)); 56897c478bd9Sstevel@tonic-gate 56907c478bd9Sstevel@tonic-gate np->id = s_strdup(numeral_id); 56917c478bd9Sstevel@tonic-gate np->full_path = s_strdup(linkptr); 56927c478bd9Sstevel@tonic-gate np->rule_index = index; 56937c478bd9Sstevel@tonic-gate np->cmp_str = cmp_str; 56948d483882Smlf np->flags = 0; 56957c478bd9Sstevel@tonic-gate 56967c478bd9Sstevel@tonic-gate np->next = setp->headnumeral; 56977c478bd9Sstevel@tonic-gate setp->headnumeral = np; 56987c478bd9Sstevel@tonic-gate } 56997c478bd9Sstevel@tonic-gate 57007c478bd9Sstevel@tonic-gate 57017c478bd9Sstevel@tonic-gate /* 57027c478bd9Sstevel@tonic-gate * This should be called either before or after granting access to a 57037c478bd9Sstevel@tonic-gate * command line version of devfsadm running, since it may have changed 57047c478bd9Sstevel@tonic-gate * the state of /dev. It forces future enumerate calls to re-build 57057c478bd9Sstevel@tonic-gate * cached information from /dev. 57067c478bd9Sstevel@tonic-gate */ 57077c478bd9Sstevel@tonic-gate void 57087c478bd9Sstevel@tonic-gate invalidate_enumerate_cache(void) 57097c478bd9Sstevel@tonic-gate { 57107c478bd9Sstevel@tonic-gate numeral_set_t *setp; 57117c478bd9Sstevel@tonic-gate numeral_set_t *savedsetp; 57127c478bd9Sstevel@tonic-gate numeral_t *savednumset; 57137c478bd9Sstevel@tonic-gate numeral_t *numset; 57147c478bd9Sstevel@tonic-gate int i; 57157c478bd9Sstevel@tonic-gate 57167c478bd9Sstevel@tonic-gate for (setp = head_numeral_set; setp != NULL; ) { 57177c478bd9Sstevel@tonic-gate /* 57187c478bd9Sstevel@tonic-gate * check all regexp's passed in function against 57197c478bd9Sstevel@tonic-gate * those in cached set. 57207c478bd9Sstevel@tonic-gate */ 57217c478bd9Sstevel@tonic-gate 57227c478bd9Sstevel@tonic-gate savedsetp = setp; 57237c478bd9Sstevel@tonic-gate setp = setp->next; 57247c478bd9Sstevel@tonic-gate 57257c478bd9Sstevel@tonic-gate for (i = 0; i < savedsetp->re_count; i++) { 57267c478bd9Sstevel@tonic-gate free(savedsetp->re[i]); 57277c478bd9Sstevel@tonic-gate } 57287c478bd9Sstevel@tonic-gate free(savedsetp->re); 57297c478bd9Sstevel@tonic-gate 57307c478bd9Sstevel@tonic-gate for (numset = savedsetp->headnumeral; numset != NULL; ) { 57317c478bd9Sstevel@tonic-gate savednumset = numset; 57327c478bd9Sstevel@tonic-gate numset = numset->next; 57337c478bd9Sstevel@tonic-gate assert(savednumset->rule_index < savedsetp->re_count); 57347c478bd9Sstevel@tonic-gate free(savednumset->id); 57357c478bd9Sstevel@tonic-gate free(savednumset->full_path); 57367c478bd9Sstevel@tonic-gate free(savednumset->cmp_str); 57377c478bd9Sstevel@tonic-gate free(savednumset); 57387c478bd9Sstevel@tonic-gate } 57397c478bd9Sstevel@tonic-gate free(savedsetp); 57407c478bd9Sstevel@tonic-gate } 57417c478bd9Sstevel@tonic-gate head_numeral_set = NULL; 57427c478bd9Sstevel@tonic-gate } 57437c478bd9Sstevel@tonic-gate 57447c478bd9Sstevel@tonic-gate /* 57457c478bd9Sstevel@tonic-gate * Copies over links from /dev to <root>/dev and device special files in 57467c478bd9Sstevel@tonic-gate * /devices to <root>/devices, preserving the existing file modes. If 57477c478bd9Sstevel@tonic-gate * the link or special file already exists on <root>, skip the copy. (it 57487c478bd9Sstevel@tonic-gate * would exist only if a package hard coded it there, so assume package 57497c478bd9Sstevel@tonic-gate * knows best?). Use /etc/name_to_major and <root>/etc/name_to_major to 57507c478bd9Sstevel@tonic-gate * make translations for major numbers on device special files. No need to 57517c478bd9Sstevel@tonic-gate * make a translation on minor_perm since if the file was created in the 57527c478bd9Sstevel@tonic-gate * miniroot then it would presumably have the same minor_perm entry in 57537c478bd9Sstevel@tonic-gate * <root>/etc/minor_perm. To be used only by install. 57547c478bd9Sstevel@tonic-gate */ 57557c478bd9Sstevel@tonic-gate int 57567c478bd9Sstevel@tonic-gate devfsadm_copy(void) 57577c478bd9Sstevel@tonic-gate { 57587c478bd9Sstevel@tonic-gate char filename[PATH_MAX + 1]; 57597c478bd9Sstevel@tonic-gate 57607c478bd9Sstevel@tonic-gate /* load the installed root's name_to_major for translations */ 57617c478bd9Sstevel@tonic-gate (void) snprintf(filename, sizeof (filename), "%s%s", root_dir, 57627c478bd9Sstevel@tonic-gate NAME_TO_MAJOR); 57637c478bd9Sstevel@tonic-gate if (load_n2m_table(filename) == DEVFSADM_FAILURE) { 57647c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 57657c478bd9Sstevel@tonic-gate } 57667c478bd9Sstevel@tonic-gate 57677c478bd9Sstevel@tonic-gate /* Copy /dev to target disk. No need to copy /devices with devfs */ 57687c478bd9Sstevel@tonic-gate (void) nftw(DEV, devfsadm_copy_file, 20, FTW_PHYS); 57697c478bd9Sstevel@tonic-gate 57707c478bd9Sstevel@tonic-gate /* Let install handle copying over path_to_inst */ 57717c478bd9Sstevel@tonic-gate 57727c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 57737c478bd9Sstevel@tonic-gate } 57747c478bd9Sstevel@tonic-gate 57757c478bd9Sstevel@tonic-gate /* 57767c478bd9Sstevel@tonic-gate * This function copies links, dirs, and device special files. 57777c478bd9Sstevel@tonic-gate * Note that it always returns DEVFSADM_SUCCESS, so that nftw doesn't 57787c478bd9Sstevel@tonic-gate * abort. 57797c478bd9Sstevel@tonic-gate */ 57807c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 57817c478bd9Sstevel@tonic-gate static int 57827c478bd9Sstevel@tonic-gate devfsadm_copy_file(const char *file, const struct stat *stat, 57837c478bd9Sstevel@tonic-gate int flags, struct FTW *ftw) 57847c478bd9Sstevel@tonic-gate { 57857c478bd9Sstevel@tonic-gate struct stat sp; 57867c478bd9Sstevel@tonic-gate dev_t newdev; 57877c478bd9Sstevel@tonic-gate char newfile[PATH_MAX + 1]; 57887c478bd9Sstevel@tonic-gate char linkcontents[PATH_MAX + 1]; 57897c478bd9Sstevel@tonic-gate int bytes; 57907c478bd9Sstevel@tonic-gate const char *fcn = "devfsadm_copy_file"; 57917c478bd9Sstevel@tonic-gate 57927c478bd9Sstevel@tonic-gate (void) strcpy(newfile, root_dir); 57937c478bd9Sstevel@tonic-gate (void) strcat(newfile, "/"); 57947c478bd9Sstevel@tonic-gate (void) strcat(newfile, file); 57957c478bd9Sstevel@tonic-gate 57967c478bd9Sstevel@tonic-gate if (lstat(newfile, &sp) == 0) { 57977c478bd9Sstevel@tonic-gate /* newfile already exists, so no need to continue */ 57987c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 57997c478bd9Sstevel@tonic-gate } 58007c478bd9Sstevel@tonic-gate 58017c478bd9Sstevel@tonic-gate if (((stat->st_mode & S_IFMT) == S_IFBLK) || 58027c478bd9Sstevel@tonic-gate ((stat->st_mode & S_IFMT) == S_IFCHR)) { 58037c478bd9Sstevel@tonic-gate if (translate_major(stat->st_rdev, &newdev) == 58047c478bd9Sstevel@tonic-gate DEVFSADM_FAILURE) { 58057c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 58067c478bd9Sstevel@tonic-gate } 58077c478bd9Sstevel@tonic-gate if (mknod(newfile, stat->st_mode, newdev) == -1) { 58087c478bd9Sstevel@tonic-gate err_print(MKNOD_FAILED, newfile, strerror(errno)); 58097c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 58107c478bd9Sstevel@tonic-gate } 58117c478bd9Sstevel@tonic-gate } else if ((stat->st_mode & S_IFMT) == S_IFDIR) { 58127c478bd9Sstevel@tonic-gate if (mknod(newfile, stat->st_mode, 0) == -1) { 58137c478bd9Sstevel@tonic-gate err_print(MKNOD_FAILED, newfile, strerror(errno)); 58147c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 58157c478bd9Sstevel@tonic-gate } 58167c478bd9Sstevel@tonic-gate } else if ((stat->st_mode & S_IFMT) == S_IFLNK) { 58177c478bd9Sstevel@tonic-gate if ((bytes = readlink(file, linkcontents, PATH_MAX)) == -1) { 58187c478bd9Sstevel@tonic-gate err_print(READLINK_FAILED, fcn, file, strerror(errno)); 58197c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 58207c478bd9Sstevel@tonic-gate } 58217c478bd9Sstevel@tonic-gate linkcontents[bytes] = '\0'; 58227c478bd9Sstevel@tonic-gate if (symlink(linkcontents, newfile) == -1) { 58237c478bd9Sstevel@tonic-gate err_print(SYMLINK_FAILED, newfile, newfile, 58240a653502Swroche strerror(errno)); 58257c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 58267c478bd9Sstevel@tonic-gate } 58277c478bd9Sstevel@tonic-gate } 58287c478bd9Sstevel@tonic-gate 58297c478bd9Sstevel@tonic-gate (void) lchown(newfile, stat->st_uid, stat->st_gid); 58307c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 58317c478bd9Sstevel@tonic-gate } 58327c478bd9Sstevel@tonic-gate 58337c478bd9Sstevel@tonic-gate /* 58347c478bd9Sstevel@tonic-gate * Given a dev_t from the running kernel, return the new_dev_t 58357c478bd9Sstevel@tonic-gate * by translating to the major number found on the installed 58367c478bd9Sstevel@tonic-gate * target's root name_to_major file. 58377c478bd9Sstevel@tonic-gate */ 58387c478bd9Sstevel@tonic-gate static int 58397c478bd9Sstevel@tonic-gate translate_major(dev_t old_dev, dev_t *new_dev) 58407c478bd9Sstevel@tonic-gate { 58417c478bd9Sstevel@tonic-gate major_t oldmajor; 58427c478bd9Sstevel@tonic-gate major_t newmajor; 58437c478bd9Sstevel@tonic-gate minor_t oldminor; 58447c478bd9Sstevel@tonic-gate minor_t newminor; 58457c478bd9Sstevel@tonic-gate char cdriver[FILENAME_MAX + 1]; 58467c478bd9Sstevel@tonic-gate char driver[FILENAME_MAX + 1]; 58477c478bd9Sstevel@tonic-gate char *fcn = "translate_major: "; 58487c478bd9Sstevel@tonic-gate 58497c478bd9Sstevel@tonic-gate oldmajor = major(old_dev); 58500a653502Swroche if (modctl(MODGETNAME, driver, sizeof (driver), &oldmajor) != 0) { 58517c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 58527c478bd9Sstevel@tonic-gate } 58537c478bd9Sstevel@tonic-gate 58547c478bd9Sstevel@tonic-gate if (strcmp(driver, "clone") != 0) { 58557c478bd9Sstevel@tonic-gate /* non-clone case */ 58567c478bd9Sstevel@tonic-gate 58577c478bd9Sstevel@tonic-gate /* look up major number is target's name2major */ 58587c478bd9Sstevel@tonic-gate if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) { 58597c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 58607c478bd9Sstevel@tonic-gate } 58617c478bd9Sstevel@tonic-gate 58627c478bd9Sstevel@tonic-gate *new_dev = makedev(newmajor, minor(old_dev)); 58637c478bd9Sstevel@tonic-gate if (old_dev != *new_dev) { 58647c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%sdriver: %s old: %lu,%lu " 58650a653502Swroche "new: %lu,%lu\n", fcn, driver, major(old_dev), 58660a653502Swroche minor(old_dev), major(*new_dev), minor(*new_dev)); 58677c478bd9Sstevel@tonic-gate } 58687c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 58697c478bd9Sstevel@tonic-gate } else { 58707c478bd9Sstevel@tonic-gate /* 58717c478bd9Sstevel@tonic-gate * The clone is a special case. Look at its minor 58727c478bd9Sstevel@tonic-gate * number since it is the major number of the real driver. 58737c478bd9Sstevel@tonic-gate */ 58747c478bd9Sstevel@tonic-gate if (get_major_no(driver, &newmajor) == DEVFSADM_FAILURE) { 58757c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 58767c478bd9Sstevel@tonic-gate } 58777c478bd9Sstevel@tonic-gate 58787c478bd9Sstevel@tonic-gate oldminor = minor(old_dev); 58797c478bd9Sstevel@tonic-gate if (modctl(MODGETNAME, cdriver, sizeof (cdriver), 58800a653502Swroche &oldminor) != 0) { 58817c478bd9Sstevel@tonic-gate err_print(MODGETNAME_FAILED, oldminor); 58827c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 58837c478bd9Sstevel@tonic-gate } 58847c478bd9Sstevel@tonic-gate 58857c478bd9Sstevel@tonic-gate if (get_major_no(cdriver, &newminor) == DEVFSADM_FAILURE) { 58867c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 58877c478bd9Sstevel@tonic-gate } 58887c478bd9Sstevel@tonic-gate 58897c478bd9Sstevel@tonic-gate *new_dev = makedev(newmajor, newminor); 58907c478bd9Sstevel@tonic-gate if (old_dev != *new_dev) { 58917c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "%sdriver: %s old: " 58920a653502Swroche "%lu,%lu new: %lu,%lu\n", fcn, driver, 58930a653502Swroche major(old_dev), minor(old_dev), 58940a653502Swroche major(*new_dev), minor(*new_dev)); 58957c478bd9Sstevel@tonic-gate } 58967c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 58977c478bd9Sstevel@tonic-gate } 58987c478bd9Sstevel@tonic-gate } 58997c478bd9Sstevel@tonic-gate 59007c478bd9Sstevel@tonic-gate /* 59017c478bd9Sstevel@tonic-gate * 59027c478bd9Sstevel@tonic-gate * Find the major number for driver, searching the n2m_list that was 59037c478bd9Sstevel@tonic-gate * built in load_n2m_table(). 59047c478bd9Sstevel@tonic-gate */ 59057c478bd9Sstevel@tonic-gate static int 59067c478bd9Sstevel@tonic-gate get_major_no(char *driver, major_t *major) 59077c478bd9Sstevel@tonic-gate { 59087c478bd9Sstevel@tonic-gate n2m_t *ptr; 59097c478bd9Sstevel@tonic-gate 59107c478bd9Sstevel@tonic-gate for (ptr = n2m_list; ptr != NULL; ptr = ptr->next) { 59117c478bd9Sstevel@tonic-gate if (strcmp(ptr->driver, driver) == 0) { 59127c478bd9Sstevel@tonic-gate *major = ptr->major; 59137c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 59147c478bd9Sstevel@tonic-gate } 59157c478bd9Sstevel@tonic-gate } 59167c478bd9Sstevel@tonic-gate err_print(FIND_MAJOR_FAILED, driver); 59177c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 59187c478bd9Sstevel@tonic-gate } 59197c478bd9Sstevel@tonic-gate 59207c478bd9Sstevel@tonic-gate /* 59217c478bd9Sstevel@tonic-gate * Loads a name_to_major table into memory. Used only for suninstall's 59227c478bd9Sstevel@tonic-gate * private -R option to devfsadm, to translate major numbers from the 59237c478bd9Sstevel@tonic-gate * running to the installed target disk. 59247c478bd9Sstevel@tonic-gate */ 59257c478bd9Sstevel@tonic-gate static int 59267c478bd9Sstevel@tonic-gate load_n2m_table(char *file) 59277c478bd9Sstevel@tonic-gate { 59287c478bd9Sstevel@tonic-gate FILE *fp; 59291ca93273Seota char line[1024], *cp; 59307c478bd9Sstevel@tonic-gate char driver[PATH_MAX + 1]; 59317c478bd9Sstevel@tonic-gate major_t major; 59327c478bd9Sstevel@tonic-gate n2m_t *ptr; 59337c478bd9Sstevel@tonic-gate int ln = 0; 59347c478bd9Sstevel@tonic-gate 59357c478bd9Sstevel@tonic-gate if ((fp = fopen(file, "r")) == NULL) { 59367c478bd9Sstevel@tonic-gate err_print(FOPEN_FAILED, file, strerror(errno)); 59377c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 59387c478bd9Sstevel@tonic-gate } 59397c478bd9Sstevel@tonic-gate 59407c478bd9Sstevel@tonic-gate while (fgets(line, sizeof (line), fp) != NULL) { 59417c478bd9Sstevel@tonic-gate ln++; 59421ca93273Seota /* cut off comments starting with '#' */ 59431ca93273Seota if ((cp = strchr(line, '#')) != NULL) 59441ca93273Seota *cp = '\0'; 59451ca93273Seota /* ignore comment or blank lines */ 59461ca93273Seota if (is_blank(line)) 59477c478bd9Sstevel@tonic-gate continue; 59481ca93273Seota /* sanity-check */ 59497c478bd9Sstevel@tonic-gate if (sscanf(line, "%1024s%lu", driver, &major) != 2) { 59507c478bd9Sstevel@tonic-gate err_print(IGNORING_LINE_IN, ln, file); 59517c478bd9Sstevel@tonic-gate continue; 59527c478bd9Sstevel@tonic-gate } 59537c478bd9Sstevel@tonic-gate ptr = (n2m_t *)s_malloc(sizeof (n2m_t)); 59547c478bd9Sstevel@tonic-gate ptr->major = major; 59557c478bd9Sstevel@tonic-gate ptr->driver = s_strdup(driver); 59567c478bd9Sstevel@tonic-gate ptr->next = n2m_list; 59577c478bd9Sstevel@tonic-gate n2m_list = ptr; 59587c478bd9Sstevel@tonic-gate } 59597c478bd9Sstevel@tonic-gate if (fclose(fp) == EOF) { 59607c478bd9Sstevel@tonic-gate err_print(FCLOSE_FAILED, file, strerror(errno)); 59617c478bd9Sstevel@tonic-gate } 59627c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 59637c478bd9Sstevel@tonic-gate } 59647c478bd9Sstevel@tonic-gate 59658d483882Smlf /* 59668d483882Smlf * Called at devfsadm startup to read the file /etc/dev/enumerate_reserved 59678d483882Smlf * Creates a linked list of devlinks from which reserved IDs can be derived 59688d483882Smlf */ 59698d483882Smlf static void 59708d483882Smlf read_enumerate_file(void) 59718d483882Smlf { 59728d483882Smlf FILE *fp; 59738d483882Smlf int linenum; 59748d483882Smlf char line[PATH_MAX+1]; 59758d483882Smlf enumerate_file_t *entry; 59768d483882Smlf struct stat current_sb; 59778d483882Smlf static struct stat cached_sb; 59788d483882Smlf static int cached = FALSE; 59798d483882Smlf 59808d483882Smlf assert(enumerate_file); 59818d483882Smlf 59828d483882Smlf if (stat(enumerate_file, ¤t_sb) == -1) { 59838d483882Smlf vprint(RSRV_MID, "No reserved file: %s\n", enumerate_file); 59848d483882Smlf cached = FALSE; 59858d483882Smlf if (enumerate_reserved != NULL) { 59868d483882Smlf vprint(RSRV_MID, "invalidating %s cache\n", 59878d483882Smlf enumerate_file); 59888d483882Smlf } 59898d483882Smlf while (enumerate_reserved != NULL) { 59908d483882Smlf entry = enumerate_reserved; 59918d483882Smlf enumerate_reserved = entry->er_next; 59928d483882Smlf free(entry->er_file); 59938d483882Smlf free(entry->er_id); 59948d483882Smlf free(entry); 59958d483882Smlf } 59968d483882Smlf return; 59978d483882Smlf } 59988d483882Smlf 59998d483882Smlf /* if already cached, check to see if it is still valid */ 60008d483882Smlf if (cached == TRUE) { 60018d483882Smlf 60028d483882Smlf if (current_sb.st_mtime == cached_sb.st_mtime) { 60038d483882Smlf vprint(RSRV_MID, "%s cache valid\n", enumerate_file); 60048d483882Smlf vprint(FILES_MID, "%s cache valid\n", enumerate_file); 60058d483882Smlf return; 60068d483882Smlf } 60078d483882Smlf 60088d483882Smlf vprint(RSRV_MID, "invalidating %s cache\n", enumerate_file); 60098d483882Smlf vprint(FILES_MID, "invalidating %s cache\n", enumerate_file); 60108d483882Smlf 60118d483882Smlf while (enumerate_reserved != NULL) { 60128d483882Smlf entry = enumerate_reserved; 60138d483882Smlf enumerate_reserved = entry->er_next; 60148d483882Smlf free(entry->er_file); 60158d483882Smlf free(entry->er_id); 60168d483882Smlf free(entry); 60178d483882Smlf } 60188d483882Smlf vprint(RSRV_MID, "Recaching file: %s\n", enumerate_file); 60198d483882Smlf } else { 60208d483882Smlf vprint(RSRV_MID, "Caching file (first time): %s\n", 60218d483882Smlf enumerate_file); 60228d483882Smlf cached = TRUE; 60238d483882Smlf } 60248d483882Smlf 60258d483882Smlf (void) stat(enumerate_file, &cached_sb); 60268d483882Smlf 60278d483882Smlf if ((fp = fopen(enumerate_file, "r")) == NULL) { 60288d483882Smlf err_print(FOPEN_FAILED, enumerate_file, strerror(errno)); 60298d483882Smlf return; 60308d483882Smlf } 60318d483882Smlf 60328d483882Smlf vprint(RSRV_MID, "Reading reserve file: %s\n", enumerate_file); 60338d483882Smlf linenum = 0; 60348d483882Smlf while (fgets(line, sizeof (line), fp) != NULL) { 60358d483882Smlf char *cp, *ncp; 60368d483882Smlf 60378d483882Smlf linenum++; 60388d483882Smlf 60398d483882Smlf /* remove newline */ 60408d483882Smlf cp = strchr(line, '\n'); 60418d483882Smlf if (cp) 60428d483882Smlf *cp = '\0'; 60438d483882Smlf 60440a653502Swroche vprint(RSRV_MID, "Reserve file: line %d: %s\n", linenum, line); 60458d483882Smlf 60468d483882Smlf /* skip over space and tab */ 60470a653502Swroche for (cp = line; *cp == ' ' || *cp == '\t'; cp++) 60480a653502Swroche ; 60498d483882Smlf 60508d483882Smlf if (*cp == '\0' || *cp == '#') { 60518d483882Smlf vprint(RSRV_MID, "Skipping line: '%s'\n", line); 60528d483882Smlf continue; /* blank line or comment line */ 60538d483882Smlf } 60548d483882Smlf 60558d483882Smlf ncp = cp; 60568d483882Smlf 60578d483882Smlf /* delete trailing blanks */ 60580a653502Swroche for (; *cp != ' ' && *cp != '\t' && *cp != '\0'; cp++) 60590a653502Swroche ; 60608d483882Smlf *cp = '\0'; 60618d483882Smlf 60628d483882Smlf entry = s_zalloc(sizeof (enumerate_file_t)); 60638d483882Smlf entry->er_file = s_strdup(ncp); 60648d483882Smlf entry->er_id = NULL; 60658d483882Smlf entry->er_next = enumerate_reserved; 60668d483882Smlf enumerate_reserved = entry; 60678d483882Smlf } 60688d483882Smlf 60698d483882Smlf if (fclose(fp) == EOF) { 60708d483882Smlf err_print(FCLOSE_FAILED, enumerate_file, strerror(errno)); 60718d483882Smlf } 60728d483882Smlf } 60738d483882Smlf 60747c478bd9Sstevel@tonic-gate /* 60757c478bd9Sstevel@tonic-gate * Called at devfsadm startup to read in the devlink.tab file. Creates 60767c478bd9Sstevel@tonic-gate * a linked list of devlinktab_list structures which will be 60777c478bd9Sstevel@tonic-gate * searched for every minor node. 60787c478bd9Sstevel@tonic-gate */ 60797c478bd9Sstevel@tonic-gate static void 60807c478bd9Sstevel@tonic-gate read_devlinktab_file(void) 60817c478bd9Sstevel@tonic-gate { 60827c478bd9Sstevel@tonic-gate devlinktab_list_t *headp = NULL; 60837c478bd9Sstevel@tonic-gate devlinktab_list_t *entryp; 60847c478bd9Sstevel@tonic-gate devlinktab_list_t **previous; 60857c478bd9Sstevel@tonic-gate devlinktab_list_t *save; 60861ca93273Seota char line[MAX_DEVLINK_LINE], *cp; 60877c478bd9Sstevel@tonic-gate char *selector; 60887c478bd9Sstevel@tonic-gate char *p_link; 60897c478bd9Sstevel@tonic-gate char *s_link; 60907c478bd9Sstevel@tonic-gate FILE *fp; 60917c478bd9Sstevel@tonic-gate int i; 60927c478bd9Sstevel@tonic-gate static struct stat cached_sb; 60937c478bd9Sstevel@tonic-gate struct stat current_sb; 60947c478bd9Sstevel@tonic-gate static int cached = FALSE; 60957c478bd9Sstevel@tonic-gate 60967c478bd9Sstevel@tonic-gate if (devlinktab_file == NULL) { 60977c478bd9Sstevel@tonic-gate return; 60987c478bd9Sstevel@tonic-gate } 60997c478bd9Sstevel@tonic-gate 61007c478bd9Sstevel@tonic-gate (void) stat(devlinktab_file, ¤t_sb); 61017c478bd9Sstevel@tonic-gate 61027c478bd9Sstevel@tonic-gate /* if already cached, check to see if it is still valid */ 61037c478bd9Sstevel@tonic-gate if (cached == TRUE) { 61047c478bd9Sstevel@tonic-gate 61057c478bd9Sstevel@tonic-gate if (current_sb.st_mtime == cached_sb.st_mtime) { 61067c478bd9Sstevel@tonic-gate vprint(FILES_MID, "%s cache valid\n", devlinktab_file); 61077c478bd9Sstevel@tonic-gate return; 61087c478bd9Sstevel@tonic-gate } 61097c478bd9Sstevel@tonic-gate 61107c478bd9Sstevel@tonic-gate vprint(FILES_MID, "invalidating %s cache\n", devlinktab_file); 61117c478bd9Sstevel@tonic-gate 61127c478bd9Sstevel@tonic-gate while (devlinktab_list != NULL) { 61137c478bd9Sstevel@tonic-gate free_link_list(devlinktab_list->p_link); 61147c478bd9Sstevel@tonic-gate free_link_list(devlinktab_list->s_link); 61157c478bd9Sstevel@tonic-gate free_selector_list(devlinktab_list->selector); 61167c478bd9Sstevel@tonic-gate free(devlinktab_list->selector_pattern); 61177c478bd9Sstevel@tonic-gate free(devlinktab_list->p_link_pattern); 61187c478bd9Sstevel@tonic-gate if (devlinktab_list->s_link_pattern != NULL) { 61197c478bd9Sstevel@tonic-gate free(devlinktab_list->s_link_pattern); 61207c478bd9Sstevel@tonic-gate } 61217c478bd9Sstevel@tonic-gate save = devlinktab_list; 61227c478bd9Sstevel@tonic-gate devlinktab_list = devlinktab_list->next; 61237c478bd9Sstevel@tonic-gate free(save); 61247c478bd9Sstevel@tonic-gate } 61257c478bd9Sstevel@tonic-gate } else { 61267c478bd9Sstevel@tonic-gate cached = TRUE; 61277c478bd9Sstevel@tonic-gate } 61287c478bd9Sstevel@tonic-gate 61297c478bd9Sstevel@tonic-gate (void) stat(devlinktab_file, &cached_sb); 61307c478bd9Sstevel@tonic-gate 61317c478bd9Sstevel@tonic-gate if ((fp = fopen(devlinktab_file, "r")) == NULL) { 61327c478bd9Sstevel@tonic-gate err_print(FOPEN_FAILED, devlinktab_file, strerror(errno)); 61337c478bd9Sstevel@tonic-gate return; 61347c478bd9Sstevel@tonic-gate } 61357c478bd9Sstevel@tonic-gate 61367c478bd9Sstevel@tonic-gate previous = &headp; 61377c478bd9Sstevel@tonic-gate 61387c478bd9Sstevel@tonic-gate while (fgets(line, sizeof (line), fp) != NULL) { 61397c478bd9Sstevel@tonic-gate devlinktab_line++; 61407c478bd9Sstevel@tonic-gate i = strlen(line); 61417c478bd9Sstevel@tonic-gate if (line[i-1] == NEWLINE) { 61427c478bd9Sstevel@tonic-gate line[i-1] = '\0'; 61437c478bd9Sstevel@tonic-gate } else if (i == sizeof (line-1)) { 61447c478bd9Sstevel@tonic-gate err_print(LINE_TOO_LONG, devlinktab_line, 61457c478bd9Sstevel@tonic-gate devlinktab_file, sizeof (line)-1); 61460a653502Swroche while (((i = getc(fp)) != '\n') && (i != EOF)) 61470a653502Swroche ; 61487c478bd9Sstevel@tonic-gate continue; 61497c478bd9Sstevel@tonic-gate } 61507c478bd9Sstevel@tonic-gate 61511ca93273Seota /* cut off comments starting with '#' */ 61521ca93273Seota if ((cp = strchr(line, '#')) != NULL) 61531ca93273Seota *cp = '\0'; 61541ca93273Seota /* ignore comment or blank lines */ 61551ca93273Seota if (is_blank(line)) 61567c478bd9Sstevel@tonic-gate continue; 61577c478bd9Sstevel@tonic-gate 61587c478bd9Sstevel@tonic-gate vprint(DEVLINK_MID, "table: %s line %d: '%s'\n", 61590a653502Swroche devlinktab_file, devlinktab_line, line); 61607c478bd9Sstevel@tonic-gate 61617c478bd9Sstevel@tonic-gate /* break each entry into fields. s_link may be NULL */ 61627c478bd9Sstevel@tonic-gate if (split_devlinktab_entry(line, &selector, &p_link, 61637c478bd9Sstevel@tonic-gate &s_link) == DEVFSADM_FAILURE) { 61647c478bd9Sstevel@tonic-gate vprint(DEVLINK_MID, "split_entry returns failure\n"); 61657c478bd9Sstevel@tonic-gate continue; 61667c478bd9Sstevel@tonic-gate } else { 61677c478bd9Sstevel@tonic-gate vprint(DEVLINK_MID, "split_entry selector='%s' " 61680a653502Swroche "p_link='%s' s_link='%s'\n\n", selector, 61690a653502Swroche p_link, (s_link == NULL) ? "" : s_link); 61707c478bd9Sstevel@tonic-gate } 61717c478bd9Sstevel@tonic-gate 61720a653502Swroche entryp = 61730a653502Swroche (devlinktab_list_t *)s_malloc(sizeof (devlinktab_list_t)); 61747c478bd9Sstevel@tonic-gate 61757c478bd9Sstevel@tonic-gate entryp->line_number = devlinktab_line; 61767c478bd9Sstevel@tonic-gate 61770a653502Swroche if ((entryp->selector = create_selector_list(selector)) 61780a653502Swroche == NULL) { 61797c478bd9Sstevel@tonic-gate free(entryp); 61807c478bd9Sstevel@tonic-gate continue; 61817c478bd9Sstevel@tonic-gate } 61827c478bd9Sstevel@tonic-gate entryp->selector_pattern = s_strdup(selector); 61837c478bd9Sstevel@tonic-gate 61847c478bd9Sstevel@tonic-gate if ((entryp->p_link = create_link_list(p_link)) == NULL) { 61857c478bd9Sstevel@tonic-gate free_selector_list(entryp->selector); 61867c478bd9Sstevel@tonic-gate free(entryp->selector_pattern); 61877c478bd9Sstevel@tonic-gate free(entryp); 61887c478bd9Sstevel@tonic-gate continue; 61897c478bd9Sstevel@tonic-gate } 61907c478bd9Sstevel@tonic-gate 61917c478bd9Sstevel@tonic-gate entryp->p_link_pattern = s_strdup(p_link); 61927c478bd9Sstevel@tonic-gate 61937c478bd9Sstevel@tonic-gate if (s_link != NULL) { 61947c478bd9Sstevel@tonic-gate if ((entryp->s_link = 61957c478bd9Sstevel@tonic-gate create_link_list(s_link)) == NULL) { 61967c478bd9Sstevel@tonic-gate free_selector_list(entryp->selector); 61977c478bd9Sstevel@tonic-gate free_link_list(entryp->p_link); 61987c478bd9Sstevel@tonic-gate free(entryp->selector_pattern); 61997c478bd9Sstevel@tonic-gate free(entryp->p_link_pattern); 62007c478bd9Sstevel@tonic-gate free(entryp); 62017c478bd9Sstevel@tonic-gate continue; 62027c478bd9Sstevel@tonic-gate } 62030a653502Swroche entryp->s_link_pattern = s_strdup(s_link); 62047c478bd9Sstevel@tonic-gate } else { 62057c478bd9Sstevel@tonic-gate entryp->s_link = NULL; 62067c478bd9Sstevel@tonic-gate entryp->s_link_pattern = NULL; 62077c478bd9Sstevel@tonic-gate 62087c478bd9Sstevel@tonic-gate } 62097c478bd9Sstevel@tonic-gate 62107c478bd9Sstevel@tonic-gate /* append to end of list */ 62117c478bd9Sstevel@tonic-gate 62127c478bd9Sstevel@tonic-gate entryp->next = NULL; 62137c478bd9Sstevel@tonic-gate *previous = entryp; 62147c478bd9Sstevel@tonic-gate previous = &(entryp->next); 62157c478bd9Sstevel@tonic-gate } 62167c478bd9Sstevel@tonic-gate if (fclose(fp) == EOF) { 62177c478bd9Sstevel@tonic-gate err_print(FCLOSE_FAILED, devlinktab_file, strerror(errno)); 62187c478bd9Sstevel@tonic-gate } 62197c478bd9Sstevel@tonic-gate devlinktab_list = headp; 62207c478bd9Sstevel@tonic-gate } 62217c478bd9Sstevel@tonic-gate 62227c478bd9Sstevel@tonic-gate /* 62237c478bd9Sstevel@tonic-gate * 62247c478bd9Sstevel@tonic-gate * For a single line entry in devlink.tab, split the line into fields 62257c478bd9Sstevel@tonic-gate * selector, p_link, and an optionally s_link. If s_link field is not 62267c478bd9Sstevel@tonic-gate * present, then return NULL in s_link (not NULL string). 62277c478bd9Sstevel@tonic-gate */ 62287c478bd9Sstevel@tonic-gate static int 62297c478bd9Sstevel@tonic-gate split_devlinktab_entry(char *entry, char **selector, char **p_link, 62307c478bd9Sstevel@tonic-gate char **s_link) 62317c478bd9Sstevel@tonic-gate { 62327c478bd9Sstevel@tonic-gate char *tab; 62337c478bd9Sstevel@tonic-gate 62347c478bd9Sstevel@tonic-gate *selector = entry; 62357c478bd9Sstevel@tonic-gate 62367c478bd9Sstevel@tonic-gate if ((tab = strchr(entry, TAB)) != NULL) { 62377c478bd9Sstevel@tonic-gate *tab = '\0'; 62387c478bd9Sstevel@tonic-gate *p_link = ++tab; 62397c478bd9Sstevel@tonic-gate } else { 62407c478bd9Sstevel@tonic-gate err_print(MISSING_TAB, devlinktab_line, devlinktab_file); 62417c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 62427c478bd9Sstevel@tonic-gate } 62437c478bd9Sstevel@tonic-gate 62447c478bd9Sstevel@tonic-gate if (*p_link == '\0') { 62457c478bd9Sstevel@tonic-gate err_print(MISSING_DEVNAME, devlinktab_line, devlinktab_file); 62467c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 62477c478bd9Sstevel@tonic-gate } 62487c478bd9Sstevel@tonic-gate 62497c478bd9Sstevel@tonic-gate if ((tab = strchr(*p_link, TAB)) != NULL) { 62507c478bd9Sstevel@tonic-gate *tab = '\0'; 62517c478bd9Sstevel@tonic-gate *s_link = ++tab; 62527c478bd9Sstevel@tonic-gate if (strchr(*s_link, TAB) != NULL) { 62537c478bd9Sstevel@tonic-gate err_print(TOO_MANY_FIELDS, devlinktab_line, 62540a653502Swroche devlinktab_file); 62557c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 62567c478bd9Sstevel@tonic-gate } 62577c478bd9Sstevel@tonic-gate } else { 62587c478bd9Sstevel@tonic-gate *s_link = NULL; 62597c478bd9Sstevel@tonic-gate } 62607c478bd9Sstevel@tonic-gate 62617c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 62627c478bd9Sstevel@tonic-gate } 62637c478bd9Sstevel@tonic-gate 62647c478bd9Sstevel@tonic-gate /* 62657c478bd9Sstevel@tonic-gate * For a given devfs_spec field, for each element in the field, add it to 62667c478bd9Sstevel@tonic-gate * a linked list of devfs_spec structures. Return the linked list in 62677c478bd9Sstevel@tonic-gate * devfs_spec_list. 62687c478bd9Sstevel@tonic-gate */ 62697c478bd9Sstevel@tonic-gate static selector_list_t * 62707c478bd9Sstevel@tonic-gate create_selector_list(char *selector) 62717c478bd9Sstevel@tonic-gate { 62720a653502Swroche char *key; 62730a653502Swroche char *val; 62740a653502Swroche int error = FALSE; 62750a653502Swroche selector_list_t *head_selector_list = NULL; 62760a653502Swroche selector_list_t *selector_list; 62770a653502Swroche 62780a653502Swroche /* parse_devfs_spec splits the next field into keyword & value */ 62790a653502Swroche while ((*selector != NULL) && (error == FALSE)) { 62800a653502Swroche if (parse_selector(&selector, &key, &val) == DEVFSADM_FAILURE) { 62810a653502Swroche error = TRUE; 62820a653502Swroche break; 62830a653502Swroche } else { 62840a653502Swroche selector_list = (selector_list_t *) 62850a653502Swroche s_malloc(sizeof (selector_list_t)); 62860a653502Swroche if (strcmp(NAME_S, key) == 0) { 62870a653502Swroche selector_list->key = NAME; 62880a653502Swroche } else if (strcmp(TYPE_S, key) == 0) { 62890a653502Swroche selector_list->key = TYPE; 62900a653502Swroche } else if (strncmp(ADDR_S, key, ADDR_S_LEN) == 0) { 62910a653502Swroche selector_list->key = ADDR; 62920a653502Swroche if (key[ADDR_S_LEN] == '\0') { 62930a653502Swroche selector_list->arg = 0; 62940a653502Swroche } else if (isdigit(key[ADDR_S_LEN]) != FALSE) { 62950a653502Swroche selector_list->arg = 62960a653502Swroche atoi(&key[ADDR_S_LEN]); 62970a653502Swroche } else { 62980a653502Swroche error = TRUE; 62990a653502Swroche free(selector_list); 63000a653502Swroche err_print(BADKEYWORD, key, 63010a653502Swroche devlinktab_line, devlinktab_file); 63020a653502Swroche break; 63030a653502Swroche } 63040a653502Swroche } else if (strncmp(MINOR_S, key, MINOR_S_LEN) == 0) { 63050a653502Swroche selector_list->key = MINOR; 63060a653502Swroche if (key[MINOR_S_LEN] == '\0') { 63070a653502Swroche selector_list->arg = 0; 63080a653502Swroche } else if (isdigit(key[MINOR_S_LEN]) != FALSE) { 63090a653502Swroche selector_list->arg = 63100a653502Swroche atoi(&key[MINOR_S_LEN]); 63110a653502Swroche } else { 63120a653502Swroche error = TRUE; 63130a653502Swroche free(selector_list); 63140a653502Swroche err_print(BADKEYWORD, key, 63150a653502Swroche devlinktab_line, devlinktab_file); 63160a653502Swroche break; 63170a653502Swroche } 63180a653502Swroche vprint(DEVLINK_MID, "MINOR = %s\n", val); 63190a653502Swroche } else { 63200a653502Swroche err_print(UNRECOGNIZED_KEY, key, 63210a653502Swroche devlinktab_line, devlinktab_file); 63220a653502Swroche error = TRUE; 63230a653502Swroche free(selector_list); 63240a653502Swroche break; 63250a653502Swroche } 63260a653502Swroche selector_list->val = s_strdup(val); 63270a653502Swroche selector_list->next = head_selector_list; 63280a653502Swroche head_selector_list = selector_list; 63290a653502Swroche vprint(DEVLINK_MID, "key='%s' val='%s' arg=%d\n", 63300a653502Swroche key, val, selector_list->arg); 63310a653502Swroche } 63320a653502Swroche } 63330a653502Swroche 63340a653502Swroche if ((error == FALSE) && (head_selector_list != NULL)) { 63350a653502Swroche return (head_selector_list); 63360a653502Swroche } else { 63370a653502Swroche /* parse failed. Free any allocated structs */ 63380a653502Swroche free_selector_list(head_selector_list); 63390a653502Swroche return (NULL); 63400a653502Swroche } 63417c478bd9Sstevel@tonic-gate } 63427c478bd9Sstevel@tonic-gate 63437c478bd9Sstevel@tonic-gate /* 63447c478bd9Sstevel@tonic-gate * Takes a semicolon separated list of selector elements and breaks up 63457c478bd9Sstevel@tonic-gate * into a keyword-value pair. semicolon and equal characters are 63467c478bd9Sstevel@tonic-gate * replaced with NULL's. On success, selector is updated to point to the 63477c478bd9Sstevel@tonic-gate * terminating NULL character terminating the keyword-value pair, and the 63487c478bd9Sstevel@tonic-gate * function returns DEVFSADM_SUCCESS. If there is a syntax error, 63497c478bd9Sstevel@tonic-gate * devfs_spec is not modified and function returns DEVFSADM_FAILURE. 63507c478bd9Sstevel@tonic-gate */ 63517c478bd9Sstevel@tonic-gate static int 63527c478bd9Sstevel@tonic-gate parse_selector(char **selector, char **key, char **val) 63537c478bd9Sstevel@tonic-gate { 63547c478bd9Sstevel@tonic-gate char *equal; 63557c478bd9Sstevel@tonic-gate char *semi_colon; 63567c478bd9Sstevel@tonic-gate 63577c478bd9Sstevel@tonic-gate *key = *selector; 63587c478bd9Sstevel@tonic-gate 63597c478bd9Sstevel@tonic-gate if ((equal = strchr(*key, '=')) != NULL) { 63607c478bd9Sstevel@tonic-gate *equal = '\0'; 63617c478bd9Sstevel@tonic-gate } else { 63627c478bd9Sstevel@tonic-gate err_print(MISSING_EQUAL, devlinktab_line, devlinktab_file); 63637c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 63647c478bd9Sstevel@tonic-gate } 63657c478bd9Sstevel@tonic-gate 63667c478bd9Sstevel@tonic-gate *val = ++equal; 63677c478bd9Sstevel@tonic-gate if ((semi_colon = strchr(equal, ';')) != NULL) { 63687c478bd9Sstevel@tonic-gate *semi_colon = '\0'; 63697c478bd9Sstevel@tonic-gate *selector = semi_colon + 1; 63707c478bd9Sstevel@tonic-gate } else { 63717c478bd9Sstevel@tonic-gate *selector = equal + strlen(equal); 63727c478bd9Sstevel@tonic-gate } 63737c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 63747c478bd9Sstevel@tonic-gate } 63757c478bd9Sstevel@tonic-gate 63767c478bd9Sstevel@tonic-gate /* 63777c478bd9Sstevel@tonic-gate * link is either the second or third field of devlink.tab. Parse link 63787c478bd9Sstevel@tonic-gate * into a linked list of devlink structures and return ptr to list. Each 63797c478bd9Sstevel@tonic-gate * list element is either a constant string, or one of the following 63807c478bd9Sstevel@tonic-gate * escape sequences: \M, \A, \N, or \D. The first three escape sequences 63817c478bd9Sstevel@tonic-gate * take a numerical argument. 63827c478bd9Sstevel@tonic-gate */ 63837c478bd9Sstevel@tonic-gate static link_list_t * 63847c478bd9Sstevel@tonic-gate create_link_list(char *link) 63857c478bd9Sstevel@tonic-gate { 63867c478bd9Sstevel@tonic-gate int x = 0; 63877c478bd9Sstevel@tonic-gate int error = FALSE; 63887c478bd9Sstevel@tonic-gate int counter_found = FALSE; 63897c478bd9Sstevel@tonic-gate link_list_t *head = NULL; 63907c478bd9Sstevel@tonic-gate link_list_t **ptr; 63917c478bd9Sstevel@tonic-gate link_list_t *link_list; 63927c478bd9Sstevel@tonic-gate char constant[MAX_DEVLINK_LINE]; 63937c478bd9Sstevel@tonic-gate char *error_str; 63947c478bd9Sstevel@tonic-gate 63957c478bd9Sstevel@tonic-gate if (link == NULL) { 63967c478bd9Sstevel@tonic-gate return (NULL); 63977c478bd9Sstevel@tonic-gate } 63987c478bd9Sstevel@tonic-gate 63997c478bd9Sstevel@tonic-gate while ((*link != '\0') && (error == FALSE)) { 64007c478bd9Sstevel@tonic-gate link_list = (link_list_t *)s_malloc(sizeof (link_list_t)); 64017c478bd9Sstevel@tonic-gate link_list->next = NULL; 64027c478bd9Sstevel@tonic-gate 64037c478bd9Sstevel@tonic-gate while ((*link != '\0') && (*link != '\\')) { 64047c478bd9Sstevel@tonic-gate /* a non-escaped string */ 64057c478bd9Sstevel@tonic-gate constant[x++] = *(link++); 64067c478bd9Sstevel@tonic-gate } 64077c478bd9Sstevel@tonic-gate if (x != 0) { 64087c478bd9Sstevel@tonic-gate constant[x] = '\0'; 64097c478bd9Sstevel@tonic-gate link_list->type = CONSTANT; 64107c478bd9Sstevel@tonic-gate link_list->constant = s_strdup(constant); 64117c478bd9Sstevel@tonic-gate x = 0; 64127c478bd9Sstevel@tonic-gate vprint(DEVLINK_MID, "CONSTANT FOUND %s\n", constant); 64137c478bd9Sstevel@tonic-gate } else { 64147c478bd9Sstevel@tonic-gate switch (*(++link)) { 64157c478bd9Sstevel@tonic-gate case 'M': 64167c478bd9Sstevel@tonic-gate link_list->type = MINOR; 64177c478bd9Sstevel@tonic-gate break; 64187c478bd9Sstevel@tonic-gate case 'A': 64197c478bd9Sstevel@tonic-gate link_list->type = ADDR; 64207c478bd9Sstevel@tonic-gate break; 64217c478bd9Sstevel@tonic-gate case 'N': 64227c478bd9Sstevel@tonic-gate if (counter_found == TRUE) { 64237c478bd9Sstevel@tonic-gate error = TRUE; 64240a653502Swroche error_str = 64250a653502Swroche "multiple counters not permitted"; 64267c478bd9Sstevel@tonic-gate free(link_list); 64277c478bd9Sstevel@tonic-gate } else { 64287c478bd9Sstevel@tonic-gate counter_found = TRUE; 64297c478bd9Sstevel@tonic-gate link_list->type = COUNTER; 64307c478bd9Sstevel@tonic-gate } 64317c478bd9Sstevel@tonic-gate break; 64327c478bd9Sstevel@tonic-gate case 'D': 64337c478bd9Sstevel@tonic-gate link_list->type = NAME; 64347c478bd9Sstevel@tonic-gate break; 64357c478bd9Sstevel@tonic-gate default: 64367c478bd9Sstevel@tonic-gate error = TRUE; 64377c478bd9Sstevel@tonic-gate free(link_list); 64387c478bd9Sstevel@tonic-gate error_str = "unrecognized escape sequence"; 64397c478bd9Sstevel@tonic-gate break; 64407c478bd9Sstevel@tonic-gate } 64417c478bd9Sstevel@tonic-gate if (*(link++) != 'D') { 64427c478bd9Sstevel@tonic-gate if (isdigit(*link) == FALSE) { 64437c478bd9Sstevel@tonic-gate error_str = "escape sequence must be " 64440a653502Swroche "followed by a digit\n"; 64457c478bd9Sstevel@tonic-gate error = TRUE; 64467c478bd9Sstevel@tonic-gate free(link_list); 64477c478bd9Sstevel@tonic-gate } else { 64487c478bd9Sstevel@tonic-gate link_list->arg = 64490a653502Swroche (int)strtoul(link, &link, 10); 64507c478bd9Sstevel@tonic-gate vprint(DEVLINK_MID, "link_list->arg = " 64510a653502Swroche "%d\n", link_list->arg); 64527c478bd9Sstevel@tonic-gate } 64537c478bd9Sstevel@tonic-gate } 64547c478bd9Sstevel@tonic-gate } 64557c478bd9Sstevel@tonic-gate /* append link_list struct to end of list */ 64567c478bd9Sstevel@tonic-gate if (error == FALSE) { 64570a653502Swroche for (ptr = &head; *ptr != NULL; ptr = &((*ptr)->next)) 64580a653502Swroche ; 64597c478bd9Sstevel@tonic-gate *ptr = link_list; 64607c478bd9Sstevel@tonic-gate } 64617c478bd9Sstevel@tonic-gate } 64627c478bd9Sstevel@tonic-gate 64637c478bd9Sstevel@tonic-gate if (error == FALSE) { 64647c478bd9Sstevel@tonic-gate return (head); 64657c478bd9Sstevel@tonic-gate } else { 64667c478bd9Sstevel@tonic-gate err_print(CONFIG_INCORRECT, devlinktab_line, devlinktab_file, 64677c478bd9Sstevel@tonic-gate error_str); 64687c478bd9Sstevel@tonic-gate free_link_list(head); 64697c478bd9Sstevel@tonic-gate return (NULL); 64707c478bd9Sstevel@tonic-gate } 64717c478bd9Sstevel@tonic-gate } 64727c478bd9Sstevel@tonic-gate 64737c478bd9Sstevel@tonic-gate /* 64747c478bd9Sstevel@tonic-gate * Called for each minor node devfsadm processes; for each minor node, 64757c478bd9Sstevel@tonic-gate * look for matches in the devlinktab_list list which was created on 64767c478bd9Sstevel@tonic-gate * startup read_devlinktab_file(). If there is a match, call build_links() 64777c478bd9Sstevel@tonic-gate * to build a logical devlink and a possible extra devlink. 64787c478bd9Sstevel@tonic-gate */ 64797c478bd9Sstevel@tonic-gate static int 64807c478bd9Sstevel@tonic-gate process_devlink_compat(di_minor_t minor, di_node_t node) 64817c478bd9Sstevel@tonic-gate { 64827c478bd9Sstevel@tonic-gate int link_built = FALSE; 64837c478bd9Sstevel@tonic-gate devlinktab_list_t *entry; 64847c478bd9Sstevel@tonic-gate char *nodetype; 64857c478bd9Sstevel@tonic-gate char *dev_path; 64867c478bd9Sstevel@tonic-gate 64877c478bd9Sstevel@tonic-gate if (devlinks_debug == TRUE) { 64887c478bd9Sstevel@tonic-gate nodetype = di_minor_nodetype(minor); 64897c478bd9Sstevel@tonic-gate assert(nodetype != NULL); 64907c478bd9Sstevel@tonic-gate if ((dev_path = di_devfs_path(node)) != NULL) { 64910a653502Swroche vprint(INFO_MID, "'%s' entry: %s:%s\n", 64920a653502Swroche nodetype, dev_path, 64930a653502Swroche di_minor_name(minor) ? di_minor_name(minor) : ""); 64947c478bd9Sstevel@tonic-gate di_devfs_path_free(dev_path); 64957c478bd9Sstevel@tonic-gate } 64967c478bd9Sstevel@tonic-gate 64977c478bd9Sstevel@tonic-gate } 64987c478bd9Sstevel@tonic-gate 64997c478bd9Sstevel@tonic-gate 65007c478bd9Sstevel@tonic-gate /* don't process devlink.tab if devfsadm invoked with -c <class> */ 65017c478bd9Sstevel@tonic-gate if (num_classes > 0) { 65027c478bd9Sstevel@tonic-gate return (FALSE); 65037c478bd9Sstevel@tonic-gate } 65047c478bd9Sstevel@tonic-gate 65057c478bd9Sstevel@tonic-gate for (entry = devlinktab_list; entry != NULL; entry = entry->next) { 65067c478bd9Sstevel@tonic-gate if (devlink_matches(entry, minor, node) == DEVFSADM_SUCCESS) { 65077c478bd9Sstevel@tonic-gate link_built = TRUE; 65087c478bd9Sstevel@tonic-gate (void) build_links(entry, minor, node); 65097c478bd9Sstevel@tonic-gate } 65107c478bd9Sstevel@tonic-gate } 65117c478bd9Sstevel@tonic-gate return (link_built); 65127c478bd9Sstevel@tonic-gate } 65137c478bd9Sstevel@tonic-gate 65147c478bd9Sstevel@tonic-gate /* 65157c478bd9Sstevel@tonic-gate * For a given devlink.tab devlinktab_list entry, see if the selector 65167c478bd9Sstevel@tonic-gate * field matches this minor node. If it does, return DEVFSADM_SUCCESS, 65177c478bd9Sstevel@tonic-gate * otherwise DEVFSADM_FAILURE. 65187c478bd9Sstevel@tonic-gate */ 65197c478bd9Sstevel@tonic-gate static int 65207c478bd9Sstevel@tonic-gate devlink_matches(devlinktab_list_t *entry, di_minor_t minor, di_node_t node) 65217c478bd9Sstevel@tonic-gate { 65227c478bd9Sstevel@tonic-gate selector_list_t *selector = entry->selector; 65237c478bd9Sstevel@tonic-gate char *addr; 65247c478bd9Sstevel@tonic-gate char *minor_name; 65257c478bd9Sstevel@tonic-gate char *node_type; 65267c478bd9Sstevel@tonic-gate 65277c478bd9Sstevel@tonic-gate for (; selector != NULL; selector = selector->next) { 65287c478bd9Sstevel@tonic-gate switch (selector->key) { 65297c478bd9Sstevel@tonic-gate case NAME: 65307c478bd9Sstevel@tonic-gate if (strcmp(di_node_name(node), selector->val) != 0) { 65317c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 65327c478bd9Sstevel@tonic-gate } 65337c478bd9Sstevel@tonic-gate break; 65347c478bd9Sstevel@tonic-gate case TYPE: 65357c478bd9Sstevel@tonic-gate node_type = di_minor_nodetype(minor); 65367c478bd9Sstevel@tonic-gate assert(node_type != NULL); 65377c478bd9Sstevel@tonic-gate if (strcmp(node_type, selector->val) != 0) { 65387c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 65397c478bd9Sstevel@tonic-gate } 65407c478bd9Sstevel@tonic-gate break; 65417c478bd9Sstevel@tonic-gate case ADDR: 65427c478bd9Sstevel@tonic-gate if ((addr = di_bus_addr(node)) == NULL) { 65437c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 65447c478bd9Sstevel@tonic-gate } 65457c478bd9Sstevel@tonic-gate if (selector->arg == 0) { 65467c478bd9Sstevel@tonic-gate if (strcmp(addr, selector->val) != 0) { 65477c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 65487c478bd9Sstevel@tonic-gate } 65497c478bd9Sstevel@tonic-gate } else { 65507c478bd9Sstevel@tonic-gate if (compare_field(addr, selector->val, 65517c478bd9Sstevel@tonic-gate selector->arg) == DEVFSADM_FAILURE) { 65527c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 65537c478bd9Sstevel@tonic-gate } 65547c478bd9Sstevel@tonic-gate } 65557c478bd9Sstevel@tonic-gate break; 65567c478bd9Sstevel@tonic-gate case MINOR: 65577c478bd9Sstevel@tonic-gate if ((minor_name = di_minor_name(minor)) == NULL) { 65587c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 65597c478bd9Sstevel@tonic-gate } 65607c478bd9Sstevel@tonic-gate if (selector->arg == 0) { 65617c478bd9Sstevel@tonic-gate if (strcmp(minor_name, selector->val) != 0) { 65627c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 65637c478bd9Sstevel@tonic-gate } 65647c478bd9Sstevel@tonic-gate } else { 65657c478bd9Sstevel@tonic-gate if (compare_field(minor_name, selector->val, 65660a653502Swroche selector->arg) == DEVFSADM_FAILURE) { 65677c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 65687c478bd9Sstevel@tonic-gate } 65697c478bd9Sstevel@tonic-gate } 65707c478bd9Sstevel@tonic-gate break; 65717c478bd9Sstevel@tonic-gate default: 65727c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 65737c478bd9Sstevel@tonic-gate } 65747c478bd9Sstevel@tonic-gate } 65757c478bd9Sstevel@tonic-gate 65767c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 65777c478bd9Sstevel@tonic-gate } 65787c478bd9Sstevel@tonic-gate 65797c478bd9Sstevel@tonic-gate /* 65807c478bd9Sstevel@tonic-gate * For the given minor node and devlinktab_list entry from devlink.tab, 65817c478bd9Sstevel@tonic-gate * build a logical dev link and a possible extra devlink. 65827c478bd9Sstevel@tonic-gate * Return DEVFSADM_SUCCESS if link is created, otherwise DEVFSADM_FAILURE. 65837c478bd9Sstevel@tonic-gate */ 65847c478bd9Sstevel@tonic-gate static int 65857c478bd9Sstevel@tonic-gate build_links(devlinktab_list_t *entry, di_minor_t minor, di_node_t node) 65867c478bd9Sstevel@tonic-gate { 65877c478bd9Sstevel@tonic-gate char secondary_link[PATH_MAX + 1]; 65887c478bd9Sstevel@tonic-gate char primary_link[PATH_MAX + 1]; 65897c478bd9Sstevel@tonic-gate char contents[PATH_MAX + 1]; 65907c478bd9Sstevel@tonic-gate char *dev_path; 65917c478bd9Sstevel@tonic-gate 65927c478bd9Sstevel@tonic-gate if ((dev_path = di_devfs_path(node)) == NULL) { 65937c478bd9Sstevel@tonic-gate err_print(DI_DEVFS_PATH_FAILED, strerror(errno)); 65947c478bd9Sstevel@tonic-gate devfsadm_exit(1); 6595*537714daSvikram /*NOTREACHED*/ 65967c478bd9Sstevel@tonic-gate } 65977c478bd9Sstevel@tonic-gate (void) strcpy(contents, dev_path); 65987c478bd9Sstevel@tonic-gate di_devfs_path_free(dev_path); 65997c478bd9Sstevel@tonic-gate 66007c478bd9Sstevel@tonic-gate (void) strcat(contents, ":"); 66017c478bd9Sstevel@tonic-gate (void) strcat(contents, di_minor_name(minor)); 66027c478bd9Sstevel@tonic-gate 66037c478bd9Sstevel@tonic-gate if (construct_devlink(primary_link, entry->p_link, contents, 66040a653502Swroche minor, node, entry->p_link_pattern) == DEVFSADM_FAILURE) { 66057c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 66067c478bd9Sstevel@tonic-gate } 66077c478bd9Sstevel@tonic-gate (void) devfsadm_mklink(primary_link, node, minor, 0); 66087c478bd9Sstevel@tonic-gate 66097c478bd9Sstevel@tonic-gate if (entry->s_link == NULL) { 66107c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 66117c478bd9Sstevel@tonic-gate } 66127c478bd9Sstevel@tonic-gate 66130a653502Swroche if (construct_devlink(secondary_link, entry->s_link, primary_link, 66140a653502Swroche minor, node, entry->s_link_pattern) == DEVFSADM_FAILURE) { 66157c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 66167c478bd9Sstevel@tonic-gate } 66177c478bd9Sstevel@tonic-gate 66187c478bd9Sstevel@tonic-gate (void) devfsadm_secondary_link(secondary_link, primary_link, 0); 66197c478bd9Sstevel@tonic-gate 66207c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 66217c478bd9Sstevel@tonic-gate } 66227c478bd9Sstevel@tonic-gate 66237c478bd9Sstevel@tonic-gate /* 66247c478bd9Sstevel@tonic-gate * The counter rule for devlink.tab entries is implemented via 66257c478bd9Sstevel@tonic-gate * devfsadm_enumerate_int_start(). One of the arguments to this function 66267c478bd9Sstevel@tonic-gate * is a path, where each path component is treated as a regular expression. 66277c478bd9Sstevel@tonic-gate * For devlink.tab entries, this path regular expression is derived from 66287c478bd9Sstevel@tonic-gate * the devlink spec. get_anchored_re() accepts path regular expressions derived 66297c478bd9Sstevel@tonic-gate * from devlink.tab entries and inserts the anchors '^' and '$' at the beginning 66307c478bd9Sstevel@tonic-gate * and end respectively of each path component. This is done to prevent 66317c478bd9Sstevel@tonic-gate * false matches. For example, without anchors, "a/([0-9]+)" will match "ab/c9" 66327c478bd9Sstevel@tonic-gate * and incorrect links will be generated. 66337c478bd9Sstevel@tonic-gate */ 66347c478bd9Sstevel@tonic-gate static int 66357c478bd9Sstevel@tonic-gate get_anchored_re(char *link, char *anchored_re, char *pattern) 66367c478bd9Sstevel@tonic-gate { 66377c478bd9Sstevel@tonic-gate if (*link == '/' || *link == '\0') { 66387c478bd9Sstevel@tonic-gate err_print(INVALID_DEVLINK_SPEC, pattern); 66397c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 66407c478bd9Sstevel@tonic-gate } 66417c478bd9Sstevel@tonic-gate 66427c478bd9Sstevel@tonic-gate *anchored_re++ = '^'; 66437c478bd9Sstevel@tonic-gate for (; *link != '\0'; ) { 66447c478bd9Sstevel@tonic-gate if (*link == '/') { 66457c478bd9Sstevel@tonic-gate while (*link == '/') 66467c478bd9Sstevel@tonic-gate link++; 66477c478bd9Sstevel@tonic-gate *anchored_re++ = '$'; 66487c478bd9Sstevel@tonic-gate *anchored_re++ = '/'; 66497c478bd9Sstevel@tonic-gate if (*link != '\0') { 66507c478bd9Sstevel@tonic-gate *anchored_re++ = '^'; 66517c478bd9Sstevel@tonic-gate } 66527c478bd9Sstevel@tonic-gate } else { 66537c478bd9Sstevel@tonic-gate *anchored_re++ = *link++; 66547c478bd9Sstevel@tonic-gate if (*link == '\0') { 66557c478bd9Sstevel@tonic-gate *anchored_re++ = '$'; 66567c478bd9Sstevel@tonic-gate } 66577c478bd9Sstevel@tonic-gate } 66587c478bd9Sstevel@tonic-gate } 66597c478bd9Sstevel@tonic-gate *anchored_re = '\0'; 66607c478bd9Sstevel@tonic-gate 66617c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 66627c478bd9Sstevel@tonic-gate } 66637c478bd9Sstevel@tonic-gate 66647c478bd9Sstevel@tonic-gate static int 66657c478bd9Sstevel@tonic-gate construct_devlink(char *link, link_list_t *link_build, char *contents, 66667c478bd9Sstevel@tonic-gate di_minor_t minor, di_node_t node, char *pattern) 66677c478bd9Sstevel@tonic-gate { 66687c478bd9Sstevel@tonic-gate int counter_offset = -1; 66697c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[1] = {NULL}; 66707c478bd9Sstevel@tonic-gate char templink[PATH_MAX + 1]; 66717c478bd9Sstevel@tonic-gate char *buff; 66727c478bd9Sstevel@tonic-gate char start[10]; 66737c478bd9Sstevel@tonic-gate char *node_path; 66747c478bd9Sstevel@tonic-gate char anchored_re[PATH_MAX + 1]; 66757c478bd9Sstevel@tonic-gate 66767c478bd9Sstevel@tonic-gate link[0] = '\0'; 66777c478bd9Sstevel@tonic-gate 66787c478bd9Sstevel@tonic-gate for (; link_build != NULL; link_build = link_build->next) { 66797c478bd9Sstevel@tonic-gate switch (link_build->type) { 66807c478bd9Sstevel@tonic-gate case NAME: 66817c478bd9Sstevel@tonic-gate (void) strcat(link, di_node_name(node)); 66827c478bd9Sstevel@tonic-gate break; 66837c478bd9Sstevel@tonic-gate case CONSTANT: 66847c478bd9Sstevel@tonic-gate (void) strcat(link, link_build->constant); 66857c478bd9Sstevel@tonic-gate break; 66867c478bd9Sstevel@tonic-gate case ADDR: 66877c478bd9Sstevel@tonic-gate if (component_cat(link, di_bus_addr(node), 66880a653502Swroche link_build->arg) == DEVFSADM_FAILURE) { 66897c478bd9Sstevel@tonic-gate node_path = di_devfs_path(node); 66907c478bd9Sstevel@tonic-gate err_print(CANNOT_BE_USED, pattern, node_path, 66910a653502Swroche di_minor_name(minor)); 66927c478bd9Sstevel@tonic-gate di_devfs_path_free(node_path); 66937c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 66947c478bd9Sstevel@tonic-gate } 66957c478bd9Sstevel@tonic-gate break; 66967c478bd9Sstevel@tonic-gate case MINOR: 66977c478bd9Sstevel@tonic-gate if (component_cat(link, di_minor_name(minor), 66980a653502Swroche link_build->arg) == DEVFSADM_FAILURE) { 66997c478bd9Sstevel@tonic-gate node_path = di_devfs_path(node); 67007c478bd9Sstevel@tonic-gate err_print(CANNOT_BE_USED, pattern, node_path, 67010a653502Swroche di_minor_name(minor)); 67027c478bd9Sstevel@tonic-gate di_devfs_path_free(node_path); 67037c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 67047c478bd9Sstevel@tonic-gate } 67057c478bd9Sstevel@tonic-gate break; 67067c478bd9Sstevel@tonic-gate case COUNTER: 67077c478bd9Sstevel@tonic-gate counter_offset = strlen(link); 67087c478bd9Sstevel@tonic-gate (void) strcat(link, "([0-9]+)"); 67097c478bd9Sstevel@tonic-gate (void) sprintf(start, "%d", link_build->arg); 67107c478bd9Sstevel@tonic-gate break; 67117c478bd9Sstevel@tonic-gate default: 67127c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 67137c478bd9Sstevel@tonic-gate } 67147c478bd9Sstevel@tonic-gate } 67157c478bd9Sstevel@tonic-gate 67167c478bd9Sstevel@tonic-gate if (counter_offset != -1) { 67177c478bd9Sstevel@tonic-gate /* 67187c478bd9Sstevel@tonic-gate * copy anything appended after "([0-9]+)" into 67197c478bd9Sstevel@tonic-gate * templink 67207c478bd9Sstevel@tonic-gate */ 67217c478bd9Sstevel@tonic-gate 67227c478bd9Sstevel@tonic-gate (void) strcpy(templink, 67230a653502Swroche &link[counter_offset + strlen("([0-9]+)")]); 67247c478bd9Sstevel@tonic-gate if (get_anchored_re(link, anchored_re, pattern) 67257c478bd9Sstevel@tonic-gate != DEVFSADM_SUCCESS) { 67267c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 67277c478bd9Sstevel@tonic-gate } 67287c478bd9Sstevel@tonic-gate rules[0].re = anchored_re; 67297c478bd9Sstevel@tonic-gate rules[0].subexp = 1; 67307c478bd9Sstevel@tonic-gate rules[0].flags = MATCH_ALL; 67317c478bd9Sstevel@tonic-gate if (devfsadm_enumerate_int_start(contents, 0, &buff, 67327c478bd9Sstevel@tonic-gate rules, 1, start) == DEVFSADM_FAILURE) { 67337c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 67347c478bd9Sstevel@tonic-gate } 67357c478bd9Sstevel@tonic-gate (void) strcpy(&link[counter_offset], buff); 67367c478bd9Sstevel@tonic-gate free(buff); 67377c478bd9Sstevel@tonic-gate (void) strcat(link, templink); 67387c478bd9Sstevel@tonic-gate vprint(DEVLINK_MID, "COUNTER is %s\n", link); 67397c478bd9Sstevel@tonic-gate } 67407c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 67417c478bd9Sstevel@tonic-gate } 67427c478bd9Sstevel@tonic-gate 67437c478bd9Sstevel@tonic-gate /* 67447c478bd9Sstevel@tonic-gate * Compares "field" number of the comma separated list "full_name" with 67457c478bd9Sstevel@tonic-gate * field_item. Returns DEVFSADM_SUCCESS for match, 67467c478bd9Sstevel@tonic-gate * DEVFSADM_FAILURE for no match. 67477c478bd9Sstevel@tonic-gate */ 67487c478bd9Sstevel@tonic-gate static int 67497c478bd9Sstevel@tonic-gate compare_field(char *full_name, char *field_item, int field) 67507c478bd9Sstevel@tonic-gate { 67517c478bd9Sstevel@tonic-gate --field; 67527c478bd9Sstevel@tonic-gate while ((*full_name != '\0') && (field != 0)) { 67537c478bd9Sstevel@tonic-gate if (*(full_name++) == ',') { 67547c478bd9Sstevel@tonic-gate field--; 67557c478bd9Sstevel@tonic-gate } 67567c478bd9Sstevel@tonic-gate } 67577c478bd9Sstevel@tonic-gate 67587c478bd9Sstevel@tonic-gate if (field != 0) { 67597c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 67607c478bd9Sstevel@tonic-gate } 67617c478bd9Sstevel@tonic-gate 67627c478bd9Sstevel@tonic-gate while ((*full_name != '\0') && (*field_item != '\0') && 67630a653502Swroche (*full_name != ',')) { 67647c478bd9Sstevel@tonic-gate if (*(full_name++) != *(field_item++)) { 67657c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 67667c478bd9Sstevel@tonic-gate } 67677c478bd9Sstevel@tonic-gate } 67687c478bd9Sstevel@tonic-gate 67697c478bd9Sstevel@tonic-gate if (*field_item != '\0') { 67707c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 67717c478bd9Sstevel@tonic-gate } 67727c478bd9Sstevel@tonic-gate 67737c478bd9Sstevel@tonic-gate if ((*full_name == '\0') || (*full_name == ',')) 67747c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 67757c478bd9Sstevel@tonic-gate 67767c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 67777c478bd9Sstevel@tonic-gate } 67787c478bd9Sstevel@tonic-gate 67797c478bd9Sstevel@tonic-gate /* 67807c478bd9Sstevel@tonic-gate * strcat() field # "field" of comma separated list "name" to "link". 67817c478bd9Sstevel@tonic-gate * Field 0 is the entire name. 67827c478bd9Sstevel@tonic-gate * Return DEVFSADM_SUCCESS or DEVFSADM_FAILURE. 67837c478bd9Sstevel@tonic-gate */ 67847c478bd9Sstevel@tonic-gate static int 67857c478bd9Sstevel@tonic-gate component_cat(char *link, char *name, int field) 67867c478bd9Sstevel@tonic-gate { 67877c478bd9Sstevel@tonic-gate 67887c478bd9Sstevel@tonic-gate if (name == NULL) { 67897c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 67907c478bd9Sstevel@tonic-gate } 67917c478bd9Sstevel@tonic-gate 67927c478bd9Sstevel@tonic-gate if (field == 0) { 67937c478bd9Sstevel@tonic-gate (void) strcat(link, name); 67947c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 67957c478bd9Sstevel@tonic-gate } 67967c478bd9Sstevel@tonic-gate 67977c478bd9Sstevel@tonic-gate while (*link != '\0') { 67987c478bd9Sstevel@tonic-gate link++; 67997c478bd9Sstevel@tonic-gate } 68007c478bd9Sstevel@tonic-gate 68017c478bd9Sstevel@tonic-gate --field; 68027c478bd9Sstevel@tonic-gate while ((*name != '\0') && (field != 0)) { 68037c478bd9Sstevel@tonic-gate if (*(name++) == ',') { 68047c478bd9Sstevel@tonic-gate --field; 68057c478bd9Sstevel@tonic-gate } 68067c478bd9Sstevel@tonic-gate } 68077c478bd9Sstevel@tonic-gate 68087c478bd9Sstevel@tonic-gate if (field != 0) { 68097c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 68107c478bd9Sstevel@tonic-gate } 68117c478bd9Sstevel@tonic-gate 68127c478bd9Sstevel@tonic-gate while ((*name != '\0') && (*name != ',')) { 68137c478bd9Sstevel@tonic-gate *(link++) = *(name++); 68147c478bd9Sstevel@tonic-gate } 68157c478bd9Sstevel@tonic-gate 68167c478bd9Sstevel@tonic-gate *link = '\0'; 68177c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 68187c478bd9Sstevel@tonic-gate } 68197c478bd9Sstevel@tonic-gate 68207c478bd9Sstevel@tonic-gate static void 68217c478bd9Sstevel@tonic-gate free_selector_list(selector_list_t *head) 68227c478bd9Sstevel@tonic-gate { 68237c478bd9Sstevel@tonic-gate selector_list_t *temp; 68247c478bd9Sstevel@tonic-gate 68257c478bd9Sstevel@tonic-gate while (head != NULL) { 68267c478bd9Sstevel@tonic-gate temp = head; 68277c478bd9Sstevel@tonic-gate head = head->next; 68287c478bd9Sstevel@tonic-gate free(temp->val); 68297c478bd9Sstevel@tonic-gate free(temp); 68307c478bd9Sstevel@tonic-gate } 68317c478bd9Sstevel@tonic-gate } 68327c478bd9Sstevel@tonic-gate 68337c478bd9Sstevel@tonic-gate static void 68347c478bd9Sstevel@tonic-gate free_link_list(link_list_t *head) 68357c478bd9Sstevel@tonic-gate { 68367c478bd9Sstevel@tonic-gate link_list_t *temp; 68377c478bd9Sstevel@tonic-gate 68387c478bd9Sstevel@tonic-gate while (head != NULL) { 68397c478bd9Sstevel@tonic-gate temp = head; 68407c478bd9Sstevel@tonic-gate head = head->next; 68417c478bd9Sstevel@tonic-gate if (temp->type == CONSTANT) { 68427c478bd9Sstevel@tonic-gate free(temp->constant); 68437c478bd9Sstevel@tonic-gate } 68447c478bd9Sstevel@tonic-gate free(temp); 68457c478bd9Sstevel@tonic-gate } 68467c478bd9Sstevel@tonic-gate } 68477c478bd9Sstevel@tonic-gate 68487c478bd9Sstevel@tonic-gate /* 68497c478bd9Sstevel@tonic-gate * Prints only if level matches one of the debug levels 68507c478bd9Sstevel@tonic-gate * given on command line. INFO_MID is always printed. 68517c478bd9Sstevel@tonic-gate * 68527c478bd9Sstevel@tonic-gate * See devfsadm.h for a listing of globally defined levels and 68537c478bd9Sstevel@tonic-gate * meanings. Modules should prefix the level with their 68547c478bd9Sstevel@tonic-gate * module name to prevent collisions. 68557c478bd9Sstevel@tonic-gate */ 68567c478bd9Sstevel@tonic-gate /*PRINTFLIKE2*/ 68577c478bd9Sstevel@tonic-gate void 68587c478bd9Sstevel@tonic-gate devfsadm_print(char *msgid, char *message, ...) 68597c478bd9Sstevel@tonic-gate { 68607c478bd9Sstevel@tonic-gate va_list ap; 68617c478bd9Sstevel@tonic-gate static int newline = TRUE; 68627c478bd9Sstevel@tonic-gate int x; 68637c478bd9Sstevel@tonic-gate 68647c478bd9Sstevel@tonic-gate if (msgid != NULL) { 68657c478bd9Sstevel@tonic-gate for (x = 0; x < num_verbose; x++) { 68667c478bd9Sstevel@tonic-gate if (strcmp(verbose[x], msgid) == 0) { 68677c478bd9Sstevel@tonic-gate break; 68687c478bd9Sstevel@tonic-gate } 68697c478bd9Sstevel@tonic-gate if (strcmp(verbose[x], ALL_MID) == 0) { 68707c478bd9Sstevel@tonic-gate break; 68717c478bd9Sstevel@tonic-gate } 68727c478bd9Sstevel@tonic-gate } 68737c478bd9Sstevel@tonic-gate if (x == num_verbose) { 68747c478bd9Sstevel@tonic-gate return; 68757c478bd9Sstevel@tonic-gate } 68767c478bd9Sstevel@tonic-gate } 68777c478bd9Sstevel@tonic-gate 68787c478bd9Sstevel@tonic-gate va_start(ap, message); 68797c478bd9Sstevel@tonic-gate 68807c478bd9Sstevel@tonic-gate if (msgid == NULL) { 68817c478bd9Sstevel@tonic-gate if (logflag == TRUE) { 68827c478bd9Sstevel@tonic-gate (void) vsyslog(LOG_NOTICE, message, ap); 68837c478bd9Sstevel@tonic-gate } else { 68847c478bd9Sstevel@tonic-gate (void) vfprintf(stdout, message, ap); 68857c478bd9Sstevel@tonic-gate } 68867c478bd9Sstevel@tonic-gate 68877c478bd9Sstevel@tonic-gate } else { 68887c478bd9Sstevel@tonic-gate if (logflag == TRUE) { 68897c478bd9Sstevel@tonic-gate (void) syslog(LOG_DEBUG, "%s[%ld]: %s: ", 68900a653502Swroche prog, getpid(), msgid); 68917c478bd9Sstevel@tonic-gate (void) vsyslog(LOG_DEBUG, message, ap); 68927c478bd9Sstevel@tonic-gate } else { 68937c478bd9Sstevel@tonic-gate if (newline == TRUE) { 68947c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "%s[%ld]: %s: ", 68950a653502Swroche prog, getpid(), msgid); 68967c478bd9Sstevel@tonic-gate } 68977c478bd9Sstevel@tonic-gate (void) vfprintf(stdout, message, ap); 68987c478bd9Sstevel@tonic-gate } 68997c478bd9Sstevel@tonic-gate } 69007c478bd9Sstevel@tonic-gate 69017c478bd9Sstevel@tonic-gate if (message[strlen(message) - 1] == '\n') { 69027c478bd9Sstevel@tonic-gate newline = TRUE; 69037c478bd9Sstevel@tonic-gate } else { 69047c478bd9Sstevel@tonic-gate newline = FALSE; 69057c478bd9Sstevel@tonic-gate } 69067c478bd9Sstevel@tonic-gate va_end(ap); 69077c478bd9Sstevel@tonic-gate } 69087c478bd9Sstevel@tonic-gate 69097c478bd9Sstevel@tonic-gate /* 69107c478bd9Sstevel@tonic-gate * print error messages to the terminal or to syslog 69117c478bd9Sstevel@tonic-gate */ 69127c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 69137c478bd9Sstevel@tonic-gate void 69147c478bd9Sstevel@tonic-gate devfsadm_errprint(char *message, ...) 69157c478bd9Sstevel@tonic-gate { 69167c478bd9Sstevel@tonic-gate va_list ap; 69177c478bd9Sstevel@tonic-gate 69187c478bd9Sstevel@tonic-gate va_start(ap, message); 69197c478bd9Sstevel@tonic-gate 69207c478bd9Sstevel@tonic-gate if (logflag == TRUE) { 69217c478bd9Sstevel@tonic-gate (void) vsyslog(LOG_ERR, message, ap); 69227c478bd9Sstevel@tonic-gate } else { 69237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: ", prog); 69247c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, message, ap); 69257c478bd9Sstevel@tonic-gate } 69267c478bd9Sstevel@tonic-gate va_end(ap); 69277c478bd9Sstevel@tonic-gate } 69287c478bd9Sstevel@tonic-gate 69297c478bd9Sstevel@tonic-gate /* 69307c478bd9Sstevel@tonic-gate * return noupdate state (-s) 69317c478bd9Sstevel@tonic-gate */ 69327c478bd9Sstevel@tonic-gate int 69337c478bd9Sstevel@tonic-gate devfsadm_noupdate(void) 69347c478bd9Sstevel@tonic-gate { 69357c478bd9Sstevel@tonic-gate return (file_mods == TRUE ? DEVFSADM_TRUE : DEVFSADM_FALSE); 69367c478bd9Sstevel@tonic-gate } 69377c478bd9Sstevel@tonic-gate 69387c478bd9Sstevel@tonic-gate /* 69397c478bd9Sstevel@tonic-gate * return current root update path (-r) 69407c478bd9Sstevel@tonic-gate */ 69417c478bd9Sstevel@tonic-gate const char * 69427c478bd9Sstevel@tonic-gate devfsadm_root_path(void) 69437c478bd9Sstevel@tonic-gate { 69447c478bd9Sstevel@tonic-gate if (root_dir[0] == '\0') { 69457c478bd9Sstevel@tonic-gate return ("/"); 69467c478bd9Sstevel@tonic-gate } else { 69477c478bd9Sstevel@tonic-gate return ((const char *)root_dir); 69487c478bd9Sstevel@tonic-gate } 69497c478bd9Sstevel@tonic-gate } 69507c478bd9Sstevel@tonic-gate 69513c4226f9Spjha void 69523c4226f9Spjha devfsadm_free_dev_names(char **dev_names, int len) 69533c4226f9Spjha { 69543c4226f9Spjha int i; 69553c4226f9Spjha 69563c4226f9Spjha for (i = 0; i < len; i++) 69573c4226f9Spjha free(dev_names[i]); 69583c4226f9Spjha free(dev_names); 69593c4226f9Spjha } 69603c4226f9Spjha 69613c4226f9Spjha /* 69623c4226f9Spjha * Return all devlinks corresponding to phys_path as an array of strings. 69633c4226f9Spjha * The number of entries in the array is returned through lenp. 69643c4226f9Spjha * devfsadm_free_dev_names() is used to free the returned array. 69653c4226f9Spjha * NULL is returned on failure or when there are no matching devlinks. 69663c4226f9Spjha * 69673c4226f9Spjha * re is an extended regular expression in regex(5) format used to further 69683c4226f9Spjha * match devlinks pointing to phys_path; it may be NULL to match all 69693c4226f9Spjha */ 69703c4226f9Spjha char ** 69713c4226f9Spjha devfsadm_lookup_dev_names(char *phys_path, char *re, int *lenp) 69723c4226f9Spjha { 69733c4226f9Spjha struct devlink_cb_arg cb_arg; 69743c4226f9Spjha char **dev_names = NULL; 69753c4226f9Spjha int i; 69763c4226f9Spjha 69773c4226f9Spjha *lenp = 0; 69783c4226f9Spjha cb_arg.count = 0; 69793c4226f9Spjha cb_arg.rv = 0; 69803c4226f9Spjha (void) di_devlink_cache_walk(devlink_cache, re, phys_path, 69813c4226f9Spjha DI_PRIMARY_LINK, &cb_arg, devlink_cb); 69823c4226f9Spjha 69833c4226f9Spjha if (cb_arg.rv == -1 || cb_arg.count <= 0) 69843c4226f9Spjha return (NULL); 69853c4226f9Spjha 69863c4226f9Spjha dev_names = s_malloc(cb_arg.count * sizeof (char *)); 69873c4226f9Spjha if (dev_names == NULL) 69883c4226f9Spjha goto out; 69893c4226f9Spjha 69903c4226f9Spjha for (i = 0; i < cb_arg.count; i++) { 69913c4226f9Spjha dev_names[i] = s_strdup(cb_arg.dev_names[i]); 69923c4226f9Spjha if (dev_names[i] == NULL) { 69933c4226f9Spjha devfsadm_free_dev_names(dev_names, i); 69943c4226f9Spjha dev_names = NULL; 69953c4226f9Spjha goto out; 69963c4226f9Spjha } 69973c4226f9Spjha } 69983c4226f9Spjha *lenp = cb_arg.count; 69993c4226f9Spjha 70003c4226f9Spjha out: 70013c4226f9Spjha free_dev_names(&cb_arg); 70023c4226f9Spjha return (dev_names); 70033c4226f9Spjha } 70043c4226f9Spjha 70057c478bd9Sstevel@tonic-gate /* common exit function which ensures releasing locks */ 70067c478bd9Sstevel@tonic-gate static void 70077c478bd9Sstevel@tonic-gate devfsadm_exit(int status) 70087c478bd9Sstevel@tonic-gate { 70097c478bd9Sstevel@tonic-gate if (DEVFSADM_DEBUG_ON) { 70107c478bd9Sstevel@tonic-gate vprint(INFO_MID, "exit status = %d\n", status); 70117c478bd9Sstevel@tonic-gate } 70127c478bd9Sstevel@tonic-gate 70137c478bd9Sstevel@tonic-gate if (rcm_hdl) { 70147c478bd9Sstevel@tonic-gate if (thr_self() != process_rcm_events_tid) { 70157c478bd9Sstevel@tonic-gate (void) mutex_lock(&rcm_eventq_lock); 70167c478bd9Sstevel@tonic-gate need_to_exit_rcm_event_thread = 1; 70177c478bd9Sstevel@tonic-gate (void) cond_broadcast(&rcm_eventq_cv); 70187c478bd9Sstevel@tonic-gate (void) mutex_unlock(&rcm_eventq_lock); 70197c478bd9Sstevel@tonic-gate 70207c478bd9Sstevel@tonic-gate /* wait until process_rcm_events() thread exits */ 70217c478bd9Sstevel@tonic-gate (void) thr_join(process_rcm_events_tid, NULL, NULL); 70227c478bd9Sstevel@tonic-gate } 70237c478bd9Sstevel@tonic-gate librcm_free_handle(rcm_hdl); 70247c478bd9Sstevel@tonic-gate (void) dlclose(librcm_hdl); 70257c478bd9Sstevel@tonic-gate } 70267c478bd9Sstevel@tonic-gate 7027*537714daSvikram exit_dev_lock(1); 7028*537714daSvikram exit_daemon_lock(1); 70297c478bd9Sstevel@tonic-gate 70307c478bd9Sstevel@tonic-gate if (logflag == TRUE) { 70317c478bd9Sstevel@tonic-gate closelog(); 70327c478bd9Sstevel@tonic-gate } 70337c478bd9Sstevel@tonic-gate 70347c478bd9Sstevel@tonic-gate exit(status); 7035*537714daSvikram /*NOTREACHED*/ 70367c478bd9Sstevel@tonic-gate } 70377c478bd9Sstevel@tonic-gate 70387c478bd9Sstevel@tonic-gate /* 7039facf4a8dSllai * set root_dir, devices_dir, dev_dir using optarg. 70407c478bd9Sstevel@tonic-gate */ 70417c478bd9Sstevel@tonic-gate static void 7042facf4a8dSllai set_root_devices_dev_dir(char *dir) 70437c478bd9Sstevel@tonic-gate { 70447c478bd9Sstevel@tonic-gate size_t len; 70457c478bd9Sstevel@tonic-gate 70467c478bd9Sstevel@tonic-gate root_dir = s_strdup(dir); 70477c478bd9Sstevel@tonic-gate len = strlen(dir) + strlen(DEVICES) + 1; 70487c478bd9Sstevel@tonic-gate devices_dir = s_malloc(len); 70497c478bd9Sstevel@tonic-gate (void) snprintf(devices_dir, len, "%s%s", root_dir, DEVICES); 70507c478bd9Sstevel@tonic-gate len = strlen(root_dir) + strlen(DEV) + 1; 70517c478bd9Sstevel@tonic-gate dev_dir = s_malloc(len); 70527c478bd9Sstevel@tonic-gate (void) snprintf(dev_dir, len, "%s%s", root_dir, DEV); 70537c478bd9Sstevel@tonic-gate } 70547c478bd9Sstevel@tonic-gate 70557c478bd9Sstevel@tonic-gate /* 70567c478bd9Sstevel@tonic-gate * Removes quotes. 70577c478bd9Sstevel@tonic-gate */ 70587c478bd9Sstevel@tonic-gate static char * 70597c478bd9Sstevel@tonic-gate dequote(char *src) 70607c478bd9Sstevel@tonic-gate { 70617c478bd9Sstevel@tonic-gate char *dst; 70627c478bd9Sstevel@tonic-gate int len; 70637c478bd9Sstevel@tonic-gate 70647c478bd9Sstevel@tonic-gate len = strlen(src); 70657c478bd9Sstevel@tonic-gate dst = s_malloc(len + 1); 70667c478bd9Sstevel@tonic-gate if (src[0] == '\"' && src[len - 1] == '\"') { 70677c478bd9Sstevel@tonic-gate len -= 2; 70687c478bd9Sstevel@tonic-gate (void) strncpy(dst, &src[1], len); 70697c478bd9Sstevel@tonic-gate dst[len] = '\0'; 70707c478bd9Sstevel@tonic-gate } else { 70717c478bd9Sstevel@tonic-gate (void) strcpy(dst, src); 70727c478bd9Sstevel@tonic-gate } 70737c478bd9Sstevel@tonic-gate return (dst); 70747c478bd9Sstevel@tonic-gate } 70757c478bd9Sstevel@tonic-gate 70767c478bd9Sstevel@tonic-gate /* 70777c478bd9Sstevel@tonic-gate * For a given physical device pathname and spectype, return the 70787c478bd9Sstevel@tonic-gate * ownership and permissions attributes by looking in data from 70797c478bd9Sstevel@tonic-gate * /etc/minor_perm. If currently in installation mode, check for 70807c478bd9Sstevel@tonic-gate * possible major number translations from the miniroot to the installed 70817c478bd9Sstevel@tonic-gate * root's name_to_major table. Note that there can be multiple matches, 70827c478bd9Sstevel@tonic-gate * but the last match takes effect. pts seems to rely on this 70837c478bd9Sstevel@tonic-gate * implementation behavior. 70847c478bd9Sstevel@tonic-gate */ 70857c478bd9Sstevel@tonic-gate static void 70867c478bd9Sstevel@tonic-gate getattr(char *phy_path, char *aminor, int spectype, dev_t dev, mode_t *mode, 70877c478bd9Sstevel@tonic-gate uid_t *uid, gid_t *gid) 70887c478bd9Sstevel@tonic-gate { 70897c478bd9Sstevel@tonic-gate char devname[PATH_MAX + 1]; 70907c478bd9Sstevel@tonic-gate char *node_name; 70917c478bd9Sstevel@tonic-gate char *minor_name; 70927c478bd9Sstevel@tonic-gate int match = FALSE; 70937c478bd9Sstevel@tonic-gate int is_clone; 70947c478bd9Sstevel@tonic-gate int mp_drvname_matches_node_name; 70957c478bd9Sstevel@tonic-gate int mp_drvname_matches_minor_name; 70967c478bd9Sstevel@tonic-gate int mp_drvname_is_clone; 70977c478bd9Sstevel@tonic-gate int mp_drvname_matches_drvname; 70987c478bd9Sstevel@tonic-gate struct mperm *mp; 70997c478bd9Sstevel@tonic-gate major_t major_no; 71007c478bd9Sstevel@tonic-gate char driver[PATH_MAX + 1]; 71017c478bd9Sstevel@tonic-gate 71027c478bd9Sstevel@tonic-gate /* 71037c478bd9Sstevel@tonic-gate * Get the driver name based on the major number since the name 71047c478bd9Sstevel@tonic-gate * in /devices may be generic. Could be running with more major 71057c478bd9Sstevel@tonic-gate * numbers than are in /etc/name_to_major, so get it from the kernel 71067c478bd9Sstevel@tonic-gate */ 71077c478bd9Sstevel@tonic-gate major_no = major(dev); 71087c478bd9Sstevel@tonic-gate 71097c478bd9Sstevel@tonic-gate if (modctl(MODGETNAME, driver, sizeof (driver), &major_no) != 0) { 71107c478bd9Sstevel@tonic-gate /* return default values */ 71117c478bd9Sstevel@tonic-gate goto use_defaults; 71127c478bd9Sstevel@tonic-gate } 71137c478bd9Sstevel@tonic-gate 71147c478bd9Sstevel@tonic-gate (void) strcpy(devname, phy_path); 71157c478bd9Sstevel@tonic-gate 71167c478bd9Sstevel@tonic-gate node_name = strrchr(devname, '/'); /* node name is the last */ 71177c478bd9Sstevel@tonic-gate /* component */ 71187c478bd9Sstevel@tonic-gate if (node_name == NULL) { 71197c478bd9Sstevel@tonic-gate err_print(NO_NODE, devname); 71207c478bd9Sstevel@tonic-gate goto use_defaults; 71217c478bd9Sstevel@tonic-gate } 71227c478bd9Sstevel@tonic-gate 71237c478bd9Sstevel@tonic-gate minor_name = strchr(++node_name, '@'); /* see if it has address part */ 71247c478bd9Sstevel@tonic-gate 71257c478bd9Sstevel@tonic-gate if (minor_name != NULL) { 71267c478bd9Sstevel@tonic-gate *minor_name++ = '\0'; 71277c478bd9Sstevel@tonic-gate } else { 71287c478bd9Sstevel@tonic-gate minor_name = node_name; 71297c478bd9Sstevel@tonic-gate } 71307c478bd9Sstevel@tonic-gate 71317c478bd9Sstevel@tonic-gate minor_name = strchr(minor_name, ':'); /* look for minor name */ 71327c478bd9Sstevel@tonic-gate 71337c478bd9Sstevel@tonic-gate if (minor_name == NULL) { 71347c478bd9Sstevel@tonic-gate err_print(NO_MINOR, devname); 71357c478bd9Sstevel@tonic-gate goto use_defaults; 71367c478bd9Sstevel@tonic-gate } 71377c478bd9Sstevel@tonic-gate *minor_name++ = '\0'; 71387c478bd9Sstevel@tonic-gate 71397c478bd9Sstevel@tonic-gate /* 71407c478bd9Sstevel@tonic-gate * mp->mp_drvname = device name from minor_perm 71417c478bd9Sstevel@tonic-gate * mp->mp_minorname = minor part of device name from 71427c478bd9Sstevel@tonic-gate * minor_perm 71437c478bd9Sstevel@tonic-gate * drvname = name of driver for this device 71447c478bd9Sstevel@tonic-gate */ 71457c478bd9Sstevel@tonic-gate 71467c478bd9Sstevel@tonic-gate is_clone = (strcmp(node_name, "clone") == 0 ? TRUE : FALSE); 71477c478bd9Sstevel@tonic-gate for (mp = minor_perms; mp != NULL; mp = mp->mp_next) { 71487c478bd9Sstevel@tonic-gate mp_drvname_matches_node_name = 71490a653502Swroche (strcmp(mp->mp_drvname, node_name) == 0 ? TRUE : FALSE); 71507c478bd9Sstevel@tonic-gate mp_drvname_matches_minor_name = 71510a653502Swroche (strcmp(mp->mp_drvname, minor_name) == 0 ? TRUE:FALSE); 71527c478bd9Sstevel@tonic-gate mp_drvname_is_clone = 71530a653502Swroche (strcmp(mp->mp_drvname, "clone") == 0 ? TRUE : FALSE); 71547c478bd9Sstevel@tonic-gate mp_drvname_matches_drvname = 71550a653502Swroche (strcmp(mp->mp_drvname, driver) == 0 ? TRUE : FALSE); 71567c478bd9Sstevel@tonic-gate 71577c478bd9Sstevel@tonic-gate /* 71587c478bd9Sstevel@tonic-gate * If one of the following cases is true, then we try to change 71597c478bd9Sstevel@tonic-gate * the permissions if a "shell global pattern match" of 71607c478bd9Sstevel@tonic-gate * mp_>mp_minorname matches minor_name. 71617c478bd9Sstevel@tonic-gate * 71627c478bd9Sstevel@tonic-gate * 1. mp->mp_drvname matches driver. 71637c478bd9Sstevel@tonic-gate * 71647c478bd9Sstevel@tonic-gate * OR 71657c478bd9Sstevel@tonic-gate * 71667c478bd9Sstevel@tonic-gate * 2. mp->mp_drvname matches node_name and this 71677c478bd9Sstevel@tonic-gate * name is an alias of the driver name 71687c478bd9Sstevel@tonic-gate * 71697c478bd9Sstevel@tonic-gate * OR 71707c478bd9Sstevel@tonic-gate * 71717c478bd9Sstevel@tonic-gate * 3. /devices entry is the clone device and either 71727c478bd9Sstevel@tonic-gate * minor_perm entry is the clone device or matches 71737c478bd9Sstevel@tonic-gate * the minor part of the clone device. 71747c478bd9Sstevel@tonic-gate */ 71757c478bd9Sstevel@tonic-gate 71767c478bd9Sstevel@tonic-gate if ((mp_drvname_matches_drvname == TRUE)|| 71777c478bd9Sstevel@tonic-gate ((mp_drvname_matches_node_name == TRUE) && 71787c478bd9Sstevel@tonic-gate (alias(driver, node_name) == TRUE)) || 71797c478bd9Sstevel@tonic-gate ((is_clone == TRUE) && 71807c478bd9Sstevel@tonic-gate ((mp_drvname_is_clone == TRUE) || 71817c478bd9Sstevel@tonic-gate (mp_drvname_matches_minor_name == TRUE)))) { 71827c478bd9Sstevel@tonic-gate /* 71837c478bd9Sstevel@tonic-gate * Check that the minor part of the 71847c478bd9Sstevel@tonic-gate * device name from the minor_perm 71857c478bd9Sstevel@tonic-gate * entry matches and if so, set the 71867c478bd9Sstevel@tonic-gate * permissions. 71877c478bd9Sstevel@tonic-gate * 71887c478bd9Sstevel@tonic-gate * Under real devfs, clone minor name is changed 71897c478bd9Sstevel@tonic-gate * to match the driver name, but minor_perm may 71907c478bd9Sstevel@tonic-gate * not match. We reconcile it here. 71917c478bd9Sstevel@tonic-gate */ 71927c478bd9Sstevel@tonic-gate if (aminor != NULL) 71937c478bd9Sstevel@tonic-gate minor_name = aminor; 71947c478bd9Sstevel@tonic-gate 71957c478bd9Sstevel@tonic-gate if (gmatch(minor_name, mp->mp_minorname) != 0) { 71967c478bd9Sstevel@tonic-gate *uid = mp->mp_uid; 71977c478bd9Sstevel@tonic-gate *gid = mp->mp_gid; 71987c478bd9Sstevel@tonic-gate *mode = spectype | mp->mp_mode; 71997c478bd9Sstevel@tonic-gate match = TRUE; 72007c478bd9Sstevel@tonic-gate } 72017c478bd9Sstevel@tonic-gate } 72027c478bd9Sstevel@tonic-gate } 72037c478bd9Sstevel@tonic-gate 72047c478bd9Sstevel@tonic-gate if (match == TRUE) { 72057c478bd9Sstevel@tonic-gate return; 72067c478bd9Sstevel@tonic-gate } 72077c478bd9Sstevel@tonic-gate 72087c478bd9Sstevel@tonic-gate use_defaults: 72097c478bd9Sstevel@tonic-gate /* not found in minor_perm, so just use default values */ 72107c478bd9Sstevel@tonic-gate *uid = root_uid; 72117c478bd9Sstevel@tonic-gate *gid = sys_gid; 72127c478bd9Sstevel@tonic-gate *mode = (spectype | 0600); 72137c478bd9Sstevel@tonic-gate } 72147c478bd9Sstevel@tonic-gate 72157c478bd9Sstevel@tonic-gate /* 72167c478bd9Sstevel@tonic-gate * Called by devfs_read_minor_perm() to report errors 72177c478bd9Sstevel@tonic-gate * key is: 72187c478bd9Sstevel@tonic-gate * line number: ignoring line number error 72197c478bd9Sstevel@tonic-gate * errno: open/close errors 72207c478bd9Sstevel@tonic-gate * size: alloc errors 72217c478bd9Sstevel@tonic-gate */ 72227c478bd9Sstevel@tonic-gate static void 72237c478bd9Sstevel@tonic-gate minorperm_err_cb(minorperm_err_t mp_err, int key) 72247c478bd9Sstevel@tonic-gate { 72257c478bd9Sstevel@tonic-gate switch (mp_err) { 72267c478bd9Sstevel@tonic-gate case MP_FOPEN_ERR: 72277c478bd9Sstevel@tonic-gate err_print(FOPEN_FAILED, MINOR_PERM_FILE, strerror(key)); 72287c478bd9Sstevel@tonic-gate break; 72297c478bd9Sstevel@tonic-gate case MP_FCLOSE_ERR: 72307c478bd9Sstevel@tonic-gate err_print(FCLOSE_FAILED, MINOR_PERM_FILE, strerror(key)); 72317c478bd9Sstevel@tonic-gate break; 72327c478bd9Sstevel@tonic-gate case MP_IGNORING_LINE_ERR: 72337c478bd9Sstevel@tonic-gate err_print(IGNORING_LINE_IN, key, MINOR_PERM_FILE); 72347c478bd9Sstevel@tonic-gate break; 72357c478bd9Sstevel@tonic-gate case MP_ALLOC_ERR: 72367c478bd9Sstevel@tonic-gate err_print(MALLOC_FAILED, key); 72377c478bd9Sstevel@tonic-gate break; 72387c478bd9Sstevel@tonic-gate case MP_NVLIST_ERR: 72397c478bd9Sstevel@tonic-gate err_print(NVLIST_ERROR, MINOR_PERM_FILE, strerror(key)); 72407c478bd9Sstevel@tonic-gate break; 72417c478bd9Sstevel@tonic-gate case MP_CANT_FIND_USER_ERR: 72427c478bd9Sstevel@tonic-gate err_print(CANT_FIND_USER, DEFAULT_DEV_USER); 72437c478bd9Sstevel@tonic-gate break; 72447c478bd9Sstevel@tonic-gate case MP_CANT_FIND_GROUP_ERR: 72457c478bd9Sstevel@tonic-gate err_print(CANT_FIND_GROUP, DEFAULT_DEV_GROUP); 72467c478bd9Sstevel@tonic-gate break; 72477c478bd9Sstevel@tonic-gate } 72487c478bd9Sstevel@tonic-gate } 72497c478bd9Sstevel@tonic-gate 72507c478bd9Sstevel@tonic-gate static void 72517c478bd9Sstevel@tonic-gate read_minor_perm_file(void) 72527c478bd9Sstevel@tonic-gate { 72537c478bd9Sstevel@tonic-gate static int cached = FALSE; 72547c478bd9Sstevel@tonic-gate static struct stat cached_sb; 72557c478bd9Sstevel@tonic-gate struct stat current_sb; 72567c478bd9Sstevel@tonic-gate 72577c478bd9Sstevel@tonic-gate (void) stat(MINOR_PERM_FILE, ¤t_sb); 72587c478bd9Sstevel@tonic-gate 72597c478bd9Sstevel@tonic-gate /* If already cached, check to see if it is still valid */ 72607c478bd9Sstevel@tonic-gate if (cached == TRUE) { 72617c478bd9Sstevel@tonic-gate 72627c478bd9Sstevel@tonic-gate if (current_sb.st_mtime == cached_sb.st_mtime) { 72637c478bd9Sstevel@tonic-gate vprint(FILES_MID, "%s cache valid\n", MINOR_PERM_FILE); 72647c478bd9Sstevel@tonic-gate return; 72657c478bd9Sstevel@tonic-gate } 72667c478bd9Sstevel@tonic-gate devfs_free_minor_perm(minor_perms); 72677c478bd9Sstevel@tonic-gate minor_perms = NULL; 72687c478bd9Sstevel@tonic-gate } else { 72697c478bd9Sstevel@tonic-gate cached = TRUE; 72707c478bd9Sstevel@tonic-gate } 72717c478bd9Sstevel@tonic-gate 72727c478bd9Sstevel@tonic-gate (void) stat(MINOR_PERM_FILE, &cached_sb); 72737c478bd9Sstevel@tonic-gate 72747c478bd9Sstevel@tonic-gate vprint(FILES_MID, "loading binding file: %s\n", MINOR_PERM_FILE); 72757c478bd9Sstevel@tonic-gate 72767c478bd9Sstevel@tonic-gate minor_perms = devfs_read_minor_perm(minorperm_err_cb); 72777c478bd9Sstevel@tonic-gate } 72787c478bd9Sstevel@tonic-gate 72797c478bd9Sstevel@tonic-gate static void 72807c478bd9Sstevel@tonic-gate load_minor_perm_file(void) 72817c478bd9Sstevel@tonic-gate { 72827c478bd9Sstevel@tonic-gate read_minor_perm_file(); 72837c478bd9Sstevel@tonic-gate if (devfs_load_minor_perm(minor_perms, minorperm_err_cb) != 0) 72847c478bd9Sstevel@tonic-gate err_print(gettext("minor_perm load failed\n")); 72857c478bd9Sstevel@tonic-gate } 72867c478bd9Sstevel@tonic-gate 72877c478bd9Sstevel@tonic-gate static char * 72887c478bd9Sstevel@tonic-gate convert_to_re(char *dev) 72897c478bd9Sstevel@tonic-gate { 72907c478bd9Sstevel@tonic-gate char *p, *l, *out; 72917c478bd9Sstevel@tonic-gate int i; 72927c478bd9Sstevel@tonic-gate 72937c478bd9Sstevel@tonic-gate out = s_malloc(PATH_MAX); 72947c478bd9Sstevel@tonic-gate 72957c478bd9Sstevel@tonic-gate for (l = p = dev, i = 0; (*p != '\0') && (i < (PATH_MAX - 1)); 72967c478bd9Sstevel@tonic-gate ++p, i++) { 72977c478bd9Sstevel@tonic-gate if ((*p == '*') && ((l != p) && (*l == '/'))) { 72987c478bd9Sstevel@tonic-gate out[i++] = '.'; 72997c478bd9Sstevel@tonic-gate out[i] = '+'; 73007c478bd9Sstevel@tonic-gate } else { 73017c478bd9Sstevel@tonic-gate out[i] = *p; 73027c478bd9Sstevel@tonic-gate } 73037c478bd9Sstevel@tonic-gate l = p; 73047c478bd9Sstevel@tonic-gate } 73057c478bd9Sstevel@tonic-gate out[i] = '\0'; 73067c478bd9Sstevel@tonic-gate p = (char *)s_malloc(strlen(out) + 1); 73077c478bd9Sstevel@tonic-gate (void) strlcpy(p, out, strlen(out) + 1); 73087c478bd9Sstevel@tonic-gate free(out); 73097c478bd9Sstevel@tonic-gate 73107c478bd9Sstevel@tonic-gate vprint(FILES_MID, "converted %s -> %s\n", dev, p); 73117c478bd9Sstevel@tonic-gate 73127c478bd9Sstevel@tonic-gate return (p); 73137c478bd9Sstevel@tonic-gate } 73147c478bd9Sstevel@tonic-gate 73157c478bd9Sstevel@tonic-gate static void 73167c478bd9Sstevel@tonic-gate read_logindevperm_file(void) 73177c478bd9Sstevel@tonic-gate { 73187c478bd9Sstevel@tonic-gate static int cached = FALSE; 73197c478bd9Sstevel@tonic-gate static struct stat cached_sb; 73207c478bd9Sstevel@tonic-gate struct stat current_sb; 73217c478bd9Sstevel@tonic-gate struct login_dev *ldev; 73227c478bd9Sstevel@tonic-gate FILE *fp; 73237c478bd9Sstevel@tonic-gate char line[MAX_LDEV_LINE]; 73247c478bd9Sstevel@tonic-gate int ln, perm, rv; 73256e670f77Saj char *cp, *console, *dlist, *dev; 73267c478bd9Sstevel@tonic-gate char *lasts, *devlasts, *permstr, *drv; 73277c478bd9Sstevel@tonic-gate struct driver_list *list, *next; 73287c478bd9Sstevel@tonic-gate 73297c478bd9Sstevel@tonic-gate /* Read logindevperm only when enabled */ 73307c478bd9Sstevel@tonic-gate if (login_dev_enable != TRUE) 73317c478bd9Sstevel@tonic-gate return; 73327c478bd9Sstevel@tonic-gate 73337c478bd9Sstevel@tonic-gate if (cached == TRUE) { 73347c478bd9Sstevel@tonic-gate if (stat(LDEV_FILE, ¤t_sb) == 0 && 73357c478bd9Sstevel@tonic-gate current_sb.st_mtime == cached_sb.st_mtime) { 73367c478bd9Sstevel@tonic-gate vprint(FILES_MID, "%s cache valid\n", LDEV_FILE); 73377c478bd9Sstevel@tonic-gate return; 73387c478bd9Sstevel@tonic-gate } 73397c478bd9Sstevel@tonic-gate vprint(FILES_MID, "invalidating %s cache\n", LDEV_FILE); 73407c478bd9Sstevel@tonic-gate while (login_dev_cache != NULL) { 73417c478bd9Sstevel@tonic-gate 73427c478bd9Sstevel@tonic-gate ldev = login_dev_cache; 73437c478bd9Sstevel@tonic-gate login_dev_cache = ldev->ldev_next; 73447c478bd9Sstevel@tonic-gate free(ldev->ldev_console); 73457c478bd9Sstevel@tonic-gate free(ldev->ldev_device); 73467c478bd9Sstevel@tonic-gate regfree(&ldev->ldev_device_regex); 73477c478bd9Sstevel@tonic-gate list = ldev->ldev_driver_list; 73487c478bd9Sstevel@tonic-gate while (list) { 73497c478bd9Sstevel@tonic-gate next = list->next; 73507c478bd9Sstevel@tonic-gate free(list); 73517c478bd9Sstevel@tonic-gate list = next; 73527c478bd9Sstevel@tonic-gate } 73537c478bd9Sstevel@tonic-gate free(ldev); 73547c478bd9Sstevel@tonic-gate } 73557c478bd9Sstevel@tonic-gate } else { 73567c478bd9Sstevel@tonic-gate cached = TRUE; 73577c478bd9Sstevel@tonic-gate } 73587c478bd9Sstevel@tonic-gate 73597c478bd9Sstevel@tonic-gate assert(login_dev_cache == NULL); 73607c478bd9Sstevel@tonic-gate 73617c478bd9Sstevel@tonic-gate if (stat(LDEV_FILE, &cached_sb) != 0) { 73627c478bd9Sstevel@tonic-gate cached = FALSE; 73637c478bd9Sstevel@tonic-gate return; 73647c478bd9Sstevel@tonic-gate } 73657c478bd9Sstevel@tonic-gate 73667c478bd9Sstevel@tonic-gate vprint(FILES_MID, "loading file: %s\n", LDEV_FILE); 73677c478bd9Sstevel@tonic-gate 73687c478bd9Sstevel@tonic-gate if ((fp = fopen(LDEV_FILE, "r")) == NULL) { 73697c478bd9Sstevel@tonic-gate /* Not fatal to devfsadm */ 73707c478bd9Sstevel@tonic-gate cached = FALSE; 73717c478bd9Sstevel@tonic-gate err_print(FOPEN_FAILED, LDEV_FILE, strerror(errno)); 73727c478bd9Sstevel@tonic-gate return; 73737c478bd9Sstevel@tonic-gate } 73747c478bd9Sstevel@tonic-gate 73757c478bd9Sstevel@tonic-gate ln = 0; 73767c478bd9Sstevel@tonic-gate while (fgets(line, MAX_LDEV_LINE, fp) != NULL) { 73777c478bd9Sstevel@tonic-gate ln++; 73787c478bd9Sstevel@tonic-gate 73797c478bd9Sstevel@tonic-gate /* Remove comments */ 73807c478bd9Sstevel@tonic-gate if ((cp = strchr(line, '#')) != NULL) 73817c478bd9Sstevel@tonic-gate *cp = '\0'; 73827c478bd9Sstevel@tonic-gate 73837c478bd9Sstevel@tonic-gate if ((console = strtok_r(line, LDEV_DELIMS, &lasts)) == NULL) 73847c478bd9Sstevel@tonic-gate continue; /* Blank line */ 73857c478bd9Sstevel@tonic-gate 73867c478bd9Sstevel@tonic-gate if ((permstr = strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) { 73877c478bd9Sstevel@tonic-gate err_print(IGNORING_LINE_IN, ln, LDEV_FILE); 73887c478bd9Sstevel@tonic-gate continue; /* Malformed line */ 73897c478bd9Sstevel@tonic-gate } 73907c478bd9Sstevel@tonic-gate 73917c478bd9Sstevel@tonic-gate /* 73927c478bd9Sstevel@tonic-gate * permstr is string in octal format. Convert to int 73937c478bd9Sstevel@tonic-gate */ 73947c478bd9Sstevel@tonic-gate cp = NULL; 73957c478bd9Sstevel@tonic-gate errno = 0; 73967c478bd9Sstevel@tonic-gate perm = strtol(permstr, &cp, 8); 73977c478bd9Sstevel@tonic-gate if (errno || perm < 0 || perm > 0777 || *cp != '\0') { 73987c478bd9Sstevel@tonic-gate err_print(IGNORING_LINE_IN, ln, LDEV_FILE); 73997c478bd9Sstevel@tonic-gate continue; 74007c478bd9Sstevel@tonic-gate } 74017c478bd9Sstevel@tonic-gate 74026e670f77Saj if ((dlist = strtok_r(NULL, LDEV_DELIMS, &lasts)) == NULL) { 74037c478bd9Sstevel@tonic-gate err_print(IGNORING_LINE_IN, ln, LDEV_FILE); 74047c478bd9Sstevel@tonic-gate continue; 74057c478bd9Sstevel@tonic-gate } 74067c478bd9Sstevel@tonic-gate 74076e670f77Saj dev = strtok_r(dlist, LDEV_DEV_DELIM, &devlasts); 74087c478bd9Sstevel@tonic-gate while (dev) { 74097c478bd9Sstevel@tonic-gate 74107c478bd9Sstevel@tonic-gate ldev = (struct login_dev *)s_zalloc( 74117c478bd9Sstevel@tonic-gate sizeof (struct login_dev)); 74127c478bd9Sstevel@tonic-gate ldev->ldev_console = s_strdup(console); 74137c478bd9Sstevel@tonic-gate ldev->ldev_perms = perm; 74147c478bd9Sstevel@tonic-gate 74157c478bd9Sstevel@tonic-gate /* 74167c478bd9Sstevel@tonic-gate * the logical device name may contain '*' which 74177c478bd9Sstevel@tonic-gate * we convert to a regular expression 74187c478bd9Sstevel@tonic-gate */ 74197c478bd9Sstevel@tonic-gate ldev->ldev_device = convert_to_re(dev); 74207c478bd9Sstevel@tonic-gate if (ldev->ldev_device && 74217c478bd9Sstevel@tonic-gate (rv = regcomp(&ldev->ldev_device_regex, 74227c478bd9Sstevel@tonic-gate ldev->ldev_device, REG_EXTENDED))) { 74237c478bd9Sstevel@tonic-gate bzero(&ldev->ldev_device_regex, 74247c478bd9Sstevel@tonic-gate sizeof (ldev->ldev_device_regex)); 74257c478bd9Sstevel@tonic-gate err_print(REGCOMP_FAILED, 74267c478bd9Sstevel@tonic-gate ldev->ldev_device, rv); 74277c478bd9Sstevel@tonic-gate } 74287c478bd9Sstevel@tonic-gate ldev->ldev_next = login_dev_cache; 74297c478bd9Sstevel@tonic-gate login_dev_cache = ldev; 74307c478bd9Sstevel@tonic-gate dev = strtok_r(NULL, LDEV_DEV_DELIM, &devlasts); 74317c478bd9Sstevel@tonic-gate } 74327c478bd9Sstevel@tonic-gate 74337c478bd9Sstevel@tonic-gate drv = strtok_r(NULL, LDEV_DRVLIST_DELIMS, &lasts); 74347c478bd9Sstevel@tonic-gate if (drv) { 74357c478bd9Sstevel@tonic-gate if (strcmp(drv, LDEV_DRVLIST_NAME) == 0) { 74367c478bd9Sstevel@tonic-gate 74370a653502Swroche drv = strtok_r(NULL, LDEV_DRV_DELIMS, &lasts); 74387c478bd9Sstevel@tonic-gate 74397c478bd9Sstevel@tonic-gate while (drv) { 74407c478bd9Sstevel@tonic-gate vprint(FILES_MID, 74410a653502Swroche "logindevperm driver=%s\n", drv); 74427c478bd9Sstevel@tonic-gate 74437c478bd9Sstevel@tonic-gate /* 74447c478bd9Sstevel@tonic-gate * create a linked list of driver 74457c478bd9Sstevel@tonic-gate * names 74467c478bd9Sstevel@tonic-gate */ 74477c478bd9Sstevel@tonic-gate list = (struct driver_list *) 74487c478bd9Sstevel@tonic-gate s_zalloc( 74497c478bd9Sstevel@tonic-gate sizeof (struct driver_list)); 74507c478bd9Sstevel@tonic-gate (void) strlcpy(list->driver_name, drv, 74517c478bd9Sstevel@tonic-gate sizeof (list->driver_name)); 74527c478bd9Sstevel@tonic-gate list->next = ldev->ldev_driver_list; 74537c478bd9Sstevel@tonic-gate ldev->ldev_driver_list = list; 74547c478bd9Sstevel@tonic-gate drv = strtok_r(NULL, LDEV_DRV_DELIMS, 74557c478bd9Sstevel@tonic-gate &lasts); 74567c478bd9Sstevel@tonic-gate } 74577c478bd9Sstevel@tonic-gate } 74587c478bd9Sstevel@tonic-gate } 74597c478bd9Sstevel@tonic-gate } 74607c478bd9Sstevel@tonic-gate (void) fclose(fp); 74617c478bd9Sstevel@tonic-gate } 74627c478bd9Sstevel@tonic-gate 74637c478bd9Sstevel@tonic-gate /* 74647c478bd9Sstevel@tonic-gate * Tokens are separated by ' ', '\t', ':', '=', '&', '|', ';', '\n', or '\0' 74657c478bd9Sstevel@tonic-gate * 74667c478bd9Sstevel@tonic-gate * Returns DEVFSADM_SUCCESS if token found, DEVFSADM_FAILURE otherwise. 74677c478bd9Sstevel@tonic-gate */ 74687c478bd9Sstevel@tonic-gate static int 74697c478bd9Sstevel@tonic-gate getnexttoken(char *next, char **nextp, char **tokenpp, char *tchar) 74707c478bd9Sstevel@tonic-gate { 74717c478bd9Sstevel@tonic-gate char *cp; 74727c478bd9Sstevel@tonic-gate char *cp1; 74737c478bd9Sstevel@tonic-gate char *tokenp; 74747c478bd9Sstevel@tonic-gate 74757c478bd9Sstevel@tonic-gate cp = next; 74767c478bd9Sstevel@tonic-gate while (*cp == ' ' || *cp == '\t') { 74777c478bd9Sstevel@tonic-gate cp++; /* skip leading spaces */ 74787c478bd9Sstevel@tonic-gate } 74797c478bd9Sstevel@tonic-gate tokenp = cp; /* start of token */ 74807c478bd9Sstevel@tonic-gate while (*cp != '\0' && *cp != '\n' && *cp != ' ' && *cp != '\t' && 74810a653502Swroche *cp != ':' && *cp != '=' && *cp != '&' && 74820a653502Swroche *cp != '|' && *cp != ';') { 74837c478bd9Sstevel@tonic-gate cp++; /* point to next character */ 74847c478bd9Sstevel@tonic-gate } 74857c478bd9Sstevel@tonic-gate /* 74867c478bd9Sstevel@tonic-gate * If terminating character is a space or tab, look ahead to see if 74877c478bd9Sstevel@tonic-gate * there's another terminator that's not a space or a tab. 74887c478bd9Sstevel@tonic-gate * (This code handles trailing spaces.) 74897c478bd9Sstevel@tonic-gate */ 74907c478bd9Sstevel@tonic-gate if (*cp == ' ' || *cp == '\t') { 74917c478bd9Sstevel@tonic-gate cp1 = cp; 74927c478bd9Sstevel@tonic-gate while (*++cp1 == ' ' || *cp1 == '\t') 74937c478bd9Sstevel@tonic-gate ; 74947c478bd9Sstevel@tonic-gate if (*cp1 == '=' || *cp1 == ':' || *cp1 == '&' || *cp1 == '|' || 74950a653502Swroche *cp1 == ';' || *cp1 == '\n' || *cp1 == '\0') { 74967c478bd9Sstevel@tonic-gate *cp = NULL; /* terminate token */ 74977c478bd9Sstevel@tonic-gate cp = cp1; 74987c478bd9Sstevel@tonic-gate } 74997c478bd9Sstevel@tonic-gate } 75007c478bd9Sstevel@tonic-gate if (tchar != NULL) { 75017c478bd9Sstevel@tonic-gate *tchar = *cp; /* save terminating character */ 75027c478bd9Sstevel@tonic-gate if (*tchar == '\0') { 75037c478bd9Sstevel@tonic-gate *tchar = '\n'; 75047c478bd9Sstevel@tonic-gate } 75057c478bd9Sstevel@tonic-gate } 75067c478bd9Sstevel@tonic-gate *cp++ = '\0'; /* terminate token, point to next */ 75077c478bd9Sstevel@tonic-gate *nextp = cp; /* set pointer to next character */ 75087c478bd9Sstevel@tonic-gate if (cp - tokenp - 1 == 0) { 75097c478bd9Sstevel@tonic-gate return (DEVFSADM_FAILURE); 75107c478bd9Sstevel@tonic-gate } 75117c478bd9Sstevel@tonic-gate *tokenpp = tokenp; 75127c478bd9Sstevel@tonic-gate return (DEVFSADM_SUCCESS); 75137c478bd9Sstevel@tonic-gate } 75147c478bd9Sstevel@tonic-gate 75157c478bd9Sstevel@tonic-gate /* 75167c478bd9Sstevel@tonic-gate * read or reread the driver aliases file 75177c478bd9Sstevel@tonic-gate */ 75187c478bd9Sstevel@tonic-gate static void 75197c478bd9Sstevel@tonic-gate read_driver_aliases_file(void) 75207c478bd9Sstevel@tonic-gate { 75217c478bd9Sstevel@tonic-gate 75227c478bd9Sstevel@tonic-gate driver_alias_t *save; 75237c478bd9Sstevel@tonic-gate driver_alias_t *lst_tail; 75247c478bd9Sstevel@tonic-gate driver_alias_t *ap; 75257c478bd9Sstevel@tonic-gate static int cached = FALSE; 75267c478bd9Sstevel@tonic-gate FILE *afd; 75277c478bd9Sstevel@tonic-gate char line[256]; 75287c478bd9Sstevel@tonic-gate char *cp; 75297c478bd9Sstevel@tonic-gate char *p; 75307c478bd9Sstevel@tonic-gate char t; 75317c478bd9Sstevel@tonic-gate int ln = 0; 75327c478bd9Sstevel@tonic-gate static struct stat cached_sb; 75337c478bd9Sstevel@tonic-gate struct stat current_sb; 75347c478bd9Sstevel@tonic-gate 75357c478bd9Sstevel@tonic-gate (void) stat(ALIASFILE, ¤t_sb); 75367c478bd9Sstevel@tonic-gate 75377c478bd9Sstevel@tonic-gate /* If already cached, check to see if it is still valid */ 75387c478bd9Sstevel@tonic-gate if (cached == TRUE) { 75397c478bd9Sstevel@tonic-gate 75407c478bd9Sstevel@tonic-gate if (current_sb.st_mtime == cached_sb.st_mtime) { 75417c478bd9Sstevel@tonic-gate vprint(FILES_MID, "%s cache valid\n", ALIASFILE); 75427c478bd9Sstevel@tonic-gate return; 75437c478bd9Sstevel@tonic-gate } 75447c478bd9Sstevel@tonic-gate 75457c478bd9Sstevel@tonic-gate vprint(FILES_MID, "invalidating %s cache\n", ALIASFILE); 75467c478bd9Sstevel@tonic-gate while (driver_aliases != NULL) { 75477c478bd9Sstevel@tonic-gate free(driver_aliases->alias_name); 75487c478bd9Sstevel@tonic-gate free(driver_aliases->driver_name); 75497c478bd9Sstevel@tonic-gate save = driver_aliases; 75507c478bd9Sstevel@tonic-gate driver_aliases = driver_aliases->next; 75517c478bd9Sstevel@tonic-gate free(save); 75527c478bd9Sstevel@tonic-gate } 75537c478bd9Sstevel@tonic-gate } else { 75547c478bd9Sstevel@tonic-gate cached = TRUE; 75557c478bd9Sstevel@tonic-gate } 75567c478bd9Sstevel@tonic-gate 75577c478bd9Sstevel@tonic-gate (void) stat(ALIASFILE, &cached_sb); 75587c478bd9Sstevel@tonic-gate 75597c478bd9Sstevel@tonic-gate vprint(FILES_MID, "loading binding file: %s\n", ALIASFILE); 75607c478bd9Sstevel@tonic-gate 75617c478bd9Sstevel@tonic-gate if ((afd = fopen(ALIASFILE, "r")) == NULL) { 75627c478bd9Sstevel@tonic-gate err_print(FOPEN_FAILED, ALIASFILE, strerror(errno)); 75637c478bd9Sstevel@tonic-gate devfsadm_exit(1); 7564*537714daSvikram /*NOTREACHED*/ 75657c478bd9Sstevel@tonic-gate } 75667c478bd9Sstevel@tonic-gate 75671ca93273Seota while (fgets(line, sizeof (line), afd) != NULL) { 75687c478bd9Sstevel@tonic-gate ln++; 75691ca93273Seota /* cut off comments starting with '#' */ 75701ca93273Seota if ((cp = strchr(line, '#')) != NULL) 75711ca93273Seota *cp = '\0'; 75721ca93273Seota /* ignore comment or blank lines */ 75731ca93273Seota if (is_blank(line)) 75741ca93273Seota continue; 75757c478bd9Sstevel@tonic-gate cp = line; 75767c478bd9Sstevel@tonic-gate if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) { 75777c478bd9Sstevel@tonic-gate err_print(IGNORING_LINE_IN, ln, ALIASFILE); 75787c478bd9Sstevel@tonic-gate continue; 75797c478bd9Sstevel@tonic-gate } 75807c478bd9Sstevel@tonic-gate if (t == '\n' || t == '\0') { 75817c478bd9Sstevel@tonic-gate err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE); 75827c478bd9Sstevel@tonic-gate continue; 75837c478bd9Sstevel@tonic-gate } 75847c478bd9Sstevel@tonic-gate ap = (struct driver_alias *) 75850a653502Swroche s_zalloc(sizeof (struct driver_alias)); 75867c478bd9Sstevel@tonic-gate ap->driver_name = s_strdup(p); 75877c478bd9Sstevel@tonic-gate if (getnexttoken(cp, &cp, &p, &t) == DEVFSADM_FAILURE) { 75887c478bd9Sstevel@tonic-gate err_print(DRV_BUT_NO_ALIAS, ln, ALIASFILE); 75897c478bd9Sstevel@tonic-gate free(ap->driver_name); 75907c478bd9Sstevel@tonic-gate free(ap); 75917c478bd9Sstevel@tonic-gate continue; 75927c478bd9Sstevel@tonic-gate } 75937c478bd9Sstevel@tonic-gate if (*p == '"') { 75947c478bd9Sstevel@tonic-gate if (p[strlen(p) - 1] == '"') { 75957c478bd9Sstevel@tonic-gate p[strlen(p) - 1] = '\0'; 75967c478bd9Sstevel@tonic-gate p++; 75977c478bd9Sstevel@tonic-gate } 75987c478bd9Sstevel@tonic-gate } 75997c478bd9Sstevel@tonic-gate ap->alias_name = s_strdup(p); 76007c478bd9Sstevel@tonic-gate if (driver_aliases == NULL) { 76017c478bd9Sstevel@tonic-gate driver_aliases = ap; 76027c478bd9Sstevel@tonic-gate lst_tail = ap; 76037c478bd9Sstevel@tonic-gate } else { 76047c478bd9Sstevel@tonic-gate lst_tail->next = ap; 76057c478bd9Sstevel@tonic-gate lst_tail = ap; 76067c478bd9Sstevel@tonic-gate } 76077c478bd9Sstevel@tonic-gate } 76087c478bd9Sstevel@tonic-gate if (fclose(afd) == EOF) { 76097c478bd9Sstevel@tonic-gate err_print(FCLOSE_FAILED, ALIASFILE, strerror(errno)); 76107c478bd9Sstevel@tonic-gate } 76117c478bd9Sstevel@tonic-gate } 76127c478bd9Sstevel@tonic-gate 76137c478bd9Sstevel@tonic-gate /* 76147c478bd9Sstevel@tonic-gate * return TRUE if alias_name is an alias for driver_name, otherwise 76157c478bd9Sstevel@tonic-gate * return FALSE. 76167c478bd9Sstevel@tonic-gate */ 76177c478bd9Sstevel@tonic-gate static int 76187c478bd9Sstevel@tonic-gate alias(char *driver_name, char *alias_name) 76197c478bd9Sstevel@tonic-gate { 76207c478bd9Sstevel@tonic-gate driver_alias_t *alias; 76217c478bd9Sstevel@tonic-gate 76227c478bd9Sstevel@tonic-gate /* 76237c478bd9Sstevel@tonic-gate * check for a match 76247c478bd9Sstevel@tonic-gate */ 76257c478bd9Sstevel@tonic-gate for (alias = driver_aliases; alias != NULL; alias = alias->next) { 76267c478bd9Sstevel@tonic-gate if ((strcmp(alias->driver_name, driver_name) == 0) && 76277c478bd9Sstevel@tonic-gate (strcmp(alias->alias_name, alias_name) == 0)) { 76287c478bd9Sstevel@tonic-gate return (TRUE); 76297c478bd9Sstevel@tonic-gate } 76307c478bd9Sstevel@tonic-gate } 76317c478bd9Sstevel@tonic-gate return (FALSE); 76327c478bd9Sstevel@tonic-gate } 76337c478bd9Sstevel@tonic-gate 76347c478bd9Sstevel@tonic-gate /* 76357c478bd9Sstevel@tonic-gate * convenience functions 76367c478bd9Sstevel@tonic-gate */ 7637facf4a8dSllai static int 7638facf4a8dSllai s_stat(const char *path, struct stat *sbufp) 7639facf4a8dSllai { 7640facf4a8dSllai int rv; 7641facf4a8dSllai retry: 7642facf4a8dSllai if ((rv = stat(path, sbufp)) == -1) { 7643facf4a8dSllai if (errno == EINTR) 7644facf4a8dSllai goto retry; 7645facf4a8dSllai } 7646facf4a8dSllai return (rv); 7647facf4a8dSllai } 7648facf4a8dSllai 76497c478bd9Sstevel@tonic-gate static void * 76507c478bd9Sstevel@tonic-gate s_malloc(const size_t size) 76517c478bd9Sstevel@tonic-gate { 76527c478bd9Sstevel@tonic-gate void *rp; 76537c478bd9Sstevel@tonic-gate 76547c478bd9Sstevel@tonic-gate rp = malloc(size); 76557c478bd9Sstevel@tonic-gate if (rp == NULL) { 76567c478bd9Sstevel@tonic-gate err_print(MALLOC_FAILED, size); 76577c478bd9Sstevel@tonic-gate devfsadm_exit(1); 7658*537714daSvikram /*NOTREACHED*/ 76597c478bd9Sstevel@tonic-gate } 76607c478bd9Sstevel@tonic-gate return (rp); 76617c478bd9Sstevel@tonic-gate } 76627c478bd9Sstevel@tonic-gate 76637c478bd9Sstevel@tonic-gate /* 76647c478bd9Sstevel@tonic-gate * convenience functions 76657c478bd9Sstevel@tonic-gate */ 76667c478bd9Sstevel@tonic-gate static void * 76677c478bd9Sstevel@tonic-gate s_realloc(void *ptr, const size_t size) 76687c478bd9Sstevel@tonic-gate { 76697c478bd9Sstevel@tonic-gate ptr = realloc(ptr, size); 76707c478bd9Sstevel@tonic-gate if (ptr == NULL) { 76717c478bd9Sstevel@tonic-gate err_print(REALLOC_FAILED, size); 76727c478bd9Sstevel@tonic-gate devfsadm_exit(1); 7673*537714daSvikram /*NOTREACHED*/ 76747c478bd9Sstevel@tonic-gate } 76757c478bd9Sstevel@tonic-gate return (ptr); 76767c478bd9Sstevel@tonic-gate } 76777c478bd9Sstevel@tonic-gate 76787c478bd9Sstevel@tonic-gate static void * 76797c478bd9Sstevel@tonic-gate s_zalloc(const size_t size) 76807c478bd9Sstevel@tonic-gate { 76817c478bd9Sstevel@tonic-gate void *rp; 76827c478bd9Sstevel@tonic-gate 76837c478bd9Sstevel@tonic-gate rp = calloc(1, size); 76847c478bd9Sstevel@tonic-gate if (rp == NULL) { 76857c478bd9Sstevel@tonic-gate err_print(CALLOC_FAILED, size); 76867c478bd9Sstevel@tonic-gate devfsadm_exit(1); 7687*537714daSvikram /*NOTREACHED*/ 76887c478bd9Sstevel@tonic-gate } 76897c478bd9Sstevel@tonic-gate return (rp); 76907c478bd9Sstevel@tonic-gate } 76917c478bd9Sstevel@tonic-gate 76927c478bd9Sstevel@tonic-gate char * 76937c478bd9Sstevel@tonic-gate s_strdup(const char *ptr) 76947c478bd9Sstevel@tonic-gate { 76957c478bd9Sstevel@tonic-gate void *rp; 76967c478bd9Sstevel@tonic-gate 76977c478bd9Sstevel@tonic-gate rp = strdup(ptr); 76987c478bd9Sstevel@tonic-gate if (rp == NULL) { 76997c478bd9Sstevel@tonic-gate err_print(STRDUP_FAILED, ptr); 77007c478bd9Sstevel@tonic-gate devfsadm_exit(1); 7701*537714daSvikram /*NOTREACHED*/ 77027c478bd9Sstevel@tonic-gate } 77037c478bd9Sstevel@tonic-gate return (rp); 77047c478bd9Sstevel@tonic-gate } 77057c478bd9Sstevel@tonic-gate 77067c478bd9Sstevel@tonic-gate static void 77077c478bd9Sstevel@tonic-gate s_closedir(DIR *dirp) 77087c478bd9Sstevel@tonic-gate { 77097c478bd9Sstevel@tonic-gate retry: 77107c478bd9Sstevel@tonic-gate if (closedir(dirp) != 0) { 77117c478bd9Sstevel@tonic-gate if (errno == EINTR) 77127c478bd9Sstevel@tonic-gate goto retry; 77137c478bd9Sstevel@tonic-gate err_print(CLOSEDIR_FAILED, strerror(errno)); 77147c478bd9Sstevel@tonic-gate } 77157c478bd9Sstevel@tonic-gate } 77167c478bd9Sstevel@tonic-gate 77177c478bd9Sstevel@tonic-gate static void 77187c478bd9Sstevel@tonic-gate s_mkdirp(const char *path, const mode_t mode) 77197c478bd9Sstevel@tonic-gate { 77207c478bd9Sstevel@tonic-gate vprint(CHATTY_MID, "mkdirp(%s, 0x%lx)\n", path, mode); 77217c478bd9Sstevel@tonic-gate if (mkdirp(path, mode) == -1) { 77227c478bd9Sstevel@tonic-gate if (errno != EEXIST) { 77237c478bd9Sstevel@tonic-gate err_print(MKDIR_FAILED, path, mode, strerror(errno)); 77247c478bd9Sstevel@tonic-gate } 77257c478bd9Sstevel@tonic-gate } 77267c478bd9Sstevel@tonic-gate } 77277c478bd9Sstevel@tonic-gate 77287c478bd9Sstevel@tonic-gate static void 77297c478bd9Sstevel@tonic-gate s_unlink(const char *file) 77307c478bd9Sstevel@tonic-gate { 77317c478bd9Sstevel@tonic-gate retry: 77327c478bd9Sstevel@tonic-gate if (unlink(file) == -1) { 77337c478bd9Sstevel@tonic-gate if (errno == EINTR || errno == EAGAIN) 77347c478bd9Sstevel@tonic-gate goto retry; 77357c478bd9Sstevel@tonic-gate if (errno != ENOENT) { 77367c478bd9Sstevel@tonic-gate err_print(UNLINK_FAILED, file, strerror(errno)); 77377c478bd9Sstevel@tonic-gate } 77387c478bd9Sstevel@tonic-gate } 77397c478bd9Sstevel@tonic-gate } 77407c478bd9Sstevel@tonic-gate 77417c478bd9Sstevel@tonic-gate static void 77427c478bd9Sstevel@tonic-gate add_verbose_id(char *mid) 77437c478bd9Sstevel@tonic-gate { 77447c478bd9Sstevel@tonic-gate num_verbose++; 77457c478bd9Sstevel@tonic-gate verbose = s_realloc(verbose, num_verbose * sizeof (char *)); 77467c478bd9Sstevel@tonic-gate verbose[num_verbose - 1] = mid; 77477c478bd9Sstevel@tonic-gate } 77487c478bd9Sstevel@tonic-gate 77497c478bd9Sstevel@tonic-gate /* 77507c478bd9Sstevel@tonic-gate * returns DEVFSADM_TRUE if contents is a minor node in /devices. 77517c478bd9Sstevel@tonic-gate * If mn_root is not NULL, mn_root is set to: 77527c478bd9Sstevel@tonic-gate * if contents is a /dev node, mn_root = contents 77537c478bd9Sstevel@tonic-gate * OR 77547c478bd9Sstevel@tonic-gate * if contents is a /devices node, mn_root set to the '/' 77557c478bd9Sstevel@tonic-gate * following /devices. 77567c478bd9Sstevel@tonic-gate */ 77577c478bd9Sstevel@tonic-gate static int 77587c478bd9Sstevel@tonic-gate is_minor_node(char *contents, char **mn_root) 77597c478bd9Sstevel@tonic-gate { 77607c478bd9Sstevel@tonic-gate char *ptr; 77617c478bd9Sstevel@tonic-gate char device_prefix[100]; 77627c478bd9Sstevel@tonic-gate 77637c478bd9Sstevel@tonic-gate (void) snprintf(device_prefix, sizeof (device_prefix), "../devices/"); 77647c478bd9Sstevel@tonic-gate 77657c478bd9Sstevel@tonic-gate if ((ptr = strstr(contents, device_prefix)) != NULL) { 77667c478bd9Sstevel@tonic-gate if (mn_root != NULL) { 77677c478bd9Sstevel@tonic-gate /* mn_root should point to the / following /devices */ 77687c478bd9Sstevel@tonic-gate *mn_root = ptr += strlen(device_prefix) - 1; 77697c478bd9Sstevel@tonic-gate } 77707c478bd9Sstevel@tonic-gate return (DEVFSADM_TRUE); 77717c478bd9Sstevel@tonic-gate } 77727c478bd9Sstevel@tonic-gate 77737c478bd9Sstevel@tonic-gate (void) snprintf(device_prefix, sizeof (device_prefix), "/devices/"); 77747c478bd9Sstevel@tonic-gate 77757c478bd9Sstevel@tonic-gate if (strncmp(contents, device_prefix, strlen(device_prefix)) == 0) { 77767c478bd9Sstevel@tonic-gate if (mn_root != NULL) { 77777c478bd9Sstevel@tonic-gate /* mn_root should point to the / following /devices */ 77787c478bd9Sstevel@tonic-gate *mn_root = contents + strlen(device_prefix) - 1; 77797c478bd9Sstevel@tonic-gate } 77807c478bd9Sstevel@tonic-gate return (DEVFSADM_TRUE); 77817c478bd9Sstevel@tonic-gate } 77827c478bd9Sstevel@tonic-gate 77837c478bd9Sstevel@tonic-gate if (mn_root != NULL) { 77847c478bd9Sstevel@tonic-gate *mn_root = contents; 77857c478bd9Sstevel@tonic-gate } 77867c478bd9Sstevel@tonic-gate return (DEVFSADM_FALSE); 77877c478bd9Sstevel@tonic-gate } 77887c478bd9Sstevel@tonic-gate 77897c478bd9Sstevel@tonic-gate /* 77907c478bd9Sstevel@tonic-gate * Lookup nvpair corresponding to the given name and type: 77917c478bd9Sstevel@tonic-gate * 77927c478bd9Sstevel@tonic-gate * The standard nvlist_lookup functions in libnvpair don't work as our 77937c478bd9Sstevel@tonic-gate * nvlist is not allocated with NV_UNIQUE_NAME or NV_UNIQUE_NAME_TYPE. 77947c478bd9Sstevel@tonic-gate */ 77957c478bd9Sstevel@tonic-gate static nvpair_t * 77967c478bd9Sstevel@tonic-gate lookup_nvpair(nvlist_t *nvl, char *name, data_type_t type) 77977c478bd9Sstevel@tonic-gate { 77987c478bd9Sstevel@tonic-gate nvpair_t *nvp; 77997c478bd9Sstevel@tonic-gate 78007c478bd9Sstevel@tonic-gate for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL; 78017c478bd9Sstevel@tonic-gate nvp = nvlist_next_nvpair(nvl, nvp)) { 78027c478bd9Sstevel@tonic-gate if (strcmp(name, nvpair_name(nvp)) == 0 && 78037c478bd9Sstevel@tonic-gate nvpair_type(nvp) == type) 78047c478bd9Sstevel@tonic-gate return (nvp); 78057c478bd9Sstevel@tonic-gate } 78067c478bd9Sstevel@tonic-gate 78077c478bd9Sstevel@tonic-gate return (NULL); 78087c478bd9Sstevel@tonic-gate } 78097c478bd9Sstevel@tonic-gate 78107c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 78117c478bd9Sstevel@tonic-gate static void 78127c478bd9Sstevel@tonic-gate process_rcm_events(void *arg) 78137c478bd9Sstevel@tonic-gate { 78147c478bd9Sstevel@tonic-gate struct rcm_eventq *ev, *ev_next; 7815210db224Sericheng nvpair_t *nvp; 7816210db224Sericheng char *path, *driver; 7817210db224Sericheng int instance; 7818210db224Sericheng int err; 78197c478bd9Sstevel@tonic-gate int need_to_exit; 78207c478bd9Sstevel@tonic-gate 78217c478bd9Sstevel@tonic-gate for (;;) { 78227c478bd9Sstevel@tonic-gate (void) mutex_lock(&rcm_eventq_lock); 78237c478bd9Sstevel@tonic-gate while (rcm_eventq_head == NULL && 78247c478bd9Sstevel@tonic-gate need_to_exit_rcm_event_thread == 0) 78257c478bd9Sstevel@tonic-gate (void) cond_wait(&rcm_eventq_cv, &rcm_eventq_lock); 78267c478bd9Sstevel@tonic-gate 78277c478bd9Sstevel@tonic-gate need_to_exit = need_to_exit_rcm_event_thread; 78287c478bd9Sstevel@tonic-gate ev = rcm_eventq_head; 78297c478bd9Sstevel@tonic-gate rcm_eventq_head = rcm_eventq_tail = NULL; 78307c478bd9Sstevel@tonic-gate (void) mutex_unlock(&rcm_eventq_lock); 78317c478bd9Sstevel@tonic-gate 78327c478bd9Sstevel@tonic-gate for (; ev != NULL; ev = ev_next) { 78337c478bd9Sstevel@tonic-gate /* 78347c478bd9Sstevel@tonic-gate * Private notification interface to RCM: 78357c478bd9Sstevel@tonic-gate * Do not retry the RCM notification on an error since 78367c478bd9Sstevel@tonic-gate * we do not know whether the failure occurred in 78377c478bd9Sstevel@tonic-gate * librcm, rcm_daemon or rcm modules or scripts. 78387c478bd9Sstevel@tonic-gate */ 7839210db224Sericheng if (librcm_notify_event(rcm_hdl, 7840210db224Sericheng RCM_RESOURCE_NETWORK_NEW, 0, ev->nvl, NULL) 7841210db224Sericheng != RCM_SUCCESS) { 7842210db224Sericheng 7843210db224Sericheng err = errno; 7844210db224Sericheng 7845210db224Sericheng if (((nvp = lookup_nvpair(ev->nvl, 7846210db224Sericheng RCM_NV_DEVFS_PATH, DATA_TYPE_STRING)) 7847210db224Sericheng == NULL) || 7848210db224Sericheng (nvpair_value_string(nvp, &path) != 0)) 78490a653502Swroche path = "unknown"; 7850210db224Sericheng 7851210db224Sericheng if (((nvp = lookup_nvpair(ev->nvl, 7852210db224Sericheng RCM_NV_DRIVER_NAME, DATA_TYPE_STRING)) 7853210db224Sericheng == NULL) || 7854210db224Sericheng (nvpair_value_string(nvp, &driver) != 0)) 78550a653502Swroche driver = "unknown"; 7856210db224Sericheng if (((nvp = lookup_nvpair(ev->nvl, 7857210db224Sericheng RCM_NV_INSTANCE, DATA_TYPE_INT32)) 7858210db224Sericheng == NULL) || 7859210db224Sericheng (nvpair_value_int32(nvp, &instance) != 0)) 78600a653502Swroche instance = -1; 7861210db224Sericheng 7862210db224Sericheng err_print(RCM_NOTIFY_FAILED, path, driver, 7863210db224Sericheng instance, strerror(err)); 7864210db224Sericheng } 78657c478bd9Sstevel@tonic-gate 78667c478bd9Sstevel@tonic-gate ev_next = ev->next; 78677c478bd9Sstevel@tonic-gate nvlist_free(ev->nvl); 78687c478bd9Sstevel@tonic-gate free(ev); 78697c478bd9Sstevel@tonic-gate } 78707c478bd9Sstevel@tonic-gate 78717c478bd9Sstevel@tonic-gate if (need_to_exit) 78727c478bd9Sstevel@tonic-gate return; 78737c478bd9Sstevel@tonic-gate } 78747c478bd9Sstevel@tonic-gate } 78757c478bd9Sstevel@tonic-gate 78767c478bd9Sstevel@tonic-gate /* 78777c478bd9Sstevel@tonic-gate * Initialize rcm related handles and function pointers. 78787c478bd9Sstevel@tonic-gate * Since RCM need not present in miniroot, we dlopen librcm. 78797c478bd9Sstevel@tonic-gate */ 78807c478bd9Sstevel@tonic-gate static int 78817c478bd9Sstevel@tonic-gate rcm_init(void) 78827c478bd9Sstevel@tonic-gate { 7883d62bc4baSyz #define LIBRCM_PATH "/lib/librcm.so" 78847c478bd9Sstevel@tonic-gate rcm_handle_t *hdl = NULL; 78857c478bd9Sstevel@tonic-gate int err; 78867c478bd9Sstevel@tonic-gate 78877c478bd9Sstevel@tonic-gate if ((librcm_hdl = dlopen(LIBRCM_PATH, RTLD_LAZY)) == NULL) { 78887c478bd9Sstevel@tonic-gate /* 78897c478bd9Sstevel@tonic-gate * don't log an error here, since librcm may not be present 78907c478bd9Sstevel@tonic-gate * in miniroot. 78917c478bd9Sstevel@tonic-gate */ 78927c478bd9Sstevel@tonic-gate return (-1); 78937c478bd9Sstevel@tonic-gate } 78947c478bd9Sstevel@tonic-gate 78957c478bd9Sstevel@tonic-gate librcm_alloc_handle = (int (*)())dlsym(librcm_hdl, "rcm_alloc_handle"); 78967c478bd9Sstevel@tonic-gate librcm_free_handle = (void (*)())dlsym(librcm_hdl, "rcm_free_handle"); 78977c478bd9Sstevel@tonic-gate librcm_notify_event = (int (*)())dlsym(librcm_hdl, "rcm_notify_event"); 78987c478bd9Sstevel@tonic-gate 78997c478bd9Sstevel@tonic-gate if (librcm_alloc_handle == NULL || librcm_notify_event == NULL || 79007c478bd9Sstevel@tonic-gate librcm_free_handle == NULL) { 79017c478bd9Sstevel@tonic-gate err_print(MISSING_SYMBOLS, LIBRCM_PATH); 79027c478bd9Sstevel@tonic-gate goto out; 79037c478bd9Sstevel@tonic-gate } 79047c478bd9Sstevel@tonic-gate 79057c478bd9Sstevel@tonic-gate /* Initialize the rcm handle */ 79067c478bd9Sstevel@tonic-gate if (librcm_alloc_handle(NULL, 0, NULL, &hdl) != RCM_SUCCESS) { 79077c478bd9Sstevel@tonic-gate err_print(RCM_ALLOC_HANDLE_ERROR); 79087c478bd9Sstevel@tonic-gate goto out; 79097c478bd9Sstevel@tonic-gate } 79107c478bd9Sstevel@tonic-gate 79117c478bd9Sstevel@tonic-gate (void) cond_init(&rcm_eventq_cv, USYNC_THREAD, 0); 79127c478bd9Sstevel@tonic-gate (void) mutex_init(&rcm_eventq_lock, USYNC_THREAD, 0); 79137c478bd9Sstevel@tonic-gate 79147c478bd9Sstevel@tonic-gate /* create a thread to notify RCM of events */ 79157c478bd9Sstevel@tonic-gate if ((err = thr_create(NULL, 0, (void *(*)(void *))process_rcm_events, 79167c478bd9Sstevel@tonic-gate NULL, 0, &process_rcm_events_tid)) != 0) { 79177c478bd9Sstevel@tonic-gate err_print(CANT_CREATE_THREAD, "process_rcm_events", 79187c478bd9Sstevel@tonic-gate strerror(err)); 79197c478bd9Sstevel@tonic-gate goto out; 79207c478bd9Sstevel@tonic-gate } 79217c478bd9Sstevel@tonic-gate 79227c478bd9Sstevel@tonic-gate rcm_hdl = hdl; 79237c478bd9Sstevel@tonic-gate return (0); 79247c478bd9Sstevel@tonic-gate 79257c478bd9Sstevel@tonic-gate out: 79267c478bd9Sstevel@tonic-gate if (hdl) 79277c478bd9Sstevel@tonic-gate librcm_free_handle(hdl); 79287c478bd9Sstevel@tonic-gate (void) dlclose(librcm_hdl); 79297c478bd9Sstevel@tonic-gate return (-1); 79307c478bd9Sstevel@tonic-gate } 79317c478bd9Sstevel@tonic-gate 79327c478bd9Sstevel@tonic-gate /* 79337c478bd9Sstevel@tonic-gate * Build an nvlist using the minor data. Pack it and add the packed nvlist 79347c478bd9Sstevel@tonic-gate * as a byte array to nv_list parameter. 79357c478bd9Sstevel@tonic-gate * Return 0 on success, errno on failure. 79367c478bd9Sstevel@tonic-gate */ 79377c478bd9Sstevel@tonic-gate static int 79387c478bd9Sstevel@tonic-gate add_minor_data_to_nvl(nvlist_t *nv_list, di_minor_t minor) 79397c478bd9Sstevel@tonic-gate { 79407c478bd9Sstevel@tonic-gate nvlist_t *nvl = NULL; 79417c478bd9Sstevel@tonic-gate int32_t minor_type; 79427c478bd9Sstevel@tonic-gate char *minor_name, *minor_node_type; 79437c478bd9Sstevel@tonic-gate int err; 79447c478bd9Sstevel@tonic-gate char *buf = NULL; 79457c478bd9Sstevel@tonic-gate size_t buflen = 0; 79467c478bd9Sstevel@tonic-gate 79477c478bd9Sstevel@tonic-gate if ((err = nvlist_alloc(&nvl, 0, 0)) != 0) 79487c478bd9Sstevel@tonic-gate return (err); 79497c478bd9Sstevel@tonic-gate 79507c478bd9Sstevel@tonic-gate minor_type = (int32_t)di_minor_type(minor); 79517c478bd9Sstevel@tonic-gate if ((err = nvlist_add_int32(nvl, RCM_NV_MINOR_TYPE, minor_type)) != 0) 79527c478bd9Sstevel@tonic-gate goto error; 79537c478bd9Sstevel@tonic-gate 79547c478bd9Sstevel@tonic-gate minor_name = di_minor_name(minor); 79557c478bd9Sstevel@tonic-gate if ((err = nvlist_add_string(nvl, RCM_NV_MINOR_NAME, minor_name)) != 0) 79567c478bd9Sstevel@tonic-gate goto error; 79577c478bd9Sstevel@tonic-gate 79587c478bd9Sstevel@tonic-gate if ((minor_node_type = di_minor_nodetype(minor)) == NULL) 79597c478bd9Sstevel@tonic-gate minor_node_type = ""; 79607c478bd9Sstevel@tonic-gate if ((err = nvlist_add_string(nvl, RCM_NV_MINOR_NODE_TYPE, 79617c478bd9Sstevel@tonic-gate minor_node_type)) != 0) 79627c478bd9Sstevel@tonic-gate goto error; 79637c478bd9Sstevel@tonic-gate 79647c478bd9Sstevel@tonic-gate if ((err = nvlist_pack(nvl, &buf, &buflen, NV_ENCODE_NATIVE, 0)) != 0) 79657c478bd9Sstevel@tonic-gate goto error; 79667c478bd9Sstevel@tonic-gate 79677c478bd9Sstevel@tonic-gate err = nvlist_add_byte_array(nv_list, RCM_NV_MINOR_DATA, 79687c478bd9Sstevel@tonic-gate (uchar_t *)(buf), (uint_t)(buflen)); 79697c478bd9Sstevel@tonic-gate 79707c478bd9Sstevel@tonic-gate error: 79717c478bd9Sstevel@tonic-gate nvlist_free(nvl); 79727c478bd9Sstevel@tonic-gate if (buf) 79737c478bd9Sstevel@tonic-gate free(buf); 79747c478bd9Sstevel@tonic-gate return (err); 79757c478bd9Sstevel@tonic-gate } 79767c478bd9Sstevel@tonic-gate 79777c478bd9Sstevel@tonic-gate static void 79787c478bd9Sstevel@tonic-gate enqueue_rcm_event(nvlist_t *nvl) 79797c478bd9Sstevel@tonic-gate { 79807c478bd9Sstevel@tonic-gate struct rcm_eventq *ev; 79817c478bd9Sstevel@tonic-gate 79827c478bd9Sstevel@tonic-gate ev = (struct rcm_eventq *)s_zalloc(sizeof (struct rcm_eventq)); 79837c478bd9Sstevel@tonic-gate ev->nvl = nvl; 79847c478bd9Sstevel@tonic-gate 79857c478bd9Sstevel@tonic-gate (void) mutex_lock(&rcm_eventq_lock); 79867c478bd9Sstevel@tonic-gate if (rcm_eventq_head == NULL) 79877c478bd9Sstevel@tonic-gate rcm_eventq_head = ev; 79887c478bd9Sstevel@tonic-gate else 79897c478bd9Sstevel@tonic-gate rcm_eventq_tail->next = ev; 79907c478bd9Sstevel@tonic-gate rcm_eventq_tail = ev; 79917c478bd9Sstevel@tonic-gate (void) cond_broadcast(&rcm_eventq_cv); 79927c478bd9Sstevel@tonic-gate (void) mutex_unlock(&rcm_eventq_lock); 79937c478bd9Sstevel@tonic-gate } 79947c478bd9Sstevel@tonic-gate 79957c478bd9Sstevel@tonic-gate /* 79967c478bd9Sstevel@tonic-gate * Generate an nvlist using the information given in node and minor_name. 79977c478bd9Sstevel@tonic-gate * If minor_name is NULL the nvlist will contain information on 79987c478bd9Sstevel@tonic-gate * all minor nodes. Otherwise the nvlist will contain information 79997c478bd9Sstevel@tonic-gate * only on the given minor_name. Notify RCM passing the nvlist. 80007c478bd9Sstevel@tonic-gate * 80017c478bd9Sstevel@tonic-gate * Return 0 upon successfully notifying RCM, errno on failure. 80027c478bd9Sstevel@tonic-gate */ 80037c478bd9Sstevel@tonic-gate static int 80047c478bd9Sstevel@tonic-gate notify_rcm(di_node_t node, char *minor_name) 80057c478bd9Sstevel@tonic-gate { 80067c478bd9Sstevel@tonic-gate nvlist_t *nvl = NULL; 80077c478bd9Sstevel@tonic-gate char *path, *driver_name; 80087c478bd9Sstevel@tonic-gate char *node_name; 80097c478bd9Sstevel@tonic-gate int err; 80107c478bd9Sstevel@tonic-gate int32_t instance; 80117c478bd9Sstevel@tonic-gate di_minor_t minor; 80127c478bd9Sstevel@tonic-gate 80137c478bd9Sstevel@tonic-gate if ((driver_name = di_driver_name(node)) == NULL) 80147c478bd9Sstevel@tonic-gate driver_name = ""; 80157c478bd9Sstevel@tonic-gate 80167c478bd9Sstevel@tonic-gate instance = (int32_t)di_instance(node); 80177c478bd9Sstevel@tonic-gate 80187c478bd9Sstevel@tonic-gate if ((path = di_devfs_path(node)) == NULL) { 80197c478bd9Sstevel@tonic-gate err = errno; 80207c478bd9Sstevel@tonic-gate goto error; 80217c478bd9Sstevel@tonic-gate } 80227c478bd9Sstevel@tonic-gate 80237c478bd9Sstevel@tonic-gate if ((err = nvlist_alloc(&nvl, 0, 0)) != 0) 80247c478bd9Sstevel@tonic-gate goto error; 80257c478bd9Sstevel@tonic-gate 80267c478bd9Sstevel@tonic-gate if ((err = nvlist_add_string(nvl, RCM_NV_DRIVER_NAME, driver_name)) 80277c478bd9Sstevel@tonic-gate != 0) 80287c478bd9Sstevel@tonic-gate goto error; 80297c478bd9Sstevel@tonic-gate 80307c478bd9Sstevel@tonic-gate if ((err = nvlist_add_int32(nvl, RCM_NV_INSTANCE, instance)) != 0) 80317c478bd9Sstevel@tonic-gate goto error; 80327c478bd9Sstevel@tonic-gate 80337c478bd9Sstevel@tonic-gate if ((node_name = di_node_name(node)) == NULL) 80347c478bd9Sstevel@tonic-gate node_name = ""; 80357c478bd9Sstevel@tonic-gate if ((err = nvlist_add_string(nvl, RCM_NV_NODE_NAME, node_name)) != 0) 80367c478bd9Sstevel@tonic-gate goto error; 80377c478bd9Sstevel@tonic-gate 80387c478bd9Sstevel@tonic-gate if ((err = nvlist_add_string(nvl, RCM_NV_DEVFS_PATH, path)) != 0) 80397c478bd9Sstevel@tonic-gate goto error; 80407c478bd9Sstevel@tonic-gate 80417c478bd9Sstevel@tonic-gate minor = di_minor_next(node, DI_MINOR_NIL); 80427c478bd9Sstevel@tonic-gate while (minor != DI_MINOR_NIL) { 80437c478bd9Sstevel@tonic-gate if ((minor_name == NULL) || 80447c478bd9Sstevel@tonic-gate (strcmp(minor_name, di_minor_name(minor)) == 0)) { 80457c478bd9Sstevel@tonic-gate if ((err = add_minor_data_to_nvl(nvl, minor)) != 0) 80467c478bd9Sstevel@tonic-gate goto error; 80477c478bd9Sstevel@tonic-gate } 80487c478bd9Sstevel@tonic-gate minor = di_minor_next(node, minor); 80497c478bd9Sstevel@tonic-gate } 80507c478bd9Sstevel@tonic-gate 80517c478bd9Sstevel@tonic-gate enqueue_rcm_event(nvl); 80527c478bd9Sstevel@tonic-gate di_devfs_path_free(path); 80537c478bd9Sstevel@tonic-gate return (0); 80547c478bd9Sstevel@tonic-gate 80557c478bd9Sstevel@tonic-gate error: 80567c478bd9Sstevel@tonic-gate err_print(RCM_NVLIST_BUILD_ERROR, ((path != NULL) ? path : "unknown"), 80577c478bd9Sstevel@tonic-gate driver_name, instance, strerror(err)); 80587c478bd9Sstevel@tonic-gate 80597c478bd9Sstevel@tonic-gate if (path) 80607c478bd9Sstevel@tonic-gate di_devfs_path_free(path); 80617c478bd9Sstevel@tonic-gate if (nvl) 80627c478bd9Sstevel@tonic-gate nvlist_free(nvl); 80637c478bd9Sstevel@tonic-gate return (err); 80647c478bd9Sstevel@tonic-gate } 80657c478bd9Sstevel@tonic-gate 80667c478bd9Sstevel@tonic-gate /* 80677c478bd9Sstevel@tonic-gate * Add the specified property to nvl. 80687c478bd9Sstevel@tonic-gate * Returns: 80697c478bd9Sstevel@tonic-gate * 0 successfully added 80707c478bd9Sstevel@tonic-gate * -1 an error occurred 80717c478bd9Sstevel@tonic-gate * 1 could not add the property for reasons not due to errors. 80727c478bd9Sstevel@tonic-gate */ 80737c478bd9Sstevel@tonic-gate static int 80747c478bd9Sstevel@tonic-gate add_property(nvlist_t *nvl, di_prop_t prop) 80757c478bd9Sstevel@tonic-gate { 80767c478bd9Sstevel@tonic-gate char *name; 80777c478bd9Sstevel@tonic-gate char *attr_name; 80787c478bd9Sstevel@tonic-gate int n, len; 80797c478bd9Sstevel@tonic-gate int32_t *int32p; 80807c478bd9Sstevel@tonic-gate int64_t *int64p; 80817c478bd9Sstevel@tonic-gate char *str; 80827c478bd9Sstevel@tonic-gate char **strarray; 80837c478bd9Sstevel@tonic-gate uchar_t *bytep; 80847c478bd9Sstevel@tonic-gate int rv = 0; 80857c478bd9Sstevel@tonic-gate int i; 80867c478bd9Sstevel@tonic-gate 80877c478bd9Sstevel@tonic-gate if ((name = di_prop_name(prop)) == NULL) 80887c478bd9Sstevel@tonic-gate return (-1); 80897c478bd9Sstevel@tonic-gate 80907c478bd9Sstevel@tonic-gate len = sizeof (DEV_PROP_PREFIX) + strlen(name); 80917c478bd9Sstevel@tonic-gate if ((attr_name = malloc(len)) == NULL) 80927c478bd9Sstevel@tonic-gate return (-1); 80937c478bd9Sstevel@tonic-gate 80947c478bd9Sstevel@tonic-gate (void) strlcpy(attr_name, DEV_PROP_PREFIX, len); 80957c478bd9Sstevel@tonic-gate (void) strlcat(attr_name, name, len); 80967c478bd9Sstevel@tonic-gate 80977c478bd9Sstevel@tonic-gate switch (di_prop_type(prop)) { 80987c478bd9Sstevel@tonic-gate case DI_PROP_TYPE_BOOLEAN: 80997c478bd9Sstevel@tonic-gate if (nvlist_add_boolean(nvl, attr_name) != 0) 81007c478bd9Sstevel@tonic-gate goto out; 81017c478bd9Sstevel@tonic-gate break; 81027c478bd9Sstevel@tonic-gate 81037c478bd9Sstevel@tonic-gate case DI_PROP_TYPE_INT: 81047c478bd9Sstevel@tonic-gate if ((n = di_prop_ints(prop, &int32p)) < 1) 81057c478bd9Sstevel@tonic-gate goto out; 81067c478bd9Sstevel@tonic-gate 81077c478bd9Sstevel@tonic-gate if (n <= (PROP_LEN_LIMIT / sizeof (int32_t))) { 81087c478bd9Sstevel@tonic-gate if (nvlist_add_int32_array(nvl, attr_name, int32p, 81097c478bd9Sstevel@tonic-gate n) != 0) 81107c478bd9Sstevel@tonic-gate goto out; 81117c478bd9Sstevel@tonic-gate } else 81127c478bd9Sstevel@tonic-gate rv = 1; 81137c478bd9Sstevel@tonic-gate break; 81147c478bd9Sstevel@tonic-gate 81157c478bd9Sstevel@tonic-gate case DI_PROP_TYPE_INT64: 81167c478bd9Sstevel@tonic-gate if ((n = di_prop_int64(prop, &int64p)) < 1) 81177c478bd9Sstevel@tonic-gate goto out; 81187c478bd9Sstevel@tonic-gate 81197c478bd9Sstevel@tonic-gate if (n <= (PROP_LEN_LIMIT / sizeof (int64_t))) { 81207c478bd9Sstevel@tonic-gate if (nvlist_add_int64_array(nvl, attr_name, int64p, 81217c478bd9Sstevel@tonic-gate n) != 0) 81227c478bd9Sstevel@tonic-gate goto out; 81237c478bd9Sstevel@tonic-gate } else 81247c478bd9Sstevel@tonic-gate rv = 1; 81257c478bd9Sstevel@tonic-gate break; 81267c478bd9Sstevel@tonic-gate 81277c478bd9Sstevel@tonic-gate case DI_PROP_TYPE_BYTE: 81287c478bd9Sstevel@tonic-gate case DI_PROP_TYPE_UNKNOWN: 81297c478bd9Sstevel@tonic-gate if ((n = di_prop_bytes(prop, &bytep)) < 1) 81307c478bd9Sstevel@tonic-gate goto out; 81317c478bd9Sstevel@tonic-gate 81327c478bd9Sstevel@tonic-gate if (n <= PROP_LEN_LIMIT) { 81337c478bd9Sstevel@tonic-gate if (nvlist_add_byte_array(nvl, attr_name, bytep, n) 81347c478bd9Sstevel@tonic-gate != 0) 81357c478bd9Sstevel@tonic-gate goto out; 81367c478bd9Sstevel@tonic-gate } else 81377c478bd9Sstevel@tonic-gate rv = 1; 81387c478bd9Sstevel@tonic-gate break; 81397c478bd9Sstevel@tonic-gate 81407c478bd9Sstevel@tonic-gate case DI_PROP_TYPE_STRING: 81417c478bd9Sstevel@tonic-gate if ((n = di_prop_strings(prop, &str)) < 1) 81427c478bd9Sstevel@tonic-gate goto out; 81437c478bd9Sstevel@tonic-gate 81447c478bd9Sstevel@tonic-gate if ((strarray = malloc(n * sizeof (char *))) == NULL) 81457c478bd9Sstevel@tonic-gate goto out; 81467c478bd9Sstevel@tonic-gate 81477c478bd9Sstevel@tonic-gate len = 0; 81487c478bd9Sstevel@tonic-gate for (i = 0; i < n; i++) { 81497c478bd9Sstevel@tonic-gate strarray[i] = str + len; 81507c478bd9Sstevel@tonic-gate len += strlen(strarray[i]) + 1; 81517c478bd9Sstevel@tonic-gate } 81527c478bd9Sstevel@tonic-gate 81537c478bd9Sstevel@tonic-gate if (len <= PROP_LEN_LIMIT) { 81547c478bd9Sstevel@tonic-gate if (nvlist_add_string_array(nvl, attr_name, strarray, 81557c478bd9Sstevel@tonic-gate n) != 0) { 81567c478bd9Sstevel@tonic-gate free(strarray); 81577c478bd9Sstevel@tonic-gate goto out; 81587c478bd9Sstevel@tonic-gate } 81597c478bd9Sstevel@tonic-gate } else 81607c478bd9Sstevel@tonic-gate rv = 1; 81617c478bd9Sstevel@tonic-gate free(strarray); 81627c478bd9Sstevel@tonic-gate break; 81637c478bd9Sstevel@tonic-gate 81647c478bd9Sstevel@tonic-gate default: 81657c478bd9Sstevel@tonic-gate rv = 1; 81667c478bd9Sstevel@tonic-gate break; 81677c478bd9Sstevel@tonic-gate } 81687c478bd9Sstevel@tonic-gate 81697c478bd9Sstevel@tonic-gate free(attr_name); 81707c478bd9Sstevel@tonic-gate return (rv); 81717c478bd9Sstevel@tonic-gate 81727c478bd9Sstevel@tonic-gate out: 81737c478bd9Sstevel@tonic-gate free(attr_name); 81747c478bd9Sstevel@tonic-gate return (-1); 81757c478bd9Sstevel@tonic-gate } 81767c478bd9Sstevel@tonic-gate 81777c478bd9Sstevel@tonic-gate static void 81787c478bd9Sstevel@tonic-gate free_dev_names(struct devlink_cb_arg *x) 81797c478bd9Sstevel@tonic-gate { 81807c478bd9Sstevel@tonic-gate int i; 81817c478bd9Sstevel@tonic-gate 81827c478bd9Sstevel@tonic-gate for (i = 0; i < x->count; i++) { 81837c478bd9Sstevel@tonic-gate free(x->dev_names[i]); 81847c478bd9Sstevel@tonic-gate free(x->link_contents[i]); 81857c478bd9Sstevel@tonic-gate } 81867c478bd9Sstevel@tonic-gate } 81877c478bd9Sstevel@tonic-gate 81887c478bd9Sstevel@tonic-gate /* callback function for di_devlink_cache_walk */ 81897c478bd9Sstevel@tonic-gate static int 81907c478bd9Sstevel@tonic-gate devlink_cb(di_devlink_t dl, void *arg) 81917c478bd9Sstevel@tonic-gate { 81927c478bd9Sstevel@tonic-gate struct devlink_cb_arg *x = (struct devlink_cb_arg *)arg; 81937c478bd9Sstevel@tonic-gate const char *path; 81947c478bd9Sstevel@tonic-gate const char *content; 81957c478bd9Sstevel@tonic-gate 81967c478bd9Sstevel@tonic-gate if ((path = di_devlink_path(dl)) == NULL || 81977c478bd9Sstevel@tonic-gate (content = di_devlink_content(dl)) == NULL || 819812d8cf2aSjg (x->dev_names[x->count] = s_strdup(path)) == NULL) 81997c478bd9Sstevel@tonic-gate goto out; 82007c478bd9Sstevel@tonic-gate 820112d8cf2aSjg if ((x->link_contents[x->count] = s_strdup(content)) == NULL) { 82027c478bd9Sstevel@tonic-gate free(x->dev_names[x->count]); 82037c478bd9Sstevel@tonic-gate goto out; 82047c478bd9Sstevel@tonic-gate } 82057c478bd9Sstevel@tonic-gate 82067c478bd9Sstevel@tonic-gate x->count++; 82077c478bd9Sstevel@tonic-gate if (x->count >= MAX_DEV_NAME_COUNT) 82087c478bd9Sstevel@tonic-gate return (DI_WALK_TERMINATE); 82097c478bd9Sstevel@tonic-gate 82107c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 82117c478bd9Sstevel@tonic-gate 82127c478bd9Sstevel@tonic-gate out: 82137c478bd9Sstevel@tonic-gate x->rv = -1; 82147c478bd9Sstevel@tonic-gate free_dev_names(x); 82157c478bd9Sstevel@tonic-gate return (DI_WALK_TERMINATE); 82167c478bd9Sstevel@tonic-gate } 82177c478bd9Sstevel@tonic-gate 82187c478bd9Sstevel@tonic-gate /* 82197c478bd9Sstevel@tonic-gate * Lookup dev name corresponding to the phys_path. 82207c478bd9Sstevel@tonic-gate * phys_path is path to a node or minor node. 82217c478bd9Sstevel@tonic-gate * Returns: 82227c478bd9Sstevel@tonic-gate * 0 with *dev_name set to the dev name 82237c478bd9Sstevel@tonic-gate * Lookup succeeded and dev_name found 82247c478bd9Sstevel@tonic-gate * 0 with *dev_name set to NULL 82257c478bd9Sstevel@tonic-gate * Lookup encountered no errors but dev name not found 82267c478bd9Sstevel@tonic-gate * -1 82277c478bd9Sstevel@tonic-gate * Lookup failed 82287c478bd9Sstevel@tonic-gate */ 82297c478bd9Sstevel@tonic-gate static int 82307c478bd9Sstevel@tonic-gate lookup_dev_name(char *phys_path, char **dev_name) 82317c478bd9Sstevel@tonic-gate { 82327c478bd9Sstevel@tonic-gate struct devlink_cb_arg cb_arg; 82337c478bd9Sstevel@tonic-gate 82347c478bd9Sstevel@tonic-gate *dev_name = NULL; 82357c478bd9Sstevel@tonic-gate 82367c478bd9Sstevel@tonic-gate cb_arg.count = 0; 82377c478bd9Sstevel@tonic-gate cb_arg.rv = 0; 82387c478bd9Sstevel@tonic-gate (void) di_devlink_cache_walk(devlink_cache, NULL, phys_path, 82397c478bd9Sstevel@tonic-gate DI_PRIMARY_LINK, &cb_arg, devlink_cb); 82407c478bd9Sstevel@tonic-gate 82417c478bd9Sstevel@tonic-gate if (cb_arg.rv == -1) 82427c478bd9Sstevel@tonic-gate return (-1); 82437c478bd9Sstevel@tonic-gate 82447c478bd9Sstevel@tonic-gate if (cb_arg.count > 0) { 824512d8cf2aSjg *dev_name = s_strdup(cb_arg.dev_names[0]); 82467c478bd9Sstevel@tonic-gate free_dev_names(&cb_arg); 82477c478bd9Sstevel@tonic-gate if (*dev_name == NULL) 82487c478bd9Sstevel@tonic-gate return (-1); 82497c478bd9Sstevel@tonic-gate } 82507c478bd9Sstevel@tonic-gate 82517c478bd9Sstevel@tonic-gate return (0); 82527c478bd9Sstevel@tonic-gate } 82537c478bd9Sstevel@tonic-gate 82547c478bd9Sstevel@tonic-gate static char * 82557c478bd9Sstevel@tonic-gate lookup_disk_dev_name(char *node_path) 82567c478bd9Sstevel@tonic-gate { 82577c478bd9Sstevel@tonic-gate struct devlink_cb_arg cb_arg; 82587c478bd9Sstevel@tonic-gate char *dev_name = NULL; 82597c478bd9Sstevel@tonic-gate int i; 82607c478bd9Sstevel@tonic-gate char *p; 82617c478bd9Sstevel@tonic-gate int len1, len2; 82627c478bd9Sstevel@tonic-gate 82637c478bd9Sstevel@tonic-gate #define DEV_RDSK "/dev/rdsk/" 82647c478bd9Sstevel@tonic-gate #define DISK_RAW_MINOR ",raw" 82657c478bd9Sstevel@tonic-gate 82667c478bd9Sstevel@tonic-gate cb_arg.count = 0; 82677c478bd9Sstevel@tonic-gate cb_arg.rv = 0; 82687c478bd9Sstevel@tonic-gate (void) di_devlink_cache_walk(devlink_cache, NULL, node_path, 82697c478bd9Sstevel@tonic-gate DI_PRIMARY_LINK, &cb_arg, devlink_cb); 82707c478bd9Sstevel@tonic-gate 82717c478bd9Sstevel@tonic-gate if (cb_arg.rv == -1 || cb_arg.count == 0) 82727c478bd9Sstevel@tonic-gate return (NULL); 82737c478bd9Sstevel@tonic-gate 82747c478bd9Sstevel@tonic-gate /* first try lookup based on /dev/rdsk name */ 82757c478bd9Sstevel@tonic-gate for (i = 0; i < cb_arg.count; i++) { 82767c478bd9Sstevel@tonic-gate if (strncmp(cb_arg.dev_names[i], DEV_RDSK, 82777c478bd9Sstevel@tonic-gate sizeof (DEV_RDSK) - 1) == 0) { 827812d8cf2aSjg dev_name = s_strdup(cb_arg.dev_names[i]); 82797c478bd9Sstevel@tonic-gate break; 82807c478bd9Sstevel@tonic-gate } 82817c478bd9Sstevel@tonic-gate } 82827c478bd9Sstevel@tonic-gate 82837c478bd9Sstevel@tonic-gate if (dev_name == NULL) { 82847c478bd9Sstevel@tonic-gate /* now try lookup based on a minor name ending with ",raw" */ 82857c478bd9Sstevel@tonic-gate len1 = sizeof (DISK_RAW_MINOR) - 1; 82867c478bd9Sstevel@tonic-gate for (i = 0; i < cb_arg.count; i++) { 82877c478bd9Sstevel@tonic-gate len2 = strlen(cb_arg.link_contents[i]); 82887c478bd9Sstevel@tonic-gate if (len2 >= len1 && 82897c478bd9Sstevel@tonic-gate strcmp(cb_arg.link_contents[i] + len2 - len1, 82907c478bd9Sstevel@tonic-gate DISK_RAW_MINOR) == 0) { 829112d8cf2aSjg dev_name = s_strdup(cb_arg.dev_names[i]); 82927c478bd9Sstevel@tonic-gate break; 82937c478bd9Sstevel@tonic-gate } 82947c478bd9Sstevel@tonic-gate } 82957c478bd9Sstevel@tonic-gate } 82967c478bd9Sstevel@tonic-gate 82977c478bd9Sstevel@tonic-gate free_dev_names(&cb_arg); 82987c478bd9Sstevel@tonic-gate 829912d8cf2aSjg if (dev_name == NULL) 830012d8cf2aSjg return (NULL); 83017c478bd9Sstevel@tonic-gate if (strlen(dev_name) == 0) { 83027c478bd9Sstevel@tonic-gate free(dev_name); 83037c478bd9Sstevel@tonic-gate return (NULL); 83047c478bd9Sstevel@tonic-gate } 83057c478bd9Sstevel@tonic-gate 83067c478bd9Sstevel@tonic-gate /* if the name contains slice or partition number strip it */ 83077c478bd9Sstevel@tonic-gate p = dev_name + strlen(dev_name) - 1; 83087c478bd9Sstevel@tonic-gate if (isdigit(*p)) { 83097c478bd9Sstevel@tonic-gate while (p != dev_name && isdigit(*p)) 83107c478bd9Sstevel@tonic-gate p--; 83117c478bd9Sstevel@tonic-gate if (*p == 's' || *p == 'p') 83127c478bd9Sstevel@tonic-gate *p = '\0'; 83137c478bd9Sstevel@tonic-gate } 83147c478bd9Sstevel@tonic-gate 83157c478bd9Sstevel@tonic-gate return (dev_name); 83167c478bd9Sstevel@tonic-gate } 83177c478bd9Sstevel@tonic-gate 831830294554Sphitran static char * 831930294554Sphitran lookup_lofi_dev_name(char *node_path, char *minor) 832030294554Sphitran { 832130294554Sphitran struct devlink_cb_arg cb_arg; 832230294554Sphitran char *dev_name = NULL; 832330294554Sphitran int i; 832430294554Sphitran int len1, len2; 832530294554Sphitran 832630294554Sphitran cb_arg.count = 0; 832730294554Sphitran cb_arg.rv = 0; 832830294554Sphitran (void) di_devlink_cache_walk(devlink_cache, NULL, node_path, 832930294554Sphitran DI_PRIMARY_LINK, &cb_arg, devlink_cb); 833030294554Sphitran 833130294554Sphitran if (cb_arg.rv == -1 || cb_arg.count == 0) 833230294554Sphitran return (NULL); 833330294554Sphitran 833430294554Sphitran /* lookup based on a minor name ending with ",raw" */ 833530294554Sphitran len1 = strlen(minor); 833630294554Sphitran for (i = 0; i < cb_arg.count; i++) { 833730294554Sphitran len2 = strlen(cb_arg.link_contents[i]); 833830294554Sphitran if (len2 >= len1 && 833930294554Sphitran strcmp(cb_arg.link_contents[i] + len2 - len1, 834030294554Sphitran minor) == 0) { 834130294554Sphitran dev_name = s_strdup(cb_arg.dev_names[i]); 834230294554Sphitran break; 834330294554Sphitran } 834430294554Sphitran } 834530294554Sphitran 834630294554Sphitran free_dev_names(&cb_arg); 834730294554Sphitran 834830294554Sphitran if (dev_name == NULL) 834930294554Sphitran return (NULL); 835030294554Sphitran if (strlen(dev_name) == 0) { 835130294554Sphitran free(dev_name); 835230294554Sphitran return (NULL); 835330294554Sphitran } 835430294554Sphitran 835530294554Sphitran return (dev_name); 835630294554Sphitran } 835730294554Sphitran 83587c478bd9Sstevel@tonic-gate static char * 83597c478bd9Sstevel@tonic-gate lookup_network_dev_name(char *node_path, char *driver_name) 83607c478bd9Sstevel@tonic-gate { 83617c478bd9Sstevel@tonic-gate char *dev_name = NULL; 83627c478bd9Sstevel@tonic-gate char phys_path[MAXPATHLEN]; 83637c478bd9Sstevel@tonic-gate 83647c478bd9Sstevel@tonic-gate if (lookup_dev_name(node_path, &dev_name) == -1) 83657c478bd9Sstevel@tonic-gate return (NULL); 83667c478bd9Sstevel@tonic-gate 83677c478bd9Sstevel@tonic-gate if (dev_name == NULL) { 83687c478bd9Sstevel@tonic-gate /* dlpi style-2 only interface */ 83697c478bd9Sstevel@tonic-gate (void) snprintf(phys_path, sizeof (phys_path), 83707c478bd9Sstevel@tonic-gate "/pseudo/clone@0:%s", driver_name); 83717c478bd9Sstevel@tonic-gate if (lookup_dev_name(phys_path, &dev_name) == -1 || 83727c478bd9Sstevel@tonic-gate dev_name == NULL) 83737c478bd9Sstevel@tonic-gate return (NULL); 83747c478bd9Sstevel@tonic-gate } 83757c478bd9Sstevel@tonic-gate 83767c478bd9Sstevel@tonic-gate return (dev_name); 83777c478bd9Sstevel@tonic-gate } 83787c478bd9Sstevel@tonic-gate 8379db11e6feSjacobs static char * 8380db11e6feSjacobs lookup_printer_dev_name(char *node_path) 8381db11e6feSjacobs { 8382db11e6feSjacobs struct devlink_cb_arg cb_arg; 8383db11e6feSjacobs char *dev_name = NULL; 8384db11e6feSjacobs int i; 8385db11e6feSjacobs 8386db11e6feSjacobs #define DEV_PRINTERS "/dev/printers/" 8387db11e6feSjacobs 8388db11e6feSjacobs cb_arg.count = 0; 8389db11e6feSjacobs cb_arg.rv = 0; 8390db11e6feSjacobs (void) di_devlink_cache_walk(devlink_cache, NULL, node_path, 8391db11e6feSjacobs DI_PRIMARY_LINK, &cb_arg, devlink_cb); 8392db11e6feSjacobs 8393db11e6feSjacobs if (cb_arg.rv == -1 || cb_arg.count == 0) 8394db11e6feSjacobs return (NULL); 8395db11e6feSjacobs 8396db11e6feSjacobs /* first try lookup based on /dev/printers name */ 8397db11e6feSjacobs for (i = 0; i < cb_arg.count; i++) { 8398db11e6feSjacobs if (strncmp(cb_arg.dev_names[i], DEV_PRINTERS, 8399db11e6feSjacobs sizeof (DEV_PRINTERS) - 1) == 0) { 8400db11e6feSjacobs dev_name = s_strdup(cb_arg.dev_names[i]); 8401db11e6feSjacobs break; 8402db11e6feSjacobs } 8403db11e6feSjacobs } 8404db11e6feSjacobs 8405db11e6feSjacobs /* fallback to the first name */ 8406db11e6feSjacobs if ((dev_name == NULL) && (cb_arg.count > 0)) 8407db11e6feSjacobs dev_name = s_strdup(cb_arg.dev_names[0]); 8408db11e6feSjacobs 8409db11e6feSjacobs free_dev_names(&cb_arg); 8410db11e6feSjacobs 8411db11e6feSjacobs return (dev_name); 8412db11e6feSjacobs } 8413db11e6feSjacobs 84147c478bd9Sstevel@tonic-gate /* 84157c478bd9Sstevel@tonic-gate * Build an nvlist containing all attributes for devfs events. 84167c478bd9Sstevel@tonic-gate * Returns nvlist pointer on success, NULL on failure. 84177c478bd9Sstevel@tonic-gate */ 84187c478bd9Sstevel@tonic-gate static nvlist_t * 84197c478bd9Sstevel@tonic-gate build_event_attributes(char *class, char *subclass, char *node_path, 842030294554Sphitran di_node_t node, char *driver_name, int instance, char *minor) 84217c478bd9Sstevel@tonic-gate { 84227c478bd9Sstevel@tonic-gate nvlist_t *nvl; 84237c478bd9Sstevel@tonic-gate int err = 0; 84247c478bd9Sstevel@tonic-gate di_prop_t prop; 84257c478bd9Sstevel@tonic-gate int count; 84267c478bd9Sstevel@tonic-gate char *prop_name; 84277c478bd9Sstevel@tonic-gate int x; 84287c478bd9Sstevel@tonic-gate char *dev_name = NULL; 84297c478bd9Sstevel@tonic-gate int dev_name_lookup_err = 0; 84307c478bd9Sstevel@tonic-gate 84317c478bd9Sstevel@tonic-gate if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, 0)) != 0) { 84327c478bd9Sstevel@tonic-gate nvl = NULL; 84337c478bd9Sstevel@tonic-gate goto out; 84347c478bd9Sstevel@tonic-gate } 84357c478bd9Sstevel@tonic-gate 84367c478bd9Sstevel@tonic-gate if ((err = nvlist_add_int32(nvl, EV_VERSION, EV_V1)) != 0) 84377c478bd9Sstevel@tonic-gate goto out; 84387c478bd9Sstevel@tonic-gate 84397c478bd9Sstevel@tonic-gate if ((err = nvlist_add_string(nvl, DEV_PHYS_PATH, node_path)) != 0) 84407c478bd9Sstevel@tonic-gate goto out; 84417c478bd9Sstevel@tonic-gate 84427c478bd9Sstevel@tonic-gate if (strcmp(class, EC_DEV_ADD) != 0 && 84437c478bd9Sstevel@tonic-gate strcmp(class, EC_DEV_REMOVE) != 0) 84447c478bd9Sstevel@tonic-gate return (nvl); 84457c478bd9Sstevel@tonic-gate 84467c478bd9Sstevel@tonic-gate if (driver_name == NULL || instance == -1) 84477c478bd9Sstevel@tonic-gate goto out; 84487c478bd9Sstevel@tonic-gate 84497c478bd9Sstevel@tonic-gate if (strcmp(subclass, ESC_DISK) == 0) { 84507c478bd9Sstevel@tonic-gate if ((dev_name = lookup_disk_dev_name(node_path)) == NULL) { 84517c478bd9Sstevel@tonic-gate dev_name_lookup_err = 1; 84527c478bd9Sstevel@tonic-gate goto out; 84537c478bd9Sstevel@tonic-gate } 84547c478bd9Sstevel@tonic-gate } else if (strcmp(subclass, ESC_NETWORK) == 0) { 84557c478bd9Sstevel@tonic-gate if ((dev_name = lookup_network_dev_name(node_path, driver_name)) 84567c478bd9Sstevel@tonic-gate == NULL) { 84577c478bd9Sstevel@tonic-gate dev_name_lookup_err = 1; 84587c478bd9Sstevel@tonic-gate goto out; 84597c478bd9Sstevel@tonic-gate } 8460db11e6feSjacobs } else if (strcmp(subclass, ESC_PRINTER) == 0) { 8461db11e6feSjacobs if ((dev_name = lookup_printer_dev_name(node_path)) == NULL) { 8462db11e6feSjacobs dev_name_lookup_err = 1; 8463db11e6feSjacobs goto out; 8464db11e6feSjacobs } 846530294554Sphitran } else if (strcmp(subclass, ESC_LOFI) == 0) { 846630294554Sphitran /* 846730294554Sphitran * The raw minor node is created or removed after the block 846830294554Sphitran * node. Lofi devfs events are dependent on this behavior. 846930294554Sphitran * Generate the sysevent only for the raw minor node. 847030294554Sphitran */ 847130294554Sphitran if (strstr(minor, "raw") == NULL) { 847230294554Sphitran if (nvl) { 847330294554Sphitran nvlist_free(nvl); 847430294554Sphitran } 847530294554Sphitran return (NULL); 847630294554Sphitran } 847730294554Sphitran if ((dev_name = lookup_lofi_dev_name(node_path, minor)) == 847830294554Sphitran NULL) { 847930294554Sphitran dev_name_lookup_err = 1; 848030294554Sphitran goto out; 848130294554Sphitran } 84827c478bd9Sstevel@tonic-gate } 84837c478bd9Sstevel@tonic-gate 84847c478bd9Sstevel@tonic-gate if (dev_name) { 84857c478bd9Sstevel@tonic-gate if ((err = nvlist_add_string(nvl, DEV_NAME, dev_name)) != 0) 84867c478bd9Sstevel@tonic-gate goto out; 84877c478bd9Sstevel@tonic-gate free(dev_name); 84887c478bd9Sstevel@tonic-gate dev_name = NULL; 84897c478bd9Sstevel@tonic-gate } 84907c478bd9Sstevel@tonic-gate 84917c478bd9Sstevel@tonic-gate if ((err = nvlist_add_string(nvl, DEV_DRIVER_NAME, driver_name)) != 0) 84927c478bd9Sstevel@tonic-gate goto out; 84937c478bd9Sstevel@tonic-gate 84947c478bd9Sstevel@tonic-gate if ((err = nvlist_add_int32(nvl, DEV_INSTANCE, instance)) != 0) 84957c478bd9Sstevel@tonic-gate goto out; 84967c478bd9Sstevel@tonic-gate 84977c478bd9Sstevel@tonic-gate if (strcmp(class, EC_DEV_ADD) == 0) { 84987c478bd9Sstevel@tonic-gate /* add properties */ 84997c478bd9Sstevel@tonic-gate count = 0; 85007c478bd9Sstevel@tonic-gate for (prop = di_prop_next(node, DI_PROP_NIL); 85017c478bd9Sstevel@tonic-gate prop != DI_PROP_NIL && count < MAX_PROP_COUNT; 85027c478bd9Sstevel@tonic-gate prop = di_prop_next(node, prop)) { 85037c478bd9Sstevel@tonic-gate 85047c478bd9Sstevel@tonic-gate if (di_prop_devt(prop) != DDI_DEV_T_NONE) 85057c478bd9Sstevel@tonic-gate continue; 85067c478bd9Sstevel@tonic-gate 85077c478bd9Sstevel@tonic-gate if ((x = add_property(nvl, prop)) == 0) 85087c478bd9Sstevel@tonic-gate count++; 85097c478bd9Sstevel@tonic-gate else if (x == -1) { 85107c478bd9Sstevel@tonic-gate if ((prop_name = di_prop_name(prop)) == NULL) 85117c478bd9Sstevel@tonic-gate prop_name = ""; 85127c478bd9Sstevel@tonic-gate err_print(PROP_ADD_FAILED, prop_name); 85137c478bd9Sstevel@tonic-gate goto out; 85147c478bd9Sstevel@tonic-gate } 85157c478bd9Sstevel@tonic-gate } 85167c478bd9Sstevel@tonic-gate } 85177c478bd9Sstevel@tonic-gate 85187c478bd9Sstevel@tonic-gate return (nvl); 85197c478bd9Sstevel@tonic-gate 85207c478bd9Sstevel@tonic-gate out: 85217c478bd9Sstevel@tonic-gate if (nvl) 85227c478bd9Sstevel@tonic-gate nvlist_free(nvl); 85237c478bd9Sstevel@tonic-gate 85247c478bd9Sstevel@tonic-gate if (dev_name) 85257c478bd9Sstevel@tonic-gate free(dev_name); 85267c478bd9Sstevel@tonic-gate 852793239addSjohnlev if (dev_name_lookup_err) { 852893239addSjohnlev /* 852993239addSjohnlev * If a lofi mount fails, the /devices node may well have 853093239addSjohnlev * disappeared by the time we run, so let's not complain. 853193239addSjohnlev */ 853293239addSjohnlev if (strcmp(subclass, ESC_LOFI) != 0) 853393239addSjohnlev err_print(DEV_NAME_LOOKUP_FAILED, node_path); 853493239addSjohnlev } else { 85357c478bd9Sstevel@tonic-gate err_print(BUILD_EVENT_ATTR_FAILED, (err) ? strerror(err) : ""); 853693239addSjohnlev } 85377c478bd9Sstevel@tonic-gate return (NULL); 85387c478bd9Sstevel@tonic-gate } 85397c478bd9Sstevel@tonic-gate 85407c478bd9Sstevel@tonic-gate static void 85417c478bd9Sstevel@tonic-gate log_event(char *class, char *subclass, nvlist_t *nvl) 85427c478bd9Sstevel@tonic-gate { 85437c478bd9Sstevel@tonic-gate sysevent_id_t eid; 85447c478bd9Sstevel@tonic-gate 85457c478bd9Sstevel@tonic-gate if (sysevent_post_event(class, subclass, "SUNW", DEVFSADMD, 85467c478bd9Sstevel@tonic-gate nvl, &eid) != 0) { 85477c478bd9Sstevel@tonic-gate err_print(LOG_EVENT_FAILED, strerror(errno)); 85487c478bd9Sstevel@tonic-gate } 85497c478bd9Sstevel@tonic-gate } 85507c478bd9Sstevel@tonic-gate 8551f05faa4eSjacobs /* 8552f05faa4eSjacobs * When devfsadmd needs to generate sysevents, they are queued for later 8553f05faa4eSjacobs * delivery this allows them to be delivered after the devlinks db cache has 8554f05faa4eSjacobs * been flushed guaranteeing that applications consuming these events have 8555f05faa4eSjacobs * access to an accurate devlinks db. The queue is a FIFO, sysevents to be 8556f05faa4eSjacobs * inserted in the front of the queue and consumed off the back. 8557f05faa4eSjacobs */ 8558f05faa4eSjacobs static void 8559f05faa4eSjacobs enqueue_sysevent(char *class, char *subclass, nvlist_t *nvl) 8560f05faa4eSjacobs { 8561f05faa4eSjacobs syseventq_t *tmp; 8562f05faa4eSjacobs 8563f05faa4eSjacobs if ((tmp = s_zalloc(sizeof (*tmp))) == NULL) 8564f05faa4eSjacobs return; 8565f05faa4eSjacobs 8566f05faa4eSjacobs tmp->class = s_strdup(class); 8567f05faa4eSjacobs tmp->subclass = s_strdup(subclass); 8568f05faa4eSjacobs tmp->nvl = nvl; 8569f05faa4eSjacobs 8570f05faa4eSjacobs (void) mutex_lock(&syseventq_mutex); 8571f05faa4eSjacobs if (syseventq_front != NULL) 8572f05faa4eSjacobs syseventq_front->next = tmp; 8573f05faa4eSjacobs else 8574f05faa4eSjacobs syseventq_back = tmp; 8575f05faa4eSjacobs syseventq_front = tmp; 8576f05faa4eSjacobs (void) mutex_unlock(&syseventq_mutex); 8577f05faa4eSjacobs } 8578f05faa4eSjacobs 8579f05faa4eSjacobs static void 8580f05faa4eSjacobs process_syseventq() 8581f05faa4eSjacobs { 8582f05faa4eSjacobs (void) mutex_lock(&syseventq_mutex); 8583f05faa4eSjacobs while (syseventq_back != NULL) { 8584f05faa4eSjacobs syseventq_t *tmp = syseventq_back; 8585f05faa4eSjacobs 8586f05faa4eSjacobs vprint(CHATTY_MID, "sending queued event: %s, %s\n", 85870a653502Swroche tmp->class, tmp->subclass); 8588f05faa4eSjacobs 8589f05faa4eSjacobs log_event(tmp->class, tmp->subclass, tmp->nvl); 8590f05faa4eSjacobs 8591f05faa4eSjacobs if (tmp->class != NULL) 8592f05faa4eSjacobs free(tmp->class); 8593f05faa4eSjacobs if (tmp->subclass != NULL) 8594f05faa4eSjacobs free(tmp->subclass); 8595f05faa4eSjacobs if (tmp->nvl != NULL) 8596f05faa4eSjacobs nvlist_free(tmp->nvl); 8597f05faa4eSjacobs syseventq_back = syseventq_back->next; 8598f05faa4eSjacobs if (syseventq_back == NULL) 8599f05faa4eSjacobs syseventq_front = NULL; 8600f05faa4eSjacobs free(tmp); 8601f05faa4eSjacobs } 8602f05faa4eSjacobs (void) mutex_unlock(&syseventq_mutex); 8603f05faa4eSjacobs } 8604f05faa4eSjacobs 86057c478bd9Sstevel@tonic-gate static void 8606f05faa4eSjacobs build_and_enq_event(char *class, char *subclass, char *node_path, 860730294554Sphitran di_node_t node, char *minor) 86087c478bd9Sstevel@tonic-gate { 86097c478bd9Sstevel@tonic-gate nvlist_t *nvl; 86107c478bd9Sstevel@tonic-gate 8611f05faa4eSjacobs vprint(CHATTY_MID, "build_and_enq_event(%s, %s, %s, 0x%8.8x)\n", 86120a653502Swroche class, subclass, node_path, (int)node); 8613f05faa4eSjacobs 86147c478bd9Sstevel@tonic-gate if (node != DI_NODE_NIL) 86157c478bd9Sstevel@tonic-gate nvl = build_event_attributes(class, subclass, node_path, node, 861630294554Sphitran di_driver_name(node), di_instance(node), minor); 86177c478bd9Sstevel@tonic-gate else 86187c478bd9Sstevel@tonic-gate nvl = build_event_attributes(class, subclass, node_path, node, 861930294554Sphitran NULL, -1, minor); 86207c478bd9Sstevel@tonic-gate 86217c478bd9Sstevel@tonic-gate if (nvl) { 8622f05faa4eSjacobs enqueue_sysevent(class, subclass, nvl); 86237c478bd9Sstevel@tonic-gate } 86247c478bd9Sstevel@tonic-gate } 8625facf4a8dSllai 86261ca93273Seota /* 86271ca93273Seota * is_blank() returns 1 (true) if a line specified is composed of 86281ca93273Seota * whitespace characters only. otherwise, it returns 0 (false). 86291ca93273Seota * 86301ca93273Seota * Note. the argument (line) must be null-terminated. 86311ca93273Seota */ 86321ca93273Seota static int 86331ca93273Seota is_blank(char *line) 86341ca93273Seota { 86351ca93273Seota for (/* nothing */; *line != '\0'; line++) 86361ca93273Seota if (!isspace(*line)) 86371ca93273Seota return (0); 86381ca93273Seota return (1); 86391ca93273Seota } 86401ca93273Seota 8641aa646b9dSvikram /* 8642aa646b9dSvikram * Functions to deal with the no-further-processing hash 8643aa646b9dSvikram */ 8644aa646b9dSvikram 8645aa646b9dSvikram static void 8646aa646b9dSvikram nfphash_create(void) 8647aa646b9dSvikram { 8648aa646b9dSvikram assert(nfp_hash == NULL); 8649aa646b9dSvikram nfp_hash = s_zalloc(NFP_HASH_SZ * sizeof (item_t *)); 8650aa646b9dSvikram } 8651aa646b9dSvikram 8652aa646b9dSvikram static int 8653aa646b9dSvikram nfphash_fcn(char *key) 8654aa646b9dSvikram { 8655aa646b9dSvikram int i; 8656aa646b9dSvikram uint64_t sum = 0; 8657aa646b9dSvikram 8658aa646b9dSvikram for (i = 0; key[i] != '\0'; i++) { 8659aa646b9dSvikram sum += (uchar_t)key[i]; 8660aa646b9dSvikram } 8661aa646b9dSvikram 8662aa646b9dSvikram return (sum % NFP_HASH_SZ); 8663aa646b9dSvikram } 8664aa646b9dSvikram 8665aa646b9dSvikram static item_t * 8666aa646b9dSvikram nfphash_lookup(char *key) 8667aa646b9dSvikram { 8668aa646b9dSvikram int index; 8669aa646b9dSvikram item_t *ip; 8670aa646b9dSvikram 8671aa646b9dSvikram index = nfphash_fcn(key); 8672aa646b9dSvikram 8673aa646b9dSvikram assert(index >= 0); 8674aa646b9dSvikram 8675aa646b9dSvikram for (ip = nfp_hash[index]; ip; ip = ip->i_next) { 8676aa646b9dSvikram if (strcmp(ip->i_key, key) == 0) 8677aa646b9dSvikram return (ip); 8678aa646b9dSvikram } 8679aa646b9dSvikram 8680aa646b9dSvikram return (NULL); 8681aa646b9dSvikram } 8682aa646b9dSvikram 8683aa646b9dSvikram static void 8684aa646b9dSvikram nfphash_insert(char *key) 8685aa646b9dSvikram { 8686aa646b9dSvikram item_t *ip; 8687aa646b9dSvikram int index; 8688aa646b9dSvikram 8689aa646b9dSvikram index = nfphash_fcn(key); 8690aa646b9dSvikram 8691aa646b9dSvikram assert(index >= 0); 8692aa646b9dSvikram 8693aa646b9dSvikram ip = s_zalloc(sizeof (item_t)); 8694aa646b9dSvikram ip->i_key = s_strdup(key); 8695aa646b9dSvikram 8696aa646b9dSvikram ip->i_next = nfp_hash[index]; 8697aa646b9dSvikram nfp_hash[index] = ip; 8698aa646b9dSvikram } 8699aa646b9dSvikram 8700aa646b9dSvikram static void 8701aa646b9dSvikram nfphash_destroy(void) 8702aa646b9dSvikram { 8703aa646b9dSvikram int i; 8704aa646b9dSvikram item_t *ip; 8705aa646b9dSvikram 8706aa646b9dSvikram for (i = 0; i < NFP_HASH_SZ; i++) { 8707aa646b9dSvikram /*LINTED*/ 8708aa646b9dSvikram while (ip = nfp_hash[i]) { 8709aa646b9dSvikram nfp_hash[i] = ip->i_next; 8710aa646b9dSvikram free(ip->i_key); 8711aa646b9dSvikram free(ip); 8712aa646b9dSvikram } 8713aa646b9dSvikram } 8714aa646b9dSvikram 8715aa646b9dSvikram free(nfp_hash); 8716aa646b9dSvikram nfp_hash = NULL; 8717aa646b9dSvikram } 8718aa646b9dSvikram 8719facf4a8dSllai static int 8720facf4a8dSllai devname_kcall(int subcmd, void *args) 8721facf4a8dSllai { 8722facf4a8dSllai int error = 0; 8723facf4a8dSllai char *nvlbuf = NULL; 8724facf4a8dSllai size_t nvlsize; 8725facf4a8dSllai 8726facf4a8dSllai switch (subcmd) { 8727facf4a8dSllai case MODDEVNAME_NSMAPS: 8728facf4a8dSllai error = nvlist_pack((nvlist_t *)args, &nvlbuf, &nvlsize, 0, 0); 8729facf4a8dSllai if (error) { 8730facf4a8dSllai err_print("packing MODDEVNAME_NSMAPS failed\n"); 8731facf4a8dSllai break; 8732facf4a8dSllai } 8733facf4a8dSllai error = modctl(MODDEVNAME, subcmd, nvlbuf, nvlsize); 8734facf4a8dSllai if (error) { 8735facf4a8dSllai vprint(INFO_MID, "modctl(MODDEVNAME, " 8736facf4a8dSllai "MODDEVNAME_NSMAPS) failed - %s\n", 8737facf4a8dSllai strerror(errno)); 8738facf4a8dSllai } 8739facf4a8dSllai free(nvlbuf); 8740facf4a8dSllai nvlist_free(args); 8741facf4a8dSllai break; 8742facf4a8dSllai case MODDEVNAME_LOOKUPDOOR: 8743facf4a8dSllai error = modctl(MODDEVNAME, subcmd, (uintptr_t)args); 8744facf4a8dSllai if (error) { 8745facf4a8dSllai vprint(INFO_MID, "modctl(MODDEVNAME, " 8746facf4a8dSllai "MODDEVNAME_LOOKUPDOOR) failed - %s\n", 8747facf4a8dSllai strerror(errno)); 8748facf4a8dSllai } 8749facf4a8dSllai break; 8750facf4a8dSllai default: 8751facf4a8dSllai error = EINVAL; 8752facf4a8dSllai break; 8753facf4a8dSllai } 8754facf4a8dSllai return (error); 8755facf4a8dSllai } 8756facf4a8dSllai 8757facf4a8dSllai static void 8758facf4a8dSllai devname_setup_nsmaps(void) 8759facf4a8dSllai { 8760facf4a8dSllai int error = 0; 8761facf4a8dSllai 8762facf4a8dSllai if (devname_first_call) { 8763facf4a8dSllai devname_first_call = 0; 8764facf4a8dSllai } 8765facf4a8dSllai 8766facf4a8dSllai error = di_devname_get_mapinfo(DEVNAME_MASTER_MAP, &devname_maps); 8767facf4a8dSllai 8768facf4a8dSllai if (error) { 87690bfaec69Sllai vprint(DEVNAME_MID, "devname_setup_nsmaps: non-existing/empty" 87700bfaec69Sllai "%s\n", DEVNAME_MASTER_MAP); 8771facf4a8dSllai } else { 8772facf4a8dSllai di_devname_print_mapinfo(devname_maps); 87730bfaec69Sllai 8774facf4a8dSllai /* pass down the existing map names to kernel */ 8775facf4a8dSllai (void) devname_kcall(MODDEVNAME_NSMAPS, (void *)devname_maps); 8776facf4a8dSllai } 8777facf4a8dSllai } 8778facf4a8dSllai 8779facf4a8dSllai static void 8780facf4a8dSllai devname_ns_services(uint8_t cmd, char *key, char *map) 8781facf4a8dSllai { 8782facf4a8dSllai nvlist_t *nvl = NULL; 8783facf4a8dSllai int32_t error = 0; 8784facf4a8dSllai sdev_door_res_t res; 8785facf4a8dSllai 8786facf4a8dSllai vprint(DEVNAME_MID, "devname_ns_services: cmd %d key %s map %s\n", 8787facf4a8dSllai cmd, key, map); 8788facf4a8dSllai 8789facf4a8dSllai switch (cmd) { 8790facf4a8dSllai case DEVFSADMD_NS_LOOKUP: 8791facf4a8dSllai vprint(DEVNAME_MID, "calling di_devname_get_mapent\n"); 8792facf4a8dSllai error = di_devname_get_mapent(key, map, &nvl); 8793facf4a8dSllai if (nvl == NULL) { 8794facf4a8dSllai error = DEVFSADM_NS_FAILED; 8795facf4a8dSllai goto done; 8796facf4a8dSllai } 8797facf4a8dSllai 8798facf4a8dSllai if (error) { 8799facf4a8dSllai nvlist_free(nvl); 8800facf4a8dSllai goto done; 8801facf4a8dSllai } 8802facf4a8dSllai 8803facf4a8dSllai if (devname_debug_msg) 8804facf4a8dSllai di_devname_print_mapinfo(nvl); 8805facf4a8dSllai 8806facf4a8dSllai vprint(DEVNAME_MID, "calling di_devname_action_on_key for %d\n", 8807facf4a8dSllai cmd); 8808facf4a8dSllai error = di_devname_action_on_key(nvl, cmd, key, (void *)&res); 8809facf4a8dSllai nvlist_free(nvl); 8810facf4a8dSllai break; 8811facf4a8dSllai case DEVFSADMD_NS_READDIR: 8812facf4a8dSllai vprint(DEVNAME_MID, "calling di_devname_get_mapinfo for cmd %d" 8813facf4a8dSllai "\n", cmd); 8814facf4a8dSllai error = di_devname_get_mapinfo(map, &nvl); 8815facf4a8dSllai if (nvl == NULL) { 8816facf4a8dSllai error = DEVFSADM_NS_FAILED; 8817facf4a8dSllai goto done; 8818facf4a8dSllai } 8819facf4a8dSllai 8820facf4a8dSllai if (error) { 8821facf4a8dSllai nvlist_free(nvl); 8822facf4a8dSllai goto done; 8823facf4a8dSllai } 8824facf4a8dSllai 8825facf4a8dSllai if (devname_debug_msg) 8826facf4a8dSllai di_devname_print_mapinfo(nvl); 8827facf4a8dSllai 8828facf4a8dSllai vprint(DEVNAME_MID, "calling di_devname_action_on_key\n"); 8829facf4a8dSllai error = di_devname_action_on_key(nvl, cmd, key, (void *)&res); 8830facf4a8dSllai nvlist_free(nvl); 8831facf4a8dSllai break; 8832facf4a8dSllai default: 8833facf4a8dSllai error = DEVFSADM_RUN_NOTSUP; 8834facf4a8dSllai break; 8835facf4a8dSllai } 8836facf4a8dSllai 8837facf4a8dSllai done: 8838facf4a8dSllai vprint(DEVNAME_MID, "error %d\n", error); 8839facf4a8dSllai res.devfsadm_error = error; 8840facf4a8dSllai (void) door_return((char *)&res, sizeof (struct sdev_door_res), 8841facf4a8dSllai NULL, 0); 8842facf4a8dSllai } 8843facf4a8dSllai 8844facf4a8dSllai /* ARGSUSED */ 8845facf4a8dSllai static void 8846facf4a8dSllai devname_lookup_handler(void *cookie, char *argp, size_t arg_size, 8847facf4a8dSllai door_desc_t *dp, uint_t n_desc) 8848facf4a8dSllai { 8849facf4a8dSllai int32_t error = 0; 8850facf4a8dSllai door_cred_t dcred; 8851facf4a8dSllai struct dca_impl dci; 8852facf4a8dSllai uint8_t cmd; 8853facf4a8dSllai char *ns_map, *ns_name; 8854facf4a8dSllai sdev_door_res_t res; 8855facf4a8dSllai sdev_door_arg_t *args; 8856facf4a8dSllai 8857facf4a8dSllai if (argp == NULL || arg_size == 0) { 8858facf4a8dSllai vprint(DEVNAME_MID, "devname_lookup_handler: argp wrong\n"); 8859facf4a8dSllai error = DEVFSADM_RUN_INVALID; 8860facf4a8dSllai goto done; 8861facf4a8dSllai } 8862facf4a8dSllai vprint(DEVNAME_MID, "devname_lookup_handler\n"); 8863facf4a8dSllai 8864facf4a8dSllai if (door_cred(&dcred) != 0 || dcred.dc_euid != 0) { 8865facf4a8dSllai vprint(DEVNAME_MID, "devname_lookup_handler: cred wrong\n"); 8866facf4a8dSllai error = DEVFSADM_RUN_EPERM; 8867facf4a8dSllai goto done; 8868facf4a8dSllai } 8869facf4a8dSllai 8870facf4a8dSllai args = (sdev_door_arg_t *)argp; 8871facf4a8dSllai cmd = args->devfsadm_cmd; 8872facf4a8dSllai 8873facf4a8dSllai vprint(DEVNAME_MID, "devname_lookup_handler: cmd %d\n", cmd); 8874facf4a8dSllai switch (cmd) { 8875facf4a8dSllai case DEVFSADMD_NS_LOOKUP: 8876facf4a8dSllai case DEVFSADMD_NS_READDIR: 8877facf4a8dSllai ns_name = s_strdup(args->ns_hdl.ns_name); 8878facf4a8dSllai ns_map = s_strdup(args->ns_hdl.ns_map); 8879facf4a8dSllai 8880facf4a8dSllai vprint(DEVNAME_MID, " ns_name %s ns_map %s\n", ns_name, ns_map); 8881facf4a8dSllai if (ns_name == NULL || ns_map == NULL) { 8882facf4a8dSllai error = DEVFSADM_RUN_INVALID; 8883facf4a8dSllai goto done; 8884facf4a8dSllai } 8885facf4a8dSllai 8886facf4a8dSllai devname_ns_services(cmd, ns_name, ns_map); 8887facf4a8dSllai return; 8888facf4a8dSllai case DEVFSADMD_RUN_ALL: 8889facf4a8dSllai /* 8890facf4a8dSllai * run "devfsadm" 8891facf4a8dSllai */ 8892facf4a8dSllai dci.dci_root = "/"; 8893facf4a8dSllai dci.dci_minor = NULL; 8894facf4a8dSllai dci.dci_driver = NULL; 8895facf4a8dSllai dci.dci_error = 0; 8896facf4a8dSllai dci.dci_flags = 0; 8897facf4a8dSllai dci.dci_arg = NULL; 8898facf4a8dSllai 8899facf4a8dSllai lock_dev(); 8900facf4a8dSllai update_drvconf((major_t)-1); 8901facf4a8dSllai dci.dci_flags |= DCA_FLUSH_PATHINST; 8902facf4a8dSllai 8903facf4a8dSllai pre_and_post_cleanup(RM_PRE); 8904facf4a8dSllai devi_tree_walk(&dci, DINFOFORCE|DI_CACHE_SNAPSHOT_FLAGS, NULL); 8905facf4a8dSllai error = (int32_t)dci.dci_error; 8906facf4a8dSllai if (!error) { 8907facf4a8dSllai pre_and_post_cleanup(RM_POST); 8908facf4a8dSllai update_database = TRUE; 8909facf4a8dSllai unlock_dev(SYNC_STATE); 8910facf4a8dSllai update_database = FALSE; 8911facf4a8dSllai } else { 8912facf4a8dSllai if (DEVFSADM_DEBUG_ON) { 8913facf4a8dSllai vprint(INFO_MID, "devname_lookup_handler: " 8914facf4a8dSllai "DEVFSADMD_RUN_ALL failed\n"); 8915facf4a8dSllai } 8916facf4a8dSllai 8917facf4a8dSllai unlock_dev(SYNC_STATE); 8918facf4a8dSllai } 8919facf4a8dSllai break; 8920facf4a8dSllai default: 8921facf4a8dSllai /* log an error here? */ 8922facf4a8dSllai error = DEVFSADM_RUN_NOTSUP; 8923facf4a8dSllai break; 8924facf4a8dSllai } 8925facf4a8dSllai 8926facf4a8dSllai done: 8927facf4a8dSllai vprint(DEVNAME_MID, "devname_lookup_handler: error %d\n", error); 8928facf4a8dSllai res.devfsadm_error = error; 8929facf4a8dSllai (void) door_return((char *)&res, sizeof (struct sdev_door_res), 8930facf4a8dSllai NULL, 0); 8931facf4a8dSllai } 89328d483882Smlf 89338d483882Smlf 89348d483882Smlf di_devlink_handle_t 89358d483882Smlf devfsadm_devlink_cache(void) 89368d483882Smlf { 89378d483882Smlf return (devlink_cache); 89388d483882Smlf } 89398d483882Smlf 89408d483882Smlf int 89418d483882Smlf devfsadm_reserve_id_cache(devlink_re_t re_array[], enumerate_file_t *head) 89428d483882Smlf { 89438d483882Smlf enumerate_file_t *entry; 89448d483882Smlf int nelem; 89458d483882Smlf int i; 89468d483882Smlf int subex; 89478d483882Smlf char *re; 89488d483882Smlf size_t size; 89498d483882Smlf regmatch_t *pmch; 89508d483882Smlf 89518d483882Smlf /* 89528d483882Smlf * Check the <RE, subexp> array passed in and compile it. 89538d483882Smlf */ 89548d483882Smlf for (i = 0; re_array[i].d_re; i++) { 89558d483882Smlf if (re_array[i].d_subexp == 0) { 89568d483882Smlf err_print("bad subexp value in RE: %s\n", 89578d483882Smlf re_array[i].d_re); 89588d483882Smlf goto bad_re; 89598d483882Smlf } 89608d483882Smlf 89618d483882Smlf re = re_array[i].d_re; 89628d483882Smlf if (regcomp(&re_array[i].d_rcomp, re, REG_EXTENDED) != 0) { 89638d483882Smlf err_print("reg. exp. failed to compile: %s\n", re); 89648d483882Smlf goto bad_re; 89658d483882Smlf } 89668d483882Smlf subex = re_array[i].d_subexp; 89678d483882Smlf nelem = subex + 1; 89688d483882Smlf re_array[i].d_pmatch = s_malloc(sizeof (regmatch_t) * nelem); 89698d483882Smlf } 89708d483882Smlf 89718d483882Smlf entry = head ? head : enumerate_reserved; 89728d483882Smlf for (; entry; entry = entry->er_next) { 89738d483882Smlf if (entry->er_id) { 89748d483882Smlf vprint(RSBY_MID, "entry %s already has ID %s\n", 89758d483882Smlf entry->er_file, entry->er_id); 89768d483882Smlf continue; 89778d483882Smlf } 89788d483882Smlf for (i = 0; re_array[i].d_re; i++) { 89798d483882Smlf subex = re_array[i].d_subexp; 89808d483882Smlf pmch = re_array[i].d_pmatch; 89818d483882Smlf if (regexec(&re_array[i].d_rcomp, entry->er_file, 89828d483882Smlf subex + 1, pmch, 0) != 0) { 89838d483882Smlf /* No match */ 89848d483882Smlf continue; 89858d483882Smlf } 89868d483882Smlf size = pmch[subex].rm_eo - pmch[subex].rm_so; 89878d483882Smlf entry->er_id = s_malloc(size + 1); 89888d483882Smlf (void) strncpy(entry->er_id, 89898d483882Smlf &entry->er_file[pmch[subex].rm_so], size); 89908d483882Smlf entry->er_id[size] = '\0'; 89918d483882Smlf if (head) { 89928d483882Smlf vprint(RSBY_MID, "devlink(%s) matches RE(%s). " 89938d483882Smlf "ID is %s\n", entry->er_file, 89948d483882Smlf re_array[i].d_re, entry->er_id); 89958d483882Smlf } else { 89968d483882Smlf vprint(RSBY_MID, "rsrv entry(%s) matches " 89978d483882Smlf "RE(%s) ID is %s\n", entry->er_file, 89988d483882Smlf re_array[i].d_re, entry->er_id); 89998d483882Smlf } 90008d483882Smlf break; 90018d483882Smlf } 90028d483882Smlf } 90038d483882Smlf 90048d483882Smlf for (i = 0; re_array[i].d_re; i++) { 90058d483882Smlf regfree(&re_array[i].d_rcomp); 90068d483882Smlf assert(re_array[i].d_pmatch); 90078d483882Smlf free(re_array[i].d_pmatch); 90088d483882Smlf } 90098d483882Smlf 90108d483882Smlf entry = head ? head : enumerate_reserved; 90118d483882Smlf for (; entry; entry = entry->er_next) { 90128d483882Smlf if (entry->er_id == NULL) 90138d483882Smlf continue; 90148d483882Smlf if (head) { 90158d483882Smlf vprint(RSBY_MID, "devlink: %s\n", entry->er_file); 90168d483882Smlf vprint(RSBY_MID, "ID: %s\n", entry->er_id); 90178d483882Smlf } else { 90188d483882Smlf vprint(RSBY_MID, "reserve file entry: %s\n", 90198d483882Smlf entry->er_file); 90208d483882Smlf vprint(RSBY_MID, "reserve file id: %s\n", 90218d483882Smlf entry->er_id); 90228d483882Smlf } 90238d483882Smlf } 90248d483882Smlf 90258d483882Smlf return (DEVFSADM_SUCCESS); 90268d483882Smlf 90278d483882Smlf bad_re: 90288d483882Smlf for (i = i-1; i >= 0; i--) { 90298d483882Smlf regfree(&re_array[i].d_rcomp); 90308d483882Smlf assert(re_array[i].d_pmatch); 90318d483882Smlf free(re_array[i].d_pmatch); 90328d483882Smlf } 90338d483882Smlf return (DEVFSADM_FAILURE); 90348d483882Smlf } 9035e37c6c37Scth 9036e37c6c37Scth /* 9037e37c6c37Scth * Return 1 if we have reserved links. 9038e37c6c37Scth */ 9039e37c6c37Scth int 9040e37c6c37Scth devfsadm_have_reserved() 9041e37c6c37Scth { 9042e37c6c37Scth return (enumerate_reserved ? 1 : 0); 9043e37c6c37Scth } 90448d483882Smlf 90458d483882Smlf /* 90468d483882Smlf * This functions errs on the side of caution. If there is any error 90478d483882Smlf * we assume that the devlink is *not* reserved 90488d483882Smlf */ 90498d483882Smlf int 90508d483882Smlf devfsadm_is_reserved(devlink_re_t re_array[], char *devlink) 90518d483882Smlf { 90528d483882Smlf int match; 90538d483882Smlf enumerate_file_t estruct = {NULL}; 90548d483882Smlf enumerate_file_t *entry; 90558d483882Smlf 90568d483882Smlf match = 0; 90578d483882Smlf estruct.er_file = devlink; 90588d483882Smlf estruct.er_id = NULL; 90598d483882Smlf estruct.er_next = NULL; 90608d483882Smlf 90618d483882Smlf if (devfsadm_reserve_id_cache(re_array, &estruct) != DEVFSADM_SUCCESS) { 90628d483882Smlf err_print("devfsadm_is_reserved: devlink (%s) does not " 90638d483882Smlf "match RE\n", devlink); 90648d483882Smlf return (0); 90658d483882Smlf } 90668d483882Smlf if (estruct.er_id == NULL) { 90678d483882Smlf err_print("devfsadm_is_reserved: ID derived from devlink %s " 90688d483882Smlf "is NULL\n", devlink); 90698d483882Smlf return (0); 90708d483882Smlf } 90718d483882Smlf 90728d483882Smlf entry = enumerate_reserved; 90738d483882Smlf for (; entry; entry = entry->er_next) { 90748d483882Smlf if (entry->er_id == NULL) 90758d483882Smlf continue; 90768d483882Smlf if (strcmp(entry->er_id, estruct.er_id) != 0) 90778d483882Smlf continue; 90788d483882Smlf match = 1; 90798d483882Smlf vprint(RSBY_MID, "reserve file entry (%s) and devlink (%s) " 90808d483882Smlf "match\n", entry->er_file, devlink); 90818d483882Smlf break; 90828d483882Smlf } 90838d483882Smlf 90848d483882Smlf free(estruct.er_id); 90858d483882Smlf return (match); 90868d483882Smlf } 9087